Python DBSession.flush方法代码示例

# 需要导入模块: from sap.model import DBSession [as 别名]
# 或者: from sap.model.DBSession import flush [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 Detalle del item.

		@type  kw : Hash
		@param kw : Keywords

		"""
		detalle =  DBSession.query(DetalleItem).get(id)
		detalle.valor = kw['valor']
		detalle.observacion = kw ['observacion']

		DBSession.merge(detalle)
		DBSession.flush()

		item = DBSession.query(Item).get(detalle.id_item)

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

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

# 需要导入模块: from sap.model import DBSession [as 别名]
# 或者: from sap.model.DBSession import flush [as 别名]
	def commit_transaction(self, can_commit):
		"""
		Realiza commit de la transaccion

		@type  can_commit  : Boolean
		@param can_commit  : Variable de control de la transaccion
		"""
		if can_commit == True :
			DBSession.flush()
			transaction.commit()

# 需要导入模块: from sap.model import DBSession [as 别名]
# 或者: from sap.model.DBSession import flush [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 flush [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 flush [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 flush [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 flush [as 别名]
 def create(self, **kw):
         adjuntos = Adjuntos()
                     
         #save the filename to the database
         #adjuntos.idItem= kw['idItem']
         adjuntos.picture_filename = kw['adjuntos_filename'].filename
         #DBSession.add(adjuntos)
         DBSession.flush()
     
         """#write the picture file to the public directory
         adjuntos_path = os.path.join(adjuntos_dirname, str(adjuntos.id))
         try:
             os.makedirs(adjuntos_path)
         except OSError:
             #ignore if the folder already exists
             pass
             
         adjuntos_path = os.path.join(adjuntos_path, adjuntos.adjuntos_filename)
         f = file(adjuntos_path, "w")
         f.write(kw['adjuntos_filename'].value)
         f.close()
         """
         #flash("adjuntos was successfully created.")
         redirect("./adjuntos")

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

		@type  idtipo : Integer
		@param idtipo : Identificador del tipo de item.

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

		@type  kw : Hash
		@param kw : Keywords

		"""
		del kw['sprox_id']
		atributo_tipo_item = AtributoTipoItem()
		atributo_tipo_item.tipo_item = idtipo
		atributo_tipo_item.nombre = kw['nombre']
		atributo_tipo_item.tipo_id = kw['tipo']
		DBSession.add(atributo_tipo_item)

		items = DBSession.query(Item).filter(Item.tipo_item==idtipo)

		for item in items :
			detalle = DetalleItem()
			detalle.nombre = atributo_tipo_item.nombre
			detalle.id_atributo_tipo_item = atributo_tipo_item.id_atributo_tipo_item
			detalle.valor = None
			detalle.recurso = None
			item.detalles.append(detalle)
			DBSession.merge(item)
		DBSession.flush()

		flash("El Atributo del tipo de Item ha sido creado correctamente")
		redirect('/miproyecto/fase/tipo_item/atributos/'+idtipo+'/new')

# 需要导入模块: from sap.model import DBSession [as 别名]
# 或者: from sap.model.DBSession import flush [as 别名]

#.........这里部分代码省略.........
		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):
				relacion.id_item_actual = hist_relacion.id_item_1
				relacion.id_item_relacionado = hist_relacion.id_item_2
				relacion.relacion_parentesco = hist_relacion.id_tipo_relacion
				DBSession.merge(relacion)

		print "Merge"
		DBSession.merge(item)
		print "Flush"
		DBSession.flush()
		return

# 需要导入模块: from sap.model import DBSession [as 别名]
# 或者: from sap.model.DBSession import flush [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 de detalles
		#~ detalles = DBSession.query(DetalleItem).\
					#~ filter(DetalleItem.id_item==item.id_item).\
					#~ all()
		for archivo in item.archivos :
			historial_archivo = HistorialArchivo()
			historial_archivo.archivo = archivo.archivo
			historial_archivo.file_name = archivo.file_name
			historial_archivo.content_type = archivo.content_type
			historial_archivo.id_historial =  historial.id_historial_item
			historial_archivo.id_item = archivo.id_item

			historial.archivos.append(historial_archivo)

		for detalle in item.detalles:
			historial_detalle = HistorialDetalleItem()
			historial_detalle.id_detalle = detalle.id_item_detalle
			historial_detalle.id_atributo_tipo_item = detalle.id_atributo_tipo_item
			historial_detalle.id_item = detalle.id_item
			historial_detalle.observacion = detalle.observacion
			historial_detalle.valor = detalle.valor

			historial.detalles.append(historial_detalle)

		#Obtener las relaciones
		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:
			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)
		DBSession.flush()

# 需要导入模块: from sap.model import DBSession [as 别名]
# 或者: from sap.model.DBSession import flush [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))

# 需要导入模块: from sap.model import DBSession [as 别名]
# 或者: from sap.model.DBSession import flush [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']
		item = Item()
		item.nombre = kw['nombre']
		item.descripcion = kw['descripcion']
		item.complejidad = kw['complejidad']
		item.prioridad = kw['prioridad']
		item.observacion = kw['observacion']
		item.fase = idfase
		# Se crea con estado En Desarrollo por defecto
		item.estado = 2
		item.tipo_item = kw['tipo_item_relacion']
		item.version = 1

		tipo_item = DBSession.query(TipoItem).get(item.tipo_item)

		#anhadir detalles al item segun el tipo de item al cual corresponda
		item.detalles = item_util.anadir_detalles(tipo_item)

		item.codigo = item_util.gen_cod(idfase, item.tipo_item)
		DBSession.add(item)
		DBSession.flush()

		# Se guarda la relacion elegida en el formulario
		if(kw['relaciones'] != None):

			relacion = RelacionItem()
			#el padre es el item que se selecciono en el combo
			relacion.id_item_actual = kw['relaciones']
			#el item nuevo es el hijo
			relacion.id_item_relacionado = item.id_item
			item_relacionado = DBSession.query(Item).get(kw['relaciones'])

			#auditar el item
			item_util.audit_item(item_relacionado)
			item_relacionado.version += 1

			DBSession.merge(item_relacionado)
			DBSession.flush()

			if(item_relacionado.fase == int(idfase)):
				#relacion padre-hijo
				relacion.relacion_parentesco = 1
			else:
				relacion.relacion_parentesco = 2

 			DBSession.add(relacion)
			DBSession.flush()

		#flash("El item se ha creado correctamente")
		redirect('/miproyecto/fase/item/ver/'+str(item.id_item))