TypesAttributeTrait::userTypeQuery() - Code Metrics - Inspection of "Merge branch 'develop'" - flipboxfactory/organizations - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( e381cf...9deca2 )

by Nate
created 2019-02-04 21:08 UTC
TypesAttributeTrait::userTypeQuery() A

↳ Parent: TypesAttributeTrait
Complexity

Conditions	2
Paths	2
Size

Total Lines
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	6
Importance

Changes
Metric	Value
dl	0
loc	15
ccs	0
cts	12
cp	0
rs	9.7666
c	0
b	0
f	0
cc	2
nc	2
nop	1
crap	6
<?php

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

namespace flipbox\organizations\elements;

use Craft;
use craft\helpers\ArrayHelper;
use flipbox\craft\ember\helpers\QueryHelper;
use flipbox\organizations\queries\OrganizationTypeQuery;
use flipbox\organizations\records\OrganizationType;
use flipbox\organizations\records\OrganizationType as TypeModel;
use flipbox\organizations\records\OrganizationTypeAssociation;

/**
 * @author Flipbox Factory <[email protected]>
 * @since 1.0.0
 */
trait TypesAttributeTrait
{
    /**
     * @var OrganizationTypeQuery
     */
    private $types;

    /**
     * @var TypeModel|false
     */
    private $activeType;

    /************************************************************
     * REQUEST
     ************************************************************/

    /**
     * AssociateUserToOrganization an array of types from request input
     *
     * @param string $identifier
     * @return $this
     */
    public function setTypesFromRequest(string $identifier = 'types')
    {
        if (null !== ($types = Craft::$app->getRequest()->getBodyParam($identifier))) {
            $this->setTypes((array) $types);
        }

        return $this;
    }

    /************************************************************
     * ACTIVE TYPE
     ************************************************************/

    /**
     * @param TypeModel|null $type
     * @return $this
     */
    public function setActiveType(TypeModel $type = null)
    {
        if ($type) {
            $this->addType($type);
        }

        $this->activeType = (null === $type) ? false : $type;
        return $this;
    }

    /**
     * @return TypeModel|null
     */
    public function getActiveType()
    {
        if (null === $this->activeType) {
            if (!$activeType = $this->getPrimaryType()) {
                $activeType = false;
            }

            $this->activeType = $activeType;
        }

        return (false === $this->activeType) ? null : $this->activeType;
    }

    /************************************************************
     * TYPES QUERY
     ************************************************************/

    /**
     * @param array $criteria
     * @return OrganizationTypeQuery
     */
    public function userTypeQuery($criteria = []): OrganizationTypeQuery
    {
        /** @noinspection PhpUndefinedMethodInspection */
        $query = OrganizationType::find()
            ->organization($this);

        if (!empty($criteria)) {
            QueryHelper::configure(
                $query,
                $criteria
            );
        }

        return $query;
    }
    
    /************************************************************
     * TYPES
     ************************************************************/

    /**
     * Get an array of types associated to an organization
     *
     * @param array $criteria
     * @return OrganizationTypeQuery
     */
    public function getTypes($criteria = [])
    {
        if (null === $this->types) {
            $this->types = $this->userTypeQuery();
        }

        if (!empty($criteria)) {
            QueryHelper::configure(
                $this->types,
                $criteria
            );
        }

        return $this->types;
    }

    /**
     * AssociateUserToOrganization types to an organization
     *
     * @param $types
     * @return $this
     */
    public function setTypes($types)
    {
        if ($types instanceof OrganizationTypeQuery) {
            $this->types = $types;
            return $this;
        }

        // Reset the query
        $this->types = $this->userTypeQuery();

        // Remove all types
        $this->types->setCachedResult([]);

        if (!empty($types)) {
            if (!is_array($types)) {
                $types = [$types];
            }

            $this->addTypes($types);
        }

        return $this;
    }

    /**
     * AssociateUserToOrganization an array of types to an organization
     *
     * @param $types
     * @return $this
     */
    public function addTypes(array $types)
    {
        // In case a config is directly passed
        if (ArrayHelper::isAssociative($types)) {
            $types = [$types];
        }

        foreach ($types as $key => $type) {
            // Ensure we have a model
            if (!$type instanceof OrganizationType) {
                $type = $this->resolveType($type);
            }

            $this->addType($type);
        }

        return $this;
    }

    /**
     * AssociateUserToOrganization a type to an organization
     *
     * @param OrganizationType $type
     * @return $this
     */
    public function addType(OrganizationType $type)
    {
        $currentTypes = $this->getTypes()->all();

        $indexedTypes = ArrayHelper::index(
            $currentTypes,
            'handle'
        );

        if (!array_key_exists($type->handle, $indexedTypes)) {
            $currentTypes[] = $type;
            $this->getTypes()->setCachedResult($currentTypes);
        }

        return $this;
    }

    /**
     * DissociateUserFromOrganization a type from an organization
     *
     * @param array $types
     * @return $this
     */
    public function removeTypes(array $types)
    {
        // In case a config is directly passed
        if (ArrayHelper::isAssociative($types)) {
            $types = [$types];
        }

        foreach ($types as $key => $type) {
            if (!$type instanceof OrganizationType) {
                $type = $this->resolveType($type);
            }

            $this->removeType($type);
        }

        return $this;
    }

    /**
     * @param mixed $type
     * @return OrganizationType
     */
    protected function resolveType($type): OrganizationType
    {
        if (null !== ($type = OrganizationType::findOne($type))) {
            return $type;
        }

        if (!is_array($type)) {
            $type = ArrayHelper::toArray($type, [], false);
        }

        return new OrganizationType($type);
    }

    /**
     * DissociateUserFromOrganization a type from an organization
     *
     * @param OrganizationType $type
     * @return $this
     */
    public function removeType(OrganizationType $type)
    {
        $indexedTypes = ArrayHelper::index(
            $this->getTypes()->all(),
            'handle'
        );

        // Does the type already exist?
        if (array_key_exists($type->handle, $indexedTypes)) {
            unset($indexedTypes[$type->handle]);

            $this->getTypes()->setCachedResult(
                array_values($indexedTypes)
            );
        }

        return $this;
    }

    /**
     * Reset types
     *
     * @return $this
     */
    public function resetTypes()
    {
        $this->types = null;
        return $this;
    }

    /**
     * Get an associated type by identifier (id/handle)
     *
     * @param $identifier
     * @return null|TypeModel
     */
    public function getType($identifier)
    {
        // Determine index type
        $indexBy = (is_numeric($identifier)) ? 'id' : 'handle';

        // Find all types
        $allTypes = ArrayHelper::index(
            $this->getTypes()->all(),
            $indexBy
        );

        return array_key_exists($identifier, $allTypes) ? $allTypes[$identifier] : null;
    }

    /**
     * Identify whether a type is associated to the element
     *
     * @param TypeModel|null $type
     * @return bool
     */
    public function hasType(TypeModel $type = null): bool
    {
        if (null === $type) {
            return !empty($this->getTypes());
        }

        return null !== $this->getType($type->id);
    }


    /************************************************************
     * PRIMARY TYPE
     ************************************************************/

    /**
     * Identify whether a primary type is set
     *
     * @return bool
     */
    public function hasPrimaryType()
    {
        return $this->getTypes()->one() instanceof TypeModel;
    }

    /**
     * Identify whether the type is primary
     *
     * @param $type
     * @return bool
     */
    public function isPrimaryType(TypeModel $type)
    {
        if ($primaryType = $this->getPrimaryType()) {
            return $primaryType->id === $type->id;
        }

        return false;
    }

    /**
     * @param TypeModel $type
     * @return $this
     */
    public function setPrimaryType(TypeModel $type = null)
    {
        if (null === $type) {
            return $this;
        }

        return $this->setTypes(
            array_merge(
                [
                    $type
                ],
                $this->getTypes()->all()
            )
        );
    }

    /**
     * Get the primary type
     *
     * @return TypeModel|null
     */
    public function getPrimaryType()
    {
        if (!$this->hasPrimaryType()) {
            return null;
        }

        return $this->getTypes()->one();
    }

    /*******************************************
     * ASSOCIATE and/or DISASSOCIATE
     *******************************************/

    /**
     * @return bool
     * @throws \Throwable
     * @throws \flipbox\craft\ember\exceptions\RecordNotFoundException
     * @throws \yii\db\StaleObjectException
     */
    public function saveTypes(): bool
    {
        // No changes?
        if (null === ($types = $this->getTypes()->getCachedResult())) {
            return true;
        }

        $currentAssociations = OrganizationTypeAssociation::find()
            ->organizationId($this->getId() ?: false)
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            ->indexBy('typeId')
            ->all();

        $success = true;
        $associations = [];
        $order = 1;
        foreach ($types as $type) {
            if (null === ($association = ArrayHelper::remove($currentAssociations, $type->getId()))) {
                $association = (new OrganizationTypeAssociation())
                    ->setType($type)
                    ->setOrganization($this);
            }

            $association->sortOrder = $order++;

            $associations[] = $association;
        }

        // Delete those removed
        foreach ($currentAssociations as $currentAssociation) {
            if (!$currentAssociation->delete()) {
                $success = false;
            }
        }

        foreach ($associations as $association) {
            if (!$association->save()) {
                $success = false;
            }
        }

        if (!$success) {
            $this->addError('types', 'Unable to associate types.');
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
        }

        return $success;
    }

    /**
     * @param TypeModel $type
     * @param int|null $sortOrder
     * @return bool
     */
    public function associateType(OrganizationType $type, int $sortOrder = null): bool
    {
        if (null === ($association = OrganizationTypeAssociation::find()
            ->organizationId($this->getId() ?: false)
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            ->typeId($type->getId() ?: false)
            ->one())
        ) {
            $association = new OrganizationTypeAssociation([
                'organization' => $this,
                'type' => $type
            ]);
        }

        if (null !== $sortOrder) {
            $association->sortOrder = $sortOrder;
        }

        if (!$association->save()) {
            $this->addError('organizations', 'Unable to associate type.');
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}

            return false;
        }

        $this->resetTypes();

        return true;
    }

    /**
     * @param OrganizationTypeQuery $query
     * @return bool
     * @throws \Throwable
     */
    public function associateTypes(OrganizationTypeQuery $query): bool
    {
        $types = $query->all();

        if (empty($types)) {
            return true;
        }

        $currentAssociations = OrganizationTypeAssociation::find()
            ->organizationId($this->getId() ?: false)
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            ->indexBy('typeId')
            ->all();

        $success = true;
        foreach ($types as $type) {
            if (null === ($association = ArrayHelper::remove($currentAssociations, $type->getId()))) {
                $association = (new OrganizationTypeAssociation())
                    ->setType($type)
                    ->setOrganization($this);
            }

            if (!$association->save()) {
                $success = false;
            }
        }

        if (!$success) {
            $this->addError('organizations', 'Unable to associate types.');
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
        }

        $this->resetTypes();

        return $success;
    }

    /**
     * @param TypeModel $type
     * @return bool
     * @throws \Throwable
     * @throws \yii\db\StaleObjectException
     */
    public function dissociateType(OrganizationType $type): bool
    {
        if (null === ($association = OrganizationTypeAssociation::find()
                ->organizationId($this->getId() ?: false)
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
                ->typeId($type->getId() ?: false)
                ->one())
        ) {
            return true;
        }

        if (!$association->delete()) {
0   == false // true
0   == null  // true
123 == false // false
123 == null  // false

// It is often better to use strict comparison
0 === false // false
0 === null  // false
            $this->addError('organizations', 'Unable to dissociate type.');
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}

            return false;
        }

        $this->resetTypes();

        return true;
    }

    /**
     * @param OrganizationTypeQuery $query
     * @return bool
     */
    public function dissociateTypes(OrganizationTypeQuery $query): bool
    {
        $types = $query->all();

        if (empty($types)) {
            return true;
        }

        $currentAssociations = OrganizationTypeAssociation::find()
            ->organizationId($this->getId() ?: false)
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            ->indexBy('typeId')
            ->all();

        $success = true;
        foreach ($types as $type) {
            if (null === ($association = ArrayHelper::remove($currentAssociations, $type->getId()))) {
                continue;
            }

            if (!$association->delete()) {
                $success = false;
            }
        }

        if (!$success) {
            $this->addError('organizations', 'Unable to dissociate types.');
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
        }

        $this->resetTypes();

        return $success;
    }
}

1			<?php
2
3			/**
4			* @copyright Copyright (c) Flipbox Digital Limited
5			* @license https://flipboxfactory.com/software/organization/license
6			* @link https://www.flipboxfactory.com/software/organization/
7			*/
8
9			namespace flipbox\organizations\elements;
10
11			use Craft;
12			use craft\helpers\ArrayHelper;
13			use flipbox\craft\ember\helpers\QueryHelper;
14			use flipbox\organizations\queries\OrganizationTypeQuery;
15			use flipbox\organizations\records\OrganizationType;
16			use flipbox\organizations\records\OrganizationType as TypeModel;
17			use flipbox\organizations\records\OrganizationTypeAssociation;
18
19			/**
20			* @author Flipbox Factory <[email protected]>
21			* @since 1.0.0
22			*/
23			trait TypesAttributeTrait
24			{
25			/**
26			* @var OrganizationTypeQuery
27			*/
28			private $types;
29
30			/**
31			* @var TypeModel\|false
32			*/
33			private $activeType;
34
35			/************************************************************
36			* REQUEST
37			************************************************************/
38
39			/**
40			* AssociateUserToOrganization an array of types from request input
flipboxfactory / organizations

Push — master ( e381cf...9deca2 )

TypesAttributeTrait::userTypeQuery() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
