chore: move video sharing methods to video_config app

Author: farhan

.github/workflows/unit-tests.yml

@@ -17,6 +17,7 @@ jobs:
     name: ${{ matrix.shard_name }}(py=${{ matrix.python-version }},dj=${{ matrix.django-version }},mongo=${{ matrix.mongo-version }})
     runs-on: ${{ matrix.os-version }}
     strategy:
+        fail-fast: false
       matrix:
         python-version:
           - "3.11"

cms/djangoapps/contentstore/views/preview.py

@@ -18,6 +18,7 @@
 from xblock.exceptions import NoSuchHandlerError
 from xblock.runtime import KvsFieldData
 
+from openedx.core.djangoapps.video_config.services import VideoConfigService
 from xmodule.contentstore.django import contentstore
 from xmodule.exceptions import NotFoundError, ProcessingError
 from xmodule.modulestore.django import XBlockI18nService, modulestore
@@ -214,7 +215,8 @@ def _prepare_runtime_for_preview(request, block):
         "teams_configuration": TeamsConfigurationService(),
         "sandbox": SandboxService(contentstore=contentstore, course_id=course_id),
         "cache": CacheService(cache),
-        'replace_urls': ReplaceURLService
+        'replace_urls': ReplaceURLService,
+        'video_config': VideoConfigService(),
     }
 
     block.runtime.get_block_for_descriptor = partial(_load_preview_block, request)

lms/djangoapps/courseware/block_render.py

@@ -42,6 +42,7 @@
 from xblock.runtime import KvsFieldData
 
 from lms.djangoapps.teams.services import TeamsService
+from openedx.core.djangoapps.video_config.services import VideoConfigService
 from openedx.core.lib.xblock_services.call_to_action import CallToActionService
 from xmodule.contentstore.django import contentstore
 from xmodule.exceptions import NotFoundError, ProcessingError
@@ -635,6 +636,7 @@ def inner_get_block(block: XBlock) -> XBlock | None:
         'call_to_action': CallToActionService(),
         'publish': EventPublishingService(user, course_id, track_function),
         'enrollments': EnrollmentsService(),
+        'video_config': VideoConfigService(),
     }
 
     runtime.get_block_for_descriptor = inner_get_block

lms/djangoapps/courseware/tests/test_video_mongo.py

@@ -37,7 +37,7 @@
 from lxml import etree
 from path import Path as path
 from xmodule.contentstore.content import StaticContent
-from xmodule.course_block import (
+from openedx.core.djangoapps.video_config.utils import (
     COURSE_VIDEO_SHARING_ALL_VIDEOS,
     COURSE_VIDEO_SHARING_NONE,
     COURSE_VIDEO_SHARING_PER_VIDEO
@@ -57,6 +57,7 @@
 from common.djangoapps.xblock_django.constants import ATTR_KEY_REQUEST_COUNTRY_CODE
 from lms.djangoapps.courseware.tests.helpers import get_context_dict_from_string
 from openedx.core.djangoapps.video_config.toggles import PUBLIC_VIDEO_SHARE
+from openedx.core.djangoapps.video_config.utils import VideoSharingUtils
 from openedx.core.djangoapps.video_pipeline.config.waffle import DEPRECATE_YOUTUBE
 from openedx.core.djangoapps.waffle_utils.models import WaffleFlagCourseOverrideModel
 from openedx.core.djangolib.testing.utils import CacheIsolationTestCase
@@ -261,14 +262,14 @@ def test_is_public_sharing_enabled(self, feature_enabled):
         """Test public video url."""
         assert self.block.public_access is True
         with self.mock_feature_toggle(enabled=feature_enabled):
-            assert self.block.is_public_sharing_enabled() == feature_enabled
+            assert VideoSharingUtils.is_public_sharing_enabled(self.block) == feature_enabled
 
     def test_is_public_sharing_enabled__not_public(self):
         self.block.public_access = False
         with self.mock_feature_toggle():
-            assert not self.block.is_public_sharing_enabled()
+            assert not VideoSharingUtils.is_public_sharing_enabled(self.block)
 
-    @patch('xmodule.video_block.video_block.VideoBlock.get_course_video_sharing_override')
+    @patch('openedx.core.djangoapps.video_config.utils.VideoSharingUtils.get_course_video_sharing_override')
     def test_is_public_sharing_enabled_by_course_override(self, mock_course_sharing_override):
 
         # Given a course overrides all videos to be shared
@@ -277,47 +278,47 @@ def test_is_public_sharing_enabled_by_course_override(self, mock_course_sharing_
 
         # When I try to determine if public sharing is enabled
         with self.mock_feature_toggle():
-            is_public_sharing_enabled = self.block.is_public_sharing_enabled()
+            is_public_sharing_enabled = VideoSharingUtils.is_public_sharing_enabled(self.block)
 
         # Then I will get that course value
         self.assertTrue(is_public_sharing_enabled)
 
-    @patch('xmodule.video_block.video_block.VideoBlock.get_course_video_sharing_override')
+    @patch('openedx.core.djangoapps.video_config.utils.VideoSharingUtils.get_course_video_sharing_override')
     def test_is_public_sharing_disabled_by_course_override(self, mock_course_sharing_override):
         # Given a course overrides no videos to be shared
         mock_course_sharing_override.return_value = COURSE_VIDEO_SHARING_NONE
         self.block.public_access = 'some-arbitrary-value'
 
         # When I try to determine if public sharing is enabled
         with self.mock_feature_toggle():
-            is_public_sharing_enabled = self.block.is_public_sharing_enabled()
+            is_public_sharing_enabled = VideoSharingUtils.is_public_sharing_enabled(self.block)
 
         # Then I will get that course value
         self.assertFalse(is_public_sharing_enabled)
 
     @ddt.data(COURSE_VIDEO_SHARING_PER_VIDEO, None)
-    @patch('xmodule.video_block.video_block.VideoBlock.get_course_video_sharing_override')
+    @patch('openedx.core.djangoapps.video_config.utils.VideoSharingUtils.get_course_video_sharing_override')
     def test_is_public_sharing_enabled_per_video(self, mock_override_value, mock_course_sharing_override):
         # Given a course does not override per-video settings
         mock_course_sharing_override.return_value = mock_override_value
         self.block.public_access = 'some-arbitrary-value'
 
         # When I try to determine if public sharing is enabled
         with self.mock_feature_toggle():
-            is_public_sharing_enabled = self.block.is_public_sharing_enabled()
+            is_public_sharing_enabled = VideoSharingUtils.is_public_sharing_enabled(self.block)
 
         # I will get the per-video value
         self.assertEqual(self.block.public_access, is_public_sharing_enabled)
 
-    @patch('xmodule.video_block.video_block.get_course_by_id')
+    @patch('openedx.core.lib.courses.get_course_by_id')
     def test_is_public_sharing_course_not_found(self, mock_get_course):
         # Given a course does not override per-video settings
         mock_get_course.side_effect = Http404()
         self.block.public_access = 'some-arbitrary-value'
 
         # When I try to determine if public sharing is enabled
         with self.mock_feature_toggle():
-            is_public_sharing_enabled = self.block.is_public_sharing_enabled()
+            is_public_sharing_enabled = VideoSharingUtils.is_public_sharing_enabled(self.block)
 
         # I will fall-back to per-video values
         self.assertEqual(self.block.public_access, is_public_sharing_enabled)
@@ -326,7 +327,7 @@ def test_is_public_sharing_course_not_found(self, mock_get_course):
     def test_context(self, is_public_sharing_enabled):
         with self.mock_feature_toggle():
             with patch.object(
-                self.block,
+                VideoSharingUtils,
                 'is_public_sharing_enabled',
                 return_value=is_public_sharing_enabled
             ):

lms/djangoapps/courseware/views/views.py

@@ -138,6 +138,7 @@
 from openedx.core.djangoapps.site_configuration import helpers as configuration_helpers
 from openedx.core.djangoapps.util.user_messages import PageLevelMessages
 from openedx.core.djangoapps.video_config.toggles import PUBLIC_VIDEO_SHARE
+from openedx.core.djangoapps.video_config.utils import VideoSharingUtils
 from openedx.core.djangoapps.zendesk_proxy.utils import create_zendesk_ticket
 from openedx.core.djangolib.markup import HTML, Text
 from openedx.core.lib.courses import get_course_by_id
@@ -1869,7 +1870,7 @@ def get_course_and_video_block(self, usage_key_string):
             )
 
             # Block must be marked as public to be viewed
-            if not video_block.is_public_sharing_enabled():
+            if not VideoSharingUtils.is_public_sharing_enabled(video_block):
                 raise Http404("Video not found.")
 
         return course, video_block

openedx/core/djangoapps/video_config/services.py

@@ -0,0 +1,64 @@
+"""
+Video Configuration Service for XBlock runtime.
+
+This service provides video-related configuration and feature flags
+that are specific to the edx-platform implementation
+for the extracted video block in xblocks-contrib repository.
+"""
+
+import logging
+
+from opaque_keys.edx.keys import CourseKey, UsageKey
+
+from openedx.core.djangoapps.video_config.utils import VideoSharingUtils
+from organizations.api import get_course_organization
+
+
+log = logging.getLogger(__name__)
+
+
+class VideoConfigService:
+    """
+    Service for providing video-related configuration and feature flags.
+
+    This service abstracts away edx-platform specific functionality
+    that the Video XBlock needs, allowing the Video XBlock to be
+    extracted to a separate repository.
+    """
+
+    def get_public_video_url(self, usage_id: UsageKey) -> str:
+        """
+        Returns the public video url
+        """
+        return VideoSharingUtils.get_public_video_url(usage_id)
+
+    def get_public_sharing_context(self, video_block, course_key: CourseKey) -> dict:
+        """
+        Get the complete public sharing context for a video.
+
+        Args:
+            video_block: The video XBlock instance
+            course_id: The course identifier
+
+        Returns:
+            dict: Context dictionary with sharing information, empty if sharing is disabled
+        """
+        context = {}
+
+        if not VideoSharingUtils.is_public_sharing_enabled(video_block):
+            return context
+
+        public_video_url = VideoSharingUtils.get_public_video_url(video_block.location)
+        context['public_sharing_enabled'] = True
+        context['public_video_url'] = public_video_url
+
+        organization = get_course_organization(course_key)
+
+        from xmodule.video_block.sharing_sites import sharing_sites_info_for_video
+        sharing_sites_info = sharing_sites_info_for_video(
+            public_video_url,
+            organization=organization
+        )
+        context['sharing_sites_info'] = sharing_sites_info
+
+        return context

openedx/core/djangoapps/video_config/utils.py

@@ -0,0 +1,92 @@
+"""
+Video configuration utilities
+"""
+
+import logging
+
+from django.conf import settings
+from opaque_keys.edx.keys import UsageKey
+
+from openedx.core.djangoapps.video_config.toggles import PUBLIC_VIDEO_SHARE
+from openedx.core.lib.courses import get_course_by_id
+
+log = logging.getLogger(__name__)
+
+# Video sharing constants
+COURSE_VIDEO_SHARING_PER_VIDEO = 'per-video'
+COURSE_VIDEO_SHARING_ALL_VIDEOS = 'all-on'
+COURSE_VIDEO_SHARING_NONE = 'all-off'
+
+
+class VideoSharingUtils:
+    """
+    Provides utility methods for video sharing functionality.
+    """
+
+    @staticmethod
+    def get_public_video_url(usage_id: UsageKey) -> str:
+        """
+        Returns the public video url
+        """
+        return fr'{settings.LMS_ROOT_URL}/videos/{str(usage_id)}'
+
+    @staticmethod
+    def is_public_sharing_enabled(video_block):
+        """
+        Check if public sharing is enabled for a video.
+
+        Args:
+            video_block: The video XBlock instance
+
+        Returns:
+            bool: True if public sharing is enabled, False otherwise
+        """
+        if not video_block.context_key.is_course:
+            return False  # Only courses support this feature (not libraries)
+
+        try:
+            # Video share feature must be enabled for sharing settings to take effect
+            feature_enabled = PUBLIC_VIDEO_SHARE.is_enabled(video_block.context_key)
+        except Exception as err:  # pylint: disable=broad-except
+            log.exception(f"Error retrieving course for course ID: {video_block.context_key}")
+            return False
+
+        if not feature_enabled:
+            return False
+
+        # Check if the course specifies a general setting
+        course_video_sharing_option = VideoSharingUtils.get_course_video_sharing_override(video_block)
+
+        # Course can override all videos to be shared
+        if course_video_sharing_option == COURSE_VIDEO_SHARING_ALL_VIDEOS:
+            return True
+
+        # ... or no videos to be shared
+        elif course_video_sharing_option == COURSE_VIDEO_SHARING_NONE:
+            return False
+
+        # ... or can fall back to per-video setting
+        # Equivalent to COURSE_VIDEO_SHARING_PER_VIDEO or None / unset
+        else:
+            return video_block.public_access
+
+    @staticmethod
+    def get_course_video_sharing_override(video_block):
+        """
+        Return course video sharing options override or None
+
+        Args:
+            video_block: The video XBlock instance
+
+        Returns:
+            Course video sharing option or None
+        """
+        if not video_block.context_key.is_course:
+            return False  # Only courses support this feature (not libraries)
+
+        try:
+            course = get_course_by_id(video_block.context_key)
+            return getattr(course, 'video_sharing_options', None)
+        except Exception as err:  # pylint: disable=broad-except
+            log.exception(f"Error retrieving course for course ID: {video_block.course_id}")
+            return None

xmodule/course_block.py

@@ -18,6 +18,11 @@
 from pytz import utc
 from xblock.fields import Boolean, Dict, Float, Integer, List, Scope, String
 from openedx.core.djangoapps.video_pipeline.models import VideoUploadsEnabledByDefault
+from openedx.core.djangoapps.video_config.utils import (
+    COURSE_VIDEO_SHARING_ALL_VIDEOS,
+    COURSE_VIDEO_SHARING_NONE,
+    COURSE_VIDEO_SHARING_PER_VIDEO,
+)
 from openedx.core.lib.license import LicenseMixin
 from openedx.core.lib.teams_config import TeamsConfig  # lint-amnesty, pylint: disable=unused-import
 from xmodule import course_metadata_utils
@@ -55,9 +60,6 @@
 COURSE_VISIBILITY_PUBLIC_OUTLINE = 'public_outline'
 COURSE_VISIBILITY_PUBLIC = 'public'
 
-COURSE_VIDEO_SHARING_PER_VIDEO = 'per-video'
-COURSE_VIDEO_SHARING_ALL_VIDEOS = 'all-on'
-COURSE_VIDEO_SHARING_NONE = 'all-off'
 # .. toggle_name: FEATURES['CREATE_COURSE_WITH_DEFAULT_ENROLLMENT_START_DATE']
 # .. toggle_implementation: SettingDictToggle
 # .. toggle_default: False

xmodule/modulestore/split_mongo/caching_descriptor_system.py

@@ -25,6 +25,7 @@
 from xmodule.modulestore.split_mongo.split_mongo_kvs import SplitMongoKVS
 from xmodule.util.misc import get_library_or_course_attribute
 from xmodule.x_module import XModuleMixin
+from openedx.core.djangoapps.video_config.services import VideoConfigService
 
 log = logging.getLogger(__name__)
 
@@ -242,6 +243,8 @@ def service(self, block, service_name):
                     self.block_field_datas[block] = None
                     raise
             return self.block_field_datas[block]
+        elif service_name == 'video_config':
+            return VideoConfigService()
         return super().service(block, service_name)
 
     def _init_field_data_for_block(self, block):

xmodule/tests/__init__.py

@@ -32,6 +32,7 @@
 from xmodule.tests.helpers import StubReplaceURLService, mock_render_template, StubMakoService, StubUserService
 from xmodule.util.sandboxing import SandboxService
 from xmodule.x_module import DoNothingCache, XModuleMixin
+from openedx.core.djangoapps.video_config.services import VideoConfigService
 from openedx.core.lib.cache_utils import CacheService
 
 
@@ -242,14 +243,15 @@ def get_test_descriptor_system(render_template=None, **kwargs):
     Construct a test DescriptorSystem instance.
     """
     field_data = DictFieldData({})
+    video_config = VideoConfigService()
 
     descriptor_system = TestDescriptorSystem(
         load_item=Mock(name='get_test_descriptor_system.load_item'),
         resources_fs=Mock(name='get_test_descriptor_system.resources_fs'),
         error_tracker=Mock(name='get_test_descriptor_system.error_tracker'),
         render_template=render_template or mock_render_template,
         mixins=(InheritanceMixin, XModuleMixin),
-        services={'field-data': field_data},
+        services={'field-data': field_data, 'video_config': video_config},
         **kwargs
     )
     descriptor_system.get_asides = lambda block: []