Python DBSession.add方法代码示例

# 需要导入模块: from saip.model import DBSession [as 别名]
# 或者: from saip.model.DBSession import add [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 add [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 add [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 add [as 别名]
    def crear_relacion(self, item_1, item_2, nueva_version):
        """
        Crea una relación entre dos ítems.

        @param item_1: Item antecesor/padre de la relación a ser creada.
        @type item_1: L{Item}
        @param item_2: Item sucesor/hijo de la relación a ser creada.
        @type item_2: L{Item}
        @return: True si la relación se creó exitosamente, 
                 False en caso contrario.
        @rtype: Bool
        """
        r = Relacion()
        r.id = "RE-" + item_1.id + "-" + unicode(item_1.version) + "+" + \
                item_2.id + "-" + unicode(item_2.version)
        r.item_1 = item_1
        r.item_2 = item_2
        a = forma_ciclo(r.item_1)
        DBSession.add(r)      
        if a:
            if nueva_version == r.item_1:
                DBSession.delete(r.item_2)
            DBSession.delete(r)
            return False
        else:
            return True        

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

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

# 需要导入模块: from saip.model import DBSession [as 别名]
# 或者: from saip.model.DBSession import add [as 别名]
 def setUp(self):
     """Prepare model test fixture."""
     try:
         new_attrs = {}
         new_attrs.update(self.attrs)
         new_attrs.update(self.do_get_dependencies())
         self.obj = self.klass(**new_attrs)
         DBSession.add(self.obj)
         DBSession.flush()
         return self.obj
     except:
         DBSession.rollback()
         raise

# 需要导入模块: from saip.model import DBSession [as 别名]
# 或者: from saip.model.DBSession import add [as 别名]
 def post(self, **kw):
     """ Registra el nuevo rol creado. """
     r = Rol()
     r.nombre = kw['nombre']
     r.descripcion = kw['descripcion']
     r.tipo = kw['tipo']
     ids_roles = DBSession.query(Rol.id).all()
     if ids_roles:        
         proximo_id_rol = proximo_id(ids_roles)
     else:
         proximo_id_rol = "RL1"
     r.id = proximo_id_rol
     DBSession.add(r)
     raise redirect('./')

# 需要导入模块: from saip.model import DBSession [as 别名]
# 或者: from saip.model.DBSession import add [as 别名]
 def crear_revision(self, item, msg):
     """ Crea una revisión cuando al borrar una relación un ítem queda
         huérfano, se le genera una revisión al mismo.
     """
     rv = Revision()
     ids_revisiones = DBSession.query(Revision.id) \
                     .filter(Revision.id_item == item.id).all()
     if ids_revisiones:
         proximo_id_revision = proximo_id(ids_revisiones)
     else:
         proximo_id_revision = "RV1-" + item.id
     rv.id = proximo_id_revision
     rv.item = item
     rv.descripcion = msg
     DBSession.add(rv)       

# 需要导入模块: from saip.model import DBSession [as 别名]
# 或者: from saip.model.DBSession import add [as 别名]
 def post(self, **kw):
     """ Registra el nuevo tipo de ítem creado. """
     t = TipoItem()
     t.descripcion = kw['descripcion']
     t.nombre = kw['nombre']
     t.codigo = kw['codigo'].upper()
     ids_tipos_item = DBSession.query(TipoItem.id).filter(TipoItem.id_fase \
                     == self.id_fase).all()
     if ids_tipos_item:        
         proximo_id_tipo_item = proximo_id(ids_tipos_item)
     else:
         proximo_id_tipo_item = "TI1-" + self.id_fase
     t.id = proximo_id_tipo_item
     t.fase = DBSession.query(Fase).filter(Fase.id == self.id_fase).one()        
     DBSession.add(t)
     raise redirect('./')

# 需要导入模块: from saip.model import DBSession [as 别名]
# 或者: from saip.model.DBSession import add [as 别名]
 def post(self, **kw):
     c = Caracteristica()
     c.descripcion = kw['descripcion']
     c.nombre = kw['nombre']
     c.tipo = kw['tipo']
     ids_caracteristicas = DBSession.query(Caracteristica.id).filter( \
                 Caracteristica.id_tipo_item == self.id_tipo_item).all()
     if ids_caracteristicas:        
         proximo_id_caracteristica = proximo_id(ids_caracteristicas)
     else:
         proximo_id_caracteristica = "CA1-" + self.id_tipo_item
     c.id = proximo_id_caracteristica
     c.tipo_item = DBSession.query(TipoItem).filter(TipoItem.id == \
             self.id_tipo_item).one()        
     DBSession.add(c)
     self.set_null(c)
     raise redirect('./')