OrderFixture::generateInvalidSkipMessage() - Code Metrics - Inspection of "Use fallback locale as default for the new adminis..." - pamil/Sylius - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — default-locale-code ( 1d8918 )

by Kamil

created 2019-08-26 11:48 UTC

OrderFixture::generateInvalidSkipMessage() A

↳ Parent: OrderFixture

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	8
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	2

<?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.
 */

declare(strict_types=1);

namespace Sylius\Bundle\CoreBundle\Fixture;

use Doctrine\Common\Persistence\ObjectManager;
use SM\Factory\FactoryInterface as StateMachineFactoryInterface;
use Sylius\Bundle\FixturesBundle\Fixture\AbstractFixture;
use Sylius\Component\Core\Checker\OrderPaymentMethodSelectionRequirementCheckerInterface;
use Sylius\Component\Core\Checker\OrderShippingMethodSelectionRequirementCheckerInterface;
use Sylius\Component\Core\Model\AddressInterface;
use Sylius\Component\Core\Model\ChannelInterface;
use Sylius\Component\Core\Model\OrderInterface;
use Sylius\Component\Core\Model\OrderItemInterface;
use Sylius\Component\Core\Model\ProductInterface;
use Sylius\Component\Core\OrderCheckoutStates;
use Sylius\Component\Core\OrderCheckoutTransitions;
use Sylius\Component\Core\Repository\PaymentMethodRepositoryInterface;
use Sylius\Component\Core\Repository\ShippingMethodRepositoryInterface;
use Sylius\Component\Order\Modifier\OrderItemQuantityModifierInterface;
use Sylius\Component\Resource\Factory\FactoryInterface;
use Sylius\Component\Resource\Repository\RepositoryInterface;
use Symfony\Component\Config\Definition\Builder\ArrayNodeDefinition;
use Webmozart\Assert\Assert;

class OrderFixture extends AbstractFixture
{
    /** @var FactoryInterface */
    private $orderFactory;

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

    /** @var OrderItemQuantityModifierInterface */
    private $orderItemQuantityModifier;

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

    /** @var RepositoryInterface */
    private $channelRepository;

    /** @var RepositoryInterface */
    private $customerRepository;

    /** @var RepositoryInterface */
    private $productRepository;

    /** @var RepositoryInterface */
    private $countryRepository;

    /** @var PaymentMethodRepositoryInterface */
    private $paymentMethodRepository;

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

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

    /** @var StateMachineFactoryInterface */
    private $stateMachineFactory;

    /** @var OrderShippingMethodSelectionRequirementCheckerInterface */
    private $orderShippingMethodSelectionRequirementChecker;

    /** @var OrderPaymentMethodSelectionRequirementCheckerInterface */
    private $orderPaymentMethodSelectionRequirementChecker;

    /** @var \Faker\Generator */
    private $faker;

    public function __construct(
        FactoryInterface $orderFactory,
        FactoryInterface $orderItemFactory,
        OrderItemQuantityModifierInterface $orderItemQuantityModifier,
        ObjectManager $orderManager,
        RepositoryInterface $channelRepository,
        RepositoryInterface $customerRepository,
        RepositoryInterface $productRepository,
        RepositoryInterface $countryRepository,
        PaymentMethodRepositoryInterface $paymentMethodRepository,
        ShippingMethodRepositoryInterface $shippingMethodRepository,
        FactoryInterface $addressFactory,
        StateMachineFactoryInterface $stateMachineFactory,
        OrderShippingMethodSelectionRequirementCheckerInterface $orderShippingMethodSelectionRequirementChecker,
        OrderPaymentMethodSelectionRequirementCheckerInterface $orderPaymentMethodSelectionRequirementChecker
    ) {
        $this->orderFactory = $orderFactory;
        $this->orderItemFactory = $orderItemFactory;
        $this->orderItemQuantityModifier = $orderItemQuantityModifier;
        $this->orderManager = $orderManager;
        $this->channelRepository = $channelRepository;
        $this->customerRepository = $customerRepository;
        $this->productRepository = $productRepository;
        $this->countryRepository = $countryRepository;
        $this->paymentMethodRepository = $paymentMethodRepository;
        $this->shippingMethodRepository = $shippingMethodRepository;
        $this->addressFactory = $addressFactory;
        $this->stateMachineFactory = $stateMachineFactory;
        $this->orderShippingMethodSelectionRequirementChecker = $orderShippingMethodSelectionRequirementChecker;
        $this->orderPaymentMethodSelectionRequirementChecker = $orderPaymentMethodSelectionRequirementChecker;

        $this->faker = \Faker\Factory::create();
    }

    /**
     * {@inheritdoc}
     */
    public function load(array $options): void
    {
        $channels = $this->channelRepository->findAll();
        $customers = $this->customerRepository->findAll();
        $countries = $this->countryRepository->findAll();

        $randomDates = $this->generateDates($options['amount']);

        for ($i = 0; $i < $options['amount']; ++$i) {
            $channel = $this->faker->randomElement($channels);
            $customer = $this->faker->randomElement($customers);
            $countryCode = $this->faker->randomElement($countries)->getCode();

            $currencyCode = $channel->getBaseCurrency()->getCode();
            $localeCode = $this->faker->randomElement($channel->getLocales()->toArray())->getCode();

            /** @var OrderInterface $order */
            $order = $this->orderFactory->createNew();
            $order->setChannel($channel);
            $order->setCustomer($customer);
            $order->setCurrencyCode($currencyCode);
            $order->setLocaleCode($localeCode);

            $this->generateItems($order);

            $this->address($order, $countryCode);
            $this->selectShipping($order);
            $this->selectPayment($order);
            $this->completeCheckout($order);
            $this->setOrderCompletedDate($order, $randomDates[$i]);

            $this->orderManager->persist($order);

            if (0 === ($i % 50)) {
                $this->orderManager->flush();
            }
        }

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

    /**
     * {@inheritdoc}
     */
    public function getName(): string
    {
        return 'order';
    }

    /**
     * {@inheritdoc}
     */
    protected function configureOptionsNode(ArrayNodeDefinition $optionsNode): void
    {
        $optionsNode
            ->children()
                ->integerNode('amount')->isRequired()->min(0)->end()
        ;
    }

    private function generateItems(OrderInterface $order): void
    {
        $numberOfItems = random_int(1, 5);
        $products = $this->productRepository->findAll();
        $generatedItems = [];

        for ($i = 0; $i < $numberOfItems; ++$i) {
            /** @var ProductInterface $product */
            $product = $this->faker->randomElement($products);

            if (!$product->hasChannel($order->getChannel())) {
                $i--;
                continue;
            }

            $variant = $this->faker->randomElement($product->getVariants()->toArray());

            if (array_key_exists($variant->getCode(), $generatedItems)) {
                /** @var OrderItemInterface $item */
                $item = $generatedItems[$variant->getCode()];
                $this->orderItemQuantityModifier->modify($item, $item->getQuantity() + random_int(1, 5));

                continue;
            }

            /** @var OrderItemInterface $item */
            $item = $this->orderItemFactory->createNew();

            $item->setVariant($variant);
            $this->orderItemQuantityModifier->modify($item, random_int(1, 5));

            $generatedItems[$variant->getCode()] = $item;
            $order->addItem($item);
        }
    }

    private function address(OrderInterface $order, string $countryCode): void
    {
        /** @var AddressInterface $address */
        $address = $this->addressFactory->createNew();
        $address->setFirstName($this->faker->firstName);
        $address->setLastName($this->faker->lastName);
        $address->setStreet($this->faker->streetAddress);
        $address->setCountryCode($countryCode);
        $address->setCity($this->faker->city);
        $address->setPostcode($this->faker->postcode);

        $order->setShippingAddress($address);
        $order->setBillingAddress(clone $address);

        $this->applyCheckoutStateTransition($order, OrderCheckoutTransitions::TRANSITION_ADDRESS);
    }

    private function selectShipping(OrderInterface $order): void
    {
        if (!$this->orderShippingMethodSelectionRequirementChecker->isShippingMethodSelectionRequired($order)) {
            $this->applyCheckoutStateTransition($order, OrderCheckoutTransitions::TRANSITION_SKIP_SHIPPING);

            return;
        }

        $channel = $order->getChannel();
        $shippingMethods = $this->shippingMethodRepository->findEnabledForChannel($channel);

        if (count($shippingMethods) === 0) {
            throw new \InvalidArgumentException(sprintf(
                'You have no shipping method available for the channel with code "%s", but they are required to proceed an order',
                $channel->getCode()
            ));
        }

        $shippingMethod = $this->faker->randomElement($shippingMethods);

        /** @var ChannelInterface $channel */
        $channel = $order->getChannel();
        Assert::notNull($shippingMethod, $this->generateInvalidSkipMessage('shipping', $channel->getCode()));

        foreach ($order->getShipments() as $shipment) {
            $shipment->setMethod($shippingMethod);
        }

        $this->applyCheckoutStateTransition($order, OrderCheckoutTransitions::TRANSITION_SELECT_SHIPPING);
    }

    private function selectPayment(OrderInterface $order): void
    {
        if (!$this->orderPaymentMethodSelectionRequirementChecker->isPaymentMethodSelectionRequired($order)) {
            $this->applyCheckoutStateTransition($order, OrderCheckoutTransitions::TRANSITION_SKIP_PAYMENT);

            return;
        }

        $paymentMethod = $this
            ->faker
            ->randomElement($this->paymentMethodRepository->findEnabledForChannel($order->getChannel()))
        ;

        /** @var ChannelInterface $channel */
        $channel = $order->getChannel();
        Assert::notNull($paymentMethod, $this->generateInvalidSkipMessage('payment', $channel->getCode()));

        foreach ($order->getPayments() as $payment) {
            $payment->setMethod($paymentMethod);
        }

        $this->applyCheckoutStateTransition($order, OrderCheckoutTransitions::TRANSITION_SELECT_PAYMENT);
    }

    private function completeCheckout(OrderInterface $order): void
    {
        if ($this->faker->boolean(25)) {
            $order->setNotes($this->faker->sentence);
        }

        $this->applyCheckoutStateTransition($order, OrderCheckoutTransitions::TRANSITION_COMPLETE);
    }

    private function applyCheckoutStateTransition(OrderInterface $order, string $transition): void
    {
        $this->stateMachineFactory->get($order, OrderCheckoutTransitions::GRAPH)->apply($transition);
    }

    private function setOrderCompletedDate(OrderInterface $order, \DateTimeInterface $date): void
    {
        if ($order->getCheckoutState() === OrderCheckoutStates::STATE_COMPLETED) {
            $order->setCheckoutCompletedAt($date);
        }
    }

    private function generateDates(int $amount): array
    {
        $dates = [];

        for ($i = 0; $i < $amount; ++$i) {
            /** @var \DateTimeInterface|array $dates */
            $dates[] = $this->faker->dateTimeBetween('-1 years', 'now');
        }
        sort($dates);

        return $dates;
    }

    private function generateInvalidSkipMessage(string $type, string $channelCode): string
    {
        return sprintf(
            "No enabled %s method was found for the channel '%s'. " .
            "Set 'skipping_%s_step_allowed' option to true for this channel if you want to skip %s method selection.",
            $type, $channelCode, $type, $type
        );
    }
}


1			<?php
2
3			/*
4			* This file is part of the Sylius package.
5			*
6			* (c) Paweł Jędrzejewski
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			declare(strict_types=1);
13
14			namespace Sylius\Bundle\CoreBundle\Fixture;
15
16			use Doctrine\Common\Persistence\ObjectManager;
17			use SM\Factory\FactoryInterface as StateMachineFactoryInterface;
18			use Sylius\Bundle\FixturesBundle\Fixture\AbstractFixture;
19			use Sylius\Component\Core\Checker\OrderPaymentMethodSelectionRequirementCheckerInterface;
20			use Sylius\Component\Core\Checker\OrderShippingMethodSelectionRequirementCheckerInterface;
21			use Sylius\Component\Core\Model\AddressInterface;
22			use Sylius\Component\Core\Model\ChannelInterface;
23			use Sylius\Component\Core\Model\OrderInterface;
24			use Sylius\Component\Core\Model\OrderItemInterface;
25			use Sylius\Component\Core\Model\ProductInterface;
26			use Sylius\Component\Core\OrderCheckoutStates;
27			use Sylius\Component\Core\OrderCheckoutTransitions;
28			use Sylius\Component\Core\Repository\PaymentMethodRepositoryInterface;
29			use Sylius\Component\Core\Repository\ShippingMethodRepositoryInterface;
30			use Sylius\Component\Order\Modifier\OrderItemQuantityModifierInterface;
31			use Sylius\Component\Resource\Factory\FactoryInterface;
32			use Sylius\Component\Resource\Repository\RepositoryInterface;
33			use Symfony\Component\Config\Definition\Builder\ArrayNodeDefinition;
34			use Webmozart\Assert\Assert;
35
36			class OrderFixture extends AbstractFixture
37			{
38			/** @var FactoryInterface */
39			private $orderFactory;
40
41			/** @var FactoryInterface */
42			private $orderItemFactory;
43
44			/** @var OrderItemQuantityModifierInterface */
45			private $orderItemQuantityModifier;
46
47			/** @var ObjectManager */
48			private $orderManager;
49
50			/** @var RepositoryInterface */
51			private $channelRepository;
52
53			/** @var RepositoryInterface */
54			private $customerRepository;
55
56			/** @var RepositoryInterface */
57			private $productRepository;
58
59			/** @var RepositoryInterface */
60			private $countryRepository;
61
62			/** @var PaymentMethodRepositoryInterface */
63			private $paymentMethodRepository;
64
65			/** @var ShippingMethodRepositoryInterface */
66			private $shippingMethodRepository;
67
68			/** @var FactoryInterface */
69			private $addressFactory;
70
71			/** @var StateMachineFactoryInterface */
72			private $stateMachineFactory;
73
74			/** @var OrderShippingMethodSelectionRequirementCheckerInterface */
75			private $orderShippingMethodSelectionRequirementChecker;
76
77			/** @var OrderPaymentMethodSelectionRequirementCheckerInterface */
78			private $orderPaymentMethodSelectionRequirementChecker;
79
80			/** @var \Faker\Generator */
81			private $faker;
82
83			public function __construct(
84			FactoryInterface $orderFactory,
85			FactoryInterface $orderItemFactory,
86			OrderItemQuantityModifierInterface $orderItemQuantityModifier,
87			ObjectManager $orderManager,
88			RepositoryInterface $channelRepository,
89			RepositoryInterface $customerRepository,
90			RepositoryInterface $productRepository,
91			RepositoryInterface $countryRepository,
92			PaymentMethodRepositoryInterface $paymentMethodRepository,
93			ShippingMethodRepositoryInterface $shippingMethodRepository,
94			FactoryInterface $addressFactory,
95			StateMachineFactoryInterface $stateMachineFactory,
96			OrderShippingMethodSelectionRequirementCheckerInterface $orderShippingMethodSelectionRequirementChecker,
97			OrderPaymentMethodSelectionRequirementCheckerInterface $orderPaymentMethodSelectionRequirementChecker
98			) {
99			$this->orderFactory = $orderFactory;
100			$this->orderItemFactory = $orderItemFactory;
101			$this->orderItemQuantityModifier = $orderItemQuantityModifier;
102			$this->orderManager = $orderManager;
103			$this->channelRepository = $channelRepository;
104			$this->customerRepository = $customerRepository;
105			$this->productRepository = $productRepository;
106			$this->countryRepository = $countryRepository;
107			$this->paymentMethodRepository = $paymentMethodRepository;
108			$this->shippingMethodRepository = $shippingMethodRepository;
109			$this->addressFactory = $addressFactory;
110			$this->stateMachineFactory = $stateMachineFactory;
111			$this->orderShippingMethodSelectionRequirementChecker = $orderShippingMethodSelectionRequirementChecker;
112			$this->orderPaymentMethodSelectionRequirementChecker = $orderPaymentMethodSelectionRequirementChecker;
113
114			$this->faker = \Faker\Factory::create();
115			}
116
117			/**
118			* {@inheritdoc}
119			*/
120			public function load(array $options): void
121			{
122			$channels = $this->channelRepository->findAll();
123			$customers = $this->customerRepository->findAll();
124			$countries = $this->countryRepository->findAll();
125
126			$randomDates = $this->generateDates($options['amount']);
127
128			for ($i = 0; $i < $options['amount']; ++$i) {
129			$channel = $this->faker->randomElement($channels);
130			$customer = $this->faker->randomElement($customers);
131			$countryCode = $this->faker->randomElement($countries)->getCode();
132
133			$currencyCode = $channel->getBaseCurrency()->getCode();
134			$localeCode = $this->faker->randomElement($channel->getLocales()->toArray())->getCode();
135
136			/** @var OrderInterface $order */
137			$order = $this->orderFactory->createNew();
138			$order->setChannel($channel);
139			$order->setCustomer($customer);
140			$order->setCurrencyCode($currencyCode);
141			$order->setLocaleCode($localeCode);
142
143			$this->generateItems($order);
144
145			$this->address($order, $countryCode);
146			$this->selectShipping($order);
147			$this->selectPayment($order);
148			$this->completeCheckout($order);
149			$this->setOrderCompletedDate($order, $randomDates[$i]);
150
151			$this->orderManager->persist($order);
152
153			if (0 === ($i % 50)) {
154			$this->orderManager->flush();
155			}
156			}
157
158			$this->orderManager->flush();
159			}
160
161			/**
162			* {@inheritdoc}
163			*/
164			public function getName(): string
165			{
166			return 'order';
167			}
168
169			/**
170			* {@inheritdoc}
171			*/
172			protected function configureOptionsNode(ArrayNodeDefinition $optionsNode): void
173			{
174			$optionsNode
175			->children()
176			->integerNode('amount')->isRequired()->min(0)->end()
177			;
178			}
179
180			private function generateItems(OrderInterface $order): void
181			{
182			$numberOfItems = random_int(1, 5);
183			$products = $this->productRepository->findAll();
184			$generatedItems = [];
185
186			for ($i = 0; $i < $numberOfItems; ++$i) {
187			/** @var ProductInterface $product */
188			$product = $this->faker->randomElement($products);
189
190			if (!$product->hasChannel($order->getChannel())) {
191			$i--;
192			continue;
193			}
194
195			$variant = $this->faker->randomElement($product->getVariants()->toArray());
196
197			if (array_key_exists($variant->getCode(), $generatedItems)) {
198			/** @var OrderItemInterface $item */
199			$item = $generatedItems[$variant->getCode()];
200			$this->orderItemQuantityModifier->modify($item, $item->getQuantity() + random_int(1, 5));
201
202			continue;
203			}
204
205			/** @var OrderItemInterface $item */
206			$item = $this->orderItemFactory->createNew();
207
208			$item->setVariant($variant);
209			$this->orderItemQuantityModifier->modify($item, random_int(1, 5));
210
211			$generatedItems[$variant->getCode()] = $item;
212			$order->addItem($item);
213			}
214			}
215
216			private function address(OrderInterface $order, string $countryCode): void
217			{
218			/** @var AddressInterface $address */
219			$address = $this->addressFactory->createNew();
220			$address->setFirstName($this->faker->firstName);
221			$address->setLastName($this->faker->lastName);
222			$address->setStreet($this->faker->streetAddress);
223			$address->setCountryCode($countryCode);
224			$address->setCity($this->faker->city);
225			$address->setPostcode($this->faker->postcode);
226
227			$order->setShippingAddress($address);
228			$order->setBillingAddress(clone $address);
229
230			$this->applyCheckoutStateTransition($order, OrderCheckoutTransitions::TRANSITION_ADDRESS);
231			}
232
233			private function selectShipping(OrderInterface $order): void
234			{
235			if (!$this->orderShippingMethodSelectionRequirementChecker->isShippingMethodSelectionRequired($order)) {
236			$this->applyCheckoutStateTransition($order, OrderCheckoutTransitions::TRANSITION_SKIP_SHIPPING);
237
238			return;
239			}
240
241			$channel = $order->getChannel();
242			$shippingMethods = $this->shippingMethodRepository->findEnabledForChannel($channel);
243
244			if (count($shippingMethods) === 0) {
245			throw new \InvalidArgumentException(sprintf(
246			'You have no shipping method available for the channel with code "%s", but they are required to proceed an order',
247			$channel->getCode()
248			));
249			}
250
251			$shippingMethod = $this->faker->randomElement($shippingMethods);
252
253			/** @var ChannelInterface $channel */
254			$channel = $order->getChannel();
255			Assert::notNull($shippingMethod, $this->generateInvalidSkipMessage('shipping', $channel->getCode()));
256
257			foreach ($order->getShipments() as $shipment) {
258			$shipment->setMethod($shippingMethod);
259			}
260
261			$this->applyCheckoutStateTransition($order, OrderCheckoutTransitions::TRANSITION_SELECT_SHIPPING);
262			}
263
264			private function selectPayment(OrderInterface $order): void
265			{
266			if (!$this->orderPaymentMethodSelectionRequirementChecker->isPaymentMethodSelectionRequired($order)) {
267			$this->applyCheckoutStateTransition($order, OrderCheckoutTransitions::TRANSITION_SKIP_PAYMENT);
268
269			return;
270			}
271
272			$paymentMethod = $this
273			->faker
274			->randomElement($this->paymentMethodRepository->findEnabledForChannel($order->getChannel()))
275			;
276
277			/** @var ChannelInterface $channel */
278			$channel = $order->getChannel();
279			Assert::notNull($paymentMethod, $this->generateInvalidSkipMessage('payment', $channel->getCode()));
280
281			foreach ($order->getPayments() as $payment) {
282			$payment->setMethod($paymentMethod);
283			}
284
285			$this->applyCheckoutStateTransition($order, OrderCheckoutTransitions::TRANSITION_SELECT_PAYMENT);
286			}
287
288			private function completeCheckout(OrderInterface $order): void
289			{
290			if ($this->faker->boolean(25)) {
291			$order->setNotes($this->faker->sentence);
292			}
293
294			$this->applyCheckoutStateTransition($order, OrderCheckoutTransitions::TRANSITION_COMPLETE);
295			}
296
297			private function applyCheckoutStateTransition(OrderInterface $order, string $transition): void
298			{
299			$this->stateMachineFactory->get($order, OrderCheckoutTransitions::GRAPH)->apply($transition);
300			}
301
302			private function setOrderCompletedDate(OrderInterface $order, \DateTimeInterface $date): void
303			{
304			if ($order->getCheckoutState() === OrderCheckoutStates::STATE_COMPLETED) {
305			$order->setCheckoutCompletedAt($date);
306			}
307			}
308
309			private function generateDates(int $amount): array
310			{
311			$dates = [];
312
313			for ($i = 0; $i < $amount; ++$i) {
314			/** @var \DateTimeInterface\|array $dates */
315			$dates[] = $this->faker->dateTimeBetween('-1 years', 'now');
316			}
317			sort($dates);
318
319			return $dates;
320			}
321
322			private function generateInvalidSkipMessage(string $type, string $channelCode): string
323			{
324			return sprintf(
325			"No enabled %s method was found for the channel '%s'. " .
326			"Set 'skipping_%s_step_allowed' option to true for this channel if you want to skip %s method selection.",
327			$type, $channelCode, $type, $type
328			);
329			}
330			}
331

pamil / Sylius

Push — default-locale-code ( 1d8918 )

OrderFixture::generateInvalidSkipMessage() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like