예제 #1
0
 def guardarItem(self, item, idI, lista, esReversion):
     """
     Metodo utilizado para guardar los datos del item
     @type  item: Item
     @param item: Item controlado a guardar
     @type  idI: String
     @param idI: Id del item a guardar. Si item es nuevo id es 0
     @type lista: Atributos[]
     @param lista:lista de atributos
     @type esReversion:String
     @param esReversion:Indica si es una reversion 
     """
     sesion=Session()
     i=item;
     i.version=1;
     if(idI!=0): #si es que es un item a modificar
         i=sesion.query(Item).filter(Item.idItem==idI).first()
         
         #se crea un nuevo item para el historial 
         histoItem=HistorialItem(i.nombreItem, i.version, i.prioridad, i.costo, i.complejidad, i.fechaInicio, i.fechaFinalizacion, \
                     i.tipoItem_id,i.estado, i.descripcion, \
                     i.fechaCreacion, i.autorVersion_id, i.idItem)
         sesion.add(histoItem);
         
         if (esReversion>0):
             r=sesion.query(Relacion).filter(Relacion.hijo_id==i.idItem).all()
             
             for rela in r: #se agrega la relaciones actuales al historial
                 histoRel=HistorialRelacion(rela.padre_id, rela.hijo_id, rela.versionHijo)
                 #rela.versionHijo=rela.versionHijo+1;
                 sesion.add(histoRel);
                 #sesion.merge(rela);
             #se borra las relaciones existentes en la tabla Relacion
             sesion.query(Relacion).filter(Relacion.hijo_id==i.idItem).delete();
             
             
             q2=sesion.query(HistorialRelacion).filter(HistorialRelacion.hijo_id==i.idItem)\
                                          .filter(HistorialRelacion.versionHijo==esReversion)\
                                          .all()
             for relInsertar in q2:
                 relReversionada=Relacion(relInsertar.padre_id,relInsertar.hijo_id,i.version+1);
                 sesion.add(relReversionada)
             
         else: #es un imte a modificar SOLO SE COPIA LAS RELACIONES ACTUALES AL HISTORIAL
             #SE CAMBIA LA VERSION A VERSION EN LA TABLA RELACION
             r=sesion.query(Relacion).filter(Relacion.hijo_id==i.idItem).all()
             
             for rela in r: #se agrega la relaciones actuales al historial
                 histoRel=HistorialRelacion(rela.padre_id, rela.hijo_id, rela.versionHijo)
                 rela.versionHijo=rela.versionHijo+1;
                 sesion.add(histoRel);
                 sesion.merge(rela);
         #el estado no debe cambiar con "modificar item"        
         item.estado=i.estado        
         i.setValues(item.nombreItem, item.prioridad, item.costo, item.complejidad, item.fechaInicio, item.fechaFinalizacion, \
                     i.tipoItem_id,item.estado, item.descripcion, \
                     item.fechaCreacion, item.autorVersion_id, item.idFase)
         i.version=i.version+1;
         i.tag=item.tag
        
     
     else: #item nuevo
         2+2 #nada se hace se agrega nada mas
         tipoItem=sesion.query(TipoItem).filter(TipoItem.idTipoItem==i.tipoItem_id).first()
         if(tipoItem is not None and tipoItem.estado=='activo'):
             tipoItem.estado='inst'
             sesion.merge(tipoItem)
     
     sesion.add(i);
     si=None
     
     if(idI==0):
         si=sesion.query(Item).filter(Item.nombreItem==item.nombreItem).first();
         if (si is not None):
             for at in lista:
                         iti=InstanciaTipoItem(si.idItem, at["nombreAtributo"], at["tipoPrimario"])
                         sesion.add(iti)
                             
                         #sesion.commit()
                             
                         c=sesion.query(InstanciaTipoItem).filter(InstanciaTipoItem.idItem==si.idItem)\
                                     .filter(InstanciaTipoItem.nombreCampo==at["nombreAtributo"]).first()
                         idc=c.idInstanciaTipoItem;
                         if at["tipoPrimario"]=="Texto":
                            
                             inst_cad=InstanciaCadena(at["valor"])
                             inst_cad.instanciaTipoItem_id=idc;
                             inst_cad.version=si.version;
                             sesion.add(inst_cad)
                             #sesion.commit();
                             
                         elif at["tipoPrimario"]=="Numerico":
                             
                             inst_cad=InstanciaNumerico(at["valor"])
                             inst_cad.instanciaTipoItem_id=idc;
                             inst_cad.version=si.version;
                             sesion.add(inst_cad)
                             #sesion.commit();
                         elif at["tipoPrimario"]=="Entero":
                            
                             inst_cad=InstanciaEntero(at["valor"])
                             inst_cad.instanciaTipoItem_id=idc;
                             inst_cad.version=si.version;
                             sesion.add(inst_cad)
                             #sesion.commit();
                         elif at["tipoPrimario"]=="Fecha":
                             
                             inst_cad=InstanciaFecha(at["valor"])
                             inst_cad.instanciaTipoItem_id=idc;
                             inst_cad.version=si.version;
                             sesion.add(inst_cad)
                             #sesion.commit();
                         
         else:
             sesion.close()
             return make_response('t,no se puDOinsertar el Item')
     else: #item a modificar
         #se obtiene el item a modificar
         si=sesion.query(Item).filter(Item.idItem==idI).first()
         
         if (si is not None):
             for at in lista:
                         c=sesion.query(InstanciaTipoItem).filter(InstanciaTipoItem.idItem==si.idItem)\
                                     .filter(InstanciaTipoItem.nombreCampo==at["nombreAtributo"]).first()
                         idc=c.idInstanciaTipoItem;
                         if at["tipoPrimario"]=="Texto":
                            
                             inst_cad=InstanciaCadena(at["valor"])
                             inst_cad.instanciaTipoItem_id=idc;
                             inst_cad.version=si.version; 
                             sesion.add(inst_cad)
                             #sesion.commit(); 
                             
                         elif at["tipoPrimario"]=="Numerico":
                             
                             inst_cad=InstanciaNumerico(at["valor"])
                             inst_cad.instanciaTipoItem_id=idc;
                             inst_cad.version=si.version;
                             sesion.add(inst_cad)
                             #sesion.commit();
                         elif at["tipoPrimario"]=="Entero":
                            
                             inst_cad=InstanciaEntero(at["valor"])
                             inst_cad.instanciaTipoItem_id=idc;
                             inst_cad.version=si.version;
                             sesion.add(inst_cad)
                             #sesion.commit();
                         elif at["tipoPrimario"]=="Fecha":
                             
                             inst_cad=InstanciaFecha(at["valor"])
                             inst_cad.instanciaTipoItem_id=idc;
                             inst_cad.version=si.version;
                             sesion.add(inst_cad)
                             #sesion.commit();
                         
         else:
             sesion.close()
             return make_response('t,no pudo insertar el Item2')
     
     sesion.commit()
     sesion.close()
     
     return make_response("f,Item guardado correctamente")
예제 #2
0
    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")
예제 #3
0
    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")