function GetPath()
{
$themesModule = Module::GetNewModule('themes', $this->item['theme']);
if ($path = $themesModule->item['path'] . '/' . String::PrepareForURL($this->item['titre'])) {
return $path;
} else {
trigger_error("Couldn't get path for item", E_USER_ERROR);
return false;
}
}
function ItemViewController()
{
// Include all item data as template variables
$this->layout->AddVariables($this->item);
// Load text blocks related to this module
$blocs = Module::GetNewModule('blocs');
$queryParams = array('where' => 'page = ' . $this->itemID);
$blocs->FetchItems($queryParams);
if ($blocs->items) {
foreach ($blocs->items as $item) {
$this->view[String::PrepareForURL($item['titre'])] = $item['texte'];
}
}
// Use specified path as a way to load views
$path = $this->item['pagePath'];
$this->LoadView($path);
}
function PagesViewController()
{
if ($_GET['m'] == 'updated') {
HTTP::RedirectLocal('merci');
return false;
}
$this->view['form'] = $this->GetForm();
$themes = Module::GetNewModule('themes');
$queryParams = array('fields' => 'titreCourt', 'orderby' => 'sortIndex');
$themes->FetchItems($queryParams);
$this->view['themes'] = $themes->items;
}
function AdminExportViewController()
{
global $_JAM;
$_JAM->title = $this->nestedModule->strings['adminTitle'];
// Check whether we should display anything at all
if ($exportFields = $this->nestedModule->config['adminExportFields']) {
// Fetch data according to export fields
$queryParams = array('fields' => $exportFields);
// Always fetch primary key field
if ($this->nestedModule->config['keepVersions']) {
$primaryKeyField = 'master';
} else {
$primaryKeyField = 'id';
}
$queryParams['fields'][] = $primaryKeyField;
// Use first field as sort field
$sortField = current($exportFields);
$queryParams['orderby'] = $sortField . ' ASC';
// Fetch data
$this->nestedModule->FetchItems($queryParams);
foreach ($exportFields as $field) {
// Get related arrays
if ($relatedArray = $this->nestedModule->GetRelatedArray($field)) {
$relatedArrays[$field] = $relatedArray;
}
// Determiner headers
$this->nestedModule->view['headers'][] = $this->nestedModule->strings['fields'][$field];
}
// Assemble into final array
foreach ($this->nestedModule->items as $id => $item) {
foreach ($exportFields as $field) {
if ($relatedArrays[$field]) {
// Field has related array
$value = $relatedArrays[$field][$item[$field]];
} else {
// Check whether field type is boolean
if ($this->nestedModule->schema[$field]['type'] == 'bool') {
// Replace boolean value with human-readable string
$value = $item[$field] ? $_JAM->strings['words']['affirmative'] : $_JAM->strings['words']['negative'];
} else {
// Use straight value
$value = $item[$field];
}
}
// Fix weird bug with non-breaking spaces
$value = str_replace(' ', ' ', $value);
$data[$item[$primaryKeyField]][] = $value;
}
}
// Add related module data if applicable
if ($relatedModules = $this->nestedModule->config['adminExportRelatedModules']) {
foreach ($relatedModules as $relatedModuleName) {
// Create new module object
$relatedModule = Module::GetNewModule($relatedModuleName);
// Find field that relates to this module
foreach ($relatedModule->schema as $field => $info) {
if ($info['relatedModule'] == $this->nestedModule->name) {
$relatedModuleField = $field;
break;
}
}
// We absolutely need a field to continue
if (!$relatedModuleField) {
break;
}
// Add relevant header
$this->nestedModule->view['headers'][] = $relatedModule->strings['adminTitle'];
// Fetch data
$keyQueryParams = Module::ParseConfigFile($relatedModuleName, 'config/keyQuery.ini', true);
$params = $keyQueryParams;
$params['fields'][] = $relatedModuleField;
$relatedModuleData = $relatedModule->FetchItems($params);
// Obtain name of key field in related module (sneaky)
$keyFields = $keyQueryParams['fields'];
end($keyFields);
$relatedKeyField = key($keyFields);
// Populate data array with data from related module
foreach ($relatedModuleData as $relatedItem) {
$relatedID = $relatedItem[$relatedModuleField];
if ($data[$relatedID]) {
$data[$relatedID][$relatedModule->name][] = $relatedItem[$relatedKeyField];
}
}
// Convert arrays to HTML lists
foreach ($data as $id => $item) {
if ($array = $item[$relatedModule->name]) {
$listString = '';
foreach ($array as $listItem) {
$listString .= e('li', $listItem);
}
$list = e('ul', $listString);
$data[$id][$relatedModule->name] = $list;
}
}
}
}
// Store in template
$this->nestedModule->view['data'] = $data;
}
}
<?php
$themes = Module::GetNewModule('themes');
?>
<?php
$themes->LoadView('entete');
?>
</div>
<?php
}
?>
<?php
if ($afficherEtape) {
?>
<?php
$etapes = Module::GetNewModule('fleche', $etape);
?>
<?php
$etapes->Display();
?>
<?php
}
?>
<div class="clear"> </div>
</div>
</div>
<?php
if ($titreCorps) {
?>
<div id="titre">
function FirstRun()
{
// Load table structure for required tables
$tables = IniFile::Parse('engine/database/tables.ini', true);
// Create tables
foreach ($tables as $name => $schema) {
if (!Database::CreateTable($name, $schema)) {
trigger_error("Couldn't create table " . $name, E_USER_ERROR);
}
}
// Manually add admin module to _modules table
if (Query::TableIsEmpty('_modules')) {
$adminModule = array('name' => 'admin');
if (!Database::Insert('_modules', $adminModule)) {
trigger_error("Couldn't install core modules", E_USER_ERROR);
}
}
// Install required modules
$requiredModules = array('users', 'files');
foreach ($requiredModules as $moduleName) {
$module = Module::GetNewModule($moduleName);
$module->Install();
}
// Add default admin user
if (Query::TableIsEmpty('users')) {
$adminUserParams = array('created' => $this->databaseTime, 'login' => 'admin', 'name' => 'Admin', 'password' => 'admin', 'status' => 3);
if (!Database::Insert('users', $adminUserParams)) {
trigger_error("Couldn't create admin user", E_USER_ERROR);
}
}
// Add admin path
$adminModuleId = Query::SingleValue('_modules', 'id', "name = 'admin'");
if (!Path::Insert('admin', $adminModuleId, false)) {
trigger_error("Couldn't add admin path", E_USER_ERROR);
}
// Redirect to admin interface
HTTP::RedirectLocal('admin');
}
function Initialize()
{
// Set PHP configuration options
$options = array('mbstring.language' => 'Neutral', 'mbstring.internal_encoding' => 'UTF-8', 'mbstring.encoding_translation' => 'On', 'mbstring.http_input' => 'auto', 'mbstring.detect_order' => 'ASCII,UTF-8,JIS,SJIS,EUC-JP', 'upload_max_filesize' => '21M', 'post_max_size' => '24M', 'display_errors' => true);
foreach ($options as $key => $value) {
ini_set($key, $value);
}
// Required for UTF-8 support
mb_language('uni');
// Error display
//error_reporting(E_ALL^E_NOTICE);
error_reporting(0);
// Add app/ and engine/ to include path
set_include_path(get_include_path() . PATH_SEPARATOR . './app' . PATH_SEPARATOR . './engine');
// Load classes
$classesDir = 'engine/classes';
$dirHandle = opendir($classesDir);
while ($filename = readdir($dirHandle)) {
// Make sure files end in .php
if ($filename != basename($filename, '.php')) {
$classPath = $classesDir . '/' . $filename;
if (!is_dir($classPath)) {
require_once $classPath;
}
}
}
// Start caching engine; this also initializes output buffering
$this->cache = new Cache();
// Start output buffering
ob_start('mb_output_handler');
// Define files directory
$this->filesDirectory = 'files/';
// Load configuration files
$this->projectConfig = IniFile::Parse('app/config/project.ini', true);
$this->serverConfig = IniFile::Parse('app/config/server.ini', true);
// Define constants
define('ROOT', $this->serverConfig['root']);
define('ERROR_FOREIGN_KEY_CONSTRAINT', 2);
// Used in engine/classes/Module.php
// Load database field types
$this->fieldTypes = IniFile::Parse('engine/database/types.ini');
// Load module fields
$this->moduleFields = IniFile::Parse('engine/database/moduleFields.ini', true);
$this->versionsSupportFields = IniFile::Parse('engine/database/versionsSupportFields.ini', true);
// Load GetID3
require_once 'engine/libraries/getid3/getid3.php';
// Determine default language
$this->defaultLanguage = $this->projectConfig['languages'][0];
// Determine requested language
$requestedLanguage = $_GET['language'];
if ($requestedLanguage && in_array($requestedLanguage, $this->projectConfig['languages'])) {
// User has manually switched language
Cookie::Create('language', $requestedLanguage);
$this->language = $requestedLanguage;
} elseif ($_COOKIE['language']) {
// User has previously selected a language
$this->language = $_COOKIE['language'];
} else {
// User has never selected a language; use default
$this->language = $this->defaultLanguage;
}
// Load strings in the requested language
$this->strings = IniFile::Parse('engine/strings/' . $this->language . '.ini', true);
// Load shorthands (useful function aliases; must load after strings)
require 'engine/helpers/shorthands.php';
// Connect to database
$db = $this->serverConfig['database'];
if (!($this->databaseLink = Database::Connect($db['server'], $db['username'], $db['password'], $db['database']))) {
trigger_error("Couldn't connect to database " . $db['database'], E_USER_ERROR);
}
// Get available modules list
$engineModules = Filesystem::GetDirNames('engine/modules');
$this->appModules = Filesystem::GetDirNames('app/modules');
$this->availableModules = $engineModules + $this->appModules;
// Strip root directory and trailing slashes from full path request
$pathString = $_SERVER['REQUEST_URI'];
$barePath = substr($pathString, 0, strrpos($pathString, '?'));
$pathString = $barePath ? $barePath : $pathString;
$fullRequest = rtrim($pathString, '/');
preg_match('|^' . ROOT . '(.*)$|', $fullRequest, $requestArray);
// Use requested URL, or use root path if none was requested
$this->request = $requestArray[1] ? $requestArray[1] : $this->projectConfig['rootPath'];
// We sync using database time (might differ from PHP time)
$databaseTimeQuery = new Query(array('fields' => 'NOW()'));
$databaseTime = $databaseTimeQuery->GetSingleValue();
$this->databaseTime = $databaseTime;
// Make sure everything is properly initialized
$tables = Database::GetTables();
if (!$tables['users'] || !$tables['_paths']) {
require 'engine/helpers/firstrun.php';
}
// Get installed modules list
$this->installedModules = Query::SimpleResults('_modules');
// Create User object
$this->user = new User();
// Create layout object
$this->template = new Template();
// Determine mode
$requestedMode = $_GET['mode'];
$availableModes = IniFile::Parse('engine/config/modes.ini');
if ($availableModes[$requestedMode]) {
// If requested mode exists, use it
$this->mode = $requestedMode;
} else {
// HTML is the default mode
$this->mode = 'html';
}
// Load paths
$paths = Query::FullResults('_paths');
foreach ($paths as $path) {
// Use path as key in $_JAM->paths array
$this->paths[$path['path']] = $path;
}
// Look for request in paths
if ($path = $this->paths[$this->request]) {
// Path does exist
if ($path['current']) {
// This is a valid path; proceed to module
if ($this->rootModule = Module::GetNewModule($this->installedModules[$path['module']], $path['item'])) {
// Check whether we have sufficient privileges to display the module
if ($this->rootModule->CanView()) {
// Display module
$this->rootModule->Display();
// Determine path to admin pane for this item
$adminPath = 'admin/' . $moduleName;
if ($this->paths[$adminPath]) {
if ($path['item']) {
$adminPath .= '?a=edit&id=' . $path['item'];
}
$this->adminPath = ROOT . $adminPath;
} else {
$this->adminPath = ROOT . 'admin';
}
} else {
// Display login if we can't display
$this->user->Connect();
}
} else {
trigger_error("Couldn't load root module", E_USER_ERROR);
}
} else {
// This is an obsolete URL; find its current (up to date) equivalent
$whereArray = array('module = ' . $path['module'], 'item = ' . $path['item'], "language = '" . $path['language'] . "'", 'current = TRUE');
$currentPath = Query::SingleValue('_paths', 'path', $whereArray);
HTTP::NewLocation($currentPath);
}
} else {
// Path does not exist; throw 404
header("HTTP/1.0 404 Not Found");
$this->rootModule = Module::GetNewModule('errors');
$this->rootModule->Display();
}
// Store and flush the contents of the output buffer
$buffer = ob_get_clean();
// Load and display template
if ($this->mode == 'html' && $this->rootModuleName == 'admin') {
// Special case for admin pages requested in HTML
$templateName = 'html_admin';
} else {
$templateName = $this->mode;
}
$this->template->SetTemplate($templateName);
$this->template->Display($buffer);
// Set MIME type
$contentType = $this->contentType ? $this->contentType : $availableModes[$this->mode];
if ($contentType) {
header('Content-Type: ' . $contentType);
}
// Write to cache; this also cleans output buffering
$this->cache->Write();
}
function AutoForm($fieldsArray = false, $hiddenFields = false)
{
global $_JAM;
// Create Form object
if (!($form = $this->GetForm())) {
return false;
}
$form->Open();
// Include language selection menu if applicable
if (!$this->config['languageAgnostic'] && count($_JAM->projectConfig['languages']) > 1 && !($fieldsArray && !@in_array('language', $fieldsArray))) {
if ($this->item) {
print $form->Hidden('language');
} else {
foreach ($_JAM->projectConfig['languages'] as $language) {
$languagesArray[$language] = $_JAM->strings['languages'][$language];
}
print $form->Popup('language', $languagesArray, $_JAM->strings['fields']['language']);
}
}
// Include sortIndex field if applicable
if ($this->config['allowSort']) {
print $form->Field('sortIndex', '3', $_JAM->strings['fields']['sortIndex']);
}
foreach ($this->schema as $name => $info) {
// Don't include basic module fields
if (!$this->config['useCustomTable'] && $_JAM->moduleFields[$name]) {
continue;
}
// Don't include versions support fields
if ($this->config['keepVersions'] && $_JAM->versionsSupportFields[$name]) {
continue;
}
// Skip this item if $fieldsArray is present and it doesn't contain this item
if ($fieldsArray && !in_array($name, $fieldsArray)) {
continue;
}
// Get proper title from string
if (!($title = $this->strings['fields'][$name])) {
// Use field name if no localized string is found
$title = $name;
}
print $form->AutoItem($name, $title);
}
// Display related modules if we have item data
if ($this->itemID) {
foreach ($_JAM->installedModules as $module) {
// First check whether we have a view configured for related module display
if (($relatedModuleSchema = Module::ParseConfigFile($module, 'config/schema.ini', true)) && ($relatedModuleKeyQuery = Module::ParseConfigFile($module, 'config/keyQuery.ini', true))) {
foreach ($relatedModuleSchema as $field => $info) {
if ($info['relatedModule'] == $this->name) {
$relatedModule = Module::GetNewModule($module);
// Load all fields
$queryParams = array('fields' => $relatedModuleKeyQuery['fields'], 'where' => $module . '.' . $field . ' = ' . $this->itemID);
$relatedModule->FetchItems($queryParams);
$relatedModule->LoadView('subform');
}
}
}
}
}
if ($hiddenFields) {
foreach ($hiddenFields as $field => $value) {
print $form->Hidden($field, $value);
}
}
print $form->Submit();
$form->Close();
return true;
}
foreach ($tables as $name => $schema) {
if (!Database::CreateTable($name, $schema)) {
trigger_error("Couldn't create table " . $name, E_USER_ERROR);
}
}
// Manually add admin module to _modules table
if (Query::TableIsEmpty('_modules')) {
$adminModule = array('name' => 'admin');
if (!Database::Insert('_modules', $adminModule)) {
trigger_error("Couldn't install core modules", E_USER_ERROR);
}
}
// Install required modules
$requiredModules = array('users', 'files');
foreach ($requiredModules as $moduleName) {
$module = Module::GetNewModule($moduleName);
$module->Install();
}
// Add default admin user
if (Query::TableIsEmpty('users')) {
$adminUserParams = array('created' => $_JAM->databaseTime, 'login' => 'admin', 'name' => 'Admin', 'password' => 'admin', 'status' => 3);
if (!Database::Insert('users', $adminUserParams)) {
trigger_error("Couldn't create admin user", E_USER_ERROR);
}
}
// Add admin path
$adminModuleId = Query::SingleValue('_modules', 'id', "name = 'admin'");
if (!Path::Insert('admin', $adminModuleId, false)) {
trigger_error("Couldn't add admin path", E_USER_ERROR);
}
// Redirect to admin interface
function PagesViewController()
{
if ($_GET['m'] == 'updated') {
HTTP::RedirectLocal('merci');
return false;
}
$this->view['form'] = $this->GetForm();
// Add perspective specified as GET variable to form values
$this->view['form']->LoadValue('perspective', $_GET['perspective']);
$perspectives = Module::GetNewModule('perspectives');
$queryParams = array('fields' => 'numero');
$perspectives->FetchItems($queryParams);
$this->view['perspectives'] = $perspectives->items;
$themes = Module::GetNewModule('themes');
$queryParams = array('orderby' => 'sortIndex');
$themes->FetchItems($queryParams);
$this->view['themes'] = $themes->items;
}