No pid provider, adiciona deprecated_sps_pkg_name para identificar pacotes registrados e melhora a identificação e exclusão de duplicados

article/models.py

@@ -930,56 +930,76 @@ def find_duplicated_pkg_names(cls, journal=None, journal_id=None):
             params["journal"] = journal
         if journal_id:
             params["journal__id"] = journal_id
-        duplicates = (
+        return (
             cls.objects.filter(**params)
             .exclude(sps_pkg_name__isnull=True)
             .exclude(sps_pkg_name="")
             .exclude(data_status=choices.DATA_STATUS_DUPLICATED)
             .values("sps_pkg_name")
             .annotate(count=Count("id"))
             .filter(count__gt=1)
+            .values_list("sps_pkg_name", flat=True)
+        )
+
+    @classmethod
+    def find_duplicated_pid_v2(cls, journal=None, journal_id=None):
+        # Busca em ambos os campos de ISSN
+        params = {}
+        if journal:
+            params["journal"] = journal
+        if journal_id:
+            params["journal__id"] = journal_id
+        return (
+            cls.objects.filter(**params)
+            .exclude(pid_v2__isnull=True)
+            .exclude(pid_v2="")
+            .exclude(data_status=choices.DATA_STATUS_DUPLICATED)
+            .values("pid_v2")
+            .annotate(count=Count("id"))
+            .filter(count__gt=1)
+            .values_list("pid_v2", flat=True)
         )
-        return list(item["sps_pkg_name"] for item in duplicates)
 
     @classmethod
-    def mark_items_as_duplicated(cls, journal=None, journal_id=None):
+    def deduplicate_items(cls, user, journal=None, journal_id=None, mark_as_duplicated=False, deduplicate=False):
         """
         Corrige todos os artigos marcados como DATA_STATUS_DUPLICATED com base nos ISSNs fornecidos.
 
         Args:
             issns: Lista de ISSNs para verificar duplicatas.
             user: Usuário que está executando a operação.
         """
-        article_duplicated_pkg_names = cls.find_duplicated_pkg_names(
+        article_duplicated_pid_v2 = cls.find_duplicated_pid_v2(
             journal, journal_id
         )
-        if not article_duplicated_pkg_names:
-            return
-        cls.objects.filter(sps_pkg_name__in=article_duplicated_pkg_names).exclude(
-            data_status=choices.DATA_STATUS_DUPLICATED
-        ).update(
-            data_status=choices.DATA_STATUS_DUPLICATED,
-        )
-        return article_duplicated_pkg_names
-
-    @classmethod
-    def deduplicate_items(cls, user, journal=None, journal_id=None):
-        """
-        Corrige todos os artigos marcados como DATA_STATUS_DUPLICATED com base nos ISSNs fornecidos.
+        if article_duplicated_pid_v2.exists():
+            if mark_as_duplicated:
+                cls.objects.filter(pid_v2__in=article_duplicated_pid_v2).exclude(
+                    data_status=choices.DATA_STATUS_DUPLICATED
+                ).update(
+                    data_status=choices.DATA_STATUS_DUPLICATED,
+                )
+            if deduplicate:
+                for pid_v2 in article_duplicated_pid_v2:
+                    cls.fix_duplicated_items(user, None, pid_v2)
 
-        Args:
-            issns: Lista de ISSNs para verificar duplicatas.
-            user: Usuário que está executando a operação.
-        """
         article_duplicated_pkg_names = cls.find_duplicated_pkg_names(
             journal, journal_id
         )
-        for pkg_name in article_duplicated_pkg_names:
-            cls.fix_duplicated_pkg_name(pkg_name, user)
+        if article_duplicated_pkg_names.exists():
+            if mark_as_duplicated:
+                cls.objects.filter(sps_pkg_name__in=article_duplicated_pkg_names).exclude(
+                    data_status=choices.DATA_STATUS_DUPLICATED
+                ).update(
+                    data_status=choices.DATA_STATUS_DUPLICATED,
+                )
+            if deduplicate:
+                for pkg_name in article_duplicated_pkg_names:
+                    cls.fix_duplicated_items(user, pkg_name, None)
         return article_duplicated_pkg_names
 
     @classmethod
-    def fix_duplicated_pkg_name(cls, pkg_name, user):
+    def fix_duplicated_items(cls, user, pkg_name, pid_v2):
         """
         Corrige artigos marcados como DATA_STATUS_DUPLICATED com base no pkg_name fornecido.
 
@@ -991,7 +1011,12 @@ def fix_duplicated_pkg_name(cls, pkg_name, user):
             int: Número de artigos atualizados.
         """
         try:
-            articles = cls.objects.filter(sps_pkg_name=pkg_name).exclude(
+            filters = Q()
+            if pkg_name:
+                filters |= Q(sps_pkg_name=pkg_name)
+            if pid_v2:
+                filters |= Q(pid_v2=pid_v2)
+            articles = cls.objects.filter(filters).exclude(
                 data_status=choices.DATA_STATUS_DUPLICATED
             )
             if articles.count() <= 1:
@@ -1014,8 +1039,8 @@ def fix_duplicated_pkg_name(cls, pkg_name, user):
             UnexpectedEvent.create(
                 exception=exception,
                 exc_traceback=exc_traceback,
-                action="article.models.Article.fix_duplicated_pkg_name",
-                detail=pkg_name,
+                action="article.models.Article.fix_duplicated_items",
+                detail=pkg_name or pid_v2,
             )
 
 

article/tasks.py

@@ -1063,11 +1063,8 @@ def task_fix_journal_articles_status(
         if mark_as_public:
             Article.mark_items_as_public(journal_id=journal_id)
 
-        if mark_as_duplicated:
-            Article.mark_items_as_duplicated(journal_id=journal_id)
-
-        if deduplicate:
-            Article.deduplicate_items(user, journal_id=journal_id)
+        if mark_as_duplicated or deduplicate:
+            Article.deduplicate_items(user, journal_id=journal_id, mark_as_duplicated=mark_as_duplicated, deduplicate=deduplicate)
 
         return {
             "status": "success",

pid_provider/models.py

@@ -1315,7 +1315,7 @@ def mark_items_as_invalid(cls, issns):
     @profile_classmethod
     def find_duplicated_pkg_names(cls, issns):
         # Busca em ambos os campos de ISSN
-        duplicates = (
+        return (
             cls.objects.filter(Q(issn_print__in=issns) | Q(issn_electronic__in=issns))
             .exclude(pkg_name__isnull=True)
             .exclude(pkg_name="")
@@ -1328,52 +1328,82 @@ def find_duplicated_pkg_names(cls, issns):
             .values("pkg_name")
             .annotate(count=Count("id"))
             .filter(count__gt=1)
+            .values_list("pkg_name", flat=True)
         )
-        return list(set(item["pkg_name"] for item in duplicates))
-
-    @classmethod
+
     @profile_classmethod
-    def mark_items_as_duplicated(cls, issns):
-        ppx_duplicated_pkg_names = PidProviderXML.find_duplicated_pkg_names(issns)
-        if not ppx_duplicated_pkg_names:
-            return
-        cls.objects.filter(pkg_name__in=ppx_duplicated_pkg_names).exclude(
-            proc_status=choices.PPXML_STATUS_DUPLICATED
-        ).update(
-            proc_status=choices.PPXML_STATUS_DUPLICATED,
+    def find_duplicated_v2(cls, issns):
+        # Busca em ambos os campos de ISSN
+        return (
+            cls.objects.filter(Q(issn_print__in=issns) | Q(issn_electronic__in=issns))
+            .exclude(v2__isnull=True)
+            .exclude(v2="")
+            .exclude(
+                proc_status__in=[
+                    choices.PPXML_STATUS_DUPLICATED,
+                    choices.PPXML_STATUS_INVALID,
+                ]
+            )
+            .values("v2")
+            .annotate(count=Count("id"))
+            .filter(count__gt=1)
+            .values_list("v2", flat=True)
         )
-        return ppx_duplicated_pkg_names
 
     @classmethod
     @profile_classmethod
-    def deduplicate_items(cls, user, issns):
+    def deduplicate_items(cls, user, issns, mark_as_duplicated=False, deduplicate=False):
         """
         Corrige todos os artigos marcados como DATA_STATUS_DUPLICATED com base nos ISSNs fornecidos.
 
         Args:
             issns: Lista de ISSNs para verificar duplicatas.
             user: Usuário que está executando a operação.
         """
+        duplicated_v2 = cls.find_duplicated_v2(issns)
+        if duplicated_v2.exists():
+            if mark_as_duplicated:
+                cls.objects.filter(v2__in=duplicated_v2).exclude(
+                    proc_status=choices.PPXML_STATUS_DUPLICATED
+                ).update(
+                    proc_status=choices.PPXML_STATUS_DUPLICATED,
+                )
+            if deduplicate:
+                for v2 in duplicated_v2:
+                    cls.fix_duplicated_items(user, None, v2)
+
         duplicated_pkg_names = cls.find_duplicated_pkg_names(issns)
-        for pkg_name in duplicated_pkg_names:
-            cls.fix_duplicated_pkg_name(pkg_name, user)
-        return duplicated_pkg_names
+        if duplicated_pkg_names.exists():
+            if mark_as_duplicated:
+                cls.objects.filter(pkg_name__in=duplicated_pkg_names).exclude(
+                    proc_status=choices.PPXML_STATUS_DUPLICATED
+                ).update(
+                    proc_status=choices.PPXML_STATUS_DUPLICATED,
+                )
+            if deduplicate:
+                for pkg_name in duplicated_pkg_names:
+                    cls.fix_duplicated_items(user, pkg_name, None)
 
     @classmethod
     @profile_classmethod
-    def fix_duplicated_pkg_name(cls, pkg_name, user):
+    def fix_duplicated_items(cls, user, pkg_name, v2):
         """
         Corrige items marcados como PPXML_STATUS_DUPLICATED com base no pkg_name fornecido.
 
         Args:
-            pkg_name: Nome do pacote para verificar duplicatas.
             user: Usuário que está executando a operação.
-
+            pkg_name: Nome do pacote para verificar duplicatas.
+            v2: Valor do pid v2 para verificar duplicatas.
         Returns:
             int: Número de items atualizados.
         """
         try:
-            items = cls.objects.filter(pkg_name=pkg_name)
+            filters = Q()
+            if v2:
+                filters |= Q(v2=v2) | Q(other_pid__pid_in_xml=v2)
+            if pkg_name:
+                filters |= Q(pkg_name=pkg_name)
+            items = cls.objects.filter(filters)
             if items.count() <= 1:
                 return 0
 
@@ -1409,7 +1439,7 @@ def fix_duplicated_pkg_name(cls, pkg_name, user):
             UnexpectedEvent.create(
                 exception=exception,
                 exc_traceback=exc_traceback,
-                action="pid_provider.models.PidProviderXML.fix_duplicated_pkg_name",
+                action="pid_provider.models.PidProviderXML.fix_duplicated_items",
                 detail=pkg_name,
             )
 

pid_provider/query_params.py

@@ -63,9 +63,19 @@ def aop_pid(self):
 
     @cached_property
     def pkg_name(self):
-        """Nome do pacote do documento."""
+        """Nome do pacote do documento, parâmtro usado ao instanciar XMLAdapter"""
         return self.xml_adapter.pkg_name
-
+
+    @cached_property
+    def sps_pkg_name(self):
+        """Nome do pacote do documento (deprecated)."""
+        return self.xml_adapter.sps_pkg_name
+
+    @cached_property
+    def deprecated_sps_pkg_name(self):
+        """Nome do pacote do documento (deprecated)."""
+        return self.xml_adapter.sps_pkg_name
+
     @cached_property
     def main_doi(self):
         """DOI principal do documento."""
@@ -176,8 +186,15 @@ def identifier_queries(self):
             q |= Q(v2=self.aop_pid) | Q(aop_pid=self.aop_pid)
 
         # Package name
+        pkg_names = set()
         if self.pkg_name:
-            q |= Q(pkg_name=self.pkg_name)
+            pkg_names.add(self.pkg_name)
+        if self.sps_pkg_name:
+            pkg_names.add(self.sps_pkg_name)
+        if self.deprecated_sps_pkg_name:
+            pkg_names.add(self.deprecated_sps_pkg_name)
+        if pkg_names:
+            q |= Q(pkg_name__in=pkg_names)
 
         # # DOI principal
         # if self.main_doi:

pid_provider/tasks.py

@@ -281,11 +281,8 @@ def task_fix_journal_pid_provider_xmls_status(
         if mark_as_invalid:
             PidProviderXML.mark_items_as_invalid(journal.issns)
 
-        if mark_as_duplicated:
-            PidProviderXML.mark_items_as_duplicated(journal.issns)
-
-        if deduplicate:
-            PidProviderXML.deduplicate_items(user, journal.issns)
+        if mark_as_duplicated or deduplicate:
+            PidProviderXML.deduplicate_items(user, journal.issns, mark_as_duplicated=mark_as_duplicated, deduplicate=deduplicate)
 
         return {
             "status": "success",

requirements/base.txt

@@ -87,7 +87,7 @@ pysolr==3.9.0  # https://pypi.org/project/pysolr/
 # ------------------------------------------------------------------------------
 tornado>=6.5.2 # not directly required, pinned by Snyk to avoid a vulnerability 
 lxml==6.0.2  # https://github.com/lxml/lxml
-git+https://git@github.com/scieloorg/packtools@4.13.1#egg=packtools
+git+https://git@github.com/scieloorg/packtools@4.14.0#egg=packtools
 
 # pymongo
 # ------------------------------------------------------------------------------