def test_complete_studies(self):
ec = Client()
id = 28795402
ncts = [
'NCT00031265', 'NCT02199847', 'NCT00902980', 'NCT01266824',
'NCT03418909'
]
article = ec.efetch(db='pubmed', id=id)
for i, a in enumerate(article):
crud.pubmedarticle_to_db(a, 'systematic_reviews')
for n in ncts[:3]:
crud.review_trial(id, n, False, 'included', 'testuser_1', 1)
for n in ncts[3:]:
crud.review_trial(id, n, False, 'relevant', 'testuser_1', 1)
crud.complete_studies(id, True)
metadata = crud.review_medtadata_db(id)
self.assertEqual(metadata['included_complete'], True)
trials = crud.get_review_trials_fast(id)['reg_trials']
for i, t in enumerate(trials):
if t['nct_id'] in ncts[:3]:
self.assertEqual(trials[i]['verified'], True)
self.assertEqual(trials[i]['relationship'], 'included')
if t['nct_id'] in ncts[3:]:
self.assertEqual(trials[i]['verified'], False)
self.assertEqual(trials[i]['relationship'], 'relevant')
crud.complete_studies(id, False)
trials = crud.get_review_trials_fast(id)['reg_trials']
for i, t in enumerate(trials):
if t['nct_id'] in ncts[:3]:
self.assertEqual(trials[i]['verified'], False)
self.assertEqual(trials[i]['relationship'], 'included')
def test_pubmedarticle_to_db(self):
ec = Client()
ids = [28616955, 28800192, 28797191]
for id in ids:
self.assertIsNone(crud.review_medtadata_db(id))
article = ec.efetch(db='pubmed', id=ids)
for i, a in enumerate(article):
crud.pubmedarticle_to_db(a, 'systematic_reviews')
self.assertIsNotNone(crud.review_medtadata_db(ids[i]))
self.assertEqual(
crud.review_medtadata_db(ids[i])['title'], a.title)
self.assertEqual(
crud.review_medtadata_db(ids[i])['review_id'], int(a.pmid))
self.assertEqual(
crud.review_medtadata_db(ids[i])['abstract'], a.abstract)
self.assertEqual(
crud.review_medtadata_db(ids[i])['source'], a.jrnl)
self.assertEqual(crud.review_medtadata_db(ids[i])['doi'], a.doi)
self.assertEqual(
crud.review_medtadata_db(ids[i])['publish_date'], int(a.year))
self.assertEqual(
crud.review_medtadata_db(ids[i])['authors'],
', '.join(a.authors))
self.assertEqual(
crud.review_medtadata_db(ids[i])['included_complete'], False)
self.assertEqual(
crud.review_medtadata_db(ids[i])['verified_review'], None)
def update_trial_publications(period):
"""
Pull the newest pubmed articles that reference ct.gov IDs and save them to the database
Should be run every period number of days
@param period: number of days back to start search
@return: None
"""
ec = Client(api_key=eutils_key)
base_url = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi'
r = utils.retry_get(base_url,
params={
'db':
'pubmed',
'term':
'clinicaltrials.gov[si]',
'format':
'json',
'retmax':
10000,
'email':
crud.eutils_email,
'tool':
crud.eutils_tool,
'api_key':
eutils_key,
'date_type':
'edat',
'mindate':
(datetime.now().date() -
timedelta(days=period)).strftime('%Y/%m/%d'),
'maxdate':
3000
})
print r.url
json = r.json()
pmids = json['esearchresult']['idlist']
print pmids
segments = utils.chunks(pmids, 100)
for s in segments:
while True:
try:
articles = ec.efetch(db='pubmed', id=s)
break
except (eutils.exceptions.EutilsNCBIError,
eutils.exceptions.EutilsRequestError,
requests.exceptions.SSLError,
requests.exceptions.ConnectionError) as e:
print e
time.sleep(5)
for a in articles:
print a.pmid
if a.nct_ids:
ids = a.nct_ids
crud.pubmedarticle_to_db(a, 'trial_publications')
for id in ids:
crud.publication_trial(a.pmid, id, 9)
def test_pulication_trial(self):
ec = Client()
trialpub_ids = [29871025, 29859785, 29866619]
nct_ids = ['NCT02317328', 'NCT02317874', 'NCT02317887', 'NCT02330055']
trialpubs = ec.efetch(db='pubmed', id=trialpub_ids)
for i, a in enumerate(trialpubs):
crud.pubmedarticle_to_db(a, 'trial_publications')
self.assertIsNone(crud.linked_nctids(a.pmid))
for nct_id in nct_ids:
crud.publication_trial(a.pmid, nct_id, 2)
self.assertEqual(crud.linked_nctids(a.pmid), nct_ids)
def test_check_existing_review_trial(self):
ec = Client()
id = 28934560
nct_id = 'NCT00678431'
article = ec.efetch(db='pubmed', id=id)
for i, a in enumerate(article):
crud.pubmedarticle_to_db(a, 'systematic_reviews')
crud.review_trial(id, nct_id, False, 'relevant', 'testuser_2', 2)
link = crud.check_existing_review_trial(id, nct_id)
self.assertIsNotNone(link)
no_link = crud.check_existing_review_trial(5464824, 'NCT00000000')
self.assertIsNone(no_link)
def test_get_link_id(self):
ec = Client()
id = 28934560
nct_id = 'NCT00678431'
article = ec.efetch(db='pubmed', id=id)
for i, a in enumerate(article):
crud.pubmedarticle_to_db(a, 'systematic_reviews')
crud.review_trial(id, nct_id, False, 'relevant', 'testuser_2', 2)
link_id = crud.get_link_id(nct_id, id)
self.assertIsNotNone(link_id)
no_link = crud.get_link_id('NCT02064179', 28931939)
self.assertIsNone(no_link)
def test_convert_id(self):
ec = Client()
id = 28795402
article = ec.efetch(db='pubmed', id=id)
for i, a in enumerate(article):
crud.pubmedarticle_to_db(a, 'systematic_reviews')
self.assertEqual(crud.convert_id(id, 'doi'), '10.1002/ijc.30922')
self.assertEqual(crud.convert_id('10.1002/ijc.30922', 'pmid'), id)
article = ec.efetch(db='pubmed', id=24829965)
for i, a in enumerate(article):
crud.pubmedarticle_to_db(a, 'systematic_reviews')
self.assertEqual(crud.convert_id(24829965, 'doi'), None)
def test_review_lock_status(self):
ec = Client()
ids = [28616955, 28800192, 28797191]
for id in ids:
self.assertIsNone(crud.review_medtadata_db(id))
article = ec.efetch(db='pubmed', id=ids)
for i, a in enumerate(article):
crud.pubmedarticle_to_db(a, 'systematic_reviews')
self.assertEqual(crud.review_lock_status(ids[i]), False)
crud.complete_studies(ids[i], True)
self.assertEqual(crud.review_lock_status(ids[i]), True)
crud.complete_studies(ids[i], False)
self.assertEqual(crud.review_lock_status(ids[i]), False)
def test_get_review_trials_fast(self):
ec = Client()
id = 28795402
ncts = [
'NCT00031265', 'NCT02199847', 'NCT00902980', 'NCT01266824',
'NCT03418909'
]
article = ec.efetch(db='pubmed', id=id)
for i, a in enumerate(article):
crud.pubmedarticle_to_db(a, 'systematic_reviews')
for n in ncts:
crud.review_trial(id, n, False, 'included', 'testuser_1', 1)
trials = crud.get_review_trials_fast(id)['reg_trials']
retrieved_ncts = [t['nct_id'] for t in trials]
for n in ncts:
self.assertTrue(n in retrieved_ncts)
def test_get_locked(self):
ec = Client()
ids = [28569363, 29202845, 28933578]
for id in ids:
self.assertIsNone(crud.review_medtadata_db(id))
article = ec.efetch(db='pubmed', id=ids)
for i, a in enumerate(article):
crud.pubmedarticle_to_db(a, 'systematic_reviews')
self.assertIsNone(crud.get_locked())
crud.complete_studies(ids[0], True)
self.assertEqual(crud.get_locked(), [ids[0]])
crud.complete_studies(ids[1], True)
self.assertEqual(crud.get_locked(), [ids[0], ids[1]])
crud.complete_studies(ids[2], True)
self.assertEqual(crud.get_locked(), [ids[0], ids[1], ids[2]])
crud.complete_studies(ids[1], False)
self.assertEqual(crud.get_locked(), [ids[0], ids[2]])
def test_review_publication(self):
ec = Client()
trialpub_ids = [29871025, 29859785, 29866619]
review_ids = [28775712, 28549125, 29929949]
trialpubs = ec.efetch(db='pubmed', id=trialpub_ids)
reviews = ec.efetch(db='pubmed', id=review_ids)
for i, a in enumerate(trialpubs):
crud.pubmedarticle_to_db(a, 'trial_publications')
for i, a in enumerate(reviews):
crud.pubmedarticle_to_db(a, 'systematic_reviews')
crud.review_publication(a.pmid, trialpub_ids[i], 1)
conn = self.mock_conn(True)
cur = conn.cursor()
cur.execute(
"SELECT trialpub_id from review_trialpubs where review_id = %s;",
(a.pmid, ))
trialpub = cur.fetchone()
self.assertEqual(trialpub[0], trialpub_ids[i])
conn.close()
def test_vote(self):
ec = Client()
id = 28934560
nct_id = 'NCT00678431'
article = ec.efetch(db='pubmed', id=id)
for i, a in enumerate(article):
crud.pubmedarticle_to_db(a, 'systematic_reviews')
crud.review_trial(id, nct_id, False, 'relevant', 'testuser_2', 2)
link_id = crud.get_link_id(nct_id, id)
crud.vote(link_id, 'up', 1)
trials = crud.get_review_trials_fast(id)['reg_trials']
for i, t in enumerate(trials):
if t['nct_id'] == nct_id:
self.assertEqual(trials[i]['nct_id'], nct_id)
self.assertEqual(trials[i]['upvotes'], 2)
self.assertEqual(set(trials[i]['voters'].split(', ')),
{'testuser_2', 'testuser_1'})
self.assertEqual(trials[i]['downvotes'], 0)
self.assertEqual(trials[i]['verified'], False)
self.assertEqual(trials[i]['relationship'], 'relevant')
def test_add_trial_to_locked(self):
ec = Client()
ids = [28616955, 28800192, 28797191]
nct_ids = ['NCT00195624', 'NCT00200889', 'NCT00207688']
test_nct = 'NCT00695409'
for id in ids:
self.assertIsNone(crud.review_medtadata_db(id))
article = ec.efetch(db='pubmed', id=ids)
for i, a in enumerate(article):
crud.pubmedarticle_to_db(a, 'systematic_reviews')
crud.review_trial(ids[i], nct_ids[i], False, 'included',
'testuser_1', 1, 'up')
crud.complete_studies(ids[i], True)
crud.review_trial(ids[i], test_nct, False, 'included',
'testuser_1', 1, 'up')
self.assertIsNone(
crud.check_existing_review_trial(ids[i], test_nct))
crud.complete_studies(ids[i], False)
crud.review_trial(ids[i], test_nct, False, 'included',
'testuser_1', 1, 'up')
self.assertIsNotNone(
crud.check_existing_review_trial(ids[i], test_nct))
def update_trial_publications(period):
"""
Pull the newest pubmed articles that reference ct.gov IDs and save them to the database
Should be run every period number of days
@param period: number of days back to start search
@return: None
"""
# edge cases
# 32601120 NCT0282152 -- nct given with missing digit
# 31899823 NCT00020085 -- nct is an alias for NCT00004635
ec = Client(api_key=eutils_key)
pmids = []
page = 0
print('update_trial_publications, gathering pmids')
base_url = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi'
while True:
r = utils.retry_get(base_url,
params={
'db':
'pubmed',
'term':
'clinicaltrials.gov[si]',
'format':
'json',
'retmax':
10000,
'retstart':
page * 10000,
'email':
crud.eutils_email,
'tool':
crud.eutils_tool,
'api_key':
eutils_key,
'date_type':
'edat',
'mindate':
(datetime.now() -
timedelta(days=period)).strftime('%Y/%m/%d'),
'maxdate':
3000
})
if not r:
break
json = r.json()
current_pmids = json['esearchresult']['idlist']
if not current_pmids or len(current_pmids) == 0:
break
pmids = pmids + current_pmids
print('page %s, pmid count: %s' % (page, len(pmids)))
page += 1
segments = utils.chunks(pmids, 100)
for s in segments:
while True:
try:
articles = ec.efetch(db='pubmed', id=s)
# articles = ec.efetch(db='pubmed', id=[31335881])
break
except (eutils.EutilsNCBIError, eutils.EutilsRequestError,
requests.exceptions.SSLError,
requests.exceptions.ConnectionError) as e:
print(e)
time.sleep(5)
for a in articles:
xpath = 'MedlineCitation/Article/DataBankList/DataBank[DataBankName = "ClinicalTrials.gov"]/AccessionNumberList/AccessionNumber/text()'
nct_ids = a._xml_root.xpath(xpath)
print('nct_ids found for pmid %s = [%s]' %
(a.pmid, ', '.join(nct_ids)))
if len(nct_ids) > 0:
crud.pubmedarticle_to_db(a, 'trial_publications')
for nct_id in nct_ids:
if len(nct_id) != 11:
print(
'##WARNING!: ignoring %s (%s) - not the expected 11 chars long, possible missing digit'
% (nct_id, a.pmid))
continue
crud.publication_trial(a.pmid, nct_id, 9)
def populate_reviews(period):
""" download all new reviews made available on pubmed in the last <period> # days & save to db if they have trials in
CrossRef or Cochrane """
base_url = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi'
r = utils.requests_retry_session().get(
base_url,
params={
'db':
'pubmed',
'term':
'systematic review[ti] OR meta analysis[ti] OR cochrane database of systematic reviews[ta]',
'format':
'json',
'retmax':
300000,
'email':
crud.eutils_email,
'tool':
crud.eutils_tool,
'api_key':
eutils_key,
'date_type':
'edat',
'mindate': (datetime.now().date() -
timedelta(days=period)).strftime('%Y/%m/%d'),
'maxdate':
'3000'
})
json = r.json()
pmids = json['esearchresult']['idlist']
print len(pmids)
segments = utils.chunks(pmids, 100)
ec = Client(api_key=eutils_key)
for s in segments:
while True:
try:
articles = ec.efetch(db='pubmed', id=s)
break
except (eutils.exceptions.EutilsNCBIError,
eutils.exceptions.EutilsRequestError,
requests.exceptions.SSLError,
requests.exceptions.ConnectionError) as e:
print e
time.sleep(5)
a_iter = iter(articles)
while True:
try:
article = a_iter.next()
except StopIteration:
break
print '-----------------' + article.pmid + '-------------------------'
if article.doi is not None:
ids = bot.check_trialpubs_nctids(article.pmid, article.doi)
else:
ids = bot.check_trialpubs_nctids(article.pmid)
if ids:
if ids.pmids:
print ids.pmids
count = crud.articles_with_nctids(
tuple(x for x in ids.pmids))
print count
if count and len(count) > 0:
print 'articles with links = ' + str(len(count))
print 'inserting ' + str(article.pmid)
crud.pubmedarticle_to_db(article, 'systematic_reviews')
for trialpub in count:
crud.review_publication(article.pmid, trialpub, 9)
linked_ncts = crud.linked_nctids(trialpub)
for nct in linked_ncts:
crud.review_trial(article.pmid,
nct,
False,
'included',
user_id=9,
nickname='crossrefbot')
if ids.nctids:
crud.pubmedarticle_to_db(article, 'systematic_reviews')
print 'nct ids in crossref = ' + str(len(ids.nctids))
for nct_id in ids.nctids:
crud.review_trial(article.pmid, nct_id, False,
'included', 'crossrefbot', 9)
if not ids.nctids and not ids.pmids:
print 'found nothing'
else:
print 'nothing'
if 'Cochrane' in article.jrnl:
print 'Cochrane'
crud.pubmedarticle_to_db(article, 'systematic_reviews')
bot.cochranebot(article.doi, article.pmid)
bot.cochrane_ongoing_excluded(article.doi, article.pmid)
conn = dblib.create_con(VERBOSE=True)
cur = conn.cursor(cursor_factory=psycopg2.extras.DictCursor)
cur.execute(
"select rt.review_id, json_agg(distinct v.user_id) as users from review_rtrial rt"
" inner join votes v on rt.id = v.link_id where rt.review_id = %s group by"
" rt.review_id;", (article.pmid, ))
new_users = cur.fetchone()
if not new_users:
new_users = {'users': []}
if not {17, 9} & set(new_users['users']):
print 'deleting ' + str(new_users['users']), article.pmid
cur.execute(
"delete from votes where link_id in (select id from review_rtrial where review_id = %s);",
(article.pmid, ))
conn.commit()
cur.execute(
"delete from review_trialpubs where review_id = %s;",
(article.pmid, ))
conn.commit()
cur.execute(
"delete from review_rtrial where review_id = %s;",
(article.pmid, ))
conn.commit()
cur.execute(
"delete from systematic_reviews where review_id = %s;",
(article.pmid, ))
conn.commit()
conn.close()
else:
print 'not cochrane'
def search(json):
"""
conduct a search
@param json: JSON object specifying serch keywords
"""
id = json['review_id']
emit('search_update', {'msg': 'Searching...'}, room=request.sid)
eventlet.sleep(0)
if not id:
emit('page_content', {
'section': 'no_results',
'data': render_template('noresults.html', id=id)
},
room=request.sid)
return
conn = dblib.create_con(VERBOSE=True)
cur = conn.cursor(cursor_factory=psycopg2.extras.DictCursor)
# try to retrieve review with matching PMID if id is int
review = ''
found = True
if (utils.RepresentsInt(id)):
review = crud.review_medtadata_db(id)
# try to retrieve review with matching DOI if id is DOI
elif utils.is_doi(id):
cur.execute("SELECT * FROM systematic_reviews WHERE doi = %s;", (id, ))
review = cur.fetchone()
conn.close()
# if not int or DOI, return no results page
else:
conn.close()
emit('search_update',
{'msg': 'Searching for keyword matches in our database'},
room=request.sid)
search_result = request_data.advanced_search(id)
if not search_result:
emit('page_content', {
'section': 'no_results',
'data': render_template('noresults.html', id=id)
},
room=request.sid)
return
emit('page_content', {
'section':
'search_results',
'data':
render_template(
'searchresult.html', reviews=search_result, searchterm=id)
},
room=request.sid)
return
# if there is no match in our DB
if review is None:
found = False
if not current_user.is_authenticated:
conn.close()
emit('page_content', {
'section': 'no_results',
'data': render_template('noresults.html', id=id)
},
room=request.sid)
return
emit('search_update', {
'msg': 'Not found in local database. Searching PubMed for article'
},
room=request.sid)
eventlet.sleep(0)
if utils.is_doi(id):
# try to retrieve PMID if DOI
convert = crud.convert_id(id, 'pmid')
if convert:
id = convert
# return no result if no results
else:
emit('search_update', {'msg': 'Not found in Pubmed :('},
room=request.sid)
emit('page_content', {
'section': 'no_results',
'data': render_template('noresults.html', id=id)
},
room=request.sid)
return
# try to retrieve the review from pubmed
ec = Client(api_key=eutils_key)
article = ec.efetch(db='pubmed', id=id)
found_review = None
for art in article:
if art and str(art.pmid) == id:
found_review = art
break
if found_review:
result = found_review.pmid
if not result:
flash(
'Unable to retrieve metadata for this article. Please try again later'
)
abort(404)
emit('search_update',
{'msg': 'Found article on PubMed. Downloading metadata...'},
room=request.sid)
eventlet.sleep(0)
crud.pubmedarticle_to_db(found_review, 'systematic_reviews')
review = crud.review_medtadata_db(id)
emit('page_content', {
'data': render_template('review_data.html', review=review),
'section': 'review_data'
},
room=request.sid)
eventlet.sleep(0)
emit('search_update', {'msg': 'Saved metadata... triggering bots'},
room=request.sid)
bot.docsim.delay(id, sess_id=request.sid)
eventlet.sleep(0)
if 'cochrane' in review['source'].lower() and 'doi' in review:
cb_bb = bot.cochrane_ongoing_excluded.si(review['doi'],
id,
sess_id=request.sid)
cb_bb.link(bot.basicbot2.si(review_id=id, sess_id=request.sid))
chord(
(bot.cochranebot.s(review['doi'], id, sess_id=request.sid),
bot.check_citations.s(id, sess_id=request.sid)),
cb_bb).delay()
else:
chord((bot.check_citations.s(id, sess_id=request.sid)),
bot.basicbot2.si(review_id=id,
sess_id=request.sid)).delay()
else:
print 'no result'
emit('page_content', {
'section': 'no_results',
'data': render_template('noresults.html', id=id)
},
room=request.sid)
return
# if there IS a match in our DB
if found:
print 'emitting found review'
eventlet.sleep(0)
emit('search_update',
{'msg': 'Found review in our database! Retrieving data..'},
room=request.sid)
eventlet.sleep(0)
print 'emitting review content'
emit('page_content', {
'data':
render_template('review_data.html',
review=review,
starred=crud.is_starred(review['review_id'],
current_user.db_id)
if current_user.is_authenticated else False),
'section':
'review_data',
'related_reviews':
render_template('related_reviews.html',
related_reviews=crud.related_reviews(
review['review_id']))
},
room=request.sid)
eventlet.sleep(0)
trials = crud.get_review_trials_fast(
review[0],
usr=current_user if current_user.is_authenticated else None)
relevant = [
trial['nct_id'] for trial in trials['reg_trials']
if trial['relationship'] == 'relevant'
]
verified = [
trial['nct_id'] for trial in trials['reg_trials']
if trial['relationship'] == 'included'
]
emit('search_update', {'msg': 'Generating cool plots...'},
room=request.sid)
eventlet.sleep(0)
formatted = utils.trials_to_plotdata(trials['reg_trials'])
socketio.emit('page_content', {
'section': 'plot',
'data': formatted,
'page': 'reviewdetail',
'review_id': review[0]
},
room=request.sid)
emit('page_content', {
'section':
'rel_trials',
'data':
render_template('rel_trials.html',
reg_trials=trials['reg_trials'],
locked=review['included_complete'])
},
room=request.sid)
eventlet.sleep(0)
if verified:
emit('page_content', {
'section':
'incl_trials',
'data':
render_template('incl_trials.html',
reg_trials=trials['reg_trials'],
locked=review['included_complete'])
},
room=request.sid)
eventlet.sleep(0)
else:
emit('page_content', {
'section':
'incl_trials',
'data':
render_template(
'incl_trials.html', reg_trials=[], locked=False)
},
room=request.sid)
def test_review_trial(self):
ec = Client()
id = 28616955
nct_ids = ['NCT00195624', 'NCT00200889', 'NCT00207688']
article = ec.efetch(db='pubmed', id=id)
for i, a in enumerate(article):
crud.pubmedarticle_to_db(a, 'systematic_reviews')
self.assertEqual(len(crud.get_review_trials_fast(id)['reg_trials']), 0)
# trial is inserted with correct values
crud.review_trial(id, nct_ids[0], False, 'relevant', 'testuser_1', 1)
trials = crud.get_review_trials_fast(id)['reg_trials']
for i, t in enumerate(trials):
if t['nct_id'] == nct_ids[0]:
self.assertEqual(trials[i]['nct_id'], nct_ids[0])
self.assertEqual(trials[i]['upvotes'], 1)
self.assertEqual(trials[i]['downvotes'], 0)
self.assertEqual(trials[i]['voters'], 'testuser_1')
self.assertEqual(trials[i]['verified'], False)
self.assertEqual(trials[i]['relationship'], 'relevant')
# when the trial is added again by another user, it should recieve an upvote
crud.review_trial(id, nct_ids[0], False, 'relevant', 'testuser_2', 2)
trials = crud.get_review_trials_fast(id)['reg_trials']
for i, t in enumerate(trials):
if t['nct_id'] == nct_ids[0]:
self.assertEqual(trials[i]['nct_id'], nct_ids[0])
self.assertEqual(trials[i]['upvotes'], 2)
self.assertEqual(set(trials[i]['voters'].split(', ')),
{'testuser_1', 'testuser_2'})
self.assertEqual(trials[i]['downvotes'], 0)
self.assertEqual(trials[i]['verified'], False)
self.assertEqual(trials[i]['relationship'], 'relevant')
# adding an existing trial from the relevant column as included will move it
crud.review_trial(id, nct_ids[0], False, 'included', 'testuser_2', 2)
trials = crud.get_review_trials_fast(id)['reg_trials']
for i, t in enumerate(trials):
if t['nct_id'] == nct_ids[0]:
self.assertEqual(trials[i]['nct_id'], nct_ids[0])
self.assertEqual(trials[i]['upvotes'], 2)
self.assertEqual(set(trials[i]['voters'].split(', ')),
{'testuser_1', 'testuser_2'})
self.assertEqual(trials[i]['downvotes'], 0)
self.assertEqual(trials[i]['verified'], False)
self.assertEqual(trials[i]['relationship'], 'included')
# test included trial
crud.review_trial(id, nct_ids[1], False, 'included', 'testuser_2', 2)
trials = crud.get_review_trials_fast(id)['reg_trials']
for i, t in enumerate(trials):
if t['nct_id'] == nct_ids[1]:
self.assertEqual(trials[i]['nct_id'], nct_ids[1])
self.assertEqual(trials[i]['upvotes'], 1)
self.assertEqual(trials[i]['voters'], 'testuser_2')
self.assertEqual(trials[i]['downvotes'], 0)
self.assertEqual(trials[i]['verified'], False)
self.assertEqual(trials[i]['relationship'], 'included')
# trying to insert a relevant trial when it's already included will give a vote but not move the trial
crud.review_trial(id, nct_ids[1], False, 'relevant', 'testuser_1', 1)
trials = crud.get_review_trials_fast(id)['reg_trials']
for i, t in enumerate(trials):
if t['nct_id'] == nct_ids[1]:
self.assertEqual(trials[i]['nct_id'], nct_ids[1])
self.assertEqual(trials[i]['upvotes'], 2)
self.assertEqual(set(trials[i]['voters'].split(', ')),
{'testuser_1', 'testuser_2'})
self.assertEqual(trials[i]['downvotes'], 0)
self.assertEqual(trials[i]['verified'], False)
self.assertEqual(trials[i]['relationship'], 'included')
# except for user_id 17 which can move included to relevant
crud.review_trial(id,
nct_ids[1],
False,
'relevant',
'cochranebot',
17,
vote_type='down')
trials = crud.get_review_trials_fast(id)['reg_trials']
for i, t in enumerate(trials):
if t['nct_id'] == nct_ids[1]:
self.assertEqual(trials[i]['nct_id'], nct_ids[1])
self.assertEqual(trials[i]['upvotes'], 2)
self.assertEqual(set(trials[i]['voters'].split(', ')),
{'cochranebot', 'testuser_1', 'testuser_2'})
self.assertEqual(trials[i]['downvotes'], 1)
self.assertEqual(trials[i]['verified'], False)
self.assertEqual(trials[i]['relationship'], 'relevant')
# if the review is locked and the trial is included, allow a vote
crud.review_trial(id, nct_ids[2], False, 'included', 'testuser_1', 1)
crud.complete_studies(id, True)
crud.review_trial(id, nct_ids[2], False, 'included', 'testuser_2', 2)
trials = crud.get_review_trials_fast(id)['reg_trials']
for i, t in enumerate(trials):
if t['nct_id'] == nct_ids[2]:
self.assertEqual(trials[i]['nct_id'], nct_ids[2])
self.assertEqual(trials[i]['upvotes'], 2)
self.assertEqual(set(trials[i]['voters'].split(', ')),
{'testuser_1', 'testuser_2'})
self.assertEqual(trials[i]['downvotes'], 0)
self.assertEqual(trials[i]['verified'], True)
self.assertEqual(trials[i]['relationship'], 'included')