$this->debugPrint(
            "{$method}: {$baseUrl}?{$queryString}"
        );
 
        $this->client->resetParameters();
        if ($method == 'GET') {
            $baseUrl .= '?' . $queryString;
        } elseif ($method == 'POST') {
            $this->client->setRawBody(
                $queryString, 'application/x-www-form-urlencoded'
            );
        }
 
        $this->client->setHeaders($headers);
 
        // Send Request
        $this->client->setUri($baseUrl);
        $result = $this->client->setMethod($method)->send();
        if (!$result->isSuccess()) {
            throw new SerialsSolutions_Summon_Exception($result->getBody());
        }
        return $result->getBody();
    }
}
 

        }
        asort($query);
        $queryString = implode('&', $query);
 
        // Build Authorization Headers
        $headers = array(
            'Accept' => 'application/'.$this->responseType,
            'x-summon-date' => gmdate('D, d M Y H:i:s T'),
            'Host' => 'api.summon.serialssolutions.com'
        );
        $data = implode("\n", $headers) . "\n/$this->version/$service\n" .
            urldecode($queryString) . "\n";
        $hmacHash = $this->hmacsha1($this->apiKey, $data);
        $headers['Authorization'] = "Summon $this->apiId;$hmacHash";
        if ($this->sessionId) {
            $headers['x-summon-session-id'] = $this->sessionId;
        }
 
        // Send request
        $result = $this->httpRequest($baseUrl, $method, $queryString, $headers);
        if (!$raw) {
            // Process response
            $result = $this->process($result); 
        }
        return $result;
    }
 
    /**
     * Perform normalization and analysis of Summon return value.
     *
     * @param array $input The raw response from Summon
     *
     * @throws SerialsSolutions_Summon_Exception
     * @return array       The processed response from Summon
     */
    protected function process($input)
    {
        if ($this->responseType !== "json") {
            return $input;
        }

        // Query String Parameters
        $options = $query->getOptionsArray();
        $options['s.role'] = $this->authedUser ? 'authenticated' : 'none';
 
        // Special case -- if user filtered down to newspapers AND excluded them,
        // we can't possibly have any results:
        if (isset($options['s.fvf']) && is_array($options['s.fvf'])
            && in_array('ContentType,Newspaper Article,true', $options['s.fvf'])
            && in_array('ContentType,Newspaper Article', $options['s.fvf'])
        ) {
            return array(
                'recordCount' => 0,
                'documents' => array()
            );
        }
 
        $this->debugPrint('Query: ' . print_r($options, true));
 
        try {
            $result = $this->call($options, 'search', 'GET', $raw);
        } catch (SerialsSolutions_Summon_Exception $e) {
            if ($returnErr) {
                return array(
                    'recordCount' => 0,
                    'documents' => array(),
                    'errors' => $e->getMessage()
                );
            } else {
                $this->handleFatalError($e);
            }
        }
 
        return $result;
    }
 
    /**
     * Submit REST Request
     *
     * @param array  $params  An array of parameters for the request
     * @param string $service The API Service to call

     *
     * @return RecordCollectionInterface
     */
    public function search(
        AbstractQuery $query,
        $offset,
        $limit,
        ParamBag $params = null
    ) {
        $baseParams = $this->getQueryBuilder()->build($query);
        if (null !== $params) {
            $baseParams->mergeWith($params);
        }
        $baseParams->set('pageSize', $limit);
        $page = $limit > 0 ? floor($offset / $limit) + 1 : 1;
        $baseParams->set('pageNumber', $page);
 
        $summonQuery = $this->paramBagToSummonQuery($baseParams);
        try {
            $response = $this->connector->query($summonQuery);
        } catch (SummonException $e) {
            throw new BackendException(
                $e->getMessage(),
                $e->getCode(),
                $e
            );
        }
        $collection = $this->createRecordCollection($response);
        $this->injectSourceIdentifier($collection);
        return $collection;
    }
 
    /**
     * Retrieve a single document.
     *
     * @param string   $id     Document identifier
     * @param ParamBag $params Search backend parameters
     *
     * @return RecordCollectionInterface
     * @throws RecordMissingException

     *
     * @return CommandInterface Command instance for method chaining
     */
    public function execute(BackendInterface $backend): CommandInterface
    {
        $this->validateBackend($backend);
        if (
            !($backend instanceof $this->interface)
            || !method_exists($this->interface, $this->method)
        ) {
            throw new BackendException(
                "$this->backendId does not support $this->method()"
            );
        }
        $args = $this->getArguments();
        if ($backend instanceof ExtraRequestDetailsInterface) {
            $backend->resetExtraRequestDetails();
        }
        $this->finalizeExecution(
            call_user_func([$backend, $this->method], ...$args)
        );
        if ($backend instanceof ExtraRequestDetailsInterface) {
            $this->extraRequestDetails = $backend->getExtraRequestDetails();
        }
        return $this;
    }
}
 

     *
     * @return CommandInterface Command instance for method chaining
     */
    public function execute(BackendInterface $backend): CommandInterface
    {
        $this->validateBackend($backend);
        if (
            !($backend instanceof $this->interface)
            || !method_exists($this->interface, $this->method)
        ) {
            throw new BackendException(
                "$this->backendId does not support $this->method()"
            );
        }
        $args = $this->getArguments();
        if ($backend instanceof ExtraRequestDetailsInterface) {
            $backend->resetExtraRequestDetails();
        }
        $this->finalizeExecution(
            call_user_func([$backend, $this->method], ...$args)
        );
        if ($backend instanceof ExtraRequestDetailsInterface) {
            $this->extraRequestDetails = $backend->getExtraRequestDetails();
        }
        return $this;
    }
}
 

    }
 
    /**
     * Invoke a command.
     *
     * @param CommandInterface $command Command
     *
     * @return CommandInterface
     */
    public function invoke(CommandInterface $command)
    {
        // The backend instance is no longer added as an event parameter.
        // All other legacy event parameters are accessible via the command object.
        $args = ['command' => $command];
 
        $backend = $this->resolve($command->getTargetIdentifier(), $args);
 
        $this->triggerPre($this, $args);
        try {
            $command->execute($backend);
        } catch (BackendException $e) {
            $args['error'] = $e;
            $this->triggerError($this, $args);
            throw $e;
        }
        $this->triggerPost($this, $args);
 
        return $command;
    }
 
    /**
     * Resolve a backend.
     *
     * @param string            $backendId Backend name
     * @param array|ArrayAccess $args      Service function arguments
     *
     * @return BackendInterface
     *
     * @throws Exception\RuntimeException Unable to resolve backend
     */

     * Support method for performAndProcessSearch -- perform a search based on the
     * parameters passed to the object.
     *
     * @return void
     */
    protected function performSearch()
    {
        $query  = $this->getParams()->getQuery();
        $limit  = $this->getParams()->getLimit();
        $offset = $this->getStartRecord() - 1;
        $params = $this->getParams()->getBackendParameters();
        $command = new SearchCommand(
            $this->backendId,
            $query,
            $offset,
            $limit,
            $params
        );
        $collection = $this->getSearchService()
            ->invoke($command)->getResult();
        $this->responseFacets = $collection->getFacets();
        $this->resultTotal = $collection->getTotal();
 
        // Process spelling suggestions if enabled (note that we need this
        // check here because sometimes the Summon API returns suggestions
        // even when the spelling parameter is set to false).
        if ($this->getOptions()->spellcheckEnabled()) {
            $spellcheck = $collection->getSpellcheck();
            $this->processSpelling($spellcheck);
        }
 
        // Get best bets and database recommendations.
        $this->bestBets = $collection->getBestBets();
        $this->databaseRecommendations = $collection->getDatabaseRecommendations();
        $this->topicRecommendations = $collection->getTopicRecommendations();
 
        // Add fake date facets if flagged earlier; this is necessary in order
        // to display the date range facet control in the interface.
        $dateFacets = $this->getParams()->getDateFacetSettings();
        if (!empty($dateFacets)) {

    }
 
    /**
     * Actually execute the search.
     *
     * @return void
     */
    public function performAndProcessSearch()
    {
        // Initialize variables to defaults (to ensure they don't stay null
        // and cause unnecessary repeat processing):
        // The value of -1 indicates that resultTotal is not available.
        $this->resultTotal = -1;
        $this->results = [];
        $this->suggestions = [];
        $this->errors = [];
 
        // Run the search:
        $this->startQueryTimer();
        $this->performSearch();
        $this->stopQueryTimer();
    }
 
    /**
     * Returns the stored list of facets for the last search
     *
     * @param array $filter Array of field => on-screen description listing
     * all of the desired facet fields; set to null to get all configured values.
     *
     * @return array        Facets data arrays
     */
    abstract public function getFacetList($filter = null);
 
    /**
     * Abstract support method for performAndProcessSearch -- perform a search based
     * on the parameters passed to the object. This method is responsible for
     * filling in all of the key class properties: results, resultTotal, etc.
     *
     * @return void
     */

        $params->setLastView($lastView);
        $params->initFromRequest($request);
 
        if (is_callable($setupCallback)) {
            $setupCallback($this, $params, $runningSearchId);
        }
 
        // Trigger the "configuration done" event.
        $this->getEventManager()->trigger(
            self::EVENT_CONFIGURED,
            $this,
            compact('params', 'request', 'runningSearchId')
        );
 
        // Attempt to perform the search; if there is a problem, inspect any Solr
        // exceptions to see if we should communicate to the user about them.
        try {
            // Explicitly execute search within controller -- this allows us to
            // catch exceptions more reliably:
            $results->performAndProcessSearch();
        } catch (\VuFindSearch\Backend\Exception\BackendException $e) {
            if ($e->hasTag(ErrorListener::TAG_PARSER_ERROR)) {
                // We need to create and process an "empty results" object to
                // ensure that recommendation modules and templates behave
                // properly when displaying the error message.
                $results = $this->resultsManager->get('EmptySet');
                $results->setParams($params);
                $results->performAndProcessSearch();
            } else {
                throw $e;
            }
        }
 
        // Trigger the "search completed" event.
        $this->getEventManager()->trigger(
            self::EVENT_COMPLETE,
            $this,
            compact('results', 'runningSearchId')
        );
 

        $view->multiFacetsSelection = (bool)($config->Results_Settings->multiFacetsSelection ?? false);
        $extraErrors = [];
 
        // Handle saved search requests:
        $savedId = $this->params()->fromQuery('saved', false);
        if ($savedId !== false) {
            return $this->redirectToSavedSearch($savedId);
        }
 
        $runner = $this->getService(\VuFind\Search\SearchRunner::class);
 
        // Send both GET and POST variables to search class:
        $request = $this->getRequest()->getQuery()->toArray()
            + $this->getRequest()->getPost()->toArray();
        $view->request = $request;
 
        $lastView = $this->getSearchMemory()
            ->retrieveLastSetting($this->searchClassId, 'view');
        try {
            $view->results = $results = $runner->run(
                $request,
                $this->searchClassId,
                $setupCallback ?: $this->getSearchSetupCallback(),
                $lastView
            );
        } catch (\VuFindSearch\Backend\Exception\DeepPagingException $e) {
            return $this->redirectToLegalSearchPage($request, $e->getLegalPage());
        }
        $view->params = $params = $results->getParams();
 
        // For page parameter being out of results list, we want to redirect to correct page
        $page = $params->getPage();
        $totalResults = $results->getResultTotal();
        $limit = $params->getLimit();
        $lastPage = $limit ? ceil($totalResults / $limit) : 1;
        if ($totalResults > 0 && $page > $lastPage) {
            $queryParams = $request;
            $queryParams['page'] = $lastPage;
            return $this->redirect()->toRoute('search-results', [], [ 'query' => $queryParams ]);
        }

            throw new \Exception('Unrecoverable deep paging error.');
        }
        $request['page'] = $page;
        $this->flashMessenger()->addErrorMessage(
            [
                'msg' => 'deep_paging_failure',
                'tokens' => ['%%page%%' => $page],
            ]
        );
        return $this->redirect()->toUrl('?' . http_build_query($request));
    }
 
    /**
     * Send search results to results view
     *
     * @return Response|ViewModel
     */
    public function resultsAction()
    {
        return $this->getSearchResultsView();
    }
 
    /**
     * Support method for getSearchResultsView() -- return the search results
     * reformatted as an RSS feed.
     *
     * @param $view ViewModel View model
     *
     * @return Response
     */
    protected function getRssSearchResponse(ViewModel $view): Response
    {
        // Build the RSS feed:
        $feedHelper = $this->getViewRenderer()->plugin('resultfeed');
        $feed = $feedHelper($view->results);
        $writer = new \Laminas\Feed\Writer\Renderer\Feed\Rss($feed);
        $writer->render();
 
        // Apply XSLT if we can find a relevant file:
        $themeInfo = $this->getService(\VuFindTheme\ThemeInfo::class);

        if (isset($specialFacets['checkboxes'])) {
            $view->checkboxFacets = $this->processAdvancedCheckboxes(
                $specialFacets['checkboxes'],
                $view->saved
            );
        }
        $view->ranges = $this
            ->getAllRangeSettings($specialFacets, $view->saved, 'Summon');
 
        return $view;
    }
 
    /**
     * Search action -- call standard results action
     *
     * @return mixed
     */
    public function searchAction()
    {
        return $this->resultsAction();
    }
 
    /**
     * Process the facets to be used as limits on the Advanced Search screen.
     *
     * @param array  $facetList    The advanced facet values
     * @param object $searchObject Saved search object (false if none)
     *
     * @return array               Sorted facets, with selected values flagged.
     */
    protected function processAdvancedFacets($facetList, $searchObject = false)
    {
        // Process the facets, assuming they came back
        foreach ($facetList as $facet => $list) {
            foreach ($list['list'] as $key => $value) {
                // Build the filter string for the URL:
                $fullFilter = ($value['operator'] == 'OR' ? '~' : '')
                    . $facet . ':"' . $value['value'] . '"';
 
                // If we haven't already found a selected facet and the current

     */
    public function onDispatch(MvcEvent $e)
    {
        $routeMatch = $e->getRouteMatch();
        if (! $routeMatch) {
            /**
             * @todo Determine requirements for when route match is missing.
             *       Potentially allow pulling directly from request metadata?
             */
            throw new DomainException('Missing route matches; unsure how to retrieve action');
        }
 
        $action = $routeMatch->getParam('action', 'not-found');
        $method = static::getMethodFromAction($action);
 
        if (! method_exists($this, $method)) {
            $method = 'notFoundAction';
        }
 
        $actionResponse = $this->$method();
 
        $e->setResult($actionResponse);
 
        return $actionResponse;
    }
}
 

        }
 
        if ($this->sharedManager) {
            foreach ($this->sharedManager->getListeners($this->identifiers, $name) as $priority => $listeners) {
                $listOfListenersByPriority[$priority][] = $listeners;
            }
        }
 
        // Sort by priority in reverse order
        krsort($listOfListenersByPriority);
 
        // Initial value of stop propagation flag should be false
        $event->stopPropagation(false);
 
        // Execute listeners
        $responses = new ResponseCollection();
        foreach ($listOfListenersByPriority as $listOfListeners) {
            foreach ($listOfListeners as $listeners) {
                foreach ($listeners as $listener) {
                    $response = $listener($event);
                    $responses->push($response);
 
                    // If the event was asked to stop propagating, do so
                    if ($event->propagationIsStopped()) {
                        $responses->setStopped(true);
                        return $responses;
                    }
 
                    // If the result causes our validation callback to return true,
                    // stop propagation
                    if ($callback && $callback($response)) {
                        $responses->setStopped(true);
                        return $responses;
                    }
                }
            }
        }
 
        return $responses;
    }

            $event->setParams($argv);
        }
 
        return $this->triggerListeners($event, $callback);
    }
 
    /**
     * @inheritDoc
     */
    public function triggerEvent(EventInterface $event)
    {
        return $this->triggerListeners($event);
    }
 
    /**
     * @inheritDoc
     */
    public function triggerEventUntil(callable $callback, EventInterface $event)
    {
        return $this->triggerListeners($event, $callback);
    }
 
    /**
     * @inheritDoc
     */
    public function attach($eventName, callable $listener, $priority = 1)
    {
        if (! is_string($eventName)) {
            throw new Exception\InvalidArgumentException(sprintf(
                '%s expects a string for the event; received %s',
                __METHOD__,
                get_debug_type($eventName),
            ));
        }
 
        $this->events[$eventName][(int) $priority][0][] = $listener;
        return $listener;
    }
 
    /**

     * @events dispatch.pre, dispatch.post
     * @param  Request $request
     * @param  null|Response $response
     * @return Response|mixed
     */
    public function dispatch(Request $request, Response $response = null)
    {
        $this->request = $request;
        if (! $response) {
            $response = new HttpResponse();
        }
        $this->response = $response;
 
        $e = $this->getEvent();
        $e->setName(MvcEvent::EVENT_DISPATCH);
        $e->setRequest($request);
        $e->setResponse($response);
        $e->setTarget($this);
 
        $result = $this->getEventManager()->triggerEventUntil(static fn($test): bool => $test instanceof Response, $e);
 
        if ($result->stopped()) {
            return $result->last();
        }
 
        return $e->getResult();
    }
 
    /**
     * Get request object
     *
     * @return Request
     */
    public function getRequest()
    {
        if (! $this->request) {
            $this->request = new HttpRequest();
        }
 
        return $this->request;

            );
            return $this->complete($return, $e);
        } catch (Throwable $exception) {
            $return = $this->marshalBadControllerEvent($controllerName, $e, $application, $exception);
            return $this->complete($return, $e);
        } catch (Exception $exception) {  // @TODO clean up once PHP 7 requirement is enforced
            $return = $this->marshalBadControllerEvent($controllerName, $e, $application, $exception);
            return $this->complete($return, $e);
        }
 
        if ($controller instanceof InjectApplicationEventInterface) {
            $controller->setEvent($e);
        }
 
        $request  = $e->getRequest();
        $response = $application->getResponse();
        $caughtException = null;
 
        try {
            $return = $controller->dispatch($request, $response);
        } catch (Throwable $ex) {
            $caughtException = $ex;
        } catch (Exception $ex) {  // @TODO clean up once PHP 7 requirement is enforced
            $caughtException = $ex;
        }
 
        if ($caughtException !== null) {
            $e->setName(MvcEvent::EVENT_DISPATCH_ERROR);
            $e->setError($application::ERROR_EXCEPTION);
            $e->setController($controllerName);
            $e->setControllerClass($controller::class);
            $e->setParam('exception', $caughtException);
 
            $return = $application->getEventManager()->triggerEvent($e)->last();
            if (! $return) {
                $return = $e->getResult();
            }
        }
 
        return $this->complete($return, $e);

        }
 
        if ($this->sharedManager) {
            foreach ($this->sharedManager->getListeners($this->identifiers, $name) as $priority => $listeners) {
                $listOfListenersByPriority[$priority][] = $listeners;
            }
        }
 
        // Sort by priority in reverse order
        krsort($listOfListenersByPriority);
 
        // Initial value of stop propagation flag should be false
        $event->stopPropagation(false);
 
        // Execute listeners
        $responses = new ResponseCollection();
        foreach ($listOfListenersByPriority as $listOfListeners) {
            foreach ($listOfListeners as $listeners) {
                foreach ($listeners as $listener) {
                    $response = $listener($event);
                    $responses->push($response);
 
                    // If the event was asked to stop propagating, do so
                    if ($event->propagationIsStopped()) {
                        $responses->setStopped(true);
                        return $responses;
                    }
 
                    // If the result causes our validation callback to return true,
                    // stop propagation
                    if ($callback && $callback($response)) {
                        $responses->setStopped(true);
                        return $responses;
                    }
                }
            }
        }
 
        return $responses;
    }

            $event->setParams($argv);
        }
 
        return $this->triggerListeners($event, $callback);
    }
 
    /**
     * @inheritDoc
     */
    public function triggerEvent(EventInterface $event)
    {
        return $this->triggerListeners($event);
    }
 
    /**
     * @inheritDoc
     */
    public function triggerEventUntil(callable $callback, EventInterface $event)
    {
        return $this->triggerListeners($event, $callback);
    }
 
    /**
     * @inheritDoc
     */
    public function attach($eventName, callable $listener, $priority = 1)
    {
        if (! is_string($eventName)) {
            throw new Exception\InvalidArgumentException(sprintf(
                '%s expects a string for the event; received %s',
                __METHOD__,
                get_debug_type($eventName),
            ));
        }
 
        $this->events[$eventName][(int) $priority][0][] = $listener;
        return $listener;
    }
 
    /**

            $response = $result->last();
            if ($response instanceof ResponseInterface) {
                $event->setName(MvcEvent::EVENT_FINISH);
                $event->setTarget($this);
                $event->setResponse($response);
                $event->stopPropagation(false); // Clear before triggering
                $events->triggerEvent($event);
                $this->response = $response;
                return $this;
            }
        }
 
        if ($event->getError()) {
            return $this->completeRequest($event);
        }
 
        // Trigger dispatch event
        $event->setName(MvcEvent::EVENT_DISPATCH);
        $event->stopPropagation(false); // Clear before triggering
        $result = $events->triggerEventUntil($shortCircuit, $event);
 
        // Complete response
        $response = $result->last();
        if ($response instanceof ResponseInterface) {
            $event->setName(MvcEvent::EVENT_FINISH);
            $event->setTarget($this);
            $event->setResponse($response);
            $event->stopPropagation(false); // Clear before triggering
            $events->triggerEvent($event);
            $this->response = $response;
            return $this;
        }
 
        $response = $this->response;
        $event->setResponse($response);
        return $this->completeRequest($event);
    }
 
    /**
     * Complete the request

$vufindProfiler = getenv('VUFIND_PROFILER_XHPROF');
if (!empty($vufindProfiler)) {
    include __DIR__ . '/../module/VuFind/functions/profiler.php';
    enableVuFindProfiling($vufindProfiler);
}
 
// Run the application!
$app = include __DIR__ . '/../config/application.php';
if (PHP_SAPI === 'cli') {
    return $app->getServiceManager()
        ->get(\VuFindConsole\ConsoleRunner::class)->run();
} else {
    // Setup remote code coverage if enabled:
    if (getenv('VUFIND_CODE_COVERAGE')) {
        $modules = $app->getServiceManager()
            ->get(\Laminas\ModuleManager\ModuleManager::class)->getModules();
        include __DIR__ . '/../module/VuFind/functions/codecoverage.php';
        setupVuFindRemoteCodeCoverage($modules);
    }
    $app->run();
}