Phalcon\Cashier\Subscription

Complexity

Total Complexity

33

Size/Duplication

Total Lines	365
Duplicated Lines	0 %

Importance

Changes	3
Bugs	0	Features	0

22 Methods

Rating	Name	Duplication	Size	Complexity
A	initialize()	0	3	1
A	onTrial()	0	7	2
A	cancelled()	0	3	1
A	swap()	0	40	4
A	active()	0	3	2
A	decrementQuantity()	0	5	1
A	noProrate()	0	5	1
A	updateQuantity()	0	13	1
A	incrementQuantity()	0	5	1
A	user()	0	3	1
A	getSource()	0	3	1
A	onGracePeriod()	0	8	2
A	valid()	0	3	3
A	incrementAndInvoice()	0	7	1
A	anchorBillingCycleOn()	0	9	2
A	reactivate()	0	7	1
A	asStripeSubscription()	0	4	1
A	cancelNow()	0	8	1
A	resume()	0	28	3
A	cancel()	0	9	1
A	markAsCancelled()	0	3	1
A	syncTaxPercentage()	0	5	1

<?php

namespace Phalcon\Cashier;

use Carbon\Carbon;
use LogicException;
use DateTimeInterface;
use Baka\Database\Model;

class Subscription extends Model
{
    /**
     * The attributes that aren't mass assignable.
     *
     * @var array
     */
    protected $guarded = [];

    /**
     * The attributes that should be mutated to dates.
     *
     * @var array
     */
    protected $dates = [
        'trial_ends_at', 'ends_at',
        'created_at', 'updated_at',
    ];

    /**
     * Indicates if the plan change should be prorated.
     *
     * @var bool
     */
    protected $prorate = true;

    /**
     * The date on which the billing cycle should be anchored.
     *
     * @var string|null
     */
    protected $billingCycleAnchor = null;

    public function initialize()
    {
        $this->belongsTo('user_id', '\App\Models\Users', 'id', ['alias' => 'user']);
    }

    public function getSource(): string
    {
        return 'subscriptions';
    }

    /**
     * Get the user that owns the subscription.
     */
    public function user()
    {
        return $this->user;
    }

    /**
     * Determine if the subscription is active, on trial, or within its grace period.
     *
     * @return bool
     */
    public function valid()
    {
        return $this->active() || $this->onTrial() || $this->onGracePeriod();
    }

    /**
     * Determine if the subscription is active.
     *
     * @return bool
     */
    public function active()
    {
        return is_null($this->ends_at) || $this->onGracePeriod();
    }

    /**
     * Determine if the subscription is no longer active.
     *
     * @return bool
     */
    public function cancelled()
    {
        return !is_null($this->ends_at);
    }

    /**
     * Determine if the subscription is within its trial period.
     *
     * @return bool
     */
    public function onTrial()
    {
        if (!is_null($this->trial_ends_at)) {
            $trialEndsAt = new \DateTime($this->trial_ends_at);
            return Carbon::today()->lt(Carbon::instance($trialEndsAt));
        } else {
            return false;
        }
    }

    /**
     * Determine if the subscription is within its grace period after cancellation.
     *
     * @return bool
     */
    public function onGracePeriod()
    {
        $endsAt = new \DateTime($this->ends_at);

        if (!is_null($endsAt)) {
            return Carbon::now()->lt(Carbon::instance($endsAt));
        } else {
            return false;
        }
    }

    /**
     * Increment the quantity of the subscription.
     *
     * @param  int  $count
     * @return $this
     */
    public function incrementQuantity($count = 1)
    {
        $this->updateQuantity($this->quantity + $count);

        return $this;
    }

    /**
     *  Increment the quantity of the subscription, and invoice immediately.
     *
     * @param  int  $count
     * @return $this
     */
    public function incrementAndInvoice($count = 1)
    {
        $this->incrementQuantity($count);

        $this->user->invoice();

        return $this;
    }

    /**
     * Decrement the quantity of the subscription.
     *
     * @param  int  $count
     * @return $this
     */
    public function decrementQuantity($count = 1)
    {
        $this->updateQuantity(max(1, $this->quantity - $count));

        return $this;
    }

    /**
     * Update the quantity of the subscription.
     *
     * @param  int  $quantity
     * @param  \Stripe\Customer|null  $customer
     * @return $this
     */
    public function updateQuantity($quantity, $customer = null)
    {
        $subscription = $this->asStripeSubscription();

        $subscription->quantity = $quantity;

        $subscription->save();

        $this->quantity = $quantity;

The property quantity does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->save();

        return $this;
    }

    /**
     * Indicate that the plan change should not be prorated.
     *
     * @return $this
     */
    public function noProrate()
    {
        $this->prorate = false;

        return $this;
    }

    /**
     * Change the billing cycle anchor on a plan change.
     *
     * @param  int|string  $date
     * @return $this
     */
    public function anchorBillingCycleOn($date = 'now')
    {
        if ($date instanceof DateTimeInterface) {

$date is never a sub-type of DateTimeInterface.

            $date = $date->getTimestamp();
        }

        $this->billingCycleAnchor = $date;

        return $this;
    }

    /**
     * Swap the subscription to a new Stripe plan.
     *
     * @param  string  $plan
     * @return $this
     */
    public function swap($plan)
    {
        $subscription = $this->asStripeSubscription();

        $subscription->plan = $plan;

It seems like $plan of type string is incompatible with the declared type Stripe\Plan of property $plan.

        $subscription->prorate = $this->prorate;

        $subscription->cancel_at_period_end = false;

        if (!is_null($this->billingCycleAnchor)) {
            $subscription->billingCycleAnchor = $this->billingCycleAnchor;
        }

        // If no specific trial end date has been set, the default behavior should be
        // to maintain the current trial state, whether that is "active" or to run
        // the swap out with the exact number of days left on this current plan.
        if ($this->onTrial()) {
            $subscription->trial_end = strtotime($this->trial_ends_at);
        } else {
            $subscription->trial_end = 'now';

The property $trial_end was declared of type integer, but 'now' is of type string. Maybe add a type cast?

        }

        // Again, if no explicit quantity was set, the default behaviors should be to
        // maintain the current quantity onto the new plan. This is a sensible one
        // that should be the expected behavior for most developers with Stripe.
        if ($this->quantity) {
            $subscription->quantity = $this->quantity;
        }

        $subscription->save();

        $this->user->invoice();

        $this->update([
            'stripe_plan' => $plan,
            'ends_at' => null,
        ]);

        return $this;
    }

    /**
     * Cancel the subscription at the end of the billing period.
     *
     * @return $this
     */
    public function cancel()
    {
        $subscription = $this->asStripeSubscription();
        $subscription->cancel_at_period_end = true;
        $subscription->save();

        $this->markAsCancelled();

        return $this;
    }

    /**
     * Reactivate the subscription at the end of the billing period.
     *
     * @return $this
     */
    public function reactivate()
    {
        $subscription = $this->asStripeSubscription();
        $subscription->cancel_at_period_end = false;
        $subscription->save();

        return $this;
    }

    /**
     * Cancel the subscription immediately.
     *
     * @return $this
     */
    public function cancelNow()
    {
        $subscription = $this->asStripeSubscription();
        $subscription->cancel();

        $this->markAsCancelled();

        return $this;
    }

    /**
     * Mark the subscription as cancelled.
     *
     * @return void
     */
    public function markAsCancelled()
    {
        $this->update(['ends_at' => Carbon::now()->toDateTimeString()]);
    }

    /**
     * Resume the cancelled subscription.
     *
     * @return $this
     *
     * @throws \LogicException
     */
    public function resume()
    {
        if (!$this->onGracePeriod()) {
            throw new LogicException('Unable to resume subscription that is not within grace period.');
        }

        $subscription = $this->asStripeSubscription();

        $subscription->cancel_at_period_end = false;

        // To resume the subscription we need to set the plan parameter on the Stripe
        // subscription object. This will force Stripe to resume this subscription
        // where we left off. Then, we'll set the proper trial ending timestamp.
        $subscription->plan = $this->stripe_plan;

        if ($this->onTrial()) {
            $subscription->trial_end = strtotime($this->trial_ends_at);
        } else {
            $subscription->trial_end = 'now';

The property $trial_end was declared of type integer, but 'now' is of type string. Maybe add a type cast?

        }
        $subscription->save();

        // Finally, we will remove the ending timestamp from the user's record in the
        // local database to indicate that the subscription is active again and is
        // no longer "cancelled". Then we will save this record in the database.
        $this->update(['ends_at' => null]);

        return $this;
    }

    /**
     * Sync the tax percentage of the user to the subscription.
     *
     * @return void
     */
    public function syncTaxPercentage()
    {
        $subscription = $this->asStripeSubscription();
        $subscription->tax_percent = $this->user->taxPercentage();
        $subscription->save();
    }

    /**
     * Get the subscription as a Stripe subscription object.
     *
     * @return \Stripe\Subscription
     */
    public function asStripeSubscription()
    {
        $user = $this->user();
        return $user->asStripeCustomer()->subscriptions->retrieve($this->stripe_id);
    }
}