feat: upstream-downstream entity linking

cms/envs/common.py

@@ -1887,6 +1887,7 @@
     "openedx_learning.apps.authoring.components",
     "openedx_learning.apps.authoring.contents",
     "openedx_learning.apps.authoring.publishing",
+    "openedx_learning.apps.authoring.linking",
 ]
 
 

lms/envs/common.py

@@ -3380,6 +3380,7 @@ def _make_locale_paths(settings):  # pylint: disable=missing-function-docstring
     "openedx_learning.apps.authoring.components",
     "openedx_learning.apps.authoring.contents",
     "openedx_learning.apps.authoring.publishing",
+    "openedx_learning.apps.authoring.linking",
 ]
 
 

openedx/core/djangoapps/content/course_overviews/signals.py

@@ -26,6 +26,8 @@
 IMPORT_COURSE_DETAILS = Signal()
 # providing_args=["courserun_key"]
 DELETE_COURSE_DETAILS = Signal()
+# providing_args=["courserun_key", "old_name", "new_name"]
+COURSE_NAME_CHANGED = Signal()
 
 
 @receiver(SignalHandler.course_published)
@@ -89,6 +91,7 @@ def _check_for_course_changes(previous_course_overview, updated_course_overview)
         _check_for_course_start_date_changes(previous_course_overview, updated_course_overview)
         _check_for_pacing_changes(previous_course_overview, updated_course_overview)
         _check_for_cert_date_changes(previous_course_overview, updated_course_overview)
+        _check_for_display_name_change(previous_course_overview, updated_course_overview)
 
 
 def _check_for_course_start_date_changes(previous_course_overview, updated_course_overview):
@@ -216,3 +219,16 @@ def _send_course_cert_date_change_signal():
 
     if send_signal:
         transaction.on_commit(_send_course_cert_date_change_signal)
+
+
+def _check_for_display_name_change(previous_course_overview, updated_course_overview):
+    """
+    Checks for change in display name of course and sends COURSE_NAME_CHANGED signal.
+    """
+    if previous_course_overview.display_name_with_default != updated_course_overview.display_name_with_default:
+        COURSE_NAME_CHANGED.send(
+            sender=None,
+            courserun_key=str(previous_course_overview.id),
+            old_name=previous_course_overview.display_name_with_default,
+            new_name=updated_course_overview.display_name_with_default,
+        )

openedx/core/djangoapps/content_libraries/api.py

@@ -1952,3 +1952,28 @@ def import_blocks_create_task(library_key, course_key, use_course_key_as_block_i
     log.info(f"Import block task created: import_task={import_task} "
              f"celery_task={result.id}")
     return import_task
+
+
+def create_or_update_xblock_upstream_link(xblock, course_key: str, course_name: str, created: datetime | None = None):
+    """
+    Create or update upstream->downstream link in database for given xblock.
+    """
+    if not xblock.upstream:
+        return None
+    upstream_usage_key = UsageKeyV2.from_string(xblock.upstream)
+    try:
+        lib_component = get_component_from_usage_key(upstream_usage_key)
+    except ObjectDoesNotExist:
+        log.error(f"Library component not found for {upstream_usage_key}")
+        lib_component = None
+    authoring_api.update_or_create_entity_link(
+        lib_component,
+        upstream_usage_key=xblock.upstream,
+        upstream_context_key=str(upstream_usage_key.context_key),
+        downstream_context_key=course_key,
+        downstream_context_title=course_name,
+        downstream_usage_key=str(xblock.usage_key),
+        version_synced=xblock.upstream_version,
+        version_declined=xblock.upstream_version_declined,
+        created=created,
+    )

openedx/core/djangoapps/content_libraries/management/commands/recreate_upstream_links.py

@@ -0,0 +1,76 @@
+"""
+Management command to recreate upstream-dowstream links in PublishableEntityLink for course(s).
+
+This command can be run for all the courses or for given list of courses.
+"""
+
+from __future__ import annotations
+
+import logging
+from datetime import datetime, timezone
+
+from django.core.management.base import BaseCommand, CommandError
+from django.utils.translation import gettext as _
+
+from openedx.core.djangoapps.content.course_overviews.models import CourseOverview
+
+from ...tasks import create_or_update_upstream_links
+
+log = logging.getLogger(__name__)
+
+
+class Command(BaseCommand):
+    """
+    Recreate links for course(s) in PublishableEntityLink table.
+
+    Examples:
+        # Recreate upstream links for two courses.
+        $ ./manage.py cms recreate_upstream_links --course course-v1:edX+DemoX.1+2014 \
+        --course course-v1:edX+DemoX.2+2015
+        # Recreate upstream links for all courses.
+        $ ./manage.py cms recreate_upstream_links --all
+        # Force recreate links for all courses including completely processed ones.
+        $ ./manage.py cms recreate_upstream_links --all
+    """
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            '--course',
+            metavar=_('COURSE_KEY'),
+            action='append',
+            help=_('Recreate links for xblocks under given course keys. For eg. course-v1:edX+DemoX.1+2014'),
+            default=[],
+        )
+        parser.add_argument(
+            '--all',
+            action='store_true',
+            help=_(
+                'Recreate links for xblocks under all courses. NOTE: this can take long time depending'
+                ' on number of course and xblocks'
+            ),
+        )
+        parser.add_argument(
+            '--force',
+            action='store_true',
+            help=_('Recreate links even for completely processed courses.'),
+        )
+
+    def handle(self, *args, **options):
+        """
+        Handle command
+        """
+        courses = options['course']
+        should_process_all = options['all']
+        force = options['force']
+        time_now = datetime.now(tz=timezone.utc)
+        if not courses and not should_process_all:
+            raise CommandError('Either --course or --all argument should be provided.')
+
+        if should_process_all and courses:
+            raise CommandError('Only one of --course or --all argument should be provided.')
+
+        if should_process_all:
+            courses = CourseOverview.get_all_course_keys()
+        for course in courses:
+            log.info(f"Start processing upstream->dowstream links in course: {course}")
+            create_or_update_upstream_links.delay(str(course), force, created=time_now)

openedx/core/djangoapps/content_libraries/signal_handlers.py

@@ -5,29 +5,34 @@
 import logging
 
 from django.conf import settings
-from django.db.models.signals import post_save, post_delete, m2m_changed
+from django.db.models.signals import m2m_changed, post_delete, post_save
 from django.dispatch import receiver
 
 from opaque_keys import InvalidKeyError
 from opaque_keys.edx.locator import LibraryLocatorV2, LibraryUsageLocatorV2
 from openedx_events.content_authoring.data import (
     ContentObjectChangedData,
     LibraryCollectionData,
+    XBlockData,
 )
 from openedx_events.content_authoring.signals import (
     CONTENT_OBJECT_ASSOCIATIONS_CHANGED,
     LIBRARY_COLLECTION_CREATED,
     LIBRARY_COLLECTION_DELETED,
     LIBRARY_COLLECTION_UPDATED,
+    XBLOCK_CREATED,
+    XBLOCK_DELETED,
+    XBLOCK_UPDATED,
 )
-from openedx_learning.api.authoring import get_component, get_components
+from openedx_learning.api.authoring import delete_entity_link, get_component, get_components
 from openedx_learning.api.authoring_models import Collection, CollectionPublishableEntity, Component, PublishableEntity
 
 from lms.djangoapps.grades.api import signals as grades_signals
+from openedx.core.djangoapps.content.course_overviews.signals import COURSE_NAME_CHANGED
 
 from .api import library_component_usage_key
 from .models import ContentLibrary, LtiGradedResource
-
+from .tasks import create_or_update_xblock_upstream_link, update_course_name_in_upstream_links
 
 log = logging.getLogger(__name__)
 
@@ -203,3 +208,42 @@ def library_collection_entities_changed(sender, instance, action, pk_set, **kwar
 
     for component in components.all():
         _library_collection_component_changed(component, library.library_key)
+
+
+@receiver(XBLOCK_CREATED)
+@receiver(XBLOCK_UPDATED)
+def create_or_update_upstream_downstream_link_handler(**kwargs):
+    """
+    Automatically create or update upstream->downstream link in database.
+    """
+    xblock_info = kwargs.get("xblock_info", None)
+    if not xblock_info or not isinstance(xblock_info, XBlockData):
+        log.error("Received null or incorrect data for event")
+        return
+
+    create_or_update_xblock_upstream_link.delay(str(xblock_info.usage_key))
+
+
+@receiver(XBLOCK_DELETED)
+def delete_upstream_downstream_link_handler(**kwargs):
+    """
+    Delete upstream->downstream link from database on xblock delete.
+    """
+    xblock_info = kwargs.get("xblock_info", None)
+    if not xblock_info or not isinstance(xblock_info, XBlockData):
+        log.error("Received null or incorrect data for event")
+        return
+
+    delete_entity_link(str(xblock_info.usage_key))
+
+
+@receiver(COURSE_NAME_CHANGED, dispatch_uid="update_course_name_in_upstream_links_handler")
+def update_course_name_in_upstream_links_handler(courserun_key, old_name, new_name, **kwargs):
+    """
+    Handler to update course names in upstream->downstream links on change.
+    """
+    log.info(f"Updating course name in upstream->downstream links from '{old_name}' to '{new_name}'")
+    update_course_name_in_upstream_links.delay(
+        courserun_key,
+        new_name,
+    )

openedx/core/djangoapps/content_libraries/tasks.py

@@ -17,18 +17,23 @@
 from __future__ import annotations
 
 import logging
+from datetime import datetime, timezone
 
 from celery import shared_task
 from celery_utils.logged_task import LoggedTask
 from celery.utils.log import get_task_logger
 from edx_django_utils.monitoring import set_code_owner_attribute, set_code_owner_attribute_from_module
+from opaque_keys.edx.keys import UsageKey
 
 from user_tasks.tasks import UserTask, UserTaskStatus
 from xblock.fields import Scope
 
 from opaque_keys.edx.keys import CourseKey
 from opaque_keys.edx.locator import BlockUsageLocator
+from openedx.core.djangoapps.content.course_overviews.models import CourseOverview
 from openedx.core.lib import ensure_cms
+from openedx_learning.api.authoring import get_entity_links, get_or_create_learning_context_link_status
+from openedx_learning.api.authoring_models import LearningContextLinksStatusChoices
 from xmodule.capa_block import ProblemBlock
 from xmodule.library_content_block import ANY_CAPA_TYPE_VALUE, LegacyLibraryContentBlock
 from xmodule.modulestore import ModuleStoreEnum
@@ -169,6 +174,69 @@ def duplicate_children(
                 self.status.fail({'raw_error_msg': str(exception)})
 
 
+@shared_task(base=LoggedTask)
+@set_code_owner_attribute
+def create_or_update_xblock_upstream_link(usage_key):
+    """
+    Create or update upstream link for a single xblock.
+    """
+    ensure_cms("create_or_update_xblock_upstream_link may only be executed in a CMS context")
+    xblock = modulestore().get_item(UsageKey.from_string(usage_key))
+    if not xblock.upstream or not xblock.upstream_version:
+        return
+    try:
+        course_name = CourseOverview.get_from_id(xblock.course_id).display_name_with_default
+    except CourseOverview.DoesNotExist:
+        TASK_LOGGER.exception(f'Could not find course: {xblock.course_id}')
+        return
+    api.create_or_update_xblock_upstream_link(xblock, str(xblock.course_id), course_name)
+
+
+@shared_task(base=LoggedTask)
+@set_code_owner_attribute
+def create_or_update_upstream_links(course_key_str: str, force: bool = False, created: datetime | None = None):
+    """
+    A Celery task to create or update upstream downstream links in database from course xblock content.
+    """
+    ensure_cms("create_or_update_upstream_links may only be executed in a CMS context")
+
+    if not created:
+        created = datetime.now(timezone.utc)
+    course_status = get_or_create_learning_context_link_status(course_key_str, created)
+    if course_status.status in [
+        LearningContextLinksStatusChoices.COMPLETED,
+        LearningContextLinksStatusChoices.PROCESSING
+    ] and not force:
+        return
+    store = modulestore()
+    course_key = CourseKey.from_string(course_key_str)
+    course_status.status = LearningContextLinksStatusChoices.PROCESSING
+    course_status.save()
+    try:
+        course_name = CourseOverview.get_from_id(course_key).display_name_with_default
+    except CourseOverview.DoesNotExist:
+        TASK_LOGGER.exception(f'Could not find course: {course_key_str}')
+        return
+    xblocks = store.get_items(course_key, settings={"upstream": lambda x: x is not None})
+    for xblock in xblocks:
+        api.create_or_update_xblock_upstream_link(xblock, course_key_str, course_name, created)
+    course_status.status = LearningContextLinksStatusChoices.COMPLETED
+    course_status.save()
+
+
+@shared_task(base=LoggedTask)
+@set_code_owner_attribute
+def update_course_name_in_upstream_links(course_key_str: str, new_course_name: str):
+    """
+    Celery task to update course name in upstream->downstream entity links.
+    """
+    updated_time = datetime.now(timezone.utc)
+    get_entity_links({"downstream_context_key": course_key_str}).update(
+        downstream_context_title=new_course_name,
+        updated=updated_time
+    )
+
+
 def _sync_children(
     task: LibrarySyncChildrenTask,
     store: MixedModuleStore,