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 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 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()
