Python model.DBSession类代码示例

 def post(self, **kw):
     """ Registra el nuevo proyecto creado. """
     p = Proyecto()
     p.descripcion = kw['descripcion']
     p.nombre = kw['nombre']
     p.estado = 'Nuevo'
     p.nro_fases = int(kw['nro_fases'])
     ids_proyectos = DBSession.query(Proyecto.id).all()
     if ids_proyectos:
         proximo_id_proyecto = proximo_id(ids_proyectos)
     else:
         proximo_id_proyecto = "PR1"
     p.id = proximo_id_proyecto
     if kw['lider']:
         objeto_usuario = DBSession.query(Usuario).filter(Usuario.id == \
                         kw['lider']).one()
         p.lider = objeto_usuario
         ids_fichas = DBSession.query(Ficha.id).filter(Ficha.id_usuario == \
                     kw['lider']).all()
         r = DBSession.query(Rol).filter(Rol.id == u'RL2').one()
         ficha = Ficha()
         ficha.usuario = objeto_usuario
         ficha.rol = r
         ficha.proyecto = p
         if ids_fichas:
             proximo_id_ficha = proximo_id(ids_fichas)
         else:
             proximo_id_ficha = "FI1-" + kw["lider"]
         ficha.id = proximo_id_ficha
         DBSession.add(p)
         DBSession.add(ficha)            
     else:
         DBSession.add(p)
     raise redirect('./')

 def importar_caracteristica(self, id_tipo_item_viejo, id_tipo_item_nuevo):
     """
     Importa las características correspondientes al tipo de ítem a 
     importar.
     @param id_tipo_item_viejo: Id del tipo de item a importar.
     @type id_tipo_item_viejo: Unicode. 
     @param id_tipo_item_nuevo: Id del tipo de item nuevo o importado.
     @type id_tipo_item_nuevo: Unicode
     """
     caracteristicas = DBSession.query(Caracteristica) \
            .filter(Caracteristica.id_tipo_item == id_tipo_item_viejo).all()
     for caracteristica in caracteristicas:
         c = Caracteristica()
         c.nombre = caracteristica.nombre
         c.tipo = caracteristica.tipo
         c.descripcion = caracteristica.descripcion
         ids_caracteristicas = DBSession.query(Caracteristica.id) \
            .filter(Caracteristica.id_tipo_item == id_tipo_item_nuevo).all()
         if ids_caracteristicas:        
             proximo_id_caracteristica = proximo_id(ids_caracteristicas)
         else:
             proximo_id_caracteristica = "CA1-" + id_tipo_item_nuevo
         c.id = proximo_id_caracteristica
         c.tipo_item = DBSession.query(TipoItem).filter(TipoItem.id == \
             id_tipo_item_nuevo).one()
         DBSession.add(c)

    def update_params(self, d):
        """ @param d: diccionario con las opciones posibles de ítems.
            @return: d con los valores correctos de ítems posibles.
        """
        super(ItemsField, self).update_params(d)
        id_fase = unicode(request.url.split("/")[-3])
        ids_tipos_item = DBSession.query(TipoItem.id).filter(TipoItem.id_fase == id_fase)
        items = (
            DBSession.query(Item)
            .filter(Item.id_tipo_item.in_(ids_tipos_item))
            .filter(Item.id_linea_base == None)
            .filter(Item.borrado == False)
            .filter(Item.revisiones == None)
            .all()
        )

        items_a_mostrar = UnificarItem(items)
        aux = list()
        for item in reversed(items_a_mostrar):
            if item.estado != u"Aprobado" or es_huerfano(item):
                items_a_mostrar.remove(item)
        for item in items_a_mostrar:
            aux.append(item.id + "/" + str(item.version))
        lista = [x for x in d["options"] if x[0] in aux]
        d["options"] = lista

    def buscar(self, **kw):
        """ Lista las fases de acuerdo a un criterio de búsqueda introducido
            por el usuario.
        """
        buscar_table_filler = FaseTableFiller(DBSession)
        if "parametro" in kw:
            buscar_table_filler.init(kw["parametro"], self.id_proyecto)
        else:
            buscar_table_filler.init("", self.id_proyecto)
        tmpl_context.widget = self.table
        value = buscar_table_filler.get_value()
        d = dict(value_list = value, model = "fase", accion = "./buscar")

        cant_fases = DBSession.query(Fase).filter(Fase.id_proyecto == \
                    self.id_proyecto).count()
        otroproyecto = DBSession.query(Proyecto).filter(Proyecto.id != \
                       self.id_proyecto).filter(Proyecto.fases != None).count()
        if cant_fases < DBSession.query(Proyecto.nro_fases).filter( \
                        Proyecto.id == self.id_proyecto).scalar():
            d["suficiente"] = True
        else:
            d["suficiente"] = False
        d["model"] = "Fases"
        d["permiso_crear"] = TienePermiso("crear fase", id_proyecto = \
                            self.id_proyecto).is_met(request.environ)
        d["permiso_importar"] = TienePermiso("importar fase", id_proyecto = \
                    self.id_proyecto).is_met(request.environ) and otroproyecto
        d["direccion_anterior"] = "../.."
        return d

 def __actions__(self, obj):
     """ Define las acciones posibles para cada relación.
     """
     primary_fields = self.__provider__.get_primary_fields(self.__entity__)
     pklist = '/'.join(map(lambda x: str(getattr(obj, x)), primary_fields))
     value = '<div>'
     relacion = DBSession.query(Relacion).get(pklist)
     item = DBSession.query(Item).filter(Item.id == self.id_item).filter( \
             Item.version == self.version_item).one()
     bloqueado = False
     if item.linea_base:
         if item.linea_base.cerrado: bloqueado = True
     if TienePermiso("eliminar relaciones", id_fase = item.tipo_item.fase \
                     .id).is_met(request.environ) and not bloqueado and \
                     relacion.item_2 == item:
         value = value + '<div>'\
           '<form method="POST" action="'+pklist+'" class="button-to">'\
         '<input type="hidden" name="_method" value="DELETE" />'\
         '<input class="delete-button" onclick="return confirm' \
         '(\'¿Está seguro?\');" value="delete" type="submit" '\
         'style="background-color: transparent; float:left; border:0;' \
         ' color: #286571; display: inline; margin: 0; padding: 0;"/>'\
         '</form>'\
         '</div>'
     value = value + '</div>'
     return value

    def post(self, **kw):
        """Registra el nuevo archivo creado."""
        id_item_version = unicode(request.url.split("/")[-3])
        self.id_item = id_item_version.split("-")[0] + "-" + id_item_version \
                    .split("-")[1] + "-" + id_item_version.split("-")[2] + \
                    "-" + id_item_version.split("-")[3]
        self.version_item = id_item_version.split("-")[4]
        it = DBSession.query(Item).filter(Item.id == self.id_item) \
            .filter(Item.version == self.version_item).one()
        nueva_version = self.crear_version(it)
        a = Archivo()

        ids_archivos = DBSession.query(Archivo.id).all()
        if ids_archivos:        
            proximo_id_archivo = proximo_id(ids_archivos)
        else:
            proximo_id_archivo = "AR1"
        a.id = proximo_id_archivo 
        a.nombre = kw['archivo'].filename
        a.contenido = kw['archivo'].value
        a.items.append(nueva_version)
        DBSession.add(a)
        flash(u"Creación realizada de forma exitosa")
        raise redirect('./../../' + nueva_version.id + '-' + unicode( \
                        nueva_version.version) + '/' + 'archivos/')

    def importar_caracteristica(self, id_tipo_item_viejo, id_tipo_item_nuevo):
        """ Realiza la importación de características de un tipo de ítem a otro.
            @param id_tipo_item_viejo: id del tipo de ítem a ser importado.
            @param id_tipo_item_nuevo: id del tipo de ítem que será creado en
                base al importado.
            @type id_tipo_item_viejo: unicode
            @type id_tipo_item_nuevo: unicode
        """
        caracteristicas = DBSession.query(Caracteristica) \
            .filter(Caracteristica.id_tipo_item == id_tipo_item_viejo).all()
        for caracteristica in caracteristicas:
            c = Caracteristica()
            c.nombre = caracteristica.nombre
            c.tipo = caracteristica.tipo
            c.descripcion = caracteristica.descripcion
            ids_caracteristicas = DBSession.query(Caracteristica.id) \
               .filter(Caracteristica.id_tipo_item == id_tipo_item_nuevo).all()
            if ids_caracteristicas:        
                proximo_id_caracteristica = proximo_id(ids_caracteristicas)
            else:
                proximo_id_caracteristica = "CA1-" + id_tipo_item_nuevo
            c.id = proximo_id_caracteristica

            c.tipo_item = DBSession.query(TipoItem).filter(TipoItem.id == \
                        id_tipo_item_nuevo).one()
            DBSession.add(c)

 def _do_get_provider_count_and_objs(self, buscado = "", **kw):
     """
     Se utiliza para listar solo las fichas que cumplan ciertas
     condiciones y de acuerdo a ciertos permisos.
     """
     if self.id_fase == "":
         fichas = DBSession.query(Ficha) \
                 .filter(Ficha.id.contains(self.buscado)).all()    
     else:
         id_proyecto = self.id_fase.split("-")[1]
         permiso_asignar_rol_fase = TienePermiso("asignar rol fase", \
                     id_fase = self.id_fase).is_met(request.environ)
         permiso_asignar_rol_cualquier_fase = TienePermiso( \
                 "asignar rol cualquier fase", id_proyecto = \
                 id_proyecto).is_met(request.environ)
         if permiso_asignar_rol_fase or permiso_asignar_rol_cualquier_fase:
             fichas = DBSession.query(Ficha).filter(Ficha.id_fase == \
             self.id_fase).all()
             for ficha in reversed(fichas):
                 if ficha.rol.tipo != u"Fase": 
                     fichas.remove(ficha)
                 elif not (self.buscado in ficha.usuario.nombre_usuario or \
                     self.buscado in ficha.rol.nombre or self.buscado in \
                     ficha.id or self.buscado in ficha.proyecto.nombre or \
                     self.buscado in ficha.fase.nombre): fichas.remove(ficha)
                 
         else: fichas = list()
     return len(fichas), fichas 

 def post_delete(self, *args, **kw):
     """ Elimina un item."""
     pks = self.provider.get_primary_fields(self.model)
     clave_primaria = args[0]
     pk_version = unicode(clave_primaria.split("-")[4])
     pk_id = unicode(clave_primaria.split("-")[0] + "-" + \
             clave_primaria.split("-")[1] + "-" + \
             clave_primaria.split("-")[2] + "-" + \
             clave_primaria.split("-")[3])
     it = DBSession.query(Item).filter(Item.id == pk_id) \
             .filter(Item.version == pk_version).scalar()
     self.crear_version(it, None , True)
     items = DBSession.query(Item).filter(Item.id == pk_id).all()
     for item in items:
         item.borrado = True
         item.linea_base = None
     re = it.relaciones_a
     re_act = relaciones_a_actualizadas(re)
     if re:
         for relacion in re:
             if relacion in re_act:
                 nueva_version = self.crear_version(relacion.item_2, \
                                 relacion)            
                 if es_huerfano(nueva_version) and \
                     (nueva_version.estado == u"Aprobado" \
                     or nueva_version.linea_base):
                         msg = u"Item huerfano"
                         nueva_version.estado = u"En desarrollo"
                         self.crear_revision(nueva_version, msg)
                         if nueva_version.linea_base: 
                             consistencia_lb(nueva_version.linea_base)                
     redirect('./')

 def post(self, **kw):
     """ Registra el nuevo ítem creado. """
     i = Item()
     i.descripcion = kw['descripcion']
     i.nombre = kw['nombre']
     i.estado = 'En desarrollo'
     i.observaciones = kw['observaciones']
     i.prioridad = kw['prioridad']
     i.complejidad = kw['complejidad']
     i.version = 1
     i.borrado = False
     caract = DBSession.query(Caracteristica) \
             .filter(Caracteristica.id_tipo_item == kw['tipo_item']).all()
     anexo = dict()
     for nom_car in caract: 
         anexo[nom_car.nombre] = kw[nom_car.nombre]
     i.anexo = json.dumps(anexo)
     ids_items = DBSession.query(Item.id) \
             .filter(Item.id_tipo_item == kw["tipo_item"]).all()
     if ids_items:        
         proximo_id_item = proximo_id(ids_items)
     else:
         proximo_id_item = "IT1-" + kw["tipo_item"]
     i.id = proximo_id_item
     i.tipo_item = DBSession.query(TipoItem) \
             .filter(TipoItem.id == kw["tipo_item"]).one()
     DBSession.add(i)
     i.codigo = i.tipo_item.codigo + "-" + i.id.split("-")[0][2:]
     raise redirect('./')

    def buscar(self, **kw):
        """ Lista las relaciones de acuerdo a un criterio de búsqueda
            introducido por el usuario.
        """
        buscar_table_filler = RelacionTableFiller(DBSession)
        item = DBSession.query(Item).filter(Item.id == self.id_item) \
            .filter(Item.version == self.version_item).one()
        buscar_table_filler = RelacionTableFiller(DBSession)
        if "parametro" in kw:
            buscar_table_filler.init(kw["parametro"], self.id_item, \
                    self.version_item)
        else:
            buscar_table_filler.init("", self.id_item, self.version_item)
        tmpl_context.widget = self.table
        value = buscar_table_filler.get_value()
        d = dict(value_list = value, model = "Relaciones", accion = "./buscar")
        d["fases"] = list()
        lista = [x.id_item_2 for x in item.relaciones_a] + \
                [x.id_item_1 for x in item.relaciones_b]
        fase_actual = DBSession.query(Fase).filter(Fase.id == \
                item.tipo_item.id_fase).one()
        band = False
        ts_item = [t for t in fase_actual.tipos_item]
        items = list()
        for t_item in ts_item:
            items = items + t_item.items
        for it in reversed(items):
            if it.borrado: items.remove(it) 
        for it in items:
            if it.id not in lista and it.id != self.id_item and \
               it.estado == u"Aprobado" and not it.revisiones:
                band = True
                break
        if band: d["fases"].append(fase_actual)
        fase_ant = DBSession.query(Fase).filter(Fase.id_proyecto == \
                item.tipo_item.fase.id_proyecto).filter(Fase.orden == \
                item.tipo_item.fase.orden - 1).first()
        if fase_ant:
            band = False
            ts_item = [t for t in fase_ant.tipos_item]
            items = list()
            for t_item in ts_item:
                items = items + t_item.items
            for it in reversed(items):
	            if it.borrado: items.remove(it) 
            for it in items:
                if it.id not in lista and it.linea_base:
                    if it.linea_base.cerrado and it.linea_base.consistente:
                        band = True
                        break
            if band: d["fases"].append(fase_ant)        
        bloqueado = False
        if item.linea_base:
            if item.linea_base.cerrado: bloqueado = True
        if d["fases"]:
            d["permiso_crear"] = TienePermiso("crear relaciones", id_fase = \
                    fase_actual.id).is_met(request.environ) and not bloqueado
        else: d["permiso_crear"] = False
        d["direccion_anterior"] = "../.."        
        return d

    def _do_get_provider_count_and_objs(self, buscado = "", **kw):
        """ Se utiliza para listar las fases que cumplan ciertas condiciones y
            ciertos permisos.
        """
        id_proyecto = unicode(request.url.split("/")[-3])
        if TieneAlgunPermiso(tipo = u"Fase", recurso = u"Item", id_proyecto = \
                            id_proyecto):
            fases = DBSession.query(Fase).filter(Fase.id_proyecto == \
                    id_proyecto).order_by(Fase.orden).all()

            for fase in reversed(fases):
                buscado = self.buscado in fase.nombre or \
                          self.buscado in fase.descripcion or \
                          self.buscado in str(fase.orden) or \
                          self.buscado in str(fase.fecha_inicio) or \
                          self.buscado in str(fase.fecha_fin) or \
                          self.buscado in fase.estado

                if not buscado: fases.remove(fase)  
            for fase in reversed(fases):
                if not TieneAlgunPermiso(tipo = u"Fase", recurso = u"Item", \
                                    id_fase = fase.id).is_met(request.environ):
                    fases.remove(fase)
                elif fase.orden > 1:
                    fase_prev = DBSession.query(Fase).filter(Fase.id_proyecto \
                            == id_proyecto).filter(Fase.orden == \
                            fase.orden - 1).one()
                    if not fase_prev.lineas_base: fases.remove(fase)
        else: fases = list()
        return len(fases), fases

 def crear_tipo_default(self, id_fase):
     """ Crea un tipo de ítem por defecto al crear una fase.
     """
     ti = TipoItem()
     ti.nombre = "Default"    
     ti.descripcion = "Default"
     ti.id = "TI1-" + id_fase
     ti.codigo = "DF"
     ti.fase = DBSession.query(Fase).filter(Fase.id == id_fase).one() 
     DBSession.add(ti)

    def get_all(self, *args, **kw):
        """Lista las relaciones de acuerdo a lo establecido en
           L{relacion_controller.RelacionTableFiller._do_get_provider_count_and_objs}.
        """
        relacion_table_filler.init("", self.id_item, self.version_item)   
        d = super(RelacionController, self).get_all(*args, **kw)
        item = DBSession.query(Item).filter(Item.id == self.id_item) \
            .filter(Item.version == self.version_item).one()
        d["accion"] = "./buscar"
        d["fases"] = list()
        d["model"] = "Relaciones"
        lista = [x.id_item_2 for x in item.relaciones_a] + \
                [x.id_item_1 for x in item.relaciones_b]
        fase_actual = DBSession.query(Fase).filter(Fase.id == \
                item.tipo_item.id_fase).one()
        band = False
        ts_item = [t for t in fase_actual.tipos_item]
        items = list()
        for t_item in ts_item:
            items = items + t_item.items
        for it in reversed(items):
            if it.borrado: items.remove(it) 
        for it in items:
            if it.id not in lista and it.id != self.id_item and \
               it.estado == u"Aprobado" and not it.revisiones:
                band = True
                break
        if band: d["fases"].append(fase_actual)
        fase_ant = DBSession.query(Fase).filter(Fase.id_proyecto == \
                item.tipo_item.fase.id_proyecto).filter(Fase.orden == \
                item.tipo_item.fase.orden - 1).first()
        if fase_ant:
            band = False
            ts_item = [t for t in fase_ant.tipos_item]
            items = list()
            for t_item in ts_item:
                items = items + t_item.items
            for it in reversed(items):
	            if it.borrado: items.remove(it) 
            for it in items:
                if it.id not in lista and it.linea_base:
                    if it.linea_base.cerrado and it.linea_base.consistente:
                        band = True
                        break
            if band: d["fases"].append(fase_ant)
        bloqueado = False
        if item.linea_base:
            if item.linea_base.cerrado: bloqueado = True
        if d["fases"]:
            d["permiso_crear"] = TienePermiso("crear relaciones", id_fase = \
                    fase_actual.id).is_met(request.environ) and not bloqueado
        else: d["permiso_crear"] = False
        d["direccion_anterior"] = "../.."
        return d

 def _do_get_provider_count_and_objs(self, buscado="", id_item = "", \
                                     version = "", **kw):
     """ Se utiliza para listar los archivos que cumplan ciertas condiciones
         y ciertos permisos.
     """
     archivos = DBSession.query(Archivo).filter(or_(Archivo.id.contains( \
                self.buscado), Archivo.nombre.contains(self.buscado))).all()
     item = DBSession.query(Item).filter(Item.id == self.id_item) \
             .filter(Item.version == self.version).one()
     for archivo in reversed(archivos):
         if item not in archivo.items: archivos.remove(archivo)
     return len(archivos), archivos