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
 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
 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
 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")
 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')
 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)
    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")
 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)
 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)           
 def delete(self, fileid):
     try:
         userfile = DBSession.query(AtributoArchivo).filter_by(id=fileid).one()
     except:
         return redirect("/")
     DBSession.delete(userfile)
     return redirect("/")
 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)
    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)
 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')
 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)
 def usersRol(self, **kw):
     fase = DBSession.query(Fase).\
         filter(Fase.id_fase==\
                Globals.current_phase.id_fase).one()
         
     users = DBSession.query(Usuario).\
         filter(Usuario.fases.contains(fase)).all()
     
     return dict(usuarios=users)
 def saveUserToPhase(self, **kw):
     usuario = DBSession.query(Usuario).\
                 filter(Usuario.id_usuario==int(kw['id_user'])).one()
                 
     fase = DBSession.query(Fase).\
             filter(Fase.id_fase == Globals.current_phase.id_fase).one()
             
     fase.usuarios.append(usuario)
     
     redirect('asignUsers')
 def listUsersProject(self):
     """Envia al template la lista de usuarios que pertenecen
     al proyecto actual para mostrar una lista de estos"""
     #Obtenemos los usuarios del proyecto actual       
     project = DBSession.query(Proyecto).\
         filter(Proyecto.id_proyecto==\
                 Globals.current_project.id_proyecto).one()
     list = DBSession.query(Usuario.id_usuario,Usuario.nom_usuario).\
             filter(Usuario.proyecto.contains(project))
     
     return dict(usuarios=list)
 def delPrivilegio(self, **kw):
     permiso=DBSession.query(Permisos).\
             filter(Permisos.id_permiso==int(kw['id_permiso'])).one()
                 
     privilegio=DBSession.query(Privilegios).\
             filter(Privilegios.id_privilegio==\
                    int(kw['id_privilegio'])).one()
                       
     permiso.privilegios.remove(privilegio)
     
     redirect('index?id_rol='+str(Globals.current_rol.id_rol))
 def quitUserOfProject(self, **kw):
     """Lista de usuarios para
     Desasignar del Proyecto Elegido"""         
     #Obtenemos los usuarios del proyecto actual       
     project = DBSession.query(Proyecto).\
         filter(Proyecto.id_proyecto==\
                 Globals.current_project.id_proyecto).one()
     list = DBSession.query(Usuario.id_usuario,Usuario.nom_usuario).\
             filter(Usuario.proyecto.contains(project))
     
     return dict(usuarios=list)
 def addPrivilegio(self, **kw):
     permiso = DBSession.query(Permisos).\
             filter(Permisos.id_permiso==int(kw['id_permiso'])).one()
             
     opciones = DBSession.query(Privilegios.id_privilegio,\
                                Privilegios.nom_privilegio).\
                 filter(~Privilegios.permiso.contains(permiso))
     
     tmpl_context.form = add_privilegios
                 
     return dict(option_list=opciones, idPermiso=int(kw['id_permiso']))
 def searchUsersOfPhase_list(self, **kw):
     word = '%'+kw['key']+'%'
             
     fase = DBSession.query(Fase).\
         filter(Fase.id_fase==\
                Globals.current_phase.id_fase).one()
                
     users = DBSession.query(Usuario).\
         filter(Usuario.fases.contains(fase)).\
         filter(Usuario.nom_usuario.like(word)).all()
         
     return dict(usuarios=users)
 def appendPrivilegio(self, **kw):
     permiso = DBSession.query(Permisos).\
             filter(Permisos.id_permiso==int(kw['id_permiso'])).\
             one()
           
     if kw['privilegios'] != None:
         for id_privilegio in kw['privilegios']:
             privilegio = DBSession.query(Privilegios).\
                             filter(Privilegios.id_privilegio==\
                                    int(id_privilegio)).one()
             permiso.privilegios.append(privilegio)
      
     redirect('index?id_rol='+str(Globals.current_rol.id_rol))
 def savePhase(self, **kw):
     Phase = Fase()
     project = DBSession.query(Proyecto).\
         filter(Proyecto.id_proyecto == Globals.current_project.id_proyecto).one()
     estado =DBSession.query(Estado).\
         filter(Estado.nom_estado == 'Inicial').one()
     Phase.proyectoFase = project
     Phase.estadoFase = estado
     Phase.nro_fase = kw['nroPhase']
     Phase.nom_fase = kw['phaseName']
     Phase.des_fase = kw['descripcion']                
     DBSession.add(Phase)                
     flash(_("Se ha creado una nueva Fase: %s") %kw['phaseName'],'info')
     redirect("index?id_proyecto="+str(Globals.current_project.id_proyecto))
 def saveUserToProject(self, **kw):    
     """Funcion que se encarga de guardar en la base de datos
     la relacion del usuario seleccionado con el proyecto
     actual"""
     
     proyecto = DBSession.query(Proyecto).\
         filter(Proyecto.id_proyecto == \
                 Globals.current_project.id_proyecto).one()
     
     usuario = DBSession.query(Usuario).\
                 filter(Usuario.id_usuario == int(kw['id_user'])).\
                 one()
     proyecto.usuarios.append(usuario)
         
     redirect('userToProject')
 def listLideres(self, **kw):
     """ Pasa la lista de usuarios que poseen el rol de Lider
     de Proyecto en el Proyecto actual elegido"""
     lider_rol = DBSession.query(Rol).\
                 filter(Rol.nom_rol==u'Lider de Proyecto').one()
            
     list1 = DBSession.query(RolProyectoUsuario).\
             filter(RolProyectoUsuario.roles==lider_rol).\
             filter(RolProyectoUsuario.proyecto==Globals.current_project).all()
     
     list=[]    
     for element in list1:
         list.append(element.usuarios)       
                     
     return dict(usuarios = list)
 def search(self, **kw):
     """Realiza la busqueda de proyectos que pertenecen al usuario
     actualmente logueado"""
     word = '%'+kw['key']+'%'        
     
     if is_type('admin'):
         projects = DBSession.query(Proyecto).\
                 filter(Proyecto.nom_proyecto.like(word)).\
                 order_by(Proyecto.nom_proyecto)
     else:
         projects = DBSession.query(Proyecto).\
             filter(Proyecto.nom_proyecto.like(word)).\
             filter(Proyecto.usuarios.any(login_name=request.identity['repoze.who.userid']))
         
     return dict(proyectos=projects)
 def searchUsers2(self, **kw):
     """Realiza la busqueda de usuarios que SI pertenecen al proyecto
     actual. Esta busqueda se utiliza para DESASIGNAR usuarios del 
     proyecto elegido"""
     word = '%'+kw['key']+'%'        
     
     #Obtenemos los usuarios del proyecto actual       
     project = DBSession.query(Proyecto).\
         filter(Proyecto.id_proyecto==\
                 Globals.current_project.id_proyecto).one()
     list = DBSession.query(Usuario.id_usuario,Usuario.nom_usuario).\
             filter(Usuario.nom_usuario.like(word)).\
             filter(Usuario.proyecto.contains(project))
         
     return dict(usuarios=list)
 def saveProject(self, **kw):
     """
     Funcion que se encarga de guardar los datos introducidos en el formulario
     para el nuevo proyecto.
     Al crear un nuevo proyecto se establece el estado de este
     en 'No Iniciado'
     """
     aProject = Proyecto()
     estado =DBSession.query(Estado).filter(Estado.nom_estado == 'No Iniciado').one()
     aProject.estadoProyecto = estado
     aProject.nom_proyecto = kw['projectName']
     aProject.des_proyecto = kw['descripcion']
     DBSession.add(aProject)                
     flash(_("Se ha creado un nuevo Proyecto: %s") %kw['projectName'],'info')
     redirect("adminProject")
 def adminProject(self):
     """
     Muestra todos los proyectos existentes al administrador del 
     sistema o los proyectos del usuario que ha ingresado al sistema
     """
      
     if is_type('admin'):
         projects = DBSession.query(Proyecto).order_by(Proyecto.nom_proyecto)            
     else:
         user = DBSession.query(Usuario).\
             filter(Usuario.login_name==request.identity['repoze.who.userid']).one()
         
         projects = DBSession.query(Proyecto).\
             filter(Proyecto.usuarios.contains(user)).all()
         
     return dict(proyectos=projects)
 def saveRolPhase(self, **kw):
     rol = DBSession.query(Rol).\
         filter(Rol.id_rol == int(kw['id_rol'])).one()
         
     fase = DBSession.query(Fase).\
         filter(Fase.id_fase == Globals.current_phase.id_fase).one()
         
     user = DBSession.query(Usuario).\
         filter(Usuario.id_usuario==int(kw['id_usuario'])).one()
         
     rol_fase = RolFaseUsuario()
     rol_fase.roles = rol
     rol_fase.fase = fase
     rol_fase.usuarios = user
          
     redirect('asignRolPhase?id_usuario=' + str(user.id_usuario))