Nip\Records\AbstractModels\Record

Complexity

Total Complexity

33

Size/Duplication

Total Lines	256
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

18.18%

Importance

Changes

0

27 Methods

Rating	Name	Duplication	Size	Complexity
A	__get()	0	8	2
A	__set()	0	4	1
A	__isset()	0	4	1
A	__unset()	0	4	1
A	__call()	0	9	2
A	getHelper()	0	4	1
A	getName()	0	7	2
A	setName()	0	4	1
A	writeDBData()	0	6	2
A	getDBData()	0	4	1
A	getPrimaryKey()	0	6	1
A	insert()	0	10	2
A	update()	0	5	1
A	save()	0	4	1
A	saveRecord()	0	4	1
A	delete()	0	4	1
A	isInDB()	0	5	1
A	exists()	0	4	1
A	toJSON()	0	4	1
A	toArray()	0	5	1
A	toApiArray()	0	5	1
A	getCloneWithRelations()	0	7	1
A	getClone()	0	9	1
A	updateDataFromRecord()	0	7	1
A	writeData()	0	6	2
A	cloneRelations()	0	4	1
A	getRequest()	0	4	1

<?php

namespace Nip\Records\AbstractModels;

use Nip\HelperBroker;
use \Exception;
use Nip\Records\Traits\HasManager\HasManagerRecordTrait;
use Nip\Utility\Traits\NameWorksTrait;

/**
 * Class Row
 * @package Nip\Records\_Abstract
 *
 * @method \Nip_Helper_Url URL()
 */
abstract class Record
{
    use NameWorksTrait;
    use HasManagerRecordTrait;

    protected $_name = null;

    protected $_dbData = [];
    protected $_helpers = [];


    protected $_data;

    public function &__get($name)
    {
        if (!$this->__isset($name)) {
            $this->_data[$name] = null;
        }

        return $this->_data[$name];
    }

    public function __set($name, $value)
    {
        $this->_data[$name] = $value;
    }

    public function __isset($name)
    {
        return isset($this->_data[$name]);
    }

    public function __unset($name)
    {
        unset($this->_data[$name]);
    }


    /**
     * Overloads Ucfirst() helper
     *
     * @param string $name
     * @param array $arguments
     * @return \Nip\Helpers\AbstractHelper|null
     */
    public function __call($name, $arguments)
    {
        if ($name === ucfirst($name)) {
            return $this->getHelper($name);
        }

        trigger_error("Call to undefined method $name", E_USER_ERROR);
        return null;
    }

    /**
     * @param string $name
     * @return \Nip\Helpers\AbstractHelper
     */
    public function getHelper($name)
    {
        return HelperBroker::get($name);
    }

    /**
     * @return mixed
     */
    public function getName()
    {
        if ($this->_name == null) {
            $this->_name = inflector()->unclassify(get_class($this));
        }
        return $this->_name;
    }

    /**
     * @param mixed $name
     */
    public function setName($name)
    {
        $this->_name = $name;
    }

    /**
     * @param bool|array $data
     */
    public function writeDBData($data = false)
    {
        foreach ($data as $key => $value) {

The expression $data of type boolean|array is not guaranteed to be traversable. How about adding an additional type check?

            $this->_dbData[$key] = $value;
        }
    }

    /**
     * @return array
     */
    public function getDBData()
    {
        return $this->_dbData;
    }

    /**
     * @return mixed
     */
    public function getPrimaryKey()
    {
        $pk = $this->getManager()->getPrimaryKey();

        return $this->{$pk};
    }


    /**
     * @return bool
     */
    public function insert()
    {
        $pk = $this->getManager()->getPrimaryKey();
        $lastId = $this->getManager()->insert($this);
        if ($pk == 'id') {
            $this->{$pk} = $lastId;
        }

        return $lastId > 0;
    }

    /**
     * @return bool|\Nip\Database\Result
     */
    public function update()
    {
        $return = $this->getManager()->update($this);
        return $return;
    }

    public function save()
    {
        $this->getManager()->save($this);
    }

    public function saveRecord()
    {
        $this->getManager()->save($this);
    }

    public function delete()
    {
        $this->getManager()->delete($this);
    }

    /**
     * @return bool
     */
    public function isInDB()
    {
        $pk = $this->getManager()->getPrimaryKey();
        return $this->{$pk} > 0;
    }

    /**
     * @return bool|false|Record
     */
    public function exists()
    {
        return $this->getManager()->exists($this);
    }

    /**
     * @return string
     */
    public function toJSON()
    {
        return json_encode($this->toArray());
    }

    /**
     * @return mixed
     */
    public function toArray()
    {
        $vars = get_object_vars($this);
        return $vars['_data'];
    }

    /**
     * @return mixed
     */
    public function toApiArray()
    {
        $data = $this->toArray();
        return $data;
    }

    /**
     * @return Record
     */
    public function getCloneWithRelations()
    {
        $item = $this->getClone();
        $item->cloneRelations($this);

        return $item;
    }

    /**
     * @return Record
     */
    public function getClone()
    {
        $clone = $this->getManager()->getNew();
        $clone->updateDataFromRecord($this);

        unset($clone->{$this->getManager()->getPrimaryKey()}, $clone->created);

        return $clone;
    }

    /**
     * @param self $record
     */
    public function updateDataFromRecord($record)
    {
        $data = $record->toArray();
        $this->writeData($data);

        unset($this->{$this->getManager()->getPrimaryKey()}, $this->created);
    }

    /**
     * @param bool|array $data
     */
    public function writeData($data = false)
    {
        foreach ($data as $key => $value) {

The expression $data of type boolean|array is not guaranteed to be traversable. How about adding an additional type check?

            $this->__set($key, $value);
        }
    }

    /**
     * Clone the relations records from a sibling
     * @param self $from
     * @return \Nip\Records\Traits\Relations\HasRelationsRecordTrait

The return type \Nip\Records\Traits\Relations\HasRelationsRecordTrait is a trait, and thus cannot be used for type-hinting in PHP. Maybe consider adding an interface and use that for type-hinting?

     */
    public function cloneRelations($from)
    {
        return $this->getManager()->cloneRelations($from, $this);

The method cloneRelations does not exist on object<Nip\Records\AbstractModels\RecordManager>? Since you implemented __call, maybe consider adding a @method annotation.

    }

    /**
     * @return \Nip\Request
     */
    protected function getRequest()
    {
        return $this->getManager()->getRequest();
    }
}