Exemplo n.º 1
0
    def delete(self, id_proyecto, id_fase, id_tipo_item, **kw):
        """Metodo que elimina un registro de la base de datos"""
        try:
            atributos = DBSession.query(Atributo).filter_by(id_tipo_item=id_tipo_item).all()

            for atributo in atributos:
                DBSession.delete(DBSession.query(Atributo).get(atributo.id_atributo))

            DBSession.delete(DBSession.query(TipoItem).get(id_tipo_item))
            DBSession.flush()
            transaction.commit()
        except IntegrityError:
            transaction.abort()
            flash(_("No se ha eliminado! Hay Problemas con el servidor..."), 'error')
            redirect("/admin/tipo_item/listadoTipoItemPorFase", id_proyecto=id_proyecto, id_fase=id_fase)
        except SQLAlchemyError:
            flash(_("No se ha eliminado! SQLAlchemyError..."), 'error')
            redirect("/admin/tipo_item/listadoTipoItemPorFase", id_proyecto=id_proyecto, id_fase=id_fase)
        except (AttributeError, NameError):
            flash(_("No se ha eliminado! Hay Problemas con el servidor..."), 'error')
            redirect("/admin/tipo_item/listadoTipoItemPorFase", id_proyecto=id_proyecto, id_fase=id_fase)
        else:
            flash(_("Tipo de Item eliminado!"), 'ok')

        redirect("/admin/tipo_item/listadoTipoItemPorFase", id_proyecto=id_proyecto, id_fase=id_fase)
Exemplo n.º 2
0
    def delete(self, id_proyecto, **kw):
        """Metodo que elimina un registro de la base de datos"""
        try:
            proyecto = DBSession.query(Proyecto).get(id_proyecto)
            fases = proyecto.fases

            for fase in fases:
                id_fase = fase.id_fase
                tipo_items = DBSession.query(TipoItem).filter_by(id_fase=id_fase).all()
                for tipo_item in tipo_items:
                    id_tipo_item = tipo_item.id_tipo_item
                    atributos = DBSession.query(Atributo).filter_by(id_tipo_item=id_tipo_item).all()
                    for atributo in atributos:
                        DBSession.delete(DBSession.query(Atributo).get(atributo.id_atributo))
                    DBSession.delete(DBSession.query(TipoItem).get(id_tipo_item))
                DBSession.delete(DBSession.query(Fase).get(id_fase))

            DBSession.delete(DBSession.query(Proyecto).get(id_proyecto))
            DBSession.flush()
            transaction.commit()
        except IntegrityError:
            transaction.abort()
            flash(_("No se pudo eliminar! Hay Problemas con el servidor..."), 'error')
            redirect("/admin/proyecto/listado")
        except SQLAlchemyError:
            flash(_("No se pudo eliminar! SQLAlchemyError..."), 'error')
            redirect("/admin/proyecto/listado")
        except (AttributeError, NameError):
            flash(_("No se pudo eliminar! Hay Problemas con el servidor..."), 'error')
            redirect("/admin/proyecto/listado")
        else:
            flash(_("Proyecto eliminado!"), 'ok')

        redirect("/admin/proyecto/listado")
Exemplo n.º 3
0
    def delete(self, id_usuario, **kw):
        """Metodo que elimina un registro de la base de datos"""
        try:
            DBSession.delete(DBSession.query(Usuario).get(id_usuario))
            DBSession.flush()
            transaction.commit()
        except IntegrityError:
            transaction.abort()
            flash(_("No se ha eliminado! Hay Problemas con el servidor..."), 'error')
            redirect("/admin/usuario/listado")
        except SQLAlchemyError:
            flash(_("No se ha eliminado! SQLAlchemyError..."), 'error')
            redirect("/admin/usuario/listado")
        except (AttributeError, NameError):
            flash(_("No se ha eliminado! Hay Problemas con el servidor..."), 'error')
            redirect("/admin/usuario/listado")
        else:
            flash(_("Usuario eliminado!"), 'ok')

        redirect("/admin/usuario/listado")
Exemplo n.º 4
0
    def delete(self, id_rol, **kw):
        """Metodo que elimina un registro de la base de datos"""
        try:
            DBSession.delete(DBSession.query(Rol).get(id_rol))
            DBSession.flush()
            transaction.commit()
        except IntegrityError:
            transaction.abort()
            flash(_("No se ha eliminado! Hay Problemas con el servidor..."), 'error')
            redirect("/admin/rol/listado")
        except SQLAlchemyError:
            flash(_("No se ha eliminado! SQLAlchemyError..."), 'error')
            redirect("/admin/rol/listado")
        except (AttributeError, NameError):
            flash(_("No se ha eliminado! Hay Problemas con el servidor..."), 'error')
            redirect("/admin/rol/listado")
        else:
            flash(_("Rol eliminado!"), 'ok')

        redirect("/admin/rol/listado")
Exemplo n.º 5
0
    def delete(self, id_proyecto, id_fase, **kw):
        """ Metodo que elimina un registro de la base de datos 
            Parametros:
                       -  id_fase: identificador de la fase
        """
        try:
            tipo_items = DBSession.query(TipoItem).filter_by(id_fase=id_fase).all()

            for tipo_item in tipo_items:
                id_tipo_item = tipo_item.id_tipo_item
                atributos = DBSession.query(Atributo).filter_by(id_tipo_item=id_tipo_item).all()
                for atributo in atributos:
                    DBSession.delete(DBSession.query(Atributo).get(atributo.id_atributo))
                DBSession.delete(DBSession.query(TipoItem).get(id_tipo_item))

            DBSession.delete(DBSession.query(Fase).get(id_fase))
            transaction.commit()
        except IntegrityError:
            transaction.abort()
            flash(_("No se ha eliminado! Hay Problemas con el servidor..."), 'error')
            redirect("/admin/fase/listadoFasesPorProyecto", id_proyecto=id_proyecto)
        except SQLAlchemyError:
            flash(_("No se ha eliminado! SQLAlchemyError..."), 'error')
            redirect("/admin/fase/listadoFasesPorProyecto", id_proyecto=id_proyecto)
        except (AttributeError, NameError):
            flash(_("No se ha eliminado! Hay Problemas con el servidor..."), 'error')
            redirect("/admin/fase/listadoFasesPorProyecto", id_proyecto=id_proyecto)
        else:
            flash(_("Fase eliminada!"), 'ok')

        redirect("/admin/fase/listadoFasesPorProyecto", id_proyecto=id_proyecto)
Exemplo n.º 6
0
    def delete(self, id_proyecto, id_fase, id_tipo_item, id_atributo, **kw):
        """ Metodo que elimina el registro de un atributo
            Parametros: - id_atributo: Para identificar el atributo a eliminar
                        - id_tipo_item: Para redireccionar al listado de atributos correspondientes al tipo de item 
        """
        try:
            DBSession.delete(DBSession.query(Atributo).get(id_atributo))
            DBSession.flush()
            transaction.commit()
        except IntegrityError:
            transaction.abort()
            flash(_("No se ha eliminado! Hay Problemas con el servidor..."),
                  'error')
            redirect("/admin/atributo/listadoAtributosPorTipoItem",
                     id_proyecto=id_proyecto,
                     id_fase=id_fase,
                     id_tipo_item=id_tipo_item)
        except SQLAlchemyError:
            flash(_("No se ha eliminado! SQLAlchemyError..."), 'error')
            redirect("/admin/atributo/listadoAtributosPorTipoItem",
                     id_proyecto=id_proyecto,
                     id_fase=id_fase,
                     id_tipo_item=id_tipo_item)
        except (AttributeError, NameError):
            flash(_("No se ha eliminado! Hay Problemas con el servidor..."),
                  'error')
            redirect("/admin/atributo/listadoAtributosPorTipoItem",
                     id_proyecto=id_proyecto,
                     id_fase=id_fase,
                     id_tipo_item=id_tipo_item)
        else:
            flash(_("Atributo eliminado!"), 'ok')

        redirect("/admin/atributo/listadoAtributosPorTipoItem",
                 id_proyecto=id_proyecto,
                 id_fase=id_fase,
                 id_tipo_item=id_tipo_item)
Exemplo n.º 7
0
    def delete(self, id_proyecto, id_fase, id_tipo_item, **kw):
        """Metodo que elimina un registro de la base de datos"""
        try:
            atributos = DBSession.query(Atributo).filter_by(
                id_tipo_item=id_tipo_item).all()

            for atributo in atributos:
                DBSession.delete(
                    DBSession.query(Atributo).get(atributo.id_atributo))

            DBSession.delete(DBSession.query(TipoItem).get(id_tipo_item))
            DBSession.flush()
            transaction.commit()
        except IntegrityError:
            transaction.abort()
            flash(_("No se ha eliminado! Hay Problemas con el servidor..."),
                  'error')
            redirect("/admin/tipo_item/listadoTipoItemPorFase",
                     id_proyecto=id_proyecto,
                     id_fase=id_fase)
        except SQLAlchemyError:
            flash(_("No se ha eliminado! SQLAlchemyError..."), 'error')
            redirect("/admin/tipo_item/listadoTipoItemPorFase",
                     id_proyecto=id_proyecto,
                     id_fase=id_fase)
        except (AttributeError, NameError):
            flash(_("No se ha eliminado! Hay Problemas con el servidor..."),
                  'error')
            redirect("/admin/tipo_item/listadoTipoItemPorFase",
                     id_proyecto=id_proyecto,
                     id_fase=id_fase)
        else:
            flash(_("Tipo de Item eliminado!"), 'ok')

        redirect("/admin/tipo_item/listadoTipoItemPorFase",
                 id_proyecto=id_proyecto,
                 id_fase=id_fase)
Exemplo n.º 8
0
    def delete(self, id_proyecto, **kw):
        """Metodo que elimina un registro de la base de datos"""
        try:
            proyecto = DBSession.query(Proyecto).get(id_proyecto)
            fases = proyecto.fases

            for fase in fases:
                id_fase = fase.id_fase
                tipo_items = DBSession.query(TipoItem).filter_by(
                    id_fase=id_fase).all()
                for tipo_item in tipo_items:
                    id_tipo_item = tipo_item.id_tipo_item
                    atributos = DBSession.query(Atributo).filter_by(
                        id_tipo_item=id_tipo_item).all()
                    for atributo in atributos:
                        DBSession.delete(
                            DBSession.query(Atributo).get(
                                atributo.id_atributo))
                    DBSession.delete(
                        DBSession.query(TipoItem).get(id_tipo_item))
                DBSession.delete(DBSession.query(Fase).get(id_fase))

            DBSession.delete(DBSession.query(Proyecto).get(id_proyecto))
            DBSession.flush()
            transaction.commit()
        except IntegrityError:
            transaction.abort()
            flash(_("No se pudo eliminar! Hay Problemas con el servidor..."),
                  'error')
            redirect("/admin/proyecto/listado")
        except SQLAlchemyError:
            flash(_("No se pudo eliminar! SQLAlchemyError..."), 'error')
            redirect("/admin/proyecto/listado")
        except (AttributeError, NameError):
            flash(_("No se pudo eliminar! Hay Problemas con el servidor..."),
                  'error')
            redirect("/admin/proyecto/listado")
        else:
            flash(_("Proyecto eliminado!"), 'ok')

        redirect("/admin/proyecto/listado")
Exemplo n.º 9
0
    def delete(self, id_proyecto, id_fase, **kw):
        """ Metodo que elimina un registro de la base de datos 
            Parametros:
                       -  id_fase: identificador de la fase
        """
        try:
            tipo_items = DBSession.query(TipoItem).filter_by(
                id_fase=id_fase).all()

            for tipo_item in tipo_items:
                id_tipo_item = tipo_item.id_tipo_item
                atributos = DBSession.query(Atributo).filter_by(
                    id_tipo_item=id_tipo_item).all()
                for atributo in atributos:
                    DBSession.delete(
                        DBSession.query(Atributo).get(atributo.id_atributo))
                DBSession.delete(DBSession.query(TipoItem).get(id_tipo_item))

            DBSession.delete(DBSession.query(Fase).get(id_fase))
            transaction.commit()
        except IntegrityError:
            transaction.abort()
            flash(_("No se ha eliminado! Hay Problemas con el servidor..."),
                  'error')
            redirect("/admin/fase/listadoFasesPorProyecto",
                     id_proyecto=id_proyecto)
        except SQLAlchemyError:
            flash(_("No se ha eliminado! SQLAlchemyError..."), 'error')
            redirect("/admin/fase/listadoFasesPorProyecto",
                     id_proyecto=id_proyecto)
        except (AttributeError, NameError):
            flash(_("No se ha eliminado! Hay Problemas con el servidor..."),
                  'error')
            redirect("/admin/fase/listadoFasesPorProyecto",
                     id_proyecto=id_proyecto)
        else:
            flash(_("Fase eliminada!"), 'ok')

        redirect("/admin/fase/listadoFasesPorProyecto",
                 id_proyecto=id_proyecto)
Exemplo n.º 10
0
    def delete(self, id_relacion, idItemActual, id_proyecto, id_fase,
               id_tipo_item):
        """Metodo que elimina un registro de la base de datos"""
        item = DBSession.query(Item).get(idItemActual)
        id_item = item.id_item
        version_anterior = item.version
        version_nueva = int(item.version) + 1
        linea_bases_item = item.linea_bases

        #Comprobamos que no se encuentre en una Linea Base
        if linea_bases_item != []:
            for linea_base_item in linea_bases_item:
                flash(
                    _("No puede Eliminar la relacion del Item! Se encuentra en una Linea Base..."
                      ), 'error')
                redirect('/relacion/listado',
                         id_item=idItemActual,
                         id_proyecto=id_proyecto,
                         id_fase=id_fase,
                         id_tipo_item=id_tipo_item)

        #El Item cambia de version al eliminar la relacion
        itemHistorial = ItemHistorial()
        itemHistorial.id_item = item.id_item
        itemHistorial.id_tipo_item = item.id_tipo_item
        itemHistorial.codigo = item.codigo
        itemHistorial.descripcion = item.descripcion
        itemHistorial.complejidad = item.complejidad
        itemHistorial.prioridad = item.prioridad
        itemHistorial.estado = "Desarrollo"
        itemHistorial.version = version_anterior
        itemHistorial.observacion = item.observacion
        itemHistorial.fecha_modificacion = item.fecha_modificacion
        item.version = version_nueva
        item.estado = "Desarrollo"
        DBSession.add(itemHistorial)
        DBSession.flush()

        #Consultamos los detalles que tiene el Item a ser editado y tambien
        #los atributos actuales de su Tipo de Item correspondiente
        detalles = DBSession.query(ItemDetalle).filter_by(id_item=id_item)
        atributos = DBSession.query(Atributo).filter_by(
            id_tipo_item=id_tipo_item)
        lista_id_atributo = []

        if atributos != None:
            for atributo in atributos:
                lista_id_atributo.append(atributo.id_atributo)

        #Enviamos al historial los detalles del Item a ser editado
        if detalles != None:
            for detalle in detalles:
                if lista_id_atributo.count(detalle.id_atributo) >= 1:
                    lista_id_atributo.remove(detalle.id_atributo)
                itemDetalleHistorial = ItemDetalleHistorial()
                itemDetalleHistorial.id_item = id_item
                itemDetalleHistorial.id_item_detalle = detalle.id_item_detalle
                itemDetalleHistorial.id_atributo = detalle.id_atributo
                itemDetalleHistorial.nombre_atributo = detalle.nombre_atributo
                itemDetalleHistorial.valor = detalle.valor
                itemDetalleHistorial.version = version_anterior
                DBSession.add(itemDetalleHistorial)
                DBSession.flush()

        #Cargamos a vacio los atributos que no contemplaban los detalles actuales
        if lista_id_atributo != None:
            for id_atributo in lista_id_atributo:
                atributo = DBSession.query(Atributo).get(id_atributo)
                itemDetalle = ItemDetalle()
                itemDetalle.id_item = id_item
                itemDetalle.id_atributo = atributo.id_atributo
                itemDetalle.nombre_atributo = atributo.nombre
                itemDetalle.valor = ""
                DBSession.add(itemDetalle)
                DBSession.flush()

        #Enviamos sus relaciones actuales al historial de relaciones
        hijos = DBSession.query(RelacionItem).filter_by(id_item1=id_item)
        antecesores = DBSession.query(RelacionItem).filter_by(id_item2=id_item)
        if hijos != None:
            for hijo in hijos:
                relacion_historial = RelacionHistorial()
                relacion_historial.tipo = hijo.tipo
                relacion_historial.id_item1 = hijo.id_item1
                relacion_historial.id_item2 = hijo.id_item2
                relacion_historial.version_modif = version_anterior
                DBSession.add(relacion_historial)
                DBSession.flush()
        if antecesores != None:
            for antecesor in antecesores:
                relacion_historial = RelacionHistorial()
                relacion_historial.tipo = antecesor.tipo
                relacion_historial.id_item1 = antecesor.id_item1
                relacion_historial.id_item2 = antecesor.id_item2
                relacion_historial.version_modif = version_anterior
                DBSession.add(relacion_historial)
                DBSession.flush()

        #Ponemos a revision todos los items afectados por el item editado
        #Tambien colocamos a "Revision" las Lineas Bases correspondientes
        global itemsAfectados
        global listaRelaciones
        itemsAfectados = []
        listaRelaciones = []

        itemsAfectados.append(id_item)

        for item_afectado in itemsAfectados:
            self.buscarRelaciones(item_afectado)

        for item_afectado in itemsAfectados:
            item_cambio = DBSession.query(Item).get(item_afectado)
            item_cambio.estado = "Revision"
            linea_bases_item = item_cambio.linea_bases
            if linea_bases_item != None:
                for linea_base_item in linea_bases_item:
                    if linea_base_item.estado == "Aprobado":
                        id_linea_base = linea_base_item.id_linea_base
                        linea_base = DBSession.query(LineaBase).get(
                            id_linea_base)
                        linea_base.estado = "Revision"
                        fase = DBSession.query(Fase).get(linea_base.id_fase)
                        if fase.relacion_estado_fase.nombre == "Finalizado":
                            fase.id_estado_fase = '4'
                        DBSession.flush()
            DBSession.flush()

        #Los archivos adjuntos del Item a ser editado se copian
        #para tener el registro de estos archivos con esa version de item
        archivos_item_editado = DBSession.query(ItemArchivo).filter_by(
            id_item=id_item).filter_by(version_item=version_anterior)
        if archivos_item_editado != None:
            for archivo in archivos_item_editado:
                nuevo_archivo = ItemArchivo()
                nuevo_archivo.id_item = archivo.id_item
                nuevo_archivo.version_item = version_anterior
                nuevo_archivo.nombre_archivo = archivo.nombre_archivo
                nuevo_archivo.contenido_archivo = archivo.contenido_archivo
                archivo.version_item = version_nueva
                DBSession.add(nuevo_archivo)
                DBSession.flush()

        DBSession.delete(DBSession.query(RelacionItem).get(id_relacion))
        DBSession.flush()
        transaction.commit()
        flash(_("Relacion eliminada!"), 'ok')
        redirect('/relacion/listado',
                 id_item=idItemActual,
                 id_proyecto=id_proyecto,
                 id_fase=id_fase,
                 id_tipo_item=id_tipo_item)
Exemplo n.º 11
0
    def delete(self, id_relacion, idItemActual, id_proyecto, id_fase, id_tipo_item):
        """Metodo que elimina un registro de la base de datos"""
        item = DBSession.query(Item).get(idItemActual)
        id_item = item.id_item
        version_anterior = item.version
        version_nueva = int(item.version) + 1
        linea_bases_item = item.linea_bases

        #Comprobamos que no se encuentre en una Linea Base
        if linea_bases_item != []:
           for linea_base_item in linea_bases_item:
               flash(_("No puede Eliminar la relacion del Item! Se encuentra en una Linea Base..."), 'error')
               redirect('/relacion/listado', id_item=idItemActual, id_proyecto=id_proyecto, id_fase=id_fase, id_tipo_item=id_tipo_item)

        #El Item cambia de version al eliminar la relacion
        itemHistorial = ItemHistorial()
        itemHistorial.id_item = item.id_item
        itemHistorial.id_tipo_item = item.id_tipo_item
        itemHistorial.codigo = item.codigo
        itemHistorial.descripcion = item.descripcion
        itemHistorial.complejidad = item.complejidad
        itemHistorial.prioridad = item.prioridad
        itemHistorial.estado = "Desarrollo"
        itemHistorial.version = version_anterior
        itemHistorial.observacion = item.observacion
        itemHistorial.fecha_modificacion = item.fecha_modificacion
        item.version = version_nueva
        item.estado = "Desarrollo"
        DBSession.add(itemHistorial)
        DBSession.flush()

        #Consultamos los detalles que tiene el Item a ser editado y tambien
        #los atributos actuales de su Tipo de Item correspondiente
        detalles = DBSession.query(ItemDetalle).filter_by(id_item=id_item)
        atributos = DBSession.query(Atributo).filter_by(id_tipo_item=id_tipo_item)
        lista_id_atributo = []

        if atributos != None:
           for atributo in atributos:
               lista_id_atributo.append(atributo.id_atributo)

        #Enviamos al historial los detalles del Item a ser editado
        if detalles != None:
           for detalle in detalles:
               if lista_id_atributo.count(detalle.id_atributo) >= 1: 
                  lista_id_atributo.remove(detalle.id_atributo)
               itemDetalleHistorial = ItemDetalleHistorial()
               itemDetalleHistorial.id_item = id_item
               itemDetalleHistorial.id_item_detalle = detalle.id_item_detalle
               itemDetalleHistorial.id_atributo = detalle.id_atributo
               itemDetalleHistorial.nombre_atributo = detalle.nombre_atributo
               itemDetalleHistorial.valor = detalle.valor
               itemDetalleHistorial.version = version_anterior
               DBSession.add(itemDetalleHistorial)
               DBSession.flush()

        #Cargamos a vacio los atributos que no contemplaban los detalles actuales
        if lista_id_atributo != None:
           for id_atributo in lista_id_atributo:
               atributo = DBSession.query(Atributo).get(id_atributo)
               itemDetalle = ItemDetalle()
               itemDetalle.id_item = id_item
               itemDetalle.id_atributo = atributo.id_atributo
               itemDetalle.nombre_atributo = atributo.nombre
               itemDetalle.valor = ""
               DBSession.add(itemDetalle)
               DBSession.flush()

        #Enviamos sus relaciones actuales al historial de relaciones
        hijos = DBSession.query(RelacionItem).filter_by(id_item1=id_item)
        antecesores = DBSession.query(RelacionItem).filter_by(id_item2=id_item)
        if hijos != None:
           for hijo in hijos:
               relacion_historial = RelacionHistorial()
               relacion_historial.tipo = hijo.tipo
               relacion_historial.id_item1 = hijo.id_item1
               relacion_historial.id_item2 = hijo.id_item2
               relacion_historial.version_modif = version_anterior
               DBSession.add(relacion_historial)
               DBSession.flush()
        if antecesores != None:
           for antecesor in antecesores:
               relacion_historial = RelacionHistorial()
               relacion_historial.tipo = antecesor.tipo
               relacion_historial.id_item1 = antecesor.id_item1
               relacion_historial.id_item2 = antecesor.id_item2
               relacion_historial.version_modif = version_anterior
               DBSession.add(relacion_historial)
               DBSession.flush()

        #Ponemos a revision todos los items afectados por el item editado
        #Tambien colocamos a "Revision" las Lineas Bases correspondientes
        global itemsAfectados
        global listaRelaciones
        itemsAfectados = []
        listaRelaciones = []
            
        itemsAfectados.append(id_item)

        for item_afectado in itemsAfectados:
            self.buscarRelaciones(item_afectado)

        for item_afectado in itemsAfectados:
            item_cambio = DBSession.query(Item).get(item_afectado)
            item_cambio.estado = "Revision"
            linea_bases_item = item_cambio.linea_bases
            if linea_bases_item != None:
               for linea_base_item in linea_bases_item:
                   if linea_base_item.estado == "Aprobado":
                      id_linea_base = linea_base_item.id_linea_base 
                      linea_base = DBSession.query(LineaBase).get(id_linea_base)
                      linea_base.estado = "Revision"
                      fase = DBSession.query(Fase).get(linea_base.id_fase)
                      if fase.relacion_estado_fase.nombre == "Finalizado":
                         fase.id_estado_fase = '4'
                      DBSession.flush()
            DBSession.flush() 

        #Los archivos adjuntos del Item a ser editado se copian
        #para tener el registro de estos archivos con esa version de item
        archivos_item_editado = DBSession.query(ItemArchivo).filter_by(id_item=id_item).filter_by(version_item=version_anterior)
        if archivos_item_editado != None:
           for archivo in archivos_item_editado:
               nuevo_archivo = ItemArchivo()
               nuevo_archivo.id_item = archivo.id_item
               nuevo_archivo.version_item = version_anterior
               nuevo_archivo.nombre_archivo = archivo.nombre_archivo
               nuevo_archivo.contenido_archivo = archivo.contenido_archivo
               archivo.version_item = version_nueva
               DBSession.add(nuevo_archivo)
               DBSession.flush()     

        DBSession.delete(DBSession.query(RelacionItem).get(id_relacion))
        DBSession.flush()
        transaction.commit()   
        flash(_("Relacion eliminada!"), 'ok')
        redirect('/relacion/listado', id_item=idItemActual, id_proyecto=id_proyecto, id_fase=id_fase, id_tipo_item=id_tipo_item)