def estado(self, obj, **kw):
id_item = UrlParser.parse_id(request.url, "items")
id_version = UrlParser.parse_id(request.url, "versiones")
if not id_version:
item = Item.por_id(id_item)
rti = DBSession.query(RelacionPorItem).\
filter(and_(RelacionPorItem.id_propiedad_item\
== item.id_propiedad_item,\
RelacionPorItem.id_relacion == obj.id_relacion))\
.first()
else:
p_item = PropiedadItem.por_id(id_version)
rti = DBSession.query(RelacionPorItem).\
filter(and_(RelacionPorItem.id_propiedad_item\
== p_item.id_propiedad_item,\
RelacionPorItem.id_relacion == obj.id_relacion))\
.first()
color = u"inherit;"
estado = u"No"
if(rti.revisar):
color = u"#ff0000;"
estado = u'Sí'
value = '<div style="color:' + color + '">' + estado + '</div>'
return value
def nuevo_rol_desde_plantilla(cls, plantilla=None, id_plantilla=None, id=None):
"""
Crea un rol a partir de una plantilla
@param plantilla: rol del tipo plantilla.
@param id_plantilla: id del rol del tipo plantilla.
@param id: identificador con el qué asociar al rol.
"""
base_query = DBSession.query(Rol)
if (id_plantilla):
plantilla = base_query.filter(Rol.id_rol == int(id_plantilla)).first()
rol = Rol()
rol.nombre_rol = plantilla.nombre_rol
rol.descripcion = plantilla.descripcion
if (plantilla.tipo == u"Plantilla proyecto"):
rol.tipo = u"Proyecto"
rol.id_proyecto = id
elif (plantilla.tipo == u"Plantilla fase"):
rol.tipo = u"Fase"
rol.id_fase = id
elif (plantilla.tipo == u"Plantilla tipo ítem"):
rol.tipo = u"Tipo de Ítem"
rol.id_tipo_item = id
for perm in plantilla.permisos:
perm.roles.append(rol)
DBSession.add(rol)
DBSession.flush()
rol.codigo = Rol.generar_codigo(rol)
return rol
def desasignar_roles(self, *args, **kw):
""" Desasigna los roles seleccionados a un usuario """
if kw:
pks = []
for k, pk in kw.items():
if not k.isalnum():
continue
pks.append(int(pk))
transaction.begin()
id_user = UrlParser.parse_id(request.url, "miembrosfase")
user = Usuario.por_id(id_user)
c = 0
while c < len(user.roles):
r = user.roles[c]
if r.id_rol in pks:
if r.nombre_rol == "Miembro de Fase":
msg = "No puedes eliminar el rol {nr}. Si deseas "
msg += "que el usuario deje de ser miembro, debes "
msg += "hacerlo en la pagina de Miembros de la Fase."
flash(msg.format(nr=r.nombre_rol), "warning")
DBSession.rollback()
return "./"
del user.roles[c]
else:
c += 1
transaction.commit()
flash("Roles Desasignados correctamente")
else:
flash("Seleccione por lo menos un rol", "warning")
return "./"
def post_delete(self, *args, **kw):
"""This is the code that actually deletes the record"""
atras = './'
id_tipo = int(args[0])
tipo = TipoItem.por_id(id_tipo)
DBSession.delete(tipo)
redirect(atras)
def desasignar_roles(self, *args, **kw):
""" Desasigna los roles seleccionados a un usuario """
if kw:
pks = []
for k, pk in kw.items():
if not k.isalnum():
continue
pks.append(int(pk))
transaction.begin()
id_user = UrlParser.parse_id(request.url, "miembrosfase")
user = Usuario.por_id(id_user)
c = 0
while c < len(user.roles):
r = user.roles[c]
if r.id_rol in pks:
if r.nombre_rol == "Miembro de Fase":
msg = "No puedes eliminar el rol {nr}. Si deseas "
msg += "que el usuario deje de ser miembro, debes "
msg += "hacerlo en la pagina de Miembros de la Fase."
flash(msg.format(nr=r.nombre_rol), "warning")
DBSession.rollback()
return "./"
del user.roles[c]
else:
c += 1
transaction.commit()
flash("Roles Desasignados correctamente")
else:
flash("Seleccione por lo menos un rol", "warning")
return "./"
def estado(self, obj, **kw):
id_item = UrlParser.parse_id(request.url, "items")
id_version = UrlParser.parse_id(request.url, "versiones")
if not id_version:
item = Item.por_id(id_item)
rti = DBSession.query(RelacionPorItem).\
filter(and_(RelacionPorItem.id_propiedad_item\
== item.id_propiedad_item,\
RelacionPorItem.id_relacion == obj.id_relacion))\
.first()
else:
p_item = PropiedadItem.por_id(id_version)
rti = DBSession.query(RelacionPorItem).\
filter(and_(RelacionPorItem.id_propiedad_item\
== p_item.id_propiedad_item,\
RelacionPorItem.id_relacion == obj.id_relacion))\
.first()
color = u"inherit;"
estado = u"No"
if (rti.revisar):
color = u"#ff0000;"
estado = u'Sí'
value = '<div style="color:' + color + '">' + estado + '</div>'
return value
def post_delete(self, *args, **kw):
"""This is the code that actually deletes the record"""
id_atributo = int(args[0])
transaction.begin()
attr = AtributosPorTipoItem.por_id(id_atributo)
DBSession.delete(attr)
transaction.commit()
flash("Atributo Eliminado")
redirect("./")
def post_delete(self, *args, **kw):
"""This is the code that actually deletes the record"""
id_atributo = int(args[0])
transaction.begin()
attr = AtributosPorTipoItem.por_id(id_atributo)
DBSession.delete(attr)
transaction.commit()
flash("Atributo Eliminado")
redirect("./")
def post(self, *args, **kw):
if "sprox_id" in kw:
del kw["sprox_id"]
if "repita_password" in kw:
del kw["repita_password"]
if kw["nro_documento"]:
kw["nro_documento"] = int(kw["nro_documento"])
usuario = Usuario(**kw)
DBSession.add(usuario)
redirect("./")
def post_delete(self, id_proyecto):
proy = Proyecto.por_id(int(id_proyecto))
p_items = DBSession.query(PropiedadItem).filter(and_(PropiedadItem.id_item_actual ==\
Item.id_item, Item.id_fase == \
Fase.id_fase, Fase.id_proyecto ==
id_proyecto)).all()
for pi in p_items:
DBSession.delete(pi)
DBSession.delete(proy)
flash("Proyecto Eliminado")
redirect("/proyectos/")
def post_delete(self, id_proyecto):
proy = Proyecto.por_id(int(id_proyecto))
p_items = DBSession.query(PropiedadItem).filter(and_(PropiedadItem.id_item_actual ==\
Item.id_item, Item.id_fase == \
Fase.id_fase, Fase.id_proyecto ==
id_proyecto)).all()
for pi in p_items:
DBSession.delete(pi)
DBSession.delete(proy)
flash("Proyecto Eliminado")
redirect("/proyectos/")
def remover_seleccionados(self, *args, **kw):
"""
Desasigna miembros de la fase.
"""
id_fase = UrlParser.parse_id(request.url, "fases")
if kw:
pks = []
for k, pk in kw.items():
if not k.isalnum():
continue
pks.append(int(pk))
transaction.begin()
usuarios = DBSession.query(Usuario) \
.filter(Usuario.id_usuario.in_(pks)).all()
fase = Fase.por_id(id_fase)
nr = u"Lider de Proyecto"
rlp = DBSession.query(Rol) \
.filter(and_(Rol.tipo == u"Proyecto",
Rol.id_proyecto == fase.id_proyecto,
Rol.nombre_rol == nr)).first()
warning = False
for u in usuarios:
if rlp in u.roles and len(rlp.usuarios) == 1:
msg = "No puedes eliminar al usuario {nu} porque "
msg += "es el {nr}"
flash(msg.format(nu=u.nombre_usuario,
nr=nr), "warning")
warning = True
continue
c = 0
while c < len(u.roles):
if u.roles[c].id_fase == id_fase and \
u.roles[c].tipo == u"Fase":
del u.roles[c]
else:
c += 1
transaction.commit()
if not warning:
flash("Usuarios removidos correctamente")
else:
flash("Seleccione por lo menos un usuario", "warning")
return "../"
def _my_update_params(self, d, nullable=False):
options = []
options.append((None, '-----------------'))
#Solo tipos de otros proyectos
id_proyecto = UrlParser.parse_id(request.url, "proyectos")
id_fase = UrlParser.parse_id(request.url, "fases")
if not id_proyecto:
id_proyecto = UrlParser.parse_id(request.url, "proyectos_fase")
if not id_proyecto:
id_proyecto = UrlParser.parse_id(request.url, "proyectos_fase_ti")
id_fase = UrlParser.parse_id(request.url, "fases_ti")
if (self.accion == "new"):
#de otros proyectos.
if id_proyecto:
tipos_items = DBSession.query(TipoItem) \
.filter(TipoItem.id_proyecto != id_proyecto) \
.all()
for ti in tipos_items:
options.append((ti.id_tipo_item, '%s (%s)' % (ti.nombre,
ti.codigo)))
#importa de otras fases tambien
if id_fase:
fase = Fase.por_id(id_fase)
id_proyecto = fase.id_proyecto
tipos_items_fase = DBSession.query(TipoItem) \
.filter(and_(TipoItem.id_proyecto == id_proyecto,
TipoItem.id_fase != id_fase)) \
.all()
'''
tipos_items_fase = DBSession.query(TipoItem) \
.filter(or_(TipoItem.id_proyecto != id_proyecto,
and_(TipoItem.id_proyecto == id_proyecto,
TipoItem.id_fase != id_fase))) \
.all()
'''
for ti in tipos_items_fase:
#solo si posee algun permiso sobre el tipo de item
#if (AlgunPermiso(tipo="Tipo", id_tipo_item=ti.id_tipo_item)):
options.append((ti.id_tipo_item, '%s (%s)' % (ti.nombre,
ti.codigo)))
d['options'] = options
return d
def remover_seleccionados(self, *args, **kw):
"""
Desasigna miembros de la fase.
"""
id_fase = UrlParser.parse_id(request.url, "fases")
if kw:
pks = []
for k, pk in kw.items():
if not k.isalnum():
continue
pks.append(int(pk))
transaction.begin()
usuarios = DBSession.query(Usuario) \
.filter(Usuario.id_usuario.in_(pks)).all()
fase = Fase.por_id(id_fase)
nr = u"Lider de Proyecto"
rlp = DBSession.query(Rol) \
.filter(and_(Rol.tipo == u"Proyecto",
Rol.id_proyecto == fase.id_proyecto,
Rol.nombre_rol == nr)).first()
warning = False
for u in usuarios:
if rlp in u.roles and len(rlp.usuarios) == 1:
msg = "No puedes eliminar al usuario {nu} porque "
msg += "es el {nr}"
flash(msg.format(nu=u.nombre_usuario, nr=nr), "warning")
warning = True
continue
c = 0
while c < len(u.roles):
if u.roles[c].id_fase == id_fase and \
u.roles[c].tipo == u"Fase":
del u.roles[c]
else:
c += 1
transaction.commit()
if not warning:
flash("Usuarios removidos correctamente")
else:
flash("Seleccione por lo menos un usuario", "warning")
return "../"
def post(self, *args, **kw):
if "sprox_id" in kw:
del kw["sprox_id"]
proy = Proyecto(**kw)
DBSession.add(proy)
DBSession.flush()
proy.codigo = Proyecto.generar_codigo(proy)
#Creamos el rol miembro y lider de proyecto para este proyecto.
plant_l = Rol.obtener_rol_plantilla(nombre_rol=u"Lider de Proyecto")
rol_l = Rol.nuevo_rol_desde_plantilla(plantilla=plant_l, id=proy.id_proyecto)
flash("Se ha creado un nuevo proyecto")
redirect("/proyectos/")
def asignar_roles(self, *args, **kw):
""" Asigna los roles seleccionados a un usuario """
if kw:
pks = []
for k, pk in kw.items():
if not k.isalnum():
continue
pks.append(int(pk))
transaction.begin()
id_user = UrlParser.parse_id(request.url, "miembros")
id_proyecto = UrlParser.parse_id(request.url, "proyectos")
user = Usuario.por_id(id_user)
roles = DBSession.query(Rol).filter(Rol.id_rol.in_(pks)).all()
for r in roles:
if r.tipo.find(
u"Plantilla") >= 0: #crear rol a partir de plantilla
rol_new = Rol.nuevo_rol_desde_plantilla(plantilla=r,
id=id_proyecto)
rol_new.usuarios.append(user)
else:
r.usuarios.append(user)
transaction.commit()
flash("Roles Asignados correctamente")
else:
flash("Seleccione por lo menos un rol", "warning")
return "./"
def _do_get_provider_count_and_objs(self, usuario=None, asignados=True,
id_proyecto=None, **kw):
count, lista = super(MiembrosProyectoRolesTableFiller,
self)._do_get_provider_count_and_objs(**kw)
roles = []
if not asignados:
roles_proy = DBSession.query(Rol) \
.filter(or_(and_(Rol.tipo == ("Proyecto"),
Rol.id_proyecto == id_proyecto),
and_(Rol.tipo == "Plantilla proyecto",
Rol.nombre_rol != u"Miembro de Proyecto",
Rol.nombre_rol != u"Lider de Proyecto")
)).all()
for r in roles_proy:
if r not in usuario.roles:
roles.append(r)
else:
if id_proyecto:
for r in usuario.roles:
if r.tipo == "Proyecto" and r.id_proyecto == id_proyecto:
roles.append(r)
return len(roles), roles
def _do_get_provider_count_and_objs(self,
usuario=None,
asignados=True,
id_tipo_item=None,
**kw):
count, lista = super(MiembrosTipoRolesTableFiller,
self)._do_get_provider_count_and_objs(**kw)
roles = []
if not asignados:
roles_tipo = DBSession.query(Rol) \
.filter(or_(and_(Rol.tipo.like(u"Tipo%"),
Rol.id_tipo_item == id_tipo_item),
and_(Rol.tipo.like(u"Plantilla tipo ítem"))
)).all()
for r in roles_tipo:
if r not in usuario.roles:
roles.append(r)
else:
if id_tipo_item:
for r in usuario.roles:
if r.tipo.find(
u"Tipo") >= 0 and r.id_tipo_item == id_tipo_item:
roles.append(r)
return len(roles), roles
def post(self, *args, **kw):
if "sprox_id" in kw:
del kw["sprox_id"]
proy = Proyecto(**kw)
DBSession.add(proy)
DBSession.flush()
proy.codigo = Proyecto.generar_codigo(proy)
#Creamos el rol miembro y lider de proyecto para este proyecto.
plant_l = Rol.obtener_rol_plantilla(nombre_rol=u"Lider de Proyecto")
rol_l = Rol.nuevo_rol_desde_plantilla(plantilla=plant_l,
id=proy.id_proyecto)
flash("Se ha creado un nuevo proyecto")
redirect("/proyectos/")
def asignar_roles(self, *args, **kw):
""" Asigna los roles seleccionados a un usuario """
if kw:
pks = []
for k, pk in kw.items():
if not k.isalnum():
continue
pks.append(int(pk))
transaction.begin()
id_user = UrlParser.parse_id(request.url, "nomiembros")
id_proyecto = UrlParser.parse_id(request.url, "proyectos")
user = Usuario.por_id(id_user)
roles = DBSession.query(Rol).filter(Rol.id_rol.in_(pks)).all()
for r in roles:
if r.tipo.find(u"Plantilla") >= 0: #crear rol a partir de plantilla
rol_new = Rol.nuevo_rol_desde_plantilla(plantilla=r,
id=id_proyecto)
rol_new.usuarios.append(user)
else:
r.usuarios.append(user)
transaction.commit()
flash("Roles Asignados correctamente")
else:
flash("Seleccione por lo menos un rol", "warning")
return "./"
def _do_get_provider_count_and_objs(self,
usuario=None,
asignados=True,
id_fase=None,
**kw):
count, lista = super(MiembrosFaseRolesTableFiller,
self)._do_get_provider_count_and_objs(**kw)
roles = []
if not asignados:
roles_fase = DBSession.query(Rol) \
.filter(or_(and_(Rol.tipo == u"Fase",
Rol.id_fase == id_fase),
and_(Rol.tipo == u"Plantilla fase")
)).all()
for r in roles_fase:
if r not in usuario.roles:
roles.append(r)
else:
if id_fase:
for r in usuario.roles:
if r.tipo == "Fase" and r.id_fase == id_fase:
roles.append(r)
return len(roles), roles
def _do_get_provider_count_and_objs(self,
usuario=None,
asignados=True,
id_proyecto=None,
**kw):
count, lista = super(MiembrosProyectoRolesTableFiller,
self)._do_get_provider_count_and_objs(**kw)
roles = []
if not asignados:
roles_proy = DBSession.query(Rol) \
.filter(or_(and_(Rol.tipo == ("Proyecto"),
Rol.id_proyecto == id_proyecto),
and_(Rol.tipo == "Plantilla proyecto",
Rol.nombre_rol != u"Miembro de Proyecto",
Rol.nombre_rol != u"Lider de Proyecto")
)).all()
for r in roles_proy:
if r not in usuario.roles:
roles.append(r)
else:
if id_proyecto:
for r in usuario.roles:
if r.tipo == "Proyecto" and r.id_proyecto == id_proyecto:
roles.append(r)
return len(roles), roles
def _my_update_params(self, d, nullable=False):
options = []
options.append((0, "----------"))
proyectos = DBSession.query(Proyecto).all()
for p in proyectos:
options.append((p.id_proyecto, '%s (%s)' % (p.codigo, p.nombre)))
d['options'] = options
return d
def _my_update_params(self, d, nullable=False):
options = []
options.append((0, "----------"))
tipos = DBSession.query(TipoItem).all()
for t in tipos:
options.append((t.id_tipo_item, '%s' % t.codigo))
d['options'] = options
return d
def _my_update_params(self, d, nullable=False):
options = []
options.append((0, "----------"))
tipos = DBSession.query(TipoItem).all()
for t in tipos:
options.append((t.id_tipo_item, '%s' % t.codigo))
d['options'] = options
return d
def _my_update_params(self, d, nullable=False):
options = []
options.append((0, "----------"))
fases = DBSession.query(Fase).all()
for f in fases:
options.append((f.id_fase, '%s (%s)' % (f.codigo, f.nombre)))
d['options'] = options
return d
def _my_update_params(self, d, nullable=False):
options = []
options.append((0, "----------"))
proyectos = DBSession.query(Proyecto).all()
for p in proyectos:
options.append((p.id_proyecto, '%s (%s)' % (p.codigo,
p.nombre)))
d['options'] = options
return d
def _my_update_params(self, d, nullable=False):
options = []
options.append((0, "----------"))
fases = DBSession.query(Fase).all()
for f in fases:
options.append((f.id_fase, '%s (%s)' % (f.codigo,
f.nombre)))
d['options'] = options
return d
def por_nombre_permiso(cls, np):
"""
Método de clase que realiza las búsquedas por nombre de permiso.
@param np: nombre del permiso
@type np: C{unicode}
@return: el elemento recuperado
@rtype: L{Permiso}
"""
return DBSession.query(Permiso).filter_by(nombre_permiso=np).one()
def por_id(cls, id):
"""
Método de clase que realiza las búsquedas por identificador.
@param id: identificador del elemento a recuperar
@type id: C{Integer}
@return: el elemento recuperado
@rtype: L{Permiso}
"""
return DBSession.query(cls).filter_by(id_permiso=id).one()
def por_nombre_permiso(cls, np):
"""
Método de clase que realiza las búsquedas por nombre de permiso.
@param np: nombre del permiso
@type np: C{unicode}
@return: el elemento recuperado
@rtype: L{Permiso}
"""
return DBSession.query(Permiso).filter_by(nombre_permiso=np).one()
def por_id(cls, id):
"""
Método de clase que realiza las búsquedas por identificador.
@param id: identificador del elemento a recuperar
@type id: C{Integer}
@return: el elemento recuperado
@rtype: L{Permiso}
"""
return DBSession.query(cls).filter_by(id_permiso=id).one()
def _my_update_params(self, d, nullable=False):
options = []
pks = []
for i, v in enumerate(d["value"]):
pks.append(int(v))
permisos = DBSession.query(Permiso) \
.filter(Permiso.id_permiso.in_(pks)).all()
for p in permisos:
options.append((p.id_permiso, '%s' % p.nombre_permiso))
d['options'] = options
return d
def _my_update_params(self, d, nullable=False):
options = []
pks = []
for i, v in enumerate(d["value"]):
pks.append(int(v))
permisos = DBSession.query(Permiso) \
.filter(Permiso.id_permiso.in_(pks)).all()
for p in permisos:
options.append((p.id_permiso, '%s' % p.nombre_permiso))
d['options'] = options
return d
def enviar_pass(self, **kw):
"""Recupera el pass enviado por mail uno nuevo."""
usernamegiven = kw["loginusernamegiven"]
user = Usuario.by_user_name(usernamegiven)
if user != None:
smtp_gmail = Gmail()
mail = user.email #DEBUG: u"*****@*****.**"
hash = hashlib.new('ripemd160')
hash.update(user.email + unicode(random.random()))
new_pass = hash.hexdigest()[0:15]
user._set_password(new_pass)
DBSession.add(user)
text = _(u"Tu nueva contraseña es : %s") % new_pass
smtp_gmail.enviar_mail(mail, text)
smtp_gmail.quit()
flash(_(u'Nueva contraseña enviada a %s') % mail)
redirect(url('/login'))
else:
flash(_(u'No existe Usuario'))
redirect(url('/recuperar_pass'))
def _do_get_provider_count_and_objs(self, id_item=None, tipo=None, **kw):
"""
Recupera los ítems para los cuales tenemos algún permiso. y está o no
relacionado al campo relacionado.
Si el usuario se encuentra en una fase, retorna solo
los ítems que pertenecen a dicha fase.
"""
#count, lista = super(ItemTableFiller, self).\
# _do_get_provider_count_and_objs(**kw)
filtrados = []
if id_item:
item = Item.por_id(int(id_item))
if (tipo == 'P-H'):
items_fase_actual = DBSession.query(Item)\
.filter(and_(Item.id_propiedad_item == PropiedadItem.id_propiedad_item,\
Item.id_item != item.id_item, Item.id_fase == item.id_fase,
PropiedadItem.estado != u"Eliminado"))\
.all()
for it in items_fase_actual:
if (not it.esta_relacionado(id_item)):
filtrados.append(it)
if (tipo == 'A-S'):
fase = Fase.por_id(item.id_fase)
items_fase_anterior = DBSession.query(Item)\
.filter(and_(Item.id_propiedad_item == PropiedadItem.id_propiedad_item,\
Item.id_fase == Fase.id_fase, Fase.id_proyecto == fase.id_proyecto, PropiedadItem.estado == u"Bloqueado", \
Fase.posicion == fase.posicion - 1, fase.posicion != 1))\
.all()
for it in items_fase_anterior:
if (not it.esta_relacionado(id_item)):
filtrados.append(it)
return len(filtrados), filtrados
def _do_get_provider_count_and_objs(self, id_fase=None, items=None, **kw):
"""
Recupera los items aprobados de la fase en cuestión
"""
if items or items == []:
return len(items), items
id_fase = int(id_fase) #falta probar.
query = DBSession.query(Item).join(PropiedadItem) \
.filter(and_(Item.id_propiedad_item == \
PropiedadItem.id_propiedad_item,
and_(Item.id_fase == id_fase,
PropiedadItem.estado == u"Aprobado")))
return query.count(), query.all()
def nuevo_rol_desde_plantilla(cls,
plantilla=None,
id_plantilla=None,
id=None):
"""
Crea un rol a partir de una plantilla
@param plantilla: rol del tipo plantilla.
@param id_plantilla: id del rol del tipo plantilla.
@param id: identificador con el qué asociar al rol.
"""
base_query = DBSession.query(Rol)
if (id_plantilla):
plantilla = base_query.filter(
Rol.id_rol == int(id_plantilla)).first()
rol = Rol()
rol.nombre_rol = plantilla.nombre_rol
rol.descripcion = plantilla.descripcion
if (plantilla.tipo == u"Plantilla proyecto"):
rol.tipo = u"Proyecto"
rol.id_proyecto = id
elif (plantilla.tipo == u"Plantilla fase"):
rol.tipo = u"Fase"
rol.id_fase = id
elif (plantilla.tipo == u"Plantilla tipo ítem"):
rol.tipo = u"Tipo de Ítem"
rol.id_tipo_item = id
for perm in plantilla.permisos:
perm.roles.append(rol)
DBSession.add(rol)
DBSession.flush()
rol.codigo = Rol.generar_codigo(rol)
return rol
def crear_rol(cls, **kw):
""" Crea un nuevo rol """
if "sprox_id" in kw:
del kw["sprox_id"]
if "permisos_src" in kw: #campo que genera dojo
del kw["permisos_src"]
pks = kw["permisos"]
del kw["permisos"]
for k in ["id_proyecto", "id_fase", "id_tipo_item"]:
if kw.has_key(k):
if kw[k]:
kw[k] = int(kw[k])
else:
del kw[k]
rol_new = Rol(**kw)
if type(pks).__name__ == 'list':
for i, pk in enumerate(pks):
pks[i] = int(pk)
else:
pks = [int(pks)]
permisos = DBSession.query(Permiso).filter( \
Permiso.id_permiso.in_(pks)).all()
if not permisos:
return None
for p in permisos:
p.roles.append(rol_new)
DBSession.flush()
rol_new.codigo = Rol.generar_codigo(rol_new)
DBSession.add(rol_new)
return rol_new
def crear_rol(cls, **kw):
""" Crea un nuevo rol """
if "sprox_id" in kw:
del kw["sprox_id"]
if "permisos_src" in kw: #campo que genera dojo
del kw["permisos_src"]
pks = kw["permisos"]
del kw["permisos"]
for k in ["id_proyecto", "id_fase", "id_tipo_item"]:
if kw.has_key(k):
if kw[k]:
kw[k] = int(kw[k])
else:
del kw[k]
rol_new = Rol(**kw)
if type(pks).__name__ == 'list':
for i, pk in enumerate(pks):
pks[i] = int(pk)
else:
pks = [int(pks)]
permisos = DBSession.query(Permiso).filter( \
Permiso.id_permiso.in_(pks)).all()
if not permisos:
return None
for p in permisos:
p.roles.append(rol_new)
DBSession.flush()
rol_new.codigo = Rol.generar_codigo(rol_new)
DBSession.add(rol_new)
return rol_new
def obtener_rol_plantilla(cls, **kw):
"""
Obtiene un rol utilizado como plantilla, para la creación de
otros roles
@param kw: posee el identificador o el nombre del rol.
"""
base_query = DBSession.query(Rol)
if "id" in kw:
rol = base_query.filter(and_(Rol.id_rol == int(kw["id"]),
Rol.tipo.like(u"Plantilla%"))).first()
elif "nombre_rol" in kw:
rol = base_query.filter(and_(
Rol.nombre_rol == unicode(kw["nombre_rol"]),
Rol.tipo.like(u"Plantilla%"))).first()
return rol
def actualizar_rol(cls, **kw):
"""Actualiza un rol"""
if "sprox_id" in kw:
del kw["sprox_id"]
if "permisos_src" in kw: #campo que genera dojo
del kw["permisos_src"]
pks = kw["permisos"]
if type(pks).__name__ == 'list':
for i, pk in enumerate(pks):
pks[i] = int(pk)
else:
pks = [int(pks)]
del kw["permisos"]
for k in ["id_proyecto", "id_fase", "id_tipo_item"]:
if kw.has_key(k):
if kw[k]:
kw[k] = int(kw[k])
else:
del kw[k]
rol_mod = Rol.por_id(kw['id_rol'])
for k in [
"id_proyecto", "id_fase", "id_tipo_item", "nombre_rol",
"descripcion"
]:
if kw.has_key(k):
setattr(rol_mod, k, kw[k])
c = 0
while c < len(rol_mod.permisos):
p = rol_mod.permisos[c]
if p.id_permiso not in pks:
del rol_mod.permisos[c]
else:
c += 1
if pks:
permisos = DBSession.query(Permiso).filter( \
Permiso.id_permiso.in_(pks)).all()
if not permisos:
return None
for p in permisos:
if p not in rol_mod.permisos:
p.roles.append(rol_mod)
return rol_mod
def obtener_rol_plantilla(cls, **kw):
"""
Obtiene un rol utilizado como plantilla, para la creación de
otros roles
@param kw: posee el identificador o el nombre del rol.
"""
base_query = DBSession.query(Rol)
if "id" in kw:
rol = base_query.filter(
and_(Rol.id_rol == int(kw["id"]),
Rol.tipo.like(u"Plantilla%"))).first()
elif "nombre_rol" in kw:
rol = base_query.filter(
and_(Rol.nombre_rol == unicode(kw["nombre_rol"]),
Rol.tipo.like(u"Plantilla%"))).first()
return rol
def asignar_roles(self, *args, **kw):
""" Asigna los roles seleccionados a un usuario """
if kw:
pks = []
for k, pk in kw.items():
if not k.isalnum():
continue
pks.append(int(pk))
transaction.begin()
id_user = UrlParser.parse_id(request.url, "usuarios")
user = Usuario.por_id(id_user)
roles = DBSession.query(Rol).filter(Rol.id_rol.in_(pks)).all()
for r in roles:
r.usuarios.append(user)
transaction.commit()
flash("Roles Asignados correctamente")
return "./"
def actualizar_rol(cls, **kw):
"""Actualiza un rol"""
if "sprox_id" in kw:
del kw["sprox_id"]
if "permisos_src" in kw: #campo que genera dojo
del kw["permisos_src"]
pks = kw["permisos"]
if type(pks).__name__ == 'list':
for i, pk in enumerate(pks):
pks[i] = int(pk)
else:
pks = [int(pks)]
del kw["permisos"]
for k in ["id_proyecto", "id_fase", "id_tipo_item"]:
if kw.has_key(k):
if kw[k]:
kw[k] = int(kw[k])
else:
del kw[k]
rol_mod = Rol.por_id(kw['id_rol'])
for k in ["id_proyecto", "id_fase", "id_tipo_item", "nombre_rol",
"descripcion"]:
if kw.has_key(k):
setattr(rol_mod, k, kw[k])
c = 0
while c < len(rol_mod.permisos):
p = rol_mod.permisos[c]
if p.id_permiso not in pks:
del rol_mod.permisos[c]
else:
c += 1
if pks:
permisos = DBSession.query(Permiso).filter( \
Permiso.id_permiso.in_(pks)).all()
if not permisos:
return None
for p in permisos:
if p not in rol_mod.permisos:
p.roles.append(rol_mod)
return rol_mod
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
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
def roles_desasignados(cls,
usuario,
id_proyecto=None,
id_fase=None,
id_tipo_item=None):
"""
Obtiene los roles que no están asignados al usuario
@param usuario: identificador del usuario para ver cuales roles no
tiene asignado.
"""
roles = DBSession.query(cls).all()
id_u = int(usuario)
desasignados = []
#falta discrimininar el tipo
for r in roles:
if id_proyecto:
if r.tipo != u"Plantilla proyecto" and \
r.id_proyecto != id_proyecto:
continue
elif id_fase:
if r.tipo != u"Plantilla fase" and \
r.id_fase != id_fase:
continue
elif id_tipo_item:
if r.tipo != u"Plantilla tipo ítem" and \
r.id_tipo_item != id_tipo_item:
continue
elif (r.tipo.find(u"Plantilla") >= 0):
continue
esta = False
for u in r.usuarios:
if (u.id_usuario == id_u):
esta = True
break
if (not esta):
desasignados.append(r)
return desasignados
def _do_get_provider_count_and_objs(self, usuario=None, asignados=True,
id_fase=None, **kw):
count, lista = super(MiembrosFaseRolesTableFiller,
self)._do_get_provider_count_and_objs(**kw)
roles = []
if not asignados:
roles_fase = DBSession.query(Rol) \
.filter(or_(and_(Rol.tipo == u"Fase",
Rol.id_fase == id_fase),
and_(Rol.tipo == u"Plantilla fase")
)).all()
for r in roles_fase:
if r not in usuario.roles:
roles.append(r)
else:
if id_fase:
for r in usuario.roles:
if r.tipo == "Fase" and r.id_fase == id_fase:
roles.append(r)
return len(roles), roles
def roles_desasignados(cls, usuario, id_proyecto=None,
id_fase=None, id_tipo_item=None):
"""
Obtiene los roles que no están asignados al usuario
@param usuario: identificador del usuario para ver cuales roles no
tiene asignado.
"""
roles = DBSession.query(cls).all()
id_u = int(usuario)
desasignados = []
#falta discrimininar el tipo
for r in roles:
if id_proyecto:
if r.tipo != u"Plantilla proyecto" and \
r.id_proyecto != id_proyecto:
continue
elif id_fase:
if r.tipo != u"Plantilla fase" and \
r.id_fase != id_fase:
continue
elif id_tipo_item:
if r.tipo != u"Plantilla tipo ítem" and \
r.id_tipo_item != id_tipo_item:
continue
elif (r.tipo.find(u"Plantilla") >= 0):
continue
esta = False
for u in r.usuarios:
if (u.id_usuario == id_u):
esta = True
break
if (not esta):
desasignados.append(r)
return desasignados
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 tearDown(self):
"""Finish model test fixture."""
DBSession.rollback()
def permisos_ti(cls):
"""
Método de clase que retorna los permisos que poseen un contexto.
"""
return DBSession.query(Permiso).filter(Permiso.tipo.like("%Tipo%")).all()
def tearDown(self):
"""Finish model test fixture."""
DBSession.rollback()
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 _do_get_provider_count_and_objs(self, order=None, **kw): #sobreescribimos el método
"""
Este método define como la consulta a la base de
datos se debe realizar.
"""
filtrados = []
query = DBSession.query(self.__entity__)
mapper = self.__entity__.__mapper__
res = []
# p = " "
if not self.filtros:
if (self.cualquiera == ""):
if (order):
return query.count, query.order_by(order).all()
else:
return query.count, query.all()
#contaminando código
for key in mapper.columns.keys():
column = mapper.columns.get(key)
# p = p + "/" + str(column) + ":" + column.type.__visit_name__
if column.type.__visit_name__ == 'unicode':
res.extend(query.filter(column.ilike(self.cualquiera + "%")).all())
# query = query.filter(column.ilike(self.cualquiera + "%"))
elif (column.type.__visit_name__ == 'integer' and self.buscar_enteros):
entero = int(self.cualquiera)
res.extend(query.filter(column.in_([entero])).all())
# query = query.filter(column.in_([entero]))
filtrados.extend(res)
# session["print"] = p
# session.save()
filtrados = self.__remover_duplicados(filtrados)
return len(filtrados), filtrados
# p = ""
for fil_col, fil_val_list in self.filtros.items(): #filtrado OR
col = mapper.columns.get(fil_col)
col_type = col.type.__visit_name__
# p = p + "/" + str(col) + ":" + col_type
if col_type == 'integer':
lista = []
for i, fvl in enumerate(fil_val_list):
try:
lista.append(int(fvl))
except:
continue
res = query.filter(col.in_(lista)).all()
elif col_type == 'unicode':
for fvl in fil_val_list:
res.extend(query.filter(col.ilike(fvl)).all())
elif col_type == 'datetime':
for i in range(0, len(fil_val_list), 2):
date0 = fil_val_list[i]
date1 = fil_val_list[i + 1]
if (date0 == '' or date1 == ''):
continue
res.extend(query.filter(col.between(date0, date1)))
filtrados.extend(res)
# session["print"] = p
# session.save()
filtrados = self.__remover_duplicados(filtrados)
return len(filtrados), filtrados