SubscriptionController::startSubscriptionWithPaymentDetails() - Code Metrics - Inspection of "[Billing] Update" - getparthenon/parthenon - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — main ( dc7994...b21dd6 )

by Iain

created 2023-04-11 16:18 UTC

startSubscriptionWithPaymentDetails() B

↳ Parent: SubscriptionController

Complexity

Conditions	8
Paths	33

Size

Total Lines	53
Code Lines	29

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	1	Features	0

Metric	Value
cc	8
eloc	29
nc	33
nop	6
dl	0
loc	53
rs	8.2114
c	1
b	1
f	0

How to fix Long Method

<?php

declare(strict_types=1);

/*
 * Copyright Iain Cambridge 2020-2023.
 *
 * Use of this software is governed by the Business Source License included in the LICENSE file and at https://getparthenon.com/docs/next/license.
 *
 * Change Date: TBD ( 3 years after 2.2.0 release )
 *
 * On the date above, in accordance with the Business Source License, use of this software will be governed by the open source license specified in the LICENSE file.
 */

namespace Parthenon\Billing\Controller;

use Obol\Exception\UnsupportedFunctionalityException;
use Parthenon\Billing\CustomerProviderInterface;
use Parthenon\Billing\Dto\StartSubscriptionDto;
use Parthenon\Billing\Exception\NoCustomerException;
use Parthenon\Billing\Exception\NoPlanFoundException;
use Parthenon\Billing\Exception\NoPlanPriceFoundException;
use Parthenon\Billing\Repository\CustomerRepositoryInterface;
use Parthenon\Billing\Repository\SubscriptionRepositoryInterface;
use Parthenon\Billing\Response\StartSubscriptionResponse;
use Parthenon\Billing\Subscription\SubscriptionManagerInterface;
use Parthenon\Common\Exception\NoEntityFoundException;
use Parthenon\Common\LoggerAwareTrait;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;
use Symfony\Component\Serializer\SerializerInterface;
use Symfony\Component\Validator\Validator\ValidatorInterface;

class SubscriptionController
{
    use LoggerAwareTrait;

    #[Route('/billing/subscription/{subscriptionId}/cancel', name: 'parthenon_billing_subscription_cancel', methods: ['POST'])]
    public function cancelSubscription(Request $request, SubscriptionRepositoryInterface $subscriptionRepository, SubscriptionManagerInterface $subscriptionManager): Response
    {
        try {
            $subscription = $subscriptionRepository->getById($request->get('subscriptionId'));
        } catch (NoEntityFoundException $E) {
            return new JsonResponse(status: JsonResponse::HTTP_NOT_FOUND);
        }

        $subscriptionManager->cancelSubscriptionAtEndOfCurrentPeriod($subscription);

        return new JsonResponse(status: JsonResponse::HTTP_ACCEPTED);
    }

    #[Route('/billing/subscription/start', name: 'parthenon_billing_subscription_start_with_payment_details', methods: ['POST'])]
    public function startSubscriptionWithPaymentDetails(
        Request $request,
        CustomerProviderInterface $customerProvider,
        SerializerInterface $serializer,
        CustomerRepositoryInterface $customerRepository,
        ValidatorInterface $validator,
        SubscriptionManagerInterface $subscriptionManager,
    ): Response {
        $this->getLogger()->info('Starting the subscription');

        try {
            $customer = $customerProvider->getCurrentCustomer();
        } catch (NoCustomerException $exception) {
            $this->getLogger()->error('No customer found when starting subscription with payment details - probable misconfigured firewall.');

            return new JsonResponse(StartSubscriptionResponse::createGeneralError(), JsonResponse::HTTP_BAD_REQUEST);
        }

        try {
            /** @var StartSubscriptionDto $subscriptionDto */
            $subscriptionDto = $serializer->deserialize($request->getContent(), StartSubscriptionDto::class, 'json');

            $errors = $validator->validate($subscriptionDto);

            if (count($errors) > 0) {
                return new JsonResponse(StartSubscriptionResponse::createInvalidRequestResponse($errors), JsonResponse::HTTP_BAD_REQUEST);
            }

            $subscription = $subscriptionManager->startSubscriptionWithDto($customer, $subscriptionDto);

            $customerRepository->save($customer);
        } catch (NoEntityFoundException $exception) {
            return new JsonResponse(StartSubscriptionResponse::createGeneralError(), JsonResponse::HTTP_BAD_REQUEST);
        } catch (NoPlanPriceFoundException $exception) {
            $this->getLogger()->warning('No price plan found');

            return new JsonResponse(StartSubscriptionResponse::createPlanPriceNotFound(), JsonResponse::HTTP_BAD_REQUEST);
        } catch (NoPlanFoundException $exception) {
            $this->getLogger()->warning('No plan found');

            return new JsonResponse(StartSubscriptionResponse::createPlanNotFound(), JsonResponse::HTTP_BAD_REQUEST);
        } catch (UnsupportedFunctionalityException $exception) {
            $this->getLogger()->error('Payment provider does not support payment details');

            return new JsonResponse(StartSubscriptionResponse::createUnsupportedPaymentProvider(), JsonResponse::HTTP_BAD_REQUEST);
        } catch (\Throwable $t) {
            $this->getLogger()->error('Unknown error while starting a subscription');

            throw $t;
        }

        return new JsonResponse(StartSubscriptionResponse::createSuccessResponse($subscription), JsonResponse::HTTP_CREATED);
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/*
6			* Copyright Iain Cambridge 2020-2023.
7			*
8			* Use of this software is governed by the Business Source License included in the LICENSE file and at https://getparthenon.com/docs/next/license.
9			*
10			* Change Date: TBD ( 3 years after 2.2.0 release )
11			*
12			* On the date above, in accordance with the Business Source License, use of this software will be governed by the open source license specified in the LICENSE file.
13			*/
14
15			namespace Parthenon\Billing\Controller;
16
17			use Obol\Exception\UnsupportedFunctionalityException;
18			use Parthenon\Billing\CustomerProviderInterface;
19			use Parthenon\Billing\Dto\StartSubscriptionDto;
20			use Parthenon\Billing\Exception\NoCustomerException;
21			use Parthenon\Billing\Exception\NoPlanFoundException;
22			use Parthenon\Billing\Exception\NoPlanPriceFoundException;
23			use Parthenon\Billing\Repository\CustomerRepositoryInterface;
24			use Parthenon\Billing\Repository\SubscriptionRepositoryInterface;
25			use Parthenon\Billing\Response\StartSubscriptionResponse;
26			use Parthenon\Billing\Subscription\SubscriptionManagerInterface;
27			use Parthenon\Common\Exception\NoEntityFoundException;
28			use Parthenon\Common\LoggerAwareTrait;
29			use Symfony\Component\HttpFoundation\JsonResponse;
30			use Symfony\Component\HttpFoundation\Request;
31			use Symfony\Component\HttpFoundation\Response;
32			use Symfony\Component\Routing\Annotation\Route;
33			use Symfony\Component\Serializer\SerializerInterface;
34			use Symfony\Component\Validator\Validator\ValidatorInterface;
35
36			class SubscriptionController
37			{
38			use LoggerAwareTrait;
39
40			#[Route('/billing/subscription/{subscriptionId}/cancel', name: 'parthenon_billing_subscription_cancel', methods: ['POST'])]
41			public function cancelSubscription(Request $request, SubscriptionRepositoryInterface $subscriptionRepository, SubscriptionManagerInterface $subscriptionManager): Response
42			{
43			try {
44			$subscription = $subscriptionRepository->getById($request->get('subscriptionId'));
45			} catch (NoEntityFoundException $E) {
46			return new JsonResponse(status: JsonResponse::HTTP_NOT_FOUND);
47			}
48
49			$subscriptionManager->cancelSubscriptionAtEndOfCurrentPeriod($subscription);
50
51			return new JsonResponse(status: JsonResponse::HTTP_ACCEPTED);
52			}
53
54			#[Route('/billing/subscription/start', name: 'parthenon_billing_subscription_start_with_payment_details', methods: ['POST'])]
55			public function startSubscriptionWithPaymentDetails(
56			Request $request,
57			CustomerProviderInterface $customerProvider,
58			SerializerInterface $serializer,
59			CustomerRepositoryInterface $customerRepository,
60			ValidatorInterface $validator,
61			SubscriptionManagerInterface $subscriptionManager,
62			): Response {
63			$this->getLogger()->info('Starting the subscription');
64
65			try {
66			$customer = $customerProvider->getCurrentCustomer();
67			} catch (NoCustomerException $exception) {
68			$this->getLogger()->error('No customer found when starting subscription with payment details - probable misconfigured firewall.');
69
70			return new JsonResponse(StartSubscriptionResponse::createGeneralError(), JsonResponse::HTTP_BAD_REQUEST);
71			}
72
73			try {
74			/** @var StartSubscriptionDto $subscriptionDto */
75			$subscriptionDto = $serializer->deserialize($request->getContent(), StartSubscriptionDto::class, 'json');
76
77			$errors = $validator->validate($subscriptionDto);
78
79			if (count($errors) > 0) {
80			return new JsonResponse(StartSubscriptionResponse::createInvalidRequestResponse($errors), JsonResponse::HTTP_BAD_REQUEST);
81			}
82
83			$subscription = $subscriptionManager->startSubscriptionWithDto($customer, $subscriptionDto);
84
85			$customerRepository->save($customer);
86			} catch (NoEntityFoundException $exception) {
87			return new JsonResponse(StartSubscriptionResponse::createGeneralError(), JsonResponse::HTTP_BAD_REQUEST);
88			} catch (NoPlanPriceFoundException $exception) {
89			$this->getLogger()->warning('No price plan found');
90
91			return new JsonResponse(StartSubscriptionResponse::createPlanPriceNotFound(), JsonResponse::HTTP_BAD_REQUEST);
92			} catch (NoPlanFoundException $exception) {
93			$this->getLogger()->warning('No plan found');
94
95			return new JsonResponse(StartSubscriptionResponse::createPlanNotFound(), JsonResponse::HTTP_BAD_REQUEST);
96			} catch (UnsupportedFunctionalityException $exception) {
97			$this->getLogger()->error('Payment provider does not support payment details');
98
99			return new JsonResponse(StartSubscriptionResponse::createUnsupportedPaymentProvider(), JsonResponse::HTTP_BAD_REQUEST);
100			} catch (\Throwable $t) {
101			$this->getLogger()->error('Unknown error while starting a subscription');
102
103			throw $t;
104			}
105
106			return new JsonResponse(StartSubscriptionResponse::createSuccessResponse($subscription), JsonResponse::HTTP_CREATED);
107			}
108			}
109

getparthenon / parthenon

Push — main ( dc7994...b21dd6 )

startSubscriptionWithPaymentDetails() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like