def save_my_molecule():
user = user_datastore.get_user(current_user.id)
smiles = request.form['smiles']
name = request.form['name']
if rdkit_smile(smiles) is None:
result = {'status': 'danger',
'msg': 'Please enter a valid SMILES',
'issues': []}
return jsonify(result=result)
mol_query = MyMolecule.objects(db.Q(owner=user) & db.Q(smiles=smiles))
if len(mol_query) != 0:
my_mol = mol_query[0]
else:
my_mol = MyMolecule(owner=user,
smiles=smiles)
try:
mol = Chem.MolFromSmiles(smiles)
my_mol.svg = get_images.moltosvg(mol,molSize=(100,100),kekulize=True)
except:
my_mol.svg = ''
my_mol.name = name
my_mol.save()
result = {'status': 'success',
'msg': 'Molecule saved',
'issues': []}
return jsonify(result=result)
def delete_reaction_suggestion():
suggestion_id = request.form['suggestion_id']
sug = ReactionSuggestion.objects(id=suggestion_id)[0]
if current_user.is_authenticated:
user = user_datastore.get_user(current_user.id)
if sug.owner == user or user.has_rule('rxn_rules_admin'):
sug.delete()
for comment in sug.comments:
comment.delete()
flash('Issue deleted', 'success')
result = {
'status': 'success',
'msg': 'Comment deleted',
'issues': []
}
return jsonify(result=result)
result = {
'status': 'danger',
'msg': 'No access to delete this suggestion',
'issues': []
}
return jsonify(result=result)
def delete_comment():
if current_user.is_authenticated:
user = user_datastore.get_user(current_user.id)
else:
user = None
comment_id = request.form['comment_id']
comment_obj = Comment.objects(id=comment_id)[0]
if comment_obj.owner == user or current_user.has_role('rxn_rules_admin'):
comment_obj.delete()
result = {'status': 'success', 'msg': 'Comment deleted', 'issues': []}
flash('Comment deleted', 'success')
return jsonify(result=result)
else:
result = {
'status': 'danger',
'msg':
'Could not delete - You are not the owner of this comment and do not have access',
'issues': []
}
flash('You are not the owner of this comment and do not have access',
'danger')
return jsonify(result=result)
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 raise_activity_data_issue():
user = user_datastore.get_user(current_user.id)
activity_id = request.form['activity_id']
comment = request.form['comment']
activity = Activity.objects(id=activity_id)[0].select_related()
comment_obj = Comment(owner=user, text=comment)
comment_obj.save()
if len(ActivityIssue.objects(activity=activity)) == 0:
new_issue = ActivityIssue(activity=activity,
raised_by=user,
comments=[comment_obj])
new_issue.save()
result = {
'status': 'success',
'msg': 'Issue has been created',
'issues': []
}
return jsonify(result=result)
else:
result = {
'status':
'danger',
'msg':
'An issue has already been raised for this data',
'issues':
['Please see the activity data issues page for more information']
}
return jsonify(result=result)
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 delete_account():
delete_check = request.form['delete']
if delete_check == 'DELETE':
user = user_datastore.get_user(current_user.id)
user.delete()
return jsonify({'result': 'done'})
else:
return jsonify({'result': 'failed'})
def get_users_saves(all_saves):
user = user_datastore.get_user(current_user.id)
user_saves = []
for save_tuple in all_saves:
if len(Network.objects(uuid=save_tuple[2])) > 0:
mongo_network = Network.objects(uuid=save_tuple[2])[0]
if mongo_network.owner == user:
user_saves.append(save_tuple)
return user_saves
def delete_network_save():
save_id = request.form['save_id']
user = user_datastore.get_user(current_user.id)
query = Network.objects(uuid=save_id)
if len(query) > 0:
to_delete = query[0]
if to_delete.owner == user:
to_delete.delete()
return jsonify({})
def load_my_molecules():
user = user_datastore.get_user(current_user.id)
mols = MyMolecule.objects(db.Q(owner=user))
mol_dict = {}
for mol in mols:
mol_dict[mol.smiles] = (mol.name, mol.svg)
result = {'mol_dict': mol_dict}
return jsonify(result=result)
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 contributor_sign_up():
form = ContributorSignup()
if form.validate_on_submit() == True:
if current_user.is_authenticated:
user = user_datastore.get_user(current_user.id)
contributor_role = Role.objects(name='contributor')[0]
user_datastore.add_role_to_user(user, contributor_role)
return redirect(url_for("biocatdb.contributor_is_signed_up"))
return render_template('contributor_sign_up/contributor_signup.html',
form=form)
def my_sequences():
user = user_datastore.get_user(current_user.id)
query = db.Q(owner=user)
enzyme_data = sequence_table.get_enzyme_data(query)
enzyme_types = sorted(list(EnzymeType.objects().distinct("enzyme_type")))
return render_template('edit_tables/edit_sequences.html',
seq_data=enzyme_data, seq_button_columns=['edit', 'delete', 'papers'],
seq_table_height='80vh', enzyme_types=enzyme_types, show_header_filters=True,
include_owner=True, lock_enz_type='false',
title=f"Enzyme sequences assigned to {user.first_name} {user.last_name}",
row_click_modal=False)
def reaction_suggestion(suggestion_id):
r_sug = ReactionSuggestion.objects(id=suggestion_id).select_related()[0]
reaction_name = r_sug.name
page_title = f"Reaction suggestion for {reaction_name}"
reaction_smarts = str(yaml.dump(list(r_sug.smarts)))
reaction_details = r_sug.details
owner = f"{r_sug.owner.first_name} {r_sug.owner.last_name}, {r_sug.owner.affiliation}"
status = r_sug.status
can_save = False
can_delete = False
enable_comments = True
if current_user.is_authenticated:
user = user_datastore.get_user(current_user.id)
if r_sug.owner == user or user.has_role('rxn_rules_admin'):
can_save = True
can_delete = True
else:
user = None
comments = []
for comment in r_sug.comments:
comment_can_edit = False
comment_can_delete = False
if current_user.has_role('rxn_rules_admin') or comment.owner == user:
comment_can_edit = True
comment_can_delete = True
new_comment = {
'user':
f"{comment.owner.first_name} {comment.owner.last_name}, {comment.owner.affiliation}",
'date': comment.date.strftime("%d/%m/%Y, %H:%M:%S"),
'comment': comment.text,
'comment_id': str(comment.id),
'can_edit': comment_can_edit,
'can_delete': comment_can_delete
}
comments.append(new_comment)
return render_template('reaction_suggestions/reaction_suggestion.html',
page_title=page_title,
suggestion_id=suggestion_id,
reaction_name=reaction_name,
reaction_smarts=reaction_smarts,
reaction_details=reaction_details,
owner=owner,
comments=comments,
status=status,
can_save=can_save,
can_delete=can_delete,
enable_comments=enable_comments)
def my_reaction_issues_table():
user = user_datastore.get_user(current_user.id)
issues = Issue.objects(raised_by=user).only('id', 'date', 'reaction',
'issue_reaction_svg',
'raised_by', 'status',
'public',
'comments').select_related()
reaction_issues_data = get_issue_data(issues)
display_public = 'true'
return render_template('reaction_issues/reactions_issues_table.html',
reaction_issues_data=reaction_issues_data,
display_public=display_public)
def save_reaction_suggestion():
user = user_datastore.get_user(current_user.id)
suggestion_id = request.form['suggestion_id']
reaction_name = request.form['reaction_name']
reaction_smarts = str(request.form['reaction_smarts'])
details = request.form['details']
smarts_list = []
if len(reaction_smarts) != 0:
try:
smarts_list = yaml.safe_load(reaction_smarts)
except:
result = {
'status': 'danger',
'msg': 'Could not load SMARTS yaml',
'issues': []
}
return jsonify(result=result)
if suggestion_id == '':
r_suggestion = ReactionSuggestion(name=reaction_name,
owner=user,
details=details,
smarts=smarts_list,
comments=[])
r_suggestion.save()
result = {
'status': 'success',
'msg': 'Reaction suggestion saved',
'issues': [],
'suggestion_id': str(r_suggestion.id)
}
return jsonify(result=result)
else:
r_suggestion = ReactionSuggestion.objects(id=suggestion_id)[0]
r_suggestion.name = reaction_name
r_suggestion.smarts = smarts_list
r_suggestion.details = details
r_suggestion.save()
result = {
'status': 'success',
'msg': 'Reaction suggestion saved',
'issues': [],
'suggestion_id': str(r_suggestion.id)
}
return jsonify(result=result)
def reaction_issue(issue_id):
if current_user.is_authenticated:
user = user_datastore.get_user(current_user.id)
else:
user = None
issue = Issue.objects(id=issue_id).select_related()[0]
reaction_svg = smiles_rxn_to_svg(issue.issue_reaction_smiles,
rxnSize=(600, 150))
if issue.public == True:
public = 'Public'
else:
public = 'Not public'
num_issues = len(
Issue.objects(db.Q(reaction=issue.reaction) & db.Q(status='Open')))
comments = []
for comment in issue.comments:
can_edit = False
can_delete = False
if current_user.has_role('rxn_rules_admin') or comment.owner == user:
can_edit = True
can_delete = True
new_comment = {
'user':
f"{comment.owner.first_name} {comment.owner.last_name}, {comment.owner.affiliation}",
'date': comment.date.strftime("%d/%m/%Y, %H:%M:%S"),
'comment': comment.text,
'comment_id': str(comment.id),
'can_edit': can_edit,
'can_delete': can_delete
}
comments.append(new_comment)
return render_template(
'reaction_issues/issue_page.html',
reaction_name=issue.reaction.name,
reaction_svg=reaction_svg,
reaction_smiles=issue.issue_reaction_smiles,
raised_by=
f"{issue.raised_by.first_name} {issue.raised_by.last_name}, {issue.raised_by.affiliation}",
date=issue.date.strftime("%d/%m/%Y"),
status=issue.status,
public=public,
num_issues=num_issues,
issue_id=str(issue.id),
comments=comments)
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 load_from_mongo(id):
data = False
if len(Network.objects(uuid=id)) > 0:
if current_user.is_authenticated:
user = user_datastore.get_user(current_user.id)
else:
user = False
mongo_network = Network.objects(uuid=id)[0]
if (mongo_network.public == True) or (mongo_network.owner == user):
data = mongo_network.data
if mongo_network.owner != user:
data['save_id'] = str(uuid.uuid4())
data['save_links'] = []
return data
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 enzyme_champion_seq(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'))
query = db.Q(enzyme_type=enzyme_type)
enzyme_data = sequence_table.get_enzyme_data(query)
enzyme_types = sorted(list(EnzymeType.objects().distinct("enzyme_type")))
return render_template('edit_tables/edit_sequences.html',
seq_data=enzyme_data, seq_button_columns=['edit', 'merge', 'delete', 'papers'],
seq_table_height='80vh', enzyme_types=enzyme_types,
show_header_filters=True, include_owner=True, lock_enz_type='true',
title=f"Enzyme champion for {enzyme_type} sequences",
row_click_modal=False)
def change_sequence_assign():
original_name = request.form['original_name']
self_assigned = bool(strtobool(request.form['self_assigned']))
print(self_assigned)
user = user_datastore.get_user(current_user.id)
seq = Sequence.objects(enzyme_name=original_name)[0]
if (seq.owner == user) and (self_assigned is False):
seq.owner = None
seq.save()
elif (seq.owner == None) and (self_assigned == True):
seq.owner = user
seq.save()
result = {'status': 'success', 'msg': 'Sequence assigned', 'issues': []}
return jsonify(result=result)
def activity_data_issue(issue_id):
print(issue_id)
if current_user.is_authenticated:
user = user_datastore.get_user(current_user.id)
else:
user = None
issue = ActivityIssue.objects(id=issue_id).select_related()[0]
reaction_svg = generate_rxn_svg(issue.activity, rxnSize=(600, 150))
paper = issue.activity.paper.short_citation
comments = []
for comment in issue.comments:
can_edit = False
can_delete = False
if current_user.has_role('rxn_rules_admin') or comment.owner == user:
can_edit = True
can_delete = True
new_comment = {
'user':
f"{comment.owner.first_name} {comment.owner.last_name}, {comment.owner.affiliation}",
'date': comment.date.strftime("%d/%m/%Y, %H:%M:%S"),
'comment': comment.text,
'comment_id': str(comment.id),
'can_edit': can_edit,
'can_delete': can_delete
}
comments.append(new_comment)
return render_template(
'issues/activity_issue_page.html',
reaction_svg=reaction_svg,
raised_by=
f"{issue.raised_by.first_name} {issue.raised_by.last_name}, {issue.raised_by.affiliation}",
date=issue.date.strftime("%d/%m/%Y"),
status=issue.status,
paper=paper,
issue_id=str(issue.id),
activity_id=str(issue.activity.id),
enzyme_name=issue.activity.enzyme_name,
paper_id=str(issue.activity.paper.id),
comments=comments)
def delete_my_molecule():
user = user_datastore.get_user(current_user.id)
smiles = request.form['smiles']
mols = MyMolecule.objects(db.Q(owner=user) & db.Q(smiles=smiles))
if len(mols) != 0:
mol = mols[0]
mol.delete()
result = {'status': 'success',
'msg': 'Molecule deleted',
'issues': []}
return jsonify(result=result)
result = {'status': 'danger',
'msg': 'Could not delete molecule',
'issues': []}
return jsonify(result=result)
def submit_reaction_issue():
substrates = json.loads(request.form['parents'])
products = json.loads(request.form['children'])
reaction_name = request.form['reaction']
comment = request.form['comment']
public = bool(strtobool(request.form['public']))
if len(Reaction.objects(name=reaction_name)) == 0:
result = {
'status': 'danger',
'msg': 'Can not raise an issue for a non retrobiocat reaction',
'issues': []
}
return jsonify(result=result)
reaction_smiles = f"{substrates[0]}"
if len(substrates) > 1:
reaction_smiles += f".{substrates[1]}"
reaction_smiles += f">>{products[0]}"
query_reaction_svg = smiles_rxn_to_svg(reaction_smiles, rxnSize=(300, 70))
user = user_datastore.get_user(current_user.id)
reaction = Reaction.objects(name=reaction_name)[0]
comment_obj = Comment(owner=user, text=comment)
comment_obj.save()
issue = Issue(reaction=reaction,
issue_reaction_smiles=reaction_smiles,
issue_reaction_svg=query_reaction_svg,
raised_by=user,
status='Open',
comments=[comment_obj],
public=public)
issue.save()
print(f"Issue saved for {issue.reaction}")
result = {'status': 'success', 'msg': 'Issue raised', '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 my_network_saves():
if not current_user.is_authenticated:
return redirect('/')
user = user_datastore.get_user(current_user.id)
saves = []
for network in Network.objects(owner=user):
try:
img = str(Chem.MolFromSmiles(network.target_smiles))
img = img[:-1] + 'width="100" height="100" >'
except:
img = ''
network_dict = {
'Name':
network.name,
'Target':
img,
'Decription':
network.description,
'Saved at':
str(network.time),
'Sharable':
str(network.public),
'UUID':
network.uuid,
'Link':
url_for('retrobiocat.network_explorer',
task_id=network.uuid,
_external=True)
}
saves.append(network_dict)
headings = ['Name', 'Target', 'Decription', 'Saved at', 'Sharable']
return render_template('my_network_saves/my_network_saves.html',
headings=headings,
row_saves=saves)
def remove_contributor():
user = user_datastore.get_user(current_user.id)
contributor_role = Role.objects(name='contributor')[0]
if contributor_role in user.roles:
user.roles.remove(contributor_role)
user.save()
result = {
'status': 'success',
'msg': 'Contributor status removed',
'issues': []
}
flash('Contributor status removed', 'success')
else:
result = {
'status': 'danger',
'msg': 'User does not have contributor status',
'issues': []
}
flash('User does not have contributor status', 'danger')
return jsonify(result=result)
