Source for file actionfactory.php

Documentation is available at actionfactory.php

  1. <?php
  2. /**
  3. * Create Action object that will do whatever category of work is required in this invocation
  4. *
  5. * @author     Stuart Prescott
  6. * @copyright  Copyright Stuart Prescott
  7. * @license    http://opensource.org/licenses/gpl-license.php GNU Public License
  8. * @version    $Id$
  9. * @package    Bumblebee
  10. * @subpackage Actions
  11. *
  12. *  path (bumblebee root)/inc/actions/actionfactory.php
  13. */
  14.  
  15. /** Load ancillary functions */
  16. require_once 'inc/typeinfo.php';
  17. checkValidInclude();
  18.  
  19. /**  permissions definitions */
  20. require_once 'inc/permissions.php';
  21.  
  22. if (LOAD_ALL_PHP_FILES) {
  23.   /**  basic functions (user functions) */
  24.   require_once 'login.php';
  25.   require_once 'logout.php';
  26.   require_once 'view.php';
  27.   require_once 'calendar.php';
  28.   require_once 'book.php';
  29.   require_once 'bookcontact.php';
  30.   require_once 'password.php';
  31.   require_once 'masquerade.php';
  32.  
  33.   // admin functions
  34.     /**  admin functions*/
  35.   require_once 'groups.php';
  36.   require_once 'projects.php';
  37.   require_once 'users.php';
  38.   require_once 'instruments.php';
  39.   require_once 'consumables.php';
  40.   require_once 'consume.php';
  41.   require_once 'deletedbookings.php';
  42.   require_once 'costs.php';
  43.   require_once 'specialcosts.php';
  44.   require_once 'userclass.php';
  45.   require_once 'instrumentclass.php';
  46.   //require_once 'adminconfirm.php';
  47.     require_once 'emaillist.php';
  48.   // require_once 'report.php';
  49.     require_once 'export.php';
  50.   require_once 'billing.php';
  51.   require_once 'backupdatabase.php';
  52.   require_once 'settings.php';
  53. }
  54.  
  55. require_once 'unknownaction.php';
  56. require_once 'inc/typeinfo.php';
  57. require_once 'actions.php';
  58.  
  59. /**
  60. * Factory class for creating Action objects
  61. *
  62. * An Action is a single operation requested by the user. What action is to be performed
  63. * is determined by the action-triage mechanism in the class ActionFactory.
  64. *
  65. * Everything done by an application suite (e.g. edit/create a user) can be reduced to
  66. * broad categories of actions (e.g. edituser) which can be encapsulated within an
  67. * object framework in which every object has the same interface.
  68. *
  69. * The invoking code is thus boiled down to something quite simple:
  70. * <code>
  71. * $action = new ActionFactory($params);
  72. * $action->go();
  73. * </code>
  74. * where ActionFactory does the work of deciding what is to be done on this
  75. * invocation and instantiates the appropriate action object.
  76. *
  77. * The action object then actually performs the tasks desired by the user.
  78. *
  79. * Here, we use the data from the browser (a PATH_INFO variable from the URL in the form
  80. * index.php/user) to triage the transaction.
  81. *
  82. * @package    Bumblebee
  83. * @subpackage Actions
  84. */
  85. class ActionFactory {
  86.   /** @var string          the user-supplied "verb" (name of the action) e.g. "edituser" */
  87.   var $_verb;
  88.   /** @var string          the actual user-supplied verb... we may pretend to do something else due to permissions  */
  89.   var $_original_verb;
  90.   /**  @var string         Each action has a description associated with it that we will put into the HTML title tag  */
  91.   var $title;
  92.   /**  @var ActionAction   The action object (some descendent of the ActionAction class)   */
  93.   var $_action;
  94.   /**  @var BumblebeeAuth  The user's login credentials object  */
  95.   var $_auth;
  96.   /**  @var array          user-supplied data from the PATH_INFO and GET sections of the URL  */
  97.   var $PDATA;
  98.   /**  @var string         The 'verb' that should follow this current action were a standard workflow being followed   */
  99.   var $nextaction;
  100.   /**  @var array          ActionListing object  */
  101.   var $actionListing;
  102.   /**  @var ActionData     The action data object for this action  */
  103.   var $_actionData;
  104.  
  105.   /**
  106.   * Constructor for the class
  107.   *
  108.   * - Parse the submitted data
  109.   * - work out what action we are supposed to be performing
  110.   * - set up the title tag for the browser
  111.   * - create the ActionAction descendent object that will perform the task
  112.   *
  113.   * @param BumblebeeAuth $auth      user login credentials object
  114.   * @param string        $forceVerb force a particular action
  115.   */
  116.   function ActionFactory($auth, $forceVerb=null) {
  117.     $this->_auth = $auth;
  118.     #$this->PDATA = $this->_eatPathInfo();
  119.     $this->PDATA = $this->_eatGPCInfo();
  120.     $this->actionListing = new ActionListing();
  121.     $this->_verb = $this->_checkActions($forceVerb);
  122.     $this->_actionData = $this->actionListing->actions[$this->_verb];
  123.     $this->nextaction = $this->_actionData->next_action();
  124.     $this->title = $this->_actionData->title();
  125.     $this->_action = $this->_makeAction();
  126.     $this->_action->readOnly = ! $this->checkMagic();
  127.   }
  128.  
  129.   /**
  130.   * Fire the action: make things actually happen now
  131.   */
  132.   function go() {
  133.     $this->_action->go();
  134.   }
  135.  
  136.   function verb() {
  137.     return $this->_verb;
  138.   }
  139.  
  140.   /**
  141.   * Determine what action should be performed.
  142.   *
  143.   * This is done by:
  144.   * - checking that the user is logged in... if not, they *must* login
  145.   * - looking for hints in the user-supplied data for what the correct action is
  146.   * - checking that the user is an admin user if admin functions were requested
  147.   *
  148.   * @param string        $forceVerb  force a particular action
  149.   * @return string                   the name of the action (verb) to be undertaken
  150.   */
  151.   function _checkActions($forceVerb) {
  152.     if ($forceVerb !== null) return $forceVerb;
  153.  
  154.     $action = '';
  155.  
  156.     # first, we need to determine if we are actually logged in or not
  157.     # if we are not logged in, the the action *has* to be 'login'
  158.     if (! $this->_auth->isLoggedIn()) return 'login';
  159.  
  160.     #We can have action verbs past to us in three different ways.
  161.     # 1. first PATH_INFO
  162.     # 2. explicit PATH_INFO action=
  163.     # 3. action= form fields
  164.     # Later specifications are used in preference to earlier ones
  165.  
  166.     $explicitaction = issetSet($this->PDATA, 'forceaction');
  167.     $pathaction = issetSet($this->PDATA, 'action');
  168.     $formaction = issetSet($_POST, 'action');
  169.     #$pathaction = $PDATA['action'];
  170.     #$formaction = $_POST['action'];
  171.  
  172.     if ($formaction) $action = $formaction;
  173.     if ($pathaction) $action = $pathaction;
  174.     if ($explicitaction) $action = $explicitaction;
  175.  
  176.     $this->_original_verb = $action;
  177.  
  178.     // dump if unknown action
  179.     if (! $this->actionListing->action_exists($action)) {
  180.       return 'unknown';
  181.     }
  182.     // protect admin functions
  183.     if (! $this->_auth->permitted($this->actionListing->actions[$action]->permissions)) {
  184.       return 'forbidden!';
  185.     }
  186.  
  187.     # We also need to check to see if we are trying to change privileges
  188.     #if (isset($_POST['changemasq']) && $_POST['changemasq']) return 'masquerade';
  189.  
  190.     return $action;
  191.   }
  192.  
  193.   /**
  194.   * Trigger a restart of the action or a new action
  195.   *
  196.   * Sometimes, an action may need to be restarted or the action changed (e.g. logout => login)
  197.   *
  198.   * @param string $newaction  new verb for the new action
  199.   */
  200.   function _actionRestart($newaction) {
  201.     $this->_verb=$newaction;
  202.     $this->_action = $this->_makeAction();
  203.     $this->go();
  204.   }
  205.  
  206.   /**
  207.   * Parse the user-supplied data in PATH_INFO part of URL
  208.   *
  209.   * @returns array  (key => $data)
  210.   */
  211.   function _eatPathInfo() {
  212.     $pd = array();
  213.     $pathinfo = issetSet($_SERVER, 'PATH_INFO');
  214.     if ($pathinfo) {
  215.       $path = explode('/', $pathinfo);
  216.       $pd['action'] = $path[1];
  217.       $actions = preg_grep("/^action=/", $path);
  218.       $forceaction = array_keys($actions);
  219.       if (isset($forceaction[0])) {
  220.         preg_match("/^action=(.+)/",$path[$forceaction[0]],$m);
  221.         $pd['forceaction'] = $m[1];
  222.         $max = $forceaction[0];
  223.       } else {
  224.         $max = count($path);
  225.       }
  226.       for($i=2; $i<$max; $i++) {
  227.         $pd[$i-1] = $path[$i];
  228.       }
  229.     }
  230.     return $pd;
  231.   }
  232.  
  233.   /**
  234.   * Parse the user-supplied data from either the GET or POST data
  235.   *
  236.   * @returns array  (key => $data)
  237.   */
  238.   function _eatGPCInfo() {
  239.     //$pd = $this->_eatPathInfo();
  240.     //return array_merge($pd, $_GET, $_POST);
  241.     $data = array_merge($_GET, $_POST);
  242.     foreach ($data as $k => $v) {
  243.       if (preg_match('@^reflection_(.+)$@', $k, $matches)) {
  244.         $data[$matches[1]] = $v;
  245.         #print "Remapped $matches[1] => $v<br />";
  246.       }
  247.     }
  248.     return $data;
  249.   }
  250.  
  251.   function checkMagic() {
  252.     return isset($this->_auth) && $this->_auth->isValidTag(issetSet($_POST, 'magicTag', NULL));
  253.   }
  254.  
  255.   /**
  256.   * Is it ok to allow the HTML template to dump to the browser from the output buffer?
  257.   *
  258.   * (see BufferedAction descendents)
  259.   *
  260.   * @returns boolean  ok to dump to browser
  261.   */
  262.   function ob_flush_ok() {
  263.     return $this->_action->ob_flush_ok;
  264.   }
  265.  
  266.   /**
  267.   * Cause buffered actions to output their data to the browser
  268.   *
  269.   * (see BufferedAction descendents)
  270.   */
  271.   function returnBufferedStream() {
  272.     if (method_exists($this->_action, 'sendBufferedStream')) {
  273.       $this->_action->sendBufferedStream();
  274.     }
  275.   }
  276.  
  277.   /**
  278.   * create the action object (a descendent of ActionAction) for the user-defined verb
  279.   */
  280.   function _makeAction() {
  281.     /** to reduce PHP processing overhead, include only the file that is required for this action */
  282.     require_once $this->_actionData->include_file();
  283.     switch ($this->_verb) {
  284.       case 'forbidden!':
  285.         return new ActionUnknown($this->_original_verb, 1);
  286.       case 'unknown':
  287.         return new ActionUnknown($this->_original_verb);
  288.       default:
  289.         $class = $this->_actionData->action_class();
  290.         return new $class ($this->_auth, $this->PDATA);
  291.     }
  292.   }
  293.  
  294. }
  295.  //class ActionFactory
  296.  
  297. ?>

Documentation generated on Tue, 06 Mar 2007 10:00:28 +0000 by phpDocumentor 1.3.0