Python DBSession.add方法代码示例

# 需要导入模块: from sap.model import DBSession [as 别名]
# 或者: from sap.model.DBSession import add [as 别名]
 def post_delete(self, *args, **kw):
     """This is the code that actually deletes the record"""
     pks = self.provider.get_primary_fields(self.model)
     d = {}
     for i, arg in enumerate(args):
         d[pks[i]] = arg
         
     """extraer el idFase para poder retornar en el estado anterior """
     idfase= DBSession.query(Item.idFase).filter_by(id=d['id']).first()
     """------------------------------------------------------------"""
     
     """Se crea objeto y cambia de estado """
     itemeDelete=DBSession.query(Item).filter_by(id=d['id']).first()
     itemeDelete.estado="borrado"
     itemeDelete.ultimaversion=0
     
     DBSession.add(itemeDelete)
     
     """---------Se borra las relaciones del Item Borrado--------------"""
     
     relaciones= DBSession.query(RelacionItem).filter((RelacionItem.idItem1==d['id']) | (RelacionItem.idItem2==d['id'])).all()
     
     longitud=len(relaciones)
     
     for x in range(longitud):
         DBSession.delete(relaciones[x])
     
     """---------------------------------------------------------------"""
     
     #self.provider.delete(self.model, d)
     
     #self.provider.delete(self.model, d)
     
     #redirect('./' + '../' * (len(pks) - 1))
     raise redirect('/item/?fid='+str(idfase[0]))

# 需要导入模块: from sap.model import DBSession [as 别名]
# 或者: from sap.model.DBSession import add [as 别名]
	def borrarRelacion(self, item1, item2, idfase, **kw):

		if not self.puede_borrar(item1, item2, idfase):
			flash ("No se peude borrar la relacion! deja huerfanos", 'warning')
			redirect("/miproyecto/fase/relacion/list/"+idfase)

		#auditar items y aumentar su version
		item_1 = DBSession.query(Item).get(item1)
		item_2 = DBSession.query(Item).get(item2)

		item_util.audit_item(item_1)
		item_util.audit_item(item_2)

		item_1.version += 1
		item_2.version += 1

		item_1.estado = 3
		item_2.estado = 3

		DBSession.add(item_1)
		DBSession.add(item_2)

		DBSession.delete(DBSession.query(RelacionItem).\
					filter(RelacionItem.id_item_actual==item1).\
					filter(RelacionItem.id_item_relacionado==item2).\
					one())

		#marcar en revision los relacionados
		fase = DBSession.query(Fase).get(item_1.fase)
		grafo = item_util.proyectGraphConstructor(fase.proyecto)
		item_util.marcar_en_revision(grafo, item_1.id_item)
		item_util.marcar_en_revision(grafo, item_2.id_item)

		flash("Se ha eliminado la relacion: "+item1+" <--> "+item2)
		redirect("/miproyecto/fase/relacion/list/"+idfase)

# 需要导入模块: from sap.model import DBSession [as 别名]
# 或者: from sap.model.DBSession import add [as 别名]
	def importar_este_tipo(self, idtipo, idfase):
		"""
		Se obtiene de la BD el tipo de item y sus atributos
		"""
		tipo = DBSession.query(TipoItem).get(idtipo)
		atributos = DBSession.query(AtributoTipoItem).\
						filter(AtributoTipoItem.tipo_item==tipo.id_tipo_item)
		"""
		Se settean los valores de la copia
		El nuevo tipo de item (copia_tipo )pertenecera a esta fase ahora
		"""
		copia_tipo = TipoItem()
		copia_tipo.nombre = tipo.nombre
		copia_tipo.descripcion = tipo.descripcion
		copia_tipo.fase = idfase
		copia_tipo.codigo = tipo.codigo
		'''
		Se settean los valores para cada copia_atributo
		'''
		for atributo in atributos:
			copia_atributo = AtributoTipoItem()
			copia_atributo.nombre = atributo.nombre
			copia_atributo.tipo_id = atributo.tipo_id
			copia_tipo.atributos.append(copia_atributo)

		DBSession.add(copia_tipo)
		flash("El tipo de item "+str(tipo.nombre)+
										" pertenece ahora a esta fase")
		redirect("/miproyecto/fase/tipo_item/importar/"+str(idfase))

# 需要导入模块: from sap.model import DBSession [as 别名]
# 或者: from sap.model.DBSession import add [as 别名]
	def asociar_usuario_fase(self, usuario_id, fase_id):
		"""
		Asocia los permisos de un usuario con una fase, asi los usuarios que posean
		el rol estaran asociados a la fase.

		@type  usuario_id  : String
		@param usuario_id : Codigo del rol

		@type  fase_id   : Integer
		@param fase_id   : Identificador de la fase

		@rtype  : Rol
		@return : El rol que es aplicado a la fase.
		"""

		fase = DBSession.query(Fase).get(fase_id)
		#Se obtienen los permisos del template
		permisos_rol = self.distinct(DBSession.query(Permiso).\
						filter(RolPermisoProyecto.permiso_id == Permiso.permiso_id).\
						filter(RolPermisoProyecto.proyecto_id == fase.proyecto)
						)

		#Se se asocian el rol con la fase
		for permiso in permisos_rol:

			rpu = UsuarioPermisoFase()

			rpu.fase_id = fase_id
			rpu.usuario_id = usuario_id
			rpu.permiso_id = permiso.permiso_id
			#Asocia el rol con los permisos y la fase
			DBSession.add(rpu)

# 需要导入模块: from sap.model import DBSession [as 别名]
# 或者: from sap.model.DBSession import add [as 别名]
	def asignar_rol_usuario(self,usuario_id , cod_rol, id_proyecto):
		"""
		Asigna un rol asociado a un proyecto al usuario determinado.

		@type  usuario_id  : Integer
		@param usuario_id  : Identificador del usuario

		@type  cod_rol    : String
		@param cod_rol    : Codigo del rol

		@type  id_proyecto : Integer
		@param id_proyecto : Identificador del proyecto al cual se va aplicar el rol

		@rtype  : Rol
		@return : El rol que es asignado al usuario.
		"""
		#Se obtiene el rol con el nombre correspondiente
		rol = rol_util.get_by_codigo(cod_rol)
		#Se verifica si el usuario posee el rol
		rol_usuario = usuario_util.usuario_has_rol(usuario_id, rol)
		#si no posee el rol, se le asigna
		if rol_usuario == None:
			rol_usuario = RolUsuario()
			rol_usuario.usuario_id = usuario_id
			rol_usuario.rol_id = rol.rol_id

			DBSession.add(rol_usuario)

		return rol

# 需要导入模块: from sap.model import DBSession [as 别名]
# 或者: from sap.model.DBSession import add [as 别名]
	def post(self, args={}, **kw):
		"""
		Evento invocado luego de un evento post en el form de crear
		ecargado de persistir las nuevas instancias.

		@type  args : Hash
		@param args : Argumentos de template

		@type  kw : Hash
		@param kw : Keywords

		"""

		del kw['sprox_id']
		rol = Rol()
		rol.codigo = kw['codigo']
		rol.nombre = kw['nombre']
		rol.descripcion = kw['descripcion']

		for permiso in kw['permisos'] :
			rol.permisos.append(DBSession.query(Permiso).get(permiso))

		DBSession.add(rol)
		flash("El rol ha sido creado correctamente.")
		redirect("/administracion/rol/get_all")

# 需要导入模块: from sap.model import DBSession [as 别名]
# 或者: from sap.model.DBSession import add [as 别名]
 def setup(self):
     try:
         new_attrs = {}
         new_attrs.update(self.attrs)
         new_attrs.update(self.do_get_dependencies())
         self.obj = self.klass(**new_attrs)
         DBSession.add(self.obj)
         DBSession.flush()
         return self.obj
     except:
         DBSession.rollback()
         raise

# 需要导入模块: from sap.model import DBSession [as 别名]
# 或者: from sap.model.DBSession import add [as 别名]
 def setUp(self):
     """Prepare model test fixture."""
     try:
         new_attrs = {}
         new_attrs.update(self.attrs)
         new_attrs.update(self.do_get_dependencies())
         self.obj = self.klass(**new_attrs)
         DBSession.add(self.obj)
         DBSession.flush()
         return self.obj
     except:
         DBSession.rollback()
         raise

# 需要导入模块: from sap.model import DBSession [as 别名]
# 或者: from sap.model.DBSession import add [as 别名]
	def post(self, idfase, args={},**kw):
		"""
		Evento invocado luego de un evento post en el form de crear
		ecargado de persistir las nuevas instancias.

		@type  idfase : Integer
		@param idfase : Identificador de la fase.

		@type  args : Hash
		@param args : Argumentos de template

		@type  kw : Hash
		@param kw : Keywords

		"""
		del kw['sprox_id']
		"""
		se crea la nueva relacion y se le asignan los valores de los combos
		"""
		if kw['item_1'] != None and kw['item_2'] != None:
			relacion = RelacionItem()
			relacion.id_item_actual = kw['item_1']
			relacion.id_item_relacionado = kw['item_2']
			relacion.relacion_parentesco = 2

			DBSession.merge(relacion)

			#auditar items y aumentar su version
			item1 = DBSession.query(Item).get(kw['item_1'])
			item2 = DBSession.query(Item).get(kw['item_2'])

			item_util.audit_item(item1)
			item_util.audit_item(item2)

			item1.version += 1
			item2.version += 1

			DBSession.add(item1)
			DBSession.add(item2)

			#marcar en revision los relacionados
			fase = DBSession.query(Fase).get(item1.fase)
			grafo = item_util.proyectGraphConstructor(fase.proyecto)
			item_util.marcar_en_revision(grafo, item1.id_item)

			flash("La relacion se ha creado correctamente")
			redirect("/miproyecto/fase/relacion/list/"+idfase)

		flash("No se puede crear la relacion", 'warning')
		redirect("/miproyecto/fase/relacion/"+idfase+"/new/")

# 需要导入模块: from sap.model import DBSession [as 别名]
# 或者: from sap.model.DBSession import add [as 别名]
	def audit_item(self, item):
		"""
		Registra los cambios realizados al item determinado en el historial
		se persiste los valore del item y su atributos en el historial.

		@type  item  : Integer
		@param item  : Identificador del proyecto al cual se va aplicar el rol
		"""
		historial = HistorialItem()

		historial.id_item = item.id_item
		historial.nombre = item.nombre
		historial.codigo = item.codigo
		historial.estado = item.estado
		historial.tipo_item = item.tipo_item
		historial.fase = item.fase
		historial.version = item.version
		historial.prioridad = item.prioridad
		historial.complejidad = item.complejidad
		historial.descripcion = item.descripcion
		historial.observacion = item.observacion
		historial.linea_base = item.linea_base
		#historial de detalles
		detalles = DBSession.query(DetalleItem).\
					filter(DetalleItem.id_item==historial.id_item).\
					all()
		for detalle in detalles:
			historial_detalle = HistorialDetalleItem()
			historial_detalle.id_detalle = detalle.id_item_detalle
			historial_detalle.id_item = detalle.id_item
			historial_detalle.adjunto = detalle.adjunto
			historial_detalle.observacion = detalle.observacion
			historial_detalle.valor = detalle.valor
			historial.detalles.append(historial_detalle)

		#Obtener las relaciones
		relaciones = DBSession.query(RelacionItem).\
							filter((RelacionItem.id_item_actual or
							RelacionItem.id_item_relacionado) == item.id_item).\
							all()

		for relacion in relaciones:
			historial_relacion = HistorialRelacion()
			historial_relacion.id_item_1 = relacion.id_item_actual
			historial_relacion.id_item_2 = relacion.id_item_relacionado
			historial_relacion.id_tipo_relacion = relacion.relacion_parentesco
			historial.relaciones.append(historial_relacion)

		DBSession.add(historial)

# 需要导入模块: from sap.model import DBSession [as 别名]
# 或者: from sap.model.DBSession import add [as 别名]
	def post(self, idproyecto, **kw):
		"""
		Evento invocado luego de un evento post en el form de crear
		ecargado de persistir las nuevas instancias.

		@type  idproyecto : Integer
		@param idproyecto : Identificador del Proyecto.

		@type  kw : Hash
		@param kw : Keywords

		"""
		del kw['sprox_id']
		fase = Fase(**kw)
		fase.proyecto = idproyecto
		DBSession.add(fase)
		redirect("/miproyecto/ver/"+idproyecto)

# 需要导入模块: from sap.model import DBSession [as 别名]
# 或者: from sap.model.DBSession import add [as 别名]
	def post(self, args={}, **kw):
		"""
		Evento invocado luego de un evento post en el form de crear
		ecargado de persistir las nuevas instancias.

		@type  args : Hash
		@param args : Argumentos de template

		@type  kw : Hash
		@param kw : Keywords

		"""

		del kw['sprox_id']
		usuario = Usuario(**kw)
		DBSession.add(usuario)
		flash("El usuario ha sido creado correctamente.")
		redirect("/administracion/usuario/get_all")

# 需要导入模块: from sap.model import DBSession [as 别名]
# 或者: from sap.model.DBSession import add [as 别名]
 def post(self, *args, **kw):
     
     userfile=kw['userfile']
     log.debug("kwwww: %s" %kw)
     
     forbidden_files = [".js", ".htm", ".html"]
     for forbidden_file in forbidden_files:
         if userfile.filename.find(forbidden_file) != -1:
             return redirect("/adjuntos/new")
     filecontent = userfile.file.read()
     new_file = Adjuntos(filename=userfile.filename, filecontent=filecontent)
     DBSession.add(new_file)
     DBSession.flush()
     redirect("/adjuntos/new")
     
     
     #self.provider.create(self.model, params=kw)
     
     
     raise redirect('/adjuntos/new')

# 需要导入模块: from sap.model import DBSession [as 别名]
# 或者: from sap.model.DBSession import add [as 别名]
	def put(self, id, **kw):
		"""
		Evento invocado luego de un evento post en el form de editar
		encargado de persistir las modificaciones de las instancias.

		@type  id : Integer
		@param id : Identificador del item.

		@type  kw : Hash
		@param kw : Keywords

		"""
		kw['id_item'] = id
		
		item = DBSession.query(Item).get(int(kw['id_item']))
		
		item_util.audit_item(item)
		
		archivo =  Archivo()
		archivo.id_item = id

		if kw ['archivo'] != None:
			stream = True
			archivo.archivo = ""

			while stream :
				stream = kw ['archivo'].file.read(1024)
				archivo.archivo += stream

			archivo.file_name = kw ['archivo'].filename
			archivo.content_type = kw ['archivo'].type
			kw ['archivo'].file.close()


		DBSession.add(archivo)

		item.version += 1
		DBSession.merge(item)

		flash("El item atributo ha sido modificado correctamente.")
		redirect('/miproyecto/fase/item/poner_en_revision/'+str(archivo.id_item))

# 需要导入模块: from sap.model import DBSession [as 别名]
# 或者: from sap.model.DBSession import add [as 别名]
	def post(self,**kw):
		"""
		Evento invocado luego de un evento post en el form de crear
		ecargado de persistir las nuevas instancias.

		@type  kw : Hash
		@param kw : Keywords
		"""

		del kw['sprox_id']
		kw['lider'] = DBSession.query(Usuario).get(kw['lider'])
		kw['estado'] = estado_proyecto_util.get_by_codigo('Inicial')
		proyecto = Proyecto(**kw)
		#persiste el proyecto
		DBSession.add(proyecto)
		#Se anhade el rol de lider
		proy=DBSession.query(Proyecto).filter(Proyecto.nombre==proyecto.nombre).first()

		util.asignar_lider(proy)

		flash("El proyecto ha sido creado correctamente.")
		redirect("/administracion/proyecto/")