Refactor more methods to the SearchService (#3775)

Author: demiankatz

module/VuFind/config/module.config.php

@@ -423,6 +423,7 @@
             'VuFind\Cover\Loader' => 'VuFind\Cover\LoaderFactory',
             'VuFind\Cover\Router' => 'VuFind\Cover\RouterFactory',
             'VuFind\Crypt\HMAC' => 'VuFind\Crypt\HMACFactory',
+            'VuFind\Crypt\SecretCalculator' => 'VuFind\Crypt\SecretCalculatorFactory',
             'VuFind\Date\Converter' => 'VuFind\Service\DateConverterFactory',
             'VuFind\Db\AdapterFactory' => 'VuFind\Service\ServiceWithConfigIniFactory',
             'VuFind\Db\Row\PluginManager' => 'VuFind\ServiceManager\AbstractPluginManagerFactory',

module/VuFind/src/VuFind/AjaxHandler/GetSearchResults.php

@@ -116,7 +116,6 @@ class GetSearchResults extends \VuFind\AjaxHandler\AbstractBase implements
      * @param ?UserEntityInterface $user             Logged-in user
      * @param string               $sessionId        Session ID
      * @param SearchNormalizer     $searchNormalizer Search normalizer
-     * @param Search               $searchTable      Search table
      * @param array                $config           Main configuration
      * @param Memory               $searchMemory     Search memory
      */
@@ -128,7 +127,6 @@ public function __construct(
         protected ?UserEntityInterface $user,
         protected string $sessionId,
         protected SearchNormalizer $searchNormalizer,
-        protected Search $searchTable,
         protected array $config,
         protected Memory $searchMemory
     ) {
@@ -361,8 +359,7 @@ protected function renderAnalytics(ParamsHelper $requestParams, Results $results
      */
     protected function saveSearchToHistory(Results $results): void
     {
-        $this->searchTable->saveSearch(
-            $this->searchNormalizer,
+        $this->searchNormalizer->saveNormalizedSearch(
             $results,
             $this->sessionId,
             $this->user?->getId()

module/VuFind/src/VuFind/AjaxHandler/GetSearchResultsFactory.php

@@ -77,7 +77,6 @@ public function __invoke(
             $container->get(\VuFind\Auth\Manager::class)->getUserObject(),
             $container->get(\Laminas\Session\SessionManager::class)->getId(),
             $container->get(\VuFind\Search\SearchNormalizer::class),
-            $container->get(\VuFind\Db\Table\PluginManager::class)->get(\VuFind\Db\Table\Search::class),
             $container->get(\VuFind\Config\PluginManager::class)->get('config')->toArray(),
             $container->get(\VuFind\Search\Memory::class)
         );

module/VuFind/src/VuFind/Controller/AbstractSearch.php

@@ -30,10 +30,13 @@
 
 namespace VuFind\Controller;
 
+use Exception;
 use Laminas\Http\Response as HttpResponse;
 use Laminas\Session\SessionManager;
 use Laminas\Stdlib\ResponseInterface as Response;
 use Laminas\View\Model\ViewModel;
+use VuFind\Db\Entity\SearchEntityInterface;
+use VuFind\Db\Service\SearchServiceInterface;
 use VuFind\Search\RecommendListener;
 use VuFind\Solr\Utils as SolrUtils;
 
@@ -141,8 +144,10 @@ protected function redirectToSavedSearch($id)
 
         // If we got this far, the user is allowed to view the search, so we can
         // deminify it to a new object.
-        $minSO = $search->getSearchObjectOrThrowException();
-        $savedSearch = $minSO->deminify($this->getResultsManager());
+        $savedSearch = $search->getSearchObject()?->deminify($this->getResultsManager());
+        if (!$savedSearch) {
+            throw new Exception("Problem getting search object from search {$search->getId()}.");
+        }
 
         // Now redirect to the URL associated with the saved search; this
         // simplifies problems caused by mixing different classes of search
@@ -513,15 +518,13 @@ protected function getRedirectForRecord(
      *
      * @param int $searchId Primary key value
      *
-     * @return ?\VuFind\Db\Row\Search
+     * @return ?SearchEntityInterface
      */
     protected function retrieveSearchSecurely($searchId)
     {
-        $searchTable = $this->getTable('Search');
         $sessId = $this->serviceLocator->get(SessionManager::class)->getId();
-        $user = $this->getUser();
-        $userId = $user ? $user->id : null;
-        return $searchTable->getOwnedRowById($searchId, $sessId, $userId);
+        $user = $this->getUser() ?: null;
+        return $this->getDbService(SearchServiceInterface::class)->getSearchByIdAndOwner($searchId, $sessId, $user);
     }
 
     /**
@@ -533,14 +536,12 @@ protected function retrieveSearchSecurely($searchId)
      */
     protected function saveSearchToHistory($results)
     {
-        $user = $this->getUser();
+        $user = $this->getUser() ?: null;
         $sessId = $this->serviceLocator->get(SessionManager::class)->getId();
-        $history = $this->getTable('Search');
-        $history->saveSearch(
-            $this->serviceLocator->get(\VuFind\Search\SearchNormalizer::class),
+        $this->serviceLocator->get(\VuFind\Search\SearchNormalizer::class)->saveNormalizedSearch(
             $results,
             $sessId,
-            $user->id ?? null
+            $user?->getId()
         );
     }
 
@@ -562,8 +563,10 @@ protected function restoreAdvancedSearch($searchId)
         }
 
         // Restore the full search object:
-        $minSO = $search->getSearchObjectOrThrowException();
-        $savedSearch = $minSO->deminify($this->getResultsManager());
+        $savedSearch = $search->getSearchObject()?->deminify($this->getResultsManager());
+        if (!$savedSearch) {
+            throw new Exception("Problem getting search object from search {$search->getId()}.");
+        }
 
         // Fail if this is not the right type of search:
         if ($savedSearch->getParams()->getSearchType() != 'advanced') {

module/VuFind/src/VuFind/Controller/MyResearchController.php

@@ -32,13 +32,17 @@
 namespace VuFind\Controller;
 
 use DateTime;
+use Exception;
 use Laminas\ServiceManager\ServiceLocatorInterface;
 use Laminas\Session\Container;
 use Laminas\View\Model\ViewModel;
 use VuFind\Account\UserAccountService;
 use VuFind\Auth\ILSAuthenticator;
 use VuFind\Controller\Feature\ListItemSelectionTrait;
+use VuFind\Crypt\SecretCalculator;
+use VuFind\Db\Entity\SearchEntityInterface;
 use VuFind\Db\Entity\UserEntityInterface;
+use VuFind\Db\Service\SearchServiceInterface;
 use VuFind\Db\Service\UserListServiceInterface;
 use VuFind\Db\Service\UserResourceServiceInterface;
 use VuFind\Db\Service\UserServiceInterface;
@@ -440,14 +444,14 @@ public function logoutAction()
      * @param int $userId   ID of active user
      *
      * @throws ForbiddenException
-     * @return \VuFind\Db\Row\Search
+     * @return SearchEntityInterface
      */
     protected function getSearchRowSecurely($searchId, $userId)
     {
-        $searchTable = $this->getTable('Search');
         $sessId = $this->serviceLocator
             ->get(\Laminas\Session\SessionManager::class)->getId();
-        $search = $searchTable->getOwnedRowById($searchId, $sessId, $userId);
+        $search = $this->getDbService(SearchServiceInterface::class)
+            ->getSearchByIdAndOwner($searchId, $sessId, $userId);
         if (empty($search)) {
             throw new ForbiddenException('Access denied.');
         }
@@ -507,7 +511,6 @@ protected function scheduleSearch(UserEntityInterface $user, $schedule, $sid)
         if (!isset($scheduleOptions[$schedule])) {
             throw new ForbiddenException('Illegal schedule option: ' . $schedule);
         }
-        $search = $this->getTable('Search');
         $baseurl = rtrim($this->getServerUrl('home'), '/');
         $userId = $user->getId();
         $savedRow = $this->getSearchRowSecurely($sid, $userId);
@@ -516,7 +519,6 @@ protected function scheduleSearch(UserEntityInterface $user, $schedule, $sid)
         $sessId = $this->serviceLocator
             ->get(\Laminas\Session\SessionManager::class)->getId();
         $duplicateId = $this->isDuplicateOfSavedSearch(
-            $search,
             $savedRow,
             $sessId,
             $userId
@@ -536,9 +538,11 @@ protected function scheduleSearch(UserEntityInterface $user, $schedule, $sid)
             // By default, a first scheduled email will be sent because the database
             // last notification date will be initialized to a past date. If we don't
             // want that to happen, we need to set it to a more appropriate date:
-            $savedRow->last_notification_sent = date('Y-m-d H:i:s');
+            $savedRow->setLastNotificationSent(new DateTime());
         }
-        $savedRow->setSchedule($schedule, $baseurl);
+        $savedRow->setNotificationFrequency($schedule);
+        $savedRow->setNotificationBaseUrl($baseurl);
+        $this->getDbService(SearchServiceInterface::class)->persistEntity($savedRow);
         return $this->redirect()->toRoute('search-history');
     }
 
@@ -575,11 +579,8 @@ public function schedulesearchAction()
 
         // If the user has just logged in, the search might be a duplicate; if
         // so, let's switch to the pre-existing version instead.
-        $searchTable = $this->getTable('search');
-        $sessId = $this->serviceLocator
-            ->get(\Laminas\Session\SessionManager::class)->getId();
+        $sessId = $this->serviceLocator->get(\Laminas\Session\SessionManager::class)->getId();
         $duplicateId = $this->isDuplicateOfSavedSearch(
-            $searchTable,
             $search,
             $sessId,
             $user->getId()
@@ -594,9 +595,11 @@ public function schedulesearchAction()
         }
 
         // Now fetch all the results:
-        $resultsManager = $this->serviceLocator
-            ->get(\VuFind\Search\Results\PluginManager::class);
-        $results = $search->getSearchObjectOrThrowException()->deminify($resultsManager);
+        $resultsManager = $this->serviceLocator->get(\VuFind\Search\Results\PluginManager::class);
+        $results = $search->getSearchObject()?->deminify($resultsManager);
+        if (!$results) {
+            throw new Exception("Problem getting search object from search {$search->getId()}.");
+        }
 
         // Build the form.
         return $this->createViewModel(
@@ -607,36 +610,34 @@ public function schedulesearchAction()
     /**
      * Is the provided search row a duplicate of a search that is already saved?
      *
-     * @param \VuFind\Db\Table\Search $searchTable Search table
-     * @param ?\VuFind\Db\Row\Search  $rowToCheck  Search row to check (if any)
-     * @param string                  $sessId      Current session ID
-     * @param int                     $userId      Current user ID
+     * @param ?SearchEntityInterface $rowToCheck Search row to check (if any)
+     * @param string                 $sessId     Current session ID
+     * @param int                    $userId     Current user ID
      *
      * @return ?int
      */
     protected function isDuplicateOfSavedSearch(
-        \VuFind\Db\Table\Search $searchTable,
-        ?\VuFind\Db\Row\Search $rowToCheck,
+        ?SearchEntityInterface $rowToCheck,
         string $sessId,
         int $userId
     ): ?int {
         if (!$rowToCheck) {
             return null;
         }
-        $normalizer = $this->serviceLocator
-            ->get(\VuFind\Search\SearchNormalizer::class);
-        $normalized = $normalizer
-            ->normalizeMinifiedSearch($rowToCheck->getSearchObjectOrThrowException());
-        $matches = $searchTable->getSearchRowsMatchingNormalizedSearch(
+        $normalizer = $this->serviceLocator->get(\VuFind\Search\SearchNormalizer::class);
+        $searchObject = $rowToCheck->getSearchObject();
+        if (!$searchObject) {
+            throw new Exception("Problem getting search object from search {$rowToCheck->getId()}.");
+        }
+        $normalized = $normalizer->normalizeMinifiedSearch($searchObject);
+        $matches = $normalizer->getSearchesMatchingNormalizedSearch(
             $normalized,
             $sessId,
             $userId
         );
         foreach ($matches as $current) {
-            // $current->saved may be 1 (MySQL) or true (PostgreSQL), so we should
-            // avoid a strict === comparison here:
-            if ($current->saved == 1 && $current->id !== $rowToCheck->id) {
-                return $current->id;
+            if ($current->getSaved() && $current->getId() !== $rowToCheck->getId()) {
+                return $current->getId();
             }
         }
         return null;
@@ -673,12 +674,11 @@ public function savesearchAction()
             // saved row, we should just delete the duplicate. (This can happen if
             // the user clicks "save" before logging in, then logs in during the
             // save process, but has the same search already saved in their account).
-            $searchTable = $this->getTable('search');
+            $searchService = $this->getDbService(SearchServiceInterface::class);
             $sessId = $this->serviceLocator
                 ->get(\Laminas\Session\SessionManager::class)->getId();
-            $rowToCheck = $searchTable->getOwnedRowById($id, $sessId, $user->getId());
+            $rowToCheck = $searchService->getSearchByIdAndOwner($id, $sessId, $user);
             $duplicateId = $this->isDuplicateOfSavedSearch(
-                $searchTable,
                 $rowToCheck,
                 $sessId,
                 $user->getId()
@@ -2318,25 +2318,21 @@ public function unsubscribeAction()
         $view = $this->createViewModel();
         if ($this->params()->fromQuery('confirm', false) == 1) {
             if ($type == 'alert') {
-                $search
-                    = $this->getTable('Search')->select(['id' => $id])->current();
+                $searchService = $this->getDbService(SearchServiceInterface::class);
+                $search = $searchService->getSearchById($id);
                 if (!$search) {
                     throw new \Exception('Invalid parameters.');
                 }
-                $user = $this->getTable('User')->getById($search->user_id);
-                $secret = $search->getUnsubscribeSecret(
-                    $this->serviceLocator->get(\VuFind\Crypt\HMAC::class),
-                    $user
-                );
+                $secret = $this->serviceLocator->get(SecretCalculator::class)->getSearchUnsubscribeSecret($search);
                 if ($key !== $secret) {
                     throw new \Exception('Invalid parameters.');
                 }
-                $search->setSchedule(0);
+                $search->setNotificationFrequency(0);
+                $searchService->persistEntity($search);
                 $view->success = true;
             }
         } else {
-            $view->unsubscribeUrl
-                = $this->getRequest()->getRequestUri() . '&confirm=1';
+            $view->unsubscribeUrl = $this->getRequest()->getRequestUri() . '&confirm=1';
         }
         return $view;
     }

module/VuFind/src/VuFind/Controller/Plugin/ResultScroller.php

@@ -31,8 +31,10 @@
 
 namespace VuFind\Controller\Plugin;
 
+use Exception;
 use Laminas\Mvc\Controller\Plugin\AbstractPlugin;
 use Laminas\Session\Container as SessionContainer;
+use VuFind\Db\Service\SearchServiceInterface;
 use VuFind\RecordDriver\AbstractBase as BaseRecord;
 use VuFind\Search\Base\Results;
 use VuFind\Search\Memory as SearchMemory;
@@ -659,15 +661,17 @@ protected function fetchPage($searchObject, $page = null)
      */
     protected function restoreSearch(int $searchId): ?Results
     {
-        $searchTable = $this->getController()->getTable('Search');
-        $row = $searchTable->getOwnedRowById(
+        $searchService = $this->getController()->getDbService(SearchServiceInterface::class);
+        $row = $searchService->getSearchByIdAndOwner(
             $searchId,
             $this->session->getManager()->getId(),
             null
         );
         if (!empty($row)) {
-            $minSO = $row->getSearchObjectOrThrowException();
-            $search = $minSO->deminify($this->resultsManager);
+            $search = $row->getSearchObject()?->deminify($this->resultsManager);
+            if (!$search) {
+                throw new Exception("Problem getting search object from search {$row->getId()}.");
+            }
             // The saved search does not remember its original limit or sort;
             // we should reapply them from the session data:
             $search->getParams()->setLimit(

module/VuFind/src/VuFind/Controller/UpgradeController.php

@@ -346,16 +346,18 @@ protected function fixInvalidUserIdsInSearchTable(): void
     protected function fixSearchChecksumsInDatabase()
     {
         $manager = $this->serviceLocator->get(ResultsManager::class);
-        $search = $this->getTable('search');
-        $searchWhere = ['checksum' => null, 'saved' => 1];
-        $searchRows = $search->select($searchWhere);
+        $searchService = $this->getDbService(SearchServiceInterface::class);
+        $searchRows = $searchService->getSavedSearchesWithMissingChecksums();
         if (count($searchRows) > 0) {
             foreach ($searchRows as $searchRow) {
-                $searchObj = $searchRow->getSearchObjectOrThrowException()->deminify($manager);
+                $searchObj = $searchRow->getSearchObject()?->deminify($manager);
+                if (!$searchObj) {
+                    throw new Exception("Missing search data for row {$searchRow->getId()}.");
+                }
                 $url = $searchObj->getUrlQuery()->getParams();
                 $checksum = crc32($url) & 0xFFFFFFF;
-                $searchRow->checksum = $checksum;
-                $searchRow->save();
+                $searchRow->setChecksum($checksum);
+                $searchService->persistEntity($searchRow);
             }
             $this->session->warnings->append(
                 'Added checksum to ' . count($searchRows) . ' rows in search table'