Shopware\Core\Checkout\Promotion\Util\PromotionCodeService

Complexity

Total Complexity

22

Size/Duplication

Total Lines	183
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	getPreview()	0	3	1
A	getFixedCode()	0	5	1
A	splitPattern()	0	7	1
A	replaceIndividualCodes()	0	11	2
A	addIndividualCodes()	0	22	2
A	calculatePossibilites()	0	19	2
A	prepareCodeEntities()	0	8	1
A	generateIndividualCodes()	0	28	5
A	getRandomChar()	0	7	2
A	__construct()	0	4	1
A	resetPromotionCodes()	0	7	1
A	generateCode()	0	8	2
A	isCodePatternAlreadyInUse()	0	7	1

<?php declare(strict_types=1);

namespace Shopware\Core\Checkout\Promotion\Util;

use Shopware\Core\Checkout\Promotion\Exception\PatternAlreadyInUseException;
use Shopware\Core\Checkout\Promotion\Exception\PatternNotComplexEnoughException;
use Shopware\Core\Checkout\Promotion\PromotionEntity;
use Shopware\Core\Framework\Context;
use Shopware\Core\Framework\DataAbstractionLayer\EntityRepositoryInterface;
use Shopware\Core\Framework\DataAbstractionLayer\Search\Criteria;
use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\EqualsFilter;
use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\NotFilter;

class PromotionCodeService
{
    public const PROMOTION_PATTERN_REGEX = '/(?<prefix>[^%]*)(?<replacement>(%[sd])+)(?<suffix>.*)/';
    public const CODE_COMPLEXITY_FACTOR = 0.5;

    /**
     * @var EntityRepositoryInterface
     */
    private $individualCodesRepository;

    /**
     * @var EntityRepositoryInterface
     */
    private $promotionRepository;

    public function __construct(EntityRepositoryInterface $promotionRepository, EntityRepositoryInterface $individualCodesRepository)
    {
        $this->promotionRepository = $promotionRepository;
        $this->individualCodesRepository = $individualCodesRepository;
    }

    public function getFixedCode(): string
    {
        $pattern = \implode('', \array_fill(0, 4, '%s%d'));

        return $this->generateIndividualCodes($pattern, 1)[0];
    }

    public function getPreview(string $pattern): string
    {
        return $this->generateIndividualCodes($pattern, 1)[0];
    }

    /**
     * @throws PatternNotComplexEnoughException
     *
     * @return array<string>
     */
    public function generateIndividualCodes(string $pattern, int $amount, array $codeBlacklist = []): array
    {
        if ($amount < 1) {
            return [];
        }

        $codePattern = $this->splitPattern($pattern);
        $blacklistCount = \count($codeBlacklist);

        /*
         * This condition ensures a fundamental randomness to the generated codes in ratio to all possibilities, which
         * also minimizes the number of retries. Therefore, the CODE_COMPLEXITY_FACTOR is the worst-case-scenario
         * probability to find a new unique promotion code.
         */
        if ($this->calculatePossibilites($codePattern['replacementString']) * self::CODE_COMPLEXITY_FACTOR < ($amount + $blacklistCount)) {
            throw new PatternNotComplexEnoughException();
        }

        $codes = $codeBlacklist;
        do {
            $codes[] = $this->generateCode($codePattern);

            if (\count($codes) >= $amount + $blacklistCount) {
                $codes = \array_unique($codes);
            }
        } while (\count($codes) < $amount + $blacklistCount);

        return \array_diff($codes, $codeBlacklist);
    }

    public function addIndividualCodes(string $promotionId, int $amount, Context $context): void
    {
        $criteria = (new Criteria([$promotionId]))
            ->addAssociation('individualCodes');

        /** @var PromotionEntity $promotion */
        $promotion = $this->promotionRepository->search($criteria, $context)->first();

        if ($promotion->getIndividualCodes() === null) {
            $this->replaceIndividualCodes($promotionId, $promotion->getIndividualCodePattern(), $amount, $context);

            return;
        }

        $newCodes = $this->generateIndividualCodes(
            $promotion->getIndividualCodePattern(),
            $amount,
            $promotion->getIndividualCodes()->getCodeArray()
        );

        $codeEntries = $this->prepareCodeEntities($promotionId, $newCodes);
        $this->individualCodesRepository->upsert($codeEntries, $context);
    }

    /**
     * @throws PatternAlreadyInUseException
     */
    public function replaceIndividualCodes(string $promotionId, string $pattern, int $amount, Context $context): void
    {
        if ($this->isCodePatternAlreadyInUse($pattern, $promotionId, $context)) {
            throw new PatternAlreadyInUseException();
        }

        $codes = $this->generateIndividualCodes($pattern, $amount);
        $codeEntries = $this->prepareCodeEntities($promotionId, $codes);

        $this->resetPromotionCodes($promotionId, $context);
        $this->individualCodesRepository->upsert($codeEntries, $context);
    }

    public function resetPromotionCodes(string $promotionId, Context $context): void
    {
        $criteria = (new Criteria())
            ->addFilter(new EqualsFilter('promotionId', $promotionId));
        $deleteCodes = \array_values($this->individualCodesRepository->searchIds($criteria, $context)->getData());

        $this->individualCodesRepository->delete($deleteCodes, $context);
    }

    public function splitPattern(string $pattern): array
    {
        \preg_match(self::PROMOTION_PATTERN_REGEX, $pattern, $codePattern);
        $codePattern['replacementString'] = \str_replace('%', '', $codePattern['replacement']);
        $codePattern['replacementArray'] = \str_split($codePattern['replacementString']);

        return $codePattern;
    }

    public function isCodePatternAlreadyInUse(string $pattern, string $promotionId, Context $context): bool
    {
        $criteria = (new Criteria())
            ->addFilter(new NotFilter('AND', [new EqualsFilter('id', $promotionId)]))
            ->addFilter(new EqualsFilter('individualCodePattern', $pattern));

        return $this->promotionRepository->search($criteria, $context)->getTotal() > 0;
    }

    private function generateCode(array $codePattern): string
    {
        $code = '';
        foreach ($codePattern['replacementArray'] as $letter) {
            $code .= $this->getRandomChar($letter);
        }

        return $codePattern['prefix'] . $code . $codePattern['suffix'];
    }

    private function calculatePossibilites(string $pattern): int
    {
        /*
         * These counts describe the amount of possibilities in a single digit, depending on variable type:
         * - d: digits (0-9)
         * - s: letters (A-Z)
         */
        $possibilityCounts = [
            'd' => 10,
            's' => 26,
        ];
        $counts = \count_chars($pattern, 1);

        $result = 1;
        foreach ($counts as $key => $count) {
            $result *= $possibilityCounts[\chr($key)] ** $count;
        }

        return $result;
    }

    private function getRandomChar(string $type): string
    {
        if ($type === 'd') {
            return (string) \random_int(0, 9);
        }

        return \chr(\random_int(65, 90));
    }

    private function prepareCodeEntities(string $promotionId, array $codes): array
    {
        return \array_values(\array_map(static function ($code) use ($promotionId) {
            return [
                'promotionId' => $promotionId,
                'code' => $code,
            ];
        }, $codes));
    }
}