flipbox\organizations\relationships\UserRelationship

Complexity

Total Complexity

44

Size/Duplication

Total Lines	306
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	12

Test Coverage

Coverage

0%

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	getCollection()	0	11	2
A	createCollectionFromRelations()	0	25	4
A	existingRelationships()	0	8	1
A	elementQuery()	0	7	2
A	associationQuery()	0	10	2
A	create()	0	10	2
A	delta()	0	31	5
A	hasChanged()	0	8	4
A	sync()	0	15	2
A	insertCollection()	0	9	3
A	updateCollection()	0	12	3
A	findKey()	0	17	4
A	findRelationshipKey()	0	11	4
A	resolveObjectInternal()	0	20	5

<?php

/**
 * @copyright  Copyright (c) Flipbox Digital Limited
 * @license    https://flipboxfactory.com/software/organization/license
 * @link       https://www.flipboxfactory.com/software/organization/
 */

namespace flipbox\organizations\relationships;

use craft\elements\db\UserQuery;
use craft\elements\User;
use craft\helpers\ArrayHelper;
use flipbox\organizations\elements\Organization;
use flipbox\organizations\Organizations;
use flipbox\organizations\queries\UserAssociationQuery;
use flipbox\organizations\records\UserAssociation;
use Tightenco\Collect\Support\Collection;

/**
 * Manages Users associated to Organizations
 *
 * @author Flipbox Factory <hello@flipboxfactory.com>
 * @since 2.0.0
 *
 * @method UserAssociation findOrCreate($object)
 * @method UserAssociation findOne($object = null)
 * @method UserAssociation findOrFail($object)
 */
class UserRelationship implements RelationshipInterface
{
    use RelationshipTrait;

    /**
     * @var Organization
     */
    private $organization;

    /**
     * @param Organization $organization
     */
    public function __construct(Organization $organization)
    {
        $this->organization = $organization;
    }


    /************************************************************
     * COLLECTION
     ************************************************************/

    /**
     * Get a collection of associated users
     *
     * @return User[]|Collection
     */
    public function getCollection(): Collection
    {
        if (null === $this->relations) {
            return new Collection(
                $this->elementQuery()
                    ->all()
            );
        }

        return $this->createCollectionFromRelations();
    }

    /**
     * @return Collection
     */
    protected function createCollectionFromRelations()
    {
        $ids = $this->getRelationships()->pluck('userId')->all();
        if (empty($ids)) {
            return $this->getRelationships()->pluck('user');
        }

        // 'eager' load where we'll pre-populate all of the elements
        $elements = $this->elementQuery()
            ->id($ids)
            ->indexBy('id')
            ->all();

        return $this->getRelationships()
            ->transform(function (UserAssociation $association) use ($elements) {
                if (!$association->isUserSet() && isset($elements[$association->getUserId()])) {

The method isUserSet does not exist on object<flipbox\organizations\records\UserAssociation>? Since you implemented __call, maybe consider adding a @method annotation.

                    $association->setUser($elements[$association->getUserId()]);
                }

                $association->setOrganization($this->organization);

                return $association;
            })
            ->pluck('user');
    }

    /**
     * @return Collection
     */
    protected function existingRelationships(): Collection
    {
        $relationships = $this->associationQuery()
            ->with('types')
            ->all();

        return $this->createRelations($relationships);
    }

    /************************************************************
     * QUERY
     ************************************************************/

    /**
     * @return UserQuery
     */
    private function elementQuery(): UserQuery
    {
        return User::find()
            ->organizationId($this->organization->getId() ?: false)
            ->anyStatus()
            ->limit(null);
    }

    /**
     * @return UserAssociationQuery
     */
    private function associationQuery(): UserAssociationQuery
    {
        /** @noinspection PhpUndefinedMethodInspection */
        return UserAssociation::find()
            ->setOrganizationId($this->organization->getId() ?: false)

It seems like $this->organization->getId() ?: false can also be of type false; however, flipbox\organizations\queries\OrganizationAttributeTrait::setOrganizationId() does only seem to accept string|array<integer,string>|integer|array<integer,integer>|object<flipbox\organizations\elements\Organization>|array<integer,object<flipbox\organizations\elements\Organization>>|null, did you maybe forget to handle an error condition?

            ->orderBy([
                'organizationOrder' => SORT_ASC
            ])
            ->limit(null);
    }

    /************************************************************
     * CREATE
     ************************************************************/

    /**
     * @param $object
     * @return UserAssociation
     */
    protected function create($object): UserAssociation
    {
        if ($object instanceof UserAssociation) {
            return $object;
        }

        return (new UserAssociation())
            ->setOrganization($this->organization)
            ->setUser($this->resolveObject($object));
    }


    /*******************************************
     * DELTA
     *******************************************/

    /**
     * @inheritDoc
     */
    protected function delta(): array
    {
        $existingAssociations = $this->associationQuery()
            ->indexBy('userId')
            ->all();

        $associations = [];
        $order = 1;

        /** @var UserAssociation $newAssociation */
        foreach ($this->getRelationships() as $newAssociation) {
            $association = ArrayHelper::remove(
                $existingAssociations,
                $newAssociation->getUserId()
            );

            $newAssociation->userOrder = $order++;

            /** @var UserAssociation $association */
            $association = $association ?: $newAssociation;

            // Has anything changed?
            if (!$association->getIsNewRecord() && !$this->hasChanged($newAssociation, $association)) {
                continue;
            }

            $associations[] = $this->sync($association, $newAssociation);
        }

        return [$associations, $existingAssociations];
    }

    /**
     * @param UserAssociation $new
     * @param UserAssociation $existing
     * @return bool
     */
    private function hasChanged(UserAssociation $new, UserAssociation $existing): bool
    {
        return (Organizations::getInstance()->getSettings()->getEnforceUserSortOrder() &&
                $new->userOrder != $existing->userOrder
            ) ||
            $new->state != $existing->state ||
            $new->getTypes()->isMutated();
    }

    /**
     * @param UserAssociation $from
     * @param UserAssociation $to
     *
     * @return UserAssociation
     */
    private function sync(UserAssociation $to, UserAssociation $from): UserAssociation
    {
        $to->userOrder = $from->userOrder;
        $to->state = $from->state;

        if ($from->getTypes()->isMutated()) {
            $to->getTypes()->clear()->add(
                $from->getTypes()->getCollection()
            );
        }

        $to->ignoreSortOrder();

        return $to;
    }


    /*******************************************
     * COLLECTION UTILS
     *******************************************/

    /**
     * @inheritDoc
     */
    protected function insertCollection(Collection $collection, UserAssociation $association)
    {
        if (Organizations::getInstance()->getSettings()->getEnforceUserSortOrder() && $association->userOrder > 0) {
            $collection->splice($association->userOrder - 1, 0, [$association]);
            return;
        }

        $collection->push($association);
    }

    /**
     * @inheritDoc
     */
    protected function updateCollection(Collection $collection, UserAssociation $association)
    {
        if (!Organizations::getInstance()->getSettings()->getEnforceUserSortOrder()) {
            return;
        }

        if (null !== ($key = $this->findKey($association))) {
            $collection->offsetUnset($key);
        }

        $this->insertCollection($collection, $association);
    }


    /*******************************************
     * UTILS
     *******************************************/

    /**
     * @param UserAssociation|User|int|array|null $object
     * @return int|null
     */
    protected function findKey($object = null)
    {
        if ($object instanceof UserAssociation) {
            if (!$object->getUser()) {
                var_dump("NOT FOUND");

var_dump('NOT FOUND'); looks like debug code. Are you sure you do not want to remove it? This might expose sensitive data.

                return null;
            }

            return $this->findRelationshipKey($object->getUser()->email);
        }

        if (null === ($element = $this->resolveObject($object))) {
            return null;
        }

        return $this->findRelationshipKey($element->email);
    }

    /**
     * @param $identifier
     * @return int|string|null
     */
    private function findRelationshipKey($identifier)
    {
        /** @var UserAssociation $association */
        foreach ($this->getRelationships()->all() as $key => $association) {
            if (null !== $association->getUser() && $association->getUser()->email == $identifier) {
                return $key;
            }
        }

        return null;
    }

    /**
     * @param UserAssociation|User|int|array|null $user
     * @return User|null
     */
    protected function resolveObjectInternal($user)
    {
        if ($user instanceof UserAssociation) {
            return $user->getUser();
        }

        if ($user instanceof User) {
            return $user;
        }

        if (is_numeric($user)) {
            return \Craft::$app->getUsers()->getUserById($user);
        }

        if (is_string($user)) {
            return \Craft::$app->getUsers()->getUserByUsernameOrEmail($user);
        }

        return User::findOne($user);

The expression \craft\elements\User::findOne($user); of type craft\base\Element|null|craft\base\Element[] adds the type craft\base\Element[] to the return on line 333 which is incompatible with the return type documented by flipbox\organizations\relationships\UserRelationship::resolveObjectInternal of type craft\elements\User|null.

    }
}