Fix: percent-encode paths when rewriting cached Portal Engine thumbnail URLs after a move

rewriteChildrenIndexPaths() rewrites the cached thumbnail URL for moved
assets/data-objects in the search index, but only special-cased spaces
(" " -> "%20") when matching the path prefix. Portal Engine's frontend
thumbnail URLs are built via urlencode_ignore_slash() (rawurlencode()
per path segment), which percent-encodes any non-unreserved character,
including accented letters (e.g. "é" -> "%C3%A9"). So for any moved
folder containing such characters, the prefix match silently failed
and the cached thumbnail URL was left pointing at the pre-move path -
breaking images in Portal Engine while the Studio backend (which
re-fetches thumbnails live rather than reading the cached field)
appeared unaffected.

Pass a fully percent-encoded path variant into the Painless script and
match/replace against it as a fallback, instead of only handling
spaces.

PEES-1245

Author: robertSt7

src/SearchIndexAdapter/DefaultSearch/PathService.php

@@ -124,6 +124,12 @@ private function updatePath(string $indexName, string $currentPath, string $newP
                     'params' => [
                         'currentPath' => $currentPath . '/',
                         'newPath' => $newPath . '/',
+                        // Portal Engine's frontend thumbnail URLs are built via
+                        // urlencode_ignore_slash() (rawurlencode() per path segment), so accented
+                        // and other non-unreserved characters end up percent-encoded there. Provide
+                        // the equivalently-encoded path so the script can match/replace that form too.
+                        'currentPathEncoded' => $this->encodePathSegments($currentPath) . '/',
+                        'newPathEncoded' => $this->encodePathSegments($newPath) . '/',
                         'now' => date('c'),
                     ],
                 ],
@@ -188,15 +194,14 @@ private function getScriptSource(): string
                                 }
                             }
                             
-                            String encodedCurrentPath = params.currentPath.replace(" ", "%20");
                             String thumbPath = thumb.substring(pathStart);
-                            
-                            if(thumbPath.startsWith(encodedCurrentPath) || thumbPath.startsWith(params.currentPath)) {
-                                String matchedPath = thumbPath.startsWith(encodedCurrentPath) ? 
-                                    encodedCurrentPath : params.currentPath;
+
+                            if(thumbPath.startsWith(params.currentPathEncoded) || thumbPath.startsWith(params.currentPath)) {
+                                boolean matchedEncoded = thumbPath.startsWith(params.currentPathEncoded);
+                                String matchedPath = matchedEncoded ? params.currentPathEncoded : params.currentPath;
                                 String remainingPath = thumbPath.substring(matchedPath.length());
-                                String encodedNewPath = params.newPath.replace(" ", "%20");
-                                customFields.thumbnail = prefix + encodedNewPath + remainingPath;
+                                String replacementPath = matchedEncoded ? params.newPathEncoded : params.newPath;
+                                customFields.thumbnail = prefix + replacementPath + remainingPath;
                             }
 
                         }
@@ -218,6 +223,15 @@ private function getScriptSource(): string
                 ctx._source.system_fields.checksum = 0';
     }
 
+    /**
+     * Mirrors urlencode_ignore_slash() (rawurlencode() applied per path segment), which is how
+     * Portal Engine builds its frontend thumbnail URLs (ThumbnailService::getThumbnailPath()).
+     */
+    private function encodePathSegments(string $path): string
+    {
+        return implode('/', array_map('rawurlencode', explode('/', $path)));
+    }
+
     private function countDocumentsByPath(string $indexName, string $path): int
     {
         $countResult = $this->client->search([

tests/Unit/SearchIndexAdapter/DefaultSearch/PathServiceTest.php

@@ -0,0 +1,71 @@
+<?php
+declare(strict_types=1);
+
+/**
+ * This source file is available under the terms of the
+ * Pimcore Open Core License (POCL)
+ * Full copyright and license information is available in
+ * LICENSE.md which is distributed with this source code.
+ *
+ *  @copyright  Copyright (c) Pimcore GmbH (https://www.pimcore.com)
+ *  @license    Pimcore Open Core License (POCL)
+ */
+
+namespace Pimcore\Bundle\GenericDataIndexBundle\Tests\Unit\SearchIndexAdapter\DefaultSearch;
+
+use Codeception\Test\Unit;
+use Pimcore\Bundle\GenericDataIndexBundle\SearchIndexAdapter\DefaultSearch\PathService;
+use Pimcore\Bundle\GenericDataIndexBundle\Service\SearchIndex\IndexService\ElementTypeAdapter\AdapterServiceInterface;
+use Pimcore\Bundle\GenericDataIndexBundle\Service\SearchIndex\SearchIndexConfigServiceInterface;
+use Pimcore\SearchClient\SearchClientInterface;
+use ReflectionMethod;
+
+/**
+ * Regression coverage for PEES-1245: Portal Engine's frontend thumbnail URLs are built via
+ * urlencode_ignore_slash() (rawurlencode() per path segment), so a path containing accented or
+ * other non-unreserved characters is stored percent-encoded in the search index. When such a
+ * folder is moved, rewriteChildrenIndexPaths() must be able to match and rewrite that encoded
+ * form as well as the plain form, otherwise the cached thumbnail URL is left stale.
+ *
+ * @internal
+ */
+final class PathServiceTest extends Unit
+{
+    public function testEncodePathSegmentsEncodesAccentedCharactersButKeepsSlashes(): void
+    {
+        $this->assertSame(
+            '/caf%C3%A9/sub-folder',
+            $this->encodePathSegments('/café/sub-folder')
+        );
+    }
+
+    public function testEncodePathSegmentsEncodesSpaces(): void
+    {
+        $this->assertSame(
+            '/my%20folder/asset',
+            $this->encodePathSegments('/my folder/asset')
+        );
+    }
+
+    public function testEncodePathSegmentsLeavesUnreservedCharactersUntouched(): void
+    {
+        $this->assertSame(
+            '/Folder-1/asset_2.jpg',
+            $this->encodePathSegments('/Folder-1/asset_2.jpg')
+        );
+    }
+
+    private function encodePathSegments(string $path): string
+    {
+        $service = new PathService(
+            $this->makeEmpty(SearchClientInterface::class),
+            $this->makeEmpty(AdapterServiceInterface::class),
+            $this->makeEmpty(SearchIndexConfigServiceInterface::class),
+        );
+
+        $method = new ReflectionMethod(PathService::class, 'encodePathSegments');
+        $method->setAccessible(true);
+
+        return $method->invoke($service, $path);
+    }
+}