Source for file Base.php

Documentation is available at Base.php

  1. <?php
  2. /**
  3.  * This application is free software; you can redistribute
  4.  * it and/or modify it under the terms of the GNU
  5.  * General Public License as published by the Free
  6.  * Software Foundation; either version 3 of the License,
  7.  * or (at your option) any later version.
  8.  * 
  9.  * This application is distributed in the hope that it will
  10.  * be useful, but WITHOUT ANY WARRANTY; without even the
  11.  * implied warranty of MERCHANTABILITY or FITNESS FOR A
  12.  * PARTICULAR PURPOSE.  See the GNU General Public
  13.  * License for more details.
  14.  *
  15.  *
  16.  * @author Andrew Judd <contact@andrewjudd.ca>
  17.  * @copyright Andrew Judd, 2010
  18.  * @license http://www.gnu.org/licenses/gpl-3.0.txt GPLv3
  19.  *
  20.  * @project Mini MVC
  21.  * @name system/helpers/Base.php
  22.  * @description This class will provide some of the helper functions for the
  23.  *               generation of all of the pages as well as serve as a base for
  24.  *               any controllers to take on.
  25.  */
  26.  
  27. /* Check if attempting for direct access */
  28. if !defined '__FULLPATH__' ) )
  29. {
  30.     die header 'HTTP/1.0 404 Not Found' ) );
  31. }
  32.  
  33. class Base
  34. {
  35.     /**
  36.      * Stores any errors which have occurred while loading or handling of the
  37.      * information.
  38.      */
  39.     public static $errors NULL;
  40.     
  41.     /**
  42.      * Stores all of the configuration settings for the application.  This should
  43.      * either be NULL or an array.
  44.      */
  45.     protected static $config NULL;
  46.  
  47.     /**
  48.      * Stores the URI information about the page the user is currently on.
  49.      */
  50.     public static $uri NULL;
  51.  
  52.     /**
  53.      * Stores the parameters from the URL to pass into the function call.
  54.      */
  55.     public static $parameters NULL;
  56.  
  57.     /**
  58.      * Stores the list of error messages which will come from the template
  59.      * engine.  Only available through this class.
  60.      */
  61.     protected static $errorMessages NULL;
  62.  
  63.     /**
  64.      * Stores the list of any arguments which will be passed into the function
  65.      * if required.  If used, this will be an array which starts at 0 with all
  66.      * extra URI parameters (i.e. $uri [ 1 ] onwards) as well as any information
  67.      * provided through $_GET which will be bound to the variable names as
  68.      * dictated in $_GET.
  69.      */
  70.     public static $arguments array ();
  71.  
  72.     /** 
  73.      * An array of elements which will contain all of the database connections.
  74.      */
  75.     protected static $db_conns NULL;
  76.  
  77.     /**
  78.      * Constants for the pre-defined 'header', 'body', and 'footer' elements of
  79.      * the array.
  80.      */
  81.     const VIEW_HEADER 'header';
  82.     const VIEW_BODY 'body';
  83.     const VIEW_FOOTER 'footer';
  84.  
  85.     /**
  86.      * Constants for the configuration variable.
  87.      */
  88.     const DATABASE 'database';
  89.  
  90.     /**
  91.      * Constructor, will create the Base object setting up anything that it
  92.      * requires.
  93.      * @param array $config - The configuration for the application
  94.      */
  95.     public function __construct $config NULL )
  96.     {
  97.         /* Initialize the base class */
  98.         Base::__initialize $config );
  99.  
  100.         /* Parse the URI */
  101.         URI::__parseURI ();
  102.     }
  103.  
  104.     /**
  105.      * This function is used in order to initialize the configuration object if
  106.      * needed as well as set up the error messages based on the XML file
  107.      * located in the directory as speicified by the configuration file.
  108.      * @param array $config - The configuration for the application
  109.      */
  110.     public static function __initialize $config NULL )
  111.     {
  112.         /*  Load the specified error file and schema */
  113.         Base::__loadXML __ERRORFILE__Base::$errorMessages__ERRORSCHEMA__ );
  114.  
  115.         /* Only set the configuration if it isn't NULL */
  116.         if $config != NULL )
  117.         {
  118.             Base::$config $config;
  119.         }
  120.  
  121.     }
  122.  
  123.     /**
  124.      * This function can be used anywhere in order to load a specific helper
  125.      * library in order to allow it to be used later on.
  126.      * @param string $helper - The name of the library to load
  127.      * @returns boolean - TRUE if the library has been loaded, FALSE otherwise
  128.      */
  129.     public static function __loadHelper $helper )
  130.     {
  131.         /* Firstly, check the system helpers */
  132.         $chkPath __SYSTEMHELPERS__ $helper '.php';
  133.  
  134.         /* Check if the file exists */
  135.         if file_exists $chkPath == true )
  136.         {
  137.              /* Then load the system helper */
  138.              require_once $chkPath );
  139.         }
  140.         else
  141.         {
  142.             /* 
  143.              * Otherwise, it isn't a system library, so look in the user helper
  144.              * folder.
  145.              */
  146.             $chkPath __USERHELPERS__ $helper '.php';
  147.  
  148.             /* Check if the file exists */
  149.             if file_exists $chkPath == true )
  150.             {
  151.                 /* Then load the library */
  152.                 require_once $chkPath );
  153.             }
  154.             else
  155.             {
  156.                 /* It doesn't exist, so add it to the list of error messages */
  157.                 Base::$errors [sprintf Base::$errorMessages 'invalidlibrary' ],
  158.                     $helper );
  159.  
  160.                 return false );
  161.             }
  162.         }
  163.  
  164.         return true );
  165.     }
  166.  
  167.  
  168.     /**
  169.      * This fucntion is used in order load a specific controller into the
  170.      * memory so that it is able to be used later on (from the controller
  171.      * folder).
  172.      * @param $controller - The Controller which we will be loading
  173.      * @returns boolean - TRUE if the load was succesful, FALSE otherwise
  174.      */
  175.     public static function __loadController $controller )
  176.     {
  177.         /* Check if the file exists */
  178.         $file __CONTROLLERS__ strtolower $controller '.php';
  179.  
  180.         if file_exists $file ) )
  181.         {
  182.             /* Make sure that the base controller is included */
  183.             require_once __CONTROLLERS__ 'basecontroller.php' );
  184.  
  185.             /* Require the controller (only once) */
  186.             require_once $file );
  187.  
  188.             /* Check if the class exists */
  189.             if !class_exists $controller 'Controller' ) )
  190.             {
  191.                 /* Otherwise, class doesn't exist so provide an error message */
  192.                 Base::$errors [sprintf Base::$errorMessages
  193.                     'invalidcontroller' ]$controller );
  194.  
  195.                 /* Return error */
  196.                 return false );
  197.             }
  198.         }
  199.         else
  200.         {
  201.             Base::$errors [sprintf Base::$errorMessages
  202.                'controllerfilenotfound' ]$controller__CONTROLLERS__ );
  203.  
  204.             /* No file found, so return an error */
  205.             return false );
  206.         }
  207.  
  208.         /* Load successful */
  209.         return true );
  210.     }
  211.  
  212.     /**
  213.      * This function is used in order to load multiple views and display them
  214.      * on the page.
  215.      * @param array $views - An array of views which will be loaded.  There
  216.      *                        are three keys which can be used within this
  217.      *                        section.  They are as follows:
  218.      *                        <ul>
  219.      *                           <li>
  220.      *                               <em>header</em> - The information which
  221.      *                               will appear at the top of the page.
  222.      *                           </li>
  223.      *                           <li>
  224.      *                               <em>body</em> - The information which will
  225.      *                               appear in between the header and the footer
  226.      *                               of the web site.
  227.      *                           </li>
  228.      *                           <li>
  229.      *                               <em>footer</em> - The information which
  230.      *                               will appear at the end of your web site.
  231.      *                           </li>
  232.      *                       </ul>
  233.      *                       <strong>Please Note</strong>: At least one of
  234.      *                       these elements should exist within the array
  235.      *                       which is passed into this function or else nothing
  236.      *                       will be emitted.
  237.      *                       <strong>Please Note</strong>: Each of these elements
  238.      *                       can either be a single view or an array of views
  239.      *                       which will all be displayed.
  240.      * @param array $vars - An array containing an array of all variables which
  241.      *                       will be passed to each of the views.  Similar to
  242.      *                       the $views array, will pass all variables which are
  243.      *                       listed for those elements to only their
  244.      *                       corresponding views.  Any variables outside of the
  245.      *                       three keywords (header, body, footer) will be sent
  246.      *                       to each of the views.
  247.      *                       <strong>Please Note</strong>: variables will
  248.      *                       receive the variable name which corresponds to the
  249.      *                       key in the array.  For example, if you have an
  250.      *                       array: array ( 'foo' => 'bar' ), within the view,
  251.      *                       you are able to access this variable through $foo.
  252.      */
  253.     public static function __loadViews array $views$vars array () )
  254.     {
  255.         /* The base array that will be used */
  256.         $arrayBase array ();
  257.  
  258.         /* Add in all of the non-header/body/footer elements */
  259.         foreach $vars as $key => $value )
  260.         {
  261.             /* See if it is one of our reserved keys */
  262.             if $key != Base::VIEW_HEADER && $key != Base::VIEW_BODY &&
  263.                 $key != Base::VIEW_FOOTER )
  264.             {
  265.                 /* Not one of the predefined, so add it to the base array */
  266.                 $arrayBase $key $value;
  267.             }
  268.         }
  269.  
  270.         /* Try to load the header */
  271.         if isset $views Base::VIEW_HEADER ) )
  272.         {
  273.             Base::__handleView Base::VIEW_HEADER$views Base::VIEW_HEADER ],
  274.                 $arrayBase$vars );
  275.         }
  276.  
  277.         /* Try to load the body */
  278.         if isset $views Base::VIEW_BODY ) )
  279.         {
  280.             Base::__handleView Base::VIEW_BODY$views Base::VIEW_BODY ],
  281.                 $arrayBase$vars );
  282.         }
  283.  
  284.         /* Try to load the footer */
  285.         if isset $views Base::VIEW_FOOTER ) )
  286.         {
  287.             Base::__handleView Base::VIEW_FOOTER$views Base::VIEW_FOOTER ],
  288.                 $arrayBase$vars );
  289.         }
  290.  
  291.     }
  292.  
  293.     /**
  294.      * This function is used internally in order to handle the actual processing
  295.      * of everything to do with the view.  It will break the view up into several
  296.      * pieces and then present it in the specified order (as decided by where it
  297.      * is within the array.
  298.      * @param string $viewSection - The part of the view we are in.  Should be
  299.      *                               one of Base::VIEW_HEADER, Base::VIEW_BODY,
  300.      *                               BASE::VIEW_FOOTER
  301.      * @param array/string - Either and array of views to load, or a single view
  302.      * @param array $arrayBase - The baseline set of variables which will be sent
  303.      *                            to each of the views
  304.      * @param array $vars - The list of all variables to be provided in the view
  305.      */
  306.     private static function __handleView $viewSection$viewsarray $arrayBasearray $vars )
  307.     {
  308.         /* Check if we have any section-wide variables */
  309.         if isset $vars $viewSection &&
  310.             is_array $vars $viewSection ) )
  311.         {
  312.             /* 
  313.              * Load any variables which will be 'global'
  314.              * to the specified view section.
  315.              */
  316.  
  317.             foreach $vars $viewSection as $key => $value )
  318.             {
  319.                 /* Check if it is numeric (if it is, then it is view specific) */
  320.                 if is_int $key ) )
  321.                 {
  322.                     /* Otherwise, we are relatively global */
  323.                     $arrayBase $key $value;
  324.                 }
  325.             }
  326.         }
  327.  
  328.         /* There is at least 1 header, so try to load it */
  329.         if is_array $views ) )
  330.         {
  331.             /* Go through each of the elements including them one at a time */
  332.             foreach $views as $view => $name )
  333.             {
  334.                 $arraySend $arrayBase;
  335.  
  336.                 /* Add in any special view variables */
  337.                 if isset $vars $viewSection $view ) )
  338.                 {
  339.                     /* Add in only values which have keys */
  340.                     foreach $vars $viewSection $view as $key => $value )
  341.                     {
  342.                         /* Check if it is a valid key */
  343.                         if is_int $key ) )
  344.                         {
  345.                             /* It is, so send it through */
  346.                             $arraySend $key $value;
  347.                         }
  348.                         /* Otherwise it is invalid */
  349.                         else
  350.                         {
  351.                             /* Provide an error */
  352.                             Base::$errors [sprintf Base::$errorMessages
  353.                                 'invalidviewparameter' ]$key$views,
  354.                                 $value );
  355.                         }
  356.                     }
  357.                 }
  358.  
  359.                 /* Send the view */
  360.                 Base::__loadView $name$arraySend );
  361.             }
  362.         }
  363.         /* Otherwise there is only one element */
  364.         else
  365.         {
  366.             $arraySend $arrayBase;
  367.  
  368.             /* Add in any special view variables */
  369.             if isset $vars $viewSection ) )
  370.             {
  371.                 /* Add in only values which have keys */
  372.                 foreach $vars $viewSection as $key => $value )
  373.                 {
  374.                     /* Check if it is a valid key */
  375.                     if is_int $key ) )
  376.                     {
  377.                         /* It is, so send it through */
  378.                         $arraySend $key $value;
  379.                     }
  380.                     /* Otherwise it is invalid */
  381.                     else
  382.                     {
  383.                         /* Provide an error */
  384.                         Base::$errors [sprintf Base::$errorMessages
  385.                             'invalidviewparameter' ]$key$views,
  386.                             $value );
  387.                     }
  388.                 }
  389.             }
  390.  
  391.             /* Send the view */
  392.             Base::__loadView $views$arraySend );
  393.         }
  394.     }
  395.  
  396.     /**
  397.      * This function is used to actually load the specified view on the page.
  398.      * It starts by converting all of the predefined variables to variables
  399.      * for the page, and then it will check if the view exists.  If yes, then
  400.      * it will include it.
  401.      * @param $view - The view to load
  402.      * @param $vars - The variables which are accessible by the view
  403.      * @returns boolean - True if the displaying of the view was successful,
  404.      *                     False otherwise
  405.      */
  406.     public static function __loadView $view$vars array () )
  407.     {
  408.         /* Make sure that the view name passed in is a string */
  409.         if is_string $view ) )
  410.         {
  411.             /* Add the error */
  412.             Base::$errors [sprintf Base::$errorMessages
  413.                 'invalidviewvalue' );
  414.  
  415.             /* Can't do anything else here */
  416.             return false );
  417.         }
  418.  
  419.         /* Check if the base line is already present */
  420.         if stripos $view__VIEWS__ === FALSE )
  421.         {
  422.             /* Add in the views path */
  423.             $viewFile __VIEWS__ $view;
  424.         }
  425.         /* Otherwise, the path is already included */
  426.         else
  427.         {
  428.             /* Path is already accounted for */
  429.             $viewFile $view;
  430.         }
  431.  
  432.         /* Ensure that the view exists */
  433.         if file_exists $viewFile ) )
  434.         {
  435.             /* Add the error */
  436.             Base::$errors [sprintf Base::$errorMessages
  437.                 'viewfilenotfound' ]$view__VIEWS__ );
  438.  
  439.             /* Can't do anything else */
  440.             return false );
  441.         }
  442.  
  443.         /* All is good, so generate the variables and include it */
  444.  
  445.         foreach $vars as $key => $value )
  446.         {
  447.             $$key $value;
  448.         }
  449.  
  450.         include $viewFile );
  451.  
  452.         /* We were successful, so return true */
  453.         return true );
  454.     }
  455.  
  456.      /**
  457.      * This function is used in order to load any flat XML file into an array.
  458.      * It will take in a file and then load each of the elements into an
  459.      * array based on the element names.
  460.      * @param $xmlFile - The file name to load
  461.      * @param &$xmlData - The variable to store the array information into
  462.      * @param $schema - NULL by default, means that it will not be validated
  463.      *                   against any schema, however if a filename is provided,
  464.      *                   then the XML file will be validated.
  465.      */
  466.     public static function __loadXML $xmlFile&$xmlData$schema NULL )
  467.     {
  468.         
  469.         $xmlData array ();
  470.  
  471.         /* Load the XML file */
  472.         $xml new DOMDocument ();
  473.         $xml -> load $xmlFile );
  474.  
  475.         /* Try to validate the schema if necessary */
  476.         if $schema != NULL )
  477.         {
  478.             /* Enable the internal error handling */
  479.             libxml_use_internal_errors true );
  480.  
  481.             /* We have a schema, so validate against it */
  482.             if !$xml -> schemaValidate $schema ) )
  483.             {
  484.                 /* Not validated, so include errors and then return */
  485.                 libxml_display_errors ();
  486.  
  487.                 return;
  488.             }
  489.         }
  490.  
  491.         /* Grabe the document element */
  492.         $xmlDoc $xml -> documentElement;
  493.  
  494.         /* Load the data into the array */
  495.         foreach $xmlDoc -> childNodes as $child )
  496.         {
  497.             /* Assign the element to the array */
  498.             $xmlData $child -> nodeName ]  $child -> nodeValue;
  499.         }
  500.  
  501.         /* Clear up the created object */
  502.         unset $xml );
  503.     }
  504.  
  505.     /**
  506.      * This function is used in order to get external access to the list of
  507.      * error messages from a non-Base object class.
  508.      * @param $key - The key for the error message which is desired
  509.      * @returns string - The error message which corresponds to the key, or NULL
  510.      *                    if the error message at the key doesn't exist
  511.      */
  512.     public static function __getErrorMessage $key )
  513.     {
  514.         /* Check that the key exists before returning */
  515.         if isset Base::$errorMessages $key ) )
  516.         {
  517.             /* Return the error message */
  518.             return Base::$errorMessages $key );
  519.         }
  520.  
  521.         /* Return NULL if it doesn't exist */
  522.         return NULL );
  523.     }
  524.  
  525.     /*
  526.      * The following two functions were retrieved from:
  527.      * http://www.ibm.com/developerworks/opensource/library/x-validxphp/index.html?ca=dgr-twtrPHP-XML-Parsingdth-XML&S_TACT=105AGY83&S_CMP=TWDW
  528.      * They deal with the handling of errors using the DOMDocument object
  529.      * built into PHP as well as how to validate and parse an XML file
  530.      * from a predefined schema.
  531.      */
  532.     private static function libxml_display_errors ()
  533.     
  534.         $errors libxml_get_errors();
  535.  
  536.         foreach $errors as $error )
  537.         
  538.              libxml_display_error $error );
  539.         
  540.  
  541.         libxml_clear_errors ();
  542.     }
  543.  
  544.     private static function libxml_display_error $error )
  545.     {
  546.         $message '';
  547.  
  548.         switch $error -> level )
  549.         
  550.             case LIBXML_ERR_WARNING
  551.                 $message .= 'Warning ' $error -> code ': ';
  552.                 break
  553.             case LIBXML_ERR_ERROR
  554.                 $message .= 'Error ' $error -> code ': '
  555.                 break
  556.             case LIBXML_ERR_FATAL
  557.                 $message .= 'Fatal Error ' $error -> code ': '
  558.                 break
  559.         }
  560.  
  561.         $message .= trim $error -> message );
  562.  
  563.         if $error -> file )
  564.         {
  565.             $message .= ' in ' $error -> file;
  566.         }
  567.  
  568.         $message .= ' on line ' $error -> line;
  569.  
  570.         Base::$errors [$message
  571.     
  572.  
  573. }

Documentation generated on Thu, 01 Jul 2010 20:37:13 -0400 by phpDocumentor 1.4.3