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)
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)
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)
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
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")
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
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")
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)
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'])
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!")
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'''
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")
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!')
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)
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."
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!"
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")
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
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."
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)
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")
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"
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"
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"