Subversion Repositories PHPX

<?php

namespace PointedEars\PHPX;

/**
* Abstract model class for Object-Relational Mapping
*
* Provides simple mapping of a model object to records of
* a table of a relational database.
*
* @property Db\Table $persistentTable
* @author Thomas Lahn
*/
abstract class Model extends \PointedEars\PHPX\AbstractModel
{
  /**
   * The <code>Table</code> for instances of this model
   *
   * @type Table|string
   */
        protected static $_persistentTable;

  /**
   * The name(s) of the property or properties whose value(s)
   * identify this object in the <code>Table</code>.  They are
   * used for comparing against the primary key column(s) of
   * the <code>Table</code>.
   *
   * @type string|array[string]
   */
        protected static $_persistentId = 'id';

  /**
   * The names of the properties that should be used in database
   * queries, and their mapping to the columns of
   * the <code>Table</code>, if specified (keys are property names,
   * values are column names, or both if the key is numeric).
   *
   * NOTE: It should not be necessary to include the
   * <code>persistentId</code> property value here.  If an object
   * is not in the database, it should be assigned an ID
   * automatically when saved; if it is in the database,
   * you already have its ID as you searched by it.
   *
   * @type array
   */
  protected static $_persistentProperties = array();

        /**
   * Creates a new model object
   *
   * @see AbstractModel::__construct()
   */
  public function __construct (
    array $data = null, array $mapping = null, $exclusiveMapping = false)
  {
    parent::__construct($data, $mapping, $exclusiveMapping);
  }

  public function getPersistentTable ()
  {
        $class = \get_class($this);
        if (\is_string($class::$_persistentTable))
        {
                /* Call setter to convert to Table */
                $this->setPersistentTable($class::$_persistentTable);
        }

        return $class::$_persistentTable;
  }

  public function setPersistentTable ($value)
  {
        $class = \get_class($this);
        if ($value instanceof Table)
        {
                $class::$_persistentTable = $value;
        }
        else
        {
                $table = new $value();
                if (!($table instanceof Db\Table))
                {
                        throw new \InvalidArgumentException(
                                'Parameter does not specify a subclass of \\PointedEars\\PHPX\\Table: '
                                . $value
                        );
                }

                $class::$_persistentTable = $table;
        }
  }

  /**
   * Returns an array containing the property-column mapping.
   *
   * @param array $propertyNames = null
   *   Names of the properties that should be included.
   *   The default is to include all persistent properties.
   * @return array
   */
  public static function getPersistentMapping (array $propertyNames = null)
  {
    $a = array();

        $persistent_properties = static::$_persistentProperties;

        if ($propertyNames === null)
        {
                $propertyNames = $persistent_properties;
        }

        foreach ($propertyNames as $property_name)
        {
          if (!array_key_exists($property_name, $persistent_properties))
          {
                        $column_name = $property_name;
          }
          else
          {
            $column_name = $persistent_properties[$property_name];
          }

                $a[$property_name] = $column_name;
        }

        return $a;
  }

  /**
   * Returns an array for database queries containing the
   * property values of this object, using the specified
   * property-to-column mapping.
   *
   * @param array $propertyNames = null
   *   Names of the properties that should be included.
   *   The default is to include all persistent properties.
   * @return array
   */
  public function getPropertyArray (array $propertyNames = null)
  {
        $a = array();

        if ($propertyNames === null)
        {
                $class = \get_class($this);
                $propertyNames = $class::$_persistentProperties;
        }

        foreach ($propertyNames as $propertyName => $columnName)
        {
                if (is_numeric($propertyName))
                {
                        $propertyName = $columnName;
                }

                $a[$columnName] = $this->$propertyName;
        }

        return $a;
  }

  /**
   * Finds the record for the model object in the table, fills
   * the object with missing data, and returns the result.
   *
   * @param mixed $id = null
   *   The ID of the object to find.  If <code>null</code> (default),
   *   the object is searched for by its current ID.
   * @return Model|null
   *   This object filled with missing data, or <code>null</code>
   *   if there is no data for this object
   * @see Table::find(int)
   */
  public function find ($id = null)
  {
        $class = \get_class($this);
        if ($id === null)
        {
          $id = $this->{$class::$_persistentId};
        }

    $result = $this->persistentTable->find($id);
    if ($id !== null)
    {
      $this->{$class::$_persistentId} = $id;
    }

    $result = $this->persistentTable->find($this->{$class::$_persistentId});
    if ($result)
    {
        return $this->map($result);
    }

    return null;
  }

  /**
   * Finds the records for model objects in the table by value,
   * and returns the result.
   *
   * @param string $name
   *   Name of the property to search for.
   * @param mixed $value = null
   *   The property value to find.  If <code>null</code>,
   *   the current value of the specified property is used.
   *   (To search for null, you need to make sure that the
   *   current property value is <code>null</code>, which is
   *   the PHP default.)
   * @return array[Model]|null
   *   Model objects, or <code>null</code> if there is no data
   *   for this property and value
   * @see Table::select(Model)
   */
  public function findByProperty ($name, $value = null)
  {
    $class = \get_class($this);
        $mapping = $class::getPersistentMapping(array($name));

        if ($value === null)
        {
          $value = $this->$name;
        }

    $results = $this->persistentTable->select(null,
      array($mapping[$name] => $value));

    if ($results)
    {
        return array_map(array($this, 'map'), $results);
    }

    return null;
  }

  /**
   * Saves the model object in the table
   *
   * @param array $propertyNames = null
   *   Names of the properties whose values should be saved
   *   in the database.  The default is to save the values
   *   of all persistent properties.
   * @return boolean
   *   The return value of
   *   <code>$this->persistentTable->updateOrInsert()</code>.
   * @see Model::getPropertyArray()
   * @see Table::updateOrInsert()
   */
  public function save (array $propertyNames = null)
  {
        $table = $this->persistentTable;
        $class = \get_class($this);
        $idPropertyName = $class::$_persistentId;

        $result = $table->updateOrInsert(
                $this->getPropertyArray($propertyNames),
                array(
                        $table->id => $this->$idPropertyName
                )
        );

        if ($result && ($lastInsertId = $table->lastInsertId))
        {
                $this->$idPropertyName = $lastInsertId;
        }

        return $result;
  }

  /**
   * Inserts the model object into the table
   *
   * @param array $propertyNames = null
   *   Names of the properties whose values should be insert
   *   in the database.  The default is to insert the values
   *   of all persistent properties.
   * @return boolean
   * @see Model::getPropertyArray()
   * @see Table::insert()
   */
  public function insert (array $propertyNames = null)
  {
        $table = $this->persistentTable;
        $class = \get_class($this);
        $idPropertyName = $class::$_persistentId;

        $result = $table->insert($this->getPropertyArray($propertyNames));

        if ($result && ($lastInsertId = $table->lastInsertId))
        {
                $this->$idPropertyName = $lastInsertId;
        }

        return $result;
  }

  /**
   * Deletes a model object from the <code>Table</code>
   *
   * @return bool
   * @see Table::delete()
   */
  public function delete ()
  {
        $class = \get_class($this);
        return $this->persistentTable->delete($this->{$class::$_persistentId});
  }
}