SubscriptionManager::startSubscriptionWithDto() - Code Metrics - Inspection of "[Billing] Add start subscription to billabear" - getparthenon/parthenon - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — main ( b21561...f38fd7 )

by Iain
created 2024-06-05 04:18 UTC
SubscriptionManager::startSubscriptionWithDto() A

↳ Parent: SubscriptionManager
Complexity

Conditions	1
Paths	1
Size

Total Lines	6
Code Lines	3
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	1
eloc	3
c	1
b	0
f	0
nc	1
nop	2
dl	0
loc	6
rs	10
<?php

declare(strict_types=1);

/*
 * Copyright (C) 2020-2024 Iain Cambridge
 *
 *     This program is free software: you can redistribute it and/or modify
 *     it under the terms of the GNU General Public License as published by
 *     the Free Software Foundation, either version 3 of the License, or
 *     (at your option) any later version.
 *
 *     This program is distributed in the hope that it will be useful,
 *     but WITHOUT ANY WARRANTY; without even the implied warranty of
 *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *     GNU General Public License for more details.
 *
 *     You should have received a copy of the GNU General Public License
 *     along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

namespace Parthenon\Billing\BillaBear;

use BillaBear\ApiException;
filter:
    dependency_paths: ["lib/*"]
use BillaBear\Model\SubscriptionStartBody;
filter:
    dependency_paths: ["lib/*"]
use Parthenon\Billing\Dto\StartSubscriptionDto;
use Parthenon\Billing\Entity\CustomerInterface;
use Parthenon\Billing\Entity\PaymentCard;
use Parthenon\Billing\Entity\Price;
use Parthenon\Billing\Entity\Subscription;
use Parthenon\Billing\Entity\SubscriptionPlan;
use Parthenon\Billing\Enum\BillingChangeTiming;
use Parthenon\Billing\Event\SubscriptionCreated;
use Parthenon\Billing\Exception\NoPaymentDetailsException;
use Parthenon\Billing\Exception\PaymentFailureException;
use Parthenon\Billing\Plan\Plan;
use Parthenon\Billing\Plan\PlanManagerInterface;
use Parthenon\Billing\Plan\PlanPrice;
use Parthenon\Billing\Subscription\SubscriptionManagerInterface;
use Parthenon\Common\Exception\GeneralException;
use Psr\Http\Message\ResponseInterface;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;

class SubscriptionManager implements SubscriptionManagerInterface
{
    public function __construct(
        private SdkFactory $sdkFactory,
        private PlanManagerInterface $planManager,
        private EventDispatcherInterface $dispatcher,
    ) {
    }

    public function startSubscription(
        CustomerInterface $customer,
        SubscriptionPlan|Plan $plan,
        Price|PlanPrice $planPrice,
        ?PaymentCard $paymentDetails = null,
        int $seatNumbers = 1,
        ?bool $hasTrial = null,
        ?int $trialLengthDays = 0,
    ): Subscription {
        if (!$plan instanceof Plan) {
            throw new GeneralException('Invalid type of plan given');
        }

        $customerId = $customer->getExternalCustomerReference();
        $payload = [
            'subscription_plan' => $plan->getEntityId(),
            'price' => $planPrice->getEntityId(),
            'price' => $planPrice->/** @scrutinizer ignore-call */ getEntityId(),
            'seat_numbers' => $seatNumbers,
        ];

        if ($paymentDetails) {
            $payload['payment_details'] = $paymentDetails->getId();
        }

        $subscriptionStart = new SubscriptionStartBody($payload);

        try {
            $response = $this->sdkFactory->createSubscriptionsApi()->customerStartSubscription($subscriptionStart, $customerId);
        } catch (ApiException $apiException) {
            if ($apiException->getResponseObject() instanceof ResponseInterface) {
                match ($apiException->getResponseObject()->getStatusCode()) {
                    402 => new PaymentFailureException('Payment failed', previous: $apiException),
                    406 => new NoPaymentDetailsException('No payment details', previous: $apiException),
                    default => new GeneralException(previous: $apiException),
                };
            }
            throw new GeneralException(previous: $apiException);
        } catch (\Throwable $exception) {
            new GeneralException($exception->getMessage(), previous: $exception);
        }
        $subscription = new Subscription();
        $subscription->setCustomer($customer);
        $subscription->setId($response->getId());
        $subscription->setValidUntil(new \DateTime($response->getValidUntil()));
        $subscription->setMainExternalReference($response->getMainExternalReference());
        $subscription->setChildExternalReference($response->getChildExternalReference());

        $this->dispatcher->dispatch(new SubscriptionCreated($subscription), SubscriptionCreated::NAME);

        return $subscription;
    }

    public function startSubscriptionWithDto(CustomerInterface $customer, StartSubscriptionDto $startSubscriptionDto): Subscription
    {
        $plan = $this->planManager->getPlanByName($startSubscriptionDto->getPlanName());
        $planPrice = $plan->getPriceForPaymentSchedule($startSubscriptionDto->getSchedule(), $startSubscriptionDto->getCurrency());

        return $this->startSubscription($customer, $plan, $planPrice, null, $startSubscriptionDto->getSeatNumbers());
    }

    public function cancelSubscriptionAtEndOfCurrentPeriod(Subscription $subscription): Subscription
    {
        // TODO: Implement cancelSubscriptionAtEndOfCurrentPeriod() method.
    }
interface ReturnsInt {
    public function returnsIntHinted(): int;
}

class MyClass implements ReturnsInt {
    public function returnsIntHinted(): int
    {
        if (foo()) {
            return 123;
        }
        // here: null is implicitly returned
    }
}

    public function cancelSubscriptionInstantly(Subscription $subscription): Subscription
    {
        // TODO: Implement cancelSubscriptionInstantly() method.
    }
interface ReturnsInt {
    public function returnsIntHinted(): int;
}

class MyClass implements ReturnsInt {
    public function returnsIntHinted(): int
    {
        if (foo()) {
            return 123;
        }
        // here: null is implicitly returned
    }
}

    public function cancelSubscriptionOnDate(Subscription $subscription, \DateTimeInterface $dateTime): Subscription
    {
        // TODO: Implement cancelSubscriptionOnDate() method.
    }
interface ReturnsInt {
    public function returnsIntHinted(): int;
}

class MyClass implements ReturnsInt {
    public function returnsIntHinted(): int
    {
        if (foo()) {
            return 123;
        }
        // here: null is implicitly returned
    }
}

    public function changeSubscriptionPrice(Subscription $subscription, Price $price, BillingChangeTiming $billingChangeTiming): void
    {
        // TODO: Implement changeSubscriptionPrice() method.
    }

    public function changeSubscriptionPlan(Subscription $subscription, SubscriptionPlan $plan, Price $price, BillingChangeTiming $billingChangeTiming): void
    {
        // TODO: Implement changeSubscriptionPlan() method.
    }
}

getparthenon / parthenon

Push — main ( b21561...f38fd7 )

SubscriptionManager::startSubscriptionWithDto() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
