def render_analysis_list():
try:
current_user = get_current_user()
return render_template('pages/list.html',
page_data=ListTableData(current_user, get_analyses(current_user), 'Analyses'))
except Exception as e:
return handle_exception_browser(e)
def render_home():
try:
current_user = get_current_user()
page_data = DashboardPageData(current_user)
return render_template('pages/home.html', page_data=page_data)
except Exception as e:
return handle_exception_browser(e)
def render_create_user_group():
try:
current_user = get_current_user()
if request.method == 'POST':
data = {
'admin_ids':
[int(val) for val in request.form.getlist('admin_ids')],
'member_ids':
[int(val) for val in request.form.getlist('member_ids')],
'name':
request.form.get('name'),
'description':
request.form.get('description')
}
user_group = create_user_group(current_user, data)
return redirect(
url_for('user_groups.render_user_group',
user_group_id=user_group.id))
if request.method == 'GET':
selected_user_ids = {int(token) for token in request.args.get('sample_ids').strip('"').split(',')} \
if request.args.get('user_ids', '') else {}
selected_users = get_all_read_permitted_records(current_user, User)
return render_template('pages/create.html',
page_data=UserGroupCreateFormData(
current_user, selected_users))
except Exception as e:
return handle_exception_browser(e)
def render_analysis(analysis_id=None):
try:
current_user = get_current_user()
return render_template('pages/analysis_entry.html',
page_data=AnalysisPageData(current_user, get_analysis(current_user, analysis_id)))
except Exception as e:
return handle_exception_browser(e)
def render_create_collection():
try:
current_user = get_current_user()
if request.method == 'POST':
form_data = process_input_dict(request.form.to_dict(), True)
samples = [
dt.samples.get_sample(current_user, sample_id)
for sample_id in request.form.getlist('sample_ids')
]
if 'sample_ids' in form_data:
del form_data['sample_ids']
sort_by = form_data['sort_by']
del form_data['sort_by']
collection = dt.wrappers.collections.create_collection(
current_user, samples, form_data, sort_by=sort_by)
return redirect(
url_for('collections.render_collection',
collection_id=collection.id))
if request.method == 'GET':
if request.args.get('sample_ids', ''):
sample_ids = [
int(token) for token in request.args.get(
'sample_ids').strip('"').split(',')
]
selected_samples = Sample.query.filter(
Sample.id.in_(sample_ids)).all()
else:
selected_samples = None
return render_template('pages/create.html',
page_data=CollectionCreateFormData(
current_user, selected_samples))
except Exception as e:
return handle_exception_browser(e)
def render_edit_workflow(workflow_id=None):
try:
return redirect(
f"{url_for('static', filename='workflow_editor/index.html')}#/{workflow_id}"
)
except Exception as e:
return handle_exception_browser(e)
def render_upload_sample_group():
try:
current_user = get_current_user()
if request.method == 'POST':
files = request.files.getlist('files')
filenames = [
os.path.join(UPLOADDIR, secure_filename(file.filename))
for file in files
]
[file.save(filename) for file, filename in zip(files, filenames)]
metadata = process_input_dict(request.form.to_dict(), True)
workflow_data = create_sample_creation_workflow(
current_user, filenames, metadata)
metadata['samples'] = [
get_sample(current_user, sample_id)
for sample_id in workflow_data['output_ids']
]
sample_group = create_sample_group(current_user, metadata)
job = start_job(workflow_data['workflow'], workflow_data['job'],
current_user, 'upload')
update_sample_group(current_user, sample_group,
{'upload_job_id': job.id})
return redirect(
url_for('sample_groups.render_sample_group',
sample_group_id=sample_group.id))
return render_template('pages/create.html',
page_data=SampleCreateFormData(current_user))
except Exception as e:
return handle_exception_browser(e)
def render_workflow(workflow_id=None):
try:
current_user = get_current_user()
return render_template('pages/workflow_entry.html',
page_data=WorkflowPageData(
current_user,
get_workflow(current_user, workflow_id)))
except Exception as e:
return handle_exception_browser(e)
def render_user_profile(user_id=None):
try:
current_user = get_current_user()
return render_template('pages/user_entry.html',
page_data=UserPageData(
current_user,
get_user(current_user, user_id)))
except Exception as e:
return handle_exception_browser(e)
def render_user_group_list():
try:
current_user = get_current_user()
return render_template('pages/list.html',
page_data=ListTableData(
current_user, get_user_groups(current_user),
'User Groups'))
except Exception as e:
return handle_exception_browser(e)
def render_external_file(external_file_id=None):
try:
current_user = get_current_user()
return render_template('pages/external_file_entry.html',
page_data=ExternalFilePageData(
current_user,
dt.external_files.get_external_file(
current_user, external_file_id)))
except Exception as e:
return handle_exception_browser(e)
def render_external_file_list():
try:
current_user = get_current_user()
return render_template(
'pages/list.html',
page_data=ListTableData(
current_user,
dt.external_files.get_external_files(current_user),
'External File Records'))
except Exception as e:
return handle_exception_browser(e)
def render_user_group(user_group_id=None):
try:
current_user = get_current_user()
user_group = get_user_group(current_user, user_group_id)
if request.method == 'DELETE':
delete_user_group(current_user, user_group)
return redirect(url_for('user_groups.render_user_group_list'))
return render_template('pages/user_group_entry.html',
page_data=UserGroupPageData(
current_user, user_group))
except Exception as e:
return handle_exception_browser(e)
def render_create_workflow():
try:
current_user = get_current_user()
if request.method == 'POST':
workflow = create_workflow(
current_user, process_input_dict(request.form.to_dict(), True))
return redirect(
url_for('workflows.render_workflow', workflow_id=workflow.id))
return render_template('pages/create.html',
page_data=WorkflowCreateFormData(current_user))
except Exception as e:
return handle_exception_browser(e)
def render_create_external_file():
try:
current_user = get_current_user()
if request.method == 'POST':
# following must be true:
# 1. if "file" is empty, then "filename" is not blank and the file exists
# 2. if "file" is not empty, then "filename" is blank or "filename" is not blank and the file does not exist
# 1. "filename" is not blank and file exists and "file" is empty
# 2. "filename" is not blank and file does not exist and "file" is not empty
data = process_input_dict(request.form.to_dict(), True)
if 'filename' in data and data['filename']:
data['filename'] = os.path.join(
DATADIR, 'external', secure_filename(data['filename']))
if (not os.path.isfile(
data['filename'])) and (not request.files.get('file')):
Path(data['filename']).parent.mkdir(exist_ok=True,
parents=True)
Path(data['filename']).touch()
if request.files.get('file') and os.path.isfile(
data['filename']):
raise ValueError(
f'File {data["filename"]} already exists!')
else:
if not request.files.get('file'):
raise ValueError(
f'No file submitted and filename field left blank!')
if request.files.get('file'):
file = request.files.get('file')
if 'filename' in data and not data['filename']:
del data['filename']
if 'filename' in data and os.path.isfile(data['filename']):
raise ValueError(
f'File {data["filename"]} already exists! Please set a filename in the filename field.'
)
filename = os.path.join(UPLOADDIR,
secure_filename(file.filename))
file.save(filename)
external_file = dt.external_files.upload_external_file(
current_user, filename, data)
else:
external_file = dt.external_files.create_external_file(
current_user, data)
return redirect(
url_for('external_files.render_external_file',
external_file_id=external_file.id))
return render_template(
'pages/create.html',
page_data=ExternalFileCreateFormData(current_user))
except Exception as e:
return handle_exception_browser(e)
def render_sample(sample_id=None):
try:
current_user = get_current_user()
sample = get_sample(current_user, sample_id)
if request.method == 'DELETE':
delete_sample(current_user, sample)
return redirect(url_for('samples.render_sample_list'))
if request.method == 'POST':
update_sample(current_user, sample, request.form)
return render_template('pages/sample_entry.html',
page_data=SamplePageData(current_user, sample))
except Exception as e:
return handle_exception_browser(e)
def render_user_list():
try:
current_user = get_current_user()
if current_user.admin:
mailto = get_mailto_all()
else:
mailto = None
return render_template('pages/user_list.html',
page_data=UserListTableData(
current_user, get_users(current_user),
mailto))
except Exception as e:
return handle_exception_browser(e)
def render_workflow_module_list():
try:
current_user = get_current_user()
if request.args.get('path'):
path = request.args.get('path')
module = get_module(path)
return render_template('pages/workflow_module_entry.html',
page_data=WorkflowModulePageData(
current_user, module))
return render_template('pages/list.html',
page_data=ListTableData(current_user,
get_modules(),
'Workflow Modules'))
except Exception as e:
return handle_exception_browser(e)
def render_collection(collection_id=None):
try:
current_user = get_current_user()
collection = get_collection(current_user, collection_id)
if request.method == 'DELETE':
delete_collection(current_user, collection_id)
return redirect(url_for('collections.render_collection_list'))
if request.method == 'POST':
dataset_name = request.form.get('dataset_name')
dataset_type = request.form.get('dtype')
dt.collections.create_new_label_dataset(current_user, collection,
dataset_name, dataset_type)
return render_template('pages/collection_entry.html',
page_data=CollectionPageData(
current_user, collection))
except Exception as e:
return handle_exception_browser(e)
def render_submit_job():
try:
if request.args.get('workflow_id') is None:
raise NotFoundException(f'No workflow id provided')
current_user = get_current_user()
workflow = get_workflow(current_user, request.args.get('workflow_id'))
workflow_data = workflow.get_file_info()
if request.method == 'POST':
job_params, workflow_data, labels, options = prepare_job_params(workflow_data,
process_input_dict(request.form),
current_user, workflow.id)
job = start_job(workflow_data, job_params, current_user, 'analysis', labels, options)
return redirect(url_for('jobs.render_job', job_id=job.id))
page_data = SubmitFormData(current_user, workflow_data, f'Workflow {workflow.id}')
return render_template('pages/submit_job.html', page_data=page_data)
except Exception as e:
return handle_exception_browser(e)
def render_create_analysis():
try:
current_user = get_current_user()
if request.method == 'POST':
new_data = process_input_dict(request.form.to_dict(), True)
if 'collection_ids' in new_data:
del new_data['collection_ids']
collection_ids = [int(collection_id) for collection_id in request.form.getlist('collection_ids')]
collections = Collection.query.filter(Collection.id.in_(collection_ids)).all()
analysis = dt.analyses.create_analysis(current_user, new_data, collections)
return redirect(url_for('analyses.render_analysis', analysis_id=analysis.id))
selected_collection_ids = [int(token) for token in request.args.get('collection_ids').strip('"').split(',')] \
if request.args.get('sample_ids', '') else []
selected_collections = Collection.query.filter(Collection.id.in_(selected_collection_ids)).all()
return render_template('pages/create.html',
page_data=AnalysisCreateFormData(current_user, selected_collections))
except Exception as e:
return handle_exception_browser(e)
def render_sample_group(sample_group_id=None):
try:
current_user = get_current_user()
sample_group = get_sample_group(current_user, sample_group_id)
if request.method == 'DELETE':
samples_to_delete = [
sample for sample in sample_group.samples
if len(sample.sample_groups) < 2
]
delete_sample_group(current_user, sample_group)
for sample in samples_to_delete:
try:
delete_sample(current_user, sample)
except AuthException:
pass
return redirect(url_for('sample_groups.render_sample_group_list'))
if request.method == 'POST':
update_sample_group(current_user, sample_group, request.form)
return render_template('pages/sample_group_entry.html',
page_data=SampleGroupPageData(
current_user, sample_group))
except Exception as e:
return handle_exception_browser(e)
def render_job_list():
try:
return render_template('pages/list.html',
page_data=ListTableData(get_current_user(), get_jobs(), 'Jobs'))
except Exception as e:
return handle_exception_browser(e)
def render_job(job_id=None):
try:
return render_template('pages/job_entry.html',
page_data=JobPageData(get_current_user(), get_job(job_id)))
except Exception as e:
return handle_exception_browser(e)
def render_settings():
try:
current_user = get_current_user()
if request.method == 'GET':
return render_template('pages/settings.html',
page_data=SettingsPageData(current_user))
if request.method == 'POST':
data = {
key: value
for key, value in request.form.to_dict().items() if value
}
if 'changePassword1' in data:
if current_user.admin:
change_password = not (data['changePassword1'] == ''
and data['changePassword2'] == ''
and data['changeEmail'] == '')
valid_passwords = data['changePassword1'] == data[
'changePassword2']
if change_password:
if not valid_passwords:
return render_template(
'pages/settings.html',
error='Passwords do not match')
new_password = data['changePassword1']
email = data['changeEmail']
other_user = dt.users.get_user_by_email(email)
dt.users.update_user(current_user, other_user,
{'password': new_password})
msg = f'Changed password for {email}'
return render_template(
'pages/settings.html',
page_data=SettingsPageData(current_user),
msg=msg)
return render_template(
'pages/settings.html',
page_data=SettingsPageData(current_user),
error='You are not an admin!')
else:
change_password = '******' in data and 'password2' in data
valid_passwords = data['password1'] == data[
'password2'] if change_password else False
new_data = {
key: value
for key, value in data.items()
if key in {'email', 'name', 'theme'}
}
valid_keys = ['name', 'email', 'password', 'theme']
if change_password:
if not valid_passwords:
return render_template(
'pages/settings.html',
page_data=SettingsPageData(current_user),
error='passwords do not match')
new_data['password'] = data['password1']
msg = '\n'.join([
'Changed password' if key == 'password' else
'Changed %s to %s.' % (key, value)
for key, value in new_data.items() if key in valid_keys
])
dt.users.update_user(current_user, current_user, new_data)
# update session with new data
if 'password' in new_data:
# invalidate session on password change
browser_logout()
return redirect(
url_for('browser.browser_login',
msg=msg,
next=url_for('browser.render_settings')))
login_user(current_user)
return redirect(url_for(
'browser.render_settings')) # redirect a fresh GET request
except Exception as e:
return handle_exception_browser(e)
