[FEATURE] calculate site hash by site-identifier strategy by setting

Adds new SiteHash calculation strategy, which can be enabled by extension setting `siteHashStrategy`.
The old strategy is currently as default, the new will become default on EXT:solr 13.1.x+
The new strategy for site-hash can be enabled by setting
`$GLOBALS['TYPO3_CONF_VARS']['EXTENSIONS']['solr']['siteHashStrategy'] = 1`

The `document.site` will contain the site-identifier instead of domain,
if the site-hash strategy is set to Identifier.

Fixes: #3459

Author: dkd-kaehm

Build/Test/IntegrationTests.xml

@@ -30,6 +30,6 @@
   </testsuites>
   <php>
     <ini name="display_errors" value="1"/>
-    <env name="TYPO3_CONTEXT" value="Testing"/>
+    <env name="TYPO3_CONTEXT" value="Testing" force="true"/>
   </php>
 </phpunit>

Build/Test/UnitTests.xml

@@ -30,7 +30,7 @@
 	</testsuites>
 	<php>
 		<ini name="display_errors" value="1"/>
-		<env name="TYPO3_CONTEXT" value="Testing"/>
+		<env name="TYPO3_CONTEXT" value="Testing" force="true"/>
 	</php>
 	<extensions>
 		<bootstrap class="DG\BypassFinals\PHPUnitExtension"/>

Classes/Domain/Search/ApacheSolrDocument/Builder.php

@@ -21,6 +21,7 @@
 use ApacheSolrForTypo3\Solr\Domain\Site\Site;
 use ApacheSolrForTypo3\Solr\Domain\Site\SiteRepository;
 use ApacheSolrForTypo3\Solr\Domain\Variants\IdBuilder;
+use ApacheSolrForTypo3\Solr\System\Configuration\ExtensionConfiguration;
 use ApacheSolrForTypo3\Solr\System\Solr\Document\Document;
 use ApacheSolrForTypo3\Solr\Typo3PageContentExtractor;
 use ApacheSolrForTypo3\Solr\Util;
@@ -40,6 +41,7 @@ class Builder
 {
     public function __construct(
         protected readonly IdBuilder $variantIdBuilder,
+        protected ExtensionConfiguration $extensionConfiguration,
     ) {}
 
     /**
@@ -64,7 +66,10 @@ public function fromPage(
         $documentId = $this->getPageDocumentId($pageInformation, $pageArguments, $siteLanguage, $accessGroups, $mountPointParameter);
 
         $document->setField('id', $documentId);
-        $document->setField('site', $site->getDomain());
+        $document->setField('site', $site->getSiteIdentifier());
+        if ($this->extensionConfiguration->getSiteHashStrategy() === 0) {
+            $document->setField('site', $site->getDomain());
+        }
         $document->setField('siteHash', $site->getSiteHash());
         $document->setField('appKey', 'EXT:solr');
         $document->setField('type', 'pages');

Classes/Domain/Search/Query/QueryBuilder.php

@@ -274,7 +274,7 @@ public function useSiteHashFromAllowedSites(string $allowedSites): QueryBuilder
         $allowedSites = GeneralUtility::trimExplode(',', $allowedSites);
         $filters = [];
         foreach ($allowedSites as $site) {
-            $siteHash = $this->siteHashService->getSiteHashForDomain($site);
+            $siteHash = $this->siteHashService->getSiteHashForSiteIdentifier($site);
             $filters[] = 'siteHash:"' . $siteHash . '"';
         }
 

Classes/Domain/Site/Site.php

@@ -284,18 +284,16 @@ public function getPages(
         return $this->pagesRepository->findAllSubPageIdsByRootPage($pageId, $initialPagesAdditionalWhereClause);
     }
 
-    /**
-     * Generates the site's unique Site Hash.
-     *
-     * The Site Hash is build from the site's main domain, the system encryption
-     * key, and the extension "tx_solr". These components are concatenated and
-     * sha1-hashed.
-     */
     public function getSiteHash(): string
     {
         return $this->siteHash;
     }
 
+    public function getSiteIdentifier(): string
+    {
+        return $this->typo3SiteObject->getIdentifier();
+    }
+
     /**
      * Gets the site's main domain.
      *

Classes/Domain/Site/SiteHashService.php

@@ -17,22 +17,31 @@
 
 namespace ApacheSolrForTypo3\Solr\Domain\Site;
 
+use ApacheSolrForTypo3\Solr\Event\Site\AfterSiteHashHasBeenDeterminedForSiteEvent;
+use ApacheSolrForTypo3\Solr\System\Configuration\ExtensionConfiguration;
 use ApacheSolrForTypo3\Solr\System\Util\SiteUtility;
+use Psr\EventDispatcher\EventDispatcherInterface;
+use TYPO3\CMS\Core\Core\Environment;
 use TYPO3\CMS\Core\Exception\SiteNotFoundException;
+use TYPO3\CMS\Core\Site\Entity\Site as TYPO3Site;
 use TYPO3\CMS\Core\Site\SiteFinder;
+use TYPO3\CMS\Core\Utility\GeneralUtility;
 
 /**
  * SiteHashService
  *
- * Responsible to provide sitehash related service methods.
+ * Responsible to provide site-hash related service methods.
  */
 class SiteHashService
 {
-    protected SiteFinder $siteFinder;
+    protected EventDispatcherInterface $eventDispatcher;
 
-    public function __construct(SiteFinder $siteFinder)
-    {
-        $this->siteFinder = $siteFinder;
+    public function __construct(
+        protected SiteFinder $siteFinder,
+        protected ExtensionConfiguration $extensionConfiguration,
+        ?EventDispatcherInterface $eventDispatcherInterface = null,
+    ) {
+        $this->eventDispatcher = $eventDispatcherInterface ?? GeneralUtility::makeInstance(EventDispatcherInterface::class);
     }
 
     /**
@@ -52,32 +61,98 @@ public function getAllowedSitesForPageIdAndAllowedSitesConfiguration(
         ?string $allowedSitesConfiguration = '',
     ): string {
         if ($allowedSitesConfiguration === '__all') {
-            return $this->getDomainListOfAllSites();
+            return $this->extensionConfiguration->getSiteHashStrategy() === 1
+                ? $this->getIdentifiersOfAllSites()
+                : $this->getDomainListOfAllSites();
         }
         if ($allowedSitesConfiguration === '*') {
             return '*';
         }
         // we thread empty allowed site configurations as __solr_current_site since this is the default behaviour
         $allowedSitesConfiguration = empty($allowedSitesConfiguration) ? '__solr_current_site' : $allowedSitesConfiguration;
-        return $this->getDomainByPageIdAndReplaceMarkers($pageId, $allowedSitesConfiguration);
+
+        if ($this->extensionConfiguration->getSiteHashStrategy() === 0) {
+            return $this->getDomainByPageIdAndReplaceMarkers($pageId, $allowedSitesConfiguration);
+        }
+        return $this->getSiteIdentifierByPageIdAndReplaceMarkers($pageId, $allowedSitesConfiguration);
+    }
+
+    public function getSiteHash(TYPO3Site $site): string
+    {
+        static $siteHashes = [];
+        if (isset($siteHashes[$site->getIdentifier()])) {
+            return $siteHashes[$site->getIdentifier()];
+        }
+
+        $siteHash = $this->getSiteHashForSiteIdentifier($site->getIdentifier());
+
+        $event = $this->eventDispatcher->dispatch(
+            new AfterSiteHashHasBeenDeterminedForSiteEvent(
+                $siteHash,
+                $site,
+                $this->extensionConfiguration,
+            ),
+        );
+        $siteHashes[$site->getIdentifier()] = $event->getSiteHash();
+        return $siteHashes[$site->getIdentifier()];
     }
 
     /**
      * Gets the site hash for a given domain
+     *
+     * @deprecated The method SiteHashService::getSiteHashForDomain() is deprecated and will be removed in version 13.1.x+.
+     *             Use SiteHashService::getSiteHashForSiteIdentifier() or SiteHashService::getSiteHash() instead.
      */
     public function getSiteHashForDomain(string $domain): string
+    {
+        trigger_error(
+            'The method SiteHashService::getSiteHashForDomain() is deprecated and will be removed in version 13.1.x+.' .
+            'Use SiteHashService::getSiteHashForSiteIdentifier() or SiteHashService::getSiteHash() instead.',
+            E_USER_DEPRECATED,
+        );
+        return $this->getSiteHashForSiteIdentifier($domain);
+    }
+
+    /**
+     * Gets the site hash for a given site-identifier
+     */
+    public function getSiteHashForSiteIdentifier(string $siteIdentifier): string
     {
         static $siteHashes = [];
-        if (isset($siteHashes[$domain])) {
-            return $siteHashes[$domain];
+        if (isset($siteHashes[$siteIdentifier])) {
+            return $siteHashes[$siteIdentifier];
+        }
+
+        $applicationContext = (string)Environment::getContext();
+        if ($this->extensionConfiguration->getSiteHashStrategy() === 0) {
+            $applicationContext = '';
+        }
+        $siteHashes[$siteIdentifier] = sha1($applicationContext . $siteIdentifier . $GLOBALS['TYPO3_CONF_VARS']['SYS']['encryptionKey'] . 'tx_solr');
+        return $siteHashes[$siteIdentifier];
+    }
+
+    /**
+     * Returns a comma separated list of all site-identifiers.
+     */
+    protected function getIdentifiersOfAllSites(): string
+    {
+        $sites = $this->siteFinder->getAllSites();
+        $siteIdentifiers = [];
+        foreach ($sites as $typo3Site) {
+            $connections = SiteUtility::getAllSolrConnectionConfigurations($typo3Site);
+            if (!empty($connections)) {
+                $siteIdentifiers[] = $typo3Site->getIdentifier();
+            }
         }
 
-        $siteHashes[$domain] = sha1($domain . $GLOBALS['TYPO3_CONF_VARS']['SYS']['encryptionKey'] . 'tx_solr');
-        return $siteHashes[$domain];
+        return implode(',', $siteIdentifiers);
     }
 
     /**
      * Returns a comma separated list of all domains from all sites.
+     *
+     * @deprecated SiteHashService::getDomainListOfAllSites() is deprecated and will be removed in v14.
+     *             Use SiteHashService::getIdentifiersOfAllSites() instead.
      */
     protected function getDomainListOfAllSites(): string
     {
@@ -93,9 +168,29 @@ protected function getDomainListOfAllSites(): string
         return implode(',', $domains);
     }
 
+    /**
+     * Retrieves the site identifier of the site that belongs to the passed pageId and replaces their markers __solr_current_site
+     * and __current_site.
+     */
+    protected function getSiteIdentifierByPageIdAndReplaceMarkers(int $pageId, string $allowedSitesConfiguration): string
+    {
+        try {
+            $typo3Site = $this->siteFinder->getSiteByPageId($pageId);
+            $siteIdentifierOfPage = $typo3Site->getIdentifier();
+        } catch (SiteNotFoundException) {
+            return '';
+        }
+
+        $allowedSites = str_replace(['__solr_current_site', '__current_site'], $siteIdentifierOfPage, $allowedSitesConfiguration);
+        return (string)$allowedSites;
+    }
+
     /**
      * Retrieves the domain of the site that belongs to the passed pageId and replaces their markers __solr_current_site
      * and __current_site.
+     *
+     * @deprecated SiteHashService::getDomainByPageIdAndReplaceMarkers() is deprecated and will be removed in v14.
+     *             Use SiteHashService::getSiteIdentifierByPageIdAndReplaceMarkers() instead.
      */
     protected function getDomainByPageIdAndReplaceMarkers(int $pageId, string $allowedSitesConfiguration): string
     {

Classes/Domain/Site/SiteRepository.php

@@ -250,14 +250,27 @@ protected function buildSite(int $rootPageId): ?Site
         return $this->buildTypo3ManagedSite($rootPageRecord);
     }
 
+    /**
+     * Returns the site hash for given site.
+     */
+    protected function getSiteHash(CoreSite $site): string
+    {
+        /** @var SiteHashService $siteHashService */
+        $siteHashService = GeneralUtility::makeInstance(SiteHashService::class);
+        return $siteHashService->getSiteHash($site);
+    }
+
     /**
      * Returns the site hash for given domain.
+     *
+     * @deprecated SiteRepository::getSiteHashForDomain() is soft deprecated and will be removed in v13.1.x+.
+     *             The SiteRepository::getSiteHash() will be used instead.
      */
     protected function getSiteHashForDomain(string $domain): string
     {
         /** @var SiteHashService $siteHashService */
         $siteHashService = GeneralUtility::makeInstance(SiteHashService::class);
-        return $siteHashService->getSiteHashForDomain($domain);
+        return $siteHashService->getSiteHashForSiteIdentifier($domain);
     }
 
     /**
@@ -302,7 +315,11 @@ protected function buildTypo3ManagedSite(array $rootPageRecord): ?Site
         );
         $domain = $event->getDomain();
 
-        $siteHash = $this->getSiteHashForDomain($domain);
+        $siteHash = $this->getSiteHash($typo3Site);
+        if ($this->extensionConfiguration->getSiteHashStrategy() === 0) {
+            $siteHash = $this->getSiteHashForDomain($domain);
+        }
+
         $defaultLanguage = $typo3Site->getDefaultLanguage()->getLanguageId();
         $pageRepository = GeneralUtility::makeInstance(PagesRepository::class);
         $availableLanguageIds = array_map(static function ($language) {

Classes/Eid/ApiEid.php

@@ -40,7 +40,7 @@ class ApiEid
         'siteHash' => [
             'params' => [
                 'required' => [
-                    'domain',
+                    'siteIdentifier',
                 ],
             ],
         ],
@@ -53,6 +53,12 @@ class ApiEid
      */
     public function main(ServerRequestInterface $request): ResponseInterface
     {
+        $queryParams = $request->getQueryParams();
+        // @todo, remove this backwards-compatibility-adjustment together with siteHashStrategy setting.
+        if (isset($queryParams['domain'])) {
+            $queryParams['siteIdentifier'] = $queryParams['domain'];
+            $request = $request->withQueryParams($queryParams);
+        }
         $this->validateRequest($request);
         return $this->{'get' . ucfirst($request->getQueryParams()['api']) . 'Response'}($request);
     }
@@ -64,13 +70,26 @@ public function main(ServerRequestInterface $request): ResponseInterface
      */
     protected function getSiteHashResponse(ServerRequestInterface $request): JsonResponse
     {
-        $domain = $request->getQueryParams()['domain'];
+        $queryParams = $request->getQueryParams();
+        $siteIdentifier = $queryParams['siteIdentifier'];
 
         /** @var SiteHashService $siteHashService */
         $siteHashService = GeneralUtility::makeInstance(SiteHashService::class);
-        $siteHash = $siteHashService->getSiteHashForDomain($domain);
+        $siteHash = $siteHashService->getSiteHashForSiteIdentifier($siteIdentifier);
+        $jsonResponseContents = [
+            'sitehash' => $siteHash,
+        ];
+        // @todo, remove this backwards-compatibility-adjustment together with siteHashStrategy setting.
+        if (isset($queryParams['domain'])) {
+            $deprecationMessage = 'The domain parameter for eID=tx_solr_api - api=siteHash is deprecated, please use siteIdentifier instead.';
+            trigger_error(
+                $deprecationMessage,
+                E_USER_DEPRECATED,
+            );
+            $jsonResponseContents['deprecation notice'] = $deprecationMessage;
+        }
         return new JsonResponse(
-            ['sitehash' => $siteHash],
+            $jsonResponseContents,
         );
     }
 
@@ -106,6 +125,7 @@ protected function validateRequest(ServerRequestInterface $request): void
         }
 
         $requiredApiParams = $this->getApiMethodDefinitions()[$params['api']]['params']['required'] ?? [];
+
         $requiredApiParams[] = 'eID';
         $missingParams = array_values(array_diff($requiredApiParams, array_keys($request->getQueryParams())));
         if (!empty($missingParams)) {

Classes/Event/Site/AfterDomainHasBeenDeterminedForSiteEvent.php

@@ -22,6 +22,9 @@
 
 /**
  * This event is dispatched when determining which domain to use for a site
+ *
+ * @deprecated AfterDomainHasBeenDeterminedForSiteEvent is deprecated and will be removed in v13.1.x+.
+ *             Use AfterSiteHashHasBeenDeterminedForSiteEvent instead.
  */
 final class AfterDomainHasBeenDeterminedForSiteEvent
 {