HasAddresses::addAddress() - Code Metrics - chuckcms/addresses - Measure and Improve Code Quality continuously with Scrutinizer

HasAddresses::addAddress() A
last analyzed 2021-09-07 11:07 UTC

↳ Parent: HasAddresses
Complexity

Conditions	1
Paths	1
Size

Total Lines	5
Code Lines	2
Duplication

Lines	0
Ratio	0 %
Importance

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

namespace Chuckcms\Addresses\Traits;

use Chuckcms\Addresses\Contracts\Address;
use Chuckcms\Addresses\Exceptions\FailedValidation;
use Chuckcms\Addresses\Models\Address as AddressModel;
use Illuminate\Database\Eloquent\Relations\MorphMany;
use Illuminate\Support\Collection;
use Illuminate\Validation\Validator;
filter:
    dependency_paths: ["lib/*"]

trait HasAddresses
{
    private $addressClass;

    /**
     * Boot the addressable trait for the model.
     *
     * @return void
     */
    public static function bootHasAddresses()
    {
        static::deleting(function (self $model) {
            if (method_exists($model, 'isForceDeleting') && $model->isForceDeleting()) {
                $model->addresses()->forceDelete();

                return;
            }

            $model->addresses()->delete();
        });
    }

    public function getAddressClass()
    {
        if (!isset($this->addressClass)) {
            $this->addressClass = config('addresses.models.address');
            $this->addressClass = /** @scrutinizer ignore-call */ config('addresses.models.address');
        }

        return $this->addressClass;
    }

    /**
     * A model may have multiple addresses.
     *
     * @return MorphMany
     */
    public function addresses(): MorphMany
    {
        return $this->morphMany(
        return $this->/** @scrutinizer ignore-call */ morphMany(
            config('addresses.models.address'),
            config('addresses.models.address'),
            config('addresses.column_names.model_morph_name'),
            config('addresses.column_names.model_morph_type'),
            config('addresses.column_names.model_morph_key')
        );
    }

    /**
     * Check if model has addresses.
     *
     * @return bool
     */
    public function hasAddresses(): bool
    {
        return (bool) count($this->addresses);

    }

    /**
     * Add an address to this model.
     *
     * @param array $attributes
     *
     * @throws Exception
     *
     * @return mixed
     */
    public function addAddress(array $attributes)
    {
        $attributes = $this->loadAddressAttributes($attributes);

        return $this->addresses()->create($attributes);
    }

    /**
     * Updates the given address.
     *
     * @param Address $address
     * @param array   $attributes
     *
     * @throws Exception
     *
     * @return bool
     */
    public function updateAddress(Address $address, array $attributes): bool
    {
        $attributes = $this->loadAddressAttributes($attributes);

        return $address->fill($attributes)->save();
        return $address->/** @scrutinizer ignore-call */ fill($attributes)->save();
    }

    /**
     * Deletes given address(es).
     *
     * @param int|array|\Chuck\Address\Contracts\Address $addresses
filter:
    dependency_paths: ["lib/*"]
     * @param bool                                       $force
     *
     * @throws Exception
     *
     * @return mixed
     */
    public function deleteAddress($addresses, $force = false): bool
    {
        if (is_int($addresses) && $this->hasAddress($addresses)) {
            return $force ?
                    $this->addresses()->where('id', $addresses)->forceDelete() :
                    $this->addresses()->where('id', $addresses)->delete();
        }

        if ($addresses instanceof Address && $this->hasAddress($addresses)) {
            return $force ?
                    $this->addresses()->where('id', $addresses->id)->forceDelete() :

                    $this->addresses()->where('id', $addresses->id)->delete();
        }

        if (is_array($addresses)) {
            foreach ($addresses as $address) {
                if ($this->deleteAddress($address, $force)) {
                    continue;
                }
            }

            return true;
        }

        return false;
    }

    /**
     * Forcefully deletes given address(es).
     *
     * @param int|array|\Chuck\Address\Contracts\Address $addresses
     * @param bool                                       $force
     *
     * @throws Exception
     *
     * @return mixed
     */
    public function forceDeleteAddress($addresses): bool
    {
        return $this->deleteAddress($addresses, true);
    }

    /**
     * Determine if the model has (one of) the given address(es).
     *
     * @param int|array|\Chuck\Address\Contracts\Address|\Illuminate\Support\Collection $addresses
     *
     * @return bool
     */
    public function hasAddress($addresses): bool
    {
        if (is_int($addresses)) {
            return $this->addresses->contains('id', $addresses);

        }

        if ($addresses instanceof Address) {
            return $this->addresses->contains('id', $addresses->id);
        }

        if (is_array($addresses)) {
            foreach ($addresses as $address) {
                if ($this->hasAddress($address)) {
                    return true;
                }
            }

            return false;
        }

        return $addresses->intersect($this->addresses)->isNotEmpty();
    }

    public function getAddressLabels(): Collection
    {
        return $this->addresses->pluck('label');

    }

    /**
     * Get the public address.
     *
     * @param string $direction
     *
     * @return Address|null
     */
    public function getPublicAddress(string $direction = 'desc'): ?Address
    {
        return $this->addresses()
                    ->isPublic()
                    ->orderBy('is_public', $direction)
                    ->first();
    }

    /**
     * Get the primary address.
     *
     * @param string $direction
     *
     * @return Address|null
     */
    public function getPrimaryAddress(string $direction = 'desc'): ?Address
    {
        return $this->addresses()
                    ->isPrimary()
                    ->orderBy('is_primary', $direction)
                    ->first();
    }

    /**
     * Get the billing address.
     *
     * @param string $direction
     *
     * @return Address|null
     */
    public function getBillingAddress(string $direction = 'desc'): ?Address
    {
        return $this->addresses()
                    ->isBilling()
                    ->orderBy('is_billing', $direction)
                    ->first();
    }

    /**
     * Get the first shipping address.
     *
     * @param string $direction
     *
     * @return Address|null
     */
    public function getShippingAddress(string $direction = 'desc'): ?Address
    {
        return $this->addresses()
                    ->isShipping()
                    ->orderBy('is_shipping', $direction)
                    ->first();
    }

    /**
     * Add country id to attributes array.
     *
     * @param array $attributes
     *
     * @throws FailedValidation
     *
     * @return array
     */
    public function loadAddressAttributes(array $attributes): array
    {
        if (!isset($attributes['label'])) {
            throw new FailedValidation('[Addresses] No label given.');
        }

        $validator = $this->validateAddress($attributes);

        if ($validator->fails()) {
            $errors = $validator->errors()->all();
            $error = '[Addresses] '.implode(' ', $errors);

            throw new FailedValidation($error);
        }

        return $attributes;
    }

    /**
     * Validate the address.
     *
     * @param array $attributes
     *
     * @return Validator
     */
    public function validateAddress(array $attributes): Validator
    {
        $rules = (new AddressModel())->getValidationRules();

        return validator($attributes, $rules);
        return /** @scrutinizer ignore-call */ validator($attributes, $rules);
    }
}

chuckcms / addresses

HasAddresses::addAddress() A last analyzed 2021-09-07 11:07 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

HasAddresses::addAddress() A
last analyzed 2021-09-07 11:07 UTC
