Python DBSession.query方法代码示例

# 需要导入模块: from projectmanager.model import DBSession [as 别名]
# 或者: from projectmanager.model.DBSession import query [as 别名]
 def getHijos(self, idVersion):
     item = DBSession.query(VersionItem).\
         filter(VersionItem.id_version_item==idVersion).one()
         
     hijos=[]
    
     try:
         
         itemPadre=DBSession.query(Padre).\
         filter(Padre.id_version_item==int(idVersion)).\
         one()
         
         if not self.impacto_graph.has_node(idVersion):
             self.impacto_graph.add_node(idVersion,
             [('label',item.item.nom_item + "\n" + str(item.peso))])
                                     
         for hijo in itemPadre.hijos:
             if hijo.ultima_version=='S' and\
             hijo.estado.nom_estado!='Eliminado':
                 hijos.append(hijo)                    
                                     
                 if not self.impacto_graph.has_node(hijo.id_version_item):
                     self.impacto_graph.add_node(hijo.id_version_item,
                     [('label',hijo.item.nom_item + "\n" + str(hijo.peso))])
                 
                 if not self.impacto_graph.\
                 has_edge((idVersion,hijo.id_version_item)):                      
                     self.impacto_graph.\
                         add_edge((idVersion,hijo.id_version_item),
                                   label='Hijo')
                 
     except NoResultFound,e:
         existe=False

# 需要导入模块: from projectmanager.model import DBSession [as 别名]
# 或者: from projectmanager.model.DBSession import query [as 别名]
 def delete(self, **kw):    
     """ Funcion que borra un proyecto seleccionado"""
     dProject = DBSession.query(Proyecto).\
         filter(Proyecto.id_proyecto==kw['id']).one()
     
     fases = DBSession.query(Fase).\
         filter(Fase.proyectoFase==dProject)
     
     for fase in fases.all():
         users=DBSession.query(Usuario).\
             filter(Usuario.fases.contains(fase)).all()
             
         for user in users:
             fase.usuarios.remove(user)
                    
     rol_proyecto = DBSession.query(RolProyectoUsuario).\
         filter(RolProyectoUsuario.proyecto==dProject)            
     rol_proyecto.delete()             
     
     rol_fase = DBSession.query(RolFaseUsuario).\
         filter(RolFaseUsuario.fase.has(proyectoFase=dProject))        
     rol_fase.delete()
            
     fases.delete()                  
     DBSession.delete(dProject)
     redirect("adminProject")

# 需要导入模块: from projectmanager.model import DBSession [as 别名]
# 或者: from projectmanager.model.DBSession import query [as 别名]
 def getAntecesores(self, idVersion):
     itemVersion = DBSession.query(VersionItem).\
         filter(VersionItem.id_version_item == int(idVersion)).one()
     
     if not self.impacto_graph.has_node(idVersion):
         self.impacto_graph.add_node(idVersion,
         [('label',itemVersion.item.nom_item + "\n" + str(itemVersion.peso)),
         ('shape','box'),('rankdir','RL')])           
         
     antecesores=[]
     
     for antecesor in itemVersion.Antecesores:
         unItem = DBSession.query(VersionItem).\
         filter(VersionItem.id_version_item==antecesor.id_version_item).one()
         
         if unItem.ultima_version=='S' and\
         unItem.estado.nom_estado!='Eliminado':
             antecesores.append(unItem)
             
             if not self.impacto_graph.has_node(unItem.id_version_item):
                 self.impacto_graph.add_node(unItem.id_version_item,
                 [('label',unItem.item.nom_item + "\n" + str(unItem.peso)),
                 ('shape','box'),('rankdir','RL')])
             
             if not self.impacto_graph.\
             has_edge((unItem.id_version_item,idVersion)):
                 self.impacto_graph.\
                     add_edge((idVersion,unItem.id_version_item),
                              label='Antecesor')
     
     return antecesores

# 需要导入模块: from projectmanager.model import DBSession [as 别名]
# 或者: from projectmanager.model.DBSession import query [as 别名]
 def getSucesores(self, idVersion):
     sucesores=[]
     item = DBSession.query(VersionItem).\
         filter(VersionItem.id_version_item == idVersion).one()
         
     try:
         yoAntecesor=DBSession.query(Antecesor).\
         filter(Antecesor.id_version_item==int(idVersion)).one()
         
         if not self.impacto_graph.has_node(idVersion):
             self.impacto_graph.add_node(idVersion,
             [('label',item.item.nom_item + "\n" + str(item.peso)),
             ('shape','box'),('rankdir','LR')])
         
         for sucesor in yoAntecesor.sucesores:
             if sucesor.ultima_version=='S' and\
             sucesor.estado.nom_estado!='Eliminado':
                 sucesores.append(sucesor)
                 
                 if not self.impacto_graph.\
                 has_node(sucesor.id_version_item):
                     self.impacto_graph.add_node(sucesor.id_version_item,
                     [('label',sucesor.item.nom_item + "\n" + str(sucesor.peso)),
                     ('shape','box'),('rankdir','LR')])
                     
                 if not self.impacto_graph.\
                 has_edge((idVersion,sucesor.id_version_item)):
                     self.impacto_graph.add_edge((idVersion,
                     sucesor.id_version_item),
                     label='Sucesor')                                        
         
     except NoResultFound,e:
         existe=False

# 需要导入模块: from projectmanager.model import DBSession [as 别名]
# 或者: from projectmanager.model.DBSession import query [as 别名]
 def aprobar(self, **kw):  
     print '***************************************************************************************************************'
     print 'entro aca'
     lineaBase_id = kw['idlineaBase']   
     nroLineaBaseAprobar = DBSession.query(NroLineaBase).\
                           filter(NroLineaBase.id_nro_lb == lineaBase_id).one()
                           
     items = nroLineaBaseAprobar.item
     
     band = 1
     if (items == []):
         band = 0
         flash(_("ERROR!! NO SE PUEDE APROBAR UNA LINEA BASE SIN ITEMS"))
         redirect("/lineaBase/index?id_fase="+str(Globals.current_phase.id_fase))
     else:
         
         estadoA = DBSession.query(Estado).filter(Estado.nom_estado == 'Aprobado').one()
         for itemEstado in nroLineaBaseAprobar.item:       
             itemEstado.estado = estadoA
         
         Globals.current_phase.id_estado = estadoA.id_estado
         nroLineaBaseAprobar.id_estado = estadoA.id_estado
         
         DBSession.add(nroLineaBaseAprobar)
         DBSession.flush()     
         
         flash(_("LA LINEA BASE HA SIDO APROBADA"))
         redirect("/lineaBase/index?id_fase="+str(Globals.current_phase.id_fase))

# 需要导入模块: from projectmanager.model import DBSession [as 别名]
# 或者: from projectmanager.model.DBSession import query [as 别名]
 def startProject(self, **kw):
     """Funcion que cambia el estado de una fase No Inciada a 
     Iniciada. Controla primero que las fases se hayan creado
     correctamente"""
     project = DBSession.query(Proyecto).filter(Proyecto.id_proyecto==int(kw['id'])).one()
     estado =DBSession.query(Estado).filter(Estado.nom_estado == 'Iniciado').one()
     
     #Controlar Orden de las fases
     FasesList = DBSession.query(Fase).\
         filter(Fase.id_proyecto==project.id_proyecto).\
         order_by(Fase.nro_fase).all()
         
     if len(FasesList) <= 0:
         flash(_("No se puede iniciar el Proyecto sin Fases"),'warning')
         redirect('adminProject')
         
     actual = FasesList[0].nro_fase
     if(actual != 1):
         flash(_("La Primera Fase debe tener el Orden: 1, Favor realize los cambios respectivos"),'warning')
         redirect('adminProject')
         
     for fase in FasesList:
         next = fase.nro_fase
         if next > actual+1:
             flash(_("Segun el orden de las Fases le falta crear una o mas fases"
             ". Favor Asegurese de que todas las fases esten en un orden correlativo"),
             'warning')
             redirect('adminProject')
         else:
             actual = next
     
     project.estadoProyecto = estado
     redirect('adminProject')

# 需要导入模块: from projectmanager.model import DBSession [as 别名]
# 或者: from projectmanager.model.DBSession import query [as 别名]
 def searchNoUsers(self, **kw):
     """Realiza la busqueda de usuarios que NO pertenecen al proyecto
     actual. Esta busqueda se utiliza para ASIGNAR usuarios al proyecto
     elegido"""
     word = '%'+kw['key']+'%'        
     
     #Obtenemos los usuarios que tienen proyectos asignados
     #menos el actual       
     project = DBSession.query(Proyecto).\
                 filter(Proyecto.id_proyecto==\
                 Globals.current_project.id_proyecto).one()
     list1 = DBSession.query(Usuario.id_usuario,Usuario.nom_usuario).\
             filter(Usuario.groups.any(group_name='user')).\
             filter(~Usuario.proyecto.contains(project))
             
     #Obtenemos los usuarios del tipo user y los que no 
     #tienen ningun proyecto asignado
     list2 = DBSession.query(Usuario.id_usuario,Usuario.nom_usuario).filter(Usuario.proyecto==None).\
             filter(Usuario.groups.any(group_name='user'))   
     
     user_list = list1.union(list2).order_by(Usuario.nom_usuario)
     
     user_list = user_list.filter(Usuario.nom_usuario.like(word))
         
     return dict(usuarios=user_list)

# 需要导入模块: from projectmanager.model import DBSession [as 别名]
# 或者: from projectmanager.model.DBSession import query [as 别名]
    def saveItem(self, **kw):
        unItem = Item()
        unItem.nom_item = kw["nomItem"]
        # aProject.des_proyecto = kw['descripcion']
        DBSession.add(unItem)

        unaVersionItem = VersionItem()
        unaVersionItem.item = unItem

        unEstado = DBSession.query(Estado).filter_by(id_estado=1).one()
        unTipoItem = DBSession.query(TipoItem).filter_by(id_tipo_item=1).one()
        unUsuario = DBSession.query(Usuario).filter_by(id_usuario=1).one()

        unaVersionItem.estado = unEstado
        unaVersionItem.tipoItem = unTipoItem
        unaVersionItem.usuarioModifico = unUsuario
        unaVersionItem.fecha = "10/06/2011"
        unaVersionItem.observaciones = kw["observaciones"]
        # unaVersionItem.peso = kw['peso']

        DBSession.add(unaVersionItem)

        for atributo in DBSession.query(Atributo).filter_by(tipoItem=unTipoItem):
            nuevoAtributoItem = AtributoItem()
            nuevoAtributoItem.atributo = atributo
            nuevoAtributoItem.versionItem = unaVersionItem
            nuevoAtributoItem.val_atributo = atributo.val_default
            DBSession.add(nuevoAtributoItem)

        flash(_("Se ha creado un nuevo Item: %s") % kw["itemName"], "info")
        redirect("adminItem")

# 需要导入模块: from projectmanager.model import DBSession [as 别名]
# 或者: from projectmanager.model.DBSession import query [as 别名]
 def index(self,**kw):        
     """Lista las fases de un proyecto seleccionado por el usuario.
     Parametros: id del proyecto
     Retorna: Lista de Fases del proyecto habilitadas para el
     usuario actual"""
     Globals.current_project = DBSession.query(Proyecto).\
         filter(Proyecto.id_proyecto==int(kw['id_proyecto'])).one()             
              
     user = DBSession.query(Usuario).\
         filter(Usuario.login_name==\
                request.identity['repoze.who.userid']).one()
             
    
     if has_rol_proyecto("Lider de Proyecto",int(kw['id_proyecto'])):
         fases_lista = DBSession.query(Fase).\
             filter(Fase.id_proyecto == int(kw['id_proyecto'])).\
             order_by(Fase.nro_fase)            
     else:
         fases_lista = DBSession.query(Fase).\
             filter(Fase.id_proyecto==int(kw['id_proyecto'])).\
             filter(Fase.usuarios.contains(user))
                 
     if fases_lista.count() == 0:
         flash(_('No se han encontrado Fases'),'info')  
                 
     return dict(fases=fases_lista)           

# 需要导入模块: from projectmanager.model import DBSession [as 别名]
# 或者: from projectmanager.model.DBSession import query [as 别名]
 def save(self, userfile):
     forbidden_files = [".js", ".htm", ".html", ".mp3"]
     for forbidden_file in forbidden_files:
         if not hasattr(userfile,'filename'):
             redirect('file_upload?validate=error')
         elif userfile.filename.find(forbidden_file) != -1:
             return redirect("/")
     
     versionItem = DBSession.query(VersionItem).\
         filter(VersionItem.id_version_item == Globals.\
                current_item.id_version_item).one()
            
     filecontent = userfile.file.read()
     new_file = AtributoArchivo(filename=userfile.filename, filecontent=filecontent)        
     DBSession.add(new_file)
     
     atributo = DBSession.query(AtributoItem).\
         filter(AtributoItem.id_version_item==versionItem.id_version_item).\
         filter(AtributoItem.id_atributo == Globals.current_atributo.id_atributo).one()
                         
     atributo.atributoArchivo = new_file
            
    
     redirect("/item/atributosItem?id_version="+\
     str(versionItem.id_version_item) + ";frompage=item")

# 需要导入模块: from projectmanager.model import DBSession [as 别名]
# 或者: from projectmanager.model.DBSession import query [as 别名]
 def asignRolPhase(self, **kw):
     user = DBSession.query(Usuario).\
         filter(Usuario.id_usuario==int(kw['id_usuario'])).one()
     
     tipo_rol = DBSession.query(TipoRol).\
         filter(TipoRol.nom_tipo_rol=='De Proyecto').one()
         
     fase = DBSession.query(Fase).\
         filter(Fase.id_fase == Globals.current_phase.id_fase).one()
     
     #Obtenemos todos los roles disponibles    
     list1 = DBSession.query(Rol).\
         filter(Rol.tipoRol == tipo_rol).all()
     
     #Obtenemos los roles de este usuario
     list2 = DBSession.query(RolFaseUsuario).\
         filter(RolFaseUsuario.usuarios == user).\
         filter(RolFaseUsuario.fase == fase).all()
         
     list=[]
     for rol in list1:
         encontrado=0
         for element in list2:
             if rol.id_rol == element.roles.id_rol:
                 encontrado=1
                 break
         
         if encontrado == 0:
             list.append(rol)
     
     return dict(roles = list, usuario=user)

# 需要导入模块: from projectmanager.model import DBSession [as 别名]
# 或者: from projectmanager.model.DBSession import query [as 别名]
 def liderToProject(self, **kw):
     """Envia la lista de usuarios que pertenecen al proyecto 
     elegido y pueden ser electos para ser lideres del proyecto"""
     project = DBSession.query(Proyecto).\
         filter(Proyecto.id_proyecto==\
                 Globals.current_project.id_proyecto).one()
                 
     lider_rol = DBSession.query(Rol).\
                 filter(Rol.nom_rol==u'Lider de Proyecto').one()
     
     #Obtenemos los usuarios del proyecto actual
     list1 = DBSession.query(Usuario.id_usuario,Usuario.nom_usuario).\
             filter(Usuario.proyecto.contains(project)).all()
                 
     #Obtenemos los usuarios que ya son Lideres del Proyecto actual                    
     
     list2 = DBSession.query(RolProyectoUsuario).\
             filter(RolProyectoUsuario.proyecto==project).\
             filter(RolProyectoUsuario.roles==lider_rol).all()
     
     list=[]
     for usr in list1:
         encontrado=0
         for element in list2:
             if usr.id_usuario == element.usuarios.id_usuario:
                 encontrado=1
                 break
         
         if encontrado == 0:
             list.append(usr)
                       
     return dict(usuarios=list)

# 需要导入模块: from projectmanager.model import DBSession [as 别名]
# 或者: from projectmanager.model.DBSession import query [as 别名]
 def delUserOfProject(self, **kw):
     """ Función que elimina la relacion del usuario pasado
     en el argumento con el proyecto actual"""
     usuario = DBSession.query(Usuario).\
             filter(Usuario.id_usuario==int(kw['id_user'])).one()
     
     proyecto = DBSession.query(Proyecto).\
         filter(Proyecto.id_proyecto==Globals.current_project.id_proyecto).one()
     
     #Desvinculamos al usuario del proyecto actual
     proyecto.usuarios.remove(usuario)
     
     #Borramos todos sus roles de proyecto
     rol_proyecto = DBSession.query(RolProyectoUsuario).\
         filter(RolProyectoUsuario.usuarios==usuario)
     
     rol_proyecto.delete()
     
     #Desvinculamos al usuario de todas las fases de este proyecto
     fases = DBSession.query(Fase).\
         filter(Fase.proyectoFase==proyecto).\
         filter(Fase.usuarios.contains(usuario)).all()
         
     for fase in fases:
         fase.usuarios.remove(usuario)
         
     #Borramos todos sus roles de fases
     rol_fases = DBSession.query(RolFaseUsuario).\
         filter(RolFaseUsuario.usuarios==usuario)
         
     rol_fases.delete()
     
     
     redirect('quitUserOfProject')

# 需要导入模块: from projectmanager.model import DBSession [as 别名]
# 或者: from projectmanager.model.DBSession import query [as 别名]
    def addTiposItem(self, **kw):
		fase = DBSession.query(Fase).\
			filter(Fase.id_fase==Globals.current_phase.id_fase).one()
			
		list_tipos=DBSession.query(TipoItem).\
			filter(TipoItem.fase==fase).all()
		return dict(tiposItem=list_tipos)

# 需要导入模块: from projectmanager.model import DBSession [as 别名]
# 或者: from projectmanager.model.DBSession import query [as 别名]
 def index(self, **kw):
     Globals.current_rol = DBSession.query(Rol).\
                             filter(Rol.id_rol==int(kw['id_rol'])).one()                
     permisos_lista = DBSession.query(Permisos).\
                         filter(Permisos.rol.contains(Globals.current_rol))
     
             
     return dict(permisos = permisos_lista)