PHP Helpers::fatalError方法代码示例

 /**
  *   Erstellt ein PDO Objekt
  *
  * @return PDO pdo
  */
 public static function getPDO()
 {
     if (self::$pdo == null) {
         $config = Config::getArray();
         if (!isset($config["database"])) {
             Helpers::fatalError("No database configuration found.");
         }
         $host = '';
         if (isset($config['database']['host'])) {
             $host = 'host=' . $config['database']['host'] . ';';
         }
         $port = '';
         if (isset($config['database']['port'])) {
             $port = 'port=' . $config['database']['port'] . ';';
         }
         $socket = '';
         if (isset($config['database']['socket'])) {
             $socket = 'unix_socket=' . $config['database']['socket'] . ';';
         }
         $dsn = 'mysql:dbname=' . $config["database"]["name"] . ';' . $host . $port . $socket . 'charset=utf8;';
         try {
             $pdo = new PDO($dsn, $config["database"]["user"], $config["database"]["password"], array(PDO::MYSQL_ATTR_INIT_COMMAND => "SET NAMES utf8"));
         } catch (PDOException $e) {
             Helpers::fatalError("Could no connect to the database: " . $e->getMessage());
         }
         self::$pdo = $pdo;
     }
     return self::$pdo;
 }

 public static function loadStrings($file, $id = '')
 {
     if (is_file($file)) {
         $temp = (include $file);
         if (is_array($temp)) {
             self::$strings = array_merge(self::$strings, $temp);
             self::$id = $id;
         }
     } else {
         Helpers::fatalError('The language file [' . $file . '] could not be found.');
     }
 }

 protected static function loadArray($file, $can_not_be_empty)
 {
     if (!file_exists($file)) {
         Helpers::fatalError('DataStructure: Missing file: ' . $file . '!');
     }
     $array = (include $file);
     if (!is_array($array)) {
         Helpers::fatalError('DataStructure: file must return an array in: ' . $file . '!');
     }
     if ($can_not_be_empty && count($array) < 1) {
         Helpers::fatalError('DataStructure: the array is empty in: ' . $file . '!');
     }
     return $array;
 }

 protected static function error($function)
 {
     $message = $function . ' could not succeed.';
     if (function_exists("error_get_last")) {
         $info = error_get_last();
         $message .= ' Error-Message: ' . $info['message'];
     }
     switch (self::$error_mode) {
         case self::ERROR_MODE_DEBUG:
             Helpers::debugError($message);
             break;
         case self::ERROR_MODE_FATAL:
             Helpers::fatalError($message);
             break;
         case self::ERROR_MODE_SILENT:
             break;
         default:
             break;
     }
 }

 public function walkElementContainer(&$data, $structure, $parameters)
 {
     if (is_array($data)) {
         if (count($data) > 0) {
             $elements_structure = DataStructure::elementsArray();
             for ($element_index = 0; $element_index < count($data); $element_index++) {
                 $element_data =& $data[$element_index]['content'];
                 $element_id = $data[$element_index]['elementId'];
                 $element_parameters = array('elementId' => $element_id, 'elementIndex' => $element_index);
                 $element_parameters = array_merge($parameters, $element_parameters);
                 if (!isset($elements_structure[$element_id])) {
                     Helpers::fatalError('DataModifier: A element with the ID [' . $element_id . '] does not exist.');
                 }
                 $element_structure = $elements_structure[$element_id]['structure'];
                 $this->modifyFields($element_data, $element_structure, $element_parameters);
                 $this->walkFields($element_data, $element_structure, $element_parameters);
             }
         }
     }
 }

            $configuration_ok = false;
        } else {
            if (count($config['languages']['list']) < 1) {
                $configuration_ok = false;
            }
        }
    }
    if (!$configuration_ok) {
        Helpers::fatalError('The system is not properly configured (in /system/custom/config/main.config.php)', true);
    }
}
// Datenstruktur, Plugins, Module, Modifikatoren laden
DataStructure::load();
Plugins::load();
FrontendModules::load();
DataModifiers::load();
// Frontend-Controller-Klassen-Datei laden
$controller_file_name = Config::get()->frontendController->classFile;
if (!file_exists($controller_file_name)) {
    Helpers::fatalError('Frontend controller class file not found (' . $controller_file_name . ' doesn\'t exist)!', true);
}
require_once $controller_file_name;
// Klasse instanziieren
$controller_class_name = Config::get()->frontendController->className;
if (!class_exists($controller_class_name)) {
    Helpers::fatalError('Frontend controller class not found (class "' . $controller_class_name . '" doesn\'t exist in ' . $controller_file_name . ')!', true);
}
$controller = new $controller_class_name();
Registry::set('frontendController', $controller);
// Und los...
$controller->run();

     $action = $path[2];
 } else {
     $action = 'default';
 }
 $method = $action . 'Action';
 // Datei inkludieren
 require_once APPLICATION_ROOT . 'system/core/backend/controllers/' . $folder . '/' . $file;
 // Prüfen, ob Klasse existiert
 if (!class_exists($class)) {
     Helpers::fatalError('Page not found (class "' . $class . '" doesn\'t exist in system/core/backend/controllers/' . $folder . '/' . $file . ')!', true);
 }
 // Klasse instanziieren
 $controller = new $class($module);
 // Prüfen, ob Methode existiert
 if (!method_exists($controller, $method)) {
     Helpers::fatalError('Page not found (class-method "' . $method . '" doesn\'t exist in class "' . $class . '" ist in system/core/backend/controllers/' . $folder . '/' . $file . ')!', true);
 }
 // View erzeugen und mit Controller verbinden
 $view = new View();
 $view->assignTemplate(APPLICATION_ROOT . 'system/core/backend/views/' . $folder . '/' . UTF8String::strtolower($file));
 $view->assign('baseUrl', Config::get()->baseUrl);
 $view->assign('moduleUrl', Config::get()->baseUrl . 'admin/' . $folder . '/' . $module . '/');
 $view->assign('publicUrl', Config::get()->baseUrl . 'system/core/backend/public/');
 $view->assign('backendLanguage', $language_id);
 $controller->assignView($view);
 // Action-Methode ausführen
 $controller->callActionMethod($action);
 // Ausgabe des Views...
 if ($controller->getView() != null) {
     $controller->getView()->output();
 }

 public function getPage($page_id, $language_id, $preview = false)
 {
     // Smarty initialisieren
     $smarty = new Template();
     // Seiten-Infos laden
     $pages = new Pages();
     $page_properties = $pages->getProperties($page_id);
     if ($page_properties === false) {
         Helpers::fatalError('A page with the ID "' . $page_id . '" does not exist!');
     }
     // Wenn die Vorschau-Version der Seite angefordert wurde,
     // überprüfen, ob überhaupt eine editierte Version der Seite existiert,
     // wenn nicht, Vorschau-Modus ignorieren
     if ($preview) {
         if ($page_properties['status'] == Pages::STATUS_PUBLISHED) {
             $preview = false;
         }
     }
     // Seiteneigenes Verzeichnis abhängig von $preview auslesen
     if ($preview) {
         $page_files = $pages->getPageFilesEditFolder($page_id, $page_properties);
         $page_files_url = $pages->getPageFilesEditUrl($page_id, $page_properties);
     } else {
         $page_files = $pages->getPageFilesPublishedFolder($page_id, $page_properties);
         $page_files_url = $pages->getPageFilesPublishedUrl($page_id, $page_properties);
     }
     $page_url = $pages->getPageUrl($page_id, $language_id, $page_properties);
     // Grundlegende Variablen zuweisen, die zwar mit dem Inhalt nichts zu tun haben, aber wichtig sind :-)
     $smarty->assign('baseUrl', Config::get()->baseUrl);
     $smarty->assign('publicUrl', Config::get()->baseUrl . 'system/custom/frontend/public/');
     $smarty->assign('pageUrl', $page_url);
     $smarty->assign('pageId', $page_id);
     $smarty->assign('languageId', $language_id);
     $smarty->assign('templateId', $page_properties['template-id']);
     $smarty->assign('uniqueId', $page_properties['unique-id']);
     $smarty->assign('pageFiles', $page_files);
     $smarty->assign('pageFilesUrl', $page_files_url);
     $languages = Config::get()->languages->list->getArrayCopy();
     foreach ($languages as $key => $value) {
         $languages[$key]['id'] = $key;
     }
     $smarty->assign('languages', $languages);
     // Seiten-Struktur laden
     $pages_structure = DataStructure::pagesArray();
     if (!isset($pages_structure[$page_properties['template-id']]['structure'])) {
         Helpers::fatalError('A page template with the ID "' . $page_properties['template-id'] . '" does not exist!');
     }
     $page_structure = $pages_structure[$page_properties['template-id']]['structure'];
     // Die folgenden Parameter werden an die Modifikatoren und Plugins übergeben
     $parameters = array('preview' => $preview, 'pageId' => $page_id, 'languageId' => $language_id, 'templateId' => $page_properties['template-id'], 'uniqueId' => $page_properties['unique-id'], 'pageUrl' => $page_url, 'pageFiles' => $page_files, 'pageFilesUrl' => $page_files_url, 'smarty' => $smarty);
     // Seiten-Inhalt laden
     $content_object = new PageContent();
     if (!$content_object->load($page_id, !$preview)) {
         Helpers::fatalError('The content of the page with the ID "' . $page_id . '" could not be loaded!');
     }
     $page_content = $content_object->getArray($language_id, $smarty, $parameters);
     // Globale Elemente laden
     $this->loadGlobalElementsPage($smarty, $language_id);
     $this->assignGlobalElementsToSmarty($smarty, $language_id);
     // Inhalte zuweisen
     foreach ($page_structure as $block_id => $block) {
         if ($block['type'] == 'datablock') {
             $block_data = null;
             if (isset($page_content[$block_id])) {
                 $block_data = $page_content[$block_id];
             }
             $smarty->assign($block_id, $block_data);
         } elseif ($block['type'] == 'container') {
             $container_content = '';
             if (isset($page_content[$block_id])) {
                 if (is_array($page_content[$block_id])) {
                     foreach ($page_content[$block_id] as $container_element_key => $container_element) {
                         $container_content = $container_content . $this->getElement($page_id, $language_id, $container_element['elementId'], $container_element['content'], $preview);
                     }
                 }
             }
             $smarty->assign($block_id, $container_content);
         }
     }
     // registrierte Plugins aufrufen, vielleicht hat ja noch jemand etwas hinzuzufügen :-)
     Plugins::call(Plugins::ASSIGN_PAGE_DATA, $parameters);
     // Smarty-Template für die Template-ID der aktuellen Seite zurückgeben
     $page_template = $pages_structure[$page_properties['template-id']];
     return $smarty->fetch('file:[pages]' . $page_template['template']);
 }

*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
if (!Auth::isLoggedIn()) {
    Helpers::fatalError('Error: No valid user logged in.', true);
}
require_once realpath(dirname(__FILE__) . '/../../../library/elfinder/elFinderConnector.class.php');
require_once realpath(dirname(__FILE__) . '/../../../library/elfinder/elFinder.class.php');
require_once realpath(dirname(__FILE__) . '/../../../library/elfinder/elFinderVolumeDriver.class.php');
require_once realpath(dirname(__FILE__) . '/../../../library/elfinder/elFinderVolumeLocalFileSystem.class.php');
// Required for MySQL storage connector
// include_once dirname(__FILE__).DIRECTORY_SEPARATOR.'elFinderVolumeMySQL.class.php';
// Required for FTP connector support
// include_once dirname(__FILE__).DIRECTORY_SEPARATOR.'elFinderVolumeFTP.class.php';
/**
 * Simple function to demonstrate how to control file access using "accessControl" callback.
 * This method will disable accessing files/folders starting from  '.' (dot)
 *
 * @param  UTF8String $attr attribute name (read|write|locked|hidden)
 * @param  UTF8String $path file path relative to volume root directory started with directory separator

 public function callActionMethod($action)
 {
     // JS 26.02.2014 - habe gerade gesehen dass eine Aktion "before" zu �blen Problemen f�hren k�nnte...
     // Eigentlich m�sste man die Funktion "beforeAction" umbenennen, aber aus Kompatibilit�tsgr�nden lassen wir es mal so
     // und fangen es einfach ggf. ab...
     if ($action == 'before') {
         Helpers::fatalError('An action can not have the name "before" because it is used internal.', true);
     }
     $method = $action . 'Action';
     if (method_exists($this, $method)) {
         if ($this->userIsAuthorized($action)) {
             if ($this->beforeAction($action)) {
                 $this->{$method}();
             }
         }
         return true;
     } else {
         return false;
     }
 }

 public function run()
 {
     // Startup-Ereignis
     Plugins::call(Plugins::STARTUP, null);
     // Router laden
     $router_file_name = Config::get()->frontendRouter->classFile;
     if (!file_exists($router_file_name)) {
         Helpers::fatalError('Frontend router class file not found (' . $router_file_name . ' doesn\'t exist)!', true);
     }
     require_once $router_file_name;
     $router_class_name = Config::get()->frontendRouter->className;
     if (!class_exists($router_class_name)) {
         Helpers::fatalError('Frontend router class not found (class "' . $router_class_name . '" doesn\'t exist in ' . $router_file_name . ')!', true);
     }
     $router = new $router_class_name();
     Registry::set('frontendRouter', $router);
     // PageBuilder laden
     $page_builder_file_name = Config::get()->pageBuilder->classFile;
     if (!file_exists($page_builder_file_name)) {
         Helpers::fatalError('PageBuilder class file not found (' . $page_builder_file_name . ' doesn\'t exist)!', true);
     }
     require_once $page_builder_file_name;
     $page_builder_class_name = Config::get()->pageBuilder->className;
     if (!class_exists($page_builder_class_name)) {
         Helpers::fatalError('PageBuilder class not found (class "' . $page_builder_class_name . '" doesn\'t exist in ' . $page_builder_file_name . ')!', true);
     }
     $page_builder = new $page_builder_class_name();
     Registry::set('pageBuilder', $page_builder);
     // routing
     $router->route();
     $languageId = $router->getLanguageId();
     if ($router->pageFound()) {
         $pageId = $router->getPageId();
         $error_404 = false;
     } else {
         $pageId = $router->getErrorPageId();
         $error_404 = true;
     }
     if ($pageId !== false) {
         // Ist die Seite ein Link? Dann einfach auf die angegebene URL weiterleiten...
         if ($router->isPageLink()) {
             Helpers::redirect($router->getPageLinkUrl(), Config::get()->pageLinkRedirectionResponseCode);
             exit;
         }
         // �bersetzungen laden
         $config = Config::getArray();
         $languages = $config['languages']['list'];
         setlocale(LC_ALL, $languages[$languageId]['locale']);
         if (is_array($languages[$languageId]['translation'])) {
             if (count($languages[$languageId]['translation']) > 0) {
                 foreach ($languages[$languageId]['translation'] as $translation_file) {
                     Translate::loadStrings($translation_file, $languageId);
                 }
             }
         } else {
             if ($languages[$languageId]['translation'] != '') {
                 Translate::loadStrings($languages[$languageId]['translation'], $languageId);
             }
         }
         // Before-Display-Ereignis
         Plugins::call(Plugins::BEFORE_DISPLAY, array('preview' => $router->isPreview(), 'pageId' => $pageId, 'languageId' => $languageId));
         if (!$router->isPreview()) {
             // Versuchen, die Seite aus dem Cache zu holen
             $output = PageCache::getPage($pageId, $languageId);
             $output_cached = false;
             // Keine Version im Cache verf�gbar, Seite neu erzeugen
             if ($output === false) {
                 $output = $page_builder->getPage($pageId, $languageId);
             } else {
                 $output_cached = true;
             }
             // Wenn noch nicht im Cache, erzeugte Ausgabe im Cache ablegen
             if (!$output_cached) {
                 PageCache::cachePage($pageId, $languageId, $output);
             }
         } else {
             // Im Vorschau-Modus den Cache nicht verwenden
             // Und dem PageBuilder sagen, dass er die Vorschau-Version erstellen soll
             $output = $page_builder->getPage($pageId, $languageId, true);
             $output_cached = false;
         }
         // HTTP-Header senden
         if ($error_404) {
             if (!headers_sent()) {
                 header($_SERVER["SERVER_PROTOCOL"] . " 404 Not Found");
             }
         }
         $page_builder->outputHeader($pageId, $languageId);
         // Header-Senden-Ereignis
         Plugins::call(Plugins::SEND_HEADER, array('preview' => $router->isPreview(), 'pageId' => $pageId, 'languageId' => $languageId));
         // Modify-Output-Before-Display-Ereignis, bietet die M�glichkeit,
         // dass ein Plugin die Ausgabe vor der Ausgabe nochmal ver�ndert,
         // unabh�ngig davon, ob die Seite aus dem Cache geladen wurde oder nicht
         Plugins::call(Plugins::MODIFY_OUTPUT_BEFORE_DISPLAY, array('preview' => $router->isPreview(), 'pageId' => $pageId, 'languageId' => $languageId, 'isCached' => $output_cached), $output);
         // Seite ausgeben
         print $output;
         // After-Display-Ereignis
         Plugins::call(Plugins::AFTER_DISPLAY, array('preview' => $router->isPreview(), 'pageId' => $pageId, 'languageId' => $languageId));
     } else {
         Helpers::fatalError('Error 404: page not found ', true);
//.........这里部分代码省略.........