def verificaExistencia(self, id_tipo, name):
c1 = DBSession.query(Campo).filter(Campo.id_tipo_item == id_tipo)
c2 = DBSession.query(Campo).filter(Campo.nombre.like(name))
c = c1.intersect(c2)
if c.count() > 0:
return True
return False
def deleteById(self, id):
''' Elimina un Proyecto de la base de datos
@param: id del proyecto'''
roles = DBSession.query(RolUsuario).filter(RolUsuario.id_proyecto==id)
if roles.count()>0:
return False
transaction.begin()
u = self.getById(id)
if u.fases != []:
for i in u.fases:
transaction.begin()
recurso = DBSession.query(Recurso).filter(Recurso.id_fase==i.id_fase).one()
DBSession.delete(recurso)
transaction.commit()
transaction.begin()
fase = DBSession.query(Fase).filter(Fase.id_fase==i.id_fase).one()
DBSession.delete(fase)
transaction.commit()
transaction.begin()
recurso = DBSession.query(Recurso).filter(id == Recurso.id_proyecto).one()
DBSession.delete(recurso)
transaction.commit()
transaction.begin()
u = self.getById(id)
DBSession.delete(u)
transaction.commit()
transaction.commit()
return True
def verificaExistencia(self, id_tipo, name):
c1 = DBSession.query(Campo).filter(Campo.id_tipo_item==id_tipo)
c2 = DBSession.query(Campo).filter(Campo.nombre.like(name))
c = c1.intersect(c2)
if c.count()>0:
return True
return False
def actualizarPrefijosItem(self, id_tipo_item, viejo, nuevo):
'''Actualiza los prefijos de los items al editar el tipo de item
@param id_tipo_item: id del tipo de item
@param viejo: prefijo anterior
@param nuevo:prefijo nuevo
'''
if nuevo == viejo:
return 0;
if nuevo=="":
ti = DBSession.query(TipoItem).filter(TipoItem.id_tipo_item == id_tipo_item).one()
nombre = ti.nombre
n = nombre.split(' ')
nu = "".join(n)
nuevo = nu.upper()[0:3]
ti.prefijo=nuevo
DBSession.merge(ti)
transaction.commit()
transaction.begin()
items = DBSession.query(Item).filter(Item.id_tipo_item==id_tipo_item).all()
for i in items:
cod = i.codigo
lista = cod.split('-')
nro = lista[len(lista)-1]
n = nro.strip(' ')
i.codigo= nuevo + " - " + n
self.update(i)
transaction.commit()
def comprobarUso(self, id_tipo_item):
ti = DBSession.query(TipoItem).filter(TipoItem.id_tipo_item == id_tipo_item).one()
items=DBSession.query(Item).filter(Item.id_tipo_item == ti.id_tipo_item)
if items.count()>0:
print "Existen " + str(items.count()) + " items con este tipo de item"
return False
else:
return True
def getByNombreIdFase(self,nombre, fase):
u = DBSession.query(TipoItem).filter(TipoItem.nombre.like(nombre))
us= DBSession.query(TipoItem).filter(TipoItem.id_fase==fase)
user = us.intersect(u)
if user.count()>0:
return user.one()
else:
return None
def getByNombreIdFase(self, nombre, fase):
u = DBSession.query(TipoItem).filter(TipoItem.nombre.like(nombre))
us = DBSession.query(TipoItem).filter(TipoItem.id_fase == fase)
user = us.intersect(u)
if user.count() > 0:
return user.one()
else:
return None
def verificaExistenciaPut(self, id_fase, name):
print ("Verificando si existe: " + str(id_fase) + " " + name)
c2 = DBSession.query(TipoItem).filter(TipoItem.nombre.like(name))
c1 = DBSession.query(TipoItem).filter(TipoItem.id_fase==id_fase)
c = c2.intersect(c1)
if c.count()>1:
print "Indica que existe"
return True
return False
def verificaExistencia(self, id_fase, name):
print("Verificando si existe: " + str(id_fase) + " " + name)
c2 = DBSession.query(TipoItem).filter(TipoItem.nombre.like(name))
c1 = DBSession.query(TipoItem).filter(TipoItem.id_fase == id_fase)
c = c2.intersect(c1)
if c.count() > 0:
print "Indica que existe"
return True
return False
def generar_codigo(self, idfase, tipo_item):
transaction.begin()
fase = DBSession.query(Fase).filter(Fase.id_fase == idfase).one()
nro = fase.nro_item + 1
fase.nro_item = fase.nro_item +1
DBSession.merge(fase)
transaction.commit()
if tipo_item ==-1:
codigo = "Gen - " + str(nro)
else:
tipo = DBSession.query(TipoItem).filter(TipoItem.id_tipo_item == tipo_item).one()
codigo = tipo.prefijo + " - " + str(nro)
return codigo
def generar_codigo(self, idfase, tipo_item):
transaction.begin()
fase = DBSession.query(Fase).filter(Fase.id_fase == idfase).one()
nro = fase.nro_item + 1
fase.nro_item = fase.nro_item + 1
DBSession.merge(fase)
transaction.commit()
if tipo_item == -1:
codigo = "Gen - " + str(nro)
else:
tipo = DBSession.query(TipoItem).filter(
TipoItem.id_tipo_item == tipo_item).one()
codigo = tipo.prefijo + " - " + str(nro)
return codigo
def buscar(self, buscado, id_fase):
lista = DBSession.query(Item).filter(
Item.identificador.op('~*')(buscado)
& (Item.id_fase == id_fase)
& (Item.actual == 'true')
& (Item.estado != 'eliminado')).all()
return lista
def getByItem(self, id_item):
'''Obtiene las relaciones en las que el item recibido este
@param: id_item perteneciente a una relacion
@return: lista de relaciones en la que aparece el item recibido
'''
lista = DBSession.query(Relacion).filter((Relacion.id_item1 == id_item) | (Relacion.id_item2 == id_item))
return lista
def delete(self,user):
recurso = DBSession.query(Recurso).filter(user.id_fase == Recurso.id_fase)
DBSession.delete(recurso)
transaction.commit()
DBSession.delete(user)
transaction.commit()
def generar_codigo(self):
codigo = DBSession.query(Codigo).filter(Codigo.codigo==0).one()
valor = codigo.valor
codigo.valor +=1
DBSession.merge(codigo)
transaction.commit()
return valor
def getByRolUsuarioProyecto(self, id_rol, id_usuario, id_proyecto):
ru = DBSession.query(RolUsuario).filter(
(RolUsuario.id_rol == id_rol)
& (RolUsuario.id_usuario == id_usuario)
& (RolUsuario.id_proyecto == id_proyecto)).one()
print("Encontrado: " + str(ru.id_proyecto))
return ru
def getAll(self):
"""
Obtiene todos los permisos de la base de datos
@return: Una lista de todos los permisos
"""
all = DBSession.query(Permiso).all()
return all
def getById(self,id1,id2,tipo):
''' Retorna una relacion por su clave primaria
@param: id1, id del item1
@param: id2, id del item2
@param: tipo, tipo de relacion '''
lista = DBSession.query(Relacion).filter((Relacion.id_item1 == id1) & (Relacion.id_item2 == id2) & (Relacion.tipo_relacion == tipo)).one()
return lista
def buscar_por_fase(self, id_fase):
''' Obtiene las relacions de una fase
@param: id_fase
@return: lista de relaciones de la fase'''
lista = DBSession.query(Relacion).filter((Relacion.id_fase1 == id_fase)
|(Relacion.id_fase2 == id_fase)).all()
return lista
def getItemsFaseActualRelacion(self,id_fase, id_item):
lista = DBSession.query(Item).filter((Item.id_fase == id_fase)
& (Item.actual == 'true')
& (Item.estado != 'eliminado')
& (Item.id_item != id_item)).all()
return lista
def prueba(self):
query = DBSession.query(Usuario)
it = query.filter(Usuario.id_usuario == 1 ).one()
res = ""
for r in it.roles :
for p in r.permisos_recursos:
res = res + p.permiso.nombre + " "+str(p.recurso.id_recurso) + " "
return res
def getItemsEliminados(self,id_fase):
'''Obtiene los items eliminados de una fase
@param id_fase: id de la fase a evaluar
@return: lista de items eliminados en la fase
'''
items = DBSession.query(Item).filter((Item.id_fase == id_fase)
&(Item.estado == 'eliminado')).all()
return items
def buscar_por_linea_base(self,id_lb):
'''Obtiene la lista de items pertenecientes a una linea base
@param id_lb: id de la linea base
@return: lista de objetos Item
'''
lista = DBSession.query(Item).filter((Item.actual == 'true')
&(Item.id_linea_base == id_lb)).all()
return lista
def getByNombre(self, loginName):
"""
Obtiene un usuario de la base de datos de acuerdo al nombre
@param loginName: el nombre del usuario que se quiere obtener
@return: El objeto usuario que se busca
"""
user = DBSession.query(Usuario).filter(Usuario.nombre.like(loginName)).one();
return user
def getById(self,id):
"""
Obtiene un permiso de la base de datos de acuerdo al identificador
@param id: el identificador del permiso que se quiere obtener
@return: El objeto permiso que se busca
"""
permiso = DBSession.query(Permiso).filter(Permiso.id_permiso==(id)).one();
return permiso
def getByName(self,name):
"""
Obtiene un permiso de la base de datos de acuerdo al nombre
@param name: el nombre del permiso que se quiere obtener
@return: El objeto permiso que se busca
"""
permiso = DBSession.query(Permiso).filter(Permiso.nombre == name).one();
return permiso
def buscar_por_fase(self, id_fase):
"""
Obtiene las lineas base de una fase dada
@param id_fase: el identificador de la fase de donde se obtendran la lista
@return: Una lista que contiene las lineas base de la fase dada
"""
lista = DBSession.query(LineaBase).filter(LineaBase.fase == id_fase).all()
return lista
def getThisRol(self, id_rol):
rol_usuario = DBSession.query(RolUsuario).filter(RolUsuario.id_rol == id_rol).all()
users = self.getAll()
l = []
for k in rol_usuario:
u = self.getById(k.id_usuario)
l.append(u)
return l
def prueba(self):
query = DBSession.query(Usuario)
it = query.filter(Usuario.id_usuario == 1 ).one()
res = ""
for r in it.roles :
for p in r.permisos_recursos:
res = res + p.permiso.nombre + " "+str(p.recurso.id_recurso) + " "
return res
def getById(self, id):
"""
Obtiene una linea base de la base de datos de acuerdo al identificador
@param id: el identificador de la linea base que se quiere obtener
@return: El objeto linea base que se busca
"""
item = DBSession.query(LineaBase).filter(LineaBase.id_linea_base==id).one()
return item
def getById(self, idUser):
"""
Obtiene un usuario de la base de datos de acuerdo al identificador
@param idUser: el identificador del usuario que se quiere obtener
@return: El objeto usuario que se busca
"""
user = DBSession.query(Usuario).filter(Usuario.id_usuario==(idUser)).one();
return user
def buscar(self,id_fase, buscado):
print "----------BUSQUEDA TIPO ITEM--------------"
thisfase = DBSession.query(TipoItem).filter(TipoItem.id_fase==id_fase)
lista1 = thisfase.filter(TipoItem.nombre.op('~*')(buscado))
lista2 = thisfase.filter(TipoItem.descripcion.op('~*')(buscado))
lista = lista1.union(lista2).all()
print lista
return lista
def deleteById(self, id):
recurso = DBSession.query(Recurso).filter(id == Recurso.id_proyecto).one()
DBSession.delete(recurso)
transaction.commit()
u = self.getById(id)
DBSession.delete(u)
transaction.commit()
def deleteById(self, id):
recurso = DBSession.query(Recurso).filter(id == Recurso.id_proyecto).one()
DBSession.delete(recurso)
transaction.commit()
u = self.getById(id)
DBSession.delete(u)
transaction.commit()
def getByNombre(self, loginName):
''' Obtener un Proyecto por su nombre
@param: Nombre buscado
@return: Registro de proyecto que coincida o None'''
user=None
try:
user = DBSession.query(Proyecto).filter(Proyecto.nombre==loginName).one();
finally:
return user
def buscar(self, buscado):
''' Obtiene una lista de proyectos de acuerdo a un parametro de busqueda
@param: parametro de busqueda'''
parametros = Parser().init(buscado)
lista = []
for buscado in parametros:
list = DBSession.query(Proyecto).filter(Proyecto.nombre.op('~*')(buscado)).all()
lista.extend(list)
return lista
def about(self):
"""Handle the 'about' page."""
query = DBSession.query(Usuario)
rol = query.filter(Usuario.id_usuario == 2).one()
res = ""
for r in rol.permisos:
res = res + r.nombre + "\n"
#return dict(page='index')
return res
def about(self):
"""Handle the 'about' page."""
query = DBSession.query(Usuario)
rol = query.filter(Usuario.id_usuario == 2).one()
res = ""
for r in rol.permisos:
res = res + r.nombre + "\n"
#return dict(page='index')
return res
def generarCodigo(self, id_proyecto):
transaction.begin()
idp = int(id_proyecto)
p = DBSession.query(Proyecto).filter(Proyecto.id_proyecto == idp).one()
nro = p.nro_fase + 1
p.nro_fase = nro
DBSession.merge(p)
transaction.commit()
return nro
def getItemsAprobados(self,id_fase):
'''Obtiene los items en estado aprobado de una fase
@id_fase: id de la fase
'''
items = DBSession.query(Item).filter((Item.id_fase == id_fase)
&(Item.estado == 'aprobado')
&(Item.actual == 'true')
&(Item.id_linea_base == None)).all()
return items
def getProyecto(self, uid):
u = self.getById(uid)
l = []
sistema = False
for i in u.roles:
if i.id_proyecto >=0:
l.append(ProyectoManager().getById(i.id_proyecto))
if i.id_proyecto == -1:
sistema = True
y = DBSession.query(Proyecto).all()
for i in y:
if i.id_administrador == u.id_usuario:
if not(i in l):
l.append(i)
return (l,sistema)
def buscar_por_proyecto(self, buscado):
lista = DBSession.query(Fase).filter(Fase.id_proyecto == buscado).all()
return lista
def buscar(self, buscado, id_proyecto):
lista = DBSession.query(Fase).filter(
Fase.nombre.op('~*')(buscado)
& (Fase.id_proyecto == id_proyecto)).all()
return lista
def test_query_obj(self):
"""Model objects can be queried"""
obj = DBSession.query(self.klass).one()
for key, value in self.attrs.iteritems():
assert_equals(getattr(obj, key), value)
def getAll(self):
user = DBSession.query(Fase).all()
return user
def getByName(self, loginName):
user = DBSession.query(TipoItem).filter(
TipoItem.nombre.like(loginName)).one()
return user
def getAll(self):
user = DBSession.query(TipoItem).all()
return user
def getAll(self):
user = DBSession.query(Proyecto).all()
return user
def getByName(self, name):
rol = DBSession.query(Rol).filter(Rol.nombre.like(name)).one()
return rol
def getById(self, idUser):
user = DBSession.query(TipoItem).filter(
TipoItem.id_tipo_item == (idUser)).one()
return user
def buscar(self, buscado):
lista = DBSession.query(Proyecto).filter(Proyecto.nombre.op('~*')(buscado)).all()
return lista
def delete_recurso(self,user):
recurso = DBSession.query(Recurso).filter(user.id_proyecto == Recurso.id_proyecto)
DBSession.delete(recurso)
transaction.commit()
def getById(self, idUser):
user = DBSession.query(Proyecto).filter(Proyecto.id_proyecto==(idUser)).one();
return user
def getByNombre(self, nombre):
user = DBSession.query(Proyecto).filter(Proyecto.nombre.like(nombre)).one();
return user
def getById(self, idUser):
user = DBSession.query(Fase).filter(Fase.id_fase == (idUser)).one()
return user
def getNotThisFase(self, id_fase):
tipos = DBSession.query(TipoItem).filter(
TipoItem.id_fase != id_fase).all()
return tipos
def buscar(self, buscado):
print "----------BUSQUEDA TIPO ITEM--------------"
lista = DBSession.query(TipoItem).filter(
TipoItem.nombre.op('~*')(buscado)).all()
print lista
return lista
def getById(self, id):
query = DBSession.query(Rol)
rol = query.filter(Rol.id_rol == id).one()
return rol
