def post(self, args={}, **kw):
"""
Evento invocado luego de un evento post en el form de crear
ecargado de persistir las nuevas instancias.
@type args : Hash
@param args : Argumentos de template
@type kw : Hash
@param kw : Keywords
"""
del kw['sprox_id']
rol = Rol()
rol.codigo = kw['codigo']
rol.nombre = kw['nombre']
rol.descripcion = kw['descripcion']
for permiso in kw['permisos'] :
rol.permisos.append(DBSession.query(Permiso).get(permiso))
DBSession.add(rol)
flash("El rol ha sido creado correctamente.")
redirect("/administracion/rol/get_all")
def _do_get_provider_count_and_objs(self, **kw):
limit = kw.get('limit', None)
offset = kw.get('offset', None)
order_by = kw.get('order_by', None)
desc = kw.get('desc', False)
idUsuario= [x for x in DBSession.query(User.user_id).filter_by(user_name=request.identity['repoze.who.userid'])]
idProy=[x for x in DBSession.query(ProyFaseUsuario.idProyecto).filter_by(iduser=idUsuario[0]).distinct()]
proyectos=[]
longitud=len(idProy)
for y in range(longitud):
proyectos.append(DBSession.query(self.__entity__).filter_by(id = idProy[y]).one())
if len(kw) > 0:
for y in range(longitud):
proyectos.append(DBSession.query(self.__entity__).filter((Proyecto.id == idProy[y]) & (Proyecto.nombre.ilike('%'+str(kw['buscar'])+'%'))).one())
objs =proyectos
else:
objs = proyectos
count = len(objs)
self.__count__ = count
return count, objs
def revivir_item (self, historial_item): """ Restaura el item a su ultima version sin sus relaciones """ item = Item() item.id_item = historial_item.id_item item.nombre = historial_item.nombre item.codigo = historial_item.codigo #el estado del item es en desarrollo al revivir item.estado = 2 item.tipo_item = historial_item.tipo_item item.fase = historial_item.fase item.version = historial_item.version item.prioridad = historial_item.prioridad item.complejidad = historial_item.complejidad item.descripcion = historial_item.descripcion item.observacion = historial_item.observacion item.linea_base = historial_item.linea_base #recuperar los detalles historial_detalles = DBSession.query(HistorialDetalleItem).\ filter(HistorialDetalleItem.id_item==historial_item.id_item).\ all() for hist_detalle in historial_detalles: detalle = DetalleItem() detalle.id_detalle = hist_detalle.id_detalle detalle.id_item = hist_detalle.id_item detalle.recurso = hist_detalle.recurso detalle.valor = hist_detalle.valor item.detalles.append(detalle) DBSession.merge(item)
def faseGraphConstructor(self, idfase): #lista de items para el grafo items = DBSession.query(Item).filter(Item.fase==idfase).all() itemsId = [] """ Todos los items de la fase forman parte del grafo (item = nodo) "grafo" es un grafo dirigido que representa las relaciones padre-hijo en una fase. """ grafo = digraph() for item in items: grafo.add_nodes([item.id_item]) """ Se busca en la tabla RelacionItem todas las relaciones de padre-hijo que contengan a los items de la fase """ #guardar los ids de los items for item in items: itemsId = itemsId + [item.id_item] relaciones = DBSession.query(RelacionItem).\ filter(RelacionItem.relacion_parentesco==1).\ filter(RelacionItem.id_item_actual.in_(itemsId)).\ filter(RelacionItem.id_item_relacionado.in_(itemsId)).\ all() #Se añaden las aristas entre los items relacionados for relacion in relaciones: grafo.add_edge((relacion.id_item_actual, relacion.id_item_relacionado)) return grafo
def put(self, args={}, **kw):
"""
Evento invocado luego de un evento post en el form de editar
ecargado de persistir las modificaciones de las instancias.
@type args : Hash
@param args : Argumentos de template
@type kw : Hash
@param kw : Keywords
"""
del kw['sprox_id']
rol = DBSession.query(Rol).get(int(kw['rol_id']))
rol.nombre = kw['nombre']
rol.codigo = kw['codigo']
rol.descripcion = kw['descripcion']
rol.is_template = kw['is_template']
rol.permisos = []
for permiso_id in kw['permisos'] :
rol.permisos.append(DBSession.query(Permiso).get(permiso_id))
DBSession.merge(rol)
flash("El rol '"+rol.nombre+"' ha sido modificado correctamente.")
redirect("/administracion/rol/get_all")
def revivir(self, id_historial):
historial = DBSession.query(HistorialItem).get(id_historial)
#se revive el item a partir de su historial
item_util.revivir_item(historial)
#se elimina el historial del item muerto
DBSession.delete(historial)
redirect("/miproyecto/fase/item/ver/"+str(historial.id_item))
def __actions__(self, obj):
"""Override this function to define how action links should be displayed for the given record."""
primary_fields = self.__provider__.get_primary_fields(self.__entity__)
pklist = '/'.join(map(lambda x: str(getattr(obj, x)), primary_fields))
#if has_permission('manage'):############
proyecto = DBSession.query(Fase.idproyec).filter_by(id = pklist).first()
estado = DBSession.query(Proyecto.estado).filter_by(id = proyecto).first()
faseanterior = DBSession.query(Fase).filter((Fase.idproyec == proyecto) & (Fase.id < pklist)).order_by(Fase.id).all()
longitud = len(faseanterior)
if str(estado[0]).__eq__("iniciado"):
if longitud > 0:
if (faseanterior[longitud-1].estado == 'inicial') | (faseanterior[longitud-1].estado == 'desarrollo'):
value = '<div></div>'
else:
value = '<div><a class="loginlogout" href="/item/?fid='+pklist+ '">Items</a><br/>'\
'<a class="loginlogout" href="/revivir/?fid='+pklist+ '">RevivirItem</a><br/>'\
'<a class="loginlogout" href="/lineabase/?fid='+pklist+ '">LineaBase</a></div>'
else:
value = '<div><a class="loginlogout" href="/item/?fid='+pklist+ '">Items</a><br/>'\
'<a class="loginlogout" href="/revivir/?fid='+pklist+ '">RevivirItem</a><br/>'\
'<a class="loginlogout" href="/lineabase/?fid='+pklist+ '">LineaBase</a></div>'
else:
value = '<div><a class="loginlogout" href="/item/?fid='+pklist+ '">Items</a><br/>'\
'<a class="loginlogout" href="/lineabase/?fid='+pklist+ '">LineaBase</a></div>'
return value
def _do_get_provider_count_and_objs(self, **kw):
limit = kw.get('limit', None)
offset = kw.get('offset', None)
order_by = kw.get('order_by', None)
desc = kw.get('desc', False)
#objs = DBSession.query(self.__entity__).filter_by(idFase=1).all()
log.debug('pruebaRevivir: %s' % kw)
if len(kw) > 0:
if len(kw) > 1:
objs = DBSession.query(self.__entity__).filter(
(Item.idFase == kw['fid']) & (Item.estado == "borrado")
& (Item.nombre.ilike('%' + str(kw['buscar']) +
'%'))).all()
else:
objs = DBSession.query(self.__entity__).filter_by(
idFase=kw['fid'], estado="borrado").all()
#objs = DBSession.query(self.__entity__).filter((Item.nrohistorial==kw['hid'])& (Item.ultimaversion==0) & (Item.nombre.ilike('%'+str(kw['buscar'])+'%'))).all()
#objs = DBSession.query(self.__entity__).all()
else:
objs = DBSession.query(self.__entity__).all()
count = len(objs)
self.__count__ = count
return count, objs
def put(self, *args, **kw):
"""update"""
pks = self.provider.get_primary_fields(self.model)
for i, pk in enumerate(pks):
if pk not in kw and i < len(args):
kw[pk] = args[i]
idTipoDeItem=DBSession.query(Campos.idTipoDeItem).filter_by(id=kw['id']).first()
if kw['nombre']==None:
flash("El nuevo Atributo debe tener un nombre" , "error")
redirect('../'+ kw['id'] +'/edit')
nombreduplicado=DBSession.query(Campos.nombre).filter((Campos.idTipoDeItem==idTipoDeItem) &(Campos.id != kw['id']) &(Campos.nombre==kw['nombre'])).first()
if nombreduplicado != None :
flash("Ya existe un Atributo con el mismo nombre" , "error")
redirect('../'+ kw['id'] +'/edit')
self.provider.update(self.model, params=kw)
idtipo=DBSession.query(Campos.idTipoDeItem).filter_by(id=kw[pk]).first()
redirect('../?tid=' + str(idtipo[0]))
def post(self, *args, **kw):
"""extrae el numhistorial ordenado sin repetir, para luego tomar el mayor valor y asi
poder asignarle un numhistorial mayor
"""
num = [
x for x in (DBSession.query(Item.nrohistorial).order_by(
Item.nrohistorial.desc()).distinct())
]
"""Por cada Item creado, aumenta el nrohistorial en una unidad """
if num != None and len(num) > 0:
kw['nrohistorial'] = int(num[0][0]) + 1
else:
kw['nrohistorial'] = 1
fase = DBSession.query(Fase).filter_by(id=kw['idFase']).first()
if str(fase.estado).__eq__('inicial'):
fase.estado = 'desarrollo'
elif str(fase.estado).__eq__('lineaBaseTotal'):
fase.estado = 'lineaBaseParcial'
#self.provider.create(self.model, params=kw)
raise redirect('./?fid=' + kw['idFase'])
def new(self,lid=None ,*args, **kw):
tmpl_context.widget = self.new_form
if len(kw)<2:
"""-----obtiene el idFase de la en el que esta la linea base------- """
fid=DBSession.query(LineaBase.idFase).filter_by(id=lid).first()
log.debug("fidddd= %s" %fid)
"""-----------------------------------------------------------------"""
emfaseactual= [x for x in DBSession.query(Item.id, Item.nombre).filter_by(idFase=fid,idLineaBase=None).all()]
return dict(value={'lineabase':lid}, model=self.model.__name__,items_options=itemfaseactual)
"""Este else es como el Post.Como,al guardar no se va al Post,vuelve al new, entonces se le creo este "else" """
else:
kw2=dict()
kw2['id']=kw['items']
kw2['idLineaBase']=kw['lineabase']
self.provider.update(self.model, params=kw2)
raise redirect('../' +'../itemlineabase/?lid='+ kw['lineabase'])
def put(self, *args, **kw):
"""update"""
pks = self.provider.get_primary_fields(self.model)
for i, pk in enumerate(pks):
if pk not in kw and i < len(args):
kw[pk] = args[i]
idTipoDeItem = DBSession.query(
Campos.idTipoDeItem).filter_by(id=kw['id']).first()
if kw['nombre'] == None:
flash("El nuevo Atributo debe tener un nombre", "error")
redirect('../' + kw['id'] + '/edit')
nombreduplicado = DBSession.query(
Campos.nombre).filter((Campos.idTipoDeItem == idTipoDeItem)
& (Campos.id != kw['id'])
& (Campos.nombre == kw['nombre'])).first()
if nombreduplicado != None:
flash("Ya existe un Atributo con el mismo nombre", "error")
redirect('../' + kw['id'] + '/edit')
self.provider.update(self.model, params=kw)
idtipo = DBSession.query(
Campos.idTipoDeItem).filter_by(id=kw[pk]).first()
redirect('../?tid=' + str(idtipo[0]))
def __actions__(self, obj):
"""Override this function to define how action links should be displayed for the given record."""
primary_fields = self.__provider__.get_primary_fields(self.__entity__)
pklist = '/'.join(map(lambda x: str(getattr(obj, x)), primary_fields))
#if has_permission('manage'):############
proyecto = DBSession.query(Fase.idproyec).filter_by(id = pklist).first()
estado = DBSession.query(Proyecto.estado).filter_by(id = proyecto).first()
value='<div></div>'
if str(estado[0]).__eq__("nuevo"):
value = '<div><div><a class="edit_link" href="'+pklist+'/edit" style="text-decoration:none">edit</a></div>'\
'<div><form method="POST" action="'+pklist+'" class="button-to">'\
'<input type="hidden" name="_method" value="DELETE" />'\
'<input class="delete-button" onclick="return confirm(\'Are you sure?\');" value="delete" type="submit" '\
'style="background-color: transparent; float:left; border:0; color: #286571; display: inline; margin: 0; padding: 0;"/>'\
'</form>'\
'</div>''</div>'
elif str(estado[0]).__eq__("iniciado"):
value = '<div><div><a class="edit_link" href="'+pklist+'/edit" style="text-decoration:none">edit</a>'\
'<div><a class="loginlogout" href="/tipodeitem/?fid='+pklist+ '">TiposItem</a></div><br/>'\
'<div><a class="loginlogout" href="/importartipodeitem/new/?fid='+pklist+ '">ImportarTipoItem</a></div><br/>'\
'</div></div>'
return value
def new(self, idtipo, args={}, **kw):
"""
Encargado de cargar el widget para crear nuevas instancias,
solo tienen acceso aquellos usuarios que posean el premiso de crear
@type idtipo : Integer
@param idtipo : Identificador del Atributo del item.
@type args : Hash
@param args : Argumentos de template
@type kw : Hash
@param kw : Keywords
@rtype : Diccionario
@return : El diccionario que sera utilizado en el template.
"""
tmpl_context.widget = new_atributo_form
self.params['modelname'] = "Atributos del Tipo de Item"
self.params['idtipo'] = idtipo
self.params['tipo_item'] = DBSession.query(TipoItem).get(idtipo)
self.params['current_name'] = self.params['tipo_item'].nombre
id_fase = self.params['tipo_item'].fase
self.params['fase'] = DBSession.query(Fase).get(id_fase)
self.params['idfase'] = id_fase
self.params['header_file'] = 'tipo_item'
self.params['cancelar_url'] = '/miproyecto/fase/tipo_item/atributos/list/'+str(idtipo)
return dict(value=kw, params=self.params)
def __actions__(self, obj):
"""Override this function to define how action links should be displayed for the given record."""
primary_fields = self.__provider__.get_primary_fields(self.__entity__)
pklist = '/'.join(map(lambda x: str(getattr(obj, x)), primary_fields))
#if has_permission('manage'):############
proyecto = DBSession.query(Fase.idproyec).filter_by(id=pklist).first()
estado = DBSession.query(
Proyecto.estado).filter_by(id=proyecto).first()
faseanterior = DBSession.query(Fase).filter(
(Fase.idproyec == proyecto) & (Fase.id < pklist)).order_by(
Fase.id).all()
longitud = len(faseanterior)
if str(estado[0]).__eq__("iniciado"):
if longitud > 0:
if (faseanterior[longitud - 1].estado == 'inicial') | (
faseanterior[longitud - 1].estado == 'desarrollo'):
value = '<div></div>'
else:
value = '<div><a class="loginlogout" href="/item/?fid='+pklist+ '">Items</a><br/>'\
'<a class="loginlogout" href="/revivir/?fid='+pklist+ '">RevivirItem</a><br/>'\
'<a class="loginlogout" href="/lineabase/?fid='+pklist+ '">LineaBase</a></div>'
else:
value = '<div><a class="loginlogout" href="/item/?fid='+pklist+ '">Items</a><br/>'\
'<a class="loginlogout" href="/revivir/?fid='+pklist+ '">RevivirItem</a><br/>'\
'<a class="loginlogout" href="/lineabase/?fid='+pklist+ '">LineaBase</a></div>'
else:
value = '<div><a class="loginlogout" href="/item/?fid='+pklist+ '">Items</a><br/>'\
'<a class="loginlogout" href="/lineabase/?fid='+pklist+ '">LineaBase</a></div>'
return value
def get_all(self, idfase, **kw):
"""Lista todos los items de la fase"""
has_permiso = session_util.authorize_fase('ver_fase', idfase)
if ( has_permiso == None) :
flash("No posee permisos sobre la fase #"+str(idfase),'error')
redirect('/miproyecto/fase/error')
tmpl_context.widget = item_table
items = DBSession.query(Item).filter(Item.fase==idfase).all()
value = item_filler.get_value(items)
permiso_editar = fase_util.check_fase_permiso(idfase, 'editar_fase')
permiso_anadir = fase_util.check_fase_permiso(idfase, 'administrar_participantes')
self.params['title'] = 'Titulo'
self.params['permiso_editar'] = permiso_editar
self.params['permiso_anadir'] = permiso_anadir
self.params['modelname'] = 'Items'
self.params['header_file'] = 'fase'
self.params['permiso'] = 'crear_item'
self.params['idfase'] = idfase
self.params['fase'] = DBSession.query(Fase).get(idfase)
self.params['new_url'] = '/miproyecto/fase/item/'+idfase+'/new/'
self.params['label'] = 'Agregar Atributo'
self.params['usuarios'] = usuario_util.get_usuarios_by_fase(idfase)
return dict(value=value, params = self.params)
def put(self, id, **kw):
"""
Evento invocado luego de un evento post en el form de editar
ecargado de persistir las modificaciones de las instancias.
@type id : Integer
@param id : Identificador del usuario.
@type kw : Hash
@param kw : Keywords
"""
usuario = DBSession.query(Usuario).get( int(id) )
usuario.nombre = kw['nombre']
usuario.email_address = kw['email_address']
if usuario._password != kw['password'] :
print 'Actualizando la contrasenha'
usuario._set_password(kw['password'])
DBSession.merge(usuario)
flash("El usuario '"+usuario.nombre+"' ha sido modificado correctamente.")
redirect("/administracion/usuario/get_all")
def iniciar_proyecto(self, idproyecto, **kw):
proyecto = DBSession.query(Proyecto).get(idproyecto)
proyecto.estado = estado_proyecto_util.get_by_codigo('Desarrollo')
DBSession.merge(proyecto)
redirect('/miproyecto/ver/'+str(idproyecto))
def gen_cod (self, id_fase, id_tipo): #traer la fase fase_actual = DBSession.query(Fase).get(id_fase) #se consulta por el numero de la fase actual dentro del proyecto nro_fase = 1 + len(DBSession.query(Fase).\ filter(Fase.proyecto==fase_actual.proyecto).\ filter(Fase.id_fase<fase_actual.id_fase).\ all()) #cantidad de items + 1 es el nro de item del nuevo item #dentro del proyecto actual nro_item = 1 + len(DBSession.query(Item).\ filter(Item.fase==fase_actual.id_fase).\ all()) #obtener el tipo de item al cual corresponde el item, el codigo #de este es utilizado como prefijo del codigo del item tipo = DBSession.query(TipoItem).get(id_tipo) prefijo = tipo.codigo #se concatenan los resultados item_codigo = prefijo + str(nro_fase) + str(nro_item) return item_codigo
def post(self, *args, **kw):
ids = kw['items']
longitud = len(ids)
items = DBSession.query(Item).filter_by(idFase=kw['idFase'],
ultimaversion=1).all()
if (longitud > 0):
fase = DBSession.query(Fase).filter_by(id=kw['idFase']).first()
if longitud == len(items):
fase.estado = 'lineaBaseTotal'
else:
fase.estado = 'lineaBaseParcial'
lineabase = self.provider.create(self.model, params=kw)
for indice in range(longitud):
item = DBSession.query(Item).filter_by(id=ids[indice]).first()
item.idLineaBase = lineabase.id
raise redirect('./?fid=' + kw['idFase'])
else:
flash("No ha seleccionado ningun item", "error")
raise redirect('./new/?fid=' + kw['idFase'])
def _do_get_provider_count_and_objs(self, **kw):
limit = kw.get('limit', None)
offset = kw.get('offset', None)
order_by = kw.get('order_by', None)
desc = kw.get('desc', False)
#objs = DBSession.query(self.__entity__).filter_by(idFase=1).all()
if len(kw) > 0:
if len(kw) > 1:
#objs = DBSession.query(self.__entity__).filter((Fase.idproyec==kw['pid']) & (Fase.nombre.ilike('%'+str(kw['buscar'])+'%'))).all()
if kw['buscar']=="":
objs = DBSession.query(self.__entity__).filter_by(nrohistorial=kw['hid'], ultimaversion=0).all()
else:
objs = DBSession.query(self.__entity__).filter((Item.nrohistorial==kw['hid'])& (Item.ultimaversion==0) & (Item.version ==kw['buscar'])).all()
else:
objs = DBSession.query(self.__entity__).filter_by(nrohistorial=kw['hid'], ultimaversion=0).all()
else:
objs = DBSession.query(self.__entity__).all()
count = len(objs)
self.__count__ = count
return count, objs
def importar_este_tipo(self, idtipo, idfase):
"""
Se obtiene de la BD el tipo de item y sus atributos
"""
tipo = DBSession.query(TipoItem).get(idtipo)
atributos = DBSession.query(AtributoTipoItem).\
filter(AtributoTipoItem.tipo_item==tipo.id_tipo_item)
"""
Se settean los valores de la copia
El nuevo tipo de item (copia_tipo )pertenecera a esta fase ahora
"""
copia_tipo = TipoItem()
copia_tipo.nombre = tipo.nombre
copia_tipo.descripcion = tipo.descripcion
copia_tipo.fase = idfase
copia_tipo.codigo = tipo.codigo
'''
Se settean los valores para cada copia_atributo
'''
for atributo in atributos:
copia_atributo = AtributoTipoItem()
copia_atributo.nombre = atributo.nombre
copia_atributo.tipo_id = atributo.tipo_id
copia_tipo.atributos.append(copia_atributo)
DBSession.add(copia_tipo)
flash("El tipo de item "+str(tipo.nombre)+
" pertenece ahora a esta fase")
redirect("/miproyecto/fase/tipo_item/importar/"+str(idfase))
def _do_get_provider_count_and_objs(self, **kw):
limit = kw.get('limit', None)
offset = kw.get('offset', None)
order_by = kw.get('order_by', None)
desc = kw.get('desc', False)
#objs = DBSession.query(self.__entity__).filter_by(idFase=1).all()
if len(kw) > 0:
objs = DBSession.query(
self.__entity__).filter((RelacionItem.idItem1 == kw['iid']) | (
RelacionItem.idItem2 == kw['iid'])).all()
listarelaciones = DBSession.query(
self.__entity__).filter((RelacionItem.idItem1 == kw['iid']) | (
RelacionItem.idItem2 == kw['iid'])).all()
for x in range(len(listarelaciones)):
item1 = DBSession.query(Item).filter_by(
id=listarelaciones[x].idItem1).first()
item2 = DBSession.query(Item).filter_by(
id=listarelaciones[x].idItem2).first()
if (int(item1.ultimaversion) != 1) | (int(item2.ultimaversion)
!= 1):
objs.remove(listarelaciones[x])
else:
objs = DBSession.query(self.__entity__).all()
count = len(objs)
self.__count__ = count
return count, objs
def asociar_usuario_fase(self, usuario_id, fase_id): """ Asocia los permisos de un usuario con una fase, asi los usuarios que posean el rol estaran asociados a la fase. @type usuario_id : String @param usuario_id : Codigo del rol @type fase_id : Integer @param fase_id : Identificador de la fase @rtype : Rol @return : El rol que es aplicado a la fase. """ fase = DBSession.query(Fase).get(fase_id) #Se obtienen los permisos del template permisos_rol = self.distinct(DBSession.query(Permiso).\ filter(RolPermisoProyecto.permiso_id == Permiso.permiso_id).\ filter(RolPermisoProyecto.proyecto_id == fase.proyecto) ) #Se se asocian el rol con la fase for permiso in permisos_rol: rpu = UsuarioPermisoFase() rpu.fase_id = fase_id rpu.usuario_id = usuario_id rpu.permiso_id = permiso.permiso_id #Asocia el rol con los permisos y la fase DBSession.add(rpu)
def view(self, fileid):
iid = DBSession.query(Adjuntos.idItem).filter_by(id=fileid).first()
log.debug("iidssss: %s" % iid)
try:
userfile = DBSession.query(Adjuntos).filter_by(id=fileid).one()
except:
redirect("../../adjuntos/new/adjuntos/new")
content_types = {
'display': {},
'download': {
'.pdf': 'application/pdf',
'.zip': 'application/zip',
'.rar': 'application/x-rar-compressed',
'.png': 'image/jpeg',
'.jpeg': 'image/jpeg',
'.jpg': 'image/jpeg',
'.gif': 'image/jpeg',
'.txt': 'text/plain'
}
}
for file_type in content_types['display']:
if userfile.filename.endswith(file_type):
response.headers["Content-Type"] = content_types['display'][
file_type]
for file_type in content_types['download']:
if userfile.filename.endswith(file_type):
response.headers["Content-Type"] = content_types['download'][
file_type]
response.headers[
"Content-Disposition"] = 'attachment; filename="' + userfile.filename + '"'
if userfile.filename.find(".") == -1:
response.headers["Content-Type"] = "text/plain"
return userfile.filecontent
def _do_get_provider_count_and_objs(self, **kw):
limit = kw.get('limit', None)
offset = kw.get('offset', None)
order_by = kw.get('order_by', None)
desc = kw.get('desc', False)
#objs = DBSession.query(self.__entity__).filter_by(idFase=1).all()
if len(kw) > 0:
if len(kw) > 1:
#objs = DBSession.query(self.__entity__).filter((Fase.idproyec==kw['pid']) & (Fase.nombre.ilike('%'+str(kw['buscar'])+'%'))).all()
if kw['buscar'] == "":
objs = DBSession.query(self.__entity__).filter_by(
nrohistorial=kw['hid'], ultimaversion=0).all()
else:
objs = DBSession.query(self.__entity__).filter(
(Item.nrohistorial == kw['hid'])
& (Item.ultimaversion == 0)
& (Item.version == kw['buscar'])).all()
else:
objs = DBSession.query(self.__entity__).filter_by(
nrohistorial=kw['hid'], ultimaversion=0).all()
else:
objs = DBSession.query(self.__entity__).all()
count = len(objs)
self.__count__ = count
return count, objs
def asignar_rol_usuario(self,usuario_id , cod_rol, id_proyecto): """ Asigna un rol asociado a un proyecto al usuario determinado. @type usuario_id : Integer @param usuario_id : Identificador del usuario @type cod_rol : String @param cod_rol : Codigo del rol @type id_proyecto : Integer @param id_proyecto : Identificador del proyecto al cual se va aplicar el rol @rtype : Rol @return : El rol que es asignado al usuario. """ #Se obtiene el rol con el nombre correspondiente rol = rol_util.get_by_codigo(cod_rol) #Se verifica si el usuario posee el rol rol_usuario = usuario_util.usuario_has_rol(usuario_id, rol) #si no posee el rol, se le asigna if rol_usuario == None: rol_usuario = RolUsuario() rol_usuario.usuario_id = usuario_id rol_usuario.rol_id = rol.rol_id DBSession.add(rol_usuario) return rol
def proyectGraphConstructor(self, idproyecto): fases = DBSession.query(Fase).filter(Fase.proyecto==idproyecto).all() grafo = digraph() items = [] itemsId = [] #se "obtienen los items de cada fase for fase in fases: items = items + list(DBSession.query(Item).filter(Item.fase==fase.id_fase)) for item in items: grafo.add_nodes([item.id_item]) #guardar los ids de los items for item in items: itemsId = itemsId + [item.id_item] """ Se busca en la tabla RelacionItem todas las relaciones que contengan a los items del proyecto """ relaciones = DBSession.query(RelacionItem).\ filter((RelacionItem.id_item_actual).in_(itemsId)).\ all() #Se añaden las aristas entre los items relacionados for relacion in relaciones: grafo.add_edge((relacion.id_item_actual,relacion.id_item_relacionado)) return grafo
def new(self, lid=None, *args, **kw):
tmpl_context.widget = self.new_form
if len(kw) < 2:
"""-----obtiene el idFase de la en el que esta la linea base------- """
fid = DBSession.query(LineaBase.idFase).filter_by(id=lid).first()
log.debug("fidddd= %s" % fid)
"""-----------------------------------------------------------------"""
emfaseactual = [
x for x in DBSession.query(Item.id, Item.nombre).filter_by(
idFase=fid, idLineaBase=None).all()
]
return dict(value={'lineabase': lid},
model=self.model.__name__,
items_options=itemfaseactual)
"""Este else es como el Post.Como,al guardar no se va al Post,vuelve al new, entonces se le creo este "else" """
else:
kw2 = dict()
kw2['id'] = kw['items']
kw2['idLineaBase'] = kw['lineabase']
self.provider.update(self.model, params=kw2)
raise redirect('../' + '../itemlineabase/?lid=' + kw['lineabase'])
def borrarRelacion(self, item1, item2, idfase, **kw):
if not self.puede_borrar(item1, item2, idfase):
flash ("No se peude borrar la relacion! deja huerfanos", 'warning')
redirect("/miproyecto/fase/relacion/list/"+idfase)
#auditar items y aumentar su version
item_1 = DBSession.query(Item).get(item1)
item_2 = DBSession.query(Item).get(item2)
item_util.audit_item(item_1)
item_util.audit_item(item_2)
item_1.version += 1
item_2.version += 1
item_1.estado = 3
item_2.estado = 3
DBSession.add(item_1)
DBSession.add(item_2)
DBSession.delete(DBSession.query(RelacionItem).\
filter(RelacionItem.id_item_actual==item1).\
filter(RelacionItem.id_item_relacionado==item2).\
one())
#marcar en revision los relacionados
fase = DBSession.query(Fase).get(item_1.fase)
grafo = item_util.proyectGraphConstructor(fase.proyecto)
item_util.marcar_en_revision(grafo, item_1.id_item)
item_util.marcar_en_revision(grafo, item_2.id_item)
flash("Se ha eliminado la relacion: "+item1+" <--> "+item2)
redirect("/miproyecto/fase/relacion/list/"+idfase)
def put(self, *args, **kw):
"""update"""
pks = self.provider.get_primary_fields(self.model)
for i, pk in enumerate(pks):
if pk not in kw and i < len(args):
kw[pk] = args[i]
idproyec = DBSession.query(
Fase.idproyec).filter_by(id=kw['id']).first()
if kw['nombre'] == None:
flash("Una fase debe tener un nombre", "error")
redirect('/fase/' + kw['id'] + '/edit')
nombreduplicado = DBSession.query(
Fase.nombre).filter((Fase.idproyec == idproyec)
& (Fase.id != kw['id'])
& (Fase.nombre == kw['nombre'])).first()
if nombreduplicado != None:
flash("Ya existe una fase con el mismo nombre", "error")
redirect('/fase/' + kw['id'] + '/edit')
self.provider.update(self.model, params=kw)
idProy = DBSession.query(Fase.idproyec).filter_by(id=kw['id']).first()
redirect('../?pid=' + str(idProy[0]))
def _do_get_provider_count_and_objs(self ,**kw):
limit = kw.get('limit', None)
offset = kw.get('offset', None)
order_by = kw.get('order_by', None)
desc = kw.get('desc', False)
if len(kw) > 0:
"""Se extrae el id del usuario quien inicio sesion"""
idUsuario= [x for x in DBSession.query(User.user_id).filter_by(user_name=request.identity['repoze.who.userid'])]
"""Se extrae los id de las fases en la cual el usuario tiene permiso """
idsfases=[x for x in DBSession.query(ProyFaseUsuario.idFase).filter_by(idProyecto=kw['pid'] , iduser=idUsuario[0]).distinct()]
fases=[]
longitud=len(idsfases)
if len(kw) > 1:
for y in range(longitud):
visualizar=DBSession.query(self.__entity__).filter((Fase.id==idsfases[y]) & (Fase.nombre.ilike('%'+str(kw['buscar'])+'%'))).first()
if visualizar != None:
fases.append(visualizar)
else:
for y in range(longitud):
fases.append(DBSession.query(self.__entity__).filter_by(id=idsfases[y]).first())
objs=fases
else:
objs = DBSession.query(self.__entity__).all()
count = len(objs)
self.__count__ = count
return count, objs
def put(self, args={}, **kw):
"""
Evento invocado luego de un evento post en el form de editar
ecargado de persistir las modificaciones de las instancias.
@type args : Hash
@param args : Argumentos de template
@type kw : Hash
@param kw : Keywords
"""
#Se obtiene de la base de datos el proyecto modifcado
proyecto = DBSession.query(Proyecto).get(int(kw['id_proyecto']))
#Se actualizan unicamente los campos actualizables
proyecto.nombre=kw['nombre']
proyecto.nro_fases = kw['nro_fases']
proyecto.descripcion = kw['descripcion']
#asignar lider
proyecto.lider = DBSession.query(Usuario).get(kw['lider'])
util.asignar_lider(proyecto)
DBSession.merge(proyecto)
flash("El proyecto ha sido '" +proyecto.nombre+ "' modificado correctamente.")
redirect("/administracion/proyecto/list")
def get_usuarios_by_fase(self, id, permiso_name='ver_fase'):
"""
Obtiene una lista de los usuarios que poseen el permiso especificado sobre
un proyecto.
@type id : Integer
@param id : Identificador de la fase
@type permiso_name : String
@param permiso_name : Nombre del permiso
@rtype : Usuario []
@return : Lista de usuarios que poseen el permiso sobre la fase
"""
usuarios = DBSession.query(Usuario).\
filter(UsuarioPermisoFase.usuario_id == Usuario.usuario_id).\
filter(UsuarioPermisoFase.fase_id == id).\
filter(UsuarioPermisoFase.permiso_id == Permiso.permiso_id).\
filter(Permiso.nombre == permiso_name).all()
#Si el usuairo es lider del proyecto se saltan los controles
user = checker.get_current_user()
fase = DBSession.query(Fase).get(id)
rol = self.get_rol_by_codigo('lider_' + str(fase.proyecto))
if self.usuario_has_rol(user.usuario_id, rol ):
usuarios.append(user)
return self.distinct(usuarios)
def post_delete(self, id_linea_base, **kw):
lb = DBSession.query(LineaBase).get(id_linea_base)
#guardar el id de la fase de la linea base para el redirect
idfase = lb.fase
#borrar la linea base
DBSession.delete(lb)
flash("La linea base ha sido eliminada correctamente.")
redirect("/miproyecto/fase/linea_base/list/"+str(idfase))
def aprobar_item(self, iditem, **kw):
"""
Metodo para aprobar un item
"""
item = DBSession.query(Item).get(iditem)
item.estado = 1
idfase = item.fase
DBSession.merge(item)
flash("El item " + item.codigo+ " ha sido aprobado correctamente")
redirect('/miproyecto/fase/item/ver/'+str(iditem))
def commit_transaction(self, can_commit): """ Realiza commit de la transaccion @type can_commit : Boolean @param can_commit : Variable de control de la transaccion """ if can_commit == True : DBSession.flush() transaction.commit()
def poner_en_revision(self, id_item):
item = DBSession.query(Item).get(id_item)
fase = DBSession.query(Fase).get(item.fase)
grafo = item_util.proyectGraphConstructor(fase.proyecto)
item_util.marcar_en_revision(grafo, item.id_item)
flash("El item " +str(item.nombre)+ " fue puesto en revision.", 'warning')
redirect('/miproyecto/fase/item/ver/'+str(item.id_item))
def new(self,pid=None ,*args, **kw):
"""Display a page to show a new record."""
tmpl_context.widget = self.new_form
fases = [x for x in DBSession.query(Fase.id, Fase.nombre).filter_by(idproyec=pid)]
usuarios = [x for x in (DBSession.query(User.user_id, User.user_name))]
usuarios.remove(usuarios[0])
#permisos= [x for x in (DBSession.query(Permission. permission_id ,Permission. permission_name))]
return dict(value={'idProyecto':pid}, model=self.model.__name__, fases_options=fases, usuarios_options=usuarios)
def new(self, tid=None, *args, **kw):
"""Display a page to show a new record."""
fid = DBSession.query(TipoDeItem.idFase).filter_by(id=tid).first()
comlejidadoptions = [
(1, "Muy Baja (1)"),
(2, "Baja (2)"),
(3, "Media (3)"),
(4, "Alta (4)"),
(5, "Muy Alta (5)"),
]
campos = [
TextField("nombre", label_text="Nombre", disabled=True),
Spacer(),
HiddenField("idFase", label_text="idFase"),
HiddenField("version", label_text="version"),
HiddenField("estado", label_text="estado"),
SingleSelectField("complejidad", options=comlejidadoptions, label_text="complejidad"),
Spacer(),
HiddenField("nrohistorial", label_text="nrohistorial"),
HiddenField("idTipoDeItem", label_text="idTipoDeItem"),
]
camponombre = DBSession.query(Campos.tipoDeDato, Campos.nombre, Campos.id).filter_by(idTipoDeItem=tid).all()
for ct in camponombre:
# log.debug(ct[1])
if str(ct[0]).__eq__("date"):
campo1 = CalendarDatePicker(str(ct[2]), label_text=ct[1] + " (" + ct[0] + ")", date_format="%d/%m/%Y")
else:
campo1 = TextField(str(ct[2]), label_text=ct[1] + " (" + ct[0] + ")")
campos.append(campo1)
campos.append(Spacer())
# self.new_form = TableForm('tf', fields=campos, submit_text='Guardar')
# tmpl_context.widget = self.new_form
tmpl_context.widget = TableForm("create_table_form", fields=campos, submit_text="Guardar")
"""El tipo de Item elegido es extraido para asignar su nombre al item"""
tipo_item_elegido = DBSession.query(TipoDeItem).filter_by(id=tid).first()
nrogenerado = tipo_item_elegido.nrogeneracion + 1
if int(nrogenerado) < 10:
nombreitem = tipo_item_elegido.nombre + "-00" + str(nrogenerado)
elif int(nrogenerado) < 100:
nombreitem = tipo_item_elegido.nombre + "-0" + str(nrogenerado)
else:
nombreitem = tipo_item_elegido.nombre + "-" + str(nrogenerado)
return dict(value={"idTipoDeItem": tid, "idFase": fid, "nombre": nombreitem}, model=self.model.__name__)
def new(self,iid=None ,*args, **kw):
"""Se obtiene el id del tipo de item elegido para el item"""
idtipo=DBSession.query(Item.idTipoDeItem).filter_by(id=iid).first()
atributos= [x for x in (DBSession.query(Campos.nombre, Campos.nombre).filter_by(idTipoDeItem=idtipo))]
tmpl_context.widget = self.new_form
return dict(value={'iditem':iid}, model=self.model.__name__, atributos_options=atributos)
def _do_get_provider_count_and_objs(self, **kw):
limit = kw.get('limit', None)
offset = kw.get('offset', None)
order_by = kw.get('order_by', None)
desc = kw.get('desc', False)
if len(kw) > 0:
objs = DBSession.query(
self.__entity__).filter_by(idTipoDeItem=kw['tid']).all()
else:
#objs = DBSession.query(self.__entity__).filter_by(idproyec=kw[result['pid']]).all()
objs = DBSession.query(self.__entity__).all()
count = len(objs)
self.__count__ = count
return count, objs
def aprobaritem(self, **kw):
item = DBSession.query(Item).filter_by(id=kw['iid']).first()
item.estado = 'aprobado'
fid = DBSession.query(Item.idFase,
Item.nombre).filter_by(id=kw['iid']).first()
if item.idLineaBase != None:
listaitem = DBSession.query(Item).filter_by(
idLineaBase=item.idLineaBase, ultimaversion=1).all()
longitud = len(listaitem)
contadoraprob = 0
modificado = False
for x in range(longitud):
#Verificar si todos los item de la linea base estan aprobados
if str(listaitem[x].estado).__eq__('aprobado'):
contadoraprob = contadoraprob + 1
#Verificar si existe por lo menos un item en estado modificado
elif str(listaitem[x].estado).__eq__('modificado'):
modificado = True
#Entra si todos los item de la linea base estan aprobados
if contadoraprob == longitud:
lineabase = DBSession.query(LineaBase).filter_by(
id=item.idLineaBase).first()
lineabase.estado = 'cerrada'
cantItemLB = DBSession.query(Item).filter_by(
idLineaBase=lineabase.id, ultimaversion=1).all()
cantItemFase = DBSession.query(Item).filter_by(
idFase=fid[0], ultimaversion=1).all()
fase = DBSession.query(Fase).filter_by(id=fid[0]).first()
if len(cantItemLB) == len(cantItemFase):
fase.estado = 'lineaBaseTotal'
flash("El item \"" +str(fid[1]) +"\" fue aprobado, "\
"la linea base \"" + lineabase.nombre + "\" fue cerrada y "\
"la fase \""+fase.nombre+"\" paso al estado de \"Linea Base Total\"")
redirect('/item/?fid=' + str(fid[0]))
else:
fase.estado = 'lineaBaseParcial'
flash("El item \"" +str(fid[1]) +"\" fue aprobado, "\
"la linea base \"" + lineabase.nombre + "\" fue cerrada y "\
"la fase \""+fase.nombre+"\" paso al estado de \"Linea Base Parcial\"")
redirect('/item/?fid=' + str(fid[0]))
#Entra si no existem item modificados en la linea base"""
elif not modificado:
lineabase = DBSession.query(LineaBase).filter_by(
id=item.idLineaBase).first()
lineabase.estado = 'comprometida'
flash("El item \"" +str(fid[1]) +"\" fue aprobado y "\
"la linea base \"" + lineabase.nombre + "\" ahora esta comprometida")
redirect('/item/?fid=' + str(fid[0]))
flash("El item \"" + str(fid[1]) + "\" fue aprobado")
redirect('/item/?fid=' + str(fid[0]))
def get_all(self, tid=None, *args, **kw):
kw['tid'] = tid
result = super(CamposController, self).get_all(*args, **kw)
result['tid'] = tid
fid = DBSession.query(TipoDeItem.idFase).filter_by(id=tid).first()
result['fid'] = fid[0]
return result
def __actions__(self, obj):
"""Override this function to define how action links should be displayed for the given record."""
primary_fields = self.__provider__.get_primary_fields(self.__entity__)
pklist = '/'.join(map(lambda x: str(getattr(obj, x)), primary_fields))
iteminstancia = DBSession.query(
Item.id).filter_by(idTipoDeItem=pklist).all()
cantidadinstancia = len(iteminstancia)
#log.debug('iteminstancia: %s' %iteminstancia)
if cantidadinstancia > 0:
value = '<div><a class="edit_link" href="'+pklist+'/edit" style="text-decoration:none">edit</a>'\
'<div><a class="loginlogout" href="/campos/?tid='+pklist+'">AtributosEspecificos</a></div><br/></div>'
else:
value = '<div><div><a class="edit_link" href="'+pklist+'/edit" style="text-decoration:none">edit</a>'\
'</div><div>'\
'<div><a class="loginlogout" href="/campos/?tid='+pklist+'">AtributosEspecificos</a></div><br/>'\
'<form method="POST" action="'+pklist+'" class="button-to">'\
'<input type="hidden" name="_method" value="DELETE" />'\
'<input class="delete-button" onclick="return confirm(\'Are you sure?\');" value="delete" type="submit" '\
'style="background-color: transparent; float:left; border:0; color: #286571; display: inline; margin: 0; padding: 0;"/>'\
'</form>'\
'</div></div>'
return value
def calcularimpacto(self, **kw):
"""ids[] es un vector en el cual se guardaran los 'id' """
ids = []
itemraiz = DBSession.query(Item).filter_by(id=kw['iid']).first()
ids.append(itemraiz)
impacto = 0
relacionesTotal = []
self.recorrerArbolAtras(ids, itemraiz, relacionesTotal)
self.recorrerArbolAdelante(ids, itemraiz, relacionesTotal)
for item in ids:
complejidad = int(item.complejidad)
impacto = impacto + complejidad
nodosporfase = []
while len(ids) != 0:
aux = []
for item in ids:
if ids[0].idFase == item.idFase:
aux.append(item)
for item in aux:
ids.remove(item)
nodosporfase.append(aux)
self.dibujar(relacionesTotal, nodosporfase, itemraiz)
flash("El impacto de modificar el item \"" + itemraiz.nombre +
"\" es: " + str(impacto))
#redirect('/item/?fid='+str(fid[0]))
return dict(link={'url': '/item/?fid=' + str(itemraiz.idFase)})
def dibujar(self, *args):
"""Dibuja un grafo dirigido a partir de una matriz de relaciones
y una matriz de nodos"""
relaciones = args[0]
nodosporfase = args[1]
itemraiz = args[2]
g = self.grafo_de_relaciones(relaciones)
for fase in nodosporfase:
subg = pydot.Subgraph('', rank='same')
nombreFase = DBSession.query(
Fase.nombre).filter_by(id=fase[0].idFase).first()
subg.add_node(pydot.Node(nombreFase[0],label=nombreFase[0],\
color='white'))
for nodo in fase:
if nodo == itemraiz:
subg.add_node(pydot.Node(nodo.id,\
label=str(nodo.nombre)+"\nPeso: "+str(nodo.complejidad),\
color='PaleGreen3', style='filled'))
else:
subg.add_node(pydot.Node(nodo.id,\
label=str(nodo.nombre)+"\nPeso: "+str(nodo.complejidad),\
color='NavajoWhite1', style='filled'))
g.add_subgraph(subg)
g.write_png('sap/public/images/example2_graph.png')
class LineaBaseForm(TableForm):
#action = 'CrearLineaBase'
#genre_options = [x for x in (DBSession.query(Group).filter_by(group_name="lider").one()).users]
item_options = [x for x in (DBSession.query(Item.id, Item.nombre))]
fields = [
TextField('nombre', label_text='Nombre'),
TextField('idFase', label_text='idFase'),
Spacer(),
#TextField('idItem', label_text='idItem'),
MultipleSelectField('idItem', options=item_options,
label_text='Items'),
#SingleSelectField('idItem', options=item_options),
Spacer(),
TextField('estado', label_text='estado'),
Spacer(),
CalendarDatePicker('fechaCreacion', date_format='%d-%m-%y'),
Spacer(),
#SingleSelectField('liderProyecto', options=genre_options),
#TextField('liderProyecto', label_text='Lider de Proyecto')
]
submit_text = 'Crear LineaBase'
def _do_get_provider_count_and_objs(self, **kw):
limit = kw.get('limit', None)
offset = kw.get('offset', None)
order_by = kw.get('order_by', None)
desc = kw.get('desc', False)
#objs = DBSession.query(self.__entity__).filter_by(idFase=1).all()
if len(kw) > 0:
objs = DBSession.query(
self.__entity__).filter_by(iditem=kw['iid']).all()
else:
objs = DBSession.query(self.__entity__).all()
count = len(objs)
self.__count__ = count
return count, objs
def recorrerArbolAtras(self, *args):
ids = args[0]
itemraiz = args[1]
"""-------------Obtiene de la BD las relaciones actuales del nodo en cuestion---"""
relaciones = DBSession.query(RelacionItem.idItem1,RelacionItem.idItem2).\
filter((RelacionItem.idItem1==itemraiz)).all()
"""------------------------------------------------------------------------"""
for relacion in relaciones:
itemrelacion = DBSession.query(Item).filter_by(
id=relacion.idItem2).first()
if itemrelacion.ultimaversion == 1:
if (ids.count(itemrelacion.id) < 1):
ids.append(itemrelacion.id)
self.recorrerArbolAtras(ids, itemrelacion.id)
def new(self, tid=None, *args, **kw):
"""Display a page to show a new record."""
fid = DBSession.query(TipoDeItem.idFase).filter_by(id=tid).first()
"""Extra los campos del tipo de Item elegido """
"""fields=[]
campotipo= DBSession.query(Campos.tipoDeDato, Campos.nombre).filter_by(idTipoDeItem=13).all()
for ct in campotipo:
#log.debug(ct[1])
campo1 = TextField(ct[1], label_text= ct[1])
fields.append(campo1)
item_add_form = ItemForm('create_item_form', fields)
tmpl_context.widget = item_add_form
"""
tmpl_context.widget = self.new_form
#return dict(value=kw, model=self.model.__name__)
#child_args=dict(child_args=form_fields_dict)
return dict(value={
'idTipoDeItem': tid,
'idFase': fid,
},
model=self.model.__name__)
def _do_get_provider_count_and_objs(self, **kw):
limit = kw.get('limit', None)
offset = kw.get('offset', None)
order_by = kw.get('order_by', None)
desc = kw.get('desc', False)
if len(kw) > 0:
objs = DBSession.query(self.__entity__).filter((
Proyecto.liderProyecto == request.identity['repoze.who.userid']
) & (Proyecto.nombre.ilike('%' + str(kw['buscar']) + '%'))).all()
else:
objs = DBSession.query(self.__entity__).filter_by(
liderProyecto=request.identity['repoze.who.userid']).all()
count = len(objs)
self.__count__ = count
return count, objs
def _do_get_provider_count_and_objs(self, **kw):
limit = kw.get('limit', None)
offset = kw.get('offset', None)
order_by = kw.get('order_by', None)
desc = kw.get('desc', False)
if len(kw) > 0:
"""Filtra para que liste solo las lineas bases que pertenece a la fase elegida """
objs = DBSession.query(
self.__entity__).filter_by(idFase=kw['fid']).all()
else:
objs = DBSession.query(self.__entity__).all()
count = len(objs)
self.__count__ = count
return count, objs
def post_delete(self, *args, **kw):
"""This is the code that actually deletes the record"""
pks = self.provider.get_primary_fields(self.model)
d = {}
for i, arg in enumerate(args):
d[pks[i]] = arg
"""extraer el idFase para poder retornar en el estado anterior """
idfase = DBSession.query(Item.idFase).filter_by(id=d['id']).first()
"""------------------------------------------------------------"""
"""Se crea objeto y cambia de estado """
itemeDelete = DBSession.query(Item).filter_by(id=d['id']).first()
itemeDelete.estado = "borrado"
itemeDelete.ultimaversion = 0
DBSession.add(itemeDelete)
"""---------Se borra las relaciones del Item Borrado--------------"""
relaciones = DBSession.query(
RelacionItem).filter((RelacionItem.idItem1 == d['id'])
| (RelacionItem.idItem2 == d['id'])).all()
longitud = len(relaciones)
for x in range(longitud):
DBSession.delete(relaciones[x])
"""---------------------------------------------------------------"""
#self.provider.delete(self.model, d)
#self.provider.delete(self.model, d)
#redirect('./' + '../' * (len(pks) - 1))
raise redirect('/item/?fid=' + str(idfase[0]))
def new(self, *args, **kw):
"""Display a page to show a new record."""
tmpl_context.widget = self.new_form
lideres = [x for x in (DBSession.query(Group).filter_by(group_name="lider").one()).users]
return dict(value=kw, model=self.model.__name__, lider_options=lideres)
def _do_get_provider_count_and_objs(self ,**kw):
limit = kw.get('limit', None)
offset = kw.get('offset', None)
order_by = kw.get('order_by', None)
desc = kw.get('desc', False)
if len(kw) > 0:
if len(kw) > 1:
objs = DBSession.query(self.__entity__).filter((Fase.idproyec==kw['pid']) & (Fase.nombre.ilike('%'+str(kw['buscar'])+'%'))).all()
else:
objs = DBSession.query(self.__entity__).filter_by(idproyec=kw['pid']).all()
else:
#objs = DBSession.query(self.__entity__).filter_by(idproyec=kw[result['pid']]).all()
objs = DBSession.query(self.__entity__).all()
count = len(objs)
self.__count__ = count
return count, objs
def post(self, *args, **kw):
userfile = kw['userfile']
log.debug("kwwww: %s" % kw)
forbidden_files = [".js", ".htm", ".html"]
for forbidden_file in forbidden_files:
if userfile.filename.find(forbidden_file) != -1:
return redirect("/adjuntos/new")
filecontent = userfile.file.read()
new_file = Adjuntos(filename=userfile.filename,
filecontent=filecontent)
DBSession.add(new_file)
DBSession.flush()
redirect("/adjuntos/new")
#self.provider.create(self.model, params=kw)
raise redirect('/adjuntos/new')
