flipbox\organizations\elements\Organization

Complexity

Total Complexity

65

Size/Duplication

Total Lines	657
Duplicated Lines	0 %

Coupling/Cohesion

Components	3
Dependencies	18

Test Coverage

Coverage

0%

Importance

Changes

0

35 Methods

Rating	Name	Duplication	Size	Complexity
A	displayName()	0	4	1
A	getIsEditable()	0	4	1
A	hasTitles()	0	4	1
A	isLocalized()	0	4	1
A	hasContent()	0	4	1
A	hasUris()	0	4	1
A	find()	0	4	1
A	getOne()	0	13	2
A	getAll()	0	15	2
A	findByCondition()	0	12	3
A	hasStatuses()	0	4	1
A	getRef()	0	8	2
A	attributes()	0	13	1
A	rules()	0	22	1
A	attributeLabels()	0	13	1
A	getFieldLayout()	0	8	2
A	getCpEditUrl()	0	4	1
A	defineSources()	0	10	2
A	defineDefaultSources()	0	11	1
A	defineTypeSources()	0	21	2
A	defineUserSources()	0	24	2
A	defineActions()	0	17	1
A	defineSearchableAttributes()	0	6	1
A	defineSortOptions()	0	7	1
A	eagerLoadingMap()	0	9	2
A	setEagerLoadedElements()	0	12	2
A	defineTableAttributes()	0	11	1
A	tableAttributeHtml()	0	19	4
A	getUriFormat()	0	12	3
A	route()	0	28	4
A	getSiteSettings()	0	22	3
A	beforeSave()	0	8	2
A	afterSave()	0	18	4
A	saveRecord()	0	30	5
A	elementToRecord()	0	14	2

<?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\base\Element;
use craft\elements\actions\Edit as EditAction;
use craft\elements\db\ElementQueryInterface;
use craft\elements\User;
use craft\errors\ElementNotFoundException;
use craft\helpers\DateTimeHelper;
use craft\helpers\Json;
use craft\helpers\StringHelper;
use craft\helpers\UrlHelper as UrlHelper;
use flipbox\craft\ember\helpers\ModelHelper;
use flipbox\organizations\models\DateJoinedAttributeTrait;
use flipbox\organizations\Organizations as OrganizationPlugin;
use flipbox\organizations\queries\OrganizationQuery;
use flipbox\organizations\records\Organization as OrganizationRecord;
use flipbox\organizations\records\OrganizationType;
use flipbox\organizations\records\OrganizationType as TypeModel;
use yii\base\ErrorException as Exception;

/**
 * @author Flipbox Factory <hello@flipboxfactory.com>
 * @since 1.0.0
 */
class Organization extends Element
{
    use DateJoinedAttributeTrait,
        TypesAttributeTrait,
        UsersAttributeTrait;

    /**
     * @inheritdoc
     */
    public static function displayName(): string
    {
        return Craft::t('organizations', 'Organization');
    }

    /**
     * @inheritdoc
     */
    public function getIsEditable(): bool
    {
        return true;
    }

    /**
     * @inheritdoc
     */
    public static function hasTitles(): bool
    {
        return true;
    }

    /**
     * @inheritdoc
     */
    public static function isLocalized(): bool
    {
        return true;
    }

    /**
     * @inheritdoc
     */
    public static function hasContent(): bool
    {
        return true;
    }

    /**
     * @inheritdoc
     */
    public static function hasUris(): bool
    {
        return true;
    }

    /**
     * @inheritdoc
     *
     * @return OrganizationQuery
     */
    public static function find(): ElementQueryInterface
    {
        return new OrganizationQuery(static::class);
    }

    /*******************************************
     * GET
     *******************************************/

    /**
     * Returns a single element instance by a primary key or a set of element criteria parameters.
     *
     * The method accepts:
     *
     *  - an int: query by a single ID value and return the corresponding element (or null if not found).
     *  - an array of name-value pairs: query by a set of parameter values and return the first element
     *    matching all of them (or null if not found).
     *
     * Note that this method will automatically call the `one()` method and return an
     * [[ElementInterface|\craft\base\Element]] instance. For example,
     *
     * ```php
     * // find a single entry whose ID is 10
     * $entry = Entry::findOne(10);
     * // the above code is equivalent to:
     * $entry = Entry::find->id(10)->one();
     * // find the first user whose email ends in "example.com"
     * $user = User::findOne(['email' => '*example.com']);
     * // the above code is equivalent to:
     * $user = User::find()->email('*example.com')->one();
     * ```
     *
     * @param mixed $criteria The element ID or a set of element criteria parameters
     * @return static Element instance matching the condition, or null if nothing matches.
     * @throws ElementNotFoundException
     */
    public static function getOne($criteria)
    {
        if (null === ($element = static::findOne($criteria))) {

The expression static::findOne($criteria); of type craft\base\Element|null|craft\base\Element[] adds the type craft\base\Element[] to the return on line 140 which is incompatible with the return type documented by flipbox\organizations\elements\Organization::getOne of type flipbox\organizations\elements\Organization.

            throw new ElementNotFoundException(
                sprintf(
                    "Organization not found with the following criteria: %s",
                    Json::encode($criteria)
                )
            );
        }

        return $element;
    }

    /**
     * Returns a list of elements that match the specified ID(s) or a set of element criteria parameters.
     *
     * The method accepts:
     *
     *  - an int: query by a single ID value and return an array containing the corresponding element
     *    (or an empty array if not found).
     *  - an array of integers: query by a list of ID values and return the corresponding elements (or an
     *    empty array if none was found).
     *    Note that an empty array will result in an empty result as it will be interpreted as a search for
     *    primary keys and not an empty set of element criteria parameters.
     *  - an array of name-value pairs: query by a set of parameter values and return an array of elements
     *    matching all of them (or an empty array if none was found).
     *
     * Note that this method will automatically call the `all()` method and return an array of
     * [[ElementInterface|\craft\base\Element]] instances. For example,
     *
     * ```php
     * // find the entries whose ID is 10
     * $entries = Entry::findAll(10);
     * // the above code is equivalent to:
     * $entries = Entry::find()->id(10)->all();
     * // find the entries whose ID is 10, 11 or 12.
     * $entries = Entry::findAll([10, 11, 12]);
     * // the above code is equivalent to:
     * $entries = Entry::find()->id([10, 11, 12]])->all();
     * // find users whose email ends in "example.com"
     * $users = User::findAll(['email' => '*example.com']);
     * // the above code is equivalent to:
     * $users = User::find()->email('*example.com')->all();
     * ```
     *
     * @param mixed $criteria The element ID, an array of IDs, or a set of element criteria parameters
     * @return static[] an array of Element instances, or an empty array if nothing matches.
     * @throws ElementNotFoundException
     */
    public static function getAll($criteria)
    {
        $elements = static::findAll($criteria);

        if (empty($elements)) {
            throw new ElementNotFoundException(
                sprintf(
                    "Organization not found with the following criteria: %s",
                    Json::encode($criteria)
                )
            );
        }

        return $elements;
    }

    /**
     * @param mixed $criteria
     * @param bool $one
     * @return Element|Element[]|null
     */
    protected static function findByCondition($criteria, bool $one)
    {
        if (is_numeric($criteria)) {
            $criteria = ['id' => $criteria];
        }

        if (is_string($criteria)) {
            $criteria = ['slug' => $criteria];
        }

        return parent::findByCondition($criteria, $one);
    }

    /**
     * Returns whether this element type can have statuses.
     *
     * @return boolean
     */
    public static function hasStatuses(): bool
    {
        return true;
    }

    /**
     * @inheritdoc
     */
    public function getRef()
    {
        if (!$primary = $this->getPrimaryType()) {
            return $this->slug;
        }

        return $primary->handle . '/' . $this->slug;
    }

    /**
     * @return array
     */
    public function attributes()
    {
        return array_merge(
            parent::attributes(),
            $this->dateJoinedAttributes(),
            [
                //                'types',
                //                'activeType',
                //                'primaryType',
                //                'users',
            ]
        );
    }

    /**
     * @inheritdoc
     * @throws \yii\base\InvalidConfigException
     */
    public function rules()
    {
        return array_merge(
            parent::rules(),
            $this->dateJoinedRules(),
            [
                [
                    [
                        'types',
                        'activeType',
                        'primaryType',
                        'users',
                    ],
                    'safe',
                    'on' => [
                        ModelHelper::SCENARIO_DEFAULT
                    ]

                ],
            ]
        );
    }

    /**
     * @return array
     */
    public function attributeLabels()
    {
        return array_merge(
            parent::attributeLabels(),
            $this->dateJoinedAttributeLabels(),
            [
                //                'types' => Craft::t('organizations', 'Types'),
                //                'activeType' => Craft::t('organizations', 'Active Type'),
                //                'primaryType' => Craft::t('organizations', 'Primary Type'),
                //                'users' => Craft::t('organizations', 'Users'),
            ]
        );
    }

    /************************************************************
     * FIELD LAYOUT
     ************************************************************/

    /**
     * @inheritdoc
     */
    public function getFieldLayout()
    {
        if (!$type = $this->getActiveType()) {
            return OrganizationPlugin::getInstance()->getSettings()->getFieldLayout();
        }

        return $type->getFieldLayout();
    }

    /************************************************************
     * ELEMENT ADMIN
     ************************************************************/

    /**
     * @inheritdoc
     */
    public function getCpEditUrl()
    {
        return UrlHelper::cpUrl('organizations/' . $this->id);
    }

    /**
     * @inheritdoc
     */
    protected static function defineSources(string $context = null): array
    {
        switch ($context) {
            case 'user':
                return self::defineUserSources();

            default:
                return self::defineTypeSources();
        }
    }

    /**
     * @return array
     */
    private static function defineDefaultSources(): array
    {
        return [
            [
                'key' => '*',
                'label' => Craft::t('organizations', 'All organizations'),
                'criteria' => ['status' => null],
                'hasThumbs' => true
            ]
        ];
    }

    /**
     * @return array
     */
    private static function defineTypeSources(): array
    {
        $sources = self::defineDefaultSources();

        // Array of all organization types
        $organizationTypes = OrganizationType::findAll([]);

        $sources[] = ['heading' => Craft::t('organizations', 'Types')];

        /** @var TypeModel $organizationType */
        foreach ($organizationTypes as $organizationType) {
            $sources[] = [
                'key' => 'type:' . $organizationType->id,
                'label' => $organizationType->name,
                'criteria' => ['status' => null, 'typeId' => $organizationType->id],
                'hasThumbs' => true
            ];
        }

        return $sources;
    }

    /**
     * @return array
     */
    private static function defineUserSources(): array
    {
        $sources = self::defineDefaultSources();

        // Array of all organization types
        $organizationUsers = User::find();

        $sources[] = ['heading' => Craft::t('organizations', 'Users')];

        /** @var User $organizationUser */
        foreach ($organizationUsers as $organizationUser) {
            $sources[] = [
                'key' => 'user:' . $organizationUser->id,
                'label' => $organizationUser->getFullName(),
                'criteria' => [
                    'status' => null,
                    'users' => [$organizationUser->id]
                ],
                'hasThumbs' => true
            ];
        }

        return $sources;
    }

    /**
     * @inheritdoc
     */
    protected static function defineActions(string $source = null): array
    {
        $actions = [];

        // Edit
        $actions[] = Craft::$app->getElements()->createAction([
            'type' => EditAction::class,
            'label' => Craft::t('organizations', 'Edit organization'),
        ]);

//        if (Craft::$app->getUser()->checkPermission('deleteOrganizations')) {
//            // DeleteOrganization
//            $actions[] = DeleteAction::class;
//        }

        return $actions;
    }

    /**
     * @inheritdoc
     */
    protected static function defineSearchableAttributes(): array
    {
        return [
            'id'
        ];
    }

    /**
     * @inheritdoc
     */
    protected static function defineSortOptions(): array
    {
        return [
            'title' => Craft::t('organizations', 'Name'),
            'dateJoined' => Craft::t('organizations', 'Join Date'),
        ];
    }

    /**
     * @inheritdoc
     */
    public static function eagerLoadingMap(array $sourceElements, string $handle)
    {
        switch ($handle) {
            case 'users':
                return self::eagerLoadingUsersMap($sourceElements);
        }

        return parent::eagerLoadingMap($sourceElements, $handle);
    }

    /**
     * @inheritdoc
     */
    public function setEagerLoadedElements(string $handle, array $elements)
    {
        switch ($handle) {
            case 'users':
                $users = $elements ?? [];
                $this->setUsers($users);
                break;

            default:
                parent::setEagerLoadedElements($handle, $elements);
        }
    }

    /**
     * @inheritdoc
     */
    public static function defineTableAttributes(): array
    {
        return [
            'id' => ['label' => Craft::t('app', 'Name')],
            'uri' => ['label' => Craft::t('app', 'URI')],
            'types' => ['label' => Craft::t('organizations', 'Type(s)')],
            'dateJoined' => ['label' => Craft::t('organizations', 'Join Date')],
            'dateCreated' => ['label' => Craft::t('app', 'Date Created')],
            'dateUpdated' => ['label' => Craft::t('app', 'Date Updated')],
        ];
    }



    // Indexes, etc.
    // -------------------------------------------------------------------------

    /**
     * @inheritdoc
     */
    public function tableAttributeHtml(string $attribute): string
    {

        switch ($attribute) {
            case 'types':
                $typeHtmlParts = [];
                foreach ($this->getTypes()->all() as $type) {
                    $typeHtmlParts[] = '<a href="' .
                        UrlHelper::cpUrl('organizations/' . $this->id . '/' . $type->handle) .
                        '">' .
                        $type->name .
                        '</a>';
                }

                return !empty($typeHtmlParts) ? StringHelper::toString($typeHtmlParts, ', ') : '';
        }

        return parent::tableAttributeHtml($attribute);
    }

    /**
     * @inheritdoc
     */
    public function getUriFormat()
    {
        if (null === ($siteSettings = $this->getSiteSettings())) {
            return null;
        }

        if (!$siteSettings->hasUrls()) {
            return null;
        }

        return $siteSettings->getUriFormat();
    }

    /**
     * @inheritdoc
     */
    public function route()
    {
        if (in_array(
            $this->getStatus(),
            [static::STATUS_DISABLED, static::STATUS_ARCHIVED],
            true
        )) {
            return null;
        }

        if (null === ($siteSettings = $this->getSiteSettings())) {
            return null;
        }

        if (!$siteSettings->hasUrls()) {
            return null;
        }

        return [
            'templates/render',
            [
                'template' => $siteSettings->getTemplate(),
                'variables' => [
                    'organization' => $this,
                ]
            ]
        ];
    }

    /**
     * @return \flipbox\organizations\records\OrganizationTypeSiteSettings|null
     */
    protected function getSiteSettings()
    {
        try {
            $settings = OrganizationPlugin::getInstance()->getSettings();
            $siteSettings = $settings->getSiteSettings()[$this->siteId] ?? null;

            if (null !== ($type = $this->getPrimaryType())) {
                $siteSettings = $type->getSiteSettings()[$this->siteId] ?? $siteSettings;
            }

            return $siteSettings;
        } catch (\Exception $e) {
            OrganizationPlugin::error(
                sprintf(
                    "An exception was caught while to resolve site settings: %s",
                    $e->getMessage()
                )
            );
        }

        return null;
    }

    /************************************************************
     * EVENTS
     ************************************************************/

    /**
     * @inheritdoc
     */
    public function beforeSave(bool $isNew): bool
    {
        if (empty($this->getDateJoined())) {
            $this->setDateJoined(DateTimeHelper::currentUTCDateTime());
        }

        return parent::beforeSave($isNew);
    }

    /**
     * @inheritdoc
     * @throws /Exception
     */
    public function afterSave(bool $isNew)
    {
        if (false === $this->saveRecord($isNew)) {
            throw new Exception('Unable to save organization record');
        }

        // Types
        if (false === $this->saveTypes()) {
            throw new Exception("Unable to save types.");
        }

        // Users
        if (false === $this->saveUsers()) {
            throw new Exception("Unable to save users.");
        }

        parent::afterSave($isNew);
    }

    /*******************************************
     * RECORD
     *******************************************/

    /**
     * @param bool $isNew
     * @return bool
     */
    protected function saveRecord(bool $isNew): bool
    {
        $record = $this->elementToRecord();

        if (!$record->save()) {
            $this->addErrors($record->getErrors());

            OrganizationPlugin::error(
                Json::encode($this->getErrors()),
                __METHOD__
            );

            return false;
        }

        if (false !== ($dateUpdated = DateTimeHelper::toDateTime($record->dateUpdated))) {
            $this->dateUpdated = $dateUpdated;
        }


        if ($isNew) {
            $this->id = $record->id;

            if (false !== ($dateCreated = DateTimeHelper::toDateTime($record->dateCreated))) {
                $this->dateCreated = $dateCreated;
            }
        }

        return true;
    }

    /**
     * @inheritdoc
     * @return OrganizationRecord
     */
    protected function elementToRecord(): OrganizationRecord
    {
        if (!$record = OrganizationRecord::findOne([
            'id' => $this->getId()
        ])) {
            $record = new OrganizationRecord();
        }

        // PopulateOrganizationTypeTrait the record attributes
        $record->id = $this->getId();
        $record->dateJoined = $this->getDateJoined();

        return $record;
    }
}