root/trunk/patPortal.php

<?PHP
/**
 * patPortal
 *
 * $Id$
 *
 * An extendible framework to solve the
 * web problem (and others as well)
 *
 * @author        Stephan Schmidt <schst@php-tools.net>
 * @license        PHP License
 * @package        patPortal
 */

if (!defined( 'PATPORTAL_BASE_PATH' )) {
    define( 'PATPORTAL_BASE_PATH', dirname( __FILE__ ) );
}

/**
 * uses the factory
 */
require_once PATPORTAL_BASE_PATH.'/patPortal/Factory.php';
    
/**
 * autoload function that loads classes on demand
 *
 * @param    string        name of the class
 */
function __autoload($class)
{
    patPortal_Factory::loadClass($class);
}

/**
 * patPortal main class
 *
 * This is the controller
 *
 * @author        Stephan Schmidt <schst@php-tools.net>
 * @license        PHP License
 * @package        patPortal
 */
class patPortal
{
   /**
    * store the instance
    *
    * @var object patPortal
    */
    private static $instance = null;

   /**
    * configuration object
    *
    * @var object patPortal_Configuration
    */
    private $config;
    
   /**
    * error handler
    *
    * @var    object patPortal_ErrorHandler
    */
    private $errorHandler;

   /**
    * accesspoint of the portal
    *
    * @var  object patPortal_AccessPoint
    */
    private $accessPoint;

   /**
    * request
    *
    * @var  patPortal_Request
    */
    private $request;

   /**
    * response
    *
    * @var  patPortal_Response
    */
    private $response;

   /**
    * session
    *
    * @var  patPortal_Session
    */
    private $session;
    
   /**
    * authentication
    *
    * @var  patPortal_Auth
    */
    private $auth = null;

   /**
    * event manager
    *
    * @var  patPortal_EventManager
    */
    private $eventManager;

   /**
    * The requested page
    *
    * @var  patPortal_Page
    */
    private $page;

   /**
    * create a new patPortal instance
    *
    * @param    string    path to configuration file
    */
    public static function create($configFile = null)
    {
        if (self::$instance === null) {
            self::$instance = new patPortal( $configFile );
        }
        return self::$instance;
    }

   /**
    * constructor
    *
    * @param    string    path to the main configuration file
    */
    private function __construct($configFile)
    {
        $this->config = patPortal_Configuration::singleton();
        $this->config->setConfigFile( $configFile );
        $this->errorHandler = new patPortal_ErrorHandler();
        
        // we'll convert patError objects to Exceptions
        patErrorManager::setErrorHandling(E_ALL, 'callback', array( $this->errorHandler, 'handlePatError' ) );
    }

   /**
    * provide the service
    *
    * This method accepts three parameters. You may specify
    * a portal, an accesspoint and a debugging enviroment
    *
    * @param    string        portal id
    * @param    string        access point
    * @param    string        debugging environment
    */
    public function service( $portalId, $accessPoint, $environment )
    {
        try {
            /**
             * load config
             */
            $this->config->load( $portalId, $accessPoint, $environment );
    
            $this->buildEnvironment();
    
            $this->loadPlugins();
            
            /**
             * insert cache here!
             */
            $this->render();

            // insert HTML snippets created by the plugins
            patPortal_PluginManager::insertOutput($this->request, $this->response);
            
            $this->response->send($this->request);
            
            $this->closeEnvironment();
        } catch (Exception $e) {
            
            // This is used while patPortal is still in development
            // more flexible error handling will be implemented later
            echo '<b>Exception has been thrown, we need an error page.</b>';
            echo '<pre>';
            echo $e;
            echo '</pre>';
            exit();
        }
    }

   /**
    * build the environment
    *
    * @todo        check for errors
    */
    private function buildEnvironment()
    {
        $this->registerErrorHandling();

        /**
         * configure directories
         */
        patPortal_Factory::configureDirectories( $this->config->getDirectories() );

        $this->registerEventListeners();

        $this->config->getPersistence();
        
        $this->accessPoint = $this->config->getAccessPoint();
        
        $sitemap = $this->accessPoint->getSitemap();
        $this->sitemap = patPortal_Sitemap::singleton( $sitemap['type'], $sitemap );

        $this->request  = $this->accessPoint->getRequest($this->eventManager);

        $this->response = $this->accessPoint->getResponse($this->eventManager);
        
        // access point uses session
        if ($this->accessPoint->hasSession()) {
            // name of the session
            $sessionName = $this->accessPoint->getSessionName();
            
            // check, whether the request contained the ID
            $id = $this->request->getSessionIdentifier($sessionName);
            
            // fetch the session object
            $this->session = $this->accessPoint->getSession($this->eventManager, $id);
            
            // pass it to the request
            $this->request->setSession($this->session);
        }
        
        // accesspoint uses authentication
        if ($this->accessPoint->hasAuth()) {
            $this->auth = $this->accessPoint->getAuth($this->eventManager);
            $this->request->setAuth($this->auth);
        }

        // fetch the properties of the request
        $this->request->fetchProperties();
        $this->request->applyUrlScheme();
    }

   /**
    * register event listeners
    *
    * @return   boolean
    */    
    function registerEventListeners()
    {
        $this->eventManager = patPortal_EventManager::getInstance('Root', null, 'Portal');
        patPortal_EventManager::registerEventListeners($this->config->getEvents(), $this);
        return true;
    }

   /**
    * register the error handling
    *
    * @return    boolean
    */
    private function registerErrorHandling()
    {
        foreach ($this->config->getErrorHandling() as $level => $handlers) {
            foreach ($handlers as $handler => $options) {
                $this->errorHandler->registerHandler($level, $handler, $options);
            }
        }
        return true;
    }

   /**
    * load all registered plugins
    *
    * Plugins are defined in the XML file.
    *
    * @return boolean
    */
    private function loadPlugins()
    {
        $pluginSpecs = $this->config->getPlugins();
        patPortal_PluginManager::registerPlugins($pluginSpecs);
        
        patPortal_PluginManager::processRequest($this->request, $this->response);
        return true;
    }
    
   /**
    * close the environment
    *
    * Stores session data, etc.
    */
    private function closeEnvironment()
    {
        if (is_object($this->session)) {
            $this->session->closeSession();
        }
    }

   /**
    * render the current page
    *
    * This will:
    * - load and render all components
    *
    * @return    boolean
    */
    private function render()
    {
        $requestedPage = $this->request->getPath();
        $this->callPage($requestedPage);

        $this->page->prepare();

        if ($this->request->hasFrame()) {
            $this->config->selectFrame($this->request->getFrame());
        } else {
            $this->config->selectFrame($this->page->frame);
        }

        $this->page->buildAreas($this->config->getAreas());
        
        if ($this->request->cancelled()) {
            return true;
        }
        $this->page->buildComponents();
        
        patPortal_Lifecycle::execute();
        
        $this->request->start();

        patPortal_Lifecycle::render($this->page);

        return true;
    }
    
   /**
    * open a page
    *
    * @param    string    path of the page
    * @todo        find a clean way to set the path inside the request, maybe a distinction between requestedPath and served path
    */
    private function callPage( $path )
    {
        if (!$this->sitemap->pageExists($path)) {
            $event = $this->eventManager->raiseEvent('PageNotFound', $path);
            $path  = $event->getContext();
            
            if (!$event->isCancelled()) {
                patErrorManager::raiseNotice('NOCODE', 'The requested page '.$path.' does not exist');
                $path = $this->accessPoint->getIndex();
            }
        }
        $this->request->setPath($path);
        $this->page = $this->sitemap->loadPage($path);
        if (!$this->page->isAccessible($this->request)) {
            $event = $this->eventManager->raiseEvent('PageNotAccessible', $path);
            $newPath = $event->getContext();
            
            if (!$event->isCancelled()) {
                patErrorManager::raiseNotice('NOCODE', 'The requested page '.$path.' may not be accessed');
                $path = $this->accessPoint->getIndex();
                $this->page = $this->sitemap->loadPage($path);
            } else {
                if ($newPath !== $path) {
                    $this->page = $this->sitemap->loadPage($newPath);
                }
            }
        }
        $this->page->createEventManager($this->eventManager);
    }
    
   /**
    * return the event manager
    *
    * @return patPortal_EventManager
    */
    public function getEventManager()
    {
        return $this->eventManager;
    }    
}
/**
 * Exception class
 *
 * @author        Stephan Schmidt
 * @package        patPortal
 */
class patPortalException extends Exception {}
?>