PageRenderTime 63ms CodeModel.GetById 18ms RepoModel.GetById 0ms app.codeStats 0ms

/community/www/install/install.php

https://github.com/svn2github/efront-lms
PHP | 1434 lines | 1291 code | 8 blank | 135 comment | 152 complexity | 19fa2f1d90f4cdd8d9afd4f61ad2da24 MD5 | raw file
Possible License(s): BSD-3-Clause, MPL-2.0-no-copyleft-exception, LGPL-3.0

Large files files are truncated, but you can click here to view the full file

    

  1. <?php
    2. 

  2. /**
    3. 

  3.  * $LastChangedRevision$
    4. 

  4.  * Installation file
    5. 

  5.  *
    6. 

  6.  * This file is used to perform the installation
    7. 

  7.  * @package eFront
    8. 

  8.  */
    9. 

  9. session_cache_limiter('none'); //Initialize session
    10. 

  10. session_start();
    11. 

  11. 

  12. Installation :: setErrorReporting();
    13. 

  13. //error_reporting(E_ALL);
    14. 

  14. 

  15. /*The inclusion directory*/
    16. 

  16. $path = "../../libraries/";
    17. 

  17. 

  18. //Read current version from sample_config file
    19. 

  19. preg_match("/define\('G_VERSION_NUM', '(.*)'\);/", file_get_contents("sample_config.php"), $matches);
    20. 

  20. define("G_VERSION_NUM", $matches[1]);
    21. 

  21. //Read current build from globals.php file
    22. 

  22. //preg_match('/\$LastChangedRevision$matches);
    23. 

  23. preg_match('/\$build = (\d+);/', file_get_contents($path."globals.php"), $matches);
    24. 

  24. 

  25. 

  26. 

  27. 

  28. define("G_BUILD", $matches[1]);
    29. 

  29. 

  30. $versionTypes = array('educational' => 'Educational',
    31. 

  31.                       'enterprise' => 'Enterprise',
    32. 

  32.                       'standard' => 'Community++',
    33. 

  33.                       'community' => 'Community');
    34. 

  34. define("G_VERSIONTYPE", 'community');
    35. 

  35. /*Disable output buffering during installation for better error handling*/
    36. 

  36. define("NO_OUTPUT_BUFFERING", true);
    37. 

  37. //Set some ini properties we need
    38. 

  38. ini_set("display_errors", true);
    39. 

  39. ini_set('include_path', $path.'../PEAR/');
    40. 

  40. //ini_set("memory_limit", "-1");
    41. 

  41. ini_get("max_execution_time") < 120 ? ini_set("max_execution_time", "120") : null;
    42. 

  42. //It is imperative that the smarty directory is writable in order to continue
    43. 

  43. if (!is_writable($path.'smarty/themes_cache')) {
    44. 

  44.  echo Installation :: printErrorMessage("Directory <b>".realpath($path.'smarty/themes_cache')."</b> must be writable by the server in order to continue");
    45. 

  45.  exit;
    46. 

  46. }
    47. 

  47. //Check whether we are on http or https
    48. 

  48. isset($_SERVER['HTTPS']) && $_SERVER['HTTPS'] == 'on' ? $protocol = 'https' : $protocol = 'http';
    49. 

  49. //Set the servername
    50. 

  50. define("G_SERVERNAME", dirname(dirname($protocol.'://'.$_SERVER['HTTP_HOST'].$_SERVER['PHP_SELF'])).'/');
    51. 

  51. //Check if smarty and language file exist, and halt program execution if it is not present
    52. 

  52. if (is_file($path."smarty/smarty_config.php") && is_file($path."language/lang-english.php.inc")) {
    53. 

  53.  /**The default theme path*/
    54. 

  54.  define("G_THEMESPATH", str_replace("\\", "/", dirname(dirname(dirname(__FILE__)))."/www/themes/"));
    55. 

  55.     /** The default theme path*/
    56. 

  56.     define("G_DEFAULTTHEMEPATH", G_THEMESPATH."default/");
    57. 

  57.     /** The default theme url*/
    58. 

  58.     define("G_DEFAULTTHEMEURL", "themes/default/");
    59. 

  59.     $currentTheme = "efront2013";
    60. 

  60.  /**The current theme path*/
    61. 

  61.  define("G_CURRENTTHEMEPATH", G_THEMESPATH.$currentTheme."/");
    62. 

  62.  /**The current theme url*/
    63. 

  63.  define("G_CURRENTTHEMEURL", "themes/".$currentTheme."/");
    64. 

  64.  /**The current theme css url*/
    65. 

  65.  define("G_CURRENTTHEMECSS", G_CURRENTTHEMEURL."css/css_global.css");
    66. 

  66.  /**The current theme cache path*/
    67. 

  67.  define("G_CURRENTTHEMECACHE", dirname(dirname(dirname(__FILE__)))."/libraries/smarty/themes_cache/".$currentTheme."/");
    68. 

  68.  /**The smarty libraries*/
    69. 

  69.  require_once $path."smarty/libs/Smarty.class.php";
    70. 

  70.  require_once $path."smarty/smarty_config.php";
    71. 

  71.  /**The default language file*/
    72. 

  72.  require_once $path."language/lang-english.php.inc";
    73. 

  73. } else {
    74. 

  74.  echo Installation :: printErrorMessage("Some files are missing, installation cannot continue");
    75. 

  75.  exit;
    76. 

  76. }
    77. 

  77. //If we asked for unattended installation, there must be a 2nd parameter with the configuration details or performing an upgrade
    78. 

  78. if (isset($_GET['unattended']) && !isset($_GET['upgrade']) && (!isset($_GET['config']) || !is_file(basename($_GET['config'])))) {
    79. 

  79.  unset($_GET['unattended']);
    80. 

  80. }
    81. 

  81. $smarty -> assign("T_VERSION_TYPE", $versionTypes[G_VERSIONTYPE]);
    82. 

  82. if (is_file($path."configuration.php")) {
    83. 

  83.  $smarty -> assign("T_INSTALLATION_OPTIONS", array(array('text' => 'Emergency restore', 'image' => "16x16/undo.png", 'href' => 'install/'.basename($_SERVER['PHP_SELF'])."?restore=1")));
    84. 

  84.  $smarty -> assign("T_CONFIGURATION_EXISTS", true);
    85. 

  85. }
    86. 

  86. if ((isset($_GET['step']) && $_GET['step'] == 1) || isset($_GET['unattended'])) {
    87. 

  87.  if (is_file('../php.ini') && !is_file('php.ini') && copy('../php.ini', 'php.ini') && !isset($_GET['unattended'])) {
    88. 

  88.   header("location:".$_SERVER['PHP_SELF']."?step=1".(isset($_GET['upgrade']) ? '&upgrade=1' : ''));
    89. 

  89.  }
    90. 

  90.  $exclude_normal = true;
    91. 

  91.  require_once $path."includes/check_status.php";
    92. 

  92.  Installation :: fix($settings_mandatory, 'local');
    93. 

  93.  if ($_GET['mode'] != 'none' && sizeof($settings_mandatory) > 0) {
    94. 

  94.   if (!$_GET['mode']) {
    95. 

  95.    Installation :: fix($settings_mandatory, 'local');
    96. 

  96.    header("location:".$_SERVER['PHP_SELF']."?step=1&mode=htaccess".(isset($_GET['upgrade']) ? '&upgrade=1' : ''));
    97. 

  97.   } else {
    98. 

  98.    Installation :: fix($settings_mandatory, 'htaccess');
    99. 

  99.    header("location:".$_SERVER['PHP_SELF']."?step=1&mode=none".(isset($_GET['upgrade']) ? '&upgrade=1' : ''));
    100. 

  100.   }
    101. 

  101.  } else if ($_GET['mode'] == 'none' && sizeof($settings_mandatory) > 0) {
    102. 

  102.   $message = 'The system tried to automatically fix the errors shown below by applying custom php.ini and .htaccess files, but was unable to. Please fix the following errors manually.';
    103. 

  103.  } else if ($_GET['mode'] == 'none') {
    104. 

  104.   $message = 'The system automatically changed some php parameters to meet installation prerequisites by applying a local php.ini and/or a .htaccess file';
    105. 

  105.   $message_type = 'success';
    106. 

  106.  }
    107. 

  107.  if (!$install) {
    108. 

  108.   $smarty -> assign("T_MISSING_SETTINGS", true);
    109. 

  109.  }
    110. 

  110. }
    111. 

  111. if ((isset($_GET['step']) && $_GET['step'] == 2) || isset($_GET['unattended'])) {
    112. 

  112.  //unset session, if any
    113. 

  113.  //    unset($_SESSION);
    114. 

  114.  //    session_destroy();
    115. 

  115.  /** HTML_QuickForm Class*/
    116. 

  116.  require_once 'HTML/QuickForm.php';
    117. 

  117.  /** HTML_QuickForm Smarty renderer class*/
    118. 

  118.  require_once 'HTML/QuickForm/Renderer/ArraySmarty.php';
    119. 

  119.  /**ADODB database abstraction class*/
    120. 

  120.  require_once($path.'adodb/adodb.inc.php');
    121. 

  121.  /**ADODB exceptions class*/
    122. 

  122.  require_once($path.'adodb/adodb-exceptions.inc.php');
    123. 

  123.  /**Various tools*/
    124. 

  124.  require_once($path.'tools.php');
    125. 

  125.  if ($_GET['upgrade']) {
    126. 

  126.   $currentVersion = Installation :: checkCurrentVersion();
    127. 

  127.   $smarty -> assign("T_CURRENT_VERSION", $currentVersion);
    128. 

  128.  }
    129. 

  129.  //Initialize ADODB
    130. 

  130.  $ADODB_CACHE_DIR = $path."adodb/cache";
    131. 

  131.  $ADODB_FETCH_MODE = ADODB_FETCH_ASSOC;
    132. 

  132.  $form = new HTML_QuickForm("info_form", "post", $_SERVER['PHP_SELF']."?step=2".($_GET['upgrade'] ? '&upgrade=1': ''), "", "class = 'indexForm'", true);
    133. 

  133.  $form -> registerRule('checkParameter', 'callback', 'eF_checkParameter'); //Register this rule for checking user input with our function, eF_checkParameter
    134. 

  134.  $form -> addElement('select', 'db_type', null, array('mysql' => 'MySQL', 'mssql' => 'MSSQL'));
    135. 

  135.  //$form -> addRule('db_type', 'The field "database type" is mandatory', 'required', null, 'client');                //The database type can only be string and is mandatory
    136. 

  136.  $form -> addRule('db_type', 'Invalid database type', 'checkParameter', 'string'); //The database type can only be string and is mandatory
    137. 

  137.  $form -> setDefaults(array('db_type' => 'mysql'));
    138. 

  138.  $form -> freeze(array('db_type')); //Freeze this element, since it can't change for now
    139. 

  139.  $form -> addElement('text', 'db_host', null, 'class = "inputText"');
    140. 

  140.  $form -> addRule('db_host', 'The field "Database host" is mandatory', 'required', null, 'client'); //The database type can only be string and is mandatory
    141. 

  141.  //$form -> addRule('db_host', 'Invalid database host', 'checkParameter', 'alnum_general');         //The database host can only be string and is mandatory
    142. 

  142.  $form -> addElement('text', 'db_user', null, 'class = "inputText"');
    143. 

  143.  $form -> addRule('db_user', 'The field "Database user" is mandatory', 'required', null, 'client'); //The database type can only be string and is mandatory
    144. 

  144.  $form -> addRule('db_user', 'Invalid database user', 'checkParameter', 'alnum'); //The database user can only be string
    145. 

  145.  $form -> addElement('password', 'db_password', null, 'class = "inputText"');
    146. 

  146.  $form -> addElement('text', 'db_name', null, 'class = "inputText"');
    147. 

  147.  $form -> addRule('db_name', 'The field "Database name" is mandatory', 'required', null, 'client'); //The database type can only be string and is mandatory
    148. 

  148.  $form -> addRule('db_name', 'Invalid database name', 'checkParameter', 'alnum'); //The database name can only be string
    149. 

  149.  $form -> addElement('text', 'db_prefix', null, 'class = "inputText"');
    150. 

  150.  $form -> addRule('db_prefix', 'Invalid database prefix', 'checkParameter', 'alnum'); //The database name can only be string
    151. 

  151.  if ($_GET['upgrade']) {
    152. 

  152.   $form -> addElement('text', 'old_db_name', null, 'class = "inputText"');
    153. 

  153.   $form -> addRule('old_db_name', 'The field "Upgrade from database" is mandatory', 'required', null, 'client'); //The database type can only be string and is mandatory
    154. 

  154.   $form -> addRule('old_db_name', 'Invalid database name', 'checkParameter', 'alnum_general'); //The database name can only be string
    155. 

  155.   //$form -> addElement('checkbox', 'upgrade_search', null, null, 'style = "vertical-align:middle"');
    156. 

  156.   $form -> addElement('checkbox', 'backup', null, null, 'style = "vertical-align:middle"');
    157. 

  157.  } else {
    158. 

  158.   $form -> addElement('text', 'admin_name', null, 'class = "inputText"');
    159. 

  159.   $form -> addRule('admin_name', 'The field "Administrator user name" is mandatory', 'required', null, 'client');
    160. 

  160.   $form -> addRule('admin_name', 'Invalid administrator user name', 'checkParameter', 'login');
    161. 

  161.   $form -> addElement('password', 'admin_password', null, 'class = "inputText"');
    162. 

  162.   $form -> addRule('admin_password', 'The field "Administrator password" is mandatory', 'required', null, 'client');
    163. 

  163.   $form -> addElement('text', 'admin_email', null, 'class = "inputText"');
    164. 

  164.   $form -> addRule('admin_email', 'The field "Administrator email" is mandatory', 'required', null, 'client');
    165. 

  165.   $form -> addRule('admin_email', 'Invalid administrator email', 'checkParameter', 'email');
    166. 

  166.   $form -> addElement('checkbox', 'default_data', null, null, 'style = "vertical-align:middle"');
    167. 

  167.  }
    168. 

  168.  $form -> addElement('submit', 'submit_form', $_GET['upgrade'] ? 'Upgrade' : 'Install', 'class = "flatButton"');
    169. 

  169.  $form -> addElement('submit', 'delete_form', 'Delete existing tables and retry', 'class = "flatButton"');
    170. 

  170.  $form -> setDefaults(array('db_host' => 'localhost', //$_SERVER['HTTP_HOST']
    171. 

  171.                                'db_user' => 'root',
    172. 

  172.                                'db_password' => '',
    173. 

  173.                                'db_name' => 'efront',
    174. 

  174.                                'db_prefix' => '',
    175. 

  175.                                'admin_name' => 'admin',
    176. 

  176.            'backup' => true,
    177. 

  177.  //'upgrade_search' => true,
    178. 

  178.                                'default_data' => true));
    179. 

  179.  if ($_GET['upgrade']) {
    180. 

  180.   $form -> setDefaults($currentVersion);
    181. 

  181.   $form -> setDefaults(array('old_db_name' => $currentVersion['db_name']));
    182. 

  182.  }
    183. 

  183.  $form->disable_csrf = true;
    184. 

  184.  if (($form -> isSubmitted() && $form -> validate()) || isset($_GET['unattended'])) {
    185. 

  185.   try {
    186. 

  186.    if (function_exists('apc_clear_cache')) {
    187. 

  187.     apc_clear_cache('user');
    188. 

  188.    }
    189. 

  189.    $db = ADONewConnection($form -> exportValue('db_type')); //Set Connection parameter to "mysql"
    190. 

  190.    if (isset($_GET['unattended'])) {
    191. 

  191.     if (isset($_GET['upgrade'])) {
    192. 

  192.      $values = $currentVersion;
    193. 

  193.      $values['old_db_name'] = $values['db_name'];
    194. 

  194.     } else {
    195. 

  195.      $contents = file(basename($_GET['config']));
    196. 

  196.      $values = array();
    197. 

  197.      foreach ($contents as $value) {
    198. 

  198.       $value = explode("=", $value);
    199. 

  199.       $values[trim($value[0])] = trim($value[1]);
    200. 

  200.      }
    201. 

  201.     }
    202. 

  202.    } else {
    203. 

  203.     $values = $form -> exportValues();
    204. 

  204.    }
    205. 

  205.    //first, try to connect to the host
    206. 

  206.    $db -> NConnect($values['db_host'], $values['db_user'], $values['db_password']);
    207. 

  207.    if ($values['db_type'] == 'mysql') {
    208. 

  208.     $db -> Execute("SET NAMES 'UTF8'");
    209. 

  209.    }
    210. 

  210.    $file_contents = trim(file_get_contents("sql_".$values['db_type'].".txt")); //Get the sql queries text
    211. 

  211.    $file_contents = explode(';',$file_contents); //Form the sql queries, by splitting each CREATE statement
    212. 

  212.    if (!end($file_contents)) {
    213. 

  213.     array_pop($file_contents); //Remove last element, if it is an empty array (which is usually the case)
    214. 

  214.    }
    215. 

  215.    //Create the new database and database tables, either if it is a clean install, or if it is an upgrade in a different database
    216. 

  216.    if (!$_GET['upgrade'] || $values['old_db_name'] != $values['db_name']) {
    217. 

  217.     //Check whether the db exists. If not, create it
    218. 

  218.     try {
    219. 

  219.      $db -> NConnect($values['db_host'], $values['db_user'], $values['db_password'], $values['db_name']);
    220. 

  220.     } catch (Exception $e) {
    221. 

  221.      $db -> Execute("create database ".$values['db_name']." DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci"); //Create the new database
    222. 

  222.      $db -> NConnect($values['db_host'], $values['db_user'], $values['db_password'], $values['db_name']);
    223. 

  223.     }
    224. 

  224.     if ($values['db_type'] == 'mysql') {
    225. 

  225.      $db -> Execute("SET NAMES 'UTF8'");
    226. 

  226.     }
    227. 

  227.     foreach ($file_contents as $query) {
    228. 

  228.      //Apply the selected prefix to table names
    229. 

  229.      $query = preg_replace('/CREATE TABLE (\w+) (.*)/', 'CREATE TABLE '.$values['db_prefix'].'$1 $2', $query);
    230. 

  230.      preg_match('/CREATE TABLE (\w+) .*/', $query, $matches);
    231. 

  231.      try {
    232. 

  232.       if (isset($values['delete_form']) && $matches[1]) {
    233. 

  233.        //$db -> Execute("drop table if exists ".$matches[1]);
    234. 

  234.        Installation :: dropTableIfExists($matches[1], $values['db_type']);
    235. 

  235.       }
    236. 

  236.       $db -> Execute($query);
    237. 

  237.      } catch (Exception $e) {
    238. 

  238.       $failed_tables[] = $e -> msg; //Each failed query will not halt the execution, but will be recorded to this table
    239. 

  239.      }
    240. 

  240.     }
    241. 

  241.     if (isset($failed_tables)) { //If there were any errors, assign them to smarty to be displayed
    242. 

  242.      $smarty -> assign('T_FAILED_TABLES', 1);
    243. 

  243.      throw new Exception(implode(', ', $failed_tables));
    244. 

  244.     }
    245. 

  245.    }
    246. 

  246.    if ($_GET['upgrade']) {
    247. 

  247.     $db -> NConnect($values['db_host'], $values['db_user'], $values['db_password'], $values['db_name']);
    248. 

  248.     $db -> Execute("SET NAMES 'UTF8'");
    249. 

  249.     try {
    250. 

  250.      $db -> Execute("truncate cache");
    251. 

  251.     } catch (Exception $e) {} //If the table could not be emptied, it doesn't exist, which is ok
    252. 

  252.     $dbVersion = $db -> getCol("select value from configuration where name = 'database_version'");
    253. 

  253.     if (!empty($dbVersion)) {
    254. 

  254.      $dbVersion = $dbVersion[0];
    255. 

  255.     } else {
    256. 

  256.      $dbVersion = '3.5';
    257. 

  257.     }
    258. 

  258.     //Include old configuration file in order to perform the automatic backup, use database functions, etc
    259. 

  259.     require_once($path."configuration.php");
    260. 

  260.     if ($values['backup'] || isset($_GET['unattended'])) {
    261. 

  261.      $backupFile = EfrontSystem :: backup($values['db_name'].'_'.time().'.zip'); //Auto backup database
    262. 

  262.     }
    263. 

  263.     if (version_compare($dbVersion, '3.6.11') == -1) {
    264. 

  264.      Installation :: createTable('themes', $file_contents);
    265. 

  265.      //Get all the database tables, except for the temporary installation tables
    266. 

  266.      $result = $db -> Execute("show table status"); //Get the database tables
    267. 

  267.      while (!$result->EOF) {
    268. 

  268.       if (strpos($result -> fields['Name'], 'install_') !== 0) {
    269. 

  269.        $tables[] = $result -> fields['Name'];
    270. 

  270.       }
    271. 

  271.       $result -> MoveNext();
    272. 

  272.      }
    273. 

  273.      //We are upgrading onto the same database.
    274. 

  274.      if ($values['old_db_name'] == $values['db_name']) {
    275. 

  275.       $db -> NConnect($values['db_host'], $values['db_user'], $values['db_password'], $values['db_name']);
    276. 

  276.       $db -> Execute("SET NAMES 'UTF8'");
    277. 

  277.       //ini_set("memory_limit", "-1");
    278. 

  278.       //Delete old temporary installation tables
    279. 

  279.       foreach ($tables as $table) {
    280. 

  280.        try {
    281. 

  281.         $result = $db -> Execute("drop table install_$table"); //Delete temporary installation tables, if such exist
    282. 

  282.        } catch (Exception $e) {
    283. 

  283.        } //If the table could not be deleted, it doesn't exist
    284. 

  284.       }
    285. 

  285.       //Create temporary tables with the 'install_' prefix
    286. 

  286.       foreach ($file_contents as $query) {
    287. 

  287.        //Apply the selected prefix to table names
    288. 

  288.        $matches = array();
    289. 

  289.        preg_match('/CREATE TABLE (\w+) .*/', $query, $matches);
    290. 

  290.        $queryCreate = preg_replace('/CREATE TABLE (\w+) (.*)/', 'CREATE TABLE if not exists '.$values['db_prefix'].'$1 $2', $query);
    291. 

  291.        $queryCreateTemp = preg_replace('/(.*CREATE TABLE )(\w+)( .*)/', '$1 '.$values['db_prefix'].'install_$2 $3', $query); //Use temporary installation tables
    292. 

  292.        try {
    293. 

  293.         $db -> Execute($queryCreateTemp);
    294. 

  294.         $db -> Execute($queryCreate);
    295. 

  295.         $newTables[] = $matches[1];
    296. 

  296.        } catch (Exception $e) {
    297. 

  297.         $failed_tables[] = $e -> msg; //Each failed query will not halt the execution, but will be recorded to this table
    298. 

  298.        }
    299. 

  299.       }
    300. 

  300.       if (isset($failed_tables)) { //If there were any errors, assign them to smarty to be displayed
    301. 

  301.        $smarty -> assign('T_FAILED_TABLES', 1);
    302. 

  302.        throw new Exception(implode(', ', $failed_tables));
    303. 

  303.       }
    304. 

  304.       $existingTables = array_diff($tables, $newTables); //These are tables pre-existing in the database, which should remain intact
    305. 

  305.       $userProfile = eF_getTableData("user_profile", "*"); //Get any additional user profile fields
    306. 

  306.      } else {
    307. 

  307.       //The inclusion of configuration.php triggered the creation of a new configuration file. Truncate it in the new database
    308. 

  308.       $result = $db -> Execute("truncate configuration");
    309. 

  309.       //Special handling of modules table
    310. 

  310.       $db -> NConnect($values['db_host'], $values['db_user'], $values['db_password'], $values['old_db_name']);
    311. 

  311.       $db -> Execute("SET NAMES 'UTF8'");
    312. 

  312.       $existingTables = $db -> GetCol("show tables");
    313. 

  313.       $moduleTables = array_diff($existingTables, $tables);
    314. 

  314.       $moduleTableQueries = array();
    315. 

  315.       foreach ($moduleTables as $table) {
    316. 

  316.        $result = $db -> execute("show create table ".$table);
    317. 

  317.        $moduleTableQueries[$table] = $result -> getAll();
    318. 

  318.        $tables[] = $table;
    319. 

  319.       }
    320. 

  320.       $userProfile = eF_getTableData("user_profile", "*"); //Get any additional user profile fields
    321. 

  321.       $db -> NConnect($values['db_host'], $values['db_user'], $values['db_password'], $values['db_name']);
    322. 

  322.       $db -> Execute("SET NAMES 'UTF8'");
    323. 

  323.       //Delete old temporary installation tables
    324. 

  324.       foreach ($tables as $key => $table) {
    325. 

  325.        try {
    326. 

  326.         $result = $db -> Execute("drop table install_$table"); //Delete temporary installation tables, if such exist
    327. 

  327.        } catch (Exception $e) {
    328. 

  328.        } //If the table could not be deleted, it doesn't exist
    329. 

  329.        if (preg_match("/^.*_view$/", $table)) {
    330. 

  330.         unset($tables[$key]);
    331. 

  331.        }
    332. 

  332.       }
    333. 

  333.       //Create missing tables in the target database
    334. 

  334.       foreach ($moduleTableQueries as $query) {
    335. 

  335.        if (isset($query[0]['Create Table'])) {
    336. 

  336.         $db -> Execute($query[0]['Create Table']);
    337. 

  337.        }
    338. 

  338.       }
    339. 

  339.       //For every table that already exists in the target database, we must empty otherwise we may end up with duplicate values
    340. 

  340.       $commonTables = array_intersect($existingTables, $tables);
    341. 

  341.       foreach ($commonTables as $table) {
    342. 

  342.        try {
    343. 

  343.         $db -> Execute("truncate table $table");
    344. 

  344.        } catch (Exception $e) {/*Do nothing, if for example it's views we are trying to truncate*/
    345. 

  345.        }
    346. 

  346.       }
    347. 

  347.      }
    348. 

  348.      for ($i = 0; $i < sizeof($userProfile); $i++) {
    349. 

  349.       $userProfile[$i]['mandatory'] ? $mandatory = "NOT NULL" : $mandatory = "NULL";
    350. 

  350.       $userProfile[$i]['default_value'] ? $default = $userProfile[$i]['default_value'] : $default = false;
    351. 

  351.       try {
    352. 

  352.        if ($values['old_db_name'] == $values['db_name']) {
    353. 

  353.         $db -> Execute("ALTER TABLE install_users ADD ".$userProfile[$i]['name']." varchar(255) ".$mandatory." DEFAULT '".$default."'");
    354. 

  354.        } else {
    355. 

  355.         $db -> Execute("ALTER TABLE users ADD ".$userProfile[$i]['name']." varchar(255) ".$mandatory." DEFAULT '".$default."'");
    356. 

  356.        }
    357. 

  357.       } catch (Exception $e) {
    358. 

  358.        $failed_updates[] = $e -> msg;
    359. 

  359.       }
    360. 

  360.      }
    361. 

  361.      unset($tables['userpage']); //deprecated table
    362. 

  362.      $upgradedTables = array();
    363. 

  363.      foreach ($tables as $table) {
    364. 

  364.       if ($values['old_db_name'] == $values['db_name']) {
    365. 

  365.        if (!in_array($table, $existingTables)) {
    366. 

  366.         //Installation :: updateDBTable($table, "install_".$table);
    367. 

  367.         if (Installation :: quickUpgrade($table)) {
    368. 

  368.          $upgradedTables[] = $table;
    369. 

  369.         }
    370. 

  370.        }
    371. 

  371.       } else {
    372. 

  372.        $oldDB = array('db_host' => $values['db_host'], 'db_user' => $values['db_user'], 'db_password' => $values['db_password'], 'db_name' => $values['old_db_name']);
    373. 

  373.        $newDB = array('db_host' => $values['db_host'], 'db_user' => $values['db_user'], 'db_password' => $values['db_password'], 'db_name' => $values['db_name']);
    374. 

  374.        Installation :: updateDBTable($table, $table, $oldDB, $newDB);
    375. 

  375.       }
    376. 

  376.      }
    377. 

  377.      //In any case, Restore connection to the normal database
    378. 

  378.      $GLOBALS['db'] -> NConnect($values['db_host'], $values['db_user'], $values['db_password'], $values['db_name']);
    379. 

  379.      $GLOBALS['db'] -> Execute("SET NAMES 'UTF8'");
    380. 

  380.      //The upgrade completed successfully, so delete old tables and rename temporary install_ tables to its original names
    381. 

  381.      if ($values['old_db_name'] == $values['db_name']) {
    382. 

  382.       foreach ($upgradedTables as $table) {
    383. 

  383.        if (!in_array($table, $existingTables)) {
    384. 

  384.         $db -> Execute("drop table $table");
    385. 

  385.         $db -> Execute("RENAME TABLE install_$table TO $table");
    386. 

  386.        }
    387. 

  387.       }
    388. 

  388.       foreach ($tables as $table) {
    389. 

  389.        if (!in_array($table, $existingTables)) {
    390. 

  390.         try {
    391. 

  391.          $db -> Execute("drop table install_$table");
    392. 

  392.         } catch (Exception $e) {
    393. 

  393.         }
    394. 

  394.        }
    395. 

  395.       }
    396. 

  396.      }
    397. 

  397.      if ($values['upgrade_search']) {
    398. 

  398.       //EfrontSearch::reBuiltIndex();
    399. 

  399.      }
    400. 

  400.      if (version_compare($dbVersion, '3.6.7') == -1) {
    401. 

  401.       $courses = eF_getTableData("courses","*");
    402. 

  402.       foreach ($courses as $key => $value) {
    403. 

  403.        $options = unserialize($value['options']);
    404. 

  404.        if (!isset($options['certificate_export_method'])) {
    405. 

  405.         $options['certificate_export_method'] = 'rtf';
    406. 

  406.         eF_updateTableData('courses',array('options' => serialize($options)),'id='.$value['id']);
    407. 

  407.        }
    408. 

  408.       }
    409. 

  409.       EfrontTimes :: upgradeFromUsersOnline();
    410. 

  410.      }
    411. 

  411.      if (version_compare($dbVersion, '3.6.10') == -1) {
    412. 

  412.       $result = eF_getTableData("users_to_projects", "*");
    413. 

  413.       foreach ($result as $value) {
    414. 

  414.        if (isset($value['filename']) && $value['filename'] != '') {
    415. 

  415.         try {
    416. 

  416.          $file = new EfrontFile($value['filename']);
    417. 

  417.          if ($file['directory'] == G_UPLOADPATH.$value['users_LOGIN'].'/projects') {
    418. 

  418.           $projectDirectory = G_UPLOADPATH.$value['users_LOGIN'].'/projects/'.$value['projects_ID'].'/';
    419. 

  419.           if (!is_dir($projectDirectory)) {
    420. 

  420.            EfrontDirectory :: createDirectory($projectDirectory);
    421. 

  421.           }
    422. 

  422.           $file -> rename($projectDirectory.$file['physical_name']);
    423. 

  423.          }
    424. 

  424.         } catch (Exception $e) {
    425. 

  425.         }
    426. 

  426.        }
    427. 

  427.       }
    428. 

  428.       //change flv path with offset because of the tinymce 3.4.2
    429. 

  429.       $result = eF_getTableData("content", "*", "data like '%flvToPlay%'");
    430. 

  430.       foreach ($result as $value) {
    431. 

  431.        if (mb_strpos($value['data'], "flvToPlay=../../../../../") !== false) {
    432. 

  432.         $value['data'] = str_replace("flvToPlay=../../../../../", "flvToPlay=##EFRONTEDITOROFFSET##", $value['data']);
    433. 

  433.         eF_updateTableData("content", array('data' => $value['data']), "id=".$value['id']);
    434. 

  434.        }
    435. 

  435.       }
    436. 

  436.      }
    437. 

  437.      $options = EfrontConfiguration :: getValues();
    438. 

  438.      //This means that the version upgrading from is 3.5
    439. 

  439.      if ($dbVersion == '3.5') {
    440. 

  440.       //Try to restore custom blocks
    441. 

  441.       try {
    442. 

  442.        if ($options['custom_blocks']) {
    443. 

  443.         $basedir = G_EXTERNALPATH;
    444. 

  444.         if (!is_dir($basedir) && !mkdir($basedir, 0755)) {
    445. 

  445.          throw new EfrontFileException(_COULDNOTCREATEDIRECTORY.': '.$fullPath, EfrontFileException :: CANNOT_CREATE_DIR);
    446. 

  446.         }
    447. 

  447.         $blocks = unserialize($options['custom_blocks']);
    448. 

  448.         foreach ($blocks as $value) {
    449. 

  449.          $value['name'] = rand().time(); //Use a random name
    450. 

  450.          $block = array('name' => $value['name'],
    451. 

  451.            'title' => $value['title']);
    452. 

  452.          file_put_contents($basedir.$value['name'].'.tpl', $value['content']);
    453. 

  453.          isset($customBlocks) && sizeof($customBlocks) > 0 ? $customBlocks[] = $block : $customBlocks = array($block);
    454. 

  454.         }
    455. 

  455.         $currentSetTheme = new themes($GLOBALS['configuration']['theme']);
    456. 

  456.         $currentSetTheme -> layout['custom_blocks'] = $customBlocks;
    457. 

  457.         $currentSetTheme -> persist();
    458. 

  458.        }
    459. 

  459.       } catch (Exception $e) {
    460. 

  460.       }
    461. 

  461.       //Try to restore custom logo
    462. 

  462.       try {
    463. 

  463.        $logoFile = new EfrontFile($options['logo']);
    464. 

  464.        if (strpos($logoFile['path'], G_LOGOPATH) === false) {
    465. 

  465.         copy ($logoFile['path'], G_LOGOPATH.$logoFile['name']);
    466. 

  466.        }
    467. 

  467.       } catch (Exception $e) {
    468. 

  468.       }
    469. 

  469.       //Try to restore custom favicon
    470. 

  470.       try {
    471. 

  471.        if (strpos($faviconFile['path'], G_LOGOPATH) === false) {
    472. 

  472.         $faviconFile = new EfrontFile($options['logo']);
    473. 

  473.        }
    474. 

  474.        copy ($faviconFile['path'], G_LOGOPATH.$faviconFile['name']);
    475. 

  475.       } catch (Exception $e) {
    476. 

  476.       }
    477. 

  477.       //Try to restore paypalbusiness addres
    478. 

  478.       try {
    479. 

  479.        $result = eF_getTableData("paypal_configuration", "paypalbusiness");
    480. 

  480.        if (!empty($result)) {
    481. 

  481.         EfrontConfiguration :: setValue('paypalbusiness', $result[0]['paypalbusiness']);
    482. 

  482.        }
    483. 

  483.       } catch (Exception $e) {
    484. 

  484.       }
    485. 

  485.       //Reset certain version options
    486. 

  486.       try {
    487. 

  487.        if ($options['version_type'] == 'standard') {
    488. 

  488.         EfrontConfiguration :: setValue('version_type', 'community');
    489. 

  489.        }
    490. 

  490.       } catch (Exception $e) {
    491. 

  491.       }
    492. 

  492.       //Add default notifications to 3.5
    493. 

  493.       EfrontNotification::addDefaultNotifications();
    494. 

  494.      }
    495. 

  495.     }
    496. 

  496.     //Now upgrade to 3.6.12
    497. 

  497.     include ("upgrade.php");
    498. 

  498.     Installation :: createConfigurationFile($values, true);
    499. 

  499.     //the following lines remove some old editor files that prevent editor from loading in version 3.6
    500. 

  500.     $removedDir = array();
    501. 

  501.     //$removedDir[] = G_ROOTPATH.'www/editor/tiny_mce/themes/advanced/langs';
    502. 

  502.     $removedDir[] = G_ROOTPATH.'www/editor/tiny_mce/plugins/zoom';
    503. 

  503.     $removedDir[] = G_ROOTPATH.'www/editor/tiny_mce/plugins/flash';
    504. 

  504.     $removedDir[] = G_ROOTPATH.'www/editor/tiny_mce/plugins/devkit';
    505. 

  505.     $removedDir[] = G_ROOTPATH.'www/editor/tiny_mce/plugins/mathtype';
    506. 

  506.     $removedDir[] = G_ROOTPATH.'www/editor/tiny_mce/plugins/lessons_info';
    507. 

  507.     foreach ($removedDir as $key => $value) {
    508. 

  508.      if (is_dir($value)) {
    509. 

  509.       try {
    510. 

  510.        $directory = new EfrontDirectory($value);
    511. 

  511.        $directory -> delete();
    512. 

  512.       } catch (EfrontFileException $e) {} //Don't stop on filesystem errors
    513. 

  513.      }
    514. 

  514.     }
    515. 

  515.     $fileSystemTree = new FileSystemTree(G_ROOTPATH.'www/editor/tiny_mce/plugins', true);
    516. 

  516.     foreach (new EfrontDirectoryOnlyFilterIterator($fileSystemTree -> tree) as $key => $value) {
    517. 

  517.     //alternatively we can delete only lang files without _dlg
    518. 

  518.     /*	if (is_dir($key.'/langs')) {
    519. 

  519. 						try {
    520. 

  520. 							$directory = new EfrontDirectory($key.'/langs');
    521. 

  521. 							$directory -> delete();
    522. 

  522. 						} catch (EfrontFileException $e) {}                                    //Don't stop on filesystem errors
    523. 

  523. 					}
    524. 

  524. 				*/
    525. 

  525.      if (is_dir($key.'/jscripts')) {
    526. 

  526.       try {
    527. 

  527.        if ($value['name'] != 'preview' && $value['name'] != 'Jsvk') {
    528. 

  528.         $directory = new EfrontDirectory($key.'/jscripts');
    529. 

  529.         $directory -> delete();
    530. 

  530.        }
    531. 

  531.       } catch (EfrontFileException $e) {} //Don't stop on filesystem errors
    532. 

  532.      }
    533. 

  533.     }
    534. 

  534.     try {
    535. 

  535.      $cacheTree = new FileSystemTree(G_THEMECACHE, true);
    536. 

  536.      foreach (new EfrontDirectoryOnlyFilterIterator($cacheTree -> tree) as $value) {
    537. 

  537.       $value -> delete();
    538. 

  538.      }
    539. 

  539.     } catch (Exception $e) {}
    540. 

  540.     EfrontConfiguration :: setValue('database_version', G_VERSION_NUM);
    541. 

  541.     if (!defined("PREPROCESSED") && $GLOBALS['configuration']['version_type'] != G_VERSIONTYPE) {
    542. 

  542.      EfrontConfiguration :: setValue('version_type', G_VERSIONTYPE);
    543. 

  543.      EfrontConfiguration :: setValue('version_users', '');
    544. 

  544.      EfrontConfiguration :: setValue('version_activated', '');
    545. 

  545.      EfrontConfiguration :: setValue('version_upgrades', '');
    546. 

  546.      EfrontConfiguration :: setValue('version_key', '');
    547. 

  547.     }
    548. 

  548.     EfrontConfiguration :: setValue('editor_type', 'tinymce_new');
    549. 

  549.     EfrontConfiguration :: setValue('phplivedocx_server', 'https://api.livedocx.com/1.2/mailmerge.asmx?WSDL'); //code for updating phplivedocx_server
    550. 

  550.     $defaultConfig = EfrontConfiguration :: getValues();
    551. 

  551.     $phplivedocxConfig = '<?php
    552. 

  552. define("PATH_ZF","'.G_ROOTPATH.'Zend/library/'.'");
    553. 

  553. define("USERNAME","'.$defaultConfig['phplivedocx_username'].'");
    554. 

  554. define("PASSWORD","'.$defaultConfig['phplivedocx_password'].'");
    555. 

  555. define("PHPLIVEDOCXAPI","'.$defaultConfig['phplivedocx_server'].'");
    556. 

  556. ?>';
    557. 

  557.     try {
    558. 

  558.      if (!file_exists($path."phplivedocx_config.php") || is_writable($path."phplivedocx_config.php")) {
    559. 

  559.       file_put_contents($path."phplivedocx_config.php", $phplivedocxConfig);
    560. 

  560.      }
    561. 

  561.     } catch (Exception $e) {}
    562. 

  562.     //Upgrade for 3.6.8's default/site/theme logo: If a logo is set, then set this as the 'site logo' and set 'use_logo' to 1 (which means 'use site logo')
    563. 

  563.     if ($GLOBALS['configuration']['logo'] && !$GLOBALS['configuration']['site_logo']) {
    564. 

  564.      EfrontConfiguration :: setValue('use_logo', 1);
    565. 

  565.      EfrontConfiguration :: setValue('site_logo', $GLOBALS['configuration']['logo']);
    566. 

  566.     }
    567. 

  567.     $defaultConfig['editor_type'] == 'tinymce_new' ? $editorDir = 'tiny_mce_new' : $editorDir = 'tiny_mce';
    568. 

  568.     try {
    569. 

  569.      $cacheEditor = new FileSystemTree(G_ROOTPATH.'www/editor/'.$editorDir, true);
    570. 

  570.      foreach (new EfrontFileOnlyFilterIterator($cacheEditor -> tree) as $key => $value) {
    571. 

  571.       if ($value['extension'] == 'gz') {
    572. 

  572.        $value -> delete();
    573. 

  573.       }
    574. 

  574.      }
    575. 

  575.     } catch (Exception $e) {}
    576. 

  576.     Installation :: addModules(true);
    577. 

  577.     EfrontStats :: createViews();
    578. 

  578.     if (!isset($_GET['unattended'])) {
    579. 

  579.      header("location:".$_SERVER['PHP_SELF']."?finish=1&upgrade=1");
    580. 

  580.      exit;
    581. 

  581.     }
    582. 

  582.    } else {
    583. 

  583.     //Create the file libraries/configuration.php
    584. 

  584.     Installation :: createConfigurationFile($values);
    585. 

  585.     /**Include the file configuration.php*/
    586. 

  586.     require_once($path."configuration.php");
    587. 

  587.     if (stripos(php_uname(), 'windows') !== false) {
    588. 

  588.      EfrontConfiguration :: setValue('file_encoding', 'UTF7-IMAP');
    589. 

  589.     }
    590. 

  590.     EfrontConfiguration :: setValue('time_zone', date_default_timezone_get());
    591. 

  591.     /*Languages declarations. Must be put before creating default users and lessons*/
    592. 

  592.     include_once "insert_languages.php";
    593. 

  593.     addLanguagesDB();
    594. 

  594.     //modern is the default theme
    595. 

  595.     try {
    596. 

  596.      $file = new EfrontFile(G_THEMESPATH."efront2013/theme.xml");
    597. 

  597.      themes :: create(themes :: parseFile($file));
    598. 

  598.      $currentTheme = new themes('efront2013');
    599. 

  599.      EfrontConfiguration :: setValue('theme', $currentTheme -> {$currentTheme -> entity}['id']);
    600. 

  600.     } catch (Exception $e) {}
    601. 

  601.     //Create the default system users and lessons
    602. 

  602.     if (isset($values['default_data']) && $values['default_data']) {
    603. 

  603. /*					
    604. 

  604. 					//The new db itself
    605. 

    606. 

  606. 					foreach (explode(";\r\n", file_get_contents(G_LIBRARIESPATH.'enterprise.sql')) as $command) {
    607. 

    608. 

  608. 						if (trim($command)) {
    609. 

    610. 

  610. 							$db -> execute(trim($command));
    611. 

    612. 

  612. 						}
    613. 

    614. 

  614. 					}					
    615. 

  615. 					$db -> Execute($sql);
    616. 

  616. 					$fields = array('password' => EfrontUser::createPassword($values['admin_password']),
    617. 

  617. 							'email' => $values['admin_email'],
    618. 

  618. 							'timestamp' => time());
    619. 

  619. 					eF_updateTableData("users", $fields);
    620. 

  620. 					$fields = array('login' => $values['admin_name']);
    621. 

    622. 

  622. 					eF_updateTableData("users", $fields, "login='admin'");
    623. 

  623. 					$fields = array('created' => time());
    624. 

    625. 

  625. 					eF_updateTableData("courses", $fields);
    626. 

  626. 					eF_updateTableData("lessons", $fields);
    627. 

  627. 					$fields = array('from_timestamp' => time());
    628. 

  628. 					eF_updateTableData("users_to_courses", $fields);
    629. 

  629. 					eF_updateTableData("users_to_lessons", $fields);
    630. 

  630. */
    631. 

  631.      $result = Installation :: createDefaultUsers($values);
    632. 

  632.      foreach ($result as $value) {
    633. 

  633.       if ($value -> user['user_type'] != 'administrator') {
    634. 

  634.        $lessonUsers[$value -> user['login']] = $value -> user['user_type'];
    635. 

  635.       }
    636. 

  636.      }
    637. 

  637.      Installation :: createDefaultLessons($values, $lessonUsers);
    638. 

  638.     } else {
    639. 

  639.      $result = Installation :: createDefaultUsers($values, true);
    640. 

  640.     }
    641. 

  641.     EfrontConfiguration :: setValue('editor_type', 'tinymce_new');
    642. 

  642.     EfrontNotification::addDefaultNotifications();
    643. 

  643.     EfrontConfiguration :: setValue('phplivedocx_server', 'https://api.livedocx.com/1.2/mailmerge.asmx?WSDL'); //code for updating phplivedocx_server
    644. 

  644.     $defaultConfig = EfrontConfiguration :: getValues();
    645. 

  645.     $phplivedocxConfig = '<?php
    646. 

  646. define("PATH_ZF","'.G_ROOTPATH.'Zend/library/'.'");
    647. 

  647. define("USERNAME","'.$defaultConfig['phplivedocx_username'].'");
    648. 

  648. define("PASSWORD","'.$defaultConfig['phplivedocx_password'].'");
    649. 

  649. define("PHPLIVEDOCXAPI","'.$defaultConfig['phplivedocx_server'].'");
    650. 

  650. ?>';
    651. 

  651.     file_put_contents($path."phplivedocx_config.php", $phplivedocxConfig);
    652. 

  652.     Installation :: addModules();
    653. 

  653.     if (is_file('post_install.php')) {
    654. 

  654.      include('post_install.php');
    655. 

  655.      runPostInstallationFunctions();
    656. 

  656.     }
    657. 

  657.     EfrontStats::createViews();
    658. 

  658.     if (!isset($_GET['unattended'])) {
    659. 

  659.      header("location:".$_SERVER['PHP_SELF']."?finish=1");
    660. 

  660.      exit;
    661. 

  661.     }
    662. 

  662.    }
    663. 

  663.   } catch (Exception $e) {
    664. 

  664.    Installation::handleInstallationExceptions($e);
    665. 

  665.   }
    666. 

  666.  }
    667. 

  667.  $renderer = new HTML_QuickForm_Renderer_ArraySmarty($smarty);
    668. 

  668.  $renderer->setRequiredTemplate(
    669. 

  669.        '{$html}{if $required}
    670. 

  670.             &nbsp;<span class = "formRequired">*</span>
    671. 

  671.         {/if}'
    672. 

  672.         );
    673. 

  673.         $form -> setJsWarnings('The following errors occured:', 'Please correct the above errors');
    674. 

  674.         $form -> setRequiredNote('* Denotes mandatory fields');
    675. 

  675.         $form -> accept($renderer);
    676. 

  676.         $smarty -> assign('T_DATABASE_FORM', $renderer -> toArray());
    677. 

  677. }
    678. 

  678. if (isset($_GET['finish']) || isset($_GET['unattended'])) {
    679. 

  679.  //delete theme cache
    680. 

  680.  try {
    681. 

  681.   $path = "../../libraries/";
    682. 

  682.   require_once($path."configuration.php");
    683. 

  683.   $cacheTree = new FileSystemTree(G_THEMECACHE, true);
    684. 

  684.   foreach (new EfrontDirectoryOnlyFilterIterator($cacheTree -> tree) as $value) {
    685. 

  685.    //$value -> delete();
    686. 

  686.   }
    687. 

  687.  } catch (Exception $e) {
    688. 

  688.   Installation::handleInstallationExceptions($e);
    689. 

  689.  }
    690. 

  690.  if (isset($_GET['unattended'])) {
    691. 

  691.   if ($_GET['ajax']) {
    692. 

  692.    echo json_encode(array('status' => 1, 'message' => 'Successfully completed Unattended upgrade'));
    693. 

  693.    EfrontSystem :: unlockSystem();
    694. 

  694.   } else {
    695. 

  695.    header("location:".G_SERVERNAME."index.php?delete_install=1");
    696. 

  696.   }
    697. 

  697.  } else {
    698. 

  698.   session_destroy();
    699. 

  699.   unset($_SESSION);
    700. 

  700.  }
    701. 

  701.  //$message = "Upgrade is completed, but the contents of the templates folder, ".G_THEMECACHE." could not be deleted. Please delete them manually";
    702. 

  702. }
    703. 

  703. if (isset($_GET['restore'])) {
    704. 

  704.  try {
    705. 

  705.   $path = "../../libraries/";
    706. 

  706.   try {
    707. 

  707.    if (is_file($path."configuration.php")) {
    708. 

  708.     require_once($path."configuration.php");
    709. 

  709.    } else {
    710. 

  710.     echo Installation :: printErrorMessage("You must have a valid configuration file for the emergency restore to work");
    711. 

  711.     exit;
    712. 

  712.    }
    713. 

  713.   } catch (Exception $e) {
    714. 

  714.    $smarty -> assign("T_EXCEPTION_TRACE", $e -> getTraceAsString());
    715. 

  715.    $message = $e -> getMessage().' ('.$e -> getCode().') &nbsp;<a href = "javascript:void(0)" onclick = "eF_js_showDivPopup(\''._ERRORDETAILS.'\', 2, \'error_details\')">'._MOREINFO.'</a>';
    716. 

  716.    $message_type = 'failure';
    717. 

  717.   }
    718. 

  718.   foreach($it = new DirectoryIterator(G_BACKUPPATH) as $key => $value) {
    719. 

  719.    if (!$value -> isDir() && pathinfo($value -> getFileName(), PATHINFO_EXTENSION) == 'zip') {
    720. 

  720.     $files[] = basename($value);
    721. 

  721.    }
    722. 

  722.   }
    723. 

  723.   $smarty -> assign("T_BACKUP_FILES", $files);
    724. 

  724.   if (isset($_GET['file']) && in_array($_GET['file'], $files)) {
    725. 

  725.    //ini_set("memory_limit", "-1");
    726. 

  726.    EfrontSystem :: restore(G_BACKUPPATH.$_GET['file']); //Auto backup database
    727. 

  727.    $message = "The restoring procedure completed successfully";
    728. 

  728.    $message_type = "success";
    729. 

  729.   }
    730. 

  730.  } catch (Exception $e) {
    731. 

  731.   Installation::handleInstallationExceptions($e);
    732. 

  732.  }
    733. 

  733. }
    734. 

  734. $loadScripts = array('EfrontScripts',
    735. 

  735.       'scriptaculous/prototype',
    736. 

  736.       'scriptaculous/scriptaculous',
    737. 

  737.       'scriptaculous/effects',
    738. 

  738.                      'efront_ajax');
    739. 

  739. $smarty -> assign("T_HEADER_LOAD_SCRIPTS", implode(",", array_unique($loadScripts))); //array_unique, so it doesn't send duplicate entries
    740. 

  740. $smarty -> assign("T_MESSAGE", $message);
    741. 

  741. $smarty -> assign("T_MESSAGE_TYPE", $message_type);
    742. 

  742. $smarty -> load_filter('output', 'eF_template_applyImageMap');
    743. 

  743. $smarty -> load_filter('output', 'eF_template_applyThemeToImages');
    744. 

  744. $smarty -> display ("install/install.tpl");
    745. 

  745. /**
    746. 

  746.  *
    747. 

  747.  * @author user
    748. 

  748.  *
    749. 

  749.  */
    750. 

  750. class InstallationException extends Exception
    751. 

  751. {
    752. 

  752.  const DATABASE_NOT_EMPTY = 1;
    753. 

  753. }
    754. 

  754. /**
    755. 

  755.  *
    756. 

  756.  * @author user
    757. 

  757.  *
    758. 

  758.  */
    759. 

  759. class Installation
    760. 

  760. {
    761. 

  761.  /**
    762. 

  762. 	 *
    763. 

  763. 	 * @param $values
    764. 

  764. 	 * @return unknown_type
    765. 

  765. 	 */
    766. 

  766.  public static function createConfigurationFile($values, $upgrade = false) {
    767. 

  767.   $patterns = array("/(define\(['\"]G_DBTYPE['\"], ['\"]).*(['\"]\);)/",
    768. 

  768.                        "/(define\(['\"]G_DBHOST['\"], ['\"]).*(['\"]\);)/",
    769. 

  769.                        "/(define\(['\"]G_DBUSER['\"], ['\"]).*(['\"]\);)/",
    770. 

  770.                        "/(define\(['\"]G_DBPASSWD['\"], ['\"]).*(['\"]\);)/",
    771. 

  771.                        "/(define\(['\"]G_DBNAME['\"], ['\"]).*(['\"]\);)/",
    772. 

  772.                        "/(define\(['\"]G_DBPREFIX['\"], ['\"]).*(['\"]\);)/",
    773. 

  773.                        "/(define\(['\"]G_VERSION_NUM['\"], ['\"]).*(['\"]\);)/");
    774. 

  774.   dirname(dirname($_SERVER['PHP_SELF'])) != '.' ? $servername = dirname(dirname($_SERVER['PHP_SELF'])) : $servername = '';
    775. 

  775.   $servername = str_replace("\\", "/", $servername);
    776. 

  776.   $replacements = array('${1}'.$values['db_type'].'${2}',
    777. 

  777.                   '${1}'.$values['db_host'].'${2}',
    778. 

  778.                   '${1}'.$values['db_user'].'${2}',
    779. 

  779.                   '${1}'.$values['db_password'].'${2}',
    780. 

  780.                   '${1}'.$values['db_name'].'${2}',
    781. 

  781.                   '${1}'.$values['db_prefix'].'${2}',
    782. 

  782.                            '${1}'.G_VERSION_NUM.'${2}');
    783. 

  783.   if ($upgrade) {
    784. 

  784.    $file_contents = file_get_contents($GLOBALS['path'].'configuration.php'); //Load sample configuration file
    785. 

  785.    $new_file_contents = preg_replace("/(define\(['\"]G_SERVERNAME['\"], ['\"]).*(['\"]\);)/", "define('G_OFFSET', '".rtrim($servername, "/").'/'."');", $file_contents, -1, $count);
    786. 

  786.   } else {
    787. 

  787.    $file_contents = file_get_contents('sample_config.php'); //Load sample configuration file
    788. 

  788.    $new_file_contents = preg_replace("/define\('G_OFFSET', ''\)/", "define('G_OFFSET', '".rtrim($servername, "/").'/'."')", $file_contents, -1, $count);
    789. 

  789.   }
    790. 

  790.   $new_file_contents = preg_replace($patterns, $replacements, $new_file_contents, -1, $count); //Replace sample settings with current settings
    791. 

  791.   if (!file_put_contents($GLOBALS['path'].'configuration.php', $new_file_contents)) {
    792. 

  792.    throw new Exception("The configuration file could not be created");
    793. 

  793.   }
    794. 

  794.  }
    795. 

  795.  /**
    796. 

  796. 	 *
    797. 

  797. 	 * @param $values
    798. 

  798. 	 * @param $users
    799. 

  799. 	 * @return unknown_type
    800. 

  800. 	 */
    801. 

  801.  public static function createDefaultLessons($values, $users) {
    802. 

  802.   //Content is now taken from a file called sample_data.sql. To produce an up-to-date version of this file,
    803. 

  803.   //call the following command from the command line:
    804. 

  804.   //mysqldump -u periklis -p <db_name> lessons courses users_to_lessons users_to_courses search_keywords search_invertedindex tests_to_questions tests rules questions lesson_conditions glossary f_forums lessons_to_courses directions content --no-create-info --compact --single-transaction > ~/sample_data.sql
    805. 

  805.   //Replacing <db_name> with the database that will provide the data
    806. 

  806.   foreach (explode("\n", file_get_contents('sample_data.sql')) as $command) {
    807. 

  807.    if (trim($command)) {
    808. 

  808.     $GLOBALS['db'] -> execute(trim($command));
    809. 

  809.    }
    810. 

  810.   }
    811. 

  811.   $file = new EfrontFile(EfrontDirectory :: normalize(getcwd()).'/lessons.zip');
    812. 

  812.   $newFile = $file->copy(G_LESSONSPATH, true);
    813. 

  813.   $newFile->uncompress();
    814. 

  814.   $newFile->delete();
    815. 

  815. /*		
    816. 

  816. 		//Check if any lessons were created in a previous attempt
    817. 

  817. 		$result = eF_getTableData("lessons", "*");
    818. 

  818. 		foreach ($result as $value) {
    819. 

  819. 			$lesson = new EfrontLesson($value);
    820. 

  820. 			$lesson -> delete();
    821. 

  821. 		}
    822. 

  822. 		//Check if any courses were created in a previous attempt
    823. 

  823. 		$result = eF_getTableData("courses", "id");
    824. 

  824. 		foreach ($result as $value) {
    825. 

  825. 			$course = new EfrontLesson($value);
    826. 

  826. 			$course -> delete();
    827. 

  827. 		}
    828. 

  828. 		//Check if any categories were created in a previous attempt
    829. 

  829. 		$result = eF_getTableDataFlat("directions", "id");
    830. 

  830. 		if (sizeof($result) > 0) {
    831. 

  831. 			foreach ($result['id'] as $id) {
    832. 

  832. 				EfrontDirection::deleteDirection($id);
    833. 

  833. 			}
    834. 

  834. 		}
    835. 

    836. 

  836. 		//Create default categories
    837. 

  837. 		$ancientCivId  = eF_insertTableData("directions", array('name' => 'Ancient Civilizations', 'active' => 1));
    838. 

  838. 		$ProgrammingId = eF_insertTableData("directions", array('name' => 'Programming', 'active' => 1));
    839. 

    840. 

  840. 		try {
    841. 

  841. 			//Create "Greedy Algorithms" lesson
    842. 

  842. 			$fields = array('directions_ID'  => $ProgrammingId, 'active' => 1, 'course_only' => 0);
    843. 

  843. 			$file   = new EfrontFile(EfrontDirectory :: normalize(getcwd()).'/Greedy_algorithms.zip');
    844. 

  844. 			$lesson = EfrontLesson :: createLesson(array_merge(array('name' => 'Greedy algorithms'), $fields));
    845. 

  845. 			$file   = $file -> copy($lesson -> getDirectory());
    846. 

  846. 			$lesson -> import($file);
    847. 

  847. 			$lesson -> addUsers(array_keys($users), array_values($users));
    848. 

  848. 		} catch (Exception $e) {}//do nothing, just move on to the next lesson
    849. 

    850. 

  850. 		try {
    851. 

  851. 			//Create "Maya civilization" lesson
    852. 

  852. 			$fields = array('directions_ID'  => $ancientCivId, 'active' => 1, 'course_only' => 0);
    853. 

  853. 			$file   = new EfrontFile(EfrontDirectory :: normalize(getcwd()).'/Maya_civilization.zip');
    854. 

  854. 			$lesson = EfrontLesson :: createLesson(array_merge(array('name' => 'Maya civilization'), $fields));
    855. 

  855. 			$file   = $file -> copy($lesson -> getDirectory());
    856. 

  856. 			$lesson -> import($file);
    857. 

  857. 			$lesson -> addUsers(array_keys($users), array_values($users));
    858. 

  858. 		} catch (Exception $e) {}//do nothing, just move on to the next lesson
    859. 

    860. 

  860. 		try {
    861. 

  861. 			//Create "How to be a programmer" course
    862. 

  862. 			$fields = array('directions_ID'  => $ProgrammingId, 'active' => 1);
    863. 

  863. 			$file   = new EfrontFile(EfrontDirectory :: normalize(getcwd()).'/How_to_be_a_programmer.zip');
    864. 

  864. 			$course = EfrontCourse :: createCourse(array_merge(array('name' => 'How to be a programmer'), $fields));
    865. 

  865. 			$file   = $file -> copy($lesson -> getDirectory());        //$lesson is put here on purpose, since $course does not have a directory
    866. 

  866. 			$course -> import($file);
    867. 

  867. 			$course -> addUsers(array('student'), 'student');
    868. 

  868. 			$course -> addUsers(array('professor'), 'professor');
    869. 

  869. 		} catch (Exception $e) {}//do nothing, just move on to the next lesson
    870. 

  870. */
    871. 

  871.  }
    872. 

  872.  /**
    873. 

  873. 	 *
    874. 

  874. 	 * @param $values
    875. 

  875. 	 * @return unknown_type
    876. 

  876. 	 */
    877. 

  877.  public static function createDefaultUsers($values, $adminOnly = false) {
    878. 

  878.    $language = 'english';
    879. 

  879.   $adminData = array('login' => $values['admin_name'],
    880. 

  880.                         'password' => $values['admin_password'],
    881. 

  881.                         'email' => $values['admin_email'],
    882. 

  882.                         'name' => 'System',
    883. 

  883.                         'surname' => 'Administrator',
    884. 

  884.                         'languages_NAME' => $language,
    885. 

  885.                         'active' => '1',
    886. 

  886.                         'user_type'=> 'administrator',
    887. 

  887.                         'additional_accounts' => $adminOnly ? '' : serialize(array('student', 'professor')));
    888. 

  888.   $admin = EfrontUser :: createUser($adminData);
    889. 

  889.   EfrontConfiguration :: setValue('system_email', $values['admin_email']);
    890. 

  890.   if (!$adminOnly) {
    891. 

  891.    $professorData = array('login' => 'professor',
    892. 

  892.                              'password' => $values['admin_password'],
    893. 

  893.                              'email' => $values['admin_email'],
    894. 

  894.                              'name' => 'Default',
    895. 

  895.                              'surname' => 'Professor',
    896. 

  896.                              'languages_NAME' => $language,
    897. 

  897.                              'active' => '1',
    898. 

  898.                              'user_type'=> 'professor',
    899. 

  899.                              'additional_accounts' => serialize(array($values['admin_name'], 'student')));
    900. 

  900.    $professor = EfrontUser :: createUser($professorData);
    901. 

  901.    $studentData = array('login' => 'student',
    902. 

  902.                            'password' => $values['admin_password'],
    903. 

  903.                            'email' => $values['admin_email'],
    904. 

  904.                            'name' => 'Default',
    905. 

  905.                            'surname' => 'Student',
    906. 

  906.                            'languages_NAME' => $language,
    907. 

  907.                            'active' => '1',
    908. 

  908.                            'user_type'=> 'student',
    909. 

  909.                            'additional_accounts' => serialize(array($values['admin_name'], 'professor')));
    910. 

  910.    $student = EfrontUser :: createUser($studentData);
    911. 

  911.    return array($admin, $professor, $student);
    912. 

  912.   } else {
    913. 

  913.    return array($admin);
    914. 

  914.   }
    915. 

  915.  }
    916. 

  916.  /**
    917. 

  917. 	 * Install modules
    918. 

  918. 	 *
    919. 

  919. 	 * @since 3.6.0
    920. 

  920. 	 * @access public
    921. 

  921. 	 * @static
    922. 

  922. 	 */
    923. 

  923.  public static function addModules($upgrade = false) {
    924. 

  924.   $modulesToInstall = array(
    925. 

  925.     "administrator_tools",
    926. 

  926.     "bbb",
    927. 

  927.     "billboard",
    928. 

  928.     "blogs",
    929. 

  929.     "bootstrap",
    930. 

  930.     "chat",
    931. 

  931.     "crossword",
    932. 

  932.     "export_unit",
    933. 

  933.     "faq",
    934. 

  934.     "flashcards",
    935. 

  935.     "gift_aiken",
    936. 

  936.     "gradebook",
    937. 

  937.     "idle_users",
    938. 

  938.     "info_kiosk",
    939. 

  939.     "journal",
    940. 

  940.     "links",
    941. 

  941.     "outlook_invitation",
    942. 

  942.     "quick_mails",
    943. 

  943.     "quote",
    944. 

  944.     "rss",
    945. 

  945.     "security",
    946. 

  946.     "workbook",
    947. 

  947.     "youtube",
    948. 

  948.     );
    949. 

  949.   $modulesList = eF_getTableData("modules", "*");
    950. 

  950.   foreach ($modulesList as $module) {
    951. 

  951.    $existingModules[] = $module['className'];
    952. 

  952.   }
    953. 

  953.   $filesystem = new FileSystemTree(G_MODULESPATH, true);
    954. 

  954.   foreach (new EfrontNodeFilterIterator($filesystem -> tree) as $moduleDirectory => $value) {
    955. 

  955.    try {
    956. 

  956.     if (in_array(str_replace("module_", "", basename($moduleDirectory)), $modulesToInstall) && is_file($moduleDirectory.'/module.xml')) {
    957. 

  957.      $xml = simplexml_load_file($moduleDirectory.'/module.xml');
    958. 

  958.      $className = (string)$xml -> className;
    959. 

  959.      $className = str_replace(" ", "", $className);
    960. 

  960.      $database_file = (string)$xml -> database;
    961. 

  961.      if (is_file($moduleDirectory.'/'.$className. ".class.php")) {
    962. 

  962.       require_once $moduleDirectory."/".$className.".class.php";
    963. 

  963.       if (class_exists($className)) {
    964. 

  964.        $module = new $className("administrator.php?ctg=module&op=".$className, $className);
    965. 

  965.        // Check whether the roles defined are acceptable
    966. 

  966.        $roles = $module -> getPermittedRoles();
    967. 

  967.        $roles_failure = 0;
    968. 

  968.        if (sizeof($roles) == 0) {
    969. 

  969.         throw new Exception(_NOMODULEPERMITTEDROLESDEFINED);
    970. 

  970.        } else {
    971. 

  971.         foreach ($roles as $role) {
    972. 

  972.          if ($role != 'administrator' && $role != 'student' && $role != 'professor') {
    973. 

  973.           throw new Exception(_NOMODULEPERMITTEDROLESDEFINED);
    974. 

  974.          }
    975. 

  975.         }
    976. 

  976.        }
    977. 

  977.        $fields = array('className' => $className,
    978. 

  978.                                    'db_file' => $database_file,
    979. 

  979.                                    'name' => $className,
    980. 

  980.                                    'active' => 0,
    981. 

  981.                                    'title' => ((string)$xml -> title)?(string)$xml -> title:" ",
    982. 

  982.                                    'author' => (string)$xml -> author,
    983. 

  983.                                    'version' => (string)$xml -> version,
    984. 

  984.                                    'description' => (string)$xml -> description,
    985. 

  985.                                    'position' => basename($moduleDirectory),
    986. 

  986.                                    'permissions' => implode(",", $module -> getPermittedRoles()));
    987. 

  987.        // Install module database
    988. 

  988.        if ($upgrade && in_array($className, $existingModules)) {
    989. 

  989.         if ($module -> onUpgrade()) {
    990. 

  990.          eF_updateTableData("modules", $fields, "className ='".$_GET['upgrade']."'");
    991. 

  991.         } else {
    992. 

  992.          throw new Exception(_MODULEDBERRORONUPGRADECHECKUPGRADEFUNCTION);
    993. 

  993.         }
    994. 

  994.        } else {
    995. 

  995.         if ($module -> onInstall()) {
    996. 

  996.          if ($className == 'module_security') {
    997. 

  997.           $fields['active'] = 1; //Since 3.6.10, security module starts as activated (instead of rss)
    998. 

  998.          }
    999. 

  999.          eF_insertTableData("modules", $fields);
    1000. 

  1000.         } else {
    1001. 

  1001.          throw new Exception(_MODULEDBERRORONINSTALL);
    1002. 

  1002.         }
    1003. 

  1003.        }
    1004. 

  1004.       } else {
    1005. 

  1005.        throw new Exception('"'.$className .'" '. _MODULECLASSNOTEXISTSIN . ' ' .$moduleDirectory.'/'.$className.'.class.php');
    1006. 

  1006.       }
    1007. 

  1007.      } else {
    1008. 

  1008.       throw new Exception(_NOMODULECLASSFOUND . ' "'. $className .'" : '.$moduleDirectory);
    1009. 

  1009.      }
    1010. 

  1010.     }
    1011. 

  1011.    } catch (Exception $e) {/*Don't install any failed modules*/}
    1012. 

  1012.   }
    1013. 

  1013.  }
    1014. 

  1014.  /**
    1015. 

  1015. 	 *
    1016. 

  1016. 	 * @return unknown_type
    1017. 

  1017. 	 */
    1018. 

  1018.  public static function checkCurrentVersion() {
    1019. 

  1019.   if (is_file($GLOBALS['path'].'configuration.php')) {
    1020. 

  1020.    $file_contents = file_get_contents($GLOBALS['path'].'configuration.php'); //Load existing configuration file
    1021. 

  1021.    preg_match('/define\(["\']G_DBTYPE["\'], ["\'](.*)["\']\);/', $file_contents, $type);
    1022. 

  1022.    preg_match('/define\(["\']G_DBHOST["\'], ["\'](.*)["\']\);/', $file_contents, $host);
    1023. 

  1023.    preg_match('/define\(["\']G_DBUSER["\'], ["\'](.*)["\']\);/', $file_contents, $user);
    1024. 

  1024.    preg_match('/define\(["\']G_DBPASSWD["\'], ["\'](.*)["\']\);/', $file_contents, $password);
    1025. 

  1025.    preg_match('/define\(["\']G_DBNAME["\'], ["\'](.*)["\']\);/', $file_contents, $name);
    1026. 

  1026.    //preg_match('/define\(["\']G_VERSION_NUM["\'], ["\'](.*)["\']\);/', $file_contents, $name);
    1027. 

  1027.    $currentVersion = array('db_type' => $type[1],
    1028. 

  1028.                   'db_host' => $host[1],
    1029. 

  1029.                                     'db_user' => $user[1],
    1030. 

  1030.                                     'db_password' => $password[1],
    1031. 

  1031.                                     'db_name' => $name[1]);
    1032. 

  1032.   } else {
    1033. 

  1033.   }
    1034. 

  1034.   return $currentVersion;
    1035. 

  1035.  }
    1036. 

  1036.  /**
    1037. 

  1037. 	 * Automatically fix PHP settings errors
    1038. 

  1038. 	 *
    1039. 

  1039. 	 * This function is used to automatically apply a suitable php.ini or .htaccess file to correct the most
    1040. 

  1040. 	 * usual PHP settings errors: session.save_path, magic_quotes_gpc, register_globals.
    1041. 

  1041. 	 *
    1042. 

  1042. 	 * @param array $settings The settings that need to be fixed
    1043. 

  1043. 	 * @param string $mode Can be 'local', which means that the fix will be in a local php.ini file, or 'htaccess', which means that the fix will be performed with a .htaccess file
    1044. 

  1044. 	 * @since 3.6.0
    1045. 

  1045. 	 * @access public
    1046. 

  1046. 	 * @static
    1047. 

  1047. 	 */
    1048. 

  1048.  public static function fix($settings, $mode = 'local') {
    1049. 

  1049.   $sessionSavePathDir = '';
    1050. 

  1050.   if ($settings['session.save_path'] && function_exists('sys_get_temp_dir') && is_writable(sys_get_temp_dir())) { //If the session.save_path does not exist, set it to system's default temp dir
    1051. 

  1051.    $sessionSavePathDir = trim(sys_get_temp_dir(), '\\');
    1052. 

  1052.   } else if (!function_exists('sys_get_temp_dir') || (function_exists('sys_get_temp_dir') && !is_writable(sys_get_temp_dir()))) {
    1053. 

  1053.    $rootDir = dirname(dirname(dirname(__FILE__)));
    1054. 

  1054.    if (is_dir(dirname($rootDir).'/tmp') && is_writable(dirname($rootDir).'/tmp')) {…
    1055.

Large files files are truncated, but you can click here to view the full file