+ code
+
+ {{ xml }}
+
+{% endblock %}
\ No newline at end of file
diff --git a/upload/templates/modeladmin/upload/qapackage/index_results.html b/upload/templates/modeladmin/upload/qapackage/index_results.html
new file mode 100644
index 000000000..76c3ca49e
--- /dev/null
+++ b/upload/templates/modeladmin/upload/qapackage/index_results.html
@@ -0,0 +1,13 @@
+{% extends "modeladmin/listing_results.html" %}
+{% extends "modeladmin/index_results.html" %}
+{% load i18n wagtailadmin_tags %}
+
+ssssssssss
+{% block no_results_message %}
+ {% fragment as no_results_message %}
+
+ {{ no_results_text|capfirst }}
+ {% endfragment %}
+
+ {{ no_results_message }}
+{% endblock %} \ No newline at end of file diff --git a/upload/templates/modeladmin/upload/validationreport/edit.html b/upload/templates/modeladmin/upload/validationreport/edit.html new file mode 100644 index 000000000..501785e5c --- /dev/null +++ b/upload/templates/modeladmin/upload/validationreport/edit.html @@ -0,0 +1,19 @@ +{% extends "modeladmin/edit.html" %} +{% load i18n modeladmin_tags wagtailadmin_tags wagtailcore_tags %} +{% block header %} + {% include "modeladmin/includes/header_with_history.html" with title=view.get_page_title subtitle=view.get_page_subtitle icon=view.header_icon merged=1 latest_log_entry=latest_log_entry history_url=history_url %} + +{% endblock %} diff --git a/upload/templates/modeladmin/upload/xmlerrorreport/edit.html b/upload/templates/modeladmin/upload/xmlerrorreport/edit.html new file mode 100644 index 000000000..501785e5c --- /dev/null +++ b/upload/templates/modeladmin/upload/xmlerrorreport/edit.html @@ -0,0 +1,19 @@ +{% extends "modeladmin/edit.html" %} +{% load i18n modeladmin_tags wagtailadmin_tags wagtailcore_tags %} +{% block header %} + {% include "modeladmin/includes/header_with_history.html" with title=view.get_page_title subtitle=view.get_page_subtitle icon=view.header_icon merged=1 latest_log_entry=latest_log_entry history_url=history_url %} + +{% endblock %} diff --git a/upload/templates/modeladmin/upload/xmlinforeport/edit.html b/upload/templates/modeladmin/upload/xmlinforeport/edit.html new file mode 100644 index 000000000..501785e5c --- /dev/null +++ b/upload/templates/modeladmin/upload/xmlinforeport/edit.html @@ -0,0 +1,19 @@ +{% extends "modeladmin/edit.html" %} +{% load i18n modeladmin_tags wagtailadmin_tags wagtailcore_tags %} +{% block header %} + {% include "modeladmin/includes/header_with_history.html" with title=view.get_page_title subtitle=view.get_page_subtitle icon=view.header_icon merged=1 latest_log_entry=latest_log_entry history_url=history_url %} + +{% endblock %} diff --git a/upload/utils/zip_pkg.py b/upload/utils/zip_pkg.py new file mode 100644 index 000000000..9bec4a707 --- /dev/null +++ b/upload/utils/zip_pkg.py @@ -0,0 +1,79 @@ +import os +import logging +from tempfile import TemporaryDirectory, mkdtemp +from zipfile import ZIP_DEFLATED, BadZipFile, ZipFile + + +class PkgZip: + + def __init__(self, file_path): + self.file_path = file_path + + def split(self): + found = False + with ZipFile(self.file_path) as zf: + xml_and_related_items = self.get_zip_content(zf) + pkgs = self.get_packages( + xml_and_related_items["xmls"], + xml_and_related_items["other_files"] + ) + for xml_name, items in pkgs.items(): + yield self.zip_package(zf, xml_name, items) + + def get_zip_content(self, zf): + file_paths = set(zf.namelist() or []) + logging.info(f"file_paths: {file_paths}") + + other_files = {} + xmls = {} + for file_path in file_paths: + basename = os.path.basename(file_path) + if basename.startswith("."): + continue + name, ext = os.path.splitext(basename) + data = {"file_path": file_path, "basename": basename} + logging.info(f"{self.file_path} {data}") + if ext == ".xml": + xmls.setdefault(name, []) + xmls[name].append(data) + else: + other_files.setdefault(name, []) + other_files[name].append(data) + return {"xmls": xmls, "other_files": other_files} + + def get_packages(self, xmls, other_files): + for k, v in xmls.items(): + logging.info((k, v)) + for k, v in other_files.items(): + logging.info((k, v)) + + other_files_keys = list(other_files.keys()) + for key in xmls.keys(): + for other_files_key in other_files_keys: + logging.info(f"{key} | {other_files_key}") + if key == other_files_key: + logging.info("a") + xmls[key].extend(other_files.pop(other_files_key)) + elif other_files_key.startswith(key + "-"): + logging.info("b") + xmls[key].extend(other_files.pop(other_files_key)) + else: + logging.info("c") + return xmls + + def zip_package(self, zf, xml_name, files): + try: + content = None + with TemporaryDirectory() as tmpdirname: + zfile = os.path.join(tmpdirname, f"{xml_name}.zip") + with ZipFile(zfile, "w", compression=ZIP_DEFLATED) as zfw: + for item in files: + zfw.writestr( + item["basename"], zf.read(item["file_path"]) + ) + with open(zfile, "rb") as zfw: + content = zfw.read() + return {"xml_name": xml_name, "content": content} + except Exception as exc: + logging.exception(exc) + return {"xml_name": xml_name, "error": str(exc)} diff --git a/upload/validation/html_validation.py b/upload/validation/html_validation.py new file mode 100644 index 000000000..04b1c103f --- /dev/null +++ b/upload/validation/html_validation.py @@ -0,0 +1,59 @@ +from django.utils.translation import gettext_lazy as _ + + +def validate_webpage(web_page, xml_with_pre): + """ + Arguments + --------- + xml_with_pre : XMLWithPre + web_page : dict { + "lang": "en", + "url": "url", + } + + Returns + ------- + Generator of validation result + """ + # web_page['url'] can be None + + if not web_page["url"]: + yield { + "message": _("Web page `{}` does not exist").format( + web_page['lang'] + ) + } + + for item in absent_xml_data_in_web_page(web_page, xml_with_pre): + yield { + "message": _("It was expected to find `{}` in {} ({})").format( + item, web_page['url'], web_page['lang'] + ) + } + + +def absent_xml_data_in_web_page(web_page, xml_with_pre): + """ + Retorna itens (str) presentes no XML e não encontrados no web page + + Arguments + --------- + xml_with_pre : XMLWithPre + web_page : dict { + "name": "1234-1234-acron-45-1-1.pdf', + "lang": "en", + "component_type": "web_page", + "main": "en", + "content": b'', + } + + Returns + ------- + Gerador de textos faltantes no web page + """ + # TODO + # lembrar de considerar o idioma ao comparar: + # selecionar os dados do idioma de acordo com o idioma do web page + # lembrar de considerar que os dados não associados ao idioma + # tem que ser encontrados em todos os web pages + pass diff --git a/upload/validation/rendition_validation.py b/upload/validation/rendition_validation.py new file mode 100644 index 000000000..b76e8c47b --- /dev/null +++ b/upload/validation/rendition_validation.py @@ -0,0 +1,82 @@ +from django.utils.translation import gettext_lazy as _ + + +def validate_rendition(rendition, xml_with_pre): + """ + Arguments + --------- + xml_with_pre : XMLWithPre + rendition : dict { + "name": "1234-1234-acron-45-1-1.pdf', + "lang": "en", + "component_type": "rendition", + "main": "en", + "content": b'', + } + + Returns + ------- + Generator of validation result + """ + for item in absent_xml_data_in_rendition(rendition, xml_with_pre): + yield { + "message": _("It was expected to find `{}` in {} ({})").format( + item, rendition['name'], rendition['lang'] + ) + } + + for item in absent_pdf_words_in_xml_data(rendition, xml_with_pre): + yield { + "message": _("It was expected to find `{}` in XML ({})").format( + item, rendition['lang'] + ) + } + + +def absent_xml_data_in_rendition(rendition, xml_with_pre): + """ + Retorna itens (str) presentes no XML e não encontrados no PDF + + Arguments + --------- + xml_with_pre : XMLWithPre + rendition : dict { + "name": "1234-1234-acron-45-1-1.pdf', + "lang": "en", + "component_type": "rendition", + "main": "en", + "content": b'', + } + + Returns + ------- + Gerador de textos faltantes no PDF + """ + # TODO + # lembrar de considerar o idioma ao comparar: + # selecionar os dados do idioma de acordo com o idioma do PDF + # lembrar de considerar que os dados não associados ao idioma + # tem que ser encontrados em todos os PDFs + return [] + + +def absent_pdf_words_in_xml_data(rendition, xml_with_pre): + """ + Retorna itens (str) presentes no PDF e não encontrados no XML + + Arguments + --------- + xml_with_pre : XMLWithPre + rendition : dict { + "name": "1234-1234-acron-45-1-1.pdf', + "lang": "en", + "component_type": "rendition", + "main": "en", + "content": b'', + } + + Returns + ------- + Gerador de textos faltantes no XML + """ + return [] diff --git a/upload/validation/xml_data_checker.py b/upload/validation/xml_data_checker.py new file mode 100644 index 000000000..c43b5dd64 --- /dev/null +++ b/upload/validation/xml_data_checker.py @@ -0,0 +1,168 @@ +import sys +import logging + +from django.utils.translation import gettext_lazy as _ +from packtools.sps.validation import xml_validator as packtools_xml_data_checker +from upload.models import ( + XMLError, + XMLInfo, + XMLErrorReport, + XMLInfoReport, + choices, +) + + +class XMLDataChecker: + def __init__(self, package, journal, issue, params=None): + self.error_report = None + self.info_report = None + self.package = package + self.user = package.creator + self.journal = journal + self.issue = issue + self.xmltree = package.xml_with_pre.xmltree + self.params = {} + self.params.update(params or {}) + self.params.update(self.get_journal_params()) + + def get_journal_params(self): + try: + return { + # "get_doi_data": callable_get_doi_data, + "doi_required": self.journal.doi_prefix, + "expected_toc_sections": self.journal.toc_sections, + "journal_acron": self.journal.journal_acron, + "publisher_name_list": self.journal.publisher_names, + "nlm_ta": self.journal.nlm_title, + "journal_license_code": self.journal.license_code, + } + except Exception as e: + return {} + + def create_info_report(self): + self.info_report = XMLInfoReport.create_or_update( + self.user, + self.package, + _("XML Info Report"), + choices.VAL_CAT_XML_CONTENT, + reset_validations=False, + ) + + def create_error_report(self, report_name): + return XMLErrorReport.create_or_update( + self.user, + self.package, + _("XML Error Report") + f': {report_name}', + choices.VAL_CAT_XML_CONTENT, + reset_validations=False, + ) + + def validate(self): + try: + index = None + operation = self.package.start(self.user, "xml data validation") + XMLInfo.objects.filter(report__package=self.package).delete() + XMLError.objects.filter(report__package=self.package).delete() + for response in packtools_xml_data_checker.validate_xml_content( + self.xmltree, self.params + ): + group = response["group"] + results = response["items"] + try: + for index, result in enumerate(results): + if not result: + continue + self._handle_result(group, result, index) + except Exception as exc: + exc_type, exc_value, exc_traceback = sys.exc_info() + logging.exception(exc) + self._handle_exception({"group": group, "exception": exc, "exc_traceback": exc_traceback}) + + for error_report in self.package.xml_error_report.all(): + if error_report.xml_error.count(): + error_report.finish_validations() + else: + error_report.delete() + + # devido às tarefas serem executadas concorrentemente, + # necessário registrar as tarefas finalizadas + if self.info_report: + self.info_report.finish_validations() + + operation.finish( + self.user, + completed=True, + detail={}, + ) + return True + except Exception as e: + exc_type, exc_value, exc_traceback = sys.exc_info() + operation = self.package.start(self.user, f"result {index}") + detail = {} + detail.update(result) + detail["len"] = {k: len(v) for k, v in result.items() if v} + operation.finish( + self.user, + completed=False, + exception=e, + exc_traceback=exc_traceback, + detail=detail, + ) + + def _handle_result(self, group, result, index): + try: + status_ = result["response"] + subject = group + if status_ == "OK": + if not self.info_report: + self.create_info_report() + report = self.info_report + else: + report = self.create_error_report(group or '') + + validation_result = report.add_validation_result( + status=status_, + message=result.get("advice"), + data=result, + subject=subject, + ) + attribute = "/".join([item for item in (result.get("item"), result.get("sub_item")) if item]) + validation_result.focus = result.get("title") + validation_result.attribute = attribute + validation_result.parent = result.get("parent") + validation_result.parent_id = result.get("parent_id") + validation_result.parent_article_type = result.get("parent_article_type") + validation_result.validation_type = result.get("validation_type") or "xml" + + if status_ != "OK": + validation_result.advice = result.get("advice") + validation_result.expected_value = result.get("expected_value") + validation_result.got_value = result.get("got_value") + validation_result.reaction = choices.ER_REACTION_FIX + + validation_result.save() + return validation_result + except Exception as e: + logging.exception(e) + exc_type, exc_value, exc_traceback = sys.exc_info() + operation = self.package.start(self.user, f"result {index}") + detail = {} + detail.update(result or {}) + detail["len"] = {k: len(v) for k, v in result.items() if v} + operation.finish( + self.user, + completed=False, + exception=e, + exc_traceback=exc_traceback, + detail=detail, + ) + + def _handle_exception(self, result): + group = result.get("group") or "configuration" + operation = self.package.start(self.user, f"{group} exception") + operation.finish( + self.user, + completed=False, + exception=result.get("exception"), + exc_traceback=result.get("exc_traceback"), + ) \ No newline at end of file diff --git a/upload/validation/xml_validation.py b/upload/validation/xml_validation.py new file mode 100644 index 000000000..90c2b9169 --- /dev/null +++ b/upload/validation/xml_validation.py @@ -0,0 +1,488 @@ +import csv +import json +import logging +import os +import sys + +from importlib.resources import files +from packtools.sps.models.dates import ArticleDates +from packtools.sps.pid_provider.xml_sps_lib import XMLWithPre +from packtools.sps.validation.aff import ( + AffiliationsListValidation, + AffiliationValidation, +) +from packtools.sps.validation.alternatives import ( + AlternativesValidation, + AlternativeValidation, +) +from packtools.sps.validation.article_abstract import ( + HighlightsValidation, + VisualAbstractsValidation, +) +from packtools.sps.validation.article_and_subarticles import ( + ArticleAttribsValidation, + ArticleIdValidation, + ArticleLangValidation, + ArticleTypeValidation, +) +from packtools.sps.validation.article_author_notes import AuthorNotesValidation +from packtools.sps.validation.article_citations import ( + ArticleCitationsValidation, + ArticleCitationValidation, +) +from packtools.sps.validation.article_contribs import ( + ArticleContribsValidation, + ContribsValidation, + ContribValidation, +) +from packtools.sps.validation.article_data_availability import ( + DataAvailabilityValidation, +) +from packtools.sps.validation.article_doi import ArticleDoiValidation +from packtools.sps.validation.article_lang import ( + ArticleLangValidation as ArticleLangValidation2, +) +from packtools.sps.validation.article_license import ArticleLicenseValidation +from packtools.sps.validation.article_toc_sections import ArticleTocSectionsValidation +from packtools.sps.validation.article_xref import ArticleXrefValidation +from packtools.sps.validation.dates import ArticleDatesValidation +from packtools.sps.validation.fig import FigValidation +from packtools.sps.validation.footnotes import FootnoteValidation +from packtools.sps.validation.formula import FormulaValidation +from packtools.sps.validation.front_articlemeta_issue import IssueValidation, Pagination +from packtools.sps.validation.funding_group import FundingGroupValidation +from packtools.sps.validation.journal_meta import ( + AcronymValidation, + ISSNValidation, + JournalIdValidation, + JournalMetaValidation, + PublisherNameValidation, + TitleValidation, +) +from packtools.sps.validation.peer_review import ( + AuthorPeerReviewValidation, + CustomMetaPeerReviewValidation, + DatePeerReviewValidation, + PeerReviewsValidation, + RelatedArticleValidation, +) +from packtools.sps.validation.preprint import PreprintValidation +from packtools.sps.validation.related_articles import RelatedArticlesValidation +from packtools.sps.validation.supplementary_material import ( + SupplementaryMaterialValidation, +) +from packtools.sps.validation.tablewrap import TableWrapValidation +from packtools.sps.validation.utils import get_doi_information + + +def get_data(filename, key, sps_version=None): + sps_version = sps_version or "default" + # Reads contents with UTF-8 encoding and returns str. + content = ( + files(f"packtools.sps.sps_versions") + .joinpath(f"{sps_version}") + .joinpath(f"{filename}.json") + .read_text() + ) + x = " ".join(content.split()) + fixed = x.replace(", ]", "]").replace(", }", "}") + data = json.loads(fixed) + return data[key] + + +def create_report(report_file_path, xml_path, params, fieldnames=None): + if not params: + params = { + # "get_doi_data": callable_get_doi_data, + "doi_required": params.get("doi_required"), + "expected_toc_sections": params.get("expected_toc_sections"), + "journal_acron": params.get("journal_acron"), + "publisher_name_list": params.get("publisher_name_list"), + "nlm_ta": params.get("nlm_ta"), + } + for xml_with_pre in XMLWithPre.create(path=xml_path): + rows = validate_xml_content(xml_with_pre.filename, xml_with_pre.xmltree, params) + save_csv(report_file_path, rows, fieldnames) + print(f"Created {report_file_path}") + + +def save_csv(filepath, rows, fieldnames=None): + + with open(filepath, "w", newline="") as csvfile: + header = False + for row in rows: + try: + logging.exception(row["exception"]) + continue + except KeyError: + if not fieldnames: + fieldnames = list(row.keys()) + if not header: + writer = csv.DictWriter(csvfile, fieldnames=fieldnames) + writer.writeheader() + header = True + writer.writerow(row) + + +def validate_xml_content(sps_pkg_name, xmltree, params): + logging.info("") + # params = { + # "get_doi_data": callable_get_doi_data, + # "doi_required": params.get("doi_required"), + # "expected_toc_sections": params.get("expected_toc_sections"), + # "journal_acron": params.get("journal_acron"), + # "publisher_name_list": params.get("publisher_name_list"), + # "nlm_ta": params.get("nlm_ta"), + # } + + validation_group_and_function_items = ( + ("journal", validate_journal), + ("article attributes", validate_article_attributes), + ("article attributes", validate_languages), + ("article attributes", validate_article_type), + ("article-id", validate_article_id_other), + # ("article-id", validate_doi), + # ("dates", validate_dates), + ("author", validate_contribs), + ("author affiliations", validate_affiliations), + ("author notes", validate_author_notes), + ("text languages", validate_toc_sections), + ("text languages", validate_article_languages), + ("text xref", validate_xref), + ("open science", validate_data_availability), + ("open science", validate_licenses), + ("open science", validate_preprint), + # ("open science peer review", validate_peer_review), + ("references", validate_references), + ("funding", validate_funding_group), + ("related articles", validate_related_articles), + ("special abstracts", validate_visual_abstracts), + ("special abstracts", validate_highlights), + ("footnotes", validate_footnotes), + # ("table-wrap", validate_table_wrap), + # ("figures", validate_figures), + # ("formulas", validate_formulas), + ("supplementary material", validate_supplementary_material), + ) + + sps_version = xmltree.find(".").get("specific-use") + for validation_group, f in validation_group_and_function_items: + try: + items = f(xmltree, sps_version, params) + for item in items: + try: + item["group"] = validation_group + yield item + except Exception as exc: + print(f"item: {item} / group: {validation_group}") + exc_type, exc_value, exc_traceback = sys.exc_info() + yield dict( + exception=exc, + exc_traceback=exc_traceback, + function=validation_group, + sps_pkg_name=sps_pkg_name, + item=item, + ) + except Exception as exc: + exc_type, exc_value, exc_traceback = sys.exc_info() + yield dict( + exception=exc, + exc_traceback=exc_traceback, + function=validation_group, + sps_pkg_name=sps_pkg_name, + ) + + +def validate_affiliations(xmltree, sps_version, params): + logging.info("validate_affiliations") + validator = AffiliationsListValidation(xmltree) + data = get_data("country_codes", "country_codes_list") + yield from validator.validade_affiliations_list(data) + + +def validate_highlights(xmltree, sps_version, params): + logging.info("validate_highlights") + validator = HighlightsValidation(xmltree) + yield from validator.highlight_validation() + + +def validate_visual_abstracts(xmltree, sps_version, params): + logging.info("validate_visual_abstracts") + validator = VisualAbstractsValidation(xmltree) + yield from validator.visual_abstracts_validation() + + +def validate_languages(xmltree, sps_version, params): + logging.info("validate_languages") + validator = ArticleLangValidation(xmltree) + yield from validator.validate_language( + get_data("language_codes", "language_codes_list") + ) + + +def validate_article_attributes(xmltree, sps_version, params): + logging.info("validate_article_attributes") + validator = ArticleAttribsValidation(xmltree) + yield from validator.validate_dtd_version( + get_data("dtd_version", "dtd_version_list", sps_version) + ) + yield from validator.validate_specific_use( + get_data("specific_use", "specif_use_list") + ) + + +def validate_article_id_other(xmltree, sps_version, params): + logging.info("validate_article_id_other") + validator = ArticleIdValidation(xmltree) + try: + return validator.validate_article_id_other() + except AttributeError: + return None + + +def validate_article_type(xmltree, sps_version, params): + logging.info("validate_article_type") + validator = ArticleTypeValidation(xmltree) + # FIXME validar article_type para sub-article + try: + yield from validator.validate_article_type( + get_data("article_type", "article_type_list", sps_version) + ) + except Exception as e: + raise e + + # TODO + # yield from validator.validate_article_type_vs_subject_similarity( + # subjects_list=None, expected_similarity=1, error_level=None, target_article_types=None + # ) + + +def validate_author_notes(xmltree, sps_version, params): + logging.info("validate_author_notes") + data = {"sps-1.9": ["conflict"], "sps-1.10": ["coi-statement"]} + validator = AuthorNotesValidation(xmltree, data.get(sps_version)) + yield from validator.validate_author_note() + + +def validate_references(xmltree, sps_version, params): + logging.info("validate_references") + # FIXME criar json para a versão sps-1.9 + publication_type_list = get_data( + "publication_types_references", "publication_type_list", sps_version + ) + validator = ArticleCitationsValidation(xmltree, publication_type_list) + start_year = None + + xml = ArticleDates(xmltree) + end_year = int(xml.collection_date["year"] or xml.article_date["year"]) + + # FIXME remover xmltree do método + yield from validator.validate_article_citations( + xmltree, publication_type_list, start_year, end_year + ) + + +def validate_contribs(xmltree, sps_version, params): + logging.info("validate_contribs") + data = { + "credit_taxonomy_terms_and_urls": None, + "callable_get_data": None, + } + validator = ArticleContribsValidation(xmltree, data) + # FIXME + yield from validator.validate_contribs_orcid_is_unique(error_level="CRITICAL") + # for contrib in validator.contribs.contribs: + # yield from ContribsValidation(contrib, data, content_types).validate() + + +def validate_data_availability(xmltree, sps_version, params): + logging.info("validate_data_availability") + validator = DataAvailabilityValidation(xmltree) + try: + specific_use_list = get_data( + "data_availability_specific_use", "specific_use", sps_version + ) + except Exception as e: + specific_use_list = None + + if specific_use_list: + yield from validator.validate_data_availability( + specific_use_list, + error_level="ERROR", + ) + + +def validate_doi(xmltree, sps_version, params): + logging.info("validate_doi") + # FIXME falta de padrão + validator = ArticleDoiValidation(xmltree) + + if params.get("doi_required"): + error_level = "CRITICAL" + else: + error_level = "ERROR" + yield from validator.validate_doi_exists(error_level=error_level) + yield from validator.validate_all_dois_are_unique(error_level="ERROR") + yield from validator.validate_doi_registered(get_doi_information) + + +def validate_article_languages(xmltree, sps_version, params): + logging.info("validate_article_languages") + # FIXME falta de padrão + validator = ArticleLangValidation2(xmltree) + yield from validator.validate_article_lang() + + +def validate_licenses(xmltree, sps_version, params): + logging.info("validate_licenses") + validator = ArticleLicenseValidation(xmltree) + # yield from validator.validate_license(license_expected_value) + # falta de json em sps-1.9 + yield from validator.validate_license_code(params.get("journal_license_code")) + + +def validate_toc_sections(xmltree, sps_version, params): + logging.info("validate_toc_sections") + validator = ArticleTocSectionsValidation(xmltree) + yield from validator.validate_article_toc_sections( + params.get("expected_toc_sections") + ) + yield from validator.validade_article_title_is_different_from_section_titles() + + +def validate_xref(xmltree, sps_version, params): + logging.info("validate_xref") + validator = ArticleXrefValidation(xmltree) + yield from validator.validate_id() + yield from validator.validate_rid() + + +def validate_dates(xmltree, sps_version, params): + logging.info("validate_dates") + validator = ArticleDatesValidation(xmltree) + order = get_data( + "history_dates_order_of_events", + "order", + sps_version, + ) + required_events = get_data( + "history_dates_required_events", + "required_events", + sps_version, + ) + yield from validator.validate_history_dates(order, required_events) + yield from validator.validate_number_of_digits_in_article_date() + + # FIXME + yield from validator.validate_article_date(future_date=None) + yield from validator.validate_collection_date(future_date=None) + + +def validate_figures(xmltree, sps_version, params): + logging.info("validate_figures") + # FIXME faltam validações de label, caption, graphic ou alternatives + validator = FigValidation(xmltree) + yield from validator.validate_fig_existence() + + +def validate_footnotes(xmltree, sps_version, params): + logging.info("validate_footnotes") + # FIXME não existe somente um tipo de footnotes, faltam validações, error_level + validator = FootnoteValidation(xmltree) + yield from validator.fn_validation() + + +def validate_formulas(xmltree, sps_version, params): + logging.info("validate_formulas") + # FIXME faltam validações de label, caption, graphic ou alternatives + validator = FormulaValidation(xmltree) + yield from validator.validate_formula_existence() + + +def validate_funding_group(xmltree, sps_version, params): + logging.info("validate_funding_group") + # FIXME ? _callable_extern_validate_default + # faltam validações + validator = FundingGroupValidation(xmltree) + yield from validator.funding_sources_exist_validation() + # ??? yield from validator.award_id_format_validation(_callable_extern_validate_default) + + +def validate_journal(xmltree, sps_version, params): + logging.info("validate_journal") + + validator = AcronymValidation(xmltree) + yield from validator.acronym_validation(params["journal_acron"]) + + validator = PublisherNameValidation(xmltree) + yield from validator.validate_publisher_names(params["publisher_name_list"]) + + try: + if params["nlm_ta"]: + validator = JournalIdValidation(xmltree) + yield from validator.nlm_ta_id_validation(params["nlm_ta"]) + except KeyError: + pass + + +def validate_peer_review(xmltree, sps_version, params): + logging.info("validate_peer_review") + # FIXME temos todos os json? + + validator = PeerReviewsValidation( + xmltree, + contrib_type_list=get_data( + "specific_use_for_peer_reviews", "contrib_type_list", sps_version + ), + specific_use_list=get_data( + "specific_use_for_peer_reviews", "specific_use_list", sps_version + ), + date_type_list=get_data( + "specific_use_for_peer_reviews", "date_type_list", sps_version + ), + meta_value_list=get_data("meta_value", "meta_value_list", sps_version), + related_article_type_list=get_data( + "related_article_type", "related_article_type_list", sps_version + ), + link_type_list=get_data( + "related_article__ext_link_type", + "related_article__ext_link_type_list", + sps_version, + ), + ) + yield from validator.validate() + + +def validate_preprint(xmltree, sps_version, params): + logging.info("validate_preprint") + # FIXME fora de padrão + validator = PreprintValidation(xmltree) + yield from validator.preprint_validation() + + +def validate_related_articles(xmltree, sps_version, params): + logging.info("validate_related_articles") + validator = RelatedArticlesValidation(xmltree) + correspondence_list = get_data( + "related_article", + "correspondence_list", + sps_version, + ) + yield from validator.related_articles_matches_article_type_validation( + correspondence_list + ) + yield from validator.related_articles_doi() + + +def validate_supplementary_material(xmltree, sps_version, params): + logging.info("validate_supplementary_material") + # FIXME validações incompletas + validator = SupplementaryMaterialValidation(xmltree) + yield from validator.validate_supplementary_material_existence() + + +def validate_table_wrap(xmltree, sps_version, params): + logging.info("validate_table_wrap") + # FIXME validações incompletas + validator = TableWrapValidation(xmltree) + yield from validator.validate_tablewrap_existence() diff --git a/upload/views.py b/upload/views.py index ce5c1b2db..e16a15562 100644 --- a/upload/views.py +++ b/upload/views.py @@ -1,10 +1,14 @@ import logging +import os from django.contrib import messages -from django.http import Http404, HttpResponse, HttpResponseRedirect, JsonResponse +from django.http import Http404, HttpResponse, HttpResponseRedirect from django.shortcuts import get_object_or_404, redirect, render from django.utils.translation import gettext_lazy as _ -from wagtail_modeladmin.views import CreateView, EditView, InspectView + +from wagtail.snippets.views.snippets import CreateView, EditView, InspectView + +from core.views import UserTrackingCreateView, UserTrackingEditView from article.models import Article from issue.models import Issue @@ -22,165 +26,165 @@ from team.models import has_permission -class PackageZipCreateView(CreateView): - def form_valid(self, form): - if not has_permission(self.request.user): - messages.error( - self.request, - _("Operation not available"), - ) - return HttpResponseRedirect(self.get_success_url()) +# =================================================================== +# Create / Edit Views customizadas +# =================================================================== - pkg_zip = form.save_all(self.request.user) - task_receive_packages.apply_async( - kwargs=dict( - user_id=self.request.user.id, - pkg_zip_id=pkg_zip.id, - ) - ) - if pkg_zip.show_package_validations: - return redirect(f"/admin/upload/package?q={pkg_zip.name}") - else: - return HttpResponseRedirect(self.get_success_url()) - - -class PackageAdminInspectView(InspectView): - def get_optimized_package_filepath_and_directory(self): - # Obtém caminho do pacote otimizado - _path = package_utils.generate_filepath_with_new_extension( - self.instance.file.name, - ".optz", - True, - ) - # Obtém diretório em que o pacote otimizado foi extraído - _directory = file_utils.get_file_url( - dirname="", filename=file_utils.get_filename_from_filepath(_path) - ) +class PackageZipCreateView(UserTrackingCreateView): + """ + Upload de pacote ZIP. - return _path, _directory + Sobrescreve post() porque precisa: + 1. Checar permissão antes do save + 2. Disparar task assíncrona após o save + 3. Redirecionar condicionalmente + """ - def set_pdf_paths(self, data, optz_dir): - try: - for rendition in package_utils.get_article_renditions_from_zipped_xml( - self.instance.file.name - ): - package_files = file_utils.get_file_list_from_zip( - self.instance.file.name - ) - document_name = package_utils.get_xml_filename(package_files) - rendition_name = package_utils.get_rendition_expected_name( - rendition, document_name + def post(self, request, *args, **kwargs): + if not has_permission(request.user): + messages.error(request, _("Operation not available")) + return redirect(self.get_add_url()) + + self.form = self.get_form() + if self.form.is_valid(): + pkg_zip = self.save_instance() + pkg_zip.name, ext = os.path.splitext(os.path.basename(pkg_zip.file.name)) + pkg_zip.save() + + task_receive_packages.apply_async( + kwargs=dict( + user_id=request.user.id, + pkg_zip_id=pkg_zip.id, ) - data["pdfs"].append( - { - "base_uri": file_utils.os.path.join(optz_dir, rendition_name), - "language": rendition.language, - } - ) - except XMLFormatError: - data["pdfs"] = [] - - def get_context_data(self): - blocking_errors = list( - PkgValidationResult.objects.filter( - report__package=self.instance, - status=choices.VALIDATION_RESULT_BLOCKING, - ).values_list("message", flat=True) - ) - data = { - "pkg_zip_name": self.instance.pkg_zip.name, - "linked": self.instance.linked.all(), - "validation_results": {}, - "package_id": self.instance.id, - "original_pkg": self.instance.file.name, - "status": self.instance.status, - "category": self.instance.category, - "languages": package_utils.get_languages(self.instance.file.name), - "pdfs": [], - "reports": list(self.instance.reports), - "xml_error_reports": list(self.instance.xml_error_reports), - "xml_info_reports": list(self.instance.xml_info_reports), - "summary": self.instance.summary, - "xml": self.instance.xml, - "blocking_errors": blocking_errors, - } + ) - # optz_file_path, optz_dir = self.get_optimized_package_filepath_and_directory() - # data["optimized_pkg"] = optz_file_path - # self.set_pdf_paths(data, optz_dir) + if pkg_zip.show_package_validations: + return redirect(f"/admin/upload/package?q={pkg_zip.name}") + else: + return redirect(self.get_success_url()) + else: + return self.form_invalid(self.form) - return super().get_context_data(**data) +class XMLInfoReportEditView(UserTrackingEditView): + """ + Edição de XMLInfoReport. -class XMLInfoReportEditView(EditView): + Sobrescreve post() para redirect customizado após save. + """ fields = ["package"] - def form_valid(self, form): - - report = form.save_all(self.request.user) - - messages.success( - self.request, - _("Success ..."), - ) - - # dispara a tarefa que realiza as validações de - # assets, renditions, XML content etc - return redirect(self.get_package_url()) + def post(self, request, *args, **kwargs): + self.form = self.get_form() + if self.form.is_valid(): + self.save_instance() + messages.success(request, _("Success ...")) + return redirect(self.get_success_url()) + else: + return self.form_invalid(self.form) - def get_package_url(self): + def get_success_url(self): report = self.instance return f"/admin/upload/package/inspect/{report.package.id}/?#xi" class ValidationReportEditView(XMLInfoReportEditView): - def get_package_url(self): + def get_success_url(self): report = self.instance return f"/admin/upload/package/inspect/{report.package.id}/?#vr{report.id}" class XMLErrorReportEditView(XMLInfoReportEditView): - def get_package_url(self): + def get_success_url(self): report = self.instance return f"/admin/upload/package/inspect/{report.package.id}/?#xer{report.id}" + def post(self, request, *args, **kwargs): + if not has_permission(request.user): + messages.error(request, _("Operation not available")) + return redirect(self.get_success_url()) + + self.form = self.get_form() + if self.form.is_valid(): + self.form.save_all(request.user) + self.save_instance() + return redirect(self.get_success_url()) + else: + return self.form_invalid(self.form) + + +class UploadValidatorEditView(UserTrackingEditView): + """ + Sobrescreve post() para checar permissão antes do save. + """ + + def post(self, request, *args, **kwargs): + if not has_permission(request.user): + messages.error(request, _("Operation not available")) + return redirect(self.get_success_url()) + + self.form = self.get_form() + if self.form.is_valid(): + self.save_instance() + return redirect(self.get_success_url()) + else: + return self.form_invalid(self.form) + + +# =================================================================== +# Mixin e views de decisão de publicação +# =================================================================== + class PackageDecisionMixin: - """Mixin configurável para processar decisões de publicação de pacotes""" + """ + Mixin para processar decisões de publicação de pacotes. + + Sobrescreve post() porque precisa: + 1. Checar permissão + 2. Salvar com tracking de updated_by + 3. Disparar tasks condicionais + 4. Processar decisão de QA + 5. Redirecionar com mensagem de sucesso/erro + """ - # Atributos que podem ser sobrescritos nas classes filhas success_message = _("The decision was executed as planned") error_message = _("There was an impediment to executing the decision.") permission_error_message = _("Operation not available") def get_task_function(self): - """Pode ser sobrescrito se diferentes views usarem tasks diferentes""" + """Pode ser sobrescrito se diferentes views usarem tasks diferentes.""" return task_publish_article def process_decision(self, package, user, force_journal, force_issue): - """Pode ser sobrescrito para customizar o processamento""" + """Pode ser sobrescrito para customizar o processamento.""" return package.process_qa_decision( user, self.get_task_function(), force_journal, force_issue ) - def form_valid(self, form): - if not has_permission(self.request.user): - messages.error(self.request, self.permission_error_message) - return HttpResponseRedirect(self.get_success_url()) + def post(self, request, *args, **kwargs): + if not has_permission(request.user): + messages.error(request, self.permission_error_message) + return redirect(self.get_success_url()) + + self.form = self.get_form() + if not self.form.is_valid(): + return self.form_invalid(self.form) - package = form.save_all(self.request.user) + # save_instance() seta updated_by e salva + package = self.save_instance() - user = self.request.user - force_journal_publication = form.cleaned_data.get("force_journal_publication") + user = request.user + force_journal_publication = self.form.cleaned_data.get("force_journal_publication") if force_journal_publication and package.journal: task_complete_journal_data.delay( user_id=user.id, username=user.username, journal_id=package.journal.id, ) - force_issue_publication = form.cleaned_data.get("force_issue_publication") + force_issue_publication = self.form.cleaned_data.get("force_issue_publication") if force_issue_publication and package.issue: task_complete_issue_data.delay( user_id=user.id, @@ -190,51 +194,109 @@ def form_valid(self, form): if self.process_decision( package, - self.request.user, + user, force_journal_publication, force_issue_publication, ): - messages.success(self.request, self.success_message) - return HttpResponseRedirect(self.get_success_url()) + messages.success(request, self.success_message) + return redirect(self.get_success_url()) else: - messages.error(self.request, self.error_message) - return self.form_invalid(form) + messages.error(request, self.error_message) + return self.form_invalid(self.form) -class QAPackageEditView(PackageDecisionMixin, EditView): - # Usando as mensagens padrão +class QAPackageEditView(PackageDecisionMixin, UserTrackingEditView): pass -class ReadyToPublishPackageEditView(PackageDecisionMixin, EditView): - # Exemplo de customização de mensagens +class ReadyToPublishPackageEditView(PackageDecisionMixin, UserTrackingEditView): success_message = _("Article successfully published") error_message = _("Failed to publish the article. Please try again.") -class UploadValidatorEditView(EditView): - def form_valid(self, form): - if not has_permission(self.request.user): - messages.error( - self.request, - _("Operation not available"), - ) - return HttpResponseRedirect(self.get_success_url()) - obj = form.save_all(self.request.user) - return HttpResponseRedirect(self.get_success_url()) +# =================================================================== +# Inspect View +# =================================================================== -def finish_deposit(request): +class PackageAdminInspectView(InspectView): """ - This view function enables the user to finish deposit of a package through the graphic-interface. + MIGRAÇÃO: InspectView do wagtail.snippets tem a mesma interface + que a do ModelAdmin para get_context_data(). """ + + def get_optimized_package_filepath_and_directory(self): + _path = package_utils.generate_filepath_with_new_extension( + self.instance.file.name, + ".optz", + True, + ) + _directory = file_utils.get_file_url( + dirname="", filename=file_utils.get_filename_from_filepath(_path) + ) + return _path, _directory + + def set_pdf_paths(self, data, optz_dir): + try: + for rendition in package_utils.get_article_renditions_from_zipped_xml( + self.instance.file.name + ): + package_files = file_utils.get_file_list_from_zip( + self.instance.file.name + ) + document_name = package_utils.get_xml_filename(package_files) + rendition_name = package_utils.get_rendition_expected_name( + rendition, document_name + ) + data["pdfs"].append( + { + "base_uri": file_utils.os.path.join(optz_dir, rendition_name), + "language": rendition.language, + } + ) + except XMLFormatError: + data["pdfs"] = [] + + def get_context_data(self): + blocking_errors = list( + PkgValidationResult.objects.filter( + report__package=self.instance, + status=choices.VALIDATION_RESULT_BLOCKING, + ).values_list("message", flat=True) + ) + data = { + "pkg_zip_name": self.instance.pkg_zip.name, + "linked": self.instance.linked.all(), + "validation_results": {}, + "package_id": self.instance.id, + "original_pkg": self.instance.file.name, + "status": self.instance.status, + "category": self.instance.category, + "languages": package_utils.get_languages(self.instance.file.name), + "pdfs": [], + "reports": list(self.instance.reports), + "xml_error_reports": list(self.instance.xml_error_reports), + "xml_info_reports": list(self.instance.xml_info_reports), + "summary": self.instance.summary, + "xml": self.instance.xml, + "blocking_errors": blocking_errors, + } + + return super().get_context_data(**data) + + +# =================================================================== +# Function-based views (sem mudança na migração) +# =================================================================== + + +def finish_deposit(request): package_id = request.GET.get("package_id") if package_id: package = get_object_or_404(Package, pk=package_id) if package.finish_deposit(task_publish_article): - # muda o status para a próxima etapa messages.success(request, _("Package has been deposited")) return redirect("/admin/upload/package/") @@ -258,9 +320,6 @@ def finish_deposit(request): def download_errors(request): - """ - This view function enables the user to finish deposit of a package through the graphic-interface. - """ package_id = request.GET.get("package_id") if package_id: @@ -278,9 +337,6 @@ def download_errors(request): def display_xml(request): - """ - This view function enables the user to see a preview of HTML - """ package_id = request.GET.get("package_id") if package_id: @@ -295,9 +351,6 @@ def display_xml(request): def preview_document(request): - """ - This view function enables the user to see a preview of HTML - """ package_id = request.GET.get("package_id") if package_id: @@ -317,9 +370,6 @@ def preview_document(request): def assign(request): - """ - Assign review to a team member or decide about the package - """ package_id = request.GET.get("package_id") user = request.user @@ -329,14 +379,6 @@ def assign(request): package = get_object_or_404(Package, pk=package_id) is_reassign = package.assignee is not None - # package.assignee = user - # package.save() - - # if not is_reassign: - # messages.success(request, _("Package has been assigned with success.")) - # else: - # messages.warning(request, _("Package has been reassigned with success.")) - return redirect(f"/admin/upload/qapackage/edit/{package_id}") @@ -360,4 +402,4 @@ def archive_package(request): package.status ), ) - return redirect(f"/admin/upload/package/") + return redirect(f"/admin/upload/package/") \ No newline at end of file diff --git a/upload/wagtail_hooks.py b/upload/wagtail_hooks.py index 9cfc39bef..e3254f336 100644 --- a/upload/wagtail_hooks.py +++ b/upload/wagtail_hooks.py @@ -9,6 +9,13 @@ from wagtail.snippets.views.snippets import SnippetViewSet, SnippetViewSetGroup from config.menu import get_menu_order +from core.permission_helper import ( + AllAccessPolicy, + StaffWritePolicy, + ReadOnlyPolicy, + AutoGeneratedOwnerEditPolicy, + StaffViewSuperWritePolicy, +) from upload.views import ( ReadyToPublishPackageEditView, PackageAdminInspectView, @@ -17,9 +24,9 @@ XMLErrorReportEditView, XMLInfoReportEditView, PackageZipCreateView, + UploadValidatorEditView, ) - -from .button_helper import UploadButtonHelper +from .permission_helper import UploadPermissions from .models import ( ReadyToPublishPackage, Package, @@ -35,14 +42,28 @@ PackageZip, ArchivedPackage, ) -from .permission_helper import UploadPermissionHelper -from team.models import has_permission + + +# =================================================================== +# Aliases locais para legibilidade nos get_queryset +# =================================================================== +_can_access = UploadPermissions.user_can_access +_is_staff = UploadPermissions.user_is_staff +_qs_for_user = UploadPermissions.get_queryset_for_user + + +# =================================================================== +# ViewSets do grupo Upload +# =================================================================== class PackageZipViewSet(SnippetViewSet): model = PackageZip - # button_helper_class = UploadButtonHelper - permission_helper_class = UploadPermissionHelper + permission_policy = AllAccessPolicy( + PackageZip, + access_check=_can_access, + staff_check=_is_staff, + ) add_view_class = PackageZipCreateView menu_label = _("Package upload") menu_icon = "folder" @@ -65,19 +86,17 @@ class PackageZipViewSet(SnippetViewSet): ) def get_queryset(self, request): - if not self.permission_helper.user_can_use_upload_module(request.user, None): - return super().get_queryset(request).none() - - params = {} - if not self.permission_helper.user_is_analyst_team_member(request.user, None): - params = {"creator": request.user} - return super().get_queryset(request).filter(**params) + qs = super().get_queryset(request) + return _qs_for_user(request.user, qs) class PackageViewSet(SnippetViewSet): model = Package - button_helper_class = UploadButtonHelper - permission_helper_class = UploadPermissionHelper + permission_policy = StaffWritePolicy( + Package, + access_check=_can_access, + staff_check=_is_staff, + ) inspect_view_class = PackageAdminInspectView inspect_template_name = "modeladmin/upload/package/inspect.html" menu_label = _("Package admin") @@ -123,7 +142,7 @@ class PackageViewSet(SnippetViewSet): ) def get_queryset(self, request): - if not self.permission_helper.user_can_use_upload_module(request.user, None): + if not _can_access(request.user): return super().get_queryset(request).none() params = {} @@ -132,7 +151,7 @@ def get_queryset(self, request): except KeyError: logging.info(request.GET) - if self.permission_helper.user_is_analyst_team_member(request.user, None): + if _is_staff(request.user): waiting_status = [ choices.PS_ENQUEUED_FOR_VALIDATION, choices.PS_PENDING_CORRECTION, @@ -143,20 +162,15 @@ def get_queryset(self, request): action_required = [ choices.PS_VALIDATED_WITH_ERRORS, ] - - # Ações requeridas no menu QA, neste menu é para consultar action_required_qa_menu = [ choices.PS_PENDING_QA_DECISION, ] - - # Ações requeridas no menu Publication, neste menu é para consultar action_required_publication_menu = [ choices.PS_READY_TO_PREVIEW, choices.PS_PREVIEW, choices.PS_READY_TO_PUBLISH, choices.PS_PUBLISHED, ] - status = ( action_required + waiting_status @@ -180,7 +194,6 @@ def get_queryset(self, request): choices.PS_READY_TO_PUBLISH, choices.PS_PUBLISHED, ] - status = action_required + waiting_status return super().get_queryset(request).filter(status__in=status, **params) @@ -188,8 +201,11 @@ def get_queryset(self, request): class QualityAnalysisPackageViewSet(SnippetViewSet): model = QAPackage - button_helper_class = UploadButtonHelper - permission_helper_class = UploadPermissionHelper + permission_policy = StaffWritePolicy( + QAPackage, + access_check=_can_access, + staff_check=_is_staff, + ) menu_label = _("Quality control admin") menu_icon = "folder" menu_order = 200 @@ -226,22 +242,9 @@ class QualityAnalysisPackageViewSet(SnippetViewSet): ) def get_queryset(self, request): - if not self.permission_helper.user_can_use_upload_module(request.user, None): + if not _can_access(request.user): return super().get_queryset(request).none() - """ - Para Analista de Qualidade - PS_VALIDATED_WITH_ERRORS: - sem esperar o produtor de XML terminar o depósito, - revisar os erros, aceitar ou rejeitar pacote - PS_PENDING_CORRECTION: - a pedido do produtor de XML, - revisar os erros, aceitar ou rejeitar pacote - PS_PENDING_QA_DECISION: - a pedido do produtor de XML, - revisar os erros, aceitar ou rejeitar pacote - - Para o produtor de XML, apenas consulta - """ + status = [ choices.PS_VALIDATED_WITH_ERRORS, choices.PS_PENDING_CORRECTION, @@ -250,14 +253,14 @@ def get_queryset(self, request): params = { "blocking_errors": 0, } - if self.permission_helper.user_is_analyst_team_member(request.user, None): + if _is_staff(request.user): return ( super() .get_queryset(request) .filter( Q(assignee__isnull=True) | Q(assignee=request.user), status__in=status, - **params + **params, ) ) else: @@ -268,9 +271,11 @@ def get_queryset(self, request): class ReadyToPublishPackageViewSet(SnippetViewSet): model = ReadyToPublishPackage - - button_helper_class = UploadButtonHelper - permission_helper_class = UploadPermissionHelper + permission_policy = StaffWritePolicy( + ReadyToPublishPackage, + access_check=_can_access, + staff_check=_is_staff, + ) menu_label = _("Publication admin") menu_icon = "folder" menu_order = 200 @@ -309,19 +314,19 @@ class ReadyToPublishPackageViewSet(SnippetViewSet): ) def get_queryset(self, request): - if not self.permission_helper.user_can_use_upload_module(request.user, None): + if not _can_access(request.user): return super().get_queryset(request).none() + status = [ choices.PS_READY_TO_PREVIEW, choices.PS_PREVIEW, choices.PS_READY_TO_PUBLISH, choices.PS_PUBLISHED, - # choices.PS_SCHEDULED_PUBLICATION, ] params = { "blocking_errors": 0, } - if self.permission_helper.user_is_analyst_team_member(request.user, None): + if _is_staff(request.user): return super().get_queryset(request).filter(status__in=status, **params) else: params["creator"] = request.user @@ -329,12 +334,83 @@ def get_queryset(self, request): return super().get_queryset(request).filter(status__in=status, **params) +class ArchivedPackageViewSet(SnippetViewSet): + model = ArchivedPackage + permission_policy = ReadOnlyPolicy( + ArchivedPackage, + access_check=_can_access, + ) + inspect_view_class = PackageAdminInspectView + inspect_template_name = "modeladmin/upload/package/inspect.html" + menu_label = _("Archived Packages") + menu_icon = "folder" + menu_order = 200 + add_to_settings_menu = False + list_per_page = 20 + + list_display = ( + "__str__", + "critical_errors", + "xml_errors_percentage", + "category", + "status", + "creator", + "updated", + "expiration_date", + ) + list_filter = ( + "creator", + "category", + "status", + ) + search_fields = ( + "name", + "journal__official_journal__title", + "issue__journal__official_journal__title", + "article__pid_v3", + "creator__username", + "updated_by__username", + "pkg_zip__file", + ) + inspect_view_fields = ( + "article", + "issue", + "category", + "status", + "file", + "created", + "updated", + "expiration_date", + "files_list", + ) + + def get_queryset(self, request): + if not _can_access(request.user): + return super().get_queryset(request).none() + + params = {} + if not _is_staff(request.user): + params = {"creator": request.user} + + return ( + super() + .get_queryset(request) + .filter(~Q(status__in=choices.PS_WIP), **params) + ) + + +# =================================================================== +# ViewSets do grupo Error Management +# =================================================================== + + class XMLErrorReportViewSet(SnippetViewSet): model = XMLErrorReport - permission_helper_class = UploadPermissionHelper + permission_policy = AutoGeneratedOwnerEditPolicy( + XMLErrorReport, + access_check=_can_access, + ) edit_view_class = XMLErrorReportEditView - # create_view_class = XMLErrorReportCreateView - # inspect_view_class = XMLErrorReportAdminInspectView menu_label = _("XML Error Reports") menu_icon = "error" add_to_settings_menu = False @@ -355,20 +431,16 @@ class XMLErrorReportViewSet(SnippetViewSet): ) def get_queryset(self, request): - if not self.permission_helper.user_can_use_upload_module(request.user, None): - return super().get_queryset(request).none() - - if self.permission_helper.user_is_analyst_team_member(request.user, None): - return super().get_queryset(request) - - return super().get_queryset(request).filter(package__creator=request.user) + qs = super().get_queryset(request) + return _qs_for_user(request.user, qs, creator_field="package__creator") class XMLErrorViewSet(SnippetViewSet): model = XMLError - permission_helper_class = UploadPermissionHelper - # create_view_class = XMLErrorCreateView - # inspect_view_class = XMLErrorAdminInspectView + permission_policy = ReadOnlyPolicy( + XMLError, + access_check=_can_access, + ) menu_label = _("XML errors") menu_icon = "error" add_to_settings_menu = False @@ -395,21 +467,17 @@ class XMLErrorViewSet(SnippetViewSet): ) def get_queryset(self, request): - if not self.permission_helper.user_can_use_upload_module(request.user, None): - return super().get_queryset(request).none() - - if self.permission_helper.user_is_analyst_team_member(request.user, None): - return super().get_queryset(request) - - return super().get_queryset(request).filter(package__creator=request.user) + qs = super().get_queryset(request) + return _qs_for_user(request.user, qs, creator_field="package__creator") class XMLInfoReportViewSet(SnippetViewSet): model = XMLInfoReport - permission_helper_class = UploadPermissionHelper + permission_policy = ReadOnlyPolicy( + XMLInfoReport, + access_check=_can_access, + ) edit_view_class = XMLInfoReportEditView - # create_view_class = XMLInfoReportCreateView - # inspect_view_class = XMLInfoReportAdminInspectView menu_label = _("XML Info Reports") menu_icon = "error" add_to_settings_menu = False @@ -430,20 +498,16 @@ class XMLInfoReportViewSet(SnippetViewSet): ) def get_queryset(self, request): - if not self.permission_helper.user_can_use_upload_module(request.user, None): - return super().get_queryset(request).none() - - if self.permission_helper.user_is_analyst_team_member(request.user, None): - return super().get_queryset(request) - - return super().get_queryset(request).filter(package__creator=request.user) + qs = super().get_queryset(request) + return _qs_for_user(request.user, qs, creator_field="package__creator") class XMLInfoViewSet(SnippetViewSet): model = XMLInfo - permission_helper_class = UploadPermissionHelper - # create_view_class = XMLInfoCreateView - # inspect_view_class = XMLInfoAdminInspectView + permission_policy = ReadOnlyPolicy( + XMLInfo, + access_check=_can_access, + ) menu_label = _("XML info") menu_icon = "error" add_to_settings_menu = False @@ -470,22 +534,17 @@ class XMLInfoViewSet(SnippetViewSet): ) def get_queryset(self, request): - if not self.permission_helper.user_can_use_upload_module(request.user, None): - return super().get_queryset(request).none() - - if self.permission_helper.user_is_analyst_team_member(request.user, None): - return super().get_queryset(request) - - return super().get_queryset(request).filter(package__creator=request.user) + qs = super().get_queryset(request) + return _qs_for_user(request.user, qs, creator_field="package__creator") class ValidationReportViewSet(SnippetViewSet): model = ValidationReport - permission_helper_class = UploadPermissionHelper - # create_view_class = ValidationReportCreateView + permission_policy = ReadOnlyPolicy( + ValidationReport, + access_check=_can_access, + ) edit_view_class = ValidationReportEditView - - # inspect_view_class = ValidationReportAdminInspectView menu_label = _("Validation Reports") menu_icon = "error" add_to_settings_menu = False @@ -506,20 +565,17 @@ class ValidationReportViewSet(SnippetViewSet): ) def get_queryset(self, request): - if not self.permission_helper.user_can_use_upload_module(request.user, None): - return super().get_queryset(request).none() - - if self.permission_helper.user_is_analyst_team_member(request.user, None): - return super().get_queryset(request) - - return super().get_queryset(request).filter(package__creator=request.user) + qs = super().get_queryset(request) + return _qs_for_user(request.user, qs, creator_field="package__creator") class ValidationViewSet(SnippetViewSet): model = PkgValidationResult - permission_helper_class = UploadPermissionHelper - # create_view_class = ValidationCreateView - # inspect_view_class = ValidationAdminInspectView + permission_policy = ReadOnlyPolicy( + PkgValidationResult, + access_check=_can_access, + ) + edit_view_class = UploadValidatorEditView menu_label = _("Validations") menu_icon = "error" add_to_settings_menu = False @@ -537,20 +593,16 @@ class ValidationViewSet(SnippetViewSet): ) def get_queryset(self, request): - if not self.permission_helper.user_can_use_upload_module(request.user, None): - return super().get_queryset(request).none() - - if self.permission_helper.user_is_analyst_team_member(request.user, None): - return super().get_queryset(request) - - return super().get_queryset(request).filter(package__creator=request.user) + qs = super().get_queryset(request) + return _qs_for_user(request.user, qs, creator_field="package__creator") class UploadValidatorViewSet(SnippetViewSet): model = UploadValidator - permission_helper_class = UploadPermissionHelper - # create_view_class = ValidationCreateView - # inspect_view_class = ValidationAdminInspectView + permission_policy = StaffViewSuperWritePolicy( + UploadValidator, + staff_check=_is_staff, + ) menu_label = _("Upload Validator") menu_icon = "folder" add_to_settings_menu = False @@ -568,76 +620,16 @@ class UploadValidatorViewSet(SnippetViewSet): ) def get_queryset(self, request): - if not self.permission_helper.user_can_use_upload_module(request.user, None): + if not _can_access(request.user): return super().get_queryset(request).none() - - if self.permission_helper.user_is_analyst_team_member(request.user, None): + if _is_staff(request.user): return super().get_queryset(request) - return super().get_queryset(request).none() -class ArchivedPackageViewSet(SnippetViewSet): - model = ArchivedPackage - button_helper_class = UploadButtonHelper - permission_helper_class = UploadPermissionHelper - inspect_view_class = PackageAdminInspectView - inspect_template_name = "modeladmin/upload/package/inspect.html" - menu_label = _("Archived Packages") - menu_icon = "folder" - menu_order = 200 - add_to_settings_menu = False - list_per_page = 20 - - list_display = ( - "__str__", - "critical_errors", - "xml_errors_percentage", - "category", - "status", - "creator", - "updated", - "expiration_date", - ) - list_filter = ( - "creator", - "category", - "status", - ) - search_fields = ( - "name", - "journal__official_journal__title", - "issue__journal__official_journal__title", - "article__pid_v3", - "creator__username", - "updated_by__username", - "pkg_zip__file", - ) - inspect_view_fields = ( - "article", - "issue", - "category", - "status", - "file", - "created", - "updated", - "expiration_date", - "files_list", - ) - - def get_queryset(self, request): - if not self.permission_helper.user_can_use_upload_module(request.user, None): - return super().get_queryset(request).none() - - params = {} - if not self.permission_helper.user_is_analyst_team_member(request.user, None): - params = {"creator": request.user} - - return ( - super() - .get_queryset(request) - .filter(~Q(status__in=choices.PS_WIP), **params) - ) +# =================================================================== +# Grupos de menu +# =================================================================== class UploadViewSetGroup(SnippetViewSetGroup): @@ -660,8 +652,6 @@ class UploadReportsViewSetGroup(SnippetViewSetGroup): menu_icon = "folder" menu_label = _("Error management") items = [ - # os itens a seguir possibilitam que na página Package.inspect - # funcionem os links para os relatórios XMLErrorViewSet, XMLErrorReportViewSet, XMLInfoReportViewSet, @@ -675,8 +665,17 @@ class UploadReportsViewSetGroup(SnippetViewSetGroup): register_snippet(UploadReportsViewSetGroup) +# =================================================================== +# URLs e hooks de botões +# =================================================================== + + @hooks.register("register_admin_urls") def register_disclosure_url(): return [ path("upload/", include("upload.urls", namespace="upload")), ] + + +# Registra os hooks de botões customizados +from . import button_helper # noqa: F401, E402 \ No newline at end of file