flipbox\spark\services\Model

Complexity

Total Complexity

54

Size/Duplication

Total Lines	496
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Test Coverage

Coverage

0%

Importance

Changes

0

28 Methods

Rating	Name	Duplication	Size	Complexity
	modelClass()	0	1	?
A	modelClassInstance()	0	4	1
A	create()	0	22	3
A	createFromRecord()	0	18	3
A	findAll()	0	17	4
A	getAll()	0	9	2
A	find()	0	17	4
A	get()	0	10	2
A	findAllByQuery()	0	11	2
A	findByQuery()	0	10	2
A	findAllByCondition()	0	14	3
A	getAllByCondition()	0	9	2
A	findByCondition()	0	10	2
A	getByCondition()	0	9	2
A	findAllByCriteria()	0	15	3
A	getAllByCriteria()	0	9	2
A	findByCriteria()	0	10	2
A	getByCriteria()	0	9	2
A	findByRecord()	0	14	2
A	getByRecord()	0	4	1
A	findRecordByModel()	0	4	1
A	getRecordByModel()	0	9	2
A	findCache()	0	9	2
A	findCacheByRecord()	0	4	1
A	addToCache()	0	4	1
A	notFoundException()	0	9	1
A	notFoundByCriteriaException()	0	10	1
A	notFoundByConditionException()	0	10	1

<?php

/**
 * @copyright  Copyright (c) Flipbox Digital Limited
 * @license    https://github.com/flipbox/spark/blob/master/LICENSE
 * @link       https://github.com/flipbox/spark
 */

namespace flipbox\spark\services;

use craft\helpers\Json as JsonHelper;
use flipbox\spark\exceptions\ModelNotFoundException;
use flipbox\spark\exceptions\RecordNotFoundException;
use flipbox\spark\helpers\ArrayHelper;
use flipbox\spark\helpers\ModelHelper;
use flipbox\spark\models\Model as BaseModel;
use flipbox\spark\records\Record;
use yii\base\Component;
use yii\base\InvalidConfigException;
use yii\db\QueryInterface;

/**
 * @author Flipbox Factory <hello@flipboxfactory.com>
 * @since 1.0.0
 */
abstract class Model extends Component
{

    use traits\Model;

    /**
     * @var BaseModel[]
     */
    protected $cacheAll;


    /*******************************************
     * MODEL CLASSES
     *******************************************/

    /**
     * @return string
     */
    abstract public static function modelClass(): string;

    /**
     * @return string
     */
    public static function modelClassInstance(): string
    {
        return BaseModel::class;
    }

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

    /**
     * @param array|Record $config
     * @param string|null $toScenario
     * @throws InvalidConfigException
     * @return BaseModel
     */
    public function create($config = [], string $toScenario = null): BaseModel
    {

        // Treat records as known data and set via config
        if ($config instanceof Record) {
            return $this->createFromRecord($config, $toScenario);
        }

        // Force Array
        if (!is_array($config)) {
            $config = ArrayHelper::toArray($config, [], false);
        }

        // Set the model class
        $config['class'] = static::modelClass();

        return ModelHelper::create(
            $config,
            static::modelClassInstance(),
            $toScenario
        );
    }

    /**
     * @param Record $record
     * @param string|null $toScenario
     * @throws InvalidConfigException
     * @return BaseModel
     */
    protected function createFromRecord(Record $record, string $toScenario = null): BaseModel
    {

        if (null !== $toScenario) {
            $record->setScenario($toScenario);
        }

        $modelClass = static::modelClass();

        /** @var BaseModel $model */
        $model = new $modelClass($record);

        if (null !== $toScenario) {
            $model->setScenario($toScenario);
        }

        return $model;
    }

    /*******************************************
     * FIND/GET ALL
     *******************************************/

    /**
     * @param string $toScenario
     * @return BaseModel[]
     */
    public function findAll(string $toScenario = null)
    {

        // Check addToCache
        if (is_null($this->cacheAll)) {
            $this->cacheAll = [];

            // Find record in db
            if ($records = $this->findAllRecords()) {
                foreach ($records as $record) {
                    $this->cacheAll[] = $this->findByRecord($record, $toScenario);
                }
            }
        }

        return $this->cacheAll;
    }

    /**
     * @param string $toScenario
     * @return BaseModel[]
     * @throws ModelNotFoundException
     */
    public function getAll(string $toScenario = null): array
    {

        if (!$models = $this->findAll($toScenario)) {
            $this->notFoundException();
        }

        return $models;
    }

    /*******************************************
     * FIND/GET
     *******************************************/

    /**
     * @param $identifier
     * @param string $toScenario
     * @return BaseModel|null
     */
    public function find($identifier, string $toScenario = null)
    {

        if ($identifier instanceof BaseModel) {
            $this->addToCache($identifier);

            if (null !== $toScenario) {
                $identifier->setScenario($toScenario);
            }

            return $identifier;
        } elseif ($identifier instanceof Record) {
            return $this->findByRecord($identifier, $toScenario);
        }

        return null;
    }

    /**
     * @param $identifier
     * @param string $toScenario
     * @return BaseModel
     * @throws ModelNotFoundException
     */
    public function get($identifier, string $toScenario = null): BaseModel
    {

        // Find model by ID
        if (!$model = $this->find($identifier, $toScenario)) {
            $this->notFoundException();
        }

        return $model;
    }

    /*******************************************
     * FIND/GET BY QUERY
     *******************************************/

    /**
     * @param QueryInterface $query
     * @param string $toScenario
     * @return BaseModel[]
     */
    public function findAllByQuery(QueryInterface $query, string $toScenario = null): array
    {

        $models = array();

        foreach ($query->all() as $record) {
            $models[] = $this->findByRecord($record, $toScenario);
        }

        return $models;
    }

    /**
     * @param QueryInterface $query
     * @param string $toScenario
     * @return BaseModel|null
     */
    public function findByQuery(QueryInterface $query, string $toScenario = null)
    {

        /** @var Record $record */
        if (!$record = $query->one()) {
            return null;
        }

        return $this->findByRecord($record, $toScenario);

$record is of type array|boolean, but the function expects a object<flipbox\spark\records\Record>.

    }

    /*******************************************
     * FIND/GET BY CONDITION
     *******************************************/

    /**
     * @param $condition
     * @param string $toScenario
     * @return BaseModel[]
     */
    public function findAllByCondition($condition, string $toScenario = null): array
    {

        $models = [];

        // Find record in db
        if ($records = $this->findAllRecordsByCondition($condition)) {
            foreach ($records as $record) {
                $models[] = $this->findByRecord($record, $toScenario);
            }
        }

        return $models;
    }

    /**
     * @param $condition
     * @param string $toScenario
     * @return BaseModel[]
     * @throws ModelNotFoundException
     */
    public function getAllByCondition($condition, string $toScenario = null): array
    {

        if (!$models = $this->findAllByCondition($condition, $toScenario)) {
            $this->notFoundByConditionException($condition);
        }

        return $models;
    }

    /**
     * @param $condition
     * @param string $toScenario
     * @return BaseModel|null
     */
    public function findByCondition($condition, string $toScenario = null)
    {

        // Find record in db
        if ($record = $this->findRecordByCondition($condition)) {
            return $this->findByRecord($record, $toScenario);
        }

        return null;
    }

    /**
     * @param $condition
     * @param string $toScenario
     * @return BaseModel
     * @throws ModelNotFoundException
     */
    public function getByCondition($condition, string $toScenario = null): BaseModel
    {

        if (!$model = $this->findByCondition($condition, $toScenario)) {
            $this->notFoundByConditionException($condition);
        }

        return $model;
    }

    /*******************************************
     * FIND/GET BY CRITERIA
     *******************************************/

    /**
     * @param $criteria
     * @param string $toScenario
     * @return BaseModel[]
     */
    public function findAllByCriteria($criteria, string $toScenario = null): array
    {

        $models = [];

        // Find record in db
        if ($records = $this->findAllRecordsByCriteria($criteria)
        ) {
            foreach ($records as $record) {
                $models[] = $this->findByRecord($record, $toScenario);
            }
        }

        return $models;
    }

    /**
     * @param $criteria
     * @param string $toScenario
     * @return BaseModel[]
     * @throws ModelNotFoundException
     */
    public function getAllByCriteria($criteria, string $toScenario = null): array
    {

        if (!$models = $this->findAllByCriteria($criteria, $toScenario)) {
            $this->notFoundByCriteriaException($criteria);
        }

        return $models;
    }

    /**
     * @param $criteria
     * @param string $toScenario
     * @return BaseModel|null
     */
    public function findByCriteria($criteria, string $toScenario = null)
    {

        // Find record in db
        if ($record = $this->findRecordByCriteria($criteria)) {
            return $this->findByRecord($record, $toScenario);
        }

        return null;
    }

    /**
     * @param $criteria
     * @param string $toScenario
     * @return BaseModel
     * @throws ModelNotFoundException
     */
    public function getByCriteria($criteria, string $toScenario = null): BaseModel
    {

        if (!$model = $this->findByCriteria($criteria, $toScenario)) {
            $this->notFoundByCriteriaException($criteria);
        }

        return $model;
    }


    /*******************************************
     * FIND/GET BY RECORD
     *******************************************/

    /**
     * @param Record $record
     * @param string $toScenario
     * @return BaseModel
     */
    public function findByRecord(Record $record, string $toScenario = null): BaseModel
    {

        // Check addToCache
        if (!$model = $this->findCacheByRecord($record)) {
            // New model
            $model = $this->createFromRecord($record, $toScenario);

            // Cache it
            $this->addToCache($model);
        }

        return $model;
    }

    /**
     * @param Record $record
     * @param string $toScenario
     * @return BaseModel
     */
    public function getByRecord(Record $record, string $toScenario = null): BaseModel
    {
        return $this->findByRecord($record, $toScenario);
    }

    /**
     * @param BaseModel $model
     * @return Record|null
     */
    public function findRecordByModel(BaseModel $model)
    {
        return null;
    }

    /**
     * @param BaseModel $model
     * @return Record
     * @throws RecordNotFoundException
     */
    public function getRecordByModel(BaseModel $model): Record
    {

        if (!$record = $this->findRecordByModel($model)) {
            throw new RecordNotFoundException("Record does not exist found.");
        }

        return $record;
    }

    /*******************************************
     * CACHE
     *******************************************/

    /**
     * @param $identifier
     * @return BaseModel|null
     */
    public function findCache($identifier)
    {

        if ($identifier instanceof Record) {
            return $this->findCacheByRecord($identifier);
        }

        return null;
    }

    /**
     * @param Record $record
     * @return BaseModel|null
     */
    public function findCacheByRecord(Record $record)
    {
        return null;
    }

    /**
     * @param BaseModel $model
     * @return static
     */
    public function addToCache(BaseModel $model)
    {
        return $this;
    }


    /*******************************************
     * EXCEPTIONS
     *******************************************/

    /**
     * @throws ModelNotFoundException
     */
    protected function notFoundException()
    {

        throw new ModelNotFoundException(
            sprintf(
                "Model does not exist."
            )
        );
    }

    /**
     * @param null $criteria
     * @throws ModelNotFoundException
     */
    protected function notFoundByCriteriaException($criteria = null)
    {

        throw new ModelNotFoundException(
            sprintf(
                'Model does not exist with the criteria "%s".',
                (string)JsonHelper::encode($criteria)
            )
        );
    }

    /**
     * @param null $condition
     * @throws ModelNotFoundException
     */
    protected function notFoundByConditionException($condition = null)
    {

        throw new ModelNotFoundException(
            sprintf(
                'Model does not exist with the condition "%s".',
                (string)JsonHelper::encode($condition)
            )
        );
    }
}