Python DBSession.add方法代码示例

# 需要导入模块: from sgs.model import DBSession [as 别名]
# 或者: from sgs.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 sgs.model import DBSession [as 别名]
# 或者: from sgs.model.DBSession import add [as 别名]
    def post(self, _method='', **kw):
        del kw['sprox_id']
        detalletipoitem = DetalleTipoItem()
        #detalletipoitem.id_detalletipoitem = kw['id_detalletipoitem']
        detalletipoitem.nombre_atributo = kw['nombre_atributo']
	detalletipoitem.tipo_dato = kw['tipo_dato']
	
	for i in kw['tipositem']:
	    p = DBSession.query(TipoItem).get(i)
	    detalletipoitem.tipositem.append(p)

        DBSession.add(detalletipoitem)
        flash('Detalle de Tipo de item creado')
        redirect('/desarrollo/detalle_tipo_item/list')

# 需要导入模块: from sgs.model import DBSession [as 别名]
# 或者: from sgs.model.DBSession import add [as 别名]
    def post(self, _method='', **kw):
        del kw['sprox_id']
        fase = Fase()
        #fase.id_fase = kw['id_fase']#fase.fases=[]
        for f in kw['proyectos']:
            p = DBSession.query(Proyecto).get(f)
            fase.proyectos.append(p)
        fase.cod_fase = kw['cod_fase']
        fase.nombre_fase = kw['nombre_fase']
        fase.descripcion = kw['descripcion']
        #fase.fases=[]
        for f in kw['proyectos']:
            p = DBSession.query(Proyecto).get(f)
            fase.proyectos.append(p)

        DBSession.add(fase)
        flash('Fase creada')
        redirect('/desarrollo/fase/list')

# 需要导入模块: from sgs.model import DBSession [as 别名]
# 或者: from sgs.model.DBSession import add [as 别名]
	def post(self, _method='', **kw):
		del kw['sprox_id']
		#rol = DBSession.query(Rol).get(id)
		rol = Rol()
		#rol.id_rol = kw['id_rol']
		rol.cod_rol = kw['cod_rol']
		rol.group_name = kw['group_name']
		rol.descripcion = kw['descripcion']
		#rol.permissions=[]
		for i in kw['permissions']:
			p = DBSession.query(Permiso).get(i)
			rol.permissions.append(p)
			#rol.permissions.append(DBSession.query(Permiso).get(permiso))
		#kw['permissions'] = permisos
		#rol = Rol(**kw)
		DBSession.add(rol)
		flash('Rol creado')
		redirect('/administracion/rol/list')

# 需要导入模块: from sgs.model import DBSession [as 别名]
# 或者: from sgs.model.DBSession import add [as 别名]
	def post(self, _method='', **kw):
		del kw['sprox_id']
		usuario = Usuario()
		usuario.cod_usuario = kw['cod_usuario']
		usuario.nombre = kw['nombre']
		usuario.user_name = kw['user_name']
		usuario.password = kw['password']
		#usuario.groups = []
		
		#for i in kw['proyect']:
		#	p = DBSession.query(Proyecto).get(i)
		#	usuario.proyect.append(p)

		for i in kw['groups']:
			p = DBSession.query(Rol).get(i)
			usuario.groups.append(p)
		DBSession.add(usuario)
		flash('Usuario creado')
		redirect('/administracion/usuario/list')

# 需要导入模块: from sgs.model import DBSession [as 别名]
# 或者: from sgs.model.DBSession import add [as 别名]
	def post(self, _method='', **kw):
		del kw['sprox_id']
		proyecto = Proyecto()
		#proyecto.id_proyecto = kw['id_proyecto']
		proyecto.cod_proyecto = kw['cod_proyecto']
		proyecto.nombre_proyecto = kw['nombre_proyecto']
		proyecto.descripcion = kw['descripcion']
		proyecto.fecha_inicio = kw['fecha_inicio']
		#proyecto.proyectos=[]
		for i in kw['usuarios'] :
			p = DBSession.query(Usuario).get(i)
			proyecto.usuarios.append(p)
			#rol.permissions.append(DBSession.query(Permiso).get(permiso))

		#kw['permissions'] = permisos

		#rol = Rol(**kw)
		DBSession.add(proyecto)
		flash('Proyecto creado')
		redirect('/administracion/proyecto/list')

# 需要导入模块: from sgs.model import DBSession [as 别名]
# 或者: from sgs.model.DBSession import add [as 别名]
 def post(self, _method='', **kw):
     del kw['sprox_id']
     tipoitem = TipoItem(**kw)
     DBSession.add(tipoitem)
     flash('Tipo de item creado')
     redirect('/desarrollo/tipo_item/list')

# 需要导入模块: from sgs.model import DBSession [as 别名]
# 或者: from sgs.model.DBSession import add [as 别名]
	def post(self, id_fase, method='', **kw):
		del kw['sprox_id']
		lineabase = LineaBase()
		lineabase.cod_lb = kw['cod_lb']
		lineabase.estado = "cerrado"
		lineabase.id_fase = id_fase 
		#id_fa = id_fase
		for i in kw['item']:
			p = DBSession.query(Item).get(i)
			lineabase.item.append(p)
		
		items = []
		tipos = DBSession.query(TipoItem.id_tipoitem).filter(TipoItem.id_fase == id_fase).all()
		for i in tipos:
			item = DBSession.query(Item.id_item).filter(Item.id_tipoitem==i).all()
			items.extend(item)
		
		if (len(items) == len(kw['item'])):
			lineabase.tipo = "total"
		else:
			lineabase.tipo = "parcial"
		DBSession.add(lineabase)
		lb = DBSession.query(LineaBase.id_lb).filter(LineaBase.id_fase==id_fase).all() 
		if (lb is not None):
			for j in lb:
				linea = DBSession.query(LineaBase).get(j)
				if (linea.id_lb != lineabase.id_lb and linea.tipo == "total"):
					linea.tipo = "parcial"
					DBSession.merge(linea)
		DBSession.flush()
		
		for i in kw['item']:
			p = DBSession.query(Item).get(i)
			p.id_lb = lineabase.id_lb
			DBSession.merge(p)
			
			
		
		identity = request.environ.get('repoze.who.identity')
		if identity is not None:
			user = identity.get('user')
		idi = user.id_usuario
		
		ahora = time.localtime()
		
		anho = str(ahora.tm_year)
		mes = str(ahora.tm_mon)
		dia = str(ahora.tm_mday)
		hora = str(ahora.tm_hour)
		min = str(ahora.tm_min)
		seg = str(ahora.tm_sec)
		historial = Historial()
		historial.cod_recurso = lineabase.cod_lb
		historial.tipo_recurso = "Linea_Base"
		historial.nombre_recurso = "sinNombre"
		historial.operacion = "Creacion"
		historial.fecha_operacion = anho+'-'+mes+'-'+dia
		historial.hora = hora+':'+min+':'+seg
		historial.nombre_usuario = user.user_name
		DBSession.add(historial)
		
		flash('Linea Base creada')
		redirect('/configuracion/linea_base/list/'+str(lineabase.id_fase))

# 需要导入模块: from sgs.model import DBSession [as 别名]
# 或者: from sgs.model.DBSession import add [as 别名]
	def abrir(self, id, **kw):
		
		identity = request.environ.get('repoze.who.identity')
		if identity is not None:
			user = identity.get('user')
		idi = user.id_usuario
		
		id_fase = DBSession.query(LineaBase.id_fase).filter(LineaBase.id_lb==id).one()
		
		rol_lider = DBSession.query(RolUsuario).filter(RolUsuario.id_usuario==idi).\
				filter(Rol.group_name=="lider").filter(Rol.id_rol == RolUsuario.id_rol).all()
		
		if(len(rol_lider)==0):
			abrir = DBSession.query(Usperfa).filter(Usperfa.id_fase==id_fase).\
											filter(Permiso.permission_name=="abrir_linea_base").\
											filter(Usperfa.id_permiso==Permiso.id_permiso).\
											filter(RolUsuario.id_usuario==idi).all()
			if len(abrir)==0:
				flash("No posee los permisos para abrir linea base",'error')
				redirect("/configuracion/linea_base/error")
			else:
				lineabase = DBSession.query(LineaBase).get(id)
				lineabase.estado = "abierto"
				DBSession.merge(lineabase)
				
				items = DBSession.query(Item).filter(Item.id_lb==id).all()
				print "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"+str(len(items)) 
				for i in items:
					i.estado = "revision"
					DBSession.merge(i)
				identity = request.environ.get('repoze.who.identity')
				if identity is not None:
					user = identity.get('user')
				idi = user.id_usuario
				
				ahora = time.localtime()
				
				anho = str(ahora.tm_year)
				mes = str(ahora.tm_mon)
				dia = str(ahora.tm_mday)
				hora = str(ahora.tm_hour)
				min = str(ahora.tm_min)
				seg = str(ahora.tm_sec)
				historial = Historial()
				historial.cod_recurso = lineabase.cod_lb
				historial.tipo_recurso = "Linea_Base"
				historial.nombre_recurso = "sinNombre"
				historial.operacion = "Apertura"
				historial.fecha_operacion = anho+'-'+mes+'-'+dia
				historial.hora = hora+':'+min+':'+seg
				historial.nombre_usuario = user.user_name
				DBSession.add(historial)
				
				
				
				flash('Linea Base Abierta')
				redirect('/configuracion/linea_base/list/'+str(lineabase.id_fase))
		else:
			lineabase = DBSession.query(LineaBase).get(id)
			lineabase.estado = "abierto"
			DBSession.merge(lineabase)
			
			items = DBSession.query(Item).filter(Item.id_lb==id).all()
			print "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"+str(len(items)) 
			for i in items:
				i.estado = "revision"
				DBSession.merge(i)
			
			identity = request.environ.get('repoze.who.identity')
			if identity is not None:
				user = identity.get('user')
			idi = user.id_usuario
			
			ahora = time.localtime()
			
			anho = str(ahora.tm_year)
			mes = str(ahora.tm_mon)
			dia = str(ahora.tm_mday)
			hora = str(ahora.tm_hour)
			min = str(ahora.tm_min)
			seg = str(ahora.tm_sec)
			historial = Historial()
			historial.cod_recurso = lineabase.cod_lb
			historial.tipo_recurso = "Linea_Base"
			historial.nombre_recurso = "sinNombre"
			historial.operacion = "Apertura"
			historial.fecha_operacion = anho+'-'+mes+'-'+dia
			historial.hora = hora+':'+min+':'+seg
			historial.nombre_usuario = user.user_name
			DBSession.add(historial)
			
			flash('Linea Base Abierta')
			redirect('/configuracion/linea_base/list/'+str(lineabase.id_fase))

# 需要导入模块: from sgs.model import DBSession [as 别名]
# 或者: from sgs.model.DBSession import add [as 别名]
	def post(self, id_fase, method='', **kw):
		"""Metodo invocado para persistir los datos del item creado en la BD"""
		del kw['sprox_id']
		funciones = Funciones()
		item = Item()
		item.id_tipoitem = kw['tipo_item']
		tipoitem = DBSession.query(TipoItem).filter(TipoItem.id_tipoitem==item.id_tipoitem).first()
		cod_tipoitem = tipoitem.cod_tipoitem
		item.cod_item = str(cod_tipoitem)+str(funciones.generador_codigo_item(cod_tipoitem))
		item.nombre_item = kw['nombre_item']
		item.descripcion = kw['descripcion']
		item.version = 1#kw['version']
		item.estado = "en desarrollo"
		item.complejidad = kw['complejidad']

		id_fa = id_fase

		item.id_tipoitem = kw['tipo_item']
		
		DBSession.add(item)
		DBSession.flush()
		#VERSIONADO_ITEM
		cod_tipoitem_versionado = DBSession.query(TipoItem.cod_tipoitem).filter(TipoItem.id_tipoitem==item.id_tipoitem).first()
		
		versionadoitem = VersionadoItem()
		versionadoitem.cod_item = item.cod_item
		versionadoitem.cod_tipoitem= cod_tipoitem_versionado
		versionadoitem.nombre_item = item.nombre_item
		versionadoitem.descripcion = item.descripcion
		versionadoitem.version = item.version
		versionadoitem.complejidad = item.complejidad
		
		DBSession.add(versionadoitem)
		DBSession.flush()
		print ("0000000000000000000000000000000000000000000000000000000000000000 VERSIONADO %s") % (versionadoitem.id_versionado)
		
		#se crean los detalles del item en base a los detalles del tipo
		detalles = DBSession.query(DetalleTipoItem.id_detalletipoitem).filter(DetalleTipoItem.id_tipoitem==kw['tipo_item']).all()
		
		for i in detalles:
			detalle = DBSession.query(DetalleTipoItem).get(i)
			atributo = DetalleItem()
			atributo.id_item = item.id_item
			atributo.tipo_dato = DBSession.query(DetalleTipoItem.tipo_dato).filter(DetalleTipoItem.id_detalletipoitem==i).first()
			atributo.id_detalletipoitem = i
			atributo.cod_detalleitem = funciones.generador_codigo(detalle.nombre_atributo)
			atributo.cod_detalletipoitem = DBSession.query(DetalleTipoItem.cod_detalletipoitem).filter(DetalleTipoItem.id_detalletipoitem==i).first()
			atributo.nombre_atributo = detalle.nombre_atributo
			atributo.valor = None
			#atributo.archivo = None
			DBSession.add(atributo)
			
			#DETALLE_VERSIONADO_ITEM
			detalleversionadoitem = DetalleVersionadoItem()
			detalleversionadoitem.id_versionado = versionadoitem.id_versionado
			detalleversionadoitem.cod_item = item.cod_item
			detalleversionadoitem.cod_detalleitem = atributo.cod_detalleitem
			detalleversionadoitem.cod_detalletipoitem = atributo.cod_detalletipoitem
			detalleversionadoitem.nombre_atributo = detalle.nombre_atributo
			detalleversionadoitem.tipo_dato = atributo.tipo_dato
			detalleversionadoitem.valor = None
			#detalleversionadoitem.archivo = atributo.archivo
			DBSession.add(detalleversionadoitem)
			
		
		identity = request.environ.get('repoze.who.identity')
		if identity is not None:
			user = identity.get('user')
		idi = user.id_usuario
		ahora = time.localtime()
		anho = str(ahora.tm_year)
		mes = str(ahora.tm_mon)
		dia = str(ahora.tm_mday)
		hora = str(ahora.tm_hour)
		min = str(ahora.tm_min)
		seg = str(ahora.tm_sec)
		historial = Historial()
		historial.cod_recurso = item.cod_item
		historial.tipo_recurso = "Item"
		historial.nombre_recurso = item.nombre_item
		historial.operacion = "Creacion"
		historial.fecha_operacion = anho+'-'+mes+'-'+dia
		historial.hora = hora+':'+min+':'+seg
		historial.nombre_usuario = user.user_name
		DBSession.add(historial)
		
		flash('Item creado')
		redirect('/desarrollo/item/list/'+str(id_fa))

# 需要导入模块: from sgs.model import DBSession [as 别名]
# 或者: from sgs.model.DBSession import add [as 别名]
	def aprobar(self, id, **kw):
		"""Metodo invocado para aprobar un item especificado"""
		identity = request.environ.get('repoze.who.identity')
		if identity is not None:
			user = identity.get('user')
		idi = user.id_usuario
		
		id_tipo = DBSession.query(Item.id_tipoitem).filter(Item.id_item==id).one()
		id_fase = DBSession.query(TipoItem.id_fase).filter(TipoItem.id_tipoitem==id_tipo).one()
		
		rol_lider = DBSession.query(RolUsuario).filter(RolUsuario.id_usuario==idi).\
				filter(Rol.group_name=="lider").filter(Rol.id_rol == RolUsuario.id_rol).all()
		
		if(len(rol_lider)==0):
			aprob = DBSession.query(Usperfa).filter(Usperfa.id_fase==id_fase).\
											filter(Permiso.permission_name=="aprobar_item").\
											filter(Usperfa.id_permiso==Permiso.id_permiso).\
											filter(RolUsuario.id_usuario==idi).all()
			if len(aprob)==0:
				flash("No posee permiso para aprobar item",'error')
				redirect("/desarrollo/item/error")
			else:
				item = DBSession.query(Item).get(id)
				item.estado = "aprobado"
				identity = request.environ.get('repoze.who.identity')
				if identity is not None:
					user = identity.get('user')
				idi = user.id_usuario
				ahora = time.localtime()
				anho = str(ahora.tm_year)
				mes = str(ahora.tm_mon)
				dia = str(ahora.tm_mday)
				hora = str(ahora.tm_hour)
				min = str(ahora.tm_min)
				seg = str(ahora.tm_sec)
				historial = Historial()
				historial.cod_recurso = item.cod_item
				historial.tipo_recurso = "Item"
				historial.nombre_recurso = item.nombre_item
				historial.operacion = "Aprobacion"
				historial.fecha_operacion = anho+'-'+mes+'-'+dia
				historial.hora = hora+':'+min+':'+seg
				historial.nombre_usuario = user.user_name
				DBSession.add(historial)
				flash("Item aprobado")
				redirect('/desarrollo/item/list/'+str(self.id_fase))
		#~ else:
			#~ item = DBSession.query(Item).get(id)
			#~ item.estado = "aprobado"
		else:#*******************************************************************************************desde aca
			item = DBSession.query(Item).get(id)
			item.estado = "aprobado"
			iditem = item.id_item
			
			if (item.id_lb!=None):
				"""Si todos los items de la linea base, que fueron modificados, 
				se aprueban, la linea base se cierra automaticamente"""
				lb = DBSession.query(ItemLineaBase.id_lb).filter(ItemLineaBase.id_item==iditem).one()
				print ("0000000000000000000000000000000000000000000000000000000 linea base del item en put es: %s") % (lb)
				list_items = []
				apro = 0
				list_items = DBSession.query(Item).filter(Item.id_lb==lb).all()
				for k in list_items:
					if (k.estado == "aprobado"):
						apro = apro + 1
				if(len(list_items)==apro):
					li_b = DBSession.query(LineaBase).filter(LineaBase.id_lb==lb).all()
					for m in li_b:
						m.estado = "cerrado"
						DBSession.merge(m)
					#**************************************************************************************hasta aca
			
			identity = request.environ.get('repoze.who.identity')
			if identity is not None:
				user = identity.get('user')
			idi = user.id_usuario
			ahora = time.localtime()
			anho = str(ahora.tm_year)
			mes = str(ahora.tm_mon)
			dia = str(ahora.tm_mday)
			hora = str(ahora.tm_hour)
			min = str(ahora.tm_min)
			seg = str(ahora.tm_sec)
			historial = Historial()
			historial.cod_recurso = item.cod_item
			historial.tipo_recurso = "Item"
			historial.nombre_recurso = item.nombre_item
			historial.operacion = "Aprobacion"
			historial.fecha_operacion = anho+'-'+mes+'-'+dia
			historial.hora = hora+':'+min+':'+seg
			historial.nombre_usuario = user.user_name
			DBSession.add(historial)
			flash("Item aprobado")
			redirect('/desarrollo/item/list/'+str(self.id_fase))

# 需要导入模块: from sgs.model import DBSession [as 别名]
# 或者: from sgs.model.DBSession import add [as 别名]
	def post_delete(self, id, **kw):
		"""Metodo invocado para eliminar un item especificado"""
		identity = request.environ.get('repoze.who.identity')
		if identity is not None:
			user = identity.get('user')
		idi = user.id_usuario
		
		rol_lider = DBSession.query(RolUsuario).filter(RolUsuario.id_usuario==idi).\
				filter(Rol.group_name=="lider").filter(Rol.id_rol == RolUsuario.id_rol).all()
		
		if(len(rol_lider)==0):
			eliminar = DBSession.query(Usperfa).filter(Usperfa.id_fase==id_fase).\
											filter(Permiso.permission_name=="eliminar_item").\
											filter(Usperfa.id_permiso==Permiso.id_permiso).\
											filter(RolUsuario.id_usuario==idi).all()
			if len(list)==0:
				flash("No posee los permisos para eliminar los items de la fase",'error')
				redirect("/desarrollo/item/error")
			else:
				list_relaciones = DBSession.query(Relacion.id_relacion).filter(Relacion.id_item1==id).all()
				for i in list_relaciones:
					DBSession.delete(DBSession.query(Relacion).get(i))
				
				item = DBSession.query(Item).get(int(id))
				identity = request.environ.get('repoze.who.identity')
				if identity is not None:
					user = identity.get('user')
				idi = user.id_usuario
				ahora = time.localtime()
				anho = str(ahora.tm_year)
				mes = str(ahora.tm_mon)
				dia = str(ahora.tm_mday)
				hora = str(ahora.tm_hour)
				min = str(ahora.tm_min)
				seg = str(ahora.tm_sec)
				historial = Historial()
				historial.cod_recurso = item.cod_item
				historial.tipo_recurso = "Item"
				historial.nombre_recurso = item.nombre_item
				historial.operacion = "Eliminacion"
				historial.fecha_operacion = anho+'-'+mes+'-'+dia
				historial.hora = hora+':'+min+':'+seg
				historial.nombre_usuario = user.user_name
				DBSession.add(historial)
				DBSession.delete(DBSession.query(Item).get(id))
				redirect('/desarrollo/item/list/'+str(self.id_fase))
		else:
			list_relaciones = DBSession.query(Relacion.id_relacion).filter(Relacion.id_item1==id).all()
			for i in list_relaciones:
				DBSession.delete(DBSession.query(Relacion).get(i))
				
			item = DBSession.query(Item).get(int(id))
			identity = request.environ.get('repoze.who.identity')
			if identity is not None:
				user = identity.get('user')
			idi = user.id_usuario
			ahora = time.localtime()
			anho = str(ahora.tm_year)
			mes = str(ahora.tm_mon)
			dia = str(ahora.tm_mday)
			hora = str(ahora.tm_hour)
			min = str(ahora.tm_min)
			seg = str(ahora.tm_sec)
			historial = Historial()
			historial.cod_recurso = item.cod_item
			historial.tipo_recurso = "Item"
			historial.nombre_recurso = item.nombre_item
			historial.operacion = "Eliminacion"
			historial.fecha_operacion = anho+'-'+mes+'-'+dia
			historial.hora = hora+':'+min+':'+seg
			historial.nombre_usuario = user.user_name
			DBSession.add(historial)
				
				
			DBSession.delete(DBSession.query(Item).get(id))
			redirect('/desarrollo/item/list/'+str(self.id_fase))

# 需要导入模块: from sgs.model import DBSession [as 别名]
# 或者: from sgs.model.DBSession import add [as 别名]
	def put(self, id='', **kw):
		"""Metodo invocado para persistir los datos modificados """
		del kw['sprox_id']
		item = DBSession.query(Item).get(id)
		id_tipo = DBSession.query(Item.id_tipoitem).filter(Item.id_item==id).one()
		id_fase = DBSession.query(TipoItem.id_fase).filter(TipoItem.id_tipoitem==id_tipo).all()

		for i in id_fase:
			fase = DBSession.query(Fase).get(i)
		print ("0000000000000000000000000000000000000000000000000000000 version del item en put es: %d") % (item.version)
		item.nombre_item = kw['nombre_item']
		item.descripcion = kw['descripcion']
		item.estado = "revision"
		#item.id_tipoitem = kw['tipo_item']
		item.version = item.version + 1
		item.complejidad = kw['complejidad']
		
		DBSession.merge(item)
		
		""" si el item se encuentra en una linea base, esta debe estar abierta... una vez abierta, debe pasar a estado 
			comprometido
		"""
		#relaciones del item modificado
		list_relaciones = DBSession.query(Relacion.id_relacion).filter(Relacion.id_item1==id).all()
		print ("wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww linea base del item en put es: %s") % (list_relaciones)
		for i in list_relaciones:
			iditem = DBSession.query(Relacion.id_item2).filter(Relacion.id_relacion==i).one()
			lb = DBSession.query(ItemLineaBase.id_lb).filter(ItemLineaBase.id_item==iditem).one()
			print ("0000000000000000000000000000000000000000000000000000000 linea base del item en put es: %d") % (lb)
			linea = DBSession.query(LineaBase).filter(LineaBase.id_lb==lb).all()
			for j in linea:
				j.estado = "comprometida"
				DBSession.merge(j)

					
		lb = DBSession.query(ItemLineaBase.id_lb).filter(ItemLineaBase.id_item==id).first()
		if lb is not None:
			print ("0000000000000000000000000000000000000000000000000000000 linea base del item en put es: %d") % (lb)
			linea = DBSession.query(LineaBase).filter(LineaBase.id_lb==lb).all()
			for i in linea:
				i.estado = "comprometida"
				DBSession.merge(i)
		#Aqui se Agrega el registro del item a la taba de versionado
		cod_tipoitem_versionado = DBSession.query(Item.id_tipoitem).filter(Item.id_item==id).first()
		
		versionadoitem = VersionadoItem()
		versionadoitem.cod_item = item.cod_item
		versionadoitem.cod_tipoitem= cod_tipoitem_versionado
		versionadoitem.nombre_item = item.nombre_item
		versionadoitem.descripcion = item.descripcion
		versionadoitem.version = item.version
		versionadoitem.complejidad = item.complejidad
		
		DBSession.add(versionadoitem)
		DBSession.flush()

		
		identity = request.environ.get('repoze.who.identity')
		if identity is not None:
			user = identity.get('user')
		idi = user.id_usuario
		ahora = time.localtime()
		anho = str(ahora.tm_year)
		mes = str(ahora.tm_mon)
		dia = str(ahora.tm_mday)
		hora = str(ahora.tm_hour)
		min = str(ahora.tm_min)
		seg = str(ahora.tm_sec)
		historial = Historial()
		historial.cod_recurso = item.cod_item
		historial.tipo_recurso = "Item"
		historial.nombre_recurso = item.nombre_item
		historial.operacion = "Modificacion"
		historial.fecha_operacion = anho+'-'+mes+'-'+dia
		historial.hora = hora+':'+min+':'+seg
		historial.nombre_usuario = user.user_name
		DBSession.add(historial)
		
		flash('Item modificado')
		redirect("/desarrollo/item/list/"+str(fase.id_fase))

# 需要导入模块: from sgs.model import DBSession [as 别名]
# 或者: from sgs.model.DBSession import add [as 别名]
 def post(self, _method='', **kw):
     del kw['sprox_id']
     detalleitem = DetalleItem(**kw)
     DBSession.add(detalleitem)
     flash('Detalle de item creado')
     redirect('/desarrollo/detalle_item/list')

# 需要导入模块: from sgs.model import DBSession [as 别名]
# 或者: from sgs.model.DBSession import add [as 别名]
 def post(self, _method='', **kw):
     del kw['sprox_id']
     relacion = Relacion(**kw)
     DBSession.add(relacion)
     flash('Relacion creada')
     redirect('/desarrollo/relacion/list')