feat: adds content tagging app, models, and API

cms/djangoapps/contentstore/helpers.py

@@ -20,8 +20,6 @@
 from xmodule.modulestore.django import modulestore
 
 from cms.djangoapps.models.settings.course_grading import CourseGradingModel
-from common.djangoapps.student import auth
-from common.djangoapps.student.roles import CourseCreatorRole, OrgContentCreatorRole
 import openedx.core.djangoapps.content_staging.api as content_staging_api
 
 from .utils import reverse_course_url, reverse_library_url, reverse_usage_url
@@ -377,15 +375,3 @@ def is_item_in_course_tree(item):
         ancestor = ancestor.get_parent()
 
     return ancestor is not None
-
-
-def is_content_creator(user, org):
-    """
-    Check if the user has the role to create content.
-
-    This function checks if the User has role to create content
-    or if the org is supplied, it checks for Org level course content
-    creator.
-    """
-    return (auth.user_has_role(user, CourseCreatorRole()) or
-            auth.user_has_role(user, OrgContentCreatorRole(org=org)))

cms/djangoapps/contentstore/views/course.py

@@ -45,7 +45,8 @@
     has_course_author_access,
     has_studio_read_access,
     has_studio_write_access,
-    has_studio_advanced_settings_access
+    has_studio_advanced_settings_access,
+    is_content_creator,
 )
 from common.djangoapps.student.roles import (
     CourseInstructorRole,
@@ -102,7 +103,6 @@
     update_course_details,
 )
 from .component import ADVANCED_COMPONENT_TYPES
-from ..helpers import is_content_creator
 from cms.djangoapps.contentstore.xblock_services.xblock_service import (
     create_xblock_info,
 )

cms/djangoapps/contentstore/views/library.py

@@ -30,7 +30,8 @@
     STUDIO_VIEW_USERS,
     get_user_permissions,
     has_studio_read_access,
-    has_studio_write_access
+    has_studio_write_access,
+    is_content_creator,
 )
 from common.djangoapps.student.roles import (
     CourseInstructorRole,
@@ -42,7 +43,6 @@
 from ..config.waffle import REDIRECT_TO_LIBRARY_AUTHORING_MICROFRONTEND
 from ..utils import add_instructor, reverse_library_url
 from .component import CONTAINER_TEMPLATES, get_component_templates
-from ..helpers import is_content_creator
 from cms.djangoapps.contentstore.xblock_services.xblock_service import create_xblock_info
 from .user import user_with_role
 

cms/envs/common.py

@@ -1756,6 +1756,11 @@
     # API Documentation
     'drf_yasg',
 
+    # Tagging
+    'openedx_tagging.core.tagging.apps.TaggingConfig',
+    'openedx.features.content_tagging',
+
+    # Features
     'openedx.features.course_duration_limits',
     'openedx.features.content_type_gating',
     'openedx.features.discounts',

common/djangoapps/student/auth.py

@@ -150,6 +150,18 @@ def has_studio_read_access(user, course_key):
     return bool(STUDIO_VIEW_CONTENT & get_user_permissions(user, course_key))
 
 
+def is_content_creator(user, org):
+    """
+    Check if the user has the role to create content.
+
+    This function checks if the User has role to create content
+    or if the org is supplied, it checks for Org level course content
+    creator.
+    """
+    return (user_has_role(user, CourseCreatorRole()) or
+            user_has_role(user, OrgContentCreatorRole(org=org)))
+
+
 def add_users(caller, role, *users):
     """
     The caller requests adding the given users to the role. Checks that the caller

lms/envs/common.py

@@ -3216,6 +3216,10 @@ def _make_locale_paths(settings):  # pylint: disable=missing-function-docstring
     # Course Goals
     'lms.djangoapps.course_goals.apps.CourseGoalsConfig',
 
+    # Tagging
+    'openedx_tagging.core.tagging.apps.TaggingConfig',
+    'openedx.features.content_tagging',
+
     # Features
     'openedx.features.calendar_sync',
     'openedx.features.course_bookmarks',

openedx/features/content_tagging/admin.py

@@ -0,0 +1,19 @@
+""" Tagging app admin """
+from django.contrib import admin
+
+from .models import ContentTaxonomy
+
+
+class ContentTaxonomyOrgAdmin(admin.TabularInline):
+    model = ContentTaxonomy.org_owners.through
+
+
+class ContentTaxonomyAdmin(admin.ModelAdmin):
+    """
+    Admin form for the content taxonomy table.
+    """
+
+    inlines = (ContentTaxonomyOrgAdmin,)
+
+
+admin.site.register(ContentTaxonomy, ContentTaxonomyAdmin)

openedx/features/content_tagging/api.py

@@ -0,0 +1,83 @@
+"""
+Content Tagging APIs
+"""
+from typing import List
+
+import openedx_tagging.core.tagging.api as oel_tagging
+from django.db.models import QuerySet
+from organizations.models import Organization
+
+from .models import ContentTaxonomy
+
+
+def create_taxonomy(
+    name,
+    org_owners: List[Organization] = None,
+    description=None,
+    enabled=True,
+    required=False,
+    allow_multiple=False,
+    allow_free_text=False,
+) -> ContentTaxonomy:
+    """
+    Creates, saves, and returns a new ContentTaxonomy with the given attributes.
+
+    If `org_owners` is empty/None, then the returned taxonomy is enabled for all organizations.
+    """
+    taxonomy = ContentTaxonomy.objects.create(
+        name=name,
+        description=description,
+        enabled=enabled,
+        required=required,
+        allow_multiple=allow_multiple,
+        allow_free_text=allow_free_text,
+    )
+    if org_owners:
+        set_taxonomy_org_owners(taxonomy, org_owners)
+    return taxonomy
+
+
+def set_taxonomy_org_owners(
+    taxonomy: ContentTaxonomy,
+    org_owners: List[Organization] = None,
+) -> ContentTaxonomy:
+    """
+    Updates the list of org_owners on the given taxonomy.
+
+    If `org_owners` is empty/None, then the returned taxonomy is enabled for all organizations.
+    """
+    if org_owners:
+        taxonomy.org_owners.set(org_owners)
+    else:
+        taxonomy.org_owners.clear()
+    return taxonomy
+
+
+def get_taxonomies_for_org(org_owner: Organization = None, enabled=True) -> QuerySet:
+    """
+    Returns a queryset containing the enabled ContentTaxonomies owned by the given org, sorted by name.
+
+    If you want all Taxonomies, not just ContentTaxonomies, use the get_taxonomies API method, and use `enabled_for_org`
+    on any returned ContentTaxonomies to filter out by org ownership.
+
+    If you want the disabled ContentTaxonomies, pass enabled=False.
+    If you want all ContentTaxonomies (both enabled and disabled), pass enabled=None.
+    """
+    return (
+        ContentTaxonomy.objects.filter_enabled(
+            org_owner,
+            enabled,
+        )
+        .order_by("name", "id")
+        .select_subclasses()
+    )
+
+
+# Expose the oel_tagging APIs that we haven't overridden here:
+
+get_taxonomies = oel_tagging.get_taxonomies
+get_taxonomy = oel_tagging.get_taxonomy
+get_tags = oel_tagging.get_tags
+resync_object_tags = oel_tagging.resync_object_tags
+get_object_tags = oel_tagging.get_object_tags
+tag_object = oel_tagging.tag_object

openedx/features/content_tagging/apps.py

@@ -0,0 +1,12 @@
+"""
+Define the content tagging Django App.
+"""
+
+from django.apps import AppConfig
+
+
+class ContentTaggingConfig(AppConfig):
+    """App config for the content tagging feature"""
+
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "openedx.features.content_tagging"

openedx/features/content_tagging/migrations/0001_initial.py

@@ -0,0 +1,72 @@
+# Generated by Django 3.2.19 on 2023-06-19 22:44
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+    initial = True
+
+    dependencies = [
+        ("organizations", "0003_historicalorganizationcourse"),
+        ("oel_tagging", "0001_initial"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="ContentTaxonomy",
+            fields=[
+                (
+                    "taxonomy_ptr",
+                    models.OneToOneField(
+                        auto_created=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        parent_link=True,
+                        primary_key=True,
+                        serialize=False,
+                        to="oel_tagging.taxonomy",
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name_plural": "ContentTaxonomies",
+            },
+            bases=("oel_tagging.taxonomy",),
+        ),
+        migrations.CreateModel(
+            name="ContentTaxonomyOrg",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                (
+                    "org",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="organizations.organization",
+                    ),
+                ),
+                (
+                    "taxonomy",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="content_tagging.contenttaxonomy",
+                    ),
+                ),
+            ],
+        ),
+        migrations.AddField(
+            model_name="contenttaxonomy",
+            name="org_owners",
+            field=models.ManyToManyField(
+                through="content_tagging.ContentTaxonomyOrg",
+                to="organizations.Organization",
+            ),
+        ),
+    ]

openedx/features/content_tagging/models.py

@@ -0,0 +1,103 @@
+"""
+Content Tagging models
+"""
+from django.db import models
+from opaque_keys import InvalidKeyError
+from opaque_keys.edx.keys import CourseKey, UsageKey
+from openedx_tagging.core.tagging.models import Taxonomy, TaxonomyManager
+from organizations.models import Organization
+
+
+class ContentTaxonomyManager(TaxonomyManager):
+    """
+    Manages ContentTaxonomy objects, providing custom utility methods.
+
+    Inherits from InheritanceManager so that subclasses of ContentTaxonomy can be selected in a queryset.
+    """
+
+    def filter_enabled(self, org: Organization = None, enabled=True) -> models.QuerySet:
+        """
+        Returns a query set filtered to return the enabled ContentTaxonomy objects owned by the given org.
+        """
+        queryset = self
+        if enabled is not None:
+            queryset = queryset.filter(enabled=enabled)
+        org_filter = models.Q(org_owners=None)
+        if org:
+            org_filter |= models.Q(org_owners=org)
+        queryset = queryset.filter(org_filter)
+        return queryset
+
+
+class ContentTaxonomy(Taxonomy):
+    """
+    Taxonomy used for tagging content-related objects.
+
+    ContentTaxonomies can be owned by one or more organizations, which allows content authors from that organization to
+    create taxonomies, edit the taxonomy fields, and add/edit/remove Tags linked to the taxonomy.
+
+    .. no_pii:
+    """
+
+    objects = ContentTaxonomyManager()
+
+    org_owners = models.ManyToManyField(Organization, through="ContentTaxonomyOrg")
+
+    class Meta:
+        verbose_name_plural = "ContentTaxonomies"
+
+    def validate_object_tag(
+        self,
+        object_tag: "ObjectTag",
+        check_taxonomy=True,
+        check_tag=True,
+        check_object=True,
+    ) -> bool:
+        """
+        Returns True if the given object tag is valid for this ContentTaxonomy.
+
+        Extends the superclass method by adding its own object checks to ensure:
+
+        * object_tag.object_id is a valid UsageKey or CourseKey, and
+        * object_tag.object_id's "org" is enabled for this taxonomy.
+        """
+        if check_object:
+            # ContentTaxonomies require object_id to be a valid CourseKey or UsageKey
+            try:
+                object_key = UsageKey.from_string(object_tag.object_id)
+            except InvalidKeyError:
+                try:
+                    object_key = CourseKey.from_string(object_tag.object_id)
+                except InvalidKeyError:
+                    return False
+
+            # ...and object to be in an org that is enabled for this taxonomy.
+            if not self.enabled_for_org(object_key.org):
+                return False
+
+        return super().validate_object_tag(
+            object_tag,
+            check_taxonomy=check_taxonomy,
+            check_tag=check_tag,
+            check_object=check_object,
+        )
+
+    def enabled_for_org(self, org_short_name: str) -> bool:
+        """
+        Returns True if this taxonomy is enabled for the given organization.
+        """
+        enabled = self.enabled
+        if self.org_owners.count():
+            enabled &= self.org_owners.filter(
+                contenttaxonomyorg__org__short_name=org_short_name,
+            ).exists()
+        return enabled
+
+
+class ContentTaxonomyOrg(models.Model):
+    """
+    Represents the many-to-many relationship between ContentTaxonomies and Organizations.
+    """
+
+    taxonomy = models.ForeignKey(ContentTaxonomy, on_delete=models.CASCADE)
+    org = models.ForeignKey(Organization, on_delete=models.CASCADE)