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

     *  feat: adds prerequisite information attributes to exported OLX. e.g.
<sequential
required_content="91d0290972c4488db10d7ca3694e13ca"
min_score="100"
min_completion="100"
... >
    <vertical url_name="some_vertical"/>
   ...
</sequential>

    * feat: parse prerequisite information attributes during import and
create gating relationship.

Issue Link: #36995

Author: haftamuk

xmodule/modulestore/tests/test_xml_importer.py

@@ -21,6 +21,7 @@
 from xmodule.modulestore.xml_importer import StaticContentImporter, _update_block_location
 from xmodule.tests import DATA_DIR
 from xmodule.x_module import XModuleMixin
+from xmodule.modulestore.xml_importer import _process_sequential_prerequisites
 
 OPEN_BUILTIN = 'builtins.open'
 
@@ -257,3 +258,48 @@ def test_import_static_file(self):
             )
             mock_file.assert_called_with(full_file_path, 'rb')
             self.mocked_content_store.generate_thumbnail.assert_called_once()
+
+
+class TestSequentialPrerequisitesImport(unittest.TestCase):
+    """
+    Verifies sequential blocks with prerequisite attributes in OLX/XML are processed correctly
+    by _process_sequential_prerequisites function during import.
+    """
+
+    def setUp(self):
+        """
+        Set up test course and sequential.
+        """
+        self.course_key = CourseLocator('test_org', 'test_course', 'test_run')
+        self.sequential_location = self.course_key.make_usage_key('sequential', 'gated_sequential')
+
+        # Mock sequential block
+        self.mock_sequential = mock.Mock()
+        self.mock_sequential.location = self.sequential_location
+
+    def test_gating_api_calls(self):
+        """
+        Verify that _process_sequential_prerequisites correctly processes valid prerequisite data
+        and calls gating_api functions add_prerequisite and set_required_content with valid parameters
+        """
+        self.mock_sequential.xml_attributes = {
+            'required_content': 'gated_sequential',
+            'min_score': '80',
+            'min_completion': '90'
+        }
+
+        with mock.patch('xmodule.modulestore.xml_importer.gating_api') as mock_gating_api:
+            _process_sequential_prerequisites(self.mock_sequential)
+
+            mock_gating_api.add_prerequisite.assert_called_once_with(
+                self.course_key,
+                self.course_key.make_usage_key('sequential', 'gated_sequential')
+            )
+
+            mock_gating_api.set_required_content.assert_called_once_with(
+                self.course_key,
+                self.sequential_location,
+                self.course_key.make_usage_key('sequential', 'gated_sequential'),
+                80,
+                90
+            )

xmodule/modulestore/xml_importer.py

@@ -59,6 +59,7 @@
 
 from .inheritance import own_metadata
 from .store_utilities import rewrite_nonportable_content_links
+from openedx.core.lib.gating import api as gating_api
 
 log = logging.getLogger(__name__)
 
@@ -834,6 +835,43 @@ def import_library_from_xml(*args, **kwargs):
     return list(manager.run_imports())
 
 
+def _process_sequential_prerequisites(block):
+    """
+    Extracts sequential prerequisite information, flags required sequential,
+    and creates a gating relationship.
+
+    Args:
+        block: The sequential block
+    """
+    if not hasattr(block, "xml_attributes") or not block.xml_attributes:
+        log.debug('Block has no xml_attributes property: %s', block)
+        return
+    try:
+        required_content = block.xml_attributes.get('required_content', None)
+        min_score = int(block.xml_attributes.get('min_score', None))
+        min_completion = int(block.xml_attributes.get('min_completion', None))
+        if not required_content or not min_score or not min_completion:
+            log.debug('Failed to extract required_content, min_score, and/or min_completion : %s', block.xml_attributes)
+            return
+    except (ValueError, TypeError) as e:
+        log.debug('Failed to extract required_content, min_score, and/or min_completion : %s', {e})
+        return
+
+    course_key = block.location.course_key
+
+    prerequisite_usage_key = course_key.make_usage_key('sequential', required_content)
+
+    gating_api.add_prerequisite(course_key, prerequisite_usage_key)
+
+    gating_api.set_required_content(
+        course_key,
+        block.location,
+        prerequisite_usage_key,
+        min_score,
+        min_completion
+    )
+
+
 def _update_and_import_block(  # pylint: disable=too-many-statements
         block, store, user_id,
         source_course_id, dest_course_id,
@@ -918,6 +956,9 @@ def _convert_ref_fields_to_new_namespace(reference):
         block.location.block_id, fields, runtime, asides=asides
     )
 
+    if block.location.block_type == "sequential":
+        _process_sequential_prerequisites(block)
+
     # TODO: Move this code once the following condition is met.
     # Get to the point where XML import is happening inside the
     # modulestore that is eventually going to store the data.

xmodule/seq_block.py

@@ -978,8 +978,31 @@ def definition_to_xml(self, resource_fs):
         xml_object = etree.Element('sequential')
         for child in self.get_children():
             self.runtime.add_block_as_child_node(child, xml_object)
+        self.add_prerequisite_to_xml(xml_object)
         return xml_object
 
+    def add_prerequisite_to_xml(self, xml_object):
+        """
+        Add prerequisite information to sequential XML for export.
+        """
+        from openedx.core.lib.gating import api as gating_api
+
+        prereq_info = gating_api.get_required_content(
+            self.location.course_key,
+            self.location
+        )
+        if not prereq_info or not prereq_info[0]:
+            log.debug('Unable to get required content: %s', prereq_info)
+            return
+        prereq_id, min_score, min_completion = prereq_info
+        if not isinstance(prereq_id, str):
+            log.debug('Unable to extractusage key, min_score and min_completion: %s', prereq_info)
+            return
+        prereq_usage_key = UsageKey.from_string(prereq_id)
+        xml_object.set('required_content', prereq_usage_key.block_id)
+        xml_object.set('min_score', str(min_score))
+        xml_object.set('min_completion', str(min_completion))
+
     @property
     def non_editable_metadata_fields(self):
         """

xmodule/tests/test_sequence.py

@@ -24,6 +24,7 @@
 from xmodule.tests.xml import XModuleXmlImportTest
 from xmodule.tests.xml import factories as xml
 from xmodule.x_module import PUBLIC_VIEW, STUDENT_VIEW
+from lxml import etree
 
 TODAY = now()
 DUE_DATE = TODAY + timedelta(days=7)
@@ -572,3 +573,30 @@ def test_prereqs_met_content_rendered_normally(self):
         assert metadata["items"] == "rendered_blocks"
         assert metadata["next_url"] == "next_url"
         assert metadata["prev_url"] == "prev_url"
+
+    @patch("openedx.core.lib.gating.api.get_required_content")
+    def test_export_sequence_with_prerequisites(self, mock_get_required_content):
+        """
+        Test that add_prerequisite_to_xml adds prerequisite information correctly.
+        """
+        # Create a mock XML element
+        xml_object = etree.Element('sequential')
+
+        # When add_prerequisite_to_xml method calls get_required_content mocked
+        # content prepared here will be returned. Therefore, verification of
+        # contents in the exported olx/xml to those values will be verified.
+        mock_get_required_content.return_value = (
+            "block-v1:TestX+TestCourse+1+type@sequential+block@gated_sequential",
+            80,
+            90,
+        )
+
+        self.sequence_3_1.add_prerequisite_to_xml(xml_object)
+        mock_get_required_content.assert_called_once_with(
+            self.sequence_3_1.location.course_key,
+            self.sequence_3_1.location
+        )
+
+        assert xml_object.get('required_content') == 'gated_sequential'
+        assert xml_object.get('min_score') == '80'
+        assert xml_object.get('min_completion') == '90'