def add_pmids(file_name, file_pmids, src_id, uname):
""" add pmids """
try:
if len(file_pmids) > 0:
existing = DBSession.query(Filedbentity).filter(
Filedbentity.display_name == file_name).one_or_none()
pmid_list = file_pmids
if existing:
for pmid in pmid_list:
pmid = int(pmid.strip())
existing_ref_file = DBSession.query(ReferenceFile).filter(
ReferenceFile.file_id ==
existing.dbentity_id).one_or_none()
ref = DBSession.query(Referencedbentity).filter(
Referencedbentity.pmid == pmid).one_or_none()
if ref and not existing_ref_file:
new_ref_file = ReferenceFile(
created_by=uname,
file_id=existing.dbentity_id,
reference_id=ref.dbentity_id,
source_id=src_id)
DBSession.add(new_ref_file)
except Exception as e:
logging.error("Exception occurred", exc_info=True)
def add_path_entries(file_name, file_path, src_id, uname):
""" add paths to file_path table """
try:
existing = DBSession.query(Filedbentity).filter(
Filedbentity.display_name == file_name).one_or_none()
if not existing:
logging.error('error with ' + file_name)
path = DBSession.query(Path).filter_by(path=file_path).one_or_none()
if path is None:
logging.warning('Could not find path ')
else:
if existing:
existing_filepath = DBSession.query(FilePath).filter(
and_(FilePath.file_id == existing.dbentity_id,
FilePath.path_id == path.path_id)).one_or_none()
if not existing_filepath:
new_filepath = FilePath(file_id=existing.dbentity_id,
path_id=path.path_id,
source_id=src_id,
created_by=uname)
DBSession.add(new_filepath)
except Exception as e:
logging.error("Exception occurred", exc_info=True)
def main():
""""""
_ = lambda text: text
"""-----------------User-----------------"""
Permission.create('start_menu_access', _('Access to "Start" menu'))
"""-----------------Admin-----------------"""
# menus
Permission.create('admin_menu_access', _('Access to "Admin" menu'))
Permission.create('distribution_menu_access',
_('Access to "Distribution" admin menu'))
Permission.create('settings_menu_access',
_('Access to "Settings" admin menu'))
# permissions menu
Permission.create(Permission.view_permission,
_('Access to "Permissions" menu'))
Permission.create(Permission.add_permission, _('Allow add permission'))
Permission.create(Permission.delete_permission,
_('Allow remove permission'))
Permission.create('superuser', _('Superuser'))
DBSession.commit()
users = DBSession.query(User).filter(
User.chat_id.in_(SUPERUSER_ACCOUNTS)).all()
permission = DBSession.query(Permission).get('superuser')
for user in users:
if not user.has_permission(permission.code):
user.permissions.append(permission)
DBSession.add(user)
DBSession.commit()
def main():
users = DBSession.query(User).filter(User.is_active == True).all()
for user in users:
user.init_permissions()
DBSession.add(user)
DBSession.commit()
def stop(bot, update, user_data):
_ = user_data['_'] if '_' in user_data else gettext
user = DBSession.query(User).filter(
User.chat_id == user_data['user'].chat_id).first()
user.active = False
DBSession.add(user)
DBSession.commit()
bot.send_message(chat_id=user.chat_id,
text='Вы удалены из бота.')
def insert_abstract(pmid, reference_id, record, source_id, journal_abbrev,
journal_title, issn_print, created_by):
""" Add abstract to Referencedocument table
This method does not return anything, just does the necessary CRUD operations
Parameters
----------
pmid: int
reference_id: int
source_id: int
journal_abbrev: str
journal_title: str
issn_print: str
created_by: str
Return
------
empty
does not return anything
"""
text = record.get('AB', '')
if text == '':
return
locus_names_ids = DBSession.query(Locusdbentity.display_name,
Locusdbentity.sgdid).all()
html = link_gene_names(text, locus_names_ids)
x = Referencedocument(document_type='Abstract',
source_id=source_id,
reference_id=reference_id,
text=text,
html=html,
created_by=created_by)
DBSession.add(x)
entries = create_bibentry(pmid, record, journal_abbrev, journal_title,
issn_print)
y = Referencedocument(document_type='Medline',
source_id=source_id,
reference_id=reference_id,
text='\n'.join([
key + ' - ' + str(value)
for key, value in entries if value is not None
]),
html='\n'.join([
key + ' - ' + str(value)
for key, value in entries if value is not None
]),
created_by=created_by)
DBSession.add(y)
DBSession.flush()
DBSession.refresh(x)
def insert_pubtypes(pmid, reference_id, pubtypes, source_id, created_by):
for type in pubtypes:
x = Referencetype(display_name=type,
obj_url='/referencetype/' + type.replace(' ', '_'),
source_id=source_id,
reference_id=reference_id,
created_by=created_by)
DBSession.add(x)
DBSession.flush()
DBSession.refresh(x)
def get_journal_id(record, created_by):
journal_abbr = record.get('TA', '')
journal_full_name = record.get('JT', '')
# 1469-221X (Print) 1469-221X (Linking)
# 1573-6881 (Electronic) 0145-479X (Linking)
issn_list = record.get('IS', '').split(') ')
issn_print = ''
issn_electronic = ''
for issn in issn_list:
if "Print" in issn or "Linking" in issn:
issn_print = issn.split(' ')[0]
if "Electronic" in issn:
issn_electronic = issn.split(' ')[0]
if issn_print:
journals = DBSession.query(Journal).filter_by(
issn_print=issn_print).all()
if len(journals) > 0:
return journals[0].journal_id, journals[
0].med_abbr, journal_full_name, issn_print
if journal_abbr == '':
return None, '', '', ''
if journal_abbr:
journals = DBSession.query(Journal).filter_by(
med_abbr=journal_abbr).all()
if len(journals) > 0:
return journals[0].journal_id, journals[
0].med_abbr, journal_full_name, issn_print
source_id = 824 # 'PubMed'
shortened_full_name = (
journal_full_name[:197] +
'...') if len(journal_full_name) > 200 else journal_full_name
format_name = journal_full_name.replace(' ', '_') + journal_abbr.replace(
' ', '_')
j = Journal(issn_print=issn_print,
issn_electronic=issn_electronic,
display_name=shortened_full_name,
format_name=(format_name[:97] +
'...') if len(format_name) > 100 else format_name,
title=shortened_full_name,
med_abbr=journal_abbr,
source_id=source_id,
obj_url='/journal/' + format_name,
created_by=created_by)
DBSession.add(j)
DBSession.flush()
DBSession.refresh(j)
return j.journal_id, j.med_abbr, journal_full_name, issn_print
def stop(update, context):
# if user never have a conversation with bot and sending /stop he has empty user_data
if context.user_data:
_ = context.user_data['user'].translator
user = DBSession.query(User).filter(
User.chat_id == context.user_data['user'].chat_id).first()
user.active = False
user.chat_room_id = None
DBSession.add(user)
DBSession.commit()
context.bot.send_message(chat_id=user.chat_id,
text=_("You are deleted from this bot."))
def insert_authors(reference_id, authors, source_id, created_by):
if len(authors) == 0:
return
i = 0
for author in authors:
i = i + 1
x = Referenceauthor(display_name=author,
obj_url='/author/' + author.replace(' ', '_'),
source_id=source_id,
reference_id=reference_id,
author_order=i,
author_type='Author',
created_by=created_by)
DBSession.add(x)
DBSession.flush()
DBSession.refresh(x)
def insert_urls(pmid, reference_id, doi_url, pmc_url, source_id, created_by):
x = ReferenceUrl(display_name='PubMed',
obj_url=pubmed_root + str(pmid),
reference_id=reference_id,
url_type='PubMed',
source_id=source_id,
created_by=created_by)
DBSession.add(x)
if doi_url:
x = ReferenceUrl(display_name='DOI full text',
obj_url=doi_url,
reference_id=reference_id,
url_type='DOI full text',
source_id=source_id,
created_by=created_by)
DBSession.add(x)
if pmc_url:
x = ReferenceUrl(display_name='PMC full text',
obj_url=pmc_url,
reference_id=reference_id,
url_type='PMC full text',
source_id=source_id,
created_by=created_by)
DBSession.add(x)
DBSession.flush()
DBSession.refresh(x)
def users_from_chat(bot=None, job=None):
data = get_settings_file(SETTINGS_FILE)
day, month, year = data['transition'].split('.')
transition = date(int(year), int(month), int(day))
with client:
entity = client.get_entity(data['chat_link'])
users_in_chat = client.get_participants(entity)
for user_chat in users_in_chat:
user = DBSession.query(User).filter(User.chat_id == user_chat.id).first()
if user is None:
user = User()
user.chat_id = user_chat.id
user.name = user_chat.first_name
user.username = user_chat.username
user.active = True
user.join_date = date.today()
user.expiration_date = transition
DBSession.add(user)
DBSession.commit()
logger.info(f"Added {user.username}")
else: pass
def insert_relations(pmid, reference_id, record, created_by):
tag_to_type = {
"CON": "Comment",
"CIN": "Comment",
"EIN": "Erratum",
"EFR": "Erratum",
"CRI": "Corrected and Republished",
"CRF": "Corrected and Republished",
"PRIN": "Partial retraction",
"PROF": "Partial retraction",
"RPI": "Republished",
"RPF": "Republished",
"RIN": "Retraction",
"ROF": "Retraction",
"UIN": "Update",
"UOF": "Update",
"SPIN": "Summary for patients",
"ORI": "Original report"
}
inText = None
onText = None
rtype = None
for tag in [
'CIN', 'EIN', 'CRI', 'PRIN', 'RPI', 'RIN', 'UIN', 'SPIN', 'ORI'
]:
if record.get(tag):
inText = record[tag]
rtype = tag_to_type[tag]
break
for tag in ['CON', 'EFR', 'CRF', 'PROF', 'RPF', 'ROF', 'UOF']:
if record.get(tag):
onText = record[tag]
rtype = tag_to_type[tag]
break
if inText is None and onText is None:
return
source_id = 834 # 'SGD'
parent_reference_id = None
child_reference_id = None
if type(inText) == list:
inText = inText[0]
if inText is not None and "PMID:" in inText:
print(inText)
parent_reference_id = reference_id
child_pmid = inText.split("PMID: ")[1].strip()
print(child_pmid)
child_reference_id = get_reference_id(int(child_pmid))
print('is there a child?')
print((child_pmid, child_reference_id))
if child_reference_id is not None:
x = ReferenceRelation(parent_id=parent_reference_id,
child_id=child_reference_id,
source_id=source_id,
correction_type=rtype,
created_by=created_by)
DBSession.add(x)
if type(onText) == list:
onText = onText[0]
if onText is not None and "PMID:" in onText:
child_reference_id = reference_id
parent_pmid = onText.split("PMID: ")[1].strip()
parent_reference_id = get_reference_id(int(parent_pmid))
print('is there a parent?')
print((parent_pmid, parent_reference_id))
if parent_reference_id is not None:
x = ReferenceRelation(parent_id=parent_reference_id,
child_id=child_reference_id,
source_id=source_id,
correction_type=rtype,
created_by=created_by)
DBSession.add(x)
DBSession.flush()
DBSession.refresh(x)
def insert_referencedbentity(pmid,
source_id,
record,
created_by,
method_obtained="Curator triage"):
""" Inserts referencedbentity object into table referencedbentity
Parameters
----------
pmid: int
source_id: int
record: dict
created_oby: str
method_obtained: str, optional
Returns
--------
list
"""
pubstatus, date_revised = get_pubstatus_date_revised(record)
journal_id, journal, journal_title, issn_print = get_journal_id(
record, created_by)
pubdate = record.get('DP', None)
year = pubdate.split(' ')[0]
title = record.get('TI', None)
authors = record.get('AU', [])
volume = record.get('VI', None)
issue = record.get('IP', None)
pages = record.get('PG', None)
citation = set_cite(title, authors, year, journal, volume, issue, pages)
doi, doi_url = get_doi(record)
pmcid = record.get('PMC', None)
pmc_url = pmc_root + pmcid + '/' if pmcid else None
publication_status = status
fulltext_status = pdf_status
if pubstatus == 'aheadofprint':
publication_status = epub_status
fulltext_status = epub_pdf_status
if year:
year = int(year)
if journal_id:
journal_id = int(journal_id)
x = Referencedbentity(display_name=citation.split(')')[0] + ')',
source_id=source_id,
subclass='REFERENCE',
dbentity_status='Active',
method_obtained=method_obtained,
publication_status=publication_status,
fulltext_status=fulltext_status,
citation=citation,
year=year,
pmid=int(pmid),
pmcid=pmcid,
date_published=pubdate,
date_revised=date_revised,
issue=issue,
page=pages,
volume=volume,
title=title,
doi=doi,
journal_id=journal_id,
created_by=created_by)
DBSession.add(x)
DBSession.flush()
DBSession.refresh(x)
dbentity_id = x.dbentity_id
## insert into REFERENCEDOCUMENT
insert_abstract(pmid, dbentity_id, record, source_id, journal,
journal_title, issn_print, created_by)
return [dbentity_id, authors, doi_url, pmc_url, x.sgdid, x]
def insert_author_response(request):
try:
sgd = DBSession.query(Source).filter_by(display_name='Direct submission').one_or_none()
source_id = sgd.source_id
created_by = 'OTTO'
email = request.params.get('email')
if email == '':
return HTTPBadRequest(body=json.dumps({'error': "Please enter your email address."}), content_type='text/json')
is_email_valid = validate_email(email, verify=False)
if not is_email_valid:
msg = email + ' is not a valid email.'
return HTTPBadRequest(body=json.dumps({'error': msg}), content_type='text/json')
pmid = request.params.get('pmid')
pmid = pmid.replace('PMID:', '').replace('Pubmed ID:', '').strip()
if pmid == '':
return HTTPBadRequest(body=json.dumps({'error': "Please enter Pubmed ID for your paper."}), content_type='text/json')
if pmid.isdigit():
pmid = int(pmid)
else:
return HTTPBadRequest(body=json.dumps({'error': "Please enter a number for Pubmed ID."}), content_type='text/json')
x = DBSession.query(Authorresponse).filter_by(author_email=email, pmid=int(pmid)).one_or_none()
if x is not None:
return HTTPBadRequest(body=json.dumps({'error': "You have already subomitted info for PMID:" + str(pmid)+"."}), content_type='text/json')
has_novel_research = '0'
if request.params.get('has_novel_research'):
has_novel_research = '1'
has_large_scale_data = '0'
if request.params.get('has_large_scale_data'):
has_large_scale_data = '1'
research_results = request.params.get('research_result')
dataset_description = request.params.get('dataset_desc')
gene_list = request.params.get('genes')
other_description = request.params.get('other_desc')
x = Authorresponse(source_id = source_id,
pmid = pmid,
author_email = email,
has_novel_research = has_novel_research,
has_large_scale_data = has_large_scale_data,
has_fast_track_tag = '0',
curator_checked_datasets = '0',
curator_checked_genelist = '0',
no_action_required = '0',
research_results = research_results,
gene_list = gene_list,
dataset_description = dataset_description,
other_description = other_description,
created_by = created_by)
DBSession.add(x)
transaction.commit()
return {'curation_id': 0}
except Exception as e:
transaction.abort()
return HTTPBadRequest(body=json.dumps({'error': "ERROR: " + str(e)}), content_type='text/json')
