Entity\EntityModel

Complexity

Total Complexity

36

Size/Duplication

Total Lines	295
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

0%

Importance

Changes	13
Bugs	1	Features	1

21 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	3
B	processRow()	0	15	7
A	importRow()	0	7	3
A	exportRow()	0	4	1
A	fromArray()	0	6	1
A	buildContainer()	0	8	1
A	isEmpty()	0	3	1
A	isNew()	0	3	1
A	load()	0	6	1
A	insert()	0	4	1
A	update()	0	7	1
A	delete()	0	3	1
A	onSaveUnchanged()	0	5	1
A	onSaveNew()	0	5	1
B	save()	0	17	6
A	getRowOperator()	0	3	1
A	setTableName()	0	3	1
A	getTableName()	0	3	1
A	getProperties()	0	3	1
A	extendProperties()	0	3	1
A	getAccessors()	0	3	1

<?php
namespace Entity;

use \Common\Accessors;

/**
 * Class EntityModel
 *
 * This class have only one instance - i.e. is a service
 * Describes persistent entity - which can be loaded from/stored to storage
 *
 *
 * Introduces linked models and export/import operations
 *
 * Importer is a callable like
 *    function ($that, &$row[, $propertyName[, $fieldName]]) {}
 *
 * Exporter is a callable like
 *    function ($that, &$row[, $propertyName[, $fieldName]]) {}
 *
 */
class EntityModel {
  /**
   * Service to work with rows
   *
   * ALL DB ACCESS SHOULD BE DONE VIA ROW OPERATOR! NO DIRECT ACCESS TO DB IS ALLOWED!
   *
   * @var \DbRowDirectOperator $rowOperator
   */
  protected $rowOperator;
  /**
   * Name of table for this entity
   *
   * @var string $tableName
   */
  protected $tableName = '_table';

  /**
   * Name of exception class that would be thrown
   *
   * Uses for calling when you don't know which exact exception should be called
   * On Entity\EntityModel's children should be used exception class name
   *
   * @var string $exceptionClass
   */
  protected $exceptionClass = 'Entity\EntityException';
  protected $entityContainerClass = '\Entity\EntityContainer';

  /**
   * Property list and description
   *
   * propertyName => array(
   *    P_DB_FIELD => 'dbFieldName', - directly converts property to field and vice versa
   * )
   *
   * @var array[] $properties
   */
  protected $properties = array();

  /**
   * @var Accessors $accessors
   */
  protected $accessors;

  protected $newProperties = array();

  /**
   * Entity\EntityModel constructor.
   *
   * @param \Common\GlobalContainer $gc
   */
  public function __construct($gc) {
    // Here own rowOperator can be made - if needed to operate other, non-global, DB
    $this->rowOperator = $gc->dbGlobalRowOperator;

It seems like $gc->dbGlobalRowOperator can also be of type object<Closure>. However, the property $rowOperator is declared as type object<DbRowDirectOperator>. Maybe add an additional type check?

    $this->accessors = new Accessors();

    if (property_exists($this, 'newProperties') && !empty($this->newProperties)) {
      $this->extendProperties($this->newProperties);
    }
  }

  /**
   * @param EntityContainer $that
   * @param string          $accessor
   */
  protected function processRow($that, $accessor) {
    foreach ($this->properties as $propertyName => $propertyData) {
      $fieldName = !empty($propertyData[P_DB_FIELD]) ? $propertyData[P_DB_FIELD] : '';
      if ($this->accessors->exists($accessor, $propertyName)) {
        $this->accessors->execute($accessor, $propertyName, array($that, $propertyName, $fieldName));
      } elseif ($fieldName) {
        if ($accessor == P_CONTAINER_IMPORT) {
          $that->$propertyName = isset($that->row[$fieldName]) ? $that->row[$fieldName] : null;
        } else {
          $that->row += array($fieldName => $that->$propertyName);
        }
      }
      // Otherwise it's internal field - filled and used internally
    }
  }

  /**
   * Import DB row state into object properties
   *
   * @param EntityContainer $cEntity
   * @param array           $row
   */
  public function importRow($cEntity, $row) {
    $cEntity->clear();
    if (is_array($row) && !empty($row)) {
      $cEntity->row = $row;
      $this->processRow($cEntity, P_CONTAINER_IMPORT);
    }
  }

  /**
   * Exports object properties to DB row state with ID
   *
   * @param EntityContainer $cEntity
   */
  public function exportRow($cEntity) {
    $cEntity->row = array();
    $this->processRow($cEntity, P_CONTAINER_EXPORT);
  }

  /**
   * @param array $array
   *
   * @return EntityContainer
   */
  public function fromArray($array) {
    $cEntity = $this->buildContainer();
    $this->importRow($cEntity, $array);

    return $cEntity;
  }

  /**
   * @return EntityContainer
   */
  public function buildContainer() {
    /**
     * @var EntityContainer $container
     */
    $container = new $this->entityContainerClass($this);

    return $container;
  }

  /**
   * @param EntityContainer $cEntity
   *
   * @return bool
   */
  public function isEmpty($cEntity) {
    return $cEntity->isEmpty();
  }

  /**
   * @param EntityContainer $cEntity
   *
   * @return bool
   */
  // TODO - Loaded flag ?????

36% of this comment could be valid code. Did you maybe forget this after debugging?

  public function isNew($cEntity) {
    return $cEntity->isEmpty();
  }

  //
  // Save/load methods =================================================================================================

  /**
   * @param array $filter
   *
   * @return EntityContainer|false
   */
  public function load($filter) {

The parameter $filter is not used and could be removed.

    $cEntity = false;

$cEntity is not used, you could remove the assignment.

    $cEntity = $this->buildContainer();

    return $cEntity;
  }

  /**
   * @param EntityContainer $cEntity
   */
  protected function insert($cEntity) {
    $this->rowOperator->insert($this, $this->exportRow($cEntity));

$this->exportRow($cEntity) is of type null, but the function expects a array.

    // TODO - re-read record
  }

  /**
   * @param EntityContainer $cEntity
   *
   * @throws \Exception
   */
  protected function update($cEntity) {

The parameter $cEntity is not used and could be removed.

    // TODO - separate real changes from internal ones
    // Generate changeset row
    // Foreach all rows. If there is change and no delta - then put delta. Otherwise put change
    // If row not empty - update
    throw new \Exception(__CLASS__ . '::update() in ' . get_called_class() . 'is not yet implemented');
  }

  /**
   * @param EntityContainer $cEntity
   *
   * @throws \Exception
   */
  protected function delete($cEntity) {
    throw new \Exception(__CLASS__ . '::delete() in ' . get_called_class() . 'is not yet implemented');
  }

  /**
   * Method is called when trying to save DB_RECORD_LOADED but unchanged container
   *
   * Generally in this case no need in DB operations
   * If any entity require to save empty data (for updating timestamp for ex.) it should override this method
   *
   * @param EntityContainer $cEntity
   *
   * @throws \Exception
   */
  protected function onSaveUnchanged($cEntity) {

The parameter $cEntity is not used and could be removed.

    // TODO - or just save nothing ?????
//    throw new \Exception('EntityModel isNotEmpty, have dbId and not CHANGED! It can\'t be!');
    throw new \Exception(__CLASS__ . '::unchanged() in ' . get_called_class() . 'is not yet implemented');
  }

  /**
   * Method is called when trying to save newly created DB_RECORD_NEW and Empty container
   *
   * If it is needed to really save empty container (for log purposes, for ex.) child should override this method
   *
   * @param EntityContainer $cEntity
   *
   * @throws \Exception
   */
  protected function onSaveNew($cEntity) {

The parameter $cEntity is not used and could be removed.

    // Just created container and doesn't use it
//    throw new \Exception('EntityModel isEmpty but not loaded! It can\'t be!');
    throw new \Exception(__CLASS__ . '::emptyAction() in ' . get_called_class() . 'is not yet implemented');
  }

  /**
   * Saves entity to DB
   *
   * @param EntityContainer $cEntity
   */
  protected function save($cEntity) {
    if ($this->isEmpty($cEntity)) {
      if ($cEntity->isLoaded) {

The property isLoaded does not exist on object<Entity\EntityContainer>. Since you implemented __get, maybe consider adding a @property annotation.

        $this->delete($cEntity);
      } else {
        $this->onSaveNew($cEntity);
      }
    } else {
      if (empty($cEntity->dbId)) {

The property dbId does not exist on object<Entity\EntityContainer>. Since you implemented __get, maybe consider adding a @property annotation.

        $this->insert($cEntity);
      } elseif (method_exists($cEntity, 'isChanged') && $cEntity->isChanged()) {
        $this->update($cEntity);
      } else {
        $this->onSaveUnchanged($cEntity);
      }
    }
  }


  //
  // Protected properties accessors ====================================================================================

  /**
   * @return \DbRowDirectOperator
   */
  public function getRowOperator() {
    return $this->rowOperator;
  }

  /**
   * @param string $value
   */
  public function setTableName($value) {
    $this->tableName = $value;
  }

  /**
   * Gets entity's table name
   *
   * @return string
   */
  public function getTableName() {
    return $this->tableName;
  }

  /**
   * @return array[]
   */
  public function getProperties() {
    return $this->properties;
  }

  /**
   * @param $array
   */
  public function extendProperties($array) {
    $this->properties += $array;
  }

  /**
   * @return Accessors
   */
  public function getAccessors() {
    return $this->accessors;
  }

}