User.php

<?php
class Dsao_Hash_User extends Dsao_Hash
{
  protected $_row = null;

  protected $_uri = null;

  protected function __construct($hash = null, $length = 32, array $parameters = array(), $uri = '')
  {
    // Falls Objekt übergeben wurde
    if (is_object($uri))
    {
      $this->_uri = $uri;
      $this->_uri->setParameters($parameters, true);
    }
    // Ansonsten wurde String übergeben
    else
    {
      $this->_uri = new Dsao_Uri_Http($uri, $parameters);
    }

    // Falls Hash noch null ist
    if (null === $hash)
    {
      $hash = $this->_uri->hash;
    }


    parent::__construct($hash, $length);
  }

  public function __get($parameter)
  {
    return $this->_uri->__get($parameter);
  }

  public function __set($parameter, $value)
  {
    // Falls Objekt schreibgeschützt ist
    $this->isReadOnly(true);


    return $this->_uri->__set($parameter, $value);
  }

  protected function _findRow($again = false)
  {
    // Falls schon geprüft wurde und nicht nochmal geprüft werden soll
    if (null !== $this->_row && !$again)
    {
      return;
    }

    // Falls keine Hash-ID vorhanden ist
    if (!$this->_uri->idHash)
    {
      $this->_row = Dsao_Registry::getTable('user_hash')->select()
        ->where('idUser = ?', $this->_uri->idUser)
        ->where('hash = ?', $this->getHash())->fetchRow();

      // Falls Zeile gefunden wurde
      if ($this->_row)
      {
        $this->_uri->idHash = $this->_row->id;
      }
    }
    else
    {
      $this->_row = Dsao_Registry::getTable('user_hash')
        ->find($this->_uri->idHash)->current();
    }
  }

  public function deleteDuplicates()
  {
    // Falls Objekt nicht gültig
    if (!$this->isValid(null))
    {
      throw new Dsao_Exception('dsao_hash_user_object_invalid');
    }

    // Where-Klausel
    $sqlWhere = 'idUser = '. (int) $this->_row->idUser.' AND '.
      Dsao_Registry::get('db')->quoteInto
        ('hashAction = ?', $this->_row->hashAction).' AND '.
      'id != '. (int) $this->_row->id;

    // Löschen
    Dsao_Registry::getTable('user_hash')->delete($sqlWhere);

    return $this;
  }

  public function deleteRow()
  {
    // Falls Zeile vorhanden, löschen
    if ($this->isValid(null))
    {
      $this->_row->delete();
      $this->_row = null;
    }

    return $this;
  }

  public static function factory($hash = null, $uri = '', array $parameters = array(), $length = 32)
  {
    // Objekt zurück geben
    return new self($hash, $length, $parameters, $uri);
  }

  public static function fromText($text = null, $uri = '', array $parameters = array(),  $length = 32)
  {
    $hash = new self(null, $length, $parameters, $uri);

    $hash->_generateHash($text);

    return $hash;
  }

  public function getUri()
  {
    return $this->_uri;
  }

  public function hasDuplicates()
  {
    // Falls Hash nicht gültig
    $this->isReadOnly(true);

    // SELECT-Statement
    return (bool) Dsao_Registry::getTable('user_hash')->select(true)
      ->reset(Zend_Db_Select::COLUMNS)
      ->columns(new Zend_Db_Expr('COUNT(*) AS duplicates'))
      ->where('idUser = ?', (int) $this->_row->idUser)
      ->where('hashAction = ?', $this->_row->hashAction)
      ->where('id != ?', $this->_row->id)
      ->fetchRow()->duplicates;
  }

  public function isValid($parametersNames = true, $recheck = false)
  {
    // Falls entweder neu geprüft werden soll oder noch nicht geprüft wurde
    if ($recheck || null === $this->_row)
    {
      $this->_findRow();
    }

    // Falls keine Zeile gefunden, abbrechen
    if (!$this->_row || null === $parametersNames)
    {
      return $this->_row;
    }

    // Ggf. Parameterliste in Array umwandeln
    if (!is_array($parametersNames))
    {
      $parametersNames = array($parametersNames);
    }

    // Leerer Array -> false
    if (empty($parametersNames))
    {
      $parametersNames = array(false);
    }
    // Ansonsten prüfen, ob als erster Parameter true übergeben wurde
    else if ($parametersNames[0] === true)
    {
      $parametersNames = array_merge($parametersNames,
        array('hash', 'idHash'));
    }

    // Falls Benutzer-ID nicht übereinstimmt
    if ($this->_row->idUser != $this->_uri->idUser
        // oder Hash nicht übereinstimmt
        || !parent::factory($this->_row->hash)->compareTo($this)
        // oder Hash der Aktion nicht stimmt
        || !parent::factory($this->_row->hashAction)->compareTo
            (parent::fromText($this->_uri
              ->getUriString($parametersNames))))
    {
      return false;
    }

    return true;
  }

  public function insert()
  {
    // Falls Zeile vorhanden
    if ($this->isValid(null))
    {
      throw new Dsao_Exception('dsao_hash_user_hash_inserted');
    }

    // Falls keine Benutzer-ID vorhanden
    if (!$this->_uri->idUser)
    {
      throw new Dsao_Exception('dsao_hash_user_id_missing');
    }

    // Hash hinzufügen
    $this->_uri->hash = $this->getHash();

    // Hash der Aktion
    $hashAction = parent::fromText($this->_uri->
      getUriString(array(true, 'hash', 'idHash')), null, $this->_length);

    // Daten
    $data = array(
      'idUser'      => (int) $this->_uri->idUser,
      'hash'        => $this->getHash(),
      'hashAction'  => $hashAction->getHash(),
      );

    $this->_uri->idHash = Dsao_Registry::getTable('user_hash')->insert($data);

    return $this;
  }
}