feat: Subsection(sequential) prerequisites lost during course export/import

     *  feat: adds prerequisite element to exported OLX. e.g.
<sequential default_time_limit_minutes="0" display_name="Subsection 2" due="null" hide_after_due="false" show_correctness="always" start="2030-01-01T00:00:00Z">
  <prerequisite>
    <required_sequential url_name="c129cef268e340c9a92e65c224ddcaf9"/>
    <min_score>80</min_score>
    <min_completion>90</min_completion>
  </prerequisite>
  <vertical url_name="07665b20eaab4a8b888ed6ab5de6188d"/>
</sequential>

 This PR introduces support for subsection (sequential) prerequisites
in the OLX course format. Course authors can now define prerequisite
relationships between subsections with configurable completion criteria
including minimum score and completion percentage requirements.

Issue Link: #36995

Author: haftamuk

cms/djangoapps/contentstore/utils.py

@@ -121,6 +121,8 @@
 
 from .models import ComponentLink, ContainerLink
 
+from openedx.core.lib.gating.services import GatingService
+
 IMPORTABLE_FILE_TYPES = ('.tar.gz', '.zip')
 log = logging.getLogger(__name__)
 
@@ -1324,7 +1326,8 @@ def load_services_for_studio(runtime, user):
         "settings": SettingsService(),
         "lti-configuration": ConfigurationService(CourseAllowPIISharingInLTIFlag),
         "teams_configuration": TeamsConfigurationService(),
-        "library_tools": LegacyLibraryToolsService(modulestore(), user.id)
+        "library_tools": LegacyLibraryToolsService(modulestore(), user.id),
+        'gating': GatingService(),
     }
 
     runtime._services.update(services)  # lint-amnesty, pylint: disable=protected-access

openedx/core/lib/gating/services.py

@@ -54,3 +54,16 @@ def is_gate_fulfilled(self, course_key, gating_content_key, user_id):
             Returns False otherwise
         """
         return gating_api.is_gate_fulfilled(course_key, gating_content_key, user_id)
+
+    def get_required_prereq_metadata(self, course_key, gated_content_key):
+        """
+        Returns the prerequisite information of the provided subsection
+
+        Arguments:
+            course_key (str|CourseKey): The course key
+            content_key (str|UsageKey): The content usage key
+
+        Returns:
+            dict or None: The gating milestone dict or None
+        """
+        return gating_api.get_required_content(course_key, gated_content_key)

xmodule/xml_block.py

@@ -12,21 +12,18 @@
 from xblock.runtime import KvsFieldData
 from xmodule.modulestore import EdxJSONEncoder
 from xmodule.modulestore.inheritance import InheritanceKeyValueStore, own_metadata
-
+from opaque_keys.edx.keys import UsageKey
 log = logging.getLogger(__name__)
-
 # assume all XML files are persisted as utf-8.
 EDX_XML_PARSER = XMLParser(dtd_validation=False, load_dtd=False, remove_blank_text=True, encoding='utf-8')
 
-
 def name_to_pathname(name):
     """
     Convert a location name for use in a path: replace ':' with '/'.
     This allows users of the xml format to organize content into directories
     """
     return name.replace(':', '/')
 
-
 def is_pointer_tag(xml_obj):
     """
     Check if xml_obj is a pointer tag: <blah url_name="something" />.
@@ -139,6 +136,65 @@ class XmlMixin:
 
     metadata_to_export_to_policy = ('discussion_topics',)
 
+    def _extract_prereq_url_name(self, prereq_usage_key):
+        """
+        Extract the url_name from a prerequisite usage key.
+        """
+        try:
+            if isinstance(prereq_usage_key, str):
+                prereq_usage_key = UsageKey.from_string(prereq_usage_key)
+
+            # Get the block_id which should be the url_name
+            return prereq_usage_key.block_id
+
+        except (ImportError, ValueError, AttributeError, TypeError) as e:
+            log.warning("Could not extract url_name from prerequisite key %s: %s", prereq_usage_key, e)
+            # Try to extract from string as fallback
+            if isinstance(prereq_usage_key, str):
+                # Assuming format like: block-v1:org+course+run+type@sequential+block@url_name
+                if '@sequential+block@' in prereq_usage_key:
+                    parts = prereq_usage_key.split('@sequential+block@')
+                    if len(parts) > 1:
+                        return parts[1]
+            return None
+
+    def _add_prerequisite_to_xml(self, xml_object):
+        """
+        Add prerequisite information to sequential XML for export.
+        """
+        if self.category != 'sequential':
+            return
+        gating_service = self.runtime.service(self, 'gating')
+        if not gating_service:
+            return
+        prereq_info = gating_service.get_required_prereq_metadata(
+            self.location.course_key,
+            self.location
+        )
+        if not prereq_info or not prereq_info[0]:
+            return
+        prereq_id, min_score, min_completion = prereq_info
+        prereq_url_name = self._extract_prereq_url_name(prereq_id)
+        if not prereq_url_name:
+            log.warning("Could not extract prerequisite url_name from %s", prereq_id)
+            return
+
+        # Create prerequisite element
+        prereq_element = etree.Element('prerequisite')
+        required_seq_element = etree.Element('required_sequential')
+        required_seq_element.set('url_name', prereq_url_name)
+        prereq_element.append(required_seq_element)
+        if min_score is not None and int(min_score) > 0:
+            min_score_element = etree.Element('min_score')
+            min_score_element.text = str(min_score)
+            prereq_element.append(min_score_element)
+        if min_completion is not None and int(min_completion) > 0:
+            min_completion_element = etree.Element('min_completion')
+            min_completion_element.text = str(min_completion)
+            prereq_element.append(min_completion_element)
+        # Insert at the beginning
+        xml_object.insert(0, prereq_element)
+
     @staticmethod
     def _get_metadata_from_xml(xml_object, remove=True):
         """
@@ -442,6 +498,9 @@ def add_xml_to_node(self, node):
         if xml_object is None:
             return
 
+        if self.category == 'sequential':
+            self._add_prerequisite_to_xml(xml_object)  # Uncomment this later
+
         for aside in self.runtime.get_asides(self):
             if aside.needs_serialization():
                 aside_node = etree.Element("unknown_root", nsmap=XML_NAMESPACES)