learning-credentials 0.2.0rc1__py2.py3-none-any.whl

learning_credentials/migrations/0001_initial.py

@@ -0,0 +1,205 @@
+from django.db import migrations, models
+import django.utils.timezone
+import jsonfield.fields
+import model_utils.fields
+import opaque_keys.edx.django.models
+import uuid
+
+import openedx_certificates.models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        ('django_celery_beat', '0019_alter_periodictasks_options'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='ExternalCertificateAsset',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                (
+                    'created',
+                    model_utils.fields.AutoCreatedField(
+                        default=django.utils.timezone.now, editable=False, verbose_name='created'
+                    ),
+                ),
+                (
+                    'modified',
+                    model_utils.fields.AutoLastModifiedField(
+                        default=django.utils.timezone.now, editable=False, verbose_name='modified'
+                    ),
+                ),
+                ('description', models.CharField(blank=True, help_text='Description of the asset.', max_length=255)),
+                (
+                    'asset',
+                    models.FileField(
+                        help_text='Asset file. It could be a PDF template, image or font file.',
+                        max_length=255,
+                        upload_to=openedx_certificates.models.ExternalCertificateAsset.template_assets_path,
+                    ),
+                ),
+                (
+                    'asset_slug',
+                    models.SlugField(
+                        help_text="Asset's unique slug. We can reference the asset in templates using this value.",
+                        max_length=255,
+                        unique=True,
+                    ),
+                ),
+            ],
+            options={
+                'get_latest_by': 'created',
+            },
+        ),
+        migrations.CreateModel(
+            name='ExternalCertificateType',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                (
+                    'created',
+                    model_utils.fields.AutoCreatedField(
+                        default=django.utils.timezone.now, editable=False, verbose_name='created'
+                    ),
+                ),
+                (
+                    'modified',
+                    model_utils.fields.AutoLastModifiedField(
+                        default=django.utils.timezone.now, editable=False, verbose_name='modified'
+                    ),
+                ),
+                ('name', models.CharField(help_text='Name of the certificate type.', max_length=255, unique=True)),
+                (
+                    'retrieval_func',
+                    models.CharField(help_text='A name of the function to retrieve eligible users.', max_length=200),
+                ),
+                (
+                    'generation_func',
+                    models.CharField(help_text='A name of the function to generate certificates.', max_length=200),
+                ),
+                (
+                    'custom_options',
+                    jsonfield.fields.JSONField(blank=True, default=dict, help_text='Custom options for the functions.'),
+                ),
+            ],
+            options={
+                'abstract': False,
+            },
+        ),
+        migrations.CreateModel(
+            name='ExternalCertificate',
+            fields=[
+                (
+                    'created',
+                    model_utils.fields.AutoCreatedField(
+                        default=django.utils.timezone.now, editable=False, verbose_name='created'
+                    ),
+                ),
+                (
+                    'modified',
+                    model_utils.fields.AutoLastModifiedField(
+                        default=django.utils.timezone.now, editable=False, verbose_name='modified'
+                    ),
+                ),
+                (
+                    'uuid',
+                    models.UUIDField(
+                        default=uuid.uuid4,
+                        editable=False,
+                        help_text='Auto-generated UUID of the certificate',
+                        primary_key=True,
+                        serialize=False,
+                    ),
+                ),
+                ('user_id', models.IntegerField(help_text='ID of the user receiving the certificate')),
+                ('user_full_name', models.CharField(help_text='User receiving the certificate', max_length=255)),
+                (
+                    'course_id',
+                    opaque_keys.edx.django.models.CourseKeyField(
+                        help_text='ID of a course for which the certificate was issued', max_length=255
+                    ),
+                ),
+                ('certificate_type', models.CharField(help_text='Type of the certificate', max_length=255)),
+                (
+                    'status',
+                    models.CharField(
+                        choices=[
+                            ('generating', 'Generating'),
+                            ('available', 'Available'),
+                            ('error', 'Error'),
+                            ('invalidated', 'Invalidated'),
+                        ],
+                        default='generating',
+                        help_text='Status of the certificate generation task',
+                        max_length=32,
+                    ),
+                ),
+                (
+                    'download_url',
+                    models.URLField(blank=True, help_text='URL of the generated certificate PDF (e.g., to S3)'),
+                ),
+                (
+                    'legacy_id',
+                    models.IntegerField(
+                        help_text='Legacy ID of the certificate imported from another system', null=True
+                    ),
+                ),
+                ('generation_task_id', models.CharField(help_text='Task ID from the Celery queue', max_length=255)),
+            ],
+            options={
+                'unique_together': {('user_id', 'course_id', 'certificate_type')},
+            },
+        ),
+        migrations.CreateModel(
+            name='ExternalCertificateCourseConfiguration',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                (
+                    'created',
+                    model_utils.fields.AutoCreatedField(
+                        default=django.utils.timezone.now, editable=False, verbose_name='created'
+                    ),
+                ),
+                (
+                    'modified',
+                    model_utils.fields.AutoLastModifiedField(
+                        default=django.utils.timezone.now, editable=False, verbose_name='modified'
+                    ),
+                ),
+                (
+                    'course_id',
+                    opaque_keys.edx.django.models.CourseKeyField(help_text='The ID of the course.', max_length=255),
+                ),
+                (
+                    'custom_options',
+                    jsonfield.fields.JSONField(
+                        blank=True,
+                        default=dict,
+                        help_text='Custom options for the functions. If specified, they are merged with the options defined in the certificate type.',
+                    ),
+                ),
+                (
+                    'certificate_type',
+                    models.ForeignKey(
+                        help_text='Associated certificate type.',
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to='learning_credentials.externalcertificatetype',
+                    ),
+                ),
+                (
+                    'periodic_task',
+                    models.OneToOneField(
+                        help_text='Associated periodic task.',
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to='django_celery_beat.periodictask',
+                    ),
+                ),
+            ],
+            options={
+                'unique_together': {('course_id', 'certificate_type')},
+            },
+        ),
+    ]

learning_credentials/migrations/0002_migrate_to_learning_credentials.py

@@ -0,0 +1,32 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ('openedx_certificates', '0001_initial'),
+        ('learning_credentials', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.RunSQL(
+            sql=[
+                "INSERT INTO learning_credentials_externalcertificatetype (id, created, modified, name, retrieval_func, generation_func, custom_options) "
+                "SELECT id, created, modified, name, retrieval_func, generation_func, custom_options FROM openedx_certificates_externalcertificatetype;",
+
+                "INSERT INTO learning_credentials_externalcertificatecourseconfiguration (id, created, modified, course_id, custom_options, certificate_type_id, periodic_task_id) "
+                "SELECT id, created, modified, course_id, custom_options, certificate_type_id, periodic_task_id FROM openedx_certificates_externalcertificatecourseconfiguration;",
+
+                "INSERT INTO learning_credentials_externalcertificateasset (id, created, modified, description, asset, asset_slug) "
+                "SELECT id, created, modified, description, asset, asset_slug FROM openedx_certificates_externalcertificateasset;",
+
+                "INSERT INTO learning_credentials_externalcertificate (uuid, created, modified, user_id, user_full_name, course_id, certificate_type, status, download_url, legacy_id, generation_task_id) "
+                "SELECT uuid, created, modified, user_id, user_full_name, course_id, certificate_type, status, download_url, legacy_id, generation_task_id FROM openedx_certificates_externalcertificate;",
+            ],
+            reverse_sql=[
+                "DELETE FROM learning_credentials_externalcertificate;",
+                "DELETE FROM learning_credentials_externalcertificatecourseconfiguration;",
+                "DELETE FROM learning_credentials_externalcertificateasset;",
+                "DELETE FROM learning_credentials_externalcertificatetype;",
+            ],
+        ),
+    ]

learning_credentials/migrations/0003_rename_certificates_to_credentials.py

@@ -0,0 +1,128 @@
+from django.db import migrations, models
+import django.utils.timezone
+import jsonfield.fields
+import opaque_keys.edx.django.models
+import uuid
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('django_celery_beat', '0019_alter_periodictasks_options'),
+        ('learning_credentials', '0002_migrate_to_learning_credentials'),
+    ]
+
+    operations = [
+        migrations.RenameModel(
+            old_name='ExternalCertificateCourseConfiguration',
+            new_name='CredentialConfiguration',
+        ),
+        migrations.RenameModel(
+            old_name='ExternalCertificateAsset',
+            new_name='CredentialAsset',
+        ),
+        migrations.RenameModel(
+            old_name='ExternalCertificateType',
+            new_name='CredentialType',
+        ),
+        migrations.RenameModel(
+            old_name='ExternalCertificate',
+            new_name='Credential',
+        ),
+        migrations.RenameField(
+            model_name='Credential',
+            old_name='certificate_type',
+            new_name='credential_type',
+        ),
+        migrations.RenameField(
+            model_name='CredentialConfiguration',
+            old_name='certificate_type',
+            new_name='credential_type',
+        ),
+        migrations.AlterField(
+            model_name='credential',
+            name='course_id',
+            field=opaque_keys.edx.django.models.CourseKeyField(
+                help_text='ID of a course for which the credential was issued', max_length=255
+            ),
+        ),
+        migrations.AlterField(
+            model_name='credential',
+            name='credential_type',
+            field=models.CharField(help_text='Type of the credential', max_length=255),
+        ),
+        migrations.AlterField(
+            model_name='credential',
+            name='download_url',
+            field=models.URLField(blank=True, help_text='URL of the generated credential PDF (e.g., to S3)'),
+        ),
+        migrations.AlterField(
+            model_name='credential',
+            name='legacy_id',
+            field=models.IntegerField(help_text='Legacy ID of the credential imported from another system', null=True),
+        ),
+        migrations.AlterField(
+            model_name='credential',
+            name='status',
+            field=models.CharField(
+                choices=[
+                    ('generating', 'Generating'),
+                    ('available', 'Available'),
+                    ('error', 'Error'),
+                    ('invalidated', 'Invalidated'),
+                ],
+                default='generating',
+                help_text='Status of the credential generation task',
+                max_length=32,
+            ),
+        ),
+        migrations.AlterField(
+            model_name='credential',
+            name='user_full_name',
+            field=models.CharField(help_text='User receiving the credential', max_length=255),
+        ),
+        migrations.AlterField(
+            model_name='credential',
+            name='user_id',
+            field=models.IntegerField(help_text='ID of the user receiving the credential'),
+        ),
+        migrations.AlterField(
+            model_name='credential',
+            name='uuid',
+            field=models.UUIDField(
+                default=uuid.uuid4,
+                editable=False,
+                help_text='Auto-generated UUID of the credential',
+                primary_key=True,
+                serialize=False,
+            ),
+        ),
+        migrations.AlterField(
+            model_name='credentialconfiguration',
+            name='credential_type',
+            field=models.ForeignKey(
+                help_text='Associated credential type.',
+                on_delete=django.db.models.deletion.CASCADE,
+                to='learning_credentials.credentialtype',
+            ),
+        ),
+        migrations.AlterField(
+            model_name='credentialconfiguration',
+            name='custom_options',
+            field=jsonfield.fields.JSONField(
+                blank=True,
+                default=dict,
+                help_text='Custom options for the functions. If specified, they are merged with the options defined in the credential type.',
+            ),
+        ),
+        migrations.AlterField(
+            model_name='credentialtype',
+            name='generation_func',
+            field=models.CharField(help_text='A name of the function to generate credentials.', max_length=200),
+        ),
+        migrations.AlterField(
+            model_name='credentialtype',
+            name='name',
+            field=models.CharField(help_text='Name of the credential type.', max_length=255, unique=True),
+        ),
+    ]

learning_credentials/migrations/0004_replace_course_keys_with_learning_context_keys.py

@@ -0,0 +1,59 @@
+# Generated by Django 4.2.20 on 2025-03-27 17:36
+
+from django.db import migrations
+import opaque_keys.edx.django.models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('learning_credentials', '0003_rename_certificates_to_credentials'),
+    ]
+
+    operations = [
+        migrations.AlterUniqueTogether(
+            name='credential',
+            unique_together=set(),
+        ),
+        migrations.AlterUniqueTogether(
+            name='credentialconfiguration',
+            unique_together=set(),
+        ),
+
+        migrations.RenameField(
+            model_name='credential',
+            old_name='course_id',
+            new_name='learning_context_key',
+        ),
+        migrations.RenameField(
+            model_name='credentialconfiguration',
+            old_name='course_id',
+            new_name='learning_context_key',
+        ),
+
+        migrations.AlterField(
+            model_name='credential',
+            name='learning_context_key',
+            field=opaque_keys.edx.django.models.LearningContextKeyField(
+                help_text='ID of a learning context (e.g., a course or a Learning Path) for which the credential was issued',
+                max_length=255
+            ),
+        ),
+        migrations.AlterField(
+            model_name='credentialconfiguration',
+            name='learning_context_key',
+            field=opaque_keys.edx.django.models.LearningContextKeyField(
+                help_text='ID of a learning context (e.g., a course or a Learning Path).',
+                max_length=255
+            ),
+        ),
+
+        migrations.AlterUniqueTogether(
+            name='credential',
+            unique_together={('user_id', 'learning_context_key', 'credential_type')},
+        ),
+        migrations.AlterUniqueTogether(
+            name='credentialconfiguration',
+            unique_together={('learning_context_key', 'credential_type')},
+        ),
+    ]

learning_credentials/migrations/0005_rename_processors_and_generators.py

@@ -0,0 +1,106 @@
+from django.db import migrations
+
+
+def update_function_references_and_json_keys(apps, schema_editor):
+    """
+    Update both function references and JSON field keys:
+    1. Replace 'openedx_certificates' prefix with 'learning_credentials'.
+    2. Replace 'retrieve_course_completions' with 'retrieve_completions'.
+    3. Replace JSON keys 'course_name*' with 'context_name*'.
+    4. Replace the task path in PeriodicTask records.
+    """
+    CredentialType = apps.get_model('learning_credentials', 'CredentialType')
+    CredentialConfiguration = apps.get_model('learning_credentials', 'CredentialConfiguration')
+
+    for credential_type in CredentialType.objects.all():
+        credential_type.retrieval_func = credential_type.retrieval_func.replace(
+            'openedx_certificates', 'learning_credentials'
+        ).replace(
+            'retrieve_course_completions', 'retrieve_completions'
+        )
+
+        credential_type.generation_func = credential_type.generation_func.replace(
+            'openedx_certificates', 'learning_credentials'
+        ).replace(
+            'generate_pdf_certificate', 'generate_pdf_credential'
+        )
+
+        if credential_type.custom_options:
+            if 'course_name' in credential_type.custom_options:
+                credential_type.custom_options['context_name'] = credential_type.custom_options.pop('course_name')
+            if 'course_name_y' in credential_type.custom_options:
+                credential_type.custom_options['context_name_y'] = credential_type.custom_options.pop('course_name_y')
+            if 'course_name_color' in credential_type.custom_options:
+                credential_type.custom_options['context_name_color'] = credential_type.custom_options.pop('course_name_color')
+
+        credential_type.save()
+
+    for config in CredentialConfiguration.objects.all():
+        if config.custom_options:
+            if 'course_name' in config.custom_options:
+                config.custom_options['context_name'] = config.custom_options.pop('course_name')
+            if 'course_name_y' in config.custom_options:
+                config.custom_options['context_name_y'] = config.custom_options.pop('course_name_y')
+            if 'course_name_color' in config.custom_options:
+                config.custom_options['context_name_color'] = config.custom_options.pop('course_name_color')
+
+        if config.periodic_task.task == 'openedx_certificates.tasks.generate_certificates_for_course_task':
+            config.periodic_task.task = 'learning_credentials.tasks.generate_credentials_for_config_task'
+            config.periodic_task.save()
+
+        config.save()
+
+
+def reverse_function_references_and_json_keys(apps, schema_editor):
+    """Reverse the changes made to function references and JSON keys."""
+    CredentialType = apps.get_model('learning_credentials', 'CredentialType')
+    CredentialConfiguration = apps.get_model('learning_credentials', 'CredentialConfiguration')
+
+    for credential_type in CredentialType.objects.all():
+        credential_type.retrieval_func = credential_type.retrieval_func.replace(
+            'learning_credentials', 'openedx_certificates'
+        ).replace(
+            'retrieve_completions', 'retrieve_course_completions'
+        )
+
+        credential_type.generation_func = credential_type.generation_func.replace(
+            'learning_credentials', 'openedx_certificates'
+        ).replace(
+            'generate_pdf_credential', 'generate_pdf_certificate'
+        )
+
+        if credential_type.custom_options:
+            if 'context_name' in credential_type.custom_options:
+                credential_type.custom_options['course_name'] = credential_type.custom_options.pop('context_name')
+            if 'context_name_y' in credential_type.custom_options:
+                credential_type.custom_options['course_name_y'] = credential_type.custom_options.pop('context_name_y')
+            if 'context_name_color' in credential_type.custom_options:
+                credential_type.custom_options['course_name_color'] = credential_type.custom_options.pop('context_name_color')
+
+        credential_type.save()
+
+    for config in CredentialConfiguration.objects.all():
+        if config.custom_options:
+            if 'context_name' in config.custom_options:
+                config.custom_options['course_name'] = config.custom_options.pop('context_name')
+            if 'context_name_y' in config.custom_options:
+                config.custom_options['course_name_y'] = config.custom_options.pop('context_name_y')
+            if 'context_name_color' in config.custom_options:
+                config.custom_options['course_name_color'] = config.custom_options.pop('context_name_color')
+
+        if config.periodic_task.task == 'learning_credentials.tasks.generate_credentials_for_config_task':
+            config.periodic_task.task = 'openedx_certificates.tasks.generate_certificates_for_course_task'
+            config.periodic_task.save()
+
+        config.save()
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('learning_credentials', '0004_replace_course_keys_with_learning_context_keys'),
+    ]
+
+    operations = [
+        migrations.RunPython(update_function_references_and_json_keys, reverse_function_references_and_json_keys),
+    ]