def test_user_doesnt_have_all_permissions(self):
environ = make_environ('gustavo',
permissions=['watch-tv', 'party', 'eat'])
p = predicates.has_any_permission('jump', 'scream')
self.eval_unmet_predicate(
p, environ, 'The user must have at least one of the following '
'permissions: jump, scream')
class AttributController(CrudRestController):
allow_only = has_any_permission(gl.perm_admin, gl.perm_user)
model = Attributs
table = attribut_table
table_filler = attribut_table_filler
edit_form = attribut_edit_form
new_form = new_attribut_form
edit_filler = attribut_edit_filler
@with_trailing_slash
@expose('biorepo.templates.list')
@expose('json')
def get_all(self, *args, **kw):
user = handler.user.get_user_in_session(request)
# user attributs
#to block to one specific user
attributs = DBSession.query(Attributs).all()
all_attributs = [
util.to_datagrid(attribut_grid, attributs, "Attributs Table",
len(attributs) > 0)
]
return dict(page='attributs',
model='attribut',
form_title="new attribut",
items=all_attributs,
value=kw)
@expose('genshi:tgext.crud.templates.new')
def new(self, *args, **kw):
tmpl_context.widget = new_attribut_form
#take the logged user
user = handler.user.get_user_in_session(request)
#take the logged user samples
samples = DBSession.query(Samples).join(Projects).join(User).filter(
User.id == user.id).all()
meas = DBSession.query(Measurements).all()
attributs = DBSession.query(Attributs).all()
tmpl_context.samples = samples
tmpl_context.meas = meas
tmpl_context.attributs = attributs
return dict(page='samples',
value=kw,
title='New Sample',
model='Sample')
@expose('genshi:tgext.crud.templates.edit')
def edit(self, *args, **kw):
tmpl_context.widget = attribut_edit_form
user = handler.user.get_user_in_session(request)
attribut = DBSession.query(Attributs).filter(
Attributs.id == args[0]).first()
@expose('genshi:tgext.crud.templates.get_delete')
def get_delete(self, *args, **kw):
return CrudRestController.get_delete(self, *args, **kw)
def test_check_authorization(self):
logger = FakeLogger()
environ = make_environ('gustavo',
permissions=['watch-tv', 'party', 'eat'])
environ['repoze.who.logger'] = logger
p = has_any_permission('party', 'scream')
check_authorization(p, environ)
info = logger.messages['info']
assert "Authorization granted" == info[0]
def test_check_authorization(self):
logger = FakeLogger()
environ = make_environ('gustavo', permissions=['watch-tv', 'party',
'eat'])
environ['repoze.who.logger'] = logger
p = has_any_permission('party', 'scream')
check_authorization(p, environ)
info = logger.messages['info']
assert "Authorization granted" == info[0]
class ReflectController(BaseController):
allow_only = has_any_permission(constants.permissions['admin']['name'],
constants.permissions['read']['name'])
@expose()
def links(self, name, assembly_id):
url = '%s/%s/%s?name=%s' % (reflect_server, reflect_api, reflect_popup,
name)
u = urllib2.urlopen(url)
return u
def __call__(self, environ, start_response):
"""Invoke the Controller"""
# TGController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
request.identity = request.environ.get('repoze.who.identity')
# para acceder mas rapido a este componente
request.credentials = request.environ.get('repoze.what.credentials')
request.puede_gestion_conf = False
request.puede_desarrollo = False
if request.credentials:
username = request.credentials["repoze.what.userid"]
usuario = model.Usuario.by_user_name(username)
request.puede_proyecto = False
request.puede_rol = False
request.puede_fase = False
request.puede_ti = False
request.puede_busqueda = False
if AlgunPermiso(tipo="Rol").is_met(request.environ):
request.puede_rol = True
perms = request.credentials["permissions"]
if perms.count("crear proyecto") or \
perms.count("modificar proyecto") or \
perms.count("eliminar proyecto"):
request.puede_proyecto = True
if perms.count("modificar fase"):
request.puede_fase = True
if perms.count("crear tipo item") or \
perms.count("redefinir tipo item"):
request.puede_ti = True
if AlgunPermiso(tipo="Usuario").is_met(request.environ):
request.puede_busqueda = True
if AlgunPermiso(tipo="Tipo").is_met(request.environ):
request.puede_desarrollo = True
if has_any_permission(u"crear lb", u"abrir-cerrar lb",
u"consultar lb").is_met(request.environ):
request.puede_gestion_conf = True
tmpl_context.identity = request.identity
# session['atras'] = session['actual']
# session['actual'] = session['adelante']
session.save()
return TGController.__call__(self, environ, start_response)
def __call__(self, environ, start_response):
"""Invoke the Controller"""
# TGController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
request.identity = request.environ.get('repoze.who.identity')
# para acceder mas rapido a este componente
request.credentials = request.environ.get('repoze.what.credentials')
request.puede_gestion_conf = False
request.puede_desarrollo = False
if request.credentials:
username = request.credentials["repoze.what.userid"]
usuario = model.Usuario.by_user_name(username)
request.puede_proyecto = False
request.puede_rol = False
request.puede_fase = False
request.puede_ti = False
request.puede_busqueda = False
if AlgunPermiso(tipo="Rol").is_met(request.environ):
request.puede_rol = True
perms = request.credentials["permissions"]
if perms.count("crear proyecto") or \
perms.count("modificar proyecto") or \
perms.count("eliminar proyecto"):
request.puede_proyecto = True
if perms.count("modificar fase"):
request.puede_fase = True
if perms.count("crear tipo item") or \
perms.count("redefinir tipo item"):
request.puede_ti = True
if AlgunPermiso(tipo="Usuario").is_met(request.environ):
request.puede_busqueda = True
if AlgunPermiso(tipo="Tipo").is_met(request.environ):
request.puede_desarrollo = True
if has_any_permission(u"crear lb", u"abrir-cerrar lb",
u"consultar lb").is_met(request.environ):
request.puede_gestion_conf = True
tmpl_context.identity = request.identity
# session['atras'] = session['actual']
# session['actual'] = session['adelante']
session.save()
return TGController.__call__(self, environ, start_response)
class WorkerController(BaseController):
allow_only = has_any_permission(constants.permissions['admin']['name'],
constants.permissions['read']['name'])
def index(self, *args, **kw):
print 'worker received : args : %s, kw : %s' % (args, kw)
pass
@expose('json')
def new_selection(self, project_id, s, job_name, job_description, *args,
**kw):
'''
Called by the browser. Transform a selection to a new track;
'''
user = handler.user.get_user_in_session(request)
sels = json.loads(s)
project = DBSession.query(Project).filter(
Project.id == project_id).first()
if project is None:
return {'error': "project id %s doesn't exist" % project_id}
path = track.common.temporary_path()
with track.new(path, 'sql') as t:
t.fields = simple_fields
for chromosome in sels:
t.write(chromosome,
((marquee['start'], marquee['end'], 0, '', 0, '')
for marquee in sels[chromosome]))
t.datatype = constants.FEATURES
t.assembly = project.sequence.name
task_id, track_id = handler.track.create_track(
user.id,
project.sequence,
f=path,
trackname='%s %s' % (job_name, job_description),
project=project)
if task_id == constants.NOT_SUPPORTED_DATATYPE:
return {'error': "not supported datatype" % project_id}
job_id = handler.job.new_sel(user.id,
project.id,
job_description,
job_name,
task_id=task_id)
return {
'job_id': job_id,
'job_name': job_name,
'job_description': job_description,
'status': 'RUNNING'
}
@expose('json')
def status(self, job_id, *args, **kw):
try:
job_id = int(job_id)
job = DBSession.query(Job).filter(Job.id == job_id).first()
return {
'job_id': job.id,
'status': job.status,
'output': job.output,
'error': job.traceback
}
except ValueError:
pass
return {}
@expose('json')
def new_gfeatminer_job(self, project_id, job_description, job_name, data,
*args, **kw):
print 'new_gfeatminer_job pid : %s, data : %s, args : %s, kw : %s, job_name : %s, job_description : %s' % (
project_id, data, args, kw, job_name, job_description)
user = handler.user.get_user_in_session(request)
try:
data = json.loads(data)
except Exception as e:
return {
'error': 'error when loading job in GDV',
'trace': e.message
}
try:
handler.job.parse_args(data)
except IndexError as e:
return {'error': 'you did not specified a requested parameter'}
except Exception as e:
return {
'error': 'error when parsing job in GDV',
'trace': e.message
}
try:
job_id = handler.job.new_job(user.id, project_id, job_name,
job_description, data, *args, **kw)
except Exception as e:
etype, value, tb = sys.exc_info()
traceback.print_exception(etype, value, tb)
return {
'error': 'error when launching job in GDV',
'trace': e.message
}
return {
'job_id': job_id,
'job_name': job_name,
'job_description': job_description,
'status': 'RUNNING'
}
class UsersController(BaseController):
allow_only = authorize.not_anonymous()
@expose('sapns/users/edit.html')
@require(predicates.not_anonymous())
@add_language
def edit(self, cls, id_, **params):
user = dbs.query(SapnsUser).get(request.identity['user'].user_id)
id_user = int(id_)
is_manager = u'managers' in request.identity['groups']
if user.user_id != id_user and not is_manager:
redirect(url('/error'))
user = dbs.query(SapnsUser).get(id_user)
return dict(user=user, came_from=params.get('came_from'))
@expose('sapns/users/edit.html')
@require(predicates.has_any_permission('manage', 'users'))
def new(self, cls, **params):
came_from = params.get('came_from', '/dashboard/users')
return dict(user={}, came_from=url(came_from))
@expose('json')
@require(predicates.has_any_permission('manage', 'users'))
def save(self, **params):
logger = logging.getLogger('UsersController.save')
try:
#logger.info(params)
id_ = get_paramw(params, 'id', int, opcional=True)
display_name = get_paramw(params, 'display_name', unicode)
user_name = get_paramw(params, 'user_name', unicode)
email_address = get_paramw(params, 'email_address', unicode)
password = get_paramw(params, 'password', unicode, opcional=True)
copy_from = get_paramw(params, 'copy_from', int, opcional=True)
new_user = False
if id_:
user = dbs.query(SapnsUser).get(id_)
else:
new_user = True
user = SapnsUser()
user.display_name = display_name
# user_name
another = dbs.query(SapnsUser).\
filter(and_(SapnsUser.user_id != user.user_id,
SapnsUser.user_name == user_name,
)).\
first()
if another:
raise EUser(_('"User name" is already in use'))
# email_address
another = dbs.query(SapnsUser).\
filter(and_(SapnsUser.user_id != user.user_id,
SapnsUser.email_address == email_address,
)).\
first()
if another:
raise EUser(_('"E-mail address" is already in use'))
# user_name
user.user_name = user_name
# email_address
user.email_address = email_address
if password:
user.password = password
dbs.add(user)
dbs.flush()
# copy shortcuts and privileges form another user
if new_user:
user.copy_from(copy_from)
return dict(status=True)
except EUser, e:
logger.error(e)
return dict(status=False, message=unicode(e))
except Exception, e:
logger.error(e)
return dict(status=False)
class TreeviewController(BaseController):
allow_only = has_any_permission(gl.perm_admin, gl.perm_user)
@with_trailing_slash
@expose('biorepo.templates.treeview')
@expose('json')
def index(self, *args, **kw):
user_lab = session.get("current_lab", None)
user_projects = []
u_projects = []
u_samples = []
u_meas = []
u_children = []
u_global = []
dico_final = {}
#TODO : admin view - watch for a dl link
if user_lab:
lab = DBSession.query(Labs).filter(Labs.name == user_lab).first()
lab_users = lab.users
for u in lab_users:
projects = DBSession.query(Projects).filter(
Projects.user_id == u.id).all()
if len(projects) > 0:
for p in projects:
for lab in p.labs:
if lab.name == user_lab:
user_projects.append(p)
for proj in user_projects:
for sample in proj.samples:
if len(sample.measurements) > 0:
for meas in sample.measurements:
if len(meas.children) == 0:
u_meas.append({
"name":
str(meas.name) + "(" +
str(meas.id) + ")"
})
else:
for child in meas.children:
u_children.append({
"name":
str(child.name) + "(" +
str(child.id) + ")"
})
u_meas.append({
"name":
str(meas.name) + "(" +
str(meas.id) + ")",
"children":
u_children
})
u_children = []
u_samples.append({
"name":
str(sample.name) + "(" + str(sample.type) +
")",
"children":
u_meas
})
u_meas = []
else:
u_samples.append({
"name":
str(sample.name + "(" + str(sample.type) +
")")
})
if len(proj.samples) > 0:
u_projects.append({
"name": str(proj.project_name),
"children": u_samples
})
u_samples = []
else:
u_projects.append({"name": str(proj.project_name)})
u_global.append({
"name": u.firstname + " " + u.name,
"children": u_projects
})
u_projects = []
user_projects = []
#uncomment these 4 lines if you want to see every lab users registered in BioRepo
#else:
#u_global.append({"name": u.firstname + " " + u.name})
#u_projects = []
#user_projects = []
dico_final["name"] = user_lab
dico_final["children"] = u_global
return {"data": json.dumps(dico_final)}
class ProjectController(BaseController):
allow_only = has_any_permission(constants.permissions['admin']['name'],
constants.permissions['read']['name'])
@expose('pygdv.templates.project_new')
def new(self, *args, **kw):
new_form = form.NewProject(action=url('/projects/create')).req()
species = DBSession.query(Species).all()
sp_opts = [(sp.id, sp.name) for sp in species]
new_form.child.children[2].options = sp_opts
mapping = json.dumps(
dict([(sp.id,
[(seq.id, seq.name) for seq in sp.sequences
if seq.public or handler.genrep.checkright(seq, user)])
for sp in species]))
new_form.value = {'smapping': mapping}
return dict(page='projects', widget=new_form)
@with_trailing_slash
@expose('pygdv.templates.project_edit')
def edit(self, *args, **kw):
user = handler.user.get_user_in_session(request)
if request.method == 'GET':
project_id = args[0]
else:
project_id = kw.get('pid')
debug("check permission", 1)
if not checker.check_permission(
user=user,
project_id=project_id,
right_id=constants.right_upload_id) and not checker.is_admin(
user=user):
flash(
'You must have %s permission to edit the project.' %
constants.right_upload, 'error')
raise redirect('/tracks/', {'pid': project_id})
#if checker.is_admin(user=user):
#user = DBSession.query(User).join(Project).filter(Project.id == project_id).first()
widget = form.EditProject(action=url('/projects/edit/%s' %
project_id)).req()
widget.value = {'pid': project_id}
project = DBSession.query(Project).filter(
Project.id == project_id).first()
# prendre les user tracks du meme sequence id
tracks = DBSession.query(Track).join(User.tracks).filter(
and_(User.id == user.id, Track.sequence_id == project.sequence_id,
not_(Track.id.in_([t.id for t in project.tracks])))).all()
# prendre les sared tracks du meme sequence id
shared_tracks = handler.user.shared_tracks(
user.id, constants.rights['download']['id'])
shared_tracks = [
t for t in shared_tracks
if (t.sequence_id == project.sequence_id
and t.id not in [tr.id for tr in project.tracks])
]
tracks.extend(shared_tracks)
if request.method == 'GET':
debug("GET", 2)
widget.child.children[1].value = project.name
widget.child.children[2].options = [('', '')] + [
(t.id, t.name) for t in tracks
] + [(t.id, t.name, {
'selected': True
}) for t in project.tracks]
return dict(page='tracks', widget=widget, project_id=project_id)
debug("POST", 2)
try:
debug("validate post", 2)
widget.validate(kw)
except twc.ValidationError as e:
debug("error", 2)
w = e.widget
w.child.children[1].value = project.name
w.child.children[2].options = [(t.id, t.name) for t in tracks
] + [(t.id, t.name, {
'selected': True
}) for t in project.tracks]
return dict(page='tracks', widget=w, project_id=project_id)
debug("validation passed")
track_ids = kw.get('tracks', [])
if not track_ids:
track_ids = []
if not isinstance(track_ids, list):
track_ids = [track_ids]
if len(track_ids) > 0 and '' in track_ids:
track_ids.remove('')
# if the project is shared, some track cannot be removed
for t in project.tracks:
if not checker.user_own_track(
user.id, track=t) and t.id not in track_ids and t.id in [
s.id for s in shared_tracks
]:
track_ids.append(t.id)
handler.project.e(project_id=project_id,
name=kw.get('name'),
track_ids=track_ids)
raise redirect('/tracks/', {'pid': project_id})
@expose('json')
def get(self, project_key=None, project_id=None, **kw):
# get all user projects
if not project_key and not project_id:
user = handler.user.get_user_in_session(request)
projects = DBSession.query(Project).filter(
Project.user_id == user.id).all()
return reply.normal(request,
'You can upload track on these projects',
'/tracks', {'projects': projects})
project = None
# get one specific user project
if project_id is not None and project_id:
user = handler.user.get_user_in_session(request)
project = DBSession.query(Project).filter(
Project.id == int(project_id)).first()
if project is not None and not project.user_id == user.id:
reply.error(request, 'Not your project', '/tracks', {})
return reply.normal(request,
'You can upload track on this project',
'/tracks', {'project': project})
# get a project by it's key
project = DBSession.query(Project).filter(
Project.key == project_key).first()
if project is None:
return reply.error(request, 'Wrong key', '/tracks', {})
return reply.normal(request, 'You can upload track on this project',
'/tracks', {'project': project})
@expose('json')
def create(self, *args, **kw):
print 'create %s, %s' % (args, kw)
user = handler.user.get_user_in_session(request)
if not 'name' in kw:
return reply.error(request, 'Missing project `name`.',
url('/tracks'), {})
if not 'assembly' in kw:
return reply.error(request,
'Missing project `assembly` identifier.',
url('/tracks'), {})
sequence = DBSession.query(Sequence).filter(
Sequence.id == int(kw.get('assembly'))).first()
if sequence is None:
return reply.error(request, "Assembly doesn't exist in GDV.", './',
{})
project = handler.project.create(kw['name'], kw['assembly'], user.id)
return reply.normal(request, 'Project successfully created.',
url('/tracks'), {'project': project})
@expose()
def post(self, *args, **kw):
return self.create(*args, **kw)
@expose('json')
def delete(self, *args, **kw):
user = handler.user.get_user_in_session(request)
if len(args) > 0:
project_id = args[0]
if not checker.check_permission(
user=user,
project_id=project_id,
right_id=constants.right_upload_id
) and not checker.is_admin(user=user):
return reply.error(
request,
"You must have %s permission to delete the project." %
constants.right_upload, '/tracks',
{'error': 'wrong credentials'})
handler.project.delete(project_id=project_id)
return reply.normal(request, 'Project successfully deleted.',
'/tracks', {'success': 'project deleted'})
@expose('pygdv.templates.project_sharing')
def share(self, *args, **kw):
user = handler.user.get_user_in_session(request)
if request.method == 'GET':
project_id = args[0]
else:
project_id = kw.get('pid')
if not checker.check_permission(
user=user,
project_id=project_id,
right_id=constants.right_upload_id) and not checker.is_admin(
user=user):
flash('You must have %s permission to share the project',
'error') % constants.right_upload
raise redirect('/tracks', {'pid': project_id})
project = DBSession.query(Project).filter(
Project.id == project_id).first()
widget = form.ShareProject(action=url('/projects/share/%s' %
project_id))
# public url
pub = url('/public/project', {'id': project_id, 'k': project.key})
# download url
if project.download_key is None:
project.download_key = project.setdefaultkey()
down = url('/public/project', {
'id': project_id,
'k': project.download_key
})
widget.value = {'pid': project_id}
tl = handler.help.help_address(url('help'), '#share',
'sharing projects')
if request.method == 'POST':
if kw.has_key('rights'):
rights_checkboxes = kw.get('rights_checkboxes', None)
if rights_checkboxes is not None:
if not isinstance(rights_checkboxes, list):
rights_checkboxes = [rights_checkboxes]
handler.project.change_rights(kw.get('pid'),
kw.get('cid'),
rights=rights_checkboxes)
else:
handler.project.change_rights(kw.get('pid'), kw.get('cid'))
else:
circle_ids = kw.get('circles', [])
if not circle_ids: circle_ids = []
if not isinstance(circle_ids, list):
circle_ids = [circle_ids]
if len(circle_ids) > 0 and '' in circle_ids:
circle_ids.remove('')
handler.project.e(project=project, circle_ids=circle_ids)
debug(project.get_circle_with_right_display)
cr_data = [
util.to_datagrid(datagrid.project_sharing, project.circles_rights,
"Sharing",
len(project.circles_rights) > 0)
]
widget.child.children[1].options = [('','')] + [(c.id, c.name) for c in user.circles_sharing if c not in project.shared_circles] +\
[(c.id, c.name, {'selected': True}) for c in project.shared_circles]
return dict(page='projects',
public=pub,
download=down,
name=project.name,
tooltip_links=tl,
widget=widget,
items=cr_data,
project_id=project_id)
@expose('pygdv.templates.view')
def view(self, project_id, *args, **kw):
debug('VIEW')
user = handler.user.get_user_in_session(request)
if not checker.check_permission(
project_id=project_id,
user=user,
right_id=constants.rights['read']['id']):
flash(
'You must have %s permission to view the project.' %
constants.right_read, 'error')
raise redirect(url('/'))
d = handler.view.prepare_view(project_id, *args, **kw)
response.headerlist.append(('Access-Control-Allow-Origin', '*'))
return d
@require(has_permission('admin', msg='Only for admins'))
@expose('pygdv.templates.admin_project')
def admin(self):
projects = DBSession.query(Project).all()
data_projects = [
util.to_datagrid(project_admin_grid, projects, "All projects",
len(projects) > 0)
]
t = handler.help.tooltip['project']
return dict(page='projects',
model='project',
tooltip=t,
form_title="new project",
projects=data_projects,
value={})
# copy shortcuts and privileges form another user
if new_user:
user.copy_from(copy_from)
return dict(status=True)
except EUser, e:
logger.error(e)
return dict(status=False, message=unicode(e))
except Exception, e:
logger.error(e)
return dict(status=False)
@expose('sapns/users/permission.html')
@require(predicates.has_any_permission('manage', 'users'))
def permission(self, came_from='/dashboard/users'):
return dict(came_from=url(came_from))
@expose('sapns/users/roles.html')
@require(predicates.has_any_permission('manage', 'users'))
@add_language
def roles(self, id_user, **kw):
logger = logging.getLogger('UsersController.roles')
try:
user = dbs.query(SapnsUser).get(int(id_user))
roles = []
for r in dbs.query(SapnsRole).order_by(SapnsRole.group_name):
#r = SapnsRole()
class RolController(BaseController):
@expose()
def index(self):
"""Muestra la pantalla inicial"""
return dict(nombre_modelo='Rol', page='index_rol')
@expose('is2sap.templates.rol.nuevo')
@require(predicates.has_permission('administracion', msg=l_('Solo para el Administrador')))
def nuevo(self, **kw):
"""Despliega el formulario para añadir un nuevo Rol."""
try:
tmpl_context.form = crear_rol_form
except SQLAlchemyError:
flash(_("No se pudo acceder a Creacion de Roles! SQLAlchemyError..."), 'error')
redirect("/admin/rol/listado")
except (AttributeError, NameError):
flash(_("No se pudo acceder a Creacion de Roles! Hay Problemas con el servidor..."), 'error')
redirect("/admin/rol/listado")
return dict(nombre_modelo='Rol', page='nuevo_rol', value=kw)
@validate(crear_rol_form, error_handler=nuevo)
@expose()
@require(predicates.has_permission('administracion', msg=l_('Solo para el Administrador')))
def add(self, **kw):
"""Metodo para agregar un registro a la base de datos """
try:
rol = Rol()
rol.tipo = kw['tipo']
rol.nombre_rol = kw['nombre_rol']
rol.descripcion = kw['descripcion']
DBSession.add(rol)
DBSession.flush()
transaction.commit()
except IntegrityError:
transaction.abort()
flash(_("No se ha guardado! Hay Problemas con el servidor..."), 'error')
redirect("/admin/rol/listado")
except SQLAlchemyError:
flash(_("No se ha guardado! SQLAlchemyError..."), 'error')
redirect("/admin/rol/listado")
except (AttributeError, NameError):
flash(_("No se ha guardado! Hay Problemas con el servidor..."), 'error')
redirect("/admin/rol/listado")
else:
flash(_("Rol creado!"), 'ok')
redirect("/admin/rol/listado")
@expose("is2sap.templates.rol.listado")
@require(predicates.has_any_permission('administracion'))
def listado(self,page=1):
"""Metodo para listar todos los Roles existentes de la base de datos"""
try:
roles = DBSession.query(Rol).order_by(Rol.id_rol)
currentPage = paginate.Page(roles, page, items_per_page=10)
except SQLAlchemyError:
flash(_("No se pudo acceder a Roles! SQLAlchemyError..."), 'error')
redirect("/admin")
except (AttributeError, NameError):
flash(_("No se pudo acceder a Roles! Hay Problemas con el servidor..."), 'error')
redirect("/admin")
return dict(roles=currentPage.items, page='listado_rol', currentPage=currentPage)
@expose('is2sap.templates.rol.editar')
@require(predicates.has_permission('administracion', msg=l_('Solo para el Administrador')))
def editar(self, id_rol, **kw):
"""Metodo que rellena el formulario para editar los datos de un Rol"""
try:
tmpl_context.form = editar_rol_form
traerRol = DBSession.query(Rol).get(id_rol)
kw['id_rol'] = traerRol.id_rol
kw['tipo'] = traerRol.tipo
kw['nombre_rol'] = traerRol.nombre_rol
kw['descripcion'] = traerRol.descripcion
except SQLAlchemyError:
flash(_("No se pudo acceder a Edicion de Roles! SQLAlchemyError..."), 'error')
redirect("/admin/rol/listado")
except (AttributeError, NameError):
flash(_("No se pudo acceder a Edicion de Roles! Hay Problemas con el servidor..."), 'error')
redirect("/admin/rol/listado")
return dict(nombre_modelo='Rol', page='editar_rol', value=traerRol)
@validate(editar_rol_form, error_handler=editar)
@expose()
@require(predicates.has_permission('administracion', msg=l_('Solo para el Administrador')))
def update(self, **kw):
"""Metodo que actualizar la base de datos"""
try:
rol = DBSession.query(Rol).get(kw['id_rol'])
rol.tipo=kw['tipo']
rol.nombre_rol=kw['nombre_rol']
rol.descripcion = kw['descripcion']
DBSession.flush()
transaction.commit()
except IntegrityError:
transaction.abort()
flash(_("No se han guardado los cambios! Hay Problemas con el servidor..."), 'error')
redirect("/admin/rol/listado")
except SQLAlchemyError:
flash(_("No se han guardado los cambios! SQLAlchemyError..."), 'error')
redirect("/admin/rol/listado")
except (AttributeError, NameError):
flash(_("No se han guardado los cambios! Hay Problemas con el servidor..."), 'error')
redirect("/admin/rol/listado")
else:
flash(_("Se han guardado los cambios!"), 'ok')
redirect("/admin/rol/listado")
@expose('is2sap.templates.rol.confirmar_eliminar')
@require(predicates.has_permission('administracion', msg=l_('Solo para el Administrador')))
def confirmar_eliminar(self, id_rol, **kw):
"""Despliega confirmacion de eliminacion"""
try:
rol=DBSession.query(Rol).get(id_rol)
except SQLAlchemyError:
flash(_("No se pudo acceder a Eliminacion de Roles! SQLAlchemyError..."), 'error')
redirect("/admin/rol/listado")
except (AttributeError, NameError):
flash(_("No se pudo acceder a Eliminacion de Roles! Hay Problemas con el servidor..."), 'error')
redirect("/admin/rol/listado")
return dict(nombre_modelo='Rol', page='eliminar_rol', value=rol)
@expose()
@require(predicates.has_permission('administracion', msg=l_('Solo para el Administrador')))
def delete(self, id_rol, **kw):
"""Metodo que elimina un registro de la base de datos"""
try:
DBSession.delete(DBSession.query(Rol).get(id_rol))
DBSession.flush()
transaction.commit()
except IntegrityError:
transaction.abort()
flash(_("No se ha eliminado! Hay Problemas con el servidor..."), 'error')
redirect("/admin/rol/listado")
except SQLAlchemyError:
flash(_("No se ha eliminado! SQLAlchemyError..."), 'error')
redirect("/admin/rol/listado")
except (AttributeError, NameError):
flash(_("No se ha eliminado! Hay Problemas con el servidor..."), 'error')
redirect("/admin/rol/listado")
else:
flash(_("Rol eliminado!"), 'ok')
redirect("/admin/rol/listado")
@expose("is2sap.templates.rol.listar_permisos")
@require(predicates.has_permission('administracion', msg=l_('Solo para el Administrador')))
def permisos(self, id_rol, page=1):
"""Metodo para listar todos los permisos que tiene el rol seleccionado"""
try:
rol = DBSession.query(Rol).get(id_rol)
permisos = rol.permisos
currentPage = paginate.Page(permisos, page, items_per_page=10)
except SQLAlchemyError:
flash(_("No se pudo acceder a Permisos de Roles! SQLAlchemyError..."), 'error')
redirect("/admin/rol/listado")
except (AttributeError, NameError):
flash(_("No se pudo acceder a Permisos de Roles! Hay Problemas con el servidor..."), 'error')
redirect("/admin/rol/listado")
return dict(permisos=currentPage.items, page='listar_permisos', currentPage=currentPage, rol=rol)
@expose()
@require(predicates.has_permission('administracion', msg=l_('Solo para el Administrador')))
def eliminar_rol_permiso(self, id_rol, id_permiso, **kw):
"""Metodo que elimina un permiso al rol seleccionado"""
try:
permiso = DBSession.query(Permiso).get(id_permiso)
rol = DBSession.query(Rol).get(id_rol)
if permiso.roles.count(rol) >= 1:
permiso.roles.remove(rol)
DBSession.flush()
transaction.commit()
except IntegrityError:
transaction.abort()
flash(_("No se pudo desasignar el Permiso! Hay Problemas con el servidor..."), 'error')
redirect("/admin/rol/permisos", id_rol=id_rol)
except SQLAlchemyError:
flash(_("No se pudo desasignar el Permiso! SQLAlchemyError..."), 'error')
redirect("/admin/rol/permisos", id_rol=id_rol)
except (AttributeError, NameError):
flash(_("No se pudo desasignar el Permiso! Hay Problemas con el servidor..."), 'error')
redirect("/admin/rol/permisos", id_rol=id_rol)
except (ValueError):
redirect("/admin/rol/permisos", id_rol=id_rol)
else:
flash(_("Permiso desasignado!"), 'ok')
redirect("/admin/rol/permisos", id_rol=id_rol)
@expose("is2sap.templates.rol.agregar_permisos")
@require(predicates.has_permission('administracion', msg=l_('Solo para el Administrador')))
def rolPermiso(self, id_rol, page=1):
"""Metodo que permite listar los permisos que se pueden agregar al rol seleccionado"""
try:
rol = DBSession.query(Rol).get(id_rol)
permisosRol = rol.permisos
permisos = DBSession.query(Permiso).all()
for permiso in permisosRol:
if permisos.count(permiso) >= 1:
permisos.remove(permiso)
currentPage = paginate.Page(permisos, page, items_per_page=10)
except SQLAlchemyError:
flash(_("No se pudo acceder a Asignar Permisos! SQLAlchemyError..."), 'error')
redirect("/admin/rol/permisos", id_rol=id_rol)
except (AttributeError, NameError):
flash(_("No se pudo acceder a Asignar Permisos! Hay Problemas con el servidor..."), 'error')
redirect("/admin/rol/permisos", id_rol=id_rol)
return dict(permisos=currentPage.items, page='agregar_permisos',
currentPage=currentPage, id_rol=id_rol, rol=rol)
@expose()
@require(predicates.has_permission('administracion', msg=l_('Solo para el Administrador')))
def agregarPermiso(self, id_rol, id_permiso):
"""Metodo que realiza la agregacion de un permiso al rol selecccionado"""
try:
permiso = DBSession.query(Permiso).get(id_permiso)
rol = DBSession.query(Rol).get(id_rol)
permiso.roles.append(rol)
DBSession.flush()
transaction.commit()
except IntegrityError:
redirect("/admin/rol/rolPermiso",id_rol=id_rol)
except SQLAlchemyError:
flash(_("No se pudo asignar el Permiso! SQLAlchemyError..."), 'error')
redirect("/admin/rol/rolPermiso",id_rol=id_rol)
except (AttributeError, NameError):
flash(_("No se pudo asignar el Permiso! Hay Problemas con el servidor..."), 'error')
redirect("/admin/rol/rolPermiso",id_rol=id_rol)
else:
flash(_("Permiso asignado!"), 'ok')
redirect("/admin/rol/rolPermiso",id_rol=id_rol)
class PermisoController(BaseController):
@expose()
def index(self):
"""Muestra la pantalla inicial"""
return dict(nombre_modelo='Permiso', page='index_permiso')
@expose('is2sap.templates.permiso.nuevo')
@require(
predicates.has_permission('administracion',
msg=l_('Solo para el Administrador')))
def nuevo(self, **kw):
"""Despliega el formulario para añadir un nuevo Permiso."""
try:
tmpl_context.form = crear_permiso_form
except SQLAlchemyError:
flash(
_("No se pudo acceder a Creacion de Permisos! SQLAlchemyError..."
), 'error')
redirect("/admin/permiso/listado")
except (AttributeError, NameError):
flash(
_("No se pudo acceder a Creacion de Permisos! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/permiso/listado")
return dict(nombre_modelo='Permiso', page='nuevo_permiso', value=kw)
@validate(crear_permiso_form, error_handler=nuevo)
@expose()
@require(
predicates.has_permission('administracion',
msg=l_('Solo para el Administrador')))
def add(self, **kw):
"""Metodo para agregar un registro a la base de datos """
try:
permiso = Permiso()
permiso.nombre_permiso = kw['nombre_permiso']
permiso.descripcion = kw['descripcion']
DBSession.add(permiso)
DBSession.flush()
transaction.commit()
except IntegrityError:
transaction.abort()
flash(_("No se ha guardado! Hay Problemas con el servidor..."),
'error')
redirect("/admin/permiso/listado")
except SQLAlchemyError:
flash(_("No se ha guardado! SQLAlchemyError..."), 'error')
redirect("/admin/permiso/listado")
except (AttributeError, NameError):
flash(_("No se ha guardado! Hay Problemas con el servidor..."),
'error')
redirect("/admin/permiso/listado")
else:
flash(_("Permiso creado!"), 'ok')
redirect("/admin/permiso/listado")
@expose("is2sap.templates.permiso.listado")
@require(predicates.has_any_permission('administracion', 'lider_proyecto'))
def listado(self, page=1):
"""Metodo para listar todos los Permisos existentes de la base de datos"""
try:
permisos = DBSession.query(Permiso).order_by(Permiso.id_permiso)
currentPage = paginate.Page(permisos, page, items_per_page=10)
except SQLAlchemyError:
flash(_("No se pudo acceder a Permisos! SQLAlchemyError..."),
'error')
redirect("/admin")
except (AttributeError, NameError):
flash(
_("No se pudo acceder a Permisos! Hay Problemas con el servidor..."
), 'error')
redirect("/admin")
return dict(permisos=currentPage.items,
page='listado_permiso',
currentPage=currentPage)
@expose('is2sap.templates.permiso.editar')
@require(
predicates.has_permission('administracion',
msg=l_('Solo para el Administrador')))
def editar(self, id_permiso, **kw):
"""Metodo que rellena el formulario para editar los datos de un Permiso"""
try:
tmpl_context.form = editar_permiso_form
traerPermiso = DBSession.query(Permiso).get(id_permiso)
kw['id_permiso'] = traerPermiso.id_permiso
kw['nombre_permiso'] = traerPermiso.nombre_permiso
kw['descripcion'] = traerPermiso.descripcion
except SQLAlchemyError:
flash(
_("No se pudo acceder a Edicion de Permisos! SQLAlchemyError..."
), 'error')
redirect("/admin/permiso/listado")
except (AttributeError, NameError):
flash(
_("No se pudo acceder a Edicion de Permisos! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/permiso/listado")
return dict(nombre_modelo='Permiso', page='editar_permiso', value=kw)
@validate(editar_permiso_form, error_handler=editar)
@expose()
@require(
predicates.has_permission('administracion',
msg=l_('Solo para el Administrador')))
def update(self, **kw):
"""Metodo que actualizar la base de datos"""
try:
permiso = DBSession.query(Permiso).get(kw['id_permiso'])
permiso.nombre_permiso = kw['nombre_permiso']
permiso.descripcion = kw['descripcion']
DBSession.flush()
transaction.commit()
except IntegrityError:
transaction.abort()
flash(
_("No se han guardado los cambios! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/permiso/listado")
except SQLAlchemyError:
flash(_("No se han guardado los cambios! SQLAlchemyError..."),
'error')
redirect("/admin/permiso/listado")
except (AttributeError, NameError):
flash(
_("No se han guardado los cambios! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/permiso/listado")
else:
flash(_("Se han guardado los cambios!"), 'ok')
redirect("/admin/permiso/listado")
@expose('is2sap.templates.permiso.confirmar_eliminar')
@require(
predicates.has_permission('administracion',
msg=l_('Solo para el Administrador')))
def confirmar_eliminar(self, id_permiso, **kw):
"""Despliega confirmacion de eliminacion"""
try:
permiso = DBSession.query(Permiso).get(id_permiso)
except SQLAlchemyError:
flash(
_("No se pudo acceder a Eliminacion de Permisos! SQLAlchemyError..."
), 'error')
redirect("/admin/permiso/listado")
except (AttributeError, NameError):
flash(
_("No se pudo acceder a Eliminacion de Permisos! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/permiso/listado")
return dict(nombre_modelo='Permiso',
page='eliminar_permiso',
value=permiso)
@expose()
@require(
predicates.has_permission('administracion',
msg=l_('Solo para el Administrador')))
def delete(self, id_permiso, **kw):
"""Metodo que elimina un registro de la base de datos"""
try:
DBSession.delete(DBSession.query(Permiso).get(id_permiso))
DBSession.flush()
transaction.commit()
except IntegrityError:
transaction.abort()
flash(_("No se ha eliminado! Hay Problemas con el servidor..."),
'error')
redirect("/admin/permiso/listado")
except SQLAlchemyError:
flash(_("No se ha eliminado! SQLAlchemyError..."), 'error')
redirect("/admin/permiso/listado")
except (AttributeError, NameError):
flash(_("No se ha eliminado! Hay Problemas con el servidor..."),
'error')
redirect("/admin/permiso/listado")
else:
flash(_("Permiso eliminado!"), 'ok')
redirect("/admin/permiso/listado")
class CircleController(BaseController):
allow_only = has_any_permission(constants.permissions['admin']['name'], constants.permissions['read']['name'])
def new(self, *args, **kw):
widget = form.NewCircle(action=url('/circles/new')).req()
if request.method == 'GET':
return dict(page='circles', model='circle', widget=widget)
else:
try:
widget.validate(kw)
except twc.ValidationError as e:
return dict(page='circles', model='circle', widget=e.widget)
user = handler.user.get_user_in_session(request)
handler.circle.create(kw['name'], kw['description'], user)
raise redirect('/circles')
@expose('pygdv.templates.circle_index')
@with_trailing_slash
def index(self, *args, **kw):
kw['page'] = 'circle'
user = handler.user.get_user_in_session(request)
data = util.to_datagrid(datagrid.circle_grid, user.circles_owned, grid_display=len(user.circles) > 0)
t = handler.help.help_address(url('/help'), 'circles', 'help about circles')
widget = form.NewCircle(action=url('/circles/index')).req()
if request.method == 'GET':
return dict(page='circles', item=data, tooltip=t, widget=widget)
else:
try:
widget.validate(kw)
except twc.ValidationError as e:
return dict(page='circles', item=data, tooltip=t, widget=e.widget, ac_error=True)
user = handler.user.get_user_in_session(request)
handler.circle.create(kw['name'], kw['description'], user)
data = util.to_datagrid(datagrid.circle_grid, user.circles_owned, grid_display=len(user.circles) > 0)
return dict(page='circles', model='circle', item=data, widget=widget, tooltip=t)
@expose()
def delete(self, circle_id, *args, **kw):
user = handler.user.get_user_in_session(request)
if not checker.user_own_circle(user.id, circle_id):
flash('you have no right to delete this circle: you are not the creator of it')
raise redirect('/circles')
circle = DBSession.query(Circle).filter(Circle.id == circle_id).first()
DBSession.delete(circle)
DBSession.flush()
raise redirect('/circles/')
@expose()
def delete_user(self, id, user_id):
user = handler.user.get_user_in_session(request)
if not checker.user_own_circle(user.id, id):
flash('you have no rights to delete users from this circle: you are not the creator of it')
raise redirect('/circles')
circle = DBSession.query(Circle).filter(Circle.id == id).first()
to_delete = DBSession.query(User).filter(User.id == user_id).first()
circle.users.remove(to_delete)
DBSession.flush()
raise redirect('/circles/edit/%s' % id)
@expose('pygdv.templates.circle_edit')
@with_trailing_slash
def edit(self, *args, **kw):
user = handler.user.get_user_in_session(request)
t = handler.help.tooltip['circledesc']
# get circle id
if request.method == 'GET':
circle_id = args[0]
else:
circle_id = kw.get('cid')
circle_id = int(circle_id)
if circle_id not in [c.id for c in user.circles_owned]:
flash('You have no right to edit this circle', 'error')
raise redirect('/circles/')
circle = DBSession.query(Circle).filter(Circle.id == circle_id).first()
widget = form.AddUser(action=url('/circles/edit/%s' % circle_id)).req()
if request.method == 'POST':
# add user
mail = kw.get('mail')
try:
widget.validate({'cid': circle_id, 'mail': mail})
except twc.ValidationError as e:
for u in circle.users:
u.__dict__['cid'] = circle_id
wrappers = [u for u in circle.users if u.id != user.id]
data = [util.to_datagrid(datagrid.circle_description_grid, wrappers, grid_display=len(wrappers) > 0)]
return dict(page='circles', name=circle.name, widget=e.widget, items=data, value=kw, tooltip=t, au_error=True)
mail = mail.lower()
to_add = DBSession.query(User).filter(User.email == mail).first()
if to_add is None:
to_add = handler.user.create_tmp_user(mail)
handler.circle.add_user(circle_id=circle_id, user=to_add)
# build common parameters
if not checker.user_own_circle(user.id, circle_id):
flash('you have no right to edit this circle: you are not the creator of it')
raise redirect('/circles')
for u in circle.users:
u.__dict__['cid'] = circle_id
wrappers = [u for u in circle.users if u.id != user.id]
data = [util.to_datagrid(datagrid.circle_description_grid, wrappers, grid_display=len(wrappers) > 0)]
kw['cid'] = circle_id
widget.value = kw
return dict(page='circles', name=circle.name, widget=widget, items=data, tooltip=t)
# @expose()
# @validate(circle_edit_form, error_handler=edit)
# def put(self, *args, **kw):
# user = handler.user.get_user_in_session(request)
# circle_id = args[0]
# circle = DBSession.query(Circle).filter(Circle.id == circle_id).first()
# if not checker.user_own_circle(user.id, circle_id):
# flash('you have no right to edit this circle: you are not the creator of it')
# raise redirect('/circles')
# handler.circle.edit(circle, kw['name'], kw['description'], user, kw['users'])
# raise redirect('/circles')
@require(has_permission('admin', msg='Only for admins'))
@expose('pygdv.templates.list')
def admin(self):
c = DBSession.query(Circle).all()
dc = [util.to_datagrid(circle_grid, c, "All circles", len(c) > 0)]
t = handler.help.tooltip['circle']
return dict(page='circles', model='circle', tooltip=t, items=dc, value={})
def test_user_has_one_permission(self):
environ = make_environ('gustavo',
permissions=['watch-tv', 'party', 'eat'])
p = predicates.has_any_permission('party', 'scream')
self.eval_met_predicate(p, environ)
class SelectionController(object):
allow_only = has_any_permission(constants.permissions['admin']['name'],
constants.permissions['read']['name'])
@expose()
def index(self):
return ''
@expose()
def save(self, project_id, color, description, locations):
user = handler.user.get_user_in_session(request)
if not checker.check_permission(user=user,
project_id=project_id,
right_id=constants.right_upload_id):
flash(
'You must have %s permission to delete the project.' %
constants.right_upload, 'error')
return {'save': 'failed'}
#print "save %s, color %s, desc %s loc %s" % (project_id, color, description, locations)
''' For the moment, there is only one selection per project'''
sel = DBSession.query(Selection).filter(
Selection.project_id == project_id).first()
if sel is None:
sel = Selection()
sel.project_id = project_id
sel.description = description
sel.color = color
DBSession.add(sel)
DBSession.flush()
locations_ids = []
# add locations
for loc in json.loads(locations):
obj = None
if 'id' in loc:
obj = DBSession.query(Location).join(
Selection.locations).filter(
and_(Selection.id == sel.id,
Location.id == loc.get('id'))).first()
if obj is None:
obj = Location()
obj.chromosome = loc.get('chr')
obj.start = loc.get('start')
obj.end = loc.get('end')
obj.description = loc.get('desc', 'No description')
obj.selection = sel
DBSession.add(obj)
DBSession.flush()
locations_ids.append(obj.id)
# remove not saved ones
loc_to_remove = DBSession.query(Location).filter(
not_(Location.id.in_(locations_ids))).all()
for l in loc_to_remove:
DBSession.delete(l)
DBSession.flush()
return {"saved": "ok"}
@expose()
def delete(self, project_id, selection_id):
user = handler.user.get_user_in_session(request)
if not checker.check_permission(user=user,
project_id=project_id,
right_id=constants.right_upload_id):
flash(
'You must have %s permission to delete the project.' %
constants.right_upload, 'error')
return {'delete': 'failed'}
selection = DBSession.query(Selection).filter(
Selection.id == selection_id).first()
if not selection.project_id == project_id:
flash('Bad project_id: %s' % project_id, 'error')
return {'delete': 'failed'}
DBSession.delete(selection)
DBSession.flush()
return {'delete': 'success'}
@expose()
def get(self, selection_id):
sel = DBSession.query(Selection).filter(
Selection.id == selection_id).first()
b = ''
for loc in sel.locations:
b += '%s\t%s\t%s' % (loc.chromosome, loc.start, loc.end)
return b
class ProyectoController(BaseController):
@expose()
def index(self):
"""Muestra la pantalla inicial"""
return dict(nombre_modelo='Proyecto', page='index_proyecto')
@expose('is2sap.templates.proyecto.nuevo')
@require(predicates.has_any_permission('administracion'))
def nuevo(self, **kw):
"""Despliega el formulario para añadir un nuevo Proyecto."""
try:
tmpl_context.form = crear_proyecto_form
usuario_id = DBSession.query(Usuario.id_usuario).filter_by(
nombre_usuario=request.identity['repoze.who.userid']).first()
kw['id_usuario'] = usuario_id
except SQLAlchemyError:
flash(
_("No se pudo acceder a Creacion de Proyectos! SQLAlchemyError..."
), 'error')
redirect("/admin/proyecto/listado")
except (AttributeError, NameError):
flash(
_("No se pudo acceder a Creacion de Proyecto! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/proyecto/listado")
return dict(nombre_modelo='Proyecto', page='nuevo_proyecto', value=kw)
@validate(crear_proyecto_form, error_handler=nuevo)
@expose()
@require(predicates.has_any_permission('administracion'))
def add(self, **kw):
"""Metodo para agregar un registro a la base de datos """
try:
proyecto = Proyecto()
proyecto.id_usuario = kw['id_usuario']
proyecto.nombre = kw['nombre']
proyecto.descripcion = kw['descripcion']
proyecto.fecha = kw['fecha']
proyecto.iniciado = kw['iniciado']
DBSession.add(proyecto)
DBSession.flush()
transaction.commit()
except IntegrityError:
transaction.abort()
flash(_("No se ha guardado! Hay Problemas con el servidor..."),
'error')
redirect("/admin/proyecto/listado")
except SQLAlchemyError:
flash(_("No se ha guardado! SQLAlchemyError..."), 'error')
redirect("/admin/proyecto/listado")
except (AttributeError, NameError):
flash(_("No se ha guardado! Hay Problemas con el servidor..."),
'error')
redirect("/admin/proyecto/listado")
else:
flash(_("Proyecto creado!"), 'ok')
redirect("/admin/proyecto/listado")
@expose("is2sap.templates.proyecto.listado")
@require(predicates.has_any_permission('administracion', 'lider_proyecto'))
def listado(self, page=1):
"""Metodo para listar todos los Proyectos existentes de la base de datos"""
try:
proyectos = []
if predicates.has_permission('administracion'):
proyectos = DBSession.query(Proyecto).order_by(
Proyecto.id_proyecto)
elif predicates.has_permission('lider_proyecto'):
usuario = DBSession.query(Usuario).filter_by(
nombre_usuario=request.identity['repoze.who.userid']
).first()
proyectos = usuario.proyectos
currentPage = paginate.Page(proyectos, page, items_per_page=10)
except SQLAlchemyError:
flash(_("No se pudo acceder a Proyectos! SQLAlchemyError..."),
'error')
redirect("/admin")
except (AttributeError, NameError):
flash(
_("No se pudo acceder a Proyectos! Hay Problemas con el servidor..."
), 'error')
redirect("/admin")
return dict(proyectos=currentPage.items,
page='listado_proyecto',
currentPage=currentPage)
@expose('is2sap.templates.proyecto.editar')
@require(predicates.has_any_permission('administracion'))
def editar(self, id_proyecto, **kw):
"""Metodo que rellena el formulario para editar los datos de un Proyecto"""
try:
tmpl_context.form = editar_proyecto_form
traerProyecto = DBSession.query(Proyecto).get(id_proyecto)
if traerProyecto.iniciado:
flash(
_("El proyecto no puede modificarse porque ya se encuentra iniciado."
), 'error')
redirect("/admin/proyecto/listado")
kw['id_proyecto'] = traerProyecto.id_proyecto
kw['id_usuario'] = traerProyecto.id_usuario
kw['nombre'] = traerProyecto.nombre
kw['descripcion'] = traerProyecto.descripcion
kw['fecha'] = traerProyecto.fecha
kw['iniciado'] = traerProyecto.iniciado
except SQLAlchemyError:
flash(
_("No se pudo acceder a Edicion de Proyectos! SQLAlchemyError..."
), 'error')
redirect("/admin/proyecto/listado")
except (AttributeError, NameError):
flash(
_("No se pudo acceder a Edicion de Proyecto! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/proyecto/listado")
return dict(nombre_modelo='Proyecto', page='editar_proyecto', value=kw)
@validate(editar_proyecto_form, error_handler=editar)
@expose()
@require(predicates.has_any_permission('administracion'))
def update(self, **kw):
"""Metodo que actualiza la base de datos"""
try:
proyecto = DBSession.query(Proyecto).get(kw['id_proyecto'])
proyecto.id_usuario = kw['id_usuario']
proyecto.nombre = kw['nombre']
proyecto.descripcion = kw['descripcion']
proyecto.fecha = kw['fecha']
proyecto.inciado = kw['iniciado']
DBSession.flush()
transaction.commit()
except IntegrityError:
transaction.abort()
flash(
_("No se han guardado los cambios! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/proyecto/listado")
except SQLAlchemyError:
flash(_("No se han guardado los cambios! SQLAlchemyError..."),
'error')
redirect("/admin/proyecto/listado")
except (AttributeError, NameError):
flash(
_("No se han guardado los cambios! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/proyecto/listado")
else:
flash(_("Se han guardado los cambios!"), 'ok')
redirect("/admin/proyecto/listado")
@expose('is2sap.templates.proyecto.confirmar_eliminar')
@require(predicates.has_any_permission('administracion'))
def confirmar_eliminar(self, id_proyecto, **kw):
"""Despliega confirmacion de eliminacion"""
try:
proyecto = DBSession.query(Proyecto).get(id_proyecto)
if proyecto.iniciado == True:
flash(_("Proyecto ya iniciado. No puede eliminar!"), 'error')
redirect("/admin/proyecto/listado")
except SQLAlchemyError:
flash(
_("No se pudo acceder a Eliminacion de Proyecto! SQLAlchemyError..."
), 'error')
redirect("/admin/proyecto/listado")
except (AttributeError, NameError):
flash(
_("No se pudo acceder a Eliminacion de Proyecto! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/proyecto/listado")
return dict(nombre_modelo='Proyecto',
page='eliminar_proyecto',
value=proyecto)
@expose()
@require(predicates.has_any_permission('administracion'))
def delete(self, id_proyecto, **kw):
"""Metodo que elimina un registro de la base de datos"""
try:
proyecto = DBSession.query(Proyecto).get(id_proyecto)
fases = proyecto.fases
for fase in fases:
id_fase = fase.id_fase
tipo_items = DBSession.query(TipoItem).filter_by(
id_fase=id_fase).all()
for tipo_item in tipo_items:
id_tipo_item = tipo_item.id_tipo_item
atributos = DBSession.query(Atributo).filter_by(
id_tipo_item=id_tipo_item).all()
for atributo in atributos:
DBSession.delete(
DBSession.query(Atributo).get(
atributo.id_atributo))
DBSession.delete(
DBSession.query(TipoItem).get(id_tipo_item))
DBSession.delete(DBSession.query(Fase).get(id_fase))
DBSession.delete(DBSession.query(Proyecto).get(id_proyecto))
DBSession.flush()
transaction.commit()
except IntegrityError:
transaction.abort()
flash(_("No se pudo eliminar! Hay Problemas con el servidor..."),
'error')
redirect("/admin/proyecto/listado")
except SQLAlchemyError:
flash(_("No se pudo eliminar! SQLAlchemyError..."), 'error')
redirect("/admin/proyecto/listado")
except (AttributeError, NameError):
flash(_("No se pudo eliminar! Hay Problemas con el servidor..."),
'error')
redirect("/admin/proyecto/listado")
else:
flash(_("Proyecto eliminado!"), 'ok')
redirect("/admin/proyecto/listado")
@expose("is2sap.templates.proyecto.listar_roles")
@require(predicates.has_any_permission('lider_proyecto'))
def roles(self, id_proyecto, page=1):
"""Metodo para listar todos los roles que tiene el proyecto seleccionado"""
try:
proyecto = DBSession.query(Proyecto).get(id_proyecto)
id_proyecto = proyecto.id_proyecto
roles = proyecto.roles
currentPage = paginate.Page(roles, page, items_per_page=10)
except SQLAlchemyError:
flash(
_("No se pudo acceder a Roles del Proyecto! SQLAlchemyError..."
), 'error')
redirect("/admin/proyecto/listado")
except (AttributeError, NameError):
flash(
_("No se pudo acceder a Roles del Proyecto! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/proyecto/listado")
return dict(roles=currentPage.items,
page='listar_roles',
currentPage=currentPage,
id_proyecto=id_proyecto,
proyecto=proyecto)
@expose()
@require(predicates.has_any_permission('lider_proyecto'))
def eliminar_rol_proyecto(self, id_proyecto, id_rol, **kw):
"""Metodo que elimina un rol al proyecto seleccionado"""
try:
rol = DBSession.query(Rol).get(id_rol)
proyecto = DBSession.query(Proyecto).get(id_proyecto)
if rol.proyectos.count(proyecto) >= 1:
rol.proyectos.remove(proyecto)
DBSession.flush()
transaction.commit()
except IntegrityError:
transaction.abort()
flash(
_("No se ha desasignado dicho Rol! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/proyecto/roles", id_proyecto=id_proyecto)
except SQLAlchemyError:
flash(_("No se ha desasignado dicho Rol! SQLAlchemyError..."),
'error')
redirect("/admin/proyecto/roles", id_proyecto=id_proyecto)
except (AttributeError, NameError):
flash(
_("No se ha desasignado decho Rol! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/proyecto/roles", id_proyecto=id_proyecto)
else:
flash(_("Rol desasignado!"), 'ok')
redirect("/admin/proyecto/roles", id_proyecto=id_proyecto)
@expose("is2sap.templates.proyecto.agregar_roles")
@require(predicates.has_any_permission('lider_proyecto'))
def rolProyecto(self, id_proyecto, page=1):
"""Metodo que permite listar los roles que se pueden agregar al proyecto seleccionado"""
try:
proyecto = DBSession.query(Proyecto).get(id_proyecto)
id_proyecto = proyecto.id_proyecto
rolesProyecto = proyecto.roles
roles = DBSession.query(Rol).filter_by(tipo="Proyecto").order_by(
Rol.id_rol).all()
for rol in rolesProyecto:
if roles.count(rol) >= 1:
roles.remove(rol)
currentPage = paginate.Page(roles, page, items_per_page=10)
except SQLAlchemyError:
flash(
_("No se pudo acceder a Agregar Roles al Proyecto! SQLAlchemyError..."
), 'error')
redirect("/admin/proyecto/roles", id_proyecto=id_proyecto)
except (AttributeError, NameError):
flash(
_("No se pudo acceder a Agregar Roles al Proyecto! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/proyecto/roles", id_proyecto=id_proyecto)
return dict(roles=currentPage.items,
page='agregar_roles',
currentPage=currentPage,
id_proyecto=id_proyecto,
proyecto=proyecto)
@expose()
@require(predicates.has_any_permission('lider_proyecto'))
def agregarRol(self, id_proyecto, id_rol):
"""Metodo que realiza la agregacion de un rol al proyecto selecccionado"""
try:
rol = DBSession.query(Rol).get(id_rol)
proyecto = DBSession.query(Proyecto).get(id_proyecto)
rol.proyectos.append(proyecto)
DBSession.flush()
transaction.commit()
except IntegrityError:
transaction.abort()
flash(
_("No se ha asignado dicho Rol! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/proyecto/rolProyecto", id_proyecto=id_proyecto)
except SQLAlchemyError:
flash(_("No se ha asignado dicho Rol! SQLAlchemyError..."),
'error')
redirect("/admin/proyecto/rolProyecto", id_proyecto=id_proyecto)
except (AttributeError, NameError):
flash(
_("No se ha asignado decho Rol! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/proyecto/rolProyecto", id_proyecto=id_proyecto)
else:
flash(_("Rol asignado!"), 'ok')
redirect("/admin/proyecto/rolProyecto", id_proyecto=id_proyecto)
@expose("is2sap.templates.proyecto.listar_usuarios")
@require(predicates.has_any_permission('administracion', 'lider_proyecto'))
def usuarios(self, id_proyecto, page=1):
"""Metodo para listar todos los usuarios que tiene el proyecto seleccionado"""
try:
proyecto = DBSession.query(Proyecto).get(id_proyecto)
id_proyecto = proyecto.id_proyecto
usuarios = proyecto.usuarios
currentPage = paginate.Page(usuarios, page, items_per_page=10)
except SQLAlchemyError:
flash(
_("No se pudo acceder a Usuarios del Proyecto! SQLAlchemyError..."
), 'error')
redirect("/admin/proyecto/listado")
except (AttributeError, NameError):
flash(
_("No se pudo acceder a Usuarios del Proyecto! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/proyecto/listado")
return dict(usuarios=currentPage.items,
page='listar_usuarios',
id_proyecto=id_proyecto,
currentPage=currentPage,
proyecto=proyecto)
@expose()
@require(predicates.has_any_permission('administracion', 'lider_proyecto'))
def eliminar_usuario_proyecto(self, id_proyecto, id_usuario, **kw):
"""Metodo que elimina un usuario al proyecto seleccionado"""
try:
usuario = DBSession.query(Usuario).get(id_usuario)
proyecto = DBSession.query(Proyecto).get(id_proyecto)
if usuario.proyectos.count(proyecto) >= 1:
usuario.proyectos.remove(proyecto)
DBSession.flush()
transaction.commit()
except IntegrityError:
transaction.abort()
flash(
_("No se ha desasignado dicho Usuario! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/proyecto/usuarios", id_proyecto=id_proyecto)
except SQLAlchemyError:
flash(_("No se ha desasignado dicho Usuario! SQLAlchemyError..."),
'error')
redirect("/admin/proyecto/usuarios", id_proyecto=id_proyecto)
except (AttributeError, NameError):
flash(
_("No se ha desasignado decho Usuario! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/proyecto/usuarios", id_proyecto=id_proyecto)
else:
flash(_("Usuario desasignado!"), 'ok')
redirect("/admin/proyecto/usuarios", id_proyecto=id_proyecto)
@expose("is2sap.templates.proyecto.agregar_usuarios")
@require(predicates.has_any_permission('administracion', 'lider_proyecto'))
def usuarioProyecto(self, id_proyecto, page=1):
"""Metodo que permite listar los usuarios que se pueden agregar al proyecto seleccionado"""
try:
proyecto = DBSession.query(Proyecto).get(id_proyecto)
id_proyecto = proyecto.id_proyecto
usuariosProyecto = proyecto.usuarios
usuarios = DBSession.query(Usuario).order_by(
Usuario.id_usuario).all()
for usuario in usuariosProyecto:
if usuarios.count(usuario) >= 1:
usuarios.remove(usuario)
currentPage = paginate.Page(usuarios, page, items_per_page=10)
except SQLAlchemyError:
flash(
_("No se pudo acceder a Agregar Usuarios al Proyecto! SQLAlchemyError..."
), 'error')
redirect("/admin/proyecto/usuarios", id_proyecto=id_proyecto)
except (AttributeError, NameError):
flash(
_("No se pudo acceder a Agregar Usuarios al Proyecto! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/proyecto/usuarios", id_proyecto=id_proyecto)
return dict(usuarios=currentPage.items,
page='agregar_usuarios',
currentPage=currentPage,
id_proyecto=id_proyecto,
proyecto=proyecto)
@expose()
@require(predicates.has_any_permission('administracion', 'lider_proyecto'))
def agregarUsuario(self, id_proyecto, id_usuario):
"""Metodo que realiza la agregacion de un usuario al proyecto selecccionado"""
try:
usuario = DBSession.query(Usuario).get(id_usuario)
proyecto = DBSession.query(Proyecto).get(id_proyecto)
usuario.proyectos.append(proyecto)
DBSession.flush()
transaction.commit()
except IntegrityError:
transaction.abort()
flash(
_("No se ha asignado dicho Usuario! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/proyecto/usuarioProyecto",
id_proyecto=id_proyecto)
except SQLAlchemyError:
flash(_("No se ha asignado dicho Usuario! SQLAlchemyError..."),
'error')
redirect("/admin/proyecto/usuarioProyecto",
id_proyecto=id_proyecto)
except (AttributeError, NameError):
flash(
_("No se ha asignado decho Usuario! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/proyecto/usuarioProyecto",
id_proyecto=id_proyecto)
else:
flash(_("Usuario asignado!"), 'ok')
redirect("/admin/proyecto/usuarioProyecto", id_proyecto=id_proyecto)
@expose("is2sap.templates.proyecto.listaProyectos_a_iniciar")
@require(predicates.has_any_permission('lider_proyecto'))
def listaProyectos_a_iniciar(self, page=1):
"""Metodo para listar todos los Proyectos a iniciar de la base de datos"""
try:
proy = DBSession.query(Proyecto).filter_by(
iniciado=False).order_by(Proyecto.id_proyecto)
usuario = DBSession.query(Usuario).filter_by(
nombre_usuario=request.identity['repoze.who.userid']).first()
proyectos = []
for p in proy:
if usuario.proyectos.count(p) == 1:
proyectos.append(p)
currentPage = paginate.Page(proyectos, page, items_per_page=10)
except SQLAlchemyError:
flash(_("No se pudo acceder a Proyectos! SQLAlchemyError..."),
'error')
redirect("/admin")
except (AttributeError, NameError):
flash(
_("No se pudo acceder a Proyectos! Hay Problemas con el servidor..."
), 'error')
redirect("/admin")
return dict(proyectos=currentPage.items,
page='listaProyectos_a_iniciar',
currentPage=currentPage)
@expose()
@require(predicates.has_any_permission('lider_proyecto'))
def iniciar(self, id_proyecto, **kw):
"""Metodo que da inicio a un proyecto"""
try:
proyecto = DBSession.query(Proyecto).get(id_proyecto)
fases = proyecto.fases
id_proyecto = proyecto.id_proyecto
maxnumerofase = DBSession.query(func.max(
Fase.numero_fase)).filter_by(id_proyecto=id_proyecto).first()
if maxnumerofase[0] == None:
flash(
_("El Proyecto se encuentra sin fases! No puede iniciar..."
), 'error')
redirect("/admin/proyecto/listaProyectos_a_iniciar")
else:
proyecto.iniciado = True
for fase in fases:
if fase.numero_fase == 1:
fase.id_estado_fase = '2'
DBSession.flush()
transaction.commit()
except IntegrityError:
transaction.abort()
flash(
_("No se ha realizado la inicializacion! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/proyecto/listaProyectos_a_iniciar")
except SQLAlchemyError:
flash(
_("No se ha realizado la inicializacion! SQLAlchemyError..."),
'error')
redirect("/admin/proyecto/listaProyectos_a_iniciar")
except (AttributeError, NameError):
flash(
_("No se ha realizado la inicializacion! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/proyecto/listaProyectos_a_iniciar")
else:
flash(_("Proyecto iniciado!"), 'ok')
redirect("/admin/proyecto/listaProyectos_a_iniciar")
@expose("is2sap.templates.proyecto.rolesProyectoUsuario")
@require(predicates.has_any_permission('lider_proyecto'))
def rolesProyectoUsuario(self, id_proyecto, id_usuario, page=1):
"""Metodo para listar todos los roles que tiene el usuario seleccionado"""
try:
usuario = DBSession.query(Usuario).get(id_usuario)
rolesProyecto = DBSession.query(Rol).filter_by(
tipo="Proyecto").all()
roles = []
for rol in rolesProyecto:
if usuario.roles.count(rol) == 1:
roles.append(rol)
currentPage = paginate.Page(roles, page, items_per_page=10)
except SQLAlchemyError:
flash(
_("No se pudo acceder a Roles de Usuario! SQLAlchemyError..."),
'error')
redirect("/admin/proyecto/usuarios", id_proyecto=id_proyecto)
except (AttributeError, NameError, ValueError):
flash(
_("No se pudo acceder a Roles de Usuario! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/proyecto/usuarios", id_proyecto=id_proyecto)
return dict(roles=currentPage.items,
page='rolesProyectoUsuario',
currentPage=currentPage,
usuario=usuario,
id_proyecto=id_proyecto)
@expose("is2sap.templates.proyecto.agregarRolUsuario")
@require(predicates.has_any_permission('administracion', 'lider_proyecto'))
def agregarRolUsuario(self, id_usuario, id_proyecto, page=1):
"""Metodo que permite listar los roles que se pueden agregar al usuario seleccionado"""
try:
usuario = DBSession.query(Usuario).get(id_usuario)
rolesUsuario = usuario.roles
rolesDB = DBSession.query(Rol).filter_by(tipo="Proyecto").all()
roles = []
for rol in rolesDB:
if rolesUsuario.count(rol) == 0:
roles.append(rol)
currentPage = paginate.Page(roles, page, items_per_page=10)
except SQLAlchemyError:
flash(_("No se pudo acceder a Agregar Roles! SQLAlchemyError..."),
'error')
redirect("/admin/proyecto/agregarRolUsuario",
id_usuario=id_usuario,
id_proyecto=id_proyecto)
except (AttributeError, NameError, ValueError):
flash(
_("No se pudo acceder a Agregar Roles! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/proyecto/agregarRolUsuario",
id_usuario=id_usuario,
id_proyecto=id_proyecto)
return dict(roles=currentPage.items,
page='agregar_roles',
currentPage=currentPage,
id_usuario=id_usuario,
usuario=usuario,
id_proyecto=id_proyecto)
@expose()
@require(predicates.has_any_permission('administracion', 'lider_proyecto'))
def agregarRolUser(self, id_usuario, id_rol, id_proyecto):
"""Metodo que realiza la agregacion de un rol al usuario selecccionado"""
try:
rol = DBSession.query(Rol).get(id_rol)
usuario = DBSession.query(Usuario).get(id_usuario)
rol.usuarios.append(usuario)
DBSession.flush()
transaction.commit()
except IntegrityError:
transaction.abort()
flash(
_("No se pudo Asignar Rol! Hay Problemas con el servidor..."),
'error')
redirect("/admin/proyecto/rolesProyectoUsuario",
id_proyecto=id_proyecto,
id_usuario=id_usuario)
except SQLAlchemyError:
flash(_("No se pudo Asignar Rol! SQLAlchemyError..."), 'error')
redirect("/admin/proyecto/rolesProyectoUsuario",
id_proyecto=id_proyecto,
id_usuario=id_usuario)
except (AttributeError, NameError):
flash(
_("No se pudo Asignar Rol! Hay Problemas con el servidor..."),
'error')
redirect("/admin/proyecto/rolesProyectoUsuario",
id_proyecto=id_proyecto,
id_usuario=id_usuario)
else:
flash(_("Rol asignado!"), 'ok')
redirect("/admin/proyecto/rolesProyectoUsuario",
id_proyecto=id_proyecto,
id_usuario=id_usuario)
@expose()
@require(predicates.has_any_permission('administracion', 'lider_proyecto'))
def eliminar_rol_usuario(self, id_usuario, id_rol, id_proyecto, **kw):
"""Metodo que elimina un rol al usuario seleccionado"""
try:
rol = DBSession.query(Rol).get(id_rol)
usuario = DBSession.query(Usuario).get(id_usuario)
if rol.usuarios.count(usuario) >= 1:
rol.usuarios.remove(usuario)
DBSession.flush()
transaction.commit()
except IntegrityError:
transaction.abort()
flash(
_("No se pudo Desasignar Rol! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/proyecto/rolesProyectoUsuario",
id_proyecto=id_proyecto,
id_usuario=id_usuario)
except SQLAlchemyError:
flash(_("No se pudo Desasignar Rol! SQLAlchemyError..."), 'error')
redirect("/admin/proyecto/rolesProyectoUsuario",
id_proyecto=id_proyecto,
id_usuario=id_usuario)
except (AttributeError, NameError):
flash(
_("No se pudo Desasignar Rol! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/proyecto/rolesProyectoUsuario",
id_proyecto=id_proyecto,
id_usuario=id_usuario)
else:
flash(_("Rol desasignado!"), 'ok')
redirect("/admin/proyecto/rolesProyectoUsuario",
id_proyecto=id_proyecto,
id_usuario=id_usuario)
@expose("is2sap.templates.proyecto.listadoPermisoFase")
@require(predicates.has_any_permission('administracion', 'lider_proyecto'))
def listadoPermisoFase(self, id_usuario, id_rol, id_proyecto, page=1):
"""Metodo que permite listar los roles que se pueden agregar al usuario seleccionado"""
try:
roles = DBSession.query(Rol).get(id_rol)
rolesFases = roles.fases
rolesFases1 = roles.fases
proyecto = DBSession.query(Proyecto).get(id_proyecto)
listaFases = []
for fase in rolesFases:
if proyecto.fases.count(fase) == 0:
rolesFases.remove(fase)
for fase in proyecto.fases:
if rolesFases1.count(fase) == 0:
listaFases.append(fase)
currentPage = paginate.Page(rolesFases, page, items_per_page=10)
except SQLAlchemyError:
flash(_("No se pudo acceder a Listado Fases! SQLAlchemyError..."),
'error')
redirect("/admin/proyecto/rolesProyectoUsuario",
id_proyecto=id_proyecto,
id_usuario=id_usuario)
except (AttributeError, NameError):
flash(
_("No se pudo acceder a Agregar Roles! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/proyecto/rolesProyectoUsuario",
id_proyecto=id_proyecto,
id_usuario=id_usuario)
return dict(rolesFases=currentPage.items,
page='agregar_roles',
currentPage=currentPage,
id_usuario=id_usuario,
id_proyecto=id_proyecto,
fasesRestantes=listaFases,
id_rol=id_rol)
@expose()
@require(predicates.has_any_permission('administracion', 'lider_proyecto'))
def agregarPermisoFase(self,
id_usuario,
id_rol,
id_proyecto,
id_fase,
page=1):
"""Metodo que permite listar los roles que se pueden agregar al usuario seleccionado"""
try:
roles = DBSession.query(Rol).get(id_rol)
fase = DBSession.query(Fase).get(id_fase)
usuario = DBSession.query(Usuario).get(id_usuario)
roles.fases.append(fase)
usuario.fases.append(fase)
except SQLAlchemyError:
redirect("/admin/proyecto/listadoPermisoFase",
id_proyecto=id_proyecto,
id_usuario=id_usuario,
id_rol=id_rol)
except (AttributeError, NameError):
flash(
_("No se pudo acceder a Agregar Roles! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/proyecto/listadoPermisoFase",
id_proyecto=id_proyecto,
id_usuario=id_usuario,
id_rol=id_rol)
redirect("/admin/proyecto/listadoPermisoFase",
id_proyecto=id_proyecto,
id_usuario=id_usuario,
id_rol=id_rol)
@expose()
@require(predicates.has_any_permission('administracion', 'lider_proyecto'))
def eliminarPermisoFase(self,
id_usuario,
id_rol,
id_proyecto,
id_fase,
page=1):
"""Metodo que permite listar los roles que se pueden agregar al usuario seleccionado"""
try:
roles = DBSession.query(Rol).get(id_rol)
fase = DBSession.query(Fase).get(id_fase)
usuario = DBSession.query(Usuario).get(id_usuario)
if roles.fases.count(fase) >= 1:
roles.fases.remove(fase)
if usuario.fases.count(fase) >= 1:
usuario.fases.remove(fase)
except SQLAlchemyError:
flash(_("No se pudo acceder a Listado Fases! SQLAlchemyError..."),
'error')
redirect("/admin/proyecto/listadoPermisoFase",
id_proyecto=id_proyecto,
id_usuario=id_usuario,
id_rol=id_rol)
except (AttributeError, NameError, ValueError):
redirect("/admin/proyecto/listadoPermisoFase",
id_proyecto=id_proyecto,
id_usuario=id_usuario,
id_rol=id_rol)
redirect("/admin/proyecto/listadoPermisoFase",
id_proyecto=id_proyecto,
id_usuario=id_usuario,
id_rol=id_rol)
class PluginController(BaseController):
allow_only = has_any_permission(constants.permissions['admin']['name'],
constants.permissions['read']['name'])
@expose()
def get(self, *args, **kw):
bsurl = handler.job.bioscript_url
bsrequesturl = bsurl + '/plugins/fetch?oid=' + kw['oid']
user = handler.user.get_user_in_session(request)
project = DBSession.query(Project).filter(
Project.id == kw['pid']).first()
# add private parameters
pp = {
"key": user.key,
"mail": user.email,
"pid": project.id,
"pkey": project.key
}
# add prefill parameters
tracks = list(project.tracks)
selections = list(project.selections)
gtrack = [(json.dumps({
'p':
handler.track.plugin_link(t),
'n':
os.path.split(handler.track.plugin_link(t))[-1]
}), t.name) for t in tracks]
if len(selections) > 0:
s = selections[0]
if len(s.locations) > 0:
gtrack.append((handler.track.plugin_link(s, selection_id=s.id),
'selection'))
prefill = {'track': gtrack}
# prepare parameters
parameters = {
'key':
handler.job.shared_key,
'bs_private':
json.dumps({
'app': pp,
'cfg': handler.job.bioscript_config,
'prefill': prefill
})
}
# TODO fetch tracks & selections
req = urllib2.urlopen(url=bsrequesturl,
data=urllib.urlencode(parameters))
# display the form in template
response.headerlist.append(('Access-Control-Allow-Origin', '*'))
data = req.read()
return data
# @expose()
# def index(self, id, key, *args, **kw):
# bsurl = handler.job.bioscript_url
# shared_key = handler.job.shared_key
# project = DBSession.query(Project).filter(Project.key == key).first()
# req = {}
# # add private parameters
# user = handler.user.get_user_in_session(request)
# req['_up'] = json.dumps({"key": user.key, "mail": user.email, "project_key": project.key})
# req['key'] = shared_key
# # add prefill for parameters:
# gen_tracks = [[handler.track.plugin_link(track), track.name] for track in project.success_tracks]
# req['prefill'] = json.dumps({"track": gen_tracks})
# req['id'] = id
# bs_request_url = bsurl + '/plugins/get'
# f = urllib2.urlopen(bs_request_url, urllib.urlencode(req))
# return f.read()
@expose()
def validation(*args, **kw):
for arg in args_list:
if arg not in kw:
raise Exception('Missing args for the validation %s' % kw)
user = DBSession.query(User).filter(
User.email == str(kw['mail'])).first()
if user.key != str(kw['key']):
raise Exception('User not valid %s' % kw)
project = DBSession.query(Project).filter(
Project.id == int(kw['pid'])).first()
if project.key != str(kw['pkey']):
raise Exception('Project not valid %s' % kw)
job = Job()
job.user_id = user.id
job.project_id = project.id
job.status = 'PENDING'
job.ext_task_id = kw['task_id']
job.bioscript_url = handler.job.task_url(kw['task_id'])
if 'plugin_info' in kw:
info = json.loads(kw['plugin_info'])
job.name = info['title']
job.description = info['description']
else:
job.name = 'Job %s from bioscript' % kw['task_id']
job.description = 'Description available at %s' % handler.job.task_url(
kw['task_id'])
DBSession.add(job)
DBSession.flush()
return {}
@expose()
def callback(self, *args, **kw):
print kw
job = DBSession.query(Job).filter(
Job.ext_task_id == kw['task_id']).first()
project = DBSession.query(Project).filter(
Project.id == int(kw['pid'])).first()
if project is None or project.key != str(kw['pkey']):
raise Exception('Project not valid')
if job.project_id != project.id:
raise Exception('Job not valid')
status = str(kw['status'])
job.status = status
if status.lower() in ['error', 'failed']:
job.traceback = kw['error']
elif status == 'SUCCESS':
results = json.loads(kw['results'])
for result in results:
bres = Bresults()
bres.job_id = job.id
bres.output_type = str(result.get('type', 'not defined'))
bres.is_file = result.get('is_file', False)
path = str(result.get('path', ''))
bres.path = path
bres.data = str(result.get('value', ''))
is_track = result.get('type', '') == 'track'
if is_track:
out = os.path.join(filemanager.temporary_directory(),
os.path.split(path)[-1])
fileinfo = filemanager.FileInfo(inputtype='fsys',
inpath=path,
outpath=out,
admin=False)
sequence = project.sequence
user = DBSession.query(User).filter(
User.key == str(kw['key'])).first()
if user.email != str(kw['mail']):
raise Exception("Wrong user")
user_info = {
'id': user.id,
'name': user.name,
'email': user.email
}
sequence_info = {'id': sequence.id, 'name': sequence.name}
t = Track()
t.name = fileinfo.trackname
t.sequence_id = sequence.id
t.user_id = user.id
DBSession.add(t)
DBSession.flush()
async = tasks.new_input.delay(user_info, fileinfo,
sequence_info, t.id,
project.id)
t.task_id = async .task_id
bres.track_id = t.id
bres.is_track = is_track
DBSession.add(bres)
DBSession.flush()
return {}
try:
id_repo = get_paramw(kw, 'id_repo', int)
r = SapnsDoc.upload(f, id_repo)
return sj.dumps(dict(status=True,
uploaded_file=r['uploaded_file'],
file_name=r['file_name'],
file_size=r['file_size'],
))
except Exception, e:
logger.error(e)
return sj.dumps(dict(status=False, message=str(e).decode('utf-8')))
@expose()
@require(p.Any(p.in_group('managers'), p.has_any_permission('manage', 'docs')))
def download(self, id_doc):
content, mt, file_name = SapnsDoc.download(int(id_doc))
response.content_type = mt.encode('latin1')
response.headers['Content-Disposition'] = 'attachment;filename=%s' % file_name
return content
@expose('json')
@require(authorize.has_any_permission('manage', 'docs'))
def remove_file(self, **kw):
logger = logging.getLogger('DocsController.remove_file')
try:
file_name = get_paramw(kw, 'file_name', unicode)
class TrackController(BaseController):
allow_only = has_any_permission(constants.permissions['admin']['name'], constants.permissions['read']['name'])
@expose('pygdv.templates.track_index')
@expose('json')
#@paginate('items', items_per_page=10)
@with_trailing_slash
def index(self, *args, **kw):
user = handler.user.get_user_in_session(request)
shared_by = None
# view on a specific project
if 'pid' in kw and kw.get('pid'):
project_id = kw.get('pid')
project = DBSession.query(Project).filter(Project.id == project_id).first()
if project is None:
flash("Project doesn't exists", "error")
raise redirect('/tracks')
if not checker.check_permission(user=user, project=project, right_id=constants.right_read_id):
flash('You must have %s permission to view the project.' % constants.right_read, 'error')
raise redirect('/tracks')
tracks = project.tracks
# view on user project
if checker.own(user=user, project=project):
kw['own'] = True
kw['upload'] = True
grid = datagrid.track_grid_user(user, project)
# view from a shared user
else:
rights = handler.project.get_rights(project=project, user=user)
debug('find %s' % rights, 2)
if constants.right_upload_id in [r.id for r in rights]:
kw['upload'] = True
debug('view from a shared user %s' % rights)
grid = datagrid.track_grid_permissions(user=user, rights=rights, project=project)
shared_by = "%s %s" % (project.user.firstname, project.user.name[0].upper())
kw['pn'] = project.name
track_list = [util.to_datagrid(grid, tracks, "Track Listing", len(tracks) > 0)]
shared_with = project.get_circle_with_right_display
# view all user tracks
else:
if 'pid' in kw:
del kw['pid']
shared_with = ''
tracks = list(user.tracks)
# shared tracks
shared_tracks = handler.user.shared_tracks(user.id, constants.rights['download']['id'])
tracks.extend(shared_tracks)
debug('shared tracks : %s' % ', '.join((str(x) for x in shared_tracks)))
track_list = [util.to_datagrid(datagrid.track_grid_user(user), tracks, "Track Listing", len(tracks) > 0)]
kw['upload'] = True
t = handler.help.help_address(url('/help'), 'main', 'track list help')
# project list
project_list = [(p.id, p.name,) for p in user.projects]
# shared projects
shared_with_rights = handler.project.get_shared_projects(user)
sorted_projects = sorted(shared_with_rights.iteritems(), key=lambda k: k[0].name)
shared_project_list = [(p.id, p.name, ''.join([r[0] for r in rights])) for p, rights in sorted_projects]
return dict(page='tracks', model='track', form_title="new track", track_list=track_list,
project_list=project_list, shared_project_list=shared_project_list, value=kw,
tooltip=t, project_id=kw.get('pid', None), upload=kw.get('upload', None), project_name=kw.get('pn', None),
shared_with=shared_with, owner=kw.get('own', False), shared=not kw.get('own', False), shared_by=shared_by)
@require(not_anonymous())
@with_trailing_slash
@expose('pygdv.templates.track_new')
def new(self, *args, **kw):
project_name = None
ass_name = None
project_id = None
value = {}
if 'pid' in kw:
new_form = form.NewTrackPrefilled(action=url('/tracks/create')).req()
project_id = kw.get('pid')
project = DBSession.query(Project).filter(Project.id == project_id).first()
project_name = project.name
ass_name = project.sequence.name
value['project_id'] = project_id
else:
new_form = form.NewTrack(action=url('/tracks/create')).req()
species = DBSession.query(Species).all()
sp_opts = [(sp.id, sp.name) for sp in species]
new_form.child.children[5].options = sp_opts
mapping = json.dumps(dict([(sp.id, [(seq.id, seq.name) for seq in sp.sequences]) for sp in species]))
value['smapping'] = mapping
new_form.value = value
return dict(page='tracks', widget=new_form, project_id=project_id, project_name=project_name, ass_name=ass_name)
@expose('json')
def create(self, *args, **kw):
user = handler.user.get_user_in_session(request)
# get sequence
sequence = None
project_id = None
debug('Create track %s' % kw)
debug('Find sequence', 1)
if 'assembly' in kw and kw.get('assembly'):
assembly = int(kw.get('assembly'))
sequence = DBSession.query(Sequence).filter(Sequence.id == assembly).first()
elif 'sequence_id' in kw and kw.get('sequence_id'):
sequence_id = int(kw.get('sequence_id'))
sequence = DBSession.query(Sequence).filter(Sequence.id == sequence_id).first()
elif 'sequence_id' in kw and kw.get('sequence_id'):
sequence_id = int(kw.get('sequence_id'))
sequence = DBSession.query(Sequence).filter(Sequence.id == sequence_id).first()
elif 'project_id' in kw and kw.get('project_id'):
project_id = int(kw.get('project_id'))
project = DBSession.query(Project).filter(Project.id == project_id).first()
if project is None:
return reply.error(request, 'Project with id %s not found on GDV.' % project_id, tg.url('./new', {'pid': project_id}), {})
sequence = DBSession.query(Sequence).filter(Sequence.id == project.sequence_id).first()
if not sequence:
return reply.error(request, 'Sequence not found on GDV.', tg.url('./new'), {'pid': project_id})
debug('%s' % sequence.name, 2)
# know if file is comming from url, fileupload or filsystem
filetoget = None
inputtype = None
debug('Find inputtype', 1)
if 'url' in kw and kw.get('url'):
debug('from url', 2)
filetoget = kw.get('url')
if not filetoget.startswith('http://'):
filetoget = 'http://%s' % filetoget
inputtype = 'url'
elif 'fsys' in kw and kw.get('fsys'):
debug('fsys', 2)
filetoget = kw.get('fsys')
inputtype = 'fsys'
elif 'file_upload' in kw and kw.get('file_upload') is not None and kw['file_upload'] != '':
debug('file upload %s' % kw.get('file_upload'), 2)
filetoget = kw.get('file_upload')
inputtype = 'fu'
if filetoget is None:
return reply.error(request, 'No file to upload', tg.url('./new'), {'pid': project_id})
debug('file2get: %s, intype: %s' % (filetoget, inputtype), 2)
# get file name
debug('Find track name', 1)
trackname = None
if 'trackname' in kw and kw.get('trackname'):
debug('i params', 2)
trackname = kw.get('trackname')
else:
if inputtype == 'url':
debug('trackname from url', 2)
trackname = os.path.split(filetoget)[1].split('?')[0]
elif inputtype == 'fsys':
debug('trackname from fsys', 2)
trackname = os.path.split(filetoget)[-1]
elif inputtype == 'fu':
debug('trackname from fu', 2)
trackname = filetoget.filename
if trackname is None:
return reply.error(request, 'No trackname found', tg.url('./new'), {'pid': project_id})
debug('%s' % trackname, 2)
# get extension
extension = None
if 'extension' in kw and kw.get('extension'):
extension = kw.get('extension')
elif 'ext' in kw and kw.get('ext'):
extension = kw.get('ext')
else:
extension = os.path.splitext(trackname)[-1]
if extension is None or extension == '':
if inputtype == 'url':
debug('extension from url', 2)
extension = os.path.splitext(os.path.split(filetoget)[1].split('?')[0])[-1]
elif inputtype == 'fsys':
debug('extension from fsys', 2)
extension = os.path.splitext(os.path.split(filetoget)[-1])[-1]
elif inputtype == 'fu':
debug('extension from fu', 2)
extension = os.path.splitext(filetoget.filename)[-1]
if extension is None or extension == '':
return reply.error(request, 'No extension found', tg.url('./new'), {'pid': project_id})
if extension.startswith('.'):
extension = extension[1:]
extension = extension.lower()
# is the track "admin"
admin = False
if 'track_admin' in kw and kw.get('track_admin'):
# check if really admin
group_admin = DBSession.query(Group).filter(Group.id == constants.group_admins_id).first()
if user in group_admin.users:
admin = True
debug('admin: %s' % admin, 1)
#store information in a dummy object
out = os.path.join(filemanager.temporary_directory(), trackname)
fileinfo = filemanager.FileInfo(inputtype=inputtype, inpath=filetoget, trackname=trackname, extension=extension, outpath=out, admin=admin)
debug('fileinfo: %s' % fileinfo, 1)
# get additionnal information
user_info = {'id': user.id, 'name': user.name, 'email': user.email}
sequence_info = {'id': sequence.id, 'name': sequence.name}
#upload the track it's from file_upload
if inputtype == 'fu':
debug('Download', 1)
fileinfo.download()
debug('fileinfo: %s' % fileinfo, 1)
# create a track that the user can see something
t = Track()
t.name = fileinfo.trackname
t.sequence_id = sequence.id
t.user_id = user.id
DBSession.add(t)
DBSession.flush()
# send task
async = tasks.new_input.delay(user_info, fileinfo, sequence_info, t.id, project_id)
t.task_id = async.task_id
DBSession.add(t)
DBSession.flush()
debug('End create')
return reply.normal(request, 'Processing launched.', '/tracks/', {'track_id': t.id, 'pid': project_id})
# determine processes to launch
# # check if multiples url or if zipped file
# if util.is_compressed(extension) or (kw.get('url', None)!=None and len(kw.get('url', '').split())>1):
# async = tasks.multiple_track_input.delay(kw.get('uploaded', None), kw.get('file', None), kw.get('url', None), kw.get('fsys', None),
# sequence_id, user.email, user.key, project_id, kw.get('force', False), kw.get('delfile', False),
# constants.callback_track_url(), extension)
# return reply.normal(request, 'Processing launched.', '/tracks/', {'task_id': async.task_id})
# else:
# # create a new track
# _track = handler.track.new_track(user.id, track_name, sequence_id=sequence_id, admin=admin, project_id=project_id)
# # format parameters
# _uploaded = kw.get('uploaded', False)
# _file = kw.get('file', None)
# _urls = kw.get('url', None)
# _fsys=kw.get('fsys', None)
# _track_name = track_name
# _extension = extension
# _callback_url = constants.callback_track_url()
# _force = kw.get('force', False)
# _delfile = kw.get('delfile', False)
# _track_id = _track.id
# _user_key = user.key
# _user_mail = user.email
# # launch task with the parameters
# async = tasks.track_input.delay(_uploaded, _file, _urls, _fsys, _track_name, _extension, _callback_url, _force,
# _track_id, _user_mail, _user_key, sequence_id, _delfile)
# # update the track
# handler.track.update(track=_track, params={'task_id': async.task_id})
# if project_id is not None:
# return reply.normal(request,'Processing launched.', tg.url('/tracks/', {'pid': project_id}), {'task_id': async.task_id,
# 'track_id': _track.id})
# return reply.normal(request, 'Processing launched.', '/tracks/', {'task_id': async.task_id,
# 'track_id': _track.id})
@expose('json')
def post(self, *args, **kw):
project_id = kw.get('project_id', None)
urls = kw.get('urls', None)
fu = kw.get('file_upload', None)
if (fu is None or fu == '') and (urls is None or urls == ''):
flash('Missing field', 'error')
raise redirect('/tracks/new')
return self.create(*args, **kw)
@expose('json')
def post2(self, *args, **kw):
project_id = kw.get('project_id', None)
urls = kw.get('urls', None)
fu = kw.get('file_upload', None)
if (fu is None or fu == '') and (urls is None or urls == ''):
flash('Missing field', 'error')
raise redirect('/tracks/new', {'pid': project_id})
return self.create(*args, **kw)
#@expose('genshi:tgext.crud.templates.post_delete')
@expose('json')
def delete(self, track_id, **kw):
user = handler.user.get_user_in_session(request)
if track_id is not None:
if not checker.can_edit_track(user, track_id):
return reply.error(request, "You haven't the right to delete any tracks which is not yours", '/tracks', {'error': 'wrong credential'})
handler.track.delete_track(track_id=track_id)
red = '/tracks'
if 'pid' in kw:
red += '?pid=%s' % kw['pid']
return reply.normal(request, 'Track successfully deleted.', red, {'success': 'track deleted'})
@with_trailing_slash
@expose('pygdv.templates.track_edit')
def edit(self, track_id, **kw):
user = handler.user.get_user_in_session(request)
if track_id is not None:
if not checker.can_edit_track(user, track_id):
flash("You haven't the right to edit any tracks which is not yours", 'error')
raise redirect('/tracks')
widget = form.EditTrack(action=url('/tracks/edit/%s' % track_id)).req()
track = DBSession.query(Track).filter(Track.id == track_id).first()
d = {}
d['name'] = track.name
if track.parameters is None or not 'color' in track.parameters:
cc = constants.default_track_color
else:
cc = track.parameters['color']
d['track_id'] = track_id
d['color'] = cc
if 'pid' in kw:
d['pid'] = kw['pid']
widget.value = d
if request.method == 'GET':
return dict(title='Edit track', page='track', widget=widget, color=cc)
if request.method == 'POST':
try:
widget.validate(kw)
except twc.ValidationError as e:
return dict(title='Edit track', page='track', widget=e.widget, color=cc)
handler.track.edit(track=track, name=kw.get('name', None), color=kw.get('color', None))
raise redirect('/tracks', {'pid': kw.get('pid', None)})
@expose('pygdv.templates.track_export')
def export(self, track_id, *args, **kw):
user = handler.user.get_user_in_session(request)
trac = DBSession.query(Track).filter(Track.id == track_id).first()
if not checker.can_download(user, trac):
flash("You haven't the right to export any tracks which is not yours")
raise redirect('../')
data = util.to_datagrid(track_grid, [trac])
tmpl_context.form = track_export
kw['track_id'] = track_id
return dict(page='tracks', model='Track', info=data, form_title='', value=kw)
@expose()
def dump(self, track_id, format, *args, **kw):
user = handler.user.get_user_in_session(request)
if not checker.can_download(user.id, track_id):
flash("You haven't the right to export any tracks which is not yours", 'error')
raise redirect('../')
_track = DBSession.query(Track).filter(Track.id == track_id).first()
if format == 'sqlite':
response.content_type = 'application/x-sqlite3'
return open(_track.path).read()
else:
tmp_file = tempfile.NamedTemporaryFile(delete=True)
tmp_file.close()
track.convert(_track.path, (tmp_file.name, format))
response.content_type = 'text/plain'
return open(tmp_file.name).read()
@expose()
def link(self, track_id, *args, **kw):
user = handler.user.get_user_in_session(request)
trac = DBSession.query(Track).filter(Track.id == track_id).first()
if not checker.can_download(user, trac):
flash("You haven't the right to download any tracks which is not yours", 'error')
raise redirect('/tracks/')
track = DBSession.query(Track).filter(Track.id == track_id).first()
if track.status == constants.ERROR:
flash("The track processing failed. You cannot download it.", 'error')
raise redirect('/tracks/')
response.content_type = 'application/x-sqlite3'
response.headerlist.append(('Content-Disposition', 'attachment;filename=%s.sqlite' % track.name))
return open(track.path).read()
@expose()
def sql(self, sha1, name):
user = handler.user.get_user_in_session(request)
inp = DBSession.query(Input).filter(Input.sha1 == sha1).first()
if inp is None:
flash("Doesn't exist", 'error')
raise redirect('/tracks')
if not os.path.split(inp.path)[-1] == name:
flash("Doesn't exist", 'error')
raise redirect('/tracks')
for t in inp.tracks:
if user.id == t.user_id:
response.content_type = 'application/x-sqlite3'
response.headerlist.append(('Content-Disposition', 'attachment;filename=%s.sqlite' % t.name))
return open(t.path).read()
flash("You haven't the right to download any tracks which is not yours", 'error')
raise redirect('/tracks')
@expose()
def traceback(self, id):
user = handler.user.get_user_in_session(request)
if not checker.user_own_track(user.id, id) and not checker.is_admin(user):
flash("You haven't the right to look at any tracks which is not yours", 'error')
raise redirect('/tracks')
track = DBSession.query(Track).filter(Track.id == id).first()
return track.traceback
@expose()
def copy(self, track_id):
user = handler.user.get_user_in_session(request)
if not checker.can_download_track(user.id, track_id):
return reply.error(request, 'You have no right to copy this track in your profile.', './', {})
t = DBSession.query(Track).filter(Track.id == track_id).first()
if not t:
return reply.error(request, 'No track with this id.', './', {})
handler.track.copy_track(user.id, t)
return reply.normal(request, 'Copy successfull', './', {})
##### for ADMINS #######
@require(has_permission('admin', msg='Only for admins'))
@expose('pygdv.templates.track_admin')
@expose('json')
#@paginate('items', items_per_page=10)
@with_trailing_slash
def admin(self, **kw):
# view on a specific project
grid = datagrid.track_admin_grid
if kw.has_key('pid'):
project_id = kw.get('pid')
project = DBSession.query(Project).filter(Project.id == project_id).first()
tracks = project.tracks
kw['upload'] = True
kw['pn'] = project.name
track_list = [util.to_datagrid(grid, tracks, "Track Listing", len(tracks)>0)]
else:
if 'user_id' in kw:
tracks = DBSession.query(Track).filter(Track.user_id == kw['user_id']).all()
else:
tracks = DBSession.query(Track).all()
track_list = [util.to_datagrid(grid, tracks, "Track Listing", len(tracks)>0)]
kw['upload'] = True
# track list
t = handler.help.tooltip['admin']
# project list
all_projects = DBSession.query(Project).all()
project_list = [(p.id, p.name,) for p in all_projects]
return dict(page='tracks', model='track', form_title="new track", track_list=track_list,
project_list=project_list, shared_project_list=[], value=kw,
tooltip=t, project_id=kw.get('pid', None), upload=kw.get('upload', None), project_name=kw.get('pn', None))
@expose('json')
def after_sha1(self, fname, sha1, force, callback_url, track_id, old_task_id, mail, key, sequence_id, extension, trackname):
"""
Called after a sha1 where calculated on a file.
If the sha1 already exist, only the databases operations are done.
Else the input will go in the second part of the process.
The input can be 'forced' to be recomputed
"""
try:
_input = DBSession.query(Input).filter(Input.sha1 == sha1).first()
do_process = True
if util.str2bool(force) and _input is not None:
handler.track.delete_input(_input.sha1)
DBSession.delete(_input)
DBSession.flush()
elif _input is not None:
do_process = False
handler.track.update(track_id=track_id,
params={'new_input_id': _input.id})
handler.track.finalize_track_creation(track_id=track_id)
if do_process:
handler.track.update(track_id=track_id, params={'sha1': sha1})
sequence = DBSession.query(Sequence).filter(Sequence.id == sequence_id).first()
async = tasks.track_process.delay(mail, key, old_task_id, fname, sha1, callback_url, track_id, sequence.name, extension, trackname, callback_url)
handler.track.update(track_id=track_id,
params={'new_task_id': async.task_id})
return {'success': 'to second process'}
except Exception as e:
etype, value, tb = sys.exc_info()
traceback.print_exception(etype, value, tb)
return {'error': str(e)}
@expose('json')
def after_process(self, mail, key, old_task_id, track_id, datatype):
print '[x] after process [x] %s' % track_id
task = DBSession.query(Task).filter(Task.task_id == old_task_id).first()
if task is not None:
DBSession.delete(task)
DBSession.flush()
if not track_id == 'None':
handler.track.update(track_id=track_id, params={'datatype': datatype})
handler.track.finalize_track_creation(track_id=track_id)
return {'success': 'end'}
class TipoItemController(BaseController):
@expose()
def index(self):
"""Muestra la pantalla inicial"""
return dict(nombre_modelo='Tipo de Item', page='index_tipo_item')
@expose('is2sap.templates.tipo_item.listadoImportar')
@require(predicates.has_any_permission('lider_proyecto'))
def listadoImportar(self, id_proyecto, id_fase):
"""Metodo para listar los Tipos de Items que se pueden Importar"""
try:
listaProyectos = DBSession.query(Proyecto).order_by(
Proyecto.id_proyecto)
for proyecto in listaProyectos:
for fase in proyecto.fases:
for tipoitem in fase.tipoitems:
for atributo in tipoitem.atributos:
print atributo.nombre
myTree = TreeView(treeDiv='navTree')
tmpl_context.form = myTree
except SQLAlchemyError:
flash(
_("No se pudo acceder a Importacion de Tipo de Item! SQLAlchemyError..."
), 'error')
redirect("/admin/tipo_item/listadoTipoItemPorFase",
id_proyecto=id_proyecto,
id_fase=id_fase)
except (AttributeError, NameError):
flash(
_("No se pudo acceder a Importacion de Tipo de Item! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/tipo_item/listadoTipoItemPorFase",
id_proyecto=id_proyecto,
id_fase=id_fase)
return dict(listaProyectos=listaProyectos,
id_proyecto=id_proyecto,
id_fase=id_fase)
@expose()
@require(predicates.has_any_permission('lider_proyecto'))
def importar(self, **kw):
#id_proyecto, id_fase, id_tipo_item, nombre, descripcion, codigo):
"""Metodo que realiza la importacion del Tipo de Item con todos sus Atributos"""
try:
tipo_item = TipoItem()
tipo_item.id_fase = kw['id_fase']
tipo_item.nombre = kw['nombre']
tipo_item.codigo = kw['codigo']
tipo_item.descripcion = kw['descripcion']
DBSession.add(tipo_item)
DBSession.flush()
listaAtributos = DBSession.query(Atributo).filter_by(
id_tipo_item=kw['id_tipo_item']).all()
for unAtributo in listaAtributos:
print unAtributo.nombre
atributo = Atributo()
atributo.id_tipo_item = tipo_item.id_tipo_item
atributo.nombre = unAtributo.nombre
atributo.descripcion = unAtributo.descripcion
atributo.tipo = unAtributo.tipo
DBSession.add(atributo)
DBSession.flush()
transaction.commit()
except IntegrityError:
transaction.abort()
flash(
_("No se ha realizado la importacion! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/tipo_item/listadoTipoItemPorFase",
id_proyecto=kw['id_proyecto'],
id_fase=kw['id_fase'])
except SQLAlchemyError:
flash(_("No se ha realizado la importacion! SQLAlchemyError..."),
'error')
redirect("/admin/tipo_item/listadoTipoItemPorFase",
id_proyecto=kw['id_proyecto'],
id_fase=kw['id_fase'])
except (AttributeError, NameError):
flash(
_("No se ha realizado la importacion! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/tipo_item/listadoTipoItemPorFase",
id_proyecto=kw['id_proyecto'],
id_fase=kw['id_fase'])
else:
flash(_("Se ha importado correctamente!"), 'ok')
redirect("/admin/tipo_item/listadoTipoItemPorFase",
id_proyecto=kw['id_proyecto'],
id_fase=kw['id_fase'])
@expose('is2sap.templates.tipo_item.nuevo')
@require(predicates.has_any_permission('lider_proyecto'))
def nuevoDesdeFase(self, id_fase, **kw):
"""Despliega el formulario para añadir un Nuevo Tipo de Item a la fase de un proyecto."""
try:
tmpl_context.form = crear_tipo_item_form
fase = DBSession.query(Fase).get(id_fase)
id_proyecto = fase.id_proyecto
kw['id_fase'] = id_fase
except SQLAlchemyError:
flash(
_("No se pudo acceder a Creacion de Tipo de Item! SQLAlchemyError..."
), 'error')
redirect("/admin/tipo_item/listadoTipoItemPorFase",
id_proyecto=id_proyecto,
id_fase=id_fase)
except (AttributeError, NameError):
flash(
_("No se pudo acceder a Creacon de Tipo de Item! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/tipo_item/listadoTipoItemPorFase",
id_proyecto=id_proyecto,
id_fase=id_fase)
return dict(nombre_modelo='Tipo Item',
page='nuevo_tipo_item',
id_proyecto=id_proyecto,
id_fase=id_fase,
value=kw)
@expose()
@validate(crear_tipo_item_form, error_handler=nuevoDesdeFase)
@require(predicates.has_any_permission('lider_proyecto'))
def add(self, **kw):
"""Metodo para agregar un registro a la base de datos """
try:
tipo_item = TipoItem()
tipo_item.id_fase = kw['id_fase']
tipo_item.nombre = kw['nombre']
tipo_item.codigo = kw['codigo']
tipo_item.descripcion = kw['descripcion']
DBSession.add(tipo_item)
DBSession.flush()
transaction.commit()
fase = DBSession.query(Fase).get(kw['id_fase'])
id_fase = fase.id_fase
id_proyecto = fase.id_proyecto
except IntegrityError:
transaction.abort()
flash(_("No se ha guardado! Hay Problemas con el servidor..."),
'error')
redirect("/admin/tipo_item/listadoTipoItemPorFase",
id_proyecto=id_proyecto,
id_fase=id_fase)
except SQLAlchemyError:
flash(_("No se ha guardado! SQLAlchemyError..."), 'error')
redirect("/admin/tipo_item/listadoTipoItemPorFase",
id_proyecto=id_proyecto,
id_fase=id_fase)
except (AttributeError, NameError):
flash(_("No se ha guardado! Hay Problemas con el servidor..."),
'error')
redirect("/admin/tipo_item/listadoTipoItemPorFase",
id_proyecto=id_proyecto,
id_fase=id_fase)
else:
flash(_("Tipo de Item creado!"), 'ok')
redirect("/admin/tipo_item/listadoTipoItemPorFase",
id_proyecto=id_proyecto,
id_fase=id_fase)
@expose("is2sap.templates.tipo_item.listadoTipoItemPorFase")
@require(predicates.has_any_permission('lider_proyecto'))
def listadoTipoItemPorFase(self, id_proyecto, id_fase, page=1):
"""Metodo para listar los Tipos de Items de una Fase """
try:
tipoItemPorFase = DBSession.query(TipoItem).join(
TipoItem.relacion_fase).filter(
TipoItem.id_fase == id_fase).options(
contains_eager(TipoItem.relacion_fase)).order_by(
TipoItem.id_tipo_item)
nombreFase = DBSession.query(
Fase.nombre).filter_by(id_fase=id_fase).first()
idProyectoFase = DBSession.query(
Fase.id_proyecto).filter_by(id_fase=id_fase).first()
currentPage = paginate.Page(tipoItemPorFase,
page,
items_per_page=10)
except SQLAlchemyError:
flash(
_("No se pudo acceder a Tipo de Items de Fase! SQLAlchemyError..."
), 'error')
redirect("/admin/fase/listadoFasesPorProyecto",
id_proyecto=id_proyecto)
except (AttributeError, NameError):
flash(
_("No se pudo acceder a Tipo de Items de Fase! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/fase/listadoFasesPorProyecto",
id_proyecto=id_proyecto)
return dict(tipoItemPorFase=currentPage.items,
page='listado',
nombre_fase=nombreFase,
id_proyecto=id_proyecto,
id_fase=id_fase,
currentPage=currentPage)
@expose('is2sap.templates.tipo_item.editar')
@require(predicates.has_any_permission('lider_proyecto'))
def editar(self, id_tipo_item, **kw):
"""Metodo que rellena el formulario para editar los datos de un usuario"""
try:
tmpl_context.form = editar_tipo_item_form
tipo_item = DBSession.query(TipoItem).get(id_tipo_item)
id_fase = tipo_item.id_fase
fase = DBSession.query(Fase).get(id_fase)
id_proyecto = fase.id_proyecto
proyecto = DBSession.query(Proyecto).get(id_proyecto)
if proyecto.iniciado == True:
flash(_("Proyecto ya iniciado. No puede editar Tipo de Item!"),
'error')
redirect("/admin/tipo_item/listadoTipoItemPorFase",
id_proyecto=id_proyecto,
id_fase=id_fase)
traertipo_item = DBSession.query(TipoItem).get(id_tipo_item)
kw['id_tipo_item'] = traertipo_item.id_tipo_item
kw['nombre'] = traertipo_item.nombre
kw['codigo'] = traertipo_item.codigo
kw['descripcion'] = traertipo_item.descripcion
kw['id_fase'] = traertipo_item.id_fase
except SQLAlchemyError:
flash(
_("No se pudo acceder a Edicion de Tipo de Item! SQLAlchemyError..."
), 'error')
redirect("/admin/tipo_item/listadoTipoItemPorFase",
id_proyecto=id_proyecto,
id_fase=id_fase)
except (AttributeError, NameError):
flash(
_("No se pudo acceder a Edicion de Tipo de Item! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/tipo_item/listadoTipoItemPorFase",
id_proyecto=id_proyecto,
id_fase=id_fase)
return dict(nombre_modelo='Tipo Item',
id_proyecto=id_proyecto,
id_fase=id_fase,
page='editar',
value=kw)
@validate(editar_tipo_item_form, error_handler=editar)
@expose()
@require(predicates.has_any_permission('lider_proyecto'))
def update(self, **kw):
"""Metodo que actualiza la base de datos"""
try:
tipo_item = DBSession.query(TipoItem).get(kw['id_tipo_item'])
tipo_item.nombre = kw['nombre']
tipo_item.codigo = kw['codigo']
tipo_item.descripcion = kw['descripcion']
tipo_item.id_fase = kw['id_fase']
DBSession.flush()
transaction.commit()
fase = DBSession.query(Fase).get(kw['id_fase'])
id_fase = fase.id_fase
id_proyecto = fase.id_proyecto
except IntegrityError:
transaction.abort()
flash(
_("No se han guardado los cambios! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/tipo_item/listadoTipoItemPorFase",
id_proyecto=id_proyecto,
id_fase=id_fase)
except SQLAlchemyError:
flash(_("No se han guardado los cambios! SQLAlchemyError..."),
'error')
redirect("/admin/tipo_item/listadoTipoItemPorFase",
id_proyecto=id_proyecto,
id_fase=id_fase)
except (AttributeError, NameError):
flash(
_("No se han guardado los cambios! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/tipo_item/listadoTipoItemPorFase",
id_proyecto=id_proyecto,
id_fase=id_fase)
else:
flash(_("Se han guardado los cambios!"), 'ok')
redirect("/admin/tipo_item/listadoTipoItemPorFase",
id_proyecto=id_proyecto,
id_fase=id_fase)
@expose('is2sap.templates.tipo_item.confirmar_eliminar')
@require(predicates.has_any_permission('lider_proyecto'))
def confirmar_eliminar(self, id_proyecto, id_fase, id_tipo_item, **kw):
"""Despliega confirmacion de eliminacion"""
try:
proyecto = DBSession.query(Proyecto).get(id_proyecto)
if proyecto.iniciado == True:
flash(
_("Proyecto ya iniciado. No puede eliminar Tipo de Item!"),
'error')
redirect("/admin/tipo_item/listadoTipoItemPorFase",
id_proyecto=id_proyecto,
id_fase=id_fase)
tipo_item = DBSession.query(TipoItem).get(id_tipo_item)
except SQLAlchemyError:
flash(
_("No se pudo acceder a Edicion de Tipo de Item! SQLAlchemyError..."
), 'error')
redirect("/admin/tipo_item/listadoTipoItemPorFase",
id_proyecto=id_proyecto,
id_fase=id_fase)
except (AttributeError, NameError):
flash(
_("No se pudo acceder a Edicion de Tipo de Item! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/tipo_item/listadoTipoItemPorFase",
id_proyecto=id_proyecto,
id_fase=id_fase)
return dict(nombre_modelo='Tipo Item',
page='editar',
id_proyecto=id_proyecto,
id_fase=id_fase,
value=tipo_item)
@expose()
@require(predicates.has_any_permission('lider_proyecto'))
def delete(self, id_proyecto, id_fase, id_tipo_item, **kw):
"""Metodo que elimina un registro de la base de datos"""
try:
atributos = DBSession.query(Atributo).filter_by(
id_tipo_item=id_tipo_item).all()
for atributo in atributos:
DBSession.delete(
DBSession.query(Atributo).get(atributo.id_atributo))
DBSession.delete(DBSession.query(TipoItem).get(id_tipo_item))
DBSession.flush()
transaction.commit()
except IntegrityError:
transaction.abort()
flash(_("No se ha eliminado! Hay Problemas con el servidor..."),
'error')
redirect("/admin/tipo_item/listadoTipoItemPorFase",
id_proyecto=id_proyecto,
id_fase=id_fase)
except SQLAlchemyError:
flash(_("No se ha eliminado! SQLAlchemyError..."), 'error')
redirect("/admin/tipo_item/listadoTipoItemPorFase",
id_proyecto=id_proyecto,
id_fase=id_fase)
except (AttributeError, NameError):
flash(_("No se ha eliminado! Hay Problemas con el servidor..."),
'error')
redirect("/admin/tipo_item/listadoTipoItemPorFase",
id_proyecto=id_proyecto,
id_fase=id_fase)
else:
flash(_("Tipo de Item eliminado!"), 'ok')
redirect("/admin/tipo_item/listadoTipoItemPorFase",
id_proyecto=id_proyecto,
id_fase=id_fase)
class FaseController(BaseController):
@expose()
def index(self):
"""Muestra la pantalla inicial"""
return dict(nombre_modelo='Fase', page='index_fase')
@expose('is2sap.templates.fase.nuevo')
@require(predicates.has_any_permission('lider_proyecto'))
def nuevoDesdeProyecto(self, id_proyecto, **kw):
"""Despliega el formulario para añadir una fase al proyecto."""
try:
tmpl_context.form = crear_fase_form
proyecto = DBSession.query(Proyecto).get(id_proyecto)
if proyecto.iniciado == True:
flash(_("Proyecto ya iniciado. No puede crear fases!"),
'error')
redirect("/admin/fase/listadoFasesPorProyecto",
id_proyecto=id_proyecto)
maxnumerofase = DBSession.query(func.max(
Fase.numero_fase)).filter_by(id_proyecto=id_proyecto).first()
kw['id_proyecto'] = id_proyecto
kw['id_estado_fase'] = 1
if maxnumerofase[0] == None:
kw['numero_fase'] = 1
else:
kw['numero_fase'] = maxnumerofase[0] + 1
except SQLAlchemyError:
flash(
_("No se pudo acceder a Creacion de Fases! SQLAlchemyError..."
), 'error')
redirect("/admin/fase/listadoFasesPorProyecto",
id_proyecto=id_proyecto)
except (AttributeError, NameError):
flash(
_("No se pudo acceder a Creacion de Fases! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/fase/listadoFasesPorProyecto",
id_proyecto=id_proyecto)
return dict(nombre_modelo='Fase',
idProyecto=id_proyecto,
page='nuevo',
value=kw)
@validate(crear_fase_form, error_handler=nuevoDesdeProyecto)
@expose()
@require(predicates.has_any_permission('lider_proyecto'))
def add(self, **kw):
"""Metodo para agregar un registro a la base de datos """
try:
fase = Fase()
fase.id_estado_fase = kw['id_estado_fase']
fase.id_proyecto = kw['id_proyecto']
fase.nombre = kw['nombre']
fase.descripcion = kw['descripcion']
fase.numero_fase = kw['numero_fase']
DBSession.add(fase)
DBSession.flush()
transaction.commit()
except IntegrityError:
transaction.abort()
flash(_("No se ha guardado! Hay Problemas con el servidor..."),
'error')
redirect("/admin/fase/listadoFasesPorProyecto",
id_proyecto=kw['id_proyecto'])
except SQLAlchemyError:
flash(_("No se ha guardado! SQLAlchemyError..."), 'error')
redirect("/admin/fase/listadoFasesPorProyecto",
id_proyecto=kw['id_proyecto'])
except (AttributeError, NameError):
flash(_("No se ha guardado! Hay Problemas con el servidor..."),
'error')
redirect("/admin/fase/listadoFasesPorProyecto",
id_proyecto=kw['id_proyecto'])
else:
flash(_("Fase creada!"), 'ok')
redirect("/admin/fase/listadoFasesPorProyecto",
id_proyecto=kw['id_proyecto'])
@expose("is2sap.templates.fase.listadoFasesPorProyecto")
@require(predicates.has_any_permission('lider_proyecto'))
def listadoFasesPorProyecto(self, id_proyecto, page=1):
"""Metodo para listar las Fases de un proyecto """
try:
fasesPorProyecto = DBSession.query(Fase).join(
Fase.relacion_estado_fase).filter(
Fase.id_proyecto == id_proyecto).options(
contains_eager(Fase.relacion_estado_fase)).order_by(
Fase.numero_fase)
# fasesPorProyecto = DBSession.query(Fase).filter_by(id_proyecto=id_proyecto).order_by(Fase.numero_fase)
nombreProyecto = DBSession.query(
Proyecto.nombre).filter_by(id_proyecto=id_proyecto).first()
currentPage = paginate.Page(fasesPorProyecto,
page,
items_per_page=10)
except SQLAlchemyError:
flash(
_("No se pudo acceder a Fases del Proyecto! SQLAlchemyError..."
), 'error')
redirect("/admin/proyecto/listado")
except (AttributeError, NameError):
flash(
_("No se pudo acceder a Fases del Proyecto! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/proyecto/listado")
return dict(fasesPorProyecto=currentPage.items,
page='listado_fases',
nombre_proyecto=nombreProyecto,
id_proyecto=id_proyecto,
currentPage=currentPage)
@expose('is2sap.templates.fase.editar')
@require(predicates.has_any_permission('lider_proyecto'))
def editar(self, id_proyecto, id_fase, **kw):
"""Metodo que rellena el formulario para editar los datos de una Fase"""
try:
tmpl_context.form = editar_fase_form
proyecto = DBSession.query(Proyecto).get(id_proyecto)
if proyecto.iniciado == True:
flash(_("Proyecto ya iniciado. No puede editar fases!"),
'error')
redirect("/admin/fase/listadoFasesPorProyecto",
id_proyecto=id_proyecto)
traerFase = DBSession.query(Fase).get(id_fase)
kw['id_fase'] = traerFase.id_fase
kw['id_estado_fase'] = traerFase.id_estado_fase
kw['id_proyecto'] = traerFase.id_proyecto
kw['nombre'] = traerFase.nombre
kw['descripcion'] = traerFase.descripcion
kw['numero_fase'] = traerFase.numero_fase
except SQLAlchemyError:
flash(
_("No se pudo acceder a Edicion de Fases! SQLAlchemyError..."),
'error')
redirect("/admin/fase/listadoFasesPorProyecto",
id_proyecto=id_proyecto)
except (AttributeError, NameError):
flash(
_("No se pudo acceder a Edicion de Fases! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/fase/listadoFasesPorProyecto",
id_proyecto=id_proyecto)
return dict(nombre_modelo='Fase', page='editar_fase', value=kw)
@validate(editar_fase_form, error_handler=editar)
@expose()
@require(predicates.has_any_permission('lider_proyecto'))
def update(self, **kw):
"""Metodo que actualiza la fase en la base de datos"""
try:
fase = DBSession.query(Fase).get(kw['id_fase'])
fase.nombre = kw['nombre']
fase.numero_fase = kw['numero_fase']
fase.descripcion = kw['descripcion']
DBSession.flush()
transaction.commit()
except IntegrityError:
transaction.abort()
flash(
_("No se han guardado los cambios! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/fase/listadoFasesPorProyecto",
id_proyecto=kw['id_proyecto'])
except SQLAlchemyError:
flash(_("No se han guardado los cambios! SQLAlchemyError..."),
'error')
redirect("/admin/fase/listadoFasesPorProyecto",
id_proyecto=kw['id_proyecto'])
except (AttributeError, NameError):
flash(
_("No se han guardado los cambios! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/fase/listadoFasesPorProyecto",
id_proyecto=kw['id_proyecto'])
else:
flash(_("Se han guardado los cambios!"), 'ok')
redirect("/admin/fase/listadoFasesPorProyecto",
id_proyecto=kw['id_proyecto'])
@expose('is2sap.templates.fase.confirmar_eliminar')
@require(predicates.has_any_permission('lider_proyecto'))
def confirmar_eliminar(self, id_proyecto, id_fase, **kw):
"""Despliega confirmacion de eliminacion"""
try:
proyecto = DBSession.query(Proyecto).get(id_proyecto)
if proyecto.iniciado == True:
flash(_("Proyecto ya iniciado. No puede eliminar fases!"),
'error')
redirect("/admin/fase/listadoFasesPorProyecto",
id_proyecto=id_proyecto)
fase = DBSession.query(Fase).get(id_fase)
except SQLAlchemyError:
flash(
_("No se pudo acceder a Eliminacion de Fases! SQLAlchemyError..."
), 'error')
redirect("/admin/fase/listadoFasesPorProyecto",
id_proyecto=id_proyecto)
except (AttributeError, NameError):
flash(
_("No se pudo acceder a Eliminacion de Fases! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/fase/listadoFasesPorProyecto",
id_proyecto=id_proyecto)
return dict(nombre_modelo='Fase', page='eliminar_fase', value=fase)
@expose()
@require(predicates.has_any_permission('lider_proyecto'))
def delete(self, id_proyecto, id_fase, **kw):
""" Metodo que elimina un registro de la base de datos
Parametros:
- id_fase: identificador de la fase
"""
try:
tipo_items = DBSession.query(TipoItem).filter_by(
id_fase=id_fase).all()
for tipo_item in tipo_items:
id_tipo_item = tipo_item.id_tipo_item
atributos = DBSession.query(Atributo).filter_by(
id_tipo_item=id_tipo_item).all()
for atributo in atributos:
DBSession.delete(
DBSession.query(Atributo).get(atributo.id_atributo))
DBSession.delete(DBSession.query(TipoItem).get(id_tipo_item))
DBSession.delete(DBSession.query(Fase).get(id_fase))
transaction.commit()
except IntegrityError:
transaction.abort()
flash(_("No se ha eliminado! Hay Problemas con el servidor..."),
'error')
redirect("/admin/fase/listadoFasesPorProyecto",
id_proyecto=id_proyecto)
except SQLAlchemyError:
flash(_("No se ha eliminado! SQLAlchemyError..."), 'error')
redirect("/admin/fase/listadoFasesPorProyecto",
id_proyecto=id_proyecto)
except (AttributeError, NameError):
flash(_("No se ha eliminado! Hay Problemas con el servidor..."),
'error')
redirect("/admin/fase/listadoFasesPorProyecto",
id_proyecto=id_proyecto)
else:
flash(_("Fase eliminada!"), 'ok')
redirect("/admin/fase/listadoFasesPorProyecto",
id_proyecto=id_proyecto)
class AtributoController(BaseController):
@expose()
def index(self):
"""Muestra la pantalla inicial"""
return dict(nombre_modelo='Atributo', page='index_atributo')
@expose('is2sap.templates.atributo.nuevoDesdeTipoItem')
@require(predicates.has_any_permission('lider_proyecto'))
def nuevoDesdeTipoItem(self, id_tipo_item, **kw):
"""Despliega el formulario para añadir un nuevo atributo."""
try:
tmpl_context.form = crear_atributo_form
tipo_item = DBSession.query(TipoItem).get(id_tipo_item)
id_fase = tipo_item.id_fase
fase = DBSession.query(Fase).get(id_fase)
id_proyecto = fase.id_proyecto
kw['id_tipo_item'] = id_tipo_item
except SQLAlchemyError:
flash(
_("No se pudo acceder a Creacion de Atributo! SQLAlchemyError..."
), 'error')
redirect("/admin/atributo/listadoAtributosPorTipoItem",
id_proyecto=id_proyecto,
id_fase=id_fase,
id_tipo_item=id_tipo_item)
except (AttributeError, NameError):
flash(
_("No se pudo acceder a Creacon de Atributo! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/atributo/listadoAtributosPorTipoItem",
id_proyecto=id_proyecto,
id_fase=id_fase,
id_tipo_item=id_tipo_item)
return dict(nombre_modelo='Atributo',
page='nuevo_atributo',
id_proyecto=id_proyecto,
id_fase=id_fase,
id_tipo_item=id_tipo_item,
value=kw)
@validate(crear_atributo_form, error_handler=nuevoDesdeTipoItem)
@require(predicates.has_any_permission('lider_proyecto'))
@expose()
def add(self, **kw):
"""Metodo para agregar un registro a la base de datos """
try:
atributo = Atributo()
atributo.id_tipo_item = kw['id_tipo_item']
atributo.nombre = kw['nombre']
atributo.descripcion = kw['descripcion']
atributo.tipo = kw['tipo']
DBSession.add(atributo)
DBSession.flush()
transaction.commit()
tipo_item = DBSession.query(TipoItem).get(kw['id_tipo_item'])
id_tipo_item = tipo_item.id_tipo_item
fase = tipo_item.relacion_fase
id_fase = fase.id_fase
id_proyecto = fase.id_proyecto
except IntegrityError:
transaction.abort()
flash(_("No se ha guardado! Hay Problemas con el servidor..."),
'error')
redirect("/admin/atributo/listadoAtributosPorTipoItem",
id_proyecto=id_proyecto,
id_fase=id_fase,
id_tipo_item=id_tipo_item)
except SQLAlchemyError:
flash(_("No se ha guardado! SQLAlchemyError..."), 'error')
redirect("/admin/atributo/listadoAtributosPorTipoItem",
id_proyecto=id_proyecto,
id_fase=id_fase,
id_tipo_item=id_tipo_item)
except (AttributeError, NameError):
flash(_("No se ha guardado! Hay Problemas con el servidor..."),
'error')
redirect("/admin/atributo/listadoAtributosPorTipoItem",
id_proyecto=id_proyecto,
id_fase=id_fase,
id_tipo_item=id_tipo_item)
else:
flash(_("Atributo creado!"), 'ok')
redirect("/admin/atributo/listadoAtributosPorTipoItem",
id_proyecto=id_proyecto,
id_fase=id_fase,
id_tipo_item=id_tipo_item)
@expose("is2sap.templates.atributo.listadoAtributosPorTipoItem")
@require(predicates.has_any_permission('lider_proyecto'))
def listadoAtributosPorTipoItem(self,
id_proyecto,
id_fase,
id_tipo_item,
page=1):
"""Metodo para listar todos los atributos de la base de datos"""
try:
atributos = DBSession.query(Atributo).filter_by(
id_tipo_item=id_tipo_item).order_by(Atributo.id_atributo)
currentPage = paginate.Page(atributos, page, items_per_page=10)
tipo_item = DBSession.query(TipoItem).get(id_tipo_item)
except SQLAlchemyError:
flash(
_("No se pudo acceder a Atributos de Tipo de Item! SQLAlchemyError..."
), 'error')
redirect("/admin/tipo_item/listadoTipoItemPorFase",
id_proyecto=id_proyecto,
id_fase=id_fase)
except (AttributeError, NameError):
flash(
_("No se pudo acceder a Atributos de Tipo de Item! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/tipo_item/listadoTipoItemPorFase",
id_proyecto=id_proyecto,
id_fase=id_fase)
return dict(atributos=currentPage.items,
page='listado_atributos',
nombre_tipo_item=tipo_item.nombre,
id_proyecto=id_proyecto,
id_fase=id_fase,
id_tipo_item=id_tipo_item,
currentPage=currentPage)
@expose('is2sap.templates.atributo.editar')
@require(predicates.has_any_permission('lider_proyecto'))
def editar(self, id_atributo, **kw):
"""Metodo que rellena el formulario para editar los datos de un usuario"""
try:
tmpl_context.form = editar_atributo_form
traerAtributo = DBSession.query(Atributo).get(id_atributo)
id_tipo_item = traerAtributo.id_tipo_item
tipo_item = DBSession.query(TipoItem).get(id_tipo_item)
id_fase = tipo_item.id_fase
fase = DBSession.query(Fase).get(id_fase)
id_proyecto = fase.id_proyecto
proyecto = DBSession.query(Proyecto).get(id_proyecto)
if proyecto.iniciado == True:
flash(_("Proyecto ya iniciado. No puede editar Atributo!"),
'error')
redirect("/admin/atributo/listadoAtributosPorTipoItem",
id_proyecto=id_proyecto,
id_fase=id_fase,
id_tipo_item=id_tipo_item)
kw['id_atributo'] = traerAtributo.id_atributo
kw['id_tipo_item'] = traerAtributo.id_tipo_item
kw['nombre'] = traerAtributo.nombre
kw['descripcion'] = traerAtributo.descripcion
kw['tipo'] = traerAtributo.tipo
except SQLAlchemyError:
flash(
_("No se pudo acceder a Edicion de Atributo! SQLAlchemyError..."
), 'error')
redirect("/admin/atributo/listadoAtributosPorTipoItem",
id_proyecto=id_proyecto,
id_fase=id_fase,
id_tipo_item=id_tipo_item)
except (AttributeError, NameError):
flash(
_("No se pudo acceder a Edicion de Atributo! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/atributo/listadoAtributosPorTipoItem",
id_proyecto=id_proyecto,
id_fase=id_fase,
id_tipo_item=id_tipo_item)
return dict(nombre_modelo='Atributo',
page='editar',
id_proyecto=id_proyecto,
id_fase=id_fase,
id_tipo_item=id_tipo_item,
value=kw)
@validate(editar_atributo_form, error_handler=editar)
@expose()
@require(predicates.has_any_permission('lider_proyecto'))
def update(self, **kw):
"""Metodo que actualiza la base de datos"""
try:
atributo = DBSession.query(Atributo).get(kw['id_atributo'])
atributo.id_tipo_item = kw['id_tipo_item']
atributo.nombre = kw['nombre']
atributo.descripcion = kw['descripcion']
atributo.tipo = kw['tipo']
DBSession.flush()
transaction.commit()
tipo_item = DBSession.query(TipoItem).get(kw['id_tipo_item'])
id_tipo_item = tipo_item.id_tipo_item
fase = tipo_item.relacion_fase
id_fase = fase.id_fase
id_proyecto = fase.id_proyecto
except IntegrityError:
transaction.abort()
flash(
_("No se han guardado los cambios! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/atributo/listadoAtributosPorTipoItem",
id_proyecto=id_proyecto,
id_fase=id_fase,
id_tipo_item=id_tipo_item)
except SQLAlchemyError:
flash(_("No se han guardado los cambios! SQLAlchemyError..."),
'error')
redirect("/admin/atributo/listadoAtributosPorTipoItem",
id_proyecto=id_proyecto,
id_fase=id_fase,
id_tipo_item=id_tipo_item)
except (AttributeError, NameError):
flash(
_("No se han guardado los cambios! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/atributo/listadoAtributosPorTipoItem",
id_proyecto=id_proyecto,
id_fase=id_fase,
id_tipo_item=id_tipo_item)
else:
flash(_("Se han guardado los cambios!"), 'ok')
redirect("/admin/atributo/listadoAtributosPorTipoItem",
id_proyecto=id_proyecto,
id_fase=fase.id_fase,
id_tipo_item=id_tipo_item)
@expose('is2sap.templates.atributo.confirmar_eliminar')
@require(predicates.has_any_permission('lider_proyecto'))
def confirmar_eliminar(self, id_proyecto, id_fase, id_tipo_item,
id_atributo, **kw):
"""Despliega confirmacion de eliminacion"""
try:
proyecto = DBSession.query(Proyecto).get(id_proyecto)
if proyecto.iniciado == True:
flash(_("Proyecto ya iniciado. No puede eliminar Atributo!"),
'error')
redirect("/admin/atributo/listadoAtributosPorTipoItem",
id_proyecto=id_proyecto,
id_fase=id_fase,
id_tipo_item=id_tipo_item)
atributo = DBSession.query(Atributo).get(id_atributo)
except SQLAlchemyError:
flash(
_("No se pudo acceder a Eliminacion de Atributo! SQLAlchemyError..."
), 'error')
redirect("/admin/atributo/listadoAtributosPorTipoItem",
id_proyecto=id_proyecto,
id_fase=id_fase,
id_tipo_item=id_tipo_item)
except (AttributeError, NameError):
flash(
_("No se pudo acceder a Eliminacion de Atributo! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/atributo/listadoAtributosPorTipoItem",
id_proyecto=id_proyecto,
id_fase=id_fase,
id_tipo_item=id_tipo_item)
return dict(nombre_modelo='Atributo',
page='editar',
id_proyecto=id_proyecto,
id_fase=id_fase,
id_tipo_item=id_tipo_item,
value=atributo)
@expose()
@require(predicates.has_any_permission('lider_proyecto'))
def delete(self, id_proyecto, id_fase, id_tipo_item, id_atributo, **kw):
""" Metodo que elimina el registro de un atributo
Parametros: - id_atributo: Para identificar el atributo a eliminar
- id_tipo_item: Para redireccionar al listado de atributos correspondientes al tipo de item
"""
try:
DBSession.delete(DBSession.query(Atributo).get(id_atributo))
DBSession.flush()
transaction.commit()
except IntegrityError:
transaction.abort()
flash(_("No se ha eliminado! Hay Problemas con el servidor..."),
'error')
redirect("/admin/atributo/listadoAtributosPorTipoItem",
id_proyecto=id_proyecto,
id_fase=id_fase,
id_tipo_item=id_tipo_item)
except SQLAlchemyError:
flash(_("No se ha eliminado! SQLAlchemyError..."), 'error')
redirect("/admin/atributo/listadoAtributosPorTipoItem",
id_proyecto=id_proyecto,
id_fase=id_fase,
id_tipo_item=id_tipo_item)
except (AttributeError, NameError):
flash(_("No se ha eliminado! Hay Problemas con el servidor..."),
'error')
redirect("/admin/atributo/listadoAtributosPorTipoItem",
id_proyecto=id_proyecto,
id_fase=id_fase,
id_tipo_item=id_tipo_item)
else:
flash(_("Atributo eliminado!"), 'ok')
redirect("/admin/atributo/listadoAtributosPorTipoItem",
id_proyecto=id_proyecto,
id_fase=id_fase,
id_tipo_item=id_tipo_item)
# copy shortcuts and privileges form another user
if new_user:
user.copy_from(copy_from)
return dict(status=True)
except EUser, e:
logger.error(e)
return dict(status=False, message=unicode(e))
except Exception, e:
logger.error(e)
return dict(status=False)
@expose('sapns/users/permission.html')
@require(predicates.has_any_permission('manage', 'users'))
def permission(self, came_from='/dashboard/users'):
return dict(came_from=url(came_from))
@expose('sapns/users/roles.html')
@require(predicates.has_any_permission('manage', 'users'))
@add_language
def roles(self, id_user, **kw):
logger = logging.getLogger('UsersController.roles')
try:
user = dbs.query(SapnsUser).get(int(id_user))
roles = []
for r in dbs.query(SapnsRole).order_by(SapnsRole.group_name):
#r = SapnsRole()
from archeologicaladdressbook.lib.base import BaseController
from archeologicaladdressbook.lib.base import render
from archeologicaladdressbook.lib.base import validate
from archeologicaladdressbook.lib.base import authenticate_form
from archeologicaladdressbook.lib.helpers import flash_message
from archeologicaladdressbook.lib.helpers import paginate
from archeologicaladdressbook.lib.auth import ProtectController
from archeologicaladdressbook.lib.auth import ProtectAction
from archeologicaladdressbook.model import Session, Address, Person, forms
log = logging.getLogger(__name__)
@ProtectController(has_any_permission('edit', 'view'))
class AddressesController(BaseController):
""" `Addresses` Controller."""
# TODO: add check personn + address_type uniqueness constrain
# See related person infos and/or include in person templates
# index and list actions
@ProtectAction(has_permission('view'))
def index(self):
""" Render the addresses index template."""
return render('/addresses/index.mako')
@ProtectAction(has_permission('view'))
def list(self, id=None):
class RootController(BaseController):
"""
The root controller for the pygdv application.
All the other controllers and WSGI applications should be mounted on this
controller. For example::
panel = ControlPanelController()
another_app = AnotherWSGIApplication()
Keep in mind that WSGI applications shouldn't be mounted directly: They
must be wrapped around with :class:`tg.controllers.WSGIAppController`.
"""
error = ErrorController()
login = LoginController()
sequences = SequenceController()
tracks = TrackController()
projects = ProjectController()
circles = CircleController()
jobs = JobController()
public = PublicController()
help = HelpController()
genrep = GenRepController()
database = DatabaseController()
selections = SelectionController()
plugins = PluginController()
@expose('pygdv.templates.index')
def index(self, *args, **kw):
raise redirect('/tracks')
@expose('pygdv.templates.help')
def login_needed(self):
flash('You need to login', 'error')
return dict(page='index')
#@require(has_permission('admin', msg='Only for admins'))
@expose()
def test_files(self, id):
import os
from pkg_resources import resource_filename
from pygdv.tests.test_input_files import samples
from tg import response
samples_path = resource_filename('pygdv.tests', 'test_files')
print samples[int(id)]
_f = open(os.path.join(samples_path, samples[int(id)]))
response.content_type = 'plain/text'
response.headerlist.append(
('Content-Disposition',
'attachment;filename=%s' % samples[int(id)]))
return _f.read()
@expose('pygdv.templates.about')
def about(self):
"""Handle the 'about' page."""
return dict(page='about')
@expose()
def home(self, *args, **kw):
raise redirect('/')
## DEVELOPMENT PAGES ##
@require(has_permission('admin', msg='Only for admins'))
@expose('pygdv.templates.environ')
def environ(self):
"""This method showcases TG's access to the wsgi environment."""
return dict(page='environ', environment=request.environ)
# @require(has_permission('admin', msg='Only for admins'))
# @expose('pygdv.templates.data')
# @expose('json')
# def data(self, **kw):
# """This method showcases how you can use the same controller for a data page and a display page"""
# return dict(page='data',params=kw)
@require(has_any_permission('admin', 'user', msg='You must be logged'))
@expose()
def private_key(self):
from pygdv import handler
user = handler.user.get_user_in_session(request)
return user.key
@require(has_any_permission('user', 'admin', msg='You must be logged'))
@expose('pygdv.templates.me')
def me(self):
from pygdv import handler
user = handler.user.get_user_in_session(request)
return {'user': user, 'page': 'user'}
class JobController(BaseController):
allow_only = has_any_permission(constants.permissions['admin']['name'],
constants.permissions['read']['name'])
@with_trailing_slash
@expose('pygdv.templates.jobs_index')
def index(self, *args, **kw):
user = handler.user.get_user_in_session(request)
if request.method == 'POST':
jid = kw.get('id', None)
if jid is not None and checker.can_edit_job(user.id, jid):
handler.job.delete(jid)
else:
flash('not authorized')
jobs = DBSession.query(Job).filter(Job.user_id == user.id).all()
data = util.to_datagrid(datagrid.job_grid,
jobs,
"Job Listing",
grid_display=len(jobs) > 0)
t = handler.help.help_address(url('/help'), 'jobs',
'How to compute new data')
return dict(page='jobs',
model='job',
form_title="new job",
item=data,
value=kw,
tooltip=t)
@expose('pygdv.templates.job')
def result(self, id):
res = DBSession.query(Bresults).filter(Bresults.id == id).first()
checker.check_permission(
user=handler.user.get_user_in_session(request),
project=res.job.project,
right_id=constants.right_download_id)
if res.rtype in constants.track_types:
raise redirect(url('/tracks/links/%s' % res.track_id))
src = constants.extra_url() + '/' + res.rpath
return dict(page='jobs', model='Job', src=src)
@expose('json')
def delete(self, _id):
user = handler.user.get_user_in_session(request)
if not checker.can_edit_job(user.id, _id):
return {
'error': "You have don't have the right to delete this job"
}
job = DBSession.query(Job).filter(Job.id == _id).first()
# TODO delete results (DB + filesystem)
DBSession.delete(job)
raise redirect('/jobs')
@expose()
def traceback(self, id):
job = DBSession.query(Job).filter(Job.id == id).first()
if job.traceback:
return job.traceback
return 'no traceback.'
class TrackhubController(BaseController):
allow_only = has_any_permission(gl.perm_admin, gl.perm_user)
@with_trailing_slash
@expose('biorepo.templates.list_no_new')
def index(self, *args, **kw):
user = handler.user.get_user_in_session(request)
user_lab = session.get("current_lab", None)
mail = user.email
mail_tmp = mail.split("@")
mail_final = mail_tmp[0] + "AT" + mail_tmp[1]
user_TH_path = trackhubs_path() + "/" + user_lab + "/" + mail_final
trackhubs = []
if os.path.exists(user_TH_path):
list_trackhubs = os.listdir(user_TH_path)
for t in list_trackhubs:
th_path = user_TH_path + "/" + t
#the only one directory into at this th level is named by the assembly used for it
for i in os.listdir(th_path):
path_to_test = th_path + "/" + i
if os.path.isdir(path_to_test):
assembly = i
if not assembly:
break
else:
#hub_url = th_path + "/hub.txt"
hostname = socket.gethostname().lower()
#because of aliasing
if hostname == "ptbbsrv2.epfl.ch":
hostname = "biorepo.epfl.ch"
hub_url = "http://" + hostname + url(
"/trackHubs/"
) + user_lab + "/" + mail_final + "/" + t + "/hub.txt"
th = Trackhub(
t, 'http://genome.ucsc.edu/cgi-bin/hgTracks?hubUrl=' +
hub_url + "&db=" + assembly)
trackhubs.append(th)
all_trackhubs = [
util.to_datagrid(TrackhubGrid(), trackhubs, " UCSC's Trackhub(s)",
len(trackhubs) > 0)
]
return dict(page='trackhubs',
model=trackhubs,
items=all_trackhubs,
value=kw)
@expose('biorepo.templates.edit_trackhub')
def edit(self, *args, **kw):
th_name = str(args[0])
session["th_name"] = th_name
session.save()
user = handler.user.get_user_in_session(request)
user_lab = session.get("current_lab", None)
mail_path = str(user._email).lower().replace('@', 'AT')
if user_lab is None:
flash(
"Problem detected with your lab in session. Contact your administrator please",
'error')
raise redirect('/trackhubs')
complementary_path = str(
user_lab) + "/" + mail_path + "/" + th_name + "/"
th_path = trackhubs_path() + "/" + complementary_path
genome_path = th_path + "genomes.txt"
if os.path.exists(genome_path):
#get the final path
with open(genome_path, 'r') as gen:
l = gen.readline()
while l != '':
if l.startswith("trackDb"):
trackdb_path = l.split('trackDb')[1].strip()
l = gen.readline()
final_path = th_path + trackdb_path + "trackDb.txt"
with open(final_path, 'r') as final:
l = final.readline()
dic_colors = {}
cpt = 0
while l != '':
if l.startswith("\ttrack"):
track = l.split("\ttrack")[1].strip()
dic_colors[cpt] = track
cpt += 1
elif l.startswith("\tcolor"):
color = l.split("\tcolor")[1].strip()
dic_colors[cpt] = color
cpt += 1
l = final.readline()
t_length = len(dic_colors.keys())
edit_form = build_form_edit_th(t_length)(
action=url('/trackhubs/post_edit')).req()
for k, v in dic_colors.items():
#even --> track
if (k % 2 == 0):
edit_form.child.children[k].value = v
#odd --> color
else:
edit_form.child.children[k].value = v
return dict(page='trackhubs', widget=edit_form, value=kw)
else:
flash(
"Your trackhub is not accessible right now. Hardware problem on /data. Sorry for this inconvenient, retry in a fiew moment please.",
'error')
raise redirect('/trackhubs')
@expose()
def post_edit(self, *args, **kw):
dic_colors = {}
th_name = session["th_name"]
user = handler.user.get_user_in_session(request)
user_lab = session.get("current_lab", None)
mail_path = str(user._email).lower().replace('@', 'AT')
for key in kw.keys():
if key.startswith('Color_Track_'):
key_id = key.replace('Color_Track_', '')
dic_colors[int(key_id)] = kw[key] + "\n\n"
#paths...
complementary_path = str(
user_lab) + "/" + mail_path + "/" + th_name + "/"
th_path = trackhubs_path() + "/" + complementary_path
genome_path = th_path + "genomes.txt"
if os.path.exists(genome_path):
#get the final path
with open(genome_path, 'r') as gen:
l = gen.readline()
while l != '':
if l.startswith("trackDb"):
trackdb_path = l.split('trackDb')[1].strip()
l = gen.readline()
source_path = th_path + trackdb_path + "trackDb.txt"
final_path_tmp = th_path + trackdb_path + "trackDb_tmp.txt"
with open(source_path, 'r') as source:
with open(final_path_tmp, 'a') as destination:
l = source.readline()
color_cpt = 0
while l != '':
if l.startswith("\tcolor "):
color_cpt += 1
destination.write("\tcolor " +
dic_colors[color_cpt])
else:
destination.write(l)
l = source.readline()
# remove old file
os.remove(source_path)
# rename new one
os.rename(final_path_tmp, source_path)
flash("Trackhub edited !")
raise redirect("/trackhubs")
else:
flash(
"Your trackhub is not accessible right now. Hardware problem on /data. Sorry for this inconvenient, retry in a fiew moment please.",
'error')
raise redirect('/trackhubs')
@expose()
def delete(self, *args, **kw):
th_name = str(args[0])
user = handler.user.get_user_in_session(request)
user_lab = session.get("current_lab", None)
mail = user.email
mail_tmp = mail.split("@")
mail_final = mail_tmp[0] + "AT" + mail_tmp[1]
user_path = trackhubs_path() + "/" + user_lab + "/" + mail_final
th_path = user_path + "/" + th_name
try:
shutil.rmtree(th_path)
flash("Your trackhub " + th_name + " was deleted.")
except:
flash(
"Error : your trackhub was not deleted. Contact the administrator please.",
'error')
raise redirect(url('/trackhubs'))