def test_build_url_article_without_eloaction_param(self):
del (self.dict_leg['suppl_number']) # Remove the suppl_number
del (self.dict_leg['article_id'])
leg = URLegendarium(**self.dict_leg)
self.assertEqual(u'spm/2011.v67n9/154-200', leg.url_article)
def fmt_csv(self, data):
line = [
data.collection_acronym, data.publisher_id, data.journal.title,
data.journal.acronym, data.issue.volume, data.issue.number,
(data.issue.supplement_volume or '') +
(data.issue.supplement_number or ''), data.publication_date[:4],
data.start_page or '', data.start_page_sequence or '',
data.end_page or '', data.elocation or ''
]
# legendarium natural_url
natural_url = URLegendarium(
data.journal.acronym,
data.publication_date[:4],
data.issue.volume,
data.issue.number,
data.start_page or '',
data.start_page_sequence or '',
data.end_page or '',
data.elocation or '',
(data.issue.supplement_volume or '') +
(data.issue.supplement_number or ''),
).url_article
natural_key = self.build_key(line[3:])
line.append(natural_key)
line.append(natural_url)
joined_line = ','.join(['"%s"' % i.replace('"', '""') for i in line])
return joined_line
def test_build_url_issue_supplment_volume(self):
del (self.dict_leg['number']) # Remove the number
leg = URLegendarium(**self.dict_leg)
self.assertEqual(u'spm/2011.v67suppl3', leg.url_issue)
def url(self):
leg_dict = {
'acron': self.journal.acronym,
'year_pub': self.year
}
return URLegendarium(**leg_dict).url_journal
def test_build_url_article_with_sequence(self):
del (self.dict_leg['article_id'])
self.dict_leg['fpage_sequence'] = 1
leg = URLegendarium(**self.dict_leg)
self.assertEqual(u'spm/2011.v67n9suppl3/154_1-200', str(leg))
def test_build_url_journal_without_acron_param(self):
del (self.dict_leg['acron']) # Remove the acron
leg = URLegendarium(**self.dict_leg)
self.assertRaises(ValueError, lambda: leg.url_journal)
def url_last_issue(self):
leg_dict = {'acron': self.acronym,
'year_pub': self.last_issue.year,
'volume': self.last_issue.volume,
'number': self.last_issue.number,
'suppl_number': self.last_issue.suppl_text}
return URLegendarium(**leg_dict).url_issue
def pre_save(cls, sender, document, **kwargs):
leg_dict = {
'year_pub': document.year,
'volume': document.volume,
'number': document.number,
'suppl_number': document.suppl_text
}
document.url_segment = URLegendarium(**leg_dict).get_issue_seg()
def fmt_json(self, data):
item = {
'collection_acronym':
data.collection_acronym,
'publisher_id':
data.publisher_id,
'journal_title':
data.journal.title,
'journal_acronym':
data.journal.acronym,
'volume':
data.issue.volume,
'number':
data.issue.number,
'supplement': (data.issue.supplement_volume or '') +
(data.issue.supplement_number or ''),
'publication_year':
data.publication_date[:4],
'first_page':
data.start_page or '',
'first_page_seq':
data.start_page_sequence or '',
'last_page':
data.end_page or '',
'elocation':
data.elocation or '',
'doi':
data.doi or '',
'order':
data.internal_sequence_id or ''
}
# legendarium natural_url
natural_url = URLegendarium(item['journal_acronym'],
item['publication_year'], item['volume'],
item['number'], item['first_page'],
item['first_page_seq'], item['last_page'],
item['elocation'], item['supplement'],
item['doi'], item['order']).url_article
natural_key = self.build_key([
item['journal_acronym'],
item['volume'],
item['number'],
item['supplement'],
item['publication_year'],
item['first_page'],
item['first_page_seq'],
item['last_page'],
item['elocation'],
])
item['natural_key'] = natural_key
item['natural_url'] = natural_url
return json.dumps(item)
def test_build_url_issue_without_year_vol_num_param(self):
del (self.dict_leg['year_pub']) # Remove the year_pub
del (self.dict_leg['volume']) # Remove the volume
del (self.dict_leg['number']) # Remove the number
del (self.dict_leg['suppl_number']) # Remove the suppl_number
leg = URLegendarium(**self.dict_leg)
self.assertRaises(ValueError, lambda: leg.url_issue)
def url(self):
leg_dict = {
'acron': self.journal.acronym,
'year_pub': self.year,
'volume': self.volume,
'number': self.number,
'suppl_number': self.suppl_text
}
return URLegendarium(**leg_dict).url_issue
def url_next_journal(self):
url_next_journal = ""
if self.next_title:
next_journal = self.__class__.objects(
title_slug=slugify(self.next_title)
).first()
if next_journal:
url_next_journal = URLegendarium(**{'acron': next_journal.acronym}).get_journal_seg()
return url_next_journal
def url_previous_journal(self):
url_previous_journal = ""
if self.previous_journal_ref:
previous_journal = self.__class__.objects(
title_slug=slugify(self.previous_journal_ref)
).first()
if previous_journal:
url_previous_journal = URLegendarium(**{'acron': previous_journal.acronym}).get_journal_seg()
return url_previous_journal
def test_build_url_article_with_order_param(self):
del (self.dict_leg['suppl_number']) # Remove the suppl_number
del (self.dict_leg['article_id'])
del (self.dict_leg['lpage'])
del (self.dict_leg['fpage'])
self.dict_leg['order'] = '5'
leg = URLegendarium(**self.dict_leg)
self.assertEqual(u'spm/2011.v67n9/o5', leg.url_article)
def test_build_url_article_with_doi_param(self):
del (self.dict_leg['suppl_number']) # Remove the suppl_number
del (self.dict_leg['article_id'])
del (self.dict_leg['lpage'])
del (self.dict_leg['fpage'])
self.dict_leg['doi'] = '10.1590/0102-6720201600S10001'
leg = URLegendarium(**self.dict_leg)
self.assertEqual(u'spm/2011.v67n9/10.1590/0102-6720201600S10001',
leg.url_article)
def pre_save(cls, sender, document, **kwargs):
leg_dict = {
'acron': document.journal.acronym,
'year_pub': document.issue.year,
'volume': document.issue.volume,
'number': document.issue.number,
'suppl_number': document.issue.suppl_text,
'fpage': document.fpage,
'lpage': document.lpage,
'article_id': document.elocation,
'doi': document.doi,
'order': str(document.order)
}
document.url_segment = URLegendarium(**leg_dict).get_article_seg()
def fix_journal_last_issue(journal):
"""
Resolve ausência de preenchimento do atributo `LastIssue.url_segment`
Teoricamente, o atributo `LastIssue.url_segment` deveria ter sido preenchido
ao registrar os issues e/ou o journal no website. Mas no fluxo SPF,
não ocorreu.
"""
if journal.last_issue is None or journal.last_issue.url_segment:
return journal.last_issue
leg_dict = {
'year_pub': journal.last_issue.year,
'volume': journal.last_issue.volume,
'number': journal.last_issue.number,
'suppl_number': journal.last_issue.suppl_text
}
journal.last_issue.url_segment = URLegendarium(**leg_dict).get_issue_seg()
return journal.last_issue
def eligible_match_keys(document):
keys = []
keys.append(document.publisher_id)
keys.append(fbpe_key(document.publisher_id))
if document.doi:
keys.append(document.doi)
keys += pdf_keys(document.fulltexts())
suppl = ''.join([document.issue.supplement_volume or '', document.issue.supplement_number or '']).strip()
try:
leg = URLegendarium(
acron=document.journal.acronym,
year_pub=document.publication_date[:4],
volume=document.issue.volume,
number=document.issue.number,
fpage=document.start_page,
fpage_sequence=document.start_page_sequence,
lpage=document.end_page,
article_id=document.elocation,
suppl_number=suppl,
doi=document.doi,
order=document.issue.order
)
except ValueError as e:
logger.error(
'Fail to build legendarium eligible match key for %s_%s',
document.collection_acronym, document.publisher_id
)
logger.exception(e)
leg = ''
url_code = '/%s/' % leg.url_article if leg else ''
if url_code:
keys.append(url_code.upper())
return keys
def test_build_url_issue_supplment_number(self):
leg = URLegendarium(**self.dict_leg)
self.assertEqual(u'spm/2011.v67n9suppl3', leg.url_issue)
def pre_save(cls, sender, document, **kwargs):
document.title_slug = slugify(document.title)
leg_dict = {'acron': document.acronym}
document.url_segment = URLegendarium(**leg_dict).get_journal_seg()
def test_build_url_journal_with_all_param(self):
leg = URLegendarium(**self.dict_leg)
self.assertEqual(u'spm/', leg.url_journal)
def test_build_url_article_with_all_param(self):
del (self.dict_leg['suppl_number']) # Remove the suppl_number
leg = URLegendarium(**self.dict_leg)
self.assertEqual(u'spm/2011.v67n9/e00120416', leg.url_article)
