Example #1
0
 def post(self):
     """
     Metodo utilizado para recibir los datos de una linea base cuyos valores
     corresponden a los nuevos valores que tomara esa linea base en el sistema. 
     Invocado cuando se hace una peticion de modificacion de 
     linea base al servidor.
     @type descripcion : sting
     @param descripcion: descripcion de la linea base a agregar
     @type idLB : string
     @param idLB : id de la linea base a modificar
     @type estado : string
     @param estado : id de la linea base a modificar
     """
     idLb=flask.request.form['idLB']
     descripcion=flask.request.form['descripcion']
     estado=flask.request.form['estado']
     
     sesion=Session()
     l=sesion.query(LineaBase).filter(LineaBase.id==int(idLb)).first()
     if l is None:
         return "t, Linea Base no existe"
     if controlRol(str(l.idFase),'lb','administrar')==0:
         return "t, No posee permiso para realizar esta accion"
     
     
     if estado!="abierta":
         return "t,No puede modificarse una Linea Base " + estado
     lb=LineaBase(descripcion,estado)
     lb.descripcion=lb.descripcion.strip()
     lb.estado=lb.estado.strip()
     idLb=idLb.strip()
     lbc=LBControllerClass()
     
     return lbc.controlarLB(lb, idLb)
Example #2
0
 def controlarLB(self,lb,idLb):
     """
     Metodo utilizado para controlar los datos recibidos del cliente
     @type  lb: LineaBase
     @param lb: LineaBase cuyos datos seran controlados antes de ser almacenados en la bd
     @type  idLb: number
     @param idLb: El id de la linea base. Si es cero, la linea base enviada es nueva, sino, es una
         linea base ya existente cuyos atributos quieren ser modificados.
     """
     if len(lb.estado) <= 0 or len(lb.estado) > 15:
         return make_response("f,Estado de LineaBase incorrecto")
     if len(lb.descripcion) <= 0 or len(lb.descripcion) > 50:
         return make_response("f,Descripcion de LineaBase incorrecto")
     
     sesion=Session()
     controlDesc=sesion.query(LineaBase).filter(LineaBase.descripcion==lb.descripcion).first()
     if idLb==0:    
         if controlDesc is not None:
             sesion.close()
             return make_response("t,Descripcion de LineaBase coincide con otra!")
         if lb.idFase == '' or lb.idFase=='0':
             sesion.close()
             return make_response("t,Fase no valida. No se pudo crear la LineaBase")
         lb.idFase=int(lb.idFase)
     else:
         
         if controlDesc is not None and controlDesc.id != int(idLb):
             sesion.close()
             return make_response("t,Descripcion de LineaBase coincide con otra!")    
     lbm=LBManejador()    
     sesion.close()
     return lbm.guardarLB(lb, idLb)
         
Example #3
0
    def controlarPass(self, passNuevo, idU):
        sesion=Session()

        u=sesion.query(Usuario).filter(Usuario.id==idU).first()
        u.passwd=passNuevo
        um=UsuarioManejador()
        sesion.close()
        return um.guardarUsuario(u, idU)
Example #4
0
def controlRol(idFase,componente,permiso):
    
    permisos=flask.session['permisos']
    idUsuario=flask.session['idUsuario']
    idProyecto=flask.session['idProyecto']
    
    sesion=Session()
    idPL=sesion.query(Proyecto.projectLeaderId).filter(Proyecto.idProyecto==int(idProyecto)).first()
    print "id project  leader es:  "+str(idPL.projectLeaderId)+"id del usuario logueado es "+str(idUsuario)
    if idPL.projectLeaderId==int(idUsuario):
        sesion.close()
        return 1
    respuesta=0
    print "a veeeeeeeeer la fase que envio    " + idFase
    for p in permisos:
        '''corrobora si existe el permiso(consultar,finalizar,administrar) sobre el componente (fase,lb,item,tipo)'''
        
        if idFase in permisos:
            
            if permisos[idFase][componente][permiso]==1:
                respuesta=1
                sesion.close()
                return respuesta
    sesion.close()        
    return respuesta
 def setRoles(self,idProyecto,idUsuario):
     
     listadoPermisosProyecto=dict()
     
     sesion=Session()
     listaPermisos=sesion.query(Permiso.codigo,Fase.idFase).order_by('fase.id').filter(Usuario.id==int(idUsuario)).join(Usuario.roles_proyecto)\
                                 .join(Fase).join(Proyecto).filter(Proyecto.idProyecto==int(idProyecto)).join(RolProyecto.permisos).all()
     
     print "longitud lista permisos  " + str(len(listaPermisos))
     faseActual=0
     #rol=self.newRol()
     for permiso in listaPermisos:
         
         
           
         if faseActual!=permiso.idFase:
             '''se crea una estructura vacia que agrupa los permisos segun los componentes (fase==1,lb==2,item==3,tipo==4)'''
             rol=self.newRol()
             faseActual=permiso.idFase
         
         componente=permiso.codigo [:2]
         codigoPermiso= permiso.codigo [3:]
         
         if componente=='01':
             componente='fase'
         elif componente == '02':
             componente='lb'
         elif componente =='03':
             componente='item'
         elif componente =='04':
             componente='tipo'
         
         if codigoPermiso [0:1] == '1':
             codigoPermisoFinal='finalizar'
             rol[componente][codigoPermisoFinal]=1
         if codigoPermiso [1:2] == '1':
             codigoPermisoFinal='administrar'
             rol[componente][codigoPermisoFinal]=1
         if codigoPermiso [2:3] == '1':
             codigoPermisoFinal='consulta'
             rol[componente][codigoPermisoFinal]=1
              
         stringFase=str(permiso.idFase)
         listadoPermisosProyecto[stringFase]=rol
     print "listado de permisos es  este "+ str(listadoPermisosProyecto)
     flask.session['permisos']=listadoPermisosProyecto
     #print "valor de consulta para fase en el rol :  " + str(roles['fase']['consulta'])
     return
Example #6
0
    def post(self):
        rolSistemaJSON=flask.request.form['rolSistema']
        nombreUsuario=flask.request.form['nombreUsuario']
        passwd=flask.request.form['password']
        ci=flask.request.form['ci']
        nombre=flask.request.form['nombre']
        apellido= flask.request.form['apellido']
        email=flask.request.form['email']
        direccion=flask.request.form['direccion']
        telefono=flask.request.form['telefono']
        observacion=flask.request.form['observacion']
        activo=flask.request.form['activo']

        sesion=Session()
        rolSistema=json.loads(rolSistemaJSON)
        print "rol de sistema para project leader! "+ rolSistema[0]
        print "rol de sistema para administrador de usuarios! "+ rolSistema[1]
        rs=[]
        if rolSistema[0]=="1":
            rolSis=sesion.query(RolSistema).filter(RolSistema.nombre=="Project Leader").first()
            rs.append(rolSis)
        if rolSistema[1]=="1":
            rolSis=sesion.query(RolSistema).filter(RolSistema.nombre=="Administrador").first()
            rs.append(rolSis)
        sesion.close()    
        u=Usuario(nombreUsuario,passwd, nombre, apellido,email,ci,telefono,observacion,activo,direccion)
       
        u.username=u.username.strip()
        u.nombres=u.nombres.strip()
        u.passwd=u.passwd.strip()
        u.apellidos=u.apellidos.strip()
        u.email=u.email.strip()
        u.ci=u.ci.strip()
        u.telefono=u.telefono.strip()
        u.observacion=u.observacion.strip()
        u.activo=u.activo.strip()
        u.direccion=u.direccion.strip()
        for roles in rs:
            u.roles_sistema.append(roles)
      
        uc=UsuarioControllerClass()
        
        return uc.controlarUsuario(u, 0)
 def guardarRolProyecto(self, rol, idRol):
     sesion=Session()
     r=rol
     if idRol != 0:
         r=sesion.query(RolProyecto).filter(RolProyecto.id==idRol).first()
         r.nombre=rol.nombre;r.descripcion=rol.descripcion;r.estado=rol.estado
         
         
     sesion.add(r)
     sesion.commit()
     sesion.close()
     
     return make_response("f,Rol guardado correctamente")
Example #8
0
 def get(self):
     """
     Recibe la peticion de listar fases, segun los parametros que incluya la peticion.
     @type idProyecto:string
     @param idProyecto: indica el proyecto sobre el que se filtraran las fases a listar
     """
     sesion=Session() 
     #se obtiene los datos de post del server
     idProyecto=flask.session['idProyecto']
     '''
     cantComite=sesion.query(Proyecto).filter(Proyecto.idProyecto==idProyecto).join(Proyecto.usuariosComite).count()
     if cantComite % 2 ==0 or cantComite == 0:
         idProyecto=0;
     '''
     fasesLista=sesion.query(Fase).order_by("id asc").filter(Fase.idProyecto==idProyecto).all()
    
     
     respuesta=self.jasonizar(fasesLista)
     sesion.close()
     return respuesta
     
Example #9
0
 def guardarUsuario(self, user, idUsuario):
     sesion=Session()
     u=user;
     if(idUsuario!=0):
         u=sesion.query(Usuario).filter(Usuario.id==idUsuario).first()
         u.setValues(user.username,user.passwd, user.nombres, user.apellidos,\
                     user.email,user.ci,user.telefono,user.observacion,user.activo,\
                     user.direccion)
     
   
     sesion.add(u)
     sesion.commit()
     sesion.close()
     
     return make_response("f,Usuario guardado correctamente")
Example #10
0
 def controlarProyecto(self, proyecto, idProyecto):
     p=proyecto
     
     p.nombreProyecto=p.nombreProyecto.strip()
     p.observacion=p.observacion.strip()
     try:
         p.presupuesto=float(p.presupuesto)
         p.projectLeaderId=int(p.projectLeaderId)
     except:
         return make_response('t, presupuesto invalido o nro de fases invalido o \
                             projectLeaderId invalido ')
     
     '''controla el tamano de los strings, si son validos los enteros '''
      
     if not(1<=len(p.nombreProyecto)<20 \
           and 0<=len(p.observacion)<50):
         return make_response('t,Se supera caracteres de los campos ')
         
     if not(isinstance(p.projectLeaderId, int)):
         return make_response('t,projectLeaderId invalido no int ')
     
     
     if not(isinstance(p.presupuesto, float) and p.presupuesto>=float(0.0)):
         return make_response('t,PRESUPUESTO invalido')
     
     
     '''consulta si es que existe ya proyecto con ese nombre si es nuevo proyecto a crear'''
     sesion=Session()
     if(idProyecto==0):
         pry=sesion.query(Proyecto).filter(Proyecto.nombreProyecto==p.nombreProyecto).first()
         if(pry is not None):
             sesion.close()
             return make_response('t,Ya existe Proyecto con ese nombre')
     else:
         pry=sesion.query(Proyecto).filter(Proyecto.nombreProyecto==p.nombreProyecto).first()
         if(pry is not None and int(pry.idProyecto)!=int(idProyecto)):
             sesion.close()
             return make_response('t,Ya existe Proyecto con ese nombre')
     
     um=ProyectoManejador()
     sesion.close()
     return um.guardarProyecto(p, idProyecto)
     
Example #11
0
 def guardarProyecto(self, proyect, idProyecto):
     sesion=Session()
     p=proyect;
     
     if(idProyecto!=0):
         p=sesion.query(Proyecto).filter(Proyecto.idProyecto==idProyecto).first()
         p.setValues(proyect.nombreProyecto,proyect.projectLeaderId, \
                     proyect.fechaInicio, proyect.fechaFinalizacion,\
                     proyect.presupuesto,\
                     proyect.observacion,proyect.estado)
     
     sesion.add(p)
     sesion.commit()
     sesion.close()
     
     return make_response("f,Proyecto guardado correctamente")
 def post(self):
     
     idProyecto=flask.request.form['idProyecto']
     print "el proyecto es"+ str(idProyecto)
     
     
     
     sesion=Session()
     
     
     cantComite=sesion.query(Usuario).filter(Proyecto.idProyecto==idProyecto).join(Proyecto.usuariosComite).count()
     
     flask.session['esComite']=0
     if cantComite==0:
         sesion.close()
         flask.session['idProyecto']=0
         return make_response('t,El proyecto no posee miembros en Comite')
     if cantComite % 2 == 0 :
         sesion.close()
         flask.session['idProyecto']=0
         return make_response('t,La cantidad de miembros de comite es PAR')
     
     flask.session['idProyecto']=idProyecto
     
     
     idProyectoSeleccion=flask.session['idProyecto']
     idUsuario=flask.session['idUsuario']
     comiteProject=sesion.query(Usuario.id).filter(Proyecto.idProyecto==idProyectoSeleccion).join(Proyecto.usuariosComite)\
                                       .filter(Usuario.id==idUsuario).first();
     sesion.close()
     if comiteProject is None:
         flask.session['esComite']=0
     else:
         flask.session['esComite']=1
     
     print "valor de comite es:   " + str(flask.session['esComite'])     
     
     self.setRoles(idProyecto,idUsuario)
     
     return str(flask.session['esComite'])
Example #13
0
 def guardarLB(self, lb, idLb):
     """
     Metodo utilizado para guardar los datos de la fase
     @type  lb: LineaBase
     @param lb: LineaBase cuyos datos seran controlados antes de ser almacenados en la bd
     @type  idLb: number
     @param idLb: El id de la LineaBase. Si es cero, la LineaBase enviada es nueva, sino, es una
         LineaBase ya existente cuyos atributos quieren ser modificados.
     """
     sesion=Session()
     l=lb
     if idLb != 0:
         l=sesion.query(LineaBase).filter(LineaBase.id==idLb).first()
         l.descripcion=lb.descripcion;l.estado=lb.estado
         
         
     sesion.add(l)
     sesion.commit()
     sesion.close()
     
     return make_response("f,LineaBase guardada correctamente!")
Example #14
0
 def post(self):
     """
     Metodo utilizado para recibir los datos para la creacion del archivo en la base de datos. 
     El metodo es invocado cuando se hace una peticion de creacion de 
     archivo al servidor.
     @type  file: FILE
     @param file: archivo recibido como binario
     @type  id: int
     @param id: idItem dentro de la BD
     
     """
     if flask.request.method == 'POST':
         file = flask.request.files['fileToUpload']
         id=flask.request.form['idItem']
         
         sesion=Session()
         idFase=sesion.query(Item.idFase).filter(Item.idItem==int(id)).first()
         if controlRol(str(idFase.idFase),'item','administrar')==0:
             return "t, No tiene permisos para realizar esta accion"
         
         
         #flask.request.form['idItemInput']
         print (file) 
           
         if file and self.allowed_file(file.filename) and len(file.filename)<=50:
             filename = secure_filename(file.filename) 
             #if not(os.path.exists(UPLOAD_FOLDER)):
             #os.makedirs(UPLOAD_FOLDER);
             #file.save(os.path.join(UPLOAD_FOLDER, filename))
             arc=file.read()
             miFile=Archivos(filename, arc, id)
             sesion.add(miFile)
             sesion.commit()
             sesion.close()
             return  make_response("<span class='msg' style='font:12px/12px Arial, Helvetica, sans-serif;'>Se subio sscorrectamente el archivo</span> ")
         #make_response('f,Archivo subido correctameten')
         
         else: 
             return'''
Example #15
0
 def guardarFase(self, fase, idFase):
     """
     Metodo utilizado para guardar los datos de la fase
     @type  f: Fase
     @param f: Fase cuyos datos seran controlados antes de ser almacenados en la bd
     @type  idF: number
     @param idF: El id de la fase. Si es cero, la fase enviada es nueva, sino, es una
         fase ya existente cuyos atributos quieren ser modificados.
     """
     sesion=Session()
     f=fase;
     
     if(idFase!=0): 
         f=sesion.query(Fase).filter(Fase.idFase==idFase).first()
         f.setValues(fase.nombreFase,fase.descripcion, \
                     fase.estado, fase.fechaInicio,\
                     fase.fechaFinalizacion,\
                     fase.idProyecto)
     
     sesion.add(f)
     sesion.commit()
     sesion.close()
     
     return make_response("f,Fase guardada correctamente")
Example #16
0
    def wrapper(*args, **kwargs):
        
        sesion=Session()
        idProyectoSeleccion=flask.session['idProyecto']
        idUsuario=flask.session['idUsuario']
        comiteProject=sesion.query(Usuario.id).filter(Proyecto.idProyecto==idProyectoSeleccion).join(Proyecto.usuariosComite)\
                                          .filter(Usuario.id==idUsuario).first();

        if comiteProject is None:
            sesion.close()
            if 'rolPL' in flask.session or'rolAdmin' in flask.session:
                return flask.redirect(flask.url_for('miembros'))
            flask.flash("No es miembro del comite!")
            return flask.redirect(flask.url_for('index'))                                   
        else:
            print "PARTE DEL COMITE!!   "
            sesion.close()
            return method(*args, **kwargs)
 def post(self):
 
     idProyecto=flask.request.form['idProyecto']
     print 'Se busca ' + str(idProyecto)
     idUsuario=flask.request.form['idUsuarioAgregar']
     
     sesion=Session()
     user=sesion.query(Usuario).filter(Usuario.id==idUsuario).first()
    
     if(idProyecto!=0):
         p=sesion.query(Proyecto).filter(Proyecto.idProyecto==int(idProyecto)).first()
         if(user in p.usuariosMiembros):
             sesion.close()
             return "t,Usuario ya existe en proyecto" 
         else:
             p.usuariosMiembros.append(user)
         sesion.add(p)
         sesion.commit()
     
     sesion.close()
     
    
     return "f,Usuario agregado correctamente al proyecto" 
 
     
         
 def post(self):
     
     idProyecto=flask.request.form['idProyecto'] 
     idSolicitante=flask.request.form['idSolicitante']
     descripcion=flask.request.form['descripcion']
     estado="pendiente"
     itemsJSON=flask.request.form['items']
     listaItem=json.loads(itemsJSON)
     
     idProyecto=idProyecto.strip()
     idSolicitante=idSolicitante.strip()
     descripcion=descripcion.strip()
     
     #controles
     if idProyecto == '0' or idProyecto== '' or idProyecto is None:
         return make_response('t,Proyecto no valido')
     if idSolicitante == '0' or idSolicitante== '' or idSolicitante is None:
         return make_response('t,Usuario Solicitante no valido')
     lenD = len(descripcion)
     if lenD <=0 or lenD > 50:
         return make_response('t,Descripcion de Motivo no valida')
     lenD= len (listaItem)
     if lenD <=0:
         return make_response('t,Debe incluir items en la solicitud')
         
     SC=SolicitudCambio(descripcion,estado)
     SC.idSolicitante=idSolicitante
     SC.idProyecto=idProyecto
     
     sesion=Session()
     
     for idItem in listaItem:
         id=int(idItem)
         item=sesion.query(Item).filter(Item.idItem==id).first()
         
         if item is None:
             sesion.close()
             return make_response('t,Uno de los items no existe')
         
         if item.estado=="bloqueado":
             lb=sesion.query(LineaBase).join(LineaBase.items).filter(Item.idItem==item.idItem).filter(LineaBase.estado!="inactiva").first()
             if lb.estado != "cerrada":
                 sesion.close()
                 return make_response('t, el item '+item.nombreItem+' se encuentra en una Linea Base abierta')
         #control para no poner un item en mas de una SC
         SCpendientes=sesion.query(SolicitudCambio).filter(SolicitudCambio.estado=="pendiente")\
                                         .join(SolicitudCambio.items)\
                                         .filter(Item.idItem==id).count()
         if SCpendientes > 0:
             return make_response('t,El item ya se encuentra en otra solicitud')
             sesion.close()
         ##################################    
         SC.items.append(item)
     
     comite=sesion.query(Usuario).join(Proyecto.usuariosComite).filter(Proyecto.idProyecto==int(idProyecto)).all()
     i=0
     #sesion.add(SC)
     
     for miembro in comite:
         print "miembros id   " + str(miembro.id)
         voto=Voto()
         voto.solicitud=SC.id
         voto.votante=miembro.id
         voto.voto="p"
         sesion.add(voto)
         #SC.votos.append(voto)
         #sesion.add(voto)
     sesion.add(SC)    
     sesion.commit()
     sesion.close()        
     return make_response('f,Solicitud creada con Exito!')
Example #19
0
 def controlarFase(self, f, idF):
     """
     Metodo utilizado para controlar los datos recibidos del cliente
     @type  f: Fase
     @param f: Fase cuyos datos seran controlados antes de ser almacenados en la bd
     @type  idF: number
     @param idF: El id de la fase. Si es cero, la fase enviada es nueva, sino, es una
         fase ya existente cuyos atributos quieren ser modificados.
     """
     
     f.nombrefase=f.nombreFase.strip()
     #f.fechaInicio=f.fechaInicio.strip()
     #f.fechaFinalizacion=f.fechaFinalizacion.strip()
     f.descripcion=f.descripcion.strip()
     f.estado=f.estado.strip()
     print 'nombre de fase es' + str(f.nombreFase)
     print 'fecha inicio'+str(f.fechaInicio)
     print str(f.fechaFinalizacion)
     
     #try:
     print 'idproyecto ' + str(f.idProyecto)
     f.idProyecto=int(f.idProyecto)
     #except:
     #    return make_response ('t, idProyecto no se pudo castear')
     
     '''controla el tamano de los strings'''
      
     if not(1<=len(f.nombrefase)<=20 \
           and 1<=len(f.descripcion)<=50 and 1<=len(f.estado)<=12 ): 
         return make_response('t,Se supera caracteres de los campos ')
         
     
     '''controla caracterejectLeades validos en el username'''
     
     if not(1<=len(f.nombreFase)<20 \
           and 0<len(f.descripcion)<50):
         return make_response('t,Se supera caracteres de los campos ')
         
     if not(isinstance(f.idProyecto, int)):
         return make_response('t,projectLeaderId invalido no int ')
     
    
     '''consulta si es que existe ya usuario con ese nombre'''
     
     sesion=Session()
     qr=sesion.query(Fase).filter(Fase.idProyecto==f.idProyecto).filter(Fase.nombreFase==f.nombreFase).first()
     
     #print 'consulta es'+ qr
     
     if(idF==0):
         if(qr is not None):
             sesion.close()
             return make_response('t,Ya existe una fase con el nombre indicado')
     else:
         if( qr is not None and str(qr.idFase) != idF ):
             sesion.close()
             return make_response('t,Ya existe una fase con el nombre indicado')
     
     '''cuando la fase es nueva se le setea su tag'''
     if(idF==0):
         nroFasesActuales=sesion.query(Fase).filter(Fase.idProyecto==f.idProyecto).count();
         sum=nroFasesActuales+1
         f.tag="F"+str(sum);
     
     fm=FaseManejador()
     sesion.close()
     return fm.guardarFase(f, idF)
     
Example #20
0
    def post(self):
        
        idRol=flask.request.form['idRol']
        estado=flask.request.form['estado']
        
        sesion=Session()
        rol= sesion.query(RolProyecto).filter(RolProyecto.id==int(idRol)).first()
        if rol is None:
            sesion.close()
            return "t,No existe Rol"
        if estado == "activo":
            #se debe pasar a inactivo
            cantidad = sesion.query(RolProyecto).filter(RolProyecto.id==idRol).join(RolProyecto.usuarios).count()
            if cantidad > 0:
                sesion.close()
                return "t,No se puede inactivar el Rol. Ya ha sido asignado a usuario/s"
            rol.estado="inactivo"

            sesion.add(rol)
            sesion.commit()
            sesion.close()
            return "f,El Rol ha sido inactivado!" 

            
        else: 
            #se debe pasar a activo
            cantidad = sesion.query(RolProyecto).filter(RolProyecto.id==idRol).join(RolProyecto.permisos).count()
            if cantidad == 0:
                return "t,No se puede activar el Rol. No tiene permisos asignados"
            rol.estado="activo"
            
            sesion.add(rol)
            sesion.commit()
            sesion.close()
            return "f,El rol ha sido activado! Ya no se permitiran modificaciones." 
Example #21
0
 def post(self):
 
     idProyecto=flask.request.form['idProyecto']
     idProyecto=idProyecto.strip()
     if idProyecto=="0" or idProyecto=='':
         return "t, Fase no valida"
      
     sesion=Session()
     proyecto= sesion.query(Proyecto).filter(Proyecto.idProyecto==int(idProyecto)).first()
     
     #Controles
     if proyecto is None:
         sesion.close()
         return "t,La El proyecto no existe"
     
     if proyecto.estado != "activo":
         sesion.close()
         return "t,No se puede finalizar un proyecto que no este activo!"
     
     fasesProyecto= sesion.query(Fase).join(Proyecto).filter(Proyecto.idProyecto==int(idProyecto))
     
     for fase in fasesProyecto:
         if fase.estado!="finalizada":
             sesion.close()
             return "t,Todas las FASES deben estar FINALIZADAS"
     
     
     now=datetime.date.today()
     proyecto.fechaFinalizacion=now    
     proyecto.estado="finalizado"
     sesion.add(proyecto)
     sesion.commit()
     sesion.close()
     
     return "f,Ha finalizado el proyecto!" 
Example #22
0
    def guardarTipoItem(self, t_item, idT_Item, listaAtributos, idProyecto, idFase):
        sesion=Session()
        ti=t_item;
          
        if(idT_Item!=0): #es un tipo de item a modificar
            ti=sesion.query(TipoItem).filter(TipoItem.idTipoItem==idT_Item).first()
            ti.setValues(t_item.nombreTipoItem,t_item.descripcion, t_item.estado)
            
            #se traen todos los atributos de la BD correspondiente a ese item
            atribListaBD=sesion.query(Atributos).filter(Atributos.tipoItemId==idT_Item).all();
            print(atribListaBD)
            ids=[]
            #se agregar a una lista los ID's de esos atributos en BD
            for atribBD in atribListaBD:
                ids.append(atribBD.idAtributo)
                
            print(ids)
            
            #si existe atributo en la lista 
            for atr in listaAtributos:
                atr.tipoItemId=idT_Item;
                if atr.idAtributo in ids: #si el atributo esat en la lista se eliminar, o sino significa que es nuevo
                    ids.remove(atr.idAtributo)
                sesion.merge(atr)
            
            #todo lo que sobra en la lista se elimina
            for idAEliminar in ids:
                sesion.query(Atributos).filter(Atributos.idAtributo==idAEliminar).delete();
                    
        else:#es un tipo de item nuevo
            miFase=sesion.query(Fase).filter(Fase.idFase==idFase).first()
            ti.fase=miFase;
            ti.atributosItem=listaAtributos #como es nuevo se asume que todos sus atributos son nuevos
            #ti.Atributos.append()
        '''se obtiene la fase para relacionar al tipo de item'''
        
        sesion.add(ti)
        #ti=sesion.query(TipoItem).filter(TipoItem.nombreTipoItem==t_item.nombreTipoItem).first()
        sesion.commit()
         
        #sesion.add(listaAtributos[0])
        """for atrib in listaAtributos:
            atrib.tipoItemId=ti.idTipoItem;
            print 'lalalall' +str(atrib.tipoItemId)
            sesion.add(atrib)"""
            #ti.atributosItem.append(atrib);

        #for atrib in listaAtributos:
        #    atrib.tipoitem=t_item
        
        sesion.close()
        
        return make_response("f,Tipo de item guardado correctamente")
Example #23
0
 def post(self):
 
     voto=flask.request.form['voto']
     idSC=flask.request.form['idSC']
     idUsuario=flask.session['idUsuario']
     sesion=Session()
     
     voto=voto.strip()
     idSC=idSC.strip()
     
     
     if voto != 'si' and voto !='no':
         sesion.close() 
         return "t,Voto no valido"
     if idSC=='' or idSC=='0':
         sesion.close()
         return "t,Solicitud no valida"
     SC=sesion.query(SolicitudCambio).filter(SolicitudCambio.id==idSC).first()
     if SC is None:
         sesion.close()
         return "t,Solicitud no valida"
     
     if SC.estado!= "pendiente":
         sesion.close()
         return "t,La Solicitud ya ha sido procesada"
     
     aprobados=sesion.query(Voto).filter(Voto.solicitud==idSC,Voto.voto=='si').count()
     rechazados=sesion.query(Voto).filter(Voto.solicitud==idSC,Voto.voto=='no').count()
     total=sesion.query(Voto).filter(Voto.solicitud==idSC).count()
     
     setVoto=sesion.query(Voto).filter(Voto.solicitud==idSC,Voto.votante==idUsuario).first()
     if setVoto.voto!='p':
         voto=setVoto.voto
         desicion=''
         if voto=='si':
             desicion='Aprobar'
         if voto=='no':
             desicion='Rechazar'
         return "t,Usted ya ha votado por "+desicion+" la solicitud"
     
     setVoto.voto=voto;
     sesion.add(setVoto)
     
     
     
     desicion=''
     if voto=='si':
         aprobados=aprobados+1
         desicion='Aprobar'
     if voto=='no':
         rechazados=rechazados+1
         desicion='Rechazar'
     
     extraMsj=''
     
     print "resultado de la  operacion es:   " + str(aprobados/float(total))
     if aprobados/float(total) > 0.5:
         extraMsj="La solicitud tiene mayoria en APROBAR. Se ha APROBADO la solicitud "
         listaItemQuery=sesion.query(Item.idItem).filter(SolicitudCambio.id==idSC).join(SolicitudCambio.items).all()
         listaItem=[]
         for it in listaItemQuery:
             listaItem.append(it.idItem)
         for it in listaItem:
             print "item en listado a pasar:  "+ str(it)
                 
         ejecutarSCLB(listaItem,idSC)
         SCaprobada=sesion.query(SolicitudCambio).filter(SolicitudCambio.id==idSC).first()
         SCaprobada.estado='aprobada'
         sesion.add(SCaprobada)
     if  rechazados/float(total) > 0.5:
         extraMsj="La solicitud tiene mayoria en RECHAZAR. Se ha RECHAZADO la solicitud "
         SCrechazada=sesion.query(SolicitudCambio).filter(SolicitudCambio.id==idSC).first()
         SCrechazada.estado='rechazada' 
         sesion.add(SCrechazada)
     sesion.commit()
     sesion.close()    
     return "f,Usted ha votado por "+desicion+" la solicitud "+extraMsj 
Example #24
0
 def post(self):
 
     idProyecto=flask.request.form['idProyecto']
     sesion=Session()
     
     proyecto= sesion.query(Proyecto).filter(Proyecto.idProyecto==int(idProyecto)).first()
     
     #Controles
     if proyecto is None:
         sesion.close()
         return "t,El proyecto no existe"
     
     if proyecto.estado != "desarrollo":
         sesion.close()
         return "t,No se puede pasar a Activo, el proyecto debe estar en desarrollo!"
     
     numberMiembros= len(proyecto.usuariosMiembros)
     if numberMiembros <= 0:
         sesion.close()
         return "t,El proyecto no posee miembros!"
         
     numberComite= len(proyecto.usuariosComite)
     if numberComite  <= 0:
         sesion.close()
         return "t,El comite de cambios no posee miembros!"
     resto= numberComite % 2
     if resto == 0:
         sesion.close()
         return "t,El comite de cambios debe estar compuesto por un numero impar de miembros!"
     
     numberFases= sesion.query(Proyecto).filter(Proyecto.idProyecto==int(idProyecto)).join(Fase).count();
     if numberFases <= 0:
         sesion.close()
         return "t,No se puede pasar a Activo, el proyecto no contiene fases!"
     
     fasesProyecto=sesion.query(Fase).join(Proyecto).filter(Proyecto.idProyecto==int(idProyecto));
     for fase in fasesProyecto:
         fase.estado="activa"
         print "Fase:  "+fase.nombreFase+" estado de la fase: "+fase.estado
         sesion.add(fase)
         
     now=datetime.date.today()
     proyecto.fechaInicio=now
     proyecto.estado="activo"
     
     primeraFase=sesion.query(Fase).filter(Fase.idProyecto==idProyecto,Fase.tag=="F1").first()
     primeraFase.fechaInicio=proyecto.fechaInicio
     sesion.add(proyecto)
     sesion.add(primeraFase)
     sesion.commit()
     
     
     sesion.close()
     
     return "f,El proyecto ha sido activado! Ya no se permitiran modificaciones." 
Example #25
0
 def controlarUsuario(self, usuario, idU):
     u=usuario
     
     u.username=u.username.strip()
     u.nombres=u.nombres.strip()
     u.passwd=u.passwd.strip()
     u.apellidos=u.apellidos.strip()
     u.email=u.email.strip()
     u.ci=u.ci.strip()
     u.telefono=u.telefono.strip()
     u.observacion=u.observacion.strip()
     u.activo=u.activo.strip()
     u.direccion=u.direccion.strip()
     
     '''controla el tamano de los strings'''
      
     if not(1<=len(u.username)<=20 and 1<=len(u.passwd)<=32 \
           and 1<=len(u.nombres)<=30 and 1<=len(u.apellidos)<=30 and 1<=len(u.email)<=30 \
           and 1<=len(u.ci)<=10and 0<=len(u.telefono)<=13 and 0<=len(u.observacion)<=50 \
           and 1<=len(u.activo)<=10 and 0<=len(u.direccion)<=30): 
         return make_response('t,Se supera caracteres de los campos ')
         
     
     '''controla caracteres validos en el username'''
     
     for r in u.username:
         if not(65<=ord(r)<=90 or 48<=ord(r)<=57 or 97<=ord(r)<=122):
             responde=make_response("t,El username tiene espacios")
             return responde
     print "controla"
     
     '''consulta si es que existe ya usuario con ese nombre'''
     
     sesion=Session()
     if(idU==0):
         usr=sesion.query(Usuario).filter(Usuario.username==u.username).first()
         if(usr is not None):
             sesion.close()
             return make_response('t,Ya existe el usuario')
     else:
         usr=sesion.query(Usuario).filter(Usuario.username==u.username).first()
         if( usr is not None and str(usr.id) != idU ):
             sesion.close()
             return make_response('t,Ya existe el usuario')
         
         PLproyectos=sesion.query(Proyecto).join(Usuario).filter(Usuario.id==idU).filter(Proyecto.estado=="activo").count()
         print "Soy project leader de  " + str(PLproyectos) + " Proyectos activos"
         if  u.activo=="false" and PLproyectos>0:
             sesion.close()
             return make_response('t,El usuario no puede ser inactivado. Es Projec Leader de Proyectos en curso')
         
         comiteProyectos=sesion.query(Proyecto).join(Proyecto.usuariosComite).filter(Usuario.id==idU)            
         countComite=comiteProyectos.count()
         if countComite > 0:
             countComiteActivos=comiteProyectos.filter(Proyecto.estado=="activo").count()
             if countComiteActivos >0:
                 sesion.close()
                 return make_response('t,El usuario no puede ser inactivado. Es Miembro de Comite/s de Proyectos en curso')
             else:
                 sesion.close()
                 return make_response('t,Para ser Inactivado debe dejar de ser miembro de Comite/s de Cambios.')
         
     um=UsuarioManejador()
     sesion.close()
     return um.guardarUsuario(u, idU)
     
Example #26
0
 def post(self):
     
     '''Le paso id del tipo de item que importare y el id de la fase a la cual se importara el tipo'''
     idTipo=flask.request.form['idTipo']
     idFase=flask.request.form['idFase']
     if controlRol(idFase,'tipo','administrar')==0:
         return "t, No posee permiso para realizar esta accion"
     sesion=Session()
     ''' obtengo el tipo de item a importar'''
     importado=sesion.query(TipoItem).filter(TipoItem.idTipoItem==int(idTipo)).first()
     ''' busco si en la fase a importar ya existe un tipo con el mismo nombre, en caso afirmativo, se lanza una excepcion'''
     tipit=sesion.query(TipoItem).filter(TipoItem.fase_id==int(idFase)).filter(TipoItem.nombreTipoItem==importado.nombreTipoItem).first()
     if(tipit is not None):
         sesion.close()
         return make_response('t,Ya existe el tipo de item con ese nombre en esa fase')
     
     ''' se crea el tipo nuevo'''
     nuevoTipo=TipoItem(importado.nombreTipoItem,importado.descripcion,'activo')
     atributos=importado.atributosItem
     nuevoAtributos=[]
     '''extraigo todos los atributos del item importado y los meto en una lista para agregar dicha lista
     de atributos al nuevo Tipo'''
     for atributo in atributos:
         '''Pongo en None el id porque necesito que sea autogenerado'''            
         att=Atributos(None,atributo.nombreAtributo,atributo.tipoPrimarioId,atributo.longitudCadena)
         nuevoAtributos.append(att)
     nuevoTipo.atributosItem=nuevoAtributos
     nuevoTipo.fase_id=idFase
     sesion.add(nuevoTipo)
     sesion.commit()
     sesion.close()
     return make_response("f,Tipo de item importado correctamente")
Example #27
0
 def post(self):
 
     idRol=flask.request.form['idRol']
     idUsuario=flask.request.form['idUsuario']
     
     try:
         idRol=int(idRol)
         idUsuario=int(idUsuario)
     except:
         return "t,Rol o Usuario incorrectos" 
     
     sesion=Session()
     rol=sesion.query(RolProyecto).filter(RolProyecto.id==idRol).first()
     usuario= sesion.query(Usuario).filter(Usuario.id==idUsuario).first()
     
     try:
         usuario.roles_proyecto.remove(rol)
     except:
         sesion.close()
         return "t,El rol seleccionado no se encuentra asignado al Usuario"
     
     sesion.add(usuario)
     sesion.commit()
     
     
     sesion.close()
     
     return "f,Rol extraido" 
 
     
         
Example #28
0
 def guardarItem(self, item, idI, lista, esReversion):
     """
     Metodo utilizado para guardar los datos del item
     @type  item: Item
     @param item: Item controlado a guardar
     @type  idI: String
     @param idI: Id del item a guardar. Si item es nuevo id es 0
     @type lista: Atributos[]
     @param lista:lista de atributos
     @type esReversion:String
     @param esReversion:Indica si es una reversion 
     """
     sesion=Session()
     i=item;
     i.version=1;
     if(idI!=0): #si es que es un item a modificar
         i=sesion.query(Item).filter(Item.idItem==idI).first()
         
         #se crea un nuevo item para el historial 
         histoItem=HistorialItem(i.nombreItem, i.version, i.prioridad, i.costo, i.complejidad, i.fechaInicio, i.fechaFinalizacion, \
                     i.tipoItem_id,i.estado, i.descripcion, \
                     i.fechaCreacion, i.autorVersion_id, i.idItem)
         sesion.add(histoItem);
         
         if (esReversion>0):
             r=sesion.query(Relacion).filter(Relacion.hijo_id==i.idItem).all()
             
             for rela in r: #se agrega la relaciones actuales al historial
                 histoRel=HistorialRelacion(rela.padre_id, rela.hijo_id, rela.versionHijo)
                 #rela.versionHijo=rela.versionHijo+1;
                 sesion.add(histoRel);
                 #sesion.merge(rela);
             #se borra las relaciones existentes en la tabla Relacion
             sesion.query(Relacion).filter(Relacion.hijo_id==i.idItem).delete();
             
             
             q2=sesion.query(HistorialRelacion).filter(HistorialRelacion.hijo_id==i.idItem)\
                                          .filter(HistorialRelacion.versionHijo==esReversion)\
                                          .all()
             for relInsertar in q2:
                 relReversionada=Relacion(relInsertar.padre_id,relInsertar.hijo_id,i.version+1);
                 sesion.add(relReversionada)
             
         else: #es un imte a modificar SOLO SE COPIA LAS RELACIONES ACTUALES AL HISTORIAL
             #SE CAMBIA LA VERSION A VERSION EN LA TABLA RELACION
             r=sesion.query(Relacion).filter(Relacion.hijo_id==i.idItem).all()
             
             for rela in r: #se agrega la relaciones actuales al historial
                 histoRel=HistorialRelacion(rela.padre_id, rela.hijo_id, rela.versionHijo)
                 rela.versionHijo=rela.versionHijo+1;
                 sesion.add(histoRel);
                 sesion.merge(rela);
         #el estado no debe cambiar con "modificar item"        
         item.estado=i.estado        
         i.setValues(item.nombreItem, item.prioridad, item.costo, item.complejidad, item.fechaInicio, item.fechaFinalizacion, \
                     i.tipoItem_id,item.estado, item.descripcion, \
                     item.fechaCreacion, item.autorVersion_id, item.idFase)
         i.version=i.version+1;
         i.tag=item.tag
        
     
     else: #item nuevo
         2+2 #nada se hace se agrega nada mas
         tipoItem=sesion.query(TipoItem).filter(TipoItem.idTipoItem==i.tipoItem_id).first()
         if(tipoItem is not None and tipoItem.estado=='activo'):
             tipoItem.estado='inst'
             sesion.merge(tipoItem)
     
     sesion.add(i);
     si=None
     
     if(idI==0):
         si=sesion.query(Item).filter(Item.nombreItem==item.nombreItem).first();
         if (si is not None):
             for at in lista:
                         iti=InstanciaTipoItem(si.idItem, at["nombreAtributo"], at["tipoPrimario"])
                         sesion.add(iti)
                             
                         #sesion.commit()
                             
                         c=sesion.query(InstanciaTipoItem).filter(InstanciaTipoItem.idItem==si.idItem)\
                                     .filter(InstanciaTipoItem.nombreCampo==at["nombreAtributo"]).first()
                         idc=c.idInstanciaTipoItem;
                         if at["tipoPrimario"]=="Texto":
                            
                             inst_cad=InstanciaCadena(at["valor"])
                             inst_cad.instanciaTipoItem_id=idc;
                             inst_cad.version=si.version;
                             sesion.add(inst_cad)
                             #sesion.commit();
                             
                         elif at["tipoPrimario"]=="Numerico":
                             
                             inst_cad=InstanciaNumerico(at["valor"])
                             inst_cad.instanciaTipoItem_id=idc;
                             inst_cad.version=si.version;
                             sesion.add(inst_cad)
                             #sesion.commit();
                         elif at["tipoPrimario"]=="Entero":
                            
                             inst_cad=InstanciaEntero(at["valor"])
                             inst_cad.instanciaTipoItem_id=idc;
                             inst_cad.version=si.version;
                             sesion.add(inst_cad)
                             #sesion.commit();
                         elif at["tipoPrimario"]=="Fecha":
                             
                             inst_cad=InstanciaFecha(at["valor"])
                             inst_cad.instanciaTipoItem_id=idc;
                             inst_cad.version=si.version;
                             sesion.add(inst_cad)
                             #sesion.commit();
                         
         else:
             sesion.close()
             return make_response('t,no se puDOinsertar el Item')
     else: #item a modificar
         #se obtiene el item a modificar
         si=sesion.query(Item).filter(Item.idItem==idI).first()
         
         if (si is not None):
             for at in lista:
                         c=sesion.query(InstanciaTipoItem).filter(InstanciaTipoItem.idItem==si.idItem)\
                                     .filter(InstanciaTipoItem.nombreCampo==at["nombreAtributo"]).first()
                         idc=c.idInstanciaTipoItem;
                         if at["tipoPrimario"]=="Texto":
                            
                             inst_cad=InstanciaCadena(at["valor"])
                             inst_cad.instanciaTipoItem_id=idc;
                             inst_cad.version=si.version; 
                             sesion.add(inst_cad)
                             #sesion.commit(); 
                             
                         elif at["tipoPrimario"]=="Numerico":
                             
                             inst_cad=InstanciaNumerico(at["valor"])
                             inst_cad.instanciaTipoItem_id=idc;
                             inst_cad.version=si.version;
                             sesion.add(inst_cad)
                             #sesion.commit();
                         elif at["tipoPrimario"]=="Entero":
                            
                             inst_cad=InstanciaEntero(at["valor"])
                             inst_cad.instanciaTipoItem_id=idc;
                             inst_cad.version=si.version;
                             sesion.add(inst_cad)
                             #sesion.commit();
                         elif at["tipoPrimario"]=="Fecha":
                             
                             inst_cad=InstanciaFecha(at["valor"])
                             inst_cad.instanciaTipoItem_id=idc;
                             inst_cad.version=si.version;
                             sesion.add(inst_cad)
                             #sesion.commit();
                         
         else:
             sesion.close()
             return make_response('t,no pudo insertar el Item2')
     
     sesion.commit()
     sesion.close()
     
     return make_response("f,Item guardado correctamente")
 def post(self):
 
     idProyecto=flask.request.form['idProyecto']
     idUsuario=flask.request.form['idUsuario']
     
     sesion=Session()
     
     
     control = sesion.query(Usuario).filter(SolicitudCambio.idProyecto==idProyecto,SolicitudCambio.estado=="pendiente").count()
     if control > 0:
         sesion.close()
         return "t, Se esta realizando el proceso de votacion en una o mas solicitudes, no se puede modificar el comite"
     
     user=sesion.query(Usuario).filter(Usuario.id==idUsuario).first()
    
     if(idProyecto==0):
         sesion.close()
         return "t,Proyecto no existe"
     
     p=sesion.query(Proyecto).filter(Proyecto.idProyecto==int(idProyecto)).first()
     
     if(user not in p.usuariosMiembros):
         sesion.close()
         return "t,Usuario no pertenece al proyecto" 
     
     if(user in p.usuariosComite):
         sesion.close()
         return "t,Usuario ya forma parte del comite"
     
     p.usuariosComite.append(user)
     sesion.add(p)
     sesion.commit()
     #pone idProyecto en cero para que resetee la seleccion de proyectos en modulo de Desarrollo
     flask.session['idProyecto']=0
     
     sesion.close()
     
    
     return "f,Usuario agregado correctamente como miembro del Comite" 
 
     
         
Example #30
0
 def post(self):
 
     idRol=flask.request.form['idRol']
     idUsuario=flask.request.form['idUsuario']
     
     sesion=Session()
     rol=sesion.query(RolProyecto).filter(RolProyecto.id==idRol).first()
     if rol is None:
         sesion.close()
         return "t,Rol no existe"
     if(idUsuario!=0):
         p=sesion.query(Usuario).filter(Usuario.id==int(idUsuario)).first()
         if p is None:
             sesion.close()
             return "t,Usuario no existe"
         if(rol in p.roles_proyecto):
             sesion.close()
             return "t,Rol ya esta asigando al Usuario" 
         else:
             p.roles_proyecto.append(rol)
         sesion.add(p)
         sesion.commit()
     
     sesion.close()
     
    
     return "f,Rol agregado correctamente al Usuario"