learning-credentials 0.4.0__py3-none-any.whl → 0.4.0rc1__py3-none-any.whl

learning_credentials/admin.py

@@ -7,8 +7,9 @@ import inspect
 from typing import TYPE_CHECKING
 
 from django import forms
-from django.contrib import admin
+from django.contrib import admin, messages
 from django.core.exceptions import ValidationError
+from django.urls import reverse
 from django.utils.html import format_html
 from django_object_actions import DjangoObjectActions, action
 from django_reverse_admin import ReverseModelAdmin
@@ -225,7 +226,7 @@ class CredentialConfigurationAdmin(DjangoObjectActions, ReverseModelAdmin):
 
 
 @admin.register(Credential)
-class CredentialAdmin(admin.ModelAdmin):  # noqa: D101
+class CredentialAdmin(DjangoObjectActions, admin.ModelAdmin):  # noqa: D101
     list_display = (
         'user_id',
         'user_full_name',
@@ -237,19 +238,32 @@ class CredentialAdmin(admin.ModelAdmin):  # noqa: D101
         'modified',
     )
     readonly_fields = (
+        'uuid',
+        'verify_uuid',
         'user_id',
         'created',
         'modified',
         'user_full_name',
         'learning_context_key',
+        'learning_context_name',
         'credential_type',
         'status',
         'url',
         'legacy_id',
         'generation_task_id',
     )
-    search_fields = ("learning_context_key", "user_id", "user_full_name")
+    search_fields = ("learning_context_key", "user_id", "user_full_name", "uuid")
     list_filter = ("learning_context_key", "credential_type", "status")
+    change_actions = ('reissue_credential',)
+
+    def save_model(self, request: HttpRequest, obj: Credential, _form: forms.ModelForm, _change: bool):  # noqa: FBT001
+        """Display validation errors as messages in the admin interface."""
+        try:
+            obj.save()
+        except ValidationError as e:
+            self.message_user(request, e.message or "Invalid data", level=messages.ERROR)
+            # Optionally, redirect to the change form with the error message
+            return
 
     def get_form(self, request: HttpRequest, obj: Credential | None = None, **kwargs) -> forms.ModelForm:
         """Hide the download_url field."""
@@ -263,3 +277,16 @@ class CredentialAdmin(admin.ModelAdmin):  # noqa: D101
         if obj.download_url:
             return format_html("<a href='{url}'>{url}</a>", url=obj.download_url)
         return "-"
+
+    @action(label="Reissue credential", description="Reissue the credential for the user.")
+    def reissue_credential(self, request: HttpRequest, obj: Credential):
+        """Reissue the credential for the user."""
+        try:
+            new_credential = obj.reissue()
+            admin_url = reverse('admin:learning_credentials_credential_change', args=[new_credential.pk])
+            message = format_html(
+                'The credential has been reissued as <a href="{}">{}</a>.', admin_url, new_credential.uuid
+            )
+            messages.success(request, message)
+        except CredentialConfiguration.DoesNotExist:
+            messages.error(request, "The configuration does not exist.")

learning_credentials/api/v1/serializers.py

@@ -0,0 +1,13 @@
+"""API serializers for learning credentials."""
+
+from rest_framework import serializers
+
+from learning_credentials.models import Credential
+
+
+class CredentialSerializer(serializers.ModelSerializer):
+    """Serializer that returns credential metadata."""
+
+    class Meta:  # noqa: D106
+        model = Credential
+        fields = ('user_full_name', 'created', 'learning_context_name', 'status', 'invalidation_reason')

learning_credentials/api/v1/urls.py

@@ -2,7 +2,7 @@
 
 from django.urls import path
 
-from .views import CredentialConfigurationCheckView
+from .views import CredentialConfigurationCheckView, CredentialMetadataView
 
 urlpatterns = [
     path(
@@ -10,4 +10,5 @@ urlpatterns = [
         CredentialConfigurationCheckView.as_view(),
         name='credential_configuration_check',
     ),
+    path('metadata/<uuid:uuid>/', CredentialMetadataView.as_view(), name='credential-metadata'),
 ]

learning_credentials/api/v1/views.py

@@ -9,9 +9,10 @@ from rest_framework.permissions import IsAuthenticated
 from rest_framework.response import Response
 from rest_framework.views import APIView
 
-from learning_credentials.models import CredentialConfiguration
+from learning_credentials.models import Credential, CredentialConfiguration
 
 from .permissions import CanAccessLearningContext
+from .serializers import CredentialSerializer
 
 if TYPE_CHECKING:
     from rest_framework.request import Request
@@ -81,3 +82,62 @@ class CredentialConfigurationCheckView(APIView):
         }
 
         return Response(response_data, status=status.HTTP_200_OK)
+
+
+class CredentialMetadataView(APIView):
+    """API view to retrieve credential metadata by UUID."""
+
+    @apidocs.schema(
+        parameters=[
+            apidocs.string_parameter(
+                "uuid",
+                ParameterLocation.PATH,
+                description="The UUID of the credential to retrieve.",
+            ),
+        ],
+        responses={
+            200: "Successfully retrieved the credential metadata.",
+            404: "Credential not found or not valid.",
+        },
+    )
+    def get(self, _request: "Request", uuid: str) -> Response:
+        """
+        Retrieve credential metadata by its UUID.
+
+        **Example Request**
+
+        ``GET /api/learning_credentials/v1/metadata/123e4567-e89b-12d3-a456-426614174000/``
+
+        **Response Values**
+
+        - **200 OK**: Successfully retrieved the credential metadata.
+        - **404 Not Found**: Credential not found or not valid.
+
+        **Example Response**
+
+        .. code-block:: json
+
+            {
+                "user_full_name": "John Doe",
+                "created": "2023-01-01",
+                "learning_context_name": "Demo Course",
+                "status": "available",
+                "invalidation_reason": ""
+            }
+
+
+            {
+                "user_full_name": "John Doe",
+                "created": "2023-01-01",
+                "learning_context_name": "Demo Course",
+                "status": "invalidated",
+                "invalidation_reason": "Reissued due to name change."
+            }
+        """
+        try:
+            credential = Credential.objects.get(verify_uuid=uuid)
+        except Credential.DoesNotExist:
+            return Response({'error': 'Credential not found.'}, status=status.HTTP_404_NOT_FOUND)
+
+        serializer = CredentialSerializer(credential)
+        return Response(serializer.data, status=status.HTTP_200_OK)

learning_credentials/compat.py

@@ -52,13 +52,10 @@ def get_course_grading_policy(course_id: CourseKey) -> dict:
 def _get_course_name(course_id: CourseKey) -> str:
     """Get the course name from Open edX."""
     # noinspection PyUnresolvedReferences,PyPackageRequirements
-    from openedx.core.djangoapps.content.course_overviews.api import get_course_overview_or_none
+    from openedx.core.djangoapps.content.learning_sequences.api import get_course_outline
 
-    name = str(course_id)
-    if course_overview := get_course_overview_or_none(course_id):
-        name = course_overview.cert_name_long or course_overview.display_name or name
-
-    return name
+    course_outline = get_course_outline(course_id)
+    return (course_outline and course_outline.title) or str(course_id)
 
 
 def _get_learning_path_name(learning_path_key: LearningPathKey) -> str:

learning_credentials/generators.py

@@ -9,10 +9,8 @@ We will move this module to an external repository (a plugin).
 
 from __future__ import annotations
 
-import copy
 import io
 import logging
-import re
 import secrets
 from typing import TYPE_CHECKING, Any
 
@@ -21,12 +19,11 @@ from django.core.files.base import ContentFile
 from django.core.files.storage import FileSystemStorage, default_storage
 from pypdf import PdfReader, PdfWriter
 from pypdf.constants import UserAccessPermissions
-from reportlab.pdfbase.pdfmetrics import FontError, FontNotFoundError, registerFont
-from reportlab.pdfbase.ttfonts import TTFError, TTFont
-from reportlab.pdfgen.canvas import Canvas
+from reportlab.pdfbase import pdfmetrics
+from reportlab.pdfbase.ttfonts import TTFont
+from reportlab.pdfgen import canvas
 
 from .compat import get_default_storage_url, get_learning_context_name, get_localized_credential_date
-from .exceptions import AssetNotFoundError
 from .models import CredentialAsset
 
 log = logging.getLogger(__name__)
@@ -36,49 +33,6 @@ if TYPE_CHECKING:  # pragma: no cover
 
     from django.contrib.auth.models import User
     from opaque_keys.edx.keys import CourseKey
-    from pypdf import PageObject
-
-
-def _get_defaults() -> tuple[dict[str, Any], dict[str, dict[str, Any]]]:
-    """
-    Get default styling and text element configurations.
-
-    Evaluated lazily to avoid accessing Django settings at import time.
-
-    :returns: A tuple of (default_styling, default_text_elements).
-    """
-    default_styling = {
-        'font': 'Helvetica',
-        'color': '#000',
-        'size': 12,
-        'char_space': 0,
-        'uppercase': False,
-        'line_height': 1.1,
-    }
-
-    default_text_elements = {
-        'name': {
-            'text': '{name}',
-            'y': 290,
-            'size': 32,
-            'uppercase': getattr(settings, 'LEARNING_CREDENTIALS_NAME_UPPERCASE', False),
-        },
-        'context': {
-            'text': '{context_name}',
-            'y': 220,
-            'size': 28,
-            'line_height': 1.1,
-        },
-        'date': {
-            'text': '{issue_date}',
-            'y': 120,
-            'size': 12,
-            'uppercase': getattr(settings, 'LEARNING_CREDENTIALS_DATE_UPPERCASE', False),
-            'char_space': getattr(settings, 'LEARNING_CREDENTIALS_DATE_CHAR_SPACE', 0),
-        },
-    }
-
-    return default_styling, default_text_elements
 
 
 def _get_user_name(user: User) -> str:
@@ -91,193 +45,81 @@ def _get_user_name(user: User) -> str:
     return user.profile.name or f"{user.first_name} {user.last_name}"
 
 
-def _register_font(pdf_canvas: Canvas, font_name: str) -> str:
+def _register_font(options: dict[str, Any]) -> str:
     """
-    Register a custom font if not already available.
+    Register a custom font if specified in options. If not specified, use the default font (Helvetica).
 
-    Built-in fonts (like Helvetica) are already available and don't need registration.
-    Custom fonts are loaded from CredentialAsset.
-
-    :param pdf_canvas: The canvas to check available fonts on.
-    :param font_name: The name of the font to register.
-    :returns: The font name if available, otherwise use 'Helvetica' as fallback.
+    :param options: A dictionary containing the font.
+    :returns: The font name.
     """
-    # Check if font is already available (built-in or previously registered).
-    if font_name in pdf_canvas.getAvailableFonts():
-        return font_name
-
-    try:
-        registerFont(TTFont(font_name, CredentialAsset.get_asset_by_slug(font_name)))
-    except AssetNotFoundError:
-        log.warning("Font asset not found: %s", font_name)
-    except (FontError, FontNotFoundError, TTFError):
-        log.exception("Error registering font %s", font_name)
-    else:
-        return font_name
+    if font := options.get('font'):
+        pdfmetrics.registerFont(TTFont(font, CredentialAsset.get_asset_by_slug(font)))
 
-    return 'Helvetica'
+    return font or 'Helvetica'
 
 
-def _hex_to_rgb(hex_color: str) -> tuple[float, float, float]:
+def _write_text_on_template(template: any, font: str, username: str, context_name: str, options: dict[str, Any]) -> any:
     """
-    Convert a hexadecimal color code to an RGB tuple with floating-point values.
-
-    :param hex_color: A hexadecimal color string, which can start with '#' and be either 3 or 6 characters long.
-    :returns: A tuple representing the RGB color as (red, green, blue), with each value ranging from 0.0 to 1.0.
-    """
-    hex_color = hex_color.lstrip('#')
-    # Expand shorthand form (e.g. "158" to "115588")
-    if len(hex_color) == 3:
-        hex_color = ''.join([c * 2 for c in hex_color])
-
-    # noinspection PyTypeChecker
-    return tuple(int(hex_color[i : i + 2], 16) / 255 for i in range(0, 6, 2))
-
-
-def _substitute_placeholders(text: str, placeholders: dict[str, str]) -> str:
-    """
-    Substitute placeholders in text using {placeholder} syntax.
-
-    Supports escaping with {{ for literal braces.
-
-    :param text: The text containing placeholders.
-    :param placeholders: A dictionary mapping placeholder names to their values.
-    :returns: The text with placeholders substituted.
-    """
-
-    def replace_placeholder(match: re.Match) -> str:
-        key = match.group(1)
-        return placeholders.get(key, match.group(0))
-
-    # Use negative lookbehind to skip escaped braces ({{).
-    # Match {word} but not {{word}.
-    text = re.sub(r'(?<!\{)\{(\w+)\}', replace_placeholder, text)
-
-    # Replace escaped braces with literal braces.
-    return text.replace('{{', '{').replace('}}', '}')
-
-
-def _build_text_elements(options: dict[str, Any]) -> dict[str, dict[str, Any]]:
-    """
-    Build the final text elements configuration by merging defaults with user options.
-
-    Standard elements (name, context, date) use defaults that are deep-merged with user overrides.
-    Custom elements (any other key) must provide at least 'text' and 'y'.
-
-    :param options: The options dictionary from the credential configuration.
-    :returns: A dictionary of element configurations ready for rendering.
-    """
-    default_styling, default_text_elements = _get_defaults()
-    user_elements = options.get('text_elements', {})
-    defaults_config = {**default_styling, **options.get('defaults', {})}
-    result = {}
-
-    # Process standard elements (they have defaults).
-    for key, default_config in default_text_elements.items():
-        user_config = user_elements.get(key, {})
-
-        if user_config is False:
-            continue
-
-        # Merge: element defaults -> global defaults -> user config.
-        element_config = {**copy.deepcopy(default_config), **defaults_config, **user_config}
-        result[key] = element_config
+    Prepare a new canvas and write the user and course name onto it.
 
-    # Process custom elements (non-standard keys).
-    for key, user_config in user_elements.items():
-        if key in default_text_elements:
-            continue
-
-        # Skip disabled elements.
-        if user_config is False:
-            continue
-
-        if not isinstance(user_config, dict):
-            log.warning("Invalid custom element configuration for key '%s': expected dict", key)
-            continue
-
-        # Custom elements must have 'text' and 'y'.
-        if 'text' not in user_config or 'y' not in user_config:
-            log.warning("Custom element '%s' must have 'text' and 'y' properties", key)
-            continue
-
-        # Merge with global defaults only.
-        element_config = {**defaults_config, **user_config}
-        result[key] = element_config
-
-    return result
-
-
-def _render_text_element(
-    pdf_canvas: Canvas,
-    template_width: float,
-    config: dict[str, Any],
-    placeholders: dict[str, str],
-) -> None:
-    """
-    Render a single text element on the canvas.
-
-    :param pdf_canvas: The canvas to draw on.
-    :param template_width: Width of the template for centering.
-    :param config: The element configuration (all defaults are already merged).
-    :param placeholders: Dictionary of placeholder values.
+    :param template: Pdf template.
+    :param font: Font name.
+    :param username: The name of the user to generate the credential for.
+    :param context_name: The name of the learning context.
+    :param options: A dictionary documented in the `generate_pdf_credential` function.
+    :returns: A canvas with written data.
     """
-    text = _substitute_placeholders(config['text'], placeholders)
 
-    if config['uppercase']:
-        text = text.upper()
+    def hex_to_rgb(hex_color: str) -> tuple[float, float, float]:
+        """
+        Convert a hexadecimal color code to an RGB tuple with floating-point values.
 
-    font_name = _register_font(pdf_canvas, config['font'])
-    pdf_canvas.setFont(font_name, config['size'])
+        :param hex_color: A hexadecimal color string, which can start with '#' and be either 3 or 6 characters long.
+        :returns: A tuple representing the RGB color as (red, green, blue), with each value ranging from 0.0 to 1.0.
+        """
+        hex_color = hex_color.lstrip('#')
+        # Expand shorthand form (e.g. "158" to "115588")
+        if len(hex_color) == 3:
+            hex_color = ''.join([c * 2 for c in hex_color])
 
-    pdf_canvas.setFillColorRGB(*_hex_to_rgb(config['color']))
+        # noinspection PyTypeChecker
+        return tuple(int(hex_color[i : i + 2], 16) / 255 for i in range(0, 6, 2))
 
-    y = config['y']
-    char_space = config['char_space']
-    line_height = config['line_height']
-    size = config['size']
+    template_width, template_height = template.mediabox[2:]
+    pdf_canvas = canvas.Canvas(io.BytesIO(), pagesize=(template_width, template_height))
 
-    # Handle multiline text (for context element).
-    lines = text.split('\n')
-    for line_number, line in enumerate(lines):
-        text_width = pdf_canvas.stringWidth(line) + (char_space * max(0, len(line) - 1))
-        line_x = (template_width - text_width) / 2
-        line_y = y - (line_number * size * line_height)
-        pdf_canvas.drawString(line_x, line_y, line, charSpace=char_space)
+    # Write the learner name.
+    pdf_canvas.setFont(font, options.get('name_size', 32))
+    name_color = options.get('name_color', '#000')
+    pdf_canvas.setFillColorRGB(*hex_to_rgb(name_color))
 
+    name_x = (template_width - pdf_canvas.stringWidth(username)) / 2
+    name_y = options.get('name_y', 290)
+    pdf_canvas.drawString(name_x, name_y, username)
 
-def _write_text_on_template(
-    template: PageObject,
-    username: str,
-    context_name: str,
-    issue_date: str,
-    options: dict[str, Any],
-) -> Canvas:
-    """
-    Prepare a new canvas and write text elements onto it.
+    # Write the learning context name.
+    pdf_canvas.setFont(font, options.get('context_name_size', 28))
+    context_name_color = options.get('context_name_color', '#000')
+    pdf_canvas.setFillColorRGB(*hex_to_rgb(context_name_color))
 
-    :param template: PDF template.
-    :param username: The name of the user to generate the credential for.
-    :param context_name: The name of the learning context.
-    :param issue_date: The formatted issue date string.
-    :param options: A dictionary documented in the ``generate_pdf_credential`` function.
-    :returns: A canvas with written data.
-    """
-    template_width, template_height = template.mediabox[2:]
-    pdf_canvas = Canvas(io.BytesIO(), pagesize=(template_width, template_height))
+    context_name_y = options.get('context_name_y', 220)
+    context_name_line_height = 28 * 1.1
 
-    # Build placeholder values.
-    placeholders = {
-        'name': username,
-        'context_name': context_name,
-        'issue_date': issue_date,
-    }
+    # Split the learning context name into lines and write each of them in the center of the template.
+    for line_number, line in enumerate(context_name.split('\n')):
+        line_x = (template_width - pdf_canvas.stringWidth(line)) / 2
+        line_y = context_name_y - (line_number * context_name_line_height)
+        pdf_canvas.drawString(line_x, line_y, line)
 
-    # Build and render text elements.
-    elements = _build_text_elements(options)
+    # Write the issue date.
+    issue_date = get_localized_credential_date()
+    pdf_canvas.setFont(font, 12)
+    issue_date_color = options.get('issue_date_color', '#000')
+    pdf_canvas.setFillColorRGB(*hex_to_rgb(issue_date_color))
 
-    for config in elements.values():
-        _render_text_element(pdf_canvas, template_width, config, placeholders)
+    issue_date_x = (template_width - pdf_canvas.stringWidth(issue_date)) / 2
+    issue_date_y = options.get('issue_date_y', 120)
+    pdf_canvas.drawString(issue_date_x, issue_date_y, issue_date)
 
     return pdf_canvas
 
@@ -326,7 +168,7 @@ def generate_pdf_credential(
     credential_uuid: UUID,
     options: dict[str, Any],
 ) -> str:
-    r"""
+    """
     Generate a PDF credential.
 
     :param learning_context_key: The ID of the course or learning path the credential is for.
@@ -336,66 +178,34 @@ def generate_pdf_credential(
     :returns: The URL of the saved credential.
 
     Options:
-
-      - template (required): The slug of the PDF template asset.
-      - template_multiline: Alternative template for multiline context names (when using '\n').
-      - defaults: Global defaults for all text elements.
-          - font: Font name (asset slug). Default: Helvetica.
-          - color: Hex color code. Default: #000.
-          - size: Font size in points. Default: 12.
-          - char_space: Character spacing. Default: 0.
-          - uppercase: Convert text to uppercase. Default: false.
-          - line_height: Line height multiplier for multiline text. Default: 1.1.
-      - text_elements: Configuration for text elements. Standard elements (name, context, date) have
-          defaults and render automatically. Set to false to hide.
-          Custom elements require 'text' and 'y' properties.
-          Element properties:
-          - text: Text content with {placeholder} substitution. Available: {name}, {context_name}, {issue_date}.
-          - y: Vertical position (PDF coordinates from bottom).
-          - size: Font size (inherited from defaults.size).
-          - font: Font name (inherited from defaults.font).
-          - color: Hex color (inherited from defaults.color).
-          - char_space: Character spacing (inherited from defaults.char_space).
-          - uppercase: Convert text to uppercase (inherited from defaults.uppercase).
-          - line_height: Line height multiplier for multiline text (inherited from defaults.line_height).
-
-    Example::
-
-      {
-        "template": "certificate-template",
-        "defaults": {"font": "CustomFont", "color": "#333"},
-        "text_elements": {
-          "name": {"y": 300, "uppercase": true},
-          "context": {"text": "Custom Course Name"},
-          "date": false,
-          "award_line": {"text": "Awarded on {issue_date}", "y": 140, "size": 14}
-        }
-      }
+      - template: The path to the PDF template file.
+      - template_two_lines: The path to the PDF template file for two-line context names.
+        A two-line context name is specified by using a semicolon as a separator.
+      - font: The name of the font to use.
+      - name_y: The Y coordinate of the name on the credential (vertical position on the template).
+      - name_color: The color of the name on the credential (hexadecimal color code).
+      - name_size: The font size of the name on the credential. The default value is 32.
+      - context_name: Specify the custom course or Learning Path name.
+      - context_name_y: The Y coordinate of the context name on the credential (vertical position on the template).
+      - context_name_color: The color of the context name on the credential (hexadecimal color code).
+      - context_name_size: The font size of the context name on the credential. The default value is 28.
+      - issue_date_y: The Y coordinate of the issue date on the credential (vertical position on the template).
+      - issue_date_color: The color of the issue date on the credential (hexadecimal color code).
     """
     log.info("Starting credential generation for user %s", user.id)
 
     username = _get_user_name(user)
-
-    # Handle multiline context name.
-    context_name = get_learning_context_name(learning_context_key)
-    custom_context_name = ''
-    custom_context_text_element = options.get('text_elements', {}).get('context', {})
-    if isinstance(custom_context_text_element, dict):
-        custom_context_name = custom_context_text_element.get('text', '')
-
-    template_path = options.get('template')
-    if '\n' in context_name or '\n' in custom_context_name:
-        template_path = options.get('template_multiline', template_path)
-
-    if not template_path:
-        msg = "Template path must be specified in options."
-        raise ValueError(msg)
+    context_name = options.get('context_name') or get_learning_context_name(learning_context_key)
 
     # Get template from the CredentialAsset.
-    template_file = CredentialAsset.get_asset_by_slug(template_path)
+    # HACK: We support two-line strings by using a semicolon as a separator.
+    if ';' in context_name and (template_path := options.get('template_two_lines')):
+        template_file = CredentialAsset.get_asset_by_slug(template_path)
+        context_name = context_name.replace(';', '\n')
+    else:
+        template_file = CredentialAsset.get_asset_by_slug(options['template'])
 
-    # Get the issue date.
-    issue_date = get_localized_credential_date()
+    font = _register_font(options)
 
     # Load the PDF template.
     with template_file.open('rb') as template_file:
@@ -403,8 +213,8 @@ def generate_pdf_credential(
 
         credential = PdfWriter()
 
-        # Create a new canvas, prepare the page and write the data.
-        pdf_canvas = _write_text_on_template(template, username, context_name, issue_date, options)
+        # Create a new canvas, prepare the page and write the data
+        pdf_canvas = _write_text_on_template(template, font, username, context_name, options)
 
         overlay_pdf = PdfReader(io.BytesIO(pdf_canvas.getpdfdata()))
         template.merge_page(overlay_pdf.pages[0])

learning_credentials/migrations/0007_validation.py

@@ -0,0 +1,94 @@
+# Generated by Django 4.2.25 on 2025-10-31 17:43
+
+from django.db import migrations, models
+import uuid
+
+
+def backfill_credential_fields(apps, schema_editor):
+    """Generate verification UUIDs and backfill learning_context_name for all existing credentials."""
+    from learning_credentials.compat import get_learning_context_name
+
+    Credential = apps.get_model("learning_credentials", "Credential")
+    for credential in Credential.objects.all():
+        credential.verify_uuid = uuid.uuid4()
+        credential.learning_context_name = get_learning_context_name(credential.learning_context_key)
+        credential.save(update_fields=["verify_uuid", "learning_context_name"])
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("learning_credentials", "0006_cleanup_openedx_certificates_tables"),
+    ]
+
+    operations = [
+        migrations.AlterUniqueTogether(
+            name="credential",
+            unique_together=set(),
+        ),
+        migrations.AlterField(
+            model_name="credential",
+            name="user_full_name",
+            field=models.CharField(
+                editable=False,
+                help_text="User receiving the credential. This field is used for validation purposes.",
+                max_length=255,
+            ),
+        ),
+        migrations.AddField(
+            model_name="credential",
+            name="invalidated_at",
+            field=models.DateTimeField(
+                editable=False,
+                help_text="Timestamp when the credential was invalidated",
+                null=True,
+            ),
+        ),
+        migrations.AddField(
+            model_name="credential",
+            name="invalidation_reason",
+            field=models.CharField(
+                blank=True,
+                help_text="Reason for invalidating the credential",
+                max_length=255,
+            ),
+        ),
+        migrations.AddField(
+            model_name="credential",
+            name="learning_context_name",
+            field=models.CharField(
+                editable=False,
+                help_text="Name of the learning context for which the credential was issued. This field is used for validation purposes.",
+                max_length=255,
+                null=True,
+            ),
+        ),
+        migrations.AddField(
+            model_name="credential",
+            name="verify_uuid",
+            field=models.UUIDField(
+                default=uuid.uuid4,
+                editable=False,
+                help_text="UUID used for verifying the credential",
+                null=True,
+            ),
+        ),
+        migrations.RunPython(backfill_credential_fields, reverse_code=migrations.RunPython.noop),
+        migrations.AlterField(
+            model_name="credential",
+            name="learning_context_name",
+            field=models.CharField(
+                editable=False,
+                help_text="Name of the learning context for which the credential was issued. This field is used for validation purposes.",
+                max_length=255,
+            ),
+        ),
+        migrations.AlterField(
+            model_name="credential",
+            name="verify_uuid",
+            field=models.UUIDField(
+                default=uuid.uuid4,
+                editable=False,
+                help_text="UUID used for verifying the credential",
+            ),
+        ),
+    ]

learning_credentials/models.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import json
 import logging
-import uuid
+import uuid as uuid_lib
 from importlib import import_module
 from pathlib import Path
 from typing import TYPE_CHECKING, Self
@@ -16,6 +16,7 @@ from django.core.exceptions import ValidationError
 from django.db import models
 from django.db.models.signals import post_delete
 from django.dispatch import receiver
+from django.utils import timezone
 from django.utils.translation import gettext_lazy as _
 from django_celery_beat.models import IntervalSchedule, PeriodicTask
 from edx_ace import Message, Recipient, ace
@@ -33,25 +34,6 @@ if TYPE_CHECKING:  # pragma: no cover
 log = logging.getLogger(__name__)
 
 
-def _deep_merge(base: dict, override: dict) -> dict:
-    """
-    Deep merge two dictionaries.
-
-    Values from `override` take precedence. Nested dictionaries are merged recursively.
-
-    :param base: The base dictionary.
-    :param override: The dictionary with overriding values.
-    :return: A new dictionary with merged values.
-    """
-    result = base.copy()
-    for key, value in override.items():
-        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
-            result[key] = _deep_merge(result[key], value)
-        else:
-            result[key] = value
-    return result
-
-
 class CredentialType(TimeStampedModel):
     """
     Model to store global credential configurations for each type.
@@ -147,8 +129,9 @@ class CredentialConfiguration(TimeStampedModel):
         self.periodic_task.args = json.dumps([self.id])
         self.periodic_task.save()
 
+    # Replace the return type with `QuerySet[Self]` after migrating to Python 3.10+.
     @classmethod
-    def get_enabled_configurations(cls) -> QuerySet[Self]:
+    def get_enabled_configurations(cls) -> QuerySet[CredentialConfiguration]:
         """
         Get the list of enabled configurations.
 
@@ -194,10 +177,10 @@ class CredentialConfiguration(TimeStampedModel):
         module = import_module(module_path)
         func = getattr(module, func_name)
 
-        custom_options = _deep_merge(self.credential_type.custom_options, self.custom_options)
+        custom_options = {**self.credential_type.custom_options, **self.custom_options}
         return func(self.learning_context_key, custom_options)
 
-    def generate_credential_for_user(self, user_id: int, celery_task_id: int = 0):
+    def generate_credential_for_user(self, user_id: int, celery_task_id: int = 0) -> Credential:
         """
         Celery task for processing a single user's credential.
 
@@ -208,19 +191,24 @@ class CredentialConfiguration(TimeStampedModel):
         Args:
             user_id: The ID of the user to process the credential for.
             celery_task_id (optional): The ID of the Celery task that is running this function.
+
+        Returns:
+            The generated Credential object.
         """
         user = get_user_model().objects.get(id=user_id)
         # Use the name from the profile if it is not empty. Otherwise, use the first and last name.
         # We check if the profile exists because it may not exist in some cases (e.g., when a User is created manually).
         user_full_name = getattr(getattr(user, 'profile', None), 'name', f"{user.first_name} {user.last_name}")
-        custom_options = _deep_merge(self.credential_type.custom_options, self.custom_options)
+        learning_context_name = get_learning_context_name(self.learning_context_key)
+        custom_options = {**self.credential_type.custom_options, **self.custom_options}
 
-        credential, _ = Credential.objects.update_or_create(
+        credential, _ = Credential.objects.exclude(status=Credential.Status.INVALIDATED).update_or_create(
             user_id=user_id,
             learning_context_key=self.learning_context_key,
             credential_type=self.credential_type.name,
             defaults={
                 'user_full_name': user_full_name,
+                'learning_context_name': learning_context_name,
                 'status': Credential.Status.GENERATING,
                 'generation_task_id': celery_task_id,
             },
@@ -246,6 +234,8 @@ class CredentialConfiguration(TimeStampedModel):
             if user.is_active and user.has_usable_password():
                 credential.send_email()
 
+        return credential
+
 
 # noinspection PyUnusedLocal
 @receiver(post_delete, sender=CredentialConfiguration)
@@ -280,16 +270,33 @@ class Credential(TimeStampedModel):
 
     uuid = models.UUIDField(
         primary_key=True,
-        default=uuid.uuid4,
+        default=uuid_lib.uuid4,
         editable=False,
         help_text=_('Auto-generated UUID of the credential'),
     )
+    verify_uuid = models.UUIDField(
+        default=uuid_lib.uuid4,
+        editable=False,
+        help_text=_('UUID used for verifying the credential'),
+    )
     user_id = models.IntegerField(help_text=_('ID of the user receiving the credential'))
-    user_full_name = models.CharField(max_length=255, help_text=_('User receiving the credential'))
+    user_full_name = models.CharField(
+        max_length=255,
+        editable=False,
+        help_text=_('User receiving the credential. This field is used for validation purposes.'),
+    )
     learning_context_key = LearningContextKeyField(
         max_length=255,
         help_text=_('ID of a learning context (e.g., a course or a Learning Path) for which the credential was issued'),
     )
+    learning_context_name = models.CharField(
+        max_length=255,
+        editable=False,
+        help_text=_(
+            'Name of the learning context for which the credential was issued. '
+            'This field is used for validation purposes.'
+        ),
+    )
     credential_type = models.CharField(max_length=255, help_text=_('Type of the credential'))
     status = models.CharField(
         max_length=32,
@@ -300,16 +307,26 @@ class Credential(TimeStampedModel):
     download_url = models.URLField(blank=True, help_text=_('URL of the generated credential PDF (e.g., to S3)'))
     legacy_id = models.IntegerField(null=True, help_text=_('Legacy ID of the credential imported from another system'))
     generation_task_id = models.CharField(max_length=255, help_text=_('Task ID from the Celery queue'))
-
-    class Meta:  # noqa: D106
-        unique_together = (('user_id', 'learning_context_key', 'credential_type'),)
+    invalidated_at = models.DateTimeField(
+        null=True, editable=False, help_text=_('Timestamp when the credential was invalidated')
+    )
+    invalidation_reason = models.CharField(
+        max_length=255, blank=True, help_text=_('Reason for invalidating the credential')
+    )
 
     def __str__(self):  # noqa: D105
         return f"{self.credential_type} for {self.user_full_name} in {self.learning_context_key}"
 
+    def save(self, *args, **kwargs):
+        """If the invalidation reason is set, update the status and timestamp."""
+        if self.invalidation_reason and self.status != Credential.Status.INVALIDATED:
+            self.status = Credential.Status.INVALIDATED
+        if self.status == Credential.Status.INVALIDATED and not self.invalidated_at:
+            self.invalidated_at = timezone.now()
+        super().save(*args, **kwargs)
+
     def send_email(self):
         """Send a credential link to the student."""
-        learning_context_name = get_learning_context_name(self.learning_context_key)
         user = get_user_model().objects.get(id=self.user_id)
         msg = Message(
             name="certificate_generated",
@@ -318,12 +335,26 @@ class Credential(TimeStampedModel):
             language='en',
             context={
                 'certificate_link': self.download_url,
-                'course_name': learning_context_name,
+                'course_name': self.learning_context_name,
                 'platform_name': settings.PLATFORM_NAME,
             },
         )
         ace.send(msg)
 
+    def reissue(self) -> Self:
+        """Invalidate the current credential and create a new one."""
+        config = CredentialConfiguration.objects.get(
+            learning_context_key=self.learning_context_key,
+            credential_type__name=self.credential_type,
+        )
+
+        if self.invalidation_reason:
+            self.invalidation_reason += '\n'
+        self.invalidation_reason += 'Reissued'
+        self.save()
+
+        return config.generate_credential_for_user(self.user_id)
+
 
 class CredentialAsset(TimeStampedModel):
     """

learning_credentials/templates/learning_credentials/verify.html

@@ -0,0 +1,83 @@
+{% extends "main_django.html" %}
+{% load i18n %}
+{% load static %}
+
+{% block bodyextra %}
+    <div id="content" class="credential-verification-container content-wrapper main-container">
+        <section class="container">
+            <h1>{% trans "Credential verification page" %}</h1>
+            <form id="credentialVerificationForm" method="post">
+                {% csrf_token %}
+                <div class="form-group">
+                    <label for="credentialID">{% trans 'Credential ID' %}</label>
+                    <input type="text" id="credentialID" class="form-control" name="credentialID" required>
+                    <div id="formError" class="text-danger mt-2" style="display: none;"></div>
+                </div>
+                <button type="submit" class="btn btn-primary">
+                    {% trans 'Verify' %}
+                </button>
+            </form>
+
+            <div id="verificationResults" class="p-0 border-0 mt-5"></div>
+        </section>
+    </div>
+
+    <script>
+    document.getElementById('credentialVerificationForm').onsubmit = async function(event) {
+        event.preventDefault();
+        let formError = document.getElementById('formError');
+        let verificationResults = document.getElementById('verificationResults');
+
+        let credentialId = document.getElementById('credentialID').value;
+        var url = '/api/learning_credentials/v1/metadata/' + encodeURIComponent(credentialId);
+
+        // Hide previous error messages.
+        formError.style.display = 'none';
+
+        await fetch(url)
+            .then(response => response.json())
+            .then(data => {
+                const table = document.createElement('table');
+                table.className = 'table table-striped table-bordered';
+                const tbody = document.createElement('tbody');
+                Object.entries(data).forEach(([key, value]) => {
+                    if (!!value) {
+                        const row = tbody.insertRow();
+                        const cellKey = row.insertCell();
+                        const cellValue = row.insertCell();
+                        cellKey.textContent = key.split('_').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ');
+                        cellValue.textContent = value;
+                    }
+                });
+                table.appendChild(tbody);
+                verificationResults.textContent = '';
+                verificationResults.appendChild(table);
+            })
+            .catch((error) => {
+                console.error('Error:', error);
+                verificationResults.textContent = '';
+                formError.innerHTML = "An error occurred during verification. Please check the Credential ID and try again.";
+                formError.style.display = 'block';
+            });
+    }
+
+
+    $(document).ready(function(){
+        // Fill the credential ID field with URL 'credential' query param.
+        let urlParams = new URLSearchParams(window.location.search);
+        const uuid = urlParams.get('credential');
+
+        if (uuid) {
+            $('#credentialID').val(uuid);
+        }
+
+        // If the field is filled, submit the form automatically.
+        if ($('#credentialID').val()) {
+            $('#credentialVerificationForm').submit();
+        }
+
+        // Focus the field for user convenience.
+        $('#credentialID').focus();
+    });
+    </script>
+{% endblock %}

learning_credentials/urls.py

@@ -1,9 +1,11 @@
 """URLs for learning_credentials."""
 
 from django.urls import include, path
+from django.views.generic import TemplateView
 
 from .api import urls as api_urls
 
 urlpatterns = [
     path('api/learning_credentials/', include(api_urls)),
+    path('learning_credentials/verify/', TemplateView.as_view(template_name="learning_credentials/verify.html")),
 ]

{learning_credentials-0.4.0.dist-info → learning_credentials-0.4.0rc1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: learning-credentials
-Version: 0.4.0
+Version: 0.4.0rc1
 Summary: A pluggable service for preparing Open edX credentials.
 Author-email: OpenCraft <help@opencraft.com>
 License-Expression: AGPL-3.0-or-later
@@ -11,7 +11,6 @@ Keywords: Python,edx,credentials,django
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Framework :: Django
 Classifier: Framework :: Django :: 4.2
-Classifier: Framework :: Django :: 5.2
 Classifier: Intended Audience :: Developers
 Classifier: Natural Language :: English
 Classifier: Programming Language :: Python :: 3
@@ -177,38 +176,14 @@ Unreleased
 
 *
 
-0.4.0 - 2026-01-28
+0.4.0 - 2025-11-03
 ******************
 
 Added
 =====
 
-* New ``text_elements`` format for PDF credential generation with flexible text positioning and placeholder support.
-* Support for custom text elements with ``{name}``, ``{context_name}``, and ``{issue_date}`` placeholders.
-* Global ``defaults`` configuration for font, color, and character spacing.
-
-Modified
-========
-
-* Migrated generator options from flat format (``name_y``, ``context_name_color``, etc.) to structured ``text_elements`` format.
-
-0.3.1 - 2025-12-15
-******************
-
-Added
-=====
-
-* Support for defining the course name using the ``cert_name_long`` field (in Studio's Advanced Settings).
-* Support for specifying individual fonts for PDF text elements.
-* Support for \n in learning context names in PDF certificates.
-* Options for uppercase name and issue date in PDF certificates.
-* Option for defining character spacing for issue date in PDF certificates.
-* Option for defining the horizontal offset of the issue date from its centered position (``issue_date_x``).
-
-Modified
-========
-
-* Replaced ``template_two_lines`` with ``template_multiline``.
+* Frontend form and backend API endpoint for verifying credentials.
+* Option to invalidate issued credentials.
 
 0.3.0 - 2025-09-17
 ******************

{learning_credentials-0.4.0.dist-info → learning_credentials-0.4.0rc1.dist-info}/RECORD

@@ -1,19 +1,20 @@
 learning_credentials/__init__.py,sha256=8Q0-3Hdnfmcj41EKu1GSfzEfwWcYNDlItyEEke2r9bs,62
-learning_credentials/admin.py,sha256=ynK3tVJwLsIeV7Jk66t1FAVyVsU1G-KRIAdRkycVTmA,10439
+learning_credentials/admin.py,sha256=gLVpCn5oOHLL3u-wnx4R1yJXfar1Z32vk8zcTVjtBFY,11791
 learning_credentials/apps.py,sha256=trdQxe-JRhUdUaOQoQWiGL1sn6I1sfDiTvdCwy8yGuw,1037
-learning_credentials/compat.py,sha256=bTAB6bTh99ZyhUqOsDtM_BuIPzFxCjySFtfvc-_fCd4,4731
+learning_credentials/compat.py,sha256=OvgzxnhGG5A7Ij65mBv3kyaYojKKQ381RbUGsWXtyOg,4651
 learning_credentials/exceptions.py,sha256=UaqBVXFMWR2Iob7_LMb3j4NNVmWQFAgLi_MNMRUvGsI,290
-learning_credentials/generators.py,sha256=gaw3zoEzVhSjo96QM6Q6K70e_iK44LxCuQIQ05p7lP0,14895
-learning_credentials/models.py,sha256=Nltf7cN6z2lUQM1L9eh4QRC8RSz3u59-Spf2_piAC1M,16581
+learning_credentials/generators.py,sha256=KCB166rOx-bwnm6kOc-Vz2HomGdJrQXqglv2MPVBF_Q,9075
+learning_credentials/models.py,sha256=DncnadwVrmVcbrka9LBmKvTMqLq8os_wHXmWc3Zet6s,17949
 learning_credentials/processors.py,sha256=LkdjmkLBnXc9qeMcksB1T8AQ5ZhYaECyQO__KfHB_aU,15212
 learning_credentials/tasks.py,sha256=byoFEUvN_ayVaU5K5SlEiA7vu9BRPaSSmKnB9g5toec,1927
-learning_credentials/urls.py,sha256=gO_c930rzMylP-riQ9SGHXH9JIMF7ajySDT2Tc-E8x4,188
+learning_credentials/urls.py,sha256=KXZtvPXXl2X_nTREWaCFxcAgY2XET1eWRbcx2rq_6eI,348
 learning_credentials/api/__init__.py,sha256=q8sLFfwo5RwQu8FY6BJUL_Jrt3TUojbZK-Zlw9v08EM,40
 learning_credentials/api/urls.py,sha256=wW27hrrJ7D_h8PbFDbSxzeaneNla0R-56gjKy9zISG8,216
 learning_credentials/api/v1/__init__.py,sha256=A7ZqENtM4QM1A7j_cAfnzw4zn0kuyfXSWtylFIE0_f8,43
 learning_credentials/api/v1/permissions.py,sha256=TqM50TpR3JGUgZgIgKZF0-R_g1_P2V9bqKzYXgk-VvY,3436
-learning_credentials/api/v1/urls.py,sha256=6YqLS4aVfA1cuLOgVe4lFUFa38wVehYKleXBF8ImMm0,287
-learning_credentials/api/v1/views.py,sha256=rkdj1AfRBDzrpRC5uGMAxTUf4P1zs-MSF9lpNMIgYLw,3005
+learning_credentials/api/v1/serializers.py,sha256=H7l-vRTwLBplveCBjnNgSawJqpSVskeHTz7wpUiNB3g,417
+learning_credentials/api/v1/urls.py,sha256=RytArViuKZQkWs46sk58VfaVCwLV-QrgTG7cQLE_NtU,408
+learning_credentials/api/v1/views.py,sha256=CJEVPwCXs_ii463agPRpJeX6NCgyyFX9ZIBJh0BAc9I,4926
 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
@@ -21,20 +22,21 @@ learning_credentials/migrations/0003_rename_certificates_to_credentials.py,sha25
 learning_credentials/migrations/0004_replace_course_keys_with_learning_context_keys.py,sha256=5KaXvASl69qbEaHX5_Ty_3Dr7K4WV6p8VWOx72yJnTU,1919
 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/0007_migrate_to_text_elements_format.py,sha256=_olkaxPPuRys2c2X5fnyQIFVvqEfdoYu-JlApmXuHEM,4758
+learning_credentials/migrations/0007_validation.py,sha256=3vzjwDDFlwtFWmaCQ1wYfyl7Jj-cJB5Jpfq3cGo_vuI,3391
 learning_credentials/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 learning_credentials/settings/__init__.py,sha256=tofc5eg3Q2lV13Ff_jjg1ggGgWpKYoeESkP1qxl3H_A,29
 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/verify.html,sha256=vXTiZMZkTLhp6cnqKBJcQnDu7qUxLvrTzN2m1KM8_9k,3414
 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.4.0.dist-info/licenses/LICENSE.txt,sha256=GDpsPnW_1NKhPvZpZL9imz25P2nIpbwJPEhrlq4vPAU,34523
-learning_credentials-0.4.0.dist-info/METADATA,sha256=bmCj26iPdnz7Q0y_u9wCrmUz6QgUtZOxGgkn_42WPYE,8294
-learning_credentials-0.4.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-learning_credentials-0.4.0.dist-info/entry_points.txt,sha256=hHqqLUEdzAN24v5OGBX9Fr-wh3ATDPjQjByKz03eC2Y,91
-learning_credentials-0.4.0.dist-info/top_level.txt,sha256=Ce-4_leZe_nny7CpmkeRiemcDV6jIHpIvLjlcQBuf18,21
-learning_credentials-0.4.0.dist-info/RECORD,,
+learning_credentials-0.4.0rc1.dist-info/licenses/LICENSE.txt,sha256=GDpsPnW_1NKhPvZpZL9imz25P2nIpbwJPEhrlq4vPAU,34523
+learning_credentials-0.4.0rc1.dist-info/METADATA,sha256=AMzNwr8Uif8XG05ihc6hM0FmRXWQB7PVG8tdJSx8VF0,7298
+learning_credentials-0.4.0rc1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+learning_credentials-0.4.0rc1.dist-info/entry_points.txt,sha256=hHqqLUEdzAN24v5OGBX9Fr-wh3ATDPjQjByKz03eC2Y,91
+learning_credentials-0.4.0rc1.dist-info/top_level.txt,sha256=Ce-4_leZe_nny7CpmkeRiemcDV6jIHpIvLjlcQBuf18,21
+learning_credentials-0.4.0rc1.dist-info/RECORD,,

{learning_credentials-0.4.0.dist-info → learning_credentials-0.4.0rc1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.10.2)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

learning_credentials/migrations/0007_migrate_to_text_elements_format.py

@@ -1,138 +0,0 @@
-"""Migration to convert credential options from flat format to text_elements format."""
-
-from django.db import migrations
-
-# Mapping from old option names to new text_elements structure.
-# Format: (old_key, element_key, property_name)
-_OPTION_MAPPINGS = [
-    # Name element mappings.
-    ('name_y', 'name', 'y'),
-    ('name_color', 'name', 'color'),
-    ('name_size', 'name', 'size'),
-    ('name_font', 'name', 'font'),
-    ('name_uppercase', 'name', 'uppercase'),
-    # Context element mappings.
-    ('context_name', 'context', 'text'),
-    ('context_name_y', 'context', 'y'),
-    ('context_name_color', 'context', 'color'),
-    ('context_name_size', 'context', 'size'),
-    ('context_name_font', 'context', 'font'),
-    # Date element mappings.
-    ('issue_date_y', 'date', 'y'),
-    ('issue_date_color', 'date', 'color'),
-    ('issue_date_size', 'date', 'size'),
-    ('issue_date_font', 'date', 'font'),
-    ('issue_date_char_space', 'date', 'char_space'),
-    ('issue_date_uppercase', 'date', 'uppercase'),
-]
-
-
-def _convert_to_text_elements(options):
-    """
-    Convert old flat options format to new text_elements format in-place.
-
-    :param options: The options dictionary to convert.
-    """
-    if not options:
-        return
-
-    # If already in new format, skip conversion.
-    if 'text_elements' in options or 'defaults' in options:
-        return
-
-    text_elements = {}
-
-    # Handle template_two_lines -> template_multiline rename.
-    if 'template_two_lines' in options:
-        template_two_lines = options.pop('template_two_lines')
-        # Only set template_multiline if it doesn't already exist.
-        if 'template_multiline' not in options:
-            options['template_multiline'] = template_two_lines
-
-    # Handle global font -> defaults.font.
-    if 'font' in options:
-        options['defaults'] = {'font': options.pop('font')}
-
-    # Convert element-specific options by popping them from the options dict.
-    for old_key, element_key, prop_name in _OPTION_MAPPINGS:
-        if old_key in options:
-            if element_key not in text_elements:
-                text_elements[element_key] = {}
-            text_elements[element_key][prop_name] = options.pop(old_key)
-
-    # Only add text_elements if we have any.
-    if text_elements:
-        options['text_elements'] = text_elements
-
-
-def _convert_to_flat_format(options):
-    """
-    Convert new text_elements format back to old flat options format in-place.
-
-    :param options: The options dictionary to convert.
-    """
-    if not options:
-        return
-
-    # If not in new format, skip conversion.
-    if 'text_elements' not in options and 'defaults' not in options:
-        return
-
-    # Handle template_multiline -> template_two_lines for backward compatibility.
-    if 'template_multiline' in options:
-        options['template_two_lines'] = options.pop('template_multiline')
-
-    # Handle defaults.font -> font.
-    defaults = options.pop('defaults', {})
-    if 'font' in defaults:
-        options['font'] = defaults['font']
-
-    # Convert text_elements back to flat format.
-    text_elements = options.pop('text_elements', {})
-
-    for old_key, element_key, prop_name in _OPTION_MAPPINGS:
-        element_config = text_elements.get(element_key, {})
-        if isinstance(element_config, dict) and prop_name in element_config:
-            options[old_key] = element_config[prop_name]
-
-
-def _migrate_all_options(apps, convert_func):
-    """
-    Apply a conversion function to all credential configurations.
-
-    :param apps: Django apps registry.
-    :param convert_func: Function to apply to each custom_options dict.
-    """
-    CredentialType = apps.get_model('learning_credentials', 'CredentialType')
-    CredentialConfiguration = apps.get_model('learning_credentials', 'CredentialConfiguration')
-
-    for credential_type in CredentialType.objects.all():
-        if credential_type.custom_options:
-            convert_func(credential_type.custom_options)
-            credential_type.save()
-
-    for config in CredentialConfiguration.objects.all():
-        if config.custom_options:
-            convert_func(config.custom_options)
-            config.save()
-
-
-def _migrate_forward(apps, schema_editor):
-    """Convert all credential configurations to the new text_elements format."""
-    _migrate_all_options(apps, _convert_to_text_elements)
-
-
-def _migrate_backward(apps, schema_editor):
-    """Convert all credential configurations back to the old flat format."""
-    _migrate_all_options(apps, _convert_to_flat_format)
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('learning_credentials', '0006_cleanup_openedx_certificates_tables'),
-    ]
-
-    operations = [
-        migrations.RunPython(_migrate_forward, _migrate_backward),
-    ]