Entity\EntityModel

Complexity

Total Complexity

22

Size/Duplication

Total Lines	228
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

0%

Importance

Changes	3
Bugs	0	Features	0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
B	processRow()	0	15	7
A	importRow()	0	8	3
A	fromArray()	0	9	1
A	exportRow()	0	4	1
A	buildContainer()	0	8	1
A	isEmpty()	0	3	1
A	isNew()	0	3	1
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;

/**
 * Class Entity\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 key field field in this table
   *
   * @var string $idFieldName
   */
  // TODO - remove
  protected $idFieldName = 'id';

  /**
   * 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 \Common\Accessors $accessors
   */
  protected $accessors;


  /**
   * 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 \Common\Accessors();
  }

  /**
   * @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->haveAccessor($propertyName, $accessor)) {
        $this->accessors->invokeAccessor($propertyName, $accessor, 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();
    $cEntity->row = $row;

    if (is_array($row) && !empty($row)) {
      $this->processRow($cEntity, P_CONTAINER_IMPORT);
    }
  }

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

    return $cEntity;
  }

  /**
   * 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);
  }

  /**
   * @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();
  }


//  /**
//   * Clears only properties which declared in $properties array
//   *
//   * @param EntityContainer $cEntity
//   */
//  public function clearProperties($cEntity) {
//    foreach ($this->properties as $propertyName => $propertyData) {
//      unset($cEntity->$propertyName);
//    }
//  }


  /**
   * @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;
  }

//  /**
//   * @param string $value
//   */
//  public function setIdFieldName($value) {
//    $this->idField = $value;
//  }
//  /**
//   * Gets entity's DB ID field name (which is unique within entity set)
//   *
//   * @return string
//   */
//  public function getIdFieldName() {
//    return $this->idField;
//  }

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

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

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

}