Esempio n. 1
0
    def post(self, *args, **kw):
        """Se crea un nuevo item"""
        itemeditado = DBSession.query(Item).filter_by(id=kw['idItem1']).first()
        itemnuevo = Item()
        itemnuevo.version = itemeditado.version + 1
        itemnuevo.idTipoDeItem = itemeditado.idTipoDeItem
        itemnuevo.idFase = itemeditado.idFase
        itemnuevo.idLineaBase = itemeditado.idLineaBase
        itemnuevo.fechaCreacion = itemeditado.fechaCreacion
        itemnuevo.nrohistorial = itemeditado.nrohistorial
        itemnuevo.ultimaversion = 1
        itemeditado.ultimaversion = 0
        itemnuevo.estado = 'modificado'
        itemnuevo.complejidad = itemeditado.complejidad
        itemnuevo.nombre = itemeditado.nombre
        DBSession.add(itemnuevo)
        DBSession.flush()
        """-------------------------"""
        """ Crea las nuevas relaciones"""

        kw['idItem1'] = itemnuevo.id
        """ Se crea las relaciones"""
        ids = kw['idItem2']
        longitud = len(kw['idItem2'])
        for indice in range(longitud):
            kw['idItem2'] = ids[indice]
            self.provider.create(self.model, params=kw)

        ids = kw['idItem2Anterior']
        longitud = len(kw['idItem2Anterior'])
        for indice in range(longitud):
            kw['idItem2'] = ids[indice]
            self.provider.create(self.model, params=kw)
        """Realiza copia de los valores de los atributos especificos"""

        atributoeditado = DBSession.query(DetalleItem).filter_by(
            iditem=itemeditado.id).all()

        for objeto in atributoeditado:
            nuevoDetalle = DetalleItem()
            nuevoDetalle.tipo = objeto.tipo
            nuevoDetalle.nombrecampo = objeto.nombrecampo
            nuevoDetalle.valor = objeto.valor
            nuevoDetalle.iditem = itemnuevo.id
            DBSession.add(nuevoDetalle)
        """Realiza copia de los adjuntos"""
        adjuntositemeditado = DBSession.query(Adjuntos).filter_by(
            idItem=itemeditado.id).all()

        for adj in adjuntositemeditado:
            itemnuevoadjunto = Adjuntos()
            itemnuevoadjunto.idItem = itemnuevo.id
            itemnuevoadjunto.filename = adj.filename
            itemnuevoadjunto.filecontent = adj.filecontent
            DBSession.add(itemnuevoadjunto)
        """Copia las relaciones """
        #itemnuevo=DBSession.query(Item.id).filter_by(nrohistorial=nuevo['nrohistorial'], ultimaversion=1).first()
        relaciones = DBSession.query(
            RelacionItem.idItem1, RelacionItem.idItem2).filter(
                (RelacionItem.idItem2 == itemeditado.id)
                | (RelacionItem.idItem1 == itemeditado.id)).all()

        longitud = len(relaciones)

        for x in range(longitud):
            newRelation = {}
            if int(itemeditado.id) == int(relaciones[x][0]):
                newRelation['idItem1'] = int(itemnuevo.id)
                newRelation['idItem2'] = relaciones[x][1]
                self.provider.create(RelacionItem, params=newRelation)
            elif int(itemeditado.id) == int(relaciones[x][1]):
                newRelation['idItem1'] = relaciones[x][0]
                newRelation['idItem2'] = int(itemnuevo.id)
                self.provider.create(RelacionItem, params=newRelation)

        raise redirect('./?iid=' + str(kw['idItem1']))
Esempio n. 2
0
    def put(self, *args, **kw):
        """update"""

        pks = self.provider.get_primary_fields(self.model)
        for i, pk in enumerate(pks):
            if pk not in kw and i < len(args):
                kw[pk] = args[i]
        """Extrae todos los valores del item a modificar, para luego crear un nuevo item"""

        valoresItem = DBSession.query(
            Item.version, Item.idTipoDeItem, Item.idFase, Item.idLineaBase,
            Item.fechaCreacion, Item.nrohistorial,
            Item.ultimaversion).filter_by(id=kw['id']).first()
        """Se crea una lista, y se le agrega los valores que tendra el item. """
        nuevo = {}
        nuevo['version'] = valoresItem[0] + 1
        nuevo['idTipoDeItem'] = valoresItem[1]
        nuevo['idFase'] = valoresItem[2]
        nuevo['idLineaBase'] = valoresItem[3]
        nuevo['fechaCreacion'] = str(valoresItem[4])
        nuevo['nrohistorial'] = valoresItem[5]
        nuevo['ultimaversion'] = valoresItem[6]
        nuevo['estado'] = 'modificado'
        nuevo['complejidad'] = kw['complejidad']
        nuevo['nombre'] = kw['nombre']
        itemnuevo = self.provider.create(self.model, params=nuevo)
        """Realiza copia de los valores de los atributos especificos"""
        itemeditado = DBSession.query(Item).filter_by(id=kw['id']).first()
        atributoeditado = DBSession.query(DetalleItem).filter_by(
            iditem=itemeditado.id).all()

        for objeto in atributoeditado:
            nuevoDetalle = DetalleItem()
            nuevoDetalle.tipo = objeto.tipo
            nuevoDetalle.nombrecampo = objeto.nombrecampo
            nuevoDetalle.valor = objeto.valor
            nuevoDetalle.iditem = itemnuevo.id
            DBSession.add(nuevoDetalle)
        """Realiza copia de los adjuntos"""
        adjuntositemeditado = DBSession.query(Adjuntos).filter_by(
            idItem=itemeditado.id).all()

        for adj in adjuntositemeditado:
            itemnuevoadjunto = Adjuntos()
            itemnuevoadjunto.idItem = itemnuevo.id
            itemnuevoadjunto.filename = adj.filename
            itemnuevoadjunto.filecontent = adj.filecontent
            DBSession.add(itemnuevoadjunto)
        """-----------------------------"""

        itemeditado = DBSession.query(Item).filter_by(id=kw['id']).first()
        itemeditado.ultimaversion = 0
        itemnuevo = DBSession.query(Item.id).filter_by(
            nrohistorial=nuevo['nrohistorial'], ultimaversion=1).first()
        relaciones = DBSession.query(
            RelacionItem.idItem1, RelacionItem.idItem2).filter(
                (RelacionItem.idItem2 == itemeditado.id)
                | (RelacionItem.idItem1 == itemeditado.id)).all()

        longitud = len(relaciones)
        newRelation = {}

        for x in range(longitud):
            if int(itemeditado.id) == int(relaciones[x][0]):
                newRelation['idItem1'] = int(itemnuevo[0])
                newRelation['idItem2'] = relaciones[x][1]
                self.provider.create(RelacionItem, params=newRelation)
            elif int(itemeditado.id) == int(relaciones[x][1]):
                newRelation['idItem1'] = relaciones[x][0]
                newRelation['idItem2'] = int(itemnuevo[0])
                self.provider.create(RelacionItem, params=newRelation)

        ids = []
        ids.append(int(itemnuevo[0]))
        self.recorrerArbolAtras(ids, int(itemnuevo[0]))
        self.recorrerArbolAdelante(ids, int(itemnuevo[0]))
        ids.remove(int(itemnuevo[0]))
        longitudids = len(ids)

        for x in range(longitudids):
            itemrevision = DBSession.query(Item).filter_by(
                id=ids[x], ultimaversion=1).first()

            if itemrevision != None:
                if itemrevision.estado != 'modificado':
                    itemrevision.estado = 'revision'
                    if itemrevision.idLineaBase != None:
                        lineabase = DBSession.query(LineaBase).filter_by(
                            id=itemrevision.idLineaBase).first()
                        if lineabase.estado == 'cerrada':
                            lineabase.estado = 'comprometida'
                            listalineabase = DBSession.query(
                                LineaBase).filter_by(
                                    idFase=lineabase.idFase).all()
                            desarrollo = True
                            longitud = len(listalineabase)

                            for y in range(longitud):
                                if str(listalineabase[y].estado).__eq__(
                                        'cerrada'):
                                    desarrollo = False

                            if desarrollo:
                                fase = DBSession.query(Fase).filter_by(
                                    id=lineabase.idFase).first()
                                fase.estado = 'desarrollo'

        flash("El item \"" + kw['nombre'] +
              "\" ha sido modificado correctamente")

        redirect('../' + '../item/?fid=' + str(nuevo['idFase']))
Esempio n. 3
0
    def new(self, iid=None, *args, **kw):
        """Aqui entra solo para mostrar la vista y para guardar, el descargar
        borrar esta implementado en root"""

        log.debug('iid: %s' % iid)
        log.debug('adjuntos: %s' % kw)
        longitud = len(kw)
        log.debug('longitud: %s' % longitud)
        if longitud == 0:
            #current_files = DBSession.query(Adjuntos).all()
            current_files = DBSession.query(Adjuntos).filter_by(
                idItem=iid).all()

            return dict(current_files=current_files,
                        model=self.model.__name__,
                        iid=iid)
        else:
            if iid == "save":
                iid = kw['idItem']

            idItem = kw['idItem']
            userfile = kw['userfile']
            log.debug('idItem: %s' % idItem)
            if userfile == '':
                flash("No ha selecionado ningun archivo", "error")
                redirect("../new/?iid=" + str(iid))
            """
            forbidden_files = [".js", ".htm", ".html"]
            for forbidden_file in forbidden_files:
                if userfile.filename.find(forbidden_file) != -1:
                    return redirect("../adjuntos/new")
            filecontent = userfile.file.read()
            new_file = Adjuntos(filename=userfile.filename, filecontent=filecontent,idItem=idItem )
            DBSession.add(new_file)
            DBSession.flush()
            """
            """Realiza una copia del item cuando se adjunta un archivo y aumenta su version"""
            itemeditado = DBSession.query(Item).filter_by(id=idItem).first()
            itemnuevo = Item()
            itemnuevo.version = itemeditado.version + 1
            itemnuevo.idTipoDeItem = itemeditado.idTipoDeItem
            itemnuevo.idFase = itemeditado.idFase
            itemnuevo.idLineaBase = itemeditado.idLineaBase
            itemnuevo.fechaCreacion = itemeditado.fechaCreacion
            itemnuevo.nrohistorial = itemeditado.nrohistorial
            itemnuevo.ultimaversion = 1
            itemeditado.ultimaversion = 0
            itemnuevo.estado = 'modificado'
            itemnuevo.complejidad = itemeditado.complejidad
            itemnuevo.nombre = itemeditado.nombre
            DBSession.add(itemnuevo)
            """Realiza copia de los valores de los atributos especificos"""

            atributoeditado = DBSession.query(DetalleItem).filter_by(
                iditem=itemeditado.id).all()

            for objeto in atributoeditado:
                nuevoDetalle = DetalleItem()
                nuevoDetalle.tipo = objeto.tipo
                nuevoDetalle.nombrecampo = objeto.nombrecampo
                nuevoDetalle.valor = objeto.valor
                nuevoDetalle.iditem = itemnuevo.id
                DBSession.add(nuevoDetalle)
            """Copia las relaciones """
            relaciones = DBSession.query(
                RelacionItem.idItem1, RelacionItem.idItem2).filter(
                    (RelacionItem.idItem2 == itemeditado.id)
                    | (RelacionItem.idItem1 == itemeditado.id)).all()
            longitud = len(relaciones)

            for x in range(longitud):
                newRelation = RelacionItem()
                log.debug('Creando relaciones')
                if int(itemeditado.id) == int(relaciones[x][0]):
                    newRelation.idItem1 = int(itemnuevo.id)
                    newRelation.idItem2 = relaciones[x][1]
                    DBSession.add(newRelation)
                    #self.provider.create(RelacionItem, params=newRelation)
                elif int(itemeditado.id) == int(relaciones[x][1]):
                    newRelation.idItem1 = relaciones[x][0]
                    newRelation.idItem2 = int(itemnuevo.id)
                    DBSession.add(newRelation)
            """Realiza copia de los adjuntos"""
            adjuntositemeditado = DBSession.query(Adjuntos).filter_by(
                idItem=itemeditado.id).all()

            for adj in adjuntositemeditado:
                itemnuevoadjunto = Adjuntos()

                log.debug("adj: %s" % adj)
                itemnuevoadjunto = Adjuntos()
                itemnuevoadjunto.idItem = itemnuevo.id
                itemnuevoadjunto.filename = adj.filename
                itemnuevoadjunto.filecontent = adj.filecontent
                DBSession.add(itemnuevoadjunto)

            forbidden_files = [".js", ".htm", ".html"]
            for forbidden_file in forbidden_files:
                if userfile.filename.find(forbidden_file) != -1:
                    return redirect("../adjuntos/new")
            filecontent = userfile.file.read()

            log.debug('itemnuevo: %s' % itemnuevo.id)

            new_file = Adjuntos(filename=userfile.filename,
                                filecontent=filecontent,
                                idItem=itemnuevo.id)
            DBSession.add(new_file)
            #DBSession.flush()

            #self.provider.create(self.model, params=nuevo)

            log.debug('adjuntositemeditado: %s' % adjuntositemeditado)

            redirect("../new/?iid=" + str(itemnuevo.id))
Esempio n. 4
0
    def edit(self, *args, **kw):
        """este codigo es ejecutado cuando se revierte un item """

        pks = self.provider.get_primary_fields(self.model)

        kw = {}
        for i, pk in enumerate(pks):
            kw[pk] = args[i]
        value = self.edit_filler.get_value(kw)
        """-----------Se obtiene el item a revertir -------------"""
        item = DBSession.query(Item).filter_by(id=kw['id']).first()
        """------------------------------------------------------"""
        """------obtine el numero de la mayor version del item---"""
        versionmayor = DBSession.query(Item.version).filter_by(
            nrohistorial=item.nrohistorial, ultimaversion=1).first()
        """------------------------------------------------------"""
        """ ---el item con la version mayor, cambia su ultimaversion a cero --- """
        item3 = DBSession.query(Item).filter_by(nrohistorial=item.nrohistorial,
                                                ultimaversion=1).first()
        log.debug('item3= %s' % item3)
        item3.ultimaversion = 0

        log.debug("versionmayor= %s" % versionmayor[0])

        item2 = Item()
        item2.nombre = item.nombre
        item2.idTipoDeItem = item.idTipoDeItem
        item2.idFase = item.idFase
        item2.idLineaBase = item.idLineaBase
        """el item a revertir aumenta su version a la ultima y el
        el item con la ultima version, "ultima version" pasa a 0 """
        item2.version = versionmayor[0] + 1
        item2.ultimaversion = 1
        item2.estado = item.estado
        item2.complejidad = item.complejidad
        item2.fechaCreacion = item.fechaCreacion
        item2.nrohistorial = item.nrohistorial
        DBSession.add(item2)
        """Realiza copia de los valores de los atributos especificos"""

        atributoeditado = DBSession.query(DetalleItem).filter_by(
            iditem=item.id).all()

        for objeto in atributoeditado:
            nuevoDetalle = DetalleItem()
            nuevoDetalle.tipo = objeto.tipo
            nuevoDetalle.nombrecampo = objeto.nombrecampo
            nuevoDetalle.valor = objeto.valor
            nuevoDetalle.iditem = item2.id  #el ID del nuevo item
            DBSession.add(nuevoDetalle)
        """Realiza copia de los adjuntos"""
        adjuntositemeditado = DBSession.query(Adjuntos).filter_by(
            idItem=item.id).all()

        for adj in adjuntositemeditado:

            log.debug("adj: %s" % adj)
            itemnuevoadjunto = Adjuntos()
            itemnuevoadjunto.idItem = item2.id
            itemnuevoadjunto.filename = adj.filename
            itemnuevoadjunto.filecontent = adj.filecontent
            DBSession.add(itemnuevoadjunto)
        """Copia las relaciones """
        relaciones = DBSession.query(
            RelacionItem.idItem1,
            RelacionItem.idItem2).filter((RelacionItem.idItem2 == item.id) | (
                RelacionItem.idItem1 == item.id)).all()
        longitud = len(relaciones)

        for x in range(longitud):
            newRelation = RelacionItem()

            if int(item.id) == int(relaciones[x][0]):
                newRelation.idItem1 = int(item2.id)
                newRelation.idItem2 = relaciones[x][1]
                DBSession.add(newRelation)
                #self.provider.create(RelacionItem, params=newRelation)
            elif int(item.id) == int(relaciones[x][1]):
                newRelation.idItem1 = relaciones[x][0]
                newRelation.idItem2 = int(item2.id)
                DBSession.add(newRelation)

        redirect('../' + '../item/?fid=' + str(item.idFase))
Esempio n. 5
0
    def put(self, *args, **kw):
        """update"""
        pks = self.provider.get_primary_fields(self.model)
        for i, pk in enumerate(pks):
            if pk not in kw and i < len(args):
                kw[pk] = args[i]

        #self.provider.update(self.model, params=kw)
        
        log.debug('detalleEditado: %s' %kw)
        detalleitem = DBSession.query(DetalleItem).filter_by(id=kw['id']).first()
        
        if str(detalleitem.tipo).__eq__('integer'):
            try:
                int(kw['valor'])
            except:
                flash('\"' + str(detalleitem.nombrecampo) + '\". Debe ingresar un entero', 'error')
                redirect('../'+kw['id']+'/edit')
        elif str(detalleitem.tipo).__eq__('date'):
            """False = fecha no valida
                True = fecha valida"""
            if not (self.fechaValida(kw['valor'])):
                flash('\"' + str(detalleitem.nombrecampo) + '\" Fecha no valida. Formato: dd/mm/aaaa', 'error')
                redirect('../'+kw['id']+'/edit')
        else:
            if kw['valor'].__eq__(''):
                flash('\"' + str(detalleitem.nombrecampo) + '\" no puede ser vacio', 'error')
                redirect('../'+kw['id']+'/edit')
                
        """-----------Se obtiene el ID item a editado-------------"""
        iid=DBSession.query(DetalleItem.iditem).filter_by(id=kw[pk]).first()
        
        """Se crea un nuevo item"""
        itemeditado=DBSession.query(Item).filter_by(id=iid).first()
        itemnuevo=Item()
        itemnuevo.version=itemeditado.version + 1
        itemnuevo.idTipoDeItem=itemeditado.idTipoDeItem
        itemnuevo.idFase=itemeditado.idFase
        itemnuevo.idLineaBase=itemeditado.idLineaBase
        itemnuevo.fechaCreacion=itemeditado.fechaCreacion
        itemnuevo.nrohistorial=itemeditado.nrohistorial
        itemnuevo.ultimaversion=1
        itemeditado.ultimaversion=0
        itemnuevo.estado='modificado'
        itemnuevo.complejidad=itemeditado.complejidad
        itemnuevo.nombre=itemeditado.nombre
        DBSession.add(itemnuevo)

        """Realiza copia de los valores de los atributos especificos"""
            
        atributoeditado=DBSession.query(DetalleItem).filter_by(iditem=itemeditado.id).all()
            
        for objeto in atributoeditado:
            
            
            nuevoDetalle=DetalleItem()
            nuevoDetalle.tipo=objeto.tipo
            nuevoDetalle.nombrecampo=objeto.nombrecampo
            
            if str(objeto.id)==str(kw[pk]):
                nuevoDetalle.valor=kw['valor']
            else:
                nuevoDetalle.valor=objeto.valor

            nuevoDetalle.iditem=itemnuevo.id
            DBSession.add(nuevoDetalle)
                
        """Realiza copia de los adjuntos"""
        adjuntositemeditado=DBSession.query(Adjuntos).filter_by(idItem=itemeditado.id).all()
        
        for adj in adjuntositemeditado:
            itemnuevoadjunto=Adjuntos()
            itemnuevoadjunto.idItem=itemnuevo.id
            itemnuevoadjunto.filename=adj.filename
            itemnuevoadjunto.filecontent=adj.filecontent
            DBSession.add(itemnuevoadjunto)
        
        
        """Copia las relaciones """
        relaciones = DBSession.query(RelacionItem.idItem1,RelacionItem.idItem2).filter((RelacionItem.idItem2==itemeditado.id) | (RelacionItem.idItem1==itemeditado.id)).all()
        longitud = len(relaciones)
        newRelation=RelacionItem()
        for x in range(longitud):
            if int(itemeditado.id) == int(relaciones[x][0]):
                newRelation.idItem1=int(itemnuevo.id)
                newRelation.idItem2=relaciones[x][1]
                DBSession.add(newRelation)
                #self.provider.create(RelacionItem, params=newRelation)
            elif int(itemeditado.id) == int(relaciones[x][1]):
                newRelation.idItem1=relaciones[x][0]
                newRelation.idItem2=int(itemnuevo.id)
                DBSession.add(newRelation)
        
        
        #detalleitem/?iid=113
        
        redirect('../?iid=' + str(itemnuevo.id) )