Mantém ramo rc compatível com main (v2.12.0rc2)

Makefile

@@ -9,6 +9,7 @@ ifneq ($(shell docker compose version 2>/dev/null),)
   DOCKER_COMPOSE=docker compose
 else
   DOCKER_COMPOSE=docker-compose
+  DOCKER_COMPATIBILITY=--compatibility
 endif
 
 help: ## Show this help
@@ -47,6 +48,10 @@ build_no_cache:  ## Build app using $(compose) --no-cache
 up:  ## Start app using $(compose)
 	$(DOCKER_COMPOSE) -f $(compose) up -d
 
+up_scale:  ## Start app using $(compose) and scaling worker up to $(numworkers)
+	$(eval numworkers ?= 1)
+	$(DOCKER_COMPOSE) $(DOCKER_COMPATIBILITY) -f $(compose) up -d --scale celeryworker=$(numworkers)
+
 logs: ## See all app logs using $(compose)
 	$(DOCKER_COMPOSE) -f $(compose) logs -f
 
@@ -58,6 +63,12 @@ restart:
 ps:  ## See all containers using $(compose)
 	$(DOCKER_COMPOSE) -f $(compose) ps
 
+top:  ## See docker top using $(compose)
+	$(DOCKER_COMPOSE) -f $(compose) top
+
+stats:  ## See docker stats using $(compose)
+	$(DOCKER_COMPOSE) -f $(compose) stats
+
 rm:  ## Remove all containers using $(compose)
 	$(DOCKER_COMPOSE) -f $(compose) rm -f
 
@@ -149,7 +160,7 @@ volume_down:  ## Remove all volume
 	$(DOCKER_COMPOSE) -f $(compose) down -v
 
 clean_celery_logs:
-	@sudo truncate -s 0 $$(docker inspect --format='{{.LogPath}}' upload_production_celeryworker)
+	@sudo truncate -s 0 $$(docker inspect --format='{{.LogPath}}' $$($(DOCKER_COMPOSE) -f $(compose) ps -q celeryworker))
 
 exclude_upload_production_django:  ## Exclude all productions containers
 	@if [ -n "$$(docker images --format '{{.Repository}}:{{.Tag}}' | grep 'infrascielo/upload' | grep -v 'upload_production_postgres')" ]; then \

VERSION

@@ -1 +1 @@
-v3.0.0rc20
+v2.12.1rc

article/migrations/0008_add_unique_pid_v3.py

@@ -0,0 +1,41 @@
+# Generated by Django 5.2.3 on 2026-03-16 23:00
+
+from django.db import migrations, models
+
+
+def remove_duplicate_articles(apps, schema_editor):
+    """Remove duplicate Article records with the same pid_v3, keeping the most recently updated one."""
+    Article = apps.get_model("article", "Article")
+    from django.db.models import Count
+
+    # Normalize empty strings to NULL so the unique constraint ignores them
+    Article.objects.filter(pid_v3="").update(pid_v3=None)
+
+    duplicates = (
+        Article.objects.values("pid_v3")
+        .exclude(pid_v3__isnull=True)
+        .annotate(count=Count("id"))
+        .filter(count__gt=1)
+    )
+    for dup in duplicates:
+        pid_v3 = dup["pid_v3"]
+        keep = Article.objects.filter(pid_v3=pid_v3).order_by("-updated").first()
+        if keep:
+            Article.objects.filter(pid_v3=pid_v3).exclude(pk=keep.pk).delete()
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("article", "0007_alter_article_options_article_first_pubdate_iso"),
+    ]
+
+    operations = [
+        migrations.RunPython(
+            remove_duplicate_articles,
+            migrations.RunPython.noop,
+        ),
+        migrations.RemoveIndex(
+            model_name="article",
+            name="article_art_pid_v3_2370cc_idx",
+        ),
+    ]

article/migrations/0009_alter_article_pid_v3_unique.py

@@ -0,0 +1,19 @@
+# Generated by Django 5.2.3 on 2026-03-16 23:00
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("article", "0008_add_unique_pid_v3"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="article",
+            name="pid_v3",
+            field=models.CharField(
+                blank=True, max_length=23, null=True, unique=True, verbose_name="PID v3"
+            ),
+        ),
+    ]

article/models.py

@@ -48,7 +48,7 @@ class Article(ClusterableModel, CommonControlField):
         SPSPkg, blank=True, null=True, on_delete=models.SET_NULL
     )
     # PID v3
-    pid_v3 = models.CharField(_("PID v3"), max_length=23, blank=True, null=True)
+    pid_v3 = models.CharField(_("PID v3"), max_length=23, blank=True, null=True, unique=True)
     pid_v2 = models.CharField(_("PID v2"), max_length=23, blank=True, null=True)
 
     # Article type
@@ -124,7 +124,6 @@ class Article(ClusterableModel, CommonControlField):
 
     class Meta:
         indexes = [
-            models.Index(fields=["pid_v3"]),
             models.Index(fields=["status"]),
         ]
         ordering = ["position", "fpage", "-first_pubdate_iso"]
@@ -205,7 +204,15 @@ def article_langs(self):
     @classmethod
     def get(cls, pid_v3):
         if pid_v3:
-            return cls.objects.get(pid_v3=pid_v3)
+            try:
+                return cls.objects.get(pid_v3=pid_v3)
+            except cls.MultipleObjectsReturned:
+                qs = cls.objects.filter(pid_v3=pid_v3).order_by("-updated")
+                obj = qs.first()
+                if obj is None:
+                    raise cls.DoesNotExist
+                qs.exclude(pk=obj.pk).delete()
+                return obj
         raise ValueError("Article.get requires pid_v3")
 
     @classmethod
@@ -470,6 +477,152 @@ def get_repeated_items(cls, field_name, journal=None):
             .values_list(field_name, flat=True)
         )
 
+    @staticmethod
+    def has_valid_pid_v2(pid_v2, order):
+        """
+        Check if pid_v2 last 5 digits match the order value
+        (from MigratedArticle.document.order / v121) padded with zeros.
+        """
+        try:
+            if not pid_v2 or not order:
+                return True
+            if len(pid_v2) < 5:
+                return True
+            expected_suffix = str(int(str(order).strip())).zfill(5)
+            actual_suffix = pid_v2[-5:]
+            return actual_suffix == expected_suffix
+        except (TypeError, IndexError, ValueError):
+            return True
+
+    @classmethod
+    def exclude_articles_with_invalid_pid_v2(cls, journal=None):
+        """
+        Find and delete migrated articles whose pid_v2 last 5 digits
+        don't match the order (v121) from MigratedArticle.document.order.
+        Uses ArticleProc.migrated_data to access the migration data.
+        Only applies to migrated articles.
+        """
+        from proc.models import ArticleProc
+
+        filters = {
+            "migrated_data__isnull": False,
+            "sps_pkg__isnull": False,
+        }
+        if journal:
+            filters["issue_proc__journal_proc__journal"] = journal
+
+        article_procs = ArticleProc.objects.filter(
+            **filters
+        ).select_related("migrated_data", "sps_pkg")
+
+        # Bulk-fetch Article records to avoid N+1 queries via ArticleProc.article
+        sps_pkg_id_list = [
+            ap.sps_pkg_id for ap in article_procs if ap.sps_pkg_id
+        ]
+        articles_by_sps_pkg = {}
+        if sps_pkg_id_list:
+            for article in Article.objects.filter(
+                sps_pkg_id__in=sps_pkg_id_list
+            ).only("id", "pid_v2", "sps_pkg_id", "pp_xml_id"):
+                articles_by_sps_pkg[article.sps_pkg_id] = article
+
+        events = []
+        sps_pkg_ids = set()
+        pp_xml_ids = set()
+        article_ids = []
+
+        for article_proc in article_procs:
+            try:
+                article = articles_by_sps_pkg.get(article_proc.sps_pkg_id)
+                if not article or not article.pid_v2:
+                    continue
+
+                order = article_proc.migrated_data.document.order
+                if not order:
+                    continue
+
+                if not cls.has_valid_pid_v2(article.pid_v2, order):
+                    try:
+                        expected_suffix = str(int(str(order).strip())).zfill(5)
+                    except (TypeError, ValueError):
+                        expected_suffix = str(order)
+                    events.append(
+                        f"Invalid pid_v2: {article.pid_v2} "
+                        f"(order={order}, "
+                        f"expected suffix={expected_suffix}, "
+                        f"actual suffix={article.pid_v2[-5:]})"
+                    )
+                    article_ids.append(article.id)
+                    if article.sps_pkg_id:
+                        sps_pkg_ids.add(article.sps_pkg_id)
+                    if article.pp_xml_id:
+                        pp_xml_ids.add(article.pp_xml_id)
+            except Exception as e:
+                logging.exception(
+                    f"Error checking pid_v2 for ArticleProc {article_proc}: {e}"
+                )
+
+        if not article_ids:
+            events.append("No migrated articles with invalid pid_v2 found")
+            return events
+
+        with transaction.atomic():
+            deleted_articles, _ = cls.objects.filter(id__in=article_ids).delete()
+            events.append(f"Articles deletados: {deleted_articles}")
+
+            if sps_pkg_ids:
+                deleted_sps, _ = SPSPkg.objects.filter(id__in=sps_pkg_ids).delete()
+                events.append(f"SPSPkg deletados: {deleted_sps}")
+
+            if pp_xml_ids:
+                deleted_pp, _ = PidProviderXML.objects.filter(id__in=pp_xml_ids).delete()
+                events.append(f"PidProviderXML deletados: {deleted_pp}")
+
+        return events
+
+    @classmethod
+    def exclude_inconvenient_articles(cls, journal, user, timeout=None):
+        """
+        Remove all inconvenient article records in a unified operation:
+        1. Migrated articles with invalid pid_v2 (suffix doesn't match order from v121)
+        2. Duplicate articles (repeated pid_v2 or sps_pkg_name)
+        """
+        results = {
+            "events": [],
+            "numbers": {},
+            "exceptions": [],
+        }
+
+        try:
+            events = cls.exclude_articles_with_invalid_pid_v2(journal)
+            results["events"].extend(events)
+        except Exception as e:
+            results["exceptions"].append(
+                {
+                    "exclude_articles_with_invalid_pid_v2": str(e),
+                    "traceback": traceback.format_exc(),
+                }
+            )
+
+        for field_name in ("pid_v2", "sps_pkg__sps_pkg_name"):
+            repeated_items = cls.get_repeated_items(field_name, journal)
+            results["numbers"][f"repeated_by_{field_name}"] = repeated_items.count()
+            for repeated_value in repeated_items:
+                try:
+                    events = cls.exclude_repetitions(
+                        user, field_name, repeated_value, timeout=timeout
+                    )
+                    results["events"].extend(events)
+                except Exception as e:
+                    results["exceptions"].append(
+                        {
+                            f"repeated_by_{field_name}": repeated_value,
+                            "traceback": traceback.format_exc(),
+                        }
+                    )
+
+        return results
+
     @classmethod
     def select_articles(cls, journal_id_list=None, issue_id_list=None):
         kwargs = {}