Python DBSession.query方法代码示例

# 需要导入模块: from saip.model import DBSession [as 别名]
# 或者: from saip.model.DBSession import query [as 别名]
 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('./')

# 需要导入模块: from saip.model import DBSession [as 别名]
# 或者: from saip.model.DBSession import query [as 别名]
 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

# 需要导入模块: from saip.model import DBSession [as 别名]
# 或者: from saip.model.DBSession import query [as 别名]
    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

# 需要导入模块: from saip.model import DBSession [as 别名]
# 或者: from saip.model.DBSession import query [as 别名]
 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 

# 需要导入模块: from saip.model import DBSession [as 别名]
# 或者: from saip.model.DBSession import query [as 别名]
 def post(self, **kw):
     """Registra la nueva ficha creada"""
     if not DBSession.query(Ficha).filter(Ficha.id_usuario == \
             kw['usuario']).filter(Ficha.id_rol == kw['rol']) \
             .filter(Ficha.id_fase == self.id_fase).count():
         f = Ficha()
         ids_fichas = DBSession.query(Ficha.id).filter(Ficha.id_usuario == \
                 kw['usuario']).all()
         if ids_fichas:        
             proximo_id_ficha = proximo_id(ids_fichas)
         else:
             proximo_id_ficha = "FI1-" + kw['usuario']
         f.id = proximo_id_ficha
         usuario = DBSession.query(Usuario).filter(Usuario.id == \
             kw['usuario']).one()
         rol = DBSession.query(Rol).filter(Rol.id ==  kw['rol']).one()
         fase = DBSession.query(Fase).filter(Fase.id == self.id_fase).one()
         proyecto = fase.proyecto
         f.usuario = usuario
         f.rol = rol
         f.proyecto = proyecto   
         f.fase = fase        
         DBSession.add(f)
     else:
         flash(u"La ficha ya existe", u"error")
     raise redirect('./')

# 需要导入模块: from saip.model import DBSession [as 别名]
# 或者: from saip.model.DBSession import query [as 别名]
 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('./')

# 需要导入模块: from saip.model import DBSession [as 别名]
# 或者: from saip.model.DBSession import query [as 别名]
 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('./')

# 需要导入模块: from saip.model import DBSession [as 别名]
# 或者: from saip.model.DBSession import query [as 别名]
    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/')

# 需要导入模块: from saip.model import DBSession [as 别名]
# 或者: from saip.model.DBSession import query [as 别名]
    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

# 需要导入模块: from saip.model import DBSession [as 别名]
# 或者: from saip.model.DBSession import query [as 别名]
 def importar_fase(self, *args, **kw):
     """ Realiza la importación de una fase de un proyecto a otro.
     """
     id_proyecto = unicode(request.url.split("/")[-8])
     f = Fase()
     id_fase = unicode(request.url.split("/")[-2])
     fase_a_importar = DBSession.query(Fase).filter(Fase.id == id_fase) \
             .one()
     existe_nombre = DBSession.query(Fase).filter(Fase.id_proyecto == \
          id_proyecto).filter(Fase.nombre == fase_a_importar.nombre).count()    
     f.nombre = fase_a_importar.nombre
     if existe_nombre:  
         f.nombre = f.nombre + "'"   
     f.orden = self.obtener_orden(id_proyecto)
     fecha_inicio = datetime.datetime.now()
     f.fecha_inicio = datetime.date(int(fecha_inicio.year), \
                 int(fecha_inicio.month),int(fecha_inicio.day))
     
     f.descripcion = fase_a_importar.descripcion
     f.estado = u'Inicial'
     ids_fases = DBSession.query(Fase.id).filter(Fase.id_proyecto == \
                 id_proyecto).all()
     if ids_fases:        
         proximo_id_fase = proximo_id(ids_fases)
     else:
         proximo_id_fase = "FA1-" + id_proyecto
     f.id = proximo_id_fase
     f.proyecto = DBSession.query(Proyecto).filter(Proyecto.id == \
             id_proyecto).one()        
     DBSession.add(f)
     self.importar_tipo_item(id_fase, f.id)
     flash(u"Se importó de forma exitosa")
     raise redirect('./../../../../..')

# 需要导入模块: from saip.model import DBSession [as 别名]
# 或者: from saip.model.DBSession import query [as 别名]
 def importar_tipo_item(self, id_fase_vieja, id_fase_nueva):
     """ Realiza la importación de un tipo de ítem de una fase a otra.
         @param id_fase_vieja: id de la fase a ser importada.
         @param id_fase_nueva: id de la fase que será creada en
             base a la importada.
         @type id_fase_vieja: unicode
         @type id_fase_nueva: unicode
     """
     
     tipos_item = DBSession.query(TipoItem).filter(TipoItem.id_fase == \
                 id_fase_vieja).all()
     for tipo_item in tipos_item:
         t = TipoItem()
         t.codigo = tipo_item.codigo
         t.nombre = tipo_item.nombre
         t.descripcion = tipo_item.descripcion
         ids_tipos_item = DBSession.query(TipoItem.id) \
                 .filter(TipoItem.id_fase == id_fase_nueva).all()
         if ids_tipos_item:        
             proximo_id_tipo_item = proximo_id(ids_tipos_item)
         else:
             proximo_id_tipo_item = "TI1-" + id_fase_nueva
         t.id = proximo_id_tipo_item
         t.fase = DBSession.query(Fase).filter(Fase.id == id_fase_nueva) \
                 .one()
         DBSession.add(t)
         cont = DBSession.query(Caracteristica) \
                 .filter(Caracteristica.id_tipo_item == t.id).count()
         self.importar_caracteristica(tipo_item.id, t.id)

# 需要导入模块: from saip.model import DBSession [as 别名]
# 或者: from saip.model.DBSession import query [as 别名]
 def importar_tipo_item(self, *args, **kw):
     """
     Importa un tipo de ítem a una fase determinada.
     """
     id_fase = unicode(request.url.split("/")[-10])
     t = TipoItem()
     id_tipo_item = unicode(request.url.split("/")[-2])
     tipo_item_a_importar = DBSession.query(TipoItem) \
             .filter(TipoItem.id == id_tipo_item).one()
     existe_nombre = DBSession.query(TipoItem).filter(TipoItem.id_fase == \
             id_fase).filter(TipoItem.nombre == \
             tipo_item_a_importar.nombre).count()
     existe_codigo = DBSession.query(TipoItem).filter(TipoItem.id_fase == \
             id_fase).filter(TipoItem.codigo == \
             tipo_item_a_importar.codigo).count()    
     t.nombre = tipo_item_a_importar.nombre
     t.codigo = tipo_item_a_importar.codigo
     if existe_nombre:  
         t.nombre = t.nombre + "'"
     if existe_codigo:  
         t.codigo = t.codigo + "'"
     t.descripcion = tipo_item_a_importar.descripcion
     ids_tipos_item = DBSession.query(TipoItem.id) \
             .filter(TipoItem.id_fase == id_fase).all()
     if ids_tipos_item:        
         proximo_id_tipo_item = proximo_id(ids_tipos_item)
     else:
         proximo_id_tipo_item = "TI1-" + id_fase
     t.id = proximo_id_tipo_item
     t.fase = DBSession.query(Fase).filter(Fase.id == id_fase).one()        
     DBSession.add(t)
     self.importar_caracteristica(id_tipo_item, t.id)
     flash("Se importo de forma exitosa")
     raise redirect('./../../../../../../..')

# 需要导入模块: from saip.model import DBSession [as 别名]
# 或者: from saip.model.DBSession import query [as 别名]
    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)

# 需要导入模块: from saip.model import DBSession [as 别名]
# 或者: from saip.model.DBSession import query [as 别名]
    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

# 需要导入模块: from saip.model import DBSession [as 别名]
# 或者: from saip.model.DBSession import query [as 别名]
 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)