feat: allow block publish if was published before Library v2 migration

Author: asadali145

cms/djangoapps/contentstore/tasks.py

@@ -2340,12 +2340,20 @@ def _cancel_old_tasks(course_key: str, user: User, ignore_task_ids: list[str]):
 
 
 @shared_task(base=LegacyLibraryContentToItemBank, bind=True)
-def migrate_course_legacy_library_blocks_to_item_bank(self, user_id: int, course_key: str):
+def migrate_course_legacy_library_blocks_to_item_bank(
+    self, user_id: int, course_key: str, publish_if_was_published: bool = False,
+):
     """
     Migrate legacy course library blocks to Item Bank.
 
     Depending on the number of blocks and its children blocks this operation can take a significant
     amount of time and this is why it is run as a celery task.
+
+    Arguments:
+        user_id: id of the user performing the migration.
+        course_key: the course whose legacy library content blocks should be migrated.
+        publish_if_was_published: if True, blocks that were published before the migration are
+            re-published afterwards. Defaults to False, leaving migrated blocks as drafts.
     """
     ensure_cms("Legacy library content references may only be executed in CMS")
     set_code_owner_attribute_from_module(__name__)
@@ -2363,7 +2371,7 @@ def migrate_course_legacy_library_blocks_to_item_bank(self, user_id: int, course
         with store.bulk_operations(key):
             for block in blocks:
                 self.status.set_state(f'Migrating block: {block.usage_key}')
-                block.v2_update_children_upstream_version(user_id)
+                block.v2_update_children_upstream_version(user_id, publish_if_was_published)
     except Exception as exc:  # pylint: disable=broad-except
         LOGGER.exception(f'Error while migrating blocks: {exc}')
         self.status.fail(str(exc))

xmodule/library_content_block.py

@@ -329,14 +329,18 @@ def studio_post_paste(self, store, source_node) -> bool:
         self.sync_from_library(upgrade_to_latest=False)
         return True  # Children have been handled
 
-    def v2_update_children_upstream_version(self, user_id=None):
+    def v2_update_children_upstream_version(self, user_id=None, publish_if_was_published=False):
         """
         Update the upstream and upstream version fields of all children to point to library v2 version of the legacy
         library blocks. This essentially converts this legacy block to new ItemBankBlock.
+
+        If `publish_if_was_published` is True, and this block was published prior to the migration, it is
+        re-published afterwards so that the upstream/upstream_version changes reach LMS.
         """
         from cms.djangoapps.modulestore_migrator import api as migrator_api
         store = modulestore()
         with store.bulk_operations(self.course_id):
+            was_published = publish_if_was_published and store.has_published_version(self)
             children = self.get_children()
             # These are the v1 library item upstream UsageKeys
             child_old_upstream_keys = [
@@ -358,6 +362,8 @@ def v2_update_children_upstream_version(self, user_id=None):
             self.is_migrated_to_v2 = True
             self.save()
             store.update_item(self, user_id)
+            if was_published:
+                store.publish(self.location, user_id)
 
     def _validate_library_version(self, validation, lib_tools, version, library_key):
         """

xmodule/tests/test_library_content.py

@@ -826,3 +826,73 @@ def test_author_view(self):
         assert '<li>html 2</li>' in rendered.content
         assert '<li>html 3</li>' in rendered.content
         assert '<li>html 4</li>' in rendered.content
+
+
+class TestLegacyLibraryContentBlockMigrationPublishing(LegacyLibraryContentTest):
+    """
+    Unit tests for the `publish_if_was_published` flag of
+    LegacyLibraryContentBlock.v2_update_children_upstream_version.
+    """
+
+    def setUp(self):
+        from cms.djangoapps.modulestore_migrator import api
+        from cms.djangoapps.modulestore_migrator.data import CompositionLevel, RepeatHandlingStrategy
+        super().setUp()
+        user = UserFactory()
+        self._sync_lc_block_from_library()
+        self.organization = OrganizationFactory(short_name="myorg")
+        lib_api.create_library(
+            org=self.organization,
+            slug="mylib",
+            title="My Test V2 Library",
+        )
+        self.library_v2 = lib_api.ContentLibrary.objects.get(slug="mylib")
+        api.start_migration_to_library(
+            user=user,
+            source_key=self.library.location.library_key,
+            target_library_key=self.library_v2.library_key,
+            target_collection_slug=None,
+            composition_level=CompositionLevel.Component,
+            repeat_handling_strategy=RepeatHandlingStrategy.Skip,
+            preserve_url_slugs=True,
+            forward_source_to_target=True,
+        )
+
+    def test_publishes_block_that_was_previously_published(self):
+        """
+        If the LC block was published before migration, and `publish_if_was_published=True`,
+        the migration should re-publish it so the new upstream links reach the published branch.
+        """
+        self.store.publish(self.course.location, self.user_id)
+
+        self.lc_block.v2_update_children_upstream_version(self.user_id, publish_if_was_published=True)
+
+        with self.store.branch_setting(ModuleStoreEnum.Branch.published_only):
+            published_block = self.store.get_item(self.lc_block.location)
+            assert published_block.is_migrated_to_v2 is True
+            assert published_block.get_children()[0].upstream == "lb:myorg:mylib:html:html_1"
+
+    def test_does_not_publish_when_flag_is_false(self):
+        """
+        Even if the block was published before migration, it should NOT be re-published
+        when `publish_if_was_published` is False (the default).
+        """
+        self.store.publish(self.course.location, self.user_id)
+
+        self.lc_block.v2_update_children_upstream_version(self.user_id)
+
+        with self.store.branch_setting(ModuleStoreEnum.Branch.published_only):
+            published_block = self.store.get_item(self.lc_block.location)
+            # The published version still reflects the pre-migration state.
+            assert published_block.is_migrated_to_v2 is False
+
+    def test_does_not_publish_block_that_was_never_published(self):
+        """
+        If the LC block was never published, `publish_if_was_published=True` should not
+        cause it to become published.
+        """
+        assert not self.store.has_published_version(self.lc_block)
+
+        self.lc_block.v2_update_children_upstream_version(self.user_id, publish_if_was_published=True)
+
+        assert not self.store.has_published_version(self.store.get_item(self.lc_block.location))