ManiaLib 1.0b1 API Reference

Source for file RequestEngineMVC.class.php

Documentation is available at RequestEngineMVC.class.php

  1. <?php
  2. /**
  3.  * @author Maxime Raoust
  4.  * @copyright 2009-2010 NADEO
  5.  * @package ManiaLib
  6.  * @subpackage MVC
  7.  */
  8.  
  9. /**
  10.  * RequestEngine designed for MVC framework
  11.  * @package ManiaLib
  12.  * @subpackage MVC
  13.  */
  14. class RequestEngineMVC extends RequestEngine
  15. {
  16.     /**
  17.      * @ignore
  18.      */
  19.     static private $instance;
  20.     
  21.     /**#@+
  22.      * @ignore 
  23.      */
  24.     protected $action;
  25.     protected $controller;
  26.     /**#@-*/
  27.     
  28.     /**
  29.      * Gets the instance
  30.      * @return RequestEngineMVC 
  31.      */
  32.     public static function getInstance()
  33.     {
  34.         if (!self::$instance)
  35.         {
  36.             $class = __CLASS__;
  37.             self::$instance = new $class;
  38.         }
  39.         return self::$instance;
  40.     }
  41.     
  42.     /**
  43.      * @ignore
  44.      */
  45.     protected function __construct()
  46.     {
  47.         parent::__construct();
  48.         $route = array_keys($this->params);
  49.         $route = reset($route);
  50.         if($route && substr($route, 0, 1)=='/')
  51.         {
  52.             array_shift($this->params);
  53.             $route = explode('/', $route);
  54.         }
  55.         else 
  56.         {
  57.             $route = array();
  58.         }
  59.         // $route[0] is null because of the first '/'
  60.         $this->controller = array_key_exists(1, $route) && $route[1] ? $route[1] : APP_MVC_DEFAULT_CONTROLLER;
  61.         $this->action = array_key_exists(2, $route) && $route[2] ? $route[2] : null;
  62.         $this->controller = Route::separatorToUpperCamelCase($this->controller);
  63.         $this->action = $this->action ? Route::separatorToCamelCase($this->action) : null;
  64.     }
  65.     
  66.     public function getAction($defaultAction = null)
  67.     {
  68.         return $this->action ? $this->action : $defaultAction;
  69.     }
  70.         
  71.     public function getController()
  72.     {
  73.         return $this->controller;
  74.     }
  75.     
  76.     /**
  77.      * Redirects to the specified route with all defined GET vars in the URL
  78.      * @param string Can be the name of a controller or a class const of Route
  79.      * @param string Can be the name of an action or a class const of Route
  80.      */
  81.     public function redirectManialink($controller = Route::CUR, $action = Route::CUR)
  82.     {
  83.         $manialink = $this->createLink($controller, $action);
  84.         $this->redirectManialinkAbsolute($manialink);
  85.     }
  86.     
  87.     /**
  88.      * Redirects to the specified route with, with names of GET vars as parameters of the method
  89.      * @param string Can be the name of a controller or a class const of Route
  90.      * @param string Can be the name of an action or a class const of Route
  91.      */
  92.     public function redirectManialinkArgList($controller, $action)
  93.     {
  94.         $arr = func_get_args();
  95.         array_shift($arr);
  96.         $args = array();
  97.         foreach($arr as $elt)
  98.         {
  99.             if(array_key_exists($elt, $this->params))
  100.             {
  101.                 $args[$elt] = $this->params[$elt];
  102.             }    
  103.         }
  104.         $manialink = $this->createLinkString($controller, $action, $args);
  105.         $this->redirectManialinkAbsolute($manialink);
  106.     }
  107.     
  108.     /**
  109.      * Creates a link to the specified route with all defined GET vars in the URL
  110.      * @param string Can be the name of a controller or a class const of Route
  111.      * @param string Can be the name of an action or a class const of Route
  112.      */
  113.     public function createLink($controller = Route::CUR, $action = Route::CUR)
  114.     {
  115.         return $this->createLinkString($controller, $action, $this->params);
  116.     }
  117.     
  118.     /**
  119.      * Creates a link to the specified route with, with names of GET vars as parameters of the method
  120.      * @param string Can be the name of a controller or a class const of Route
  121.      * @param string Can be the name of an action or a class const of Route
  122.      */
  123.     function createLinkArgList($controller = Route::CUR, $action = Route::CUR)
  124.     {
  125.         $arr = func_get_args();
  126.         array_shift($arr);
  127.         $args = array();
  128.         foreach($arr as $elt)
  129.         {
  130.             if(array_key_exists($elt, $this->params))
  131.             {
  132.                 $args[$elt] = $this->params[$elt];
  133.             }    
  134.         }
  135.         return $this->createLinkString($controller, $action, $args);
  136.     }
  137.     
  138.     /**
  139.      * @ignore
  140.      */
  141.     protected function createLinkString($controller = Route::CUR, $action = Route::CUR, $params = array())
  142.     {
  143.         switch($controller)
  144.         {
  145.             case Route::CUR:
  146.             case null:
  147.                 $controller = $this->getController();
  148.                 break;
  149.                 
  150.             case Route::DEF:
  151.                 $controller = APP_MVC_DEFAULT_CONTROLLER;
  152.                 break;
  153.                 
  154.             case Route::NONE:
  155.                 $controller = null;
  156.                 break;
  157.                 
  158.             default:
  159.                 // Nothing here
  160.         }
  161.         
  162.         switch($action)
  163.         {
  164.             case Route::CUR:
  165.             case null:
  166.                  $action = $this->getAction(null);
  167.                  break;
  168.                  
  169.             case Route::DEF:
  170.             case Route::NONE:
  171.                 $action = null;
  172.                 break;
  173.                 
  174.             default:
  175.                 // Nothing here
  176.         }
  177.         $controller = Route::camelCaseToSeparator($controller);
  178.         $action = Route::camelCaseToSeparator($action);
  179.         
  180.         // URL string
  181.         if(APP_MVC_USE_URL_REWRITE)
  182.         {
  183.             $url = APP_URL.$controller.'/';
  184.             if($action)
  185.             {
  186.                 $url .= $action.'/';
  187.             }
  188.         }
  189.         else
  190.         {
  191.             $url = APP_URL;
  192.             $route = '';
  193.             if($controller)
  194.             {
  195.                 $route = '/'.$controller.'/';
  196.                 if($action)
  197.                 {
  198.                     $route .= $action.'/';
  199.                 }
  200.             }
  201.             if($route)
  202.             {
  203.                 $url = $url.'?'.$route;
  204.             }
  205.         }
  206.         // Create parameter string
  207.         if(count($params))
  208.         {
  209.             $params = http_build_query($params, '', '&');
  210.         }
  211.         else
  212.         {
  213.             $params = '';
  214.         }
  215.         if(APP_MVC_USE_URL_REWRITE)
  216.         {
  217.             return $url.($params? '?'.$params:'');
  218.         }    
  219.         else
  220.         {
  221.             return $url.($params? ($route?'&':'?').$params : '');
  222.         }
  223.         
  224.     }
  225. }
  226.  
  227. ?>