feat: implement optional completion

This adds a new XBlock field that allows marking sections, subsections,
and units as optional, which means that their completion is counted separately.

Author: Agrendalath

lms/djangoapps/course_api/blocks/serializers.py

@@ -85,6 +85,7 @@ def __init__(
     SupportedFieldType(BlockCompletionTransformer.COMPLETION, BlockCompletionTransformer),
     SupportedFieldType(BlockCompletionTransformer.COMPLETE),
     SupportedFieldType(BlockCompletionTransformer.RESUME_BLOCK),
+    SupportedFieldType(BlockCompletionTransformer.OPTIONAL_COMPLETION),
     SupportedFieldType(DiscussionsTopicLinkTransformer.EXTERNAL_ID),
     SupportedFieldType(DiscussionsTopicLinkTransformer.EMBED_URL),
 

lms/djangoapps/course_api/blocks/transformers/block_completion.py

@@ -18,6 +18,7 @@ class BlockCompletionTransformer(BlockStructureTransformer):
     COMPLETION = 'completion'
     COMPLETE = 'complete'
     RESUME_BLOCK = 'resume_block'
+    OPTIONAL_COMPLETION = 'optional_completion'
 
     @classmethod
     def name(cls):
@@ -43,7 +44,7 @@ def get_block_completion(cls, block_structure, block_key):
 
     @classmethod
     def collect(cls, block_structure):
-        block_structure.request_xblock_fields('completion_mode')
+        block_structure.request_xblock_fields('completion_mode', cls.OPTIONAL_COMPLETION)
 
     @staticmethod
     def _is_block_excluded(block_structure, block_key):

lms/djangoapps/course_home_api/outline/serializers.py

@@ -50,6 +50,7 @@ def get_blocks(self, block):  # pylint: disable=missing-function-docstring
             block_key: {
                 'children': [child['id'] for child in children],
                 'complete': block.get('complete', False),
+                'optional_completion': block.get('optional_completion', False),
                 'description': description,
                 'display_name': display_name,
                 'due': block.get('due'),

lms/djangoapps/courseware/courses.py

@@ -552,38 +552,51 @@ def get_course_assignment_date_blocks(course, user, request, num_return=None,
 
 
 @request_cached()
-def get_course_blocks_completion_summary(course_key, user):
+def get_course_blocks_completion_summary(course_key, user) -> dict[str, int]:
     """
-    Returns an object with the number of complete units, incomplete units, and units that contain gated content
+    Returns a dict with the number of complete units, incomplete units, and units that contain gated content
     for the given course. The complete and incomplete counts only reflect units that are able to be completed by
     the given user. If a unit contains gated content, it is not counted towards the incomplete count.
 
-    The object contains fields: complete_count, incomplete_count, locked_count
+    The dict contains fields:
+      - complete_count
+      - incomplete_count
+      - locked_count
+      - optional_complete_count
+      - optional_incomplete_count
+      - optional_locked_count
     """
     if not user.id:
-        return []
+        return {}
+
     store = modulestore()
     course_usage_key = store.make_course_usage_key(course_key)
     block_data = get_course_blocks(user, course_usage_key, allow_start_dates_in_future=True, include_completion=True)
 
-    complete_count, incomplete_count, locked_count = 0, 0, 0
+    counts = {
+        'complete_count': 0,
+        'incomplete_count': 0,
+        'locked_count': 0,
+        'optional_complete_count': 0,
+        'optional_incomplete_count': 0,
+        'optional_locked_count': 0,
+    }
     for section_key in block_data.get_children(course_usage_key):  # pylint: disable=too-many-nested-blocks
         for subsection_key in block_data.get_children(section_key):
             for unit_key in block_data.get_children(subsection_key):
                 complete = block_data.get_xblock_field(unit_key, 'complete', False)
                 contains_gated_content = block_data.get_xblock_field(unit_key, 'contains_gated_content', False)
+                optional = block_data.get_xblock_field(unit_key, 'optional_completion', False)
+                prefix = "optional_" if optional else ""
+
                 if contains_gated_content:
-                    locked_count += 1
+                    counts[f"{prefix}locked_count"] += 1
                 elif complete:
-                    complete_count += 1
+                    counts[f"{prefix}complete_count"] += 1
                 else:
-                    incomplete_count += 1
+                    counts[f"{prefix}incomplete_count"] += 1
 
-    return {
-        'complete_count': complete_count,
-        'incomplete_count': incomplete_count,
-        'locked_count': locked_count
-    }
+    return counts
 
 
 @request_cached()

openedx/features/course_experience/utils.py

@@ -114,6 +114,7 @@ def recurse_mark_auth_denial(block):
             'weight',
             'completion',
             'complete',
+            'optional_completion',
             'resume_block',
             'hide_from_toc',
             'icon_class',

xmodule/modulestore/inheritance.py

@@ -247,6 +247,17 @@ class InheritanceMixin(XBlockMixin):
         scope=Scope.settings
     )
 
+    optional_completion = Boolean(
+        display_name=_("Optional"),
+        help=_(
+            "Set this to true to mark this block as optional. "
+            "Progress in this block won't count towards course completion progress "
+            "and will count as optional progress instead."
+        ),
+        default=False,
+        scope=Scope.settings,
+    )
+
     @property
     def close_date(self):
         """