[ Index ]

PHP Cross Reference of DokuWiki

title

Body

[close]

/inc/ -> ActionRouter.php (source)

   1  <?php
   2  
   3  namespace dokuwiki;
   4  
   5  use dokuwiki\Action\AbstractAction;
   6  use dokuwiki\Action\Exception\ActionDisabledException;
   7  use dokuwiki\Action\Exception\ActionException;
   8  use dokuwiki\Action\Exception\FatalException;
   9  use dokuwiki\Action\Exception\NoActionException;
  10  use dokuwiki\Action\Plugin;
  11  
  12  /**
  13   * Class ActionRouter
  14   * @package dokuwiki
  15   */
  16  class ActionRouter {
  17  
  18      /** @var  AbstractAction */
  19      protected $action;
  20  
  21      /** @var  ActionRouter */
  22      protected static $instance = null;
  23  
  24      /** @var int transition counter */
  25      protected $transitions = 0;
  26  
  27      /** maximum loop */
  28      const MAX_TRANSITIONS = 5;
  29  
  30      /** @var string[] the actions disabled in the configuration */
  31      protected $disabled;
  32  
  33      /**
  34       * ActionRouter constructor. Singleton, thus protected!
  35       *
  36       * Sets up the correct action based on the $ACT global. Writes back
  37       * the selected action to $ACT
  38       */
  39      protected function __construct() {
  40          global $ACT;
  41          global $conf;
  42  
  43          $this->disabled = explode(',', $conf['disableactions']);
  44          $this->disabled = array_map('trim', $this->disabled);
  45          $this->transitions = 0;
  46  
  47          $ACT = act_clean($ACT);
  48          $this->setupAction($ACT);
  49          $ACT = $this->action->getActionName();
  50      }
  51  
  52      /**
  53       * Get the singleton instance
  54       *
  55       * @param bool $reinit
  56       * @return ActionRouter
  57       */
  58      public static function getInstance($reinit = false) {
  59          if((self::$instance === null) || $reinit) {
  60              self::$instance = new ActionRouter();
  61          }
  62          return self::$instance;
  63      }
  64  
  65      /**
  66       * Setup the given action
  67       *
  68       * Instantiates the right class, runs permission checks and pre-processing and
  69       * sets $action
  70       *
  71       * @param string $actionname this is passed as a reference to $ACT, for plugin backward compatibility
  72       * @triggers ACTION_ACT_PREPROCESS
  73       */
  74      protected function setupAction(&$actionname) {
  75          $presetup = $actionname;
  76  
  77          try {
  78              // give plugins an opportunity to process the actionname
  79              $evt = new Extension\Event('ACTION_ACT_PREPROCESS', $actionname);
  80              if ($evt->advise_before()) {
  81                  $this->action = $this->loadAction($actionname);
  82                  $this->checkAction($this->action);
  83                  $this->action->preProcess();
  84              } else {
  85                  // event said the action should be kept, assume action plugin will handle it later
  86                  $this->action = new Plugin($actionname);
  87              }
  88              $evt->advise_after();
  89  
  90          } catch(ActionException $e) {
  91              // we should have gotten a new action
  92              $actionname = $e->getNewAction();
  93  
  94              // this one should trigger a user message
  95              if(is_a($e, ActionDisabledException::class)) {
  96                  msg('Action disabled: ' . hsc($presetup), -1);
  97              }
  98  
  99              // some actions may request the display of a message
 100              if($e->displayToUser()) {
 101                  msg(hsc($e->getMessage()), -1);
 102              }
 103  
 104              // do setup for new action
 105              $this->transitionAction($presetup, $actionname);
 106  
 107          } catch(NoActionException $e) {
 108              msg('Action unknown: ' . hsc($actionname), -1);
 109              $actionname = 'show';
 110              $this->transitionAction($presetup, $actionname);
 111          } catch(\Exception $e) {
 112              $this->handleFatalException($e);
 113          }
 114      }
 115  
 116      /**
 117       * Transitions from one action to another
 118       *
 119       * Basically just calls setupAction() again but does some checks before.
 120       *
 121       * @param string $from current action name
 122       * @param string $to new action name
 123       * @param null|ActionException $e any previous exception that caused the transition
 124       */
 125      protected function transitionAction($from, $to, $e = null) {
 126          $this->transitions++;
 127  
 128          // no infinite recursion
 129          if($from == $to) {
 130              $this->handleFatalException(new FatalException('Infinite loop in actions', 500, $e));
 131          }
 132  
 133          // larger loops will be caught here
 134          if($this->transitions >= self::MAX_TRANSITIONS) {
 135              $this->handleFatalException(new FatalException('Maximum action transitions reached', 500, $e));
 136          }
 137  
 138          // do the recursion
 139          $this->setupAction($to);
 140      }
 141  
 142      /**
 143       * Aborts all processing with a message
 144       *
 145       * When a FataException instanc is passed, the code is treated as Status code
 146       *
 147       * @param \Exception|FatalException $e
 148       * @throws FatalException during unit testing
 149       */
 150      protected function handleFatalException(\Exception $e) {
 151          if(is_a($e, FatalException::class)) {
 152              http_status($e->getCode());
 153          } else {
 154              http_status(500);
 155          }
 156          if(defined('DOKU_UNITTEST')) {
 157              throw $e;
 158          }
 159          $msg = 'Something unforseen has happened: ' . $e->getMessage();
 160          nice_die(hsc($msg));
 161      }
 162  
 163      /**
 164       * Load the given action
 165       *
 166       * This translates the given name to a class name by uppercasing the first letter.
 167       * Underscores translate to camelcase names. For actions with underscores, the different
 168       * parts are removed beginning from the end until a matching class is found. The instatiated
 169       * Action will always have the full original action set as Name
 170       *
 171       * Example: 'export_raw' -> ExportRaw then 'export' -> 'Export'
 172       *
 173       * @param $actionname
 174       * @return AbstractAction
 175       * @throws NoActionException
 176       */
 177      public function loadAction($actionname) {
 178          $actionname = strtolower($actionname); // FIXME is this needed here? should we run a cleanup somewhere else?
 179          $parts = explode('_', $actionname);
 180          while(!empty($parts)) {
 181              $load = join('_', $parts);
 182              $class = 'dokuwiki\\Action\\' . str_replace('_', '', ucwords($load, '_'));
 183              if(class_exists($class)) {
 184                  return new $class($actionname);
 185              }
 186              array_pop($parts);
 187          }
 188  
 189          throw new NoActionException();
 190      }
 191  
 192      /**
 193       * Execute all the checks to see if this action can be executed
 194       *
 195       * @param AbstractAction $action
 196       * @throws ActionDisabledException
 197       * @throws ActionException
 198       */
 199      public function checkAction(AbstractAction $action) {
 200          global $INFO;
 201          global $ID;
 202  
 203          if(in_array($action->getActionName(), $this->disabled)) {
 204              throw new ActionDisabledException();
 205          }
 206  
 207          $action->checkPreconditions();
 208  
 209          if(isset($INFO)) {
 210              $perm = $INFO['perm'];
 211          } else {
 212              $perm = auth_quickaclcheck($ID);
 213          }
 214  
 215          if($perm < $action->minimumPermission()) {
 216              throw new ActionException('denied');
 217          }
 218      }
 219  
 220      /**
 221       * Returns the action handling the current request
 222       *
 223       * @return AbstractAction
 224       */
 225      public function getAction() {
 226          return $this->action;
 227      }
 228  }