Http.php

<?php
class Dsao_Uri_Http extends Dsao_DataHandler_Abstract
{
  protected static $_baseUri = null;

  protected $_fragment = null;

  protected static $_host = null;

  protected $_data = array();

  protected $_propertiesMandatory = array('module', 'controller', 'action');

  protected $_propertiesProtected = array('module', 'controller', 'action');

  protected static $_scheme = 'http';

  protected static $_token = null;

  public function __construct($uri = null, array $parameters = array(), $readOnly = false)
  {
    $this->setUri($uri);

    parent::__construct($parameters, $readOnly);
  }

  public function __toString()
  {
    return $this->toString();
  }

  protected function _getParametersString($parameters)
  {
    // string, Parameter, zu einem String zusammengefügt
    $parametersString = '';

    // Falls keine Parameter vorhanden oder keine übergeben werden sollen
    if (null === $this->_data || false === $parameters)
    {
      return $parametersString;
    }

    // Sortieren
    ksort($this->_data);

    // Parameterliste in Array umwandeln
    $parameters = (array) $parameters;

    // Zu übergebende Parameter
    $parametersNames = array();

    // Übergebene Parameter durchgehen
    foreach ($parameters as $parameter)
    {
      // Falls true (alle Parameter) oder false (keine Parameter)
      if (is_bool($parameter))
      {
        $parametersNames =
          (true === $parameter ? $this->_data : array());

        continue;
      }

      // Falls Parameter vorhanden
      if (isset($this->_data[$parameter]))
      {
        // Falls Parameter bereits in Liste vorhanden, löschen
        if (isset($parametersNames[$parameter]))
        {
          unset($parametersNames[$parameter]);
        }
        // Ansonsten hinzufügen
        else
        {
          $parametersNames[$parameter] = true;
        }
      }
    }

    // Nun die endgültigen Parameter durchgehen und String basteln
    foreach ($parametersNames as $parameter => $value)
    {
      // Modul, Controller, Aktion und Token und Error-Handler überspringen
      if (in_array($parameter,
        array('action', 'controller', 'module', 'token', 'error_handler')))
      {
        continue;
      }

      $parametersString .= '/'.$parameter.'/'. urlencode((string) $this->_data[$parameter]);
    }

    return $parametersString;
  }

  protected function _parsePath($module, $controller, $action)
  {
    // array, Name der Teile des Adressteils des URI
    $adress = array(
      'module'      => $module,
      'controller'  => $controller,
      'action'      => $action
    );

    // Modul, Controller und Aktion durchgehen, sofern vorhanden.
    foreach ($adress as $part => $value)
    {
      // Falls kein Wert übergeben
      if (!$value)
      {
        continue;
      }

      $this->_data[$part] = $value;
    }
  }

  protected function _parseQuery($query)
  {
    // Falls Query leer
    if (!$query)
    {
      return;
    }

    // Parameter durchgehen
    foreach (explode('&', $query) as $parameter)
    {
      $parts = explode('=', $parameter);

      $this->_data[$parts[0]] = (isset($parts[1]) ? $parts[1] : true);
    }
  }

  protected function _parseUri($uri)
  {
    // Aufteilen des URI
    $pattern =
      '~^((?<protocol>https?|ftp)://(?<host>[^/?#]*))?/'.
      '(?<baseUri>'.self::$_baseUri.'/)?((?<module>[^/?#]*)/)?'.
      '((?<controller>[^/?#]*)/)?(?<action>[^/?#]*)?'.
      '(?<userParameters>[^?#]*)?\??((?<query>[^#]*))?#?(?<fragment>.*)?$~';

    preg_match($pattern, $uri, $matches);

    // Falls Aufteilung nicht erfolgreich war
    if (empty($matches))
    {
      return;
    }

    // Falls externe Adresse übergeben wurde
    if ($matches['host'] && $matches['host'] != self::$_host)
    {
      throw new Dsao_Exception(array(
        'message' => 'dsao_uri_http_unknown_host',
        'variables' => array('host' => $matches['host']),
        ));
    }

    // Fragment setzen
    $this->_fragment = $matches['fragment'];

    // Verschiedene Teile des URI parsen, mit aufsteigender Priorität

    // Query parsen
    $this->_parseQuery($matches['query']);

    // User-Parameter parsen
    $this->_parseUserParameters($matches['userParameters']);

    // Pfad parsen
    $this->_parsePath
      ($matches['module'], $matches['controller'], $matches['action']);

  }

  protected function _parseUserParameters($parameters)
  {
    // Falls Parameterliste leer
    if (!$parameters)
    {
      return;
    }

    // array, Parameter
    $partsParameters = explode('/', $parameters);

    // int, Anzahl Parameter-Teile (= Anzahl Parameter * 2 +-1)
    $countPartsParameters = count($partsParameters);

    // Parameter durchgehen (in Zweierschritten)
    for ($i = 0; $i < $countPartsParameters; $i += 2)
    {
      // Falls Parameter leerer String, annehmen, dass aus Versehen ein Slash
      // doppelt ist, und nur um eins inkrementieren (-1 +2 = 1)
      if (!$partsParameters[$i])
      {
        $i--;
        continue;
      }

      // Falls letztes Element erreicht oder kein Wert für den Parameter
      // übergeben wurde, Wert setzen
      if ($i == ($countPartsParameters-1) || !$partsParameters[($i+1)])
      {
        $partsParameters[($i+1)] = true;
      }


      $this->_data[$partsParameters[$i]] =
        urldecode($partsParameters[($i+1)]);
    }
  }

  public function createUriString($uri, $appendToken = true, $absolute = false)
  {
    // string, URI
    $uriResult = '';

    // Falls absoluter URI angefordert wurde
    if ($absolute)
    {
      $uriResult .= self::$_scheme.'://'.self::$_host;
    }

    // Slash voranstellen
    $uri = '/'. ltrim($uri, '/');

    // Eigentlicher URI mit Parametern
    $uriResult .= (self::$_baseUri ? self::$_baseUri.$uri : $uri);

    // Falls Token angehängt werden soll
    if ($appendToken)
    {
      $uriResult .= '/token/'.self::getToken();
    }

    return $uriResult.($this->_fragment ? '#'.$this->_fragment : '');
  }

  public function getAclResourceId()
  {
    return $this->_data['module'].'_'.
      $this->_data['controller'].'_'.$this->_data['action'];
  }

  public function getFragment()
  {
    return $this->_fragment;
  }

  public function getParameters($parameters = null, $default = null)
  {
    return parent::getData($parameters, $default);
  }

  public static function getToken()
  {
    return self::$_token;
  }

  public function getUriString($parameters = true, $appendToken = false, $absolute = false)
  {
    return $this->toString($parameters, $appendToken, $absolute);
  }

  public function hasParameters(array $parametersNames = array(), $or = false)
  {
    return parent::hasData($parametersNames, $or, array('token'));
  }

  public static function setBaseUri($baseUri)
  {
    self::$_baseUri = $baseUri;
  }

  public function setFragment($fragment)
  {
    $this->_fragment = (string) $fragment;

    return $this;
  }

  public static function setHost($host)
  {
    self::$_host = $host;
  }

  public function setParameters(array $parameters = array(), $overwrite = true)
  {
    return parent::setData($parameters, $overwrite);
  }

  public static function setScheme($scheme = 'http')
  {
    self::$_scheme = $scheme;
  }

  public static function setToken($token = null)
  {
    // Falls kein Token übergeben, neues erzeugen
    if (null === $token)
    {
      $token = Dsao_Hash::factory()->getHash(4);
    }

    self::$_token = $token;

    return $token;
  }

  public function setUri($uri = false)
  {
    // Falls URI zurück gesetzt werden soll
    if (false === $uri)
    {
      $this->setParameters(array(
        'module'      => null,
        'controller'  => null,
        'action'      => null));
    }
    else
    {
      $this->_parseUri($uri);
    }

    return $this;
  }

  public function toString($parameters = true, $appendToken = false, $absolute = false)
  {
    // Gültigkeit prüfen
    $this->isValid(true);

    // string, Parameter als String zusammensetzen
    $parametersString = $this->_getParametersString($parameters);

    // URI zusammenfügen
    $uri = '/'.$this->_data['module'].'/'.
      $this->_data['controller'].'/'.$this->_data['action'].
      $parametersString;

    // URI  zurückgeben
    return $this->createUriString($uri, $appendToken, $absolute);
  }
}