Sylius\Behat\Context\Setup\ShippingContext

Complexity

Total Complexity

24

Size/Duplication

Total Lines	282
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	8

Importance

Changes

0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	15	1
A	storeShipsEverythingForFree()	0	4	1
A	theStoreShipsEverywhereForFree()	0	6	2
A	theStoreAllowsShippingMethod()	0	4	1
A	thisShippingMethodIsNamedInLocale()	0	11	1
A	theStoreAllowsShippingWithAnd()	0	5	1
A	storeHasShippingMethodWithFee()	0	4	1
A	storeHasDisabledShippingMethodWithFee()	0	4	1
A	theStoreHasShippingMethodWithFeePerUnit()	0	4	1
A	theStoreHasShippingMethodWithFeeOnFistUnitAndOnNext()	0	12	1
A	storeHasShippingMethodWithFeeNotAssignedToAnyChannel()	0	4	1
A	shippingMethodBelongsToTaxCategory()	0	5	1
A	theShippingMethodIsEnabled()	0	5	1
A	theShippingMethodIsDisabled()	0	5	1
A	thisShippingMethodRequiresAtLeastOneUnitMatchToShippingCategory()	0	8	1
A	thisShippingMethodRequiresThatAllUnitsMatchToShippingCategory()	0	8	1
A	thisShippingMethodRequiresThatNoUnitsMatchToShippingCategory()	0	8	1
B	createShippingMethod()	0	37	5
A	generateCodeFromNameAndZone()	0	4	1

<?php

/*
 * This file is part of the Sylius package.
 *
 * (c) Paweł Jędrzejewski
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Sylius\Behat\Context\Setup;

use Behat\Behat\Context\Context;
use Doctrine\Common\Persistence\ObjectManager;
use Sylius\Behat\Service\SharedStorageInterface;
use Sylius\Component\Addressing\Model\ZoneInterface;
use Sylius\Component\Addressing\Repository\ZoneRepositoryInterface;
use Sylius\Component\Core\Formatter\StringInflector;
use Sylius\Component\Core\Model\ChannelInterface;
use Sylius\Component\Core\Model\ShippingMethodInterface;
use Sylius\Component\Resource\Factory\FactoryInterface;
use Sylius\Component\Shipping\Calculator\DefaultCalculators;
use Sylius\Component\Shipping\Model\ShippingCategoryInterface;
use Sylius\Component\Shipping\Model\ShippingMethodTranslationInterface;
use Sylius\Component\Shipping\Repository\ShippingMethodRepositoryInterface;
use Sylius\Component\Taxation\Model\TaxCategoryInterface;

/**
 * @author Arkadiusz Krakowiak <arkadiusz.krakowiak@lakion.com>
 */
final class ShippingContext implements Context
{
    /**
     * @var SharedStorageInterface
     */
    private $sharedStorage;

    /**
     * @var ShippingMethodRepositoryInterface
     */
    private $shippingMethodRepository;

    /**
     * @var ZoneRepositoryInterface
     */
    private $zoneRepository;

    /**
     * @var FactoryInterface
     */
    private $shippingMethodFactory;

    /**
     * @var FactoryInterface
     */
    private $shippingMethodTranslationFactory;

    /**
     * @var ObjectManager
     */
    private $shippingMethodManager;

    /**
     * @param SharedStorageInterface $sharedStorage
     * @param ShippingMethodRepositoryInterface $shippingMethodRepository
     * @param ZoneRepositoryInterface $zoneRepository
     * @param FactoryInterface $shippingMethodFactory
     * @param FactoryInterface $shippingMethodTranslationFactory
     * @param ObjectManager $shippingMethodManager
     */
    public function __construct(
        SharedStorageInterface $sharedStorage,
        ShippingMethodRepositoryInterface $shippingMethodRepository,

The variable name $shippingMethodRepository exceeds the maximum configured length of 20.

        ZoneRepositoryInterface $zoneRepository,
        FactoryInterface $shippingMethodFactory,

The variable name $shippingMethodFactory exceeds the maximum configured length of 20.

        FactoryInterface $shippingMethodTranslationFactory,

The variable name $shippingMethodTranslationFactory exceeds the maximum configured length of 20.

        ObjectManager $shippingMethodManager

The variable name $shippingMethodManager exceeds the maximum configured length of 20.

    ) {
        $this->sharedStorage = $sharedStorage;
        $this->shippingMethodRepository = $shippingMethodRepository;
        $this->zoneRepository = $zoneRepository;
        $this->shippingMethodFactory = $shippingMethodFactory;
        $this->shippingMethodTranslationFactory = $shippingMethodTranslationFactory;
        $this->shippingMethodManager = $shippingMethodManager;
    }

    /**
     * @Given the store ships everything for free within the :zone zone
     * @Given /^the store ships everything for free for the (rest of the world)$/
     */
    public function storeShipsEverythingForFree(ZoneInterface $zone = null)
    {
        $this->createShippingMethod('Free', null, null, $zone);
    }

    /**
     * @Given the store ships everywhere for free
     */
    public function theStoreShipsEverywhereForFree()
    {
        foreach ($this->zoneRepository->findAll() as $zone) {
            $this->createShippingMethod('Free', null, null, $zone);
        }
    }

    /**
     * @Given the store (also) allows shipping with :name
     * @Given the store (also) allows shipping with :name identified by :code
     * @Given the store (also) allows shipping with :name at position :position
     */
    public function theStoreAllowsShippingMethod($name, $code = null, $position = null)
    {
        $this->createShippingMethod($name, $code, $position);
    }

    /**
     * @Given /^(this shipping method) is named "([^"]+)" in the "([^"]+)" locale$/
     */
    public function thisShippingMethodIsNamedInLocale(ShippingMethodInterface $shippingMethod, $name, $locale)
    {
        /** @var ShippingMethodTranslationInterface $translation */
        $translation = $this->shippingMethodTranslationFactory->createNew();
        $translation->setLocale($locale);
        $translation->setName($name);

        $shippingMethod->addTranslation($translation);

$translation is of type object<Sylius\Component\Shipping\Model\ShippingMethodTranslationInterface>, but the function expects a object<Sylius\Component\Resource\Model\TranslationInterface>.

        $this->shippingMethodManager->flush();
    }

    /**
     * @Given the store allows shipping with :firstName and :secondName
     */
    public function theStoreAllowsShippingWithAnd($firstName, $secondName)
    {
        $this->createShippingMethod($firstName);
        $this->createShippingMethod($secondName);
    }

    /**
     * @Given /^the store has "([^"]+)" shipping method with ("[^"]+") fee$/
     * @Given /^the store has "([^"]+)" shipping method with ("[^"]+") fee within the ("[^"]+" zone)$/
     * @Given /^the store has "([^"]+)" shipping method with ("[^"]+") fee for the (rest of the world)$/
     */
    public function storeHasShippingMethodWithFee($shippingMethodName, $fee, ZoneInterface $zone = null)
    {
        $this->createShippingMethod($shippingMethodName, null, null, $zone, 'en', ['amount' => $fee]);
    }

    /**
     * @Given /^the store has disabled "([^"]+)" shipping method with ("[^"]+") fee$/
     */
    public function storeHasDisabledShippingMethodWithFee($shippingMethodName, $fee)
    {
        $this->createShippingMethod($shippingMethodName, null, null, null, 'en', ['amount' => $fee], DefaultCalculators::FLAT_RATE, false);
    }

    /**
     * @Given /^the store has "([^"]+)" shipping method with ("[^"]+") fee per unit$/
     */
    public function theStoreHasShippingMethodWithFeePerUnit($shippingMethodName, $fee)
    {
        $this->createShippingMethod($shippingMethodName, null, null, null, 'en', ['amount' => $fee], DefaultCalculators::PER_UNIT_RATE);
    }

    /**
     * @Given /^the store has "([^"]+)" shipping method with ("[^"]+") fee on fist unit and ("[^"]+") on next (\d+)$/
     */
    public function theStoreHasShippingMethodWithFeeOnFistUnitAndOnNext($shippingMethodName, $fee, $perUnitFee, $limit)
    {
        $this->createShippingMethod(
            $shippingMethodName,
            null,
            null,
            null,
            'en',
            ['first_unit_cost' => $fee, 'additional_unit_cost' => $perUnitFee, 'additional_unit_limit' => $limit],
            DefaultCalculators::FLEXIBLE_RATE
        );
    }

    /**
     * @Given /^the store has "([^"]+)" shipping method with ("[^"]+") fee not assigned to any channel$/
     */
    public function storeHasShippingMethodWithFeeNotAssignedToAnyChannel($shippingMethodName, $fee)
    {
        $this->createShippingMethod($shippingMethodName, null, null, null, 'en', ['amount' => $fee], DefaultCalculators::FLAT_RATE, false, false);
    }

    /**
     * @Given /^(shipping method "[^"]+") belongs to ("[^"]+" tax category)$/
     */
    public function shippingMethodBelongsToTaxCategory(ShippingMethodInterface $shippingMethod, TaxCategoryInterface $taxCategory)
    {
        $shippingMethod->setTaxCategory($taxCategory);
        $this->shippingMethodManager->flush();
    }

    /**
     * @Given the shipping method :shippingMethod is enabled
     */
    public function theShippingMethodIsEnabled(ShippingMethodInterface $shippingMethod)
    {
        $shippingMethod->enable();
        $this->shippingMethodManager->flush();
    }

    /**
     * @Given the shipping method :shippingMethod is disabled
     */
    public function theShippingMethodIsDisabled(ShippingMethodInterface $shippingMethod)
    {
        $shippingMethod->disable();
        $this->shippingMethodManager->flush();
    }

    /**
     * @Given /^(this shipping method) requires at least one unit matches to ("([^"]+)" shipping category)$/
     */
    public function thisShippingMethodRequiresAtLeastOneUnitMatchToShippingCategory(
        ShippingMethodInterface $shippingMethod, 
        ShippingCategoryInterface $shippingCategory
    ) {
        $shippingMethod->setCategory($shippingCategory);
        $shippingMethod->setCategoryRequirement(ShippingMethodInterface::CATEGORY_REQUIREMENT_MATCH_ANY);
        $this->shippingMethodManager->flush();
    }

    /**
     * @Given /^(this shipping method) requires that all units match to ("([^"]+)" shipping category)$/
     */
    public function thisShippingMethodRequiresThatAllUnitsMatchToShippingCategory(
        ShippingMethodInterface $shippingMethod,
        ShippingCategoryInterface $shippingCategory
    ) {
        $shippingMethod->setCategory($shippingCategory);
        $shippingMethod->setCategoryRequirement(ShippingMethodInterface::CATEGORY_REQUIREMENT_MATCH_ALL);
        $this->shippingMethodManager->flush();
    }

    /**
     * @Given /^(this shipping method) requires that no units match to ("([^"]+)" shipping category)$/
     */
    public function thisShippingMethodRequiresThatNoUnitsMatchToShippingCategory(
        ShippingMethodInterface $shippingMethod,
        ShippingCategoryInterface $shippingCategory
    ) {
        $shippingMethod->setCategory($shippingCategory);
        $shippingMethod->setCategoryRequirement(ShippingMethodInterface::CATEGORY_REQUIREMENT_MATCH_NONE);
        $this->shippingMethodManager->flush();
    }

    /**
     * @param string $name
     * @param string|null $code
     * @param int|null $position
     * @param ZoneInterface|null $zone
     * @param string $locale
     * @param array $configuration
     * @param string $calculator
     * @param bool $enabled
     * @param bool $addForCurrentChannel
     */
    private function createShippingMethod(
        $name,
        $code = null,
        $position = null,
        ZoneInterface $zone = null,
        $locale = 'en',
        $configuration = ['amount' => 0],
        $calculator = DefaultCalculators::FLAT_RATE,
        $enabled = true,
        $addForCurrentChannel = true
    ) {
        if (null === $zone) {
            $zone = $this->sharedStorage->get('zone');
        }

        if (null === $code) {
            $code = $this->generateCodeFromNameAndZone($name, $zone->getCode());
        }

        /** @var ShippingMethodInterface $shippingMethod */
        $shippingMethod = $this->shippingMethodFactory->createNew();
        $shippingMethod->setCode($code);
        $shippingMethod->setName($name);
        $shippingMethod->setPosition($position);
        $shippingMethod->setCurrentLocale($locale);
        $shippingMethod->setConfiguration($configuration);
        $shippingMethod->setCalculator($calculator);
        $shippingMethod->setZone($zone);
        $shippingMethod->setEnabled($enabled);

        if ($addForCurrentChannel && $this->sharedStorage->has('channel')) {
            $shippingMethod->addChannel($this->sharedStorage->get('channel'));
        }

        $this->shippingMethodRepository->add($shippingMethod);
        $this->sharedStorage->set('shipping_method', $shippingMethod);
    }

    /**
     * @param string $shippingMethodName
     * @param string|null $zoneCode
     *
     * @return string
     */
    private function generateCodeFromNameAndZone($shippingMethodName, $zoneCode = null)
    {
        return StringInflector::nameToLowercaseCode($shippingMethodName).'_'.StringInflector::nameToLowercaseCode($zoneCode);
    }
}