Python DBSession.query方法代码示例

# 需要导入模块: from sgp.model import DBSession [as 别名]
# 或者: from sgp.model.DBSession import query [as 别名]
 def verificaExistencia(self, id_tipo, name):
     c1 = DBSession.query(Campo).filter(Campo.id_tipo_item==id_tipo)
     c2 = DBSession.query(Campo).filter(Campo.nombre.like(name))
     c = c1.intersect(c2)
     if c.count()>0:
         return True
     return False

# 需要导入模块: from sgp.model import DBSession [as 别名]
# 或者: from sgp.model.DBSession import query [as 别名]
 def actualizarPrefijosItem(self, id_tipo_item, viejo, nuevo):
     '''Actualiza los prefijos de los items al editar el tipo de item
     @param id_tipo_item: id del tipo de item
     @param viejo: prefijo anterior
     @param nuevo:prefijo nuevo
     ''' 
     if nuevo == viejo:
         return 0;
     if nuevo=="":
         ti = DBSession.query(TipoItem).filter(TipoItem.id_tipo_item == id_tipo_item).one()
         nombre = ti.nombre
         n = nombre.split(' ')
         nu = "".join(n)
         nuevo = nu.upper()[0:3]
         ti.prefijo=nuevo
         DBSession.merge(ti)
         transaction.commit()
     transaction.begin()
     items = DBSession.query(Item).filter(Item.id_tipo_item==id_tipo_item).all()
     for i in items:
         cod = i.codigo
         lista = cod.split('-')
         nro = lista[len(lista)-1]
         n = nro.strip(' ')
         i.codigo= nuevo + " - " + n
         self.update(i)
     transaction.commit()

# 需要导入模块: from sgp.model import DBSession [as 别名]
# 或者: from sgp.model.DBSession import query [as 别名]
    def deleteById(self, id):
        ''' Elimina un Proyecto de la base de datos
        @param: id del proyecto'''
        roles = DBSession.query(RolUsuario).filter(RolUsuario.id_proyecto==id)
        if roles.count()>0:
            return False
        transaction.begin()
        u = self.getById(id)
        if u.fases != []:
            for i in u.fases:
                transaction.begin()
                recurso = DBSession.query(Recurso).filter(Recurso.id_fase==i.id_fase).one()
                DBSession.delete(recurso)
                transaction.commit()
                transaction.begin()
                fase = DBSession.query(Fase).filter(Fase.id_fase==i.id_fase).one()
                DBSession.delete(fase)
                transaction.commit()
        transaction.begin()
        recurso = DBSession.query(Recurso).filter(id == Recurso.id_proyecto).one()
        DBSession.delete(recurso)
        transaction.commit()
        transaction.begin()
        u = self.getById(id)

        DBSession.delete(u)
        transaction.commit()
        transaction.commit()
        return True

# 需要导入模块: from sgp.model import DBSession [as 别名]
# 或者: from sgp.model.DBSession import query [as 别名]
 def comprobarUso(self, id_tipo_item):
     ti = DBSession.query(TipoItem).filter(TipoItem.id_tipo_item == id_tipo_item).one()
     items=DBSession.query(Item).filter(Item.id_tipo_item == ti.id_tipo_item)
     if items.count()>0:
         print "Existen " + str(items.count()) + " items con este tipo de item"
         return False
     else:
         return True

# 需要导入模块: from sgp.model import DBSession [as 别名]
# 或者: from sgp.model.DBSession import query [as 别名]
 def getByNombreIdFase(self,nombre, fase):
     u = DBSession.query(TipoItem).filter(TipoItem.nombre.like(nombre))
     us= DBSession.query(TipoItem).filter(TipoItem.id_fase==fase)
     user = us.intersect(u)
     if user.count()>0:
         return user.one()
     else:
         return None

# 需要导入模块: from sgp.model import DBSession [as 别名]
# 或者: from sgp.model.DBSession import query [as 别名]
 def verificaExistenciaPut(self, id_fase, name):
     print ("Verificando si existe: " + str(id_fase) + "   " + name)
     c2 = DBSession.query(TipoItem).filter(TipoItem.nombre.like(name))
     c1 = DBSession.query(TipoItem).filter(TipoItem.id_fase==id_fase)
     c = c2.intersect(c1)
     if c.count()>1:
         print "Indica que existe"
         return True
     return False

# 需要导入模块: from sgp.model import DBSession [as 别名]
# 或者: from sgp.model.DBSession import query [as 别名]
 def generar_codigo(self, idfase, tipo_item):
     transaction.begin()
     fase = DBSession.query(Fase).filter(Fase.id_fase == idfase).one()
     nro = fase.nro_item + 1
     fase.nro_item = fase.nro_item +1
     DBSession.merge(fase)
     transaction.commit()
     if tipo_item ==-1:
         codigo = "Gen - " + str(nro)
     else:
         tipo = DBSession.query(TipoItem).filter(TipoItem.id_tipo_item == tipo_item).one()   
         codigo = tipo.prefijo + " - " + str(nro) 
     return codigo

# 需要导入模块: from sgp.model import DBSession [as 别名]
# 或者: from sgp.model.DBSession import query [as 别名]
 def getByItem(self, id_item):
     '''Obtiene las relaciones en las que el item recibido este
     @param: id_item perteneciente a una relacion
     @return: lista de relaciones en la que aparece el item recibido
     '''
     lista = DBSession.query(Relacion).filter((Relacion.id_item1 == id_item) | (Relacion.id_item2 == id_item))
     return lista

# 需要导入模块: from sgp.model import DBSession [as 别名]
# 或者: from sgp.model.DBSession import query [as 别名]
 def generar_codigo(self):
     codigo = DBSession.query(Codigo).filter(Codigo.codigo==0).one()
     valor = codigo.valor
     codigo.valor +=1
     DBSession.merge(codigo)
     transaction.commit()
     return valor

# 需要导入模块: from sgp.model import DBSession [as 别名]
# 或者: from sgp.model.DBSession import query [as 别名]
 def delete(self,user):
     recurso = DBSession.query(Recurso).filter(user.id_fase == Recurso.id_fase)
     DBSession.delete(recurso)
     transaction.commit()
     
     DBSession.delete(user)
     transaction.commit()

# 需要导入模块: from sgp.model import DBSession [as 别名]
# 或者: from sgp.model.DBSession import query [as 别名]
 def getAll(self):
     """
 Obtiene todos los permisos de la base de datos
 @return: Una lista de todos los permisos
 """
     all = DBSession.query(Permiso).all()
     return all

# 需要导入模块: from sgp.model import DBSession [as 别名]
# 或者: from sgp.model.DBSession import query [as 别名]
 def getById(self,id1,id2,tipo):
     ''' Retorna una relacion por su clave primaria
     @param: id1, id del item1
     @param: id2, id del item2
     @param: tipo, tipo de relacion '''
     lista = DBSession.query(Relacion).filter((Relacion.id_item1 == id1) & (Relacion.id_item2 == id2) & (Relacion.tipo_relacion == tipo)).one()
     return lista

# 需要导入模块: from sgp.model import DBSession [as 别名]
# 或者: from sgp.model.DBSession import query [as 别名]
 def buscar_por_fase(self, id_fase):
     ''' Obtiene las relacions de una fase
     @param: id_fase
     @return: lista de relaciones de la fase'''
     lista = DBSession.query(Relacion).filter((Relacion.id_fase1 == id_fase)
                                              |(Relacion.id_fase2 == id_fase)).all()
     return lista

# 需要导入模块: from sgp.model import DBSession [as 别名]
# 或者: from sgp.model.DBSession import query [as 别名]
 def getItemsFaseActualRelacion(self,id_fase, id_item):
      
     lista = DBSession.query(Item).filter((Item.id_fase == id_fase)
                                          & (Item.actual == 'true')
                                          & (Item.estado != 'eliminado')
                                          & (Item.id_item != id_item)).all()
     return lista    

# 需要导入模块: from sgp.model import DBSession [as 别名]
# 或者: from sgp.model.DBSession import query [as 别名]
 def getByNombre(self, loginName):
     """
 Obtiene un usuario de la base de datos de acuerdo al nombre
 @param loginName: el nombre del usuario que se quiere obtener
 @return: El objeto usuario que se busca
 """
     user = DBSession.query(Usuario).filter(Usuario.nombre.like(loginName)).one();
     return user