refactor: Inject isArchivedByLearner into initial API response

This both:
* demonstrates filter pipeline steps in a practical way which relates to
  the sample archive functionality.
* removes the need to call GET ..../course-archive-status/ in order to
  render the page.

The GET API still exists, as it's called to update the state after a learner
clicks Archive/Unarchive (could probably be factored away, but not important)

This removes the old sample filter pipeline step, which changed the course about
URL into an example.com URL.

Author: kdmccormick

backend-plugin-sample/src/openedx_plugin_sample/pipeline.py

@@ -39,118 +39,37 @@
 
 import logging
 import re
+import crum
 
 from openedx_filters.filters import PipelineStep
 
+from .models import CourseArchiveStatus
+
 logger = logging.getLogger(__name__)
 
 
-class ChangeCourseAboutPageUrl(PipelineStep):
+class AddArchiveStatusToLearnerHomeCourseRun(PipelineStep):
     """
-    Filter to customize course about page URLs.
-
-    This filter demonstrates how to intercept and modify course about page URLs,
-    redirecting them to external sites or custom implementations.
-
-    Filter Hook Point:
-    This filter hooks into the course about page URL rendering process.
-    Register it for the filter: org.openedx.learning.course.about.render.started.v1
-
-    Registration Example (in settings/common.py)::
-
-        def plugin_settings(settings):
-            settings.OPEN_EDX_FILTERS_CONFIG = {
-                "org.openedx.learning.course.about.render.started.v1": {
-                    "pipeline": [
-                        "openedx_plugin_sample.pipeline.ChangeCourseAboutPageUrl"
-                    ],
-                    "fail_silently": False,
-                }
-            }
-
-    Filter Documentation:
-    - Available Filters: https://docs.openedx.org/projects/openedx-filters/en/latest/reference/filters.html
-    - PipelineStep: https://docs.openedx.org/projects/openedx-filters/en/latest/reference/filters-tooling.html#openedx_filters.filters.PipelineStep
-
-    Real-World Use Cases:
-    - Redirect to marketing site course pages
-    - Implement custom course discovery interfaces
-    - Add tracking parameters to URLs
-    - Route different course types to different platforms
-    - Implement A/B testing for course pages
+    Customize each courseRun within a Learner Dashboard's /init API response to include the CourseArchiveStatus.
     """  # noqa: E501
 
-    def run_filter(self, url, org, **kwargs):  # pylint: disable=arguments-differ
+    def run_filter(self, serialized_courserun, **kwargs):  # pylint: disable=arguments-differ
         """
-        Modify the course about page URL.
-
-        This method intercepts course about page URL generation and can modify
-        the destination URL based on business logic.
-
-        Args:
-            url (str): The original course about page URL
-            org (str): The organization/institution identifier
-            **kwargs: Additional context data from the platform
-
-        Returns:
-            dict: Dictionary with same parameter names as input
-                - url (str): Modified or original URL
-                - org (str): Organization identifier (usually unchanged)
-
-        Raises:
-            FilterException: If processing should be halted
+        Return a modified `serialized_courserun`, the data for one courseRun sent to the Learner Dashboard.
 
-        Filter Requirements:
-        - Must return dictionary with keys matching input parameters
-        - Return None to skip this filter (let other filters run)
-        - Raise FilterException to halt pipeline execution
-        - Handle all input scenarios gracefully
-
-        URL Pattern Matching:
-        This implementation looks for Open edX course keys in the format:
-        course-v1:ORG+COURSE+RUN (e.g., course-v1:edX+DemoX+Demo_Course)
-
-        Documentation:
-        - run_filter method: https://docs.openedx.org/projects/openedx-filters/en/latest/reference/filters-tooling.html#openedx_filters.filters.PipelineStep.run_filter
+        Inserts the `isArchivedByLearner` field (disambiguated from `isArchived`, which refers to whether the course run has
+        been archived by the authors).
         """  # noqa: E501
-        # Extract course ID using Open edX course key pattern
-        # Course keys follow the format: course-v1:ORG+COURSE+RUN
-        pattern = r'(?P<course_id>course-v1:[^/]+)'
-
-        match = re.search(pattern, url)
-        if match:
-            course_id = match.group('course_id')
-
-            # Example: Redirect to external marketing site
-            new_url = f"https://example.com/new_about_page/{course_id}"
-
-            logger.debug(
-                f"Redirecting course about page for {course_id} from {url} to {new_url}"
-            )
-
-            # Return modified data
-            return {"url": new_url, "org": org}
-
-        # No course ID found - return original data unchanged
-        logger.debug(f"No course ID found in URL {url}, leaving unchanged")
-        return {"url": url, "org": org}
-
-        # Alternative patterns for different business logic:
-
-        # Organization-based routing:
-        # if org == "special_org":
-        #     new_url = f"https://special-site.com/courses/{course_id}"
-        #     return {"url": new_url, "org": org}
-
-        # Course type-based routing:
-        # if "MicroMasters" in course_id:
-        #     new_url = f"https://micromasters.example.com/{course_id}"
-        #     return {"url": new_url, "org": org}
-
-        # A/B testing implementation:
-        # import random
-        # if random.choice([True, False]):
-        #     new_url = f"https://variant-a.example.com/{course_id}"
-        # else:
-        #     new_url = f"https://variant-b.example.com/{course_id}"
-        # return {"url": new_url, "org": org}
+        user = crum.get_current_request().user
+        try:
+            is_archived_by_learner = CourseArchiveStatus.objects.get(
+                user=user, course_id=serialized_courserun["courseId"]
+            ).is_archived
+        except CourseArchiveStatus.DoesNotExist:
+            is_archived_by_learner = False
+        return {
+            "serialized_courserun": {
+                **serialized_courserun,
+                "isArchivedByLearner": is_archived_by_learner,
+            },
+        }

backend-plugin-sample/src/openedx_plugin_sample/settings/common.py

@@ -96,8 +96,8 @@ def _configure_openedx_filters(settings):
     filters_config = getattr(settings, 'OPEN_EDX_FILTERS_CONFIG', {})
 
     # Filter we want to register
-    filter_name = "org.openedx.learning.course_about.page.url.requested.v1"
-    our_pipeline_step = "openedx_plugin_sample.pipeline.ChangeCourseAboutPageUrl"
+    filter_name = "org.openedx.learning.home.courserun.api.rendered.started.v1"
+    our_pipeline_step = "openedx_plugin_sample.pipeline.AddArchiveStatusToLearnerHomeCourseRun"
 
     # Check if this filter already has configuration
     if filter_name in filters_config:

frontend-plugin-sample/README.md

@@ -90,33 +90,35 @@ const courses = courseListData.visibleList;
 
 **Slot Props**: Each slot provides specific data. For CourseListSlot, see the [slot documentation](https://github.com/openedx/frontend-app-learner-dashboard/tree/master/src/plugin-slots/CourseListSlot#plugin-props).
 
-#### 2. Backend API Integration
+#### 2. Backend Data via the Filter Pipeline
 
-```jsx
-useEffect(() => {
-  const fetchArchivedCourses = async () => {
-    const client = getAuthenticatedHttpClient();
-    const lmsBaseUrl = getConfig().LMS_BASE_URL;
-
-    const response = await client.get(
-      `${lmsBaseUrl}/sample-plugin/api/v1/course-archive-status/`,
-      { params: { is_archived: true } }
-    );
-
-    const archivedCourseIds = new Set(
-      response.data.results.map((item) => item.course_id)
-    );
-    setArchivedCourses(archivedCourseIds);
-  };
+Rather than firing an extra GET to `course-archive-status/` on every dashboard
+load, the initial archive state is read directly off the slot props. The backend
+plugin uses an Open edX filter (see [`pipeline.py`](../backend-plugin-sample/src/openedx_plugin_sample/pipeline.py))
+to inject `isArchivedByLearner` into each courseRun in the Learner Home `/init`
+API response, so it arrives alongside the rest of the course data:
 
-  fetchArchivedCourses();
-}, []);
+```jsx
+const [archivedCourses, setArchivedCourses] = useState(() => {
+  const initial = new Set();
+  (courseListData?.visibleList || []).forEach((courseData) => {
+    if (courseData.courseRun?.isArchivedByLearner) {
+      initial.add(courseData.courseRun.courseId);
+    }
+  });
+  return initial;
+});
 ```
 
+**Why this pattern**: One fewer round-trip per dashboard load, and the archive
+state is consistent with the rest of the course data from the same response.
+The REST API is still used for writes (archive/unarchive) — see the toggle
+handler below.
+
 **Key Patterns:**
-- **Authentication**: `getAuthenticatedHttpClient()` handles Open edX auth
+- **Filter-injected data**: Read `courseRun.isArchivedByLearner` straight from slot props
+- **Authentication** (for writes): `getAuthenticatedHttpClient()` handles Open edX auth
 - **Configuration**: `getConfig().LMS_BASE_URL` gets platform URLs
-- **Error Handling**: Try/catch blocks for API failures
 
 #### 3. Open edX UI Components