def update_report(self):
all_msg = []
for name, allowed in self.pkg_validations.allowed_to_update.items():
msg = []
if self.pkg_validations.allowed_to_update[name] is False:
msg.append(html_reports.p_message(self.pkg_validations.evaluate_changes[name] + ': ' + _('{item} is not allowed to be updated.').format(item=name)))
# allowed to update
order_change = self.pkg_validations.changed_orders.get(name)
if order_change is not None:
# order change
if order_change[1] in self.pkg_validations.rejected_order_change.keys():
# order change is rejected
msg.append(html_reports.p_message(validation_status.STATUS_FATAL_ERROR + ': ' + _('{new_order} is being assign to more than one file: {files}').format(new_order=order_change[1], files=', '.join(self.pkg_validations.rejected_order_change[order_change[1]]))))
else:
# order change is acceptable
msg.append(html_reports.p_message(validation_status.STATUS_WARNING + ': ' + _('order changed: {old} => {new}').format(old=order_change[0], new=order_change[1])))
if len(self.pkg_validations.relaxed_comparison[name]) > 0:
msg.append(html_reports.p_message(self.pkg_validations.evaluate_changes[name] + ': ' + _('{item} contains too many differences. It seems {item} in the package is very different from the one previously published.').format(item=name)))
if len(self.pkg_validations.exact_comparison[name]) > 0:
#self.evaluate_changes[name]
msg.append(html_reports.tag('h5', _('Previously registered:')))
for label, differences in self.pkg_validations.exact_comparison[name]:
msg.append(html_reports.tag('p', differences[1]))
msg.append(html_reports.tag('h5', _('Update:')))
for label, differences in self.pkg_validations.exact_comparison[name]:
msg.append(html_reports.tag('p', differences[0]))
if len(msg) > 0:
all_msg.append(html_reports.tag('h4', name))
all_msg.append('<div class="issue-problem">')
all_msg.append(''.join(msg))
all_msg.append('</div>')
return ''.join(all_msg)
def display_article_data_to_compare(_article):
r = ''
style = 'excluded' if _article.is_ex_aop else None
status = validation_status.STATUS_INFO + ': ' + _('This article is an ex-aop article. ') + _('Order of ex-aop is reserved, it is not allowed to reuse it for other article. ') if _article.is_ex_aop else ''
r += html_reports.p_message(status)
r += display_article_metadata(_article, '<br/>')
return html_reports.tag('div', r, style)
def conclusion_message(self):
text = ''.join(self.error_messages)
app_site = converter_env.web_app_site if converter_env.web_app_site is not None else _('scielo web site')
status = ''
result = _('updated/published on {app_site}').format(app_site=app_site)
reason = ''
update = True
if self.xc_status == 'rejected':
update = False
status = validation_status.STATUS_BLOCKING_ERROR
if self.total_to_convert > 0:
if self.total_not_converted > 0:
reason = _('because it is not complete ({value} were not converted). ').format(value=str(self.total_not_converted) + '/' + str(self.total_to_convert))
else:
reason = _('because there are blocking errors in the package. ')
else:
reason = _('because there are blocking errors in the package. ')
elif self.xc_status == 'ignored':
update = False
reason = _('because no document has changed. ')
elif self.xc_status == 'accepted':
status = validation_status.STATUS_WARNING
reason = _(' even though there are some fatal errors. Note: These errors must be fixed in order to have good quality of bibliometric indicators and services. ')
elif self.xc_status == 'approved':
status = validation_status.STATUS_OK
reason = ''
else:
status = validation_status.STATUS_FATAL_ERROR
reason = _('because there are blocking errors in the package. ')
action = _('will not be')
if update:
action = _('will be')
text = u'{status}: {issueid} {action} {result} {reason}'.format(status=status, issueid=self.acron_issue_label, result=result, reason=reason, action=action)
text = html_reports.p_message(_('converted') + ': ' + str(self.total_converted) + '/' + str(self.total_to_convert), False) + html_reports.p_message(text, False)
return text
def conclusion_message(total, converted, not_converted, xc_status, acron_issue_label):
app_site = converter_env.web_app_site if converter_env.web_app_site is not None else _('scielo web site')
status = ''
action = ''
result = _('be updated/published on ') + app_site
reason = ''
if xc_status == 'rejected':
action = _(' not')
status = validation_status.STATUS_FATAL_ERROR
if total > 0:
if not_converted > 0:
reason = _('because it is not complete (') + str(not_converted) + '/' + str(total) + _(' were not converted).')
else:
reason = _('unknown')
else:
reason = _('because there are blocking errors in the package.')
elif xc_status == 'ignored':
action = _(' not')
reason = _('because no document was changed.')
elif xc_status == 'accepted':
status = validation_status.STATUS_WARNING
reason = _(' even though there are some fatal errors. Note: These errors must be fixed in order to have good quality of bibliometric indicators and services.')
elif xc_status == 'approved':
status = validation_status.STATUS_OK
reason = ''
else:
status = validation_status.STATUS_FATAL_ERROR
reason = _('because there are blocking errors in the package.')
text = status + ': ' + acron_issue_label + _(' will') + action + ' ' + result + ' ' + reason
text = html_reports.tag('h2', _('Summary report')) + html_reports.p_message(_('converted') + ': ' + str(converted) + '/' + str(total), False) + html_reports.p_message(text, False)
return text
def rejected_order_changes(self):
error_messages = []
if len(self.pkg_validations.rejected_order_change) > 0:
error_messages.append(html_reports.tag('h3', _('rejected orders')))
error_messages.append('<div class="issue-problem">')
error_messages.append(html_reports.p_message(validation_status.STATUS_FATAL_ERROR + ': ' + _('It is not allowed to use same order for different articles.')))
for order, items in self.pkg_validations.rejected_order_change.items():
error_messages.append(html_reports.tag('p', html_reports.format_html_data({order:items})))
error_messages.append('</div>')
return ''.join(error_messages)
def display_item(self, item):
return html_reports.p_message(item, False)
def register_log(message):
if not '<' in message:
message = html_reports.p_message(message, False)
converter_report_lines.append(message)
def convert_package(src_path):
xc_conclusion_msg = ''
pkg_xml_fatal_errors = 0
xc_results_report = ''
aop_results_report = ''
before_conversion_report = ''
after_conversion_report = ''
registered_scilista_item = None
report_components = {}
scilista_items = []
xc_status = 'not processed'
is_db_generation = True
converted = 0
not_converted = 0
total = 0
dtd_files = xml_versions.DTDFiles('scielo', converter_env.version)
pkg_name = os.path.basename(src_path)[:-4]
if not os.path.isdir('./../log'):
os.makedirs('./../log')
log_package = './../log/' + datetime.now().isoformat().replace(':', '_') + os.path.basename(pkg_name)
fs_utils.append_file(log_package, 'preparing')
tmp_report_path, wrk_path, pkg_path, tmp_result_path = package_paths_preparation(src_path)
final_result_path = tmp_result_path
final_report_path = tmp_report_path
fs_utils.append_file(log_package, 'normalized_package')
pkg_articles, doc_file_info_items = normalized_package(src_path, tmp_report_path, wrk_path, pkg_path, converter_env.version)
pkg = pkg_reports.PkgArticles(pkg_articles, pkg_path)
journals_list = xc_models.JournalsList()
journal = journals_list.get_journal(pkg.pkg_p_issn, pkg.pkg_e_issn, pkg.pkg_journal_title)
fs_utils.append_file(log_package, 'identify_issue')
issue_error_msg = pkg.identify_issue(converter_env.db_manager, pkg_name)
#FIXME
issue = None
fs_utils.append_file(log_package, 'pkg.xml_list()')
report_components['xml-files'] = pkg.xml_list()
scilista_items.append(pkg.acron_issue_label)
if issue_error_msg is not None:
xc_status = 'rejected'
report_components['issue-report'] = issue_error_msg
else:
fs_utils.append_file(log_package, 'db_article')
db_article = xc_models.ArticleDB(converter_env.db_manager.db_isis, pkg.issue_files, xc_models.AopManager(converter_env.db_manager.db_isis, pkg.issue_files.journal_files))
conversion = Conversion(pkg, db_article)
fs_utils.append_file(log_package, 'conversion.evaluate_pkg_and_registered_items')
conversion.evaluate_pkg_and_registered_items(converter_env.skip_identical_xml)
pkg_validator = pkg_reports.ArticlesPkgReport(tmp_report_path, pkg, journal, issue, conversion.previous_registered_articles, is_db_generation)
pkg_validator.xc_validations = conversion.xc_validations
fs_utils.append_file(log_package, 'pkg_validator.overview_report()')
report_components['pkg_overview'] = pkg_validator.overview_report()
fs_utils.append_file(log_package, 'pkg_validator.references_overview_report()')
report_components['pkg_overview'] += pkg_validator.references_overview_report()
fs_utils.append_file(log_package, 'pkg_validator.sources_overview_report()')
report_components['references'] = pkg_validator.sources_overview_report()
fs_utils.append_file(log_package, 'pkg_validator.issue_report')
report_components['issue-report'] = pkg_validator.issue_report
conversion.blocking_errors = pkg_validator.blocking_errors
fs_utils.append_file(log_package, 'conversion.initial_status_report')
before_conversion_report = conversion.initial_status_report()
if conversion.blocking_errors == 0:
fs_utils.append_file(log_package, 'pkg_validator.validate_articles_pkg_xml_and_data')
pkg_validator.validate_articles_pkg_xml_and_data(doc_file_info_items, dtd_files, False, conversion.selected_articles.keys())
pkg_xml_fatal_errors = pkg_validator.pkg_xml_structure_validations.fatal_errors + pkg_validator.pkg_xml_content_validations.fatal_errors
fs_utils.append_file(log_package, 'pkg_validator.detail_report')
report_components['detail-report'] = pkg_validator.detail_report()
fs_utils.append_file(log_package, 'conversion.convert_articles')
registered_scilista_item = conversion.convert_articles(pkg_validator)
fs_utils.append_file(log_package, 'conversion.pkg_xc_validations.report')
report_components['conversion-report'] = conversion.pkg_xc_validations.report()
if conversion.pkg_xc_validations.fatal_errors == 0:
after_conversion_report = conversion.final_status_report()
fs_utils.append_file(log_package, 'Conversion results')
xc_results_report = report_status(_('Conversion results'), conversion.conversion_status, 'conversion')
fs_utils.append_file(log_package, 'AOP status')
aop_results_report = report_status(_('AOP status'), conversion.db.aop_manager.aop_sorted_by_status, 'aop-block')
if len(aop_results_report) == 0:
aop_results_report = _('this journal has no aop.')
final_report_path = pkg.issue_files.base_reports_path
final_result_path = pkg.issue_files.issue_path
if registered_scilista_item is not None:
fs_utils.append_file(log_package, 'pkg.issue_files.copy_files_to_local_web_app()')
pkg.issue_files.copy_files_to_local_web_app()
fs_utils.append_file(log_package, 'xc_status = get_xc_status()')
xc_status = get_xc_status(registered_scilista_item, conversion.pkg_xc_validations.fatal_errors, pkg_xml_fatal_errors, conversion.blocking_errors)
if conversion.db.aop_manager.aop_sorted_by_status.get('aop scilista item to update') is not None:
for item in conversion.db.aop_manager.aop_sorted_by_status.get('aop scilista item to update'):
scilista_items.append(item)
total = len(conversion.selected_articles) if conversion.selected_articles is not None else 0
converted = len(conversion.conversion_status.get('converted', [])) if conversion.conversion_status.get('converted', []) is not None else 0
not_converted = len(conversion.conversion_status.get('not converted', [])) if conversion.conversion_status.get('not converted', []) is not None else 0
fs_utils.append_file(log_package, 'conversion.conclusion()')
xc_conclusion_msg = ''.join([html_reports.p_message(item) for item in conversion.error_messages])
xc_conclusion_msg += conclusion_message(total, converted, not_converted, xc_status, pkg.acron_issue_label)
if len(after_conversion_report) == 0:
after_conversion_report = xc_conclusion_msg
if converter_env.is_windows:
fs_utils.append_file(log_package, 'pkg_reports.processing_result_location')
report_components['xml-files'] += pkg_reports.processing_result_location(final_result_path)
report_components['db-overview'] = before_conversion_report + after_conversion_report
report_components['summary-report'] = xc_conclusion_msg + xc_results_report + aop_results_report
fs_utils.append_file(log_package, 'pkg_reports.format_complete_report')
xc_validations = pkg_reports.format_complete_report(report_components)
content = xc_validations.message
if tmp_report_path in content:
fs_utils.append_file(log_package, 'content.replace(tmp_report_path, final_report_path)')
content = content.replace(tmp_report_path, final_report_path)
report_location = final_report_path + '/xml_converter.html'
pkg_reports.save_report(report_location, [_('XML Conversion (XML to Database)'), pkg.acron_issue_label], content)
if not converter_env.is_windows:
fs_utils.append_file(log_package, 'format_reports_for_web')
format_reports_for_web(final_report_path, pkg_path, pkg.acron_issue_label.replace(' ', '/'))
if tmp_result_path != final_result_path:
fs_utils.delete_file_or_folder(tmp_result_path)
fs_utils.append_file(log_package, 'antes de return - convert_package')
os.unlink(log_package)
return (scilista_items, xc_status, xc_validations.statistics_message(), report_location)
