MichaelRubel\Couponables\HasCoupons

Complexity

Total Complexity

9

Size/Duplication

Total Lines	113
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	6
Bugs	0	Features	1

7 Methods

Rating	Name	Duplication	Size	Complexity
A	redeemCoupon()	0	8	1
A	verifyCoupon()	0	6	1
A	isCouponRedeemed()	0	8	1
A	isCouponOverLimit()	0	6	2
A	coupons()	0	6	1
A	isCouponAlreadyUsed()	0	3	1
A	redeemOrNullifyCoupon()	0	11	2

<?php

declare(strict_types=1);

namespace MichaelRubel\Couponables;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\MorphToMany;
use Illuminate\Support\Str;
use MichaelRubel\Couponables\Exceptions\CouponException;
use MichaelRubel\Couponables\Models\Contracts\CouponContract;
use MichaelRubel\Couponables\Models\Contracts\CouponPivotContract;
use MichaelRubel\Couponables\Services\Contracts\CouponServiceContract;
use MichaelRubel\EnhancedContainer\Call;

trait HasCoupons
{
    /**
     * Polymorphic relation to the coupons.
     *
     * @return MorphToMany
     */
    public function coupons(): MorphToMany
    {
        return $this->morphToMany(app(CouponContract::class), Str::singular(

It seems like morphToMany() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            config('couponables.pivot_table', 'couponables')
        ))->withPivot(
            call(CouponPivotContract::class)->getRedeemedAtColumn()
        );
    }

    /**
     * Perform coupon verification.
     *
     * @param string|null $code
     *
     * @return CouponContract
     */
    public function verifyCoupon(?string $code): CouponContract
    {
        $service = call(CouponServiceContract::class);
        $proxy   = call($service->verifyCoupon($code, $this));

        return $proxy->getInternal(Call::INSTANCE);
    }

    /**
     * Use the coupon.
     *
     * @param string|null $code
     *
     * @return CouponContract
     */
    public function redeemCoupon(?string $code): CouponContract
    {
        $service = call(CouponServiceContract::class);
        $proxy   = call($service->verifyCoupon($code, $this));

        $coupon = $proxy->getInternal(Call::INSTANCE);

        return $service->applyCoupon($coupon, $this);
    }

    /**
     * Redeem the coupon.
     *
     * @param string|null $code
     * @param mixed|null  $rescue
     * @param bool        $report
     *
     * @return CouponContract|null
     */
    public function redeemOrNullifyCoupon(?string $code, mixed $rescue = null, bool $report = false): ?CouponContract
    {
        if ($code) {
            return rescue(
                callback: fn () => call($this)->redeemCoupon($code),
                rescue: $rescue,
                report: $report
            );
        }

        return null;
    }

    /**
     * Check if the coupon is already redeemed by the model at least once.
     *
     * @param string $code
     *
     * @return bool
     */
    public function isCouponRedeemed(string $code): bool
    {
        $column = call(CouponContract::class)
            ->getCodeColumn();

        return $this->coupons()
            ->where($column, $code)
            ->exists();
    }

    /**
     * Check if coupon with this code is already used.
     *
     * @param string|null $code
     *
     * @return bool
     */
    public function isCouponAlreadyUsed(?string $code): bool
    {
        return call($this)->isCouponRedeemed($code);
    }

    /**
     * Check if the coupon is over limit for the model.
     *
     * @param string|null $code
     *
     * @return bool
     *
     */
    public function isCouponOverLimit(?string $code): bool
    {
        $service = call(CouponServiceContract::class);
        $coupon  = $service->getCoupon($code);

        return ! is_null($coupon) && call($coupon)->isOverLimitFor($this);
    }
}