Shopware\Core\Checkout\Order\SalesChannel\OrderRoute

Complexity

Total Complexity

42

Size/Duplication

Total Lines	204
Duplicated Lines	0 %

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
B	checkGuestAuth()	0	19	11
A	filterOldOrders()	0	9	2
A	__construct()	0	10	1
A	checkPromotion()	0	9	3
A	checkCartRule()	0	10	3
B	load()	0	51	11
A	getDecorated()	0	3	1
A	checkRuleType()	0	12	5
A	getActivePromotions()	0	20	5

<?php declare(strict_types=1);

namespace Shopware\Core\Checkout\Order\SalesChannel;

use OpenApi\Annotations as OA;
use Shopware\Core\Checkout\Cart\Exception\CustomerNotLoggedInException;
use Shopware\Core\Checkout\Cart\Rule\PaymentMethodRule;
use Shopware\Core\Checkout\Order\Exception\GuestNotAuthenticatedException;
use Shopware\Core\Checkout\Order\Exception\WrongGuestCredentialsException;
use Shopware\Core\Checkout\Order\OrderDefinition;
use Shopware\Core\Checkout\Order\OrderEntity;
use Shopware\Core\Checkout\Promotion\PromotionCollection;
use Shopware\Core\Checkout\Promotion\PromotionEntity;
use Shopware\Core\Content\Rule\RuleEntity;
use Shopware\Core\Framework\DataAbstractionLayer\EntityRepositoryInterface;
use Shopware\Core\Framework\DataAbstractionLayer\Search\Criteria;
use Shopware\Core\Framework\DataAbstractionLayer\Search\EntitySearchResult;
use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\EqualsFilter;
use Shopware\Core\Framework\DataAbstractionLayer\Search\RequestCriteriaBuilder;
use Shopware\Core\Framework\Plugin\Exception\DecorationPatternException;
use Shopware\Core\Framework\Routing\Annotation\Entity;
use Shopware\Core\Framework\Routing\Annotation\RouteScope;
use Shopware\Core\Framework\Routing\Annotation\Since;
use Shopware\Core\Framework\Rule\Container\Container;
use Shopware\Core\System\SalesChannel\SalesChannelContext;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\Routing\Annotation\Route;

/**
 * @RouteScope(scopes={"store-api"})
 */
class OrderRoute extends AbstractOrderRoute
{
    /**
     * @var EntityRepositoryInterface
     */
    private $orderRepository;

    /**
     * @var RequestCriteriaBuilder
     */
    private $requestCriteriaBuilder;

    /**
     * @var OrderDefinition
     */
    private $orderDefinition;

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

    public function __construct(
        EntityRepositoryInterface $orderRepository,
        RequestCriteriaBuilder $requestCriteriaBuilder,
        OrderDefinition $salesChannelOrderDefinition,
        EntityRepositoryInterface $promotionRepository
    ) {
        $this->orderRepository = $orderRepository;
        $this->requestCriteriaBuilder = $requestCriteriaBuilder;
        $this->orderDefinition = $salesChannelOrderDefinition;
        $this->promotionRepository = $promotionRepository;
    }

    public function getDecorated(): AbstractOrderRoute
    {
        throw new DecorationPatternException(self::class);
    }

    /**
     * @Since("6.2.0.0")
     * @Entity("order")
     * @OA\Post(
     *      path="/order",
     *      summary="Listing orders",
     *      operationId="readOrder",
     *      tags={"Store API", "Order"},
     *      @OA\Parameter(name="Api-Basic-Parameters"),
     *      @OA\RequestBody(
     *          required=true,
     *          @OA\JsonContent(
     *              @OA\Property(property="checkPromotion", description="Wether to check the Promotions of orders", type="string"),
     *          )
     *      ),
     *      @OA\Response(
     *          response="200",
     *          description="",
     *          @OA\JsonContent(type="array", @OA\Items(ref="#/components/schemas/order_flat"))
     *     )
     * )
     * @Route(path="/store-api/v{version}/order", name="store-api.order", methods={"GET", "POST"})
     */
    public function load(Request $request, SalesChannelContext $context, ?Criteria $criteria = null): OrderRouteResponse
    {
        // @deprecated tag:v6.4.0 - Criteria will be required
        if (!$criteria) {
            $criteria = $this->requestCriteriaBuilder->handleRequest($request, new Criteria(), $this->orderDefinition, $context->getContext());
        }

        $criteria->addFilter(new EqualsFilter('order.salesChannelId', $context->getSalesChannel()->getId()));

        $criteria->getAssociation('documents')
            ->addFilter(new EqualsFilter('config.displayInCustomerAccount', 'true'))
            ->addFilter(new EqualsFilter('sent', true));

        $criteria->addAssociation('billingAddress');

        if ($context->getCustomer()) {
            $criteria->addFilter(new EqualsFilter('order.orderCustomer.customerId', $context->getCustomer()->getId()));
        } elseif (!$criteria->hasEqualsFilter('deepLinkCode')) {
            throw new CustomerNotLoggedInException();
        }

        $orders = $this->orderRepository->search($criteria, $context->getContext());

        if ($criteria->hasEqualsFilter('deepLinkCode')) {
            $orders = $this->filterOldOrders($orders);
        }

        // Handle guest authentication if deeplink is set
        if (!$context->getCustomer() && $criteria->hasEqualsFilter('deepLinkCode')) {
            /** @var OrderEntity $order */
            $order = $orders->first();
            $this->checkGuestAuth($order, $request);
        }

        $response = new OrderRouteResponse($orders);
        if ($request->get('checkPromotion') === true) {
            /** @var OrderEntity $order */
            foreach ($orders as $order) {
                $promotions = $this->getActivePromotions($order, $context);

$order of type array is incompatible with the type Shopware\Core\Checkout\Order\OrderEntity expected by parameter $order of Shopware\Core\Checkout\Order\SalesChannel\OrderRoute::getActivePromotions().

                $changeable = true;
                foreach ($promotions as $promotion) {
                    $changeable = $this->checkPromotion($promotion);
                    if ($changeable === true) {
                        break;
                    }
                }
                $response->addPaymentChangeable([$order->getId() => $changeable]);
            }
        }

        return $response;
    }

    private function getActivePromotions(OrderEntity $order, SalesChannelContext $context): PromotionCollection
    {
        $promotionIds = [];
        foreach ($order->getLineItems() ?? [] as $lineItem) {
            $payload = $lineItem->getPayload();
            if (isset($payload['promotionId']) && $payload['promotionId'] !== null) {
                $promotionIds[] = $payload['promotionId'];
            }
        }

        $promotions = new PromotionCollection();

        if (!empty($promotionIds)) {
            $criteria = new Criteria($promotionIds);
            $criteria->addAssociation('cartRules');
            /** @var PromotionCollection $promotions */
            $promotions = $this->promotionRepository->search($criteria, $context->getContext())->getEntities();
        }

        return $promotions;
    }

    private function checkRuleType(Container $rule): bool
    {
        foreach ($rule->getRules() as $nestedRule) {
            if ($nestedRule instanceof Container && $this->checkRuleType($nestedRule) === false) {
                return false;
            }
            if ($nestedRule instanceof PaymentMethodRule) {
                return false;
            }
        }

        return true;
    }

    private function checkPromotion(PromotionEntity $promotion): bool
    {
        foreach ($promotion->getCartRules() as $cartRule) {
            if ($this->checkCartRule($cartRule) === false) {
                return false;
            }
        }

        return true;
    }

    private function checkCartRule(RuleEntity $cartRule): bool
    {
        $payload = $cartRule->getPayload();
        foreach ($payload->getRules() as $rule) {

The method getRules() does not exist on Shopware\Core\Framework\Rule\Rule. It seems like you code against a sub-type of Shopware\Core\Framework\Rule\Rule such as Shopware\Core\Framework\Rule\Container\FilterRule or Shopware\Core\Framework\Rule\Container\Container.

            if ($this->checkRuleType($rule) === false) {
                return false;
            }
        }

        return true;
    }

    private function filterOldOrders(EntitySearchResult $orders): EntitySearchResult
    {
        // Search with deepLinkCode needs updatedAt Filter
        $latestOrderDate = (new \DateTime())->setTimezone(new \DateTimeZone('UTC'))->modify(-abs(30) . ' Day');
        $orders = $orders->filter(function (OrderEntity $order) use ($latestOrderDate) {
            return $order->getCreatedAt() > $latestOrderDate || $order->getUpdatedAt() > $latestOrderDate;
        });

        return $orders;
    }

    private function checkGuestAuth(OrderEntity $order, Request $request): void
    {
        $orderCustomer = $order->getOrderCustomer();
        $guest = $orderCustomer !== null && $orderCustomer->getCustomer() !== null && $orderCustomer->getCustomer()->getGuest();
        // Throw exception when customer is not guest
        if (!$guest) {
            throw new CustomerNotLoggedInException();
        }
        // Verify email and zip code with this order
        if ($request->get('email', false) && $request->get('zipcode', false)) {
            $billingAddress = $order->getAddresses() !== null ? $order->getAddresses()->get($order->getBillingAddressId()) : null;
            if ($billingAddress === null
                || $orderCustomer === null
                || $request->get('email') !== $orderCustomer->getEmail()
                || $request->get('zipcode') !== $billingAddress->getZipcode()) {
                throw new WrongGuestCredentialsException();
            }
        } else {
            throw new GuestNotAuthenticatedException();
        }
    }
}