def delete_track(self, sequence_id, track_id): user = handler.user.get_user_in_session(request) s = DBSession.query(Sequence).filter(Sequence.id == sequence_id).first() t = DBSession.query(Track).filter(Track.id == track_id).first() s.default_tracks.remove(t) DBSession.flush() raise redirect('/sequences/edit/%s' % sequence_id)
def change_rights(project_id, circle_id, rights=None): ''' Modify the right associated to a project to a group. If any right is added, automatically add read right. @param project_id : the project id @param circle_id : the circle id @param rights : the right to update ''' project = DBSession.query(Project).filter(Project.id == project_id).first() rc_assocs = get_circle_right_assocs(circle_id, project_id) for rc in rc_assocs: if rc.circle.id == int(circle_id) : project._circle_right.remove(rc) DBSession.delete(rc) DBSession.flush() if rights is not None: _add_read_right(project, circle_id) for right_name in rights: if right_name != constants.right_read : right = DBSession.query(Right).filter(Right.name == right_name).first() cr_assoc = _get_circle_right_assoc(right, circle_id, project_id) project._circle_right.append(cr_assoc) DBSession.add(project) DBSession.flush()
def add_read_right(project, circle_id): ''' Add the ``read`` right to the project & circle specified. Flush the database ''' _add_read_right(project, circle_id) DBSession.add(project) DBSession.flush()
def remove_sharing(project=None, project_id=None): if project is None: project = DBSession.query(Project).filter( Project.id == project_id).first() for rc in project._circle_right: DBSession.delete(rc) DBSession.flush()
def can_edit_job(user_id, job_id): user = DBSession.query(User).filter(User.id == user_id).first() if is_admin(user): j = DBSession.query(Job).filter( and_(Job.id == job_id, Job.user_id == user_id)).first() return j != None return True
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))
def init(track, flush=False): p = {} doit = False if track.parameters is None: doit = True elif 'url' not in track.parameters: doit = True p = copy.deepcopy(track.parameters) if doit: p.update({ 'url': os.path.join(track.visualization, track.input.sha1, '{refseq}', constants.track_data), 'label': track.name, 'type': track.visualization == 'signal' and 'ImageTrack' or 'FeatureTrack', 'gdv_id': track.id, 'key': track.name, 'date': track.tiny_date }) track.parameters = p if flush: DBSession.flush()
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})
def add_user(circle=None, circle_id=None, user=None, user_id=None): if user is None: user = DBSession.query(User).filter(User.id == user_id).first() if circle is None: circle = DBSession.query(Circle).filter(Circle.id == circle_id).first() circle.users.append(user) DBSession.flush()
def change_rights(project_id, circle_id, rights=None): ''' Modify the right associated to a project to a group. If any right is added, automatically add read right. @param project_id : the project id @param circle_id : the circle id @param rights : the right to update ''' project = DBSession.query(Project).filter(Project.id == project_id).first() rc_assocs = get_circle_right_assocs(circle_id, project_id) for rc in rc_assocs: if rc.circle.id == int(circle_id): project._circle_right.remove(rc) DBSession.delete(rc) DBSession.flush() if rights is not None: _add_read_right(project, circle_id) for right_name in rights: if right_name != constants.right_read: right = DBSession.query(Right).filter( Right.name == right_name).first() cr_assoc = _get_circle_right_assoc(right, circle_id, project_id) project._circle_right.append(cr_assoc) DBSession.add(project) DBSession.flush()
def delete_user(self, user_id, sequence_id): user = handler.user.get_user_in_session(request) s = DBSession.query(Sequence).filter(Sequence.id == sequence_id).first() u = DBSession.query(User).filter(User.id == user_id).first() s.users.remove(u) DBSession.flush() raise redirect('/sequences/edit/%s' % sequence_id)
def delete(project=None, project_id=None): if project is None: project = DBSession.query(Project).filter( Project.id == project_id).first() remove_sharing(project=project) DBSession.delete(project) DBSession.flush()
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})
def delete_user(self, user_id, sequence_id): user = handler.user.get_user_in_session(request) s = DBSession.query(Sequence).filter( Sequence.id == sequence_id).first() u = DBSession.query(User).filter(User.id == user_id).first() s.users.remove(u) DBSession.flush() raise redirect('/sequences/edit/%s' % sequence_id)
def add_read_right_to_circles_ids(project, ids): ''' Add the ``read`` right to the project & circles specified. Flush the database ''' for id in ids: _add_read_right(project, id) DBSession.add(project) DBSession.flush()
def delete_track(self, sequence_id, track_id): user = handler.user.get_user_in_session(request) s = DBSession.query(Sequence).filter( Sequence.id == sequence_id).first() t = DBSession.query(Track).filter(Track.id == track_id).first() s.default_tracks.remove(t) DBSession.flush() raise redirect('/sequences/edit/%s' % sequence_id)
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')
def edit(self, *args, **kw): user = handler.user.get_user_in_session(request) # get circle id if request.method == 'GET': sequence_id = args[0] else : sequence_id = kw.get('cid') sequence_id=int(sequence_id) sequence = DBSession.query(Sequence).filter(Sequence.id == sequence_id).first() if not sequence: abort(404, 'Sequence with id %s not found' % sequence_id) if not sequence.public: add_user_widget = form.AddUser(action=url('/sequences/edit/%s' % sequence_id)).req() if request.method == 'POST': # add an user mail = kw.get('mail') try: add_user_widget.validate({'cid' : sequence_id, 'mail' : mail}) except twc.ValidationError as e: users = ', '.join(['%s' % u.email for u in sequence.users]) default_tracks = ', '.join(['%s' % t.name for t in sequence.default_tracks]) kw['cid'] = sequence_id users = sequence.users for u in users: u.__dict__['sid'] = sequence_id widget = e.widget widget.value = kw return dict(page='sequences', users=users, add_user=add_user, add_user_widget=add_user_widget, default_tracks=default_tracks, au_error=True, seq_id=sequence_id) to_add = DBSession.query(User).filter(User.email == mail).first() if to_add is None: to_add = handler.user.create_tmp_user(mail) sequence.users.append(to_add) DBSession.flush() kw['cid'] = sequence_id add_user_widget.value = kw else: add_user_widget = None users = sequence.users for u in users: u.__dict__['sid'] = sequence_id tracks = sequence.default_tracks for t in tracks: t.__dict__['sid'] = sequence_id add_user = util.to_datagrid(datagrid.sequence_user_grid, users, "Users", len(users)>0) def_tracks = util.to_datagrid(datagrid.sequence_default_tracks, tracks, "Default tracks", len(tracks)>0) return dict(page='sequences', users=users, add_user=add_user, add_user_widget=add_user_widget, default_tracks=def_tracks, au_error=False, seq_id=sequence_id)
def add_tracks(project, track_ids): ''' Add a list of track to the project specified. ''' for track_id in track_ids: track_ = DBSession.query(Track).filter(Track.id == track_id).first() project.tracks.append(track_) DBSession.add(project) DBSession.flush()
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/')
def get_permissions(admin): ''' Get the right permissions for an user. @param admin : True if the user is an admin. @type admin : a boolean. ''' if admin: return DBSession.query(Permission).all() return DBSession.query(Permission).filter(Permission.name != 'admin').all()
def get_permissions(admin): ''' Get the right permissions for an user. @param admin : True if the user is an admin. @type admin : a boolean. ''' if admin : return DBSession.query(Permission).all() return DBSession.query(Permission).filter(Permission.name != 'admin').all()
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)
def create_tmp_user(mail): user = User() user.name = constants.tmp_user_name user.email = mail user.firstname = '' user_group = DBSession.query(Group).filter(Group.id == constants.group_users_id).first() user_group.users.append(user) DBSession.add(user) DBSession.flush() return user
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'}
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')
def add_right(project=None, project_id=None, circle=None, circle_id=None, right=None, right_id=None): if project is None: project = DBSession.query(Project).filter(Project.id == project_id).first() if circle_id is None: circle_id = circle.id if right is None: right = DBSession.query(Right).filter(Right.id == right_id).first() cr_assoc = _get_circle_right_assoc(right, circle_id, project.id) project._circle_right.append(cr_assoc)
def edit(project, name, user_id, sequence_id=None, tracks=None, isPublic=False, circles=None): ''' Like create but edit an existing project. ''' project.name = name if sequence_id is not None: project.sequence_id = sequence_id project.user_id = user_id project.is_public = isPublic DBSession.add(project) DBSession.flush() project.tracks = [] if tracks is not None: for track_id in tracks: t = DBSession.query(Track).filter(Track.id == track_id).first() project.tracks.append(t) if circles is not None: # adding circle with the read permission by default project._circle_right = [] for circle in circles: _add_read_right(project, circle.id) DBSession.add(project) DBSession.flush() return project
def edit(project, name, user_id, sequence_id=None, tracks=None, isPublic=False, circles=None): ''' Like create but edit an existing project. ''' project.name=name if sequence_id is not None: project.sequence_id = sequence_id project.user_id = user_id project.is_public = isPublic DBSession.add(project) DBSession.flush() project.tracks = [] if tracks is not None: for track_id in tracks : t = DBSession.query(Track).filter(Track.id == track_id).first() project.tracks.append(t) if circles is not None: # adding circle with the read permission by default project._circle_right = [] for circle in circles : _add_read_right(project, circle.id) DBSession.add(project) DBSession.flush() return project
def create_tmp_user(mail): user = User() user.name = constants.tmp_user_name user.email = mail user.firstname = '' user_group = DBSession.query(Group).filter( Group.id == constants.group_users_id).first() user_group.users.append(user) DBSession.add(user) DBSession.flush() return user
def index(self, came_from='/'): ''' Redirect user on tequila page in order to log him ''' if tg.config.get('authentication.disable').lower() in ['t', 'true']: print constants.admin_user_email() environ = request.environ authentication_plugins = environ['repoze.who.plugins'] identifier = authentication_plugins['ticket'] secret = identifier.secret cookiename = identifier.cookie_name remote_addr = environ['REMOTE_ADDR'] user = DBSession.query(User).filter( User.email == constants.admin_user_email()).first() admins = tg.config.get('admin.mails') group_admins = DBSession.query(Group).filter( Group.id == constants.group_admins_id).first() if user.email in admins: user not in group_admins.users and group_admins.users.append( user) else: user in group_admins.users and group_admins.users.remove(user) DBSession.flush() userdata = "%s|%s" % (user.id, user in group_admins.users) ticket = auth_tkt.AuthTicket(secret, user.email, remote_addr, tokens=token, user_data=userdata, time=None, cookie_name=cookiename, secure=True) val = ticket.cookie_value() # set it in the cookies response.set_cookie(cookiename, value=val, max_age=None, path='/', domain=None, secure=False, httponly=False, comment=None, expires=None, overwrite=False) raise redirect(came_from) u = resolve_relative_url(url(), request.environ) res = tequila.create_request(u + '/login/auth', 'tequila.epfl.ch') raise redirect( 'https://tequila.epfl.ch/cgi-bin/tequila/requestauth?request' + res)
def user_own_circle(user_id, circle_id): ''' Look if the user own the circle. ''' circle = DBSession.query(Circle).filter(Circle.id == circle_id).first() if circle.creator_id == user_id: return True if circle.admin: user = DBSession.query(User).filter(User.id == user_id).first() admin_group = DBSession.query(Group).filter(Group.name == constants.group_admins).first() return user in admin_group.users return False
def create_admin(name): ''' Create a new admin circle. @param name : the name ''' c = Circle() c.name = name c.description = 'Circle created with Tequila' c.admin = True DBSession.add(c) DBSession.flush() return c
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'}
def edit(track=None, track_id=None, name=None, color=None): if track is None: track = DBSession.query(Track).filter(Track.id == track_id).first() debug('edit track %s' % track) if name is not None: track.name = name if track.parameters is None: init(track) if color is not None: p = copy.deepcopy(track.parameters) p.update({'color': color}) track.parameters = p DBSession.flush()
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()
def user_own_circle(user_id, circle_id): ''' Look if the user own the circle. ''' circle = DBSession.query(Circle).filter(Circle.id == circle_id).first() if circle.creator_id == user_id: return True if circle.admin: user = DBSession.query(User).filter(User.id == user_id).first() admin_group = DBSession.query(Group).filter( Group.name == constants.group_admins).first() return user in admin_group.users return False
def edit(c, name, description, creator, users=None): c.name = name c.description = description c.creator_id = creator.id c.users = [] if users is not None: for user_id in users: if not int(user_id) == creator.id: u = DBSession.query(User).filter(User.id == user_id).first() c.users.append(u) c.users.append(creator) DBSession.add(c) DBSession.flush()
def get_rights(project=None, project_id=None, user=None, user_id=None): if project is None: project = DBSession.query(Project).filter(Project.id == project_id).first() if user is None: user = DBSession.query(User).filter(User.id == user_id).first() debug('get rights %s' % project.get_circle_with_right_display) r = [] for circle, rights in project.circles_with_rights.iteritems(): debug('circle %s with rights %s' % (circle, rights), 1) if circle in user.circles: r.extend(rights) return r
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)
def get_rights(project=None, project_id=None, user=None, user_id=None): if project is None: project = DBSession.query(Project).filter( Project.id == project_id).first() if user is None: user = DBSession.query(User).filter(User.id == user_id).first() debug('get rights %s' % project.get_circle_with_right_display) r = [] for circle, rights in project.circles_with_rights.iteritems(): debug('circle %s with rights %s' % (circle, rights), 1) if circle in user.circles: r.extend(rights) return r
def check_circles_with_user(self, user, principal): ''' Check if the groups that are in tequila and add the user to it. This method is here because at first, circles was not created with `allunits` parameters but with `groups` one. So users that are logged already must be re-added to the right groups ''' hash = dict(item.split('=') for item in principal.split('\n') if len(item.split('=')) > 1) if 'allunits' in hash: group_list = hash.get('allunits').split(',') for group_name in group_list: circle = handler.circle.get_tequila_circle(group_name) if circle is None: circle = handler.circle.create_admin(group_name) circle.users.append(user) DBSession.flush()
def search(self, project_id, term, *args, **kw): project = DBSession.query(Project).filter(Project.id == project_id).first() sequence = project.sequence default = sequence.default_tracks if default is None or len(default) < 1: return {} t = default[0] chrs = {} with track.load(t.path, 'sql', readonly=True) as t: gene_name_alias = t.find_column_name(['name', 'gene_name', 'gene name', 'gname', 'Name', 'product']) try: for row in t.search({gene_name_alias: term}, [gene_name_alias, 'start', 'end']): chr, name, start, stop = row if chr not in chrs: chrs[chr] = {} names = chrs[chr] if name in names: old = names[name] start = min(old[0], start) stop = max(old[1], stop) names[name] = [start, stop] except Exception: return {} #result[chr].append([name, start, stop]) result = {} for chr, names in chrs.iteritems(): result[chr] = [] for k, v in names.iteritems(): result[chr].append([k, v[0], v[1]]) return result
def add_right(project=None, project_id=None, circle=None, circle_id=None, right=None, right_id=None): if project is None: project = DBSession.query(Project).filter( Project.id == project_id).first() if circle_id is None: circle_id = circle.id if right is None: right = DBSession.query(Right).filter(Right.id == right_id).first() cr_assoc = _get_circle_right_assoc(right, circle_id, project.id) project._circle_right.append(cr_assoc)
def _get_circle_right_assoc(right, circle_id, project_id): ''' Get the ``RightCircleAssociation`` corresponding to the right and circle_id and project_id given ''' cr_assoc = DBSession.query(RightCircleAssociation).filter( and_(RightCircleAssociation.right_id == right.id, RightCircleAssociation.circle_id == circle_id, RightCircleAssociation.project_id == project_id)).first() if cr_assoc is None: cr_assoc = RightCircleAssociation() cr_assoc.circle_id = circle_id cr_assoc.right = right cr_assoc.project_id = project_id DBSession.add(cr_assoc) return cr_assoc
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)})
def _add_read_right(project, circle_id): ''' Add the ``read`` right to the project % circle specified without flushing ''' read_right = DBSession.query(Right).filter(Right.name == constants.right_read).first() cr_assoc = _get_circle_right_assoc(read_right, circle_id, project.id) project._circle_right.append(cr_assoc)
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
def get_user(key, mail): ''' Get the user with the the given mail, with the given key. ''' user = DBSession.query(User).filter(and_(User.email == mail, User.key == key)).first() return user
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'}