Abstract.php

<?php
abstract class Dsao_Db_Table_DataHandler_Abstract
  extends Dsao_DataHandler_Abstract
{
  protected $_identifiers = array();

  protected $_synchronous = null;

  protected $_table = null;

  public function __construct(array $data = array(), $readOnly = false, $synchronous = false)
  {
    parent::__construct($data, $readOnly);

    $this->setSynchronous($synchronous);
  }

  public function __sleep()
  {
    return array_merge(parent::__sleep(), array('_synchronous'));
  }

  protected function _addWhere(Zend_Db_Select $select, array $identifiers = array(), array $options = array())
  {
    // Optionen
    $table = (isset($options['table']) ? $options['table'].'.' : '');
    $values = (isset($options['values']) ? (array) $options['values'] : array());

    // Falls keine Identifizierer übergeben wurden, die ersten gültigen nehmen
    if (!$identifiers)
    {
      $identifiers = $this->_getValidIdentifiers();
    }

    // Methode zum Hinzufügen der Where-Klausel ermitteln
    $whereMethod = 'where';

    // Falls Operator übergeben wurde
    if (isset($options['operator']) && $operator == Zend_Db_Select::SQL_OR)
    {
      $whereMethod = 'orWhere';
    }

    // Identifizierer durchgehen
    foreach ($identifiers as $identifier)
    {
      // Identifizierer quoten
      $identifierQuoted = $this->getTable()->getAdapter()
        ->quoteIdentifier($table.$identifier);

      // Wert bestimmen
      $value = (isset($values[$identifier]) ? $values[$identifier] :
        $this->__get($identifier));

      // Where-Klausel hinzufügen
      $select->$whereMethod($identifierQuoted.' = ?', $value);
    }
  }

  protected function _checkValidity()
  {
    // Falls die Elternklasse das Objekt als gültig markiert hat und entweder
    // Identifizierer vorhanden oder Objekt noch synchron
    if (parent::_checkValidity() &&
        ($this->hasIdentifier() || $this->isSynchronous()))
    {
      $this->_valid = true;
    }

    return $this->_valid;
  }

  protected function _getValidIdentifiers($firstOnly = true)
  {
    $identifiersValid = array();

    // Identifizierer durchgehen
    foreach ($this->_identifiers as $index => $identifiers)
    {
      $identifiers = (array) $identifiers;

      foreach ($identifiers as $identifier)
      {
        // Falls einer der Identifizierer nicht existiert, direkt in den
        // nächsten Durchlauf der darüber liegenden Schleife springen
        if (!$this->__isset($identifier))
        {
          break 2;
        }
      }

      $identifiersValid[] = $identifiers;

      // Falls nach erstem Fund abgebrochen werden soll
      if (true === $firstOnly)
      {
        return array_pop($identifiersValid);
      }
    }

    return $identifiersValid;
  }

  protected function _parseResult($row, $setSynchronous = true)
  {
    $synchronous = false;

    // Falls Zeile gefunden wurde
    if ($row)
    {
      $synchronous = true;

      // Falls kein Array übergeben wurde, umwandeln
      if (!is_array($row))
      {
        $row = $row->toArray();
      }

      // Daten setzen
      $this->setData($row);
    }

    // Falls Synchronität gesetzt werden soll
    if ($setSynchronous)
    {
      $this->_synchronous = $synchronous;
      $this->_valid = true;
    }

    return $synchronous;
  }

  protected function _resetValidity()
  {
    parent::_resetValidity();

    // Falls Objekt synchron
    if (true === $this->_synchronous)
    {
      $this->setSynchronous(false);
    }
  }

  public function delete()
  {
    // Ggf. Exception werfen
    $this->isReadOnly(true);
    $this->hasIdentifier(true);

    // Synchronität zurücksetzen
    $this->_synchronous = null;

    return $this;
  }

  public function exists()
  {
    // Falls Objekt noch synchron
    if ($this->isSynchronous())
    {
      return true;
    }
    // Falls keine Identifizierer vorhanden
    else if (!$this->hasIdentifier())
    {
      return false;
    }

    return null;
  }

  public function getData($properties = null, $default = null, $reload = false)
  {
    // Falls Daten erneut geladen werden sollen
    if ($reload)
    {
      // Daten erneut aus Datenbank laden
      $this->refresh();
    }

    return parent::getData($properties, $default);
  }


  public function getTable($name = null)
  {
    // Falls kein Tabellenname übergeben wurde
    if (null == $name)
    {
      // Falls Tabelle noch nicht instanziiert wurde
      if (is_string($this->_table))
      {
        $this->_table = Dsao_Registry::getTable($this->_table);
      }

      return $this->_table;
    }
    // Ansonsten Tabelle mit übergebenem Namen zurück geben
    else
    {
      return Dsao_Registry::getTable($name);
    }
  }

  public function hasIdentifier($throw = false)
  {
    // Falls gültige Identifizierer vorhanden oder Objekt synchron
    if ($this->isSynchronous() || $this->_getValidIdentifiers())
    {
      return true;
    }
    // Ansonsten ggf. Exception werfen
    else if ($throw)
    {
      throw new Dsao_Exception
        ('dsao_db_table_datahandler_abstract_identifier');
    }

    return false;
  }

  public function insert()
  {
    $this->isReadOnly(true);

    // Falls keine Änderungen vorgenommen wurden
    if (true === $this->isSynchronous())
    {
      return $this;
    }
    // Falls Objekt bereits in Datenbank
    else if (false === $this->isSynchronous())
    {
      throw new Dsao_Exception
        ('dsao_db_table_datahandler_abstract_insert_synchronous');
    }

    // Falls Objekt nicht gültig, abbrechen
    $this->isValid(true);

    return $this;
  }

  public function isSynchronous($refresh = false)
  {
    if (false === $this->_synchronous && $refresh)
    {
      $this->refresh();
    }

    return $this->_synchronous;
  }

  public function refresh()
  {
    // Ggf. Exception werfen
    $this->isReadOnly(true);
    $this->hasIdentifier(true);

    return $this;
  }

  public function setSynchronous($synchronous = true)
  {
    $this->_synchronous = (bool) $synchronous;

    // Wenn Objekt synchron ist, muss es auch gültig sein
    if ($synchronous)
    {
      $this->_valid = true;
    }

    return $this;
  }

  public function update(array $properties = array())
  {
    $this->isReadOnly(true);

    // Falls noch nie synchron gewesen, also nicht mit Datenbank verbunden
    if (null === $this->isSynchronous())
    {
      throw new Dsao_Exception
        ('dsao_db_table_datahandler_abstract_update_not_connected');
    }

    return $this;
  }
}