| <?php |
| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| /** |
| * |
| * OODT Balance |
| * Web Application Base Framework |
| * |
| * ApplicationResponse: Provides functions for dynamically constructing |
| * and delivering a response to a resource request. |
| * |
| * @author ahart |
| * |
| */ |
| class Org_Apache_Oodt_Balance_Core_ApplicationResponse { |
| |
| protected $config; |
| protected $request; |
| |
| protected $headers; |
| |
| protected $header; |
| protected $view; |
| protected $footer; |
| |
| protected $stylesheets = array(); |
| protected $javascripts = array(); |
| |
| protected $data; |
| |
| const DYN_JS_TAG = '<!-- JAVASCRIPTS -->'; |
| const DYN_CSS_TAG = '<!-- STYLESHEETS -->'; |
| |
| /** |
| * Constructor |
| * |
| * @param array $config |
| * @param Org_Apache_Oodt_Balance_Core_ApplicationRequest $request |
| */ |
| public function __construct($config, |
| Org_Apache_Oodt_Balance_Core_ApplicationRequest $request) { |
| |
| $this->config = $config; |
| |
| $this->request = $request; |
| |
| $this->headers = array(); |
| |
| $this->header = HOME . "/{$config['header_file_path']}"; |
| $this->footer = HOME . "/{$config['footer_file_path']}"; |
| } |
| |
| /** |
| * Generates a response by processing the requested view, |
| * including any header and footer views (if needed) as specified |
| * by the application config file. |
| * |
| * Available options: |
| * skipHeader: boolean (default = false) If present, omits header processing |
| * skipFooter: boolean (default = false) If present, omits footer processing |
| * skipHooks: boolean (default = false) If present, omits hook processing |
| * |
| * @param array $options |
| */ |
| public function process($options = array()) { |
| |
| // Merge defaults with provided options |
| $defaults = array( |
| 'skipHeader' => false, |
| 'skipFooter' => false, |
| 'skipHooks' => false, |
| ); |
| $options += $defaults; |
| |
| if (!$options['skipHooks']) { |
| // Include the appropriate hooks.php file |
| include ((App::Get()->request->isModule |
| ? App::Get()->request->modulePath |
| : HOME ) . '/hooks.php'); |
| |
| // Run 'before_all' hook for all requests |
| if (function_exists('hook_before_all')) { |
| hook_before_all(); |
| } |
| } |
| |
| // Preprocessing for a view |
| if (!$this->request->isScript) { |
| ob_start(); // Start buffering the output |
| |
| // Check that the requested view exists |
| if (file_exists($this->request->viewPath)) { |
| |
| // Run the beforeView hook |
| if (!$options['skipHooks'] && function_exists('hook_before_view')) { |
| hook_before_view(); |
| } |
| // Process the view |
| include($this->request->viewPath); |
| } else { |
| include(HOME . "/views/errors/404.php"); // 404 error page |
| } |
| |
| $this->view = ob_get_contents(); |
| ob_clean(); |
| |
| // Determine the header view (if any) to include |
| if (!$options['skipHeader'] && $this->header && is_file($this->header)) { |
| // Run the beforeHeader hook |
| if (!$options['skipHooks'] && function_exists('hook_before_header')) { |
| hook_before_header(); |
| } |
| |
| // Process the header |
| if (!empty($this->header)) {include($this->header);} |
| |
| $this->header = ob_get_contents(); |
| ob_clean(); |
| } |
| |
| // Determine the footer view (if any) to include |
| if (!$options['skipFooter'] && $this->footer && is_file($this->footer)) { |
| // Run the beforeFooter hook |
| if (!$options['skipHooks'] && function_exists('hook_before_footer')) { |
| hook_before_footer(); |
| } |
| |
| // Process the footer |
| if (!empty($this->footer)) {include($this->footer);} |
| |
| $this->footer = ob_get_contents(); |
| ob_clean(); |
| } |
| |
| ob_end_clean(); // Stop buffering the output |
| } else { |
| require_once( $this->request->scriptPath ); |
| exit(); |
| } |
| } |
| |
| /** |
| * Actually sends the response (using 'echo') out to the |
| * client's browser. |
| */ |
| public function send() { |
| |
| if ($this->request->isScript) { |
| if (is_file($this->request->scriptPath)) { |
| require_once($this->request->scriptPath); |
| } else { |
| header("Location: " . SITE_ROOT . "/errors/404"); |
| } |
| } else { |
| // Process any dynamically added content |
| $this->processDynamicContent(); |
| |
| // Run the beforeSend hook |
| if (function_exists('hook_before_send')) { |
| hook_before_send(); |
| } |
| foreach ($this->headers as $header) { |
| header($header); |
| } |
| if ($this->header) { |
| echo $this->header; |
| } |
| echo $this->view; |
| if ($this->footer) { |
| echo $this->footer; |
| } |
| // Run the afterSend hook |
| if (function_exists('hook_after_send')) { |
| hook_after_send(); |
| } |
| } |
| } |
| |
| public static function sendFatal($message) { |
| // Store the message in the session |
| $_SESSION['fail_message'] = $message; |
| |
| // Clear any old output and restart buffering the output |
| ob_clean(); |
| ob_start(); |
| |
| // Build the 404 error page |
| include(LIB . "/views/errors/fail.php"); |
| |
| // Get the contents as a string and flush the buffer |
| $content = ob_get_contents(); |
| |
| // Stop buffering output |
| ob_end_clean(); |
| |
| // Send the response |
| echo $content; |
| |
| exit(); |
| } |
| |
| /** |
| * Replace special tags with their dynamically assigned content. Currently, the only |
| * special tags are for defining an area for CSS and JavaScript imports. |
| * |
| */ |
| protected function processDynamicContent() { |
| |
| // Dynamically insert CSS |
| $this->header = str_replace(self::DYN_CSS_TAG,implode("\r\n",$this->stylesheets),$this->header); |
| $this->view = str_replace(self::DYN_CSS_TAG,implode("\r\n",$this->stylesheets),$this->view); |
| $this->footer = str_replace(self::DYN_CSS_TAG,implode("\r\n",$this->stylesheets),$this->footer); |
| |
| // Dynamically insert JS |
| $this->header = str_replace(self::DYN_JS_TAG,implode("\r\n",$this->javascripts),$this->header); |
| $this->view = str_replace(self::DYN_JS_TAG,implode("\r\n",$this->javascripts),$this->view); |
| $this->footer = str_replace(self::DYN_JS_TAG,implode("\r\n",$this->javascripts),$this->footer); |
| |
| } |
| |
| public function useHeaderFile($path) { |
| $this->header = $path; |
| } |
| |
| public function useFooterFile($path) { |
| $this->footer = $path; |
| } |
| |
| public function sendHeader($headerContent) { |
| $this->headers[] = $headerContent; |
| } |
| |
| public function getHeaderContent() { |
| return $this->header; |
| } |
| public function getViewContent() { |
| return $this->view; |
| } |
| public function getFooterContent() { |
| return $this->footer; |
| } |
| |
| public function data($key = null, $value = null) { |
| |
| // Return the data store associated with this request |
| if ($key == null && $value == null) { |
| return $this->data; |
| } |
| |
| // Return the stored value for the provided key |
| if ($value == null) { |
| return isset($this->data[$key]) |
| ? $this->data[$key] |
| : null; |
| } |
| |
| // Set the stored value for the key to the provided value |
| $this->data[$key] = $value; |
| } |
| |
| public function addStylesheet($href,$condition='') { |
| // Build the string for the css import |
| $str = "<link rel=\"stylesheet\" type=\"text/css\" href=\"{$href}\"/>"; |
| if (!empty($condition)) { |
| $str = "<!--[if {$condition}]>{$str}<![endif]-->"; |
| } |
| $this->stylesheets[] = $str; |
| } |
| |
| /** |
| * Add javascript resources to the response |
| * |
| * This function provides a clean way to programmatically include arbitrary |
| * Javascript resources in the response. Depending upon the value |
| * provided for 'isRaw', the contents of 'src' will either be interpreted |
| * as the 'src' attribute or the body content of the generated <script> block. |
| * |
| * @param string src - Either the url to the resource to include (if |
| * 'isRaw' = false) or a string representing the |
| * raw Javascript to include (if 'isRaw' = true) |
| * @param boolean isRaw - Controls how 'src' is interpreted. If set to false |
| * (default), 'src' will be interpreted as a URL to the |
| * Javascript resource to include. If set to true, 'src' |
| * will be interpreted as a string of raw Javascript. |
| */ |
| public function addJavascript($src, $isRaw = false) { |
| if ($isRaw === true) { |
| // Build a script container for the raw javascript |
| $str = "<script type=\"text/javascript\">{$src}</script>"; |
| $this->javascripts[] = $str; |
| } else { |
| // Build the string for the javascript file import |
| $str = "<script type=\"text/javascript\" src=\"{$src}\"></script>"; |
| $this->javascripts[] = $str; |
| } |
| } |
| } |