PageRenderTime 37ms CodeModel.GetById 15ms RepoModel.GetById 0ms app.codeStats 1ms

/manager/cacheextender/orig/document.parser.class.inc.php

https://github.com/good-web-master/modx.evo.custom
PHP | 2884 lines | 2423 code | 213 blank | 248 comment | 589 complexity | 744655921c001c01b362ba6476c44646 MD5 | raw file
Possible License(s): LGPL-2.1, AGPL-1.0, GPL-2.0, MIT, BSD-3-Clause 
    

  1. <?php

    2. 

  2. /**

    3. 

  3.  *	MODx Document Parser

    4. 

  4.  *	Function: This class contains the main document parsing functions

    5. 

  5.  *

    6. 

  6.  */

    7. 

  7. class DocumentParser {

    8. 

  8.     var $db; // db object

    9. 

  9.     var $event, $Event; // event object

    10. 

  10.     var $pluginEvent;

    11. 

  11.     var $config= null;

    12. 

  12.     var $rs;

    13. 

  13.     var $result;

    14. 

  14.     var $sql;

    15. 

  15.     var $table_prefix;

    16. 

  16.     var $debug;

    17. 

  17.     var $documentIdentifier;

    18. 

  18.     var $documentMethod;

    19. 

  19.     var $documentGenerated;

    20. 

  20.     var $documentContent;

    21. 

  21.     var $tstart;

    22. 

  22.     var $minParserPasses;

    23. 

  23.     var $maxParserPasses;

    24. 

  24.     var $documentObject;

    25. 

  25.     var $templateObject;

    26. 

  26.     var $snippetObjects;

    27. 

  27.     var $stopOnNotice;

    28. 

  28.     var $executedQueries;

    29. 

  29.     var $queryTime;

    30. 

  30.     var $currentSnippet;

    31. 

  31.     var $documentName;

    32. 

  32.     var $aliases;

    33. 

  33.     var $visitor;

    34. 

  34.     var $entrypage;

    35. 

  35.     var $documentListing;

    36. 

  36.     var $dumpSnippets;

    37. 

  37.     var $chunkCache;

    38. 

  38.     var $snippetCache;

    39. 

  39.     var $contentTypes;

    40. 

  40.     var $dumpSQL;

    41. 

  41.     var $queryCode;

    42. 

  42.     var $virtualDir;

    43. 

  43.     var $placeholders;

    44. 

  44.     var $sjscripts;

    45. 

  45.     var $jscripts;

    46. 

  46.     var $loadedjscripts;

    47. 

  47.     var $documentMap;

    48. 

  48.     var $forwards= 3;

    49. 

  49. 

    50. 

  50.     // constructor

    51. 

  51.     function DocumentParser() {

    52. 

  52.         $this->loadExtension('DBAPI') or die('Could not load DBAPI class.'); // load DBAPI class

    53. 

  53.         $this->dbConfig= & $this->db->config; // alias for backward compatibility

    54. 

  54.         $this->jscripts= array ();

    55. 

  55.         $this->sjscripts= array ();

    56. 

  56.         $this->loadedjscripts= array ();

    57. 

  57.         // events

    58. 

  58.         $this->event= new SystemEvent();

    59. 

  59.         $this->Event= & $this->event; //alias for backward compatibility

    60. 

  60.         $this->pluginEvent= array ();

    61. 

  61.         // set track_errors ini variable

    62. 

  62.         @ ini_set("track_errors", "1"); // enable error tracking in $php_errormsg

    63. 

  63.     }

    64. 

  64. 

    65. 

  65.     // loads an extension from the extenders folder

    66. 

  66.     function loadExtension($extname) {

    67. 

  67.         global $database_type;

    68. 

  68. 

    69. 

  69.         switch ($extname) {

    70. 

  70.             // Database API

    71. 

  71.             case 'DBAPI' :

    72. 

  72.                 if (!include_once MODX_BASE_PATH . 'manager/includes/extenders/dbapi.' . $database_type . '.class.inc.php')

    73. 

  73.                     return false;

    74. 

  74.                 $this->db= new DBAPI;

    75. 

  75.                 return true;

    76. 

  76.                 break;

    77. 

  77. 

    78. 

  78.                 // Manager API

    79. 

  79.             case 'ManagerAPI' :

    80. 

  80.                 if (!include_once MODX_BASE_PATH . 'manager/includes/extenders/manager.api.class.inc.php')

    81. 

  81.                     return false;

    82. 

  82.                 $this->manager= new ManagerAPI;

    83. 

  83.                 return true;

    84. 

  84.                 break;

    85. 

  85. 

    86. 

  86.             default :

    87. 

  87.                 return false;

    88. 

  88.         }

    89. 

  89.     }

    90. 

  90. 

    91. 

  91.     function getMicroTime() {

    92. 

  92.         list ($usec, $sec)= explode(' ', microtime());

    93. 

  93.         return ((float) $usec + (float) $sec);

    94. 

  94.     }

    95. 

  95. 

    96. 

  96.     function sendRedirect($url, $count_attempts= 0, $type= '', $responseCode= '') {

    97. 

  97.         if (empty ($url)) {

    98. 

  98.             return false;

    99. 

  99.         } else {

    100. 

  100.             if ($count_attempts == 1) {

    101. 

  101.                 // append the redirect count string to the url

    102. 

  102.                 $currentNumberOfRedirects= isset ($_REQUEST['err']) ? $_REQUEST['err'] : 0;

    103. 

  103.                 if ($currentNumberOfRedirects > 3) {

    104. 

  104.                     $this->messageQuit('Redirection attempt failed - please ensure the document you\'re trying to redirect to exists. <p>Redirection URL: <i>' . $url . '</i></p>');

    105. 

  105.                 } else {

    106. 

  106.                     $currentNumberOfRedirects += 1;

    107. 

  107.                     if (strpos($url, "?") > 0) {

    108. 

  108.                         $url .= "&err=$currentNumberOfRedirects";

    109. 

  109.                     } else {

    110. 

  110.                         $url .= "?err=$currentNumberOfRedirects";

    111. 

  111.                     }

    112. 

  112.                 }

    113. 

  113.             }

    114. 

  114.             if ($type == 'REDIRECT_REFRESH') {

    115. 

  115.                 $header= 'Refresh: 0;URL=' . $url;

    116. 

  116.             }

    117. 

  117.             elseif ($type == 'REDIRECT_META') {

    118. 

  118.                 $header= '<META HTTP-EQUIV="Refresh" CONTENT="0; URL=' . $url . '" />';

    119. 

  119.                 echo $header;

    120. 

  120.                 exit;

    121. 

  121.             }

    122. 

  122.             elseif ($type == 'REDIRECT_HEADER' || empty ($type)) {

    123. 

  123.                 // check if url has /$base_url

    124. 

  124.                 global $base_url, $site_url;

    125. 

  125.                 if (substr($url, 0, strlen($base_url)) == $base_url) {

    126. 

  126.                     // append $site_url to make it work with Location:

    127. 

  127.                     $url= $site_url . substr($url, strlen($base_url));

    128. 

  128.                 }

    129. 

  129.                 if (strpos($url, "\n") === false) {

    130. 

  130.                     $header= 'Location: ' . $url;

    131. 

  131.                 } else {

    132. 

  132.                     $this->messageQuit('No newline allowed in redirect url.');

    133. 

  133.                 }

    134. 

  134.             }

    135. 

  135.             if ($responseCode && (strpos($responseCode, '30') !== false)) {

    136. 

  136.                 header($responseCode);

    137. 

  137.             }

    138. 

  138.             header($header);

    139. 

  139.             exit();

    140. 

  140.         }

    141. 

  141.     }

    142. 

  142. 

    143. 

  143.     function sendForward($id, $responseCode= '') {

    144. 

  144.         if ($this->forwards > 0) {

    145. 

  145.             $this->forwards= $this->forwards - 1;

    146. 

  146.             $this->documentIdentifier= $id;

    147. 

  147.             $this->documentMethod= 'id';

    148. 

  148.             $this->documentObject= $this->getDocumentObject('id', $id);

    149. 

  149.             if ($responseCode) {

    150. 

  150.                 header($responseCode);

    151. 

  151.             }

    152. 

  152.             $this->prepareResponse();

    153. 

  153.             exit();

    154. 

  154.         } else {

    155. 

  155.             header('HTTP/1.0 500 Internal Server Error');

    156. 

  156.             die('<h1>ERROR: Too many forward attempts!</h1><p>The request could not be completed due to too many unsuccessful forward attempts.</p>');

    157. 

  157.         }

    158. 

  158.     }

    159. 

  159. 

    160. 

  160.     function sendErrorPage() {

    161. 

  161.         // invoke OnPageNotFound event

    162. 

  162.         $this->invokeEvent('OnPageNotFound');

    163. 

  163. //        $this->sendRedirect($this->makeUrl($this->config['error_page'], '', '&refurl=' . urlencode($_SERVER['PHP_SELF'] . '?' . $_SERVER['QUERY_STRING'])), 1);

    164. 

  164.         $this->sendForward($this->config['error_page'] ? $this->config['error_page'] : $this->config['site_start'], 'HTTP/1.0 404 Not Found');

    165. 

  165.         exit();

    166. 

  166.     }

    167. 

  167. 

    168. 

  168.     function sendUnauthorizedPage() {

    169. 

  169.         // invoke OnPageUnauthorized event

    170. 

  170.         $_REQUEST['refurl'] = $this->documentIdentifier;

    171. 

  171.         $this->invokeEvent('OnPageUnauthorized');

    172. 

  172.         if ($this->config['unauthorized_page']) {

    173. 

  173.             $unauthorizedPage= $this->config['unauthorized_page'];

    174. 

  174.         } elseif ($this->config['error_page']) {

    175. 

  175.             $unauthorizedPage= $this->config['error_page'];

    176. 

  176.         } else {

    177. 

  177.             $unauthorizedPage= $this->config['site_start'];

    178. 

  178.         }

    179. 

  179.         $this->sendForward($unauthorizedPage, 'HTTP/1.1 401 Unauthorized');

    180. 

  180.         exit();

    181. 

  181.     }

    182. 

  182. 

    183. 

  183.     // function to connect to the database

    184. 

  184.     // - deprecated use $modx->db->connect()

    185. 

  185.     function dbConnect() {

    186. 

  186.         $this->db->connect();

    187. 

  187.         $this->rs= $this->db->conn; // for compatibility

    188. 

  188.     }

    189. 

  189. 

    190. 

  190.     // function to query the database

    191. 

  191.     // - deprecated use $modx->db->query()

    192. 

  192.     function dbQuery($sql) {

    193. 

  193.         return $this->db->query($sql);

    194. 

  194.     }

    195. 

  195. 

    196. 

  196.     // function to count the number of rows in a record set

    197. 

  197.     function recordCount($rs) {

    198. 

  198.         return $this->db->getRecordCount($rs);

    199. 

  199.     }

    200. 

  200. 

    201. 

  201.     // - deprecated, use $modx->db->getRow()

    202. 

  202.     function fetchRow($rs, $mode= 'assoc') {

    203. 

  203.         return $this->db->getRow($rs, $mode);

    204. 

  204.     }

    205. 

  205. 

    206. 

  206.     // - deprecated, use $modx->db->getAffectedRows()

    207. 

  207.     function affectedRows($rs) {

    208. 

  208.         return $this->db->getAffectedRows($rs);

    209. 

  209.     }

    210. 

  210. 

    211. 

  211.     // - deprecated, use $modx->db->getInsertId()

    212. 

  212.     function insertId($rs) {

    213. 

  213.         return $this->db->getInsertId($rs);

    214. 

  214.     }

    215. 

  215. 

    216. 

  216.     // function to close a database connection

    217. 

  217.     // - deprecated, use $modx->db->disconnect()

    218. 

  218.     function dbClose() {

    219. 

  219.         $this->db->disconnect();

    220. 

  220.     }

    221. 

  221. 

    222. 

  222.     function getSettings() {

    223. 

  223.         if (!is_array($this->config) || empty ($this->config)) {

    224. 

  224.             if ($included= file_exists(MODX_BASE_PATH . 'assets/cache/siteCache.idx.php')) {

    225. 

  225.                 $included= include_once (MODX_BASE_PATH . 'assets/cache/siteCache.idx.php');

    226. 

  226.             }

    227. 

  227.             if (!$included || !is_array($this->config) || empty ($this->config)) {

    228. 

  228.                 include_once MODX_BASE_PATH . "/manager/processors/cache_sync.class.processor.php";

    229. 

  229.                 $cache = new synccache();

    230. 

  230.                 $cache->setCachepath(MODX_BASE_PATH . "/assets/cache/");

    231. 

  231.                 $cache->setReport(false);

    232. 

  232.                 $rebuilt = $cache->buildCache($this);

    233. 

  233.                 $included = false;

    234. 

  234.                 if($rebuilt && $included= file_exists(MODX_BASE_PATH . 'assets/cache/siteCache.idx.php')) {

    235. 

  235.                     $included= include MODX_BASE_PATH . 'assets/cache/siteCache.idx.php';

    236. 

  236.                 }

    237. 

  237.                 if(!$included) {

    238. 

  238.                     $result= $this->db->query('SELECT setting_name, setting_value FROM ' . $this->getFullTableName('system_settings'));

    239. 

  239.                     while ($row= $this->db->getRow($result, 'both')) {

    240. 

  240.                         $this->config[$row[0]]= $row[1];

    241. 

  241.                     }

    242. 

  242.                 }

    243. 

  243.             }

    244. 

  244. 

    245. 

  245.             // added for backwards compatibility - garry FS#104

    246. 

  246.             $this->config['etomite_charset'] = & $this->config['modx_charset'];

    247. 

  247. 

    248. 

  248.             // store base_url and base_path inside config array

    249. 

  249.             $this->config['base_url']= MODX_BASE_URL;

    250. 

  250.             $this->config['base_path']= MODX_BASE_PATH;

    251. 

  251.             $this->config['site_url']= MODX_SITE_URL;

    252. 

  252. 

    253. 

  253.             // load user setting if user is logged in

    254. 

  254.             $usrSettings= array ();

    255. 

  255.             if ($id= $this->getLoginUserID()) {

    256. 

  256.                 $usrType= $this->getLoginUserType();

    257. 

  257.                 if (isset ($usrType) && $usrType == 'manager')

    258. 

  258.                     $usrType= 'mgr';

    259. 

  259. 

    260. 

  260.                 if ($usrType == 'mgr' && $this->isBackend()) {

    261. 

  261.                     // invoke the OnBeforeManagerPageInit event, only if in backend

    262. 

  262.                     $this->invokeEvent("OnBeforeManagerPageInit");

    263. 

  263.                 }

    264. 

  264. 

    265. 

  265.                 if (isset ($_SESSION[$usrType . 'UsrConfigSet'])) {

    266. 

  266.                     $usrSettings= & $_SESSION[$usrType . 'UsrConfigSet'];

    267. 

  267.                 } else {

    268. 

  268.                     if ($usrType == 'web')

    269. 

  269.                         $query= $this->getFullTableName('web_user_settings') . ' WHERE webuser=\'' . $id . '\'';

    270. 

  270.                     else

    271. 

  271.                         $query= $this->getFullTableName('user_settings') . ' WHERE user=\'' . $id . '\'';

    272. 

  272.                     $result= $this->db->query('SELECT setting_name, setting_value FROM ' . $query);

    273. 

  273.                     while ($row= $this->db->getRow($result, 'both'))

    274. 

  274.                         $usrSettings[$row[0]]= $row[1];

    275. 

  275.                     if (isset ($usrType))

    276. 

  276.                         $_SESSION[$usrType . 'UsrConfigSet']= $usrSettings; // store user settings in session

    277. 

  277.                 }

    278. 

  278.             }

    279. 

  279.             if ($this->isFrontend() && $mgrid= $this->getLoginUserID('mgr')) {

    280. 

  280.                 $musrSettings= array ();

    281. 

  281.                 if (isset ($_SESSION['mgrUsrConfigSet'])) {

    282. 

  282.                     $musrSettings= & $_SESSION['mgrUsrConfigSet'];

    283. 

  283.                 } else {

    284. 

  284.                     $query= $this->getFullTableName('user_settings') . ' WHERE user=\'' . $mgrid . '\'';

    285. 

  285.                     if ($result= $this->db->query('SELECT setting_name, setting_value FROM ' . $query)) {

    286. 

  286.                         while ($row= $this->db->getRow($result, 'both')) {

    287. 

  287.                             $usrSettings[$row[0]]= $row[1];

    288. 

  288.                         }

    289. 

  289.                         $_SESSION['mgrUsrConfigSet']= $musrSettings; // store user settings in session

    290. 

  290.                     }

    291. 

  291.                 }

    292. 

  292.                 if (!empty ($musrSettings)) {

    293. 

  293.                     $usrSettings= array_merge($musrSettings, $usrSettings);

    294. 

  294.                 }

    295. 

  295.             }

    296. 

  296.             $this->config= array_merge($this->config, $usrSettings);

    297. 

  297.         }

    298. 

  298.     }

    299. 

  299. 

    300. 

  300.     function getDocumentMethod() {

    301. 

  301.         // function to test the query and find the retrieval method

    302. 

  302.         if (isset ($_REQUEST['q'])) {

    303. 

  303.             return "alias";

    304. 

  304.         }

    305. 

  305.         elseif (isset ($_REQUEST['id'])) {

    306. 

  306.             return "id";

    307. 

  307.         } else {

    308. 

  308.             return "none";

    309. 

  309.         }

    310. 

  310.     }

    311. 

  311. 

    312. 

  312.     function getDocumentIdentifier($method) {

    313. 

  313.         // function to test the query and find the retrieval method

    314. 

  314.         $docIdentifier= $this->config['site_start'];

    315. 

  315.         switch ($method) {

    316. 

  316.             case 'alias' :

    317. 

  317.                 $docIdentifier= $this->db->escape($_REQUEST['q']);

    318. 

  318.                 break;

    319. 

  319.             case 'id' :

    320. 

  320.                 if (!is_numeric($_REQUEST['id'])) {

    321. 

  321.                     $this->sendErrorPage();

    322. 

  322.                 } else {

    323. 

  323.                     $docIdentifier= intval($_REQUEST['id']);

    324. 

  324.                 }

    325. 

  325.                 break;

    326. 

  326.         }

    327. 

  327.         return $docIdentifier;

    328. 

  328.     }

    329. 

  329. 

    330. 

  330.     // check for manager login session

    331. 

  331.     function checkSession() {

    332. 

  332.         if (isset ($_SESSION['mgrValidated'])) {

    333. 

  333.             return true;

    334. 

  334.         } else {

    335. 

  335.             return false;

    336. 

  336.         }

    337. 

  337.     }

    338. 

  338. 

    339. 

  339.     function checkPreview() {

    340. 

  340.         if ($this->checkSession() == true) {

    341. 

  341.             if (isset ($_REQUEST['z']) && $_REQUEST['z'] == 'manprev') {

    342. 

  342.                 return true;

    343. 

  343.             } else {

    344. 

  344.                 return false;

    345. 

  345.             }

    346. 

  346.         } else {

    347. 

  347.             return false;

    348. 

  348.         }

    349. 

  349.     }

    350. 

  350. 

    351. 

  351.     // check if site is offline

    352. 

  352.     function checkSiteStatus() {

    353. 

  353.         $siteStatus= $this->config['site_status'];

    354. 

  354.         if ($siteStatus == 1) {

    355. 

  355.             // site online

    356. 

  356.             return true;

    357. 

  357.         }

    358. 

  358.         elseif ($siteStatus == 0 && $this->checkSession()) {

    359. 

  359.             // site offline but launched via the manager

    360. 

  360.             return true;

    361. 

  361.         } else {

    362. 

  362.             // site is offline

    363. 

  363.             return false;

    364. 

  364.         }

    365. 

  365.     }

    366. 

  366. 

    367. 

  367.     function cleanDocumentIdentifier($qOrig) {

    368. 

  368.         (!empty($qOrig)) or $qOrig = $this->config['site_start'];

    369. 

  369.         $q= $qOrig;

    370. 

  370.         /* First remove any / before or after */

    371. 

  371.         if ($q[strlen($q) - 1] == '/')

    372. 

  372.             $q= substr($q, 0, -1);

    373. 

  373.         if ($q[0] == '/')

    374. 

  374.             $q= substr($q, 1);

    375. 

  375.         /* Save path if any */

    376. 

  376.         /* FS#476 and FS#308: only return virtualDir if friendly paths are enabled */

    377. 

  377.         if ($this->config['use_alias_path'] == 1) {

    378. 

  378.             $this->virtualDir= dirname($q);

    379. 

  379.             $this->virtualDir= ($this->virtualDir == '.' ? '' : $this->virtualDir);

    380. 

  380.             $q= basename($q);

    381. 

  381.         } else {

    382. 

  382.             $this->virtualDir= '';

    383. 

  383.         }

    384. 

  384.         $q= str_replace($this->config['friendly_url_prefix'], "", $q);

    385. 

  385.         $q= str_replace($this->config['friendly_url_suffix'], "", $q);

    386. 

  386.         if (is_numeric($q) && !$this->documentListing[$q]) { /* we got an ID returned, check to make sure it's not an alias */

    387. 

  387.             /* FS#476 and FS#308: check that id is valid in terms of virtualDir structure */

    388. 

  388.             if ($this->config['use_alias_path'] == 1) {

    389. 

  389.                 if ((($this->virtualDir != '' && !$this->documentListing[$this->virtualDir . '/' . $q]) || ($this->virtualDir == '' && !$this->documentListing[$q])) && (($this->virtualDir != '' && in_array($q, $this->getChildIds($this->documentListing[$this->virtualDir], 1))) || ($this->virtualDir == '' && in_array($q, $this->getChildIds(0, 1))))) {

    390. 

  390.                     $this->documentMethod= 'id';

    391. 

  391.                     return $q;

    392. 

  392.                 } else { /* not a valid id in terms of virtualDir, treat as alias */

    393. 

  393.                     $this->documentMethod= 'alias';

    394. 

  394.                     return $q;

    395. 

  395.                 }

    396. 

  396.             } else {

    397. 

  397.                 $this->documentMethod= 'id';

    398. 

  398.                 return $q;

    399. 

  399.             }

    400. 

  400.         } else { /* we didn't get an ID back, so instead we assume it's an alias */

    401. 

  401.             if ($this->config['friendly_alias_urls'] != 1) {

    402. 

  402.                 $q= $qOrig;

    403. 

  403.             }

    404. 

  404.             $this->documentMethod= 'alias';

    405. 

  405.             return $q;

    406. 

  406.         }

    407. 

  407.     }

    408. 

  408. 

    409. 

  409.     function checkCache($id) {

    410. 

  410.         $cacheFile= "assets/cache/docid_" . $id . ".pageCache.php";

    411. 

  411.         if (file_exists($cacheFile)) {

    412. 

  412.             $this->documentGenerated= 0;

    413. 

  413.             $flContent= implode("", file($cacheFile));

    414. 

  414.             $flContent= substr($flContent, 37); // remove php header

    415. 

  415.             $a= explode("<!--__MODxCacheSpliter__-->", $flContent, 2);

    416. 

  416.             if (count($a) == 1)

    417. 

  417.                 return $a[0]; // return only document content

    418. 

  418.             else {

    419. 

  419.                 $docObj= unserialize($a[0]); // rebuild document object

    420. 

  420.                 // check page security

    421. 

  421.                 if ($docObj['privateweb'] && isset ($docObj['__MODxDocGroups__'])) {

    422. 

  422.                     $pass= false;

    423. 

  423.                     $usrGrps= $this->getUserDocGroups();

    424. 

  424.                     $docGrps= explode(",", $docObj['__MODxDocGroups__']);

    425. 

  425.                     // check is user has access to doc groups

    426. 

  426.                     if (is_array($usrGrps)) {

    427. 

  427.                         foreach ($usrGrps as $k => $v)

    428. 

  428.                             if (in_array($v, $docGrps)) {

    429. 

  429.                                 $pass= true;

    430. 

  430.                                 break;

    431. 

  431.                             }

    432. 

  432.                     }

    433. 

  433.                     // diplay error pages if user has no access to cached doc

    434. 

  434.                     if (!$pass) {

    435. 

  435.                         if ($this->config['unauthorized_page']) {

    436. 

  436.                             // check if file is not public

    437. 

  437.                             $tbldg= $this->getFullTableName("document_groups");

    438. 

  438.                             $secrs= $this->db->query("SELECT id FROM $tbldg WHERE document = '" . $id . "' LIMIT 1;");

    439. 

  439.                             if ($secrs)

    440. 

  440.                                 $seclimit= mysql_num_rows($secrs);

    441. 

  441.                         }

    442. 

  442.                         if ($seclimit > 0) {

    443. 

  443.                             // match found but not publicly accessible, send the visitor to the unauthorized_page

    444. 

  444.                             $this->sendUnauthorizedPage();

    445. 

  445.                             exit; // stop here

    446. 

  446.                         } else {

    447. 

  447.                             // no match found, send the visitor to the error_page

    448. 

  448.                             $this->sendErrorPage();

    449. 

  449.                             exit; // stop here

    450. 

  450.                         }

    451. 

  451.                     }

    452. 

  452.                 }

    453. 

  453. 				// Grab the Scripts

    454. 

  454. 				if (isset($docObj['__MODxSJScripts__'])) $this->sjscripts = $docObj['__MODxSJScripts__'];

    455. 

  455. 				if (isset($docObj['__MODxJScripts__']))  $this->jscripts = $docObj['__MODxJScripts__'];

    456. 

  456. 

    457. 

  457. 				// Remove intermediate variables

    458. 

  458.                 unset($docObj['__MODxDocGroups__'], $docObj['__MODxSJScripts__'], $docObj['__MODxJScripts__']);

    459. 

  459. 

    460. 

  460.                 $this->documentObject= $docObj;

    461. 

  461.                 return $a[1]; // return document content

    462. 

  462.             }

    463. 

  463.         } else {

    464. 

  464.             $this->documentGenerated= 1;

    465. 

  465.             return "";

    466. 

  466.         }

    467. 

  467.     }

    468. 

  468. 

    469. 

  469.     function outputContent($noEvent= false) {

    470. 

  470. 

    471. 

  471.         $this->documentOutput= $this->documentContent;

    472. 

  472. 

    473. 

  473.         if ($this->documentGenerated == 1 && $this->documentObject['cacheable'] == 1 && $this->documentObject['type'] == 'document' && $this->documentObject['published'] == 1) {

    474. 

  474.     		if (!empty($this->sjscripts)) $this->documentObject['__MODxSJScripts__'] = $this->sjscripts;

    475. 

  475.     		if (!empty($this->jscripts)) $this->documentObject['__MODxJScripts__'] = $this->jscripts;

    476. 

  476.         }

    477. 

  477. 

    478. 

  478.         // check for non-cached snippet output

    479. 

  479.         if (strpos($this->documentOutput, '[!') > -1) {

    480. 

  480.             $this->documentOutput= str_replace('[!', '[[', $this->documentOutput);

    481. 

  481.             $this->documentOutput= str_replace('!]', ']]', $this->documentOutput);

    482. 

  482. 

    483. 

  483.             // Parse document source

    484. 

  484.             $this->documentOutput= $this->parseDocumentSource($this->documentOutput);

    485. 

  485.     	}

    486. 

  486. 

    487. 

  487.     	// Moved from prepareResponse() by sirlancelot

    488. 

  488.     	// Insert Startup jscripts & CSS scripts into template - template must have a <head> tag

    489. 

  489.     	if ($js= $this->getRegisteredClientStartupScripts()) {

    490. 

  490.     		// change to just before closing </head>

    491. 

  491.     		// $this->documentContent = preg_replace("/(<head[^>]*>)/i", "\\1\n".$js, $this->documentContent);

    492. 

  492.     		$this->documentOutput= preg_replace("/(<\/head>)/i", $js . "\n\\1", $this->documentOutput);

    493. 

  493.     	}

    494. 

  494. 

    495. 

  495.     	// Insert jscripts & html block into template - template must have a </body> tag

    496. 

  496.     	if ($js= $this->getRegisteredClientScripts()) {

    497. 

  497.     		$this->documentOutput= preg_replace("/(<\/body>)/i", $js . "\n\\1", $this->documentOutput);

    498. 

  498.     	}

    499. 

  499.     	// End fix by sirlancelot

    500. 

  500. 

    501. 

  501.         // remove all unused placeholders

    502. 

  502.         if (strpos($this->documentOutput, '[+') > -1) {

    503. 

  503.             $matches= array ();

    504. 

  504.             preg_match_all('~\[\+(.*?)\+\]~', $this->documentOutput, $matches);

    505. 

  505.             if ($matches[0])

    506. 

  506.                 $this->documentOutput= str_replace($matches[0], '', $this->documentOutput);

    507. 

  507.         }

    508. 

  508. 

    509. 

  509.         $this->documentOutput= $this->rewriteUrls($this->documentOutput);

    510. 

  510. 

    511. 

  511.         // send out content-type and content-disposition headers

    512. 

  512.         if (IN_PARSER_MODE == "true") {

    513. 

  513.             $type= !empty ($this->contentTypes[$this->documentIdentifier]) ? $this->contentTypes[$this->documentIdentifier] : "text/html";

    514. 

  514.             header('Content-Type: ' . $type . '; charset=' . $this->config['modx_charset']);

    515. 

  515. //            if (($this->documentIdentifier == $this->config['error_page']) || $redirect_error)

    516. 

  516. //                header('HTTP/1.0 404 Not Found');

    517. 

  517.             if (!$this->checkPreview() && $this->documentObject['content_dispo'] == 1) {

    518. 

  518.                 if ($this->documentObject['alias'])

    519. 

  519.                     $name= $this->documentObject['alias'];

    520. 

  520.                 else {

    521. 

  521.                     // strip title of special characters

    522. 

  522.                     $name= $this->documentObject['pagetitle'];

    523. 

  523.                     $name= strip_tags($name);

    524. 

  524.                     $name= strtolower($name);

    525. 

  525.                     $name= preg_replace('/&.+?;/', '', $name); // kill entities

    526. 

  526.                     $name= preg_replace('/[^\.%a-z0-9 _-]/', '', $name);

    527. 

  527.                     $name= preg_replace('/\s+/', '-', $name);

    528. 

  528.                     $name= preg_replace('|-+|', '-', $name);

    529. 

  529.                     $name= trim($name, '-');

    530. 

  530.                 }

    531. 

  531.                 $header= 'Content-Disposition: attachment; filename=' . $name;

    532. 

  532.                 header($header);

    533. 

  533.             }

    534. 

  534.         }

    535. 

  535. 

    536. 

  536.         $totalTime= ($this->getMicroTime() - $this->tstart);

    537. 

  537.         $queryTime= $this->queryTime;

    538. 

  538.         $phpTime= $totalTime - $queryTime;

    539. 

  539. 

    540. 

  540.         $queryTime= sprintf("%2.4f s", $queryTime);

    541. 

  541.         $totalTime= sprintf("%2.4f s", $totalTime);

    542. 

  542.         $phpTime= sprintf("%2.4f s", $phpTime);

    543. 

  543.         $source= $this->documentGenerated == 1 ? "database" : "cache";

    544. 

  544.         $queries= isset ($this->executedQueries) ? $this->executedQueries : 0;

    545. 

  545. 

    546. 

  546.         $out =& $this->documentOutput;

    547. 

  547.         if ($this->dumpSQL) {

    548. 

  548.             $out .= $this->queryCode;

    549. 

  549.         }

    550. 

  550.         $out= str_replace("[^q^]", $queries, $out);

    551. 

  551.         $out= str_replace("[^qt^]", $queryTime, $out);

    552. 

  552.         $out= str_replace("[^p^]", $phpTime, $out);

    553. 

  553.         $out= str_replace("[^t^]", $totalTime, $out);

    554. 

  554.         $out= str_replace("[^s^]", $source, $out);

    555. 

  555.         //$this->documentOutput= $out;

    556. 

  556. 

    557. 

  557.         // invoke OnWebPagePrerender event

    558. 

  558.         if (!$noEvent) {

    559. 

  559.             $this->invokeEvent("OnWebPagePrerender");

    560. 

  560.         }

    561. 

  561. 

    562. 

  562.         echo $this->documentOutput;

    563. 

  563.         ob_end_flush();

    564. 

  564.     }

    565. 

  565. 

    566. 

  566.     function checkPublishStatus() {

    567. 

  567.         $cacheRefreshTime= 0;

    568. 

  568.         @include $this->config["base_path"] . "assets/cache/sitePublishing.idx.php";

    569. 

  569.         $timeNow= time() + $this->config['server_offset_time'];

    570. 

  570.         if ($cacheRefreshTime <= $timeNow && $cacheRefreshTime != 0) {

    571. 

  571.             // now, check for documents that need publishing

    572. 

  572.             $sql = "UPDATE ".$this->getFullTableName("site_content")." SET published=1, publishedon=".time()." WHERE ".$this->getFullTableName("site_content").".pub_date <= $timeNow AND ".$this->getFullTableName("site_content").".pub_date!=0 AND published=0";

    573. 

  573.             if (@ !$result= $this->db->query($sql)) {

    574. 

  574.                 $this->messageQuit("Execution of a query to the database failed", $sql);

    575. 

  575.             }

    576. 

  576. 

    577. 

  577.             // now, check for documents that need un-publishing

    578. 

  578.             $sql= "UPDATE " . $this->getFullTableName("site_content") . " SET published=0, publishedon=0 WHERE " . $this->getFullTableName("site_content") . ".unpub_date <= $timeNow AND " . $this->getFullTableName("site_content") . ".unpub_date!=0 AND published=1";

    579. 

  579.             if (@ !$result= $this->db->query($sql)) {

    580. 

  580.                 $this->messageQuit("Execution of a query to the database failed", $sql);

    581. 

  581.             }

    582. 

  582. 

    583. 

  583.             // clear the cache

    584. 

  584.             $basepath= $this->config["base_path"] . "assets/cache/";

    585. 

  585.             if ($handle= opendir($basepath)) {

    586. 

  586.                 $filesincache= 0;

    587. 

  587.                 $deletedfilesincache= 0;

    588. 

  588.                 while (false !== ($file= readdir($handle))) {

    589. 

  589.                     if ($file != "." && $file != "..") {

    590. 

  590.                         $filesincache += 1;

    591. 

  591.                         if (preg_match("/\.pageCache/", $file)) {

    592. 

  592.                             $deletedfilesincache += 1;

    593. 

  593.                             while (!unlink($basepath . "/" . $file));

    594. 

  594.                         }

    595. 

  595.                     }

    596. 

  596.                 }

    597. 

  597.                 closedir($handle);

    598. 

  598.             }

    599. 

  599. 

    600. 

  600.             // update publish time file

    601. 

  601.             $timesArr= array ();

    602. 

  602.             $sql= "SELECT MIN(pub_date) AS minpub FROM " . $this->getFullTableName("site_content") . " WHERE pub_date>$timeNow";

    603. 

  603.             if (@ !$result= $this->db->query($sql)) {

    604. 

  604.                 $this->messageQuit("Failed to find publishing timestamps", $sql);

    605. 

  605.             }

    606. 

  606.             $tmpRow= $this->db->getRow($result);

    607. 

  607.             $minpub= $tmpRow['minpub'];

    608. 

  608.             if ($minpub != NULL) {

    609. 

  609.                 $timesArr[]= $minpub;

    610. 

  610.             }

    611. 

  611. 

    612. 

  612.             $sql= "SELECT MIN(unpub_date) AS minunpub FROM " . $this->getFullTableName("site_content") . " WHERE unpub_date>$timeNow";

    613. 

  613.             if (@ !$result= $this->db->query($sql)) {

    614. 

  614.                 $this->messageQuit("Failed to find publishing timestamps", $sql);

    615. 

  615.             }

    616. 

  616.             $tmpRow= $this->db->getRow($result);

    617. 

  617.             $minunpub= $tmpRow['minunpub'];

    618. 

  618.             if ($minunpub != NULL) {

    619. 

  619.                 $timesArr[]= $minunpub;

    620. 

  620.             }

    621. 

  621. 

    622. 

  622.             if (count($timesArr) > 0) {

    623. 

  623.                 $nextevent= min($timesArr);

    624. 

  624.             } else {

    625. 

  625.                 $nextevent= 0;

    626. 

  626.             }

    627. 

  627. 

    628. 

  628.             $basepath= $this->config["base_path"] . "assets/cache";

    629. 

  629.             $fp= @ fopen($basepath . "/sitePublishing.idx.php", "wb");

    630. 

  630.             if ($fp) {

    631. 

  631.                 @ flock($fp, LOCK_EX);

    632. 

  632.                 @ fwrite($fp, "<?php \$cacheRefreshTime=$nextevent; ?>");

    633. 

  633.                 @ flock($fp, LOCK_UN);

    634. 

  634.                 @ fclose($fp);

    635. 

  635.             }

    636. 

  636.         }

    637. 

  637.     }

    638. 

  638. 

    639. 

  639.     function postProcess() {

    640. 

  640.         // if the current document was generated, cache it!

    641. 

  641.         if ($this->documentGenerated == 1 && $this->documentObject['cacheable'] == 1 && $this->documentObject['type'] == 'document' && $this->documentObject['published'] == 1) {

    642. 

  642.             $basepath= $this->config["base_path"] . "assets/cache";

    643. 

  643.             // invoke OnBeforeSaveWebPageCache event

    644. 

  644.             $this->invokeEvent("OnBeforeSaveWebPageCache");

    645. 

  645.             if ($fp= @ fopen($basepath . "/docid_" . $this->documentIdentifier . ".pageCache.php", "w")) {

    646. 

  646.                 // get and store document groups inside document object. Document groups will be used to check security on cache pages

    647. 

  647.                 $sql= "SELECT document_group FROM " . $this->getFullTableName("document_groups") . " WHERE document='" . $this->documentIdentifier . "'";

    648. 

  648.                 $docGroups= $this->db->getColumn("document_group", $sql);

    649. 

  649. 

    650. 

  650. 				// Attach Document Groups and Scripts

    651. 

  651. 				if (is_array($docGroups)) $this->documentObject['__MODxDocGroups__'] = implode(",", $docGroups);

    652. 

  652. 

    653. 

  653.                 $docObjSerial= serialize($this->documentObject);

    654. 

  654.                 $cacheContent= $docObjSerial . "<!--__MODxCacheSpliter__-->" . $this->documentContent;

    655. 

  655.                 fputs($fp, "<?php die('Unauthorized access.'); ?>$cacheContent");

    656. 

  656.                 fclose($fp);

    657. 

  657.             }

    658. 

  658.         }

    659. 

  659. 

    660. 

  660.         // Useful for example to external page counters/stats packages

    661. 

  661.         $this->invokeEvent('OnWebPageComplete');

    662. 

  662. 

    663. 

  663.         // end post processing

    664. 

  664.     }

    665. 

  665. 

    666. 

  666.     function mergeDocumentMETATags($template) {

    667. 

  667.         if ($this->documentObject['haskeywords'] == 1) {

    668. 

  668.             // insert keywords

    669. 

  669.             $keywords = $this->getKeywords();

    670. 

  670.             if (is_array($keywords) && count($keywords) > 0) {

    671. 

  671. 	            $keywords = implode(", ", $keywords);

    672. 

  672. 	            $metas= "\t<meta name=\"keywords\" content=\"$keywords\" />\n";

    673. 

  673.             }

    674. 

  674. 

    675. 

  675. 	    // Don't process when cached

    676. 

  676. 	    $this->documentObject['haskeywords'] = '0';

    677. 

  677.         }

    678. 

  678.         if ($this->documentObject['hasmetatags'] == 1) {

    679. 

  679.             // insert meta tags

    680. 

  680.             $tags= $this->getMETATags();

    681. 

  681.             foreach ($tags as $n => $col) {

    682. 

  682.                 $tag= strtolower($col['tag']);

    683. 

  683.                 $tagvalue= $col['tagvalue'];

    684. 

  684.                 $tagstyle= $col['http_equiv'] ? 'http-equiv' : 'name';

    685. 

  685.                 $metas .= "\t<meta $tagstyle=\"$tag\" content=\"$tagvalue\" />\n";

    686. 

  686.             }

    687. 

  687. 

    688. 

  688. 	    // Don't process when cached

    689. 

  689. 	    $this->documentObject['hasmetatags'] = '0';

    690. 

  690.         }

    691. 

  691. 	if ($metas) $template = preg_replace("/(<head>)/i", "\\1\n\t" . trim($metas), $template);

    692. 

  692.         return $template;

    693. 

  693.     }

    694. 

  694. 

    695. 

  695.     // mod by Raymond

    696. 

  696.     function mergeDocumentContent($template) {

    697. 

  697.         $replace= array ();

    698. 

  698.         preg_match_all('~\[\*(.*?)\*\]~', $template, $matches);

    699. 

  699.         $variableCount= count($matches[1]);

    700. 

  700.         $basepath= $this->config["base_path"] . "manager/includes";

    701. 

  701.         for ($i= 0; $i < $variableCount; $i++) {

    702. 

  702.             $key= $matches[1][$i];

    703. 

  703.             $key= substr($key, 0, 1) == '#' ? substr($key, 1) : $key; // remove # for QuickEdit format

    704. 

  704.             $value= $this->documentObject[$key];

    705. 

  705.             if (is_array($value)) {

    706. 

  706.                 include_once $basepath . "/tmplvars.format.inc.php";

    707. 

  707.                 include_once $basepath . "/tmplvars.commands.inc.php";

    708. 

  708.                 $w= "100%";

    709. 

  709.                 $h= "300";

    710. 

  710.                 $value= getTVDisplayFormat($value[0], $value[1], $value[2], $value[3], $value[4]);

    711. 

  711.             }

    712. 

  712.             $replace[$i]= $value;

    713. 

  713.         }

    714. 

  714.         $template= str_replace($matches[0], $replace, $template);

    715. 

  715. 

    716. 

  716.         return $template;

    717. 

  717.     }

    718. 

  718. 

    719. 

  719.     function mergeSettingsContent($template) {

    720. 

  720.         $replace= array ();

    721. 

  721.         $matches= array ();

    722. 

  722.         if (preg_match_all('~\[\(([a-z\_]*?)\)\]~', $template, $matches)) {

    723. 

  723.             $settingsCount= count($matches[1]);

    724. 

  724.             for ($i= 0; $i < $settingsCount; $i++) {

    725. 

  725.                 if (array_key_exists($matches[1][$i], $this->config))

    726. 

  726.                     $replace[$i]= $this->config[$matches[1][$i]];

    727. 

  727.             }

    728. 

  728. 

    729. 

  729.             $template= str_replace($matches[0], $replace, $template);

    730. 

  730.         }

    731. 

  731.         return $template;

    732. 

  732.     }

    733. 

  733. 

    734. 

  734.     function mergeChunkContent($content) {

    735. 

  735.         $replace= array ();

    736. 

  736.         $matches= array ();

    737. 

  737.         if (preg_match_all('~{{(.*?)}}~', $content, $matches)) {

    738. 

  738.             $settingsCount= count($matches[1]);

    739. 

  739.             for ($i= 0; $i < $settingsCount; $i++) {

    740. 

  740.                 if (isset ($this->chunkCache[$matches[1][$i]])) {

    741. 

  741.                     $replace[$i]= $this->chunkCache[$matches[1][$i]];

    742. 

  742.                 } else {

    743. 

  743.                     $sql= "SELECT `snippet` FROM " . $this->getFullTableName("site_htmlsnippets") . " WHERE " . $this->getFullTableName("site_htmlsnippets") . ".`name`='" . $this->db->escape($matches[1][$i]) . "';";

    744. 

  744.                     $result= $this->db->query($sql);

    745. 

  745.                     $limit= $this->db->getRecordCount($result);

    746. 

  746.                     if ($limit < 1) {

    747. 

  747.                         $this->chunkCache[$matches[1][$i]]= "";

    748. 

  748.                         $replace[$i]= "";

    749. 

  749.                     } else {

    750. 

  750.                         $row= $this->db->getRow($result);

    751. 

  751.                         $this->chunkCache[$matches[1][$i]]= $row['snippet'];

    752. 

  752.                         $replace[$i]= $row['snippet'];

    753. 

  753.                     }

    754. 

  754.                 }

    755. 

  755.             }

    756. 

  756.             $content= str_replace($matches[0], $replace, $content);

    757. 

  757.         }

    758. 

  758.         return $content;

    759. 

  759.     }

    760. 

  760. 

    761. 

  761.     // Added by Raymond

    762. 

  762.     function mergePlaceholderContent($content) {

    763. 

  763.         $replace= array ();

    764. 

  764.         $matches= array ();

    765. 

  765.         if (preg_match_all('~\[\+(.*?)\+\]~', $content, $matches)) {

    766. 

  766.             $cnt= count($matches[1]);

    767. 

  767.             for ($i= 0; $i < $cnt; $i++) {

    768. 

  768.                 $v= '';

    769. 

  769.                 $key= $matches[1][$i];

    770. 

  770.                 if (is_array($this->placeholders) && array_key_exists($key, $this->placeholders))

    771. 

  771.                     $v= $this->placeholders[$key];

    772. 

  772.                 if ($v === '')

    773. 

  773.                     unset ($matches[0][$i]); // here we'll leave empty placeholders for last.

    774. 

  774.                 else

    775. 

  775.                     $replace[$i]= $v;

    776. 

  776.             }

    777. 

  777.             $content= str_replace($matches[0], $replace, $content);

    778. 

  778.         }

    779. 

  779.         return $content;

    780. 

  780.     }

    781. 

  781. 

    782. 

  782.     // evalPlugin

    783. 

  783.     function evalPlugin($pluginCode, $params) {

    784. 

  784.         $etomite= $modx= & $this;

    785. 

  785.         $modx->event->params= & $params; // store params inside event object

    786. 

  786.         if (is_array($params)) {

    787. 

  787.             extract($params, EXTR_SKIP);

    788. 

  788.         }

    789. 

  789.         ob_start();

    790. 

  790.         eval ($pluginCode);

    791. 

  791.         $msg= ob_get_contents();

    792. 

  792.         ob_end_clean();

    793. 

  793.         if ($msg && isset ($php_errormsg)) {

    794. 

  794.             if (!strpos($php_errormsg, 'Deprecated')) { // ignore php5 strict errors

    795. 

  795.                 // log error

    796. 

  796.                 $this->logEvent(1, 3, "<b>$php_errormsg</b><br /><br /> $msg", $this->Event->activePlugin . " - Plugin");

    797. 

  797.                 if ($this->isBackend())

    798. 

  798.                     $this->Event->alert("An error occurred while loading. Please see the event log for more information.<p />$msg");

    799. 

  799.             }

    800. 

  800.         } else {

    801. 

  801.             echo $msg;

    802. 

  802.         }

    803. 

  803.         unset ($modx->event->params);

    804. 

  804.     }

    805. 

  805. 

    806. 

  806.     function evalSnippet($snippet, $params) {

    807. 

  807.         $etomite= $modx= & $this;

    808. 

  808. 

    809. 

  809.         $modx->event->params= & $params; // store params inside event object

    810. 

  810.         if (is_array($params)) {

    811. 

  811.             extract($params, EXTR_SKIP);

    812. 

  812.         }

    813. 

  813.         ob_start();

    814. 

  814.         $snip= eval ($snippet);

    815. 

  815.         $msg= ob_get_contents();

    816. 

  816.         ob_end_clean();

    817. 

  817.         if ($msg && isset ($php_errormsg)) {

    818. 

  818.             if (!strpos($php_errormsg, 'Deprecated')) { // ignore php5 strict errors

    819. 

  819.                 // log error

    820. 

  820.                 $this->logEvent(1, 3, "<b>$php_errormsg</b><br /><br /> $msg", $this->currentSnippet . " - Snippet");

    821. 

  821.                 if ($this->isBackend())

    822. 

  822.                     $this->Event->alert("An error occurred while loading. Please see the event log for more information<p />$msg");

    823. 

  823.             }

    824. 

  824.         }

    825. 

  825.         unset ($modx->event->params);

    826. 

  826.         return $msg . $snip;

    827. 

  827.     }

    828. 

  828. 

    829. 

  829.     function evalSnippets($documentSource) {

    830. 

  830.         preg_match_all('~\[\[(.*?)\]\]~ms', $documentSource, $matches);

    831. 

  831. 

    832. 

  832.         $etomite= & $this;

    833. 

  833. 

    834. 

  834.         if ($matchCount= count($matches[1])) {

    835. 

  835.             for ($i= 0; $i < $matchCount; $i++) {

    836. 

  836.                 $spos= strpos($matches[1][$i], '?', 0);

    837. 

  837.                 if ($spos !== false) {

    838. 

  838.                     $params= substr($matches[1][$i], $spos, strlen($matches[1][$i]));

    839. 

  839.                 } else {

    840. 

  840.                     $params= '';

    841. 

  841.                 }

    842. 

  842.                 $matches[1][$i]= str_replace($params, '', $matches[1][$i]);

    843. 

  843.                 $snippetParams[$i]= $params;

    844. 

  844.             }

    845. 

  845.             $nrSnippetsToGet= $matchCount;

    846. 

  846.             for ($i= 0; $i < $nrSnippetsToGet; $i++) { // Raymond: Mod for Snippet props

    847. 

  847.                 if (isset ($this->snippetCache[$matches[1][$i]])) {

    848. 

  848.                     $snippets[$i]['name']= $matches[1][$i];

    849. 

  849.                     $snippets[$i]['snippet']= $this->snippetCache[$matches[1][$i]];

    850. 

  850.                     if (array_key_exists($matches[1][$i] . "Props", $this->snippetCache))

    851. 

  851.                         $snippets[$i]['properties']= $this->snippetCache[$matches[1][$i] . "Props"];

    852. 

  852.                 } else {

    853. 

  853.                     // get from db and store a copy inside cache

    854. 

  854.                     $sql= "SELECT `name`, `snippet`, `properties` FROM " . $this->getFullTableName("site_snippets") . " WHERE " . $this->getFullTableName("site_snippets") . ".`name`='" . $this->db->escape($matches[1][$i]) . "';";

    855. 

  855.                     $result= $this->db->query($sql);

    856. 

  856.                     $added = false;

    857. 

  857.                     if ($this->db->getRecordCount($result) == 1) {

    858. 

  858.                         $row= $this->db->getRow($result);

    859. 

  859.                         if($row['name'] == $matches[1][$i]) {

    860. 

  860.                             $snippets[$i]['name']= $row['name'];

    861. 

  861.                             $snippets[$i]['snippet']= $this->snippetCache[$row['name']]= $row['snippet'];

    862. 

  862.                             $snippets[$i]['properties']= $this->snippetCache[$row['name'] . "Props"]= $row['properties'];

    863. 

  863.                             $added = true;

    864. 

  864.                         }

    865. 

  865.                     }

    866. 

  866.                     if(!$added) {

    867. 

  867.                         $snippets[$i]['name']= $matches[1][$i];

    868. 

  868.                         $snippets[$i]['snippet']= $this->snippetCache[$matches[1][$i]]= "return false;";

    869. 

  869.                         $snippets[$i]['properties']= '';

    870. 

  870.                     }

    871. 

  871.                 }

    872. 

  872.             }

    873. 

  873. 

    874. 

  874.             for ($i= 0; $i < $nrSnippetsToGet; $i++) {

    875. 

  875.                 $parameter= array ();

    876. 

  876.                 $snippetName= $this->currentSnippet= $snippets[$i]['name'];

    877. 

  877.                 // FIXME Undefined index: properties

    878. 

  878.                 if (array_key_exists('properties', $snippets[$i])) {

    879. 

  879.                     $snippetProperties= $snippets[$i]['properties'];

    880. 

  880.                 } else {

    881. 

  881.                     $snippetProperties= '';

    882. 

  882.                 }

    883. 

  883.                 // load default params/properties - Raymond

    884. 

  884.                 // FIXME Undefined variable: snippetProperties

    885. 

  885.                 $parameter= $this->parseProperties($snippetProperties);

    886. 

  886.                 // current params

    887. 

  887.                 $currentSnippetParams= $snippetParams[$i];

    888. 

  888.                 if (!empty ($currentSnippetParams)) {

    889. 

  889.                     $tempSnippetParams= str_replace("?", "", $currentSnippetParams);

    890. 

  890.                     $splitter= "&";

    891. 

  891.                     if (strpos($tempSnippetParams, "&amp;") > 0)

    892. 

  892.                         $tempSnippetParams= str_replace("&amp;", "&", $tempSnippetParams);

    893. 

  893.                     //$tempSnippetParams = html_entity_decode($tempSnippetParams, ENT_NOQUOTES, $this->config['etomite_charset']); //FS#334 and FS#456

    894. 

  894.                     $tempSnippetParams= explode($splitter, $tempSnippetParams);

    895. 

  895.                     $snippetParamCount= count($tempSnippetParams);

    896. 

  896.                     for ($x= 0; $x < $snippetParamCount; $x++) {

    897. 

  897.                         if (strpos($tempSnippetParams[$x], '=', 0)) {

    898. 

  898.                             if ($parameterTemp= explode("=", $tempSnippetParams[$x])) {

    899. 

  899.                                 $parameterTemp[0] = trim($parameterTemp[0]);

    900. 

  900.                                 $parameterTemp[1] = trim($parameterTemp[1]);

    901. 

  901.                                 $fp= strpos($parameterTemp[1], '`');

    902. 

  902.                                 $lp= strrpos($parameterTemp[1], '`');

    903. 

  903.                                 if (!($fp === false && $lp === false))

    904. 

  904.                                     $parameterTemp[1]= substr($parameterTemp[1], $fp +1, $lp -1);

    905. 

  905.                                 $parameter[$parameterTemp[0]]= $parameterTemp[1];

    906. 

  906.                             }

    907. 

  907.                         }

    908. 

  908.                     }

    909. 

  909.                 }

    910. 

  910.                 $executedSnippets[$i]= $this->evalSnippet($snippets[$i]['snippet'], $parameter);

    911. 

  911.                 if ($this->dumpSnippets == 1) {

    912. 

  912.                     echo "<fieldset><legend><b>$snippetName</b></legend><textarea style='width:60%; height:200px'>" . htmlentities($executedSnippets[$i]) . "</textarea></fieldset><br />";

    913. 

  913.                 }

    914. 

  914.                 $documentSource= str_replace("[[" . $snippetName . $currentSnippetParams . "]]", $executedSnippets[$i], $documentSource);

    915. 

  915.             }

    916. 

  916.         }

    917. 

  917.         return $documentSource;

    918. 

  918.     }

    919. 

  919. 

    920. 

  920.     function makeFriendlyURL($pre, $suff, $alias) {

    921. 

  921.         $Alias = explode('/',$alias);

    922. 

  922.         $alias = array_pop($Alias);

    923. 

  923.         $dir = implode('/', $Alias);

    924. 

  924.         unset($Alias);

    925. 

  925.         return ($dir != '' ? "$dir/" : '') . $pre . $alias . $suff;

    926. 

  926.     }

    927. 

  927. 

    928. 

  928.     function rewriteUrls($documentSource) {

    929. 

  929.         // rewrite the urls

    930. 

  930.         if ($this->config['friendly_urls'] == 1) {

    931. 

  931.             $aliases= array ();

    932. 

  932.             foreach ($this->aliasListing as $item) {

    933. 

  933.                 $aliases[$item['id']]= (strlen($item['path']) > 0 ? $item['path'] . '/' : '') . $item['alias'];

    934. 

  934.             }

    935. 

  935.             $in= '!\[\~([0-9]+)\~\]!ise'; // Use preg_replace with /e to make it evaluate PHP

    936. 

  936.             $isfriendly= ($this->config['friendly_alias_urls'] == 1 ? 1 : 0);

    937. 

  937.             $pref= $this->config['friendly_url_prefix'];

    938. 

  938.             $suff= $this->config['friendly_url_suffix'];

    939. 

  939.             $thealias= '$aliases[\\1]';

    940. 

  940.             $found_friendlyurl= "\$this->makeFriendlyURL('$pref','$suff',$thealias)";

    941. 

  941.             $not_found_friendlyurl= "\$this->makeFriendlyURL('$pref','$suff','" . '\\1' . "')";

    942. 

  942.             $out= "({$isfriendly} && isset({$thealias}) ? {$found_friendlyurl} : {$not_found_friendlyurl})";

    943. 

  943.             $documentSource= preg_replace($in, $out, $documentSource);

    944. 

  944.         } else {

    945. 

  945.             $in= '!\[\~([0-9]+)\~\]!is';

    946. 

  946.             $out= "index.php?id=" . '\1';

    947. 

  947.             $documentSource= preg_replace($in, $out, $documentSource);

    948. 

  948.         }

    949. 

  949.         return $documentSource;

    950. 

  950.     }

    951. 

  951. 

    952. 

  952.     /**

    953. 

  953.      * name: getDocumentObject  - used by parser

    954. 

  954.      * desc: returns a document object - $method: alias, id

    955. 

  955.      */

    956. 

  956.     function getDocumentObject($method, $identifier) {

    957. 

  957.         $tblsc= $this->getFullTableName("site_content");

    958. 

  958.         $tbldg= $this->getFullTableName("document_groups");

    959. 

  959. 

    960. 

  960.         // allow alias to be full path

    961. 

  961.         if($method == 'alias') {

    962. 

  962.             $identifier = $this->cleanDocumentIdentifier($identifier);

    963. 

  963.             $method = $this->documentMethod;

    964. 

  964.         }

    965. 

  965.         if($method == 'alias' && $this->config['use_alias_path'] && array_key_exists($identifier, $this->documentListing)) {

    966. 

  966.             $method = 'id';

    967. 

  967.             $identifier = $this->documentListing[$identifier];

    968. 

  968.         }

    969. 

  969.         // get document groups for current user

    970. 

  970.         if ($docgrp= $this->getUserDocGroups())

    971. 

  971.             $docgrp= implode(",", $docgrp);

    972. 

  972.         // get document

    973. 

  973.         $access= ($this->isFrontend() ? "sc.privateweb=0" : "1='" . $_SESSION['mgrRole'] . "' OR sc.privatemgr=0") .

    974. 

  974.          (!$docgrp ? "" : " OR dg.document_group IN ($docgrp)");

    975. 

  975.         $sql= "SELECT sc.*

    976. 

  976.               FROM $tblsc sc

    977. 

  977.               LEFT JOIN $tbldg dg ON dg.document = sc.id

    978. 

  978.               WHERE sc." . $method . " = '" . $identifier . "'

    979. 

  979.               AND ($access) LIMIT 1;";

    980. 

  980.         $result= $this->db->query($sql);

    981. 

  981.         $rowCount= $this->db->getRecordCount($result);

    982. 

  982.         if ($rowCount < 1) {

    983. 

  983.             if ($this->config['unauthorized_page']) {

    984. 

  984.                 // method may still be alias, while identifier is not full path alias, e.g. id not found above

    985. 

  985.                 if ($method === 'alias') {

    986. 

  986.                     $q = "SELECT dg.id FROM $tbldg dg, $tblsc sc WHERE dg.document = sc.id AND sc.alias = '{$identifier}' LIMIT 1;";

    987. 

  987.                 } else {

    988. 

  988.                     $q = "SELECT id FROM $tbldg WHERE document = '{$identifier}' LIMIT 1;";

    989. 

  989.                 }

    990. 

  990.                 // check if file is not public

    991. 

  991.                 $secrs= $this->db->query($q);

    992. 

  992.                 if ($secrs)

    993. 

  993.                     $seclimit= mysql_num_rows($secrs);

    994. 

  994.             }

    995. 

  995.             if ($seclimit > 0) {

    996. 

  996.                 // match found but not publicly accessible, send the visitor to the unauthorized_page

    997. 

  997.                 $this->sendUnauthorizedPage();

    998. 

  998.                 exit; // stop here

    999. 

  999.             } else {

    1000. 

  1000.                 $this->sendErrorPage();

    1001. 

  1001.                 exit;

    1002. 

  1002.             }

    1003. 

  1003.         }

    1004. 

  1004. 

    1005. 

  1005.         # this is now the document :) #

    1006. 

  1006.         $documentObject= $this->db->getRow($result);

    1007. 

  1007. 

    1008. 

  1008.         // load TVs and merge with document - Orig by Apodigm - Docvars

    1009. 

  1009.         $sql= "SELECT tv.*, IF(tvc.value!='',tvc.value,tv.default_text) as value ";

    1010. 

  1010.         $sql .= "FROM " . $this->getFullTableName("site_tmplvars") . " tv ";

    1011. 

  1011.         $sql .= "INNER JOIN " . $this->getFullTableName("site_tmplvar_templates")." tvtpl ON tvtpl.tmplvarid = tv.id ";

    1012. 

  1012.         $sql .= "LEFT JOIN " . $this->getFullTableName("site_tmplvar_contentvalues")." tvc ON tvc.tmplvarid=tv.id AND tvc.contentid = '" . $documentObject['id'] . "' ";

    1013. 

  1013.         $sql .= "WHERE tvtpl.templateid = '" . $documentObject['template'] . "'";

    1014. 

  1014.         $rs= $this->db->query($sql);

    1015. 

  1015.         $rowCount= $this->db->getRecordCount($rs);

    1016. 

  1016.         if ($rowCount > 0) {

    1017. 

  1017.             for ($i= 0; $i < $rowCount; $i++) {

    1018. 

  1018.                 $row= $this->db->getRow($rs);

    1019. 

  1019.                 $tmplvars[$row['name']]= array (

    1020. 

  1020.                     $row['name'],

    1021. 

  1021.                     $row['value'],

    1022. 

  1022.                     $row['display'],

    1023. 

  1023.                     $row['display_params'],

    1024. 

  1024.                     $row['type']

    1025. 

  1025.                 );

    1026. 

  1026.             }

    1027. 

  1027.             $documentObject= array_merge($documentObject, $tmplvars);

    1028. 

  1028.         }

    1029. 

  1029.         return $documentObject;

    1030. 

  1030.     }

    1031. 

  1031. 

    1032. 

  1032.     /**

    1033. 

  1033.      * name: parseDocumentSource - used by parser

    1034. 

  1034.      * desc: return document source aftering parsing tvs, snippets, chunks, etc.

    1035. 

  1035.      */

    1036. 

  1036.     function parseDocumentSource($source) {

    1037. 

  1037.         // set the number of times we are to parse the document source

    1038. 

  1038.         $this->minParserPasses= empty ($this->minParserPasses) ? 2 : $this->minParserPasses;

    1039. 

  1039.         $this->maxParserPasses= empty ($this->maxParserPasses) ? 10 : $this->maxParserPasses;

    1040. 

  1040.         $passes= $this->minParserPasses;

    1041. 

  1041.         for ($i= 0; $i < $passes; $i++) {

    1042. 

  1042.             // get source length if this is the final pass

    1043. 

  1043.             if ($i == ($passes -1))

    1044. 

  1044.                 $st= strlen($source);

    1045. 

  1045.             if ($this->dumpSnippets == 1) {

    1046. 

  1046.                 echo "<fieldset><legend><b style='color: #821517;'>PARSE PASS " . ($i +1) . "</b></legend>The following snippets (if any) were parsed during this pass.<div style='width:100%' align='center'>";

    1047. 

  1047.             }

    1048. 

  1048. 

    1049. 

  1049.             // invoke OnParseDocument event

    1050. 

  1050.             $this->documentOutput= $source; // store source code so plugins can

    1051. 

  1051.             $this->invokeEvent("OnParseDocument"); // work on it via $modx->documentOutput

    1052. 

  1052.             $source= $this->documentOutput;

    1053. 

  1053. 

    1054. 

  1054.             // combine template and document variables

    1055. 

  1055.             $source= $this->mergeDocumentContent($source);

    1056. 

  1056.             // replace settings referenced in document

    1057. 

  1057.             $source= $this->mergeSettingsContent($source);

    1058. 

  1058.             // replace HTMLSnippets in document

    1059. 

  1059.             $source= $this->mergeChunkContent($source);

    1060. 

  1060. 	    // insert META tags & keywords

    1061. 

  1061. 	    $source= $this->mergeDocumentMETATags($source);

    1062. 

  1062.             // find and merge snippets

    1063. 

  1063.             $source= $this->evalSnippets($source);

    1064. 

  1064.             // find and replace Placeholders (must be parsed last) - Added by Raymond

    1065. 

  1065.             $source= $this->mergePlaceholderContent($source);

    1066. 

  1066.             if ($this->dumpSnippets == 1) {

    1067. 

  1067.                 echo "</div></fieldset><br />";

    1068. 

  1068.             }

    1069. 

  1069.             if ($i == ($passes -1) && $i < ($this->maxParserPasses - 1)) {

    1070. 

  1070.                 // check if source length was changed

    1071. 

  1071.                 $et= strlen($source);

    1072. 

  1072.                 if ($st != $et)

    1073. 

  1073.                     $passes++; // if content change then increase passes because

    1074. 

  1074.             } // we have not yet reached maxParserPasses

    1075. 

  1075.         }

    1076. 

  1076.         return $source;

    1077. 

  1077.     }

    1078. 

  1078. 

    1079. 

  1079.     function executeParser() {

    1080. 

  1080.         //error_reporting(0);

    1081. 

  1081.         if (version_compare(phpversion(), "5.0.0", ">="))

    1082. 

  1082.             set_error_handler(array (

    1083. 

  1083.                 & $this,

    1084. 

  1084.                 "phpError"

    1085. 

  1085.             ), E_ALL);

    1086. 

  1086.         else

    1087. 

  1087.             set_error_handler(array (

    1088. 

  1088.                 & $this,

    1089. 

  1089.                 "phpError"

    1090. 

  1090.             ));

    1091. 

  1091. 

    1092. 

  1092.         $this->db->connect();

    1093. 

  1093. 

    1094. 

  1094.         // get the settings

    1095. 

  1095.         if (empty ($this->config)) {

    1096. 

  1096.             $this->getSettings();

    1097. 

  1097.         }

    1098. 

  1098. 

    1099. 

  1099.         // IIS friendly url fix

    1100. 

  1100.         if ($this->config['friendly_urls'] == 1 && strpos($_SERVER['SERVER_SOFTWARE'], 'Microsoft-IIS') !== false) {

    1101. 

  1101.             $url= $_SERVER['QUERY_STRING'];

    1102. 

  1102.             $err= substr($url, 0, 3);

    1103. 

  1103.             if ($err == '404' || $err == '405') {

    1104. 

  1104.                 $k= array_keys($_GET);

    1105. 

  1105.                 unset ($_GET[$k[0]]);

    1106. 

  1106.                 unset ($_REQUEST[$k[0]]); // remove 404,405 entry

    1107. 

  1107.                 $_SERVER['QUERY_STRING']= $qp['query'];

    1108. 

  1108.                 $qp= parse_url(str_replace($this->config['site_url'], '', substr($url, 4)));

    1109. 

  1109.                 if (!empty ($qp['query'])) {

    1110. 

  1110.                     parse_str($qp['query'], $qv);

    1111. 

  1111.                     foreach ($qv as $n => $v)

    1112. 

  1112.                         $_REQUEST[$n]= $_GET[$n]= $v;

    1113. 

  1113.                 }

    1114. 

  1114.                 $_SERVER['PHP_SELF']= $this->config['base_url'] . $qp['path'];

    1115. 

  1115.                 $_REQUEST['q']= $_GET['q']= $qp['path'];

    1116. 

  1116.             }

    1117. 

  1117.         }

    1118. 

  1118. 

    1119. 

  1119.         // check site settings

    1120. 

  1120.         if (!$this->checkSiteStatus()) {

    1121. 

  1121.             header('HTTP/1.0 503 Service Unavailable');

    1122. 

  1122.             if (!$this->config['site_unavailable_page']) {

    1123. 

  1123.                 // display offline message

    1124. 

  1124.                 $this->documentContent= $this->config['site_unavailable_message'];

    1125. 

  1125.                 $this->outputContent();

    1126. 

  1126.                 exit; // stop processing here, as the site's offline

    1127. 

  1127.             } else {

    1128. 

  1128.                 // setup offline page document settings

    1129. 

  1129.                 $this->documentMethod= "id";

    1130. 

  1130.                 $this->documentIdentifier= $this->config['site_unavailable_page'];

    1131. 

  1131.             }

    1132. 

  1132.         } else {

    1133. 

  1133.             // make sure the cache doesn't need updating

    1134. 

  1134.             $this->checkPublishStatus();

    1135. 

  1135. 

    1136. 

  1136.             // find out which document we need to display

    1137. 

  1137.             $this->documentMethod= $this->getDocumentMethod();

    1138. 

  1138.             $this->documentIdentifier= $this->getDocumentIdentifier($this->documentMethod);

    1139. 

  1139.         }

    1140. 

  1140. 

    1141. 

  1141.         if ($this->documentMethod == "none") {

    1142. 

  1142.             $this->documentMethod= "id"; // now we know the site_start, change the none method to id

    1143. 

  1143.         }

    1144. 

  1144.         if ($this->documentMethod == "alias") {

    1145. 

  1145.             $this->documentIdentifier= $this->cleanDocumentIdentifier($this->documentIdentifier);

    1146. 

  1146.         }

    1147. 

  1147. 

    1148. 

  1148.         if ($this->documentMethod == "alias") {

    1149. 

  1149.             // Check use_alias_path and check if $this->virtualDir is set to anything, then parse the path

    1150. 

  1150.             if ($this->config['use_alias_path'] == 1) {

    1151. 

  1151.                 $alias= (strlen($this->virtualDir) > 0 ? $this->virtualDir . '/' : '') . $this->documentIdentifier;

    1152. 

  1152.                 if (array_key_exists($alias, $this->documentListing)) {

    1153. 

  1153.                     $this->documentIdentifier= $this->documentListing[$alias];

    1154. 

  1154.                 } else {

    1155. 

  1155.                     $this->sendErrorPage();

    1156. 

  1156.                 }

    1157. 

  1157.             } else {

    1158. 

  1158.                 $this->documentIdentifier= $this->documentListing[$this->documentIdentifier];

    1159. 

  1159.             }

    1160. 

  1160.             $this->documentMethod= 'id';

    1161. 

  1161.         }

    1162. 

  1162. 

    1163. 

  1163.         // invoke OnWebPageInit event

    1164. 

  1164.         $this->invokeEvent("OnWebPageInit");

    1165. 

  1165. 

    1166. 

  1166.         // invoke OnLogPageView event

    1167. 

  1167.         if ($this->config['track_visitors'] == 1) {

    1168. 

  1168.             $this->invokeEvent("OnLogPageHit");

    1169. 

  1169.         }

    1170. 

  1170. 

    1171. 

  1171.         $this->prepareResponse();

    1172. 

  1172.     }

    1173. 

  1173. 

    1174. 

  1174.     function prepareResponse() {

    1175. 

  1175.         // we now know the method and identifier, let's check the cache

    1176. 

  1176.         $this->documentContent= $this->checkCache($this->documentIdentifier);

    1177. 

  1177.         if ($this->documentContent != "") {

    1178. 

  1178.             // invoke OnLoadWebPageCache  event

    1179. 

  1179.             $this->invokeEvent("OnLoadWebPageCache");

    1180. 

  1180.         } else {

    1181. 

  1181.             // get document object

    1182. 

  1182.             $this->documentObject= $this->getDocumentObject($this->documentMethod, $this->documentIdentifier);

    1183. 

  1183. 

    1184. 

  1184.             // write the documentName to the object

    1185. 

  1185.             $this->documentName= $this->documentObject['pagetitle'];

    1186. 

  1186. 

    1187. 

  1187.             // validation routines

    1188. 

  1188.             if ($this->documentObject['deleted'] == 1) {

    1189. 

  1189.                 $this->sendErrorPage();

    1190. 

  1190.             }

    1191. 

  1191.             //  && !$this->checkPreview()

    1192. 

  1192.             if ($this->documentObject['published'] == 0) {

    1193. 

  1193. 

    1194. 

  1194.                 // Can't view unpublished pages

    1195. 

  1195.                 if (!$this->hasPermission('view_unpublished')) {

    1196. 

  1196.                     $this->sendErrorPage();

    1197. 

  1197.                 } else {

    1198. 

  1198.                     // Inculde the necessary files to check document permissions

    1199. 

  1199.                     include_once ($this->config['base_path'] . '/manager/processors/user_documents_permissions.class.php');

    1200. 

  1200.                     $udperms= new udperms();

    1201. 

  1201.                     $udperms->user= $this->getLoginUserID();

    1202. 

  1202.                     $udperms->document= $this->documentIdentifier;

    1203. 

  1203.                     $udperms->role= $_SESSION['mgrRole'];

    1204. 

  1204.                     // Doesn't have access to this document

    1205. 

  1205.                     if (!$udperms->checkPermissions()) {

    1206. 

  1206.                         $this->sendErrorPage();

    1207. 

  1207.                     }

    1208. 

  1208. 

    1209. 

  1209.                 }

    1210. 

  1210. 

    1211. 

  1211.             }

    1212. 

  1212. 

    1213. 

  1213.             // check whether it's a reference

    1214. 

  1214.             if ($this->documentObject['type'] == "reference") {

    1215. 

  1215.                 if (is_numeric($this->documentObject['content'])) {

    1216. 

  1216.                     // if it's a bare document id

    1217. 

  1217.                     $this->documentObject['content']= $this->makeUrl($this->documentObject['content']);

    1218. 

  1218.                 }

    1219. 

  1219.                 elseif (strpos($this->documentObject['content'], '[~') !== false) {

    1220. 

  1220.                     // if it's an internal docid tag, process it

    1221. 

  1221.                     $this->documentObject['content']= $this->rewriteUrls($this->documentObject['content']);

    1222. 

  1222.                 }

    1223. 

  1223.                 $this->sendRedirect($this->documentObject['content'], 0, '', 'HTTP/1.0 301 Moved Permanently');

    1224. 

  1224.             }

    1225. 

  1225. 

    1226. 

  1226.             // check if we should not hit this document

    1227. 

  1227.             if ($this->documentObject['donthit'] == 1) {

    1228. 

  1228.                 $this->config['track_visitors']= 0;

    1229. 

  1229.             }

    1230. 

  1230. 

    1231. 

  1231.             // get the template and start parsing!

    1232. 

  1232.             if (!$this->documentObject['template'])

    1233. 

  1233.                 $this->documentContent= "[*content*]"; // use blank template

    1234. 

  1234.             else {

    1235. 

  1235.                 $sql= "SELECT `content` FROM " . $this->getFullTableName("site_templates") . " WHERE " . $this->getFullTableName("site_templates") . ".`id` = '" . $this->documentObject['template'] . "';";

    1236. 

  1236.                 $result= $this->db->query($sql);

    1237. 

  1237.                 $rowCount= $this->db->getRecordCount($result);

    1238. 

  1238.                 if ($rowCount > 1) {

    1239. 

  1239.                     $this->messageQuit("Incorrect number of templates returned from database", $sql);

    1240. 

  1240.                 }

    1241. 

  1241.                 elseif ($rowCount == 1) {

    1242. 

  1242.                     $row= $this->db->getRow($result);

    1243. 

  1243.                     $this->documentContent= $row['content'];

    1244. 

  1244.                 }

    1245. 

  1245.             }

    1246. 

  1246. 

    1247. 

  1247.             // invoke OnLoadWebDocument event

    1248. 

  1248.             $this->invokeEvent("OnLoadWebDocument");

    1249. 

  1249. 

    1250. 

  1250.             // Parse document source

    1251. 

  1251.             $this->documentContent= $this->parseDocumentSource($this->documentContent);

    1252. 

  1252. 

    1253. 

  1253.             // setup <base> tag for friendly urls

    1254. 

  1254.             //			if($this->config['friendly_urls']==1 && $this->config['use_alias_path']==1) {

    1255. 

  1255.             //				$this->regClientStartupHTMLBlock('<base href="'.$this->config['site_url'].'" />');

    1256. 

  1256.             //			}

    1257. 

  1257.         }

    1258. 

  1258.         register_shutdown_function(array (

    1259. 

  1259.             & $this,

    1260. 

  1260.             "postProcess"

    1261. 

  1261.         )); // tell PHP to call postProcess when it shuts down

    1262. 

  1262.         $this->outputContent();

    1263. 

  1263.         //$this->postProcess();

    1264. 

  1264.     }

    1265. 

  1265. 

    1266. 

  1266.     /***************************************************************************************/

    1267. 

  1267.     /* API functions																/

    1268. 

  1268.     /***************************************************************************************/

    1269. 

  1269. 

    1270. 

  1270.     function getParentIds($id, $height= 10) {

    1271. 

  1271.         $parents= array ();

    1272. 

  1272.         while ( $id && $height-- ) {

    1273. 

  1273.             $thisid = $id;

    1274. 

  1274.             $id = $this->aliasListing[$id]['parent'];

    1275. 

  1275.             if (!$id) break;

    1276. 

  1276.             $pkey = strlen($this->aliasListing[$thisid]['path']) ? $this->aliasListing[$thisid]['path'] : $this->aliasListing[$id]['alias'];

    1277. 

  1277.             if (!strlen($pkey)) $pkey = "{$id}";

    1278. 

  1278.             $parents[$pkey] = $id;

    1279. 

  1279.         }

    1280. 

  1280.         return $parents;

    1281. 

  1281.     }

    1282. 

  1282. 

    1283. 

  1283.     function getChildIds($id, $depth= 10, $children= array ()) {

    1284. 

  1284. 

    1285. 

  1285.         // Initialise a static array to index parents->children

    1286. 

  1286.         static $documentMap_cache = array();

    1287. 

  1287.         if (!count($documentMap_cache)) {

    1288. 

  1288.             foreach ($this->documentMap as $document) {

    1289. 

  1289.                 foreach ($document as $p => $c) {

    1290. 

  1290.                     $documentMap_cache[$p][] = $c;

    1291. 

  1291.                 }

    1292. 

  1292.             }

    1293. 

  1293.         }

    1294. 

  1294. 

    1295. 

  1295.         // Get all the children for this parent node

    1296. 

  1296.         if (isset($documentMap_cache[$id])) {

    1297. 

  1297.             $depth--;

    1298. 

  1298. 

    1299. 

  1299.             foreach ($documentMap_cache[$id] as $childId) {

    1300. 

  1300.                 $pkey = (strlen($this->aliasListing[$childId]['path']) ? "{$this->aliasListing[$childId]['path']}/" : '') . $this->aliasListing[$childId]['alias'];

    1301. 

  1301.                 if (!strlen($pkey)) $pkey = "{$childId}";

    1302. 

  1302.                     $children[$pkey] = $childId;

    1303. 

  1303. 

    1304. 

  1304.                 if ($depth) {

    1305. 

  1305.                     $children += $this->getChildIds($childId, $depth);

    1306. 

  1306.                 }

    1307. 

  1307.             }

    1308. 

  1308.         }

    1309. 

  1309.         return $children;

    1310. 

  1310.     }

    1311. 

  1311. 

    1312. 

  1312.     # Displays a javascript alert message in the web browser

    1313. 

  1313.     function webAlert($msg, $url= "") {

    1314. 

  1314.         $msg= addslashes($this->db->escape($msg));

    1315. 

  1315.         if (substr(strtolower($url), 0, 11) == "javascript:") {

    1316. 

  1316.             $act= "__WebAlert();";

    1317. 

  1317.             $fnc= "function __WebAlert(){" . substr($url, 11) . "};";

    1318. 

  1318.         } else {

    1319. 

  1319.             $act= ($url ? "window.location.href='" . addslashes($url) . "';" : "");

    1320. 

  1320.         }

    1321. 

  1321.         $html= "<script>$fnc window.setTimeout(\"alert('$msg');$act\",100);</script>";

    1322. 

  1322.         if ($this->isFrontend())

    1323. 

  1323.             $this->regClientScript($html);

    1324. 

  1324.         else {

    1325. 

  1325.             echo $html;

    1326. 

  1326.         }

    1327. 

  1327.     }

    1328. 

  1328. 

    1329. 

  1329.     # Returns true if user has the currect permission

    1330. 

  1330.     function hasPermission($pm) {

    1331. 

  1331.         $state= false;

    1332. 

  1332.         $pms= $_SESSION['mgrPermissions'];

    1333. 

  1333.         if ($pms)

    1334. 

  1334.             $state= ($pms[$pm] == 1);

    1335. 

  1335.         return $state;

    1336. 

  1336.     }

    1337. 

  1337. 

    1338. 

  1338.     # Add an a alert message to the system event log

    1339. 

  1339.     function logEvent($evtid, $type, $msg, $source= 'Parser') {

    1340. 

  1340.         $msg= $this->db->escape($msg);

    1341. 

  1341.         $source= $this->db->escape($source);

    1342. 

  1342. 	if ($GLOBALS['database_connection_charset'] == 'utf8' && extension_loaded('mbstring')) {

    1343. 

  1343. 		$source = mb_substr($source, 0, 50 , "UTF-8");

    1344. 

  1344. 	} else {

    1345. 

  1345. 		$source = substr($source, 0, 50);

    1346. 

  1346. 	}

    1347. 

  1347. 	$LoginUserID = $this->getLoginUserID();

    1348. 

  1348. 	if ($LoginUserID == '') $LoginUserID = 0;

    1349. 

  1349.         $evtid= intval($evtid);

    1350. 

  1350.         if ($type < 1) {

    1351. 

  1351.             $type= 1;

    1352. 

  1352.         }

    1353. 

  1353.         elseif ($type > 3) {

    1354. 

  1354.             $type= 3; // Types: 1 = information, 2 = warning, 3 = error

    1355. 

  1355.         }

    1356. 

  1356.         $sql= "INSERT INTO " . $this->getFullTableName("event_log") . " (eventid,type,createdon,source,description,user) " .

    1357. 

  1357. 	"VALUES($evtid,$type," . time() . ",'$source','$msg','" . $LoginUserID . "')";

    1358. 

  1358.         $ds= @$this->db->query($sql);

    1359. 

  1359.         if (!$ds) {

    1360. 

  1360.             echo "Error while inserting event log into database.";

    1361. 

  1361.             exit();

    1362. 

  1362.         }

    1363. 

  1363.     }

    1364. 

  1364. 

    1365. 

  1365.     # Returns true if parser is executed in backend (manager) mode

    1366. 

  1366.     function isBackend() {

    1367. 

  1367.         return $this->insideManager() ? true : false;

    1368. 

  1368.     }

    1369. 

  1369. 

    1370. 

  1370.     # Returns true if parser is executed in frontend mode

    1371. 

  1371.     function isFrontend() {

    1372. 

  1372.         return !$this->insideManager() ? true : false;

    1373. 

  1373.     }

    1374. 

  1374. 

    1375. 

  1375.     function getAllChildren($id= 0, $sort= 'menuindex', $dir= 'ASC', $fields= 'id, pagetitle, description, parent, alias, menutitle') {

    1376. 

  1376.         $tblsc= $this->getFullTableName("site_content");

    1377. 

  1377.         $tbldg= $this->getFullTableName("document_groups");

    1378. 

  1378.         // modify field names to use sc. table reference

    1379. 

  1379.         $fields= 'sc.' . implode(',sc.', preg_replace("/^\s/i", "", explode(',', $fields)));

    1380. 

  1380.         $sort= 'sc.' . implode(',sc.', preg_replace("/^\s/i", "", explode(',', $sort)));

    1381. 

  1381.         // get document groups for current user

    1382. 

  1382.         if ($docgrp= $this->getUserDocGroups())

    1383. 

  1383.             $docgrp= implode(",", $docgrp);

    1384. 

  1384.         // build query

    1385. 

  1385.         $access= ($this->isFrontend() ? "sc.privateweb=0" : "1='" . $_SESSION['mgrRole'] . "' OR sc.privatemgr=0") .

    1386. 

  1386.          (!$docgrp ? "" : " OR dg.document_group IN ($docgrp)");

    1387. 

  1387.         $sql= "SELECT DISTINCT $fields FROM $tblsc sc

    1388. 

  1388.               LEFT JOIN $tbldg dg on dg.document = sc.id

    1389. 

  1389.               WHERE sc.parent = '$id'

    1390. 

  1390.               AND ($access)

    1391. 

  1391.               GROUP BY sc.id

    1392. 

  1392.               ORDER BY $sort $dir;";

    1393. 

  1393.         $result= $this->db->query($sql);

    1394. 

  1394.         $resourceArray= array ();

    1395. 

  1395.         for ($i= 0; $i < @ $this->db->getRecordCount($result); $i++) {

    1396. 

  1396.             array_push($resourceArray, @ $this->db->getRow($result));

    1397. 

  1397.         }

    1398. 

  1398.         return $resourceArray;

    1399. 

  1399.     }

    1400. 

  1400. 

    1401. 

  1401.     function getActiveChildren($id= 0, $sort= 'menuindex', $dir= 'ASC', $fields= 'id, pagetitle, description, parent, alias, menutitle') {

    1402. 

  1402.         $tblsc= $this->getFullTableName("site_content");

    1403. 

  1403.         $tbldg= $this->getFullTableName("document_groups");

    1404. 

  1404. 

    1405. 

  1405.         // modify field names to use sc. table reference

    1406. 

  1406.         $fields= 'sc.' . implode(',sc.', preg_replace("/^\s/i", "", explode(',', $fields)));

    1407. 

  1407.         $sort= 'sc.' . implode(',sc.', preg_replace("/^\s/i", "", explode(',', $sort)));

    1408. 

  1408.         // get document groups for current user

    1409. 

  1409.         if ($docgrp= $this->getUserDocGroups())

    1410. 

  1410.             $docgrp= implode(",", $docgrp);

    1411. 

  1411.         // build query

    1412. 

  1412.         $access= ($this->isFrontend() ? "sc.privateweb=0" : "1='" . $_SESSION['mgrRole'] . "' OR sc.privatemgr=0") .

    1413. 

  1413.          (!$docgrp ? "" : " OR dg.document_group IN ($docgrp)");

    1414. 

  1414.         $sql= "SELECT DISTINCT $fields FROM $tblsc sc

    1415. 

  1415.               LEFT JOIN $tbldg dg on dg.document = sc.id

    1416. 

  1416.               WHERE sc.parent = '$id' AND sc.published=1 AND sc.deleted=0

    1417. 

  1417.               AND ($access)

    1418. 

  1418.               GROUP BY sc.id

    1419. 

  1419.               ORDER BY $sort $dir;";

    1420. 

  1420.         $result= $this->db->query($sql);

    1421. 

  1421.         $resourceArray= array ();

    1422. 

  1422.         for ($i= 0; $i < @ $this->db->getRecordCount($result); $i++) {

    1423. 

  1423.             array_push($resourceArray, @ $this->db->getRow($result));

    1424. 

  1424.         }

    1425. 

  1425.         return $resourceArray;

    1426. 

  1426.     }

    1427. 

  1427. 

    1428. 

  1428.     function getDocumentChildren($parentid= 0, $published= 1, $deleted= 0, $fields= "*", $where= '', $sort= "menuindex", $dir= "ASC", $limit= "") {

    1429. 

  1429.         $limit= ($limit != "") ? "LIMIT $limit" : "";

    1430. 

  1430.         $tblsc= $this->getFullTableName("site_content");

    1431. 

  1431.         $tbldg= $this->getFullTableName("document_groups");

    1432. 

  1432.         // modify field names to use sc. table reference

    1433. 

  1433.         $fields= 'sc.' . implode(',sc.', preg_replace("/^\s/i", "", explode(',', $fields)));

    1434. 

  1434.         $sort= ($sort == "") ? "" : 'sc.' . implode(',sc.', preg_replace("/^\s/i", "", explode(',', $sort)));

    1435. 

  1435.         if ($where != '')

    1436. 

  1436.             $where= 'AND ' . $where;

    1437. 

  1437.         // get document groups for current user

    1438. 

  1438.         if ($docgrp= $this->getUserDocGroups())

    1439. 

  1439.             $docgrp= implode(",", $docgrp);

    1440. 

  1440.         // build query

    1441. 

  1441.         $access= ($this->isFrontend() ? "sc.privateweb=0" : "1='" . $_SESSION['mgrRole'] . "' OR sc.privatemgr=0") .

    1442. 

  1442.          (!$docgrp ? "" : " OR dg.document_group IN ($docgrp)");

    1443. 

  1443.         $sql= "SELECT DISTINCT $fields

    1444. 

  1444.               FROM $tblsc sc

    1445. 

  1445.               LEFT JOIN $tbldg dg on dg.document = sc.id

    1446. 

  1446.               WHERE sc.parent = '$parentid' AND sc.published=$published AND sc.deleted=$deleted $where

    1447. 

  1447.               AND ($access)

    1448. 

  1448.               GROUP BY sc.id " .

    1449. 

  1449.          ($sort ? " ORDER BY $sort $dir " : "") . " $limit ";

    1450. 

  1450.         $result= $this->db->query($sql);

    1451. 

  1451.         $resourceArray= array ();

    1452. 

  1452.         for ($i= 0; $i < @ $this->db->getRecordCount($result); $i++) {

    1453. 

  1453.             array_push($resourceArray, @ $this->db->getRow($result));

    1454. 

  1454.         }

    1455. 

  1455.         return $resourceArray;

    1456. 

  1456.     }

    1457. 

  1457. 

    1458. 

  1458.     function getDocuments($ids= array (), $published= 1, $deleted= 0, $fields= "*", $where= '', $sort= "menuindex", $dir= "ASC", $limit= "") {

    1459. 

  1459.         if (count($ids) == 0) {

    1460. 

  1460.             return false;

    1461. 

  1461.         } else {

    1462. 

  1462.             $limit= ($limit != "") ? "LIMIT $limit" : ""; // LIMIT capabilities - rad14701

    1463. 

  1463.             $tblsc= $this->getFullTableName("site_content");

    1464. 

  1464.             $tbldg= $this->getFullTableName("document_groups");

    1465. 

  1465.             // modify field names to use sc. table reference

    1466. 

  1466.             $fields= 'sc.' . implode(',sc.', preg_replace("/^\s/i", "", explode(',', $fields)));

    1467. 

  1467.             $sort= ($sort == "") ? "" : 'sc.' . implode(',sc.', preg_replace("/^\s/i", "", explode(',', $sort)));

    1468. 

  1468.             if ($where != '')

    1469. 

  1469.                 $where= 'AND ' . $where;

    1470. 

  1470.             // get document groups for current user

    1471. 

  1471.             if ($docgrp= $this->getUserDocGroups())

    1472. 

  1472.                 $docgrp= implode(",", $docgrp);

    1473. 

  1473.             $access= ($this->isFrontend() ? "sc.privateweb=0" : "1='" . $_SESSION['mgrRole'] . "' OR sc.privatemgr=0") .

    1474. 

  1474.              (!$docgrp ? "" : " OR dg.document_group IN ($docgrp)");

    1475. 

  1475.             $sql= "SELECT DISTINCT $fields FROM $tblsc sc

    1476. 

  1476.                     LEFT JOIN $tbldg dg on dg.document = sc.id

    1477. 

  1477.                     WHERE (sc.id IN (" . implode(",",$ids) . ") AND sc.published=$published AND sc.deleted=$deleted $where)

    1478. 

  1478.                     AND ($access)

    1479. 

  1479.                     GROUP BY sc.id " .

    1480. 

  1480.              ($sort ? " ORDER BY $sort $dir" : "") . " $limit ";

    1481. 

  1481.             $result= $this->db->query($sql);

    1482. 

  1482.             $resourceArray= array ();

    1483. 

  1483.             for ($i= 0; $i < @ $this->db->getRecordCount($result); $i++) {

    1484. 

  1484.                 array_push($resourceArray, @ $this->db->getRow($result));

    1485. 

  1485.             }

    1486. 

  1486.             return $resourceArray;

    1487. 

  1487.         }

    1488. 

  1488.     }

    1489. 

  1489. 

    1490. 

  1490.     function getDocument($id= 0, $fields= "*", $published= 1, $deleted= 0) {

    1491. 

  1491.         if ($id == 0) {

    1492. 

  1492.             return false;

    1493. 

  1493.         } else {

    1494. 

  1494.             $tmpArr[]= $id;

    1495. 

  1495.             $docs= $this->getDocuments($tmpArr, $published, $deleted, $fields, "", "", "", 1);

    1496. 

  1496.             if ($docs != false) {

    1497. 

  1497.                 return $docs[0];

    1498. 

  1498.             } else {

    1499. 

  1499.                 return false;

    1500. 

  1500.             }

    1501. 

  1501.         }

    1502. 

  1502.     }

    1503. 

  1503. 

    1504. 

  1504.     function getPageInfo($pageid= -1, $active= 1, $fields= 'id, pagetitle, description, alias') {

    1505. 

  1505.         if ($pageid == 0) {

    1506. 

  1506.             return false;

    1507. 

  1507.         } else {

    1508. 

  1508.             $tblsc= $this->getFullTableName("site_content");

    1509. 

  1509.             $tbldg= $this->getFullTableName("document_groups");

    1510. 

  1510.             $activeSql= $active == 1 ? "AND sc.published=1 AND sc.deleted=0" : "";

    1511. 

  1511.             // modify field names to use sc. table reference

    1512. 

  1512.             $fields= 'sc.' . implode(',sc.', preg_replace("/^\s/i", "", explode(',', $fields)));

    1513. 

  1513.             // get document groups for current user

    1514. 

  1514.             if ($docgrp= $this->getUserDocGroups())

    1515. 

  1515.                 $docgrp= implode(",", $docgrp);

    1516. 

  1516.             $access= ($this->isFrontend() ? "sc.privateweb=0" : "1='" . $_SESSION['mgrRole'] . "' OR sc.privatemgr=0") .

    1517. 

  1517.              (!$docgrp ? "" : " OR dg.document_group IN ($docgrp)");

    1518. 

  1518.             $sql= "SELECT $fields

    1519. 

  1519.                     FROM $tblsc sc

    1520. 

  1520.                     LEFT JOIN $tbldg dg on dg.document = sc.id

    1521. 

  1521.                     WHERE (sc.id=$pageid $activeSql)

    1522. 

  1522.                     AND ($access)

    1523. 

  1523.                     LIMIT 1 ";

    1524. 

  1524.             $result= $this->db->query($sql);

    1525. 

  1525.             $pageInfo= @ $this->db->getRow($result);

    1526. 

  1526.             return $pageInfo;

    1527. 

  1527.         }

    1528. 

  1528.     }

    1529. 

  1529. 

    1530. 

  1530.     function getParent($pid= -1, $active= 1, $fields= 'id, pagetitle, description, alias, parent') {

    1531. 

  1531.         if ($pid == -1) {

    1532. 

  1532.             $pid= $this->documentObject['parent'];

    1533. 

  1533.             return ($pid == 0) ? false : $this->getPageInfo($pid, $active, $fields);

    1534. 

  1534.         } else

    1535. 

  1535.             if ($pid == 0) {

    1536. 

  1536.                 return false;

    1537. 

  1537.             } else {

    1538. 

  1538.                 // first get the child document

    1539. 

  1539.                 $child= $this->getPageInfo($pid, $active, "parent");

    1540. 

  1540.                 // now return the child's parent

    1541. 

  1541.                 $pid= ($child['parent']) ? $child['parent'] : 0;

    1542. 

  1542.                 return ($pid == 0) ? false : $this->getPageInfo($pid, $active, $fields);

    1543. 

  1543.             }

    1544. 

  1544.     }

    1545. 

  1545. 

    1546. 

  1546.     function getSnippetId() {

    1547. 

  1547.         if ($this->currentSnippet) {

    1548. 

  1548.             $tbl= $this->getFullTableName("site_snippets");

    1549. 

  1549.             $rs= $this->db->query("SELECT id FROM $tbl WHERE name='" . $this->db->escape($this->currentSnippet) . "' LIMIT 1");

    1550. 

  1550.             $row= @ $this->db->getRow($rs);

    1551. 

  1551.             if ($row['id'])

    1552. 

  1552.                 return $row['id'];

    1553. 

  1553.         }

    1554. 

  1554.         return 0;

    1555. 

  1555.     }

    1556. 

  1556. 

    1557. 

  1557.     function getSnippetName() {

    1558. 

  1558.         return $this->currentSnippet;

    1559. 

  1559.     }

    1560. 

  1560. 

    1561. 

  1561.     function clearCache() {

    1562. 

  1562.         $basepath= $this->config["base_path"] . "assets/cache";

    1563. 

  1563.         if (@ $handle= opendir($basepath)) {

    1564. 

  1564.             $filesincache= 0;

    1565. 

  1565.             $deletedfilesincache= 0;

    1566. 

  1566.             while (false !== ($file= readdir($handle))) {

    1567. 

  1567.                 if ($file != "." && $file != "..") {

    1568. 

  1568.                     $filesincache += 1;

    1569. 

  1569.                     if (preg_match("/\.pageCache/", $file)) {

    1570. 

  1570.                         $deletedfilesincache += 1;

    1571. 

  1571.                         unlink($basepath . "/" . $file);

    1572. 

  1572.                     }

    1573. 

  1573.                 }

    1574. 

  1574.             }

    1575. 

  1575.             closedir($handle);

    1576. 

  1576.             return true;

    1577. 

  1577.         } else {

    1578. 

  1578.             return false;

    1579. 

  1579.         }

    1580. 

  1580.     }

    1581. 

  1581. 

    1582. 

  1582.     function makeUrl($id, $alias= '', $args= '', $scheme= '') {

    1583. 

  1583.         $url= '';

    1584. 

  1584.         $virtualDir= '';

    1585. 

  1585.         $f_url_prefix = $this->config['friendly_url_prefix'];

    1586. 

  1586.         $f_url_suffix = $this->config['friendly_url_suffix'];

    1587. 

  1587.         if (!is_numeric($id)) {

    1588. 

  1588.             $this->messageQuit('`' . $id . '` is not numeric and may not be passed to makeUrl()');

    1589. 

  1589.         }

    1590. 

  1590.         if ($args != '' && $this->config['friendly_urls'] == 1) {

    1591. 

  1591.             // add ? to $args if missing

    1592. 

  1592.             $c= substr($args, 0, 1);

    1593. 

  1593.             if (strpos($f_url_prefix, '?') === false) {

    1594. 

  1594.                 if ($c == '&')

    1595. 

  1595.                     $args= '?' . substr($args, 1);

    1596. 

  1596.                 elseif ($c != '?') $args= '?' . $args;

    1597. 

  1597.             } else {

    1598. 

  1598.                 if ($c == '?')

    1599. 

  1599.                     $args= '&' . substr($args, 1);

    1600. 

  1600.                 elseif ($c != '&') $args= '&' . $args;

    1601. 

  1601.             }

    1602. 

  1602.         }

    1603. 

  1603.         elseif ($args != '') {

    1604. 

  1604.             // add & to $args if missing

    1605. 

  1605.             $c= substr($args, 0, 1);

    1606. 

  1606.             if ($c == '?')

    1607. 

  1607.                 $args= '&' . substr($args, 1);

    1608. 

  1608.             elseif ($c != '&') $args= '&' . $args;

    1609. 

  1609.         }

    1610. 

  1610.         if ($this->config['friendly_urls'] == 1 && $alias != '') {

    1611. 

  1611.             $url= $f_url_prefix . $alias . $f_url_suffix . $args;

    1612. 

  1612.         }

    1613. 

  1613.         elseif ($this->config['friendly_urls'] == 1 && $alias == '') {

    1614. 

  1614.             $alias= $id;

    1615. 

  1615.             if ($this->config['friendly_alias_urls'] == 1) {

    1616. 

  1616.                 $al= $this->aliasListing[$id];

    1617. 

  1617.                 $alPath= !empty ($al['path']) ? $al['path'] . '/' : '';

    1618. 

  1618.                 if ($al && $al['alias'])

    1619. 

  1619.                     $alias= $al['alias'];

    1620. 

  1620.             }

    1621. 

  1621.             $alias= $alPath . $f_url_prefix . $alias . $f_url_suffix;

    1622. 

  1622.             $url= $alias . $args;

    1623. 

  1623.         } else {

    1624. 

  1624.             $url= 'index.php?id=' . $id . $args;

    1625. 

  1625.         }

    1626. 

  1626. 

    1627. 

  1627.         $host= $this->config['base_url'];

    1628. 

  1628.         // check if scheme argument has been set

    1629. 

  1629.         if ($scheme != '') {

    1630. 

  1630.             // for backward compatibility - check if the desired scheme is different than the current scheme

    1631. 

  1631.             if (is_numeric($scheme) && $scheme != $_SERVER['HTTPS']) {

    1632. 

  1632.                 $scheme= ($_SERVER['HTTPS'] ? 'http' : 'https');

    1633. 

  1633.             }

    1634. 

  1634. 

    1635. 

  1635.             // to-do: check to make sure that $site_url incudes the url :port (e.g. :8080)

    1636. 

  1636.             $host= $scheme == 'full' ? $this->config['site_url'] : $scheme . '://' . $_SERVER['HTTP_HOST'] . $host;

    1637. 

  1637.         }

    1638. 

  1638. 

    1639. 

  1639.         if ($this->config['xhtml_urls']) {

    1640. 

  1640.         	return preg_replace("/&(?!amp;)/","&amp;", $host . $virtualDir . $url);

    1641. 

  1641.         } else {

    1642. 

  1642.         	return $host . $virtualDir . $url;

    1643. 

  1643.         }

    1644. 

  1644.     }

    1645. 

  1645. 

    1646. 

  1646.     function getConfig($name= '') {

    1647. 

  1647.         if (!empty ($this->config[$name])) {

    1648. 

  1648.             return $this->config[$name];

    1649. 

  1649.         } else {

    1650. 

  1650.             return false;

    1651. 

  1651.         }

    1652. 

  1652.     }

    1653. 

  1653. 

    1654. 

  1654.     function getVersionData() {

    1655. 

  1655.         include $this->config["base_path"] . "manager/includes/version.inc.php";

    1656. 

  1656.         $v= array ();

    1657. 

  1657.         $v['version']= $modx_version;

    1658. 

  1658.         $v['branch']= $modx_branch;

    1659. 

  1659.         $v['release_date']= $modx_release_date;

    1660. 

  1660.         $v['full_appname']= $modx_full_appname;

    1661. 

  1661.         return $v;

    1662. 

  1662.     }

    1663. 

  1663. 

    1664. 

  1664.     function makeList($array, $ulroot= 'root', $ulprefix= 'sub_', $type= '', $ordered= false, $tablevel= 0) {

    1665. 

  1665.         // first find out whether the value passed is an array

    1666. 

  1666.         if (!is_array($array)) {

    1667. 

  1667.             return "<ul><li>Bad list</li></ul>";

    1668. 

  1668.         }

    1669. 

  1669.         if (!empty ($type)) {

    1670. 

  1670.             $typestr= " style='list-style-type: $type'";

    1671. 

  1671.         } else {

    1672. 

  1672.             $typestr= "";

    1673. 

  1673.         }

    1674. 

  1674.         $tabs= "";

    1675. 

  1675.         for ($i= 0; $i < $tablevel; $i++) {

    1676. 

  1676.             $tabs .= "\t";

    1677. 

  1677.         }

    1678. 

  1678.         $listhtml= $ordered == true ? $tabs . "<ol class='$ulroot'$typestr>\n" : $tabs . "<ul class='$ulroot'$typestr>\n";

    1679. 

  1679.         foreach ($array as $key => $value) {

    1680. 

  1680.             if (is_array($value)) {

    1681. 

  1681.                 $listhtml .= $tabs . "\t<li>" . $key . "\n" . $this->makeList($value, $ulprefix . $ulroot, $ulprefix, $type, $ordered, $tablevel +2) . $tabs . "\t</li>\n";

    1682. 

  1682.             } else {

    1683. 

  1683.                 $listhtml .= $tabs . "\t<li>" . $value . "</li>\n";

    1684. 

  1684.             }

    1685. 

  1685.         }

    1686. 

  1686.         $listhtml .= $ordered == true ? $tabs . "</ol>\n" : $tabs . "</ul>\n";

    1687. 

  1687.         return $listhtml;

    1688. 

  1688.     }

    1689. 

  1689. 

    1690. 

  1690.     function userLoggedIn() {

    1691. 

  1691.         $userdetails= array ();

    1692. 

  1692.         if ($this->isFrontend() && isset ($_SESSION['webValidated'])) {

    1693. 

  1693.             // web user

    1694. 

  1694.             $userdetails['loggedIn']= true;

    1695. 

  1695.             $userdetails['id']= $_SESSION['webInternalKey'];

    1696. 

  1696.             $userdetails['username']= $_SESSION['webShortname'];

    1697. 

  1697.             $userdetails['usertype']= 'web'; // added by Raymond

    1698. 

  1698.             return $userdetails;

    1699. 

  1699.         } else

    1700. 

  1700.             if ($this->isBackend() && isset ($_SESSION['mgrValidated'])) {

    1701. 

  1701.                 // manager user

    1702. 

  1702.                 $userdetails['loggedIn']= true;

    1703. 

  1703.                 $userdetails['id']= $_SESSION['mgrInternalKey'];

    1704. 

  1704.                 $userdetails['username']= $_SESSION['mgrShortname'];

    1705. 

  1705.                 $userdetails['usertype']= 'manager'; // added by Raymond

    1706. 

  1706.                 return $userdetails;

    1707. 

  1707.             } else {

    1708. 

  1708.                 return false;

    1709. 

  1709.             }

    1710. 

  1710.     }

    1711. 

  1711. 

    1712. 

  1712.     function getKeywords($id= 0) {

    1713. 

  1713.         if ($id == 0) {

    1714. 

  1714.             $id= $this->documentObject['id'];

    1715. 

  1715.         }

    1716. 

  1716.         $tblKeywords= $this->getFullTableName('site_keywords');

    1717. 

  1717.         $tblKeywordXref= $this->getFullTableName('keyword_xref');

    1718. 

  1718.         $sql= "SELECT keywords.keyword FROM " . $tblKeywords . " AS keywords INNER JOIN " . $tblKeywordXref . " AS xref ON keywords.id=xref.keyword_id WHERE xref.content_id = '$id'";

    1719. 

  1719.         $result= $this->db->query($sql);

    1720. 

  1720.         $limit= $this->db->getRecordCount($result);

    1721. 

  1721.         $keywords= array ();

    1722. 

  1722.         if ($limit > 0) {

    1723. 

  1723.             for ($i= 0; $i < $limit; $i++) {

    1724. 

  1724.                 $row= $this->db->getRow($result);

    1725. 

  1725.                 $keywords[]= $row['keyword'];

    1726. 

  1726.             }

    1727. 

  1727.         }

    1728. 

  1728.         return $keywords;

    1729. 

  1729.     }

    1730. 

  1730. 

    1731. 

  1731.     function getMETATags($id= 0) {

    1732. 

  1732.         if ($id == 0) {

    1733. 

  1733.             $id= $this->documentObject['id'];

    1734. 

  1734.         }

    1735. 

  1735.         $sql= "SELECT smt.* " .

    1736. 

  1736.         "FROM " . $this->getFullTableName("site_metatags") . " smt " .

    1737. 

  1737.         "INNER JOIN " . $this->getFullTableName("site_content_metatags") . " cmt ON cmt.metatag_id=smt.id " .

    1738. 

  1738.         "WHERE cmt.content_id = '$id'";

    1739. 

  1739.         $ds= $this->db->query($sql);

    1740. 

  1740.         $limit= $this->db->getRecordCount($ds);

    1741. 

  1741.         $metatags= array ();

    1742. 

  1742.         if ($limit > 0) {

    1743. 

  1743.             for ($i= 0; $i < $limit; $i++) {

    1744. 

  1744.                 $row= $this->db->getRow($ds);

    1745. 

  1745.                 $metatags[$row['name']]= array (

    1746. 

  1746.                     "tag" => $row['tag'],

    1747. 

  1747.                     "tagvalue" => $row['tagvalue'],

    1748. 

  1748.                     "http_equiv" => $row['http_equiv']

    1749. 

  1749.                 );

    1750. 

  1750.             }

    1751. 

  1751.         }

    1752. 

  1752.         return $metatags;

    1753. 

  1753.     }

    1754. 

  1754. 

    1755. 

  1755.     function runSnippet($snippetName, $params= array ()) {

    1756. 

  1756.         if (isset ($this->snippetCache[$snippetName])) {

    1757. 

  1757.             $snippet= $this->snippetCache[$snippetName];

    1758. 

  1758.             $properties= $this->snippetCache[$snippetName . "Props"];

    1759. 

  1759.         } else { // not in cache so let's check the db

    1760. 

  1760.             $sql= "SELECT `name`, `snippet`, `properties` FROM " . $this->getFullTableName("site_snippets") . " WHERE " . $this->getFullTableName("site_snippets") . ".`name`='" . $this->db->escape($snippetName) . "';";

    1761. 

  1761.             $result= $this->db->query($sql);

    1762. 

  1762.             if ($this->db->getRecordCount($result) == 1) {

    1763. 

  1763.                 $row= $this->db->getRow($result);

    1764. 

  1764.                 $snippet= $this->snippetCache[$row['name']]= $row['snippet'];

    1765. 

  1765.                 $properties= $this->snippetCache[$row['name'] . "Props"]= $row['properties'];

    1766. 

  1766.             } else {

    1767. 

  1767.                 $snippet= $this->snippetCache[$snippetName]= "return false;";

    1768. 

  1768.                 $properties= '';

    1769. 

  1769.             }

    1770. 

  1770.         }

    1771. 

  1771.         // load default params/properties

    1772. 

  1772.         $parameters= $this->parseProperties($properties);

    1773. 

  1773.         $parameters= array_merge($parameters, $params);

    1774. 

  1774.         // run snippet

    1775. 

  1775.         return $this->evalSnippet($snippet, $parameters);

    1776. 

  1776.     }

    1777. 

  1777. 

    1778. 

  1778.     function getChunk($chunkName) {

    1779. 

  1779.         $t= $this->chunkCache[$chunkName];

    1780. 

  1780.         return $t;

    1781. 

  1781.     }

    1782. 

  1782. 

    1783. 

  1783.     // deprecated

    1784. 

  1784.     function putChunk($chunkName) { // alias name >.<

    1785. 

  1785.         return $this->getChunk($chunkName);

    1786. 

  1786.     }

    1787. 

  1787. 

    1788. 

  1788.     function parseChunk($chunkName, $chunkArr, $prefix= "{", $suffix= "}") {

    1789. 

  1789.         if (!is_array($chunkArr)) {

    1790. 

  1790.             return false;

    1791. 

  1791.         }

    1792. 

  1792.         $chunk= $this->getChunk($chunkName);

    1793. 

  1793.         foreach ($chunkArr as $key => $value) {

    1794. 

  1794.             $chunk= str_replace($prefix . $key . $suffix, $value, $chunk);

    1795. 

  1795.         }

    1796. 

  1796.         return $chunk;

    1797. 

  1797.     }

    1798. 

  1798. 

    1799. 

  1799.     function getUserData() {

    1800. 

  1800.         include $this->config["base_path"] . "manager/includes/extenders/getUserData.extender.php";

    1801. 

  1801.         return $tmpArray;

    1802. 

  1802.     }

    1803. 

  1803. 

    1804. 

  1804.     function toDateFormat($timestamp = 0, $mode = '') {

    1805. 

  1805.         $timestamp = trim($timestamp);

    1806. 

  1806.         $timestamp = intval($timestamp);

    1807. 

  1807.         

    1808. 

  1808.         switch($this->config['datetime_format']) {

    1809. 

  1809.             case 'YYYY/mm/dd':

    1810. 

  1810.                 $dateFormat = '%Y/%m/%d';

    1811. 

  1811.                 break;

    1812. 

  1812.             case 'dd-mm-YYYY':

    1813. 

  1813.                 $dateFormat = '%d-%m-%Y';

    1814. 

  1814.                 break;

    1815. 

  1815.             case 'mm/dd/YYYY':

    1816. 

  1816.                 $dateFormat = '%m/%d/%Y';

    1817. 

  1817.                 break;

    1818. 

  1818.             /*

    1819. 

  1819.             case 'dd-mmm-YYYY':

    1820. 

  1820.                 $dateFormat = '%e-%b-%Y';

    1821. 

  1821.                 break;

    1822. 

  1822.             */

    1823. 

  1823.         }

    1824. 

  1824.         

    1825. 

  1825.         if (empty($mode)) {

    1826. 

  1826.             $strTime = strftime($dateFormat . " %H:%M:%S", $timestamp);

    1827. 

  1827.         } elseif ($mode == 'dateOnly') {

    1828. 

  1828.             $strTime = strftime($dateFormat, $timestamp);

    1829. 

  1829.         } elseif ($mode == 'formatOnly') {

    1830. 

  1830.         	$strTime = $dateFormat;

    1831. 

  1831.         }

    1832. 

  1832.         return $strTime;

    1833. 

  1833.     }

    1834. 

  1834. 

    1835. 

  1835.     function toTimeStamp($str) {

    1836. 

  1836.         $str = trim($str);

    1837. 

  1837.         if (empty($str)) {return '';}

    1838. 

  1838. 

    1839. 

  1839.         switch($this->config['datetime_format']) {

    1840. 

  1840.             case 'YYYY/mm/dd':

    1841. 

  1841.             	if (!preg_match('/^[0-9]{4}\/[0-9]{2}\/[0-9]{2}[0-9 :]*$/', $str)) {return '';}

    1842. 

  1842.                 list ($Y, $m, $d, $H, $M, $S) = sscanf($str, '%4d/%2d/%2d %2d:%2d:%2d');

    1843. 

  1843.                 break;

    1844. 

  1844.             case 'dd-mm-YYYY':

    1845. 

  1845.             	if (!preg_match('/^[0-9]{2}-[0-9]{2}-[0-9]{4}[0-9 :]*$/', $str)) {return '';}

    1846. 

  1846.                 list ($d, $m, $Y, $H, $M, $S) = sscanf($str, '%2d-%2d-%4d %2d:%2d:%2d');

    1847. 

  1847.                 break;

    1848. 

  1848.             case 'mm/dd/YYYY':

    1849. 

  1849.             	if (!preg_match('/^[0-9]{2}\/[0-9]{2}\/[0-9]{4}[0-9 :]*$/', $str)) {return '';}

    1850. 

  1850.                 list ($m, $d, $Y, $H, $M, $S) = sscanf($str, '%2d/%2d/%4d %2d:%2d:%2d');

    1851. 

  1851.                 break;

    1852. 

  1852.             /*

    1853. 

  1853.             case 'dd-mmm-YYYY':

    1854. 

  1854.             	if (!preg_match('/^[0-9]{2}-[0-9a-z]+-[0-9]{4}[0-9 :]*$/i', $str)) {return '';}

    1855. 

  1855.             	list ($m, $d, $Y, $H, $M, $S) = sscanf($str, '%2d-%3s-%4d %2d:%2d:%2d');

    1856. 

  1856.                 break;

    1857. 

  1857.             */

    1858. 

  1858.         }

    1859. 

  1859.         if (!$H && !$M && !$S) {$H = 0; $M = 0; $S = 0;}

    1860. 

  1860.         $timeStamp = mktime($H, $M, $S, $m, $d, $Y);

    1861. 

  1861.         $timeStamp = intval($timeStamp);

    1862. 

  1862.         return $timeStamp;

    1863. 

  1863.     }

    1864. 

  1864. 

    1865. 

  1865.     #::::::::::::::::::::::::::::::::::::::::

    1866. 

  1866.     # Added By: Raymond Irving - MODx

    1867. 

  1867.     #

    1868. 

  1868. 

    1869. 

  1869.     function getDocumentChildrenTVars($parentid= 0, $tvidnames= array (), $published= 1, $docsort= "menuindex", $docsortdir= "ASC", $tvfields= "*", $tvsort= "rank", $tvsortdir= "ASC") {

    1870. 

  1870.         $docs= $this->getDocumentChildren($parentid, $published, 0, '*', '', $docsort, $docsortdir);

    1871. 

  1871.         if (!$docs)

    1872. 

  1872.             return false;

    1873. 

  1873.         else {

    1874. 

  1874.             $result= array ();

    1875. 

  1875.             // get user defined template variables

    1876. 

  1876.             $fields= ($tvfields == "") ? "tv.*" : 'tv.' . implode(',tv.', preg_replace("/^\s/i", "", explode(',', $tvfields)));

    1877. 

  1877.             $tvsort= ($tvsort == "") ? "" : 'tv.' . implode(',tv.', preg_replace("/^\s/i", "", explode(',', $tvsort)));

    1878. 

  1878.             if ($tvidnames == "*")

    1879. 

  1879.                 $query= "tv.id<>0";

    1880. 

  1880.             else

    1881. 

  1881.                 $query= (is_numeric($tvidnames[0]) ? "tv.id" : "tv.name") . " IN ('" . implode("','", $tvidnames) . "')";

    1882. 

  1882.             if ($docgrp= $this->getUserDocGroups())

    1883. 

  1883.                 $docgrp= implode(",", $docgrp);

    1884. 

  1884. 

    1885. 

  1885.             $docCount= count($docs);

    1886. 

  1886.             for ($i= 0; $i < $docCount; $i++) {

    1887. 

  1887. 

    1888. 

  1888.                 $tvs= array ();

    1889. 

  1889.                 $docRow= $docs[$i];

    1890. 

  1890.                 $docid= $docRow['id'];

    1891. 

  1891. 

    1892. 

  1892.                 $sql= "SELECT $fields, IF(tvc.value!='',tvc.value,tv.default_text) as value ";

    1893. 

  1893.                 $sql .= "FROM " . $this->getFullTableName('site_tmplvars') . " tv ";

    1894. 

  1894.                 $sql .= "INNER JOIN " . $this->getFullTableName('site_tmplvar_templates')." tvtpl ON tvtpl.tmplvarid = tv.id ";

    1895. 

  1895.                 $sql .= "LEFT JOIN " . $this->getFullTableName('site_tmplvar_contentvalues')." tvc ON tvc.tmplvarid=tv.id AND tvc.contentid = '" . $docid . "' ";

    1896. 

  1896.                 $sql .= "WHERE " . $query . " AND tvtpl.templateid = " . $docRow['template'];

    1897. 

  1897.                 if ($tvsort)

    1898. 

  1898.                     $sql .= " ORDER BY $tvsort $tvsortdir ";

    1899. 

  1899.                 $rs= $this->db->query($sql);

    1900. 

  1900.                 $limit= @ $this->db->getRecordCount($rs);

    1901. 

  1901.                 for ($x= 0; $x < $limit; $x++) {

    1902. 

  1902.                     array_push($tvs, @ $this->db->getRow($rs));

    1903. 

  1903.                 }

    1904. 

  1904. 

    1905. 

  1905.                 // get default/built-in template variables

    1906. 

  1906.                 ksort($docRow);

    1907. 

  1907.                 foreach ($docRow as $key => $value) {

    1908. 

  1908.                     if ($tvidnames == "*" || in_array($key, $tvidnames))

    1909. 

  1909.                         array_push($tvs, array (

    1910. 

  1910.                             "name" => $key,

    1911. 

  1911.                             "value" => $value

    1912. 

  1912.                         ));

    1913. 

  1913.                 }

    1914. 

  1914. 

    1915. 

  1915.                 if (count($tvs))

    1916. 

  1916.                     array_push($result, $tvs);

    1917. 

  1917.             }

    1918. 

  1918.             return $result;

    1919. 

  1919.         }

    1920. 

  1920.     }

    1921. 

  1921. 

    1922. 

  1922.     function getDocumentChildrenTVarOutput($parentid= 0, $tvidnames= array (), $published= 1, $docsort= "menuindex", $docsortdir= "ASC") {

    1923. 

  1923.         $docs= $this->getDocumentChildren($parentid, $published, 0, '*', '', $docsort, $docsortdir);

    1924. 

  1924.         if (!$docs)

    1925. 

  1925.             return false;

    1926. 

  1926.         else {

    1927. 

  1927.             $result= array ();

    1928. 

  1928.             for ($i= 0; $i < count($docs); $i++) {

    1929. 

  1929.                 $tvs= $this->getTemplateVarOutput($tvidnames, $docs[$i]["id"], $published);

    1930. 

  1930.                 if ($tvs)

    1931. 

  1931.                     $result[$docs[$i]['id']]= $tvs; // Use docid as key - netnoise 2006/08/14

    1932. 

  1932.             }

    1933. 

  1933.             return $result;

    1934. 

  1934.         }

    1935. 

  1935.     }

    1936. 

  1936. 

    1937. 

  1937.     // Modified by Raymond for TV - Orig Modified by Apodigm - DocVars

    1938. 

  1938.     # returns a single TV record. $idnames - can be an id or name that belongs the template that the current document is using

    1939. 

  1939.     function getTemplateVar($idname= "", $fields= "*", $docid= "", $published= 1) {

    1940. 

  1940.         if ($idname == "") {

    1941. 

  1941.             return false;

    1942. 

  1942.         } else {

    1943. 

  1943.             $result= $this->getTemplateVars(array ($idname), $fields, $docid, $published, "", ""); //remove sorting for speed

    1944. 

  1944.             return ($result != false) ? $result[0] : false;

    1945. 

  1945.         }

    1946. 

  1946.     }

    1947. 

  1947. 

    1948. 

  1948.     # returns an array of TV records. $idnames - can be an id or name that belongs the template that the current document is using

    1949. 

  1949.     function getTemplateVars($idnames= array (), $fields= "*", $docid= "", $published= 1, $sort= "rank", $dir= "ASC") {

    1950. 

  1950.         if (($idnames != '*' && !is_array($idnames)) || count($idnames) == 0) {

    1951. 

  1951.             return false;

    1952. 

  1952.         } else {

    1953. 

  1953.             $result= array ();

    1954. 

  1954. 

    1955. 

  1955.             // get document record

    1956. 

  1956.             if ($docid == "") {

    1957. 

  1957.                 $docid= $this->documentIdentifier;

    1958. 

  1958.                 $docRow= $this->documentObject;

    1959. 

  1959.             } else {

    1960. 

  1960.                 $docRow= $this->getDocument($docid, '*', $published);

    1961. 

  1961.                 if (!$docRow)

    1962. 

  1962.                     return false;

    1963. 

  1963.             }

    1964. 

  1964. 

    1965. 

  1965.             // get user defined template variables

    1966. 

  1966.             $fields= ($fields == "") ? "tv.*" : 'tv.' . implode(',tv.', preg_replace("/^\s/i", "", explode(',', $fields)));

    1967. 

  1967.             $sort= ($sort == "") ? "" : 'tv.' . implode(',tv.', preg_replace("/^\s/i", "", explode(',', $sort)));

    1968. 

  1968.             if ($idnames == "*")

    1969. 

  1969.                 $query= "tv.id<>0";

    1970. 

  1970.             else

    1971. 

  1971.                 $query= (is_numeric($idnames[0]) ? "tv.id" : "tv.name") . " IN ('" . implode("','", $idnames) . "')";

    1972. 

  1972.             if ($docgrp= $this->getUserDocGroups())

    1973. 

  1973.                 $docgrp= implode(",", $docgrp);

    1974. 

  1974.             $sql= "SELECT $fields, IF(tvc.value!='',tvc.value,tv.default_text) as value ";

    1975. 

  1975.             $sql .= "FROM " . $this->getFullTableName('site_tmplvars')." tv ";

    1976. 

  1976.             $sql .= "INNER JOIN " . $this->getFullTableName('site_tmplvar_templates')." tvtpl ON tvtpl.tmplvarid = tv.id ";

    1977. 

  1977.             $sql .= "LEFT JOIN " . $this->getFullTableName('site_tmplvar_contentvalues')." tvc ON tvc.tmplvarid=tv.id AND tvc.contentid = '" . $docid . "' ";

    1978. 

  1978.             $sql .= "WHERE " . $query . " AND tvtpl.templateid = " . $docRow['template'];

    1979. 

  1979.             if ($sort)

    1980. 

  1980.                 $sql .= " ORDER BY $sort $dir ";

    1981. 

  1981.             $rs= $this->db->query($sql);

    1982. 

  1982.             for ($i= 0; $i < @ $this->db->getRecordCount($rs); $i++) {

    1983. 

  1983.                 array_push($result, @ $this->db->getRow($rs));

    1984. 

  1984.             }

    1985. 

  1985. 

    1986. 

  1986.             // get default/built-in template variables

    1987. 

  1987.             ksort($docRow);

    1988. 

  1988.             foreach ($docRow as $key => $value) {

    1989. 

  1989.                 if ($idnames == "*" || in_array($key, $idnames))

    1990. 

  1990.                     array_push($result, array (

    1991. 

  1991.                         "name" => $key,

    1992. 

  1992.                         "value" => $value

    1993. 

  1993.                     ));

    1994. 

  1994.             }

    1995. 

  1995. 

    1996. 

  1996.             return $result;

    1997. 

  1997.         }

    1998. 

  1998.     }

    1999. 

  1999. 

    2000. 

  2000.     # returns an associative array containing TV rendered output values. $idnames - can be an id or name that belongs the template that the current document is using

    2001. 

  2001.     function getTemplateVarOutput($idnames= array (), $docid= "", $published= 1, $sep='') {

    2002. 

  2002.         if (count($idnames) == 0) {

    2003. 

  2003.             return false;

    2004. 

  2004.         } else {

    2005. 

  2005.             $output= array ();

    2006. 

  2006.             $vars= ($idnames == '*' || is_array($idnames)) ? $idnames : array ($idnames);

    2007. 

  2007.             $docid= intval($docid) ? intval($docid) : $this->documentIdentifier;

    2008. 

  2008.             $result= $this->getTemplateVars($vars, "*", $docid, $published, "", "", $sep); // remove sort for speed

    2009. 

  2009.             if ($result == false)

    2010. 

  2010.                 return false;

    2011. 

  2011.             else {

    2012. 

  2012. 		$baspath= $this->config["base_path"] . "manager/includes";

    2013. 

  2013. 		include_once $baspath . "/tmplvars.format.inc.php";

    2014. 

  2014. 		include_once $baspath . "/tmplvars.commands.inc.php";

    2015. 

  2015. 		for ($i= 0; $i < count($result); $i++) {

    2016. 

  2016. 			$row= $result[$i];

    2017. 

  2017. 			if (!$row['id'])

    2018. 

  2018. 				$output[$row['name']]= $row['value'];

    2019. 

  2019. 			else	$output[$row['name']]= getTVDisplayFormat($row['name'], $row['value'], $row['display'], $row['display_params'], $row['type'], $docid, $sep);

    2020. 

  2020. 		}

    2021. 

  2021. 		return $output;

    2022. 

  2022.             }

    2023. 

  2023.         }

    2024. 

  2024.     }

    2025. 

  2025. 

    2026. 

  2026.     # returns the full table name based on db settings

    2027. 

  2027.     function getFullTableName($tbl) {

    2028. 

  2028.         return $this->db->config['dbase'] . ".`" . $this->db->config['table_prefix'] . $tbl . "`";

    2029. 

  2029.     }

    2030. 

  2030. 

    2031. 

  2031.     # return placeholder value

    2032. 

  2032.     function getPlaceholder($name) {

    2033. 

  2033.         return $this->placeholders[$name];

    2034. 

  2034.     }

    2035. 

  2035. 

    2036. 

  2036.     # sets a value for a placeholder

    2037. 

  2037.     function setPlaceholder($name, $value) {

    2038. 

  2038.         $this->placeholders[$name]= $value;

    2039. 

  2039.     }

    2040. 

  2040. 

    2041. 

  2041.     # set arrays or object vars as placeholders

    2042. 

  2042.     function toPlaceholders($subject, $prefix= '') {

    2043. 

  2043.         if (is_object($subject)) {

    2044. 

  2044.             $subject= get_object_vars($subject);

    2045. 

  2045.         }

    2046. 

  2046.         if (is_array($subject)) {

    2047. 

  2047.             foreach ($subject as $key => $value) {

    2048. 

  2048.                 $this->toPlaceholder($key, $value, $prefix);

    2049. 

  2049.             }

    2050. 

  2050.         }

    2051. 

  2051.     }

    2052. 

  2052. 

    2053. 

  2053.     function toPlaceholder($key, $value, $prefix= '') {

    2054. 

  2054.         if (is_array($value) || is_object($value)) {

    2055. 

  2055.             $this->toPlaceholders($value, "{$prefix}{$key}.");

    2056. 

  2056.         } else {

    2057. 

  2057.             $this->setPlaceholder("{$prefix}{$key}", $value);

    2058. 

  2058.         }

    2059. 

  2059.     }

    2060. 

  2060. 

    2061. 

  2061.     # returns the virtual relative path to the manager folder

    2062. 

  2062.     function getManagerPath() {

    2063. 

  2063.         global $base_url;

    2064. 

  2064.         $pth= $base_url . 'manager/';

    2065. 

  2065.         return $pth;

    2066. 

  2066.     }

    2067. 

  2067. 

    2068. 

  2068.     # returns the virtual relative path to the cache folder

    2069. 

  2069.     function getCachePath() {

    2070. 

  2070.         global $base_url;

    2071. 

  2071.         $pth= $base_url . 'assets/cache/';

    2072. 

  2072.         return $pth;

    2073. 

  2073.     }

    2074. 

  2074. 

    2075. 

  2075.     # sends a message to a user's message box

    2076. 

  2076.     function sendAlert($type, $to, $from, $subject, $msg, $private= 0) {

    2077. 

  2077.         $private= ($private) ? 1 : 0;

    2078. 

  2078.         if (!is_numeric($to)) {

    2079. 

  2079.             // Query for the To ID

    2080. 

  2080.             $sql= "SELECT id FROM " . $this->getFullTableName("manager_users") . " WHERE username='$to';";

    2081. 

  2081.             $rs= $this->db->query($sql);

    2082. 

  2082.             if ($this->db->getRecordCount($rs)) {

    2083. 

  2083.                 $rs= $this->db->getRow($rs);

    2084. 

  2084.                 $to= $rs['id'];

    2085. 

  2085.             }

    2086. 

  2086.         }

    2087. 

  2087.         if (!is_numeric($from)) {

    2088. 

  2088.             // Query for the From ID

    2089. 

  2089.             $sql= "SELECT id FROM " . $this->getFullTableName("manager_users") . " WHERE username='$from';";

    2090. 

  2090.             $rs= $this->db->query($sql);

    2091. 

  2091.             if ($this->db->getRecordCount($rs)) {

    2092. 

  2092.                 $rs= $this->db->getRow($rs);

    2093. 

  2093.                 $from= $rs['id'];

    2094. 

  2094.             }

    2095. 

  2095.         }

    2096. 

  2096.         // insert a new message into user_messages

    2097. 

  2097.         $sql= "INSERT INTO " . $this->getFullTableName("user_messages") . " ( id , type , subject , message , sender , recipient , private , postdate , messageread ) VALUES ( '', '$type', '$subject', '$msg', '$from', '$to', '$private', '" . time() . "', '0' );";

    2098. 

  2098.         $rs= $this->db->query($sql);

    2099. 

  2099.     }

    2100. 

  2100. 

    2101. 

  2101.     # Returns true, install or interact when inside manager

    2102. 

  2102.     // deprecated

    2103. 

  2103.     function insideManager() {

    2104. 

  2104.         $m= false;

    2105. 

  2105.         if (defined('IN_MANAGER_MODE') && IN_MANAGER_MODE == 'true') {

    2106. 

  2106.             $m= true;

    2107. 

  2107.             if (defined('SNIPPET_INTERACTIVE_MODE') && SNIPPET_INTERACTIVE_MODE == 'true')

    2108. 

  2108.                 $m= "interact";

    2109. 

  2109.             else

    2110. 

  2110.                 if (defined('SNIPPET_INSTALL_MODE') && SNIPPET_INSTALL_MODE == 'true')

    2111. 

  2111.                     $m= "install";

    2112. 

  2112.         }

    2113. 

  2113.         return $m;

    2114. 

  2114.     }

    2115. 

  2115. 

    2116. 

  2116.     # Returns current user id

    2117. 

  2117.     function getLoginUserID($context= '') {

    2118. 

  2118.         if ($context && isset ($_SESSION[$context . 'Validated'])) {

    2119. 

  2119.             return $_SESSION[$context . 'InternalKey'];

    2120. 

  2120.         }

    2121. 

  2121.         elseif ($this->isFrontend() && isset ($_SESSION['webValidated'])) {

    2122. 

  2122.             return $_SESSION['webInternalKey'];

    2123. 

  2123.         }

    2124. 

  2124.         elseif ($this->isBackend() && isset ($_SESSION['mgrValidated'])) {

    2125. 

  2125.             return $_SESSION['mgrInternalKey'];

    2126. 

  2126.         }

    2127. 

  2127.     }

    2128. 

  2128. 

    2129. 

  2129.     # Returns current user name

    2130. 

  2130.     function getLoginUserName($context= '') {

    2131. 

  2131.         if (!empty($context) && isset ($_SESSION[$context . 'Validated'])) {

    2132. 

  2132.             return $_SESSION[$context . 'Shortname'];

    2133. 

  2133.         }

    2134. 

  2134.         elseif ($this->isFrontend() && isset ($_SESSION['webValidated'])) {

    2135. 

  2135.             return $_SESSION['webShortname'];

    2136. 

  2136.         }

    2137. 

  2137.         elseif ($this->isBackend() && isset ($_SESSION['mgrValidated'])) {

    2138. 

  2138.             return $_SESSION['mgrShortname'];

    2139. 

  2139.         }

    2140. 

  2140.     }

    2141. 

  2141. 

    2142. 

  2142.     # Returns current login user type - web or manager

    2143. 

  2143.     function getLoginUserType() {

    2144. 

  2144.         if ($this->isFrontend() && isset ($_SESSION['webValidated'])) {

    2145. 

  2145.             return 'web';

    2146. 

  2146.         }

    2147. 

  2147.         elseif ($this->isBackend() && isset ($_SESSION['mgrValidated'])) {

    2148. 

  2148.             return 'manager';

    2149. 

  2149.         } else {

    2150. 

  2150.             return '';

    2151. 

  2151.         }

    2152. 

  2152.     }

    2153. 

  2153. 

    2154. 

  2154.     # Returns a record for the manager user

    2155. 

  2155.     function getUserInfo($uid) {

    2156. 

  2156.         $sql= "

    2157. 

  2157.               SELECT mu.username, mu.password, mua.*

    2158. 

  2158.               FROM " . $this->getFullTableName("manager_users") . " mu

    2159. 

  2159.               INNER JOIN " . $this->getFullTableName("user_attributes") . " mua ON mua.internalkey=mu.id

    2160. 

  2160.               WHERE mu.id = '$uid'

    2161. 

  2161.               ";

    2162. 

  2162.         $rs= $this->db->query($sql);

    2163. 

  2163.         $limit= mysql_num_rows($rs);

    2164. 

  2164.         if ($limit == 1) {

    2165. 

  2165.             $row= $this->db->getRow($rs);

    2166. 

  2166.             if (!$row["usertype"])

    2167. 

  2167.                 $row["usertype"]= "manager";

    2168. 

  2168.             return $row;

    2169. 

  2169.         }

    2170. 

  2170.     }

    2171. 

  2171. 

    2172. 

  2172.     # Returns a record for the web user

    2173. 

  2173.     function getWebUserInfo($uid) {

    2174. 

  2174.         $sql= "

    2175. 

  2175.               SELECT wu.username, wu.password, wua.*

    2176. 

  2176.               FROM " . $this->getFullTableName("web_users") . " wu

    2177. 

  2177.               INNER JOIN " . $this->getFullTableName("web_user_attributes") . " wua ON wua.internalkey=wu.id

    2178. 

  2178.               WHERE wu.id='$uid'

    2179. 

  2179.               ";

    2180. 

  2180.         $rs= $this->db->query($sql);

    2181. 

  2181.         $limit= mysql_num_rows($rs);

    2182. 

  2182.         if ($limit == 1) {

    2183. 

  2183.             $row= $this->db->getRow($rs);

    2184. 

  2184.             if (!$row["usertype"])

    2185. 

  2185.                 $row["usertype"]= "web";

    2186. 

  2186.             return $row;

    2187. 

  2187.         }

    2188. 

  2188.     }

    2189. 

  2189. 

    2190. 

  2190.     # Returns an array of document groups that current user is assigned to.

    2191. 

  2191.     # This function will first return the web user doc groups when running from frontend otherwise it will return manager user's docgroup

    2192. 

  2192.     # Set $resolveIds to true to return the document group names

    2193. 

  2193.     function getUserDocGroups($resolveIds= false) {

    2194. 

  2194.         if ($this->isFrontend() && isset ($_SESSION['webDocgroups']) && isset ($_SESSION['webValidated'])) {

    2195. 

  2195.             $dg= $_SESSION['webDocgroups'];

    2196. 

  2196.             $dgn= isset ($_SESSION['webDocgrpNames']) ? $_SESSION['webDocgrpNames'] : false;

    2197. 

  2197.         } else

    2198. 

  2198.             if ($this->isBackend() && isset ($_SESSION['mgrDocgroups']) && isset ($_SESSION['mgrValidated'])) {

    2199. 

  2199.                 $dg= $_SESSION['mgrDocgroups'];

    2200. 

  2200.                 $dgn= $_SESSION['mgrDocgrpNames'];

    2201. 

  2201.             } else {

    2202. 

  2202.                 $dg= '';

    2203. 

  2203.             }

    2204. 

  2204.         if (!$resolveIds)

    2205. 

  2205.             return $dg;

    2206. 

  2206.         else

    2207. 

  2207.             if (is_array($dgn))

    2208. 

  2208.                 return $dgn;

    2209. 

  2209.             else

    2210. 

  2210.                 if (is_array($dg)) {

    2211. 

  2211.                     // resolve ids to names

    2212. 

  2212.                     $dgn= array ();

    2213. 

  2213.                     $tbl= $this->getFullTableName("documentgroup_names");

    2214. 

  2214.                     $ds= $this->db->query("SELECT name FROM $tbl WHERE id IN (" . implode(",", $dg) . ")");

    2215. 

  2215.                     while ($row= $this->db->getRow($ds))

    2216. 

  2216.                         $dgn[count($dgn)]= $row['name'];

    2217. 

  2217.                     // cache docgroup names to session

    2218. 

  2218.                     if ($this->isFrontend())

    2219. 

  2219.                         $_SESSION['webDocgrpNames']= $dgn;

    2220. 

  2220.                     else

    2221. 

  2221.                         $_SESSION['mgrDocgrpNames']= $dgn;

    2222. 

  2222.                     return $dgn;

    2223. 

  2223.                 }

    2224. 

  2224.     }

    2225. 

  2225.     function getDocGroups() {

    2226. 

  2226.         return $this->getUserDocGroups();

    2227. 

  2227.     } // deprecated

    2228. 

  2228. 

    2229. 

  2229.     # Change current web user's password - returns true if successful, oterhwise return error message

    2230. 

  2230.     function changeWebUserPassword($oldPwd, $newPwd) {

    2231. 

  2231.         $rt= false;

    2232. 

  2232.         if ($_SESSION["webValidated"] == 1) {

    2233. 

  2233.             $tbl= $this->getFullTableName("web_users");

    2234. 

  2234.             $ds= $this->db->query("SELECT `id`, `username`, `password` FROM $tbl WHERE `id`='" . $this->getLoginUserID() . "'");

    2235. 

  2235.             $limit= mysql_num_rows($ds);

    2236. 

  2236.             if ($limit == 1) {

    2237. 

  2237.                 $row= $this->db->getRow($ds);

    2238. 

  2238.                 if ($row["password"] == md5($oldPwd)) {

    2239. 

  2239.                     if (strlen($newPwd) < 6) {

    2240. 

  2240.                         return "Password is too short!";

    2241. 

  2241.                     }

    2242. 

  2242.                     elseif ($newPwd == "") {

    2243. 

  2243.                         return "You didn't specify a password for this user!";

    2244. 

  2244.                     } else {

    2245. 

  2245.                         $this->db->query("UPDATE $tbl SET password = md5('" . $this->db->escape($newPwd) . "') WHERE id='" . $this->getLoginUserID() . "'");

    2246. 

  2246.                         // invoke OnWebChangePassword event

    2247. 

  2247.                         $this->invokeEvent("OnWebChangePassword", array (

    2248. 

  2248.                             "userid" => $row["id"],

    2249. 

  2249.                             "username" => $row["username"],

    2250. 

  2250.                             "userpassword" => $newPwd

    2251. 

  2251.                         ));

    2252. 

  2252.                         return true;

    2253. 

  2253.                     }

    2254. 

  2254.                 } else {

    2255. 

  2255.                     return "Incorrect password.";

    2256. 

  2256.                 }

    2257. 

  2257.             }

    2258. 

  2258.         }

    2259. 

  2259.     }

    2260. 

  2260.     function changePassword($o, $n) {

    2261. 

  2261.         return changeWebUserPassword($o, $n);

    2262. 

  2262.     } // deprecated

    2263. 

  2263. 

    2264. 

  2264.     # returns true if the current web user is a member the specified groups

    2265. 

  2265.     function isMemberOfWebGroup($groupNames= array ()) {

    2266. 

  2266.         if (!is_array($groupNames))

    2267. 

  2267.             return false;

    2268. 

  2268.         // check cache

    2269. 

  2269.         $grpNames= isset ($_SESSION['webUserGroupNames']) ? $_SESSION['webUserGroupNames'] : false;

    2270. 

  2270.         if (!is_array($grpNames)) {

    2271. 

  2271.             $tbl= $this->getFullTableName("webgroup_names");

    2272. 

  2272.             $tbl2= $this->getFullTableName("web_groups");

    2273. 

  2273.             $sql= "SELECT wgn.name

    2274. 

  2274.                     FROM $tbl wgn

    2275. 

  2275.                     INNER JOIN $tbl2 wg ON wg.webgroup=wgn.id AND wg.webuser='" . $this->getLoginUserID() . "'";

    2276. 

  2276.             $grpNames= $this->db->getColumn("name", $sql);

    2277. 

  2277.             // save to cache

    2278. 

  2278.             $_SESSION['webUserGroupNames']= $grpNames;

    2279. 

  2279.         }

    2280. 

  2280.         foreach ($groupNames as $k => $v)

    2281. 

  2281.             if (in_array(trim($v), $grpNames))

    2282. 

  2282.                 return true;

    2283. 

  2283.         return false;

    2284. 

  2284.     }

    2285. 

  2285. 

    2286. 

  2286.     # Registers Client-side CSS scripts - these scripts are loaded at inside the <head> tag

    2287. 

  2287.     function regClientCSS($src, $media='') {

    2288. 

  2288.         if (empty($src) || isset ($this->loadedjscripts[$src]))

    2289. 

  2289.             return '';

    2290. 

  2290.         $nextpos= max(array_merge(array(0),array_keys($this->sjscripts)))+1;

    2291. 

  2291.         $this->loadedjscripts[$src]['startup']= true;

    2292. 

  2292.         $this->loadedjscripts[$src]['version']= '0';

    2293. 

  2293.         $this->loadedjscripts[$src]['pos']= $nextpos;

    2294. 

  2294.         if (strpos(strtolower($src), "<style") !== false || strpos(strtolower($src), "<link") !== false) {

    2295. 

  2295.             $this->sjscripts[$nextpos]= $src;

    2296. 

  2296.         } else {

    2297. 

  2297.             $this->sjscripts[$nextpos]= "\t" . '<link rel="stylesheet" type="text/css" href="'.$src.'" '.($media ? 'media="'.$media.'" ' : '').'/>';

    2298. 

  2298.         }

    2299. 

  2299.     }

    2300. 

  2300. 

    2301. 

  2301.     # Registers Startup Client-side JavaScript - these scripts are loaded at inside the <head> tag

    2302. 

  2302.     function regClientStartupScript($src, $options= array('name'=>'', 'version'=>'0', 'plaintext'=>false)) {

    2303. 

  2303.         $this->regClientScript($src, $options, true);

    2304. 

  2304.     }

    2305. 

  2305. 

    2306. 

  2306.     # Registers Client-side JavaScript 	- these scripts are loaded at the end of the page unless $startup is true

    2307. 

  2307.     function regClientScript($src, $options= array('name'=>'', 'version'=>'0', 'plaintext'=>false), $startup= false) {

    2308. 

  2308.         if (empty($src))

    2309. 

  2309.             return ''; // nothing to register

    2310. 

  2310.         if (!is_array($options)) {

    2311. 

  2311.             if (is_bool($options))  // backward compatibility with old plaintext parameter

    2312. 

  2312.                 $options=array('plaintext'=>$options);

    2313. 

  2313.             elseif (is_string($options)) // Also allow script name as 2nd param

    2314. 

  2314.                 $options=array('name'=>$options);

    2315. 

  2315.             else

    2316. 

  2316.                 $options=array();

    2317. 

  2317.         }

    2318. 

  2318.         $name= isset($options['name']) ? strtolower($options['name']) : '';

    2319. 

  2319.         $version= isset($options['version']) ? $options['version'] : '0';

    2320. 

  2320.         $plaintext= isset($options['plaintext']) ? $options['plaintext'] : false;

    2321. 

  2321.         $key= !empty($name) ? $name : $src;

    2322. 

  2322.         unset($overwritepos); // probably unnecessary--just making sure

    2323. 

  2323. 

    2324. 

  2324.         $useThisVer= true;

    2325. 

  2325.         if (isset($this->loadedjscripts[$key])) { // a matching script was found

    2326. 

  2326.             // if existing script is a startup script, make sure the candidate is also a startup script

    2327. 

  2327.             if ($this->loadedjscripts[$key]['startup'])

    2328. 

  2328.                 $startup= true;

    2329. 

  2329. 

    2330. 

  2330.             if (empty($name)) {

    2331. 

  2331.                 $useThisVer= false; // if the match was based on identical source code, no need to replace the old one

    2332. 

  2332.             } else {

    2333. 

  2333.                 $useThisVer = version_compare($this->loadedjscripts[$key]['version'], $version, '<');

    2334. 

  2334.             }

    2335. 

  2335. 

    2336. 

  2336.             if ($useThisVer) {

    2337. 

  2337.                 if ($startup==true && $this->loadedjscripts[$key]['startup']==false) {

    2338. 

  2338.                     // remove old script from the bottom of the page (new one will be at the top)

    2339. 

  2339.                     unset($this->jscripts[$this->loadedjscripts[$key]['pos']]);

    2340. 

  2340.                 } else {

    2341. 

  2341.                     // overwrite the old script (the position may be important for dependent scripts)

    2342. 

  2342.                     $overwritepos= $this->loadedjscripts[$key]['pos'];

    2343. 

  2343.                 }

    2344. 

  2344.             } else { // Use the original version

    2345. 

  2345.                 if ($startup==true && $this->loadedjscripts[$key]['startup']==false) {

    2346. 

  2346.                     // need to move the exisiting script to the head

    2347. 

  2347.                     $version= $this->loadedjscripts[$key][$version];

    2348. 

  2348.                     $src= $this->jscripts[$this->loadedjscripts[$key]['pos']];

    2349. 

  2349.                     unset($this->jscripts[$this->loadedjscripts[$key]['pos']]);

    2350. 

  2350.                 } else {

    2351. 

  2351.                     return ''; // the script is already in the right place

    2352. 

  2352.                 }

    2353. 

  2353.             }

    2354. 

  2354.         }

    2355. 

  2355. 

    2356. 

  2356.         if ($useThisVer && $plaintext!=true && (strpos(strtolower($src), "<script") === false))

    2357. 

  2357.             $src= "\t" . '<script type="text/javascript" src="' . $src . '"></script>';

    2358. 

  2358.         if ($startup) {

    2359. 

  2359.             $pos= isset($overwritepos) ? $overwritepos : max(array_merge(array(0),array_keys($this->sjscripts)))+1;

    2360. 

  2360.             $this->sjscripts[$pos]= $src;

    2361. 

  2361.         } else {

    2362. 

  2362.             $pos= isset($overwritepos) ? $overwritepos : max(array_merge(array(0),array_keys($this->jscripts)))+1;

    2363. 

  2363.             $this->jscripts[$pos]= $src;

    2364. 

  2364.         }

    2365. 

  2365.         $this->loadedjscripts[$key]['version']= $version;

    2366. 

  2366.         $this->loadedjscripts[$key]['startup']= $startup;

    2367. 

  2367.         $this->loadedjscripts[$key]['pos']= $pos;

    2368. 

  2368.     }

    2369. 

  2369. 

    2370. 

  2370.     # Registers Client-side Startup HTML block

    2371. 

  2371.     function regClientStartupHTMLBlock($html) {

    2372. 

  2372.         $this->regClientScript($html, true, true);

    2373. 

  2373.     }

    2374. 

  2374. 

    2375. 

  2375.     # Registers Client-side HTML block

    2376. 

  2376.     function regClientHTMLBlock($html) {

    2377. 

  2377.         $this->regClientScript($html, true);

    2378. 

  2378.     }

    2379. 

  2379. 

    2380. 

  2380.     # Remove unwanted html tags and snippet, settings and tags

    2381. 

  2381.     function stripTags($html, $allowed= "") {

    2382. 

  2382.         $t= strip_tags($html, $allowed);

    2383. 

  2383.         $t= preg_replace('~\[\*(.*?)\*\]~', "", $t); //tv

    2384. 

  2384.         $t= preg_replace('~\[\[(.*?)\]\]~', "", $t); //snippet

    2385. 

  2385.         $t= preg_replace('~\[\!(.*?)\!\]~', "", $t); //snippet

    2386. 

  2386.         $t= preg_replace('~\[\((.*?)\)\]~', "", $t); //settings

    2387. 

  2387.         $t= preg_replace('~\[\+(.*?)\+\]~', "", $t); //placeholders

    2388. 

  2388.         $t= preg_replace('~{{(.*?)}}~', "", $t); //chunks

    2389. 

  2389.         return $t;

    2390. 

  2390.     }

    2391. 

  2391. 

    2392. 

  2392.     # add an event listner to a plugin - only for use within the current execution cycle

    2393. 

  2393.     function addEventListener($evtName, $pluginName) {

    2394. 

  2394. 	    if (!$evtName || !$pluginName)

    2395. 

  2395. 		    return false;

    2396. 

  2396. 	    if (!array_key_exists($evtName,$this->pluginEvent))

    2397. 

  2397. 		    $this->pluginEvent[$evtName] = array();

    2398. 

  2398. 	    return array_push($this->pluginEvent[$evtName], $pluginName); // return array count

    2399. 

  2399.     }

    2400. 

  2400. 

    2401. 

  2401.     # remove event listner - only for use within the current execution cycle

    2402. 

  2402.     function removeEventListener($evtName) {

    2403. 

  2403.         if (!$evtName)

    2404. 

  2404.             return false;

    2405. 

  2405.         unset ($this->pluginEvent[$evtName]);

    2406. 

  2406.     }

    2407. 

  2407. 

    2408. 

  2408.     # remove all event listners - only for use within the current execution cycle

    2409. 

  2409.     function removeAllEventListener() {

    2410. 

  2410.         unset ($this->pluginEvent);

    2411. 

  2411.         $this->pluginEvent= array ();

    2412. 

  2412.     }

    2413. 

  2413. 

    2414. 

  2414.     # invoke an event. $extParams - hash array: name=>value

    2415. 

  2415.     function invokeEvent($evtName, $extParams= array ()) {

    2416. 

  2416.         if (!$evtName)

    2417. 

  2417.             return false;

    2418. 

  2418.         if (!isset ($this->pluginEvent[$evtName]))

    2419. 

  2419.             return false;

    2420. 

  2420.         $el= $this->pluginEvent[$evtName];

    2421. 

  2421.         $results= array ();

    2422. 

  2422.         $numEvents= count($el);

    2423. 

  2423.         if ($numEvents > 0)

    2424. 

  2424.             for ($i= 0; $i < $numEvents; $i++) { // start for loop

    2425. 

  2425.                 $pluginName= $el[$i];

    2426. 

  2426.                 $pluginName = stripslashes($pluginName);

    2427. 

  2427.                 // reset event object

    2428. 

  2428.                 $e= & $this->Event;

    2429. 

  2429.                 $e->_resetEventObject();

    2430. 

  2430.                 $e->name= $evtName;

    2431. 

  2431.                 $e->activePlugin= $pluginName;

    2432. 

  2432. 

    2433. 

  2433.                 // get plugin code

    2434. 

  2434.                 if (isset ($this->pluginCache[$pluginName])) {

    2435. 

  2435.                     $pluginCode= $this->pluginCache[$pluginName];

    2436. 

  2436.                     $pluginProperties= $this->pluginCache[$pluginName . "Props"];

    2437. 

  2437.                 } else {

    2438. 

  2438.                     $sql= "SELECT `name`, `plugincode`, `properties` FROM " . $this->getFullTableName("site_plugins") . " WHERE `name`='" . $pluginName . "' AND `disabled`=0;";

    2439. 

  2439.                     $result= $this->db->query($sql);

    2440. 

  2440.                     if ($this->db->getRecordCount($result) == 1) {

    2441. 

  2441.                         $row= $this->db->getRow($result);

    2442. 

  2442.                         $pluginCode= $this->pluginCache[$row['name']]= $row['plugincode'];

    2443. 

  2443.                         $pluginProperties= $this->pluginCache[$row['name'] . "Props"]= $row['properties'];

    2444. 

  2444.                     } else {

    2445. 

  2445.                         $pluginCode= $this->pluginCache[$pluginName]= "return false;";

    2446. 

  2446.                         $pluginProperties= '';

    2447. 

  2447.                     }

    2448. 

  2448.                 }

    2449. 

  2449. 

    2450. 

  2450.                 // load default params/properties

    2451. 

  2451.                 $parameter= $this->parseProperties($pluginProperties);

    2452. 

  2452.                 if (!empty ($extParams))

    2453. 

  2453.                     $parameter= array_merge($parameter, $extParams);

    2454. 

  2454. 

    2455. 

  2455.                 // eval plugin

    2456. 

  2456.                 $this->evalPlugin($pluginCode, $parameter);

    2457. 

  2457.                 if ($e->_output != "")

    2458. 

  2458.                     $results[]= $e->_output;

    2459. 

  2459.                 if ($e->_propagate != true)

    2460. 

  2460.                     break;

    2461. 

  2461.             }

    2462. 

  2462.         $e->activePlugin= "";

    2463. 

  2463.         return $results;

    2464. 

  2464.     }

    2465. 

  2465. 

    2466. 

  2466.     # parses a resource property string and returns the result as an array

    2467. 

  2467.     function parseProperties($propertyString) {

    2468. 

  2468.         $parameter= array ();

    2469. 

  2469.         if (!empty ($propertyString)) {

    2470. 

  2470.             $tmpParams= explode("&", $propertyString);

    2471. 

  2471.             for ($x= 0; $x < count($tmpParams); $x++) {

    2472. 

  2472.                 if (strpos($tmpParams[$x], '=', 0)) {

    2473. 

  2473.                     $pTmp= explode("=", $tmpParams[$x]);

    2474. 

  2474.                     $pvTmp= explode(";", trim($pTmp[1]));

    2475. 

  2475.                     if ($pvTmp[1] == 'list' && $pvTmp[3] != "")

    2476. 

  2476.                         $parameter[trim($pTmp[0])]= $pvTmp[3]; //list default

    2477. 

  2477.                     else

    2478. 

  2478.                         if ($pvTmp[1] != 'list' && $pvTmp[2] != "")

    2479. 

  2479.                             $parameter[trim($pTmp[0])]= $pvTmp[2];

    2480. 

  2480.                 }

    2481. 

  2481.             }

    2482. 

  2482.         }

    2483. 

  2483.         return $parameter;

    2484. 

  2484.     }

    2485. 

  2485. 

    2486. 

  2486.     /*############################################

    2487. 

  2487.       Etomite_dbFunctions.php

    2488. 

  2488.       New database functions for Etomite CMS

    2489. 

  2489.     Author: Ralph A. Dahlgren - rad14701@yahoo.com

    2490. 

  2490.     Etomite ID: rad14701

    2491. 

  2491.     See documentation for usage details

    2492. 

  2492.     ############################################*/

    2493. 

  2493.     function getIntTableRows($fields= "*", $from= "", $where= "", $sort= "", $dir= "ASC", $limit= "") {

    2494. 

  2494.         // function to get rows from ANY internal database table

    2495. 

  2495.         if ($from == "") {

    2496. 

  2496.             return false;

    2497. 

  2497.         } else {

    2498. 

  2498.             $where= ($where != "") ? "WHERE $where" : "";

    2499. 

  2499.             $sort= ($sort != "") ? "ORDER BY $sort $dir" : "";

    2500. 

  2500.             $limit= ($limit != "") ? "LIMIT $limit" : "";

    2501. 

  2501.             $tbl= $this->getFullTableName($from);

    2502. 

  2502.             $sql= "SELECT $fields FROM $tbl $where $sort $limit;";

    2503. 

  2503.             $result= $this->db->query($sql);

    2504. 

  2504.             $resourceArray= array ();

    2505. 

  2505.             for ($i= 0; $i < @ $this->db->getRecordCount($result); $i++) {

    2506. 

  2506.                 array_push($resourceArray, @ $this->db->getRow($result));

    2507. 

  2507.             }

    2508. 

  2508.             return $resourceArray;

    2509. 

  2509.         }

    2510. 

  2510.     }

    2511. 

  2511. 

    2512. 

  2512.     function putIntTableRow($fields= "", $into= "") {

    2513. 

  2513.         // function to put a row into ANY internal database table

    2514. 

  2514.         if (($fields == "") || ($into == "")) {

    2515. 

  2515.             return false;

    2516. 

  2516.         } else {

    2517. 

  2517.             $tbl= $this->getFullTableName($into);

    2518. 

  2518.             $sql= "INSERT INTO $tbl SET ";

    2519. 

  2519.             foreach ($fields as $key => $value) {

    2520. 

  2520.                 $sql .= $key . "=";

    2521. 

  2521.                 if (is_numeric($value))

    2522. 

  2522.                     $sql .= $value . ",";

    2523. 

  2523.                 else

    2524. 

  2524.                     $sql .= "'" . $value . "',";

    2525. 

  2525.             }

    2526. 

  2526.             $sql= rtrim($sql, ",");

    2527. 

  2527.             $sql .= ";";

    2528. 

  2528.             $result= $this->db->query($sql);

    2529. 

  2529.             return $result;

    2530. 

  2530.         }

    2531. 

  2531.     }

    2532. 

  2532. 

    2533. 

  2533.     function updIntTableRow($fields= "", $into= "", $where= "", $sort= "", $dir= "ASC", $limit= "") {

    2534. 

  2534.         // function to update a row into ANY internal database table

    2535. 

  2535.         if (($fields == "") || ($into == "")) {

    2536. 

  2536.             return false;

    2537. 

  2537.         } else {

    2538. 

  2538.             $where= ($where != "") ? "WHERE $where" : "";

    2539. 

  2539.             $sort= ($sort != "") ? "ORDER BY $sort $dir" : "";

    2540. 

  2540.             $limit= ($limit != "") ? "LIMIT $limit" : "";

    2541. 

  2541.             $tbl= $this->getFullTableName($into);

    2542. 

  2542.             $sql= "UPDATE $tbl SET ";

    2543. 

  2543.             foreach ($fields as $key => $value) {

    2544. 

  2544.                 $sql .= $key . "=";

    2545. 

  2545.                 if (is_numeric($value))

    2546. 

  2546.                     $sql .= $value . ",";

    2547. 

  2547.                 else

    2548. 

  2548.                     $sql .= "'" . $value . "',";

    2549. 

  2549.             }

    2550. 

  2550.             $sql= rtrim($sql, ",");

    2551. 

  2551.             $sql .= " $where $sort $limit;";

    2552. 

  2552.             $result= $this->db->query($sql);

    2553. 

  2553.             return $result;

    2554. 

  2554.         }

    2555. 

  2555.     }

    2556. 

  2556. 

    2557. 

  2557.     function getExtTableRows($host= "", $user= "", $pass= "", $dbase= "", $fields= "*", $from= "", $where= "", $sort= "", $dir= "ASC", $limit= "") {

    2558. 

  2558.         // function to get table rows from an external MySQL database

    2559. 

  2559.         if (($host == "") || ($user == "") || ($pass == "") || ($dbase == "") || ($from == "")) {

    2560. 

  2560.             return false;

    2561. 

  2561.         } else {

    2562. 

  2562.             $where= ($where != "") ? "WHERE  $where" : "";

    2563. 

  2563.             $sort= ($sort != "") ? "ORDER BY $sort $dir" : "";

    2564. 

  2564.             $limit= ($limit != "") ? "LIMIT $limit" : "";

    2565. 

  2565.             $tbl= $dbase . "." . $from;

    2566. 

  2566.             $this->dbExtConnect($host, $user, $pass, $dbase);

    2567. 

  2567.             $sql= "SELECT $fields FROM $tbl $where $sort $limit;";

    2568. 

  2568.             $result= $this->db->query($sql);

    2569. 

  2569.             $resourceArray= array ();

    2570. 

  2570.             for ($i= 0; $i < @ $this->db->getRecordCount($result); $i++) {

    2571. 

  2571.                 array_push($resourceArray, @ $this->db->getRow($result));

    2572. 

  2572.             }

    2573. 

  2573.             return $resourceArray;

    2574. 

  2574.         }

    2575. 

  2575.     }

    2576. 

  2576. 

    2577. 

  2577.     function putExtTableRow($host= "", $user= "", $pass= "", $dbase= "", $fields= "", $into= "") {

    2578. 

  2578.         // function to put a row into an external database table

    2579. 

  2579.         if (($host == "") || ($user == "") || ($pass == "") || ($dbase == "") || ($fields == "") || ($into == "")) {

    2580. 

  2580.             return false;

    2581. 

  2581.         } else {

    2582. 

  2582.             $this->dbExtConnect($host, $user, $pass, $dbase);

    2583. 

  2583.             $tbl= $dbase . "." . $into;

    2584. 

  2584.             $sql= "INSERT INTO $tbl SET ";

    2585. 

  2585.             foreach ($fields as $key => $value) {

    2586. 

  2586.                 $sql .= $key . "=";

    2587. 

  2587.                 if (is_numeric($value))

    2588. 

  2588.                     $sql .= $value . ",";

    2589. 

  2589.                 else

    2590. 

  2590.                     $sql .= "'" . $value . "',";

    2591. 

  2591.             }

    2592. 

  2592.             $sql= rtrim($sql, ",");

    2593. 

  2593.             $sql .= ";";

    2594. 

  2594.             $result= $this->db->query($sql);

    2595. 

  2595.             return $result;

    2596. 

  2596.         }

    2597. 

  2597.     }

    2598. 

  2598. 

    2599. 

  2599.     function updExtTableRow($host= "", $user= "", $pass= "", $dbase= "", $fields= "", $into= "", $where= "", $sort= "", $dir= "ASC", $limit= "") {

    2600. 

  2600.         // function to update a row into an external database table

    2601. 

  2601.         if (($fields == "") || ($into == "")) {

    2602. 

  2602.             return false;

    2603. 

  2603.         } else {

    2604. 

  2604.             $this->dbExtConnect($host, $user, $pass, $dbase);

    2605. 

  2605.             $tbl= $dbase . "." . $into;

    2606. 

  2606.             $where= ($where != "") ? "WHERE $where" : "";

    2607. 

  2607.             $sort= ($sort != "") ? "ORDER BY $sort $dir" : "";

    2608. 

  2608.             $limit= ($limit != "") ? "LIMIT $limit" : "";

    2609. 

  2609.             $sql= "UPDATE $tbl SET ";

    2610. 

  2610.             foreach ($fields as $key => $value) {

    2611. 

  2611.                 $sql .= $key . "=";

    2612. 

  2612.                 if (is_numeric($value))

    2613. 

  2613.                     $sql .= $value . ",";

    2614. 

  2614.                 else

    2615. 

  2615.                     $sql .= "'" . $value . "',";

    2616. 

  2616.             }

    2617. 

  2617.             $sql= rtrim($sql, ",");

    2618. 

  2618.             $sql .= " $where $sort $limit;";

    2619. 

  2619.             $result= $this->db->query($sql);

    2620. 

  2620.             return $result;

    2621. 

  2621.         }

    2622. 

  2622.     }

    2623. 

  2623. 

    2624. 

  2624.     function dbExtConnect($host, $user, $pass, $dbase) {

    2625. 

  2625.         // function to connect to external database

    2626. 

  2626.         $tstart= $this->getMicroTime();

    2627. 

  2627.         if (@ !$this->rs= mysql_connect($host, $user, $pass)) {

    2628. 

  2628.             $this->messageQuit("Failed to create connection to the $dbase database!");

    2629. 

  2629.         } else {

    2630. 

  2630.             mysql_select_db($dbase);

    2631. 

  2631.             $tend= $this->getMicroTime();

    2632. 

  2632.             $totaltime= $tend - $tstart;

    2633. 

  2633.             if ($this->dumpSQL) {

    2634. 

  2634.                 $this->queryCode .= "<fieldset style='text-align:left'><legend>Database connection</legend>" . sprintf("Database connection to %s was created in %2.4f s", $dbase, $totaltime) . "</fieldset><br />";

    2635. 

  2635.             }

    2636. 

  2636.             $this->queryTime= $this->queryTime + $totaltime;

    2637. 

  2637.         }

    2638. 

  2638.     }

    2639. 

  2639. 

    2640. 

  2640.     function getFormVars($method= "", $prefix= "", $trim= "", $REQUEST_METHOD) {

    2641. 

  2641.         //  function to retrieve form results into an associative array

    2642. 

  2642.         $results= array ();

    2643. 

  2643.         $method= strtoupper($method);

    2644. 

  2644.         if ($method == "")

    2645. 

  2645.             $method= $REQUEST_METHOD;

    2646. 

  2646.         if ($method == "POST")

    2647. 

  2647.             $method= & $_POST;

    2648. 

  2648.         elseif ($method == "GET") $method= & $_GET;

    2649. 

  2649.         else

    2650. 

  2650.             return false;

    2651. 

  2651.         reset($method);

    2652. 

  2652.         foreach ($method as $key => $value) {

    2653. 

  2653.             if (($prefix != "") && (substr($key, 0, strlen($prefix)) == $prefix)) {

    2654. 

  2654.                 if ($trim) {

    2655. 

  2655.                     $pieces= explode($prefix, $key, 2);

    2656. 

  2656.                     $key= $pieces[1];

    2657. 

  2657.                     $results[$key]= $value;

    2658. 

  2658.                 } else

    2659. 

  2659.                     $results[$key]= $value;

    2660. 

  2660.             }

    2661. 

  2661.             elseif ($prefix == "") $results[$key]= $value;

    2662. 

  2662.         }

    2663. 

  2663.         return $results;

    2664. 

  2664.     }

    2665. 

  2665. 

    2666. 

  2666.     ########################################

    2667. 

  2667.     // END New database functions - rad14701

    2668. 

  2668.     ########################################

    2669. 

  2669. 

    2670. 

  2670.     /***************************************************************************************/

    2671. 

  2671.     /* End of API functions								       */

    2672. 

  2672.     /***************************************************************************************/

    2673. 

  2673. 

    2674. 

  2674.     function phpError($nr, $text, $file, $line) {

    2675. 

  2675.         if (error_reporting() == 0 || $nr == 0 || ($nr == 8 && $this->stopOnNotice == false)) {

    2676. 

  2676.             return true;

    2677. 

  2677.         }

    2678. 

  2678.         if (is_readable($file)) {

    2679. 

  2679.             $source= file($file);

    2680. 

  2680.             $source= htmlspecialchars($source[$line -1]);

    2681. 

  2681.         } else {

    2682. 

  2682.             $source= "";

    2683. 

  2683.         } //Error $nr in $file at $line: <div><code>$source</code></div>

    2684. 

  2684.         $this->messageQuit("PHP Parse Error", '', true, $nr, $file, $source, $text, $line);

    2685. 

  2685.     }

    2686. 

  2686. 

    2687. 

  2687.     function messageQuit($msg= 'unspecified error', $query= '', $is_error= true, $nr= '', $file= '', $source= '', $text= '', $line= '') {

    2688. 

  2688. 

    2689. 

  2689.         $version= isset ($GLOBALS['version']) ? $GLOBALS['version'] : '';

    2690. 

  2690. 		$release_date= isset ($GLOBALS['release_date']) ? $GLOBALS['release_date'] : '';

    2691. 

  2691.         $parsedMessageString= "

    2692. 

  2692.               <html><head><title>MODx Content Manager $version &raquo; $release_date</title>

    2693. 

  2693.               <style>TD, BODY { font-size: 11px; font-family:verdana; }</style>

    2694. 

  2694.               <script type='text/javascript'>

    2695. 

  2695.               function copyToClip()

    2696. 

  2696.               {

    2697. 

  2697.                 holdtext.innerText = sqlHolder.innerText;

    2698. 

  2698.                 Copied = holdtext.createTextRange();

    2699. 

  2699.                 Copied.execCommand('Copy');

    2700. 

  2700.               }

    2701. 

  2701.             </script>

    2702. 

  2702.               </head><body>

    2703. 

  2703.               ";

    2704. 

  2704.         if ($is_error) {

    2705. 

  2705.             $parsedMessageString .= "<h3 style='color:red'>&laquo; MODx Parse Error &raquo;</h3>

    2706. 

  2706.                     <table border='0' cellpadding='1' cellspacing='0'>

    2707. 

  2707.                     <tr><td colspan='3'>MODx encountered the following error while attempting to parse the requested resource:</td></tr>

    2708. 

  2708.                     <tr><td colspan='3'><b style='color:red;'>&laquo; $msg &raquo;</b></td></tr>";

    2709. 

  2709.         } else {

    2710. 

  2710.             $parsedMessageString .= "<h3 style='color:#003399'>&laquo; MODx Debug/ stop message &raquo;</h3>

    2711. 

  2711.                     <table border='0' cellpadding='1' cellspacing='0'>

    2712. 

  2712.                     <tr><td colspan='3'>The MODx parser recieved the following debug/ stop message:</td></tr>

    2713. 

  2713.                     <tr><td colspan='3'><b style='color:#003399;'>&laquo; $msg &raquo;</b></td></tr>";

    2714. 

  2714.         }

    2715. 

  2715. 

    2716. 

  2716.         if (!empty ($query)) {

    2717. 

  2717.             $parsedMessageString .= "<tr><td colspan='3'><b style='color:#999;font-size: 9px;'>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;SQL:&nbsp;<span id='sqlHolder'>$query</span></b>

    2718. 

  2718.                     <br />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href='javascript:copyToClip();' style='color:#821517;font-size: 9px; text-decoration: none'>[Copy SQL to ClipBoard]</a><textarea id='holdtext' style='display:none;'></textarea></td></tr>";

    2719. 

  2719.         }

    2720. 

  2720. 

    2721. 

  2721.         if ($text != '') {

    2722. 

  2722. 

    2723. 

  2723.             $errortype= array (

    2724. 

  2724.                 E_ERROR => "Error",

    2725. 

  2725.                 E_WARNING => "Warning",

    2726. 

  2726.                 E_PARSE => "Parsing Error",

    2727. 

  2727.                 E_NOTICE => "Notice",

    2728. 

  2728.                 E_CORE_ERROR => "Core Error",

    2729. 

  2729.                 E_CORE_WARNING => "Core Warning",

    2730. 

  2730.                 E_COMPILE_ERROR => "Compile Error",

    2731. 

  2731.                 E_COMPILE_WARNING => "Compile Warning",

    2732. 

  2732.                 E_USER_ERROR => "User Error",

    2733. 

  2733.                 E_USER_WARNING => "User Warning",

    2734. 

  2734.                 E_USER_NOTICE => "User Notice",

    2735. 

  2735. 

    2736. 

  2736.             );

    2737. 

  2737. 

    2738. 

  2738.             $parsedMessageString .= "<tr><td>&nbsp;</td></tr><tr><td colspan='3'><b>PHP error debug</b></td></tr>";

    2739. 

  2739. 

    2740. 

  2740.             $parsedMessageString .= "<tr><td valign='top'>&nbsp;&nbsp;Error: </td>";

    2741. 

  2741.             $parsedMessageString .= "<td colspan='2'>$text</td><td>&nbsp;</td>";

    2742. 

  2742.             $parsedMessageString .= "</tr>";

    2743. 

  2743. 

    2744. 

  2744.             $parsedMessageString .= "<tr><td valign='top'>&nbsp;&nbsp;Error type/ Nr.: </td>";

    2745. 

  2745.             $parsedMessageString .= "<td colspan='2'>" . $errortype[$nr] . " - $nr</b></td><td>&nbsp;</td>";

    2746. 

  2746.             $parsedMessageString .= "</tr>";

    2747. 

  2747. 

    2748. 

  2748.             $parsedMessageString .= "<tr><td>&nbsp;&nbsp;File: </td>";

    2749. 

  2749.             $parsedMessageString .= "<td colspan='2'>$file</td><td>&nbsp;</td>";

    2750. 

  2750.             $parsedMessageString .= "</tr>";

    2751. 

  2751. 

    2752. 

  2752.             $parsedMessageString .= "<tr><td>&nbsp;&nbsp;Line: </td>";

    2753. 

  2753.             $parsedMessageString .= "<td colspan='2'>$line</td><td>&nbsp;</td>";

    2754. 

  2754.             $parsedMessageString .= "</tr>";

    2755. 

  2755.             if ($source != '') {

    2756. 

  2756.                 $parsedMessageString .= "<tr><td valign='top'>&nbsp;&nbsp;Line $line source: </td>";

    2757. 

  2757.                 $parsedMessageString .= "<td colspan='2'>$source</td><td>&nbsp;</td>";

    2758. 

  2758.                 $parsedMessageString .= "</tr>";

    2759. 

  2759.             }

    2760. 

  2760.         }

    2761. 

  2761. 

    2762. 

  2762.         $parsedMessageString .= "<tr><td>&nbsp;</td></tr><tr><td colspan='3'><b>Parser timing</b></td></tr>";

    2763. 

  2763. 

    2764. 

  2764.         $parsedMessageString .= "<tr><td>&nbsp;&nbsp;MySQL: </td>";

    2765. 

  2765.         $parsedMessageString .= "<td><i>[^qt^]</i></td><td>(<i>[^q^] Requests</i>)</td>";

    2766. 

  2766.         $parsedMessageString .= "</tr>";

    2767. 

  2767. 

    2768. 

  2768.         $parsedMessageString .= "<tr><td>&nbsp;&nbsp;PHP: </td>";

    2769. 

  2769.         $parsedMessageString .= "<td><i>[^p^]</i></td><td>&nbsp;</td>";

    2770. 

  2770.         $parsedMessageString .= "</tr>";

    2771. 

  2771. 

    2772. 

  2772.         $parsedMessageString .= "<tr><td>&nbsp;&nbsp;Total: </td>";

    2773. 

  2773.         $parsedMessageString .= "<td><i>[^t^]</i></td><td>&nbsp;</td>";

    2774. 

  2774.         $parsedMessageString .= "</tr>";

    2775. 

  2775. 

    2776. 

  2776.         $parsedMessageString .= "</table>";

    2777. 

  2777.         $parsedMessageString .= "</body></html>";

    2778. 

  2778. 

    2779. 

  2779.         $totalTime= ($this->getMicroTime() - $this->tstart);

    2780. 

  2780.         $queryTime= $this->queryTime;

    2781. 

  2781.         $phpTime= $totalTime - $queryTime;

    2782. 

  2782.         $queries= isset ($this->executedQueries) ? $this->executedQueries : 0;

    2783. 

  2783.         $queryTime= sprintf("%2.4f s", $queryTime);

    2784. 

  2784.         $totalTime= sprintf("%2.4f s", $totalTime);

    2785. 

  2785.         $phpTime= sprintf("%2.4f s", $phpTime);

    2786. 

  2786. 

    2787. 

  2787.         $parsedMessageString= str_replace("[^q^]", $queries, $parsedMessageString);

    2788. 

  2788.         $parsedMessageString= str_replace("[^qt^]", $queryTime, $parsedMessageString);

    2789. 

  2789.         $parsedMessageString= str_replace("[^p^]", $phpTime, $parsedMessageString);

    2790. 

  2790.         $parsedMessageString= str_replace("[^t^]", $totalTime, $parsedMessageString);

    2791. 

  2791. 

    2792. 

  2792.         // Set 500 response header

    2793. 

  2793.         header('HTTP/1.1 500 Internal Server Error');

    2794. 

  2794. 

    2795. 

  2795.         // Display error

    2796. 

  2796.         echo $parsedMessageString;

    2797. 

  2797.         ob_end_flush();

    2798. 

  2798. 

    2799. 

  2799.         // Log error

    2800. 

  2800.         $this->logEvent(0, 3, $parsedMessageString, $source= 'Parser');

    2801. 

  2801. 

    2802. 

  2802.         // Make sure and die!

    2803. 

  2803.         exit();

    2804. 

  2804.     }

    2805. 

  2805. 

    2806. 

  2806.     function getRegisteredClientScripts() {

    2807. 

  2807.         return implode("\n", $this->jscripts);

    2808. 

  2808.     }

    2809. 

  2809. 

    2810. 

  2810.     function getRegisteredClientStartupScripts() {

    2811. 

  2811.         return implode("\n", $this->sjscripts);

    2812. 

  2812.     }

    2813. 

  2813.     

    2814. 

  2814. 	/**

    2815. 

  2815. 	 * Format alias to be URL-safe. Strip invalid characters.

    2816. 

  2816. 	 *

    2817. 

  2817. 	 * @param string Alias to be formatted

    2818. 

  2818. 	 * @return string Safe alias

    2819. 

  2819. 	 */

    2820. 

  2820.     function stripAlias($alias) {

    2821. 

  2821.         // let add-ons overwrite the default behavior

    2822. 

  2822.         $results = $this->invokeEvent('OnStripAlias', array ('alias'=>$alias));

    2823. 

  2823.         if (!empty($results)) {

    2824. 

  2824.             // if multiple plugins are registered, only the last one is used

    2825. 

  2825.             return end($results);

    2826. 

  2826.         } else {

    2827. 

  2827.             // default behavior: strip invalid characters and replace spaces with dashes.

    2828. 

  2828.             $alias = strip_tags($alias); // strip HTML

    2829. 

  2829.             $alias = preg_replace('/[^\.A-Za-z0-9 _-]/', '', $alias); // strip non-alphanumeric characters

    2830. 

  2830.             $alias = preg_replace('/\s+/', '-', $alias); // convert white-space to dash

    2831. 

  2831.             $alias = preg_replace('/-+/', '-', $alias);  // convert multiple dashes to one

    2832. 

  2832.             $alias = trim($alias, '-'); // trim excess

    2833. 

  2833.             return $alias;

    2834. 

  2834.         }

    2835. 

  2835.     }

    2836. 

  2836.     

    2837. 

  2837. 

    2838. 

  2838.     // End of class.

    2839. 

  2839. 

    2840. 

  2840. }

    2841. 

  2841. 

    2842. 

  2842. // SystemEvent Class

    2843. 

  2843. class SystemEvent {

    2844. 

  2844.     var $name;

    2845. 

  2845.     var $_propagate;

    2846. 

  2846.     var $_output;

    2847. 

  2847.     var $activated;

    2848. 

  2848.     var $activePlugin;

    2849. 

  2849. 

    2850. 

  2850.     function SystemEvent($name= "") {

    2851. 

  2851.         $this->_resetEventObject();

    2852. 

  2852.         $this->name= $name;

    2853. 

  2853.     }

    2854. 

  2854. 

    2855. 

  2855.     // used for displaying a message to the user

    2856. 

  2856.     function alert($msg) {

    2857. 

  2857.         global $SystemAlertMsgQueque;

    2858. 

  2858.         if ($msg == "")

    2859. 

  2859.             return;

    2860. 

  2860.         if (is_array($SystemAlertMsgQueque)) {

    2861. 

  2861.             if ($this->name && $this->activePlugin)

    2862. 

  2862.                 $title= "<div><b>" . $this->activePlugin . "</b> - <span style='color:maroon;'>" . $this->name . "</span></div>";

    2863. 

  2863.             $SystemAlertMsgQueque[]= "$title<div style='margin-left:10px;margin-top:3px;'>$msg</div>";

    2864. 

  2864.         }

    2865. 

  2865.     }

    2866. 

  2866. 

    2867. 

  2867.     // used for rendering an out on the screen

    2868. 

  2868.     function output($msg) {

    2869. 

  2869.         $this->_output .= $msg;

    2870. 

  2870.     }

    2871. 

  2871. 

    2872. 

  2872.     function stopPropagation() {

    2873. 

  2873.         $this->_propagate= false;

    2874. 

  2874.     }

    2875. 

  2875. 

    2876. 

  2876.     function _resetEventObject() {

    2877. 

  2877.         unset ($this->returnedValues);

    2878. 

  2878.         $this->name= "";

    2879. 

  2879.         $this->_output= "";

    2880. 

  2880.         $this->_propagate= true;

    2881. 

  2881.         $this->activated= false;

    2882. 

  2882.     }

    2883. 

  2883. }

    2884. 

  2884. ?>
    2885.