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 jasonizar(self, fl):
"""
Modulo que jasoniza la respuesta.
@type fl: Fase[]
@param fl: Resultado de una consulta que trae los datos de las fases a inicluir en el listado
de fases que se devolvera al cliente.
"""
cad=''
pre="["
print('fl is '+ str(fl))
if(fl is not None):
for f in fl:
strFase=str(f.idFase)
if controlRol(strFase,'fase','consulta')==1:
if f.estado=="activa":
print('f inside loop is ' + str(f.idFase))
cad=cad+ json.dumps({"idFase":f.idFase , "nombreFase":f.tag+" "+f.nombreFase}, separators=(',',':'));
cad=cad + ","
cad=cad[0:len(cad)-1]
else:
cad=cad+ json.dumps({"idFase":0 , "nombreFase":'ninguna'}, separators=(',',':'));
cad=pre + cad+"]"
return cad
def post(self):
"""
Metodo utilizado para recibir los datos con los que se creara una Linea Base nueva dentro
de algun proyecto. Invocado cuando se hace una peticion de creacion de
linea base al servidor.
@type descripcion : sting
@param descripcion: descripcion de la linea base a agregar
@type idFase : string
@param idFase : id de la fase a la que corresponde la Linea base a agregar
"""
descripcion=flask.request.form['descripcion']
idFase=flask.request.form['idFase']
estado="abierta"
lb=LineaBase(descripcion,estado)
lb.idFase=idFase
lb.descripcion=lb.descripcion.strip()
lb.idFase=lb.idFase.strip()
if controlRol(str(idFase),'lb','administrar')==0:
return "t, No posee permiso para realizar esta accion"
lbc=LBControllerClass()
return lbc.controlarLB(lb, 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")
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 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):
"""
Metodo utilizado para recibir los datos con los que se creara un nuevo item dentro
de algun proyecto y fase determinada.
@type atributos: JSON_ATRIBUTOS
@param atributos: atributos dinamicos dependientes del tipo de item
@type nombreItem: string
@param nombreItem: nombre del item
@type fechaInicio: date
@param fechaInicio: fecha de inicio
@type fechaFinal: date
@param fechaFinal: fecha de finalizacion
@type descripcion: String
@param descripcion: una descripcion del item
@type prioridad: int
@param prioridad: prioridad a darle al item
@type complejidad: int
@param complejidad: complejidad del item entre [0.20]
@type idFase: String
@param idFase: el id de la fase al cual la fase pertenecera
@type estado: String
@param estado: define el estado del item activo, inactivo, bloqueado, desarrollo, pendiente
"""
atributos=json.loads(flask.request.form['atributos'])
nombreItem=flask.request.form['nombreItem']
prioridad=flask.request.form['prioridad']
fechaInicio=None
fechaFinalizacion=None
tipoItemId=flask.request.form['tipoItemId']
complejidad=flask.request.form['complejidad']
costo=flask.request.form['costo']
estado=flask.request.form['estado']
descripcion=flask.request.form['descripcion']
fechaCreacion= datetime.date.today()
print(fechaCreacion)
#este autorVersion se extrae del idUsuario de la sesion
autorVersion_id=flask.session['idUsuario']
idFase=flask.request.form['idFase']
#ver fechaCreacion TIMESTAMP
if controlRol(str(idFase),'item','administrar')==0:
return "t, No tiene permisos para realizar esta accion"
i=Item(nombreItem, prioridad, costo, complejidad, fechaInicio, \
fechaFinalizacion, tipoItemId, estado, descripcion,\
fechaCreacion, autorVersion_id, idFase)
ic=ItemControllerClass()
return ic.controlarItem(i, 0, atributos, 0)
def post(self):
idTipoItem=flask.request.form['idTipoItem']
nombreTI=flask.request.form['nombreTipoItem']
estado=flask.request.form['estado']
descripcion=flask.request.form['descripcion']
atributos=json.loads(flask.request.form['atributos'])
idProyecto=flask.request.form['idProyecto']
idFase=flask.request.form['idFase']
if controlRol(idFase,'tipo','administrar')==0:
return "t, No posee permiso para realizar esta accion"
ti=TipoItem(nombreTI,descripcion, estado)
tic=TipoItemControllerClass();
return tic.controlarTI(ti, idTipoItem, atributos, idProyecto, idFase)
def post(self):
nombreTI=flask.request.form['nombreTipoItem']
estado=flask.request.form['estado']
descripcion=flask.request.form['descripcion']
atributos=json.loads(flask.request.form['atributos'])
idProyecto=flask.request.form['idProyecto']
idFase=flask.request.form['idFase']
if controlRol(idFase,'tipo','administrar')==0:
return "t, No posee permiso para realizar esta accion"
# [{"idAtributos":"1","nombreAtributo":"sada","tipoPrimario":"Texto","longitudCadena":"12"},
# {"idAtributos":"2","nombreAtributo":"wad","tipoPrimario":"Texto","longitudCadena":"2"}]
ti=TipoItem(nombreTI,descripcion, estado)
tic=TipoItemControllerClass();
return tic.controlarTI(ti, 0, atributos, idProyecto, idFase)
def jasonizar(self, listaItems):
"""
modulo que jasoniza la respuesta
"""
p=''
pre="{\"totalpages\": \""+str(self.totalPages) + "\",\"currpage\" : \"" + str(self.currPage) + "\",\"totalrecords\" : \""
pre= pre + str(self.totalRecords) + " \",\"invdata\" : ["
idUsuario=flask.session['idUsuario']
controlarPermiso=1
for f in listaItems:
if controlarPermiso==1:
proyecto=sesion.query(Proyecto).join(Fase).filter(Fase.idFase==f.idFase).first()
if proyecto.projectLeaderId==idUsuario:
#si es proyect leader no se controla que tenga permisos
controlarPermiso=0
#si no se tiene permiso de consultar items, no se devuelve nada en el listar
if controlarPermiso==1 and controlRol(str(f.idFase),'item','consulta')==0:
break
#Si el usuario logueado es el que pidio la SC sobre este item, entonces puede pasar de pendiente a activo
if f.estado=="sc_activo" or f.estado=="sc_pendiente":
sc=sesion.query(SolicitudCambio).order_by("solicitud_cambio.id desc").join(SolicitudCambio.items)\
.filter(Item.idItem==f.idItem).first()
if(sc.idSolicitante==flask.session['idUsuario']):
if f.estado=="sc_activo":
f.estado="activo"
elif f.estado=="sc_pendiente":
f.estado="pendiente"
name=sesion.query(Usuario.username).filter(Usuario.id==f.autorVersion_id).first()
ti_id=f.tipoItem_id;
if f.tipoItem_id==None:
ti_id=-1;
p=p+json.dumps({"idItem":f.idItem , "nombreItem":f.nombreItem, "version": f.version, "prioridad":f.prioridad,
"fechaInicio": str(f.fechaInicio), "fechaFinalizacion": str(f.fechaFinalizacion), "tipoItem_id": ti_id,
"costo": f.costo, "complejidad": f.complejidad, "estado": f.estado, "autorVersion_id":f.autorVersion_id,
"nombreAutorVersion": name.username, "descripcion":f.descripcion, "idFase":f.idFase}, separators=(',',':'))+",";
p=p[0:len(p)-1]
p=p+"]}"
p=pre+p
return p
def post(self):
idTI=flask.request.form['idTI']
q=sesion.query(TipoItem).filter(TipoItem.idTipoItem==int(idTI)).first()
if(q is not None):
if controlRol(str(q.fase_id),'tipo','administrar')==0:
return "t, No posee permiso para realizar esta accion"
q.estado='inactivo'
sesion.merge(q)
sesion.commit()
sesion.close()
else:
sesion.close()
return make_response("t, No existe el tipo de item ")
return make_response("f, Tipo de Item inactivado correctamente ")
def jasonizar(self, listaTipoItem):
"""
modulo que jasoniza la respuesta
"""
p=''
pre="{\"totalpages\": \""+str(self.totalPages) + "\",\"currpage\" : \"" + str(self.currPage) + "\",\"totalrecords\" : \""
pre= pre + str(self.totalRecords) + " \",\"invdata\" : ["
for tipoItem in listaTipoItem:
if controlRol(str(tipoItem.fase_id),'tipo','consulta')==0:
break
p=p+"{\"idTipoItem\": \""+str(tipoItem.idTipoItem)+"\",\"nombreTipoItem\": \""+ \
tipoItem.nombreTipoItem+ \
"\",\"estado\": \""+str(tipoItem.estado)+"\", \"descripcion\": \""+ \
tipoItem.descripcion + "\"},"
p=p[0:len(p)-1]
p=p+"]}"
p=pre+p
return p
def jasonizar(self, listaItemAprobar):
"""
modulo que jasoniza la respuesta
"""
p=''
pre="{\"totalpages\": \""+str(self.totalPages) + "\",\"currpage\" : \"" + str(self.currPage) + "\",\"totalrecords\" : \""
pre= pre + str(self.totalRecords) + " \",\"invdata\" : ["
for item in listaItemAprobar:
if controlRol(str(item.idFase),'item','administrar')==1:
p=p+"{\"idItem\": \""+str(item.idItem)+ \
"\",\"idFase\": \""+ item.tag+ \
"\", \"estado\":\"" + item.estado + \
"\", \"nombreItem\":\"" + item.nombreItem + \
"\", \"incluir\":\"" + "no" +"\"},"
p=p[0:len(p)-1]
p=p+"]}"
p=pre+p
return p
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 jasonizar(self, listaLB):
"""
Modulo que jasoniza la respuesta.
@type listaLB: LineaBase[]
@param listaLB: Resultado de una consulta que trae los datos de las Lineas bases a inicluir en el listado
de lineas bases que se devolvera al cliente.
"""
p=''
pre="{\"totalpages\": \""+str(self.totalPages) + "\",\"currpage\" : \"" + str(self.currPage) + "\",\"totalrecords\" : \""
pre= pre + str(self.totalRecords) + " \",\"invdata\" : ["
for lb in listaLB:
if controlRol(str(lb.idFase),'lb','consulta')==0:
break
p=p+"{\"idLB\":\""+str(lb.id)+"\",\"descripcion\": \""+lb.descripcion +"\",\"estado\": \""+lb.estado+"\"},"
# {"nombre":"nombre","idRol":"rol","descripcion":"descripciones"},
p=p[0:len(p)-1]
p=p+"]}"
p=pre+p
return p
def post(self):
"""
Metodo utilizado para recibir los datos para eliminar una relacion dentro de la BD.
@type idRelacion: string
@param idRelacion: id del la relacion en BD
@type version_hijo: string
@param version_hijo: version del hijo a quien pertence la relacion
"""
# idFase=flask.request.form['id_Fase']
idRelacion = flask.request.form["idRelacion"]
version_hijo = flask.request.form["version_hijo"]
q = sesion.query(Relacion).filter(Relacion.idRelacion == idRelacion).first()
if q is None:
sesion.close()
return make_response("t,No existe relacion con ese id")
i = sesion.query(Item).filter(Item.idItem == q.hijo_id).first()
idFase = str(i.idFase)
if controlRol(idFase, "item", "administrar") == 0:
sesion.close()
return "t, No posee permiso para realizar esta accion"
if (
i.version == int(version_hijo) - 1
): # hay que crear una nueva version del item porque es el primero en eliminar de la version
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)
i.setValues(
i.nombreItem,
i.prioridad,
i.costo,
i.complejidad,
i.fechaInicio,
i.fechaFinalizacion,
i.tipoItem_id,
i.estado,
i.descripcion,
i.fechaCreacion,
i.autorVersion_id,
i.idFase,
)
i.version = i.version + 1
sesion.add(i)
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)
insti = sesion.query(InstanciaTipoItem).filter(InstanciaTipoItem.idItem == i.idItem).all()
for instancia in insti:
ie = (
sesion.query(InstanciaEntero)
.filter(InstanciaEntero.instanciaTipoItem_id == instancia.idInstanciaTipoItem)
.all()
)
for ies in ie:
laIE = InstanciaEntero(ies.entero)
laIE.version = ies.version + 1
laIE.instanciaTipoItem_id = ies.instanciaTipoItem_id
sesion.add(laIE)
iDate = (
sesion.query(InstanciaFecha)
.filter(InstanciaFecha.instanciaTipoItem_id == instancia.idInstanciaTipoItem)
.all()
)
for dateInst in iDate:
laF = InstanciaFecha(dateInst.fecha)
laF.version = dateInst.version + 1
laF.instanciaTipoItem_id = dateInst.instanciaTipoItem_id
sesion.add(laF)
iNum = (
sesion.query(InstanciaNumerico)
.filter(InstanciaNumerico.instanciaTipoItem_id == instancia.idInstanciaTipoItem)
.all()
)
for numInst in iNum:
laN = InstanciaNumerico(numInst.numerico)
laN.version = numInst.version + 1
laN.instanciaTipoItem_id = numInst.instanciaTipoItem_id
sesion.add(laN)
iCad = (
sesion.query(InstanciaCadena)
.filter(InstanciaCadena.instanciaTipoItem_id == instancia.idInstanciaTipoItem)
.all()
)
for cadInst in iCad:
caN = InstanciaCadena(cadInst.cadena)
caN.version = cadInst.version + 1
caN.instanciaTipoItem_id = cadInst.instanciaTipoItem_id
sesion.add(caN)
# se realiza el control
elif i.version == int(
version_hijo
): # esta en la misma sesion debe agregar nada mas sin crear nuevo item en el historial
# nada, se agrega nada mas
2 + 2
else:
return make_response("t,Nro de version invalido enviado para eliminar")
sesion.query(Relacion).filter(Relacion.idRelacion == idRelacion).delete()
sesion.commit()
sesion.close()
return make_response("f,Items eliminado correctamente")
def post(self):
"""
Metodo utilizado cuando se realiza una peticion de creacion de \
relacion al servidor.
@type idPadre: String
@param idPadre: id del item padre a relacionar
@type idHijo: String
@param idHijo: id del item hijo a relacionar
@type version: String
@param version: version del hijo a relacionar
"""
idFase = flask.request.form["id_Fase"]
padre_id = flask.request.form["padre_id"]
hijo_id = flask.request.form["hijo_id"]
version_hijo = flask.request.form["versionHijo"]
if controlRol(str(idFase), "item", "administrar") == 0:
return "t, No posee permisos para realizar esta accion"
# se realiza el control
if padre_id == hijo_id:
sesion.close()
return make_response("t,No se puede relacionar el item con el mismo item")
q = sesion.query(Relacion).filter(Relacion.padre_id == padre_id).filter(Relacion.hijo_id == hijo_id).first()
if q is not None:
sesion.close()
return make_response("t,Ya existe esa relacion")
q = sesion.query(Relacion).filter(Relacion.padre_id == hijo_id).filter(Relacion.hijo_id == padre_id).first()
if q is not None:
sesion.close()
return make_response("t,Ya existe la relacion inversa, genera una relacion circular")
qp = sesion.query(Item).filter(Item.idItem == padre_id).first()
qs = sesion.query(Item).filter(Item.idItem == hijo_id).first()
if qp is not None and qs is not None:
if qp.idFase > qs.idFase:
sesion.close()
return make_response("t,No puede relacionar un item de una Fase posterior con una fase Anterior")
if qs.estado != "activo":
sesion.close()
return make_response("t,Solamente puede relacionarse items con estado activo")
q = sesion.query(Item).filter(Item.idFase == int(idFase)).filter(Item.estado == "activo").all()
nLista = dict()
# aca se crea el grafo
p = None
h = None
for i in q:
aux = Nodo(i.idItem, i.nombreItem, i.idFase)
if int(padre_id) == aux.idItem:
p = aux
elif int(hijo_id) == aux.idItem:
h = aux
nLista[str(aux.idItem)] = aux # se utiliza un mapper
# para cada nodo en estado activo y sea de la fase
for i in nLista:
# se obtiene los nodos padres
q = sesion.query(Relacion).filter(Relacion.hijo_id == nLista[i].idItem).all()
# se crea la relacion con sus padres
for s in q:
if str(s.padre_id) in nLista:
nodo_rel = nLista[str(s.padre_id)]
nLista[i].agregarRelacion(nodo_rel)
tienec = 0
if h is not None:
h.agregarRelacion(p)
print("el ciclo es")
tienec = h.probarSiTieneCiclo(h)
if tienec == 1:
cad = ""
for a in Nodo.cicloImprimir:
cad = cad + "->" + Nodo.cicloImprimir[a]
cicloImprimir = dict()
cad = cad[2 : len(cad)]
sesion.close()
return make_response("t,La relacion que desea agregar genera el siguiente ciclo: " + cad)
# se ve el tema de la version con la relacion
i = sesion.query(Item).filter(Item.idItem == hijo_id).first()
if (
i.version == int(version_hijo) - 1
): # hay que crear una nueva version del item porque es el primero a agregar en la version
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)
i.setValues(
i.nombreItem,
i.prioridad,
i.costo,
i.complejidad,
i.fechaInicio,
i.fechaFinalizacion,
i.tipoItem_id,
i.estado,
i.descripcion,
i.fechaCreacion,
i.autorVersion_id,
i.idFase,
)
i.version = i.version + 1
sesion.add(i)
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)
insti = sesion.query(InstanciaTipoItem).filter(InstanciaTipoItem.idItem == i.idItem).all()
for instancia in insti:
ie = (
sesion.query(InstanciaEntero)
.filter(InstanciaEntero.instanciaTipoItem_id == instancia.idInstanciaTipoItem)
.all()
)
for ies in ie:
laIE = InstanciaEntero(ies.entero)
laIE.version = ies.version + 1
laIE.instanciaTipoItem_id = ies.instanciaTipoItem_id
sesion.add(laIE)
iDate = (
sesion.query(InstanciaFecha)
.filter(InstanciaFecha.instanciaTipoItem_id == instancia.idInstanciaTipoItem)
.all()
)
for dateInst in iDate:
laF = InstanciaFecha(dateInst.fecha)
laF.version = dateInst.version + 1
laF.instanciaTipoItem_id = dateInst.instanciaTipoItem_id
sesion.add(laF)
iNum = (
sesion.query(InstanciaNumerico)
.filter(InstanciaNumerico.instanciaTipoItem_id == instancia.idInstanciaTipoItem)
.all()
)
for numInst in iNum:
laN = InstanciaNumerico(numInst.numerico)
laN.version = numInst.version + 1
laN.instanciaTipoItem_id = numInst.instanciaTipoItem_id
sesion.add(laN)
iCad = (
sesion.query(InstanciaCadena)
.filter(InstanciaCadena.instanciaTipoItem_id == instancia.idInstanciaTipoItem)
.all()
)
for cadInst in iCad:
caN = InstanciaCadena(cadInst.cadena)
caN.version = cadInst.version + 1
caN.instanciaTipoItem_id = cadInst.instanciaTipoItem_id
sesion.add(caN)
elif i.version == int(
version_hijo
): # esta en la misma sesion debe agregar nada mas sin crear nuevo item en el historial
# nada, se agrega nada mas
2 + 2
else:
return make_response("t,Nro de version invalido enviado")
rel = Relacion(padre_id, hijo_id, version_hijo)
sesion.add(rel)
sesion.commit()
sesion.close()
return make_response("f,Items relacionados correctamente")
def post(self):
"""
Metodo utilizado para recibir los datos para eliminar, revivir o aprobar item en la base de datos.
@type idItem: string
@param idItem: id del item en BD
@type idFase: string
@param idFase: id de la fase del item
@type accion: string
@param accion: Permite definir si es un eliminar, revivir o aprobacion
"""
idItem=flask.request.form['idItem']
idFase=flask.request.form['idFase']
accion=flask.request.form['accion']
q=sesion.query(Item).filter(Item.idItem==idItem).first();
msg=""
if(accion=="eliminar"):
if controlRol(idFase,'item','administrar')==0:
sesion.close()
return "t, No posee permiso para realizar esta accion"
if(q.estado not in ['sc_activo','activo']):
sesion.close()
return make_response('t,El item en estado '+q.estado+' no puede ser eliminado')
else:
#Puede que hayan hijos aprobados/bloqueados/revision. Si es asi, no podra eliminarse.
cantHijos=sesion.query(Relacion).filter(Relacion.padre_id==q.idItem).count()
if cantHijos>0:
sesion.close()
return make_response('t, Elimine a los hijos que dependen de este item primeramente.')
q.estado='inactivo'
sesion.merge(q)
sesion.query(Relacion).filter(or_(Relacion.padre_id==q.idItem, Relacion.hijo_id==q.idItem)).delete();
sesion.commit()
sesion.close()
msg='f,El item se ha eliminado correctamente'
elif(accion=="revivir"):
if controlRol(idFase,'item','administrar')==0:
sesion.close()
return "t, No posee permiso para realizar esta accion"
q.estado='activo'
sesion.merge(q)
sesion.commit()
sesion.close()
msg='f,Se ha revivido correctamente al item'
elif(accion=="aprobar"):
if controlRol(idFase,'item','finalizar')==0:
sesion.close()
return "t, No posee permiso para realizar esta accion"
bandera=0;
listaPadres='';
contador=sesion.query(Relacion).filter(Relacion.hijo_id==q.idItem).count()
f=sesion.query(Fase).filter(Fase.idFase==q.idFase).first()
if(f.tag!="F1" and contador==0): #si no esta en la primera fase y contador==0
return make_response('t,No puede aprobarse un item que no tenga por lo menos algun padre')
consulta=sesion.query(Item).join(Relacion,Relacion.padre_id==Item.idItem).filter(Item.estado!='inactivo').filter(Relacion.hijo_id==q.idItem).all()
for p in consulta:
if(p.estado=='activo' or p.estado=='pendiente' or p.estado=="revision" or p.estado =="sc_activo" or p.estado =="sc_pendiente"):
bandera=bandera+1;
listaPadres=listaPadres+p.tag+", "
listaPadres=listaPadres[0:len(listaPadres)-2]
if (bandera==1):
sesion.close()
return make_response('t,El padre del item seleccionado": '+ listaPadres+ ' se encuentra en estado '+ p.estado\
+ ' y no puede aprobarse. Es condicion necesaria que todos los padres de un item esten por lo menos en estado "aprobado" para poder aprobarse. ')
elif(bandera>=2):
sesion.close()
return make_response('t,Los padres del item seleccionado: '+ listaPadres+ ' no se encuentran en estado de por lo menos aprobado'\
+ ' y no puede aprobarse. Es condicion necesaria que todos los padres de un item esten aprobados para poder aprobarse previamente. ')
if q.estado == "pendiente" or q.estado=="sc_pendiente" or q.estado=="revision":
q.estado='aprobado'
else:
return "t,El item con estado: "+q.estado+ " no puede aprobarse"
sesion.merge(q)
sesion.commit()
sesion.close()
msg='f,Se ha aprobado correctamente al item'
elif(accion=="pendiente"):
if(q.estado=="activo" or q.estado =="sc_activo"):
if controlRol(idFase,'item','administrar')==0:
sesion.close()
return "t, No posee permiso para realizar esta accion"
contador=sesion.query(Relacion).filter(Relacion.hijo_id==q.idItem).count()
f=sesion.query(Fase).filter(Fase.idFase==q.idFase).first()
if(f.tag!="F1" and contador==0): #si no esta en la primera fase y contador==0
return make_response('t,No puede pasar a pendiente un item que no tenga por lo menos algun padre')
if q.estado=="sc_activo":
q.estado='sc_pendiente'
elif q.estado=="activo" :
q.estado='pendiente'
sesion.merge(q)
sesion.commit()
sesion.close()
msg='f,Se ha cambiado correctamente el estado del item de "activo" a "pendiente"'
elif(q.estado=="pendiente" or q.estado=="sc_pendiente" ):
if controlRol(idFase,'item','administrar')==0:
sesion.close()
return "t, No posee permiso para realizar esta accion"
if q.estado=="sc_pendiente":
q.estado='sc_activo'
elif q.estado=="pendiente" :
q.estado='activo'
sesion.merge(q)
sesion.commit()
sesion.close()
msg='f,Se ha cambiado correctamente el estado del item de "pendiente" a "activo"'
else:
sesion.close()
return make_response('t,accion invalida ')
return make_response(msg)
def post(self):
"""
Metodo utilizado para recibir los datos de la fase que sera finalizada
dentro del proyecto.
@type idFase : String
@param idFase : Id de la fase a la cual se le cambiara el estado por finalizado
"""
idFase=flask.request.form['idFase']
if controlRol(idFase,'fase','finalizar')==0:
return "t, No posee permiso para esta accion"
idFase=idFase.strip()
if idFase=="0" or idFase=='':
return "t, Fase no valida"
sesion=Session()
fase= sesion.query(Fase).filter(Fase.idFase==int(idFase)).first()
#Controles
if fase is None:
sesion.close()
return "t,La fase no existe"
if fase.estado != "activa":
sesion.close()
return "t,No se puede finalizar una fase que no este activa"
#Controla items en la fase
itemsFase= sesion.query(Item).join(Fase).filter(Fase.idFase==int(idFase),Item.estado!="inactivo")
numberItems=itemsFase.count()
if numberItems <= 0:
sesion.close()
return "t,La fase no posee items!"
for item in itemsFase:
if item.estado!="bloqueado":
sesion.close()
return "t,Todos los ITEMS deben estar BLQUEADOS"
#Controla LBs en la fase
bases= sesion.query(LineaBase).join(Fase).filter(Fase.idFase==int(idFase),LineaBase.estado=="cerrada").count()
if bases <= 0:
sesion.close()
return "t,Todas las Lineas Bases deben estar Cerradas"
#Controla que todas las fases anteriores esten finalizadas
idProyecto= fase.idProyecto
fases=sesion.query(Fase).join(Proyecto).filter(Proyecto.idProyecto==idProyecto).all()
for f in fases:
if f.idFase < fase.idFase:
if f.estado!="finalizada":
sesion.close()
return "t,Fases anteriores deben ser finalizadas primeramente!"
for f in fases:
if f.idFase > fase.idFase:
f.estado="activa"
f.fechaFinalizacion=None
sesion.add(f)
fase.estado="finalizada"
now=datetime.date.today()
fase.fechaFinalizacion=now
#Pone como fecha de inicio de fase sgte la fecha de finalizacion de la actual
tagFaseSgte="F"+str(int(fase.tag[1:])+1)
faseSgte=sesion.query(Fase).join(Proyecto).filter(Proyecto.idProyecto==idProyecto)\
.filter(Fase.tag==tagFaseSgte).first()
if faseSgte != None:
faseSgte.fechaInicio=fase.fechaFinalizacion
sesion.add(faseSgte)
sesion.add(fase)
sesion.commit()
sesion.close()
return "f,La fase ha sido finalizada!"