Revert "feat: add support for lct in library_context"

This reverts commit 72ba6ef.

Author: navinkarkera

openedx/core/djangoapps/content_libraries/library_context.py

@@ -8,8 +8,8 @@
 
 from openedx_events.content_authoring.data import LibraryBlockData, LibraryContainerData
 from openedx_events.content_authoring.signals import LIBRARY_BLOCK_UPDATED, LIBRARY_CONTAINER_UPDATED
-from opaque_keys.edx.keys import UsageKeyV2, OpaqueKey
-from opaque_keys.edx.locator import LibraryContainerLocator, LibraryLocatorV2, LibraryUsageLocatorV2
+from opaque_keys.edx.keys import UsageKeyV2
+from opaque_keys.edx.locator import LibraryUsageLocatorV2, LibraryLocatorV2
 from openedx_learning.api import authoring as authoring_api
 
 from openedx.core.djangoapps.content_libraries import api, permissions
@@ -20,63 +20,50 @@
 log = logging.getLogger(__name__)
 
 
-class LibraryContextPermissionBase:
-    locator_type = OpaqueKey
+class LibraryContextImpl(LearningContext):
+    """
+    Implements content libraries as a learning context.
+
+    This is the *new* content libraries based on Learning Core, not the old content
+    libraries based on modulestore.
+    """
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
         self.use_draft = kwargs.get('use_draft', None)
 
-    def get_library_key(self, opaque_key: OpaqueKey):
+    def can_edit_block(self, user: UserType, usage_key: UsageKeyV2) -> bool:
         """
-        Get library key from given opaque_key.
-        """
-        raise NotImplementedError()
-
-    def can_edit_block(self, user: UserType, opaque_key: OpaqueKey) -> bool:
-        """
-        Assuming a block with the specified ID (opaque_key) exists, does the
+        Assuming a block with the specified ID (usage_key) exists, does the
         specified user have permission to edit it (make changes to the
         fields / authored data store)?
 
         May raise ContentLibraryNotFound if the library does not exist.
         """
-        assert isinstance(opaque_key, self.locator_type)
-        return self._check_perm(
-            user,
-            self.get_library_key(opaque_key),
-            permissions.CAN_EDIT_THIS_CONTENT_LIBRARY
-        )
+        assert isinstance(usage_key, LibraryUsageLocatorV2)
+        return self._check_perm(user, usage_key.lib_key, permissions.CAN_EDIT_THIS_CONTENT_LIBRARY)
 
-    def can_view_block_for_editing(self, user: UserType, opaque_key: OpaqueKey) -> bool:
+    def can_view_block_for_editing(self, user: UserType, usage_key: UsageKeyV2) -> bool:
         """
-        Assuming a block with the specified ID (opaque_key) exists, does the
+        Assuming a block with the specified ID (usage_key) exists, does the
         specified user have permission to view its fields and OLX details (but
         not necessarily to make changes to it)?
 
         May raise ContentLibraryNotFound if the library does not exist.
         """
-        assert isinstance(opaque_key, self.locator_type)
-        return self._check_perm(
-            user,
-            self.get_library_key(opaque_key),
-            permissions.CAN_VIEW_THIS_CONTENT_LIBRARY
-        )
+        assert isinstance(usage_key, LibraryUsageLocatorV2)
+        return self._check_perm(user, usage_key.lib_key, permissions.CAN_VIEW_THIS_CONTENT_LIBRARY)
 
-    def can_view_block(self, user: UserType, opaque_key: OpaqueKey) -> bool:
+    def can_view_block(self, user: UserType, usage_key: UsageKeyV2) -> bool:
         """
         Does the specified usage key exist in its context, and if so, does the
         specified user have permission to view it and interact with it (call
         handlers, save user state, etc.)?
 
         May raise ContentLibraryNotFound if the library does not exist.
         """
-        assert isinstance(opaque_key, self.locator_type)
-        return self._check_perm(
-            user,
-            self.get_library_key(opaque_key),
-            permissions.CAN_LEARN_FROM_THIS_CONTENT_LIBRARY
-        )
+        assert isinstance(usage_key, LibraryUsageLocatorV2)
+        return self._check_perm(user, usage_key.lib_key, permissions.CAN_LEARN_FROM_THIS_CONTENT_LIBRARY)
 
     def _check_perm(self, user: UserType, lib_key: LibraryLocatorV2, perm) -> bool:
         """ Helper method to check a permission for the various can_ methods"""
@@ -89,23 +76,6 @@ def _check_perm(self, user: UserType, lib_key: LibraryLocatorV2, perm) -> bool:
             # A 404 is probably what you want in this case, not a 500 error, so do that by default.
             raise NotFound(f"Content Library '{lib_key}' does not exist") from exc
 
-
-class LibraryContextImpl(LibraryContextPermissionBase, LearningContext):
-    """
-    Implements content libraries as a learning context.
-
-    This is the *new* content libraries based on Learning Core, not the old content
-    libraries based on modulestore.
-    """
-
-    locator_type = LibraryUsageLocatorV2
-
-    def get_library_key(self, opaque_key: OpaqueKey):
-        """
-        Get library key from given opaque_key.
-        """
-        return opaque_key.lib_key
-
     def block_exists(self, usage_key: LibraryUsageLocatorV2):
         """
         Does the block for this usage_key exist in this Library?
@@ -133,82 +103,29 @@ def block_exists(self, usage_key: LibraryUsageLocatorV2):
             local_key=usage_key.block_id,
         )
 
-    def send_block_updated_event(self, opaque_key: OpaqueKey):
+    def send_block_updated_event(self, usage_key: UsageKeyV2):
         """
         Send a "block updated" event for the library block with the given usage_key.
         """
-        assert isinstance(opaque_key, self.locator_type)
+        assert isinstance(usage_key, LibraryUsageLocatorV2)
         LIBRARY_BLOCK_UPDATED.send_event(
             library_block=LibraryBlockData(
-                library_key=opaque_key.lib_key,
-                usage_key=opaque_key,
+                library_key=usage_key.lib_key,
+                usage_key=usage_key,
             )
         )
 
-    def send_container_updated_events(self, opaque_key: OpaqueKey):
+    def send_container_updated_events(self, usage_key: UsageKeyV2):
         """
         Send "container updated" events for containers that contains the library block
         with the given usage_key.
         """
-        assert isinstance(opaque_key, self.locator_type)
-        affected_containers = api.get_containers_contains_component(opaque_key)
+        assert isinstance(usage_key, LibraryUsageLocatorV2)
+        affected_containers = api.get_containers_contains_component(usage_key)
         for container in affected_containers:
             LIBRARY_CONTAINER_UPDATED.send_event(
                 library_container=LibraryContainerData(
                     container_key=container.container_key,
                     background=True,
                 )
             )
-
-
-class LibraryContextContainerImpl(LibraryContextPermissionBase, LearningContext):
-    """
-    Implements content libraries as a learning context for containers in libraries.
-
-    This is the *new* content libraries based on Learning Core, not the old content
-    libraries based on modulestore.
-    """
-
-    locator_type = LibraryContainerLocator
-
-    def get_library_key(self, opaque_key: OpaqueKey):
-        """
-        Get library key from given opaque_key.
-        """
-        return opaque_key.library_key
-
-    def container_exists(self, container_key: LibraryContainerLocator):
-        """
-        Does the container for this key exist in this Library?
-
-        Note that this applies to all versions, i.e. you can put a container key for
-        a piece of content that has been soft-deleted (removed from Drafts), and
-        it will still return True here. That's because for the purposes of
-        permission checking, we just want to know whether that block has ever
-        existed in this Library, because we could be looking at any older
-        version of it.
-        """
-        try:
-            content_lib = ContentLibrary.objects.get_by_key(container_key.library_key)  # type: ignore[attr-defined]
-        except ContentLibrary.DoesNotExist:
-            return False
-
-        learning_package = content_lib.learning_package
-        if learning_package is None:
-            return False
-
-        return authoring_api.container_exists_by_key(
-            learning_package.id,
-            container_key,
-        )
-
-    def send_block_updated_event(self, opaque_key: OpaqueKey):
-        """
-        Send a "block updated" event for the library block with the given usage_key.
-        """
-        assert isinstance(opaque_key, self.locator_type)
-        LIBRARY_CONTAINER_UPDATED.send_event(
-            library_container=LibraryContainerData(
-                container_key=opaque_key,
-            )
-        )

openedx/core/djangoapps/content_staging/views.py

@@ -10,7 +10,7 @@
 import edx_api_doc_tools as apidocs
 from opaque_keys import InvalidKeyError
 from opaque_keys.edx.keys import UsageKey
-from opaque_keys.edx.locator import CourseLocator, LibraryContainerLocator, LibraryLocatorV2
+from opaque_keys.edx.locator import CourseLocator, LibraryLocatorV2
 from rest_framework.exceptions import NotFound, PermissionDenied, ValidationError
 from rest_framework.response import Response
 from rest_framework.views import APIView
@@ -85,18 +85,12 @@ def post(self, request):
         # Check if the content exists and the user has permission to read it.
         # Parse the usage key:
         try:
-            opaque_key = UsageKey.from_string(request.data["usage_key"])
-            if opaque_key.block_type in ('course', 'chapter', 'sequential'):
-                raise ValidationError('Requested XBlock tree is too large')
-        except InvalidKeyError:
-            try:
-                # Check if valid library container
-                opaque_key = LibraryContainerLocator.from_string(request.data["usage_key"])
-                if opaque_key.container_type != 'unit':
-                    raise ValidationError('Requested XBlock tree is too large')
-            except (ValueError, InvalidKeyError):
-                raise ValidationError('Invalid usage key')  # lint-amnesty, pylint: disable=raise-missing-from
-        course_key = getattr(opaque_key, 'context_key', None) or getattr(opaque_key, 'library_key', None)
+            usage_key = UsageKey.from_string(request.data["usage_key"])
+        except (ValueError, InvalidKeyError):
+            raise ValidationError('Invalid usage key')  # lint-amnesty, pylint: disable=raise-missing-from
+        if usage_key.block_type in ('course', 'chapter', 'sequential'):
+            raise ValidationError('Requested XBlock tree is too large')
+        course_key = usage_key.context_key
 
         # Load the block and copy it to the user's clipboard
         try:
@@ -106,7 +100,7 @@ def post(self, request):
                     raise PermissionDenied(
                         "You must be a member of the course team in Studio to export OLX using this API."
                     )
-                block = modulestore().get_item(opaque_key)
+                block = modulestore().get_item(usage_key)
                 version_num = None
 
             elif isinstance(course_key, LibraryLocatorV2):
@@ -115,12 +109,8 @@ def post(self, request):
                     request.user,
                     lib_api.permissions.CAN_VIEW_THIS_CONTENT_LIBRARY
                 )
-                if isinstance(opaque_key, LibraryContainerLocator):
-                    # TODO: load unit block data to staging content, probably need to convert unit from library to xml
-                    raise NotImplementedError("Containers not supported yet")
-                else:
-                    block = xblock_api.load_block(opaque_key, user=None)
-                    version_num = lib_api.get_library_block(opaque_key).draft_version_num
+                block = xblock_api.load_block(usage_key, user=None)
+                version_num = lib_api.get_library_block(usage_key).draft_version_num
 
             else:
                 raise ValidationError("Invalid usage_key for the content.")

openedx/core/djangoapps/xblock/learning_context/learning_context.py

@@ -3,7 +3,7 @@
 of content where learning happens.
 """
 from openedx.core.types import User as UserType
-from opaque_keys.edx.keys import OpaqueKey
+from opaque_keys.edx.keys import UsageKeyV2
 
 
 class LearningContext:
@@ -25,62 +25,62 @@ def __init__(self, **kwargs):
         parameters without changing the API.
         """
 
-    def can_edit_block(self, user: UserType, opaque_key: OpaqueKey) -> bool:  # pylint: disable=unused-argument
+    def can_edit_block(self, user: UserType, usage_key: UsageKeyV2) -> bool:  # pylint: disable=unused-argument
         """
-        Assuming a block with the specified ID (opaque_key) exists, does the
+        Assuming a block with the specified ID (usage_key) exists, does the
         specified user have permission to edit it (make changes to the
         fields / authored data store)?
 
         user: a Django User object (may be an AnonymousUser)
 
-        opaque_key: the OpaqueKey subclass used for this learning context
+        usage_key: the UsageKeyV2 subclass used for this learning context
 
         Must return a boolean.
         """
         return False
 
-    def can_view_block_for_editing(self, user: UserType, opaque_key: OpaqueKey) -> bool:
+    def can_view_block_for_editing(self, user: UserType, usage_key: UsageKeyV2) -> bool:
         """
-        Assuming a block with the specified ID (opaque_key) exists, does the
+        Assuming a block with the specified ID (usage_key) exists, does the
         specified user have permission to view its fields and OLX details (but
         not necessarily to make changes to it)?
         """
-        return self.can_edit_block(user, opaque_key)
+        return self.can_edit_block(user, usage_key)
 
-    def can_view_block(self, user: UserType, opaque_key: OpaqueKey) -> bool:  # pylint: disable=unused-argument
+    def can_view_block(self, user: UserType, usage_key: UsageKeyV2) -> bool:  # pylint: disable=unused-argument
         """
-        Assuming a block with the specified ID (opaque_key) exists, does the
+        Assuming a block with the specified ID (usage_key) exists, does the
         specified user have permission to view it and interact with it (call
         handlers, save user state, etc.)? This is also sometimes called the
         "can_learn" permission.
 
         user: a Django User object (may be an AnonymousUser)
 
-        opaque_key: the OpaqueKey subclass used for this learning context
+        usage_key: the UsageKeyV2 subclass used for this learning context
 
         Must return a boolean.
         """
         return False
 
-    def definition_for_usage(self, opaque_key, **kwargs):
+    def definition_for_usage(self, usage_key, **kwargs):
         """
         Given a usage key in this context, return the key indicating the actual XBlock definition.
 
         Retuns None if the usage key doesn't exist in this context.
         """
         raise NotImplementedError
 
-    def send_block_updated_event(self, opaque_key):
+    def send_block_updated_event(self, usage_key):
         """
-        Send a "block updated" event for the block with the given opaque_key in this context.
+        Send a "block updated" event for the block with the given usage_key in this context.
 
-        opaque_key: the OpaqueKey subclass used for this learning context
+        usage_key: the UsageKeyV2 subclass used for this learning context
         """
 
-    def send_container_updated_events(self, opaque_key):
+    def send_container_updated_events(self, usage_key):
         """
         Send "container updated" events for containers that contains the block with
-        the given opaque_key in this context.
+        the given usage_key in this context.
 
-        opaque_key: the OpaqueKey subclass used for this learning context
+        usage_key: the UsageKeyV2 subclass used for this learning context
         """

openedx/core/djangoapps/xblock/learning_context/manager.py

@@ -3,7 +3,7 @@
 """
 from edx_django_utils.plugins import PluginManager
 from opaque_keys import OpaqueKey
-from opaque_keys.edx.keys import LearningContextKey, LibraryItemKey, UsageKeyV2
+from opaque_keys.edx.keys import LearningContextKey, UsageKeyV2
 
 from openedx.core.djangoapps.xblock.apps import get_xblock_app_config
 
@@ -33,8 +33,8 @@ def get_learning_context_impl(key):
     Raises PluginError if there is some misconfiguration causing the context
     implementation to not be installed.
     """
-    if isinstance(key, LearningContextKey) or isinstance(key, LibraryItemKey):
-        context_type = key.CANONICAL_NAMESPACE  # e.g. 'lib' or 'lct'
+    if isinstance(key, LearningContextKey):
+        context_type = key.CANONICAL_NAMESPACE  # e.g. 'lib'
     elif isinstance(key, UsageKeyV2):
         context_type = key.context_key.CANONICAL_NAMESPACE
     elif isinstance(key, OpaqueKey):

setup.py

@@ -181,7 +181,6 @@
         ],
         'openedx.learning_context': [
             'lib = openedx.core.djangoapps.content_libraries.library_context:LibraryContextImpl',
-            'lct = openedx.core.djangoapps.content_libraries.library_context:LibraryContextContainerImpl',
         ],
         'openedx.dynamic_partition_generator': [
             'content_type_gating = openedx.features.content_type_gating.partitions:create_content_gating_partition',