def render(self, study):
study_info = study.info
id = study.id
abstract = study_info['study_abstract']
description = study_info['study_description']
pmids = ", ".join([pubmed_linkifier([pmid]) for pmid in study.pmids])
princ_inv = StudyPerson(study_info['principal_investigator_id'])
pi_link = study_person_linkifier((princ_inv.email, princ_inv.name))
number_samples_promised = study_info['number_samples_promised']
number_samples_collected = study_info['number_samples_collected']
metadata_complete = study_info['metadata_complete']
data_types = sorted(viewitems(get_data_types()), key=itemgetter(1))
# Retrieve the files from the uploads folder, so the user can choose
# the sample template of the study. Filter them to only include the
# ones that ends with 'txt' or 'tsv'.
files = [f for _, f in get_files_from_uploads_folders(str(study.id))
if f.endswith(('txt', 'tsv'))]
# If the sample template exists, retrieve all its filepaths
if SampleTemplate.exists(study.id):
sample_templates = SampleTemplate(study.id).get_filepaths()
else:
# If the sample template does not exist, just pass an empty list
sample_templates = []
# Check if the request came from a local source
is_local_request = is_localhost(self.request.headers['host'])
# The user can choose the sample template only if the study is
# sandboxed or the current user is an admin
show_select_sample = (
study.status == 'sandbox' or self.current_user.level == 'admin')
# Ebi information
ebi_status = study.ebi_submission_status
ebi_accession = study.ebi_study_accession
if ebi_accession:
ebi_accession = (EBI_LINKIFIER.format(ebi_accession))
return self.render_string(
"study_description_templates/study_information_tab.html",
abstract=abstract,
description=description,
id=id,
pmids=pmids,
principal_investigator=pi_link,
number_samples_promised=number_samples_promised,
number_samples_collected=number_samples_collected,
metadata_complete=metadata_complete,
show_select_sample=show_select_sample,
files=files,
study_id=study.id,
sample_templates=sample_templates,
is_local_request=is_local_request,
data_types=data_types,
ebi_status=ebi_status,
ebi_accession=ebi_accession)
def remove_add_study_template(self, raw_data, study_id, fp_rsp):
"""Replace prep templates, raw data, and sample template with a new one
"""
for rd in raw_data():
rd = RawData(rd)
for pt in rd.prep_templates:
if PrepTemplate.exists(pt):
PrepTemplate.delete(pt)
if SampleTemplate.exists(study_id):
SampleTemplate.delete(study_id)
SampleTemplate.create(load_template_to_dataframe(fp_rsp),
Study(study_id))
remove(fp_rsp)
def remove_add_study_template(self, raw_data, study_id, fp_rsp):
"""Replace prep templates, raw data, and sample template with a new one
"""
for rd in raw_data():
rd = RawData(rd)
for pt in rd.prep_templates:
if PrepTemplate.exists(pt):
PrepTemplate.delete(pt)
if SampleTemplate.exists(study_id):
SampleTemplate.delete(study_id)
SampleTemplate.create(load_template_to_dataframe(fp_rsp),
Study(study_id))
remove(fp_rsp)
def render(self, study):
study_info = study.info
abstract = study_info['study_abstract']
description = study_info['study_description']
pmids = ", ".join([pubmed_linkifier([pmid]) for pmid in study.pmids])
princ_inv = StudyPerson(study_info['principal_investigator_id'])
pi_link = study_person_linkifier((princ_inv.email, princ_inv.name))
number_samples_promised = study_info['number_samples_promised']
number_samples_collected = study_info['number_samples_collected']
metadata_complete = study_info['metadata_complete']
# Retrieve the files from the uploads folder, so the user can choose
# the sample template of the study
files = [f for _, f in get_files_from_uploads_folders(str(study.id))]
# If the sample template exists, retrieve all its filepaths
if SampleTemplate.exists(study.id):
sample_templates = SampleTemplate(study.id).get_filepaths()
else:
# If the sample template does not exist, just pass an empty list
sample_templates = []
# Check if the request came from a local source
is_local_request = self._is_local()
# The user can choose the sample template only if the study is
# sandboxed or the current user is an admin
show_select_sample = (
study.status == 'sandbox' or self.current_user.level == 'admin')
return self.render_string(
"study_description_templates/study_information_tab.html",
abstract=abstract,
description=description,
pmids=pmids,
principal_investigator=pi_link,
number_samples_promised=number_samples_promised,
number_samples_collected=number_samples_collected,
metadata_complete=metadata_complete,
show_select_sample=show_select_sample,
files=files,
study_id=study.id,
sample_templates=sample_templates,
is_local_request=is_local_request)
def display_template(self, study, user, msg, msg_level, full_access, top_tab=None, sub_tab=None, prep_tab=None):
"""Simple function to avoid duplication of code"""
study_status = study.status
user_level = user.level
sample_template_exists = SampleTemplate.exists(study.id)
if sample_template_exists:
st = SampleTemplate(study.id)
missing_cols = st.check_restrictions([SAMPLE_TEMPLATE_COLUMNS["qiita_main"]])
allow_approval = len(missing_cols) == 0
approval_deny_msg = (
"Processed data approval request is disabled due to missing "
"columns in the sample template: %s" % ", ".join(missing_cols)
)
else:
allow_approval = False
approval_deny_msg = ""
# The general information of the study can be changed if the study is
# not public or if the user is an admin, in which case they can always
# modify the information of the study
show_edit_btn = study_status != "public" or user_level == "admin"
# Make the error message suitable for html
msg = msg.replace("\n", "<br/>")
self.render(
"study_description.html",
message=msg,
level=msg_level,
study=study,
study_title=study.title,
study_alias=study.info["study_alias"],
show_edit_btn=show_edit_btn,
show_data_tabs=sample_template_exists,
full_access=full_access,
allow_approval=allow_approval,
approval_deny_msg=approval_deny_msg,
top_tab=top_tab,
sub_tab=sub_tab,
prep_tab=prep_tab,
)
def remove_add_study_template(self, raw_data, study_id, fp_rsp, data_type, is_mapping_file):
"""Replace prep templates, raw data, and sample template with a new one
"""
if is_mapping_file and data_type == "":
raise ValueError("Please, choose a data type if uploading a QIIME " "mapping file")
for rd in raw_data():
rd = RawData(rd)
for pt in rd.prep_templates:
if PrepTemplate.exists(pt):
PrepTemplate.delete(pt)
if SampleTemplate.exists(study_id):
SampleTemplate.delete(study_id)
if is_mapping_file:
create_templates_from_qiime_mapping_file(fp_rsp, Study(study_id), int(data_type))
else:
SampleTemplate.create(load_template_to_dataframe(fp_rsp), Study(study_id))
remove(fp_rsp)
def display_template(self, study, user, msg, msg_level, full_access,
top_tab=None, sub_tab=None, prep_tab=None):
"""Simple function to avoid duplication of code"""
study_status = study.status
user_level = user.level
sample_template_exists = SampleTemplate.exists(study.id)
# The general information of the study can be changed if the study is
# not public or if the user is an admin, in which case they can always
# modify the information of the study
show_edit_btn = study_status != 'public' or user_level == 'admin'
self.render('study_description.html',
message=msg,
level=msg_level,
study=study,
study_title=study.title,
study_alias=study.info['study_alias'],
show_edit_btn=show_edit_btn,
show_data_tabs=sample_template_exists,
full_access=full_access,
top_tab=top_tab,
sub_tab=sub_tab,
prep_tab=prep_tab)
from os.path import join
from time import strftime
from qiita_db.util import get_mountpoint
from qiita_db.sql_connection import SQLConnectionHandler
from qiita_db.metadata_template import SampleTemplate, PrepTemplate
conn_handler = SQLConnectionHandler()
_id, fp_base = get_mountpoint('templates')[0]
for study_id in conn_handler.execute_fetchall(
"SELECT study_id FROM qiita.study"):
study_id = study_id[0]
if SampleTemplate.exists(study_id):
st = SampleTemplate(study_id)
fp = join(fp_base, '%d_%s.txt' % (study_id, strftime("%Y%m%d-%H%M%S")))
st.to_file(fp)
st.add_filepath(fp)
for prep_template_id in conn_handler.execute_fetchall(
"SELECT prep_template_id FROM qiita.prep_template"):
prep_template_id = prep_template_id[0]
pt = PrepTemplate(prep_template_id)
study_id = pt.study_id
fp = join(fp_base, '%d_prep_%d_%s.txt' % (pt.study_id, prep_template_id,
strftime("%Y%m%d-%H%M%S")))
pt.to_file(fp)
pt.add_filepath(fp)
def test_exists_false(self):
"""Exists returns false when the SampleTemplate does not exists"""
self.assertFalse(SampleTemplate.exists(self.new_study))
def test_exists_true(self):
"""Exists returns true when the SampleTemplate already exists"""
self.assertTrue(SampleTemplate.exists(self.test_study))
def test_exists_false(self):
"""Exists returns false when the SampleTemplate does not exists"""
self.assertFalse(SampleTemplate.exists(self.new_study))
def test_exists_true(self):
"""Exists returns true when the SampleTemplate already exists"""
self.assertTrue(SampleTemplate.exists(self.test_study))
def display_template(self, study, user, msg, msg_level, top_tab=None,
sub_tab=None, prep_tab=None):
"""Simple function to avoid duplication of code"""
# getting the RawData and its prep templates
available_raw_data = yield Task(self.get_raw_data, study.raw_data())
available_prep_templates = yield Task(self.get_prep_templates,
available_raw_data)
# set variable holding if we have files attached to all raw data or not
raw_files = True if available_raw_data else False
for r in available_raw_data:
if not r.get_filepaths():
raw_files = False
# set variable holding if we have all prep templates or not
if available_prep_templates:
_test = lambda item: not item
prep_templates = all(
[_test(val) for val in viewvalues(available_prep_templates)])
else:
prep_templates = False
study_status = study.status
user_level = user.level
sample_template_exists = SampleTemplate.exists(study.id)
# The general information of the study can be changed if the study is
# not public or if the user is an admin, in which case they can always
# modify the information of the study
show_edit_btn = study_status != 'public' or user_level == 'admin'
# Files can be added to a study only if the study is sandboxed
# or if the user is the admin
show_upload_btn = study_status == 'sandbox' or user_level == 'admin'
# The request approval, approve study and make public buttons are
# mutually exclusive. Only one of them will be shown, depending on the
# current status of the study
btn_to_show = None
if (study_status == 'sandbox' and qiita_config.require_approval
and sample_template_exists and raw_files and prep_templates):
# The request approval button only appears if the study is
# sandboxed, the qiita_config specifies that the approval should
# be requested and the sample template, raw files and prep
# prep templates have been added to the study
btn_to_show = 'request_approval'
elif (user_level == 'admin' and study_status == 'awaiting_approval'
and qiita_config.require_approval):
# The approve study button only appears if the user is an admin,
# the study is waiting approval and the qiita config requires
# study approval
btn_to_show = 'approve_study'
elif study_status == 'private':
# The make public button only appers if the study is private
btn_to_show = 'make_public'
# The revert to sandbox button only appears if the study is not
# sandboxed or public
show_revert_btn = study_status not in {'sandbox', 'public'}
self.render('study_description.html',
message=msg,
level=msg_level,
user=self.current_user,
study=study,
study_title=study.title,
study_alias=study.info['study_alias'],
show_edit_btn=show_edit_btn,
show_upload_btn=show_upload_btn,
show_revert_btn=show_revert_btn,
btn_to_show=btn_to_show,
show_data_tabs=sample_template_exists,
top_tab=top_tab,
sub_tab=sub_tab,
prep_tab=prep_tab)
def display_template(self, study, user, msg, msg_level, top_tab=None,
sub_tab=None, prep_tab=None):
"""Simple function to avoid duplication of code"""
# getting the RawData and its prep templates
available_raw_data = yield Task(self.get_raw_data, study.raw_data())
available_prep_templates = yield Task(self.get_prep_templates,
available_raw_data)
# set variable holding if we have files attached to all raw data or not
raw_files = True if available_raw_data else False
for r in available_raw_data:
if not r.get_filepaths():
raw_files = False
# set variable holding if we have all prep templates or not
if available_prep_templates:
def _test(item):
return not item
prep_templates = all(
[_test(val) for val in viewvalues(available_prep_templates)])
else:
prep_templates = False
study_status = study.status
user_level = user.level
sample_template_exists = SampleTemplate.exists(study.id)
# The general information of the study can be changed if the study is
# not public or if the user is an admin, in which case they can always
# modify the information of the study
show_edit_btn = study_status != 'public' or user_level == 'admin'
# Files can be added to a study only if the study is sandboxed
# or if the user is the admin
show_upload_btn = study_status == 'sandbox' or user_level == 'admin'
# The request approval, approve study and make public buttons are
# mutually exclusive. Only one of them will be shown, depending on the
# current status of the study
btn_to_show = None
if (study_status == 'sandbox' and
qiita_config.require_approval and sample_template_exists and
raw_files and prep_templates):
# The request approval button only appears if the study is
# sandboxed, the qiita_config specifies that the approval should
# be requested and the sample template, raw files and prep
# prep templates have been added to the study
btn_to_show = 'request_approval'
elif (user_level == 'admin' and
study_status == 'awaiting_approval' and
qiita_config.require_approval):
# The approve study button only appears if the user is an admin,
# the study is waiting approval and the qiita config requires
# study approval
btn_to_show = 'approve_study'
elif study_status == 'private':
# The make public button only appers if the study is private
btn_to_show = 'make_public'
# The revert to sandbox button only appears if the study is not
# sandboxed or public
show_revert_btn = study_status not in {'sandbox', 'public'}
self.render('study_description.html',
message=msg,
level=msg_level,
study=study,
study_title=study.title,
study_alias=study.info['study_alias'],
show_edit_btn=show_edit_btn,
show_upload_btn=show_upload_btn,
show_revert_btn=show_revert_btn,
btn_to_show=btn_to_show,
show_data_tabs=sample_template_exists,
top_tab=top_tab,
sub_tab=sub_tab,
prep_tab=prep_tab)
def display_template(self, study, msg, msg_level, tab_to_display=""):
"""Simple function to avoid duplication of code"""
# Check if the request came from a local source
is_local_request = ('localhost' in self.request.headers['host'] or
'127.0.0.1' in self.request.headers['host'])
# getting raw filepath_ types
fts = [k.split('_', 1)[1].replace('_', ' ')
for k in get_filepath_types() if k.startswith('raw_')]
fts = ['<option value="%s">%s</option>' % (f, f) for f in fts]
user = User(self.current_user)
# getting the RawData and its prep templates
available_raw_data = yield Task(self.get_raw_data, study.raw_data())
available_prep_templates = yield Task(self.get_prep_templates,
available_raw_data)
# set variable holding if we have files attached to all raw data or not
raw_files = True if available_raw_data else False
for r in available_raw_data:
if not r.get_filepaths():
raw_files = False
# set variable holding if we have all prep templates or not
prep_templates = True if available_prep_templates else False
for key, val in viewitems(available_prep_templates):
if not val:
prep_templates = False
# other general vars, note that we create the select options here
# so we do not have to loop several times over them in the template
data_types = sorted(viewitems(get_data_types()), key=itemgetter(1))
data_types = ['<option value="%s">%s</option>' % (v, k)
for k, v in data_types]
filetypes = sorted(viewitems(get_filetypes()), key=itemgetter(1))
filetypes = ['<option value="%s">%s</option>' % (v, k)
for k, v in filetypes]
other_studies_rd = yield Task(self.get_raw_data_from_other_studies,
user, study)
other_studies_rd = ['<option value="%s">%s</option>' % (k,
"id: %d, study: %s" % (k, v))
for k, v in viewitems(other_studies_rd)]
ontology = Ontology(convert_to_id('ENA', 'ontology'))
# make "Other" show at the bottom of the drop down menu
ena_terms = []
for v in sorted(ontology.terms):
if v != 'Other':
ena_terms.append('<option value="%s">%s</option>' % (v, v))
ena_terms.append('<option value="Other">Other</option>')
# New Type is for users to add a new user-defined investigation type
user_defined_terms = ontology.user_defined_terms + ['New Type']
princ_inv = StudyPerson(study.info['principal_investigator_id'])
pi_link = study_person_linkifier((princ_inv.email, princ_inv.name))
if SampleTemplate.exists(study.id):
sample_templates = SampleTemplate(study.id).get_filepaths()
else:
sample_templates = []
self.render('study_description.html', user=self.current_user,
study_title=study.title, study_info=study.info,
study_id=study.id, filetypes=''.join(filetypes),
user_level=user.level, data_types=''.join(data_types),
available_raw_data=available_raw_data,
available_prep_templates=available_prep_templates,
ste=SampleTemplate.exists(study.id),
study_status=study.status,
filepath_types=''.join(fts), ena_terms=''.join(ena_terms),
tab_to_display=tab_to_display, level=msg_level,
message=msg, prep_templates=prep_templates,
raw_files=raw_files,
can_upload=check_access(user, study, no_public=True),
other_studies_rd=''.join(other_studies_rd),
user_defined_terms=user_defined_terms,
files=get_files_from_uploads_folders(str(study.id)),
is_public=study.status == 'public',
pmids=", ".join([pubmed_linkifier([pmid])
for pmid in study.pmids]),
principal_investigator=pi_link,
is_local_request=is_local_request,
sample_templates=sample_templates)
from os.path import join
from time import strftime
from qiita_db.util import get_mountpoint
from qiita_db.sql_connection import SQLConnectionHandler
from qiita_db.metadata_template import SampleTemplate, PrepTemplate
conn_handler = SQLConnectionHandler()
_id, fp_base = get_mountpoint('templates')[0]
for study_id in conn_handler.execute_fetchall(
"SELECT study_id FROM qiita.study"):
study_id = study_id[0]
if SampleTemplate.exists(study_id):
st = SampleTemplate(study_id)
fp = join(fp_base, '%d_%s.txt' % (study_id, strftime("%Y%m%d-%H%M%S")))
st.to_file(fp)
st.add_filepath(fp)
for prep_template_id in conn_handler.execute_fetchall(
"SELECT prep_template_id FROM qiita.prep_template"):
prep_template_id = prep_template_id[0]
pt = PrepTemplate(prep_template_id)
study_id = pt.study_id
fp = join(
fp_base, '%d_prep_%d_%s.txt' %
(pt.study_id, prep_template_id, strftime("%Y%m%d-%H%M%S")))
pt.to_file(fp)
