PKPRouter.inc.php

<?php
 
class PKPRouter {
   //
   // Internal state cache variables
   // NB: Please do not access directly but
   // only via their respective getters/setters
   //
   var $_application;
   var $_dispatcher;
   var $_contextDepth;
   var $_contextList;
   var $_flippedContextList;
   var $_contextPaths = array();
   var $_contexts = array();
   var $_handler;
 
   function __construct() {
   }
 
   function &getApplication() {
      assert(is_a($this->_application, 'PKPApplication'));
      return $this->_application;
   }
 
   function setApplication($application) {
      $this->_application = $application;
 
      // Retrieve context depth and list
      $this->_contextDepth = $application->getContextDepth();
      $this->_contextList = $application->getContextList();
      $this->_flippedContextList = array_flip($this->_contextList);
   }
 
   function &getDispatcher() {
      assert(is_a($this->_dispatcher, 'Dispatcher'));
      return $this->_dispatcher;
   }
 
   function setDispatcher($dispatcher) {
      $this->_dispatcher = $dispatcher;
   }
 
   function setHandler($handler) {
      $this->_handler = $handler;
   }
 
   function getHandler() {
      return $this->_handler;
   }
 
   function supports($request) {
      // Default implementation returns always true
      return true;
   }
 
   function isCacheable($request) {
      // Default implementation returns always false
      return false;
   }
 
   function getRequestedContextPaths($request) {
      // Handle context depth 0
      if (!$this->_contextDepth) return array();
 
      // Validate context parameters
      assert(isset($this->_contextDepth) && isset($this->_contextList));
 
      $isPathInfoEnabled = $request->isPathInfoEnabled();
      $userVars = array();
      $url = null;
 
      // Determine the context path
      if (empty($this->_contextPaths)) {
         if ($isPathInfoEnabled) {
            // Retrieve url from the path info
            if (isset($_SERVER['PATH_INFO'])) {
               $url = $_SERVER['PATH_INFO'];
            }
         } else {
            $url = $request->getCompleteUrl();
            $userVars = $request->getUserVars();
         }
 
         $this->_contextPaths = Core::getContextPaths($url, $isPathInfoEnabled,
            $this->_contextList, $this->_contextDepth, $userVars);
 
         HookRegistry::call('Router::getRequestedContextPaths', array(&$this->_contextPaths));
      }
 
      return $this->_contextPaths;
   }
 
   function getRequestedContextPath($request, $requestedContextLevel = 1) {
      // Handle context depth 0
      if (!$this->_contextDepth) return null;
 
      // Validate the context level
      assert(isset($this->_contextDepth) && isset($this->_contextList));
      assert($requestedContextLevel > 0 && $requestedContextLevel <= $this->_contextDepth);
 
      // Return the full context, then retrieve the requested context path
      $contextPaths = $this->getRequestedContextPaths($request);
      assert(isset($this->_contextPaths[$requestedContextLevel - 1]));
      return $this->_contextPaths[$requestedContextLevel - 1];
   }
 
   function &getContext($request, $requestedContextLevel = 1, $forceReload = false) {
      // Handle context depth 0
      if (!$this->_contextDepth) {
         $nullVar = null;
         return $nullVar;
      }
 
      if ($forceReload || !isset($this->_contexts[$requestedContextLevel])) {
         // Retrieve the requested context path (this validates the context level and the path)
         $path = $this->getRequestedContextPath($request, $requestedContextLevel);
 
         // Resolve the path to the context
         if ($path == 'index') {
            $this->_contexts[$requestedContextLevel] = null;
         } else {
            // Get the context name (this validates the context name)
            $requestedContextName = $this->_contextLevelToContextName($requestedContextLevel);
 
            // Get the DAO for the requested context.
            $contextClass = ucfirst($requestedContextName);
            $daoName = $contextClass.'DAO';
            $daoInstance = DAORegistry::getDAO($daoName);
 
            // Retrieve the context from the DAO (by path)
            $daoMethod = 'getByPath';
            assert(method_exists($daoInstance, $daoMethod));
            $this->_contexts[$requestedContextLevel] = $daoInstance->$daoMethod($path);
         }
      }
 
      return $this->_contexts[$requestedContextLevel];
   }
 
   function &getContextByName($request, $requestedContextName) {
      // Handle context depth 0
      if (!$this->_contextDepth) {
         $nullVar = null;
         return $nullVar;
      }
 
      // Convert the context name to a context level (this validates the context name)
      $requestedContextLevel = $this->_contextNameToContextLevel($requestedContextName);
 
      // Retrieve the requested context by level
      $returner = $this->getContext($request, $requestedContextLevel);
      return $returner;
   }
 
   function getIndexUrl($request) {
      if (!isset($this->_indexUrl)) {
         if ($request->isRestfulUrlsEnabled()) {
            $this->_indexUrl = $request->getBaseUrl();
         } else {
            $this->_indexUrl = $request->getBaseUrl() . '/index.php';
         }
         HookRegistry::call('Router::getIndexUrl', array(&$this->_indexUrl));
      }
 
      return $this->_indexUrl;
   }
 
 
   //
   // Protected template methods to be implemented by sub-classes.
   //
   function getCacheFilename($request) {
      // must be implemented by sub-classes
      assert(false);
   }
 
   function route($request) {
      // Must be implemented by sub-classes.
      assert(false);
   }
 
   function url($request, $newContext = null, $handler = null, $op = null, $path = null,
            $params = null, $anchor = null, $escape = false) {
      // Must be implemented by sub-classes.
      assert(false);
   }
 
   function handleAuthorizationFailure($request, $authorizationMessage) {
      // Must be implemented by sub-classes.
      assert(false);
   }
 
 
   //
   // Private helper methods
   //
   function _authorizeInitializeAndCallRequest(&$serviceEndpoint, $request, &$args, $validate = true) {
      $dispatcher = $this->getDispatcher();
 
      // It's conceivable that a call has gotten this far without
      // actually being callable, e.g. a component has been named
      // that does not exist and that no plugin has registered.
      if (!is_callable($serviceEndpoint)) $dispatcher->handle404();
 
      // Pass the dispatcher to the handler.
      $serviceEndpoint[0]->setDispatcher($dispatcher);
 
      // Authorize the request.
      $roleAssignments = $serviceEndpoint[0]->getRoleAssignments();
      assert(is_array($roleAssignments));
      if ($serviceEndpoint[0]->authorize($request, $args, $roleAssignments)) {
         // Execute class-wide data integrity checks.
         if ($validate) $serviceEndpoint[0]->validate($request, $args);
 
         // Let the handler initialize itself.
         $serviceEndpoint[0]->initialize($request, $args);
 
         // Call the service endpoint.
         $result = call_user_func($serviceEndpoint, $args, $request);
      } else {
         // Authorization failed - try to retrieve a user
         // message.
         $authorizationMessage = $serviceEndpoint[0]->getLastAuthorizationMessage();
 
         // Set a generic authorization message if no
         // specific authorization message was set.
         if ($authorizationMessage == '') $authorizationMessage = 'user.authorization.accessDenied';
 
         // Handle the authorization failure.
         $result = $this->handleAuthorizationFailure($request, $authorizationMessage);
      }
 
      // Return the result of the operation to the client.
      if (is_string($result)) echo $result;
      elseif (is_a($result, 'JSONMessage')) {
         header('Content-Type: application/json');
         echo $result->getString();
      }
   }
 
   function _urlCanonicalizeNewContext($newContext) {
      // Create an empty array in case no new context was given.
      if (is_null($newContext)) $newContext = array();
 
      // If we got the new context as a scalar then transform
      // it into an array.
      if (is_scalar($newContext)) $newContext = array($newContext);
 
      // Check whether any new context has been provided.
      // If not then return an empty array.
      $newContextProvided = false;
      foreach($newContext as $contextElement) {
         if(isset($contextElement)) $newContextProvided = true;
      }
      if (!$newContextProvided) $newContext = array();
 
      return $newContext;
   }
 
   function _urlGetBaseAndContext($request, $newContext = array()) {
      $pathInfoEnabled = $request->isPathInfoEnabled();
 
      // Retrieve the context list.
      $contextList = $this->_contextList;
 
      $baseUrlConfigSuffix = '';
      $overriddenContextCount = 0;
 
      // Determine URL context
      $context = array();
      foreach ($contextList as $contextKey => $contextName) {
         if ($pathInfoEnabled) {
            $contextParameter = '';
         } else {
            $contextParameter = $contextName.'=';
         }
 
         $newContextValue = array_shift($newContext);
         if (isset($newContextValue)) {
            // A new context has been set so use it.
            $contextValue = rawurlencode($newContextValue);
         } else {
            // No new context has been set so determine
            // the current request's context
            $contextObject = $this->getContextByName($request, $contextName);
            if ($contextObject) $contextValue = $contextObject->getPath();
            else $contextValue = 'index';
         }
 
         // Check whether the base URL is overridden.
         $baseUrlConfigSuffix .= "[$contextValue]";
         $newOverriddenBaseUrl = Config::getVar('general', 'base_url' . $baseUrlConfigSuffix);
         if (!empty($newOverriddenBaseUrl)) {
            $overriddenContextCount = $contextKey + 1;
            $overriddenBaseUrl = $newOverriddenBaseUrl;
         }
 
         $context[] = $contextParameter.$contextValue;
      }
 
      // Generate the base url
      if (!empty($overriddenBaseUrl)) {
         $baseUrl = $overriddenBaseUrl;
 
         // Throw the overridden context(s) away
         while ($overriddenContextCount>0) {
            array_shift($context);
            $overriddenContextCount--;
         }
      } else {
         $baseUrl = $this->getIndexUrl($request);
      }
 
      // Join base URL and context and return the result
      $baseUrlAndContext = array_merge(array($baseUrl), $context);
      return $baseUrlAndContext;
   }
 
   function _urlGetAdditionalParameters($request, $params = null, $escape = true) {
      $additionalParameters = array();
      if (!empty($params)) {
         assert(is_array($params));
         foreach ($params as $key => $value) {
            if (is_array($value)) {
               foreach($value as $element) {
                  $additionalParameters[] = $key.($escape?'%5B%5D=':'[]=').rawurlencode($element);
               }
            } else {
               $additionalParameters[] = $key.'='.rawurlencode($value);
            }
         }
      }
 
      return $additionalParameters;
   }
 
   function _urlFromParts($baseUrl, $pathInfoArray = array(), $queryParametersArray = array(), $anchor = '', $escape = false) {
      // parse_url does not support protocol relative URLs;
      // work around it here (https://bugs.php.net/bug.php?id=66274)
      if (strpos($baseUrl,'//')===0) {
         $baseUrl = 'http:' . $baseUrl;
         $protocolRelativeWorkaround = true;
      } else {
         $protocolRelativeWorkaround = false;
      }
 
      // Parse the base url
      $baseUrlParts = parse_url($baseUrl);
      assert(isset($baseUrlParts['scheme']) && isset($baseUrlParts['host']) && !isset($baseUrlParts['fragment']));
 
      // Reconstruct the base url without path and query
      // (supporting the work-around for protocol relative URLs)
      $baseUrl = $protocolRelativeWorkaround?'//':($baseUrlParts['scheme'].'://');
      if (isset($baseUrlParts['user'])) {
         $baseUrl .= $baseUrlParts['user'];
         if (isset($baseUrlParts['pass'])) {
            $baseUrl .= ':'.$baseUrlParts['pass'];
         }
         $baseUrl .= '@';
      }
      $baseUrl .= $baseUrlParts['host'];
      if (isset($baseUrlParts['port'])) $baseUrl .= ':'.$baseUrlParts['port'];
      $baseUrl .= '/';
 
      // Add path info from the base URL
      // to the path info array (if any).
      if (isset($baseUrlParts['path'])) {
         $pathInfoArray = array_merge(explode('/', trim($baseUrlParts['path'], '/')), $pathInfoArray);
      }
 
      // Add query parameters from the base URL
      // to the query parameter array (if any).
      if (isset($baseUrlParts['query'])) {
         $queryParametersArray = array_merge(explode('&', $baseUrlParts['query']), $queryParametersArray);
      }
 
      // Expand path info
      $pathInfo = implode('/', $pathInfoArray);
 
      // Expand query parameters
      $amp = ($escape ? '&amp;' : '&');
      $queryParameters = implode($amp, $queryParametersArray);
      $queryParameters = (empty($queryParameters) ? '' : '?'.$queryParameters);
 
      // Assemble and return the final URL
      return $baseUrl.$pathInfo.$queryParameters.$anchor;
   }
 
   function _contextLevelToContextName($contextLevel) {
      assert(isset($this->_contextList[$contextLevel - 1]));
      return $this->_contextList[$contextLevel - 1];
   }
 
   function _contextNameToContextLevel($contextName) {
      assert(isset($this->_flippedContextList[$contextName]));
      return $this->_flippedContextList[$contextName] + 1;
   }
}