def clear_databases():
EnzymeType.drop_collection()
Sequence.drop_collection()
Paper.drop_collection()
Reaction.drop_collection()
Activity.drop_collection()
Molecule.drop_collection()
def get_enzyme_paper_progress(enzyme_type_obj):
enz_type = enzyme_type_obj.enzyme_type
num_papers = len(Paper.objects(tags=enz_type))
num_complete_papers = len(
Paper.objects(
db.Q(tags=enz_type)
& (db.Q(status='Complete')
| db.Q(status='Complete - Awaiting review'))))
if num_papers == 0:
progress = [
"0%", f"{num_complete_papers} out of {num_papers}", 'bg-danger',
enzyme_type_obj.full_name
]
elif num_complete_papers == 0:
progress = [
"0%", f"{num_complete_papers} out of {num_papers}", 'bg-danger',
enzyme_type_obj.full_name
]
else:
pc_complete = round((num_complete_papers / num_papers) * 100, 1)
if pc_complete > 80:
colour = 'bg-success'
elif pc_complete > 40:
colour = 'bg-warning'
else:
colour = 'bg-danger'
progress = [
f"{pc_complete}%", f"{num_complete_papers} out of {num_papers}",
colour, enzyme_type_obj.full_name
]
return progress
def high_importance_papers():
hi_papers = Paper.objects(high_importance=True).select_related()
enzyme_types = EnzymeType.objects()
tags = []
for paper in hi_papers:
for tag in paper.tags:
if tag not in tags:
tags.append(str(tag))
tags = sorted(tags)
data_by_tag = {}
for tag in tags:
hi_q = db.Q(high_importance=True)
tag_q = db.Q(tags=tag)
papers_data = list(
Paper.objects(hi_q & tag_q).only(
*papers_table.PAPERS_TABLE_FIELDS).order_by(
'-status').as_pymongo())
papers_data = papers_table.process_papers_dict(papers_data,
show_owner=False)
data_by_tag[tag] = papers_data
enzyme_full_names = {}
for enz_type in enzyme_types:
enzyme_full_names[enz_type.enzyme_type] = enz_type.full_name
return render_template('edit_tables/high_importance_papers.html',
data_by_tag=data_by_tag,
tags=tags,
enzyme_full_names=enzyme_full_names)
def inject_login_mode():
inject_dict = {}
inject_dict['login_mode'] = app.config['USE_EMAIL_CONFIRMATION']
if current_user.is_authenticated:
user = User.objects(id=current_user.id).select_related()[0]
if user.has_role('enzyme_teams') and user.enzyme_teams is not None:
inject_dict['enzyme_teams'] = [enz_type_obj.enzyme_type for enz_type_obj in user.enzyme_teams]
if user.has_role('enzyme_champion') and user.enzyme_champion is not None:
inject_dict['enzyme_champion'] = [enz_type_obj.enzyme_type for enz_type_obj in user.enzyme_champion]
if user.has_role('contributor'):
inject_dict['user_papers_need_data'] = len(Paper.objects(Q(owner=user) & (Q(status='Data required') | Q(status='Enzymes need protein sequences') | Q(status='Issues need to be resolved'))))
inject_dict['user_seqs_need_data'] = len(Sequence.objects(Q(owner=user) & ((Q(sequence=None)|Q(sequence='')) & (Q(sequence_unavailable__ne=True)))))
inject_dict['total_team_notifications'] = 0
inject_dict['team_notifications'] = {}
inject_dict['champ_seq_notifications'] = {}
inject_dict['champ_notifications'] = {}
if 'enzyme_teams' in inject_dict:
for enz_type in inject_dict['enzyme_teams']:
num_papers = len(Paper.objects(Q(tags=enz_type) & Q(owner=None) & (Q(status='Data required') | Q(status='Enzymes need protein sequences'))))
inject_dict['team_notifications'][enz_type] = num_papers
inject_dict['total_team_notifications'] += num_papers
if 'enzyme_champion' in inject_dict:
for enz_type in inject_dict['enzyme_champion']:
num_papers = len(Paper.objects(Q(tags=enz_type) & Q(status='Complete - Awaiting review')))
num_seqs = len(Sequence.objects(Q(enzyme_type=enz_type) & ((Q(sequence=None)|Q(sequence='')) & (Q(sequence_unavailable__ne=True)))))
inject_dict['champ_notifications'][enz_type] = num_papers
inject_dict['champ_seq_notifications'][enz_type] = num_seqs
inject_dict['total_team_notifications'] += num_papers + num_seqs
return inject_dict
def submit_comment():
if current_user.is_authenticated:
user = user_datastore.get_user(current_user.id)
else:
user = None
parent_type = request.form['parent_type']
parent_id = request.form['parent_id']
comment_text = request.form['comment']
comment_id = request.form['comment_id']
if comment_id != '':
comment_obj = Comment.objects(id=comment_id)[0]
if current_user.has_role(
'rxn_rules_admin') or comment_obj.owner == user:
comment_obj.text = comment_text
comment_obj.save()
else:
result = {
'status': 'danger',
'msg': 'Could not edit comment - no access',
'issues': []
}
return jsonify(result=result)
else:
comment_obj = Comment(owner=user, text=comment_text)
comment_obj.save()
if parent_type == 'issue':
issue = Issue.objects(id=parent_id)[0]
issue.comments.append(comment_obj)
issue.save()
elif parent_type == 'activity_issue':
issue = ActivityIssue.objects(id=parent_id)[0]
issue.comments.append(comment_obj)
issue.save()
elif parent_type == 'reaction_suggestion':
r_sug = ReactionSuggestion.objects(id=parent_id)[0]
r_sug.comments.append(comment_obj)
r_sug.save()
elif parent_type == 'paper':
paper = Paper.objects(id=parent_id)[0]
paper.comments.append(comment_obj)
paper.save()
elif parent_type == 'paper':
paper = Paper.objects(id=parent_id)[0]
paper.comments.append(comment_obj)
paper.save()
result = {'status': 'success', 'msg': 'Comment submitted', 'issues': []}
return jsonify(result=result)
def task_autoprocess():
ap = AutoProcessor()
paper_ids = list(Paper.objects(status='Complete').distinct('_id'))
for id in paper_ids:
paper = Paper.objects(id=id)[0]
try:
ap.auto_process(paper)
except Exception as e:
print()
print(f'WARNING - ERROR PROCESSING PAPER - {paper.short_citation}')
print()
print(e)
print()
def papers_that_need_data():
user = user_datastore.get_user(current_user.id)
title = "Papers that require curating"
args = request.args.to_dict()
q_no_user = db.Q(owner=None)
q_no_data = db.Q(status__nin=['Complete - Awaiting review', 'Complete'])
if 'enzyme_type' in args:
q_e_type = db.Q(tags=args['enzyme_type'])
title += f" - {args['enzyme_type']}"
else:
q_e_type = db.Q()
papers_data = list(
Paper.objects(q_no_user & q_no_data & q_e_type).only(
*papers_table.PAPERS_TABLE_FIELDS).order_by(
'-status').as_pymongo())
papers_data = papers_table.process_papers_dict(papers_data,
show_owner=False)
return render_template('edit_tables/edit_papers.html',
papers_data=papers_data,
papers_table_height='80vh',
papers_button_columns=['self_assign'],
show_owner=False,
title=title,
row_click_modal=False)
def self_assign():
paper = Paper.objects(id=request.form['paper_id'])[0]
user = user_datastore.get_user(current_user.id)
if papers_functions.can_self_assign(user) == False:
result = {
'status':
'danger',
'msg':
'Can not assign paper',
'issues': [
'Users may not have more papers assigned to them than the number they have completed',
'Please complete papers already assigned to you before taking on additional papers'
]
}
return jsonify(result=result)
if paper.owner == None:
paper.owner = user
paper.save()
result = {
'status': 'success',
'msg': 'Paper is now assigned to you',
'issues': []
}
flash("Paper is now assigned to you", 'success')
return jsonify(result=result)
else:
result = {
'status': 'danger',
'msg': 'Could not assign, paper already belongs to another user',
'issues': []
}
return jsonify(result=result)
def update_paper_molecule():
paper_id = request.form['paper_id']
id = request.form['id']
smi = request.form['smi']
name = request.form['name']
paper_query = Paper.objects(id=paper_id).select_related()
if len(paper_query) != 0:
paper = paper_query[0]
if check_permission.check_paper_permission(current_user.id, paper):
act_mol = ActivityMol.objects(id=id)[0]
if smi != act_mol.smi:
try:
mol = Chem.MolFromSmiles(smi)
svg = moltosvg(mol)
except:
svg = ""
act_mol.svg = svg
act_mol.smi = smi
act_mol.name = name
act_mol.save()
result = {'status': 'success',
'msg': 'Molecule saved',
'issues': []}
return jsonify(result=result)
result = {'status': 'danger',
'msg': 'Could not delete molecule',
'issues': []}
return jsonify(result=result)
def papers_with_orhpan_sequences():
title = "Papers with orphan sequences"
activity_enzyme_names = list(
set(Activity.objects().distinct('enzyme_name')))
paper_ids = []
for name in activity_enzyme_names:
if len(Sequence.objects(enzyme_name=name)) == 0:
act = Activity.objects(enzyme_name=name)[0]
paper_ids.append(act.paper)
papers_data = list(
Paper.objects(id__in=paper_ids).only(
*papers_table.PAPERS_TABLE_FIELDS).order_by(
'-status').as_pymongo())
papers_data = papers_table.process_papers_dict(papers_data,
show_owner=False)
return render_template('edit_tables/edit_papers.html',
papers_data=papers_data,
papers_table_height='80vh',
papers_button_columns=['delete', 'edit'],
show_owner=True,
title=title,
row_click_modal=False)
def query_crossref():
paper = Paper.objects(id=request.form['paper_id'])[0]
doi = str(paper.doi).replace(' ', '')
title, authors_list, journal, date, cite_mini = papers_crossref.get_metadata_from_crossref(
doi)
print(f"{title}, {authors_list}, {journal}, {type(date)}, {cite_mini}")
if cite_mini == '':
result = {
'status': 'danger',
'msg': 'DOI not found in crossref',
'issues': []
}
else:
paper_dict = {
'short_cit': cite_mini,
'doi': doi,
'date': str(date),
'title': title,
'journal': journal,
'authors': papers_functions.list_to_string(authors_list)
}
result = {
'status': 'success',
'msg': 'Fields updated, click save to update the database',
'issues': [],
'paper': paper_dict
}
return jsonify(result=result)
def duplicate_paper_molecule():
id = request.form['id']
paper_id = request.form['paper_id']
paper_query = Paper.objects(id=paper_id).select_related()
if len(paper_query) != 0:
paper = paper_query[0]
if check_permission.check_paper_permission(current_user.id, paper):
mols = ActivityMol.objects(db.Q(id=id))
if len(mols) != 0:
mol = mols[0]
num_paper_mols = ActivityMol.objects(paper=paper).count()
new_mol = ActivityMol(name=f"{num_paper_mols+1}",
smi=mol.smi,
svg=mol.svg,
paper=paper)
new_mol.save()
mol_list = [(new_mol.name, new_mol.smi, new_mol.svg, str(new_mol.id))]
result = {'status': 'success',
'msg': 'Molecule deleted',
'issues': [],
'mol_list': mol_list}
return jsonify(result=result)
result = {'status': 'danger',
'msg': 'Could not delete molecule',
'issues': []}
return jsonify(result=result)
def edit_papers():
papers_data = list(Paper.objects().only(*papers_table.PAPERS_TABLE_FIELDS).order_by('-status').as_pymongo())
papers_data = papers_table.process_papers_dict(papers_data)
return render_template('edit_tables/edit_papers.html',
papers_data=papers_data, papers_table_height='80vh',
papers_button_columns=['delete', 'edit', 'link'],
show_owner=True,
title="Super contributor access to all papers",
row_click_modal=False)
def show_papers():
args = request.args.to_dict()
title = "Papers"
if 'reviewed' in args:
revQ = db.Q(reviewed=True)
else:
revQ = db.Q()
status_query = db.Q(status_not='Data required')
if 'enzyme_type' in args:
enzyme_type_query = db.Q(tags=args['enzyme_type'])
title += f" - featuring {args['enzyme_type']} enzymes"
else:
enzyme_type_query = db.Q()
papers = Paper.objects(enzyme_type_query & revQ)
if 'enzyme_name' in args:
papers = filter_papers_by_enzyme_name(papers, args['enzyme_name'])
title += f" - featuring {args['enzyme_name']}"
if 'reaction' in args:
papers = filter_papers_by_reaction(papers, args['reaction'])
title += f" - featuring a {args['reaction']} reaction"
paper_ids = [paper.id for paper in papers]
papers_data = list(
Paper.objects(id__in=paper_ids).only(
*papers_table.PAPERS_TABLE_FIELDS).order_by(
'-status').as_pymongo())
papers_data = papers_table.process_papers_dict(papers_data)
return render_template('edit_tables/edit_papers.html',
papers_data=papers_data,
papers_table_height='80vh',
papers_button_columns=[],
show_owner=True,
title=title,
row_click_modal=True)
def admin_set_owner():
paper = Paper.objects(id=request.form['paper_id'])[0]
new_owner_id = request.form['new_owner_id']
print(new_owner_id)
new_owner = User.objects(id=new_owner_id)[0]
paper.owner = new_owner
paper.save()
result = {'status': 'success', 'msg': 'Paper owner updated', 'issues': []}
return jsonify(result=result)
def paper_issues():
paper = Paper.objects(id=request.form['paper_id'])[0]
if check_permission.check_seq_permissions(current_user.id, paper):
issues = bool(strtobool(request.form['issues']))
paper.has_issues = issues
paper.save()
result = {
'status': 'success',
'msg': 'Issue status updated',
'issues': []
}
return jsonify(result=result)
def importance_updated():
paper = Paper.objects(id=request.form['paper_id'])[0]
if check_permission.check_seq_permissions(current_user.id, paper):
importance = bool(strtobool(request.form['importance']))
paper.high_importance = importance
paper.save()
result = {
'status': 'success',
'msg': 'Importance updated',
'issues': []
}
return jsonify(result=result)
def admin_all_seqs_to_owner():
paper = Paper.objects(id=request.form['paper_id']).select_related()[0]
seqs = Sequence.objects(db.Q(papers=paper))
for seq in seqs:
seq.owner = paper.owner
seq.save()
result = {
'status': 'success',
'msg': 'All sequences assigned to paper owner',
'issues': []
}
return jsonify(result=result)
def admin_activity_to_owner():
paper = Paper.objects(id=request.form['paper_id']).select_related()[0]
activities = Activity.objects(paper=paper)
for activity in activities:
activity.added_by = paper.owner
activity.save()
result = {
'status': 'success',
'msg': 'Activity added by updated',
'issues': []
}
return jsonify(result=result)
def my_papers():
user = user_datastore.get_user(current_user.id)
papers_data = list(Paper.objects(owner=user).only(*papers_table.PAPERS_TABLE_FIELDS).order_by('-status').as_pymongo())
papers_data = papers_table.process_papers_dict(papers_data)
papers_button_columns = ['edit']
if user.has_role('paper_adder'):
papers_button_columns.append('delete')
return render_template('edit_tables/edit_papers.html',
papers_data=papers_data, papers_table_height='80vh',
papers_button_columns=papers_button_columns,
show_owner=True,
title=f"Papers assigned to {user.first_name} {user.last_name}",
row_click_modal=False)
def submission_main_page(paper_id):
user = user_datastore.get_user(current_user.id)
paper_query = Paper.objects(id=paper_id).select_related()
if len(paper_query) == 0:
flash('Paper has not been added yet, please add to the database first', 'fail')
return redirect(url_for("biocatdb.launch_add_paper"))
paper = paper_query[0]
if not check_permission.check_paper_permission(current_user.id, paper):
flash('No access to edit this entry', 'fail')
return redirect(url_for("biocatdb.launch_add_paper"))
paper_data = get_paper_data(paper, user)
activity_data = get_activity_data(paper)
reactions = list(Reaction.objects().distinct('name'))
enzyme_names = list(Sequence.objects(papers=paper).distinct('enzyme_name'))
enzyme_types = list(EnzymeType.objects().distinct('enzyme_type'))
enzyme_data = sequence_table.get_enzyme_data(db.Q(papers=paper))
enzyme_types_in_paper = list(Sequence.objects(papers=paper).distinct('enzyme_type'))
reactions_in_paper = list(Reaction.objects(enzyme_types__in=enzyme_types_in_paper).distinct('name'))
reactions_in_activity = list(Activity.objects(paper=paper).distinct('reaction'))
status_dict = get_status(paper, user)
comments = get_comments(paper, user)
paper_molecules = get_paper_molecules(paper)
admin_panel = False
admin_dict = {}
if current_user.has_role('admin'):
admin_panel = True
admin_dict = get_admin_dict(paper)
reactions_ordered = reactions_in_activity + [r for r in reactions_in_paper if r not in reactions_in_activity]
reactions_ordered += [r for r in reactions_in_paper if r not in reactions_ordered]
reactions_ordered += [r for r in reactions if r not in reactions_ordered]
return render_template('data_submission/submission_main_page.html',
paper=paper_data,
activity_data=activity_data,
seq_data=enzyme_data, seq_button_columns=['edit', 'remove', 'papers'],
status=status_dict,
seq_table_height='60vh', enzyme_types=enzyme_types, show_header_filters=False, include_owner=True, lock_enz_type='false',
reactions=reactions_ordered, enzyme_names=enzyme_names+['Chemical'],
doi=paper.doi,
comments=comments,
paper_molecules=paper_molecules,
admin_panel=admin_panel,
admin_dict=admin_dict,
enzyme_reactions=reactions_in_paper)
def enzyme_champion_papers(enzyme_type):
user = user_datastore.get_user(current_user.id)
enzyme_type_obj = EnzymeType.objects(enzyme_type=enzyme_type)[0]
if enzyme_type_obj not in user.enzyme_champion:
flash('No access', 'danger')
return redirect(url_for('main_site.home'))
papers_data = list(Paper.objects(tags=enzyme_type).only(*papers_table.PAPERS_TABLE_FIELDS).order_by('-status').as_pymongo())
papers_data = papers_table.process_papers_dict(papers_data)
return render_template('edit_tables/edit_papers.html',
papers_data=papers_data, papers_table_height='80vh',
papers_button_columns=['delete', 'edit'],
show_owner=True,
title=f"Enzyme champion for {enzyme_type} papers",
row_click_modal=False)
def save_paper():
user = user_datastore.get_user(current_user.id)
paper = Paper.objects(id=request.form['paper_id'])[0]
if not check_permission.check_paper_permission(current_user.id, paper):
result = {
'status': 'danger',
'msg': 'No access to edit this paper',
'issues': [],
'redirect': url_for("biocatdb.launch_add_paper")
}
return jsonify(result=result)
paper.short_citation = request.form['short_cit']
paper.doi = request.form['doi'].replace(' ', '')
paper.html = 'https://doi.org/' + request.form['doi']
if request.form['date'] != "":
paper.date = request.form['date']
paper.title = request.form['title']
paper.journal = request.form['journal']
paper.authors = request.form['authors'].split(', ')
paper.tags = request.form['tags'].split(', ')
if user not in paper.edits_by:
paper.edits_by.append(user)
if (paper.owner == user) and (request.form['self_assign'] == 'false'):
paper.owner = None
paper.save()
unassign_seqs_in_paper(user, paper)
if not current_user.has_role('super_contributor'):
result = {
'status': 'warning',
'msg': 'Paper no longer assigned to you',
'issues': [],
'redirect': url_for("biocatdb.launch_add_paper")
}
return jsonify(result=result)
elif request.form['self_assign'] == 'true':
paper.owner = user
paper.save()
papers_functions.tag_paper_with_enzyme_types(paper)
result = {
'status': 'success',
'msg': 'Paper information updated',
'issues': []
}
return jsonify(result=result)
def paper_substrate_specificity(paper_id):
paper = Paper.objects(id=paper_id)[0]
title = f"{paper.short_citation} activity data"
args = request.args.to_dict()
if 'reviewed' in args:
revQ = db.Q(reviewed=True)
else:
revQ = db.Q()
paper_Q = db.Q(paper=paper)
activity_data = list(Activity.objects(paper_Q & revQ).only(*process_activity_data.mongo_cols).as_pymongo())
activity_data = process_activity_data.process_activity_data(activity_data)
activity_data = process_activity_data.smiles_to_svg(activity_data)
return render_template('substrate_specificity/table_result_specificity.html', substrate_specificity_data=activity_data, title=title)
def load_paper_data():
paper = Paper.objects(id=request.form['paper_id'])[0].select_related()
authors_str = ""
for author in paper.authors:
authors_str += f"{author}, "
authors_str = authors_str[0:-2]
if paper.owner is None:
owner = ''
else:
owner = f"{paper.owner.first_name} {paper.owner.last_name}, {paper.owner.affiliation}"
tags_str = ""
for tag in paper.tags:
tags_str += f"{tag}, "
tags_str = tags_str[0:-2]
if len(paper.authors) != 0:
v_short_cit = f"{paper.authors[0]} et al"
else:
v_short_cit = paper.title[0:10] + '..'
if paper.date != None:
date = paper.date.strftime('%B-%Y')
else:
date = None
result = {
'title': paper.title,
'authors': authors_str,
'owner': owner,
'journal': paper.journal,
'date': date,
'tags': tags_str,
'status': paper.status,
'doi': paper.doi,
'paper_id': str(paper.id),
'v_short_cit': f"<i>{v_short_cit}</i>"
}
return jsonify(result=result)
def update_reviewed_status():
papers = Paper.objects(reviewed=True)
for paper in papers:
acts = Activity.objects(paper=paper)
seqs = Sequence.objects(papers=paper)
for act in acts:
act.reviewed = True
act.save()
for seq in seqs:
seq.reviewed = True
seq.save()
result = {
'status': 'success',
'msg':
f'Updated activity and sequence data to reviewed = True, if paper has been reviewed',
'issues': []
}
return jsonify(result=result)
def task_process_images(list_filenames, paper_id, start_num=1):
osra_url = current_app.config['OSRA_API_HOST']
paper = Paper.objects(id=paper_id)[0]
job = get_current_job()
job.meta['progress'] = 'started'
job.save_meta()
dict_smiles = {}
n = start_num
for i, filename in enumerate(list_filenames):
new_smis = structure_recognition.process_image(filename, osra_url, log=True)
for j, smi in enumerate(new_smis):
name = f"{n}"
dict_smiles[name] = smi
n += 1
for name, smi in dict_smiles.items():
structure_recognition.save_mol(smi, paper, name=name)
return dict_smiles
def upload_sequence_excel():
issues = []
if request.method != 'POST':
issues.append('Method is not POST')
else:
excel_file = request.files['file_seq']
paper = Paper.objects(id=request.form['paper_id_field'])[0]
filename = secure_filename(excel_file.filename)
if filename[-5:] == '.xlsx':
excel_file.save(filename)
df = pd.read_excel(filename)
data_list = process_uploaded_excel(df)
os.remove(filename)
save_issues = save_or_add_seqs(data_list, paper)
if len(save_issues) == 0:
result = {
'status': 'success',
'msg': 'Sequences saved and added to paper',
'issues': []
}
flash("Sequences saved and added to paper", "success")
else:
result = {
'status': 'warning',
'msg': 'Sequences saved with some issues:',
'issues': save_issues
}
flash("Sequences saved with some issues", "warning")
return jsonify(result=result)
else:
issues.append('File does not end in .xlsx')
result = {
'status': 'danger',
'msg': 'Error processing file',
'issues': issues
}
return jsonify(result=result)
def review_paper():
user = user_datastore.get_user(current_user.id)
paper = Paper.objects(id=request.form['paper_id'])[0]
acts = Activity.objects(paper=paper)
seqs = Sequence.objects(papers=paper).select_related()
if check_permission.check_seq_permissions(current_user.id, paper):
reviewed = bool(strtobool(request.form['reviewed']))
paper.reviewed = reviewed
if reviewed == True:
paper.reviewed_by = user
else:
paper.reviewed_by = None
paper.save()
for act in acts:
act.reviewed = reviewed
act.save()
if reviewed == True:
for seq in seqs:
seq.reviewed = True
seq.save()
else:
for seq in seqs:
has_reviewed_paper = False
for paper in seq.papers:
if paper.reviewed == True:
has_reviewed_paper = True
break
if has_reviewed_paper == False:
seq.reviewed = False
seq.save()
result = {
'status': 'success',
'msg': 'Review status updated',
'issues': []
}
return jsonify(result=result)
def task_assign_papers():
users = User.objects()
papers = Paper.objects()
for paper in papers:
paper_status.update_status(paper)
for user in users:
usernames = get_usernames(user)
for paper in papers:
if paper.added_by is None or paper.added_by == '':
activities = Activity.objects(paper=paper)
for activity in activities:
if does_username_match(usernames,
activity.added_by_string):
activity.added_by = user
activity.save()
if paper.added_by is None or paper.added_by == '':
paper.added_by = user
paper.owner = user
paper.save()
