SynonymGroupRepository.php

Go to the documentation of this file.

<?php
namespace Magento\Search\Model;

use Magento\Framework\Exception\CouldNotDeleteException;
use Magento\Search\Api\Data\SynonymGroupInterface;
use Magento\Search\Api\SynonymGroupRepositoryInterface;
use Magento\Search\Model\ResourceModel\SynonymGroup as SynonymGroupResourceModel;

class SynonymGroupRepository implements SynonymGroupRepositoryInterface
{
    protected $synonymGroupFactory;

    protected $resourceModel;

    public function __construct(
        \Magento\Search\Model\SynonymGroupFactory $synonymGroupFactory,
        SynonymGroupResourceModel $resourceModel
    ) {
        $this->synonymGroupFactory = $synonymGroupFactory;
        $this->resourceModel = $resourceModel;
    }

    public function save(SynonymGroupInterface $synonymGroup, $errorOnMergeConflict = false)
    {
        $synonymGroupModel = $this->synonymGroupFactory->create();
        $synonymGroupModel->load($synonymGroup->getGroupId());
        $isCreate = $synonymGroupModel->getSynonymGroup() === null;
        if ($isCreate) {
            return $this->create($synonymGroup, $errorOnMergeConflict);
        } else {
            return $this->update($synonymGroupModel, $synonymGroup, $errorOnMergeConflict);
        }
    }

    public function delete(SynonymGroupInterface $synonymGroup)
    {
        try {
            $this->resourceModel->delete($synonymGroup);
        } catch (\Exception $exception) {
            throw new CouldNotDeleteException(
                __(
                    'The synonym group with the "%1" ID can\'t be deleted. %2',
                    $synonymGroup->getGroupId(),
                    $exception->getMessage()
                )
            );
        }
        return true;
    }

    public function get($synonymGroupId)
    {
        $synonymGroup = $this->synonymGroupFactory->create();
        if ($synonymGroupId !== null) {
            $synonymGroup->load($synonymGroupId);
        }
        return $synonymGroup;
    }

    private function create(SynonymGroupInterface $synonymGroup, $errorOnMergeConflict)
    {
        $matchingSynonymGroups = $this->getMatchingSynonymGroups($synonymGroup);
        if ($matchingSynonymGroups) {
            if ($errorOnMergeConflict) {
                throw new Synonym\MergeConflictException(
                    $this->parseToArray($matchingSynonymGroups),
                    $this->getExceptionMessage($matchingSynonymGroups)
                );
            }
            // merge matching synonyms before creating a new row
            $mergedSynonyms = $this->merge($synonymGroup, array_keys($matchingSynonymGroups));
            $newSynonymGroupModel = $this->synonymGroupFactory->create();
            $newSynonymGroupModel->setSynonymGroup(implode(',', $mergedSynonyms));
            $newSynonymGroupModel->setWebsiteId($synonymGroup->getWebsiteId());
            $newSynonymGroupModel->setStoreId($synonymGroup->getStoreId());
            $this->resourceModel->save($newSynonymGroupModel);
            $synonymGroup->setSynonymGroup($newSynonymGroupModel->getSynonymGroup());
            $synonymGroup->setGroupId($newSynonymGroupModel->getGroupId());
        } else {
            // no merge conflict, perform simple insert
            $synonymGroupModel = $this->synonymGroupFactory->create();
            $this->populateSynonymGroupModel($synonymGroupModel, $synonymGroup);
            $this->resourceModel->save($synonymGroupModel);
            $synonymGroup->setGroupId($synonymGroupModel->getGroupId());
        }
        return $synonymGroup;
    }

    private function merge(SynonymGroupInterface $synonymGroupToMerge, array $matchingGroupIds)
    {
        $mergedSynonyms = [];
        foreach ($matchingGroupIds as $groupId) {
            $synonymGroupModel = $this->synonymGroupFactory->create();
            $synonymGroupModel->load($groupId);
            $mergedSynonyms = array_merge($mergedSynonyms, explode(',', $synonymGroupModel->getSynonymGroup()));
            $synonymGroupModel->delete();
        }
        $mergedSynonyms = array_merge($mergedSynonyms, explode(',', $synonymGroupToMerge->getSynonymGroup()));
        $mergedSynonyms = array_unique($mergedSynonyms);
        return $mergedSynonyms;
    }

    private function populateSynonymGroupModel(SynonymGroup $modelToPopulate, SynonymGroupInterface $synonymGroupData)
    {
        $modelToPopulate->setWebsiteId($synonymGroupData->getWebsiteId());
        $modelToPopulate->setStoreId($synonymGroupData->getStoreId());
        $modelToPopulate->setSynonymGroup($synonymGroupData->getSynonymGroup());
    }

    private function update(
        SynonymGroup $oldSynonymGroup,
        SynonymGroupInterface $newSynonymGroup,
        $errorOnMergeConflict
    ) {
        $matchingSynonymGroups = $this->getMatchingSynonymGroups($newSynonymGroup);
        // ignore existing synonym group as it's value will be discarded
        $matchingSynonymGroups = array_diff_key(
            $matchingSynonymGroups,
            [$oldSynonymGroup->getGroupId() => $oldSynonymGroup->getSynonymGroup()]
        );
        if ($matchingSynonymGroups) {
            if ($errorOnMergeConflict) {
                throw new Synonym\MergeConflictException(
                    $this->parseToArray($matchingSynonymGroups),
                    $this->getExceptionMessage($matchingSynonymGroups)
                );
            }
            // merge matching synonyms before updating a row
            $mergedSynonyms = $this->merge($newSynonymGroup, array_keys($matchingSynonymGroups));
            $oldSynonymGroup->setSynonymGroup(implode(',', $mergedSynonyms));
            $oldSynonymGroup->setWebsiteId($newSynonymGroup->getWebsiteId());
            $oldSynonymGroup->setStoreId($newSynonymGroup->getStoreId());
            $this->resourceModel->save($oldSynonymGroup);
        } else {
            // no merge conflict, perform simple update
            $this->populateSynonymGroupModel($oldSynonymGroup, $newSynonymGroup);
            $this->resourceModel->save($oldSynonymGroup);
        }
        return $oldSynonymGroup;
    }

    private function getExceptionMessage($matchingSynonymGroups)
    {
        $displayString = '(';
        $displayString .= implode('), (', $matchingSynonymGroups);
        $displayString .= ')';
        return __('Merge conflict with existing synonym group(s): %1', $displayString);
    }

    private function parseToArray($matchingSynonymGroups)
    {
        $parsedArray = [];
        foreach ($matchingSynonymGroups as $matchingSynonymGroup) {
            $parsedArray[] = explode(',', $matchingSynonymGroup);
        }
        return $parsedArray;
    }

    private function getMatchingSynonymGroups(SynonymGroupInterface $synonymGroup)
    {
        $synonymGroupsInScope = $this->resourceModel->getByScope(
            $synonymGroup->getWebsiteId(),
            $synonymGroup->getStoreId()
        );
        $matchingSynonymGroups = [];
        foreach ($synonymGroupsInScope as $synonymGroupInScope) {
            if (array_intersect(
                explode(',', $synonymGroup->getSynonymGroup()),
                explode(',', $synonymGroupInScope['synonyms'])
            )) {
                $matchingSynonymGroups[$synonymGroupInScope['group_id']] = $synonymGroupInScope['synonyms'];
            }
        }
        return $matchingSynonymGroups;
    }
}