Python DBSession.delete方法代码示例

# 需要导入模块: from sap.model import DBSession [as 别名]
# 或者: from sap.model.DBSession import delete [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 delete [as 别名]
	def revivir(self, id_historial):
		historial = DBSession.query(HistorialItem).get(id_historial)
		#se revive el item a partir de su historial
		item_util.revivir_item(historial)
		#se elimina el historial del item muerto
		DBSession.delete(historial)
		redirect("/miproyecto/fase/item/ver/"+str(historial.id_item))

# 需要导入模块: from sap.model import DBSession [as 别名]
# 或者: from sap.model.DBSession import delete [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 delete [as 别名]
	def post_delete(self, id_linea_base, **kw):
		lb = DBSession.query(LineaBase).get(id_linea_base)
		#guardar el id de la fase de la linea base para el redirect
		idfase = lb.fase
		#borrar la linea base
		DBSession.delete(lb)
		flash("La linea base ha sido eliminada correctamente.")
		redirect("/miproyecto/fase/linea_base/list/"+str(idfase))

# 需要导入模块: from sap.model import DBSession [as 别名]
# 或者: from sap.model.DBSession import delete [as 别名]
	def eliminar(self, id, **kw):
		archivo = DBSession.query(Archivo).get(id)
		item_util.audit_item(archivo.item)
		archivo.item.version += 1
		DBSession.merge(archivo.item)
		id_item = archivo.id_item

		DBSession.delete(archivo)

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

# 需要导入模块: from sap.model import DBSession [as 别名]
# 或者: from sap.model.DBSession import delete [as 别名]
	def post_delete(self, id_proyecto, **kw):
		fases = DBSession.query(Fase).filter(Fase.proyecto == id_proyecto).all()
		if(len(fases) == 0):
			DBSession.delete(DBSession.query(RolPermisoProyecto).\
					  filter(RolPermisoProyecto.proyecto_id == id_proyecto))
			DBSession.delete(DBSession.query(Proyecto).get(id_proyecto))
			flash("El proyecto ha sido "+ id_proyecto +" eliminado correctamente.")

		else:
			flash("El proyecto no puede ser eliminado porque ya tiene fases", "error")

		redirect("/administracion/proyecto/")

# 需要导入模块: from sap.model import DBSession [as 别名]
# 或者: from sap.model.DBSession import delete [as 别名]
	def post_delete(self, id, **kw):
		"""
		Evento invocado desde el listado, se encarga de eliminar una instancia
		de la base de datos.
		"""
		has_permiso = fase_util.check_fase_permiso(id,'eliminar_fase',True)
		if ( has_permiso == None) :
			flash("No posee permisos para eliminar la fase #"+str(id),'error')
			redirect('/miproyecto/fase/error')

		DBSession.delete(DBSession.query(Fase).get(id))
		flash("La fase #"+ str(id) + "ha sido eliminada correctamente.")
		redirect("/miproyecto/fase/"+ str(id))

# 需要导入模块: from sap.model import DBSession [as 别名]
# 或者: from sap.model.DBSession import delete [as 别名]
	def post_delete(self, id, **kw):
		"""
		Evento invocado desde el listado, se encarga de eliminar una instancia
		de la base de datos.

		@type  id : Integer
		@param id : Identificador del atributo del tipo de item

		@type  kw : Hash
		@param kw : Keywords

		"""
		atributo = DBSession.query(AtributoTipoItem).get(id)
		id_tipo_item = atributo.id_tipo_item
		DBSession.delete(atributo)

		flash("El atributo "+ id + "ha sido eliminado correctamente.")
		redirect('/miproyecto/fase/tipo_item/atributos/list/'+id_tipo_item)

# 需要导入模块: from sap.model import DBSession [as 别名]
# 或者: from sap.model.DBSession import delete [as 别名]
	def eliminar(self, id_item):
		#se utiliza el campo estado para determinar en la tabla historial que
		#esta muerto
		item = item_util.get_current(id_item)


		has_permiso = fase_util.check_fase_permiso(item.fase,'ver_item',True)
		if ( has_permiso == None) :
			flash("No posee permisos sobre la fase #"+ \
				str(self.params['item'].fase),'warning')

			redirect('/miproyecto/fase/item/error')

		#validar que no pertenezca a una linea base
		if (not item_util.verificar_linea_base(item)):
			flash('El item pertence a un linea base Cerrada y no puede ser eliminado','warning')
			redirect("/miproyecto/fase/item/ver/"+str(item.id_item))

		relaciones = DBSession.query(RelacionItem).\
								filter(or_(RelacionItem.id_item_actual == item.id_item,
								RelacionItem.id_item_relacionado == item.id_item)).all()

		print 'len = '+ str(len(relaciones))

		for relacion in relaciones:
			if item_util.deja_huerfanos(relacion):
				flash('El item no puede ser eliminado ya que algun item de la fase siguiente depende de este', 'warning')
				redirect("/miproyecto/fase/item/ver/"+str(item.id_item))

		#estado muerto
		item.estado = 4
		item_util.audit_item(item)

		#se eliminan las relaciones que contienen al item
		for relacion in relaciones:
			DBSession.delete(relacion)

		DBSession.flush()

		DBSession.delete(item)
		flash("El item fue eliminado con exito")
		redirect("/miproyecto/fase/get_all/"+str(item.fase))

# 需要导入模块: from sap.model import DBSession [as 别名]
# 或者: from sap.model.DBSession import delete [as 别名]
	def post_delete(self, id_rol, **kw):
		DBSession.delete(DBSession.query(Rol).get(id_rol))
		flash("El rol ha sido "+ id_rol +" eliminado correctamente.")
		redirect("/administracion/rol/get_all")

# 需要导入模块: from sap.model import DBSession [as 别名]
# 或者: from sap.model.DBSession import delete [as 别名]
	def revertir_item (self, historial_item):
		"""
		Dada una entidad HistorialItem que representa una version
		anterior del item en si se obtiene de la tabla las entradas de
		esa version para que el item recupere los valores de esa version
		"""
		#debe ser una version posterior a la actual
		item = DBSession.query(Item).get(historial_item.id_item)
		detalles = item.detalles
		print "Recuperar el item "+str(item)
		item.nombre = historial_item.nombre
		item.codigo = historial_item.codigo
 		item.estado_actual = estado_item_util.get_by_codigo('Revision')
		#item.estado = item.estado_actual.id_estado_item
		item.tipo_item = historial_item.tipo_item
		item.fase = historial_item.fase
		item.version += 1
		item.prioridad = historial_item.prioridad
		item.complejidad = historial_item.complejidad
		item.descripcion = historial_item.descripcion
		item.observacion = historial_item.observacion
		item.linea_base = None

		#Se borran todos los archivos
		print "Borrando todos los archivos acutales"
		for archivo in item.archivos :
			DBSession.delete(archivo)
		#Se reestauran todos los arachivos
		item.archivos = []
		DBSession.merge(item)
		print "Anhadiendo nuevos archivos."
		for archivo in historial_item.archivos :
			print "archivo: "+ str(archivo)
			new_archivo = Archivo()
			new_archivo.archivo = archivo.archivo
			new_archivo.file_name = archivo.file_name
			new_archivo.content_type = archivo.content_type
			new_archivo.id_item = item.id_item

			DBSession.add(new_archivo)


		print "Recuperar los detalles"
		#recuperar los detalles
		historial_detalles = DBSession.query(HistorialDetalleItem).\
			filter(HistorialDetalleItem.id_historial == historial_item.id_historial_item).\
			all()

		#variable para indexar las posiciones que corresponden a los valores
		#de esa version
		atributo_mapper = {}
		index = 0

		"""
		Se establecen los detalles actuales del item a None
		para que el item conserve los campos definidos por su tipo de
		item. El item recuperara los valores de la version a la cual se
		quiere revertir
		"""
		for detalle in item.detalles:
			detalle.valor = None
			detalle.observacion = None
			atributo_mapper[detalle.id_atributo_tipo_item] = index
			index += 1

		for hist_detalle in historial_detalles:

			index = atributo_mapper[hist_detalle.id_atributo_tipo_item]

			item.detalles[index].observacion = hist_detalle.observacion
			item.detalles[index].valor = hist_detalle.valor

		DBSession.merge(item)

		#borrar las relaciones actuales
		relaciones = DBSession.query(RelacionItem).\
							filter(or_(RelacionItem.id_item_actual == item.id_item,
							RelacionItem.id_item_relacionado == item.id_item)).\
							all()
		print relaciones

		for relacion in relaciones:
			#se verifica que no deje huerfanos
			if not self.deja_huerfanos(relacion):
				print 'borrando relacion'
				DBSession.delete(relacion)

		print "Recuperar las relaciones"
		#recuperar los relaciones
		historial_relaciones = DBSession.query(HistorialRelacion).\
			filter(HistorialRelacion.id_item_1 == item.id_item or
			HistorialRelacion.id_item_2 == item.id_item).\
			all()

		print historial_relaciones

		for hist_relacion in historial_relaciones:
			relacion = RelacionItem()
			if(DBSession.query(Item).get(hist_relacion.id_item_1)!=None and
				DBSession.query(Item).get(hist_relacion.id_item_2)!=None):
#.........这里部分代码省略.........

# 需要导入模块: from sap.model import DBSession [as 别名]
# 或者: from sap.model.DBSession import delete [as 别名]
	def post_delete(self, id_usuario, **kw):
		DBSession.delete(DBSession.query(Usuario).get(id_usuario))
		flash("El usuario ha sido "+ id_usuario +" eliminado correctamente.")
		redirect("/administracion/usuario/get_all")

# 需要导入模块: from sap.model import DBSession [as 别名]
# 或者: from sap.model.DBSession import delete [as 别名]
	def post_delete(self, id_tipo_item, **kw):
		DBSession.delete(DBSession.query(TipoItem).get(id_tipo_item))
		flash("El tipo de item "+ id_tipo_item + "ha sido eliminado correctamente.")
		redirect('/miproyecto/fase/tipo_item/list/'+id_tipo_item)

# 需要导入模块: from sap.model import DBSession [as 别名]
# 或者: from sap.model.DBSession import delete [as 别名]
	def put(self, id_item, **kw):
		item =  DBSession.query(Item).get(id_item)
		# Se registra en el historial el item antes de ser modificado
		item_util.audit_item(item)
		# Se modifica el item
		item.descripcion = kw['descripcion']
		#item.codigo = kw['codigo']
		item.nombre = kw['nombre']
		item.complejidad = kw['complejidad']
		item.prioridad = kw['prioridad']
		item.observacion = kw['observacion']
		item.version = int(item.version) + 1
		item.estado = 2 # En Desarrollo
		#Se persiste el item
		DBSession.merge(item)
		DBSession.flush()

		#se verifica si ya tenia un padre
		relacion = DBSession.query(RelacionItem).\
					filter(RelacionItem.id_item_relacionado==item.id_item).\
					filter(RelacionItem.relacion_parentesco==1).\
					all()

		#se borra las relacion padre hijo si existia
		if relacion != []:
			DBSession.delete(relacion[0])

		# Si se elijio NONE en las relaciones no se hace nada
		if(kw['relaciones'] != None):

			item_padre_antecesor = DBSession.query(Item).get(kw['relaciones'])

			item_util.audit_item(item_padre_antecesor)
			item_padre_antecesor.version += 1

			DBSession.merge(item_padre_antecesor)
			DBSession.flush()

			#tipo de relacion 1 padre-hijo, 2 antecesor sucesor
			tipo_relacion = 2
			if item_padre_antecesor.fase == int(item.fase):
				tipo_relacion = 1

			rel = RelacionItem()
			rel.relacion_parentesco = tipo_relacion
			rel.id_item_actual = kw['relaciones']
			rel.id_item_relacionado = item.id_item
			DBSession.add(rel)

			DBSession.flush()

		fase = DBSession.query(Fase).get(item.fase)
		grafo = item_util.proyectGraphConstructor(fase.proyecto)
		item_util.marcar_en_revision(grafo, item.id_item)

		#la linea del item modificado permanece abierta
		if item.linea_base != None:
			linea = item.linea_base
			linea.estado = estado_linea_base_util.get_by_codigo('Abierta')

		flash("El item " +str(item.nombre)+ " ha sido modificado correctamente.")
		redirect('/miproyecto/fase/item/ver/'+str(item.id_item))