feat: command to reset attempts and rescore problem (#789)

* feat: command to reset attempts and rescore promlem

* fmt

* install in LMS plus refactoring

* more changes

* fix docs

* review chnages

* Potential fix for pull request finding

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

* refactor

---------

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

Author: asadali145

src/ol_openedx_course_sync/README.rst

@@ -15,10 +15,14 @@ For detailed installation instructions, please refer to the `plugin installation
 
 Installation required in:
 
-* CMS
+* CMS (for course sync functionality)
+* LMS (for problem attempts reset and rescore functionality)
 
 Configuration
-=============
+==============
+
+CMS Configuration
+-----------------
 
 * Add a setting ``OL_OPENEDX_COURSE_SYNC_SERVICE_WORKER_USERNAME`` for the service worker and all the sync operations will be done on behalf of this user.
 
@@ -33,10 +37,57 @@ Configuration
 Usage
 -----
 
+Course Sync (CMS)
+~~~~~~~~~~~~~~~~~
+
 * Install the plugin and run the migrations in the CMS.
 * Add the parent/source organization in the CMS admin model `CourseSyncOrganization`.
     * Course sync will only work for this organization. It will treat all the courses under this organization as parent/source courses.
 * The plugin will automatically add course re-runs created from the CMS as the child courses.
     * The organization can be different for the reruns.
 * Target/rerun courses can be managed in the CMS admin model `CourseSyncMapping`.
 * Now, any changes made in the source course will be synced to the target courses.
+
+Problem Actions (LMS)
+~~~~~~~~~~~~~~~~~~~~~
+
+The plugin provides a management command to reset learner attempts or rescore problems across the source course and all its synced target courses.
+
+**Command:** ``sync_problem_actions``
+
+**Syntax:**
+
+.. code-block:: bash
+
+    python manage.py lms sync_problem_actions <action> <source_course_key> <problem_id> [OPTIONS]
+
+**Actions:**
+
+* ``reset_attempts``: Resets learner attempts for a problem
+* ``rescore``: Rescores learners for a problem
+
+**Options:**
+
+* ``--username USERNAME``: Username to run the task as (default: 'courses_service_worker')
+* ``--only-if-higher`` / ``--no-only-if-higher``: Whether to rescore only if the new score is higher (default: True)
+
+**Examples:**
+
+Reset attempts for a problem across all synced courses:
+
+.. code-block:: bash
+
+    python manage.py lms sync_problem_actions reset_attempts \
+        "course-v1:ORG+COURSE+RUN" \
+        "block-v1:ORG+COURSE+RUN+type@problem+block@abc123" \
+        --username courses_service_worker
+
+Rescore a problem for all learners across all synced courses:
+
+.. code-block:: bash
+
+    python manage.py lms sync_problem_actions rescore \
+        "course-v1:ORG+COURSE+RUN" \
+        "block-v1:ORG+COURSE+RUN+type@problem+block@abc123" \
+        --username courses_service_worker \
+        --only-if-higher

src/ol_openedx_course_sync/ol_openedx_course_sync/apps.py

@@ -34,5 +34,11 @@ class OLOpenEdxCourseSyncConfig(AppConfig):
                 },
                 SettingsType.COMMON: {PluginSettings.RELATIVE_PATH: "settings.common"},
             },
+            ProjectType.LMS: {
+                SettingsType.PRODUCTION: {
+                    PluginSettings.RELATIVE_PATH: "settings.production"
+                },
+                SettingsType.COMMON: {PluginSettings.RELATIVE_PATH: "settings.common"},
+            },
         },
     }

src/ol_openedx_course_sync/ol_openedx_course_sync/management/__init__.py

@@ -0,0 +1,304 @@
+"""
+Management command to reset attempts or rescore problem for synced courses.
+
+Resets attempts or rescores learners for a problem across all courses in a sync mapping
+(source course and all target courses).
+
+Usage:
+    python manage.py lms sync_problem_actions <action> \
+    <source_course_key> <problem_id> [OPTIONS]
+
+Actions:
+    reset_attempts: Resets learner attempts for a problem
+    rescore: Rescores learner for a problem
+
+Options:
+    --username USERNAME
+        Username to run the task as (default: 'courses_service_worker')
+    --only-if-higher / --no-only-if-higher
+        Whether to rescore only if the new score is higher (default: True)
+
+Examples:
+    python manage.py lms sync_problem_actions reset_attempts \
+        "course-v1:ORG+COURSE+RUN" \
+        "block-v1:ORG+COURSE+RUN+type@problem+block@abc123" \
+        --username courses_service_worker
+
+    python manage.py lms sync_problem_actions rescore \
+        "course-v1:ORG+COURSE+RUN" \
+        "block-v1:ORG+COURSE+RUN+type@problem+block@abc123" \
+        --username courses_service_worker \
+        --only-if-higher
+"""
+
+import argparse
+
+from django.contrib.auth import get_user_model
+from django.core.management.base import BaseCommand, CommandError
+from django.test.client import RequestFactory
+from lms.djangoapps.instructor_task import api as task_api
+from lms.djangoapps.instructor_task.api_helper import AlreadyRunningError
+from opaque_keys import InvalidKeyError
+from opaque_keys.edx.keys import CourseKey, UsageKey
+from xmodule.modulestore.exceptions import ItemNotFoundError
+
+from ol_openedx_course_sync.utils import get_syncable_course_mappings
+
+User = get_user_model()
+
+ACTION_RESET_ATTEMPTS = "reset_attempts"
+ACTION_RESCORE = "rescore"
+VALID_ACTIONS = [ACTION_RESET_ATTEMPTS, ACTION_RESCORE]
+
+STATUS_SUBMITTED = "submitted"
+STATUS_ALREADY_RUNNING = "already_running"
+STATUS_FAILED = "failed"
+
+
+class Command(BaseCommand):
+    """
+    Reset attempts or rescore problem for all synced courses.
+    """
+
+    help = "Reset attempts or rescore problem across all synced courses"
+
+    def add_arguments(self, parser):
+        """Add command arguments."""
+        parser.add_argument(
+            "action",
+            type=str,
+            choices=VALID_ACTIONS,
+            help="Action to perform: 'reset_attempts' or 'rescore'",
+        )
+        parser.add_argument(
+            "source_course_key",
+            type=str,
+            help="Source course key (e.g., 'course-v1:ORG+COURSE+RUN')",
+        )
+        parser.add_argument(
+            "problem_id",
+            type=str,
+            help=(
+                "Problem usage key "
+                "(e.g., 'block-v1:ORG+COURSE+RUN+type@problem+block@id')"
+            ),
+        )
+        parser.add_argument(
+            "--username",
+            type=str,
+            default="courses_service_worker",
+            help="Username to run the task as (default: 'courses_service_worker')",
+        )
+        parser.add_argument(
+            "--only-if-higher",
+            action=argparse.BooleanOptionalAction,
+            default=True,
+            help=(
+                "Whether to rescore only if the new score is higher "
+                "(default: True, use --no-only-if-higher to disable)"
+            ),
+        )
+
+    def handle(self, **options):
+        """Execute the command."""
+        action = options["action"]
+        source_course_key_str = options["source_course_key"]
+        problem_id_str = options["problem_id"]
+        username = options["username"]
+        only_if_higher = options["only_if_higher"]
+
+        try:
+            source_course_key = CourseKey.from_string(source_course_key_str)
+        except InvalidKeyError as exc:
+            error_msg = f"Invalid source course key: {source_course_key_str}"
+            raise CommandError(error_msg) from exc
+
+        try:
+            problem_usage_key = UsageKey.from_string(problem_id_str)
+        except InvalidKeyError as exc:
+            error_msg = f"Invalid problem usage key: {problem_id_str}"
+            raise CommandError(error_msg) from exc
+
+        courses = self._get_synced_courses(source_course_key)
+        try:
+            request_obj = self._make_shell_request(username)
+        except User.DoesNotExist as exc:
+            error_msg = f"User not found: {username}"
+            raise CommandError(error_msg) from exc
+
+        if action == ACTION_RESET_ATTEMPTS:
+            results = self._submit_for_courses(
+                request_obj, courses, problem_usage_key, ACTION_RESET_ATTEMPTS
+            )
+        elif action == ACTION_RESCORE:
+            results = self._submit_for_courses(
+                request_obj,
+                courses,
+                problem_usage_key,
+                ACTION_RESCORE,
+                only_if_higher=only_if_higher,
+            )
+
+        self._print_summary(results, action)
+
+    def _get_synced_courses(self, source_course_key):
+        """
+        Get all courses for a sync mapping (source + all targets).
+
+        Args:
+            source_course_key: CourseKey of the source course
+
+        Returns:
+            List of course key strings
+        """
+        courses = [str(source_course_key)]
+        mappings = get_syncable_course_mappings(source_course_key)
+        if mappings:
+            courses.extend(str(mapping.target_course) for mapping in mappings)
+        return courses
+
+    def _make_shell_request(self, username):
+        """
+        Create a request object for shell execution.
+
+        Args:
+            username: Username to associate with the request
+
+        Returns:
+            Request object with user context
+
+        Raises:
+            User.DoesNotExist: If user not found
+        """
+        user = User.objects.get(username=username)
+        req = RequestFactory().post(
+            "/shell/instructor-task",
+            HTTP_USER_AGENT="lms-shell",
+            REMOTE_ADDR="127.0.0.1",
+            SERVER_NAME="localhost",
+        )
+        req.user = user
+        return req
+
+    def _submit_for_courses(
+        self,
+        request,
+        course_keys,
+        problem_usage_key,
+        action,
+        *,
+        only_if_higher=False,
+    ):
+        """
+        Submit reset/rescore tasks for courses.
+
+        Args:
+            request: Request object with user context
+            course_keys: List of course keys
+            problem_usage_key: UsageKey of the problem
+            action: Action to perform (reset_attempts or rescore)
+            only_if_higher: Only rescore if new score is higher (rescore only)
+
+        Returns:
+            List of result dictionaries
+        """
+        results = []
+
+        for course_id_str in course_keys:
+            try:
+                course_key = CourseKey.from_string(course_id_str)
+                mapped_problem_key = problem_usage_key.map_into_course(course_key)
+
+                if action == ACTION_RESET_ATTEMPTS:
+                    task = task_api.submit_reset_problem_attempts_for_all_students(
+                        request, mapped_problem_key
+                    )
+                elif action == ACTION_RESCORE:
+                    task = task_api.submit_rescore_problem_for_all_students(
+                        request, mapped_problem_key, only_if_higher=only_if_higher
+                    )
+
+                row = {
+                    "course_id": course_id_str,
+                    "action": action,
+                    "mapped_problem_id": str(mapped_problem_key),
+                    "task_id": task.task_id,
+                    "status": STATUS_SUBMITTED,
+                }
+                if action == ACTION_RESCORE:
+                    row["only_if_higher"] = only_if_higher
+
+                results.append(row)
+                if action == ACTION_RESET_ATTEMPTS:
+                    self.stdout.write(
+                        "OK | "
+                        f"{action.upper()} | {course_id_str} | {mapped_problem_key} "
+                        f"| task={task.task_id}"
+                    )
+                elif action == ACTION_RESCORE:
+                    self.stdout.write(
+                        "OK | "
+                        f"{action.upper()} | {course_id_str} | {mapped_problem_key} "
+                        f"| only_if_higher={only_if_higher} | task={task.task_id}"
+                    )
+
+            except AlreadyRunningError as exc:
+                row = {
+                    "course_id": course_id_str,
+                    "action": action,
+                    "status": STATUS_ALREADY_RUNNING,
+                    "error": str(exc),
+                }
+                results.append(row)
+                self.stdout.write(
+                    self.style.WARNING(
+                        f"SKIP(already running) | {action} | {course_id_str} | {exc}"
+                    )
+                )
+
+            except (InvalidKeyError, ItemNotFoundError, ValueError) as exc:
+                row = {
+                    "course_id": course_id_str,
+                    "action": action,
+                    "status": STATUS_FAILED,
+                    "error": str(exc),
+                }
+                results.append(row)
+                self.stdout.write(
+                    self.style.ERROR(f"FAIL | {action} | {course_id_str} | {exc}")
+                )
+
+            except Exception as exc:  # pylint: disable=broad-except  # noqa: BLE001
+                row = {
+                    "course_id": course_id_str,
+                    "action": action,
+                    "status": STATUS_FAILED,
+                    "error": str(exc),
+                }
+                results.append(row)
+                self.stdout.write(
+                    self.style.ERROR(f"FAIL | {action} | {course_id_str} | {exc}")
+                )
+
+        return results
+
+    def _print_summary(self, results, action):
+        """Print summary of operation."""
+        submitted = sum(1 for r in results if r["status"] == STATUS_SUBMITTED)
+        already_running = sum(
+            1 for r in results if r["status"] == STATUS_ALREADY_RUNNING
+        )
+        failed = sum(1 for r in results if r["status"] == STATUS_FAILED)
+
+        self.stdout.write("\n" + "=" * 50)
+        self.stdout.write(f"{action.upper()} Summary")
+        self.stdout.write("=" * 50)
+        self.stdout.write(f"Total courses:      {len(results)}")
+        self.stdout.write(self.style.SUCCESS(f"Submitted:          {submitted}"))
+        if already_running:
+            self.stdout.write(
+                self.style.WARNING(f"Already running:    {already_running}")
+            )
+        if failed:
+            self.stdout.write(self.style.ERROR(f"Failed:             {failed}"))
+        self.stdout.write("=" * 50)