bundles/Devkitchen/DocumentIndexingBundle/src/ElasticSearchService/ElasticSearchService.php line 119

Open in your IDE?
  1. <?php
  2.     /**
  3.      * project: Pimcore - SNR
  4.      * User: erikb
  5.      * Year: 2022
  6.      */
  8.     namespace Devkitchen\DocumentIndexingBundle\ElasticSearchService;
  10.     use Devkitchen\DocumentIndexingBundle\DataExtractorService\DataExtractorService;
  11.     use Devkitchen\DocumentIndexingBundle\DataExtractorService\DocumentTypeHandler\DocumentTypeHandlerInterface;
  12.     use Devkitchen\DocumentIndexingBundle\Logger\LoggerInterface;
  13.     use Elastic\Elasticsearch\Client;
  14.     use Elastic\Elasticsearch\ClientBuilder;
  15.     use Elastic\Elasticsearch\Exception\ClientResponseException;
  16.     use Elastic\Elasticsearch\Exception\ElasticsearchException;
  17.     use Elastic\Elasticsearch\Exception\MissingParameterException;
  18.     use Elastic\Elasticsearch\Exception\ServerResponseException;
  19.     use Elastic\Elasticsearch\Response\Elasticsearch;
  20.     use Elastic\Transport\Exception\NotFoundException;
  21.     use Http\Promise\Promise;
  22.     use Symfony\Component\HttpFoundation\RequestStack;
  24.     class ElasticSearchService {
  26.         /** @var array  */
  27.         protected array $hosts;
  28.         /** @var string  */
  29.         protected string $index;
  30.         /** @var string  */
  31.         protected string $user;
  32.         /** @var string  */
  33.         protected string $password;
  35.         /** @var Client $esClient */
  36.         protected Client $esClient;
  38.         /** @var LoggerInterface $logger */
  39.         protected LoggerInterface $logger;
  41.         /** @var RequestStack  */
  42.         protected RequestStack $requestStack;
  44.         /** @var string $language */
  45.         protected string $language;
  46.         /** @var string $documentType */
  47.         protected string $documentType = 'default';
  49.         public function __construct(array $hosts, string $index, string $user, string $password, LoggerInterface $logger, RequestStack $requestStack) {
  50.             $this->hosts = $hosts;
  51.             $this->index = $index;
  52.             $this->user = $user;
  53.             $this->password = $password;
  54.             $this->logger = $logger;
  55.             $this->requestStack = $requestStack;
  57.             $this->esClient = ClientBuilder::create()
  58.                             ->setHttpClient( new \GuzzleHttp\Client(['verify' => false]))
  59.                             ->setSSLVerification(false)
  60.                             ->setHosts( $this->hosts )
  61.                                             ->setBasicAuthentication( $this->user, $this->password )
  62.                                             ->build();
  64.         }
  66.         /**
  67.          * @param DataExtractorService $dataService
  68.          *
  69.          * @return mixed
  70.          */
  71.         public function delete(DataExtractorService $dataService) : mixed {
  72.             $params = [
  73.                 'index' => $this->index. '.' . $dataService->getElasticIndex() .'.' . $dataService->getLanguage(),
  74.                 'id' => $dataService->getId()
  75.             ];
  77.             try {
  78.                 return $this->esClient->delete($params);
  79.             }
  80.             catch (ServerResponseException $serverResponseException) {
  81.                 return $this->_handleErrors( $serverResponseException );
  82.             }
  83.             catch (ClientResponseException $clientResponseException) {
  84.                 return $this->_handleErrors( $clientResponseException );
  85.             }
  86.         }
  88.         /**
  89.          * @param DataExtractorService $dataService
  90.          *
  91.          * @return mixed
  92.          */
  93.         public function add(DataExtractorService $dataService) : mixed {
  94.             $params = [
  95.                 'index' => $this->index. '.' . $dataService->getElasticIndex() .'.' . $dataService->getLanguage(),
  96.                 'id' => $dataService->getId(),
  97.                 'body' => $dataService->getElasticSearchData()
  98.             ];
  100.             try {
  101.                 return $this->esClient->index( $params );
  102.             }
  103.             catch (ServerResponseException $serverResponseException) {
  104.                 return $this->_handleErrors( $serverResponseException );
  105.             }
  106.             catch (ClientResponseException $clientResponseException) {
  107.                 return $this->_handleErrors( $clientResponseException);
  108.             }
  109.         }
  111.         /**
  112.          * @param array  $query
  113.          * @param string $documentIndexName
  114.          * @param int    $from
  115.          * @param int    $size
  116.          *
  117.          * @return mixed
  118.          */
  119.         public function search(array $query, int $from = 0, int $size = 1000) : mixed {
  120.             $params = [
  121.                 'index' => $this->_buildIndexName(),
  122.                 'body' => $query,
  123.                 'from' => $from,
  124.                 'size' => $size
  125.             ];
  127.             try {
  128.                 return $this->esClient->search($params);
  129.             }
  130.             catch (ServerResponseException $serverResponseException) {
  131.                 return $this->_handleErrors( $serverResponseException );
  132.             }
  133.             catch (ClientResponseException $clientResponseException) {
  134.                 return $this->_handleErrors( $clientResponseException);
  135.             }
  136.         }
  138.         /**
  139.          * @return string
  140.          */
  141.         private function _buildIndexName() : string {
  142.             return $this->index. '.' . $this->documentType. '.' .$this->language;
  143.         }
  145.         /**
  146.          * @param $exception
  147.          *
  148.          * @return mixed
  149.          */
  150.         private function _handleErrors($exception) : mixed {
  151.             $message = $exception->getFile(). ' : '.$exception->getLine().' : '.$exception->getMessage();
  152.             $this->logger->log( 'error', $message);
  154.             return $exception->getResponse();
  155.         }
  157.         /**
  158.          * @param mixed $language
  159.          *
  160.          * @return ElasticSearchService
  161.          */
  162.         public function setLanguage( mixed $language = null): ElasticSearchService {
  163.             if ($language === null && $this->requestStack) {
  164.                 $language = $this->requestStack->getCurrentRequest()->getLocale();
  165.             }
  167.             if ($language == '') {
  168.                 $language = 'de';
  169.             }
  170.             
  171.             $this->language = $language;
  172.             return $this;
  173.         }
  175.         /**
  176.          * @param string $documentType
  177.          *
  178.          * @return ElasticSearchService
  179.          */
  180.         public function setDocumentType( string $documentType ): ElasticSearchService {
  181.             $this->documentType = $documentType;
  182.             return $this;
  183.         }
  186.     }