openedx-learning 0.29.0__tar.gz → 0.30.0__tar.gz

{openedx_learning-0.29.0/openedx_learning.egg-info → openedx_learning-0.30.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openedx-learning
-Version: 0.29.0
+Version: 0.30.0
 Summary: Open edX Learning Core and Tagging.
 Home-page: https://github.com/openedx/openedx-learning
 Author: David Ormsbee
@@ -19,13 +19,13 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.11
 License-File: LICENSE.txt
-Requires-Dist: djangorestframework<4.0
+Requires-Dist: tomlkit
+Requires-Dist: Django
 Requires-Dist: edx-drf-extensions
-Requires-Dist: attrs
 Requires-Dist: celery
-Requires-Dist: tomlkit
+Requires-Dist: attrs
+Requires-Dist: djangorestframework<4.0
 Requires-Dist: rules<4.0
-Requires-Dist: Django
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{openedx_learning-0.29.0 → openedx_learning-0.30.0}/openedx_learning/__init__.py

@@ -2,4 +2,4 @@
 Open edX Learning ("Learning Core").
 """
 
-__version__ = "0.29.0"
+__version__ = "0.30.0"

{openedx_learning-0.29.0 → openedx_learning-0.30.0}/openedx_learning/apps/authoring/backup_restore/zipper.py

@@ -47,6 +47,7 @@ from openedx_learning.apps.authoring.backup_restore.toml import (
 )
 from openedx_learning.apps.authoring.collections import api as collections_api
 from openedx_learning.apps.authoring.components import api as components_api
+from openedx_learning.apps.authoring.contents import api as contents_api
 from openedx_learning.apps.authoring.publishing import api as publishing_api
 from openedx_learning.apps.authoring.sections import api as sections_api
 from openedx_learning.apps.authoring.subsections import api as subsections_api
@@ -493,6 +494,7 @@ class LearningPackageUnzipper:
         self.zipf = zipf
         self.user = user
         self.lp_key = key  # If provided, use this key for the restored learning package
+        self.learning_package_id: int | None = None  # Will be set upon restoration
         self.utc_now: datetime = datetime.now(timezone.utc)
         self.component_types_cache: dict[tuple[str, str], ComponentType] = {}
         self.errors: list[dict[str, Any]] = []
@@ -735,6 +737,7 @@ class LearningPackageUnzipper:
             learning_package["key"] = self.lp_key
 
         learning_package_obj = publishing_api.create_learning_package(**learning_package)
+        self.learning_package_id = learning_package_obj.id
 
         with publishing_api.bulk_draft_changes_for(learning_package_obj.id):
             self._save_components(learning_package_obj, components, component_static_files)
@@ -937,16 +940,31 @@ class LearningPackageUnzipper:
             num_version: int,
             entity_key: str,
             static_files_map: dict[str, List[str]]
-    ) -> dict[str, bytes]:
+    ) -> dict[str, bytes | int]:
         """Resolve static file paths into their binary content."""
-        resolved_files: dict[str, bytes] = {}
+        resolved_files: dict[str, bytes | int] = {}
 
-        static_file_key = f"{entity_key}:v{num_version}"  # e.g., "my_component:123:v1"
+        static_file_key = f"{entity_key}:v{num_version}"  # e.g., "xblock.v1:html:my_component_123456:v1"
+        block_type = entity_key.split(":")[1]  # e.g., "html"
         static_files = static_files_map.get(static_file_key, [])
         for static_file in static_files:
             local_key = static_file.split(f"v{num_version}/")[-1]
             with self.zipf.open(static_file, "r") as f:
-                resolved_files[local_key] = f.read()
+                content_bytes = f.read()
+            if local_key == "block.xml":
+                # Special handling for block.xml to ensure
+                # storing the value as a content instance
+                if not self.learning_package_id:
+                    raise ValueError("learning_package_id must be set before resolving static files.")
+                text_content = contents_api.get_or_create_text_content(
+                    self.learning_package_id,
+                    contents_api.get_or_create_media_type(f"application/vnd.openedx.xblock.v1.{block_type}+xml").id,
+                    text=content_bytes.decode("utf-8"),
+                    created=self.utc_now,
+                )
+                resolved_files[local_key] = text_content.id
+            else:
+                resolved_files[local_key] = content_bytes
         return resolved_files
 
     def _resolve_children(self, entity_data: dict[str, Any], lookup_map: dict[str, Any]) -> list[Any]:

{openedx_learning-0.29.0 → openedx_learning-0.30.0}/openedx_learning/apps/authoring/publishing/admin.py

@@ -6,7 +6,7 @@ from __future__ import annotations
 import functools
 
 from django.contrib import admin
-from django.db.models import Count
+from django.db.models import Count, F
 from django.utils.html import format_html
 from django.utils.safestring import SafeText
 
@@ -21,6 +21,7 @@ from .models import (
     EntityListRow,
     LearningPackage,
     PublishableEntity,
+    PublishableEntityVersion,
     PublishLog,
     PublishLogRecord,
 )
@@ -48,6 +49,7 @@ class PublishLogRecordTabularInline(admin.TabularInline):
         "title",
         "old_version_num",
         "new_version_num",
+        "dependencies_hash_digest",
     )
     readonly_fields = fields
 
@@ -89,28 +91,89 @@ class PublishLogAdmin(ReadOnlyModelAdmin):
     list_filter = ["learning_package"]
 
 
+class PublishableEntityVersionTabularInline(admin.TabularInline):
+    """
+    Tabular inline for a single Draft change.
+    """
+    model = PublishableEntityVersion
+
+    fields = (
+        "version_num",
+        "title",
+        "created",
+        "created_by",
+        "dependencies_list",
+    )
+    readonly_fields = fields
+
+    def dependencies_list(self, version: PublishableEntityVersion):
+        identifiers = sorted(
+            [str(dep.key) for dep in version.dependencies.all()]
+        )
+        return "\n".join(identifiers)
+
+    def get_queryset(self, request):
+        queryset = super().get_queryset(request)
+        return (
+            queryset
+            .order_by('-version_num')
+            .select_related('created_by', 'entity')
+            .prefetch_related('dependencies')
+        )
+
+
+class PublishStatusFilter(admin.SimpleListFilter):
+    """
+    Custom filter for entities that have unpublished changes.
+    """
+    title = "publish status"
+    parameter_name = "publish_status"
+
+    def lookups(self, request, model_admin):
+        return [
+            ("unpublished_changes", "Has unpublished changes"),
+        ]
+
+    def queryset(self, request, queryset):
+        if self.value() == "unpublished_changes":
+            return (
+                queryset
+                .exclude(
+                    published__version__isnull=True,
+                    draft__version__isnull=True,
+                )
+                .exclude(
+                    published__version=F("draft__version"),
+                    published__dependencies_hash_digest=F("draft__dependencies_hash_digest")
+                )
+            )
+        return queryset
+
+
 @admin.register(PublishableEntity)
 class PublishableEntityAdmin(ReadOnlyModelAdmin):
     """
     Read-only admin view for Publishable Entities
     """
+    inlines = [PublishableEntityVersionTabularInline]
+
     list_display = [
         "key",
-        "draft_version",
         "published_version",
+        "draft_version",
         "uuid",
         "learning_package",
         "created",
         "created_by",
         "can_stand_alone",
     ]
-    list_filter = ["learning_package"]
+    list_filter = ["learning_package", PublishStatusFilter]
     search_fields = ["key", "uuid"]
 
     fields = [
         "key",
-        "draft_version",
         "published_version",
+        "draft_version",
         "uuid",
         "learning_package",
         "created",
@@ -120,8 +183,8 @@ class PublishableEntityAdmin(ReadOnlyModelAdmin):
     ]
     readonly_fields = [
         "key",
-        "draft_version",
         "published_version",
+        "draft_version",
         "uuid",
         "learning_package",
         "created",
@@ -130,21 +193,55 @@ class PublishableEntityAdmin(ReadOnlyModelAdmin):
         "can_stand_alone",
     ]
 
-    def draft_version(self, entity: PublishableEntity):
-        return entity.draft.version.version_num if entity.draft.version else None
-
-    def published_version(self, entity: PublishableEntity):
-        return entity.published.version.version_num if entity.published and entity.published.version else None
-
     def get_queryset(self, request):
         queryset = super().get_queryset(request)
         return queryset.select_related(
-            "learning_package", "published__version",
+            "learning_package", "published__version", "draft__version", "created_by"
         )
 
     def see_also(self, entity):
         return one_to_one_related_model_html(entity)
 
+    def draft_version(self, entity: PublishableEntity):
+        """
+        Version num + dependency hash if applicable, e.g. "5" or "5 (825064c2)"
+
+        If the version info is different from the published version, we
+        italicize the text for emphasis.
+        """
+        if hasattr(entity, "draft") and entity.draft.version:
+            draft_log_record = entity.draft.draft_log_record
+            if draft_log_record and draft_log_record.dependencies_hash_digest:
+                version_str = (
+                    f"{entity.draft.version.version_num} "
+                    f"({draft_log_record.dependencies_hash_digest})"
+                )
+            else:
+                version_str = str(entity.draft.version.version_num)
+
+            if version_str == self.published_version(entity):
+                return version_str
+            else:
+                return format_html("<em>{}</em>", version_str)
+
+        return None
+
+    def published_version(self, entity: PublishableEntity):
+        """
+        Version num + dependency hash if applicable, e.g. "5" or "5 (825064c2)"
+        """
+        if hasattr(entity, "published") and entity.published.version:
+            publish_log_record = entity.published.publish_log_record
+            if publish_log_record.dependencies_hash_digest:
+                return (
+                    f"{entity.published.version.version_num} "
+                    f"({publish_log_record.dependencies_hash_digest})"
+                )
+            else:
+                return str(entity.published.version.version_num)
+
+        return None
+
 
 @admin.register(Published)
 class PublishedAdmin(ReadOnlyModelAdmin):
@@ -197,6 +294,7 @@ class DraftChangeLogRecordTabularInline(admin.TabularInline):
         "title",
         "old_version_num",
         "new_version_num",
+        "dependencies_hash_digest",
     )
     readonly_fields = fields