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)