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 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 _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 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 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):
""" 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 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 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 _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 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 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 __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 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
def __actions__(self, obj):
""" Define las acciones posibles para cada línea base.
"""
primary_fields = self.__provider__.get_primary_fields(self.__entity__)
pklist = "/".join(map(lambda x: str(getattr(obj, x)), primary_fields))
value = "<div>"
id_proyecto = pklist.split("-")[2]
linea_base = DBSession.query(LineaBase).filter(LineaBase.id == pklist).one()
items = DBSession.query(Item).filter(Item.id_linea_base == pklist).all()
items_a_mostrar = UnificarItem(items)
cant_items = len(items_a_mostrar)
consistencia_lb(linea_base)
fase = DBSession.query(Fase).filter(Fase.id == self.id_fase).one()
estado_fase(fase)
if linea_base.cerrado:
if TienePermiso("abrir linea base", id_proyecto=id_proyecto, id_fase=self.id_fase).is_met(request.environ):
value = (
value + '<div><a class="abrir_link" '
'href="abrir?pk_linea_base=' + pklist + '" '
'style="text-decoration:none" TITLE = "Abrir"></a></div>'
)
if not linea_base.cerrado:
if (
TienePermiso("separar linea base", id_proyecto=id_proyecto, id_fase=self.id_fase).is_met(
request.environ
)
and cant_items > 1
):
value = (
value + '<div><a class="dividir_link" href='
'"dividir?pk_linea_base=' + pklist + '" style="text-decoration:'
'none" TITLE = "Dividir"></a></div>'
)
if linea_base.consistente:
if TienePermiso("cerrar linea base", id_proyecto=id_proyecto, id_fase=self.id_fase).is_met(
request.environ
):
value = (
value + '<div><a class="cerrar_link" href='
'"cerrar?pk_linea_base=' + pklist + '" style="text-'
'decoration:none" TITLE = "Cerrar"></a></div>'
)
if cant_items >= 1:
value = (
value + '<div><a class="item_link" href='
'"' + pklist + '/items" style="text-decoration:'
'none" TITLE = "Listar Items"></a></div>'
)
value = value + "</div>"
return value
def __actions__(self, obj):
"""
Define las acciones posibles para cada proyecto.
"""
primary_fields = self.__provider__.get_primary_fields(self.__entity__)
pklist = '/'.join(map(lambda x: str(getattr(obj, x)), primary_fields))
value = '<div>'
if TienePermiso("modificar proyecto").is_met(request.environ):
value = value + '<div><a class="edit_link" href="'+pklist+ \
'/edit" style="text-decoration:none" TITLE= "Modificar"></a>'\
'</div>'
pp = TieneAlgunPermiso(tipo = u"Proyecto", recurso = u"Fase", \
id_proyecto = pklist).is_met(request.environ)
pf = TieneAlgunPermiso(tipo = u"Fase", recurso = u"Tipo de Item", \
id_proyecto = pklist).is_met(request.environ)
pfp = TienePermiso(u"asignar rol cualquier fase", \
id_proyecto = pklist).is_met(request.environ)
pfi = TieneAlgunPermiso(tipo = "Fase", recurso = u"Ficha", \
id_proyecto = pklist).is_met(request.environ)
if pp or pf or pfp or pfi:
value = value + '<div><a class="fase_link" href="'+pklist+ \
'/fases" style="text-decoration:none" TITLE= "Fases"></a>'\
'</div>'
if TienePermiso("asignar rol proyecto", id_proyecto = pklist).is_met( \
request.environ):
value = value + '<div><a class="responsable_link" href="'+pklist+ \
'/responsables" style="text-decoration:none" '\
'TITLE= "Responsables"></a>'\
'</div>'
if TienePermiso("eliminar proyecto").is_met(request.environ):
value = value + '<div><form method="POST" action="'+pklist+ \
'" class="button-to" TITLE= "Eliminar">'\
'<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>'
pr = DBSession.query(Proyecto).get(pklist)
estado_proyecto(pr)
cant_fases = DBSession.query(Fase).filter(Fase.id_proyecto == pklist) \
.count()
if cant_fases == pr.nro_fases and pr.estado == u"Nuevo" and \
TienePermiso("setear estado proyecto en desarrollo"). \
is_met(request.environ):
value = value + '<div><a class="inicio_link" href="iniciar/' \
+pklist+'" style="text-decoration:none">Inicia proyecto' \
'</a></div>'
value = value + '</div>'
return value
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('./')
def update_params(self, d):
super(PermisosField, self).update_params(d)
id_rol = unicode(request.url.split("/")[-2])
rol = DBSession.query(Rol).filter(Rol.id == id_rol).one()
permisos_tipo = DBSession.query(Permiso.id).filter(Permiso.tipo == \
rol.tipo).all()
id_permisos_tipo = list()
for permiso in permisos_tipo: id_permisos_tipo.append(permiso[0])
a_eliminar = list()
for permiso in d['options']:
if not permiso[0] in id_permisos_tipo:
a_eliminar.append(permiso)
for elemento in a_eliminar:
d['options'].remove(elemento)
def _do_get_provider_count_and_objs(self, buscado = "", **kw):
""" Se utiliza para listar las fichas que cumplan ciertas condiciones y
ciertos permisos.
"""
if self.id_usuario == "":
fichas = DBSession.query(Ficha).all()
elif TieneAlgunPermiso(tipo = u"Sistema", recurso = u"Usuario"):
fichas = DBSession.query(Ficha).filter(Ficha.id_usuario == \
self.id_usuario).all()
for ficha in reversed(fichas):
if not (self.buscado in ficha.usuario.nombre_usuario or \
self.buscado in ficha.rol.nombre or self.buscado in \
ficha.id): fichas.remove(ficha)
return len(fichas), fichas
def _do_get_provider_count_and_objs(self, buscado = "", **kw):
"""
Se utiliza para listar solo los proyectos que cumplan ciertas
condiciones y de acuerdo a ciertos permisos.
"""
self.opcion = unicode(request.url.split("/")[-3])
if self.opcion == unicode("tipo_item"):
self.id_fase = unicode(request.url.split("/")[-4])
if TienePermiso("importar tipo de item", id_fase = self.id_fase):
proyectos = DBSession.query(Proyecto).join(Proyecto.fases) \
.filter(Proyecto.fases != None).order_by(Proyecto.id) \
.all()
for proyecto in reversed(proyectos):
buscado = self.buscado in str(proyecto.nro_fases) or \
self.buscado in str(proyecto.fecha_inicio) or \
self.buscado in str(proyecto.fecha_fin) or \
self.buscado in proyecto.lider.nombre_usuario or \
self.buscado in proyecto.nombre or \
self.buscado in proyecto.descripcion or \
self.buscado in proyecto.estado
if not buscado: proyectos.remove(proyecto)
for proyecto in reversed(proyectos):
band = True
for fase in proyecto.fases:
if len(fase.tipos_item) > 1 and \
fase.id != self.id_fase: band = False
if band: proyectos.remove(proyecto)
else:
proyectos = list()
else:
self.id_proyecto = unicode(request.url.split("/")[-4])
if TienePermiso("importar fase", id_proyecto = self.id):
proyectos = DBSession.query(Proyecto).filter(Proyecto.id != \
self.id_proyecto).filter(Proyecto.fases != \
None).order_by(Proyecto.id).all()
for proyecto in reversed(proyectos):
buscado = self.buscado in str(proyecto.nro_fases) or \
self.buscado in str(proyecto.fecha_inicio) or \
self.buscado in str(proyecto.fecha_fin) or \
self.buscado in proyecto.lider.nombre_usuario or \
self.buscado in proyecto.nombre or \
self.buscado in proyecto.descripcion or \
self.buscado in proyecto.estado
if not buscado: proyectos.remove(proyecto)
else:
proyectos = list()
return len(proyectos), proyectos
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)
def obtener_orden(self, id_proyecto):
"""Obtiene los órdenes posibles para la fase que se importa.
"""
cantidad_fases = DBSession.query(Proyecto.nro_fases) \
.filter(Proyecto.id == id_proyecto).scalar()
ordenes = DBSession.query(Fase.orden).filter(Fase.id_proyecto == \
id_proyecto).order_by(Fase.orden).all()
vec = list()
list_ordenes = list()
for elem in ordenes:
list_ordenes.append(elem.orden)
for elem in xrange(cantidad_fases):
if not (elem+1) in list_ordenes:
vec.append(elem+1)
return vec[0]
def __actions__(self, obj):
""" Define las acciones posibles para cada fase en el módulo de
gestión.
"""
primary_fields = self.__provider__.get_primary_fields(self.__entity__)
pklist = '/'.join(map(lambda x: str(getattr(obj, x)), primary_fields))
value = '<div>'
id_tipos = DBSession.query(TipoItem.id).filter(TipoItem.id_fase == \
pklist).all()
value = value + '<div><a class="linea_base_link" href="'+pklist+ \
'/lineas_base" style="text-decoration:none" TITLE = ' \
'"Lineas base"></a></div>'
value = value + '</div>'
fase = DBSession.query(Fase).filter(Fase.id == pklist).one()
estado_fase(fase)
return value
def get_all(self, *args, **kw):
""" Lista los ítems de acuerdo a lo establecido en
L{ItemTableFiller._do_get_provider_count_and_objs}.
"""
item_table_filler.init("", self.id_fase)
d = super(ItemControllerListado, self).get_all(*args, **kw)
items_borrados = DBSession.query(Item).filter(Item.id.contains( \
self.id_fase)).filter(Item.borrado == True).count()
d["permiso_recuperar"] = False
d["permiso_crear"] = False
d["accion"] = "./buscar"
d["tipos_item"] = DBSession.query(TipoItem).filter( \
TipoItem.id_fase == self.id_fase)
d["direccion_anterior"] = "../.."
d["model"] = "Items"
return d
def _do_get_provider_count_and_objs(self, **kw):
""" Se utiliza para listar los ítems que cumplan ciertas condiciones y
ciertos permisos.
"""
id_linea_base = unicode(request.url.split("/")[-3])
items = DBSession.query(Item)\
.filter(Item.id_tipo_item.contains(self.id_fase)) \
.filter(Item.borrado == False).filter(Item.id_linea_base == \
id_linea_base).order_by(Item.id).all()
for item in reversed(items):
buscado = self.buscado in item.id or \
self.buscado in item.nombre or \
self.buscado in str(item.version) or \
self.buscado in item.descripcion or \
self.buscado in item.estado or \
self.buscado in item.observaciones or \
self.buscado in str(item.complejidad) or \
self.buscado in str(item.prioridad) or \
self.buscado in item.tipo_item.nombre
if item.linea_base:
buscado = buscado or self.buscado in item.linea_base.id
if not buscado: items.remove(item)
aux = []
for item in items:
for item_2 in items:
if item.id == item_2.id :
if item.version > item_2.version:
aux.append(item_2)
elif item.version < item_2.version :
aux.append(item)
items = [i for i in items if i not in aux]
return len(items), items
def crear_version_sin_relaciones(self, it, id_item):
"""
Crea una nueva versión de un ítem dado sin sus relaciones.
@param it: Item a partir del cual se creará una nueva versión.
@type it: L{Item}
@param id_item: Id del ítem a reversionar.
@type id_item: String
"""
actual = DBSession.query(Item).filter(Item.id == id_item) \
.order_by(desc(Item.version)).first()
nueva_version = Item()
nueva_version.id = it.id
nueva_version.codigo = it.codigo
nueva_version.version = actual.version + 1
nueva_version.nombre = it.nombre
nueva_version.descripcion = it.descripcion
nueva_version.estado = u"En desarrollo"
nueva_version.observaciones = it.observaciones
nueva_version.prioridad = it.prioridad
nueva_version.complejidad = it.complejidad
nueva_version.borrado = it.borrado
nueva_version.anexo = it.anexo
nueva_version.tipo_item = it.tipo_item
nueva_version.revisiones = actual.revisiones
nueva_version.linea_base = actual.linea_base
nueva_version.archivos = it.archivos
return nueva_version
def __actions__(self, obj):
"""
Define las acciones posibles para cada ítem.
"""
primary_fields = self.__provider__.get_primary_fields(self.__entity__)
pklist = '/'.join(map(lambda x: str(getattr(obj, x)), primary_fields))
id_item = pklist.split("/")[0]
version_item = pklist.split("/")[1]
pklist = id_item+ "-" + version_item
item = DBSession.query(Item).filter(Item.id == id_item) \
.filter(Item.version == version_item).one()
value = '<div>'
bloqueado = False
if item.linea_base:
if item.linea_base.cerrado: bloqueado = True
if TienePermiso("reversionar item", id_fase = item.tipo_item.fase.id) \
.is_met(request.environ) and not bloqueado:
value = value + '<div><a class="reversion_link" href=' \
'"revertir?item='+pklist+'" style="text-decoration:none" TITLE ='\
' "Revertir"></a>'\
'</div>'
value = value + '<div><a class="relacion_link" href="'+pklist+ \
'/relaciones" style="text-decoration:none" TITLE =' \
'"Relaciones"></a></div>'
value = value + '<div><a class="archivo_link" href="'+pklist+ \
'/archivos" style="text-decoration:none" TITLE = "Archivos"></a>'\
'</div>'
if item.anexo != "{}":
value = value + '<div><a class="caracteristica_link" href=' \
'"listar_caracteristicas?pk_item='+pklist+ \
'" style="text-decoration:none" TITLE =' \
' "Ver caracteristicas"></a></div>'
value = value + '</div>'
return value
def index(self):
"""Handle the front-page."""
p_sis = TieneAlgunPermiso(tipo = u"Sistema").is_met(request.environ)
p_proy = TieneAlgunPermiso(tipo = u"Proyecto").is_met(request.environ)
p_fic = TieneAlgunPermiso(recurso = u"Ficha").is_met(request.environ)
p_t_it = TieneAlgunPermiso(recurso = u"Tipo de Item") \
.is_met(request.environ)
proys = DBSession.query(Proyecto).filter(Proyecto.estado != \
u"Nuevo").all()
permiso_desarrollo = False
if len(proys) != 0:
for p in proys:
if TieneAlgunPermiso(recurso = u"Item", id_proyecto = p.id) \
.is_met(request.environ): permiso_desarrollo = True
d = dict(page='index', direccion_anterior = "../")
d["permiso_desarrollo"] = permiso_desarrollo
for proyecto in reversed(proys):
if not self.fase_apta(proyecto): proys.remove(proyecto)
permiso_gestion = False
if len(proys) != 0:
for p in proys:
for f in p.fases:
if TieneAlgunPermiso(recurso = u"Linea Base", \
id_fase = f.id).is_met(request.environ):
permiso_gestion = True
d["permiso_administracion"] = p_sis or p_proy or p_fic or p_t_it
d["permiso_gestion"] = permiso_gestion
return d
def _do_get_provider_count_and_objs(self, **kw):
"""
Se utiliza para listar solo los proyectos que cumplan ciertas
condiciones y de acuerdo a ciertos permisos.
"""
if TieneAlgunPermiso(tipo = u"Fase", recurso = u"Linea Base"):
proyectos = DBSession.query(Proyecto).filter(Proyecto.estado != \
u"Nuevo").order_by(Proyecto.id).all()
for proyecto in reversed(proyectos):
buscado = self.buscado in str(proyecto.nro_fases) or \
self.buscado in str(proyecto.fecha_inicio) or \
self.buscado in str(proyecto.fecha_fin) or \
self.buscado in proyecto.lider.nombre_usuario or \
self.buscado in proyecto.nombre or \
self.buscado in proyecto.descripcion or \
self.buscado in proyecto.estado
if not buscado: proyectos.remove(proyecto)
for proyecto in reversed(proyectos):
if not (TieneAlgunPermiso(tipo = u"Fase", recurso = \
u"Linea Base", id_proyecto = proyecto.id) \
.is_met(request.environ) and self.fase_apta(proyecto)):
proyectos.remove(proyecto)
else: proyectos = list()
return len(proyectos), proyectos
def post_delete(self, *args, **kw):
""" Realiza la eliminación del archivo de la base de datos, creando
una nueva versión del ítem correspondiente.
"""
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)
archivo = DBSession.query(Archivo).filter(Archivo.id == args[0]).one()
nueva_version.archivos.remove(archivo)
raise redirect('./../../' + nueva_version.id + '-' + \
unicode(nueva_version.version) + '/' + 'archivos/')
def new(self, *args, **kw):
""" Permite la creación de una nueva relación entre dos ítems de un
determinado proyecto.
"""
it = DBSession.query(Item).filter(Item.id == self.id_item) \
.filter(Item.version == self.version_item).one()
if TienePermiso("crear relaciones", id_fase=it.tipo_item.fase.id):
tmpl_context.widget = self.new_form
d = dict(value=kw, model=self.model.__name__)
d["items"] = DBSession.query(Item).join(Item.tipo_item) \
.filter(TipoItem.id_fase == kw["fase"]).filter(Item.id != \
self.id_item).filter(Item.borrado == False).all()
lista = [x.id_item_2 for x in it.relaciones_a] + \
[y.id_item_1 for y in it.relaciones_b]
for item in reversed(d["items"]):
if item.id in lista:
d["items"].remove(item)
else:
if item.tipo_item.fase < it.tipo_item.fase:
if item.linea_base:
if not (item.linea_base.consistente and \
item.linea_base.cerrado):
d["items"].remove(item)
else:
d["items"].remove(item)
else:
if item.estado != u"Aprobado" or item.revisiones:
d["items"].remove(item)
aux = []
for item in d["items"]:
for item_2 in d["items"]:
if item.id == item_2.id:
if item.version > item_2.version and item_2 not in aux:
aux.append(item_2)
elif item.version < item_2.version and item not in aux:
aux.append(item)
d["items"] = [i for i in d["items"] if i not in aux and \
i.estado == u"Aprobado"]
d["direccion_anterior"] = "./"
return d
else:
flash(u"El usuario no cuenta con los permisos necesarios", \
u"error")
raise redirect('./')
def buscar(self, **kw):
""" Lista las líneas base de acuerdo a un criterio de búsqueda
introducido por el usuario.
"""
buscar_table_filler = LineaBaseTableFiller(DBSession)
if "parametro" in kw:
buscar_table_filler.init(kw["parametro"], self.id_fase)
else:
buscar_table_filler.init("", self.id_fase)
tmpl_context.widget = self.table
value = buscar_table_filler.get_value()
d = dict(value_list=value, model="Lineas Base")
d["accion"] = "./buscar"
d["permiso_crear"] = TienePermiso("crear linea base",
id_fase=self.id_fase).is_met(
request.environ)
d["permiso_unir"] = TienePermiso("unir lineas base",
id_fase=self.id_fase).is_met(
request.environ)
cant = DBSession.query(LineaBase).filter(LineaBase.cerrado == False) \
.filter(LineaBase.id_fase == self.id_fase).count()
if cant < 2:
d["lineas_base"] = False
else:
d["lineas_base"] = True
items = DBSession.query(Item).filter(Item.id_tipo_item
.contains(self.id_fase)).filter(Item.borrado == False) \
.filter(Item.id_linea_base == None).filter(Item.estado ==
u"Aprobado").all()
aux = []
for item in items:
for item_2 in items:
if item.id == item_2.id:
if item.version > item_2.version:
aux.append(item_2)
elif item.version < item_2.version:
aux.append(item)
items = [i for i in items if i not in aux and not es_huerfano(i)]
cant_items = len(items)
if cant_items == 0: d["permiso_crear"] = False
d["direccion_anterior"] = "../.."
return d
def obtener_fases_posibles(self):
""" @return: Posibles órdenes para la fase a ser editada.
"""
id_proyecto = unicode(request.url.split("/")[-4])
id_fase = unicode(request.url.split("/")[-2])
cantidad_fases = DBSession.query(Proyecto.nro_fases).filter( \
Proyecto.id == id_proyecto).scalar()
ordenes = DBSession.query(Fase.orden).filter(Fase.id_proyecto == \
id_proyecto).order_by(Fase.orden).all()
orden_actual = DBSession.query(Fase.orden).filter(Fase.id == \
id_fase).scalar()
vec = list()
list_ordenes = list()
vec.append(orden_actual)
for elem in ordenes:
list_ordenes.append(elem.orden)
for elem in xrange(cantidad_fases):
if not (elem+1) in list_ordenes:
vec.append(elem+1)
return vec
def post(self, **kw):
"""Registra la nueva fase creada."""
f = Fase()
f.nombre = kw['nombre']
f.orden = kw['orden']
f.descripcion = kw['descripcion']
f.estado = 'Inicial'
ids_fases = DBSession.query(Fase.id).filter(Fase.id_proyecto == \
self.id_proyecto).all()
if ids_fases:
proximo_id_fase = proximo_id(ids_fases)
else:
proximo_id_fase = "FA1-" + self.id_proyecto
f.id = proximo_id_fase
proyecto = DBSession.query(Proyecto).filter(Proyecto.id == \
self.id_proyecto).one()
f.proyecto = proyecto
DBSession.add(f)
self.crear_tipo_default(f.id)
raise redirect('./')
def crear_revision(self, item, msg):
"""
Crea una nueva revisión y la agrega a un item dado.
@param item: Item al cual se agregará la revisión
@type item: L{Item}
@param msg: Mensaje de la revisión
@type msg: String
"""
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)
def get_all(self, *args, **kw):
"""
Lista los ítems existentes de acuerdo a condiciones establecidas
en el L{item_controller.ItemTableFiller
._do_get_provider_count_and_objs}.
"""
item_table_filler.init("", self.id_fase)
d = super(ItemController, self).get_all(*args, **kw)
items_borrados = DBSession.query(Item).filter(Item.id.contains( \
self.id_fase)).filter(Item.borrado == True).count()
d["permiso_recuperar"] = TienePermiso("recuperar item", id_fase = \
self.id_fase).is_met(request.environ) and items_borrados
d["permiso_crear"] = TienePermiso("crear item", id_fase = \
self.id_fase).is_met(request.environ)
d["accion"] = "./buscar"
d["tipos_item"] = DBSession.query(TipoItem).filter( \
TipoItem.id_fase == self.id_fase)
d["model"] = "Items"
d["direccion_anterior"] = "../.."
return d
def post_delete(self, *args, **kw):
""" Borra una relación de la base de datos, con las dependencias
correspondientes.
"""
it = DBSession.query(Item).filter(Item.id == self.id_item) \
.filter(Item.version == self.version_item).one()
relacion = DBSession.query(Relacion) \
.filter(Relacion.id == args[0]).one()
if it == relacion.item_2:
version = unicode(it.version + 1)
else:
version = unicode(it.version)
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)
raise redirect('./../../' + it.id + '-' + \
version + '/' + 'relaciones/')
def get_all(self, *args, **kw):
"""Lista las fichas de acuerdo a lo establecido en
L{ficha_usuario_controller.FichaTableFiller._do_get_provider_count_and_objs}.
"""
ficha_table_filler.init("", self.id_usuario)
d = super(FichaUsuarioController, self).get_all(*args, **kw)
usuario = DBSession.query(Usuario).get(self.id_usuario)
d["permiso_crear"] = False
d["model"] = "Responsabilidades"
d["accion"] = "./buscar"
d["direccion_anterior"] = "../.."
return d
def revivir(self, *args, **kw):
"""Permite realizar la recuperación de ítems borrados con sus
respectivos atributos y las relaciones que sea posible recuperar.
"""
if TienePermiso("recuperar item", id_fase=self.id_fase):
pk = kw["id_item"]
pk_id = unicode(pk.split("-")[0] + "-" + pk.split("-")[1] + "-" + \
pk.split("-")[2] + "-" + pk.split("-")[3])
pk_version = pk.split("-")[4]
it = DBSession.query(Item).filter(Item.id == pk_id) \
.filter(Item.version == pk_version).one()
it.estado = u"En desarrollo"
it.borrado = False
it.linea_base = None
items = DBSession.query(Item).filter(Item.id == pk_id).all()
for item in items:
item.borrado = False
else:
flash(u"El usuario no cuenta con los permisos necesarios", \
u"error")
raise redirect('./')
def buscar(self, **kw):
""" Lista los ítems pertenecientes a una línea base de acuerdo a un
criterio de búsqueda introducido por el usuario.
"""
buscar_table_filler = ItemTableFiller(DBSession)
if "parametro" in kw:
buscar_table_filler.init(kw["parametro"], self.id_fase)
else:
buscar_table_filler.init("", self.id_fase)
tmpl_context.widget = self.table
value = buscar_table_filler.get_value()
d = dict(value_list = value, model = "Items", accion = "./buscar")
items_borrados = DBSession.query(Item) \
.filter(Item.id.contains(self.id_fase)) \
.filter(Item.borrado == True).count()
d["permiso_crear"] = False
d["permiso_recuperar"] = False
d["tipos_item"] = DBSession.query(TipoItem)\
.filter(TipoItem.id_fase == self.id_fase)
d["direccion_anterior"] = "../.."
return d
def _do_get_provider_count_and_objs(self, buscado="", **kw):
"""
Se utiliza para listar solo los roles que cumplan ciertas
condiciones y de acuerdo a ciertos permisos.
"""
if TieneAlgunPermiso(tipo = "Sistema", recurso = "Rol") \
.is_met(request.environ):
roles = DBSession.query(Rol).filter(Rol.nombre.contains( \
self.buscado)).all()
else:
roles = list()
return len(roles), roles
def _do_get_provider_count_and_objs(self, buscado="", **kw):
""" Se utiliza para listar las relaciones que cumplan ciertas
condiciones y ciertos permisos.
"""
item_1 = aliased(Item)
item_2 = aliased(Item)
raux = DBSession.query(Relacion).join((item_1, Relacion.id_item_1 == \
item_1.id)).join((item_2, Relacion.id_item_2 == item_2.id)) \
.filter(or_(and_(Relacion.id_item_1 == self.id_item, \
Relacion.version_item_1 == self.version_item), \
and_(Relacion.id_item_2 == self.id_item, \
Relacion.version_item_2 == self.version_item))) \
.filter(or_(Relacion.id.contains(self.buscado), \
item_1.nombre.contains(self.buscado), \
item_2.nombre.contains(self.buscado))).all()
item = DBSession.query(Item).filter(Item.id == self.id_item) \
.filter(Item.version == self.version_item).one()
lista = [x for x in relaciones_a_actualizadas(item.relaciones_a) + \
relaciones_b_actualizadas(item.relaciones_b)]
relaciones = [r for r in raux if r in lista]
return len(relaciones), relaciones
def _do_get_provider_count_and_objs(self, buscado="", **kw):
"""
Se utiliza para listar solo los tipos de ítem que cumplan ciertas
condiciones y de acuerdo a ciertos permisos.
"""
if self.id_fase == "":
tiposItem = DBSession.query(TipoItem).filter(or_(TipoItem.nombre \
.contains(self.buscado), TipoItem.descripcion.contains( \
self.buscado), TipoItem.codigo.contains(self.buscado))) \
.all()
else:
pf = TieneAlgunPermiso(tipo = u"Fase", recurso = u"Tipo de Item", \
id_fase = self.id_fase).is_met(request.environ)
if pf:
tiposItem = DBSession.query(TipoItem).filter( \
TipoItem.id_fase == self.id_fase).filter(or_(TipoItem.nombre. \
contains(self.buscado), TipoItem.descripcion.contains( \
self.buscado), TipoItem.codigo.contains(self.buscado))).all()
else:
tiposItem = list()
return len(tiposItem), tiposItem
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
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('./../../../../..')
def _do_get_provider_count_and_objs(self, **kw):
""" Se utiliza para listar las fases que cumplan ciertas condiciones y
ciertos permisos.
"""
self.id_proyecto = unicode(request.url.split("/")[-3])
self.opcion = unicode(request.url.split("/")[-5])
self.id_fase = unicode(request.url.split("/")[-6])
if self.opcion == unicode("tipo_item"):
if TienePermiso("importar tipo de item", id_fase=self.id_fase):
fases = DBSession.query(Fase).filter(Fase.id_proyecto == \
self.id_proyecto).filter(Fase.id != self.id_fase) \
.order_by(Fase.orden).all()
fases = [f for f in fases if len(f.tipos_item) > 1]
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)
else:
fases = list()
else:
if TienePermiso("importar fase", id_proyecto=self.id_proyecto):
fases = DBSession.query(Fase).filter(Fase.id_proyecto == \
self.id_proyecto).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)
else:
proyectos = list()
return len(fases), fases
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)
def evaluate(self, environ, credentials):
if is_anonymous().is_met(request.environ): self.unmet()
usuario = DBSession.query(Usuario).filter(Usuario.nombre_usuario == \
credentials.get('repoze.what.userid')).first()
fichas = DBSession.query(Ficha).filter(Ficha.usuario == usuario)
if self.id_proyecto:
fichas = fichas.filter(Ficha.id_proyecto == self.id_proyecto)
if self.id_fase:
fichas = fichas.filter(Ficha.id_fase == self.id_fase)
fichas = fichas.all()
if self.tipo:
for ficha in reversed(fichas):
if ficha.rol.tipo != self.tipo: fichas.remove(ficha)
if self.recurso:
band = False
for ficha in reversed(fichas):
for perm in ficha.rol.permisos:
if perm.recurso == self.recurso:
band = True
break
if not band: fichas.remove(ficha)
if not fichas: self.unmet()
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 __actions__(self, obj):
""" Define las acciones posibles para cada fase en el módulo de
desarrollo.
"""
primary_fields = self.__provider__.get_primary_fields(self.__entity__)
pklist = '/'.join(map(lambda x: str(getattr(obj, x)), primary_fields))
value = '<div>'
value = value + '<div><a class="item_link" href="'+pklist+'/items" ' \
'style="text-decoration:none" TITLE = "Items"></a></div>'
value = value + '</div>'
fase = DBSession.query(Fase).filter(Fase.id == pklist).one()
estado_fase(fase)
return value
def descargar(self, *args, **kw):
"""Realiza la descarga del archivo en la computadora del cliente.
"""
item = DBSession.query(Item).filter(Item.id == self.id_item).filter( \
Item.version == self.version_item).one()
if TienePermiso("descargar archivo", id_fase = item.tipo_item.fase \
.id).is_met(request.environ):
id_archivo = kw["id_archivo"]
archivo = DBSession.query(Archivo).filter(Archivo.id == \
id_archivo).one()
rh = response.headers
rh['Content-Type'] = 'application/octet-stream'
disposition = 'attachment; filename="' + archivo.nombre.encode(
'utf-8') + '"'
rh['Content-disposition'] = disposition
rh['Pragma'] = 'public' # for IE
rh['Cache-control'] = 'max-age=0' #for IE
return archivo.contenido
else:
flash(u"El usuario no cuenta con los permisos necesarios", \
u"error")
redirect('./')
def __actions__(self, obj):
"""
Define las acciones posibles para cada proyecto.
"""
primary_fields = self.__provider__.get_primary_fields(self.__entity__)
pklist = '/'.join(map(lambda x: str(getattr(obj, x)), primary_fields))
value = '<div>'
value = value + '<div><a class="fase_link" href="'+pklist+'/fases" '\
'style="text-decoration:none" TITLE = "Fases"></a></div>'
value = value + '</div>'
pr = DBSession.query(Proyecto).get(pklist)
estado_proyecto(pr)
return value
def get_all(self, *args, **kw):
"""Lista las líneas base de acuerdo a lo establecido en
L{linea_base_controller.LineaBaseTableFiller._do_get_provider_count_and_objs}.
"""
linea_base_table_filler.init("", id_fase=self.id_fase)
d = super(LineaBaseController, self).get_all(*args, **kw)
d["permiso_crear"] = TienePermiso("crear linea base",
id_fase=self.id_fase).is_met(
request.environ)
d["permiso_unir"] = TienePermiso("unir lineas base",
id_fase=self.id_fase).is_met(
request.environ)
d["model"] = "Lineas Base"
cant = DBSession.query(LineaBase).filter(LineaBase.cerrado == False) \
.filter(LineaBase.id_fase == self.id_fase).count()
items = DBSession.query(Item).filter(Item.id_tipo_item
.contains(self.id_fase)).filter(Item.borrado == False) \
.filter(Item.id_linea_base == None) \
.filter(Item.estado == u"Aprobado").all()
aux = []
for item in items:
for item_2 in items:
if item.id == item_2.id:
if item.version > item_2.version:
aux.append(item_2)
elif item.version < item_2.version:
aux.append(item)
items = [i for i in items if i not in aux and not es_huerfano(i)]
cant_items = len(items)
if cant < 2:
d["lineas_base"] = False
else:
d["lineas_base"] = True
if cant_items == 0: d["permiso_crear"] = False
d["direccion_anterior"] = "../.."
d["accion"] = "./buscar"
return d
def get_all(self, *args, **kw):
"""Lista las fases de acuerdo a lo establecido en
L{fase_controller.FaseTableFiller._do_get_provider_count_and_objs}.
"""
fase_table_filler.init("", self.id_proyecto)
d = super(FaseController, self).get_all(*args, **kw)
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["accion"] = "./buscar"
d["direccion_anterior"] = "../.."
return d
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_proyecto == "":
fichas = DBSession.query(Ficha).filter(Ficha.id \
.contains(self.buscado)).all()
else:
if TienePermiso("asignar rol proyecto", id_proyecto = \
self.id_proyecto).is_met(request.environ):
fichas = DBSession.query(Ficha).filter(Ficha.id_proyecto == \
self.id_proyecto).all()
for ficha in reversed(fichas):
if ficha.rol.tipo != u"Proyecto":
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): \
fichas.remove(ficha)
else:
fichas = list()
return len(fichas), fichas
def _to_python(self, value, state):
"""
Realiza el control citado anteriormente.
@param value: Se tiene el valor ingresado por el usuario.
@type value: Unicode.
@return value: Retorna el valor ingresado por el usuario.
"""
id_proyecto = self.id_proyecto = unicode(request.url.split("/")[-2])
band = DBSession.query(Proyecto).filter(Proyecto.id != id_proyecto) \
.filter(Proyecto.nombre == value).count()
if band:
raise Invalid('El nombre de proyecto elegido ya está en uso',
value, state)
return value
def _to_python(self, value, state):
"""
Realiza el control citado anteriormente.
@param value: Se tiene el valor ingresado por el usuario.
@type value: Unicode.
@return value: Retorna el valor ingresado por el usuario.
"""
id_proyecto = self.id_proyecto = unicode(request.url.split("/")[-2])
cant_fases = DBSession.query(Fase).filter(Fase.id_proyecto == \
id_proyecto).count()
if int(value) < cant_fases:
raise Invalid(u'Existen más fases que el nro. ingresado', value,
state)
return value
def _do_get_provider_count_and_objs(self, **kw):
""" Se utiliza para listar las fases que cumplan ciertas condiciones y
ciertos permisos.
"""
if self.id_proyecto == "":
fases = DBSession.query(Fase).order_by(Fase.orden).all()
else:
fases = DBSession.query(Fase).filter(Fase.id_proyecto == \
self.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)
pp = TieneAlgunPermiso(tipo = u"Proyecto", recurso = u"Fase", \
id_proyecto = self.id_proyecto).is_met(request.environ)
if not pp:
for fase in reversed(fases):
pfp = TienePermiso(u"asignar rol cualquier fase", \
id_proyecto = fase.id_proyecto).is_met(request.environ)
pfi = TieneAlgunPermiso(tipo = "Fase", recurso = u"Ficha", \
id_proyecto = fase.id_proyecto).is_met(request.environ)
pf = TieneAlgunPermiso(tipo = u"Fase", recurso = \
u"Tipo de Item", id_fase = fase.id). \
is_met(request.environ)
if not (pf or pfp or pfi):
fases.remove(fase)
return len(fases), fases
def _to_python(self, value, state):
"""
Realiza el control citado anteriormente.
@param value: Se tiene el valor ingresado por el usuario.
@type value: Unicode.
@return value: Retorna el valor ingresado por el usuario.
"""
id_fase = unicode(request.url.split("/")[-3])
valor = value.upper()
band = DBSession.query(TipoItem).filter(TipoItem.codigo == valor) \
.filter(TipoItem.id_fase == id_fase).count()
if band:
raise Invalid('El codigo de tipo de item elegido ya está en uso',
value, state)
return value
