def process_request(self, request): url = request.get_full_path() if url.startswith('/copo', 0, 5): doc = Submission().get_incomplete_submissions_for_user(request.user.id, figshare) data_dict = dict() token = None if doc.count() > 0: if 'code' in request.GET and 'state' in request.GET: token_obtained = True for d in doc: if d.get('token_obtained') == 'false': token_obtained = False break if not token_obtained: # get new token from Figshare code = request.GET.get('code') client_id = FIGSHARE_CREDENTIALS['client_id'] token_url = FIGSHARE_API_URLS['authorization_token'] # now get token data = { 'client_id': client_id, 'code': code, 'client_secret': FIGSHARE_CREDENTIALS['client_secret'], 'grant_type': 'authorization_code', 'scope': 'all' } try: r = requests.post(token_url, data) data_dict = ast.literal_eval(r.content.decode('utf-8')) token = data_dict['token'] t = Figshare().put_token_for_user(user_id=ThreadLocal.get_current_user().id, token=token) if t: # mark fighshare submissions for this user as token obtained Submission().mark_all_token_obtained(user_id=request.user.id) # if all is well, the access token will be stored in FigshareSubmussionCollection except Exception as e: print(e) else: # retrieve token token = Figshare().get_token_for_user(user_id=ThreadLocal.get_current_user().id) # request.session['partial_submissions'] = doc else: request.session['partial_submissions'] = None
def view_orcid_profile(request): user = ThreadLocal.get_current_user() op = Orcid().get_orcid_profile(user) data_dict = {'op': op} # data_dict = jsonpickle.encode(data_dict) return render(request, 'copo/orcid_profile.html', data_dict)
def done(self, form_list, **kwargs): invoice = None from django_tools.middlewares import ThreadLocal user = ThreadLocal.get_current_user().username klient = Klient.objects.get(nazwa=user) for form in form_list: if isinstance(form, ZamowienieForm): invoiceData = form.cleaned_data invoiceData.update({'klient': klient}) invoice = Zamowienie(**invoiceData) invoice.save() elif isinstance(form, BaseFormSet): for posForm in form.forms: if isinstance(posForm, PozycjaZamowieniaForm): positionData = posForm.cleaned_data positionData.update({'zamowienie': invoice}) position = PozycjaZamowienia(**positionData) position.save() else: posForm.save() self.storage.reset() return render_to_response('wizard/stepDone.html', { 'zamowienie': invoice, 'pozycje': PozycjaZamowienia.objects.filter(zamowienie_id=invoice.pk) }, context_instance=RequestContext( ThreadLocal.get_current_request()))
def done(self, form_list, **kwargs): invoice = None from django_tools.middlewares import ThreadLocal user = ThreadLocal.get_current_user().username klient = Klient.objects.get(nazwa=user) for form in form_list: if isinstance(form, ZamowienieForm): invoiceData = form.cleaned_data invoiceData.update({ 'klient': klient }) invoice = Zamowienie(**invoiceData) invoice.save() elif isinstance(form, BaseFormSet): for posForm in form.forms: if isinstance(posForm, PozycjaZamowieniaForm): positionData = posForm.cleaned_data positionData.update({ 'zamowienie': invoice }) position = PozycjaZamowienia(**positionData) position.save() else: posForm.save() self.storage.reset() return render_to_response('wizard/stepDone.html', {'zamowienie': invoice, 'pozycje': PozycjaZamowienia.objects.filter(zamowienie_id=invoice.pk)}, context_instance=RequestContext(ThreadLocal.get_current_request()))
def _check_permissions(self): usr = ThreadLocal.get_current_user() # The chunk_info field is set to 'restricted' if only authors and # reviewers of the chunk are allowed to view it. if self.chunk_info == None: cinfo = "" else: cinfo = self.chunk_info # get the authors. authors = [ str(u.username) for u in self.file.submission.authors.filter() ] # get the assigned reviewers. assigned_reviewers = User.objects.filter( tasks__submission=self.file.submission) reviewers = [str(u.username) for u in assigned_reviewers] allowed_users = authors + reviewers if cinfo.find('restricted') != -1 and not str( usr.username) in allowed_users: # Don't stop super users from viewing chunks. if not usr.is_superuser: raise PermissionDenied
def create_sra_person(self): """ create an (SRA) person record and attach to profile Args: profile_id: to be linked to created record Returns: """ user = ThreadLocal.get_current_user() auto_fields = { 'copo.person.roles.annotationValue': 'SRA Inform On Status', 'copo.person.lastName': user.last_name, 'copo.person.firstName': user.first_name, 'copo.person.roles.annotationValue_1': 'SRA Inform On Error', 'copo.person.email': user.email } people = self.get_all_records() sra_roles = list() for record in people: for role in record.get("roles", list()): sra_roles.append(role.get("annotationValue", str())) # has sra roles? has_sra_roles = all(x in sra_roles for x in ['SRA Inform On Status', 'SRA Inform On Error']) if not has_sra_roles: kwargs = dict() self.save_record(auto_fields, **kwargs) return
def GET_FOR_USER(self, user=None): if (user == None): user = ThreadLocal.get_current_user().id docs = Profiles.find({'user_id': user}) if not docs: pass return docs
def save(self, *args, **kwargs): user = ThreadLocal.get_current_user() if user: if not self.pk: self.created_by = user self.modified_by = user super(UserDateAbstractModel, self).save(*args, **kwargs)
def save(self, *args, **kwargs): current_user = ThreadLocal.get_current_user() if current_user and isinstance(current_user, User): if self.pk == None or kwargs.get("force_insert", False): # New model entry self.createby = current_user self.lastupdateby = current_user return super(UpdateUserBaseModel, self).save(*args, **kwargs)
def __init__(self, target_object, data=None, initial=None): """ prefill some user info """ if initial is None: initial = {} current_user = ThreadLocal.get_current_user() if current_user.is_authenticated(): initial["name"] = current_user.get_full_name() or current_user.username initial["email"] = current_user.email super(PyLucidCommentForm, self).__init__(target_object, data, initial)
def get_for_user(self, user=None): if not user: user = ThreadLocal.get_current_user().id docs = self.get_collection_handle().find({"user_id": user, "deleted": data_utils.get_not_deleted_flag()}).sort( [['_id', -1]]) if docs: return docs else: return None
def purge_descriptions(self): """ purges the Description collection of all 'obsolete' tokens :return: """ user_id = ThreadLocal.get_current_user().id bulk = self.DescriptionCollection.initialize_unordered_bulk_op() bulk.find({'user_id': user_id}).remove() bulk.execute()
def __init__(self, target_object, data=None, initial=None): """ prefill some user info """ if initial is None: initial = {} current_user = ThreadLocal.get_current_user() if current_user.is_authenticated(): initial["name"] = current_user.get_full_name( ) or current_user.username initial["email"] = current_user.email super(PyLucidCommentForm, self).__init__(target_object, data, initial)
def save(self, *args, **kwargs): """ Automatic update createby and lastupdateby attributes with the request object witch must be the first argument. """ current_user = ThreadLocal.get_current_user() if current_user and isinstance(current_user, User): if self.pk == None or kwargs.get("force_insert", False): # New model entry self.createby = current_user self.lastupdateby = current_user return super(UpdateInfoBaseModel, self).save(*args, **kwargs)
def _create_dataverse(self, meta, conn): alias = str(uuid.uuid4()) email = "" for f in meta["fields"]: if f["dc"] == "dc.title": name = f["vals"][0] if f["dc"] == "dc.email": email = f["vals"][0] if email == "": u = ThreadLocal.get_current_user() email = u.email dv = conn.create_dataverse(alias, name, email) return dv
def all_accessible(self, user=None, filter_showlinks=False): """ returns a PageTree queryset with all items that the given user can access. """ if user == None: user = ThreadLocal.get_current_user() queryset = self.model.on_site.order_by("position") queryset = self.filter_accessible(queryset, user) if filter_showlinks: # Filter PageTree.showlinks queryset = queryset.filter(showlinks=True) return queryset
def isValidCredentials(self, user_id): # check if token exists for user token = Figshare().get_token_for_user(user_id=ThreadLocal.get_current_user().id) if token: # now check if token works headers = {'Authorization': 'token ' + token['token']} r = requests.get('https://api.figshare.com/v2/account/articles', headers=headers) if r.status_code == 200: return True else: # we have an invalid token stored, so we should delete it and prompt the user for a new one Figshare().delete_tokens_for_user(user_id=user_id) return False
def create_description(self, stages=list(), attributes=dict()): self.purge_descriptions() fields = dict( stages=stages, attributes=attributes, created_on=data_utils.get_datetime(), user_id=ThreadLocal.get_current_user().id ) doc = self.DescriptionCollection.insert(fields) # return inserted record df = self.GET(str(doc)) return df
def get_profiles_status(self): from .copo_da import Profile # this method examines all the profiles owned by the current user and returns # the number of profiles which have been marked as dirty issues = {} issue_desc = [] issue_id = [] issues_count = 0 try: user_id = ThreadLocal.get_current_user().id prof = Profiles.find({"user_id": user_id}) except AttributeError as e: prof = [] # iterate profiles and find collections which are dirty for p in prof: try: collections_ids = p['collections'] except: issues_count += 1 context = {} context["profile_name"] = p['title'] context["link"] = reverse('copo:view_copo_profile', args=[p["_id"]]) issue_desc.append(STATUS_CODES['PROFILE_EMPTY'].format(**context)) break # now get the corresponding collection_heads collections_heads = Collections.find({'_id': {'$in': collections_ids}}, {'is_clean': 1, 'collection_details': 1}) # for c in collections_heads: # try: # if c['is_clean'] == 0: # profile = Profile().get_profile_from_collection_id(c["_id"]) # issues_count += 1 # context = {} # context["profile_name"] = p['title'] # context["link"] = reverse('copo:view_copo_profile', args=[profile["_id"]]) # # # now work out why the collection is dirty # if False: # pass # else: # issue_desc.append(STATUS_CODES['PROFILE_NOT_DEPOSITED'].format(**context)) # except: # pass issues['issue_id_list'] = issue_id issues['num_issues'] = issues_count issues['issue_description_list'] = issue_desc return issues
def save_record(self, auto_fields=dict(), **kwargs): if kwargs.get("datafile_ids", list()): datafile_ids = kwargs.get("datafile_ids") kwargs["bundle"] = datafile_ids # get the target repository from one of the files repo = DataFile().get_record_property(datafile_ids[0], "target_repository") for k, v in dict( repository=repo, status=False, complete='false', user_id=ThreadLocal.get_current_user().id, ).items(): auto_fields[self.get_qualified_field(k)] = v return super(Submission, self).save_record(auto_fields, **kwargs)
def add_personal_dataverse(self, url, name, apikey, type, username, password): u = ThreadLocal.get_current_user() doc = self.get_collection_handle().insert({ "isCG": False, "url": url, "name": name, "apikey": apikey, "personal": True, "uid": u.id, "type": type, "username": username, "password": password }) udetails = u.userdetails udetails.repo_submitter.append(str(doc)) udetails.save() return doc
def _check_permissions(self): usr = ThreadLocal.get_current_user() # The chunk_info field is set to 'restricted' if only authors and # reviewers of the chunk are allowed to view it. if self.chunk_info == None: cinfo = "" else: cinfo = self.chunk_info # get the authors. authors = [str(u.username) for u in self.file.submission.authors.filter()] # get the assigned reviewers. assigned_reviewers = User.objects.filter(tasks__submission=self.file.submission) reviewers = [str(u.username) for u in assigned_reviewers] allowed_users = authors + reviewers if cinfo.find('restricted') != -1 and not str(usr.username) in allowed_users: # Don't stop super users from viewing chunks. if not usr.is_superuser: raise PermissionDenied
def dispatch(self, request): if 'error' in request.GET or 'code' not in request.GET: # Distinguish cancel from error auth_error = request.GET.get('error', None) if auth_error == self.adapter.login_cancelled_error: error = AuthError.CANCELLED else: error = AuthError.UNKNOWN return render_authentication_error( request, self.adapter.provider_id, error=error) app = self.adapter.get_provider().get_app(self.request) client = self.get_client(request, app) try: access_token = client.get_access_token(request.GET['code']) token = self.adapter.parse_token(access_token) token.app = app login = self.adapter.complete_login(request, app, token, response=access_token) login.token = token if self.adapter.supports_state: login.state = SocialLogin \ .verify_and_unstash_state( request, get_request_param(request, 'state')) else: login.state = SocialLogin.unstash_state(request) log = complete_social_login(request, login) Orcid().store_orcid_profile('xxx', ThreadLocal.get_current_user()) return log except (PermissionDenied, OAuth2Error) as e: return render_authentication_error( request, self.adapter.provider_id, exception=e)
def validate_figshare_token(self): t = Figshare().get_token_for_user(user_id=ThreadLocal.get_current_user().id) if t: return False else: return True
def generate_filename2(instance, filename): filename = os.path.join(UPLOAD_PATH, str(ThreadLocal.get_current_user().id), instance.filename) return time.strftime(filename)
def add_token(self, owner_key=None, owner_secret=None): user = ThreadLocal.get_current_user() FigshareTokens.insert({'user_id': user.id, 'owner_key': owner_key, 'owner_secret': owner_secret})
def get_token_from_db(self): user = ThreadLocal.get_current_user() return FigshareTokens.find_one({'user_id': user.id})
def delete_old_token(self): user = ThreadLocal.get_current_user() FigshareTokens.delete_many({'user_id': user.id})
def token_exists(self): user = ThreadLocal.get_current_user() return (FigshareTokens.find({'user_id': user.id}).limit(1).count() > 0)
def generate_table_records(profile_id=str(), component=str()): # function generates component records for building an UI table - please note that for effective tabular display, # all array and object-type fields (e.g., characteristics) are deferred to sub-table display. # please define such in the schema as "show_in_table": false and "show_as_attribute": true columns = list() data_set = list() # instantiate data access object da_object = DAComponent(profile_id, component) # get and filter schema elements based on displayable columns schema = [x for x in da_object.get_schema().get("schema_dict") if x.get("show_in_table", True)] # build db column projection projection = [(x["id"].split(".")[-1], 1) for x in schema] # retrieve and process records if component == "submission": records = da_object.get_all_records_columns(sort_by="date_created", sort_direction=1, projection=dict(projection)) else: records = da_object.get_all_records_columns(projection=dict(projection)) if len(records): df = pd.DataFrame(records) df['s_n'] = df.index df['record_id'] = df._id.astype(str) df["DT_RowId"] = df.record_id df.DT_RowId = 'row_' + df.DT_RowId df = df.drop('_id', axis='columns') if component == "submission": df["special_repositories"] = df["repository"] columns.append(dict(data="special_repositories", visible=False)) columns.append(dict(data="record_id", visible=False)) detail_dict = dict(className='summary-details-control detail-hover-message', orderable=False, data=None, title='', defaultContent='', width="5%") columns.insert(0, detail_dict) df_columns = list(df.columns) for x in schema: x["id"] = x["id"].split(".")[-1] columns.append(dict(data=x["id"], title=x["label"])) if x["id"] not in df_columns: df[x["id"]] = str() df[x["id"]] = df[x["id"]].fillna('') df[x["id"]] = df[x["id"]].apply(resolve_control_output_apply, args=(x,)) data_set = df.to_dict('records') return_dict = dict(dataSet=data_set, columns=columns ) # do check for custom repos here if component == "submission": correct_repos = list() user = ThreadLocal.get_current_user() repo_ids = user.userdetails.repo_submitter all_repos = Repository().get_by_ids(repo_ids) for repo in all_repos: for r_id in repo_ids: if r_id == str(repo["_id"]): correct_repos.append(repo) for repo in correct_repos: repo["_id"] = str(repo["_id"]) return_dict["repos"] = correct_repos return return_dict
def get_tokens_for_user(request): user = ThreadLocal.get_current_user().id # get Figshare Tokens t = util.cursor_to_list(Figshare().get_figshare_tokens_for_user(user)) return HttpResponse(json_util.dumps({'figshare_tokens': t}))
def do_export(self, collection_id, dest): from dal import copo_base_da, ena_da, orcid_da from bson import ObjectId from xml import etree import xml.etree.ElementTree as ET from django_tools.middlewares import ThreadLocal head = copo_base_da.Collection_Head().GET(ObjectId(collection_id)) c = ena_da.EnaCollection().GET(head['collection_details'][0]) p = copo_base_da.Profile().get_profile_from_collection_id(collection_id) # create study.xml STUDY_SET = ET.Element("STUDY_SET") STUDY = ET.SubElement(STUDY_SET, "STUDY") STUDY.set('alias', c['investigation']['investigationTitle']) DESCRIPTOR = ET.SubElement(STUDY, "DESCRIPTOR") STUDY_TITLE = ET.SubElement(DESCRIPTOR, "STUDY_TITLE") STUDY_TITLE.text = c['investigation']['investigationTitle'] STUDY_TYPE = ET.SubElement(DESCRIPTOR, "STUDY_TYPE") STUDY_TYPE.text = c['studies'][0]['study']['studyDesignDescriptors'][0]['studyDesignType'] CENTER_PROJECT_NAME = ET.SubElement(DESCRIPTOR, "CENTER_PROJECT_NAME") CENTER_PROJECT_NAME.text = c['investigation']['investigationTitle'] STUDY_ABSTRACT = ET.SubElement(DESCRIPTOR, "STUDY_ABSTRACT") STUDY_ABSTRACT.text = p['abstract'] STUDY_DESCRIPTION = ET.SubElement(DESCRIPTOR, "STUDY_DESCRIPTION") STUDY_DESCRIPTION.text = p['abstract'] # write to file tree = ET.ElementTree(STUDY_SET) tree.write('/Users/fshaw/Desktop/study.xml') # create samples.xml SAMPLE_SET = ET.Element("SAMPLE_SET") for s in c['studies'][0]['study']['studySamples']: # get source and sample names for el in s: if 'name' in el and el['name'] == "Source Name": source_name = el['value'] if 'name' in el and el['name'] == "Sample Name": sample_name = el['value'] # get current affiliation user = ThreadLocal.get_current_user() affilation = orcid_da.Orcid().get_current_affliation(user) SAMPLE = ET.SubElement(SAMPLE_SET, "SAMPLE") SAMPLE.set('alias', sample_name) SAMPLE.set('center_name', affilation) SAMPLE_TITLE = ET.SubElement(SAMPLE, "TITLE") SAMPLE_TITLE.text = sample_name SAMPLE_NAME = ET.SubElement(SAMPLE, "SAMPLE_NAME") SCIENTIFIC_NAME = ET.SubElement(SAMPLE_NAME, "SCIENTIFIC_NAME") SCIENTIFIC_NAME.text = s[1]['items'][0]['characteristics'] TAXON_ID = ET.SubElement(SAMPLE_NAME, "TAXON_ID") TAXON_ID.text = s[1]['items'][0]['termAccessionNumber'] DESCRIPTION = ET.SubElement(SAMPLE, "DESCRIPTION") DESCRIPTION.text = source_name # write to file tree = ET.ElementTree(SAMPLE_SET) tree.write('/Users/fshaw/Desktop/sample.xml')
def get_current_user(): if settings.UNIT_TESTING: return User.objects.get(username=settings.TEST_USER_NAME) else: return ThreadLocal.get_current_user()