learning-credentials 0.3.0rc3__py3-none-any.whl → 0.3.0rc10__py3-none-any.whl

learning_credentials/processors.py

@@ -38,63 +38,46 @@ log = logging.getLogger(__name__)
 
 def _process_learning_context(
     learning_context_key: LearningContextKey,
-    course_processor: Callable[[CourseKey, dict[str, Any], int | None], dict[int, dict[str, Any]]],
+    course_processor: Callable[[CourseKey, dict[str, Any]], list[int]],
     options: dict[str, Any],
-    user_id: int | None = None,
-) -> dict[int, dict[str, Any]]:
+) -> list[int]:
     """
     Process a learning context (course or learning path) using the given course processor function.
 
     For courses, runs the processor directly. For learning paths, runs the processor on each
-    course in the path with step-specific options (if available), and returns detailed results
-    with step breakdown.
+    course in the path with step-specific options (if available), and returns the intersection
+    of eligible users across all courses.
 
     Args:
         learning_context_key: A course key or learning path key to process
-        course_processor: A function that processes a single course and returns detailed progress for all users
+        course_processor: A function that processes a single course and returns eligible user IDs
         options: Options to pass to the processor. For learning paths, may contain a "steps" key
                 with step-specific options in the format: {"steps": {"<course_key>": {...}}}
-        user_id: Optional. If provided, will filter to the specific user.
 
     Returns:
-        A dict mapping user_id to detailed progress, with step breakdown for learning paths
+        A list of eligible user IDs
     """
     if learning_context_key.is_course:
-        return course_processor(learning_context_key, options, user_id)  # type: ignore[invalid-argument-type]
+        return course_processor(learning_context_key, options)
 
     learning_path = LearningPath.objects.get(key=learning_context_key)
 
-    step_results_by_course = {}
-    all_user_ids = set()
+    results = None
+    for course in learning_path.steps.all():
+        course_options = options.get("steps", {}).get(str(course.course_key), options)
+        course_results = set(course_processor(course.course_key, course_options))
 
-    # TODO: Use a single Completion Aggregator request when retrieving step results for a single user.
-    for step in learning_path.steps.all():
-        course_options = options.get("steps", {}).get(str(step.course_key), options)
-        step_results = course_processor(step.course_key, course_options, user_id)
-
-        step_results_by_course[str(step.course_key)] = step_results
-        all_user_ids.update(step_results.keys())
+        if results is None:
+            results = course_results
+        else:
+            results &= course_results
 
     # Filter out users who are not enrolled in the Learning Path.
-    all_user_ids &= set(
-        learning_path.enrolled_users.filter(learningpathenrollment__is_active=True).values_list('id', flat=True)
+    results &= set(
+        learning_path.enrolled_users.filter(learningpathenrollment__is_active=True).values_list('id', flat=True),
     )
 
-    final_results = {}
-    for uid in all_user_ids:
-        overall_eligible = True
-        user_step_results = {}
-
-        for course_key, step_results in step_results_by_course.items():
-            if uid in step_results:
-                user_step_results[course_key] = step_results[uid]
-                overall_eligible = overall_eligible and step_results[uid].get('is_eligible', False)
-            else:
-                overall_eligible = False
-
-        final_results[uid] = {'is_eligible': overall_eligible, 'steps': user_step_results}
-
-    return final_results
+    return list(results) if results else []
 
 
 def _get_category_weights(course_id: CourseKey) -> dict[str, float]:
@@ -117,7 +100,7 @@ def _get_category_weights(course_id: CourseKey) -> dict[str, float]:
     return category_weight_ratios
 
 
-def _get_grades_by_format(course_id: CourseKey, users: list[User]) -> dict[int, dict[str, float]]:
+def _get_grades_by_format(course_id: CourseKey, users: list[User]) -> dict[int, dict[str, int]]:
     """
     Get the grades for each user, categorized by assignment types.
 
@@ -179,65 +162,30 @@ def _are_grades_passing_criteria(
     return total_score >= required_grades.get('total', 0)
 
 
-def _calculate_grades_progress(
-    user_grades: dict[str, float],
-    required_grades: dict[str, float],
-    category_weights: dict[str, float],
-) -> dict[str, Any]:
-    """
-    Calculate detailed progress information for grade-based criteria.
-
-    :param user_grades: The grades of the user, divided by category.
-    :param required_grades: The required grades for each category.
-    :param category_weights: The weight of each category.
-    :returns: Dict with is_eligible, current_grades, and required_grades.
-    """
-    # Calculate total score
-    total_score = 0
-    for category, score in user_grades.items():
-        if category in category_weights:
-            total_score += score * category_weights[category]
-
-    # Add total to user grades
-    user_grades_with_total = {**user_grades, 'total': total_score}
-
-    is_eligible = _are_grades_passing_criteria(user_grades, required_grades, category_weights)
-
-    return {
-        'is_eligible': is_eligible,
-        'current_grades': user_grades_with_total,
-        'required_grades': required_grades,
-    }
-
-
-def _retrieve_course_subsection_grades(
-    course_id: CourseKey, options: dict[str, Any], user_id: int | None = None
-) -> dict[int, dict[str, Any]]:
-    """Implementation for retrieving course grades. Always returns detailed progress for all users."""
+def _retrieve_course_subsection_grades(course_id: CourseKey, options: dict[str, Any]) -> list[int]:
+    """Implementation for retrieving course grades."""
     required_grades: dict[str, int] = options['required_grades']
     required_grades = {key.lower(): value * 100 for key, value in required_grades.items()}
 
-    users = get_course_enrollments(course_id, user_id)
+    users = get_course_enrollments(course_id)
     grades = _get_grades_by_format(course_id, users)
     log.debug(grades)
     weights = _get_category_weights(course_id)
 
-    results = {}
-    for uid, user_grades in grades.items():
-        results[uid] = _calculate_grades_progress(user_grades, required_grades, weights)
+    eligible_users = []
+    for user_id, user_grades in grades.items():
+        if _are_grades_passing_criteria(user_grades, required_grades, weights):
+            eligible_users.append(user_id)
 
-    return results
+    return eligible_users
 
 
-def retrieve_subsection_grades(
-    learning_context_key: LearningContextKey, options: dict[str, Any], user_id: int | None = None
-) -> list[int] | dict[str, Any]:
+def retrieve_subsection_grades(learning_context_key: LearningContextKey, options: dict[str, Any]) -> list[int]:
     """
     Retrieve the users that have passing grades in all required categories.
 
     :param learning_context_key: The learning context key (course or learning path).
     :param options: The custom options for the credential.
-    :param user_id: Optional. If provided, will check eligibility for the specific user.
     :returns: The IDs of the users that have passing grades in all required categories.
 
     Options:
@@ -284,16 +232,7 @@ def retrieve_subsection_grades(
             }
           }
     """
-    detailed_results = _process_learning_context(
-        learning_context_key, _retrieve_course_subsection_grades, options, user_id
-    )
-
-    if user_id is not None:
-        if user_id in detailed_results:
-            return detailed_results[user_id]
-        return {'is_eligible': False, 'current_grades': {}, 'required_grades': {}}
-
-    return [uid for uid, result in detailed_results.items() if result.get('is_eligible', False)]
+    return _process_learning_context(learning_context_key, _retrieve_course_subsection_grades, options)
 
 
 def _prepare_request_to_completion_aggregator(course_id: CourseKey, query_params: dict, url: str) -> APIView:
@@ -313,7 +252,7 @@ def _prepare_request_to_completion_aggregator(course_id: CourseKey, query_params
     drf_request = Request(django_request)  # convert django.core.handlers.wsgi.WSGIRequest to DRF request
 
     view = CompletionDetailView()
-    view.request = drf_request  # type: ignore[invalid-assignment]
+    view.request = drf_request
 
     # HACK: Bypass the API permissions.
     staff_user = get_user_model().objects.filter(is_staff=True).first()
@@ -323,10 +262,8 @@ def _prepare_request_to_completion_aggregator(course_id: CourseKey, query_params
     return view
 
 
-def _retrieve_course_completions(
-    course_id: CourseKey, options: dict[str, Any], user_id: int | None = None
-) -> dict[int, dict[str, Any]]:
-    """Implementation for retrieving course completions. Always returns detailed progress for all users."""
+def _retrieve_course_completions(course_id: CourseKey, options: dict[str, Any]) -> list[int]:
+    """Implementation for retrieving course completions."""
     # If it turns out to be too slow, we can:
     # 1. Modify the Completion Aggregator to emit a signal/event when a user achieves a certain completion threshold.
     # 2. Get this data from the `Aggregator` model. Filter by `aggregation name == 'course'`, `course_key`, `percent`.
@@ -339,47 +276,29 @@ def _retrieve_course_completions(
 
     # TODO: Extract the logic of this view into an API. The current approach is very hacky.
     view = _prepare_request_to_completion_aggregator(course_id, query_params.copy(), url)
-    completions = {}
+    completions = []
 
     while True:
         # noinspection PyUnresolvedReferences
         response = view.get(view.request, str(course_id))
         log.debug(response.data)
-        for res in response.data['results']:
-            completions[res['username']] = res['completion']['percent']
+        completions.extend(
+            res['username'] for res in response.data['results'] if res['completion']['percent'] >= required_completion
+        )
         if not response.data['pagination']['next']:
             break
         query_params['page'] += 1
         view = _prepare_request_to_completion_aggregator(course_id, query_params.copy(), url)
 
-    # Get all enrolled users and map usernames to user IDs
-    users = get_course_enrollments(course_id, user_id)
-    username_to_id = {user.username: user.id for user in users}  # type: ignore[unresolved-attribute]
-
-    # Always return detailed progress for all users as dict
-    detailed_results = {}
-    for username, current_completion in completions.items():
-        if username in username_to_id:
-            user_id_for_result = username_to_id[username]
-            progress = {
-                'is_eligible': current_completion >= required_completion,
-                'current_completion': current_completion,
-                'required_completion': required_completion,
-            }
-            detailed_results[user_id_for_result] = progress
+    return list(get_user_model().objects.filter(username__in=completions).values_list('id', flat=True))
 
-    return detailed_results
 
-
-def retrieve_completions(
-    learning_context_key: LearningContextKey, options: dict[str, Any], user_id: int | None = None
-) -> list[int] | dict[str, Any]:
+def retrieve_completions(learning_context_key: LearningContextKey, options: dict[str, Any]) -> list[int]:
     """
     Retrieve the course completions for all users through the Completion Aggregator API.
 
     :param learning_context_key: The learning context key (course or learning path).
     :param options: The custom options for the credential.
-    :param user_id: Optional. If provided, will check eligibility for the specific user.
     :returns: The IDs of the users that have achieved the required completion percentage.
 
     Options:
@@ -400,19 +319,10 @@ def retrieve_completions(
             }
           }
     """
-    detailed_results = _process_learning_context(learning_context_key, _retrieve_course_completions, options, user_id)
-
-    if user_id is not None:
-        if user_id in detailed_results:
-            return detailed_results[user_id]
-        return {'is_eligible': False, 'current_completion': 0.0, 'required_completion': 0.9}
+    return _process_learning_context(learning_context_key, _retrieve_course_completions, options)
 
-    return [uid for uid, result in detailed_results.items() if result.get('is_eligible', False)]
 
-
-def retrieve_completions_and_grades(
-    learning_context_key: LearningContextKey, options: dict[str, Any], user_id: int | None = None
-) -> list[int] | dict[str, Any]:
+def retrieve_completions_and_grades(learning_context_key: LearningContextKey, options: dict[str, Any]) -> list[int]:
     """
     Retrieve the users that meet both completion and grade criteria.
 
@@ -421,7 +331,6 @@ def retrieve_completions_and_grades(
 
     :param learning_context_key: The learning context key (course or learning path).
     :param options: The custom options for the credential.
-    :param user_id: Optional. If provided, will check eligibility for the specific user.
     :returns: The IDs of the users that meet both sets of criteria.
 
     Options:
@@ -463,23 +372,6 @@ def retrieve_completions_and_grades(
             }
           }
     """
-    if user_id is not None:
-        completion_result = retrieve_completions(learning_context_key, options, user_id)
-        grades_result = retrieve_subsection_grades(learning_context_key, options, user_id)
-
-        if type(grades_result) is not dict or type(completion_result) is not dict:
-            msg = 'Both results must be dictionaries when user_id is provided.'
-            raise ValueError(msg)
-
-        completion_eligible = completion_result.get('is_eligible', False)
-        grades_eligible = grades_result.get('is_eligible', False)
-
-        return {
-            **completion_result,
-            **grades_result,
-            'is_eligible': completion_eligible and grades_eligible,
-        }
-
     completion_eligible_users = set(retrieve_completions(learning_context_key, options))
     grades_eligible_users = set(retrieve_subsection_grades(learning_context_key, options))
 

learning_credentials/settings/common.py

@@ -1,9 +1,12 @@
 """App-specific settings for all environments."""
 
-from django.conf import Settings
+from typing import TYPE_CHECKING
 
+if TYPE_CHECKING:
+    from django.conf import Settings
 
-def plugin_settings(settings: Settings):
+
+def plugin_settings(settings: 'Settings'):
     """Add `django_celery_beat` to `INSTALLED_APPS`."""
     if 'django_celery_beat' not in settings.INSTALLED_APPS:
         settings.INSTALLED_APPS += ('django_celery_beat',)

learning_credentials/settings/production.py

@@ -1,9 +1,12 @@
 """App-specific settings for production environments."""
 
-from django.conf import Settings
+from typing import TYPE_CHECKING
 
+if TYPE_CHECKING:
+    from django.conf import Settings
 
-def plugin_settings(settings: Settings):
+
+def plugin_settings(settings: 'Settings'):
     """
     Use the database scheduler for Celery Beat.
 

{learning_credentials-0.3.0rc3.dist-info → learning_credentials-0.3.0rc10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: learning-credentials
-Version: 0.3.0rc3
+Version: 0.3.0rc10
 Summary: A pluggable service for preparing Open edX credentials.
 Author-email: OpenCraft <help@opencraft.com>
 License-Expression: AGPL-3.0-or-later
@@ -21,6 +21,8 @@ Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
 Requires-Dist: django
 Requires-Dist: django-model-utils
+Requires-Dist: edx-api-doc-tools
+Requires-Dist: edx-django-utils
 Requires-Dist: edx-opaque-keys
 Requires-Dist: celery
 Requires-Dist: django-celery-beat
@@ -31,7 +33,6 @@ Requires-Dist: pypdf
 Requires-Dist: reportlab
 Requires-Dist: openedx-completion-aggregator
 Requires-Dist: edx_ace
-Requires-Dist: edx-api-doc-tools
 Requires-Dist: learning-paths-plugin>=0.3.4
 Dynamic: license-file
 
@@ -123,7 +124,7 @@ file in this repo.
 Reporting Security Issues
 *************************
 
-Please do not report security issues in public. Please email security@openedx.org.
+Please do not report security issues in public. Please email help@opencraft.com.
 
 .. |pypi-badge| image:: https://img.shields.io/pypi/v/learning-credentials.svg
     :target: https://pypi.python.org/pypi/learning-credentials/
@@ -175,6 +176,21 @@ Unreleased
 
 *
 
+0.3.0 - 2025-09-17
+******************
+
+Added
+=====
+
+* REST API endpoint to check if credentials are configured for a learning context.
+
+0.2.4 - 2025-09-07
+
+Added
+=====
+
+* Option to customize the learner's name size on the PDF certificate.
+
 0.2.3 - 2025-08-18
 
 Modified

{learning_credentials-0.3.0rc3.dist-info → learning_credentials-0.3.0rc10.dist-info}/RECORD

@@ -1,22 +1,19 @@
 learning_credentials/__init__.py,sha256=8Q0-3Hdnfmcj41EKu1GSfzEfwWcYNDlItyEEke2r9bs,62
 learning_credentials/admin.py,sha256=ynK3tVJwLsIeV7Jk66t1FAVyVsU1G-KRIAdRkycVTmA,10439
-learning_credentials/apps.py,sha256=COijTeVYYFZgQP_-gHJNy2ITqhFT0dfimC0PtYwnynM,1136
-learning_credentials/compat.py,sha256=g32MLgTnSZLGa6H3Qsq1WIPJXWPlFaNVuyZfbZXsKR8,4832
-learning_credentials/core_api.py,sha256=ZVNPm7SQk54roZ8rmZ0Bc6T6NLvumKWJZjJepAxM6L8,3232
+learning_credentials/apps.py,sha256=7lHAqhBdOMWknA_muPxqC1RX9_8CiOMeQ79ioKA3MlY,1073
+learning_credentials/compat.py,sha256=OvgzxnhGG5A7Ij65mBv3kyaYojKKQ381RbUGsWXtyOg,4651
 learning_credentials/exceptions.py,sha256=UaqBVXFMWR2Iob7_LMb3j4NNVmWQFAgLi_MNMRUvGsI,290
-learning_credentials/generators.py,sha256=aDo1_r9IE1ad31oHmuIpU0MxqFV8K8ymMVVGfNdeXlg,9098
-learning_credentials/models.py,sha256=GurLaQ2-hY7bflOYKV5vwqTnNwM6puE0tOg4KZ8-bqQ,17694
-learning_credentials/processors.py,sha256=CfHuotWjCsg_Yx-uyZNTKzSREJj3xXD_LnTWUw3g2ms,19806
+learning_credentials/generators.py,sha256=KCB166rOx-bwnm6kOc-Vz2HomGdJrQXqglv2MPVBF_Q,9075
+learning_credentials/models.py,sha256=Wepzng9WYDAxF8ptyQokp_9jCmuEv_4FY7ytkKFS4uU,16047
+learning_credentials/processors.py,sha256=LkdjmkLBnXc9qeMcksB1T8AQ5ZhYaECyQO__KfHB_aU,15212
 learning_credentials/tasks.py,sha256=byoFEUvN_ayVaU5K5SlEiA7vu9BRPaSSmKnB9g5toec,1927
 learning_credentials/urls.py,sha256=9Xc-imliMCIOWqFHfm-CSAgwm2tQGfMR18jCyBpKcho,176
-learning_credentials/xblocks.py,sha256=gb-bfkOlRnBzwUg7CTqBJfg-BOJ1UOtaBQRmbyGuD0w,3568
 learning_credentials/api/__init__.py,sha256=q8sLFfwo5RwQu8FY6BJUL_Jrt3TUojbZK-Zlw9v08EM,40
 learning_credentials/api/urls.py,sha256=JfGSbzvC5d7s9dRq4C0d-AzTDuOVnen3wvFYSJQoEdQ,255
 learning_credentials/api/v1/__init__.py,sha256=A7ZqENtM4QM1A7j_cAfnzw4zn0kuyfXSWtylFIE0_f8,43
-learning_credentials/api/v1/permissions.py,sha256=DZMa2A6Q1ltPdWCksr7I8Ltv_qV46B9yvMM0UXXWo8E,2379
-learning_credentials/api/v1/serializers.py,sha256=c4gNva-OzBUfmKHFOgsb1Ti1GiHSnsyIeT3gYBt7fMk,2685
-learning_credentials/api/v1/urls.py,sha256=n8CTXgKyXyCkgNr210Jl5c5HQ2bZ1iEYMNLSnaB39Hc,585
-learning_credentials/api/v1/views.py,sha256=LrlHRzURWi_zEii_zq55CH05tpC2ZqPhZLyebx1Jy8M,13606
+learning_credentials/api/v1/permissions.py,sha256=TqM50TpR3JGUgZgIgKZF0-R_g1_P2V9bqKzYXgk-VvY,3436
+learning_credentials/api/v1/urls.py,sha256=xUjG3dlbhFlQ1SM45x9tltuti-DwazX51anIDgtBo4Q,287
+learning_credentials/api/v1/views.py,sha256=rkdj1AfRBDzrpRC5uGMAxTUf4P1zs-MSF9lpNMIgYLw,3005
 learning_credentials/conf/locale/config.yaml,sha256=jPen2DmckNDKK30axCKEd2Q2ha9oOG3IBxrJ63Pvznk,2280
 learning_credentials/migrations/0001_initial.py,sha256=61EvThCv-0UAnhCE5feyQVfjRodbp-6cDaAr4CY5PMA,8435
 learning_credentials/migrations/0002_migrate_to_learning_credentials.py,sha256=vUhcnQKDdwOsppkXsjz2zZwOGMwIJ-fkQRsaj-K7l1o,1779
@@ -25,21 +22,18 @@ learning_credentials/migrations/0004_replace_course_keys_with_learning_context_k
 learning_credentials/migrations/0005_rename_processors_and_generators.py,sha256=5UCqjq-CBJnRo1qBAoWs91ngyEuSMN8_tQtfzsuR5SI,5271
 learning_credentials/migrations/0006_cleanup_openedx_certificates_tables.py,sha256=aJs_gOP4TmW9J-Dmr21m94jBfLQxzjAu6-ua7x4uYLE,727
 learning_credentials/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-learning_credentials/public/css/credentials_xblock.css,sha256=O_16evZyQ6c1vr5IfkKVtwt9JbE1R4w7_mBaiXgfi4k,140
-learning_credentials/public/html/credentials_xblock.html,sha256=U00jJKJfxhfKSJDcj6xyddXqjhCgi6ftCb5-2qb8qUM,2775
-learning_credentials/public/js/credentials_xblock.js,sha256=zx0mXAPY4UOZeWKsm4rmD3yBlSDvFoX8acEoIFqKhG8,1094
 learning_credentials/settings/__init__.py,sha256=tofc5eg3Q2lV13Ff_jjg1ggGgWpKYoeESkP1qxl3H_A,29
-learning_credentials/settings/common.py,sha256=4n9AeQD-GB2MYFVrwXWEsTSrKC9btn8bgyr9OQuXNsY,302
-learning_credentials/settings/production.py,sha256=yEvsCldHOdsIswW7TPLW__b9YNEK-Qy05rX5WSAcEeo,484
+learning_credentials/settings/common.py,sha256=Cck-nyFt11G1NLiz-bHfKJp8MV6sDZGqTwdbC8_1WE0,360
+learning_credentials/settings/production.py,sha256=6P0P7JxbpWNsk4Lk8lfyxHirOWMgU4UWOb3EYKLjiVQ,542
 learning_credentials/templates/learning_credentials/base.html,sha256=wtjBYqfHmOnyEY5tN3VGOmzYLsOD24MXdEUhTZ7OmwI,662
 learning_credentials/templates/learning_credentials/edx_ace/certificate_generated/email/body.html,sha256=t-i1Ra9AC4pX-rPRifDJIvBBZuxCxdrFqg1NKTjHBOk,813
 learning_credentials/templates/learning_credentials/edx_ace/certificate_generated/email/body.txt,sha256=IF_x8aF_-dORlQB-RCh0IkJDl2ktD489E8qGgLe9M3Y,677
 learning_credentials/templates/learning_credentials/edx_ace/certificate_generated/email/from_name.txt,sha256=-n8tjPSwfwAfeOSZ1WhcCTrpOah4VswzMZ5mh63Pxow,20
 learning_credentials/templates/learning_credentials/edx_ace/certificate_generated/email/head.html,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 learning_credentials/templates/learning_credentials/edx_ace/certificate_generated/email/subject.txt,sha256=S7Hc5T_sZSsSBXm5_H5HBNNv16Ohl0oZn0nVqqeWL0g,132
-learning_credentials-0.3.0rc3.dist-info/licenses/LICENSE.txt,sha256=GDpsPnW_1NKhPvZpZL9imz25P2nIpbwJPEhrlq4vPAU,34523
-learning_credentials-0.3.0rc3.dist-info/METADATA,sha256=w2ZPv1NQwUcgWG_lKtmTDT9XoJLH3WBqfEVqvlNTW1A,6864
-learning_credentials-0.3.0rc3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-learning_credentials-0.3.0rc3.dist-info/entry_points.txt,sha256=6aT7brHXkmLp829ZgV8t9R__wXLsLOsYKmZWOvPlGyc,166
-learning_credentials-0.3.0rc3.dist-info/top_level.txt,sha256=Ce-4_leZe_nny7CpmkeRiemcDV6jIHpIvLjlcQBuf18,21
-learning_credentials-0.3.0rc3.dist-info/RECORD,,
+learning_credentials-0.3.0rc10.dist-info/licenses/LICENSE.txt,sha256=GDpsPnW_1NKhPvZpZL9imz25P2nIpbwJPEhrlq4vPAU,34523
+learning_credentials-0.3.0rc10.dist-info/METADATA,sha256=0Ongz2Z3HBDYIqt6FcGEIrVTPlAljq_uaKNZ6mDgx2g,7135
+learning_credentials-0.3.0rc10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+learning_credentials-0.3.0rc10.dist-info/entry_points.txt,sha256=hHqqLUEdzAN24v5OGBX9Fr-wh3ATDPjQjByKz03eC2Y,91
+learning_credentials-0.3.0rc10.dist-info/top_level.txt,sha256=Ce-4_leZe_nny7CpmkeRiemcDV6jIHpIvLjlcQBuf18,21
+learning_credentials-0.3.0rc10.dist-info/RECORD,,

{learning_credentials-0.3.0rc3.dist-info → learning_credentials-0.3.0rc10.dist-info}/entry_points.txt

@@ -1,5 +1,2 @@
 [lms.djangoapp]
 learning_credentials = learning_credentials.apps:LearningCredentialsConfig
-
-[xblock.v1]
-certificates = learning_credentials.xblocks:CredentialsXBlock

learning_credentials/api/v1/serializers.py

@@ -1,74 +0,0 @@
-"""Serializers for the Learning Credentials API."""
-
-from typing import Any, ClassVar
-
-from rest_framework import serializers
-
-from learning_credentials.models import Credential
-
-
-class CredentialModelSerializer(serializers.ModelSerializer):
-    """Model serializer for Credential instances."""
-
-    credential_id = serializers.UUIDField(source='uuid', read_only=True)
-    credential_type = serializers.CharField(read_only=True)
-    context_key = serializers.CharField(source='learning_context_key', read_only=True)
-    created_date = serializers.DateTimeField(source='created', read_only=True)
-    download_url = serializers.URLField(read_only=True)
-
-    class Meta:
-        """Meta configuration for CredentialModelSerializer."""
-
-        model = Credential
-        fields: ClassVar[list[str]] = [
-            'credential_id',
-            'credential_type',
-            'context_key',
-            'status',
-            'created_date',
-            'download_url',
-        ]
-        read_only_fields: ClassVar[list[str]] = [
-            'credential_id',
-            'credential_type',
-            'context_key',
-            'status',
-            'created_date',
-            'download_url',
-        ]
-
-
-class CredentialEligibilitySerializer(serializers.Serializer):
-    """Serializer for credential eligibility information with dynamic fields."""
-
-    credential_type_id = serializers.IntegerField()
-    name = serializers.CharField()
-    is_eligible = serializers.BooleanField()
-    existing_credential = serializers.UUIDField(required=False, allow_null=True)
-    existing_credential_url = serializers.URLField(required=False, allow_null=True)
-
-    current_grades = serializers.DictField(required=False)
-    required_grades = serializers.DictField(required=False)
-
-    current_completion = serializers.FloatField(required=False, allow_null=True)
-    required_completion = serializers.FloatField(required=False, allow_null=True)
-
-    steps = serializers.DictField(required=False)
-
-    def to_representation(self, instance: dict) -> dict[str, Any]:
-        """Remove null/empty fields from representation."""
-        data = super().to_representation(instance)
-        return {key: value for key, value in data.items() if value is not None and value not in ({}, [])}
-
-
-class CredentialEligibilityResponseSerializer(serializers.Serializer):
-    """Serializer for the complete credential eligibility response."""
-
-    context_key = serializers.CharField()
-    credentials = CredentialEligibilitySerializer(many=True)
-
-
-class CredentialListResponseSerializer(serializers.Serializer):
-    """Serializer for credential list response."""
-
-    credentials = CredentialModelSerializer(many=True)

learning_credentials/core_api.py

@@ -1,77 +0,0 @@
-"""API functions for the Learning Credentials app."""
-
-import logging
-from typing import TYPE_CHECKING
-
-from .models import Credential, CredentialConfiguration
-from .tasks import generate_credential_for_user_task
-
-if TYPE_CHECKING:
-    from django.contrib.auth.models import User
-    from opaque_keys.edx.keys import CourseKey
-
-logger = logging.getLogger(__name__)
-
-
-def get_eligible_users_by_credential_type(
-    course_id: 'CourseKey', user_id: int | None = None
-) -> dict[str, list['User']]:
-    """
-    Retrieve eligible users for each credential type in the given course.
-
-    :param course_id: The key of the course for which to check eligibility.
-    :param user_id: Optional. If provided, will check eligibility for the specific user.
-    :return: A dictionary with credential type as the key and eligible users as the value.
-    """
-    credential_configs = CredentialConfiguration.objects.filter(course_id=course_id)
-
-    if not credential_configs:
-        return {}
-
-    eligible_users_by_type = {}
-    for credential_config in credential_configs:
-        user_ids = credential_config.get_eligible_user_ids(user_id)
-        filtered_user_ids = credential_config.filter_out_user_ids_with_credentials(user_ids)
-
-        if user_id:
-            eligible_users_by_type[credential_config.credential_type.name] = list(set(filtered_user_ids) & {user_id})
-        else:
-            eligible_users_by_type[credential_config.credential_type.name] = filtered_user_ids
-
-    return eligible_users_by_type
-
-
-def get_user_credentials_by_type(course_id: 'CourseKey', user_id: int) -> dict[str, dict[str, str]]:
-    """
-    Retrieve the available credentials for a given user in a course.
-
-    :param course_id: The course ID for which to retrieve credentials.
-    :param user_id: The ID of the user for whom credentials are being retrieved.
-    :return: A dict where keys are credential types and values are dicts with the download link and status.
-    """
-    credentials = Credential.objects.filter(user_id=user_id, course_id=course_id)
-
-    return {cred.credential_type: {'download_url': cred.download_url, 'status': cred.status} for cred in credentials}
-
-
-def generate_credential_for_user(course_id: 'CourseKey', credential_type: str, user_id: int, force: bool = False):
-    """
-    Generate a credential for a user in a course.
-
-    :param course_id: The course ID for which to generate the credential.
-    :param credential_type: The type of credential to generate.
-    :param user_id: The ID of the user for whom the credential is being generated.
-    :param force: If True, will generate the credential even if the user is not eligible.
-    """
-    credential_config = CredentialConfiguration.objects.get(course_id=course_id, credential_type__name=credential_type)
-
-    if not credential_config:
-        logger.error('No course configuration found for course %s', course_id)
-        return
-
-    if not force and not credential_config.get_eligible_user_ids(user_id):
-        logger.error('User %s is not eligible for the credential in course %s', user_id, course_id)
-        msg = 'User is not eligible for the credential.'
-        raise ValueError(msg)
-
-    generate_credential_for_user_task.delay(credential_config.id, user_id)

learning_credentials/public/css/credentials_xblock.css

@@ -1,7 +0,0 @@
-.credentials-block .credentials-list .credential {
-    padding-bottom: 20px;
-
-    .credential-status {
-        margin-bottom: 10px;
-    }
-}