feat: Unit Prerequisites Lost During Course Export/Import

      This commit 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,13 +12,15 @@
 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 '/'.
@@ -139,6 +141,79 @@ 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
+
+        try:
+            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)
+
+        except Exception as e:
+            log.error("Error in prerequisite export for %s: %s", self.location, e)
+
+
     @staticmethod
     def _get_metadata_from_xml(xml_object, remove=True):
         """
@@ -442,6 +517,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)