Python DBSession.add方法代码示例

# 需要导入模块: from is2sap.model import DBSession [as 别名]
# 或者: from is2sap.model.DBSession import add [as 别名]
 def add(self, **kw):
     """Metodo para agregar un registro a la base de datos """
     try:
         usuario = Usuario()
         usuario.nombre = kw['nombre']
         usuario.apellido = kw['apellido']
         usuario.nombre_usuario = kw['nombre_usuario']
         usuario.password = kw['password']
         usuario.direccion = kw['direccion']
         usuario.telefono = kw['telefono']
         usuario.email = kw['email']
         DBSession.add(usuario)
         DBSession.flush()
         transaction.commit()
     except IntegrityError:
         transaction.abort()
         flash(_("No se ha guardado! Hay Problemas con el servidor..."), 'error')
         redirect("/admin/usuario/listado")
     except SQLAlchemyError:
         flash(_("No se ha guardado! SQLAlchemyError..."), 'error')
         redirect("/admin/usuario/listado")
     except (AttributeError, NameError):
         flash(_("No se ha guardado! Hay Problemas con el servidor..."), 'error')
         redirect("/admin/usuario/listado")
     else:
         flash(_("Usuario creado!"), 'ok')
 
     redirect("/admin/usuario/listado")

# 需要导入模块: from is2sap.model import DBSession [as 别名]
# 或者: from is2sap.model.DBSession import add [as 别名]
 def add(self, **kw):
     """Metodo para agregar un registro a la base de datos """
     try:
         proyecto = Proyecto()
         proyecto.id_usuario=kw['id_usuario']
         proyecto.nombre = kw['nombre']
         proyecto.descripcion = kw['descripcion']
         proyecto.fecha = kw['fecha']
         proyecto.iniciado = kw['iniciado']
         DBSession.add(proyecto)
         DBSession.flush()
         transaction.commit()
     except IntegrityError:
         transaction.abort()
         flash(_("No se ha guardado! Hay Problemas con el servidor..."), 'error')
         redirect("/admin/proyecto/listado")
     except SQLAlchemyError:
         flash(_("No se ha guardado! SQLAlchemyError..."), 'error')
         redirect("/admin/proyecto/listado")
     except (AttributeError, NameError):
         flash(_("No se ha guardado! Hay Problemas con el servidor..."), 'error')
         redirect("/admin/proyecto/listado")
     else:
         flash(_("Proyecto creado!"), 'ok')
 
     redirect("/admin/proyecto/listado")

# 需要导入模块: from is2sap.model import DBSession [as 别名]
# 或者: from is2sap.model.DBSession import add [as 别名]
 def add(self, **kw):
     """Metodo para agregar un registro a la base de datos """
     try:
         fase = Fase()
         fase.id_estado_fase=kw['id_estado_fase']
         fase.id_proyecto = kw['id_proyecto']
         fase.nombre = kw['nombre']
         fase.descripcion = kw['descripcion']
         fase.numero_fase = kw['numero_fase']
         DBSession.add(fase)
         DBSession.flush()
         transaction.commit()
     except IntegrityError:
         transaction.abort()
         flash(_("No se ha guardado! Hay Problemas con el servidor..."), 'error')
         redirect("/admin/fase/listadoFasesPorProyecto", id_proyecto=kw['id_proyecto'])
     except SQLAlchemyError:
         flash(_("No se ha guardado! SQLAlchemyError..."), 'error')
         redirect("/admin/fase/listadoFasesPorProyecto", id_proyecto=kw['id_proyecto'])
     except (AttributeError, NameError):
         flash(_("No se ha guardado! Hay Problemas con el servidor..."), 'error')
         redirect("/admin/fase/listadoFasesPorProyecto", id_proyecto=kw['id_proyecto'])
     else:
         flash(_("Fase creada!"), 'ok')
 
     redirect("/admin/fase/listadoFasesPorProyecto", id_proyecto=kw['id_proyecto'])

# 需要导入模块: from is2sap.model import DBSession [as 别名]
# 或者: from is2sap.model.DBSession import add [as 别名]
    def add(self, **kw):
        """Metodo para agregar un registro a la base de datos """
        try:
            tipo_item = TipoItem()
            tipo_item.id_fase = kw['id_fase']
            tipo_item.nombre = kw['nombre']
            tipo_item.codigo = kw['codigo']
            tipo_item.descripcion = kw['descripcion']
            DBSession.add(tipo_item)
            DBSession.flush()
            transaction.commit()
            fase = DBSession.query(Fase).get(kw['id_fase'])
            id_fase = fase.id_fase
            id_proyecto = fase.id_proyecto
        except IntegrityError:
            transaction.abort()
            flash(_("No se ha guardado! Hay Problemas con el servidor..."), 'error')
            redirect("/admin/tipo_item/listadoTipoItemPorFase", id_proyecto=id_proyecto, id_fase=id_fase)
        except SQLAlchemyError:
            flash(_("No se ha guardado! SQLAlchemyError..."), 'error')
            redirect("/admin/tipo_item/listadoTipoItemPorFase", id_proyecto=id_proyecto, id_fase=id_fase)
        except (AttributeError, NameError):
            flash(_("No se ha guardado! Hay Problemas con el servidor..."), 'error')
            redirect("/admin/tipo_item/listadoTipoItemPorFase", id_proyecto=id_proyecto, id_fase=id_fase)
        else:
            flash(_("Tipo de Item creado!"), 'ok')

        redirect("/admin/tipo_item/listadoTipoItemPorFase", id_proyecto=id_proyecto, id_fase=id_fase)

# 需要导入模块: from is2sap.model import DBSession [as 别名]
# 或者: from is2sap.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 is2sap.model import DBSession [as 别名]
# 或者: from is2sap.model.DBSession import add [as 别名]
    def add(self, **kw):
        """Metodo para agregar un registro a la base de datos """
        linea_base = LineaBase()
	linea_base.nombre = kw['nombre']
        linea_base.descripcion = kw['descripcion']
        linea_base.estado = kw['id_estado']
        linea_base.id_fase = kw['id_fase']
        linea_base.version = kw['version']
        DBSession.add(linea_base)
        DBSession.flush()
	id_fase = kw['id_fase']
	flash("Linea Base Generada")
	id_proyecto=DBSession.query(Fase.id_proyecto).filter_by(id_fase=id_fase).first()    
        redirect("/admin/linea_base/listado_linea_bases",id_proyecto=id_proyecto, id_fase=id_fase)

# 需要导入模块: from is2sap.model import DBSession [as 别名]
# 或者: from is2sap.model.DBSession import add [as 别名]
    def importar(self, **kw):
		#id_proyecto, id_fase, id_tipo_item, nombre, descripcion, codigo):
        """Metodo que realiza la importacion del Tipo de Item con todos sus Atributos"""
        try:
            tipo_item = TipoItem()
            tipo_item.id_fase = kw['id_fase']
            tipo_item.nombre = kw['nombre']
            tipo_item.codigo = kw['codigo']
            tipo_item.descripcion = kw['descripcion']
            DBSession.add(tipo_item)
            DBSession.flush()

            listaAtributos = DBSession.query(Atributo).filter_by(id_tipo_item=kw['id_tipo_item']).all()

            for unAtributo in listaAtributos:
                print unAtributo.nombre
                atributo = Atributo()
                atributo.id_tipo_item = tipo_item.id_tipo_item
                atributo.nombre = unAtributo.nombre
                atributo.descripcion = unAtributo.descripcion   
                atributo.tipo = unAtributo.tipo 
                DBSession.add(atributo)
                DBSession.flush()

            transaction.commit()
        except IntegrityError:
            transaction.abort()
            flash(_("No se ha realizado la importacion! Hay Problemas con el servidor..."), 'error')
            redirect("/admin/tipo_item/listadoTipoItemPorFase", id_proyecto=kw['id_proyecto'], id_fase=kw['id_fase'])
        except SQLAlchemyError:
            flash(_("No se ha realizado la importacion! SQLAlchemyError..."), 'error')
            redirect("/admin/tipo_item/listadoTipoItemPorFase", id_proyecto=kw['id_proyecto'], id_fase=kw['id_fase'])
        except (AttributeError, NameError):
            flash(_("No se ha realizado la importacion! Hay Problemas con el servidor..."), 'error')
            redirect("/admin/tipo_item/listadoTipoItemPorFase", id_proyecto=kw['id_proyecto'], id_fase=kw['id_fase'])
        else:
            flash(_("Se ha importado correctamente!"), 'ok')

        redirect("/admin/tipo_item/listadoTipoItemPorFase", id_proyecto=kw['id_proyecto'], id_fase=kw['id_fase'])

# 需要导入模块: from is2sap.model import DBSession [as 别名]
# 或者: from is2sap.model.DBSession import add [as 别名]
 def add(self, **kw):
     """Metodo para agregar un registro a la base de datos """
     try:
         permiso = Permiso()
         permiso.nombre_permiso = kw['nombre_permiso']
         permiso.descripcion = kw['descripcion']
         DBSession.add(permiso)
         DBSession.flush()
         transaction.commit()
     except IntegrityError:
         transaction.abort()
         flash(_("No se ha guardado! Hay Problemas con el servidor..."), 'error')
         redirect("/admin/permiso/listado")
     except SQLAlchemyError:
         flash(_("No se ha guardado! SQLAlchemyError..."), 'error')
         redirect("/admin/permiso/listado")
     except (AttributeError, NameError):
         flash(_("No se ha guardado! Hay Problemas con el servidor..."), 'error')
         redirect("/admin/permiso/listado")
     else:
         flash(_("Permiso creado!"), 'ok')
 
     redirect("/admin/permiso/listado")

# 需要导入模块: from is2sap.model import DBSession [as 别名]
# 或者: from is2sap.model.DBSession import add [as 别名]
    def add(self, **kw):
        """Metodo para agregar un registro a la base de datos """
        try:
            rol = Rol()
            rol.tipo = kw['tipo']
            rol.nombre_rol = kw['nombre_rol']
            rol.descripcion = kw['descripcion']
            DBSession.add(rol)
            DBSession.flush()
            transaction.commit()
        except IntegrityError:
            transaction.abort()
            flash(_("No se ha guardado! Hay Problemas con el servidor..."), 'error')
            redirect("/admin/rol/listado")
        except SQLAlchemyError:
            flash(_("No se ha guardado! SQLAlchemyError..."), 'error')
            redirect("/admin/rol/listado")
        except (AttributeError, NameError):
            flash(_("No se ha guardado! Hay Problemas con el servidor..."), 'error')
            redirect("/admin/rol/listado")
        else:
            flash(_("Rol creado!"), 'ok')

        redirect("/admin/rol/listado")

# 需要导入模块: from is2sap.model import DBSession [as 别名]
# 或者: from is2sap.model.DBSession import add [as 别名]
    def romper(self,  id_proyecto, id_fase, id_linea_base, **kw):     
        """Metodo que rompe la linea base"""
	fase=DBSession.query(Fase).get(id_fase)
	linea_bases=DBSession.query(LineaBase).filter_by(id_fase=id_fase).filter_by(estado='Aprobado')
	itemsenLineaBase = []
	for linea_base in linea_bases:
		itemsLineaBase = linea_base.items
		for itemLineaBase in itemsLineaBase:
			itemsenLineaBase.append(itemLineaBase)
	contador_items_en_linea_base = 0
	for item in itemsenLineaBase:
		contador_items_en_linea_base = contador_items_en_linea_base + 1
	#Se almacena la cantidad de items que se encuentran en una linea base aprobada dentro de la fase actual en: contador_items_en_linea_base
	if contador_items_en_linea_base==1:
		if fase.relacion_estado_fase.nombre_estado=='Con Lineas Bases' or fase.relacion_estado_fase.nombre_estado=='Con Lineas Bases Parciales':
			fase.id_estado_fase='2'
			maxnumerofase = DBSession.query(func.max(Fase.numero_fase)).filter_by(id_proyecto=id_proyecto).first()
			#A continuación se verifica que: si existe una fase posterior, y si no tiene items, tendrá que tener el estado de su fase inicial
			if fase.numero_fase < maxnumerofase:
				numero_fase_siguiente = fase.numero_fase+1 
				fase_siguiente=DBSession.query(Fase).filter_by(id_proyecto=id_proyecto).filter_by(numero_fase=numero_fase_siguiente).first()
				tipo_items=DBSession.query(TipoItem).filter_by(id_fase=fase_siguiente.id_fase)
				itemsDeFaseActual = []
				for tipo_item in tipo_items:
					itemsTipoItem = DBSession.query(Item).filter_by(id_tipo_item=tipo_item.id_tipo_item).filter_by(vivo=True)
					for itemTipoItem in itemsTipoItem:
						itemsDeFaseActual.append(itemTipoItem)
				contador_items_en_fase_siguiente = 0
				for item in itemsDeFaseActual:
					contador_items_en_fase_siguiente = contador_items_en_fase_siguiente + 1
				if contador_items_en_fase_siguiente == 0:
					fase_siguiente.id_estado_fase='1'	
	
	#Comprueba si la fase se encuentra en el estado Con Linas Bases, cambia al estado Con Lineas Bases Parciales,
	# si es que existe más de un item en una linea base
	if contador_items_en_linea_base>1:
		if fase.relacion_estado_fase.nombre_estado=='Con Lineas Bases':
		      fase.id_estado_fase='3'

	DBSession.flush()
        linea_base = DBSession.query(LineaBase).get(id_linea_base)
	#Cambia el estado de la linea base de Aprobado a Desarrollo
	linea_base.estado = 'Desarrollo' 
	
	
	DBSession.flush()
	#Guarda en el historial la última linea base aprobada
	linea_baseHistorial = LineaBaseHistorial()
        linea_baseHistorial.id_linea_base = linea_base.id_linea_base
        linea_baseHistorial.nombre = linea_base.nombre
        linea_baseHistorial.descripcion = linea_base.descripcion
        linea_baseHistorial.estado = linea_base.estado
        linea_baseHistorial.id_fase = linea_base.id_fase
	linea_baseHistorial.version = linea_base.version
	DBSession.add(linea_baseHistorial)
	DBSession.flush() 
	linea_baseHistorial=DBSession.query(LineaBaseHistorial).filter_by(id_linea_base=linea_base.id_linea_base).filter_by(version=linea_base.version).first()
	items = linea_base.items
        #Aqui se van agregando registros a la tabla Linea_Base_Item_Historial para que el 
	#sistema guarde automáticamente el historial de los items que contiene la linea base
	for item in items:
        	#item.linea_bases_historial.append(linea_baseHistorial)
		linea_base_item_historial=LineaBaseItemHistorial()
		linea_base_item_historial.relacion=linea_baseHistorial
		linea_base_item_historial.id_item=item.id_item
		linea_base_item_historial.id_historial_linea_base=linea_baseHistorial.id_historial_linea_base
		linea_base_item_historial.version=item.version
		item.linea_bases_historial.append(linea_base_item_historial)
		DBSession.add(linea_base_item_historial)
		DBSession.flush()
		 
	
        version_aux = int(linea_base.version)+1
  	linea_base.version = str(version_aux)
	DBSession.flush()
	flash("Linea Base Rota")
        redirect("/admin/linea_base/listado_linea_bases", id_proyecto=id_proyecto, id_fase=id_fase)

# 需要导入模块: from is2sap.model import DBSession [as 别名]
# 或者: from is2sap.model.DBSession import add [as 别名]
    def delete(self, id_relacion, idItemActual, id_proyecto, id_fase, id_tipo_item):
        """Metodo que elimina un registro de la base de datos"""
        item = DBSession.query(Item).get(idItemActual)
        id_item = item.id_item
        version_anterior = item.version
        version_nueva = int(item.version) + 1
        linea_bases_item = item.linea_bases

        #Comprobamos que no se encuentre en una Linea Base
        if linea_bases_item != []:
           for linea_base_item in linea_bases_item:
               flash(_("No puede Eliminar la relacion del Item! Se encuentra en una Linea Base..."), 'error')
               redirect('/relacion/listado', id_item=idItemActual, id_proyecto=id_proyecto, id_fase=id_fase, id_tipo_item=id_tipo_item)

        #El Item cambia de version al eliminar la relacion
        itemHistorial = ItemHistorial()
        itemHistorial.id_item = item.id_item
        itemHistorial.id_tipo_item = item.id_tipo_item
        itemHistorial.codigo = item.codigo
        itemHistorial.descripcion = item.descripcion
        itemHistorial.complejidad = item.complejidad
        itemHistorial.prioridad = item.prioridad
        itemHistorial.estado = "Desarrollo"
        itemHistorial.version = version_anterior
        itemHistorial.observacion = item.observacion
        itemHistorial.fecha_modificacion = item.fecha_modificacion
        item.version = version_nueva
        item.estado = "Desarrollo"
        DBSession.add(itemHistorial)
        DBSession.flush()

        #Consultamos los detalles que tiene el Item a ser editado y tambien
        #los atributos actuales de su Tipo de Item correspondiente
        detalles = DBSession.query(ItemDetalle).filter_by(id_item=id_item)
        atributos = DBSession.query(Atributo).filter_by(id_tipo_item=id_tipo_item)
        lista_id_atributo = []

        if atributos != None:
           for atributo in atributos:
               lista_id_atributo.append(atributo.id_atributo)

        #Enviamos al historial los detalles del Item a ser editado
        if detalles != None:
           for detalle in detalles:
               if lista_id_atributo.count(detalle.id_atributo) >= 1: 
                  lista_id_atributo.remove(detalle.id_atributo)
               itemDetalleHistorial = ItemDetalleHistorial()
               itemDetalleHistorial.id_item = id_item
               itemDetalleHistorial.id_item_detalle = detalle.id_item_detalle
               itemDetalleHistorial.id_atributo = detalle.id_atributo
               itemDetalleHistorial.nombre_atributo = detalle.nombre_atributo
               itemDetalleHistorial.valor = detalle.valor
               itemDetalleHistorial.version = version_anterior
               DBSession.add(itemDetalleHistorial)
               DBSession.flush()

        #Cargamos a vacio los atributos que no contemplaban los detalles actuales
        if lista_id_atributo != None:
           for id_atributo in lista_id_atributo:
               atributo = DBSession.query(Atributo).get(id_atributo)
               itemDetalle = ItemDetalle()
               itemDetalle.id_item = id_item
               itemDetalle.id_atributo = atributo.id_atributo
               itemDetalle.nombre_atributo = atributo.nombre
               itemDetalle.valor = ""
               DBSession.add(itemDetalle)
               DBSession.flush()

        #Enviamos sus relaciones actuales al historial de relaciones
        hijos = DBSession.query(RelacionItem).filter_by(id_item1=id_item)
        antecesores = DBSession.query(RelacionItem).filter_by(id_item2=id_item)
        if hijos != None:
           for hijo in hijos:
               relacion_historial = RelacionHistorial()
               relacion_historial.tipo = hijo.tipo
               relacion_historial.id_item1 = hijo.id_item1
               relacion_historial.id_item2 = hijo.id_item2
               relacion_historial.version_modif = version_anterior
               DBSession.add(relacion_historial)
               DBSession.flush()
        if antecesores != None:
           for antecesor in antecesores:
               relacion_historial = RelacionHistorial()
               relacion_historial.tipo = antecesor.tipo
               relacion_historial.id_item1 = antecesor.id_item1
               relacion_historial.id_item2 = antecesor.id_item2
               relacion_historial.version_modif = version_anterior
               DBSession.add(relacion_historial)
               DBSession.flush()

        #Ponemos a revision todos los items afectados por el item editado
        #Tambien colocamos a "Revision" las Lineas Bases correspondientes
        global itemsAfectados
        global listaRelaciones
        itemsAfectados = []
        listaRelaciones = []
            
        itemsAfectados.append(id_item)

        for item_afectado in itemsAfectados:
#.........这里部分代码省略.........

# 需要导入模块: from is2sap.model import DBSession [as 别名]
# 或者: from is2sap.model.DBSession import add [as 别名]
    def insertarAncestro(self, kw): 
        global inserciones
        inserciones = inserciones + 1
        print "el numero de inserciones es :", inserciones
        if inserciones == 1:
           item = DBSession.query(Item).get(kw['id_item1'])
           id_item = item.id_item
           version_anterior = item.version
           version_nueva = int(item.version) + 1
           linea_bases_item = item.linea_bases

           #Comprobamos que no se encuentre en una Linea Base
           if linea_bases_item != []:
              for linea_base_item in linea_bases_item:
                  flash(_("No se puede agregar la relacion! El Item se encuentra en una Linea Base..."), 'error')
                  return

           #El Item cambia de version al agregar la relacion
           itemHistorial = ItemHistorial()
           itemHistorial.id_item = item.id_item
           itemHistorial.id_tipo_item = item.id_tipo_item
           itemHistorial.codigo = item.codigo
           itemHistorial.descripcion = item.descripcion
           itemHistorial.complejidad = item.complejidad
           itemHistorial.prioridad = item.prioridad
           itemHistorial.estado = "Desarrollo"
           itemHistorial.version = version_anterior
           itemHistorial.observacion = item.observacion
           itemHistorial.fecha_modificacion = item.fecha_modificacion
           item.version = version_nueva
           item.estado = "Desarrollo"
           DBSession.add(itemHistorial)
           DBSession.flush()

           #Consultamos los detalles que tiene el Item a ser editado y tambien
           #los atributos actuales de su Tipo de Item correspondiente
           detalles = DBSession.query(ItemDetalle).filter_by(id_item=id_item)
           atributos = DBSession.query(Atributo).filter_by(id_tipo_item=id_tipo_item)
           lista_id_atributo = []

           if atributos != None:
              for atributo in atributos:
                  lista_id_atributo.append(atributo.id_atributo)

           #Enviamos al historial los detalles del Item a ser editado
           if detalles != None:
              for detalle in detalles:
                  if lista_id_atributo.count(detalle.id_atributo) >= 1: 
                     lista_id_atributo.remove(detalle.id_atributo)
                  itemDetalleHistorial = ItemDetalleHistorial()
                  itemDetalleHistorial.id_item = id_item
                  itemDetalleHistorial.id_item_detalle = detalle.id_item_detalle
                  itemDetalleHistorial.id_atributo = detalle.id_atributo
                  itemDetalleHistorial.nombre_atributo = detalle.nombre_atributo
                  itemDetalleHistorial.valor = detalle.valor
                  itemDetalleHistorial.version = version_anterior
                  DBSession.add(itemDetalleHistorial)
                  DBSession.flush()

           #Cargamos a vacio los atributos que no contemplaban los detalles actuales
           if lista_id_atributo != None:
              for id_atributo in lista_id_atributo:
                  atributo = DBSession.query(Atributo).get(id_atributo)
                  itemDetalle = ItemDetalle()
                  itemDetalle.id_item = id_item
                  itemDetalle.id_atributo = atributo.id_atributo
                  itemDetalle.nombre_atributo = atributo.nombre
                  itemDetalle.valor = ""
                  DBSession.add(itemDetalle)
                  DBSession.flush()

           #Enviamos sus relaciones actuales al historial de relaciones
           hijos = DBSession.query(RelacionItem).filter_by(id_item1=id_item)
           antecesores = DBSession.query(RelacionItem).filter_by(id_item2=id_item)
           if hijos != None:
              for hijo in hijos:
                  relacion_historial = RelacionHistorial()
                  relacion_historial.tipo = hijo.tipo
                  relacion_historial.id_item1 = hijo.id_item1
                  relacion_historial.id_item2 = hijo.id_item2
                  relacion_historial.version_modif = version_anterior
                  DBSession.add(relacion_historial)
                  DBSession.flush()
           if antecesores != None:
              for antecesor in antecesores:
                  relacion_historial = RelacionHistorial()
                  relacion_historial.tipo = antecesor.tipo
                  relacion_historial.id_item1 = antecesor.id_item1
                  relacion_historial.id_item2 = antecesor.id_item2
                  relacion_historial.version_modif = version_anterior
                  DBSession.add(relacion_historial)
                  DBSession.flush()

           #Insertamos la nueva relacion
           relacion = RelacionItem()
           relacion.tipo = "Antecesor-Sucesor"
           relacion.id_item1 = kw['id_item1']
           relacion.id_item2 = kw['id_item2']      
           DBSession.add(relacion)
           DBSession.flush() 
#.........这里部分代码省略.........

# 需要导入模块: from is2sap.model import DBSession [as 别名]
# 或者: from is2sap.model.DBSession import add [as 别名]
    def insertarHijo(self, kw): 
        newGrafo.__init__()
        global inserciones
        inserciones = inserciones + 1
        print "el numero de inserciones es :", inserciones
        if inserciones == 1:                        
            self.buscarCiclos(kw['id_item1'])
            id_item1 = int(kw['id_item1'])
            id_item2 = int(kw['id_item2'])
            newGrafo.add_edge(id_item1, id_item2, False)
            hayciclo = newGrafo.walk(id_item1)
            print newGrafo
            print hayciclo
            if hayciclo:
                flash(_("No se puede insertar la relacion. Produce ciclos!"), 'warning')
                return
            else: 
                item = DBSession.query(Item).get(kw['id_item1'])
                id_item = item.id_item
                version_anterior = item.version
                version_nueva = int(item.version) + 1
                linea_bases_item = item.linea_bases

                #Comprobamos que no se encuentre en una Linea Base
                if linea_bases_item != []:
                   for linea_base_item in linea_bases_item:
                       flash(_("No se puede agregar la relacion! El Item se encuentra en una Linea Base..."), 'error')
                       return

                #El Item padre cambia de version al tener una nueva relacion
                itemHistorial = ItemHistorial()
                itemHistorial.id_item = item.id_item
                itemHistorial.id_tipo_item = item.id_tipo_item
                itemHistorial.codigo = item.codigo
                itemHistorial.descripcion = item.descripcion
                itemHistorial.complejidad = item.complejidad
                itemHistorial.prioridad = item.prioridad
                itemHistorial.estado = "Desarrollo"
                itemHistorial.version = version_anterior
                itemHistorial.observacion = item.observacion
                itemHistorial.fecha_modificacion = item.fecha_modificacion
                item.version = version_nueva
                item.estado = "Desarrollo"
                DBSession.add(itemHistorial)
                DBSession.flush()

                #Consultamos los detalles que tiene el Item a ser editado y tambien
                #los atributos actuales de su Tipo de Item correspondiente
                detalles = DBSession.query(ItemDetalle).filter_by(id_item=id_item)
                atributos = DBSession.query(Atributo).filter_by(id_tipo_item=id_tipo_item)
                lista_id_atributo = []

                if atributos != None:
                   for atributo in atributos:
                       lista_id_atributo.append(atributo.id_atributo)

                #Enviamos al historial los detalles del Item a ser editado
                if detalles != None:
                   for detalle in detalles:
                       if lista_id_atributo.count(detalle.id_atributo) >= 1: 
                          lista_id_atributo.remove(detalle.id_atributo)
                       itemDetalleHistorial = ItemDetalleHistorial()
                       itemDetalleHistorial.id_item = id_item
                       itemDetalleHistorial.id_item_detalle = detalle.id_item_detalle
                       itemDetalleHistorial.id_atributo = detalle.id_atributo
                       itemDetalleHistorial.nombre_atributo = detalle.nombre_atributo
                       itemDetalleHistorial.valor = detalle.valor
                       itemDetalleHistorial.version = version_anterior
                       DBSession.add(itemDetalleHistorial)
                       DBSession.flush()

                #Cargamos a vacio los atributos que no contemplaban los detalles actuales
                if lista_id_atributo != None:
                   for id_atributo in lista_id_atributo:
                       atributo = DBSession.query(Atributo).get(id_atributo)
                       itemDetalle = ItemDetalle()
                       itemDetalle.id_item = id_item
                       itemDetalle.id_atributo = atributo.id_atributo
                       itemDetalle.nombre_atributo = atributo.nombre
                       itemDetalle.valor = ""
                       DBSession.add(itemDetalle)
                       DBSession.flush()

                #Enviamos sus relaciones actuales al historial de relaciones
                hijos = DBSession.query(RelacionItem).filter_by(id_item1=id_item)
                antecesores = DBSession.query(RelacionItem).filter_by(id_item2=id_item)
                if hijos != None:
                   for hijo in hijos:
                       relacion_historial = RelacionHistorial()
                       relacion_historial.tipo = hijo.tipo
                       relacion_historial.id_item1 = hijo.id_item1
                       relacion_historial.id_item2 = hijo.id_item2
                       relacion_historial.version_modif = version_anterior
                       DBSession.add(relacion_historial)
                       DBSession.flush()
                if antecesores != None:
                   for antecesor in antecesores:
                       relacion_historial = RelacionHistorial()
                       relacion_historial.tipo = antecesor.tipo
                       relacion_historial.id_item1 = antecesor.id_item1
#.........这里部分代码省略.........