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/tasks.py

@@ -1,7 +1,8 @@
 """
 This file contains celery tasks for contentstore views
 """
-
+from pytz import UTC
+from datetime import datetime
 import asyncio
 import base64
 import json
@@ -99,6 +100,7 @@
 from .outlines_regenerate import CourseOutlineRegenerate
 from .toggles import bypass_olx_failure_enabled
 from .utils import course_import_olx_validation_is_enabled
+import logging
 
 User = get_user_model()
 
@@ -466,6 +468,7 @@ def create_export_tarball(course_block, course_key, context, status=None):
     return export_file
 
 
+
 class CourseImportTask(UserTask):  # pylint: disable=abstract-method
     """
     Base class for course and library import tasks.
@@ -529,11 +532,271 @@ def sync_discussion_settings(course_key, user):
     except Exception as exc:  # pylint: disable=broad-except
         LOGGER.info(f'Course import {course.id}: DiscussionsConfiguration sync failed: {exc}')
 
+# ========== PREREQUISITE IMPORT FUNCTIONS ==========
+
+
+
+def _set_prerequisite_fields(sequential, is_prerequisite=False, serves_for_location=None):
+    """
+    Set prerequisite-related fields on a sequential block.
+    This function tries multiple possible field names.
+    """
+    field_set_success = False
+
+    # Try different field names for is_prerequisite ## TODO DEBUGGING ONLY I WILL HAVE TO CLEAN IT LATER
+    possible_prereq_fields = [
+        'is_prereq', 'is_prerequisite', 'prereq', 'prerequisite',
+        'is_gating_prerequisite', 'gating_prereq'
+    ]
+
+    for field_name in possible_prereq_fields:
+        if hasattr(sequential, field_name):
+            setattr(sequential, field_name, is_prerequisite)
+            logging.info(f"MOOVE: ✓ Set {field_name} = {is_prerequisite}")
+            field_set_success = True
+            break
+
+    # Try different field names for serves_as_prereq_for ## TODO DEBUGGING ONLY I WILL HAVE TO CLEAN IT LATER
+    if serves_for_location:
+        possible_serves_fields = [
+            'serves_as_prereq_for', 'prereq_for', 'gating_prereq_for',
+            'required_for', 'milestone_for'
+        ]
+
+        for field_name in possible_serves_fields:
+            if hasattr(sequential, field_name):
+                setattr(sequential, field_name, str(serves_for_location))
+                logging.info(f"MOOVE: ✓ Set {field_name} = {serves_for_location}")
+                field_set_success = True
+                break
+
+    if not field_set_success:
+        logging.warning("MOOVE: ✗ No prerequisite fields found to set")
+
+    return field_set_success
+
+def _find_sequential_by_url_name(store, course_key, url_name):
+    """
+    Find a sequential block by its url_name (block_id).
+    """
+    logging.info(f"MOOVE: Looking for sequential with url_name: {url_name}")
+
+    # Method 1: Try qualifier search
+    try:
+        sequentials = store.get_items(
+            course_key,
+            qualifiers={'category': 'sequential', 'name': url_name}
+        )
+        if sequentials:
+            logging.info(f"MOOVE: ✓ Found via qualifier: {sequentials[0].location}")
+            return sequentials[0]
+    except Exception as e:
+        logging.info(f"MOOVE: Qualifier search failed: {e}")
+
+    # Method 2: Manual search by block_id
+    all_sequentials = store.get_items(
+        course_key,
+        qualifiers={'category': 'sequential'}
+    )
+
+    for sequential in all_sequentials:
+        if sequential.location.block_id == url_name:
+            logging.info(f"MOOVE: ✓ Found via block_id match: {sequential.location}")
+            return sequential
+
+    # Method 3: Try to construct the usage key directly
+    try:
+        sequential_key = BlockUsageLocator(
+            course_key=course_key,
+            block_type='sequential',
+            block_id=url_name
+        )
+        sequential = store.get_item(sequential_key)
+        if sequential:
+            logging.info(f"MOOVE: ✓ Found via direct key: {sequential.location}")
+            return sequential
+    except Exception as e:
+        logging.info(f"MOOVE: Direct key lookup failed: {e}")
+
+    logging.warning(f"MOOVE: ✗ Sequential not found with url_name: {url_name} after all methods")
+
+    return None
+
+def _store_prerequisite_fallback(store, user_id, gated_sequential, required_sequential, prerequisite_info):
+    """
+    Fallback method to store prerequisite information when GatingService is not available.
+    """
+    try:
+        logging.info("MOOVE: === FALLBACK PREREQUISITE STORAGE ===")
+
+        # Store the relationship information on the GATED sequential
+        if hasattr(gated_sequential, 'imported_prerequisite'):
+            gated_sequential.imported_prerequisite = {
+                **prerequisite_info,
+                'required_sequential': str(required_sequential.location),
+                'setup_time': datetime.now(UTC).isoformat(),
+                'using_fallback': True
+            }
+
+        # Mark the REQUIRED sequential as being a prerequisite - THIS IS CRITICAL
+        if hasattr(required_sequential, 'is_prerequisite'):
+            required_sequential.is_prerequisite = True
+            logging.info(f"MOOVE: Fallback - Set is_prerequisite = True on {required_sequential.location}")
+        else:
+            logging.warning("MOOVE: Fallback - Required sequential doesn't have is_prerequisite field")
+
+        # Store which sequential this serves as prerequisite for
+        if hasattr(required_sequential, 'prerequisite_usage_key'):
+            required_sequential.prerequisite_usage_key = str(gated_sequential.location)
+            logging.info(f"MOOVE: Fallback - Set prerequisite_usage_key = {gated_sequential.location}")
+
+        # Update both blocks in the modulestore
+        logging.info(f"MOOVE: Updating gated sequential: {gated_sequential.location}")
+        store.update_item(gated_sequential, user_id)
+
+        logging.info(f"MOOVE: Updating required sequential: {required_sequential.location}")
+        store.update_item(required_sequential, user_id)
+
+        return True
+
+    except Exception as e:
+        logging.error(f"MOOVE: Fallback storage failed: {e}")
+        return False
+
+
+def _setup_prerequisite_relationship(store, user_id, sequential, prerequisite_info):
+    """
+    Set up prerequisite relationship for a sequential block.
+    """
+    try:
+        required_sequential_url = prerequisite_info.get('required_sequential_url')
+        min_score = prerequisite_info.get('min_score')
+        min_completion = prerequisite_info.get('min_completion')
+
+        if not required_sequential_url:
+            return False
+
+        # Find the required sequential
+        required_sequential = _find_sequential_by_url_name(
+            store, sequential.location.course_key, required_sequential_url
+        )
+
+        if not required_sequential:
+            return False
+
+        # METHOD 1: Set the prerequisite field
+        if hasattr(required_sequential, 'is_prerequisite'):
+            required_sequential.is_prerequisite = True
+            store.update_item(required_sequential, user_id)
+
+        # METHOD 2: Use the gating API to create the actual relationship
+        try:
+            success = _create_proper_gating_milestone(
+                store, user_id,
+                sequential, required_sequential,
+                min_score,
+                min_completion
+            )
+
+            if success:
+                return True
+            else:
+                return _store_prerequisite_fallback(store, user_id, sequential, required_sequential, prerequisite_info)
+
+        except Exception:
+            return _store_prerequisite_fallback(store, user_id, sequential, required_sequential, prerequisite_info)
+
+        return True
+
+    except Exception:
+        return False
+
+def _process_course_prerequisites(course_key, user_id):
+    """
+    Process all prerequisite relationships in the course after import.
+    """
+
+    try:
+        store = modulestore()
+
+        # Get all sequential blocks
+        sequentials = store.get_items(
+            course_key,
+            qualifiers={'category': 'sequential'}
+        )
+
+        logging.info(f"MOOVE: Found {len(sequentials)} sequential blocks to process")
+
+        prerequisite_count = 0
+        for sequential in sequentials:
+            if hasattr(sequential, 'prerequisite') and sequential.prerequisite:
+                prerequisite_info = sequential.prerequisite
+                required_sequential_url = prerequisite_info.get('required_sequential_url')
+
+                if required_sequential_url:
+                    logging.info(f"MOOVE: ✓ Processing prerequisite for {sequential.location}")
+
+                    # Try multiple times with delays (in case of timing issues)
+                    max_retries = 3
+                    for attempt in range(max_retries):
+                        logging.info(f"MOOVE: Attempt {attempt + 1} to find required sequential")
+                        required_sequential = _find_sequential_by_url_name(
+                            store, course_key, required_sequential_url
+                        )
+
+                        if required_sequential:
+                            logging.info(f"MOOVE: ✓ Found required sequential on attempt {attempt + 1}")
+                            success = _setup_prerequisite_relationship(
+                                store, user_id, sequential, prerequisite_info
+                            )
+                            if success:
+                                prerequisite_count += 1
+                                logging.info(f"MOOVE: ✓ Successfully processed prerequisite for {sequential.location}")
+                            else:
+                                logging.error(f"MOOVE: ✗ Failed to process prerequisite for {sequential.location}")
+                            break
+                        else:
+                            if attempt < max_retries - 1:
+                                logging.info(f"MOOVE: Required sequential not found, retrying... (attempt {attempt + 1}/{max_retries})")
+                                import time
+                                time.sleep(1)  # Wait 1 second before retry
+                            else:
+                                logging.error(f"MOOVE: ✗ Required sequential not found after {max_retries} attempts: {required_sequential_url}")
+
+        return prerequisite_count
+
+    except Exception as e:
+        logging.error(f"MOOVE: Error processing prerequisites for course {course_key}: {str(e)}")
+        return 0
+
+
+def _create_proper_gating_milestone(store, user_id, gated_sequential, required_sequential, min_score, min_completion):
+    """
+    Create the proper gating milestones that Studio actually checks.
+    """
+    try:
+        from openedx.core.lib.gating import api as gating_api
+
+        course_key = gated_sequential.location.course_key
+
+        # Create the prerequisite milestone on the required sequential
+        gating_api.add_prerequisite(course_key, required_sequential.location)
+
+        # Create the gating relationship
+        gating_api.set_required_content(
+            course_key,
+            gated_sequential.location,
+            required_sequential.location,
+            min_score,
+            min_completion
+        )
+
+        return True
+
+    except Exception:
+        return False
 
 @shared_task(base=CourseImportTask, bind=True)
-# Note: The decorator @set_code_owner_attribute cannot be used here because the UserTaskMixin
-#   does stack inspection and can't handle additional decorators.
-# lint-amnesty, pylint: disable=too-many-statements
 def import_olx(self, user_id, course_key_string, archive_path, archive_name, language):
     """
     Import a course or library from a provided OLX .tar.gz or .zip archive.
@@ -732,7 +995,7 @@ def read_chunk():
         LOGGER.info(f'{log_prefix}: Extracted file verified. Updating course started')
 
         courselike_items = import_func(
-            modulestore(), user.id,
+            modulestore(), user_id,
             settings.GITHUB_REPO_ROOT, [dirpath],
             load_error_blocks=False,
             static_content_store=contentstore(),
@@ -743,6 +1006,11 @@ def read_chunk():
         new_location = courselike_items[0].location
         LOGGER.debug('new course at %s', new_location)
 
+        # Process prerequisites after successful import
+        if is_course:
+            prerequisite_count = _process_course_prerequisites(courselike_key, user_id)
+            LOGGER.info(f'{log_prefix}: Import completed with {prerequisite_count} prerequisites processed')
+
         LOGGER.info(f'{log_prefix}: Course import successful')
         set_custom_attribute('course_import_completed', True)
     except (CourseImportException, InvalidProctoringProvider, DuplicateCourseError) as known_exe:
@@ -769,10 +1037,10 @@ def read_chunk():
                 from .views.entrance_exam import add_entrance_exam_milestone
                 add_entrance_exam_milestone(course.id, entrance_exam_chapter)
                 LOGGER.info(f'Course import {course.id}: Entrance exam imported')
+
     if is_course:
         sync_discussion_settings(courselike_key, user)
 
-
 @shared_task
 @set_code_owner_attribute
 def update_all_outlines_from_modulestore_task():

cms/djangoapps/contentstore/utils.py

@@ -116,6 +116,8 @@
 
 from .models import ComponentLink, ContainerLink
 
+from openedx.core.lib.gating.services import GatingService
+
 IMPORTABLE_FILE_TYPES = ('.tar.gz', '.zip')
 log = logging.getLogger(__name__)
 
@@ -1319,7 +1321,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