Chuckcms\Contacts\Traits\HasContacts

Complexity

Total Complexity

42

Size/Duplication

Total Lines	335
Duplicated Lines	0 %

Importance

Changes	2
Bugs	1	Features	0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	removeContact()	0	7	1
A	bootHasContacts()	0	10	3
A	getPrimaryContact()	0	6	1
A	contacts()	0	8	1
A	syncContacts()	0	5	1
A	forceDeleteContact()	0	3	1
A	getContactFirstNames()	0	3	1
A	assignContact()	0	38	5
A	getContactClass()	0	7	2
A	updateContact()	0	5	1
A	getStoredContact()	0	9	2
A	loadContactAttributes()	0	16	3
A	validateContact()	0	5	1
A	hasContacts()	0	3	1
A	addContact()	0	8	1
A	getPublicContact()	0	6	1
B	deleteContact()	0	25	10
A	hasContact()	0	21	6

<?php

namespace Chuckcms\Contacts\Traits;

use Illuminate\Support\Collection;
use Illuminate\Validation\Validator;

The type Illuminate\Validation\Validator was not found. Maybe you did not declare it correctly or list all dependencies?

use Chuckcms\Contacts\Contracts\Contact;
use Chuckcms\Contacts\Exceptions\FailedValidation;
use Chuckcms\Contacts\Models\Contact as ContactModel;
use Illuminate\Database\Eloquent\Relations\MorphToMany;

trait HasContacts
{
    private $contactClass;

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

                return;
            }

            $model->contacts()->detach();
        });
    }

    public function getContactClass()
    {
        if (!isset($this->contactClass)) {
            $this->contactClass = config('contacts.models.contact');

The function config was not found. Maybe you did not declare it correctly or list all dependencies?

        }

        return $this->contactClass;
    }

    /**
     * A model may have multiple contacts.
     *
     * @return MorphToMany
     */
    public function contacts(): MorphToMany
    {
        return $this->morphToMany(

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

            config('contacts.models.contact'),

The function config was not found. Maybe you did not declare it correctly or list all dependencies?

            'model',
            config('contacts.table_names.model_has_contacts'),
            config('contacts.column_names.model_morph_key'),
            'contact_id'
        );
    }

    /**
     * Assign the given contacts to the model. (credit to Spatie)
     *
     * @param array|int|\Chuckcms\Contacts\Contracts\Contact ...$contacts
     *
     * @return $this
     */
    public function assignContact(...$contacts)
    {
        $contacts = collect($contacts)

$contacts of type array<integer,Chuckcms\Contacts\Contracts\Contact|array|integer> is incompatible with the type Illuminate\Contracts\Support\Arrayable expected by parameter $value of collect().

            ->flatten()
            ->map(function ($contact) {
                if (empty($contact)) {
                    return false;
                }

                return $this->getStoredContact($contact);
            })
            ->filter(function ($contact) {
                return $contact instanceof Contact;
            })
            ->map->id
            ->all();

        $model = $this->getModel();

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

        if ($model->exists) {
            $this->contacts()->sync($contacts, false);
            $model->load('contacts');
        } else {
            $class = \get_class($model);

            $class::saved(
                function ($object) use ($contacts, $model) {
                    static $modelLastFiredOn;
                    if ($modelLastFiredOn !== null && $modelLastFiredOn === $model) {
                        return;
                    }
                    $object->contacts()->sync($contacts, false);
                    $object->load('contacts');
                    $modelLastFiredOn = $object;
                });
        }

        return $this;
    }

    /**
     * Revoke the given contact from the model.
     *
     * @param int|\Chuckcms\Contacts\Contracts\Contact $contact
     */
    public function removeContact($contact)
    {
        $this->contacts()->detach($this->getStoredContact($contact));

        $this->load('contacts');

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

        return $this;
    }

    /**
     * Remove all current contacts and set the given ones.
     *
     * @param array|int|\Chuckcms\Contacts\Contracts\Contact ...$contacts
     *
     * @return $this
     */
    public function syncContacts(...$contacts)
    {
        $this->contacts()->detach();

        return $this->assignContact($contacts);
    }

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

The property contacts does not exist on Chuckcms\Contacts\Traits\HasContacts. Did you mean contactClass?

    }

    /**
     * Add a contact to this model.
     *
     * @param array $attributes
     *
     * @throws Exception
     *
     * @return mixed
     */
    public function addContact(array $attributes)
    {
        $attributes = $this->loadContactAttributes($attributes);
        
        $contact = $this->getContactClass();
        $contact = $contact::create($attributes);

        return $this->assignContact($contact);
    }

    /**
     * Updates the given contact.
     *
     * @param Contact $contact
     * @param array   $attributes
     *
     * @throws Exception
     *
     * @return bool
     */
    public function updateContact(Contact $contact, array $attributes): bool
    {
        $attributes = $this->loadContactAttributes($attributes);

        return $contact->fill($attributes)->save();

The method fill() does not exist on Chuckcms\Contacts\Contracts\Contact. Since it exists in all sub-types, consider adding an abstract or default implementation to Chuckcms\Contacts\Contracts\Contact.

    }

    /**
     * Deletes given contact(s).
     *
     * @param int|array|\Chuckcms\Contacts\Contracts\Contact $contacts
     * @param bool                                           $force
     *
     * @throws Exception
     *
     * @return mixed
     */
    public function deleteContact($contacts, $force = false): bool
    {
        if (is_int($contacts) && $this->hasContact($contacts)) {
            return $force ?
                    $this->contacts()->where('id', $contacts)->forceDelete() :
                    $this->contacts()->where('id', $contacts)->delete();
        }

        if ($contacts instanceof Contact && $this->hasContact($contacts)) {
            return $force ?
                    $this->contacts()->where('id', $contacts->id)->forceDelete() :

Accessing id on the interface Chuckcms\Contacts\Contracts\Contact suggest that you code against a concrete implementation. How about adding an instanceof check?

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

        if (is_array($contacts)) {
            foreach ($contacts as $contact) {
                if ($this->deleteContact($contact, $force)) {
                    continue;
                }
            }

            return true;
        }

        return false;
    }

    /**
     * Forcefully deletes given contact(s).
     *
     * @param int|array|\Chuck\Contact\Contracts\Contact $contacts

The type Chuck\Contact\Contracts\Contact was not found. Maybe you did not declare it correctly or list all dependencies?

     * @param bool                                       $force
     *
     * @throws Exception
     *
     * @return mixed
     */
    public function forceDeleteContact($contacts): bool
    {
        return $this->deleteContact($contacts, true);
    }

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

The property contacts does not exist on Chuckcms\Contacts\Traits\HasContacts. Did you mean contactClass?

        }

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

        if (is_array($contacts)) {
            foreach ($contacts as $contact) {
                if ($this->hasContact($contact)) {
                    return true;
                }
            }

            return false;
        }

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

    public function getContactFirstNames(): Collection
    {
        return $this->contacts->pluck('first_name');

The property contacts does not exist on Chuckcms\Contacts\Traits\HasContacts. Did you mean contactClass?

    }

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

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

    /**
     * Load and validate the contact attributes array.
     *
     * @param array $attributes
     *
     * @throws FailedValidation
     *
     * @return array
     */
    public function loadContactAttributes(array $attributes): array
    {
        if (!isset($attributes['first_name'])) {
            throw new FailedValidation('[Contacts] No first name given.');
        }

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

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

            throw new FailedValidation($error);
        }

        return $attributes;
    }

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

        return validator($attributes, $rules);

The function validator was not found. Maybe you did not declare it correctly or list all dependencies?

    }

    protected function getStoredContact($contact): Contact
    {
        $contactClass = $this->getContactClass();

        if (is_numeric($contact)) {
            return $contactClass::findById($contact);
        }

        return $contact;
    }
}