[RELEASE] Version 13.1.0 with new UI

Related: https://projekte.in2code.de/issues/73866

Author: tinzog

.gitignore

@@ -24,3 +24,4 @@ Build/.phpunit.result.cache
 .php-cs-fixer.cache
 composer.lock
 docker-compose.yaml
+node_modules/

.project/data/dumps/local/pages.csv

@@ -1,5 +1,47 @@
 # In2publish Core Change Log
 
+13.1.0
+
+- [META] Set the EM conf version number to 13.1.0
+- [DOCS] Update Changelog.md
+- [META] Update branch-alias in composer.json
+- [DOCS] Update documentation and add upgrade documentation
+- [BUGFIX] Remove additional level filter in doc header
+- [BUGFIX] Fix filtering for level in overview module
+- [TEST] Fix PublishTranslationTest
+- [TEST] Fix acceptance tests
+- [TASK] Provide css class in dirty property list to be used in acceptance tests
+- [TEST] Fix PublishTranslationTest
+- [TEST] Fix PublishFilesModuleTest
+- [TEST] Fix UidClashTest
+- [TEST] Fix PublishChangedPagePropertiesTest
+- [TEST] Fix RecordTreeDisplayTest
+- [TEST] Fix PublishChangedContentTest
+- [DEV] Add make task for running single acceptance tests
+- [BUGFIX] Display state of soft deleted records in overview module
+- [TEST] Fix PublishingRecordWithDependencyTest
+- [TEST] Fix PublishFilesModuleTest
+- [TEST] Fix unit tests
+- [CLEANUP] Remove deprecated events
+- [BUGFIX] Fix problems with publication of unpublishable records in publishAll
+- [BUGFIX] Restore PublishButtonWithWarning
+- [BUGFIX] Avoid sql error when updating with empty values
+- [TASK] Show filter button in Redirects Module
+- [BUGFIX] Restore display of previews for comparison in overview module
+- [TASK] final implementation of language filter in the overview module
+- [WIP] Add language filter to OverviewModule
+- [TASK] migrate InformationModal from requireJs to ES6
+- [TASK] Add language filtering to publish overview
+- [TASK] Display reasons why record is not publishable in OverviewModule using a new InformationModal without publish buttons
+- [WIP][FEATURE] Forward-port new publish overview UI from v12
+- [BUGFIX] Restore start of SimpleStopwatch
+- [BUGFIX] Fix implicit nullable in PublishingContext and TestResult
+- [BUGFIX] Allow deserialization of site settings
+- [TASK] add support for pre TYPO3 V12 backend module names
+- [BUGFIX] remove StopwatchAlreadyStartedException keep the startTime if already set
+- [BUGFIX] Fix implicit nullable in Builder
+- [BUGFIX] Prevent exception if request is not set in LanguageAugmentations
+- 
 13.0.1
 
 - [META] Set the EM conf version number to 13.0.1

CHANGELOG.md

@@ -75,7 +75,7 @@ public function addString(string $key, string $default, array $validators = []):
     public function addOptionalArray(
         string $name,
         Builder $nodes,
-        array $default = null,
+        ?array $default = null,
         array $validators = []
     ): Builder {
         $this->addNode(Node::T_OPTIONAL_ARRAY, $name, $default, $validators, $nodes);

Classes/Component/ConfigContainer/Builder.php

@@ -24,10 +24,10 @@ class LanguageAugmentation implements SingletonInterface
 
     public function __invoke(DemandsWereCollected $event): void
     {
-        $languages = $this->request->getLanguages();
-        if (null === $this->request || empty($languages)) {
+        if (null === $this->request?->getLanguages()) {
             return;
         }
+        $languages = $this->request->getLanguages();
         $demands = $event->getDemands();
         $allDemands = $demands->getAll();
 

Classes/Component/Core/Demand/Augmentation/LanguageAugmentation.php

@@ -38,7 +38,10 @@ public function publish(Record $record)
 
         $foreignProps = $record->getForeignProps();
         $newValues = array_diff_assoc($localProps, $foreignProps);
-        $this->foreignDatabase->update($table, $newValues, $foreignIdentificationProps);
+        if (!empty($newValues)) {
+            $this->foreignDatabase->update($table, $newValues, $foreignIdentificationProps);
+        }
+
     }
 
     public function start(): void

Classes/Component/Core/Publisher/DatabaseRecordPublisher.php

@@ -33,6 +33,7 @@ class PublisherService
     protected PublisherCollection $publisherCollection;
     /** @var array<string, array<int, true>> */
     protected array $visitedRecords = [];
+    protected bool $isPublishAllMode = false;
 
     public function __construct()
     {
@@ -56,6 +57,20 @@ public function publish(PublishingContext $publishingContext): void
         $this->publishRecordTree($recordTree, $publishingContext->publishChildPages);
     }
 
+    /**
+     * Publishes all PUBLISHABLE records (dependencies must NOT be ignored during publishAll)
+     * @throws Throwable
+     */
+    public function publishAllPublishable(PublishingContext $publishingContext): void
+    {
+        $this->isPublishAllMode = true;
+        try {
+            $this->publish($publishingContext);
+        } finally {
+            $this->isPublishAllMode = false;
+        }
+    }
+
     /**
      * @throws Throwable
      * @internal This method will be made non-public in in2publish_core v13. Use publish() with PublishingContext
@@ -76,10 +91,13 @@ public function publishRecordTree(RecordTree $recordTree, bool $includeChildPage
 
         $this->publisherCollection->start();
 
+        // this is set for the first call to publishRecord, because
+        $isTopLevelCall = true;
+
         try {
             foreach ($recordTree->getChildren() as $records) {
                 foreach ($records as $record) {
-                    $this->publishRecord($record, $includeChildPages);
+                    $this->publishRecord($record, $includeChildPages, $isTopLevelCall);
                 }
             }
         } catch (Throwable $exception) {
@@ -103,8 +121,11 @@ public function publishRecordTree(RecordTree $recordTree, bool $includeChildPage
     /**
      * @SuppressWarnings(PHPMD.CyclomaticComplexity)
      */
-    protected function publishRecord(Record $record, bool $includeChildPages = false): void
-    {
+    protected function publishRecord(
+        Record $record,
+        bool $includeChildPages = false,
+        bool $isTopLevelCall = false
+    ): void {
         $classification = $record->getClassification();
         $id = $record->getId();
 
@@ -115,37 +136,124 @@ protected function publishRecord(Record $record, bool $includeChildPages = false
 
         $this->eventDispatcher->dispatch(new RecordWasSelectedForPublishing($record));
 
-        // Do not use Record::isPublishable(). Check only the record's reasons but not dependencies.
-        // Dependencies might have been fulfilled during publishing or ignored by the user by choice.
-        if (!$record->hasReasonsWhyTheRecordIsNotPublishable()) {
-            // deprecated, remove in v13
-            $this->eventDispatcher->dispatch(new PublishingOfOneRecordBegan($record));
-            if ($record->getState() !== Record::S_UNCHANGED) {
-                $this->publisherCollection->publish($record);
-            }
-            // deprecated, remove in v13
-            $this->eventDispatcher->dispatch(new PublishingOfOneRecordEnded($record));
+        $wasPublished = $this->publishRecordIfPublishable($record, $isTopLevelCall);
+
+        // Always process children if record was published
+        // Also process children if we're not in publishAll mode (individual publishing)
+        // In publishAll mode: only process child pages if includeChildPages is true AND parent was published
+        // Always process non-page children if parent was published
+        $shouldProcessChildren = $wasPublished || !$this->isPublishAllMode;
+
+        if ($shouldProcessChildren) {
+            $this->processTranslations($record, $includeChildPages, $wasPublished);
+            $this->processChildRecords($record, $includeChildPages, $wasPublished);
+        } elseif ($this->isPublishAllMode && $includeChildPages) {
+            // in publishAll mode child pages need to be evaluated independently even if parent wasn't published
+            $this->processChildPagesIndependently($record, $includeChildPages);
+        }
+    }
+
+    private function publishRecordIfPublishable(Record $record, bool $isTopLevelCall): bool
+    {
+        if ($record->hasReasonsWhyTheRecordIsNotPublishable()) {
+            return false;
+        }
+
+        if ($record->getStateRecursive() === Record::S_UNCHANGED) {
+            return false;
+        }
+
+        // Determine if record is publishable based on context
+        $shouldPublish = $this->shouldRecordBePublished($record, $isTopLevelCall);
+
+        if ($shouldPublish) {
+            $this->publisherCollection->publish($record);
             $this->eventDispatcher->dispatch(new RecordWasPublished($record));
+
+            return true;
         }
 
+        return false;
+    }
+
+    private function shouldRecordBePublished(Record $record, bool $isTopLevelCall): bool
+    {
+        // If not in publishAll mode, use the less strict check
+        if (!$this->isPublishAllMode) {
+            return true;
+        }
+
+        if ($isTopLevelCall && $record->getClassification() === 'pages') {
+            // Top-level pages and independent child pages must pass strict dependency check
+            return $record->isPublishable();
+        }
+
+        // For all other cases in publishAll mode use the less strict check since parent context provides validity
+        // - Child pages whose parent was published in current run
+        // - Non-page records (content elements, etc.)
+        // - Translations
+        return true;
+    }
+
+    private function processTranslations(Record $record, bool $includeChildPages, bool $parentWasPublished = false): void
+    {
         $translationEvent = new BeforePublishingTranslationsEvent($record, $includeChildPages);
         $this->eventDispatcher->dispatch($translationEvent);
 
-        if ($translationEvent->shouldProcessTranslations()) {
-            foreach ($record->getTranslations() as $translatedRecords) {
-                foreach ($translatedRecords as $translatedRecord) {
-                    $this->publishRecord($translatedRecord, $includeChildPages);
-                }
+        if (!$translationEvent->shouldProcessTranslations()) {
+            return;
+        }
+
+        foreach ($record->getTranslations() as $translatedRecords) {
+            foreach ($translatedRecords as $translatedRecord) {
+                // Translations are never top-level calls
+                $this->publishRecord($translatedRecord, $includeChildPages, false);
+            }
+        }
+    }
+
+    private function processChildPagesIndependently(Record $record, bool $includeChildPages): void
+    {
+        foreach ($record->getChildren() as $table => $children) {
+            if ($table !== 'pages') {
+                continue; // Only process child pages independently
+            }
+
+            foreach ($children as $child) {
+                // Child pages evaluated independently with strict checking
+                $this->publishRecord($child, $includeChildPages, true);
             }
         }
+    }
 
+    private function processChildRecords(Record $record, bool $includeChildPages, bool $parentWasPublished = false): void
+    {
         foreach ($record->getChildren() as $table => $children) {
-            if ('pages' === $table && !$includeChildPages) {
-                continue;
+            // Handle child pages based on mode and settings
+            if ($table === 'pages') {
+                if (!$includeChildPages && !$this->isPublishAllMode) {
+                    // Skip child pages only if not including them AND not in publishAll mode
+                    continue;
+                }
             }
+
             foreach ($children as $child) {
-                $this->publishRecord($child, $includeChildPages);
+                // Determine if child should be treated as top-level for dependency checking
+                $isChildTopLevelCall = false;
+
+                if ($table === 'pages') {
+                    if ($this->isPublishAllMode) {
+                        // In publishAll mode: child pages get strict checking ONLY if their parent
+                        // was not published in the current run (independent evaluation)
+                        $isChildTopLevelCall = !$parentWasPublished;
+                    } elseif ($includeChildPages && !$this->isPublishAllMode) {
+                        // Child pages in regular mode with includeChildPages always get strict checking
+                        $isChildTopLevelCall = true;
+                    }
+                }
+
+                $this->publishRecord($child, $includeChildPages, $isChildTopLevelCall);
             }
         }
     }
-}
+}

Classes/Component/Core/Publisher/PublisherService.php

@@ -13,7 +13,7 @@ class PublishingContext
 
     public function __construct(
         RecordTree $recordTree,
-        bool $publishChildPages = null
+        ?bool $publishChildPages = null
     ) {
         $this->recordTree = $recordTree;
         if (null !== $publishChildPages) {

Classes/Component/Core/Publisher/PublishingContext.php

@@ -17,7 +17,7 @@ class RecordTreeBuildRequest
     public function __construct(
         string $table,
         int $id,
-        int $pageRecursionLimit,
+        int $pageRecursionLimit = 0,
         int $dependencyRecursionLimit = 3,
         int $contentRecursionLimit = 8,
         ?array $languages = null

Classes/Component/Core/RecordTree/RecordTreeBuildRequest.php

@@ -46,6 +46,7 @@
 use In2code\In2publishCore\In2publishCoreException;
 use In2code\In2publishCore\Service\Database\RawRecordService;
 use In2code\In2publishCore\Service\Error\FailureCollectorInjection;
+use In2code\In2publishCore\Service\Language\SiteLanguageServiceInjection;
 use In2code\In2publishCore\Service\Permission\PermissionServiceInjection;
 use In2code\In2publishCore\Utility\BackendUtility;
 use In2code\In2publishCore\Utility\DatabaseUtility;
@@ -86,6 +87,7 @@ class RecordController extends ActionController
     use PublisherServiceInjection;
     use PermissionServiceInjection;
     use SimpleStopwatchInjection;
+    use SiteLanguageServiceInjection;
 
     /**
      * @codeCoverageIgnore
@@ -120,24 +122,6 @@ public function initializeIndexAction(): void
         }
 
         $this->moduleTemplate->setModuleClass('in2publish_core_m1');
-
-        $menuRegistry = $this->moduleTemplate->getDocHeaderComponent()->getMenuRegistry();
-        $menu = $menuRegistry->makeMenu();
-        $menu->setIdentifier('depth');
-        $menu->setLabel(LocalizationUtility::translate('m1.page_recursion', 'In2publishCore'));
-        for ($i = 0; $i <= 10; $i++) {
-            $menuItem = $menu->makeMenuItem();
-            $menuItem->setActive($i === $data['pageRecursionLimit']);
-            if ($i > 1) {
-                $title = LocalizationUtility::translate('m1.page_recursion.depths', 'In2publishCore', [$i]);
-            } else {
-                $title = LocalizationUtility::translate('m1.page_recursion.depth', 'In2publishCore', [$i]);
-            }
-            $menuItem->setTitle($title);
-            $menuItem->setHref($this->uriBuilder->uriFor('index', ['pageRecursionLimit' => $i]));
-            $menu->addMenuItem($menuItem);
-        }
-        $menuRegistry->addMenu($menu);
     }
 
     /**
@@ -160,12 +144,15 @@ public function indexAction(int $pageRecursionLimit): ResponseInterface
         } catch (Throwable $exception) {
             $foreignDbAvailable = false;
         }
+        $languages = $this->siteLanguageService->getAllowedLanguages($pid);
 
         $this->moduleTemplate->assignMultiple([
             'recordTree' => $recordTree,
             'localDatabaseConnectionAvailable' => $localDbAvailable,
             'foreignDatabaseConnectionAvailable' => $foreignDbAvailable,
             'publishingAvailable' => $localDbAvailable && $foreignDbAvailable,
+            'pageRecursionLimit' => $pageRecursionLimit,
+            'languages' => $languages,
         ]);
         return $this->htmlResponse();
     }