Arrilot\BitrixModels\Models\D7Model

Complexity

Total Complexity

26

Size/Duplication

Total Lines	208
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	setAdapter()	0	4	1
A	instantiateAdapter()	0	8	2
A	query()	0	4	1
A	tableClass()	0	9	2
A	cachedTableClass()	0	8	2
A	internalCreate()	0	21	4
A	delete()	0	15	2
A	save()	0	18	4
A	fieldShouldNotBeSaved()	0	4	3
A	throwExceptionOnFail()	0	6	2
A	setEventErrorsOnFail()	0	6	2

<?php

namespace Arrilot\BitrixModels\Models;

use Arrilot\BitrixModels\Adapters\D7Adapter;
use Arrilot\BitrixModels\Exceptions\ExceptionFromBitrix;
use Arrilot\BitrixModels\Queries\D7Query;
use Illuminate\Support\Collection;
use LogicException;

/**
 * static int count()
 *
 * D7Query methods
 * @method static D7Query runtime(array|\Bitrix\Main\Entity\ExpressionField $fields)
 * @method static D7Query enableDataDoubling()
 * @method static D7Query disableDataDoubling()
 * @method static D7Query cacheJoins(bool $value)
 *
 * BaseQuery methods
 * @method static Collection getList()
 * @method static D7Model first()
 * @method static D7Model getById(int $id)
 * @method static D7Query sort(string|array $by, string $order='ASC')
 * @method static D7Query order(string|array $by, string $order='ASC') // same as sort()
 * @method static D7Query filter(array $filter)
 * @method static D7Query addFilter(array $filters)
 * @method static D7Query resetFilter()
 * @method static D7Query navigation(array $filter)
 * @method static D7Query select($value)
 * @method static D7Query keyBy(string $value)
 * @method static D7Query limit(int $value)
 * @method static D7Query offset(int $value)
 * @method static D7Query page(int $num)
 * @method static D7Query take(int $value) // same as limit()
 * @method static D7Query forPage(int $page, int $perPage=15)
 * @method static \Illuminate\Pagination\LengthAwarePaginator paginate(int $perPage = 15, string $pageName = 'page')
 * @method static \Illuminate\Pagination\Paginator simplePaginate(int $perPage = 15, string $pageName = 'page')
 * @method static D7Query stopQuery()
 * @method static D7Query cache(float|int $minutes)
 */
class D7Model extends BaseBitrixModel
{
    const TABLE_CLASS = null;

    /**
     * @var null|string
     */
    protected static $cachedTableClass = null;

    /**
     * Adapter to interact with Bitrix D7 API.
     *
     * @var D7Adapter
     */
    protected static $adapter;

    /**
     * Constructor.
     *
     * @param $id
     * @param $fields
     */
    public function __construct($id = null, $fields = null)
    {
        $this->id = $id;
        $this->fill($fields);
        static::instantiateAdapter();
    }
    
    /**
     * Setter for adapter (for testing)
     * @param $adapter
     */
    public static function setAdapter($adapter)
    {
        static::$adapter = $adapter;
    }

    /**
     * Instantiate adapter if it's not instantiated.
     *
     * @return D7Adapter
     */
    public static function instantiateAdapter()
    {
        if (static::$adapter) {
            return static::$adapter;
        }

        return static::$adapter = new D7Adapter(static::cachedTableClass());
    }

    /**
     * Instantiate a query object for the model.
     *
     * @return D7Query
     */
    public static function query()
    {
        return new D7Query(static::instantiateAdapter(), get_called_class());
    }
    
    /**
     * @return string
     * @throws LogicException
     */
    public static function tableClass()
    {
        $tableClass = static::TABLE_CLASS;
        if (!$tableClass) {
            throw new LogicException('You must set TABLE_CLASS constant inside a model or override tableClass() method');
        }
    
        return $tableClass;
    }

    /**
     * Cached version of table class.
     *
     * @return string
     */
    public static function cachedTableClass()
    {
        if (is_null(static::$cachedTableClass)) {
            static::$cachedTableClass = static::tableClass();
        }

        return static::$cachedTableClass;
    }

    /**
     * Internal part of create to avoid problems with static and inheritance
     *
     * @param $fields
     *
     * @throws ExceptionFromBitrix
     *
     * @return static|bool
     */
    protected static function internalCreate($fields)
    {
        $model = new static(null, $fields);

        if ($model->onBeforeSave() === false || $model->onBeforeCreate() === false) {
            return false;
        }

        $resultObject = static::instantiateAdapter()->add($model->fields);

It seems like $model->fields can also be of type null; however, Arrilot\BitrixModels\Adapters\D7Adapter::add() does only seem to accept array, maybe add an additional type check?

        $result = $resultObject->isSuccess();
        if ($result) {
            $model->setId($resultObject->getId());
        }

        $model->setEventErrorsOnFail($resultObject);
        $model->onAfterCreate($result);
        $model->onAfterSave($result);
        $model->throwExceptionOnFail($resultObject);

        return $model;
    }

    /**
     * Delete model
     *
     * @return bool
     * @throws ExceptionFromBitrix
     */
    public function delete()
    {
        if ($this->onBeforeDelete() === false) {
            return false;
        }

        $resultObject = static::instantiateAdapter()->delete($this->id);
        $result = $resultObject->isSuccess();

        $this->setEventErrorsOnFail($resultObject);
        $this->onAfterDelete($result);
        $this->throwExceptionOnFail($resultObject);

        return $result;
    }
    
    /**
     * Save model to database.
     *
     * @param array $selectedFields save only these fields instead of all.
     * @return bool
     * @throws ExceptionFromBitrix
     */
    public function save($selectedFields = [])
    {
        $this->fieldsSelectedForSave = is_array($selectedFields) ? $selectedFields : func_get_args();
        if ($this->onBeforeSave() === false || $this->onBeforeUpdate() === false) {
            return false;
        }

        $fields = $this->normalizeFieldsForSave($this->fieldsSelectedForSave);
        $resultObject = static::instantiateAdapter()->update($this->id, $fields);
        $result = $resultObject->isSuccess();

        $this->setEventErrorsOnFail($resultObject);
        $this->onAfterUpdate($result);
        $this->onAfterSave($result);
        $this->throwExceptionOnFail($resultObject);

        return $result;
    }
    
    /**
     * Determine whether the field should be stopped from passing to "update".
     *
     * @param string $field
     * @param mixed  $value
     * @param array  $selectedFields
     *
     * @return bool
     */
    protected function fieldShouldNotBeSaved($field, $value, $selectedFields)
    {
        return (!empty($selectedFields) && !in_array($field, $selectedFields)) || $field === 'ID';
    }

    /**
     * Throw bitrix exception on fail
     *
     * @param \Bitrix\Main\Entity\Result $resultObject
     * @throws ExceptionFromBitrix
     */
    protected function throwExceptionOnFail($resultObject)
    {
        if (!$resultObject->isSuccess()) {
            throw new ExceptionFromBitrix(implode('; ', $resultObject->getErrorMessages()));
        }
    }

    /**
     * Set eventErrors field on error.
     *
     * @param \Bitrix\Main\Entity\Result $resultObject
     */
    protected function setEventErrorsOnFail($resultObject)
    {
        if (!$resultObject->isSuccess()) {
            $this->eventErrors = (array) $resultObject->getErrorMessages();
        }
    }
}