def post(self):
"""
Metodo utilizado para recibir los datos de la linea base a cerrar.
@type idLB : string
@param idLb : id de la linea base a ser cerrada
"""
idLB=flask.request.form['idLB']
sesion=Session()
lb=sesion.query(LineaBase).filter(LineaBase.id==int(idLB)).first()
if lb is None:
sesion.close()
return "t, Linea Base no existe"
if controlRol(str(lb.idFase),'lb','finalizar')==0:
sesion.close()
return "t, No posee permiso para realizar esta accion"
if(lb.estado!="abierta"):
sesion.close()
return "t, No se puede cerrar una Linea Base "+lb.estado
if len(lb.items) <= 0:
sesion.close()
return "t,Linea Base no posee items. No puede ser cerrada"
lb.estado="cerrada"
sesion.add(lb)
sesion.commit()
sesion.close()
return "f,Se ha cerrado con exito la Linea Base!"
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):
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 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 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 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 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 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 controlarRolProyecto(self,rol,idRol):
if len(rol.estado) <= 0 or len(rol.estado) > 15:
return make_response("f,Estado del Rol incorrecto")
if len(rol.nombre) <= 0 or len(rol.nombre) > 20:
return make_response("f,Nombre del Rol incorrecto")
if len(rol.descripcion) <= 0 or len(rol.descripcion) > 50:
return make_response("f,Descripcion del Rol incorrecto")
sesion=Session()
if idRol != 0:
rolFase=sesion.query(RolProyecto).filter(RolProyecto.id==int(idRol)).first()
rol.idFase=rolFase.idFase
if rol.idFase == '' or rol.idFase=='0':
sesion.close()
return make_response("t,Fase no valida. No se pudo crear el rol")
rol.idFase=int(rol.idFase)
proyectoId=sesion.query(Fase.idProyecto).filter(Fase.idFase==rol.idFase).first()
controlNombre=sesion.query(RolProyecto).join(Fase).filter(RolProyecto.nombre==rol.nombre).filter(Fase.idProyecto==proyectoId.idProyecto).first()
if idRol==0:
if controlNombre is not None:
sesion.close()
return make_response("t,Nombre del Rol ya existe")
else:
if controlNombre is not None and controlNombre.id != int(idRol):
sesion.close()
return make_response("t,Nombre del Rol ya existe")
rm=RolProyectoManejador()
sesion.close()
return rm.guardarRolProyecto(rol, idRol)
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 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"
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 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 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 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):
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 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 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 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):
idRol=flask.request.form['idRol']
idPermiso=flask.request.form['idPermiso']
try:
idRol=int(idRol)
idPermiso=int(idPermiso)
except:
return "t,No se puede convertir a entero rol o permiso"
sesion=Session()
permiso=sesion.query(Permiso).filter(Permiso.id==idPermiso).first()
rol= sesion.query(RolProyecto).filter(RolProyecto.id==idRol).first()
if rol.estado== "activo":
sesion.close()
return "t,El rol no puede ser modificado. Ya se encuentra activo"
try:
rol.permisos.remove(permiso)
except:
sesion.close()
return "t,El permiso seleccionado no se encuentra en el Rol"
sesion.add(rol)
sesion.commit()
sesion.close()
return "f,Permiso eliminado correctamente del rol"
def post(self):
"""
Metodo utilizado para recibir los datos de un item a ser agregado dentro
de una linea base.
@type idLB: string
@param idLB: id de la linea base a la cual se le agregara el item
@type idItem: string
@param idItem :id del item a agregar
"""
idLB=flask.request.form['idLB']
idItem=flask.request.form['idItem']
sesion=Session()
item=sesion.query(Item).filter(Item.idItem==idItem).first()
idFase=str(item.idFase)
if controlRol(idFase,'lb','administrar')==0:
sesion.close()
return "t, No posee permiso para realizar esta accion"
if(idLB!=0):
lb=sesion.query(LineaBase).filter(LineaBase.id==int(idLB)).first()
if lb.estado != "abierta":
sesion.close()
return "t, no se pueden agregar items a una Linea Base "+ lb.estado
lb.items.append(item)
item.estado="bloqueado"
sesion.add(lb)
sesion.add(item)
sesion.commit()
sesion.close()
return "f,Item agregado a Linea Base"
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 post(self):
idRol=flask.request.form['idRol']
idPermiso=flask.request.form['idPermiso']
sesion=Session()
permiso=sesion.query(Permiso).filter(Permiso.id==idPermiso).first()
if(idRol!=0):
p=sesion.query(RolProyecto).filter(RolProyecto.id==int(idRol)).first()
if p.estado== "activo":
sesion.close()
return "t,El rol no puede ser modificado. Ya se encuentra activo"
if(permiso in p.permisos):
sesion.close()
return "t,Permiso ya existe en el Rol"
else:
p.permisos.append(permiso)
sesion.add(p)
sesion.commit()
sesion.close()
return "f,Permiso agregado correctamente al Rol"
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 post(self):
idProyecto=flask.request.form['idProyecto']
idUsuario=flask.request.form['idUsuario']
try:
idProyecto=int(idProyecto)
idUsuario=int(idUsuario)
except:
return "t,No se puede convertir a entero proyecto o usuario"
sesion=Session()
control=sesion.query(Usuario).filter(Proyecto.idProyecto==idProyecto).join(Proyecto.usuariosComite)\
.filter(Usuario.id==idUsuario).count()
if control > 0:
sesion.close()
return "t, No se puede sacar al usuario porque es Miembro del Comite"
control = sesion.query(Usuario).filter(SolicitudCambio.idProyecto==idProyecto,SolicitudCambio.idSolicitante==idUsuario\
,SolicitudCambio.estado=="pendiente").count()
if control > 0:
sesion.close()
return "t, No se puede sacar al usuario porque tiene una Solicitud pendiente de aprobacion"
user=sesion.query(Usuario).filter(Usuario.id==int(idUsuario)).first()
proyecto= sesion.query(Proyecto).filter(Proyecto.idProyecto==int(idProyecto)).first()
try:
proyecto.usuariosMiembros.remove(user)
except:
sesion.close()
return "t,No se puede extraer del proyecto a un usuario que no es miembro"
sesion.add(proyecto)
sesion.commit()
sesion.close()
return "f,Usuario eliminado correctamente del proyecto"
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 post(self):
idProyecto=flask.request.form['idProyecto']
idUsuario=flask.request.form['idUsuario']
try:
idProyecto=int(idProyecto)
idUsuario=int(idUsuario)
except:
return "t,No se puede convertir a entero proyecto o usuario"
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==int(idUsuario)).first()
proyecto= sesion.query(Proyecto).filter(Proyecto.idProyecto==int(idProyecto)).first()
try:
proyecto.usuariosComite.remove(user)
except:
sesion.close()
return "t,No se puede extraer del Comite a un usuario que no es miembro"
sesion.add(proyecto)
sesion.commit()
flask.session['idProyecto']=0
sesion.close()
return "f,Usuario eliminado correctamente del proyecto"
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 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!')
