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