pulp-ansible 0.26.0__py3-none-any.whl → 0.27.1__py3-none-any.whl

pulp_ansible/app/__init__.py

@@ -8,5 +8,6 @@ class PulpAnsiblePluginAppConfig(PulpPluginAppConfig):
 
     name = "pulp_ansible.app"
     label = "ansible"
-    version = "0.26.0"
+    version = "0.27.1"
     python_package_name = "pulp-ansible"
+    domain_compatible = True

pulp_ansible/app/galaxy/v3/serializers.py

@@ -3,19 +3,25 @@ from django.conf import settings
 from drf_spectacular.utils import extend_schema_field, extend_schema_serializer
 from drf_spectacular.types import OpenApiTypes
 from rest_framework.reverse import reverse
-from rest_framework import serializers, relations
+from rest_framework import serializers
 
-from pulp_ansible.app import models, fields, serializers as ansible_serializers
+from pulpcore.plugin.util import get_domain
 from pulpcore.plugin.models import RepositoryVersion
 from pulpcore.plugin import serializers as core_serializers
 
+from pulp_ansible.app import models, fields, serializers as ansible_serializers
+
+DOMAIN_ENABLED = settings.DOMAIN_ENABLED
+
 
 def _get_distro_context(context):
     distro_context = {}
-    if "path" in context:
-        distro_context["path"] = context["path"]
+    if path := context.get("path") or context.get("distro_base_path"):
+        distro_context["path"] = path
     if "distro_base_path" in context:
         distro_context["distro_base_path"] = context["distro_base_path"]
+    if DOMAIN_ENABLED:
+        distro_context["pulp_domain"] = get_domain().name
     return distro_context
 
 
@@ -165,8 +171,6 @@ class CollectionMetadataSerializer(serializers.ModelSerializer):
     A serializer for a CollectionVersion metadata.
     """
 
-    tags = relations.ManyRelatedField(relations.StringRelatedField())
-
     class Meta:
         model = models.CollectionVersion
         fields = (
@@ -265,9 +269,16 @@ class UnpaginatedCollectionVersionSerializer(CollectionVersionListSerializer):
             # because using the request context to generate the full URL causes the download URL
             # to be inaccessible when pulp is running behind a reverse proxy.
             host = settings.ANSIBLE_API_HOSTNAME.strip("/")
+            extra_args = {}
+            if DOMAIN_ENABLED:
+                extra_args["pulp_domain"] = get_domain().name
             path = reverse(
                 settings.ANSIBLE_URL_NAMESPACE + "collection-artifact-download",
-                kwargs={"distro_base_path": distro_base_path, "filename": filename_path},
+                kwargs={
+                    "distro_base_path": distro_base_path,
+                    "filename": filename_path,
+                    **extra_args,
+                },
             ).strip("/")
 
             return f"{host}/{path}"

pulp_ansible/app/galaxy/v3/views.py

@@ -40,6 +40,7 @@ from pulpcore.plugin.viewsets import (
     NAME_FILTER_OPTIONS,
 )
 from pulpcore.plugin.tasking import add_and_remove, dispatch, general_create
+from pulpcore.plugin.util import get_domain, get_domain_pk, get_url
 
 from pulp_ansible.app.galaxy.v3.exceptions import ExceptionHandlerMixin
 from pulp_ansible.app.galaxy.v3.serializers import (
@@ -81,6 +82,8 @@ from pulp_ansible.app.tasks.deletion import delete_collection_version, delete_co
 from pulp_ansible.app.utils import filter_content_for_repo_version
 
 
+DOMAIN_ENABLED = settings.DOMAIN_ENABLED
+
 _CAN_VIEW_REPO_CONTENT = {
     "action": ["list", "retrieve", "download"],
     "principal": "authenticated",
@@ -131,6 +134,7 @@ class AnsibleDistributionMixin:
                 "base_path", "repository_version", "repository"
             ).select_related("repository__ansible_ansiblerepository"),
             base_path=path,
+            pulp_domain=get_domain_pk(),
         )
         if distro.repository_version_id:
             self.pulp_context = {path: distro.repository_version}
@@ -334,7 +338,7 @@ class CollectionViewSet(
         )
 
         download_count_qs = CollectionDownloadCount.objects.filter(
-            name=OuterRef("name"), namespace=OuterRef("namespace")
+            name=OuterRef("name"), namespace=OuterRef("namespace"), pulp_domain=get_domain()
         )
 
         qs = (
@@ -460,7 +464,9 @@ def get_collection_dependents(parent):
     """Given a parent collection, return a list of collection versions that depend on it."""
     key = f"{parent.namespace}.{parent.name}"
     return list(
-        CollectionVersion.objects.exclude(collection=parent).filter(dependencies__has_key=key)
+        CollectionVersion.objects.exclude(collection=parent).filter(
+            dependencies__has_key=key, pulp_domain=get_domain()
+        )
     )
 
 
@@ -477,7 +483,9 @@ def get_unique_dependents(parent):
         other_versions.append(semantic_version.Version(v.version))
 
     dependents = []
-    for child in CollectionVersion.objects.filter(dependencies__has_key=key):
+    for child in CollectionVersion.objects.filter(
+        dependencies__has_key=key, pulp_domain=get_domain()
+    ):
         spec = semantic_version.SimpleSpec(child.dependencies[key])
 
         # If this collection matches the parent collections version and there are no other
@@ -567,7 +575,7 @@ class CollectionUploadViewSet(
         serializer.is_valid(raise_exception=True)
 
         # Check that namespace, name and version can be extracted
-        request.data["repository"] = reverse("repositories-ansible/ansible-detail", args=[repo.pk])
+        request.data["repository"] = get_url(repo)
         serializer = CollectionVersionUploadSerializer(
             data=request.data, context=self.get_serializer_context()
         )
@@ -585,10 +593,14 @@ class CollectionUploadViewSet(
         )
         # Create CollectionImport and response
         CollectionImport.objects.create(task_id=task.pk)
+        if DOMAIN_ENABLED:
+            kwargs = {"pk": task.pk, "pulp_domain": get_domain().name}
+        else:
+            kwargs = {"pk": task.pk}
         data = {
             "task": reverse(
                 settings.ANSIBLE_URL_NAMESPACE + "collection-imports-detail",
-                kwargs={"pk": task.pk},
+                kwargs=kwargs,
                 request=None,
             )
         }
@@ -704,11 +716,14 @@ class CollectionArtifactDownloadView(GalaxyAuthMixin, views.APIView, AnsibleDist
     def get(self, request, *args, **kwargs):
         """Download collection."""
         distro_base_path = self.kwargs["distro_base_path"]
-        distribution = AnsibleDistribution.objects.get(base_path=distro_base_path)
+        distribution = AnsibleDistribution.objects.get(
+            base_path=distro_base_path, pulp_domain=get_domain()
+        )
 
-        url = "{host}/{prefix}/{distro_base_path}/{filename}".format(
+        url = "{host}/{prefix}{domain}/{distro_base_path}/{filename}".format(
             host=settings.CONTENT_ORIGIN.strip("/"),
             prefix=settings.CONTENT_PATH_PREFIX.strip("/"),
+            domain="/" + get_domain().name if DOMAIN_ENABLED else "",
             distro_base_path=distro_base_path,
             filename=self.kwargs["filename"],
         )
@@ -799,7 +814,9 @@ class AnsibleNamespaceViewSet(
             except IntegrityError:
                 # if artifact already exists, let's use it
                 try:
-                    artifact = Artifact.objects.get(sha256=artifact.sha256)
+                    artifact = Artifact.objects.get(
+                        sha256=artifact.sha256, pulp_domain=get_domain()
+                    )
                     artifact.touch()
                 except (Artifact.DoesNotExist, DatabaseError):
                     # the artifact has since been removed from when we first attempted to save it
@@ -831,7 +848,9 @@ class AnsibleNamespaceViewSet(
                 serializer.validated_data.setdefault(name, serializer.data[name])
         context = {}
         if "avatar" not in request.data and namespace.avatar_sha256:
-            context["artifact"] = Artifact.objects.get(sha256=namespace.avatar_sha256).pk
+            context["artifact"] = Artifact.objects.get(
+                sha256=namespace.avatar_sha256, pulp_domain=get_domain()
+            ).pk
         return self._create(request, data=serializer.validated_data, context=context)
 
     def delete(self, request, *args, **kwargs):
@@ -1283,7 +1302,10 @@ def redirect_view_generator(actions, url, viewset, distro_view=True, responses={
                     # remove the old path kwarg since we're redirecting to the new api endpoints
                     del kwargs["path"]
 
-                kwargs = {**self.kwargs, "distro_base_path": path}
+                kwargs["distro_base_path"] = path
+
+            if DOMAIN_ENABLED:
+                kwargs["pulp_domain"] = get_domain().name
 
             # don't pass request. redirects work with just the path and this solves the client
             # redirect issues for aiohttp
@@ -1293,9 +1315,9 @@ def redirect_view_generator(actions, url, viewset, distro_view=True, responses={
                 # request=self.request,
             )
 
-            args = self.request.META.get("QUERY_STRING", "")
-            if args:
-                url = "%s?%s" % (url, args)
+            qs = self.request.META.get("QUERY_STRING", "")
+            if qs:
+                url = "%s?%s" % (url, qs)
 
             return url
 

pulp_ansible/app/galaxy/v3/viewsets.py

@@ -9,7 +9,7 @@ from pulp_ansible.app.galaxy.v3.serializers import (
 )
 from pulp_ansible.app.galaxy.mixins import GalaxyAuthMixin
 
-from pulpcore.plugin.util import get_url
+from pulpcore.plugin.util import get_url, get_domain_pk
 
 from pulp_ansible.app.models import CrossRepositoryCollectionVersionIndex, AnsibleDistribution
 
@@ -83,7 +83,7 @@ class CollectionVersionSearchViewSet(GalaxyAuthMixin, viewsets.ModelViewSet):
             .select_related("collection_version")
             .select_related("repository_version")
             .select_related("namespace_metadata")
-            .all()
+            .filter(repository__pulp_domain_id=get_domain_pk())
         )
 
         for permission_class in self.get_permissions():

pulp_ansible/app/galaxy/views.py

@@ -3,6 +3,7 @@ import re
 from django.shortcuts import get_object_or_404
 from drf_spectacular.utils import extend_schema, extend_schema_view
 from rest_framework import generics, response, views
+from pulpcore.plugin.util import get_domain
 
 from pulp_ansible.app.models import AnsibleDistribution, Role
 
@@ -89,7 +90,9 @@ class RoleList(DistributionMixin, generics.ListAPIView):
         """
         Get the list of items for this view.
         """
-        roles = Role.objects.distinct("namespace", "name").filter(pk__in=self._distro_content)
+        roles = Role.objects.distinct("namespace", "name").filter(
+            pk__in=self._distro_content, pulp_domain=get_domain()
+        )
 
         namespace = self.request.query_params.get("owner__username", None)
         if namespace:
@@ -117,5 +120,7 @@ class RoleVersionList(DistributionMixin, generics.ListAPIView):
         Get the list of items for this view.
         """
         namespace, name = re.split(r"\.", self.kwargs["role_pk"])
-        versions = Role.objects.filter(pk__in=self._distro_content, name=name, namespace=namespace)
+        versions = Role.objects.filter(
+            pk__in=self._distro_content, name=name, namespace=namespace, pulp_domain=get_domain()
+        )
         return versions

pulp_ansible/app/migrations/0062_pivot_collectionversion_tags.py

@@ -0,0 +1,140 @@
+# Generated by Django 4.2.19 on 2025-05-21 13:50
+
+import django.contrib.postgres.fields
+from django.db import migrations, models
+from pulpcore.plugin.migrations import RequireVersion
+
+
+def migrate_missing_tags_up(apps, schema):
+    CollectionVersion = apps.get_model("ansible", "CollectionVersion")
+    cv_to_update = []
+    for cv in CollectionVersion.objects.filter(new_tags=None).prefetch_related("tags"):
+        cv.new_tags = [t.name for t in cv.tags.all()]
+        cv_to_update.append(cv)
+        if len(cv_to_update) >= 100:
+            CollectionVersion.objects.bulk_update(cv_to_update, ["new_tags"])
+            cv_to_update = []
+    if len(cv_to_update) > 0:
+        CollectionVersion.objects.bulk_update(cv_to_update, ["new_tags"])
+
+
+def migrate_missing_tags_down(apps, schema):
+    # Warning, this Down-Migration is not Zero-Downtime safe.
+    # Also it's not optimized.
+    Tag = apps.get_model("ansible", "Tag")
+    CollectionVersion = apps.get_model("ansible", "CollectionVersion")
+    for cv in CollectionVersion.objects.filter(new_tags__len__gt=0):
+        for tag_name in cv.new_tags:
+            tag, created = Tag.objects.get_or_create(name=tag_name)
+            cv.tags.add(tag)
+
+
+# This query generates full text search index based
+# the following data ranked from A to D:
+#   - Namespace name (weight A)
+#   - Collection name (weight A)
+#   - Collection tags (weight B)
+#   - Collection content names (weight C)
+#   - Collection description (weight D)
+NEW_TS_VECTOR_SELECT = """
+    setweight(to_tsvector(coalesce(NEW.namespace,'')), 'A')
+    || setweight(to_tsvector(coalesce(NEW.name, '')), 'A')
+    || setweight(to_tsvector(array_to_string(coalesce(NEW.tags, ARRAY[]::bpchar[]), ' ')), 'B')
+    || (
+      SELECT
+        setweight(to_tsvector(coalesce(string_agg(cvc ->> 'name', ' '), '')), 'C')
+      FROM jsonb_array_elements(NEW.contents) AS cvc
+    )
+    || setweight(to_tsvector(coalesce(NEW.description, '')), 'D')
+"""
+
+OLD_TS_VECTOR_SELECT = """
+    SELECT
+    setweight(to_tsvector(coalesce(namespace,'')), 'A')
+    || setweight(to_tsvector(coalesce(name, '')), 'A')
+    || (
+      SELECT
+        setweight(to_tsvector(
+          coalesce(string_agg("ansible_tag"."name", ' '), '')
+        ), 'B')
+      FROM
+        "ansible_tag" INNER JOIN "ansible_collectionversion_tags"
+        ON
+        ("ansible_tag"."pulp_id" = "ansible_collectionversion_tags"."tag_id" )
+      WHERE
+        "ansible_collectionversion_tags"."collectionversion_id" = cv.content_ptr_id
+    )
+    || (
+      SELECT
+        setweight(to_tsvector(
+          coalesce(string_agg(cvc ->> 'name', ' '), '')
+        ), 'C')
+      FROM jsonb_array_elements(cv.contents) AS cvc
+    )
+    || setweight(to_tsvector(coalesce(description, '')), 'D')
+    FROM ansible_collectionversion cv
+    WHERE cv.content_ptr_id = NEW.content_ptr_id
+"""
+
+# Creates a database function and a trigger to update collection search
+# vector field.
+# In the new version, tags are availabel at create and content should never be updated,
+# so having both insert and update in the trigger from now on is probably fast _and_ safe.
+UPDATE_COLLECTIONS_TS_VECTOR_TRIGGER = """
+SET CONSTRAINTS ALL IMMEDIATE;
+CREATE OR REPLACE FUNCTION update_collection_ts_vector()
+    RETURNS TRIGGER AS
+$$
+BEGIN
+    NEW.search_vector := ({TS_VECTOR_SELECT});
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+DROP TRIGGER IF EXISTS update_ts_vector ON ansible_collectionversion;
+CREATE TRIGGER update_ts_vector
+    {WHEN}
+    ON ansible_collectionversion
+    FOR EACH ROW
+EXECUTE FUNCTION update_collection_ts_vector();
+"""
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("ansible", "0061_collectionversion_new_tags"),
+    ]
+
+    operations = [
+        RequireVersion("ansible", "0.26.0"),
+        migrations.RunPython(code=migrate_missing_tags_up, reverse_code=migrate_missing_tags_down),
+        migrations.RunSQL(
+            sql=UPDATE_COLLECTIONS_TS_VECTOR_TRIGGER.format(
+                TS_VECTOR_SELECT=NEW_TS_VECTOR_SELECT,
+                WHEN="BEFORE INSERT OR UPDATE",
+            ),
+            reverse_sql=UPDATE_COLLECTIONS_TS_VECTOR_TRIGGER.format(
+                TS_VECTOR_SELECT=OLD_TS_VECTOR_SELECT,
+                WHEN="BEFORE UPDATE",
+            ),
+        ),
+        migrations.RemoveField(
+            model_name="collectionversion",
+            name="tags",
+        ),
+        migrations.DeleteModel(
+            name="Tag",
+        ),
+        migrations.RenameField(
+            model_name="collectionversion",
+            old_name="new_tags",
+            new_name="tags",
+        ),
+        migrations.AlterField(
+            model_name="collectionversion",
+            name="tags",
+            field=django.contrib.postgres.fields.ArrayField(
+                base_field=models.CharField(max_length=64, unique=True), default=list, size=None
+            ),
+        ),
+    ]

pulp_ansible/app/migrations/0063_domain_support.py

@@ -0,0 +1,118 @@
+# Generated by Django 4.2.19 on 2025-04-15 16:27
+
+from django.db import migrations, models
+import django.db.models.deletion
+import pulpcore.app.util
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("core", "0117_task_unblocked_at"),
+        ("ansible", "0062_pivot_collectionversion_tags"),
+    ]
+
+    operations = [
+        migrations.AlterUniqueTogether(
+            name="ansiblecollectiondeprecated",
+            unique_together=set(),
+        ),
+        migrations.AlterUniqueTogether(
+            name="ansiblenamespacemetadata",
+            unique_together=set(),
+        ),
+        migrations.AlterUniqueTogether(
+            name="collectionversion",
+            unique_together=set(),
+        ),
+        migrations.AlterUniqueTogether(
+            name="collectionversionmark",
+            unique_together=set(),
+        ),
+        migrations.AlterUniqueTogether(
+            name="collectionversionsignature",
+            unique_together=set(),
+        ),
+        migrations.AlterUniqueTogether(
+            name="role",
+            unique_together=set(),
+        ),
+        migrations.AddField(
+            model_name="ansiblecollectiondeprecated",
+            name="_pulp_domain",
+            field=models.ForeignKey(
+                default=pulpcore.app.util.get_domain_pk,
+                on_delete=django.db.models.deletion.PROTECT,
+                to="core.domain",
+            ),
+        ),
+        migrations.AddField(
+            model_name="ansiblenamespacemetadata",
+            name="_pulp_domain",
+            field=models.ForeignKey(
+                default=pulpcore.app.util.get_domain_pk,
+                on_delete=django.db.models.deletion.PROTECT,
+                to="core.domain",
+            ),
+        ),
+        migrations.AddField(
+            model_name="collectionversion",
+            name="_pulp_domain",
+            field=models.ForeignKey(
+                default=pulpcore.app.util.get_domain_pk,
+                on_delete=django.db.models.deletion.PROTECT,
+                to="core.domain",
+            ),
+        ),
+        migrations.AddField(
+            model_name="collectionversionmark",
+            name="_pulp_domain",
+            field=models.ForeignKey(
+                default=pulpcore.app.util.get_domain_pk,
+                on_delete=django.db.models.deletion.PROTECT,
+                to="core.domain",
+            ),
+        ),
+        migrations.AddField(
+            model_name="collectionversionsignature",
+            name="_pulp_domain",
+            field=models.ForeignKey(
+                default=pulpcore.app.util.get_domain_pk,
+                on_delete=django.db.models.deletion.PROTECT,
+                to="core.domain",
+            ),
+        ),
+        migrations.AddField(
+            model_name="role",
+            name="_pulp_domain",
+            field=models.ForeignKey(
+                default=pulpcore.app.util.get_domain_pk,
+                on_delete=django.db.models.deletion.PROTECT,
+                to="core.domain",
+            ),
+        ),
+        migrations.AlterUniqueTogether(
+            name="ansiblecollectiondeprecated",
+            unique_together={("namespace", "name", "_pulp_domain")},
+        ),
+        migrations.AlterUniqueTogether(
+            name="ansiblenamespacemetadata",
+            unique_together={("metadata_sha256", "_pulp_domain")},
+        ),
+        migrations.AlterUniqueTogether(
+            name="collectionversion",
+            unique_together={("sha256", "_pulp_domain")},
+        ),
+        migrations.AlterUniqueTogether(
+            name="collectionversionmark",
+            unique_together={("value", "marked_collection", "_pulp_domain")},
+        ),
+        migrations.AlterUniqueTogether(
+            name="collectionversionsignature",
+            unique_together={("pubkey_fingerprint", "signed_collection", "_pulp_domain")},
+        ),
+        migrations.AlterUniqueTogether(
+            name="role",
+            unique_together={("version", "name", "namespace", "_pulp_domain")},
+        ),
+    ]

pulp_ansible/app/migrations/0064_alter_collection_unique_together_and_more.py

@@ -0,0 +1,68 @@
+# Generated by Django 4.2.22 on 2025-07-01 14:04
+
+from django.db import migrations, models
+import django.db.models.deletion
+import pulpcore.app.util
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("core", "0123_upstreampulp_q_select"),
+        ("ansible", "0063_domain_support"),
+    ]
+
+    operations = [
+        migrations.AlterUniqueTogether(
+            name="collection",
+            unique_together=set(),
+        ),
+        migrations.AlterUniqueTogether(
+            name="collectiondownloadcount",
+            unique_together=set(),
+        ),
+        migrations.AddField(
+            model_name="ansiblenamespace",
+            name="pulp_domain",
+            field=models.ForeignKey(
+                default=pulpcore.app.util.get_domain_pk,
+                on_delete=django.db.models.deletion.PROTECT,
+                to="core.domain",
+            ),
+        ),
+        migrations.AddField(
+            model_name="collection",
+            name="pulp_domain",
+            field=models.ForeignKey(
+                default=pulpcore.app.util.get_domain_pk,
+                on_delete=django.db.models.deletion.PROTECT,
+                to="core.domain",
+            ),
+        ),
+        migrations.AddField(
+            model_name="collectiondownloadcount",
+            name="pulp_domain",
+            field=models.ForeignKey(
+                default=pulpcore.app.util.get_domain_pk,
+                on_delete=django.db.models.deletion.PROTECT,
+                to="core.domain",
+            ),
+        ),
+        migrations.AlterField(
+            model_name="ansiblenamespace",
+            name="name",
+            field=models.CharField(max_length=64),
+        ),
+        migrations.AlterUniqueTogether(
+            name="ansiblenamespace",
+            unique_together={("pulp_domain", "name")},
+        ),
+        migrations.AlterUniqueTogether(
+            name="collection",
+            unique_together={("pulp_domain", "namespace", "name")},
+        ),
+        migrations.AlterUniqueTogether(
+            name="collectiondownloadcount",
+            unique_together={("pulp_domain", "namespace", "name")},
+        ),
+    ]

pulp_ansible/app/modelresource.py

@@ -1,7 +1,7 @@
 import json
 
 from import_export import fields
-from import_export.widgets import ManyToManyWidget, Widget
+from import_export.widgets import Widget
 from pulpcore.plugin.importexport import BaseContentResource, QueryModelResource
 from pulp_ansible.app.models import (
     AnsibleCollectionDeprecated,
@@ -10,7 +10,6 @@ from pulp_ansible.app.models import (
     CollectionVersionMark,
     Role,
     Collection,
-    Tag,
     CollectionVersion,
     CollectionVersionSignature,
 )
@@ -99,10 +98,6 @@ class CollectionVersionContentResource(BaseContentResource):
     Resource for import/export of ansible_collectionversion-content entities.
     """
 
-    tags = fields.Field(
-        column_name="tags", attribute="tags", widget=ManyToManyWidget(Tag, field="name")
-    )
-
     def before_import_row(self, row, **kwargs):
         """
         Finds and sets collection using name and namespace.
@@ -222,29 +217,11 @@ class CollectionDeprecationResource(BaseContentResource):
         import_id_fields = ("namespace", "name")
 
 
-class TagResource(QueryModelResource):
-    """
-    Resource for import/export of ansible_tag entities.
-    """
-
-    def set_up_queryset(self):
-        """
-        :return: Tags specific to a specified repo-version.
-        """
-        collection_versions = CollectionVersion.objects.filter(pk__in=self.repo_version.content)
-        return Tag.objects.filter(pk__in=collection_versions.values_list("tags", flat=True))
-
-    class Meta:
-        model = Tag
-        import_id_fields = ("name",)
-
-
 IMPORT_ORDER = [
     AnsibleNamespaceResource,
     AnsibleNamespaceMetadataResource,
     CollectionResource,
     CollectionDeprecationResource,
-    TagResource,
     CollectionVersionContentResource,
     CollectionVersionMarkResource,
     CollectionVersionSignatureResource,