PageRenderTime 44ms CodeModel.GetById 27ms RepoModel.GetById 1ms app.codeStats 1ms

/phprptinc/ewrfn5.php

https://bitbucket.org/joemarmatulac/ebutton
PHP | 5950 lines | 4888 code | 483 blank | 579 comment | 1169 complexity | a3ee7402a967cdb6c8efb8195c9a516b MD5 | raw file
Possible License(s): LGPL-2.1 
    

  1. <?php

    2. 

  2. 

    3. 

  3. // Functions for PHP Report Maker 5

    4. 

  4. // (C) 2007-2011 e.World Technology Limited

    5. 

  5. 

    6. 

  6. if (!function_exists("G")) {

    7. 

  7. 

    8. 

  8. 	function &G($name) {

    9. 

  9. 		return $GLOBALS[$name];

    10. 

  10. 	}

    11. 

  11. }

    12. 

  12. 

    13. 

  13. // Get current page object

    14. 

  14. function &CurrentPage() {

    15. 

  15. 	return $GLOBALS["Page"];

    16. 

  16. }

    17. 

  17. 

    18. 

  18. // Get current main table object

    19. 

  19. function &CurrentTable() {

    20. 

  20. 	return $GLOBALS["Table"];

    21. 

  21. }

    22. 

  22. 

    23. 

  23. /**

    24. 

  24.  * Langauge class for reports

    25. 

  25.  */

    26. 

  26. 

    27. 

  27. class crLanguage {

    28. 

  28. 	var $LanguageId;

    29. 

  29. 	var $Phrases = NULL;

    30. 

  30. 

    31. 

  31. 	// Constructor

    32. 

  32. 	function crLanguage() {

    33. 

  33. 		global $gsLanguage;

    34. 

  34. 		$this->LoadFileList(); // Set up file list

    35. 

  35. 		if (@$_GET["language"] <> "") { // Set up language id

    36. 

  36. 			$this->LanguageId = $_GET["language"];

    37. 

  37. 			$_SESSION[EWRPT_SESSION_LANGUAGE_ID] = $this->LanguageId;

    38. 

  38. 		} elseif (@$_SESSION[EWRPT_SESSION_LANGUAGE_ID] <> "") {

    39. 

  39. 			$this->LanguageId = $_SESSION[EWRPT_SESSION_LANGUAGE_ID];

    40. 

  40. 		} else {

    41. 

  41. 			$this->LanguageId = EWRPT_LANGUAGE_DEFAULT_ID;

    42. 

  42. 		}

    43. 

  43. 		$gsLanguage = $this->LanguageId;

    44. 

  44. 		$this->Load($this->LanguageId);

    45. 

  45. 	}

    46. 

  46. 

    47. 

  47. 	// Load language file list

    48. 

  48. 	function LoadFileList() {

    49. 

  49. 		global $EWRPT_LANGUAGE_FILE;

    50. 

  50. 		if (is_array($EWRPT_LANGUAGE_FILE)) {

    51. 

  51. 			$cnt = count($EWRPT_LANGUAGE_FILE);

    52. 

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

    53. 

  53. 				$EWRPT_LANGUAGE_FILE[$i][1] = $this->LoadFileDesc(EWRPT_LANGUAGE_FOLDER . $EWRPT_LANGUAGE_FILE[$i][2]);

    54. 

  54. 		}

    55. 

  55. 	}

    56. 

  56. 

    57. 

  57. 	// Load language file description

    58. 

  58. 	function LoadFileDesc($File) {

    59. 

  59. 		if (EWRPT_USE_DOM_XML) {

    60. 

  60. 			$this->Phrases = new crXMLDocument();

    61. 

  61. 			if ($this->Phrases->Load($File))

    62. 

  62. 				return $this->GetNodeAtt($this->Phrases->DocumentElement(), "desc");

    63. 

  63. 		} else {

    64. 

  64. 			$ar = ewrpt_Xml2Array(substr(file_get_contents($File), 0, 512)); // Just read the first part

    65. 

  65. 			return (is_array($ar)) ? @$ar['ew-language']['attr']['desc'] : "";

    66. 

  66. 		}

    67. 

  67. 	}

    68. 

  68. 

    69. 

  69. 	// Load language file

    70. 

  70. 	function Load($id) {

    71. 

  71. 		$sFileName = $this->GetFileName($id);

    72. 

  72. 		if ($sFileName == "")

    73. 

  73. 			$sFileName = $this->GetFileName(EWRPT_LANGUAGE_DEFAULT_ID);

    74. 

  74. 		if ($sFileName == "")

    75. 

  75. 			return;

    76. 

  76. 		if (EWRPT_USE_DOM_XML) {

    77. 

  77. 			$this->Phrases = new crXMLDocument();

    78. 

  78. 			$this->Phrases->Load($sFileName);

    79. 

  79. 		} else {

    80. 

  80. 			if (is_array(@$_SESSION[EWRPT_PROJECT_VAR . "_" . $sFileName])) {

    81. 

  81. 				$this->Phrases = $_SESSION[EWRPT_PROJECT_VAR . "_" . $sFileName];

    82. 

  82. 			} else {

    83. 

  83. 				$this->Phrases = ewrpt_Xml2Array(file_get_contents($sFileName));

    84. 

  84. 			}

    85. 

  85. 		}

    86. 

  86. 	}

    87. 

  87. 

    88. 

  88. 	// Get language file name

    89. 

  89. 	function GetFileName($Id) {

    90. 

  90. 		global $EWRPT_LANGUAGE_FILE;

    91. 

  91. 		if (is_array($EWRPT_LANGUAGE_FILE)) {

    92. 

  92. 			$cnt = count($EWRPT_LANGUAGE_FILE);

    93. 

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

    94. 

  94. 				if ($EWRPT_LANGUAGE_FILE[$i][0] == $Id) {

    95. 

  95. 					return EWRPT_LANGUAGE_FOLDER . $EWRPT_LANGUAGE_FILE[$i][2];

    96. 

  96. 			}

    97. 

  97. 		}

    98. 

  98. 		return "";

    99. 

  99. 	}

    100. 

  100. 

    101. 

  101. 	// Get node attribute

    102. 

  102. 	function GetNodeAtt($Nodes, $Att) {

    103. 

  103. 		$value = ($Nodes) ? $this->Phrases->GetAttribute($Nodes, $Att) : "";

    104. 

  104. 

    105. 

  105. 		//return ewrpt_ConvertFromUtf8($value);

    106. 

  106. 		return $value;

    107. 

  107. 	}

    108. 

  108. 

    109. 

  109. 	// Get phrase

    110. 

  110. 	function Phrase($Name) {

    111. 

  111. 		if (is_object($this->Phrases)) {

    112. 

  112. 			return $this->GetNodeAtt($this->Phrases->SelectSingleNode("//global/phrase[@id='" . strtolower($Name) . "']"), "value");

    113. 

  113. 		} elseif (is_array($this->Phrases)) {

    114. 

  114. 			return ewrpt_ConvertFromUtf8(@$this->Phrases['ew-language']['global']['phrase'][strtolower($Name)]['attr']['value']);

    115. 

  115. 		}

    116. 

  116. 	}

    117. 

  117. 

    118. 

  118. 	// Get project phrase

    119. 

  119. 	function ProjectPhrase($Id) {

    120. 

  120. 		if (is_object($this->Phrases)) {

    121. 

  121. 			return $this->GetNodeAtt($this->Phrases->SelectSingleNode("//project/phrase[@id='" . strtolower($Id) . "']"), "value");

    122. 

  122. 		} elseif (is_array($this->Phrases)) {

    123. 

  123. 			return ewrpt_ConvertFromUtf8(@$this->Phrases['ew-language']['project']['phrase'][strtolower($Id)]['attr']['value']);

    124. 

  124. 		}

    125. 

  125. 	}

    126. 

  126. 

    127. 

  127. 	// Set project phrase

    128. 

  128. 	function setProjectPhrase($Id, $Value) {

    129. 

  129. 		if (is_array($this->Phrases)) {

    130. 

  130. 			$this->Phrases['ew-language']['project']['phrase'][strtolower($Id)]['attr']['value'] = $Value;

    131. 

  131. 		}

    132. 

  132. 	}

    133. 

  133. 

    134. 

  134. 	// Get menu phrase

    135. 

  135. 	function MenuPhrase($MenuId, $Id) {

    136. 

  136. 		if (is_object($this->Phrases)) {

    137. 

  137. 			return $this->GetNodeAtt($this->Phrases->SelectSingleNode("//project/menu[@id='" . $MenuId . "']/phrase[@id='" . strtolower($Id) . "']"), "value");

    138. 

  138. 		} elseif (is_array($this->Phrases)) {

    139. 

  139. 			return ewrpt_ConvertFromUtf8(@$this->Phrases['ew-language']['project']['menu'][$MenuId]['phrase'][strtolower($Id)]['attr']['value']);

    140. 

  140. 		}

    141. 

  141. 	}

    142. 

  142. 

    143. 

  143. 	// Set menu phrase

    144. 

  144. 	function setMenuPhrase($MenuId, $Id, $Value) {

    145. 

  145. 		if (is_array($this->Phrases)) {

    146. 

  146. 			$this->Phrases['ew-language']['project']['menu'][$MenuId]['phrase'][strtolower($Id)]['attr']['value'] = $Value;

    147. 

  147. 		}

    148. 

  148. 	}

    149. 

  149. 

    150. 

  150. 	// Get table phrase

    151. 

  151. 	function TablePhrase($TblVar, $Id) {

    152. 

  152. 		if (is_object($this->Phrases)) {

    153. 

  153. 			return $this->GetNodeAtt($this->Phrases->SelectSingleNode("//project/table[@id='" . strtolower($TblVar) . "']/phrase[@id='" . strtolower($Id) . "']"), "value");

    154. 

  154. 		} elseif (is_array($this->Phrases)) {

    155. 

  155. 			return ewrpt_ConvertFromUtf8(@$this->Phrases['ew-language']['project']['table'][strtolower($TblVar)]['phrase'][strtolower($Id)]['attr']['value']);

    156. 

  156. 		}

    157. 

  157. 	}

    158. 

  158. 

    159. 

  159. 	// Set table phrase

    160. 

  160. 	function setTablePhrase($TblVar, $Id, $Value) {

    161. 

  161. 		if (is_array($this->Phrases)) {

    162. 

  162. 			$this->Phrases['ew-language']['project']['table'][strtolower($TblVar)]['phrase'][strtolower($Id)]['attr']['value'] = $Value;

    163. 

  163. 		}

    164. 

  164. 	}

    165. 

  165. 

    166. 

  166. 	// Get chart phrase

    167. 

  167. 	function ChartPhrase($TblVar, $ChtVar, $Id) {

    168. 

  168. 		if (is_object($this->Phrases)) {

    169. 

  169. 			return $this->GetNodeAtt($this->Phrases->SelectSingleNode("//project/table[@id='" . strtolower($TblVar) . "']/chart[@id='" . strtolower($ChtVar) . "']/phrase[@id='" . strtolower($Id) . "']"), "value");

    170. 

  170. 		} elseif (is_array($this->Phrases)) {

    171. 

  171. 			return ewrpt_ConvertFromUtf8(@$this->Phrases['ew-language']['project']['table'][strtolower($TblVar)]['chart'][strtolower($ChtVar)]['phrase'][strtolower($Id)]['attr']['value']);

    172. 

  172. 		}

    173. 

  173. 	}

    174. 

  174. 

    175. 

  175. 	// Set chart phrase

    176. 

  176. 	function setChartPhrase($TblVar, $FldVar, $Id, $Value) {

    177. 

  177. 		if (is_array($this->Phrases)) {

    178. 

  178. 			$this->Phrases['ew-language']['project']['table'][strtolower($TblVar)]['chart'][strtolower($FldVar)]['phrase'][strtolower($Id)]['attr']['value'] = $Value;

    179. 

  179. 		}

    180. 

  180. 	}

    181. 

  181. 

    182. 

  182. 	// Get field phrase

    183. 

  183. 	function FieldPhrase($TblVar, $FldVar, $Id) {

    184. 

  184. 		if (is_object($this->Phrases)) {

    185. 

  185. 			return $this->GetNodeAtt($this->Phrases->SelectSingleNode("//project/table[@id='" . strtolower($TblVar) . "']/field[@id='" . strtolower($FldVar) . "']/phrase[@id='" . strtolower($Id) . "']"), "value");

    186. 

  186. 		} elseif (is_array($this->Phrases)) {

    187. 

  187. 			return ewrpt_ConvertFromUtf8(@$this->Phrases['ew-language']['project']['table'][strtolower($TblVar)]['field'][strtolower($FldVar)]['phrase'][strtolower($Id)]['attr']['value']);

    188. 

  188. 		}

    189. 

  189. 	}

    190. 

  190. 

    191. 

  191. 	// Set field phrase

    192. 

  192. 	function setFieldPhrase($TblVar, $FldVar, $Id, $Value) {

    193. 

  193. 	if (is_array($this->Phrases)) {

    194. 

  194. 		$this->Phrases['ew-language']['project']['table'][strtolower($TblVar)]['field'][strtolower($FldVar)]['phrase'][strtolower($Id)]['attr']['value'] = $Value;

    195. 

  195. 		}

    196. 

  196. 	}

    197. 

  197. 

    198. 

  198. 	// Output XML as JSON

    199. 

  199. 	function XmlToJSON($XPath) {

    200. 

  200. 		$NodeList = $this->Phrases->SelectNodes($XPath);

    201. 

  201. 		$Str = "{";

    202. 

  202. 		foreach ($NodeList as $Node) {

    203. 

  203. 			$Id = $this->GetNodeAtt($Node, "id");

    204. 

  204. 			$Value = $this->GetNodeAtt($Node, "value");

    205. 

  205. 			$Str .= "\"" . ewrpt_JsEncode2($Id) . "\":\"" . ewrpt_JsEncode2($Value) . "\",";

    206. 

  206. 		}

    207. 

  207. 		if (substr($Str, -1) == ",") $Str = substr($Str, 0, strlen($Str)-1);

    208. 

  208. 		$Str .= "}";

    209. 

  209. 		return $Str;

    210. 

  210. 	}

    211. 

  211. 

    212. 

  212. 	// Output array as JSON

    213. 

  213. 	function ArrayToJSON($client) {

    214. 

  214. 		$ar = @$this->Phrases['ew-language']['global']['phrase'];

    215. 

  215. 		$Str = "{";

    216. 

  216. 		if (is_array($ar)) {

    217. 

  217. 			foreach ($ar as $id => $node) {

    218. 

  218. 				$is_client = @$node['attr']['client'] == '1';

    219. 

  219. 				$value = ewrpt_ConvertFromUtf8(@$node['attr']['value']);

    220. 

  220. 				if (!$client || ($client && $is_client))

    221. 

  221. 					$Str .= "\"" . ewrpt_JsEncode2($id) . "\":\"" . ewrpt_JsEncode2($value) . "\",";

    222. 

  222. 			}

    223. 

  223. 		}

    224. 

  224. 		if (substr($Str, -1) == ",") $Str = substr($Str, 0, strlen($Str)-1);

    225. 

  225. 		$Str .= "}";

    226. 

  226. 		return $Str;

    227. 

  227. 	}

    228. 

  228. 

    229. 

  229. 	// Output all phrases as JSON

    230. 

  230. 	function AllToJSON() {

    231. 

  231. 		if (is_object($this->Phrases)) {

    232. 

  232. 			return "var ewLanguage = new ewrpt_Language(" . $this->XmlToJSON("//global/phrase") . ");";

    233. 

  233. 		} elseif (is_array($this->Phrases)) {

    234. 

  234. 			return "var ewLanguage = new ewrpt_Language(" . $this->ArrayToJSON(FALSE) . ");";

    235. 

  235. 		}

    236. 

  236. 	}

    237. 

  237. 

    238. 

  238. 	// Output client phrases as JSON

    239. 

  239. 	function ToJSON() {

    240. 

  240. 		if (is_object($this->Phrases)) {

    241. 

  241. 			return "var ewLanguage = new ewrpt_Language(" . $this->XmlToJSON("//global/phrase[@client='1']") . ");";

    242. 

  242. 		} elseif (is_array($this->Phrases)) {

    243. 

  243. 			return "var ewLanguage = new ewrpt_Language(" . $this->ArrayToJSON(TRUE) . ");";

    244. 

  244. 		}

    245. 

  245. 	}

    246. 

  246. }

    247. 

  247. 

    248. 

  248. // Convert XML to array

    249. 

  249. function ewrpt_Xml2Array($contents) {

    250. 

  250. 	if (!$contents) return array(); 

    251. 

  251. 	if (!function_exists('xml_parser_create')) return FALSE;

    252. 

  252. 	$get_attributes = 1; // Always get attributes. DO NOT CHANGE!

    253. 

  253. 

    254. 

  254. 	// Get the XML Parser of PHP

    255. 

  255. 	$parser = xml_parser_create();

    256. 

  256. 	xml_parser_set_option($parser, XML_OPTION_TARGET_ENCODING, "UTF-8"); // Always return in utf-8

    257. 

  257. 	xml_parser_set_option($parser, XML_OPTION_CASE_FOLDING, 0);

    258. 

  258. 	xml_parser_set_option($parser, XML_OPTION_SKIP_WHITE, 1);

    259. 

  259. 	xml_parse_into_struct($parser, trim($contents), $xml_values);

    260. 

  260. 	xml_parser_free($parser);

    261. 

  261. 	if (!$xml_values) return;

    262. 

  262. 	$xml_array = array();

    263. 

  263. 	$parents = array();

    264. 

  264. 	$opened_tags = array();

    265. 

  265. 	$arr = array();

    266. 

  266. 	$current = &$xml_array;

    267. 

  267. 	$repeated_tag_index = array(); // Multiple tags with same name will be turned into an array

    268. 

  268. 	foreach ($xml_values as $data) {

    269. 

  269. 		unset($attributes, $value); // Remove existing values

    270. 

  270. 

    271. 

  271. 		// Extract these variables into the foreach scope

    272. 

  272. 		// tag(string), type(string), level(int), attributes(array)

    273. 

  273. 

    274. 

  274. 		extract($data);

    275. 

  275. 		$result = array();

    276. 

  276. 		if (isset($value))

    277. 

  277. 			$result['value'] = $value; // Put the value in a assoc array

    278. 

  278. 

    279. 

  279. 		// Set the attributes

    280. 

  280. 		if (isset($attributes) and $get_attributes) {

    281. 

  281. 			foreach ($attributes as $attr => $val)

    282. 

  282. 				$result['attr'][$attr] = $val; // Set all the attributes in a array called 'attr'

    283. 

  283. 		} 

    284. 

  284. 

    285. 

  285. 		// See tag status and do the needed

    286. 

  286. 		if ($type == "open") { // The starting of the tag '<tag>'

    287. 

  287. 			$parent[$level-1] = &$current;

    288. 

  288. 			if (!is_array($current) || !in_array($tag, array_keys($current))) { // Insert New tag

    289. 

  289. 				if ($tag <> 'ew-language' && @$result['attr']['id'] <> '') { // 

    290. 

  290. 					$last_item_index = $result['attr']['id'];

    291. 

  291. 					$current[$tag][$last_item_index] = $result;

    292. 

  292. 					$repeated_tag_index[$tag.'_'.$level] = 1;

    293. 

  293. 					$current = &$current[$tag][$last_item_index];

    294. 

  294. 				} else {

    295. 

  295. 					$current[$tag] = $result;

    296. 

  296. 					$repeated_tag_index[$tag.'_'.$level] = 0;

    297. 

  297. 					$current = &$current[$tag];

    298. 

  298. 				}

    299. 

  299. 			} else { // Another element with the same tag name

    300. 

  300. 				if ($repeated_tag_index[$tag.'_'.$level] > 0) { // If there is a 0th element it is already an array

    301. 

  301. 					if (@$result['attr']['id'] <> '') {

    302. 

  302. 						$last_item_index = $result['attr']['id'];

    303. 

  303. 					} else {

    304. 

  304. 						$last_item_index = $repeated_tag_index[$tag.'_'.$level];

    305. 

  305. 					}

    306. 

  306. 					$current[$tag][$last_item_index] = $result;

    307. 

  307. 					$repeated_tag_index[$tag.'_'.$level]++;

    308. 

  308. 				} else { // Make the value an array if multiple tags with the same name appear together

    309. 

  309. 					$temp = $current[$tag];

    310. 

  310. 					$current[$tag] = array();

    311. 

  311. 					if (@$temp['attr']['id'] <> '') {

    312. 

  312. 						$current[$tag][$temp['attr']['id']] = $temp;

    313. 

  313. 					} else {

    314. 

  314. 						$current[$tag][] = $temp;

    315. 

  315. 					}

    316. 

  316. 					if (@$result['attr']['id'] <> '') {

    317. 

  317. 						$last_item_index = $result['attr']['id'];

    318. 

  318. 					} else {

    319. 

  319. 						$last_item_index = 1;

    320. 

  320. 					}

    321. 

  321. 					$current[$tag][$last_item_index] = $result;

    322. 

  322. 					$repeated_tag_index[$tag.'_'.$level] = 2;

    323. 

  323. 				} 

    324. 

  324. 				$current = &$current[$tag][$last_item_index];

    325. 

  325. 			}

    326. 

  326. 		} elseif ($type == "complete") { // Tags that ends in one line '<tag>'

    327. 

  327. 			if (!isset($current[$tag])) { // New key

    328. 

  328. 				$current[$tag] = array(); // Always use array for "complete" type

    329. 

  329. 				if (@$result['attr']['id'] <> '') {

    330. 

  330. 					$current[$tag][$result['attr']['id']] = $result;

    331. 

  331. 				} else {

    332. 

  332. 					$current[$tag][] = $result;

    333. 

  333. 				}

    334. 

  334. 				$repeated_tag_index[$tag.'_'.$level] = 1;

    335. 

  335. 			} else { // Existing key

    336. 

  336. 				if (@$result['attr']['id'] <> '') {

    337. 

  337. 			  	$current[$tag][$result['attr']['id']] = $result;

    338. 

  338. 				} else {

    339. 

  339. 					$current[$tag][$repeated_tag_index[$tag.'_'.$level]] = $result;

    340. 

  340. 				}

    341. 

  341. 			  $repeated_tag_index[$tag.'_'.$level]++;

    342. 

  342. 			}

    343. 

  343. 		} elseif ($type == 'close') { // End of tag '</tag>' 

    344. 

  344. 			$current = &$parent[$level-1];

    345. 

  345. 		}

    346. 

  346. 	}

    347. 

  347. 	return($xml_array);

    348. 

  348. }

    349. 

  349. 

    350. 

  350. /**

    351. 

  351.  * XML document class

    352. 

  352.  */

    353. 

  353. 

    354. 

  354. class crXMLDocument {

    355. 

  355. 	var $Encoding = "utf-8";

    356. 

  356. 	var $RootTagName;

    357. 

  357. 	var $RowTagName;

    358. 

  358. 	var $XmlDoc = FALSE;

    359. 

  359. 	var $XmlTbl;

    360. 

  360. 	var $XmlRow;

    361. 

  361. 	var $NullValue = 'NULL';

    362. 

  362. 

    363. 

  363. 	function crXMLDocument($encoding = "") {

    364. 

  364. 		if ($encoding <> "")

    365. 

  365. 			$this->Encoding = $encoding;

    366. 

  366. 		if ($this->Encoding <> "") {

    367. 

  367. 			$this->XmlDoc = new DOMDocument("1.0", strval($this->Encoding));

    368. 

  368. 		} else {

    369. 

  369. 			$this->XmlDoc = new DOMDocument("1.0");

    370. 

  370. 		}

    371. 

  371. 	}

    372. 

  372. 

    373. 

  373. 	function Load($filename) {

    374. 

  374. 		$filepath = realpath($filename);

    375. 

  375. 		return $this->XmlDoc->load($filepath);

    376. 

  376. 	}

    377. 

  377. 

    378. 

  378. 	function &DocumentElement() {

    379. 

  379. 		$de = $this->XmlDoc->documentElement;

    380. 

  380. 		return $de;

    381. 

  381. 	}

    382. 

  382. 

    383. 

  383. 	function GetAttribute($element, $name) {

    384. 

  384. 		return ($element) ? ewrpt_ConvertFromUtf8($element->getAttribute($name)) : "";

    385. 

  385. 	}

    386. 

  386. 

    387. 

  387. 	function SelectSingleNode($query) {

    388. 

  388. 		$elements = $this->SelectNodes($query);

    389. 

  389. 		return ($elements->length > 0) ? $elements->item(0) : NULL;

    390. 

  390. 	}

    391. 

  391. 

    392. 

  392. 	function SelectNodes($query) {

    393. 

  393. 		$xpath = new DOMXPath($this->XmlDoc);

    394. 

  394. 		return $xpath->query($query);

    395. 

  395. 	}

    396. 

  396. 

    397. 

  397. 	function AddRoot($roottagname = 'table') {

    398. 

  398. 		$this->RootTagName = $roottagname;

    399. 

  399. 		$this->XmlTbl = $this->XmlDoc->createElement($this->RootTagName);

    400. 

  400. 		$this->XmlDoc->appendChild($this->XmlTbl);

    401. 

  401. 	}

    402. 

  402. 

    403. 

  403. 	function AddRow($rowtagname = 'row') {

    404. 

  404. 		$this->RowTagName = $rowtagname;

    405. 

  405. 		$this->XmlRow = $this->XmlDoc->createElement($this->RowTagName);

    406. 

  406. 		if ($this->XmlTbl)

    407. 

  407. 			$this->XmlTbl->appendChild($this->XmlRow);

    408. 

  408. 	}

    409. 

  409. 

    410. 

  410. 	function AddField($name, $value) {

    411. 

  411. 		if (is_null($value)) $value = $this->NullValue;

    412. 

  412. 		$value = ewrpt_ConvertToUtf8($value); // Convert to UTF-8

    413. 

  413. 		$xmlfld = $this->XmlDoc->createElement($name);

    414. 

  414. 		$this->XmlRow->appendChild($xmlfld);

    415. 

  415. 		$xmlfld->appendChild($this->XmlDoc->createTextNode($value));

    416. 

  416. 	}

    417. 

  417. 

    418. 

  418. 	function XML() {

    419. 

  419. 		return $this->XmlDoc->saveXML();

    420. 

  420. 	}

    421. 

  421. }

    422. 

  422. 

    423. 

  423. // Select nodes from XML document

    424. 

  424. function &ewrpt_SelectNodes(&$xmldoc, $query) {

    425. 

  425. 	if ($xmldoc) {

    426. 

  426. 		$xpath = new DOMXPath($xmldoc);

    427. 

  427. 		return $xpath->query($query);

    428. 

  428. 	}

    429. 

  429. 	return NULL;

    430. 

  430. }

    431. 

  431. 

    432. 

  432. // Select single node from XML document

    433. 

  433. function &ewrpt_SelectSingleNode(&$xmldoc, $query) {

    434. 

  434. 	$elements = ewrpt_SelectNodes($xmldoc, $query);

    435. 

  435. 	return ($elements && $elements->length > 0) ? $elements->item(0) : NULL;

    436. 

  436. }

    437. 

  437. 

    438. 

  438. // Debug timer

    439. 

  439. class crTimer {

    440. 

  440. 	var $StartTime;

    441. 

  441. 	var $EndTime;

    442. 

  442. 

    443. 

  443. 	function crTimer($start = TRUE) {

    444. 

  444. 		if ($start)

    445. 

  445. 			$this->Start();

    446. 

  446. 	}

    447. 

  447. 

    448. 

  448. 	function GetTime() {

    449. 

  449. 		list($usec, $sec) = explode(" ", microtime());

    450. 

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

    451. 

  451. 	}

    452. 

  452. 

    453. 

  453. 	// Get script start time

    454. 

  454. 	function Start() {

    455. 

  455. 		if (EWRPT_DEBUG_ENABLED)

    456. 

  456. 			$this->StartTime = $this->GetTime();

    457. 

  457. 	}

    458. 

  458. 

    459. 

  459. 	// display elapsed time (in seconds)

    460. 

  460. 	function Stop() {

    461. 

  461. 		if (EWRPT_DEBUG_ENABLED)

    462. 

  462. 			$this->EndTime = $this->GetTime();

    463. 

  463. 		if (isset($this->EndTime) && isset($this->StartTime) &&

    464. 

  464. 			$this->EndTime > $this->StartTime)

    465. 

  465. 			echo '<p>Page processing time: ' . ($this->EndTime - $this->StartTime) . ' seconds</p>';

    466. 

  466. 	}

    467. 

  467. }

    468. 

  468. 

    469. 

  469. /**

    470. 

  470.  * Field class

    471. 

  471.  */

    472. 

  472. 

    473. 

  473. class crField {

    474. 

  474. 	var $TblName; // Table name

    475. 

  475. 	var $TblVar; // Table variable name

    476. 

  476. 	var $FldName; // Field name

    477. 

  477. 	var $FldVar; // Field variable name

    478. 

  478. 	var $FldExpression; // Field expression (used in SQL)

    479. 

  479. 	var $FldDefaultErrMsg; // Default error message

    480. 

  480. 	var $FldType; // Field type

    481. 

  481. 	var $FldDataType; // PHPMaker Field type

    482. 

  482. 	var $FldDateTimeFormat; // Date time format

    483. 

  483. 	var $Count; // Count

    484. 

  484. 	var $SumValue; // Sum

    485. 

  485. 	var $AvgValue; // Average

    486. 

  486. 	var $MinValue; // Minimum

    487. 

  487. 	var $MaxValue; // MaxValue

    488. 

  488. 	var $SumViewValue; // Sum

    489. 

  489. 	var $AvgViewValue; // Average

    490. 

  490. 	var $MinViewValue; // Minimum

    491. 

  491. 	var $MaxViewValue; // MaxValue

    492. 

  492. 	var $OldValue; // Old Value

    493. 

  493. 	var $CurrentValue; // Current value

    494. 

  494. 	var $ViewValue; // View value

    495. 

  495. 	var $HrefValue; // Href value

    496. 

  496. 	var $FormValue; // Form value

    497. 

  497. 	var $QueryStringValue; // QueryString value

    498. 

  498. 	var $DbValue; // Database value

    499. 

  499. 	var $ImageWidth = 0; // Image width

    500. 

  500. 	var $ImageHeight = 0; // Image height

    501. 

  501. 	var $ImageResize = FALSE; // Image resize

    502. 

  502. 	var $Sortable = TRUE; // Sortable

    503. 

  503. 	var $GroupingFieldId = 0; // Grouping field id

    504. 

  504. 	var $UploadPath = EWRPT_UPLOAD_DEST_PATH; // Upload path

    505. 

  505. 	var $TruncateMemoRemoveHtml = FALSE; // Remove HTML from memo field

    506. 

  506. 	var $CellAttrs = array(); // Cell custom attributes

    507. 

  507. 	var $ViewAttrs = array(); // View custom attributes

    508. 

  508. 	var $LinkAttrs = array(); // Href custom attributes

    509. 

  509. 	var $FldGroupByType; // Group By Type

    510. 

  510. 	var $FldGroupInt; // Group Interval

    511. 

  511. 	var $FldGroupSql; // Group SQL

    512. 

  512. 	var $GroupDbValues; // Group DB Values

    513. 

  513. 	var $GroupViewValue; // Group View Value

    514. 

  514. 	var $GroupSummaryOldValue; // Group Summary Old Value

    515. 

  515. 	var $GroupSummaryValue; // Group Summary Value

    516. 

  516. 	var $GroupSummaryViewValue; // Group Summary View Value

    517. 

  517. 	var $SqlSelect; // Field SELECT

    518. 

  518. 	var $SqlGroupBy; // Field GROUP BY

    519. 

  519. 	var $SqlOrderBy; // Field ORDER BY

    520. 

  520. 	var $ValueList; // Value List

    521. 

  521. 	var $SelectionList; // Selection List

    522. 

  522. 	var $DefaultSelectionList; // Default Selection List

    523. 

  523. 	var $AdvancedFilters; // Advanced Filters

    524. 

  524. 	var $RangeFrom; // Range From

    525. 

  525. 	var $RangeTo; // Range To

    526. 

  526. 	var $DropDownList; // Dropdown List

    527. 

  527. 	var $DropDownValue; // Dropdown Value

    528. 

  528. 	var $DefaultDropDownValue; // Default Dropdown Value

    529. 

  529. 	var $DateFilter; // Date Filter

    530. 

  530. 	var $SearchValue; // Search Value 1

    531. 

  531. 	var $SearchValue2; // Search Value 2

    532. 

  532. 	var $SearchOperator; // Search Operator 1

    533. 

  533. 	var $SearchOperator2; // Search Operator 2

    534. 

  534. 	var $SearchCondition; // Search Condition

    535. 

  535. 	var $DefaultSearchValue; // Default Search Value 1

    536. 

  536. 	var $DefaultSearchValue2; // Default Search Value 2

    537. 

  537. 	var $DefaultSearchOperator; // Default Search Operator 1

    538. 

  538. 	var $DefaultSearchOperator2; // Default Search Operator 2

    539. 

  539. 	var $DefaultSearchCondition; // Default Search Condition

    540. 

  540. 

    541. 

  541. 	// Constructor

    542. 

  542. 	function crField($tblvar, $tblname, $fldvar, $fldname, $fldexpression, $fldtype, $flddatatype, $flddtfmt) {

    543. 

  543. 		$this->TblVar = $tblvar;

    544. 

  544. 		$this->TblName = $tblname;

    545. 

  545. 		$this->FldVar = $fldvar;

    546. 

  546. 		$this->FldName = $fldname;

    547. 

  547. 		$this->FldExpression = $fldexpression;

    548. 

  548. 		$this->FldType = $fldtype;

    549. 

  549. 		$this->FldDataType = $flddatatype;

    550. 

  550. 		$this->FldDateTimeFormat = $flddtfmt;

    551. 

  551. 	}

    552. 

  552. 

    553. 

  553. 	// Field caption

    554. 

  554. 	function FldCaption() {

    555. 

  555. 		global $ReportLanguage;

    556. 

  556. 		return $ReportLanguage->FieldPhrase($this->TblVar, substr($this->FldVar, 2), "FldCaption");

    557. 

  557. 	}

    558. 

  558. 

    559. 

  559. 	// Field title

    560. 

  560. 	function FldTitle() {

    561. 

  561. 		global $ReportLanguage;

    562. 

  562. 		return $ReportLanguage->FieldPhrase($this->TblVar, substr($this->FldVar, 2), "FldTitle");

    563. 

  563. 	}

    564. 

  564. 

    565. 

  565. 	// Field image alt

    566. 

  566. 	function FldAlt() {

    567. 

  567. 		global $ReportLanguage;

    568. 

  568. 		return $ReportLanguage->FieldPhrase($this->TblVar, substr($this->FldVar, 2), "FldAlt");

    569. 

  569. 	}

    570. 

  570. 

    571. 

  571. 	// Field error message

    572. 

  572. 	function FldErrMsg() {

    573. 

  573. 		global $ReportLanguage;

    574. 

  574. 		$err = $ReportLanguage->FieldPhrase($this->TblVar, substr($this->FldVar, 2), "FldErrMsg");

    575. 

  575. 		if ($err == "") $err = $this->FldDefaultErrMsg . " - " . $this->FldCaption();

    576. 

  576. 		return $err;

    577. 

  577. 	}

    578. 

  578. 

    579. 

  579. 	// Reset CSS styles for field object

    580. 

  580. 	function ResetCSS() {

    581. 

  581. 		$this->CellAttrs["style"] = "";

    582. 

  582. 		$this->CellAttrs["class"] = "";

    583. 

  583. 		$this->ViewAttrs["style"] = "";

    584. 

  584. 		$this->ViewAttrs["class"] = "";

    585. 

  585. 	}

    586. 

  586. 

    587. 

  587. 	// View Attributes

    588. 

  588. 	function ViewAttributes() {

    589. 

  589. 		$sAtt = "";

    590. 

  590. 		if (intval($this->ImageWidth) > 0 && (!$this->ImageResize || ($this->ImageResize && intval($this->ImageHeight) <= 0)))

    591. 

  591. 			$sAtt .= " width=\"" . intval($this->ImageWidth) . "\"";

    592. 

  592. 		if (intval($this->ImageHeight) > 0 && (!$this->ImageResize || ($this->ImageResize && intval($this->ImageWidth) <= 0)))

    593. 

  593. 			$sAtt .= " height=\"" . intval($this->ImageHeight) . "\"";

    594. 

  594. 		foreach ($this->ViewAttrs as $k => $v) {

    595. 

  595. 			if (trim($v) <> "")

    596. 

  596. 				$sAtt .= " " . $k . "=\"" . trim($v) . "\"";

    597. 

  597. 		}

    598. 

  598. 		return $sAtt;

    599. 

  599. 	}

    600. 

  600. 

    601. 

  601. 	// Link Attributes

    602. 

  602. 	function LinkAttributes() {

    603. 

  603. 		$sAtt = "";

    604. 

  604. 		$sHref = trim($this->HrefValue);

    605. 

  605. 		foreach ($this->LinkAttrs as $k => $v) {

    606. 

  606. 			if (trim($v) <> "") {

    607. 

  607. 				if ($k == "href")

    608. 

  608. 					$sHref .= " " . $v;

    609. 

  609. 				else

    610. 

  610. 					$sAtt .= " " . $k . "=\"" . trim($v) . "\"";

    611. 

  611. 			}

    612. 

  612. 		}

    613. 

  613. 		if ($sHref <> "")

    614. 

  614. 			$sAtt .= " href=\"" . trim($sHref) . "\"";

    615. 

  615. 

    616. 

  616. //		if (trim($this->LinkCustomAttributes) <> "")

    617. 

  617. //			$sAtt .= " " . trim($this->LinkCustomAttributes);

    618. 

  618. 

    619. 

  619. 		return $sAtt;

    620. 

  620. 	}

    621. 

  621. 

    622. 

  622. 	// Cell attributes

    623. 

  623. 	function CellAttributes() {

    624. 

  624. 		$sAtt = "";

    625. 

  625. 		foreach ($this->CellAttrs as $k => $v) {

    626. 

  626. 			if (trim($v) <> "")

    627. 

  627. 				$sAtt .= " " . $k . "=\"" . trim($v) . "\"";

    628. 

  628. 		}

    629. 

  629. 		return $sAtt;

    630. 

  630. 	}

    631. 

  631. 

    632. 

  632. 	// Sort

    633. 

  633. 	function getSort() {

    634. 

  634. 		return @$_SESSION[EWRPT_PROJECT_VAR . "_" . $this->TblVar . "_" . EWRPT_TABLE_SORT . "_" . $this->FldVar];

    635. 

  635. 	}

    636. 

  636. 

    637. 

  637. 	function setSort($v) {

    638. 

  638. 		if (@$_SESSION[EWRPT_PROJECT_VAR . "_" . $this->TblVar . "_" . EWRPT_TABLE_SORT . "_" . $this->FldVar] <> $v) {

    639. 

  639. 			$_SESSION[EWRPT_PROJECT_VAR . "_" . $this->TblVar . "_" . EWRPT_TABLE_SORT . "_" . $this->FldVar] = $v;

    640. 

  640. 		}

    641. 

  641. 	}

    642. 

  642. 

    643. 

  643. 	function ReverseSort() {

    644. 

  644. 		return ($this->getSort() == "ASC") ? "DESC" : "ASC";

    645. 

  645. 	}

    646. 

  646. 

    647. 

  647. 	// List view value

    648. 

  648. 	function ListViewValue() {

    649. 

  649. 		$value = trim(strval($this->ViewValue));

    650. 

  650. 		if ($value <> "") {

    651. 

  651. 			$value2 = trim(preg_replace('/<[^img][^>]*>/i', '', strval($value)));

    652. 

  652. 			return ($value2 <> "") ? $this->ViewValue : "&nbsp;";

    653. 

  653. 		} else {

    654. 

  654. 			return "&nbsp;";

    655. 

  655. 		}

    656. 

  656. 	}

    657. 

  657. 

    658. 

  658. 	// Form value

    659. 

  659. 	function setFormValue($v) {

    660. 

  660. 		$this->FormValue = ewrpt_StripSlashes($v);

    661. 

  661. 		if (is_array($this->FormValue))

    662. 

  662. 			$this->FormValue = implode(",", $this->FormValue);

    663. 

  663. 		$this->CurrentValue = $this->FormValue;

    664. 

  664. 	}

    665. 

  665. 

    666. 

  666. 	// QueryString value

    667. 

  667. 	function setQueryStringValue($v) {

    668. 

  668. 		$this->QueryStringValue = ewrpt_StripSlashes($v);

    669. 

  669. 		$this->CurrentValue = $this->QueryStringValue;

    670. 

  670. 	}

    671. 

  671. 

    672. 

  672. 	// Database value

    673. 

  673. 	function setDbValue($v) {

    674. 

  674. 		$this->OldValue = $this->DbValue;

    675. 

  675. 		if (EWRPT_IS_MSSQL && ($this->FldType == 131 || $this->FldType == 139)) // MS SQL adNumeric/adVarNumeric field

    676. 

  676. 			$this->DbValue = floatval($v);

    677. 

  677. 		else

    678. 

  678. 			$this->DbValue = $v;

    679. 

  679. 		$this->CurrentValue = $this->DbValue;

    680. 

  680. 	}

    681. 

  681. 

    682. 

  682. 	// Group value

    683. 

  683. 	function GroupValue() {

    684. 

  684. 		return $this->getGroupValue($this->CurrentValue);

    685. 

  685. 	}

    686. 

  686. 

    687. 

  687. 	// Group old value

    688. 

  688. 	function GroupOldValue() {

    689. 

  689. 		return $this->getGroupValue($this->OldValue);

    690. 

  690. 	}

    691. 

  691. 

    692. 

  692. 	// Get group value

    693. 

  693. 	function getGroupValue($v) {

    694. 

  694. 		if ($this->GroupingFieldId == 1) {

    695. 

  695. 			return $v;

    696. 

  696. 		} elseif (is_array($this->GroupDbValues)) {

    697. 

  697. 			return @$this->GroupDbValues[$v];

    698. 

  698. 		} elseif ($this->FldGroupByType <> "" && $this->FldGroupByType <> "n") {

    699. 

  699. 			return ewrpt_GroupValue($this, $v);

    700. 

  700. 		} else {

    701. 

  701. 			return $v;

    702. 

  702. 		}

    703. 

  703. 	}

    704. 

  704. }

    705. 

  705. 

    706. 

  706. /**

    707. 

  707.  * Chart class

    708. 

  708.  */

    709. 

  709. 

    710. 

  710. class crChart {

    711. 

  711. 	var $TblName; // Table name

    712. 

  712. 	var $TblVar; // Table variable name

    713. 

  713. 	var $ChartName; // Chart name

    714. 

  714. 	var $ChartVar; // Chart variable name

    715. 

  715. 	var $ChartXFldName; // Chart X Field name

    716. 

  716. 	var $ChartYFldName; // Chart Y Field name

    717. 

  717. 	var $ChartSFldName; // Chart Series Field name

    718. 

  718. 	var $ChartType; // Chart Type

    719. 

  719. 	var $ChartSummaryType; // Chart Type

    720. 

  720. 	var $ChartWidth; // Chart Width

    721. 

  721. 	var $ChartHeight; // Chart Height

    722. 

  722. 	var $ChartAlign; // Chart Align

    723. 

  723. 	var $SqlSelect;

    724. 

  724. 	var $SqlGroupBy;

    725. 

  725. 	var $SqlOrderBy;

    726. 

  726. 	var $XAxisDateFormat;

    727. 

  727. 	var $NameDateFormat;

    728. 

  728. 	var $SeriesDateType;

    729. 

  729. 	var $SqlSelectSeries;

    730. 

  730. 	var $SqlGroupBySeries;

    731. 

  731. 	var $SqlOrderBySeries;

    732. 

  732. 	var $ID;

    733. 

  733. 	var $Parms = array();

    734. 

  734. 	var $Trends;

    735. 

  735. 	var $Data;

    736. 

  736. 	var $Series;

    737. 

  737. 	var $XmlDoc;

    738. 

  738. 	var $XmlRoot;

    739. 

  739. 

    740. 

  740. 	// Constructor

    741. 

  741. 	function crChart($tblvar, $tblname, $chartvar, $chartname, $xfld, $yfld, $sfld, $type, $smrytype, $width, $height, $align="") {

    742. 

  742. 		$this->TblVar = $tblvar;

    743. 

  743. 		$this->TblName = $tblname;

    744. 

  744. 		$this->ChartVar = $chartvar;

    745. 

  745. 		$this->ChartName = $chartname;

    746. 

  746. 		$this->ChartXFldName = $xfld;

    747. 

  747. 		$this->ChartYFldName = $yfld;

    748. 

  748. 		$this->ChartSFldName = $sfld;

    749. 

  749. 		$this->ChartType = $type;

    750. 

  750. 		$this->ChartSummaryType = $smrytype;

    751. 

  751. 		$this->ChartWidth = $width;

    752. 

  752. 		$this->ChartHeight = $height;

    753. 

  753. 		$this->ChartAlign = $align;

    754. 

  754. 		$this->ID = NULL;

    755. 

  755. 		$this->Parms = NULL;

    756. 

  756. 		$this->Trends = NULL;

    757. 

  757. 		$this->Data = NULL;

    758. 

  758. 		$this->Series = NULL;

    759. 

  759. 		$this->XmlDoc = new DOMDocument("1.0", "utf-8");

    760. 

  760. 	}

    761. 

  761. 

    762. 

  762. 	// Chart caption

    763. 

  763. 	function ChartCaption() {

    764. 

  764. 		global $ReportLanguage;

    765. 

  765. 		return $ReportLanguage->ChartPhrase($this->TblVar, $this->ChartVar, "ChartCaption");

    766. 

  766. 	}

    767. 

  767. 

    768. 

  768. 	// function xaxisname

    769. 

  769. 	function ChartXAxisName() {

    770. 

  770. 		global $ReportLanguage;

    771. 

  771. 		return $ReportLanguage->ChartPhrase($this->TblVar, $this->ChartVar, "ChartXAxisName");

    772. 

  772. 	}

    773. 

  773. 

    774. 

  774. 	// function yaxisname

    775. 

  775. 	function ChartYAxisName() {

    776. 

  776. 		global $ReportLanguage;

    777. 

  777. 		return $ReportLanguage->ChartPhrase($this->TblVar, $this->ChartVar, "ChartYAxisName");

    778. 

  778. 	}

    779. 

  779. 

    780. 

  780. 	// function PYAxisName

    781. 

  781. 	function ChartPYAxisName() {

    782. 

  782. 		global $ReportLanguage;

    783. 

  783. 		return $ReportLanguage->ChartPhrase($this->TblVar, $this->ChartVar, "ChartPYAxisName");

    784. 

  784. 	}

    785. 

  785. 

    786. 

  786. 	// function SYAxisName

    787. 

  787. 	function ChartSYAxisName() {

    788. 

  788. 		global $ReportLanguage;

    789. 

  789. 		return $ReportLanguage->ChartPhrase($this->TblVar, $this->ChartVar, "ChartSYAxisName");

    790. 

  790. 	}

    791. 

  791. 

    792. 

  792. 	// Set chart parameters

    793. 

  793. 	function SetChartParam($Name, $Value, $Output) {

    794. 

  794. 		$this->Parms[$Name] = array($Name, $Value, $Output);

    795. 

  795. 	}

    796. 

  796. 

    797. 

  797. 	// Set up default chart parm

    798. 

  798. 	function SetupDefaultChartParm($key, $value) {

    799. 

  799. 		if (is_array($this->Parms)) {

    800. 

  800. 			$parm = $this->LoadParm($key);

    801. 

  801. 			if (is_null($parm)) {

    802. 

  802. 				$this->Parms[$key] = array($key, $value, TRUE);

    803. 

  803. 			} elseif ($parm == "") {

    804. 

  804. 				$this->SaveParm($key, $value);

    805. 

  805. 			}

    806. 

  806. 		}

    807. 

  807. 	}

    808. 

  808. 

    809. 

  809. 	// Load chart parm

    810. 

  810. 	function LoadParm($key) {

    811. 

  811. 		if (is_array($this->Parms) && array_key_exists($key, $this->Parms))

    812. 

  812. 			return $this->Parms[$key][1];

    813. 

  813. 		return NULL;

    814. 

  814. 	}

    815. 

  815. 

    816. 

  816. 	// Save chart parm

    817. 

  817. 	function SaveParm($key, $value) {

    818. 

  818. 		if (is_array($this->Parms) && array_key_exists($key, $this->Parms))

    819. 

  819. 			$this->Parms[$key][1] = $value;

    820. 

  820. 	}

    821. 

  821. 

    822. 

  822. 	// Chart Xml

    823. 

  823. 	function ChartXml() {

    824. 

  824. 

    825. 

  825. 		// Initialize default values

    826. 

  826. 		$this->SetupDefaultChartParm("caption", "Chart");

    827. 

  827. 

    828. 

  828. 		// Show names/values/hover

    829. 

  829. 		$this->SetupDefaultChartParm("shownames", "1"); // Default show names

    830. 

  830. 		$this->SetupDefaultChartParm("showvalues", "1"); // Default show values

    831. 

  831. 		$this->SetupDefaultChartParm("showhover", "1"); // Default show hover

    832. 

  832. 

    833. 

  833. 		// Get showvalues/showhovercap

    834. 

  834. 		$cht_showValues = $this->LoadParm("showvalues");

    835. 

  835. 		$cht_showHoverCap = $this->LoadParm("showhovercap");

    836. 

  836. 

    837. 

  837. 		// Format percent for Pie charts

    838. 

  838. 		$cht_showPercentageValues = $this->LoadParm("showPercentageValues");

    839. 

  839. 		$cht_showPercentageInLabel = $this->LoadParm("showPercentageInLabel");

    840. 

  840. 		$cht_type = $this->LoadParm("type");

    841. 

  841. 		if ($cht_type == 2 || $cht_type == 6 || $cht_type == 8 || $cht_type == 101) {

    842. 

  842. 			if (($cht_showHoverCap == "1" && $cht_showPercentageValues == "1") ||

    843. 

  843. 			($cht_showValues == "1" && $cht_showPercentageInLabel == "1")) {

    844. 

  844. 				$this->SetupDefaultChartParm("formatNumber", "1");

    845. 

  845. 				$this->SaveParm("formatNumber", "1");

    846. 

  846. 			}

    847. 

  847. 		} elseif ($cht_type == 20) {

    848. 

  848. 			$this->SetupDefaultChartParm("bearBorderColor", "E33C3C");

    849. 

  849. 			$this->SetupDefaultChartParm("bearFillColor", "E33C3C");

    850. 

  850. 		}

    851. 

  851. 

    852. 

  852. 		// Process chart parms

    853. 

  853. 		$this->ProcessChartParms($cht_type, $this->Parms);

    854. 

  854. 		$chartseries =& $this->Series;

    855. 

  855. 		$chartdata =& $this->Data;

    856. 

  856. 		$cht_series = ((intval($cht_type) >= 9 && intval($cht_type) <= 19) || (intval($cht_type) >= 102 && intval($cht_type) <= 103)) ? 1 : 0; // $cht_series = 1 (Multi series charts)

    857. 

  857. 		$cht_series_type = $this->LoadParm("seriestype");

    858. 

  858. 		$cht_alpha = $this->LoadParm("alpha");

    859. 

  859. 

    860. 

  860. 		// Hide legend for single series (Bar 3D / Column 2D / Line 2D / Area 2D)

    861. 

  861. 		$scrollchart = (intval($this->LoadParm("numVisiblePlot")) > 0 && ($cht_type == 1 || $cht_type == 4 || $cht_type == 7)) ? 1 : 0;

    862. 

  862. 		$cht_single_series = ($cht_type == 104 || $scrollchart == 1) ? 1 : 0;

    863. 

  863. 		if ($cht_single_series == 1) {

    864. 

  864. 			$this->SetupDefaultChartParm("showLegend", "0");

    865. 

  865. 			$this->SaveParm("showLegend", "0");

    866. 

  866. 		}

    867. 

  867. 		if (is_array($chartdata)) {

    868. 

  868. 			$this->WriteChartHeader(); // Write chart header

    869. 

  869. 

    870. 

  870. 			// Candlestick

    871. 

  871. 			if ($cht_type == 20) {

    872. 

  872. 

    873. 

  873. 				// Write candlestick cat

    874. 

  874. 				if (count($chartdata[0]) >= 7) {

    875. 

  875. 					$cats = $this->XmlDoc->createElement('categories');

    876. 

  876. 					$this->XmlRoot->appendChild($cats);

    877. 

  877. 					$cntcat = count($chartdata);

    878. 

  878. 					for ($i = 0; $i < $cntcat; $i++) {

    879. 

  879. 						$xindex = $i+1;

    880. 

  880. 						$name = $chartdata[$i][6];

    881. 

  881. 						if ($name <> "")

    882. 

  882. 							$this->WriteChartCandlestickCatContent($cats, $xindex, $name);

    883. 

  883. 					}

    884. 

  884. 				}

    885. 

  885. 

    886. 

  886. 				// Write candlestick data

    887. 

  887. 				$data = $this->XmlDoc->createElement('data');

    888. 

  888. 				$this->XmlRoot->appendChild($data);

    889. 

  889. 				$cntdata = count($chartdata);

    890. 

  890. 				for ($i = 0; $i < $cntdata; $i++) {

    891. 

  891. 					$open = is_null($chartdata[$i][2]) ? 0 : (float)$chartdata[$i][2];

    892. 

  892. 					$high = is_null($chartdata[$i][3]) ? 0 : (float)$chartdata[$i][3];

    893. 

  893. 					$low = is_null($chartdata[$i][4]) ? 0 : (float)$chartdata[$i][4];

    894. 

  894. 					$close = is_null($chartdata[$i][5]) ? 0 : (float)$chartdata[$i][5];

    895. 

  895. 					$xindex = $i+1;

    896. 

  896. 					$this->WriteChartCandlestickContent($data, $open, $high, $low, $close, $xindex);

    897. 

  897. 				}

    898. 

  898. 

    899. 

  899. 			// Multi series

    900. 

  900. 			} else if ($cht_series == 1) {

    901. 

  901. 

    902. 

  902. 				// Multi-Y values

    903. 

  903. 				if ($cht_series_type == "1") {

    904. 

  904. 

    905. 

  905. 					// Write cat

    906. 

  906. 					$cats = $this->XmlDoc->createElement('categories');

    907. 

  907. 					$this->XmlRoot->appendChild($cats);

    908. 

  908. 					$cntcat = count($chartdata);

    909. 

  909. 					for ($i = 0; $i < $cntcat; $i++) {

    910. 

  910. 						$name = $this->ChartFormatName($chartdata[$i][0]);

    911. 

  911. 						$this->WriteChartCatContent($cats, $name);

    912. 

  912. 					}

    913. 

  913. 

    914. 

  914. 					// Write series

    915. 

  915. 					$cntdata = count($chartdata);

    916. 

  916. 					$cntseries = count($chartseries);

    917. 

  917. 					if ($cntseries > count($chartdata[0])-2) $cntseries = count($chartdata[0])-2;

    918. 

  918. 					for ($i = 0; $i < $cntseries; $i++) {

    919. 

  919. 						$color = $this->GetPaletteColor($i);

    920. 

  920. 						$bShowSeries = EWRPT_CHART_SHOW_BLANK_SERIES;

    921. 

  921. 						$dataset = $this->XmlDoc->createElement('dataset');

    922. 

  922. 						$this->WriteChartSeriesHeader($dataset, $chartseries[$i], $color, $cht_alpha);

    923. 

  923. 						$bWriteSeriesHeader = TRUE;

    924. 

  924. 						for ($j = 0; $j < $cntdata; $j++) {

    925. 

  925. 							$val = $chartdata[$j][$i+2];

    926. 

  926. 							$val = (is_null($val)) ? 0 : (float)$val;

    927. 

  927. 							if ($val <> 0) $bShowSeries = TRUE;

    928. 

  928. 							$this->WriteChartSeriesContent($dataset, $val);

    929. 

  929. 						}

    930. 

  930. 						if ($bShowSeries)

    931. 

  931. 							$this->XmlRoot->appendChild($dataset);

    932. 

  932. 					}

    933. 

  933. 

    934. 

  934. 				// Series field

    935. 

  935. 				} else {

    936. 

  936. 

    937. 

  937. 					// Get series names

    938. 

  938. 					if (is_array($chartseries)) {

    939. 

  939. 						$nSeries = count($chartseries);

    940. 

  940. 					} else {

    941. 

  941. 						$nSeries = 0;

    942. 

  942. 					}

    943. 

  943. 

    944. 

  944. 					// Write cat

    945. 

  945. 					$cats = $this->XmlDoc->createElement('categories');

    946. 

  946. 					$this->XmlRoot->appendChild($cats);

    947. 

  947. 					$chartcats = array();

    948. 

  948. 					$cntdata = count($chartdata);

    949. 

  949. 					for ($i = 0; $i < $cntdata; $i++) {

    950. 

  950. 						$name = $chartdata[$i][0];

    951. 

  951. 						if (!in_array($name, $chartcats)) {

    952. 

  952. 							$this->WriteChartCatContent($cats, $name);

    953. 

  953. 							$chartcats[] = $name;

    954. 

  954. 						}

    955. 

  955. 					}

    956. 

  956. 

    957. 

  957. 					// Write series

    958. 

  958. 					for ($i = 0; $i < $nSeries; $i++) {

    959. 

  959. 						$seriesname = (is_array($chartseries[$i])) ? $chartseries[$i][0] : $chartseries[$i];

    960. 

  960. 						$color = $this->GetPaletteColor($i);

    961. 

  961. 						$bShowSeries = EWRPT_CHART_SHOW_BLANK_SERIES;

    962. 

  962. 						$dataset = $this->XmlDoc->createElement('dataset');

    963. 

  963. 						$this->WriteChartSeriesHeader($dataset, $chartseries[$i], $color, $cht_alpha);

    964. 

  964. 						$cntcats = count($chartcats);

    965. 

  965. 						$cntdata = count($chartdata);

    966. 

  966. 						for ($j = 0; $j < $cntcats; $j++) {

    967. 

  967. 							$val = 0;

    968. 

  968. 							for ($k = 0; $k < $cntdata; $k++) {

    969. 

  969. 								if ($chartdata[$k][0] == $chartcats[$j] && $chartdata[$k][1] == $seriesname) {

    970. 

  970. 									$val = $chartdata[$k][2];

    971. 

  971. 									$val = (is_null($val)) ? 0 : (float)$val;

    972. 

  972. 									if ($val <> 0) $bShowSeries = TRUE;

    973. 

  973. 									break;

    974. 

  974. 								}

    975. 

  975. 							}

    976. 

  976. 							$this->WriteChartSeriesContent($dataset, $val);

    977. 

  977. 						}

    978. 

  978. 						if ($bShowSeries)

    979. 

  979. 							$this->XmlRoot->appendChild($dataset);

    980. 

  980. 					}

    981. 

  981. 				}

    982. 

  982. 

    983. 

  983. 			// Show single series

    984. 

  984. 			} elseif ($cht_single_series == 1) {

    985. 

  985. 

    986. 

  986. 				// Write multiple cats

    987. 

  987. 				$cats = $this->XmlDoc->createElement('categories');

    988. 

  988. 				$this->XmlRoot->appendChild($cats);

    989. 

  989. 				$cntcat = count($chartdata);

    990. 

  990. 				for ($i = 0; $i < $cntcat; $i++) {

    991. 

  991. 					$name = $this->ChartFormatName($chartdata[$i][0]);

    992. 

  992. 					if ($chartdata[$i][1] <> "") 

    993. 

  993. 						$name .= ", " . $chartdata[$i][1];

    994. 

  994. 					$this->WriteChartCatContent($cats, $name);

    995. 

  995. 				}

    996. 

  996. 

    997. 

  997. 				// Write series

    998. 

  998. 				$toolTipSep = $this->LoadParm("toolTipSepChar");

    999. 

  999. 				if ($toolTipSep == "") $toolTipSep = ":";

    1000. 

  1000. 				$cntdata = count($chartdata);

    1001. 

  1001. 				$dataset = $this->XmlDoc->createElement('dataset');

    1002. 

  1002. 				$this->WriteChartSeriesHeader($dataset, '', '', $cht_alpha);

    1003. 

  1003. 				for ($i = 0; $i < $cntdata; $i++) {

    1004. 

  1004. 					$name = $this->ChartFormatName($chartdata[$i][0]);

    1005. 

  1005. 					if ($chartdata[$i][1] <> "") 

    1006. 

  1006. 						$name .= ", " . $chartdata[$i][1];

    1007. 

  1007. 					$val = $chartdata[$i][2];

    1008. 

  1008. 					$val = (is_null($val)) ? 0 : (float)$val;

    1009. 

  1009. 					$color = $this->GetPaletteColor($i);

    1010. 

  1010. 					$toolText = $name . $toolTipSep . $val;

    1011. 

  1011. 					$this->WriteChartSeriesContent($dataset, $val, $color, $cht_alpha, '', $toolText);

    1012. 

  1012. 					$this->XmlRoot->appendChild($dataset);

    1013. 

  1013. 				}

    1014. 

  1014. 

    1015. 

  1015. 			// Single series

    1016. 

  1016. 			} else {

    1017. 

  1017. 				$cntdata = count($chartdata);

    1018. 

  1018. 				for ($i = 0; $i < $cntdata; $i++) {

    1019. 

  1019. 					$name = $this->ChartFormatName($chartdata[$i][0]);

    1020. 

  1020. 					$color = $this->GetPaletteColor($i);

    1021. 

  1021. 					if ($chartdata[$i][1] <> "") 

    1022. 

  1022. 						$name .= ", " . $chartdata[$i][1];

    1023. 

  1023. 					$val = $chartdata[$i][2];

    1024. 

  1024. 					$val = (is_null($val)) ? 0 : (float)$val;

    1025. 

  1025. 					$this->WriteChartContent($this->XmlRoot, $name, $val, $color, $cht_alpha, @$link); // Get chart content

    1026. 

  1026. 				}

    1027. 

  1027. 			}

    1028. 

  1028. 

    1029. 

  1029. 			// Get trend lines

    1030. 

  1030. 			$this->WriteChartTrendLines();

    1031. 

  1031. 		}

    1032. 

  1032. 		$wrk = $this->XmlDoc->saveXML();

    1033. 

  1033. 		return $wrk;

    1034. 

  1034. 

    1035. 

  1035. 		// ewrpt_Trace($wrk);

    1036. 

  1036. 	}

    1037. 

  1037. 

    1038. 

  1038. 	// Show chart (FusionCharts Free)

    1039. 

  1039. 	// typ: chart type (1/2/3/4/...)

    1040. 

  1040. 	// id: chart id

    1041. 

  1041. 	// parms: "bgcolor=FFFFFF|..."

    1042. 

  1042. 	// trends: trend lines

    1043. 

  1043. 	function ShowChartFCF($xml) {

    1044. 

  1044. 		$typ = $this->ChartType;

    1045. 

  1045. 		$id = $this->ID;

    1046. 

  1046. 		$parms = $this->Parms;

    1047. 

  1047. 		$trends = $this->Trends;

    1048. 

  1048. 		$data = $this->Data;

    1049. 

  1049. 		$series = $this->Series;

    1050. 

  1050. 		$width = $this->ChartWidth;

    1051. 

  1051. 		$height = $this->ChartHeight;

    1052. 

  1052. 		$align = $this->ChartAlign;

    1053. 

  1053. 		if (empty($typ))

    1054. 

  1054. 			$typ = 1;

    1055. 

  1055. 

    1056. 

  1056. 		// Get chart swf

    1057. 

  1057. 		switch ($typ) {

    1058. 

  1058. 

    1059. 

  1059. 		// Single Series

    1060. 

  1060. 			case 1:	$chartswf = "FCF_Column2D.swf"; break; // Column 2D

    1061. 

  1061. 			case 2:	$chartswf = "FCF_Pie2D.swf"; break; // Pie 2D

    1062. 

  1062. 			case 3:	$chartswf = "FCF_Bar2D.swf"; break; // Bar 2D

    1063. 

  1063. 			case 4: $chartswf = "FCF_Line.swf"; break; // Line 2D

    1064. 

  1064. 			case 5: $chartswf = "FCF_Column3D.swf"; break; // Column 3D

    1065. 

  1065. 			case 6: $chartswf = "FCF_Pie3D.swf"; break; // Pie 3D

    1066. 

  1066. 			case 7: $chartswf = "FCF_Area2D.swf"; break; // Area 2D

    1067. 

  1067. 			case 8: $chartswf = "FCF_Doughnut2D.swf"; break; // Doughnut 2D

    1068. 

  1068. 

    1069. 

  1069. 		// Multi Series

    1070. 

  1070. 			case 9: $chartswf = "FCF_MSColumn2D.swf"; break; // Multi-series Column 2D

    1071. 

  1071. 			case 10: $chartswf = "FCF_MSColumn3D.swf"; break; // Multi-series Column 3D

    1072. 

  1072. 			case 11: $chartswf = "FCF_MSLine.swf"; break; // Multi-series Line 2D

    1073. 

  1073. 			case 12: $chartswf = "FCF_MSArea2D.swf"; break; // Multi-series Area 2D

    1074. 

  1074. 			case 13: $chartswf = "FCF_MSBar2D.swf"; break; // Multi-series Bar 2D

    1075. 

  1075. 

    1076. 

  1076. 		// Stacked

    1077. 

  1077. 			case 14: $chartswf = "FCF_StackedColumn2D.swf"; break; // Stacked Column 2D

    1078. 

  1078. 			case 15: $chartswf = "FCF_StackedColumn3D.swf"; break; // Stacked Column 3D

    1079. 

  1079. 			case 16: $chartswf = "FCF_StackedArea2D.swf"; break; // Stacked Area 2D

    1080. 

  1080. 			case 17: $chartswf = "FCF_StackedBar2D.swf"; break; // Stacked Bar 2D

    1081. 

  1081. 

    1082. 

  1082. 		// Combination

    1083. 

  1083. 			case 18: $chartswf = "FCF_MSColumn2DLineDY.swf"; break; // Multi-series Column 2D Line Dual Y Chart

    1084. 

  1084. 			case 19: $chartswf = "FCF_MSColumn3DLineDY.swf"; break; // Multi-series Column 3D Line Dual Y Chart

    1085. 

  1085. 

    1086. 

  1086. 		// Financial

    1087. 

  1087. 			case 20: $chartswf = "FCF_Candlestick.swf"; break; // Candlestick

    1088. 

  1088. 

    1089. 

  1089. 		// Other

    1090. 

  1090. 			case 21: $chartswf = "FCF_Gantt.swf"; break; // Gantt

    1091. 

  1091. 			case 22: $chartswf = "FCF_Funnel.swf"; break; // Funnel

    1092. 

  1092. 

    1093. 

  1093. 		// Additional FusionCharts

    1094. 

  1094. 			case 101: $chartswf = "FCF_Doughnut2D.swf"; break; // Doughnut 3D, switch back to 2D

    1095. 

  1095. 			case 102: $chartswf = "FCF_MSBar2D.swf"; break; // Multi-series Bar 3D, switch back to 2D

    1096. 

  1096. 			case 103: $chartswf = "FCF_StackedBar2D.swf"; break; // Stacked Bar 3D, switch back to 2D

    1097. 

  1097. 			case 104: $chartswf = "FCF_Bar2D.swf"; break; // Bar 3D, switch back to 2D

    1098. 

  1098. 

    1099. 

  1099. 		// Default

    1100. 

  1100. 			default: $chartswf = "FCF_Column2D.swf"; // Default = Column 2D

    1101. 

  1101. 		}

    1102. 

  1102. 

    1103. 

  1103. 		// Set width, height and align

    1104. 

  1104. 		if (is_numeric($width) && is_numeric($height)) {

    1105. 

  1105. 			$wrkwidth = $width;

    1106. 

  1106. 			$wrkheight = $height;

    1107. 

  1107. 		} else { // default

    1108. 

  1108. 			$wrkwidth = EWRPT_CHART_WIDTH;

    1109. 

  1109. 			$wrkheight = EWRPT_CHART_HEIGHT;

    1110. 

  1110. 		}

    1111. 

  1111. 		if (strtolower($align) == "left" || strtolower($align) == "right") {

    1112. 

  1112. 			$wrkalign = strtolower($align);

    1113. 

  1113. 		} else {

    1114. 

  1114. 			$wrkalign = EWRPT_CHART_ALIGN; // default

    1115. 

  1115. 		}

    1116. 

  1116. 

    1117. 

  1117. 		// Output JavaScript for FCF

    1118. 

  1118. 		$chartxml = $xml;

    1119. 

  1119. 		$wrk = "<script type=\"text/javascript\">\n";

    1120. 

  1120. 		$wrk .= "var chartwidth = \"$wrkwidth\";\n";

    1121. 

  1121. 		$wrk .= "var chartheight = \"$wrkheight\";\n";

    1122. 

  1122. 

    1123. 

  1123. 		//$wrk .= "var chartalign = \"$wrkalign\";\n";

    1124. 

  1124. 		$wrk .= "var chartxml = \"" . ewrpt_EscapeJs($chartxml) . "\";\n";

    1125. 

  1125. 		$wrk .= "var chartid = \"div_$id\";\n";

    1126. 

  1126. 		$wrk .= "var chartswf = \"" . EWRPT_FUSIONCHARTS_FREE_CHART_PATH . $chartswf . "\";\n";

    1127. 

  1127. 		$wrk .= "var cht_$id = new FusionChartsFree(chartswf, \"chart_$id\", chartwidth, chartheight);\n";

    1128. 

  1128. 		$wrk .= "cht_$id.addParam(\"wmode\", \"transparent\");\n";

    1129. 

  1129. 		$wrk .= "cht_$id.setDataXML(chartxml);\n";

    1130. 

  1130. 		$wrk .= "var f = " . CurrentPage()->PageObjName . ".Chart_Rendering;\n";

    1131. 

  1131. 		$wrk .= "if (typeof f == \"function\") f(cht_$id, 'chart_$id');\n";

    1132. 

  1132. 		$wrk .= "cht_$id.render(chartid);\n";

    1133. 

  1133. 		$wrk .= "f = " . CurrentPage()->PageObjName . ".Chart_Rendered;\n";

    1134. 

  1134. 		$wrk .= "if (typeof f == \"function\") f(cht_$id, 'chart_$id');\n";

    1135. 

  1135. 		$wrk .= "</script>\n";

    1136. 

  1136. 

    1137. 

  1137. 		// Add debug xml

    1138. 

  1138. 		if (EWRPT_DEBUG_ENABLED)

    1139. 

  1139. 			$wrk .= "<p>(Chart XML): " . ewrpt_HtmlEncode($chartxml) . "</p>";

    1140. 

  1140. 		return $wrk;

    1141. 

  1141. 	}

    1142. 

  1142. 

    1143. 

  1143. 	// Show Chart Xml

    1144. 

  1144. 	function ShowChartXml() {

    1145. 

  1145. 

    1146. 

  1146. 		// Build chart content

    1147. 

  1147. 		$sChartContent = $this->ChartXml();

    1148. 

  1148. 		header("Content-Type: text/xml; charset=UTF-8");

    1149. 

  1149. 

    1150. 

  1150. 		// Write utf-8 BOM

    1151. 

  1151. 		echo "\xEF\xBB\xBF";

    1152. 

  1152. 

    1153. 

  1153. 		// Write utf-8 encoding

    1154. 

  1154. 		echo "<?xml version=\"1.0\" encoding=\"utf-8\" ?>";

    1155. 

  1155. 

    1156. 

  1156. 		// Write content

    1157. 

  1157. 		echo $sChartContent;

    1158. 

  1158. 	}

    1159. 

  1159. 

    1160. 

  1160. 	// Show Chart Text

    1161. 

  1161. 	function ShowChartText() {

    1162. 

  1162. 

    1163. 

  1163. 		// Build chart content

    1164. 

  1164. 		$sChartContent = $this->ChartXml();

    1165. 

  1165. 		header("Content-Type: text/plain; charset=UTF-8");

    1166. 

  1166. 

    1167. 

  1167. 		// Write content

    1168. 

  1168. 		echo $sChartContent;

    1169. 

  1169. 	}

    1170. 

  1170. 

    1171. 

  1171. 	// Get color

    1172. 

  1172. 	function GetPaletteColor($i) {

    1173. 

  1173. 		$colorpalette = $this->LoadParm("colorpalette");

    1174. 

  1174. 		$ar_cht_colorpalette = explode("|", $colorpalette);

    1175. 

  1175. 		if (is_array($ar_cht_colorpalette))

    1176. 

  1176. 			$cntar = count($ar_cht_colorpalette);

    1177. 

  1177. 		return $ar_cht_colorpalette[$i % $cntar];

    1178. 

  1178. 	}

    1179. 

  1179. 

    1180. 

  1180. 	// Convert to HTML color

    1181. 

  1181. 	function ColorCode($c) {

    1182. 

  1182. 		if ($c <> "") {

    1183. 

  1183. 

    1184. 

  1184. 			// remove #

    1185. 

  1185. 			$color = str_replace("#", "", $c);

    1186. 

  1186. 

    1187. 

  1187. 			// fill to 6 digits

    1188. 

  1188. 			return str_pad($color, 6, "0", STR_PAD_LEFT);

    1189. 

  1189. 		} else {

    1190. 

  1190. 			return "";

    1191. 

  1191. 		}

    1192. 

  1192. 	}

    1193. 

  1193. 

    1194. 

  1194. 	// Output chart header

    1195. 

  1195. 	function WriteChartHeader() {

    1196. 

  1196. 		$cht_parms = $this->Parms;

    1197. 

  1197. 		$chartElement = ($this->ChartType == 20 || (EWRPT_FUSIONCHARTS_FREE && $this->ChartType <> 21 && $this->ChartType <> 22)) ? 'graph' : 'chart';

    1198. 

  1198. 		$chart = $this->XmlDoc->createElement($chartElement);

    1199. 

  1199. 		$this->XmlRoot =& $chart;

    1200. 

  1200. 		$this->XmlDoc->appendChild($chart);

    1201. 

  1201. 		if (is_array($cht_parms)) {

    1202. 

  1202. 			foreach ($cht_parms as $parm) {

    1203. 

  1203. 				if ($parm[2])

    1204. 

  1204. 					$this->WriteAtt($chart, $parm[0], $parm[1]);

    1205. 

  1205. 			}

    1206. 

  1206. 		}

    1207. 

  1207. 	}

    1208. 

  1208. 

    1209. 

  1209. 	// Get TrendLine XML

    1210. 

  1210. 	// <trendlines>

    1211. 

  1211. 	//    <line startvalue='0.8' displayValue='Good' color='FF0000' thickness='1' isTrendZone='0'/>

    1212. 

  1212. 	//    <line startvalue='-0.4' displayValue='Bad' color='009999' thickness='1' isTrendZone='0'/>

    1213. 

  1213. 	// </trendlines>

    1214. 

  1214. 	function WriteChartTrendLines() {

    1215. 

  1215. 		$cht_trends = $this->Trends;

    1216. 

  1216. 		if (is_array($cht_trends)) {

    1217. 

  1217. 			foreach ($cht_trends as $trend) {

    1218. 

  1218. 				$trends = $this->XmlDoc->createElement('trendlines');

    1219. 

  1219. 				$this->XmlRoot->appendChild($trends);

    1220. 

  1220. 

    1221. 

  1221. 				// Get all trend lines

    1222. 

  1222. 				$this->WriteChartTrendLine($trends, $trend[0], $trend[1], $trend[2], $trend[3], $trend[4], $trend[5], $trend[6], $trend[7]);

    1223. 

  1223. 			}

    1224. 

  1224. 		}

    1225. 

  1225. 	}

    1226. 

  1226. 

    1227. 

  1227. 	// Output trend line

    1228. 

  1228. 	function WriteChartTrendLine(&$node, $startval, $endval, $color, $dispval, $thickness, $trendzone, $showontop, $alpha) {

    1229. 

  1229. 		$line = $this->XmlDoc->createElement('line');

    1230. 

  1230. 		$this->WriteAtt($line, "startValue", $startval); // Starting y value

    1231. 

  1231. 		if ($endval <> 0)

    1232. 

  1232. 			$this->WriteAtt($line, "endValue", $endval); // Ending y value

    1233. 

  1233. 		$this->WriteAtt($line, "color", $this->CheckColorCode($color)); // Color

    1234. 

  1234. 		if ($dispval <> "")

    1235. 

  1235. 			$this->WriteAtt($line, "displayValue", $dispval); // Display value

    1236. 

  1236. 		if ($thickness > 0)

    1237. 

  1237. 			$this->WriteAtt($line, "thickness", $thickness); // Thickness

    1238. 

  1238. 		$this->WriteAtt($line, "isTrendZone", $trendzone); // Display trend as zone or line

    1239. 

  1239. 		$this->WriteAtt($line, "showOnTop", $showontop); // Show on top

    1240. 

  1240. 		if ($alpha > 0)

    1241. 

  1241. 			$this->WriteAtt($line, "alpha", $alpha); // Alpha

    1242. 

  1242. 		$node->appendChild($line);

    1243. 

  1243. 	}

    1244. 

  1244. 

    1245. 

  1245. 	// Series header/footer XML (multi series)

    1246. 

  1246. 	function WriteChartSeriesHeader(&$node, $series, $color, $alpha) {

    1247. 

  1247. 		global $ReportLanguage;

    1248. 

  1248. 		$seriesname = is_array($series) ? $series[0] : $series;

    1249. 

  1249. 		if (is_null($seriesname)) {

    1250. 

  1250. 			$seriesname = $ReportLanguage->Phrase("NullLabel");

    1251. 

  1251. 		} elseif ($seriesname == "") {

    1252. 

  1252. 			$seriesname = $ReportLanguage->Phrase("EmptyLabel");

    1253. 

  1253. 		}

    1254. 

  1254. 		$this->WriteAtt($node, "seriesname", $seriesname);

    1255. 

  1255. 		$this->WriteAtt($node, "color", $this->ColorCode($color));

    1256. 

  1256. 		$this->WriteAtt($node, "alpha", $alpha);

    1257. 

  1257. 		if (is_array($series))

    1258. 

  1258. 			$this->WriteAtt($node, "parentYAxis", $series[1]);

    1259. 

  1259. 	}

    1260. 

  1260. 

    1261. 

  1261. 	// Series content XML (multi series)

    1262. 

  1262. 	function WriteChartSeriesContent(&$node, $val, $color = "", $alpha = "", $lnk = "", $toolText = "") {

    1263. 

  1263. 		$set = $this->XmlDoc->createElement('set');

    1264. 

  1264. 		$this->WriteAtt($set, "value", $this->ChartFormatNumber($val));

    1265. 

  1265. 		if ($color <> "")

    1266. 

  1266. 			$this->WriteAtt($set, "color", $this->ColorCode($color));

    1267. 

  1267. 		if ($alpha <> "")

    1268. 

  1268. 			$this->WriteAtt($set, "alpha", $alpha);

    1269. 

  1269. 		if ($lnk <> "")

    1270. 

  1270. 			$this->WriteAtt($set, "link", $lnk);

    1271. 

  1271. 		if ($toolText <> "")

    1272. 

  1272. 			$this->WriteAtt($set, "toolText", $toolText);

    1273. 

  1273. 		$node->appendChild($set);

    1274. 

  1274. 	}

    1275. 

  1275. 

    1276. 

  1276. 	// Category content XML (Candlestick category)

    1277. 

  1277. 	function WriteChartCandlestickCatContent(&$node, $xindex, $name) {

    1278. 

  1278. 		$cat = $this->XmlDoc->createElement('category');

    1279. 

  1279. 		$this->WriteAtt($cat, "name", $name);

    1280. 

  1280. 		$this->WriteAtt($cat, "xindex", $xindex);

    1281. 

  1281. 		$this->WriteAtt($cat, "showline", "1");

    1282. 

  1282. 		$node->appendChild($cat);

    1283. 

  1283. 	}

    1284. 

  1284. 

    1285. 

  1285. 	// Chart content XML (Candlestick)

    1286. 

  1286. 	function WriteChartCandlestickContent(&$node, $open, $high, $low, $close, $xindex) {

    1287. 

  1287. 		$set = $this->XmlDoc->createElement('set');

    1288. 

  1288. 		$this->WriteAtt($set, "open", $this->ChartFormatNumber($open));

    1289. 

  1289. 		$this->WriteAtt($set, "high", $this->ChartFormatNumber($high));

    1290. 

  1290. 		$this->WriteAtt($set, "low", $this->ChartFormatNumber($low));

    1291. 

  1291. 		$this->WriteAtt($set, "close", $this->ChartFormatNumber($close));

    1292. 

  1292. 		if ($xindex <> "")

    1293. 

  1293. 			$this->WriteAtt($set, "xindex", $xindex);

    1294. 

  1294. 		$node->appendChild($set);

    1295. 

  1295. 	}

    1296. 

  1296. 

    1297. 

  1297. 	// Format name for chart

    1298. 

  1298. 	function ChartFormatName($name) {

    1299. 

  1299. 		global $ReportLanguage;

    1300. 

  1300. 		if (is_null($name)) {

    1301. 

  1301. 			return $ReportLanguage->Phrase("NullLabel");

    1302. 

  1302. 		} elseif ($name == "") {

    1303. 

  1303. 			return $ReportLanguage->Phrase("EmptyLabel");

    1304. 

  1304. 		} else {

    1305. 

  1305. 			return $name;

    1306. 

  1306. 		}

    1307. 

  1307. 	}

    1308. 

  1308. 

    1309. 

  1309. 	// Format number for chart

    1310. 

  1310. 	function ChartFormatNumber($v) {

    1311. 

  1311. 		$cht_decimalprecision = $this->LoadParm("decimalPrecision");

    1312. 

  1312. 		if (is_null($cht_decimalprecision)) {

    1313. 

  1313. 			return $v;

    1314. 

  1314. 		} else {

    1315. 

  1315. 			return number_format($v, $cht_decimalprecision, '.', '');

    1316. 

  1316. 		}

    1317. 

  1317. 	}

    1318. 

  1318. 

    1319. 

  1319. 	// Write attribute

    1320. 

  1320. 	function WriteAtt(&$node, $name, $val) {

    1321. 

  1321. 		$val = $this->CheckColorCode(strval($val));

    1322. 

  1322. 		$val = $this->ChartEncode($val);

    1323. 

  1323. 		if ($node->hasAttribute($name)) {

    1324. 

  1324. 			$node->getAttributeNode($name)->value = ewrpt_XmlEncode(ewrpt_ConvertToUtf8($val));

    1325. 

  1325. 		} else {

    1326. 

  1326. 			$att = $this->XmlDoc->createAttribute($name);

    1327. 

  1327. 			$att->value = ewrpt_XmlEncode(ewrpt_ConvertToUtf8($val));

    1328. 

  1328. 			$node->appendChild($att);

    1329. 

  1329. 		}

    1330. 

  1330. 	}

    1331. 

  1331. 

    1332. 

  1332. 	// Check color code

    1333. 

  1333. 	function CheckColorCode($val) {

    1334. 

  1334. 		if (substr($val, 0, 1) == "#" && strlen($val) == 7) {

    1335. 

  1335. 			return substr($val, 1);

    1336. 

  1336. 		} else {

    1337. 

  1337. 			return $val;

    1338. 

  1338. 		}

    1339. 

  1339. 	}

    1340. 

  1340. 

    1341. 

  1341. 	// Process chart parms

    1342. 

  1342. 	function ProcessChartParms(&$ChartType, &$Parms) {

    1343. 

  1343. 		if ($ChartType == 104) $ChartType = 3; // Bar 3D, Switch back to Bar 2D

    1344. 

  1344. 

    1345. 

  1345. 		// Remove numVisiblePlot (scroll charts)

    1346. 

  1346. 		if (array_key_exists("numVisiblePlot", $Parms))

    1347. 

  1347. 			unset($Parms["numVisiblePlot"]);

    1348. 

  1348. 	}

    1349. 

  1349. 

    1350. 

  1350. 	// Encode special characters for FusionChartsFree

    1351. 

  1351. 	// + => %2B

    1352. 

  1352. 	function ChartEncode($val) {

    1353. 

  1353. 		$v = str_replace("+", "%2B", $val);

    1354. 

  1354. 		return $v;

    1355. 

  1355. 	}

    1356. 

  1356. 

    1357. 

  1357. 	// Category content XML (multi series)

    1358. 

  1358. 	function WriteChartCatContent(&$node, $name) {

    1359. 

  1359. 		$cat = $this->XmlDoc->createElement('category');

    1360. 

  1360. 		$this->WriteAtt($cat, "name", $name);

    1361. 

  1361. 		$node->appendChild($cat);

    1362. 

  1362. 	}

    1363. 

  1363. 

    1364. 

  1364. 	// Chart content XML

    1365. 

  1365. 	function WriteChartContent(&$node, $name, $val, $color, $alpha, $lnk) {

    1366. 

  1366. 		$cht_shownames = $this->LoadParm("shownames");

    1367. 

  1367. 		$set = $this->XmlDoc->createElement('set');

    1368. 

  1368. 		$this->WriteAtt($set, "name", $name);

    1369. 

  1369. 		$this->WriteAtt($set, "value", $this->ChartFormatNumber($val));

    1370. 

  1370. 		$this->WriteAtt($set, "color", $this->ColorCode($color));

    1371. 

  1371. 		$this->WriteAtt($set, "alpha", $alpha);

    1372. 

  1372. 		$this->WriteAtt($set, "link", $lnk);

    1373. 

  1373. 		if ($cht_shownames == "1")

    1374. 

  1374. 			$this->WriteAtt($set, "showName", "1");

    1375. 

  1375. 		$node->appendChild($set);

    1376. 

  1376. 	}

    1377. 

  1377. }

    1378. 

  1378. 

    1379. 

  1379. //

    1380. 

  1380. // Column class

    1381. 

  1381. //

    1382. 

  1382. class crCrosstabColumn {

    1383. 

  1383. 	var $Caption;

    1384. 

  1384. 	var $Value;

    1385. 

  1385. 	var $Visible;

    1386. 

  1386. 

    1387. 

  1387. 	function crCrosstabColumn($value, $caption, $visible = TRUE) {

    1388. 

  1388. 		$this->Caption = $caption;

    1389. 

  1389. 		$this->Value = $value;

    1390. 

  1390. 		$this->Visible = $visible;

    1391. 

  1391.     }

    1392. 

  1392. }

    1393. 

  1393. 

    1394. 

  1394. //

    1395. 

  1395. // Advanced filter class

    1396. 

  1396. //

    1397. 

  1397. class crAdvancedFilter {

    1398. 

  1398. 	var $ID;

    1399. 

  1399. 	var $Name;

    1400. 

  1400. 	var $FunctionName;

    1401. 

  1401. 	var $Enabled = TRUE;

    1402. 

  1402. 

    1403. 

  1403. 	function crAdvancedFilter($filterid, $filtername, $filterfunc) {

    1404. 

  1404. 		$this->ID = $filterid;

    1405. 

  1405. 		$this->Name = $filtername;

    1406. 

  1406. 		$this->FunctionName = $filterfunc;

    1407. 

  1407. 	}

    1408. 

  1408. }

    1409. 

  1409. 

    1410. 

  1410. /**

    1411. 

  1411.  * List option collection class

    1412. 

  1412.  */

    1413. 

  1413. 

    1414. 

  1414. class crListOptions {

    1415. 

  1415. 	var $Items = array();

    1416. 

  1416. 	var $CustomItem = "";

    1417. 

  1417. 	var $Tag = "td";

    1418. 

  1418. 	var $Separator = "";

    1419. 

  1419. 

    1420. 

  1420. 	// Add and return a new option (return-by-reference is for PHP 5 only)

    1421. 

  1421. 	function &Add($Name) {

    1422. 

  1422. 		$item = new crListOption($Name, $this->Tag, $this->Separator);

    1423. 

  1423. 		$item->Parent =& $this;

    1424. 

  1424. 		$this->Items[$Name] = $item;

    1425. 

  1425. 		return $item;

    1426. 

  1426. 	}

    1427. 

  1427. 

    1428. 

  1428. 	// Load default settings

    1429. 

  1429. 	function LoadDefault() {

    1430. 

  1430. 		$this->CustomItem = "";

    1431. 

  1431. 		foreach ($this->Items as $key => $item)

    1432. 

  1432. 			$this->Items[$key]->Body = "";

    1433. 

  1433. 	}

    1434. 

  1434. 

    1435. 

  1435. 	// Hide all options

    1436. 

  1436. 	function HideAllOptions() {

    1437. 

  1437. 		foreach ($this->Items as $key => $item)

    1438. 

  1438. 			$this->Items[$key]->Visible = FALSE;

    1439. 

  1439. 	}

    1440. 

  1440. 

    1441. 

  1441. 	// Show all options

    1442. 

  1442. 	function ShowAllOptions() {

    1443. 

  1443. 		foreach ($this->Items as $key => $item)

    1444. 

  1444. 			$this->Items[$key]->Visible = TRUE;

    1445. 

  1445. 	}

    1446. 

  1446. 

    1447. 

  1447. 	// Get item by name (return-by-reference is for PHP 5 only)

    1448. 

  1448. 	// predefined names: view/edit/copy/delete/detail_<DetailTable>/userpermission/checkbox

    1449. 

  1449. 	function &GetItem($Name) {

    1450. 

  1450. 		$item = array_key_exists($Name, $this->Items) ? $this->Items[$Name] : NULL;

    1451. 

  1451. 		return $item;

    1452. 

  1452. 	}

    1453. 

  1453. 

    1454. 

  1454. 	// Move item to position

    1455. 

  1455. 	function MoveItem($Name, $Pos) {

    1456. 

  1456. 		$cnt = count($this->Items);

    1457. 

  1457. 		if ($Pos < 0 || $Pos >= $cnt)

    1458. 

  1458. 			return;

    1459. 

  1459. 		$item = $this->GetItem($Name);

    1460. 

  1460. 		if ($item) {

    1461. 

  1461. 			unset($this->Items[$Name]);

    1462. 

  1462. 			$this->Items = array_merge(array_slice($this->Items, 0, $Pos),

    1463. 

  1463. 				array($Name => $item), array_slice($this->Items, $Pos));

    1464. 

  1464. 		}

    1465. 

  1465. 	}

    1466. 

  1466. 

    1467. 

  1467. 	// Render list options

    1468. 

  1468. 	function Render($Part, $Pos="") {

    1469. 

  1469. 		if ($this->CustomItem <> "") {

    1470. 

  1470. 			$cnt = 0;

    1471. 

  1471. 			foreach ($this->Items as &$item) {

    1472. 

  1472. 				if ($item->Visible && $this->ShowPos($item->OnLeft, $Pos))

    1473. 

  1473. 					$cnt++;

    1474. 

  1474. 				if ($item->Name == $this->CustomItem)

    1475. 

  1475. 					$opt = $item;

    1476. 

  1476. 			}

    1477. 

  1477. 			if (is_object($opt) && $cnt > 0) {

    1478. 

  1478. 				if ($this->ShowPos($opt->OnLeft, $Pos)) {

    1479. 

  1479. 					echo $opt->Render($Part, $cnt);

    1480. 

  1480. 				} else {

    1481. 

  1481. 					echo $opt->Render("", $cnt);

    1482. 

  1482. 				}

    1483. 

  1483. 			}

    1484. 

  1484. 		} else {

    1485. 

  1485. 			foreach ($this->Items as &$item) {

    1486. 

  1486. 				if ($item->Visible && $this->ShowPos($item->OnLeft, $Pos))

    1487. 

  1487. 					echo $item->Render($Part);

    1488. 

  1488. 			}

    1489. 

  1489. 		}

    1490. 

  1490. 	}

    1491. 

  1491. 

    1492. 

  1492. 	function ShowPos($OnLeft, $Pos) {

    1493. 

  1493. 		return ($OnLeft && $Pos == "left") || (!$OnLeft && $Pos == "right") || ($Pos == "");

    1494. 

  1494. 	}

    1495. 

  1495. }

    1496. 

  1496. 

    1497. 

  1497. /**

    1498. 

  1498.  * List option class

    1499. 

  1499.  */

    1500. 

  1500. 

    1501. 

  1501. class crListOption {

    1502. 

  1502. 	var $Name;

    1503. 

  1503. 	var $OnLeft;

    1504. 

  1504. 	var $CssStyle;

    1505. 

  1505. 	var $Visible = TRUE;

    1506. 

  1506. 	var $Header;

    1507. 

  1507. 	var $Body;

    1508. 

  1508. 	var $Footer;

    1509. 

  1509. 	var $Tag = "td";

    1510. 

  1510. 	var $Separator = "";

    1511. 

  1511. 	var $Parent;

    1512. 

  1512. 

    1513. 

  1513. 	function crListOption($Name, $Tag, $Separator) {

    1514. 

  1514. 		$this->Name = $Name;

    1515. 

  1515. 		$this->Tag = $Tag;

    1516. 

  1516. 		$this->Separator = $Separator;

    1517. 

  1517. 	}

    1518. 

  1518. 

    1519. 

  1519. 	function MoveTo($Pos) {

    1520. 

  1520. 		$this->Parent->MoveItem($this->Name, $Pos);

    1521. 

  1521. 	}

    1522. 

  1522. 

    1523. 

  1523. 	function Render($Part, $ColSpan = 1) {

    1524. 

  1524. 		if ($Part == "header") {

    1525. 

  1525. 			$value = $this->Header;

    1526. 

  1526. 		} elseif ($Part == "body") {

    1527. 

  1527. 			$value = $this->Body;

    1528. 

  1528. 		} elseif ($Part == "footer") {

    1529. 

  1529. 			$value = $this->Footer;

    1530. 

  1530. 		} else {

    1531. 

  1531. 			$value = $Part;

    1532. 

  1532. 		}

    1533. 

  1533. 		if (strval($value) == "" && strtolower($this->Tag) <> "td")

    1534. 

  1534. 			return "";

    1535. 

  1535. 		$res = ($value <> "") ? $value : "&nbsp;";

    1536. 

  1536. 		$tage = "</" . $this->Tag . ">";

    1537. 

  1537. 		$tags = "<" . $this->Tag;

    1538. 

  1538. 		if ($this->CssStyle <> "")

    1539. 

  1539. 			$tags .= " style=\"" . $this->CssStyle . "\"";

    1540. 

  1540. 		if (strtolower($this->Tag) == "td" && $ColSpan > 1)

    1541. 

  1541. 			$tags .= " colspan=\"" . $ColSpan . "\"";

    1542. 

  1542. 		$tags .= " class=\"phpmaker\"";

    1543. 

  1543. 		$tags .= ">";

    1544. 

  1544. 		$res = $tags . $res . $tage . $this->Separator;

    1545. 

  1545. 		return $res;

    1546. 

  1546. 	}

    1547. 

  1547. }

    1548. 

  1548. 

    1549. 

  1549. /**

    1550. 

  1550.  * Advanced Security class

    1551. 

  1551.  */

    1552. 

  1552. 

    1553. 

  1553. class crAdvancedSecurity {

    1554. 

  1554. 	var $UserLevel = array(); // All User Levels

    1555. 

  1555. 	var $UserLevelPriv = array(); // All User Level permissions

    1556. 

  1556. 	var $UserLevelID = array(); // User Level ID array

    1557. 

  1557. 	var $UserID = array(); // User ID array

    1558. 

  1558. 	var $CurrentUserLevelID;

    1559. 

  1559. 	var $CurrentUserLevel; // Permissions

    1560. 

  1560. 	var $CurrentUserID;

    1561. 

  1561. 	var $CurrentParentUserID;

    1562. 

  1562. 

    1563. 

  1563. 	// Constructor

    1564. 

  1564. 	function crAdvancedSecurity() {

    1565. 

  1565. 

    1566. 

  1566. 		// Init User Level

    1567. 

  1567. 		$this->CurrentUserLevelID = $this->SessionUserLevelID();

    1568. 

  1568. 		if (is_numeric($this->CurrentUserLevelID) && intval($this->CurrentUserLevelID) >= -1) {

    1569. 

  1569. 			$this->UserLevelID[] = $this->CurrentUserLevelID;

    1570. 

  1570. 		}

    1571. 

  1571. 

    1572. 

  1572. 		// Init User ID

    1573. 

  1573. 		$this->CurrentUserID = $this->SessionUserID();

    1574. 

  1574. 		$this->CurrentParentUserID = $this->SessionParentUserID();

    1575. 

  1575. 

    1576. 

  1576. 		// Load user level

    1577. 

  1577. 		$this->LoadUserLevel();

    1578. 

  1578. 	}

    1579. 

  1579. 

    1580. 

  1580. 	// Session User ID

    1581. 

  1581. 	function SessionUserID() {

    1582. 

  1582. 		return strval(@$_SESSION[EWRPT_SESSION_USER_ID]);

    1583. 

  1583. 	}

    1584. 

  1584. 

    1585. 

  1585. 	function setSessionUserID($v) {

    1586. 

  1586. 		$_SESSION[EWRPT_SESSION_USER_ID] = trim(strval($v));

    1587. 

  1587. 		$this->CurrentUserID = trim(strval($v));

    1588. 

  1588. 	}

    1589. 

  1589. 

    1590. 

  1590. 	// Session Parent User ID

    1591. 

  1591. 	function SessionParentUserID() {

    1592. 

  1592. 		return strval(@$_SESSION[EWRPT_SESSION_PARENT_USER_ID]);

    1593. 

  1593. 	}

    1594. 

  1594. 

    1595. 

  1595. 	function setSessionParentUserID($v) {

    1596. 

  1596. 		$_SESSION[EWRPT_SESSION_PARENT_USER_ID] = trim(strval($v));

    1597. 

  1597. 		$this->CurrentParentUserID = trim(strval($v));

    1598. 

  1598. 	}

    1599. 

  1599. 

    1600. 

  1600. 	// Session User Level ID

    1601. 

  1601. 	function SessionUserLevelID() {

    1602. 

  1602. 		return @$_SESSION[EWRPT_SESSION_USER_LEVEL_ID];

    1603. 

  1603. 	}

    1604. 

  1604. 

    1605. 

  1605. 	function setSessionUserLevelID($v) {

    1606. 

  1606. 		$_SESSION[EWRPT_SESSION_USER_LEVEL_ID] = $v;

    1607. 

  1607. 		$this->CurrentUserLevelID = $v;

    1608. 

  1608. 		if (is_numeric($v) && $v >= -1)

    1609. 

  1609. 			$this->UserLevelID = array($v);

    1610. 

  1610. 	}

    1611. 

  1611. 

    1612. 

  1612. 	// Session User Level value

    1613. 

  1613. 	function SessionUserLevel() {

    1614. 

  1614. 		return @$_SESSION[EWRPT_SESSION_USER_LEVEL];

    1615. 

  1615. 	}

    1616. 

  1616. 

    1617. 

  1617. 	function setSessionUserLevel($v) {

    1618. 

  1618. 		$_SESSION[EWRPT_SESSION_USER_LEVEL] = $v;

    1619. 

  1619. 		$this->CurrentUserLevel = $v;

    1620. 

  1620. 	}

    1621. 

  1621. 

    1622. 

  1622. 	// Current user name

    1623. 

  1623. 	function getCurrentUserName() {

    1624. 

  1624. 		return strval(@$_SESSION[EWRPT_SESSION_USER_NAME]);

    1625. 

  1625. 	}

    1626. 

  1626. 

    1627. 

  1627. 	function setCurrentUserName($v) {

    1628. 

  1628. 		$_SESSION[EWRPT_SESSION_USER_NAME] = $v;

    1629. 

  1629. 	}

    1630. 

  1630. 

    1631. 

  1631. 	function CurrentUserName() {

    1632. 

  1632. 		return $this->getCurrentUserName();

    1633. 

  1633. 	}

    1634. 

  1634. 

    1635. 

  1635. 	// Current User ID

    1636. 

  1636. 	function CurrentUserID() {

    1637. 

  1637. 		return $this->CurrentUserID;

    1638. 

  1638. 	}

    1639. 

  1639. 

    1640. 

  1640. 	// Current Parent User ID

    1641. 

  1641. 	function CurrentParentUserID() {

    1642. 

  1642. 		return $this->CurrentParentUserID;

    1643. 

  1643. 	}

    1644. 

  1644. 

    1645. 

  1645. 	// Current User Level ID

    1646. 

  1646. 	function CurrentUserLevelID() {

    1647. 

  1647. 		return $this->CurrentUserLevelID;

    1648. 

  1648. 	}

    1649. 

  1649. 

    1650. 

  1650. 	// Current User Level value

    1651. 

  1651. 	function CurrentUserLevel() {

    1652. 

  1652. 		return $this->CurrentUserLevel;

    1653. 

  1653. 	}

    1654. 

  1654. 

    1655. 

  1655. 	// Can list

    1656. 

  1656. 	function CanList() {

    1657. 

  1657. 		return (($this->CurrentUserLevel & EWRPT_ALLOW_LIST) == EWRPT_ALLOW_LIST);

    1658. 

  1658. 	}

    1659. 

  1659. 

    1660. 

  1660. 	function setCanList($b) {

    1661. 

  1661. 		if ($b) {

    1662. 

  1662. 			$this->CurrentUserLevel = ($this->CurrentUserLevel | EWRPT_ALLOW_LIST);

    1663. 

  1663. 		} else {

    1664. 

  1664. 			$this->CurrentUserLevel = ($this->CurrentUserLevel & (~ EWRPT_ALLOW_LIST));

    1665. 

  1665. 		}

    1666. 

  1666. 	}

    1667. 

  1667. 

    1668. 

  1668. 	// Can report

    1669. 

  1669. 	function CanReport() {

    1670. 

  1670. 		return (($this->CurrentUserLevel & EWRPT_ALLOW_REPORT) == EWRPT_ALLOW_REPORT);

    1671. 

  1671. 	}

    1672. 

  1672. 

    1673. 

  1673. 	function setCanReport($b) {

    1674. 

  1674. 		if ($b) {

    1675. 

  1675. 			$this->CurrentUserLevel = ($this->CurrentUserLevel | EWRPT_ALLOW_REPORT);

    1676. 

  1676. 		} else {

    1677. 

  1677. 			$this->CurrentUserLevel = ($this->CurrentUserLevel & (~ EWRPT_ALLOW_REPORT));

    1678. 

  1678. 		}

    1679. 

  1679. 	}

    1680. 

  1680. 

    1681. 

  1681. 	// Can admin

    1682. 

  1682. 	function CanAdmin() {

    1683. 

  1683. 		return (($this->CurrentUserLevel & EWRPT_ALLOW_ADMIN) == EWRPT_ALLOW_ADMIN);

    1684. 

  1684. 	}

    1685. 

  1685. 

    1686. 

  1686. 	function setCanAdmin($b) {

    1687. 

  1687. 		if ($b) {

    1688. 

  1688. 			$this->CurrentUserLevel = ($this->CurrentUserLevel | EWRPT_ALLOW_ADMIN);

    1689. 

  1689. 		} else {

    1690. 

  1690. 			$this->CurrentUserLevel = ($this->CurrentUserLevel & (~ EWRPT_ALLOW_ADMIN));

    1691. 

  1691. 		}

    1692. 

  1692. 	}

    1693. 

  1693. 

    1694. 

  1694. 	// Last URL

    1695. 

  1695. 	function LastUrl() {

    1696. 

  1696. 		return @$_COOKIE[EWRPT_PROJECT_VAR]['LastUrl'];

    1697. 

  1697. 	}

    1698. 

  1698. 

    1699. 

  1699. 	// Save last URL

    1700. 

  1700. 	function SaveLastUrl() {

    1701. 

  1701. 		$s = ewrpt_ServerVar("SCRIPT_NAME");

    1702. 

  1702. 		$q = ewrpt_ServerVar("QUERY_STRING");

    1703. 

  1703. 		if ($q <> "") $s .= "?" . $q;

    1704. 

  1704. 		if ($this->LastUrl() == $s) $s = "";

    1705. 

  1705. 		@setcookie(EWRPT_PROJECT_VAR . '[LastUrl]', $s);

    1706. 

  1706. 	}

    1707. 

  1707. 

    1708. 

  1708. 	// Auto login

    1709. 

  1709. 	function AutoLogin() {

    1710. 

  1710. 		if (@$_COOKIE[EWRPT_PROJECT_VAR]['AutoLogin'] == "autologin") {

    1711. 

  1711. 			$usr = TEAdecrypt(@$_COOKIE[EWRPT_PROJECT_VAR]['Username'], EWRPT_RANDOM_KEY);

    1712. 

  1712. 			$pwd = TEAdecrypt(@$_COOKIE[EWRPT_PROJECT_VAR]['Password'], EWRPT_RANDOM_KEY);

    1713. 

  1713. 			$AutoLogin = $this->ValidateUser($usr, $pwd, TRUE);

    1714. 

  1714. 		} else {

    1715. 

  1715. 			$AutoLogin = FALSE;

    1716. 

  1716. 		}

    1717. 

  1717. 		return $AutoLogin;

    1718. 

  1718. 	}

    1719. 

  1719. 

    1720. 

  1720. 	// Validate user

    1721. 

  1721. 	function ValidateUser($usr, $pwd, $autologin) {

    1722. 

  1722. 		global $conn, $ReportLanguage;

    1723. 

  1723. 		$ValidateUser = FALSE;

    1724. 

  1724. 

    1725. 

  1725. 		// Call User Custom Validate event

    1726. 

  1726. 		if (EWRPT_USE_CUSTOM_LOGIN) {

    1727. 

  1727. 			$ValidateUser = $this->User_CustomValidate($usr, $pwd);

    1728. 

  1728. 			if ($ValidateUser) {

    1729. 

  1729. 				$_SESSION[EWRPT_SESSION_STATUS] = "login";

    1730. 

  1730. 			}

    1731. 

  1731. 		}

    1732. 

  1732. 		if (!$ValidateUser)

    1733. 

  1733. 			$_SESSION[EWRPT_SESSION_STATUS] = ""; // Clear login status

    1734. 

  1734. 		return $ValidateUser;

    1735. 

  1735. 	}

    1736. 

  1736. 

    1737. 

  1737. 	// No User Level security

    1738. 

  1738. 	function SetUpUserLevel() {}

    1739. 

  1739. 

    1740. 

  1740. 	// Add user permission

    1741. 

  1741. 	function AddUserPermission($UserLevelName, $TableName, $UserPermission) {

    1742. 

  1742. 

    1743. 

  1743. 		// Get User Level ID from user name

    1744. 

  1744. 		$UserLevelID = "";

    1745. 

  1745. 		if (is_array($this->UserLevel)) {

    1746. 

  1746. 			foreach ($this->UserLevel as $row) {

    1747. 

  1747. 				list($levelid, $name) = $row;

    1748. 

  1748. 				if (strval($UserLevelName) == strval($name)) {

    1749. 

  1749. 					$UserLevelID = $levelid;

    1750. 

  1750. 					break;

    1751. 

  1751. 				}

    1752. 

  1752. 			}

    1753. 

  1753. 		}

    1754. 

  1754. 		if (is_array($this->UserLevelPriv) && $UserLevelID <> "") {

    1755. 

  1755. 			$cnt = count($this->UserLevelPriv);

    1756. 

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

    1757. 

  1757. 				list($table, $levelid, $priv) = $this->UserLevelPriv[$i];

    1758. 

  1758. 				if (strtolower($table) == strtolower(EWRPT_TABLE_PREFIX . $TableName) && strval($levelid) == strval($UserLevelID)) {

    1759. 

  1759. 					$this->UserLevelPriv[$i][2] = $priv | $UserPermission; // Add permission

    1760. 

  1760. 					break;

    1761. 

  1761. 				}

    1762. 

  1762. 			}

    1763. 

  1763. 		}

    1764. 

  1764. 	}

    1765. 

  1765. 

    1766. 

  1766. 	// Delete user permission

    1767. 

  1767. 	function DeleteUserPermission($UserLevelName, $TableName, $UserPermission) {

    1768. 

  1768. 

    1769. 

  1769. 		// Get User Level ID from user name

    1770. 

  1770. 		$UserLevelID = "";

    1771. 

  1771. 		if (is_array($this->UserLevel)) {

    1772. 

  1772. 			foreach ($this->UserLevel as $row) {

    1773. 

  1773. 				list($levelid, $name) = $row;

    1774. 

  1774. 				if (strval($UserLevelName) == strval($name)) {

    1775. 

  1775. 					$UserLevelID = $levelid;

    1776. 

  1776. 					break;

    1777. 

  1777. 				}

    1778. 

  1778. 			}

    1779. 

  1779. 		}

    1780. 

  1780. 		if (is_array($this->UserLevelPriv) && $UserLevelID <> "") {

    1781. 

  1781. 			$cnt = count($this->UserLevelPriv);

    1782. 

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

    1783. 

  1783. 				list($table, $levelid, $priv) = $this->UserLevelPriv[$i];

    1784. 

  1784. 				if (strtolower($table) == strtolower(EWRPT_TABLE_PREFIX . $TableName) && strval($levelid) == strval($UserLevelID)) {

    1785. 

  1785. 					$this->UserLevelPriv[$i][2] = $priv & (127 - $UserPermission); // Remove permission

    1786. 

  1786. 					break;

    1787. 

  1787. 				}

    1788. 

  1788. 			}

    1789. 

  1789. 		}

    1790. 

  1790. 	}

    1791. 

  1791. 

    1792. 

  1792. 	// Load current User Level

    1793. 

  1793. 	function LoadCurrentUserLevel($Table) {

    1794. 

  1794. 		$this->LoadUserLevel();

    1795. 

  1795. 		$this->setSessionUserLevel($this->CurrentUserLevelPriv($Table));

    1796. 

  1796. 	}

    1797. 

  1797. 

    1798. 

  1798. 	// Get current user privilege

    1799. 

  1799. 	function CurrentUserLevelPriv($TableName) {

    1800. 

  1800. 		if ($this->IsLoggedIn()) {

    1801. 

  1801. 			$Priv= 0;

    1802. 

  1802. 			foreach ($this->UserLevelID as $UserLevelID)

    1803. 

  1803. 				$Priv |= $this->GetUserLevelPrivEx($TableName, $UserLevelID);

    1804. 

  1804. 			return $Priv;

    1805. 

  1805. 		} else {

    1806. 

  1806. 			return 0;

    1807. 

  1807. 		}

    1808. 

  1808. 	}

    1809. 

  1809. 

    1810. 

  1810. 	// Get User Level ID by User Level name

    1811. 

  1811. 	function GetUserLevelID($UserLevelName) {

    1812. 

  1812. 		if (strval($UserLevelName) == "Administrator") {

    1813. 

  1813. 			return -1;

    1814. 

  1814. 		} elseif ($UserLevelName <> "") {

    1815. 

  1815. 			if (is_array($this->UserLevel)) {

    1816. 

  1816. 				foreach ($this->UserLevel as $row) {

    1817. 

  1817. 					list($levelid, $name) = $row;

    1818. 

  1818. 					if (strval($name) == strval($UserLevelName))

    1819. 

  1819. 						return $levelid;

    1820. 

  1820. 				}

    1821. 

  1821. 			}

    1822. 

  1822. 		}

    1823. 

  1823. 		return -2;

    1824. 

  1824. 	}

    1825. 

  1825. 

    1826. 

  1826. 	// Add User Level (for use with UserLevel_Loading event)

    1827. 

  1827. 	function AddUserLevel($UserLevelName) {

    1828. 

  1828. 		if (strval($UserLevelName) == "") return;

    1829. 

  1829. 		$UserLevelID = $this->GetUserLevelID($UserLevelName);

    1830. 

  1830. 		if (!is_numeric($UserLevelID)) return;

    1831. 

  1831. 		if ($UserLevelID < -1) return;

    1832. 

  1832. 		if (!in_array($UserLevelID, $this->UserLevelID))

    1833. 

  1833. 			$this->UserLevelID[] = $UserLevelID;

    1834. 

  1834. 	}

    1835. 

  1835. 

    1836. 

  1836. 	// Delete User Level (for use with UserLevel_Loading event)

    1837. 

  1837. 	function DeleteUserLevel($UserLevelName) {

    1838. 

  1838. 		if (strval($UserLevelName) == "") return;

    1839. 

  1839. 		$UserLevelID = $this->GetUserLevelID($UserLevelName);

    1840. 

  1840. 		if (!is_numeric($UserLevelID)) return;

    1841. 

  1841. 		if ($UserLevelID < -1) return;

    1842. 

  1842. 		$cnt = count($this->UserLevelID);

    1843. 

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

    1844. 

  1844. 			if ($this->UserLevelID[$i] == $UserLevelID) {

    1845. 

  1845. 				unset($this->UserLevelID[$i]);

    1846. 

  1846. 				break;

    1847. 

  1847. 			}

    1848. 

  1848. 		}

    1849. 

  1849. 	}

    1850. 

  1850. 

    1851. 

  1851. 	// User Level list

    1852. 

  1852. 	function UserLevelList() {

    1853. 

  1853. 		return implode(", ", $this->UserLevelID);

    1854. 

  1854. 	}

    1855. 

  1855. 

    1856. 

  1856. 	// User Level name list

    1857. 

  1857. 	function UserLevelNameList() {

    1858. 

  1858. 		$list = "";

    1859. 

  1859. 		foreach ($this->UserLevelID as $UserLevelID) {

    1860. 

  1860. 			if ($list <> "") $lList .= ", ";

    1861. 

  1861. 			$list .= ewrpt_QuotedValue($this->GetUserLevelName($UserLevelID), EWRPT_DATATYPE_STRING);

    1862. 

  1862. 		}

    1863. 

  1863. 		return $list;

    1864. 

  1864. 	}

    1865. 

  1865. 

    1866. 

  1866. 	// Get user privilege based on table name and User Level

    1867. 

  1867. 	function GetUserLevelPrivEx($TableName, $UserLevelID) {

    1868. 

  1868. 		if (strval($UserLevelID) == "-1") { // System Administrator

    1869. 

  1869. 			return 31; // Use old User Level values

    1870. 

  1870. 		} elseif ($UserLevelID >= 0) {

    1871. 

  1871. 			if (is_array($this->UserLevelPriv)) {

    1872. 

  1872. 				foreach ($this->UserLevelPriv as $row) {

    1873. 

  1873. 					list($table, $levelid, $priv) = $row;

    1874. 

  1874. 					if (strtolower($table) == strtolower(EWRPT_TABLE_PREFIX . $TableName) && strval($levelid) == strval($UserLevelID)) {

    1875. 

  1875. 						if (is_null($priv) || !is_numeric($priv)) return 0;

    1876. 

  1876. 						return intval($priv);

    1877. 

  1877. 					}

    1878. 

  1878. 				}

    1879. 

  1879. 			}

    1880. 

  1880. 		}

    1881. 

  1881. 		return 0;

    1882. 

  1882. 	}

    1883. 

  1883. 

    1884. 

  1884. 	// Get current User Level name

    1885. 

  1885. 	function CurrentUserLevelName() {

    1886. 

  1886. 		return $this->GetUserLevelName($this->CurrentUserLevelID());

    1887. 

  1887. 	}

    1888. 

  1888. 

    1889. 

  1889. 	// Get User Level name based on User Level

    1890. 

  1890. 	function GetUserLevelName($UserLevelID) {

    1891. 

  1891. 		if (strval($UserLevelID) == "-1") {

    1892. 

  1892. 			return "Administrator";

    1893. 

  1893. 		} elseif ($UserLevelID >= 0) {

    1894. 

  1894. 			if (is_array($this->UserLevel)) {

    1895. 

  1895. 				foreach ($this->UserLevel as $row) {

    1896. 

  1896. 					list($levelid, $name) = $row;

    1897. 

  1897. 					if (strval($levelid) == strval($UserLevelID))

    1898. 

  1898. 						return $name;

    1899. 

  1899. 				}

    1900. 

  1900. 			}

    1901. 

  1901. 		}

    1902. 

  1902. 		return "";

    1903. 

  1903. 	}

    1904. 

  1904. 

    1905. 

  1905. 	// Display all the User Level settings (for debug only)

    1906. 

  1906. 	function ShowUserLevelInfo() {

    1907. 

  1907. 		echo "<pre class=\"phpmaker\">";

    1908. 

  1908. 		print_r($this->UserLevel);

    1909. 

  1909. 		print_r($this->UserLevelPriv);

    1910. 

  1910. 		echo "</pre>";

    1911. 

  1911. 		echo "<p>Current User Level ID = " . $this->CurrentUserLevelID() . "</p>";

    1912. 

  1912. 		echo "<p>Current User Level ID List = " . $this->UserLevelList() . "</p>";

    1913. 

  1913. 	}

    1914. 

  1914. 

    1915. 

  1915. 	// Check privilege for List page (for menu items)

    1916. 

  1916. 	function AllowList($TableName) {

    1917. 

  1917. 		return ($this->CurrentUserLevelPriv($TableName) & EWRPT_ALLOW_LIST);

    1918. 

  1918. 	}

    1919. 

  1919. 

    1920. 

  1920. 	// Check if user is logged in

    1921. 

  1921. 	function IsLoggedIn() {

    1922. 

  1922. 		return (@$_SESSION[EWRPT_SESSION_STATUS] == "login");

    1923. 

  1923. 	}

    1924. 

  1924. 

    1925. 

  1925. 	// Check if user is system administrator

    1926. 

  1926. 	function IsSysAdmin() {

    1927. 

  1927. 		return (@$_SESSION[EWRPT_SESSION_SYSTEM_ADMIN] == 1);

    1928. 

  1928. 	}

    1929. 

  1929. 

    1930. 

  1930. 	// Check if user is administrator

    1931. 

  1931. 	function IsAdmin() {

    1932. 

  1932. 		$IsAdmin = $this->IsSysAdmin();

    1933. 

  1933. 		return $IsAdmin;

    1934. 

  1934.   }

    1935. 

  1935. 

    1936. 

  1936. 	// Save User Level to Session

    1937. 

  1937. 	function SaveUserLevel() {

    1938. 

  1938. 		$_SESSION[EWRPT_SESSION_AR_USER_LEVEL] = $this->UserLevel;

    1939. 

  1939. 		$_SESSION[EWRPT_SESSION_AR_USER_LEVEL_PRIV] = $this->UserLevelPriv;

    1940. 

  1940. 	}

    1941. 

  1941. 

    1942. 

  1942. 	// Load User Level from Session

    1943. 

  1943. 	function LoadUserLevel() {

    1944. 

  1944. 		if (!is_array(@$_SESSION[EWRPT_SESSION_AR_USER_LEVEL]) || !is_array(@$_SESSION[EWRPT_SESSION_AR_USER_LEVEL_PRIV])) {

    1945. 

  1945. 			$this->SetupUserLevel();

    1946. 

  1946. 			$this->SaveUserLevel();

    1947. 

  1947. 		} else {

    1948. 

  1948. 			$this->UserLevel = $_SESSION[EWRPT_SESSION_AR_USER_LEVEL];

    1949. 

  1949. 			$this->UserLevelPriv = $_SESSION[EWRPT_SESSION_AR_USER_LEVEL_PRIV];

    1950. 

  1950. 		}

    1951. 

  1951. 	}

    1952. 

  1952. 

    1953. 

  1953. 	// Get current user info

    1954. 

  1954. 	function CurrentUserInfo($fieldname) {

    1955. 

  1955. 		$info = NULL;

    1956. 

  1956. 		return $info;

    1957. 

  1957. 	}

    1958. 

  1958. 

    1959. 

  1959. 	// UserID Loading event

    1960. 

  1960. 	function UserID_Loading() {

    1961. 

  1961. 

    1962. 

  1962. 		//echo "UserID Loading: " . $this->CurrentUserID() . "<br>";

    1963. 

  1963. 	}

    1964. 

  1964. 

    1965. 

  1965. 	// UserID Loaded event

    1966. 

  1966. 	function UserID_Loaded() {

    1967. 

  1967. 

    1968. 

  1968. 		//echo "UserID Loaded: " . $this->UserIDList() . "<br>";

    1969. 

  1969. 	}

    1970. 

  1970. 

    1971. 

  1971. 	// User Level Loaded event

    1972. 

  1972. 	function UserLevel_Loaded() {

    1973. 

  1973. 

    1974. 

  1974. 		//$this->AddUserPermission(<UserLevelName>, <TableName>, <UserPermission>);

    1975. 

  1975. 		//$this->DeleteUserPermission(<UserLevelName>, <TableName>, <UserPermission>);

    1976. 

  1976. 

    1977. 

  1977. 	}

    1978. 

  1978. 

    1979. 

  1979. 	// User Custom Validate event

    1980. 

  1980. 	function User_CustomValidate(&$usr, &$pwd) {

    1981. 

  1981. 

    1982. 

  1982. 		// Return FALSE to continue with default validation after event exits, or return TRUE to skip default validation

    1983. 

  1983. 		return FALSE;

    1984. 

  1984. 	}

    1985. 

  1985. 

    1986. 

  1986. 	// User Validated event

    1987. 

  1987. 	function User_Validated(&$rs) {

    1988. 

  1988. 

    1989. 

  1989. 		// Example:

    1990. 

  1990. 		//$_SESSION['UserEmail'] = $rs['Email'];

    1991. 

  1991. 

    1992. 

  1992. 	}

    1993. 

  1993. }

    1994. 

  1994. 

    1995. 

  1995. /**

    1996. 

  1996.  * Functions for backward compatibilty

    1997. 

  1997.  */

    1998. 

  1998. 

    1999. 

  1999. // Get current user name

    2000. 

  2000. function CurrentUserName() {

    2001. 

  2001. 	global $Security;

    2002. 

  2002. 	return (isset($Security)) ? $Security->CurrentUserName() : strval(@$_SESSION[EWRPT_SESSION_USER_NAME]);

    2003. 

  2003. }

    2004. 

  2004. 

    2005. 

  2005. // Get current user ID

    2006. 

  2006. function CurrentUserID() {

    2007. 

  2007. 	global $Security;

    2008. 

  2008. 	return (isset($Security)) ? $Security->CurrentUserID() : strval(@$_SESSION[EWRPT_SESSION_USER_ID]);

    2009. 

  2009. }

    2010. 

  2010. 

    2011. 

  2011. // Get current parent user ID

    2012. 

  2012. function CurrentParentUserID() {

    2013. 

  2013. 	global $Security;

    2014. 

  2014. 	return (isset($Security)) ? $Security->CurrentParentUserID() : strval(@$_SESSION[EWRPT_SESSION_PARENT_USER_ID]);

    2015. 

  2015. }

    2016. 

  2016. 

    2017. 

  2017. // Get current user level

    2018. 

  2018. function CurrentUserLevel() {

    2019. 

  2019. 	global $Security;

    2020. 

  2020. 	return (isset($Security)) ? $Security->CurrentUserLevelID() : @$_SESSION[EWRPT_SESSION_USER_LEVEL_ID];

    2021. 

  2021. }

    2022. 

  2022. 

    2023. 

  2023. // Get current user level list

    2024. 

  2024. function CurrentUserLevelList() {

    2025. 

  2025. 	global $Security;

    2026. 

  2026. 	return (isset($Security)) ? $Security->UserLevelList() : strval(@$_SESSION[EWRPT_SESSION_USER_LEVEL_ID]);

    2027. 

  2027. }

    2028. 

  2028. 

    2029. 

  2029. // Get Current user info

    2030. 

  2030. function CurrentUserInfo($fldname) {

    2031. 

  2031. 	global $Security;

    2032. 

  2032. 	if (isset($Security)) {

    2033. 

  2033. 		return $Security->CurrentUserInfo($fldname);

    2034. 

  2034. 	} elseif (defined("EWRPT_USER_TABLE") && !IsSysAdmin()) {

    2035. 

  2035. 		$user = CurrentUserName();

    2036. 

  2036. 		if (strval($user) <> "")

    2037. 

  2037. 			return ew_ExecuteScalar("SELECT " . ew_QuotedName($fldname) . " FROM " . EW_USER_TABLE . " WHERE " .

    2038. 

  2038. 				str_replace("%u", ew_AdjustSql($user), EWRPT_USER_NAME_FILTER));

    2039. 

  2039. 	}

    2040. 

  2040. 	return NULL;

    2041. 

  2041. }

    2042. 

  2042. 

    2043. 

  2043. // Is logged in

    2044. 

  2044. function IsLoggedIn() {

    2045. 

  2045. 	global $Security;

    2046. 

  2046. 	return (isset($Security)) ? $Security->IsLoggedIn() : (@$_SESSION[EWRPT_SESSION_STATUS] == "login");

    2047. 

  2047. }

    2048. 

  2048. 

    2049. 

  2049. // Check if user is system administrator

    2050. 

  2050. function IsSysAdmin() {

    2051. 

  2051. 	return (@$_SESSION[EWRPT_SESSION_SYSTEM_ADMIN] == 1);

    2052. 

  2052. }

    2053. 

  2053. 

    2054. 

  2054. // Get current page ID

    2055. 

  2055. function CurrentPageID() {

    2056. 

  2056. 	if (isset($GLOBALS["Page"])) {

    2057. 

  2057. 		return $GLOBALS["Page"]->PageID;

    2058. 

  2058. 	} elseif (defined("EWRPT_PAGE_ID")) {

    2059. 

  2059. 		return EWRPT_PAGE_ID;

    2060. 

  2060. 	}

    2061. 

  2061. 	return "";

    2062. 

  2062. }

    2063. 

  2063. 

    2064. 

  2064. // Allow list

    2065. 

  2065. function AllowList($TableName) {

    2066. 

  2066. 	global $Security;

    2067. 

  2067. 	return $Security->AllowList($TableName);

    2068. 

  2068. }

    2069. 

  2069. 

    2070. 

  2070. // Load recordset

    2071. 

  2071. function &ew_LoadRecordset($SQL) {

    2072. 

  2072. 	global $conn;

    2073. 

  2073. 	$conn->raiseErrorFn = 'ewrpt_ErrorFn'; //*** changed to "ewrpt_"

    2074. 

  2074. 	$rs = $conn->Execute($SQL);

    2075. 

  2075. 	$conn->raiseErrorFn = '';

    2076. 

  2076. 	return $rs;

    2077. 

  2077. }

    2078. 

  2078. 

    2079. 

  2079. // Executes the query, and returns the first column of the first row

    2080. 

  2080. function ew_ExecuteScalar($SQL) {

    2081. 

  2081. 	$res = FALSE;

    2082. 

  2082. 	$rs = ew_LoadRecordset($SQL);

    2083. 

  2083. 	if ($rs && !$rs->EOF && $rs->FieldCount() > 0) {

    2084. 

  2084. 		$res = $rs->fields[0];

    2085. 

  2085. 		$rs->Close();

    2086. 

  2086. 	}

    2087. 

  2087. 	return $res;

    2088. 

  2088. }

    2089. 

  2089. 

    2090. 

  2090. // Executes the query, and returns the first row

    2091. 

  2091. function ew_ExecuteRow($SQL) {

    2092. 

  2092. 	$res = FALSE;

    2093. 

  2093. 	$rs = ew_LoadRecordset($SQL);

    2094. 

  2094. 	if ($rs && !$rs->EOF) {

    2095. 

  2095. 		$res = $rs->fields;

    2096. 

  2096. 		$rs->Close();

    2097. 

  2097. 	}

    2098. 

  2098. 	return $res;

    2099. 

  2099. }

    2100. 

  2100. 

    2101. 

  2101. // Check if valid operator

    2102. 

  2102. function ewrpt_IsValidOpr($Opr, $FldType) {

    2103. 

  2103. 	$valid = ($Opr == "=" || $Opr == "<" || $Opr == "<=" ||

    2104. 

  2104. 		$Opr == ">" || $Opr == ">=" || $Opr == "<>");

    2105. 

  2105. 	if ($FldType == EWRPT_DATATYPE_STRING || $FldType == EWRPT_DATATYPE_MEMO)

    2106. 

  2106. 		$valid = ($valid || $Opr == "LIKE" || $Opr == "NOT LIKE" || $Opr == "STARTS WITH");

    2107. 

  2107. 	return $valid;

    2108. 

  2108. }

    2109. 

  2109. 

    2110. 

  2110. // Quote table/field name

    2111. 

  2111. function ewrpt_QuotedName($Name) {

    2112. 

  2112. 	$Name = str_replace(EWRPT_DB_QUOTE_END, EWRPT_DB_QUOTE_END . EWRPT_DB_QUOTE_END, $Name);

    2113. 

  2113. 	return EWRPT_DB_QUOTE_START . $Name . EWRPT_DB_QUOTE_END;

    2114. 

  2114. }

    2115. 

  2115. 

    2116. 

  2116. // quote field values

    2117. 

  2117. function ewrpt_QuotedValue($Value, $FldType) {

    2118. 

  2118. 	if (is_null($Value))

    2119. 

  2119. 		return "NULL";

    2120. 

  2120. 	switch ($FldType) {

    2121. 

  2121. 	case EWRPT_DATATYPE_STRING:

    2122. 

  2122. 	case EWRPT_DATATYPE_BLOB:

    2123. 

  2123. 	case EWRPT_DATATYPE_MEMO:

    2124. 

  2124. 	case EWRPT_DATATYPE_TIME:

    2125. 

  2125. 			return "'" . ewrpt_AdjustSql($Value) . "'";

    2126. 

  2126. 	case EWRPT_DATATYPE_DATE:

    2127. 

  2127. 		return (EWRPT_IS_MSACCESS) ? "#" . ewrpt_AdjustSql($Value) . "#" :

    2128. 

  2128. 			"'" . ewrpt_AdjustSql($Value) . "'";

    2129. 

  2129. 

    2130. 

  2130. //	case EWRPT_DATATYPE_GUID:

    2131. 

  2131. //		if (EWRPT_IS_MSACCESS) {

    2132. 

  2132. //			if (strlen($Value) == 38) {

    2133. 

  2133. //				return "{guid " . $Value . "}";

    2134. 

  2134. //			} elseif (strlen($Value) == 36) {

    2135. 

  2135. //				return "{guid {" . $Value . "}}";

    2136. 

  2136. //			}

    2137. 

  2137. //		} else {

    2138. 

  2138. //		  return "'" . $Value . "'";

    2139. 

  2139. //		}

    2140. 

  2140. 

    2141. 

  2141. 	case EWRPT_DATATYPE_BOOLEAN: // enum('Y'/'N') or enum('1'/'0')

    2142. 

  2142. 

    2143. 

  2143. 		//return "'" . $Value . "'";

    2144. 

  2144. 		return (EWRPT_IS_MSACCESS) ? $Value : "'" . ewrpt_AdjustSql($Value) . "'";

    2145. 

  2145. 	default:

    2146. 

  2146. 		return $Value;

    2147. 

  2147. 	}

    2148. 

  2148. }

    2149. 

  2149. 

    2150. 

  2150. // Get distinct values

    2151. 

  2151. function ewrpt_GetDistinctValues($FldOpr, $sql) {

    2152. 

  2152. 	global $conn;

    2153. 

  2153. 	$ar = array();

    2154. 

  2154. 	if (strval($sql) == "")

    2155. 

  2155. 		return;

    2156. 

  2156. 	$wrkrs = $conn->Execute($sql);

    2157. 

  2157. 	if ($wrkrs && !$wrkrs->EOF) {

    2158. 

  2158. 		$ar[] = ewrpt_ConvertValue($FldOpr, $wrkrs->fields[0]);

    2159. 

  2159. 		$wrkrs->MoveNext();

    2160. 

  2160. 		while (!$wrkrs->EOF) {

    2161. 

  2161. 			$wrkval = ewrpt_ConvertValue($FldOpr, $wrkrs->fields[0]);

    2162. 

  2162. 			$cntar = count($ar);

    2163. 

  2163. 			if ($wrkval <> $ar[$cntar-1])

    2164. 

  2164. 				$ar[] = $wrkval;

    2165. 

  2165. 			$wrkrs->MoveNext();

    2166. 

  2166. 		}

    2167. 

  2167. 	}

    2168. 

  2168. 	if ($wrkrs) $wrkrs->Close();

    2169. 

  2169. 	return $ar;

    2170. 

  2170. }

    2171. 

  2171. 

    2172. 

  2172. // Convert value

    2173. 

  2173. function ewrpt_ConvertValue($FldOpr, $val) {

    2174. 

  2174. 	if (is_null($val)) {

    2175. 

  2175. 		return EWRPT_NULL_VALUE;

    2176. 

  2176. 	} elseif ($val == "") {

    2177. 

  2177. 		return EWRPT_EMPTY_VALUE;

    2178. 

  2178. 	}

    2179. 

  2179. 	if (is_float($val))

    2180. 

  2180. 		$val = (float)$val;

    2181. 

  2181. 	if ($FldOpr == "")

    2182. 

  2182. 		return $val;

    2183. 

  2183. 	if ($ar = explode(" ", $val)) {

    2184. 

  2184. 		$ar = explode("-", $ar[0]);

    2185. 

  2185. 	} else {

    2186. 

  2186. 		return $val;

    2187. 

  2187. 	}

    2188. 

  2188. 	if (!$ar || count($ar) <> 3)

    2189. 

  2189. 		return $val;

    2190. 

  2190. 	list($year, $month, $day) = $ar;

    2191. 

  2191. 	switch (strtolower($FldOpr)) {

    2192. 

  2192. 	case "year":

    2193. 

  2193. 		return $year;

    2194. 

  2194. 	case "quarter":

    2195. 

  2195. 		return "$year|" . ceil(intval($month)/3);

    2196. 

  2196. 	case "month":

    2197. 

  2197. 		return "$year|$month";

    2198. 

  2198. 	case "day":

    2199. 

  2199. 		return "$year|$month|$day";

    2200. 

  2200. 	case "date":

    2201. 

  2201. 		return "$year-$month-$day";

    2202. 

  2202. 	}

    2203. 

  2203. }

    2204. 

  2204. 

    2205. 

  2205. // Dropdown display values

    2206. 

  2206. function ewrpt_DropDownDisplayValue($v, $t, $fmt) {

    2207. 

  2207. 	global $ReportLanguage;

    2208. 

  2208. 	if ($v == EWRPT_NULL_VALUE) {

    2209. 

  2209. 		return $ReportLanguage->Phrase("NullLabel");

    2210. 

  2210. 	} elseif ($v == EWRPT_EMPTY_VALUE) {

    2211. 

  2211. 		return $ReportLanguage->Phrase("EmptyLabel");

    2212. 

  2212. 	} elseif (strtolower($t) == "boolean") {

    2213. 

  2213. 		return ewrpt_BooleanName($v);

    2214. 

  2214. 	}

    2215. 

  2215. 	if ($t == "")

    2216. 

  2216. 		return $v;

    2217. 

  2217. 	$ar = explode("|", strval($v));

    2218. 

  2218. 	switch (strtolower($t)) {

    2219. 

  2219. 	case "year":

    2220. 

  2220. 		return $v;

    2221. 

  2221. 	case "quarter":

    2222. 

  2222. 		if (count($ar) >= 2)

    2223. 

  2223. 			return ewrpt_QuarterName($ar[1]) . " " . $ar[0];

    2224. 

  2224. 	case "month":

    2225. 

  2225. 		if (count($ar) >= 2)

    2226. 

  2226. 			return ewrpt_MonthName($ar[1]) . " " . $ar[0];

    2227. 

  2227. 	case "day":

    2228. 

  2228. 		if (count($ar) >= 3)

    2229. 

  2229. 			return ewrpt_FormatDateTime($ar[0] . "-" . $ar[1] . "-" . $ar[2], $fmt);

    2230. 

  2230. 	case "date":

    2231. 

  2231. 		return ewrpt_FormatDateTime($v, $fmt);

    2232. 

  2232. 	}

    2233. 

  2233. }

    2234. 

  2234. 

    2235. 

  2235. // Get Boolean Name

    2236. 

  2236. // - Treat "T" / "True" / "Y" / "Yes" / "1" As True

    2237. 

  2237. function ewrpt_BooleanName($v) {

    2238. 

  2238. 	global $ReportLanguage;

    2239. 

  2239. 	if (is_null($v))

    2240. 

  2240. 		return $ReportLanguage->Phrase("NullLabel");

    2241. 

  2241. 	elseif (strtoupper($v) == "T" || strtoupper($v) == "TRUE" || strtoupper($v) == "Y" || strtoupper($v) == "YES" Or strval($v) == "1")

    2242. 

  2242. 		return $ReportLanguage->Phrase("BooleanYes");

    2243. 

  2243. 	else

    2244. 

  2244. 		return $ReportLanguage->Phrase("BooleanNo");

    2245. 

  2245. }

    2246. 

  2246. 

    2247. 

  2247. // Quarter name

    2248. 

  2248. function ewrpt_QuarterName($q) {

    2249. 

  2249. 	global $ReportLanguage;

    2250. 

  2250. 	switch ($q) {

    2251. 

  2251. 	case 1:

    2252. 

  2252. 		return $ReportLanguage->Phrase("Qtr1");

    2253. 

  2253. 	case 2:

    2254. 

  2254. 		return $ReportLanguage->Phrase("Qtr2");

    2255. 

  2255. 	case 3:

    2256. 

  2256. 		return $ReportLanguage->Phrase("Qtr3");

    2257. 

  2257. 	case 4:

    2258. 

  2258. 		return $ReportLanguage->Phrase("Qtr4");

    2259. 

  2259. 	default:

    2260. 

  2260. 		return $q;

    2261. 

  2261. 	}

    2262. 

  2262. }

    2263. 

  2263. 

    2264. 

  2264. // Month name

    2265. 

  2265. function ewrpt_MonthName($m) {

    2266. 

  2266. 	global $ReportLanguage;

    2267. 

  2267. 	switch ($m) {

    2268. 

  2268. 	case 1:

    2269. 

  2269. 		return $ReportLanguage->Phrase("MonthJan");

    2270. 

  2270. 	case 2:

    2271. 

  2271. 		return $ReportLanguage->Phrase("MonthFeb");

    2272. 

  2272. 	case 3:

    2273. 

  2273. 		return $ReportLanguage->Phrase("MonthMar");

    2274. 

  2274. 	case 4:

    2275. 

  2275. 		return $ReportLanguage->Phrase("MonthApr");

    2276. 

  2276. 	case 5:

    2277. 

  2277. 		return $ReportLanguage->Phrase("MonthMay");

    2278. 

  2278. 	case 6:

    2279. 

  2279. 		return $ReportLanguage->Phrase("MonthJun");

    2280. 

  2280. 	case 7:

    2281. 

  2281. 		return $ReportLanguage->Phrase("MonthJul");

    2282. 

  2282. 	case 8:

    2283. 

  2283. 		return $ReportLanguage->Phrase("MonthAug");

    2284. 

  2284. 	case 9:

    2285. 

  2285. 		return $ReportLanguage->Phrase("MonthSep");

    2286. 

  2286. 	case 10:

    2287. 

  2287. 		return $ReportLanguage->Phrase("MonthOct");

    2288. 

  2288. 	case 11:

    2289. 

  2289. 		return $ReportLanguage->Phrase("MonthNov");

    2290. 

  2290. 	case 12:

    2291. 

  2291. 		return $ReportLanguage->Phrase("MonthDec");

    2292. 

  2292. 	default:

    2293. 

  2293. 		return $m;

    2294. 

  2294. 	}

    2295. 

  2295. }

    2296. 

  2296. 

    2297. 

  2297. // Join array

    2298. 

  2298. function ewrpt_JoinArray($ar, $sep, $ft, $pos=0) {

    2299. 

  2299. 	if (!is_array($ar))

    2300. 

  2300. 		return "";

    2301. 

  2301. 	$arwrk = array_slice($ar, $pos); // return array from position pos

    2302. 

  2302. 	$cntar = count($arwrk);

    2303. 

  2303. 	for ($i = 0; $i < $cntar; $i++)

    2304. 

  2304. 		$arwrk[$i] = ewrpt_QuotedValue($arwrk[$i], $ft);

    2305. 

  2305. 	return implode($sep, $arwrk);

    2306. 

  2306. }

    2307. 

  2307. 

    2308. 

  2308. // Unformat date time based on format type

    2309. 

  2309. function ewrpt_UnFormatDateTime($dt, $namedformat) {

    2310. 

  2310. 	$dt = trim($dt);

    2311. 

  2311. 	while (strpos($dt, "  ") !== FALSE) $dt = str_replace("  ", " ", $dt);

    2312. 

  2312. 	$arDateTime = explode(" ", $dt);

    2313. 

  2313. 	if (count($arDateTime) == 0) return $dt;

    2314. 

  2314. 	$arDatePt = explode(EWRPT_DATE_SEPARATOR, $arDateTime[0]);

    2315. 

  2315. 	if ($namedformat == 0 || $namedformat == 1 || $namedformat == 2 || $namedformat == 8) {

    2316. 

  2316. 		$arDefFmt = explode(EWRPT_DATE_SEPARATOR, EWRPT_DEFAULT_DATE_FORMAT);

    2317. 

  2317. 		if ($arDefFmt[0] == "yyyy") {

    2318. 

  2318. 			$namedformat = 9;

    2319. 

  2319. 		} elseif ($arDefFmt[0] == "mm") {

    2320. 

  2320. 			$namedformat = 10;

    2321. 

  2321. 		} elseif ($arDefFmt[0] == "dd") {

    2322. 

  2322. 			$namedformat = 11;

    2323. 

  2323. 		}

    2324. 

  2324. 	}

    2325. 

  2325. 	if (count($arDatePt) == 3) {

    2326. 

  2326. 		switch ($namedformat) {

    2327. 

  2327. 		case 5:

    2328. 

  2328. 		case 9: //yyyymmdd

    2329. 

  2329. 			if (ewrpt_CheckDate($arDateTime[0])) {

    2330. 

  2330. 				list($year, $month, $day) = $arDatePt;

    2331. 

  2331. 				break;

    2332. 

  2332. 			} else {

    2333. 

  2333. 				return $dt;

    2334. 

  2334. 			}

    2335. 

  2335. 		case 6:

    2336. 

  2336. 		case 10: //mmddyyyy

    2337. 

  2337. 			if (ewrpt_CheckUSDate($arDateTime[0])) {

    2338. 

  2338. 				list($month, $day, $year) = $arDatePt;

    2339. 

  2339. 				break;

    2340. 

  2340. 			} else {

    2341. 

  2341. 				return $dt;

    2342. 

  2342. 			}

    2343. 

  2343. 		case 7:

    2344. 

  2344. 		case 11: //ddmmyyyy

    2345. 

  2345. 			if (ewrpt_CheckEuroDate($arDateTime[0])) {

    2346. 

  2346. 				list($day, $month, $year) = $arDatePt;

    2347. 

  2347. 				break;

    2348. 

  2348. 			} else {

    2349. 

  2349. 				return $dt;

    2350. 

  2350. 			}

    2351. 

  2351. 		case 12:

    2352. 

  2352. 		case 15: //yymmdd

    2353. 

  2353. 			if (ewrpt_CheckShortDate($arDateTime[0])) {

    2354. 

  2354. 				list($year, $month, $day) = $arDatePt;

    2355. 

  2355. 				$year = ewrpt_UnformatYear($year);

    2356. 

  2356. 				break;

    2357. 

  2357. 			} else {

    2358. 

  2358. 				return $dt;

    2359. 

  2359. 			}

    2360. 

  2360. 		case 13:

    2361. 

  2361. 		case 16: //mmddyy

    2362. 

  2362. 			if (ewrpt_CheckShortUSDate($arDateTime[0])) {

    2363. 

  2363. 				list($month, $day, $year) = $arDatePt;

    2364. 

  2364. 				$year = ewrpt_UnformatYear($year);

    2365. 

  2365. 				break;

    2366. 

  2366. 			} else {

    2367. 

  2367. 				return $dt;

    2368. 

  2368. 			}

    2369. 

  2369. 		case 14:

    2370. 

  2370. 		case 17: //ddmmyy

    2371. 

  2371. 			if (ewrpt_CheckShortEuroDate($arDateTime[0])) {

    2372. 

  2372. 				list($day, $month, $year) = $arDatePt;

    2373. 

  2373. 				$year = ewrpt_UnformatYear($year);

    2374. 

  2374. 				break;

    2375. 

  2375. 			} else {

    2376. 

  2376. 				return $dt;

    2377. 

  2377. 			}

    2378. 

  2378. 		default:

    2379. 

  2379. 			return $dt;

    2380. 

  2380. 		}

    2381. 

  2381. 		if (strlen($year) <= 4 && strlen($month) <= 2 && strlen($day) <= 2) {

    2382. 

  2382. 			return $year . "-" . str_pad($month, 2, "0", STR_PAD_LEFT) . "-" .

    2383. 

  2383. 				 str_pad($day, 2, "0", STR_PAD_LEFT) .

    2384. 

  2384. 				((count($arDateTime) > 1) ? " " . $arDateTime[1] : "");

    2385. 

  2385. 		} else {

    2386. 

  2386. 			return $dt;

    2387. 

  2387. 		}

    2388. 

  2388. 	} else {

    2389. 

  2389. 		return $dt;

    2390. 

  2390. 	}

    2391. 

  2391. }

    2392. 

  2392. 

    2393. 

  2393. // ViewValue

    2394. 

  2394. // - return &nbsp; if empty

    2395. 

  2395. function ewrpt_ViewValue($value) {

    2396. 

  2396. 	if ($value <> "")

    2397. 

  2397. 		return $value;

    2398. 

  2398. 	else

    2399. 

  2399. 		return "&nbsp;";

    2400. 

  2400. }

    2401. 

  2401. 

    2402. 

  2402. // Get current year

    2403. 

  2403. function ewrpt_CurrentYear() {

    2404. 

  2404. 	return intval(date('Y'));

    2405. 

  2405. }

    2406. 

  2406. 

    2407. 

  2407. // Get current quarter

    2408. 

  2408. function ewrpt_CurrentQuarter() {

    2409. 

  2409. 	return ceil(intval(date('n'))/3);

    2410. 

  2410. }

    2411. 

  2411. 

    2412. 

  2412. // Get current month

    2413. 

  2413. function ewrpt_CurrentMonth() {

    2414. 

  2414. 	return intval(date('n'));

    2415. 

  2415. }

    2416. 

  2416. 

    2417. 

  2417. // Get current day

    2418. 

  2418. function ewrpt_CurrentDay() {

    2419. 

  2419. 	return intval(date('j'));

    2420. 

  2420. }

    2421. 

  2421. 

    2422. 

  2422. // FormatDateTime

    2423. 

  2423. // Format a timestamp, datetime, date or time field from MySQL

    2424. 

  2424. // $namedformat:

    2425. 

  2425. // 0 - General Date

    2426. 

  2426. // 1 - Long Date

    2427. 

  2427. // 2 - Short Date (Default)

    2428. 

  2428. // 3 - Long Time

    2429. 

  2429. // 4 - Short Time (hh:mm:ss)

    2430. 

  2430. // 5 - Short Date (yyyy/mm/dd)

    2431. 

  2431. // 6 - Short Date (mm/dd/yyyy)

    2432. 

  2432. // 7 - Short Date (dd/mm/yyyy)

    2433. 

  2433. // 8 - Short Date (Default) + Short Time (if not 00:00:00)

    2434. 

  2434. // 9 - Short Date (yyyy/mm/dd) + Short Time (hh:mm:ss)

    2435. 

  2435. // 10 - Short Date (mm/dd/yyyy) + Short Time (hh:mm:ss)

    2436. 

  2436. // 11 - Short Date (dd/mm/yyyy) + Short Time (hh:mm:ss)

    2437. 

  2437. // 12 - Short Date - 2 digit year (yy/mm/dd)

    2438. 

  2438. // 13 - Short Date - 2 digit year (mm/dd/yy)

    2439. 

  2439. // 14 - Short Date - 2 digit year (dd/mm/yy)

    2440. 

  2440. // 15 - Short Date - 2 digit year (yy/mm/dd) + Short Time (hh:mm:ss)

    2441. 

  2441. // 16 - Short Date (mm/dd/yyyy) + Short Time (hh:mm:ss)

    2442. 

  2442. // 17 - Short Date (dd/mm/yyyy) + Short Time (hh:mm:ss)

    2443. 

  2443. function ewrpt_FormatDateTime($ts, $namedformat) {

    2444. 

  2444. 	$DefDateFormat = str_replace("yyyy", "%Y", EWRPT_DEFAULT_DATE_FORMAT);

    2445. 

  2445. 	$DefDateFormat = str_replace("mm", "%m", $DefDateFormat);

    2446. 

  2446. 	$DefDateFormat = str_replace("dd", "%d", $DefDateFormat);

    2447. 

  2447. 	if (is_numeric($ts)) // timestamp

    2448. 

  2448. 	{

    2449. 

  2449. 		switch (strlen($ts)) {

    2450. 

  2450. 			case 14:

    2451. 

  2451. 				$patt = '/(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/';

    2452. 

  2452. 				break;

    2453. 

  2453. 			case 12:

    2454. 

  2454. 				$patt = '/(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/';

    2455. 

  2455. 				break;

    2456. 

  2456. 			case 10:

    2457. 

  2457. 				$patt = '/(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/';

    2458. 

  2458. 				break;

    2459. 

  2459. 			case 8:

    2460. 

  2460. 				$patt = '/(\d{4})(\d{2})(\d{2})/';

    2461. 

  2461. 				break;

    2462. 

  2462. 			case 6:

    2463. 

  2463. 				$patt = '/(\d{2})(\d{2})(\d{2})/';

    2464. 

  2464. 				break;

    2465. 

  2465. 			case 4:

    2466. 

  2466. 				$patt = '/(\d{2})(\d{2})/';

    2467. 

  2467. 				break;

    2468. 

  2468. 			case 2:

    2469. 

  2469. 				$patt = '/(\d{2})/';

    2470. 

  2470. 				break;

    2471. 

  2471. 			default:

    2472. 

  2472. 				return $ts;

    2473. 

  2473. 		}

    2474. 

  2474. 		if ((isset($patt))&&(preg_match($patt, $ts, $matches)))

    2475. 

  2475. 		{

    2476. 

  2476. 			$year = $matches[1];

    2477. 

  2477. 			$month = @$matches[2];

    2478. 

  2478. 			$day = @$matches[3];

    2479. 

  2479. 			$hour = @$matches[4];

    2480. 

  2480. 			$min = @$matches[5];

    2481. 

  2481. 			$sec = @$matches[6];

    2482. 

  2482. 		}

    2483. 

  2483. 		if (($namedformat==0)&&(strlen($ts)<10)) $namedformat = 2;

    2484. 

  2484. 	}

    2485. 

  2485. 	elseif (is_string($ts))

    2486. 

  2486. 	{

    2487. 

  2487. 		if (preg_match('/(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})/', $ts, $matches)) // datetime

    2488. 

  2488. 		{

    2489. 

  2489. 			$year = $matches[1];

    2490. 

  2490. 			$month = $matches[2];

    2491. 

  2491. 			$day = $matches[3];

    2492. 

  2492. 			$hour = $matches[4];

    2493. 

  2493. 			$min = $matches[5];

    2494. 

  2494. 			$sec = $matches[6];

    2495. 

  2495. 		}

    2496. 

  2496. 		elseif (preg_match('/(\d{4})-(\d{2})-(\d{2})/', $ts, $matches)) // date

    2497. 

  2497. 		{

    2498. 

  2498. 			$year = $matches[1];

    2499. 

  2499. 			$month = $matches[2];

    2500. 

  2500. 			$day = $matches[3];

    2501. 

  2501. 			if ($namedformat==0) $namedformat = 2;

    2502. 

  2502. 		}

    2503. 

  2503. 		elseif (preg_match('/(^|\s)(\d{2}):(\d{2}):(\d{2})/', $ts, $matches)) // time

    2504. 

  2504. 		{

    2505. 

  2505. 			$hour = $matches[2];

    2506. 

  2506. 			$min = $matches[3];

    2507. 

  2507. 			$sec = $matches[4];

    2508. 

  2508. 			if (($namedformat==0)||($namedformat==1)) $namedformat = 3;

    2509. 

  2509. 			if ($namedformat==2) $namedformat = 4;

    2510. 

  2510. 		}

    2511. 

  2511. 		else

    2512. 

  2512. 		{

    2513. 

  2513. 			return $ts;

    2514. 

  2514. 		}

    2515. 

  2515. 	}

    2516. 

  2516. 	else

    2517. 

  2517. 	{

    2518. 

  2518. 		return $ts;

    2519. 

  2519. 	}

    2520. 

  2520. 	if (!isset($year)) $year = 0; // dummy value for times

    2521. 

  2521. 	if (!isset($month)) $month = 1;

    2522. 

  2522. 	if (!isset($day)) $day = 1;

    2523. 

  2523. 	if (!isset($hour)) $hour = 0;

    2524. 

  2524. 	if (!isset($min)) $min = 0;

    2525. 

  2525. 	if (!isset($sec)) $sec = 0;

    2526. 

  2526. 	$uts = @mktime($hour, $min, $sec, $month, $day, $year);

    2527. 

  2527. 	if ($uts < 0 || $uts == FALSE || // failed to convert

    2528. 

  2528. 		(intval($year) == 0 && intval($month) == 0 && intval($day) == 0)) {

    2529. 

  2529. 		$year = substr_replace("0000", $year, -1 * strlen($year));

    2530. 

  2530. 		$month = substr_replace("00", $month, -1 * strlen($month));

    2531. 

  2531. 		$day = substr_replace("00", $day, -1 * strlen($day));

    2532. 

  2532. 		$hour = substr_replace("00", $hour, -1 * strlen($hour));

    2533. 

  2533. 		$min = substr_replace("00", $min, -1 * strlen($min));

    2534. 

  2534. 		$sec = substr_replace("00", $sec, -1 * strlen($sec));

    2535. 

  2535. 		$DefDateFormat = str_replace("yyyy", $year, EWRPT_DEFAULT_DATE_FORMAT);

    2536. 

  2536. 		$DefDateFormat = str_replace("mm", $month, $DefDateFormat);

    2537. 

  2537. 		$DefDateFormat = str_replace("dd", $day, $DefDateFormat);

    2538. 

  2538. 		switch ($namedformat) {

    2539. 

  2539. 			case 0:

    2540. 

  2540. 				return $DefDateFormat." $hour:$min:$sec";

    2541. 

  2541. 				break;

    2542. 

  2542. 			case 1://unsupported, return general date

    2543. 

  2543. 				return $DefDateFormat." $hour:$min:$sec";

    2544. 

  2544. 				break;

    2545. 

  2545. 			case 2:

    2546. 

  2546. 				return $DefDateFormat;

    2547. 

  2547. 				break;

    2548. 

  2548. 			case 3:

    2549. 

  2549. 				if (intval($hour)==0)

    2550. 

  2550. 					return "12:$min:$sec AM";

    2551. 

  2551. 				elseif (intval($hour)>0 && intval($hour)<12)

    2552. 

  2552. 					return "$hour:$min:$sec AM";

    2553. 

  2553. 				elseif (intval($hour)==12)

    2554. 

  2554. 					return "$hour:$min:$sec PM";

    2555. 

  2555. 				elseif (intval($hour)>12 && intval($hour)<=23)

    2556. 

  2556. 					return (intval($hour)-12).":$min:$sec PM";

    2557. 

  2557. 				else

    2558. 

  2558. 					return "$hour:$min:$sec";

    2559. 

  2559. 				break;

    2560. 

  2560. 			case 4:

    2561. 

  2561. 				return "$hour:$min:$sec";

    2562. 

  2562. 				break;

    2563. 

  2563. 			case 5:

    2564. 

  2564. 				return "$year". EWRPT_DATE_SEPARATOR . "$month" . EWRPT_DATE_SEPARATOR . "$day";

    2565. 

  2565. 				break;

    2566. 

  2566. 			case 6:

    2567. 

  2567. 				return "$month". EWRPT_DATE_SEPARATOR ."$day" . EWRPT_DATE_SEPARATOR . "$year";

    2568. 

  2568. 				break;

    2569. 

  2569. 			case 7:

    2570. 

  2570. 				return "$day" . EWRPT_DATE_SEPARATOR ."$month" . EWRPT_DATE_SEPARATOR . "$year";

    2571. 

  2571. 				break;

    2572. 

  2572. 			case 8:

    2573. 

  2573. 				return $DefDateFormat . (($hour == 0 && $min == 0 && $sec == 0) ? "" : " $hour:$min:$sec");

    2574. 

  2574. 				break;

    2575. 

  2575. 			case 9:

    2576. 

  2576. 				return "$year". EWRPT_DATE_SEPARATOR . "$month" . EWRPT_DATE_SEPARATOR . "$day $hour:$min:$sec";

    2577. 

  2577. 				break;

    2578. 

  2578. 			case 10:

    2579. 

  2579. 				return "$month". EWRPT_DATE_SEPARATOR ."$day" . EWRPT_DATE_SEPARATOR . "$year $hour:$min:$sec";

    2580. 

  2580. 				break;

    2581. 

  2581. 			case 11:

    2582. 

  2582. 				return "$day" . EWRPT_DATE_SEPARATOR ."$month" . EWRPT_DATE_SEPARATOR . "$year $hour:$min:$sec";

    2583. 

  2583. 				break;

    2584. 

  2584. 			case 12:

    2585. 

  2585. 				return substr($year,-2) . EWRPT_DATE_SEPARATOR . $month . EWRPT_DATE_SEPARATOR . $day;

    2586. 

  2586. 				break;

    2587. 

  2587. 			case 13:

    2588. 

  2588. 				return substr($year,-2) . EWRPT_DATE_SEPARATOR . $month . EWRPT_DATE_SEPARATOR . $day;

    2589. 

  2589. 				break;

    2590. 

  2590. 			case 14:

    2591. 

  2591. 				return substr($year,-2) . EWRPT_DATE_SEPARATOR . $month . EWRPT_DATE_SEPARATOR . $day;

    2592. 

  2592. 				break;

    2593. 

  2593. 			default:

    2594. 

  2594. 				return $ts;

    2595. 

  2595. 		}

    2596. 

  2596. 	} else {

    2597. 

  2597. 		switch ($namedformat) {

    2598. 

  2598. 			case 0:

    2599. 

  2599. 				return strftime($DefDateFormat." %H:%M:%S", $uts);

    2600. 

  2600. 				break;

    2601. 

  2601. 			case 1:

    2602. 

  2602. 				return strftime("%A, %B %d, %Y", $uts);

    2603. 

  2603. 				break;

    2604. 

  2604. 			case 2:

    2605. 

  2605. 				return strftime($DefDateFormat, $uts);

    2606. 

  2606. 				break;

    2607. 

  2607. 			case 3:

    2608. 

  2608. 				return strftime("%I:%M:%S %p", $uts);

    2609. 

  2609. 				break;

    2610. 

  2610. 			case 4:

    2611. 

  2611. 				return strftime("%H:%M:%S", $uts);

    2612. 

  2612. 				break;

    2613. 

  2613. 			case 5:

    2614. 

  2614. 				return strftime("%Y" . EWRPT_DATE_SEPARATOR . "%m" . EWRPT_DATE_SEPARATOR . "%d", $uts);

    2615. 

  2615. 				break;

    2616. 

  2616. 			case 6:

    2617. 

  2617. 				return strftime("%m" . EWRPT_DATE_SEPARATOR . "%d" . EWRPT_DATE_SEPARATOR . "%Y", $uts);

    2618. 

  2618. 				break;

    2619. 

  2619. 			case 7:

    2620. 

  2620. 				return strftime("%d" . EWRPT_DATE_SEPARATOR . "%m" . EWRPT_DATE_SEPARATOR . "%Y", $uts);

    2621. 

  2621. 				break;

    2622. 

  2622. 			case 8:

    2623. 

  2623. 				return strftime($DefDateFormat . (($hour == 0 && $min == 0 && $sec == 0) ? "" : " %H:%M:%S"), $uts);

    2624. 

  2624. 				break;

    2625. 

  2625. 			case 9:

    2626. 

  2626. 				return strftime("%Y" . EWRPT_DATE_SEPARATOR . "%m" . EWRPT_DATE_SEPARATOR . "%d %H:%M:%S", $uts);

    2627. 

  2627. 				break;

    2628. 

  2628. 			case 10:

    2629. 

  2629. 				return strftime("%m" . EWRPT_DATE_SEPARATOR . "%d" . EWRPT_DATE_SEPARATOR . "%Y %H:%M:%S", $uts);

    2630. 

  2630. 				break;

    2631. 

  2631. 			case 11:

    2632. 

  2632. 				return strftime("%d" . EWRPT_DATE_SEPARATOR . "%m" . EWRPT_DATE_SEPARATOR . "%Y %H:%M:%S", $uts);

    2633. 

  2633. 				break;

    2634. 

  2634. 			case 12:

    2635. 

  2635. 				return strftime("%y" . EWRPT_DATE_SEPARATOR . "%m" . EWRPT_DATE_SEPARATOR . "%d", $uts);

    2636. 

  2636. 				break;

    2637. 

  2637. 			case 13:

    2638. 

  2638. 				return strftime("%m" . EWRPT_DATE_SEPARATOR . "%d" . EWRPT_DATE_SEPARATOR . "%y", $uts);

    2639. 

  2639. 				break;

    2640. 

  2640. 			case 14:

    2641. 

  2641. 				return strftime("%d" . EWRPT_DATE_SEPARATOR . "%m" . EWRPT_DATE_SEPARATOR . "%y", $uts);

    2642. 

  2642. 				break;

    2643. 

  2643. 			case 15:

    2644. 

  2644. 				return strftime("%y" . EWRPT_DATE_SEPARATOR . "%m" . EWRPT_DATE_SEPARATOR . "%d %H:%M:%S", $uts);

    2645. 

  2645. 				break;

    2646. 

  2646. 			case 16:

    2647. 

  2647. 				return strftime("%m" . EWRPT_DATE_SEPARATOR . "%d" . EWRPT_DATE_SEPARATOR . "%y %H:%M:%S", $uts);

    2648. 

  2648. 				break;

    2649. 

  2649. 			case 17:

    2650. 

  2650. 				return strftime("%d" . EWRPT_DATE_SEPARATOR . "%m" . EWRPT_DATE_SEPARATOR . "%y %H:%M:%S", $uts);

    2651. 

  2651. 				break;

    2652. 

  2652. 			default:

    2653. 

  2653. 				return $ts;

    2654. 

  2654. 		}

    2655. 

  2655. 	}

    2656. 

  2656. }

    2657. 

  2657. 

    2658. 

  2658. // FormatCurrency

    2659. 

  2659. // FormatCurrency(Expression[,NumDigitsAfterDecimal [,IncludeLeadingDigit

    2660. 

  2660. //  [,UseParensForNegativeNumbers [,GroupDigits]]]])

    2661. 

  2661. // NumDigitsAfterDecimal is the numeric value indicating how many places to the

    2662. 

  2662. // right of the decimal are displayed

    2663. 

  2663. // -1 Use Default

    2664. 

  2664. // The IncludeLeadingDigit, UseParensForNegativeNumbers, and GroupDigits

    2665. 

  2665. // arguments have the following settings:

    2666. 

  2666. // -1 True

    2667. 

  2667. // 0 False

    2668. 

  2668. // -2 Use Default

    2669. 

  2669. function ewrpt_FormatCurrency($amount, $NumDigitsAfterDecimal, $IncludeLeadingDigit = -2, $UseParensForNegativeNumbers = -2, $GroupDigits = -2) {

    2670. 

  2670. 	if (!is_numeric($amount))

    2671. 

  2671. 		return $amount;

    2672. 

  2672. 

    2673. 

  2673. 	// export the values returned by localeconv into the local scope

    2674. 

  2674. 	extract(localeconv());

    2675. 

  2675. 

    2676. 

  2676. 	// set defaults if locale is not set

    2677. 

  2677. 	if (empty($currency_symbol)) $currency_symbol = EWRPT_DEFAULT_CURRENCY_SYMBOL;

    2678. 

  2678. 	if (empty($mon_decimal_point)) $mon_decimal_point = EWRPT_DEFAULT_MON_DECIMAL_POINT;

    2679. 

  2679. 	if (empty($mon_thousands_sep)) $mon_thousands_sep = EWRPT_DEFAULT_MON_THOUSANDS_SEP;

    2680. 

  2680. 	if (empty($positive_sign)) $positive_sign = EWRPT_DEFAULT_POSITIVE_SIGN;

    2681. 

  2681. 	if (empty($negative_sign)) $negative_sign = EWRPT_DEFAULT_NEGATIVE_SIGN;

    2682. 

  2682. 	if (empty($frac_digits) || $frac_digits == CHAR_MAX) $frac_digits = EWRPT_DEFAULT_FRAC_DIGITS;

    2683. 

  2683. 	if (empty($p_cs_precedes) || $p_cs_precedes == CHAR_MAX) $p_cs_precedes = EWRPT_DEFAULT_P_CS_PRECEDES;

    2684. 

  2684. 	if (empty($p_sep_by_space) || $p_sep_by_space == CHAR_MAX) $p_sep_by_space = EWRPT_DEFAULT_P_SEP_BY_SPACE;

    2685. 

  2685. 	if (empty($n_cs_precedes) || $n_cs_precedes == CHAR_MAX) $n_cs_precedes = EWRPT_DEFAULT_N_CS_PRECEDES;

    2686. 

  2686. 	if (empty($n_sep_by_space) || $n_sep_by_space == CHAR_MAX) $n_sep_by_space = EWRPT_DEFAULT_N_SEP_BY_SPACE;

    2687. 

  2687. 	if (empty($p_sign_posn) || $p_sign_posn == CHAR_MAX) $p_sign_posn = EWRPT_DEFAULT_P_SIGN_POSN;

    2688. 

  2688. 	if (empty($n_sign_posn) || $n_sign_posn == CHAR_MAX) $n_sign_posn = EWRPT_DEFAULT_N_SIGN_POSN;

    2689. 

  2689. 

    2690. 

  2690. 	// check $NumDigitsAfterDecimal

    2691. 

  2691. 	if ($NumDigitsAfterDecimal > -1)

    2692. 

  2692. 		$frac_digits = $NumDigitsAfterDecimal;

    2693. 

  2693. 

    2694. 

  2694. 	// check $UseParensForNegativeNumbers

    2695. 

  2695. 	if ($UseParensForNegativeNumbers == -1) {

    2696. 

  2696. 		$n_sign_posn = 0;

    2697. 

  2697. 		if ($p_sign_posn == 0) {

    2698. 

  2698. 			if (DEFAULT_P_SIGN_POSN != 0)

    2699. 

  2699. 				$p_sign_posn = DEFAULT_P_SIGN_POSN;

    2700. 

  2700. 			else

    2701. 

  2701. 				$p_sign_posn = 3;

    2702. 

  2702. 		}

    2703. 

  2703. 	} elseif ($UseParensForNegativeNumbers == 0) {

    2704. 

  2704. 		if ($n_sign_posn == 0)

    2705. 

  2705. 			if (DEFAULT_P_SIGN_POSN != 0)

    2706. 

  2706. 				$n_sign_posn = DEFAULT_P_SIGN_POSN;

    2707. 

  2707. 			else

    2708. 

  2708. 				$n_sign_posn = 3;

    2709. 

  2709. 	}

    2710. 

  2710. 

    2711. 

  2711. 	// check $GroupDigits

    2712. 

  2712. 	if ($GroupDigits == -1) {

    2713. 

  2713. 		$mon_thousands_sep = EWRPT_DEFAULT_MON_THOUSANDS_SEP;

    2714. 

  2714. 	} elseif ($GroupDigits == 0) {

    2715. 

  2715. 		$mon_thousands_sep = "";

    2716. 

  2716. 	}

    2717. 

  2717. 

    2718. 

  2718. 	// start by formatting the unsigned number

    2719. 

  2719. 	$number = number_format(abs($amount),

    2720. 

  2720. 							$frac_digits,

    2721. 

  2721. 							$mon_decimal_point,

    2722. 

  2722. 							$mon_thousands_sep);

    2723. 

  2723. 

    2724. 

  2724. 	// check $IncludeLeadingDigit

    2725. 

  2725. 	if ($IncludeLeadingDigit == 0) {

    2726. 

  2726. 		if (substr($number, 0, 2) == "0.")

    2727. 

  2727. 			$number = substr($number, 1, strlen($number)-1);

    2728. 

  2728. 	}

    2729. 

  2729. 	if ($amount < 0) {

    2730. 

  2730. 		$sign = $negative_sign;

    2731. 

  2731. 

    2732. 

  2732. 		// "extracts" the boolean value as an integer

    2733. 

  2733. 		$n_cs_precedes  = intval($n_cs_precedes  == true);

    2734. 

  2734. 		$n_sep_by_space = intval($n_sep_by_space == true);

    2735. 

  2735. 		$key = $n_cs_precedes . $n_sep_by_space . $n_sign_posn;

    2736. 

  2736. 	} else {

    2737. 

  2737. 		$sign = $positive_sign;

    2738. 

  2738. 		$p_cs_precedes  = intval($p_cs_precedes  == true);

    2739. 

  2739. 		$p_sep_by_space = intval($p_sep_by_space == true);

    2740. 

  2740. 		$key = $p_cs_precedes . $p_sep_by_space . $p_sign_posn;

    2741. 

  2741. 	}

    2742. 

  2742. 	$formats = array(

    2743. 

  2743. 

    2744. 

  2744. 	  // currency symbol is after amount

    2745. 

  2745. 	  // no space between amount and sign

    2746. 

  2746. 

    2747. 

  2747. 	  '000' => '(%s' . $currency_symbol . ')',

    2748. 

  2748. 	  '001' => $sign . '%s ' . $currency_symbol,

    2749. 

  2749. 	  '002' => '%s' . $currency_symbol . $sign,

    2750. 

  2750. 	  '003' => '%s' . $sign . $currency_symbol,

    2751. 

  2751. 	  '004' => '%s' . $sign . $currency_symbol,

    2752. 

  2752. 

    2753. 

  2753. 	  // one space between amount and sign

    2754. 

  2754. 	  '010' => '(%s ' . $currency_symbol . ')',

    2755. 

  2755. 	  '011' => $sign . '%s ' . $currency_symbol,

    2756. 

  2756. 	  '012' => '%s ' . $currency_symbol . $sign,

    2757. 

  2757. 	  '013' => '%s ' . $sign . $currency_symbol,

    2758. 

  2758. 	  '014' => '%s ' . $sign . $currency_symbol,

    2759. 

  2759. 

    2760. 

  2760. 	  // currency symbol is before amount

    2761. 

  2761. 	  // no space between amount and sign

    2762. 

  2762. 

    2763. 

  2763. 	  '100' => '(' . $currency_symbol . '%s)',

    2764. 

  2764. 	  '101' => $sign . $currency_symbol . '%s',

    2765. 

  2765. 	  '102' => $currency_symbol . '%s' . $sign,

    2766. 

  2766. 	  '103' => $sign . $currency_symbol . '%s',

    2767. 

  2767. 	  '104' => $currency_symbol . $sign . '%s',

    2768. 

  2768. 

    2769. 

  2769. 	  // one space between amount and sign

    2770. 

  2770. 	  '110' => '(' . $currency_symbol . ' %s)',

    2771. 

  2771. 	  '111' => $sign . $currency_symbol . ' %s',

    2772. 

  2772. 	  '112' => $currency_symbol . ' %s' . $sign,

    2773. 

  2773. 	  '113' => $sign . $currency_symbol . ' %s',

    2774. 

  2774. 	  '114' => $currency_symbol . ' ' . $sign . '%s');

    2775. 

  2775. 

    2776. 

  2776.   // lookup the key in the above array

    2777. 

  2777. 	return sprintf($formats[$key], $number);

    2778. 

  2778. }

    2779. 

  2779. 

    2780. 

  2780. // FormatNumber

    2781. 

  2781. // FormatNumber(Expression[,NumDigitsAfterDecimal [,IncludeLeadingDigit

    2782. 

  2782. // 	[,UseParensForNegativeNumbers [,GroupDigits]]]])

    2783. 

  2783. // NumDigitsAfterDecimal is the numeric value indicating how many places to the

    2784. 

  2784. // right of the decimal are displayed

    2785. 

  2785. // -1 Use Default

    2786. 

  2786. // The IncludeLeadingDigit, UseParensForNegativeNumbers, and GroupDigits

    2787. 

  2787. // arguments have the following settings:

    2788. 

  2788. // -1 True

    2789. 

  2789. // 0 False

    2790. 

  2790. // -2 Use Default

    2791. 

  2791. function ewrpt_FormatNumber($amount, $NumDigitsAfterDecimal, $IncludeLeadingDigit = -2, $UseParensForNegativeNumbers = -2, $GroupDigits = -2) {

    2792. 

  2792. 	if (!is_numeric($amount))

    2793. 

  2793. 		return $amount;

    2794. 

  2794. 

    2795. 

  2795. 	// export the values returned by localeconv into the local scope

    2796. 

  2796. 	extract(localeconv());

    2797. 

  2797. 

    2798. 

  2798. 	// set defaults if locale is not set

    2799. 

  2799. 	if (empty($currency_symbol)) $currency_symbol = EWRPT_DEFAULT_CURRENCY_SYMBOL;

    2800. 

  2800. 	if (empty($mon_decimal_point)) $mon_decimal_point = EWRPT_DEFAULT_MON_DECIMAL_POINT;

    2801. 

  2801. 	if (empty($mon_thousands_sep)) $mon_thousands_sep = EWRPT_DEFAULT_MON_THOUSANDS_SEP;

    2802. 

  2802. 	if (empty($positive_sign)) $positive_sign = EWRPT_DEFAULT_POSITIVE_SIGN;

    2803. 

  2803. 	if (empty($negative_sign)) $negative_sign = EWRPT_DEFAULT_NEGATIVE_SIGN;

    2804. 

  2804. 	if (empty($frac_digits) || $frac_digits == CHAR_MAX) $frac_digits = EWRPT_DEFAULT_FRAC_DIGITS;

    2805. 

  2805. 	if (empty($p_cs_precedes) || $p_cs_precedes == CHAR_MAX) $p_cs_precedes = EWRPT_DEFAULT_P_CS_PRECEDES;

    2806. 

  2806. 	if (empty($p_sep_by_space) || $p_sep_by_space == CHAR_MAX) $p_sep_by_space = EWRPT_DEFAULT_P_SEP_BY_SPACE;

    2807. 

  2807. 	if (empty($n_cs_precedes) || $n_cs_precedes == CHAR_MAX) $n_cs_precedes = EWRPT_DEFAULT_N_CS_PRECEDES;

    2808. 

  2808. 	if (empty($n_sep_by_space) || $n_sep_by_space == CHAR_MAX) $n_sep_by_space = EWRPT_DEFAULT_N_SEP_BY_SPACE;

    2809. 

  2809. 	if (empty($p_sign_posn) || $p_sign_posn == CHAR_MAX) $p_sign_posn = EWRPT_DEFAULT_P_SIGN_POSN;

    2810. 

  2810. 	if (empty($n_sign_posn) || $n_sign_posn == CHAR_MAX) $n_sign_posn = EWRPT_DEFAULT_N_SIGN_POSN;

    2811. 

  2811. 

    2812. 

  2812. 	// check $NumDigitsAfterDecimal

    2813. 

  2813. 	if ($NumDigitsAfterDecimal > -1)

    2814. 

  2814. 		$frac_digits = $NumDigitsAfterDecimal;

    2815. 

  2815. 

    2816. 

  2816. 	// check $UseParensForNegativeNumbers

    2817. 

  2817. 	if ($UseParensForNegativeNumbers == -1) {

    2818. 

  2818. 		$n_sign_posn = 0;

    2819. 

  2819. 		if ($p_sign_posn == 0) {

    2820. 

  2820. 			if (DEFAULT_P_SIGN_POSN != 0)

    2821. 

  2821. 				$p_sign_posn = DEFAULT_P_SIGN_POSN;

    2822. 

  2822. 			else

    2823. 

  2823. 				$p_sign_posn = 3;

    2824. 

  2824. 		}

    2825. 

  2825. 	} elseif ($UseParensForNegativeNumbers == 0) {

    2826. 

  2826. 		if ($n_sign_posn == 0)

    2827. 

  2827. 			if (DEFAULT_P_SIGN_POSN != 0)

    2828. 

  2828. 				$n_sign_posn = DEFAULT_P_SIGN_POSN;

    2829. 

  2829. 			else

    2830. 

  2830. 				$n_sign_posn = 3;

    2831. 

  2831. 	}

    2832. 

  2832. 

    2833. 

  2833. 	// check $GroupDigits

    2834. 

  2834. 	if ($GroupDigits == -1) {

    2835. 

  2835. 		$mon_thousands_sep = EWRPT_DEFAULT_MON_THOUSANDS_SEP;

    2836. 

  2836. 	} elseif ($GroupDigits == 0) {

    2837. 

  2837. 		$mon_thousands_sep = "";

    2838. 

  2838. 	}

    2839. 

  2839. 

    2840. 

  2840. 	// start by formatting the unsigned number

    2841. 

  2841. 	$number = number_format(abs($amount),

    2842. 

  2842. 						  $frac_digits,

    2843. 

  2843. 						  $mon_decimal_point,

    2844. 

  2844. 						  $mon_thousands_sep);

    2845. 

  2845. 

    2846. 

  2846. 	// check $IncludeLeadingDigit

    2847. 

  2847. 	if ($IncludeLeadingDigit == 0) {

    2848. 

  2848. 		if (substr($number, 0, 2) == "0.")

    2849. 

  2849. 			$number = substr($number, 1, strlen($number)-1);

    2850. 

  2850. 	}

    2851. 

  2851. 	if ($amount < 0) {

    2852. 

  2852. 		$sign = $negative_sign;

    2853. 

  2853. 		$key = $n_sign_posn;

    2854. 

  2854. 	} else {

    2855. 

  2855. 		$sign = $positive_sign;

    2856. 

  2856. 		$key = $p_sign_posn;

    2857. 

  2857. 	}

    2858. 

  2858. 	$formats = array(

    2859. 

  2859. 		'0' => '(%s)',

    2860. 

  2860. 		'1' => $sign . '%s',

    2861. 

  2861. 		'2' => $sign . '%s',

    2862. 

  2862. 		'3' => $sign . '%s',

    2863. 

  2863. 		'4' => $sign . '%s');

    2864. 

  2864. 

    2865. 

  2865. 	// lookup the key in the above array

    2866. 

  2866. 	return sprintf($formats[$key], $number);

    2867. 

  2867. }

    2868. 

  2868. 

    2869. 

  2869. // FormatPercent

    2870. 

  2870. // FormatPercent(Expression[,NumDigitsAfterDecimal [,IncludeLeadingDigit

    2871. 

  2871. // 	[,UseParensForNegativeNumbers [,GroupDigits]]]])

    2872. 

  2872. // NumDigitsAfterDecimal is the numeric value indicating how many places to the

    2873. 

  2873. // right of the decimal are displayed

    2874. 

  2874. // -1 Use Default

    2875. 

  2875. // The IncludeLeadingDigit, UseParensForNegativeNumbers, and GroupDigits

    2876. 

  2876. // arguments have the following settings:

    2877. 

  2877. // -1 True

    2878. 

  2878. // 0 False

    2879. 

  2879. // -2 Use Default

    2880. 

  2880. function ewrpt_FormatPercent($amount, $NumDigitsAfterDecimal, $IncludeLeadingDigit = -2, $UseParensForNegativeNumbers = -2, $GroupDigits = -2) {

    2881. 

  2881. 	if (!is_numeric($amount))

    2882. 

  2882. 		return $amount;

    2883. 

  2883. 

    2884. 

  2884. 	// export the values returned by localeconv into the local scope

    2885. 

  2885. 	extract(localeconv());

    2886. 

  2886. 

    2887. 

  2887. 	// set defaults if locale is not set

    2888. 

  2888. 	if (empty($currency_symbol)) $currency_symbol = EWRPT_DEFAULT_CURRENCY_SYMBOL;

    2889. 

  2889. 	if (empty($mon_decimal_point)) $mon_decimal_point = EWRPT_DEFAULT_MON_DECIMAL_POINT;

    2890. 

  2890. 	if (empty($mon_thousands_sep)) $mon_thousands_sep = EWRPT_DEFAULT_MON_THOUSANDS_SEP;

    2891. 

  2891. 	if (empty($positive_sign)) $positive_sign = EWRPT_DEFAULT_POSITIVE_SIGN;

    2892. 

  2892. 	if (empty($negative_sign)) $negative_sign = EWRPT_DEFAULT_NEGATIVE_SIGN;

    2893. 

  2893. 	if (empty($frac_digits) || $frac_digits == CHAR_MAX) $frac_digits = EWRPT_DEFAULT_FRAC_DIGITS;

    2894. 

  2894. 	if (empty($p_cs_precedes) || $p_cs_precedes == CHAR_MAX) $p_cs_precedes = EWRPT_DEFAULT_P_CS_PRECEDES;

    2895. 

  2895. 	if (empty($p_sep_by_space) || $p_sep_by_space == CHAR_MAX) $p_sep_by_space = EWRPT_DEFAULT_P_SEP_BY_SPACE;

    2896. 

  2896. 	if (empty($n_cs_precedes) || $n_cs_precedes == CHAR_MAX) $n_cs_precedes = EWRPT_DEFAULT_N_CS_PRECEDES;

    2897. 

  2897. 	if (empty($n_sep_by_space) || $n_sep_by_space == CHAR_MAX) $n_sep_by_space = EWRPT_DEFAULT_N_SEP_BY_SPACE;

    2898. 

  2898. 	if (empty($p_sign_posn) || $p_sign_posn == CHAR_MAX) $p_sign_posn = EWRPT_DEFAULT_P_SIGN_POSN;

    2899. 

  2899. 	if (empty($n_sign_posn) || $n_sign_posn == CHAR_MAX) $n_sign_posn = EWRPT_DEFAULT_N_SIGN_POSN;

    2900. 

  2900. 

    2901. 

  2901. 	// check $NumDigitsAfterDecimal

    2902. 

  2902. 	if ($NumDigitsAfterDecimal > -1)

    2903. 

  2903. 		$frac_digits = $NumDigitsAfterDecimal;

    2904. 

  2904. 

    2905. 

  2905. 	// check $UseParensForNegativeNumbers

    2906. 

  2906. 	if ($UseParensForNegativeNumbers == -1) {

    2907. 

  2907. 		$n_sign_posn = 0;

    2908. 

  2908. 		if ($p_sign_posn == 0) {

    2909. 

  2909. 			if (DEFAULT_P_SIGN_POSN != 0)

    2910. 

  2910. 				$p_sign_posn = DEFAULT_P_SIGN_POSN;

    2911. 

  2911. 			else

    2912. 

  2912. 				$p_sign_posn = 3;

    2913. 

  2913. 		}

    2914. 

  2914. 	} elseif ($UseParensForNegativeNumbers == 0) {

    2915. 

  2915. 		if ($n_sign_posn == 0)

    2916. 

  2916. 			if (DEFAULT_P_SIGN_POSN != 0)

    2917. 

  2917. 				$n_sign_posn = DEFAULT_P_SIGN_POSN;

    2918. 

  2918. 			else

    2919. 

  2919. 				$n_sign_posn = 3;

    2920. 

  2920. 	}

    2921. 

  2921. 

    2922. 

  2922. 	// check $GroupDigits

    2923. 

  2923. 	if ($GroupDigits == -1) {

    2924. 

  2924. 		$mon_thousands_sep = EWRPT_DEFAULT_MON_THOUSANDS_SEP;

    2925. 

  2925. 	} elseif ($GroupDigits == 0) {

    2926. 

  2926. 		$mon_thousands_sep = "";

    2927. 

  2927. 	}

    2928. 

  2928. 

    2929. 

  2929. 	// start by formatting the unsigned number

    2930. 

  2930. 	$number = number_format(abs($amount)*100,

    2931. 

  2931. 							$frac_digits,

    2932. 

  2932. 							$mon_decimal_point,

    2933. 

  2933. 							$mon_thousands_sep);

    2934. 

  2934. 

    2935. 

  2935. 	// check $IncludeLeadingDigit

    2936. 

  2936. 	if ($IncludeLeadingDigit == 0) {

    2937. 

  2937. 		if (substr($number, 0, 2) == "0.")

    2938. 

  2938. 			$number = substr($number, 1, strlen($number)-1);

    2939. 

  2939. 	}

    2940. 

  2940. 	if ($amount < 0) {

    2941. 

  2941. 		$sign = $negative_sign;

    2942. 

  2942. 		$key = $n_sign_posn;

    2943. 

  2943. 	} else {

    2944. 

  2944. 		$sign = $positive_sign;

    2945. 

  2945. 		$key = $p_sign_posn;

    2946. 

  2946. 	}

    2947. 

  2947. 	$formats = array(

    2948. 

  2948. 		'0' => '(%s%%)',

    2949. 

  2949. 		'1' => $sign . '%s%%',

    2950. 

  2950. 		'2' => $sign . '%s%%',

    2951. 

  2951. 		'3' => $sign . '%s%%',

    2952. 

  2952. 		'4' => $sign . '%s%%');

    2953. 

  2953. 

    2954. 

  2954. 	// lookup the key in the above array

    2955. 

  2955. 	return sprintf($formats[$key], $number);

    2956. 

  2956. }

    2957. 

  2957. 

    2958. 

  2958. // Add slashes for SQL

    2959. 

  2959. function ewrpt_AdjustSql($val) {

    2960. 

  2960. 	$val = addslashes(trim($val));

    2961. 

  2961. 	return $val;

    2962. 

  2962. }

    2963. 

  2963. 

    2964. 

  2964. // Build Report SQL

    2965. 

  2965. function ewrpt_BuildReportSql($sSelect, $sWhere, $sGroupBy, $sHaving, $sOrderBy, $sFilter, $sSort) {

    2966. 

  2966. 	$sDbWhere = $sWhere;

    2967. 

  2967. 	if ($sDbWhere <> "") $sDbWhere = "(" . $sDbWhere . ")";

    2968. 

  2968. 	if ($sFilter <> "") {

    2969. 

  2969. 		if ($sDbWhere <> "") $sDbWhere .= " AND ";

    2970. 

  2970. 		$sDbWhere .= "(" . $sFilter . ")";

    2971. 

  2971. 	}

    2972. 

  2972. 	$sDbOrderBy = ewrpt_UpdateSortFields($sOrderBy, $sSort, 1);

    2973. 

  2973. 	$sSql = $sSelect;

    2974. 

  2974. 	if ($sDbWhere <> "") $sSql .= " WHERE " . $sDbWhere;

    2975. 

  2975. 	if ($sGroupBy <> "") $sSql .= " GROUP BY " . $sGroupBy;

    2976. 

  2976. 	if ($sHaving <> "") $sSql .= " HAVING " . $sHaving;

    2977. 

  2977. 	if ($sDbOrderBy <> "") $sSql .= " ORDER BY " . $sDbOrderBy;

    2978. 

  2978. 	return $sSql;

    2979. 

  2979. }

    2980. 

  2980. 

    2981. 

  2981. // Update sort fields

    2982. 

  2982. // opt = 1, merge all sort fields

    2983. 

  2983. // opt = 2, merge sOrderBy fields only

    2984. 

  2984. function ewrpt_UpdateSortFields($sOrderBy, $sSort, $opt) {

    2985. 

  2985. 	if ($sOrderBy == "") {

    2986. 

  2986. 		if ($opt == 1)

    2987. 

  2987. 			return $sSort;

    2988. 

  2988. 		else

    2989. 

  2989. 			return "";

    2990. 

  2990. 	} elseif ($sSort == "") {

    2991. 

  2991. 		return $sOrderBy;

    2992. 

  2992. 	} else {

    2993. 

  2993. 

    2994. 

  2994. 		// Merge sort field list

    2995. 

  2995. 		$arorderby = ewrpt_GetSortFlds($sOrderBy);

    2996. 

  2996. 		$cntorderby = count($arorderby);

    2997. 

  2997. 		$arsort = ewrpt_GetSortFlds($sSort);

    2998. 

  2998. 		$cntsort = count($arsort);

    2999. 

  2999. 		for ($i = 0; $i < $cntsort; $i++) {

    3000. 

  3000. 

    3001. 

  3001. 			// Get sort field

    3002. 

  3002. 			$sortfld = trim($arsort[$i]);

    3003. 

  3003. 			if (strtoupper(substr($sortfld,-4)) == " ASC") {

    3004. 

  3004. 				$sortfld = trim(substr($sortfld,0,-4));

    3005. 

  3005. 			} elseif (strtoupper(substr($sortfld,-5)) == " DESC") {

    3006. 

  3006. 				$sortfld = trim(substr($sortfld,0,-4));

    3007. 

  3007. 			}

    3008. 

  3008. 			for ($j = 0; $j < $cntorderby; $j++) {

    3009. 

  3009. 

    3010. 

  3010. 				// Get orderby field

    3011. 

  3011. 				$orderfld = trim($arorderby[$j]);

    3012. 

  3012. 				if (strtoupper(substr($orderfld,-4)) == " ASC") {

    3013. 

  3013. 					$orderfld = trim(substr($orderfld,0,-4));

    3014. 

  3014. 				} elseif (strtoupper(substr($orderfld,-5)) == " DESC") {

    3015. 

  3015. 					$orderfld = trim(substr($orderfld,0,-4));

    3016. 

  3016. 				}

    3017. 

  3017. 

    3018. 

  3018. 				// Replace field

    3019. 

  3019. 				if ($orderfld == $sortfld) {

    3020. 

  3020. 					$arorderby[$j] = $arsort[$i];

    3021. 

  3021. 					break;

    3022. 

  3022. 				}

    3023. 

  3023. 			}

    3024. 

  3024. 

    3025. 

  3025. 			// Append field

    3026. 

  3026. 			if ($opt == 1) {

    3027. 

  3027. 				if ($orderfld <> $sortfld)

    3028. 

  3028. 					$arorderby[] = $arsort[$i];

    3029. 

  3029. 			}

    3030. 

  3030. 		}

    3031. 

  3031. 		return implode(", ", $arorderby);

    3032. 

  3032. 	}

    3033. 

  3033. }

    3034. 

  3034. 

    3035. 

  3035. // Get sort fields

    3036. 

  3036. function ewrpt_GetSortFlds($flds) {

    3037. 

  3037. 	$offset = -1;

    3038. 

  3038. 	$fldpos = 0;

    3039. 

  3039. 	$ar = array();

    3040. 

  3040. 	while ($offset = strpos($flds, ",", $offset + 1)) {

    3041. 

  3041. 		$orderfld = substr($flds,$fldpos,$offset-$fldpos);

    3042. 

  3042. 		if ((strtoupper(substr($orderfld,-4)) == " ASC") || (strtoupper(substr($orderfld,-5)) == " DESC")) {

    3043. 

  3043. 			$fldpos = $offset+1;

    3044. 

  3044. 			$ar[] = $orderfld;

    3045. 

  3045. 		}

    3046. 

  3046. 	}

    3047. 

  3047. 	$ar[] = substr($flds,$fldpos);

    3048. 

  3048. 	return $ar;

    3049. 

  3049. }

    3050. 

  3050. 

    3051. 

  3051. // Get reverse sort

    3052. 

  3052. function ewrpt_ReverseSort($sorttype) {

    3053. 

  3053. 	return ($sorttype == "ASC") ? "DESC" : "ASC";

    3054. 

  3054. }

    3055. 

  3055. 

    3056. 

  3056. // Construct a crosstab field name

    3057. 

  3057. function ewrpt_CrossTabField($smrytype, $smryfld, $colfld, $datetype, $val, $qc, $alias="") {

    3058. 

  3058. 	if ($val == EWRPT_NULL_VALUE) {

    3059. 

  3059. 		$wrkval = "NULL";

    3060. 

  3060. 		$wrkqc = "";

    3061. 

  3061. 	} elseif ($val == EWRPT_EMPTY_VALUE) {

    3062. 

  3062. 		$wrkval = "";

    3063. 

  3063. 		$wrkqc = $qc;

    3064. 

  3064. 	} else {

    3065. 

  3065. 		$wrkval = $val;

    3066. 

  3066. 		$wrkqc = $qc;

    3067. 

  3067. 	}

    3068. 

  3068. 	switch ($smrytype) {

    3069. 

  3069. 	case "SUM":

    3070. 

  3070. 		$fld = $smrytype . "(" . $smryfld . "*" . ewrpt_SQLDistinctFactor($colfld, $datetype, $val, $qc) . ")";

    3071. 

  3071. 		break;

    3072. 

  3072. 	case "COUNT":

    3073. 

  3073. 		$fld = "SUM(" . ewrpt_SQLDistinctFactor($colfld, $datetype, $wrkval, $wrkqc) . ")";

    3074. 

  3074. 		break;

    3075. 

  3075. 	case "MIN":

    3076. 

  3076. 	case "MAX":

    3077. 

  3077. 		$aggwrk = ewrpt_SQLDistinctFactor($colfld, $datetype, $wrkval, $wrkqc);

    3078. 

  3078. 		$fld = $smrytype . "(IF(" . $aggwrk . "=0,NULL," . $smryfld . "))";

    3079. 

  3079. 		if (EWRPT_IS_MSACCESS)

    3080. 

  3080. 			$fld = $smrytype . "(IIf(" . $aggwrk . "=0,NULL," . $smryfld . "))";

    3081. 

  3081. 		elseif (EWRPT_IS_MSSQL || EWRPT_IS_ORACLE)

    3082. 

  3082. 			$fld = $smrytype . "(CASE " . $aggwrk . " WHEN 0 THEN NULL ELSE " . $smryfld . " END)";

    3083. 

  3083. 		elseif (EWRPT_IS_MYSQL || EWRPT_IS_POSTGRESQL)

    3084. 

  3084. 			$fld = $smrytype . "(IF(" . $aggwrk . "=0,NULL," . $smryfld . "))";

    3085. 

  3085. 		break;

    3086. 

  3086. 	case "AVG":

    3087. 

  3087. 		$sumwrk = "SUM(" . $smryfld . "*" . ewrpt_SQLDistinctFactor($colfld, $datetype, $wrkval, $wrkqc) . ")";

    3088. 

  3088. 		if ($alias != "")

    3089. 

  3089. 

    3090. 

  3090. //			$sumwrk .= " AS SUM_" . $alias;

    3091. 

  3091. 			$sumwrk .= " AS sum_" . $alias;

    3092. 

  3092. 		$cntwrk =	"SUM(" . ewrpt_SQLDistinctFactor($colfld, $datetype, $wrkval, $wrkqc) . ")";

    3093. 

  3093. 		if ($alias != "")

    3094. 

  3094. 

    3095. 

  3095. //			$cntwrk .= " AS CNT_" . $alias;

    3096. 

  3096. 			$cntwrk .= " AS cnt_" . $alias;

    3097. 

  3097. 		return $sumwrk . ", " . $cntwrk;

    3098. 

  3098. 	}

    3099. 

  3099. 	if ($alias != "")

    3100. 

  3100. 		$fld .= " AS " . $alias;

    3101. 

  3101. 	return $fld;

    3102. 

  3102. }

    3103. 

  3103. 

    3104. 

  3104. // Construct SQL Distinct factor (MySQL)

    3105. 

  3105. // - ACCESS

    3106. 

  3106. // y: IIf(Year(FieldName)=1996,1,0)

    3107. 

  3107. // q: IIf(DatePart(""q"",FieldName,1,0)=1,1,0))

    3108. 

  3108. // m: (IIf(DatePart(""m"",FieldName,1,0)=1,1,0)))

    3109. 

  3109. // others: (IIf(FieldName=val,1,0)))

    3110. 

  3110. // - MS SQL

    3111. 

  3111. // y: (1-ABS(SIGN(Year(FieldName)-1996)))

    3112. 

  3112. // q: (1-ABS(SIGN(DatePart(q,FieldName)-1)))

    3113. 

  3113. // m: (1-ABS(SIGN(DatePart(m,FieldName)-1)))

    3114. 

  3114. // d: (CASE Convert(VarChar(10),FieldName,120) WHEN '1996-1-1' THEN 1 ELSE 0 END)

    3115. 

  3115. // - MySQL

    3116. 

  3116. // y: IF(YEAR(FieldName)=1996,1,0))

    3117. 

  3117. // q: IF(QUARTER(FieldName)=1,1,0))

    3118. 

  3118. // m: IF(MONTH(FieldName)=1,1,0))

    3119. 

  3119. // - PostgreSql

    3120. 

  3120. // y: IF(EXTRACT(YEAR FROM FieldName)=1996,1,0))

    3121. 

  3121. // q: IF(EXTRACT(QUARTER FROM FieldName)=1,1,0))

    3122. 

  3122. // m: IF(EXTRACT(MONTH FROM FieldName)=1,1,0))

    3123. 

  3123. function ewrpt_SQLDistinctFactor($sFld, $dateType, $val, $qc) {

    3124. 

  3124. 

    3125. 

  3125. 	// ACCESS

    3126. 

  3126. 	if (EWRPT_IS_MSACCESS) {

    3127. 

  3127. 		if ($dateType == "y" && is_numeric($val)) {

    3128. 

  3128. 			return "IIf(Year(" . $sFld . ")=" . $val . ",1,0)";

    3129. 

  3129. 		} elseif (($dateType == "q" || $dateType == "m") && is_numeric($val)) {

    3130. 

  3130. 			return "IIf(DatePart(\"" . $dateType . "\"," . $sFld . ")=" . $val . ",1,0)";

    3131. 

  3131. 		} else {

    3132. 

  3132. 			if ($val == "NULL")

    3133. 

  3133. 				return "IIf(" . $sFld . " IS NULL,1,0)";

    3134. 

  3134. 			else

    3135. 

  3135. 				return "IIf(" . $sFld . "=" . $qc . ewrpt_AdjustSql($val) . $qc . ",1,0)";

    3136. 

  3136. 		}

    3137. 

  3137. 

    3138. 

  3138. 	// MS SQL

    3139. 

  3139. 	} elseif (EWRPT_IS_MSSQL) {

    3140. 

  3140. 		if ($dateType == "y" && is_numeric($val)) {

    3141. 

  3141. 			return "(1-ABS(SIGN(Year(" . $sFld . ")-" . $val . ")))";

    3142. 

  3142. 		} elseif (($dateType == "q" || $dateType == "m") && is_numeric($val)) {

    3143. 

  3143. 			return "(1-ABS(SIGN(DatePart(" . $dateType . "," . $sFld . ")-" . $val . ")))";

    3144. 

  3144. 		} elseif ($dateType == "d") {

    3145. 

  3145. 			return "(CASE CONVERT(VARCHAR(10)," . $sFld . ",120) WHEN " . $qc . ewrpt_AdjustSql($val) . $qc . " THEN 1 ELSE 0 END)";

    3146. 

  3146. 		} elseif ($dateType == "dt") {

    3147. 

  3147. 			return "(CASE CONVERT(VARCHAR," . $sFld . ",120) WHEN " . $qc . ewrpt_AdjustSql($val) . $qc . " THEN 1 ELSE 0 END)";

    3148. 

  3148. 		} else {

    3149. 

  3149. 			if ($val == "NULL")

    3150. 

  3150. 				return "(CASE WHEN " . $sFld . " IS NULL THEN 1 ELSE 0 END)";

    3151. 

  3151. 			else

    3152. 

  3152. 				return "(CASE " . $sFld . " WHEN " . $qc . ewrpt_AdjustSql($val) . $qc . " THEN 1 ELSE 0 END)";

    3153. 

  3153. 		}

    3154. 

  3154. 

    3155. 

  3155. 	// MySQL

    3156. 

  3156. 	} elseif (EWRPT_IS_MYSQL) {

    3157. 

  3157. 		if ($dateType == "y" && is_numeric($val)) {

    3158. 

  3158. 			return "IF(YEAR(" . $sFld . ")=" . $val . ",1,0)";

    3159. 

  3159. 		} elseif ($dateType == "q" && is_numeric($val)) {

    3160. 

  3160. 			return "IF(QUARTER(" . $sFld . ")=" . $val . ",1,0)";

    3161. 

  3161. 		} elseif ($dateType == "m" && is_numeric($val)) {

    3162. 

  3162. 			return "IF(MONTH(" . $sFld . ")=" . $val . ",1,0)";

    3163. 

  3163. 		} else {

    3164. 

  3164. 			if ($val == "NULL") {

    3165. 

  3165. 				return "IF(" . $sFld . " IS NULL,1,0)";

    3166. 

  3166. 			} else {

    3167. 

  3167. 				return "IF(" . $sFld . "=" . $qc . ewrpt_AdjustSql($val) . $qc . ",1,0)";

    3168. 

  3168. 			}

    3169. 

  3169. 		}

    3170. 

  3170. 

    3171. 

  3171. 	// PostgreSql

    3172. 

  3172. 	} elseif (EWRPT_IS_POSTGRESQL) {

    3173. 

  3173. 		if ($dateType == "y" && is_numeric($val)) {

    3174. 

  3174. 			return "CASE WHEN TO_CHAR(" . $sFld . ",'YYYY')='" . $val . "' THEN 1 ELSE 0 END";

    3175. 

  3175. 		} elseif ($dateType == "q" && is_numeric($val)) {

    3176. 

  3176. 			return "CASE WHEN TO_CHAR(" . $sFld . ",'Q')='" . $val . "' THEN 1 ELSE 0 END";

    3177. 

  3177. 		} elseif ($dateType == "m" && is_numeric($val)) {

    3178. 

  3178. 			return "CASE WHEN TO_CHAR(" . $sFld . ",'MM')=LPAD('" . $val . "',2,'0') THEN 1 ELSE 0 END";

    3179. 

  3179. 		} else {

    3180. 

  3180. 			if ($val == "NULL") {

    3181. 

  3181. 				return "CASE WHEN " . $sFld . " IS NULL THEN 1 ELSE 0 END";

    3182. 

  3182. 			} else {

    3183. 

  3183. 				return "CASE WHEN " . $sFld . "=" . $qc . ewrpt_AdjustSql($val) . $qc . " THEN 1 ELSE 0 END";

    3184. 

  3184. 			}

    3185. 

  3185. 		}

    3186. 

  3186. 

    3187. 

  3187. 	// Oracle

    3188. 

  3188. 	} elseif (EWRPT_IS_ORACLE || EWRPT_IS_POSTGRESQL) {

    3189. 

  3189. 		if ($dateType == "y" && is_numeric($val)) {

    3190. 

  3190. 			return "DECODE(TO_CHAR(" . $sFld . ",'YYYY'),'" . $val . "',1,0)";

    3191. 

  3191. 		} elseif ($dateType == "q" && is_numeric($val)) {

    3192. 

  3192. 			return "DECODE(TO_CHAR(" . $sFld . ",'Q'),'" . $val . "',1,0)";

    3193. 

  3193. 		} elseif ($dateType == "m" && is_numeric($val)) {

    3194. 

  3194. 			return "DECODE(TO_CHAR(" . $sFld . ",'MM'),LPAD('" . $val . "',2,'0'),1,0)";

    3195. 

  3195. 		} elseif ($dateType == "d") {

    3196. 

  3196. 			return "DECODE(" . $sFld . ",TO_DATE(" . $qc . ewrpt_AdjustSql($val) . $qc . ",'YYYY/MM/DD'),1,0)";

    3197. 

  3197. 		} elseif ($dateType == "dt") {

    3198. 

  3198. 			return "DECODE(" . $sFld . ",TO_DATE(" . $qc . ewrpt_AdjustSql($val) . $qc . ",'YYYY/MM/DD HH24:MI:SS'),1,0)";

    3199. 

  3199. 		} else {

    3200. 

  3200. 			if ($val == "NULL") {

    3201. 

  3201. 				return "(CASE WHEN " . $sFld . " IS NULL THEN 1 ELSE 0 END)";

    3202. 

  3202. 			} else {

    3203. 

  3203. 				return "DECODE(" . $sFld . "," . $qc . ewrpt_AdjustSql($val) . $qc . ",1,0)";

    3204. 

  3204. 			}

    3205. 

  3205. 		}

    3206. 

  3206. 	}

    3207. 

  3207. }

    3208. 

  3208. 

    3209. 

  3209. // Evaluate summary value

    3210. 

  3210. function ewrpt_SummaryValue($val1, $val2, $ityp) {

    3211. 

  3211. 	switch ($ityp) {

    3212. 

  3212. 	case "SUM":

    3213. 

  3213. 	case "COUNT":

    3214. 

  3214. 	case "AVG":

    3215. 

  3215. 		if (is_null($val2) || !is_numeric($val2)) {

    3216. 

  3216. 			return $val1;

    3217. 

  3217. 		} else {

    3218. 

  3218. 			return ($val1 + $val2);

    3219. 

  3219. 		}

    3220. 

  3220. 	case "MIN":

    3221. 

  3221. 		if (is_null($val2) || !is_numeric($val2)) {

    3222. 

  3222. 			return $val1; // Skip null and non-numeric

    3223. 

  3223. 		} elseif (is_null($val1)) {

    3224. 

  3224. 			return $val2; // Initialize for first valid value

    3225. 

  3225. 		} elseif ($val1 < $val2) {

    3226. 

  3226. 			return $val1;

    3227. 

  3227. 		} else {

    3228. 

  3228. 			return $val2;

    3229. 

  3229. 		}

    3230. 

  3230. 	case "MAX":

    3231. 

  3231. 		if (is_null($val2) || !is_numeric($val2)) {

    3232. 

  3232. 			return $val1; // Skip null and non-numeric

    3233. 

  3233. 		} elseif (is_null($val1)) {

    3234. 

  3234. 			return $val2; // Initialize for first valid value

    3235. 

  3235. 		} elseif ($val1 > $val2) {

    3236. 

  3236. 			return $val1;

    3237. 

  3237. 		} else {

    3238. 

  3238. 			return $val2;

    3239. 

  3239. 		}

    3240. 

  3240. 	}

    3241. 

  3241. }

    3242. 

  3242. 

    3243. 

  3243. // Match filter value

    3244. 

  3244. function ewrpt_MatchedFilterValue($ar, $value) {

    3245. 

  3245. 	if (!is_array($ar)) {

    3246. 

  3246. 		return (strval($ar) == strval($value));

    3247. 

  3247. 	} else {

    3248. 

  3248. 		foreach ($ar as $val) {

    3249. 

  3249. 			if (strval($val) == strval($value))

    3250. 

  3250. 				return TRUE;

    3251. 

  3251. 		}

    3252. 

  3252. 		return FALSE;

    3253. 

  3253. 	}

    3254. 

  3254. }

    3255. 

  3255. 

    3256. 

  3256. // Render repeat column table

    3257. 

  3257. // rowcnt - zero based row count

    3258. 

  3258. function ewrpt_RepeatColumnTable($totcnt, $rowcnt, $repeatcnt, $rendertype) {

    3259. 

  3259. 	$sWrk = "";

    3260. 

  3260. 	if ($rendertype == 1) { // Render control start

    3261. 

  3261. 		if ($rowcnt == 0) $sWrk .= "<table class=\"" . EWRPT_ITEM_TABLE_CLASSNAME . "\">";

    3262. 

  3262. 		if ($rowcnt % $repeatcnt == 0) $sWrk .= "<tr>";

    3263. 

  3263. 		$sWrk .= "<td>";

    3264. 

  3264. 	} elseif ($rendertype == 2) { // Render control end

    3265. 

  3265. 		$sWrk .= "</td>";

    3266. 

  3266. 		if ($rowcnt % $repeatcnt == $repeatcnt - 1) {

    3267. 

  3267. 			$sWrk .= "</tr>";

    3268. 

  3268. 		} elseif ($rowcnt == $totcnt - 1) {

    3269. 

  3269. 			for ($i = ($rowcnt % $repeatcnt) + 1; $i < $repeatcnt; $i++) {

    3270. 

  3270. 				$sWrk .= "<td>&nbsp;</td>";

    3271. 

  3271. 			}

    3272. 

  3272. 			$sWrk .= "</tr>";

    3273. 

  3273. 		}

    3274. 

  3274. 		if ($rowcnt == $totcnt - 1) $sWrk .= "</table>";

    3275. 

  3275. 	}

    3276. 

  3276. 	return $sWrk;

    3277. 

  3277. }

    3278. 

  3278. 

    3279. 

  3279. // Check if the value is selected

    3280. 

  3280. function ewrpt_IsSelectedValue(&$ar, $value, $ft) {

    3281. 

  3281. 	if (!is_array($ar))

    3282. 

  3282. 		return TRUE;

    3283. 

  3283. 	$af = (substr($value, 0, 2) == "@@");

    3284. 

  3284. 	foreach ($ar as $val) {

    3285. 

  3285. 		if ($af || substr($val, 0, 2) == "@@") { // Advanced filters

    3286. 

  3286. 			if ($val == $value)

    3287. 

  3287. 				return TRUE;

    3288. 

  3288. 		} else {

    3289. 

  3289. 			if (ewrpt_CompareValue($val, $value, $ft))

    3290. 

  3290. 				return TRUE;

    3291. 

  3291. 		}

    3292. 

  3292. 	}

    3293. 

  3293. 	return FALSE;

    3294. 

  3294. }

    3295. 

  3295. 

    3296. 

  3296. // Set up distinct values

    3297. 

  3297. // ar: array for distinct values

    3298. 

  3298. // val: value

    3299. 

  3299. // label: display value

    3300. 

  3300. // dup: check duplicate

    3301. 

  3301. function ewrpt_SetupDistinctValues(&$ar, $val, $label, $dup) {

    3302. 

  3302. 	$isarray = is_array($ar);

    3303. 

  3303. 	if ($dup && $isarray && in_array($val, array_keys($ar)))

    3304. 

  3304. 		return;

    3305. 

  3305. 	if (!$isarray) {

    3306. 

  3306. 		$ar = array($val => $label);

    3307. 

  3307. 	} elseif ($val == EWRPT_EMPTY_VALUE || $val == EWRPT_NULL_VALUE) { // Null/Empty

    3308. 

  3308. 		$ar = array_reverse($ar, TRUE);

    3309. 

  3309. 		$ar[$val] = $label; // Insert at top

    3310. 

  3310. 		$ar = array_reverse($ar, TRUE);

    3311. 

  3311. 	} else {

    3312. 

  3312. 		$ar[$val] = $label; // Default insert at end

    3313. 

  3313. 	}

    3314. 

  3314. }

    3315. 

  3315. 

    3316. 

  3316. // Compare values based on field type

    3317. 

  3317. function ewrpt_CompareValue($v1, $v2, $ft) {

    3318. 

  3318. 	switch ($ft) {

    3319. 

  3319. 

    3320. 

  3320. 	// Case adBigInt, adInteger, adSmallInt, adTinyInt, adUnsignedTinyInt, adUnsignedSmallInt, adUnsignedInt, adUnsignedBigInt

    3321. 

  3321. 	case 20:

    3322. 

  3322. 	case 3:

    3323. 

  3323. 	case 2:

    3324. 

  3324. 	case 16:

    3325. 

  3325. 	case 17:

    3326. 

  3326. 	case 18:

    3327. 

  3327. 	case 19:

    3328. 

  3328. 	case 21:

    3329. 

  3329. 		if (is_numeric($v1) && is_numeric($v2)) {

    3330. 

  3330. 			return (intval($v1) == intval($v2));

    3331. 

  3331. 		}

    3332. 

  3332. 		break;

    3333. 

  3333. 

    3334. 

  3334. 	// Case adSingle, adDouble, adNumeric, adCurrency

    3335. 

  3335. 	case 4:

    3336. 

  3336. 	case 5:

    3337. 

  3337. 	case 131:

    3338. 

  3338. 	case 6:

    3339. 

  3339. 		if (is_numeric($v1) && is_numeric($v2)) {

    3340. 

  3340. 			return ((float)$v1 == (float)$v2);

    3341. 

  3341. 		}

    3342. 

  3342. 		break;

    3343. 

  3343. 

    3344. 

  3344. 	//	Case adDate, adDBDate, adDBTime, adDBTimeStamp

    3345. 

  3345. 	case 7:

    3346. 

  3346. 	case 133:

    3347. 

  3347. 	case 134:

    3348. 

  3348. 	case 135:

    3349. 

  3349. 		if (is_numeric(strtotime($v1)) && is_numeric(strtotime($v2))) {

    3350. 

  3350. 			return (strtotime($v1) == strtotime($v2));

    3351. 

  3351. 		}

    3352. 

  3352. 		break;

    3353. 

  3353. 	default:

    3354. 

  3354. 		return (strcmp($v1, $v2) == 0); // treat as string

    3355. 

  3355. 	}

    3356. 

  3356. }

    3357. 

  3357. 

    3358. 

  3358. // Register custom filter (retained for backward compatibility)

    3359. 

  3359. function ewrpt_RegisterCustomFilter(&$fld, $ID, $Name, $FunctionName) {

    3360. 

  3360. 	ewrpt_RegisterFilter($fld, $ID, $Name, $FunctionName);

    3361. 

  3361. }

    3362. 

  3362. 

    3363. 

  3363. // Register filter

    3364. 

  3364. function ewrpt_RegisterFilter(&$fld, $ID, $Name, $FunctionName) {

    3365. 

  3365. 	if (!is_array($fld->AdvancedFilters))

    3366. 

  3366. 		$fld->AdvancedFilters = array();

    3367. 

  3367. 	$wrkid = (substr($ID,0,2) == "@@") ? $ID : "@@" . $ID;

    3368. 

  3368. 	$key = substr($wrkid,2);

    3369. 

  3369. 	$fld->AdvancedFilters[$key] = new crAdvancedFilter($wrkid, $Name, $FunctionName);

    3370. 

  3370. }

    3371. 

  3371. 

    3372. 

  3372. function ewrpt_UnregisterFilter(&$fld, $ID) {

    3373. 

  3373. 	if (is_array($fld->AdvancedFilters)) {

    3374. 

  3374. 		$wrkid = (substr($ID,0,2) == "@@") ? $ID : "@@" . $ID;

    3375. 

  3375. 		$key = substr($wrkid,2);

    3376. 

  3376. 		foreach ($fld->AdvancedFilters as $filter) {

    3377. 

  3377. 			if ($filter->ID == $wrkid) {

    3378. 

  3378. 				unset($fld->AdvancedFilters[$key]);

    3379. 

  3379. 				break;

    3380. 

  3380. 			}

    3381. 

  3381. 		}

    3382. 

  3382. 	}

    3383. 

  3383. }

    3384. 

  3384. 

    3385. 

  3385. // Get custom filter

    3386. 

  3386. function ewrpt_GetCustomFilter(&$fld, $FldVal) {

    3387. 

  3387. 	$sWrk = "";

    3388. 

  3388. 	if (is_array($fld->AdvancedFilters)) {

    3389. 

  3389. 		foreach ($fld->AdvancedFilters as $filter) {

    3390. 

  3390. 			if ($filter->ID == $FldVal && $filter->Enabled) {

    3391. 

  3391. 				$sFld = $fld->FldExpression;

    3392. 

  3392. 				$sFn = $filter->FunctionName;

    3393. 

  3393. 				$sWrk = $sFn($sFld);

    3394. 

  3394. 				break;

    3395. 

  3395. 			}

    3396. 

  3396. 		}

    3397. 

  3397. 	}

    3398. 

  3398. 	return $sWrk;

    3399. 

  3399. }

    3400. 

  3400. 

    3401. 

  3401. // Return date value

    3402. 

  3402. function ewrpt_DateVal($FldOpr, $FldVal, $ValType) {

    3403. 

  3403. 

    3404. 

  3404. 	// Compose date string

    3405. 

  3405. 	switch (strtolower($FldOpr)) {

    3406. 

  3406. 	case "year":

    3407. 

  3407. 		if ($ValType == 1) {

    3408. 

  3408. 			$wrkVal = "$FldVal-01-01";

    3409. 

  3409. 		} elseif ($ValType == 2) {

    3410. 

  3410. 			$wrkVal = "$FldVal-12-31";

    3411. 

  3411. 		}

    3412. 

  3412. 		break;

    3413. 

  3413. 	case "quarter":

    3414. 

  3414. 		list($y, $q) = explode("|", $FldVal);

    3415. 

  3415. 		if (intval($y) == 0 || intval($q) == 0) {

    3416. 

  3416. 			$wrkVal = "0000-00-00";

    3417. 

  3417. 		} else {

    3418. 

  3418. 			if ($ValType == 1) {

    3419. 

  3419. 				$m = ($q - 1) * 3 + 1;

    3420. 

  3420. 				$m = str_pad($m, 2, "0", STR_PAD_LEFT);

    3421. 

  3421. 				$wrkVal = "$y-$m-01";

    3422. 

  3422. 			} elseif ($ValType == 2) {

    3423. 

  3423. 				$m = ($q - 1) * 3 + 3;

    3424. 

  3424. 				$m = str_pad($m, 2, "0", STR_PAD_LEFT);

    3425. 

  3425. 				$wrkVal = "$y-$m-" . ewrpt_DaysInMonth($y, $m);

    3426. 

  3426. 			}

    3427. 

  3427. 		}

    3428. 

  3428. 		break;

    3429. 

  3429. 	case "month":

    3430. 

  3430. 		list($y, $m) = explode("|", $FldVal);

    3431. 

  3431. 		if (intval($y) == 0 || intval($m) == 0) {

    3432. 

  3432. 			$wrkVal = "0000-00-00";

    3433. 

  3433. 		} else {

    3434. 

  3434. 			if ($ValType == 1) {

    3435. 

  3435. 				$m = str_pad($m, 2, "0", STR_PAD_LEFT);

    3436. 

  3436. 				$wrkVal = "$y-$m-01";

    3437. 

  3437. 			} elseif ($ValType == 2) {

    3438. 

  3438. 				$m = str_pad($m, 2, "0", STR_PAD_LEFT);

    3439. 

  3439. 				$wrkVal = "$y-$m-" . ewrpt_DaysInMonth($y, $m);

    3440. 

  3440. 			}

    3441. 

  3441. 		}

    3442. 

  3442. 		break;

    3443. 

  3443. 	case "day":

    3444. 

  3444. 		$wrkVal = str_replace("|", "-", $FldVal);

    3445. 

  3445. 	}

    3446. 

  3446. 

    3447. 

  3447. 	// Add time if necessary

    3448. 

  3448. 	if (preg_match('/(\d{4}|\d{2})-(\d{1,2})-(\d{1,2})/', $wrkVal)) { // date without time

    3449. 

  3449. 		if ($ValType == 1) {

    3450. 

  3450. 			$wrkVal .= " 00:00:00";

    3451. 

  3451. 		} elseif ($ValType == 2) {

    3452. 

  3452. 			$wrkVal .= " 23:59:59";

    3453. 

  3453. 		}

    3454. 

  3454. 	}

    3455. 

  3455. 

    3456. 

  3456. 	// Check if datetime

    3457. 

  3457. 	if (preg_match('/(\d{4}|\d{2})-(\d{1,2})-(\d{1,2}) (\d{1,2}):(\d{1,2}):(\d{1,2})/', $wrkVal)) { // datetime

    3458. 

  3458. 		$DateVal = $wrkVal;

    3459. 

  3459. 	} else {

    3460. 

  3460. 		$DateVal = "";

    3461. 

  3461. 	}

    3462. 

  3462. 	return $DateVal;

    3463. 

  3463. }

    3464. 

  3464. 

    3465. 

  3465. // "Past"

    3466. 

  3466. function ewrpt_IsPast($FldExpression) {

    3467. 

  3467. 	return ("($FldExpression < '" . date("Y-m-d H:i:s") . "')");

    3468. 

  3468. }

    3469. 

  3469. 

    3470. 

  3470. // "Future";

    3471. 

  3471. function ewrpt_IsFuture($FldExpression) {

    3472. 

  3472. 	return ("($FldExpression > '" . date("Y-m-d H:i:s") . "')");

    3473. 

  3473. }

    3474. 

  3474. 

    3475. 

  3475. // "Last 30 days"

    3476. 

  3476. function ewrpt_IsLast30Days($FldExpression) {

    3477. 

  3477. 	$dt1 = date("Y-m-d", strtotime("-29 days"));

    3478. 

  3478. 	$dt2 = date("Y-m-d", strtotime("+1 days"));

    3479. 

  3479. 	return ("($FldExpression >= '$dt1' AND $FldExpression < '$dt2')");

    3480. 

  3480. }

    3481. 

  3481. 

    3482. 

  3482. // "Last 14 days"

    3483. 

  3483. function ewrpt_IsLast14Days($FldExpression) {

    3484. 

  3484. 	$dt1 = date("Y-m-d", strtotime("-13 days"));

    3485. 

  3485. 	$dt2 = date("Y-m-d", strtotime("+1 days"));

    3486. 

  3486. 	return ("($FldExpression >= '$dt1' AND $FldExpression < '$dt2')");

    3487. 

  3487. }

    3488. 

  3488. 

    3489. 

  3489. // "Last 7 days"

    3490. 

  3490. function ewrpt_IsLast7Days($FldExpression) {

    3491. 

  3491. 	$dt1 = date("Y-m-d", strtotime("-6 days"));

    3492. 

  3492. 	$dt2 = date("Y-m-d", strtotime("+1 days"));

    3493. 

  3493. 	return ("($FldExpression >= '$dt1' AND $FldExpression < '$dt2')");

    3494. 

  3494. }

    3495. 

  3495. 

    3496. 

  3496. // "Next 30 days"

    3497. 

  3497. function ewrpt_IsNext30Days($FldExpression) {

    3498. 

  3498. 	$dt1 = date("Y-m-d");

    3499. 

  3499. 	$dt2 = date("Y-m-d", strtotime("+30 days"));

    3500. 

  3500. 	return ("($FldExpression >= '$dt1' AND $FldExpression < '$dt2')");

    3501. 

  3501. }

    3502. 

  3502. 

    3503. 

  3503. // "Next 14 days"

    3504. 

  3504. function ewrpt_IsNext14Days($FldExpression) {

    3505. 

  3505. 	$dt1 = date("Y-m-d");

    3506. 

  3506. 	$dt2 = date("Y-m-d", strtotime("+14 days"));

    3507. 

  3507. 	return ("($FldExpression >= '$dt1' AND $FldExpression < '$dt2')");

    3508. 

  3508. }

    3509. 

  3509. 

    3510. 

  3510. // "Next 7 days"

    3511. 

  3511. function ewrpt_IsNext7Days($FldExpression) {

    3512. 

  3512. 	$dt1 = date("Y-m-d");

    3513. 

  3513. 	$dt2 = date("Y-m-d", strtotime("+7 days"));

    3514. 

  3514. 	return ("($FldExpression >= '$dt1' AND $FldExpression < '$dt2')");

    3515. 

  3515. }

    3516. 

  3516. 

    3517. 

  3517. // "Yesterday"

    3518. 

  3518. function ewrpt_IsYesterday($FldExpression) {

    3519. 

  3519. 	$dt1 = date("Y-m-d", strtotime("-1 days"));

    3520. 

  3520. 	$dt2 = date("Y-m-d");

    3521. 

  3521. 	return ("($FldExpression >= '$dt1' AND $FldExpression < '$dt2')");

    3522. 

  3522. }

    3523. 

  3523. 

    3524. 

  3524. // "Today"

    3525. 

  3525. function ewrpt_IsToday($FldExpression) {

    3526. 

  3526. 	$dt1 = date("Y-m-d");

    3527. 

  3527. 	$dt2 = date("Y-m-d", strtotime("+1 days"));

    3528. 

  3528. 	return ("($FldExpression >= '$dt1' AND $FldExpression < '$dt2')");

    3529. 

  3529. }

    3530. 

  3530. 

    3531. 

  3531. // "Tomorrow"

    3532. 

  3532. function ewrpt_IsTomorrow($FldExpression) {

    3533. 

  3533. 	$dt1 = date("Y-m-d", strtotime("+1 days"));

    3534. 

  3534. 	$dt2 = date("Y-m-d", strtotime("+2 days"));

    3535. 

  3535. 	return ("($FldExpression >= '$dt1' AND $FldExpression < '$dt2')");

    3536. 

  3536. }

    3537. 

  3537. 

    3538. 

  3538. // "Last month"

    3539. 

  3539. function ewrpt_IsLastMonth($FldExpression) {

    3540. 

  3540. 	$dt1 = date("Y-m", strtotime("-1 months")) . "-01";

    3541. 

  3541. 	$dt2 = date("Y-m") . "-01";

    3542. 

  3542. 	return ("($FldExpression >= '$dt1' AND $FldExpression < '$dt2')");

    3543. 

  3543. }

    3544. 

  3544. 

    3545. 

  3545. // "This month"

    3546. 

  3546. function ewrpt_IsThisMonth($FldExpression) {

    3547. 

  3547. 	$dt1 = date("Y-m") . "-01";

    3548. 

  3548. 	$dt2 = date("Y-m", strtotime("+1 months")) . "-01";

    3549. 

  3549. 	return ("($FldExpression >= '$dt1' AND $FldExpression < '$dt2')");

    3550. 

  3550. }

    3551. 

  3551. 

    3552. 

  3552. // "Next month"

    3553. 

  3553. function ewrpt_IsNextMonth($FldExpression) {

    3554. 

  3554. 	$dt1 = date("Y-m", strtotime("+1 months")) . "-01";

    3555. 

  3555. 	$dt2 = date("Y-m", strtotime("+2 months")) . "-01";

    3556. 

  3556. 	return ("($FldExpression >= '$dt1' AND $FldExpression < '$dt2')");

    3557. 

  3557. }

    3558. 

  3558. 

    3559. 

  3559. // "Last two weeks"

    3560. 

  3560. function ewrpt_IsLast2Weeks($FldExpression) {

    3561. 

  3561. 	if (strtotime("this Sunday") == strtotime("today")) {

    3562. 

  3562. 		$dt1 = date("Y-m-d", strtotime("-14 days this Sunday"));

    3563. 

  3563. 		$dt2 = date("Y-m-d", strtotime("this Sunday"));

    3564. 

  3564. 	} else {

    3565. 

  3565. 		$dt1 = date("Y-m-d", strtotime("-14 days last Sunday"));

    3566. 

  3566. 		$dt2 = date("Y-m-d", strtotime("last Sunday"));

    3567. 

  3567. 	}

    3568. 

  3568. 	return ("($FldExpression >= '$dt1' AND $FldExpression < '$dt2')");

    3569. 

  3569. }

    3570. 

  3570. 

    3571. 

  3571. // "Last week"

    3572. 

  3572. function ewrpt_IsLastWeek($FldExpression) {

    3573. 

  3573. 	if (strtotime("this Sunday") == strtotime("today")) {

    3574. 

  3574. 		$dt1 = date("Y-m-d", strtotime("-7 days this Sunday"));

    3575. 

  3575. 		$dt2 = date("Y-m-d", strtotime("this Sunday"));

    3576. 

  3576. 	} else {

    3577. 

  3577. 		$dt1 = date("Y-m-d", strtotime("-7 days last Sunday"));

    3578. 

  3578. 		$dt2 = date("Y-m-d", strtotime("last Sunday"));

    3579. 

  3579. 	}

    3580. 

  3580. 	return ("($FldExpression >= '$dt1' AND $FldExpression < '$dt2')");

    3581. 

  3581. }

    3582. 

  3582. 

    3583. 

  3583. // "This week"

    3584. 

  3584. function ewrpt_IsThisWeek($FldExpression) {

    3585. 

  3585. 	if (strtotime("this Sunday") == strtotime("today")) {

    3586. 

  3586. 		$dt1 = date("Y-m-d", strtotime("this Sunday"));

    3587. 

  3587. 		$dt2 = date("Y-m-d", strtotime("+7 days this Sunday"));

    3588. 

  3588. 	} else {

    3589. 

  3589. 		$dt1 = date("Y-m-d", strtotime("last Sunday"));

    3590. 

  3590. 		$dt2 = date("Y-m-d", strtotime("+7 days last Sunday"));

    3591. 

  3591. 	}

    3592. 

  3592. 	return ("($FldExpression >= '$dt1' AND $FldExpression < '$dt2')");

    3593. 

  3593. }

    3594. 

  3594. 

    3595. 

  3595. // "Next week"

    3596. 

  3596. function ewrpt_IsNextWeek($FldExpression) {

    3597. 

  3597. 	if (strtotime("this Sunday") == strtotime("today")) {

    3598. 

  3598. 		$dt1 = date("Y-m-d", strtotime("+7 days this Sunday"));

    3599. 

  3599. 		$dt2 = date("Y-m-d", strtotime("+14 days this Sunday"));

    3600. 

  3600. 	} else {

    3601. 

  3601. 		$dt1 = date("Y-m-d", strtotime("+7 days last Sunday"));

    3602. 

  3602. 		$dt2 = date("Y-m-d", strtotime("+14 days last Sunday"));

    3603. 

  3603. 	}

    3604. 

  3604. 	return ("($FldExpression >= '$dt1' AND $FldExpression < '$dt2')");

    3605. 

  3605. }

    3606. 

  3606. 

    3607. 

  3607. // "Next two week"

    3608. 

  3608. function ewrpt_IsNext2Weeks($FldExpression) {

    3609. 

  3609. 	if (strtotime("this Sunday") == strtotime("today")) {

    3610. 

  3610. 		$dt1 = date("Y-m-d", strtotime("+7 days this Sunday"));

    3611. 

  3611. 		$dt2 = date("Y-m-d", strtotime("+21 days this Sunday"));

    3612. 

  3612. 	} else {

    3613. 

  3613. 		$dt1 = date("Y-m-d", strtotime("+7 days last Sunday"));

    3614. 

  3614. 		$dt2 = date("Y-m-d", strtotime("+21 days last Sunday"));

    3615. 

  3615. 	}

    3616. 

  3616. 	return ("($FldExpression >= '$dt1' AND $FldExpression < '$dt2')");

    3617. 

  3617. }

    3618. 

  3618. 

    3619. 

  3619. // "Last year"

    3620. 

  3620. function ewrpt_IsLastYear($FldExpression) {

    3621. 

  3621. 	$dt1 = date("Y", strtotime("-1 years")) . "-01-01";

    3622. 

  3622. 	$dt2 = date("Y") . "-01-01";

    3623. 

  3623. 	return ("($FldExpression >= '$dt1' AND $FldExpression < '$dt2')");

    3624. 

  3624. }

    3625. 

  3625. 

    3626. 

  3626. // "This year"

    3627. 

  3627. function ewrpt_IsThisYear($FldExpression) {

    3628. 

  3628. 	$dt1 = date("Y") . "-01-01";

    3629. 

  3629. 	$dt2 = date("Y", strtotime("+1 years")) . "-01-01";

    3630. 

  3630. 	return ("($FldExpression >= '$dt1' AND $FldExpression < '$dt2')");

    3631. 

  3631. }

    3632. 

  3632. 

    3633. 

  3633. // "Next year"

    3634. 

  3634. function ewrpt_IsNextYear($FldExpression) {

    3635. 

  3635. 	$dt1 = date("Y", strtotime("+1 years")) . "-01-01";

    3636. 

  3636. 	$dt2 = date("Y", strtotime("+2 years")) . "-01-01";

    3637. 

  3637. 	return ("($FldExpression >= '$dt1' AND $FldExpression < '$dt2')");

    3638. 

  3638. }

    3639. 

  3639. 

    3640. 

  3640. // "Next year"

    3641. 

  3641. function ewrpt_DaysInMonth($y, $m) {

    3642. 

  3642. 	if (in_array($m, array(1, 3, 5, 7, 8, 10, 12))) {

    3643. 

  3643. 		return 31;

    3644. 

  3644. 	} elseif (in_array($m, array(4, 6, 9, 11))) {

    3645. 

  3645. 		return 30;

    3646. 

  3646. 	} elseif ($m == 2) {

    3647. 

  3647. 		return ($y % 4 == 0) ? 29 : 28;

    3648. 

  3648. 	}

    3649. 

  3649. 	return 0;

    3650. 

  3650. }

    3651. 

  3651. 

    3652. 

  3652. // Function to calculate date difference

    3653. 

  3653. function ewrpt_DateDiff($dateTimeBegin, $dateTimeEnd, $interval = "d") {

    3654. 

  3654. 	$dateTimeBegin = strtotime($dateTimeBegin);

    3655. 

  3655. 	if ($dateTimeBegin === -1 || $dateTimeBegin === FALSE)

    3656. 

  3656. 		return FALSE;

    3657. 

  3657. 	$dateTimeEnd = strtotime($dateTimeEnd);

    3658. 

  3658. 	if($dateTimeEnd === -1 || $dateTimeEnd === FALSE)

    3659. 

  3659. 		return FALSE;

    3660. 

  3660. 	$dif = $dateTimeEnd - $dateTimeBegin;	

    3661. 

  3661. 	$arBegin = getdate($dateTimeBegin);

    3662. 

  3662. 	$dateBegin = mktime(0, 0, 0, $arBegin["mon"], $arBegin["mday"], $arBegin["year"]);

    3663. 

  3663. 	$arEnd = getdate($dateTimeEnd);

    3664. 

  3664. 	$dateEnd = mktime(0, 0, 0, $arEnd["mon"], $arEnd["mday"], $arEnd["year"]);

    3665. 

  3665. 	$difDate = $dateEnd - $dateBegin;

    3666. 

  3666. 	switch ($interval) {

    3667. 

  3667. 		case "s": // seconds

    3668. 

  3668. 			return $dif;

    3669. 

  3669. 		case "n": // minutes

    3670. 

  3670. 			return ($dif > 0) ? floor($dif/60) : ceil($dif/60);

    3671. 

  3671. 		case "h": // hours

    3672. 

  3672. 			return ($dif > 0) ? floor($dif/3600) : ceil($dif/3600);

    3673. 

  3673. 		case "d": // days

    3674. 

  3674. 			return ($difDate > 0) ? floor($difDate/86400) : ceil($difDate/86400);

    3675. 

  3675. 		case "w": // weeks

    3676. 

  3676. 			return ($difDate > 0) ? floor($difDate/604800) : ceil($difDate/604800);

    3677. 

  3677. 		case "ww": // calendar weeks

    3678. 

  3678. 			$difWeek = (($dateEnd - $arEnd["wday"]*86400) - ($dateBegin - $arBegin["wday"]*86400))/604800;

    3679. 

  3679. 			return ($difWeek > 0) ? floor($difWeek) : ceil($difWeek);

    3680. 

  3680. 		case "m": // months

    3681. 

  3681. 			return (($arEnd["year"]*12 + $arEnd["mon"]) -	($arBegin["year"]*12 + $arBegin["mon"]));

    3682. 

  3682. 		case "yyyy": // years

    3683. 

  3683. 			return ($arEnd["year"] - $arBegin["year"]);

    3684. 

  3684. 	}

    3685. 

  3685. }

    3686. 

  3686. 

    3687. 

  3687. // Set up distinct values from ext. filter

    3688. 

  3688. function ewrpt_SetupDistinctValuesFromFilter(&$ar, $af) {

    3689. 

  3689. 	if (is_array($af)) {

    3690. 

  3690. 		foreach ($af as $filter) {

    3691. 

  3691. 			if ($filter->Enabled)

    3692. 

  3692. 				ewrpt_SetupDistinctValues($ar, $filter->ID, $filter->Name, FALSE);

    3693. 

  3693. 		}

    3694. 

  3694. 	}

    3695. 

  3695. }

    3696. 

  3696. 

    3697. 

  3697. // Get group value

    3698. 

  3698. // - Get the group value based on field type, group type and interval

    3699. 

  3699. // - ft: field type

    3700. 

  3700. // * 1: numeric, 2: date, 3: string

    3701. 

  3701. // - gt: group type

    3702. 

  3702. // * numeric: i = interval, n = normal

    3703. 

  3703. // * date: d = Day, w = Week, m = Month, q = Quarter, y = Year

    3704. 

  3704. // * string: f = first nth character, n = normal

    3705. 

  3705. // - intv: interval

    3706. 

  3706. function ewrpt_GroupValue(&$fld, $val) {

    3707. 

  3707. 	$ft = $fld->FldType;

    3708. 

  3708. 	$grp = $fld->FldGroupByType;

    3709. 

  3709. 	$intv = $fld->FldGroupInt;

    3710. 

  3710. 	switch ($ft) {

    3711. 

  3711. 

    3712. 

  3712. 	// Case adBigInt, adInteger, adSmallInt, adTinyInt, adSingle, adDouble, adNumeric, adCurrency, adUnsignedTinyInt, adUnsignedSmallInt, adUnsignedInt, adUnsignedBigInt (numeric)

    3713. 

  3713. 	case 20:

    3714. 

  3714. 	case 3:

    3715. 

  3715. 	case 2:

    3716. 

  3716. 	case 16:

    3717. 

  3717. 	case 4:

    3718. 

  3718. 	case 5:

    3719. 

  3719. 	case 131:

    3720. 

  3720. 	case 6:

    3721. 

  3721. 	case 17:

    3722. 

  3722. 	case 18:

    3723. 

  3723. 	case 19:

    3724. 

  3724. 	case 21:

    3725. 

  3725. 		if (!is_numeric($val)) return $val;	

    3726. 

  3726. 		$wrkIntv = intval($intv);

    3727. 

  3727. 		if ($wrkIntv <= 0) $wrkIntv = 10;

    3728. 

  3728. 		switch ($grp) {

    3729. 

  3729. 			case "i":

    3730. 

  3730. 				return intval($val/$wrkIntv);

    3731. 

  3731. 			default:

    3732. 

  3732. 				return $val;

    3733. 

  3733. 		}

    3734. 

  3734. 

    3735. 

  3735. 	// Case adDate, adDBDate, adDBTime, adDBTimeStamp (date)

    3736. 

  3736. //	case 7:

    3737. 

  3737. //	case 133:

    3738. 

  3738. //	case 134:

    3739. 

  3739. //	case 135:

    3740. 

  3740. 	// Case adLongVarChar, adLongVarWChar, adChar, adWChar, adVarChar, adVarWChar (string)

    3741. 

  3741. 

    3742. 

  3742. 	case 201: // string

    3743. 

  3743. 	case 203:

    3744. 

  3744. 	case 129:

    3745. 

  3745. 	case 130:

    3746. 

  3746. 	case 200:

    3747. 

  3747. 	case 202:

    3748. 

  3748. 		$wrkIntv = intval($intv);

    3749. 

  3749. 		if ($wrkIntv <= 0) $wrkIntv = 1;

    3750. 

  3750. 		switch ($grp) {

    3751. 

  3751. 			case "f":

    3752. 

  3752. 				return substr($val, 0, $wrkIntv);

    3753. 

  3753. 			default:

    3754. 

  3754. 				return $val;

    3755. 

  3755. 		}

    3756. 

  3756. 	default:

    3757. 

  3757. 		return $val; // ignore

    3758. 

  3758. 	}

    3759. 

  3759. }

    3760. 

  3760. 

    3761. 

  3761. // Display group value

    3762. 

  3762. function ewrpt_DisplayGroupValue(&$fld, $val) {

    3763. 

  3763. 	global $ReportLanguage;

    3764. 

  3764. 	$ft = $fld->FldType;

    3765. 

  3765. 	$grp = $fld->FldGroupByType;

    3766. 

  3766. 	$intv = $fld->FldGroupInt;

    3767. 

  3767. 	if (is_null($val)) return $ReportLanguage->Phrase("NullLabel");

    3768. 

  3768. 	if ($val == "") return $ReportLanguage->Phrase("EmptyLabel");

    3769. 

  3769. 	switch ($ft) {

    3770. 

  3770. 

    3771. 

  3771. 	// Case adBigInt, adInteger, adSmallInt, adTinyInt, adSingle, adDouble, adNumeric, adCurrency, adUnsignedTinyInt, adUnsignedSmallInt, adUnsignedInt, adUnsignedBigInt (numeric)

    3772. 

  3772. 	case 20:

    3773. 

  3773. 	case 3:

    3774. 

  3774. 	case 2:

    3775. 

  3775. 	case 16:

    3776. 

  3776. 	case 4:

    3777. 

  3777. 	case 5:

    3778. 

  3778. 	case 131:

    3779. 

  3779. 	case 6:

    3780. 

  3780. 	case 17:

    3781. 

  3781. 	case 18:

    3782. 

  3782. 	case 19:

    3783. 

  3783. 	case 21:

    3784. 

  3784. 		$wrkIntv = intval($intv);

    3785. 

  3785. 		if ($wrkIntv <= 0) $wrkIntv = 10;

    3786. 

  3786. 		switch ($grp) {

    3787. 

  3787. 			case "i":

    3788. 

  3788. 				return strval($val*$wrkIntv) . " - " . strval(($val+1)*$wrkIntv-1);

    3789. 

  3789. 			default:

    3790. 

  3790. 				return $val;

    3791. 

  3791. 		}

    3792. 

  3792. 		break;

    3793. 

  3793. 

    3794. 

  3794. 	// Case adDate, adDBDate, adDBTime, adDBTimeStamp (date)

    3795. 

  3795. 	case 7:

    3796. 

  3796. 	case 133:

    3797. 

  3797. 	case 134:

    3798. 

  3798. 	case 135:

    3799. 

  3799. 		$ar = explode("|", $val);

    3800. 

  3800. 		switch ($grp) {

    3801. 

  3801. 			Case "y":

    3802. 

  3802. 				return $ar[0];

    3803. 

  3803. 			Case "q":

    3804. 

  3804. 				if (count($ar) < 2) return $val;

    3805. 

  3805. 				return ewrpt_FormatQuarter($ar[0], $ar[1]);

    3806. 

  3806. 			Case "m":

    3807. 

  3807. 				if (count($ar) < 2) return $val;

    3808. 

  3808. 				return ewrpt_FormatMonth($ar[0], $ar[1]);

    3809. 

  3809. 			Case "w":

    3810. 

  3810. 				if (count($ar) < 2) return $val;

    3811. 

  3811. 				return ewrpt_FormatWeek($ar[0], $ar[1]);

    3812. 

  3812. 			Case "d":

    3813. 

  3813. 				if (count($ar) < 3) return $val;

    3814. 

  3814. 				return ewrpt_FormatDay($ar[0], $ar[1], $ar[2]);

    3815. 

  3815. 			Case "h":

    3816. 

  3816. 				return ewrpt_FormatHour($ar[0]);

    3817. 

  3817. 			Case "min":

    3818. 

  3818. 				return ewrpt_FormatMinute($ar[0]);

    3819. 

  3819. 			default:

    3820. 

  3820. 				return $val;

    3821. 

  3821. 		}

    3822. 

  3822. 		break;

    3823. 

  3823. 	default: // string and others

    3824. 

  3824. 		return $val; // ignore

    3825. 

  3825. 	}

    3826. 

  3826. }

    3827. 

  3827. 

    3828. 

  3828. function ewrpt_FormatQuarter($y, $q) {

    3829. 

  3829. 	return "Q" . $q . "/" . $y;

    3830. 

  3830. }

    3831. 

  3831. 

    3832. 

  3832. function ewrpt_FormatMonth($y, $m) {

    3833. 

  3833. 	return $m . "/" . $y;

    3834. 

  3834. }

    3835. 

  3835. 

    3836. 

  3836. function ewrpt_FormatWeek($y, $w) {

    3837. 

  3837. 	return "WK" . $w . "/" . $y;

    3838. 

  3838. }

    3839. 

  3839. 

    3840. 

  3840. function ewrpt_FormatDay($y, $m, $d) {

    3841. 

  3841. 	return $y . "-" . $m . "-" . $d;

    3842. 

  3842. }

    3843. 

  3843. 

    3844. 

  3844. function ewrpt_FormatHour($h) {

    3845. 

  3845. 	if (intval($h) == 0) {

    3846. 

  3846. 		return "12 AM";

    3847. 

  3847. 	} elseif (intval($h) < 12) {

    3848. 

  3848. 		return $h . " AM";

    3849. 

  3849. 	} elseif (intval($h) == 12) {

    3850. 

  3850. 		return "12 PM";

    3851. 

  3851. 	} else {

    3852. 

  3852. 		return ($h-12) . " PM";

    3853. 

  3853. 	}

    3854. 

  3854. }

    3855. 

  3855. 

    3856. 

  3856. function ewrpt_FormatMinute($n) {

    3857. 

  3857. 	return $n . " MIN";

    3858. 

  3858. }

    3859. 

  3859. 

    3860. 

  3860. // Get JavaScript data in the form of:

    3861. 

  3861. // [value1, text1, selected], [value2, text2, selected], ...

    3862. 

  3862. // where value1: "value 1", text1: "text 1": selected: true|false

    3863. 

  3863. function ewrpt_GetJsData(&$fld, $ft) {

    3864. 

  3864. 	$jsdata = "";

    3865. 

  3865. 	$arv = $fld->ValueList;

    3866. 

  3866. 	$ars = $fld->SelectionList;

    3867. 

  3867. 	if (is_array($arv)) {

    3868. 

  3868. 		foreach ($arv as $key => $value) {

    3869. 

  3869. 			$jsselect = (ewrpt_IsSelectedValue($ars, $key, $ft)) ? "true" : "false";

    3870. 

  3870. 			if ($jsdata <> "") $jsdata .= ",";

    3871. 

  3871. 			$jsdata .= "[\"" . ewrpt_EscapeJs($key) . "\",\"" . ewrpt_EscapeJs($value) . "\",$jsselect]";

    3872. 

  3872. 		}

    3873. 

  3873. 	}

    3874. 

  3874. 	return $jsdata;

    3875. 

  3875. }

    3876. 

  3876. 

    3877. 

  3877. // Return detail filter SQL

    3878. 

  3878. function ewrpt_DetailFilterSQL(&$fld, $fn, $val) {

    3879. 

  3879. 	$ft = $fld->FldDataType;

    3880. 

  3880. 	if ($fld->FldGroupSql <> "") $ft = EWRPT_DATATYPE_STRING;

    3881. 

  3881. 	$sqlwrk = $fn;

    3882. 

  3882. 	if (is_null($val)) {

    3883. 

  3883. 		$sqlwrk .= " IS NULL";

    3884. 

  3884. 	} else {

    3885. 

  3885. 		$sqlwrk .= " = " . ewrpt_QuotedValue($val, $ft);

    3886. 

  3886. 	}

    3887. 

  3887. 	return $sqlwrk;

    3888. 

  3888. }

    3889. 

  3889. 

    3890. 

  3890. // Return popup filter SQL

    3891. 

  3891. function ewrpt_FilterSQL(&$fld, $fn, $ft) {

    3892. 

  3892. 	$ar = $fld->SelectionList;

    3893. 

  3893. 	$af = $fld->AdvancedFilters;

    3894. 

  3894. 	$gt = $fld->FldGroupByType;

    3895. 

  3895. 	$gi = $fld->FldGroupInt;

    3896. 

  3896. 	$sql = $fld->FldGroupSql;

    3897. 

  3897. 	if (!is_array($ar)) {

    3898. 

  3898. 		return TRUE;

    3899. 

  3899. 	} else {

    3900. 

  3900. 		$sqlwrk = "";

    3901. 

  3901. 		$i = 0;

    3902. 

  3902. 		foreach ($ar as $value) {

    3903. 

  3903. 			if ($value == EWRPT_EMPTY_VALUE) { // Empty string

    3904. 

  3904. 				$sqlwrk .= "$fn = '' OR ";

    3905. 

  3905. 			} elseif ($value == EWRPT_NULL_VALUE) { // Null value

    3906. 

  3906. 				$sqlwrk .= "$fn IS NULL OR ";

    3907. 

  3907. 			} elseif (substr($value, 0, 2) == "@@") { // Advanced filter

    3908. 

  3908. 				if (is_array($af)) {

    3909. 

  3909. 					$afsql = ewrpt_AdvancedFilterSQL($af, $fn, $value); // Process popup filter

    3910. 

  3910. 					if (!is_null($afsql))

    3911. 

  3911. 						$sqlwrk .= $afsql . " OR ";

    3912. 

  3912. 				}

    3913. 

  3913. 			} elseif ($sql <> "") {

    3914. 

  3914. 				$sqlwrk .= str_replace("%s", $fn, $sql) . " = '" . $value . "' OR ";

    3915. 

  3915. 			} else {

    3916. 

  3916. 				$sqlwrk .= "$fn IN (" . ewrpt_JoinArray($ar, ", ", $ft, $i) . ") OR ";

    3917. 

  3917. 				break;

    3918. 

  3918. 			}

    3919. 

  3919. 			$i++;

    3920. 

  3920. 		}

    3921. 

  3921. 	}

    3922. 

  3922. 	if ($sqlwrk != "")

    3923. 

  3923. 		$sqlwrk = "(" . substr($sqlwrk, 0, -4) . ")";

    3924. 

  3924. 	return $sqlwrk;

    3925. 

  3925. }

    3926. 

  3926. 

    3927. 

  3927. // Return Advanced Filter SQL

    3928. 

  3928. function ewrpt_AdvancedFilterSQL(&$af, $fn, $val) {

    3929. 

  3929. 	if (!is_array($af)) {

    3930. 

  3930. 		return NULL;

    3931. 

  3931. 	} elseif (is_null($val)) {

    3932. 

  3932. 		return NULL;

    3933. 

  3933. 	} else {

    3934. 

  3934. 		foreach ($af as $filter) {

    3935. 

  3935. 			if (strval($val) == strval($filter->ID) && $filter->Enabled) {

    3936. 

  3936. 				$func = $filter->FunctionName;

    3937. 

  3937. 				return $func($fn);

    3938. 

  3938. 			}

    3939. 

  3939. 		}

    3940. 

  3940. 		return NULL;

    3941. 

  3941. 	}

    3942. 

  3942. }

    3943. 

  3943. 

    3944. 

  3944. // Truncate Memo Field based on specified length, string truncated to nearest space or CrLf

    3945. 

  3945. function ewrpt_TruncateMemo($memostr, $ln, $removehtml) {

    3946. 

  3946. 	$str = ($removehtml) ? ewrpt_RemoveHtml($memostr) : $memostr;

    3947. 

  3947. 	if (strlen($str) > 0 && strlen($str) > $ln) {

    3948. 

  3948. 		$k = 0;

    3949. 

  3949. 		while ($k >= 0 && $k < strlen($str)) {

    3950. 

  3950. 			$i = strpos($str, " ", $k);

    3951. 

  3951. 			$j = strpos($str, chr(10), $k);

    3952. 

  3952. 			if ($i === FALSE && $j === FALSE) { // Not able to truncate

    3953. 

  3953. 				return $str;

    3954. 

  3954. 			} else {

    3955. 

  3955. 

    3956. 

  3956. 				// Get nearest space or CrLf

    3957. 

  3957. 				if ($i > 0 && $j > 0) {

    3958. 

  3958. 					if ($i < $j) {

    3959. 

  3959. 						$k = $i;

    3960. 

  3960. 					} else {

    3961. 

  3961. 						$k = $j;

    3962. 

  3962. 					}

    3963. 

  3963. 				} elseif ($i > 0) {

    3964. 

  3964. 					$k = $i;

    3965. 

  3965. 				} elseif ($j > 0) {

    3966. 

  3966. 					$k = $j;

    3967. 

  3967. 				}

    3968. 

  3968. 

    3969. 

  3969. 				// Get truncated text

    3970. 

  3970. 				if ($k >= $ln) {

    3971. 

  3971. 					return substr($str, 0, $k) . "...";

    3972. 

  3972. 				} else {

    3973. 

  3973. 					$k++;

    3974. 

  3974. 				}

    3975. 

  3975. 			}

    3976. 

  3976. 		}

    3977. 

  3977. 	} else {

    3978. 

  3978. 		return $str;

    3979. 

  3979. 	}

    3980. 

  3980. }

    3981. 

  3981. 

    3982. 

  3982. // Remove HTML tags from text

    3983. 

  3983. function ewrpt_RemoveHtml($str) {

    3984. 

  3984. 	return preg_replace('/<[^>]*>/', '', strval($str));

    3985. 

  3985. }

    3986. 

  3986. 

    3987. 

  3987. // Escape string for JavaScript

    3988. 

  3988. function ewrpt_EscapeJs($str) {

    3989. 

  3989. 	$str = strval($str);

    3990. 

  3990. 	$str = str_replace("\"", "\\\"", $str);

    3991. 

  3991. 	$str = str_replace("\r", "\\r", $str);

    3992. 

  3992. 	$str = str_replace("\n", "\\n", $str);

    3993. 

  3993. 	return $str;

    3994. 

  3994. }

    3995. 

  3995. 

    3996. 

  3996. // Load Chart Series

    3997. 

  3997. function ewrpt_LoadChartSeries($sSql, &$cht) {

    3998. 

  3998. 	global $conn;

    3999. 

  3999. 	$rscht = $conn->Execute($sSql);

    4000. 

  4000. 	$sdt = $cht->SeriesDateType;

    4001. 

  4001. 	while ($rscht && !$rscht->EOF) {

    4002. 

  4002. 		$cht->Series[] = ewrpt_ChartSeriesValue($rscht->fields[0], $sdt); // Series value

    4003. 

  4003. 		$rscht->MoveNext();

    4004. 

  4004. 	}

    4005. 

  4005. 	if ($rscht) $rscht->Close();

    4006. 

  4006. }

    4007. 

  4007. 

    4008. 

  4008. // Load Chart Data

    4009. 

  4009. function ewrpt_LoadChartData($sSql, &$cht) {

    4010. 

  4010. 	global $conn;

    4011. 

  4011. 	$rscht = $conn->Execute($sSql);

    4012. 

  4012. 	$sdt = $cht->SeriesDateType;

    4013. 

  4013. 	$xdt = $cht->XAxisDateFormat;

    4014. 

  4014. 	$ndt = ($cht->ChartType == 20) ? $cht->NameDateFormat : "";

    4015. 

  4015. 	if ($sdt <> "") $xdt = $sdt;

    4016. 

  4016. 	while ($rscht && !$rscht->EOF) {

    4017. 

  4017. 		$temp = array();

    4018. 

  4018. 		$temp[0] = ewrpt_ChartXValue($rscht->fields[0], $xdt); // X value

    4019. 

  4019. 

    4020. 

  4020. //echo "0: " . $rscht->fields[0] . "<br>";

    4021. 

  4021. 		$temp[1] = ewrpt_ChartSeriesValue($rscht->fields[1], $sdt); // Series value

    4022. 

  4022. 		for ($i=2; $i < $rscht->FieldCount(); $i++) {

    4023. 

  4023. 			if ($ndt <> "" && $i == $rscht->FieldCount()-1)

    4024. 

  4024. 				$temp[$i] = ewrpt_ChartXValue($rscht->fields[$i], $ndt); // Name value

    4025. 

  4025. 			else

    4026. 

  4026. 				$temp[$i] = $rscht->fields[$i]; // Y values

    4027. 

  4027. 		}

    4028. 

  4028. 

    4029. 

  4029. //echo "1: " . $rscht->fields[1] . "<br>";

    4030. 

  4030. 		$cht->Data[] = $temp;

    4031. 

  4031. 		$rscht->MoveNext();

    4032. 

  4032. 	}

    4033. 

  4033. 	if ($rscht) $rscht->Close();

    4034. 

  4034. }

    4035. 

  4035. 

    4036. 

  4036. // Get Chart X value

    4037. 

  4037. function ewrpt_ChartXValue($val, $dt) {

    4038. 

  4038. 	if (is_numeric($dt)) {

    4039. 

  4039. 		return ewrpt_FormatDateTime($val, $dt);

    4040. 

  4040. 	} elseif ($dt == "xyq") {

    4041. 

  4041. 		$ar = explode("|", $val);

    4042. 

  4042. 		if (count($ar) >= 2)

    4043. 

  4043. 			return $ar[0] . " " . ewrpt_QuarterName($ar[1]);

    4044. 

  4044. 		else

    4045. 

  4045. 			return $val;

    4046. 

  4046. 	}

    4047. 

  4047. 	elseif ($dt == "xym") {

    4048. 

  4048. 		$ar = explode("|", $val);

    4049. 

  4049. 		if (count($ar) >= 2)

    4050. 

  4050. 			return $ar[0] . " " . ewrpt_MonthName($ar[1]);

    4051. 

  4051. 		else

    4052. 

  4052. 			return $val;

    4053. 

  4053. 	}

    4054. 

  4054. 	elseif ($dt == "xq") {

    4055. 

  4055. 		return ewrpt_QuarterName($val);

    4056. 

  4056. 	}

    4057. 

  4057. 	elseif ($dt == "xm") {

    4058. 

  4058. 		return ewrpt_MonthName($val);

    4059. 

  4059. 	}

    4060. 

  4060. 	else {

    4061. 

  4061. 		if (is_string($val))

    4062. 

  4062. 			return trim($val);

    4063. 

  4063. 		else

    4064. 

  4064. 			return $val;

    4065. 

  4065. 	}

    4066. 

  4066. }

    4067. 

  4067. 

    4068. 

  4068. // Get Chart Series value

    4069. 

  4069. function ewrpt_ChartSeriesValue($val, $dt) {

    4070. 

  4070. 	if ($dt == "syq") {

    4071. 

  4071. 		$ar = explode("|", $val);

    4072. 

  4072. 		if (count($ar) >= 2)

    4073. 

  4073. 			return $ar[0] . " " . ewrpt_QuarterName($ar[1]);

    4074. 

  4074. 		else

    4075. 

  4075. 			return $val;

    4076. 

  4076. 	}

    4077. 

  4077. 	elseif ($dt == "sym") {

    4078. 

  4078. 		$ar = explode("|", $val);

    4079. 

  4079. 		if (count($ar) >= 2)

    4080. 

  4080. 			return $ar[0] . " " . ewrpt_MonthName($ar[1]);

    4081. 

  4081. 		else

    4082. 

  4082. 			return $val;

    4083. 

  4083. 	}

    4084. 

  4084. 	elseif ($dt == "sq") {

    4085. 

  4085. 		return ewrpt_QuarterName($val);

    4086. 

  4086. 	}

    4087. 

  4087. 	elseif ($dt == "sm") {

    4088. 

  4088. 		return ewrpt_MonthName($val);

    4089. 

  4089. 	}

    4090. 

  4090. 	else {

    4091. 

  4091. 		if (is_string($val))

    4092. 

  4092. 			return trim($val);

    4093. 

  4093. 		else

    4094. 

  4094. 			return $val;

    4095. 

  4095. 	}

    4096. 

  4096. }

    4097. 

  4097. 

    4098. 

  4098. // Sort chart data

    4099. 

  4099. function ewrpt_SortChartData(&$ar, $opt, $seq="") {

    4100. 

  4100. 	if ((($opt < 3 || $opt > 4) && $seq == "") || (($opt < 1 || $opt > 4) && $seq <> ""))

    4101. 

  4101. 		return;

    4102. 

  4102. 	if (is_array($ar)) {

    4103. 

  4103. 		$cntar = count($ar);

    4104. 

  4104. 		for ($i = 0; $i < $cntar; $i++) {

    4105. 

  4105. 			for ($j = $i+1; $j < $cntar; $j++) {

    4106. 

  4106. 				switch ($opt) {

    4107. 

  4107. 					case 1: // X values ascending

    4108. 

  4108. 						$bSwap = ewrpt_CompareValueCustom($ar[$i][0], $ar[$j][0], $seq);

    4109. 

  4109. 						break;

    4110. 

  4110. 					case 2: // X values descending

    4111. 

  4111. 						$bSwap = ewrpt_CompareValueCustom($ar[$j][0], $ar[$i][0], $seq);

    4112. 

  4112. 						break;

    4113. 

  4113. 					case 3: // Y values ascending

    4114. 

  4114. 						$bSwap = ewrpt_CompareValueCustom($ar[$i][2], $ar[$j][2], $seq);

    4115. 

  4115. 						break;

    4116. 

  4116. 					case 4: // Y values descending

    4117. 

  4117. 						$bSwap = ewrpt_CompareValueCustom($ar[$j][2], $ar[$i][2], $seq);

    4118. 

  4118. 				}

    4119. 

  4119. 				if ($bSwap) {

    4120. 

  4120. 					$tmpar = $ar[$i];

    4121. 

  4121. 					$ar[$i] = $ar[$j];

    4122. 

  4122. 					$ar[$j] = $tmpar;

    4123. 

  4123. 				}

    4124. 

  4124. 			}

    4125. 

  4125. 		}

    4126. 

  4126. 	}

    4127. 

  4127. }

    4128. 

  4128. 

    4129. 

  4129. // Sort chart multi series data

    4130. 

  4130. function ewrpt_SortMultiChartData(&$ar, $opt, $seq="") {

    4131. 

  4131. 	if (!is_array($ar) || (($opt < 3 || $opt > 4) && $seq == "") || (($opt < 1 || $opt > 4) && $seq <> ""))

    4132. 

  4132. 		return;

    4133. 

  4133. 

    4134. 

  4134. 	// Obtain a list of columns

    4135. 

  4135. 	foreach ($ar as $key => $row) {

    4136. 

  4136. 		$xvalues[$key] = $row[0];

    4137. 

  4137. 		$series[$key] = $row[1];

    4138. 

  4138. 		$yvalues[$key] = $row[2];

    4139. 

  4139. 		$ysums[$key] = $row[0]; // store the x-value for the time being

    4140. 

  4140. 		if (isset($xsums[$row[0]])) {

    4141. 

  4141. 			$xsums[$row[0]] += $row[2];

    4142. 

  4142. 		} else {

    4143. 

  4143. 			$xsums[$row[0]] = $row[2];

    4144. 

  4144. 		}

    4145. 

  4145. 	}

    4146. 

  4146. 

    4147. 

  4147. 	// Set up Y sum

    4148. 

  4148. 	if ($opt == 3 || $opt == 4) {

    4149. 

  4149. 		$cnt = count($ysums);

    4150. 

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

    4151. 

  4151. 			$ysums[$i] = $xsums[$ysums[$i]];

    4152. 

  4152. 	}

    4153. 

  4153. 

    4154. 

  4154. 	// No specific sequence, use array_multisort

    4155. 

  4155. 	if ($seq == "") {

    4156. 

  4156. 		switch ($opt) {

    4157. 

  4157. 			case 1: // X values ascending

    4158. 

  4158. 				array_multisort($xvalues, SORT_ASC, $ar);

    4159. 

  4159. 				break;

    4160. 

  4160. 			case 2: // X values descending

    4161. 

  4161. 				array_multisort($xvalues, SORT_DESC, $ar);

    4162. 

  4162. 				break;

    4163. 

  4163. 			case 3:

    4164. 

  4164. 			case 4: // Y values

    4165. 

  4165. 				if ($opt == 3) { // ascending

    4166. 

  4166. 					array_multisort($ysums, SORT_ASC, $ar);

    4167. 

  4167. 				} elseif ($opt == 4) { // descending

    4168. 

  4168. 					array_multisort($ysums, SORT_DESC, $ar);

    4169. 

  4169. 				}

    4170. 

  4170. 		}

    4171. 

  4171. 

    4172. 

  4172. 	// Handle specific sequence

    4173. 

  4173. 	} else {

    4174. 

  4174. 

    4175. 

  4175. 		// Build key list

    4176. 

  4176. 		if ($opt == 1 || $opt == 2)

    4177. 

  4177. 			$vals = array_unique($xvalues);

    4178. 

  4178. 		else

    4179. 

  4179. 			$vals = array_unique($ysums);

    4180. 

  4180. 		foreach ($vals as $key => $val) {

    4181. 

  4181. 			$keys[] = array($key, $val);

    4182. 

  4182. 		}

    4183. 

  4183. 

    4184. 

  4184. 		// Sort key list based on specific sequence

    4185. 

  4185. 		$cntkey = count($keys);

    4186. 

  4186. 		for ($i = 0; $i < $cntkey; $i++) {

    4187. 

  4187. 			for ($j = $i+1; $j < $cntkey; $j++) {

    4188. 

  4188. 				switch ($opt) {

    4189. 

  4189. 

    4190. 

  4190. 					// Ascending

    4191. 

  4191. 					case 1:

    4192. 

  4192. 					case 3:

    4193. 

  4193. 						$bSwap = ewrpt_CompareValueCustom($keys[$i][1], $keys[$j][1], $seq);

    4194. 

  4194. 						break;

    4195. 

  4195. 

    4196. 

  4196. 					// Descending

    4197. 

  4197. 					case 2:

    4198. 

  4198. 					case 4:

    4199. 

  4199. 						$bSwap = ewrpt_CompareValueCustom($keys[$j][1], $keys[$i][1], $seq);

    4200. 

  4200. 						break;

    4201. 

  4201. 				}

    4202. 

  4202. 				if ($bSwap) {

    4203. 

  4203. 					$tmpkey = $keys[$i];

    4204. 

  4204. 					$keys[$i] = $keys[$j];

    4205. 

  4205. 					$keys[$j] = $tmpkey;

    4206. 

  4206. 				}

    4207. 

  4207. 			}

    4208. 

  4208. 		}

    4209. 

  4209. 		for ($i = 0; $i < $cntkey; $i++) {

    4210. 

  4210. 			$xsorted[] = $xvalues[$keys[$i][0]];

    4211. 

  4211. 		}

    4212. 

  4212. 

    4213. 

  4213. 		// Sort array based on x sequence

    4214. 

  4214. 		$arwrk = $ar;

    4215. 

  4215. 		$rowcnt = 0;

    4216. 

  4216. 		$cntx = intval(count($xsorted));

    4217. 

  4217. 		for ($i = 0; $i < $cntx; $i++) {

    4218. 

  4218. 			foreach ($arwrk as $key => $row) {

    4219. 

  4219. 				if ($row[0] == $xsorted[$i]) {

    4220. 

  4220. 					$ar[$rowcnt] = $row;

    4221. 

  4221. 					$rowcnt++;

    4222. 

  4222. 				}

    4223. 

  4223. 			}

    4224. 

  4224. 		}

    4225. 

  4225. 	}

    4226. 

  4226. }

    4227. 

  4227. 

    4228. 

  4228. // Compare values by custom sequence

    4229. 

  4229. function ewrpt_CompareValueCustom($v1, $v2, $seq) {

    4230. 

  4230. 	if ($seq == "_number") { // Number

    4231. 

  4231. 		if (is_numeric($v1) && is_numeric($v2)) {

    4232. 

  4232. 			return ((float)$v1 > (float)$v2);

    4233. 

  4233. 		}

    4234. 

  4234. 	} else if ($seq == "_date") { // Date

    4235. 

  4235. 		if (is_numeric(strtotime($v1)) && is_numeric(strtotime($v2))) {

    4236. 

  4236. 			return (strtotime($v1) > strtotime($v2));

    4237. 

  4237. 		}

    4238. 

  4238. 	} else if ($seq <> "") { // Custom sequence

    4239. 

  4239. 		$ar = explode("|", $seq);

    4240. 

  4240. 		if (in_array($v1, $ar) && in_array($v2, $ar))

    4241. 

  4241. 			return (array_search($v1, $ar) > array_search($v2, $ar));

    4242. 

  4242. 		else

    4243. 

  4243. 			return in_array($v2, $ar);

    4244. 

  4244. 	}

    4245. 

  4245. 	return ($v1 > $v2);

    4246. 

  4246. }

    4247. 

  4247. 

    4248. 

  4248. // Load array from sql

    4249. 

  4249. function ewrpt_LoadArrayFromSql($sql, &$ar) {

    4250. 

  4250. 	global $conn;

    4251. 

  4251. 	if (strval($sql) == "")

    4252. 

  4252. 		return;

    4253. 

  4253. 	$rswrk = $conn->Execute($sql);

    4254. 

  4254. 	if ($rswrk) {

    4255. 

  4255. 		while (!$rswrk->EOF) {

    4256. 

  4256. 			$v = $rswrk->fields[0];

    4257. 

  4257. 			if (is_null($v)) {

    4258. 

  4258. 				$v = EWRPT_NULL_VALUE;

    4259. 

  4259. 			} elseif ($v == "") {

    4260. 

  4260. 				$v = EWRPT_EMPTY_VALUE;

    4261. 

  4261. 			}

    4262. 

  4262. 			if (!is_array($ar))

    4263. 

  4263. 				$ar = array();

    4264. 

  4264. 			$ar[] = $v;

    4265. 

  4265. 			$rswrk->MoveNext();

    4266. 

  4266. 		}

    4267. 

  4267. 		$rswrk->Close();

    4268. 

  4268. 	}

    4269. 

  4269. }

    4270. 

  4270. 

    4271. 

  4271. // Function to Match array

    4272. 

  4272. function ewrpt_MatchedArray(&$ar1, &$ar2) {

    4273. 

  4273. 	if (!is_array($ar1) && !is_array($ar2)) {

    4274. 

  4274. 		return TRUE;

    4275. 

  4275. 	} elseif (is_array($ar1) && is_array($ar2)) {

    4276. 

  4276. 		return (count(array_diff($ar1, $ar2)) == 0);

    4277. 

  4277. 	}

    4278. 

  4278. 	return FALSE;

    4279. 

  4279. }

    4280. 

  4280. 

    4281. 

  4281. // Write a value to file for debug

    4282. 

  4282. function ewrpt_Trace($msg) {

    4283. 

  4283. 	$filename = "debug.txt";

    4284. 

  4284. 	if (!$handle = fopen($filename, 'a')) exit;

    4285. 

  4285. 	if (is_writable($filename)) fwrite($handle, $msg . "\n");

    4286. 

  4286. 	fclose($handle);

    4287. 

  4287. }

    4288. 

  4288. 

    4289. 

  4289. // Connection/Query error handler

    4290. 

  4290. function ewrpt_ErrorFn($DbType, $ErrorType, $ErrorNo, $ErrorMsg, $Param1, $Param2, $Object) {

    4291. 

  4291. 	if ($ErrorType == 'CONNECT') {

    4292. 

  4292. 		$msg = "Failed to connect to $Param2 at $Param1. Error: " . $ErrorMsg;

    4293. 

  4293. 	} elseif ($ErrorType == 'EXECUTE') {

    4294. 

  4294. 		$msg = "Failed to execute SQL: $Param1. Error: " . $ErrorMsg;

    4295. 

  4295. 	} 

    4296. 

  4296. 	$_SESSION[EWRPT_SESSION_MESSAGE] = $msg;

    4297. 

  4297. }

    4298. 

  4298. 

    4299. 

  4299. // Write HTTP header

    4300. 

  4300. function ewrpt_Header($cache, $charset = EWRPT_CHARSET) {

    4301. 

  4301. 	header("Expires: Mon, 26 Jul 1997 05:00:00 GMT"); // Date in the past

    4302. 

  4302. 	header("Last-Modified: " . gmdate("D, d M Y H:i:s") . " GMT"); // Always modified

    4303. 

  4303. 	$export = @$_GET["export"];

    4304. 

  4304. 	if ($cache || !$cache && ewrpt_IsHttps() && $export <> "" && $export <> "print") { // Allow cache

    4305. 

  4305. 		header("Cache-Control: private, must-revalidate"); // HTTP/1.1

    4306. 

  4306. 	} else { // No cache

    4307. 

  4307. 		header("Cache-Control: private, no-store, no-cache, must-revalidate"); // HTTP/1.1

    4308. 

  4308. 		header("Cache-Control: post-check=0, pre-check=0", false);

    4309. 

  4309. 		header("Pragma: no-cache"); // HTTP/1.0

    4310. 

  4310. 	}

    4311. 

  4311. 	if ($charset <> "")

    4312. 

  4312. 		header("Content-Type: text/html; charset=" . $charset); // Charset

    4313. 

  4313. }

    4314. 

  4314. 

    4315. 

  4315. // Connect to database

    4316. 

  4316. function &ewrpt_Connect() {

    4317. 

  4317. 	$GLOBALS["ADODB_FETCH_MODE"] = ADODB_FETCH_BOTH;

    4318. 

  4318. 	$conn = new mysqlt_driver_ADOConnection();

    4319. 

  4319. 	$conn->debug = EWRPT_DEBUG_ENABLED;

    4320. 

  4320. 

    4321. 

  4321. //	$conn->debug_echo = FALSE;

    4322. 

  4322. 	$conn->debug_echo = EWRPT_DEBUG_ENABLED;

    4323. 

  4323. 	$info = array("host" => EWRPT_CONN_HOST, "port" => EWRPT_CONN_PORT,

    4324. 

  4324. 		"user" => EWRPT_CONN_USER, "pass" => EWRPT_CONN_PASS, "db" => EWRPT_CONN_DB);

    4325. 

  4325. 

    4326. 

  4326. 	// Database connecting event

    4327. 

  4327. 	Database_Connecting($info);

    4328. 

  4328. 	$conn->port = intval($info["port"]);

    4329. 

  4329. 	$conn->raiseErrorFn = 'ewrpt_ErrorFn';

    4330. 

  4330. 	$conn->Connect($info["host"], $info["user"], $info["pass"], $info["db"]);

    4331. 

  4331. 	if (EWRPT_MYSQL_CHARSET <> "")

    4332. 

  4332. 		$conn->Execute("SET NAMES '" . EWRPT_MYSQL_CHARSET . "'");

    4333. 

  4333. 	$conn->raiseErrorFn = '';

    4334. 

  4334. 

    4335. 

  4335. 	// Database connected event

    4336. 

  4336. 	Database_Connected($conn);

    4337. 

  4337. 	return $conn;

    4338. 

  4338. }

    4339. 

  4339. 

    4340. 

  4340. // Database Connecting event

    4341. 

  4341. function Database_Connecting(&$info) {

    4342. 

  4342. 

    4343. 

  4343. 	// Example:

    4344. 

  4344. 	//var_dump($info);

    4345. 

  4345. 	//if (ew_ServerVar("REMOTE_ADDR") == "127.0.0.1") { // testing on local PC

    4346. 

  4346. 	//	$info["host"] = "locahost";

    4347. 

  4347. 	//	$info["user"] = "root";

    4348. 

  4348. 	//	$info["pass"] = "";

    4349. 

  4349. 	//}

    4350. 

  4350. 

    4351. 

  4351. }

    4352. 

  4352. 

    4353. 

  4353. // Database Connected event

    4354. 

  4354. function Database_Connected(&$conn) {

    4355. 

  4355. 

    4356. 

  4356. 	// Example:

    4357. 

  4357. 	//$conn->Execute("Your SQL");

    4358. 

  4358. 

    4359. 

  4359. }

    4360. 

  4360. 

    4361. 

  4361. // Check if boolean value is TRUE

    4362. 

  4362. function ewrpt_ConvertToBool($value) {

    4363. 

  4363. 	return ($value === TRUE || strval($value) == "1" ||

    4364. 

  4364. 		strtolower(strval($value)) == "y" || strtolower(strval($value)) == "t");

    4365. 

  4365. }

    4366. 

  4366. 

    4367. 

  4367. // Check if HTTP POST

    4368. 

  4368. function ewrpt_IsHttpPost() {

    4369. 

  4369. 	$ct = ewrpt_ServerVar("CONTENT_TYPE");

    4370. 

  4370. 	if (empty($ct)) $ct = ewrpt_ServerVar("HTTP_CONTENT_TYPE");

    4371. 

  4371. 	return ($ct == "application/x-www-form-urlencoded");

    4372. 

  4372. }

    4373. 

  4373. 

    4374. 

  4374. // Strip slashes

    4375. 

  4375. function ewrpt_StripSlashes($value) {

    4376. 

  4376. 	if (!get_magic_quotes_gpc()) return $value;

    4377. 

  4377. 	if (is_array($value)) { 

    4378. 

  4378. 		return array_map('ewrpt_StripSlashes', $value);

    4379. 

  4379. 	} else {

    4380. 

  4380. 		return stripslashes($value);

    4381. 

  4381. 	}

    4382. 

  4382. }

    4383. 

  4383. 

    4384. 

  4384. // Escape chars for XML

    4385. 

  4385. function ewrpt_XmlEncode($val) {

    4386. 

  4386. 	return htmlspecialchars(strval($val));

    4387. 

  4387. }

    4388. 

  4388. 

    4389. 

  4389. // Output SCRIPT tag

    4390. 

  4390. function ewrpt_AddClientScript($src, $attrs = NULL) {

    4391. 

  4391. 	$atts = array("type"=>"text/javascript", "src"=>$src);

    4392. 

  4392. 	if (is_array($attrs))

    4393. 

  4393. 		$atts = array_merge($atts, $attrs);

    4394. 

  4394. 	echo ewrpt_HtmlElement("script", $atts, "") . "\n";

    4395. 

  4395. }

    4396. 

  4396. 

    4397. 

  4397. // Output LINK tag

    4398. 

  4398. function ewrpt_AddStylesheet($href, $attrs = NULL) {

    4399. 

  4399. 	$atts = array("rel"=>"stylesheet", "type"=>"text/css", "href"=>$href);

    4400. 

  4400. 	if (is_array($attrs))

    4401. 

  4401. 		$atts = array_merge($atts, $attrs);

    4402. 

  4402. 	echo ewrpt_HtmlElement("link", $atts, "", FALSE) . "\n";

    4403. 

  4403. }

    4404. 

  4404. 

    4405. 

  4405. // Build HTML element

    4406. 

  4406. function ewrpt_HtmlElement($tagname, $attrs, $innerhtml = "", $endtag = TRUE) {

    4407. 

  4407. 	$html = "<" . $tagname;

    4408. 

  4408. 	if (is_array($attrs)) {

    4409. 

  4409. 		foreach ($attrs as $name => $attr) {

    4410. 

  4410. 			if (strval($attr) <> "")

    4411. 

  4411. 				$html .= " " . $name . "=\"" . ewrpt_HtmlEncode($attr) . "\"";

    4412. 

  4412. 		}

    4413. 

  4413. 	}

    4414. 

  4414. 	$html .= ">";

    4415. 

  4415. 	if (strval($innerhtml) <> "")

    4416. 

  4416. 		$html .= $innerhtml;

    4417. 

  4417. 	if ($endtag)

    4418. 

  4418. 		$html .= "</" . $tagname . ">";

    4419. 

  4419. 	return $html;

    4420. 

  4420. }

    4421. 

  4421. 

    4422. 

  4422. // Encode html

    4423. 

  4423. function ewrpt_HtmlEncode($exp) {

    4424. 

  4424. 	return htmlspecialchars(strval($exp));

    4425. 

  4425. }

    4426. 

  4426. 

    4427. 

  4427. // View Option Separator

    4428. 

  4428. function ewrpt_ViewOptionSeparator($rowcnt) {

    4429. 

  4429. 	return ", ";

    4430. 

  4430. }

    4431. 

  4431. 

    4432. 

  4432. // Functions for TEA encryption/decryption

    4433. 

  4433. function long2str($v, $w) {

    4434. 

  4434. 	$len = count($v);

    4435. 

  4435. 	$s = array();

    4436. 

  4436. 	for ($i = 0; $i < $len; $i++)

    4437. 

  4437. 	{

    4438. 

  4438. 		$s[$i] = pack("V", $v[$i]);

    4439. 

  4439. 	}

    4440. 

  4440. 	if ($w) {

    4441. 

  4441. 		return substr(join('', $s), 0, $v[$len - 1]);

    4442. 

  4442. 	}	else {

    4443. 

  4443. 		return join('', $s);

    4444. 

  4444. 	}

    4445. 

  4445. }

    4446. 

  4446. 

    4447. 

  4447. function str2long($s, $w) {

    4448. 

  4448. 	$v = unpack("V*", $s. str_repeat("\0", (4 - strlen($s) % 4) & 3));

    4449. 

  4449. 	$v = array_values($v);

    4450. 

  4450. 	if ($w) {

    4451. 

  4451. 		$v[count($v)] = strlen($s);

    4452. 

  4452. 	}

    4453. 

  4453. 	return $v;

    4454. 

  4454. }

    4455. 

  4455. 

    4456. 

  4456. function TEAencrypt($str, $key) {

    4457. 

  4457. 	if ($str == "") {

    4458. 

  4458. 		return "";

    4459. 

  4459. 	}

    4460. 

  4460. 	$v = str2long($str, true);

    4461. 

  4461. 	$k = str2long($key, false);

    4462. 

  4462. 	$cntk = count($k);

    4463. 

  4463. 	if ($cntk < 4) {

    4464. 

  4464. 		for ($i = $cntk; $i < 4; $i++) {

    4465. 

  4465. 			$k[$i] = 0;

    4466. 

  4466. 		}

    4467. 

  4467. 	}

    4468. 

  4468. 	$n = count($v) - 1;

    4469. 

  4469. 	$z = $v[$n];

    4470. 

  4470. 	$y = $v[0];

    4471. 

  4471. 	$delta = 0x9E3779B9;

    4472. 

  4472. 	$q = floor(6 + 52 / ($n + 1));

    4473. 

  4473. 	$sum = 0;

    4474. 

  4474. 	while (0 < $q--) {

    4475. 

  4475. 		$sum = int32($sum + $delta);

    4476. 

  4476. 		$e = $sum >> 2 & 3;

    4477. 

  4477. 		for ($p = 0; $p < $n; $p++) {

    4478. 

  4478. 			$y = $v[$p + 1];

    4479. 

  4479. 			$mx = int32((($z >> 5 & 0x07ffffff) ^ $y << 2) + (($y >> 3 & 0x1fffffff) ^ $z << 4)) ^ int32(($sum ^ $y) + ($k[$p & 3 ^ $e] ^ $z));

    4480. 

  4480. 			$z = $v[$p] = int32($v[$p] + $mx);

    4481. 

  4481. 		}

    4482. 

  4482. 		$y = $v[0];

    4483. 

  4483. 		$mx = int32((($z >> 5 & 0x07ffffff) ^ $y << 2) + (($y >> 3 & 0x1fffffff) ^ $z << 4)) ^ int32(($sum ^ $y) + ($k[$p & 3 ^ $e] ^ $z));

    4484. 

  4484. 		$z = $v[$n] = int32($v[$n] + $mx);

    4485. 

  4485. 	}

    4486. 

  4486. 	return ewrpt_UrlEncode(long2str($v, false));

    4487. 

  4487. }

    4488. 

  4488. 

    4489. 

  4489. function TEAdecrypt($str, $key) {

    4490. 

  4490. 	$str = ewrpt_UrlDecode($str);

    4491. 

  4491. 	if ($str == "") {

    4492. 

  4492. 		return "";

    4493. 

  4493. 	}

    4494. 

  4494. 	$v = str2long($str, false);

    4495. 

  4495. 	$k = str2long($key, false);

    4496. 

  4496. 	$cntk = count($k);

    4497. 

  4497. 	if ($cntk < 4) {

    4498. 

  4498. 		for ($i = $cntk; $i < 4; $i++) {

    4499. 

  4499. 			$k[$i] = 0;

    4500. 

  4500. 		}

    4501. 

  4501. 	}

    4502. 

  4502. 	$n = count($v) - 1;

    4503. 

  4503. 	$z = $v[$n];

    4504. 

  4504. 	$y = $v[0];

    4505. 

  4505. 	$delta = 0x9E3779B9;

    4506. 

  4506. 	$q = floor(6 + 52 / ($n + 1));

    4507. 

  4507. 	$sum = int32($q * $delta);

    4508. 

  4508. 	while ($sum != 0) {

    4509. 

  4509. 		$e = $sum >> 2 & 3;

    4510. 

  4510. 		for ($p = $n; $p > 0; $p--) {

    4511. 

  4511. 			$z = $v[$p - 1];

    4512. 

  4512. 			$mx = int32((($z >> 5 & 0x07ffffff) ^ $y << 2) + (($y >> 3 & 0x1fffffff) ^ $z << 4)) ^ int32(($sum ^ $y) + ($k[$p & 3 ^ $e] ^ $z));

    4513. 

  4513. 			$y = $v[$p] = int32($v[$p] - $mx);

    4514. 

  4514. 		}

    4515. 

  4515. 		$z = $v[$n];

    4516. 

  4516. 		$mx = int32((($z >> 5 & 0x07ffffff) ^ $y << 2) + (($y >> 3 & 0x1fffffff) ^ $z << 4)) ^ int32(($sum ^ $y) + ($k[$p & 3 ^ $e] ^ $z));

    4517. 

  4517. 		$y = $v[0] = int32($v[0] - $mx);

    4518. 

  4518. 		$sum = int32($sum - $delta);

    4519. 

  4519. 	}

    4520. 

  4520. 	return long2str($v, true);

    4521. 

  4521. }

    4522. 

  4522. 

    4523. 

  4523. function int32($n) {

    4524. 

  4524. 	while ($n >= 2147483648) $n -= 4294967296;

    4525. 

  4525. 	while ($n <= -2147483649) $n += 4294967296;

    4526. 

  4526. 	return (int)$n;

    4527. 

  4527. }

    4528. 

  4528. 

    4529. 

  4529. function ewrpt_UrlEncode($string) {

    4530. 

  4530. 	$data = base64_encode($string);

    4531. 

  4531. 	return str_replace(array('+','/','='), array('-','_','.'), $data);

    4532. 

  4532. }

    4533. 

  4533. 

    4534. 

  4534. function ewrpt_UrlDecode($string) {

    4535. 

  4535. 	$data = str_replace(array('-','_','.'), array('+','/','='), $string);

    4536. 

  4536. 	return base64_decode($data);

    4537. 

  4537. }

    4538. 

  4538. 

    4539. 

  4539. /**

    4540. 

  4540.  * Pager item class

    4541. 

  4541.  */

    4542. 

  4542. 

    4543. 

  4543. class crPagerItem {

    4544. 

  4544. 	var $Start;

    4545. 

  4545. 	var $Text;

    4546. 

  4546. 	var $Enabled;

    4547. 

  4547. }

    4548. 

  4548. 

    4549. 

  4549. /**

    4550. 

  4550.  * Numeric pager class

    4551. 

  4551.  */

    4552. 

  4552. 

    4553. 

  4553. class crNumericPager {

    4554. 

  4554. 	var $Items = array();

    4555. 

  4555. 	var $Count, $FromIndex, $ToIndex, $RecordCount, $PageSize, $Range;

    4556. 

  4556. 	var $FirstButton, $PrevButton, $NextButton, $LastButton;

    4557. 

  4557. 	var $ButtonCount = 0;

    4558. 

  4558. 	var $Visible = TRUE;

    4559. 

  4559. 

    4560. 

  4560. 	function crNumericPager($StartRec, $DisplayRecs, $TotalRecs, $RecRange)

    4561. 

  4561. 	{

    4562. 

  4562. 		$this->FirstButton = new crPagerItem;

    4563. 

  4563. 		$this->PrevButton = new crPagerItem;

    4564. 

  4564. 		$this->NextButton = new crPagerItem;

    4565. 

  4565. 		$this->LastButton = new crPagerItem;

    4566. 

  4566. 		$this->FromIndex = intval($StartRec);

    4567. 

  4567. 		$this->PageSize = intval($DisplayRecs);

    4568. 

  4568. 		$this->RecordCount = intval($TotalRecs);

    4569. 

  4569. 		$this->Range = intval($RecRange);

    4570. 

  4570. 		if ($this->PageSize == 0) return;

    4571. 

  4571. 		if ($this->FromIndex > $this->RecordCount)

    4572. 

  4572. 			$this->FromIndex = $this->RecordCount;

    4573. 

  4573. 		$this->ToIndex = $this->FromIndex + $this->PageSize - 1;

    4574. 

  4574. 		if ($this->ToIndex > $this->RecordCount)

    4575. 

  4575. 			$this->ToIndex = $this->RecordCount;

    4576. 

  4576. 

    4577. 

  4577. 		// setup

    4578. 

  4578. 		$this->SetupNumericPager();

    4579. 

  4579. 

    4580. 

  4580. 		// update button count

    4581. 

  4581. 		if ($this->FirstButton->Enabled) $this->ButtonCount++;

    4582. 

  4582. 		if ($this->PrevButton->Enabled) $this->ButtonCount++;

    4583. 

  4583. 		if ($this->NextButton->Enabled) $this->ButtonCount++;

    4584. 

  4584. 		if ($this->LastButton->Enabled) $this->ButtonCount++;

    4585. 

  4585. 		$this->ButtonCount += count($this->Items);

    4586. 

  4586. 	}

    4587. 

  4587. 

    4588. 

  4588. 	// Add pager item

    4589. 

  4589. 	function AddPagerItem($StartIndex, $Text, $Enabled)

    4590. 

  4590. 	{

    4591. 

  4591. 		$Item = new crPagerItem;

    4592. 

  4592. 		$Item->Start = $StartIndex;

    4593. 

  4593. 		$Item->Text = $Text;

    4594. 

  4594. 		$Item->Enabled = $Enabled;

    4595. 

  4595. 		$this->Items[] = $Item;

    4596. 

  4596. 	}

    4597. 

  4597. 

    4598. 

  4598. 	// Setup pager items

    4599. 

  4599. 	function SetupNumericPager()

    4600. 

  4600. 	{

    4601. 

  4601. 		if ($this->RecordCount > $this->PageSize) {

    4602. 

  4602. 			$Eof = ($this->RecordCount < ($this->FromIndex + $this->PageSize));

    4603. 

  4603. 			$HasPrev = ($this->FromIndex > 1);

    4604. 

  4604. 

    4605. 

  4605. 			// First Button

    4606. 

  4606. 			$TempIndex = 1;

    4607. 

  4607. 			$this->FirstButton->Start = $TempIndex;

    4608. 

  4608. 			$this->FirstButton->Enabled = ($this->FromIndex > $TempIndex);

    4609. 

  4609. 

    4610. 

  4610. 			// Prev Button

    4611. 

  4611. 			$TempIndex = $this->FromIndex - $this->PageSize;

    4612. 

  4612. 			if ($TempIndex < 1) $TempIndex = 1;

    4613. 

  4613. 			$this->PrevButton->Start = $TempIndex;

    4614. 

  4614. 			$this->PrevButton->Enabled = $HasPrev;

    4615. 

  4615. 

    4616. 

  4616. 			// Page links

    4617. 

  4617. 			if ($HasPrev || !$Eof) {

    4618. 

  4618. 				$x = 1;

    4619. 

  4619. 				$y = 1;

    4620. 

  4620. 				$dx1 = intval(($this->FromIndex-1)/($this->PageSize*$this->Range))*$this->PageSize*$this->Range + 1;

    4621. 

  4621. 				$dy1 = intval(($this->FromIndex-1)/($this->PageSize*$this->Range))*$this->Range + 1;

    4622. 

  4622. 				if (($dx1+$this->PageSize*$this->Range-1) > $this->RecordCount) {

    4623. 

  4623. 					$dx2 = intval($this->RecordCount/$this->PageSize)*$this->PageSize + 1;

    4624. 

  4624. 					$dy2 = intval($this->RecordCount/$this->PageSize) + 1;

    4625. 

  4625. 				} else {

    4626. 

  4626. 					$dx2 = $dx1 + $this->PageSize*$this->Range - 1;

    4627. 

  4627. 					$dy2 = $dy1 + $this->Range - 1;

    4628. 

  4628. 				}

    4629. 

  4629. 				while ($x <= $this->RecordCount) {

    4630. 

  4630. 					if ($x >= $dx1 && $x <= $dx2) {

    4631. 

  4631. 						$this->AddPagerItem($x, $y, $this->FromIndex<>$x);

    4632. 

  4632. 						$x += $this->PageSize;

    4633. 

  4633. 						$y++;

    4634. 

  4634. 					} elseif ($x >= ($dx1-$this->PageSize*$this->Range) && $x <= ($dx2+$this->PageSize*$this->Range)) {

    4635. 

  4635. 						if ($x+$this->Range*$this->PageSize < $this->RecordCount) {

    4636. 

  4636. 							$this->AddPagerItem($x, $y . "-" . ($y+$this->Range-1), TRUE);

    4637. 

  4637. 						} else {

    4638. 

  4638. 							$ny = intval(($this->RecordCount-1)/$this->PageSize) + 1;

    4639. 

  4639. 							if ($ny == $y) {

    4640. 

  4640. 								$this->AddPagerItem($x, $y, TRUE);

    4641. 

  4641. 							} else {

    4642. 

  4642. 								$this->AddPagerItem($x, $y . "-" . $ny, TRUE);

    4643. 

  4643. 							}

    4644. 

  4644. 						}

    4645. 

  4645. 						$x += $this->Range*$this->PageSize;

    4646. 

  4646. 						$y += $this->Range;

    4647. 

  4647. 					} else {

    4648. 

  4648. 						$x += $this->Range*$this->PageSize;

    4649. 

  4649. 						$y += $this->Range;

    4650. 

  4650. 					}

    4651. 

  4651. 				}

    4652. 

  4652. 			}

    4653. 

  4653. 

    4654. 

  4654. 			// Next Button

    4655. 

  4655. 			$TempIndex = $this->FromIndex + $this->PageSize;

    4656. 

  4656. 			$this->NextButton->Start = $TempIndex;

    4657. 

  4657. 			$this->NextButton->Enabled = !$Eof;

    4658. 

  4658. 

    4659. 

  4659. 			// Last Button

    4660. 

  4660. 			$TempIndex = intval(($this->RecordCount-1)/$this->PageSize)*$this->PageSize + 1;

    4661. 

  4661. 			$this->LastButton->Start = $TempIndex;

    4662. 

  4662. 			$this->LastButton->Enabled = ($this->FromIndex < $TempIndex);

    4663. 

  4663. 		}

    4664. 

  4664. 	}

    4665. 

  4665. }

    4666. 

  4666. 

    4667. 

  4667. /**

    4668. 

  4668.  * PrevNext pager class

    4669. 

  4669.  */

    4670. 

  4670. 

    4671. 

  4671. class crPrevNextPager {

    4672. 

  4672. 	var $FirstButton, $PrevButton, $NextButton, $LastButton;

    4673. 

  4673. 	var $CurrentPage, $PageCount, $FromIndex, $ToIndex, $RecordCount;

    4674. 

  4674. 	var $Visible = TRUE;

    4675. 

  4675. 

    4676. 

  4676. 	function crPrevNextPager($StartRec, $DisplayRecs, $TotalRecs)

    4677. 

  4677. 	{

    4678. 

  4678. 		$this->FirstButton = new crPagerItem;

    4679. 

  4679. 		$this->PrevButton = new crPagerItem;

    4680. 

  4680. 		$this->NextButton = new crPagerItem;

    4681. 

  4681. 		$this->LastButton = new crPagerItem;

    4682. 

  4682. 		$this->FromIndex = intval($StartRec);

    4683. 

  4683. 		$this->PageSize = intval($DisplayRecs);

    4684. 

  4684. 		$this->RecordCount = intval($TotalRecs);

    4685. 

  4685. 		if ($this->PageSize == 0) return;

    4686. 

  4686. 		$this->CurrentPage = intval(($this->FromIndex-1)/$this->PageSize) + 1;

    4687. 

  4687. 		$this->PageCount = intval(($this->RecordCount-1)/$this->PageSize) + 1;

    4688. 

  4688. 		if ($this->FromIndex > $this->RecordCount)

    4689. 

  4689. 			$this->FromIndex = $this->RecordCount;

    4690. 

  4690. 		$this->ToIndex = $this->FromIndex + $this->PageSize - 1;

    4691. 

  4691. 		if ($this->ToIndex > $this->RecordCount)

    4692. 

  4692. 			$this->ToIndex = $this->RecordCount;

    4693. 

  4693. 

    4694. 

  4694. 		// First Button

    4695. 

  4695. 		$TempIndex = 1;

    4696. 

  4696. 		$this->FirstButton->Start = $TempIndex;

    4697. 

  4697. 		$this->FirstButton->Enabled = ($TempIndex <> $this->FromIndex);

    4698. 

  4698. 

    4699. 

  4699. 		// Prev Button

    4700. 

  4700. 		$TempIndex = $this->FromIndex - $this->PageSize;

    4701. 

  4701. 		if ($TempIndex < 1) $TempIndex = 1;

    4702. 

  4702. 		$this->PrevButton->Start = $TempIndex;

    4703. 

  4703. 		$this->PrevButton->Enabled = ($TempIndex <> $this->FromIndex);

    4704. 

  4704. 

    4705. 

  4705. 		// Next Button

    4706. 

  4706. 		$TempIndex = $this->FromIndex + $this->PageSize;

    4707. 

  4707. 		if ($TempIndex > $this->RecordCount)

    4708. 

  4708. 			$TempIndex = $this->FromIndex;

    4709. 

  4709. 		$this->NextButton->Start = $TempIndex;

    4710. 

  4710. 		$this->NextButton->Enabled = ($TempIndex <> $this->FromIndex);

    4711. 

  4711. 

    4712. 

  4712. 		// Last Button

    4713. 

  4713. 		$TempIndex = intval(($this->RecordCount-1)/$this->PageSize)*$this->PageSize + 1;

    4714. 

  4714. 		$this->LastButton->Start = $TempIndex;

    4715. 

  4715. 		$this->LastButton->Enabled = ($TempIndex <> $this->FromIndex);

    4716. 

  4716.   }

    4717. 

  4717. }

    4718. 

  4718. 

    4719. 

  4719. /**

    4720. 

  4720.  * Email class

    4721. 

  4721.  */

    4722. 

  4722. 

    4723. 

  4723. class crEmail {

    4724. 

  4724. 

    4725. 

  4725. 	// Class properties

    4726. 

  4726. 	var $Sender = ""; // Sender

    4727. 

  4727. 	var $Recipient = ""; // Recipient

    4728. 

  4728. 	var $Cc = ""; // Cc

    4729. 

  4729. 	var $Bcc = ""; // Bcc

    4730. 

  4730. 	var $Subject = ""; // Subject

    4731. 

  4731. 	var $Format = ""; // Format

    4732. 

  4732. 	var $Content = ""; // Content

    4733. 

  4733. 	var $AttachmentContent = ""; // Attachement content

    4734. 

  4734. 	var $AttachmentFileName = ""; // Attachment file name

    4735. 

  4735. 	var $Charset = ""; // Charset

    4736. 

  4736. 	var $SendErrDescription; // Send error description

    4737. 

  4737. 

    4738. 

  4738. 	// Method to load email from template

    4739. 

  4739. 	function Load($fn) {

    4740. 

  4740. 		$fn = ewrpt_ScriptFolder() . EWRPT_PATH_DELIMITER . $fn;

    4741. 

  4741. 		$sWrk = file_get_contents($fn); // Load text file content

    4742. 

  4742. 		if ($sWrk <> "") {

    4743. 

  4743. 

    4744. 

  4744. 			// Locate Header & Mail Content

    4745. 

  4745. 			if (EWRPT_IS_WINDOWS) {

    4746. 

  4746. 				$i = strpos($sWrk, "\r\n\r\n");

    4747. 

  4747. 			} else {

    4748. 

  4748. 				$i = strpos($sWrk, "\n\n");

    4749. 

  4749. 				if ($i === FALSE) $i = strpos($sWrk, "\r\n\r\n");

    4750. 

  4750. 			}

    4751. 

  4751. 			if ($i > 0) {

    4752. 

  4752. 				$sHeader = substr($sWrk, 0, $i);

    4753. 

  4753. 				$this->Content = trim(substr($sWrk, $i, strlen($sWrk)));

    4754. 

  4754. 				if (EWRPT_IS_WINDOWS) {

    4755. 

  4755. 					$arrHeader = explode("\r\n", $sHeader);

    4756. 

  4756. 				} else {

    4757. 

  4757. 					$arrHeader = explode("\n", $sHeader);

    4758. 

  4758. 				}

    4759. 

  4759. 				for ($j = 0; $j < count($arrHeader); $j++) {

    4760. 

  4760. 					$i = strpos($arrHeader[$j], ":");

    4761. 

  4761. 					if ($i > 0) {

    4762. 

  4762. 						$sName = trim(substr($arrHeader[$j], 0, $i));

    4763. 

  4763. 						$sValue = trim(substr($arrHeader[$j], $i+1, strlen($arrHeader[$j])));

    4764. 

  4764. 						switch (strtolower($sName))

    4765. 

  4765. 						{

    4766. 

  4766. 							case "subject":

    4767. 

  4767. 								$this->Subject = $sValue;

    4768. 

  4768. 								break;

    4769. 

  4769. 							case "from":

    4770. 

  4770. 								$this->Sender = $sValue;

    4771. 

  4771. 								break;

    4772. 

  4772. 							case "to":

    4773. 

  4773. 								$this->Recipient = $sValue;

    4774. 

  4774. 								break;

    4775. 

  4775. 							case "cc":

    4776. 

  4776. 								$this->Cc = $sValue;

    4777. 

  4777. 								break;

    4778. 

  4778. 							case "bcc":

    4779. 

  4779. 								$this->Bcc = $sValue;

    4780. 

  4780. 								break;

    4781. 

  4781. 							case "format":

    4782. 

  4782. 								$this->Format = $sValue;

    4783. 

  4783. 								break;

    4784. 

  4784. 						}

    4785. 

  4785. 					}

    4786. 

  4786. 				}

    4787. 

  4787. 			}

    4788. 

  4788. 		}

    4789. 

  4789. 	}

    4790. 

  4790. 

    4791. 

  4791. 	// Method to replace sender

    4792. 

  4792. 	function ReplaceSender($ASender) {

    4793. 

  4793. 		$this->Sender = str_replace('<!--$From-->', $ASender, $this->Sender);

    4794. 

  4794. 	}

    4795. 

  4795. 

    4796. 

  4796. 	// Method to replace recipient

    4797. 

  4797. 	function ReplaceRecipient($ARecipient) {

    4798. 

  4798. 		$this->Recipient = str_replace('<!--$To-->', $ARecipient, $this->Recipient);

    4799. 

  4799. 	}

    4800. 

  4800. 

    4801. 

  4801. 	// Method to add Cc email

    4802. 

  4802. 	function AddCc($ACc) {

    4803. 

  4803. 		if ($ACc <> "") {

    4804. 

  4804. 			if ($this->Cc <> "") $this->Cc .= ";";

    4805. 

  4805. 			$this->Cc .= $ACc;

    4806. 

  4806. 		}

    4807. 

  4807. 	}

    4808. 

  4808. 

    4809. 

  4809. 	// Method to add Bcc email

    4810. 

  4810. 	function AddBcc($ABcc) {

    4811. 

  4811. 		if ($ABcc <> "")  {

    4812. 

  4812. 			if ($this->Bcc <> "") $this->Bcc .= ";";

    4813. 

  4813. 			$this->Bcc .= $ABcc;

    4814. 

  4814. 		}

    4815. 

  4815. 	}

    4816. 

  4816. 

    4817. 

  4817. 	// Method to replace subject

    4818. 

  4818. 	function ReplaceSubject($ASubject) {

    4819. 

  4819. 		$this->Subject = str_replace('<!--$Subject-->', $ASubject, $this->Subject);

    4820. 

  4820. 	}

    4821. 

  4821. 

    4822. 

  4822. 	// Method to replace content

    4823. 

  4823. 	function ReplaceContent($Find, $ReplaceWith) {

    4824. 

  4824. 		$this->Content = str_replace($Find, $ReplaceWith, $this->Content);

    4825. 

  4825. 	}

    4826. 

  4826. 

    4827. 

  4827. 	// Method to send email

    4828. 

  4828. 	function Send() {

    4829. 

  4829. 		global $gsEmailErrDesc;

    4830. 

  4830. 		$result = ewrpt_SendEmail($this->Sender, $this->Recipient, $this->Cc, $this->Bcc,

    4831. 

  4831. 			$this->Subject, $this->Content, $this->Format, $this->Charset, $this->AttachmentFileName, $this->AttachmentContent);

    4832. 

  4832. 		$this->SendErrDescription = $gsEmailErrDesc;

    4833. 

  4833. 		return $result;

    4834. 

  4834. 	}

    4835. 

  4835. }

    4836. 

  4836. 

    4837. 

  4837. // Include PHPMailer class

    4838. 

  4838. include_once("phpmailer51/class.phpmailer.php");

    4839. 

  4839. 

    4840. 

  4840. // Function to send email

    4841. 

  4841. function ewrpt_SendEmail($sFrEmail, $sToEmail, $sCcEmail, $sBccEmail, $sSubject, $sMail, $sFormat, $sCharset, $sAttachmentFileName = "", $sAttachmentContent = "") {

    4842. 

  4842. 	global $ReportLanguage, $gsEmailErrDesc;

    4843. 

  4843. 	$res = FALSE;

    4844. 

  4844. 	$mail = new PHPMailer();

    4845. 

  4845. 	$mail->IsSMTP(); 

    4846. 

  4846. 	$mail->Host = EWRPT_SMTP_SERVER;

    4847. 

  4847. 	$mail->SMTPAuth = (EWRPT_SMTP_SERVER_USERNAME <> "" && EWRPT_SMTP_SERVER_PASSWORD <> "");

    4848. 

  4848. 	$mail->Username = EWRPT_SMTP_SERVER_USERNAME;

    4849. 

  4849. 	$mail->Password = EWRPT_SMTP_SERVER_PASSWORD;

    4850. 

  4850. 	$mail->Port = EWRPT_SMTP_SERVER_PORT;

    4851. 

  4851. 	$mail->From = $sFrEmail;

    4852. 

  4852. 	$mail->FromName = $sFrEmail;

    4853. 

  4853. 	$mail->Subject = $sSubject;

    4854. 

  4854. 	$mail->Body = $sMail;

    4855. 

  4855. 	if ($sCharset <> "" && strtolower($sCharset) <> "iso-8859-1")

    4856. 

  4856. 		$mail->CharSet = $sCharset;

    4857. 

  4857. 	$sToEmail = str_replace(";", ",", $sToEmail);

    4858. 

  4858. 	$arrTo = explode(",", $sToEmail);

    4859. 

  4859. 	foreach ($arrTo as $sTo) {

    4860. 

  4860. 		$mail->AddAddress(trim($sTo));

    4861. 

  4861. 	}

    4862. 

  4862. 	if ($sCcEmail <> "") {

    4863. 

  4863. 		$sCcEmail = str_replace(";", ",", $sCcEmail);

    4864. 

  4864. 		$arrCc = explode(",", $sCcEmail);

    4865. 

  4865. 		foreach ($arrCc as $sCc) {

    4866. 

  4866. 			$mail->AddCC(trim($sCc));

    4867. 

  4867. 		}

    4868. 

  4868. 	}

    4869. 

  4869. 	if ($sBccEmail <> "") {

    4870. 

  4870. 		$sBccEmail = str_replace(";", ",", $sBccEmail);

    4871. 

  4871. 		$arrBcc = explode(",", $sBccEmail);

    4872. 

  4872. 		foreach ($arrBcc as $sBcc) {

    4873. 

  4873. 			$mail->AddBCC(trim($sBcc));

    4874. 

  4874. 		}

    4875. 

  4875. 	}

    4876. 

  4876. 	if (strtolower($sFormat) == "html") {

    4877. 

  4877. 		$mail->ContentType = "text/html";

    4878. 

  4878. 	} else {

    4879. 

  4879. 		$mail->ContentType = "text/plain";

    4880. 

  4880. 	}

    4881. 

  4881. 	if ($sAttachmentContent <> "" && $sAttachmentFileName <> "") {

    4882. 

  4882. 		$mail->AddStringAttachment($sAttachmentContent, $sAttachmentFileName);

    4883. 

  4883. 	} else if ($sAttachmentFileName <> "") {

    4884. 

  4884. 		$mail->AddAttachment($sAttachmentFileName);

    4885. 

  4885. 	}

    4886. 

  4886. 	$res = $mail->Send();

    4887. 

  4887. 	$gsEmailErrDesc = $mail->ErrorInfo;

    4888. 

  4888. 

    4889. 

  4889. 	// Uncomment to debug

    4890. 

  4890. //		var_dump($mail); exit();

    4891. 

  4891. 

    4892. 

  4892. 	return $res;

    4893. 

  4893. }

    4894. 

  4894. 

    4895. 

  4895. // Load email count

    4896. 

  4896. function ewrpt_LoadEmailCount() {

    4897. 

  4897. 

    4898. 

  4898. 	// Read from log

    4899. 

  4899. 	if (EWRPT_EMAIL_WRITE_LOG) {

    4900. 

  4900. 		$ip = ewrpt_ServerVar("REMOTE_ADDR");

    4901. 

  4901. 

    4902. 

  4902. 		// Load from database

    4903. 

  4903. 		if (EWRPT_EMAIL_WRITE_LOG_TO_DATABASE) {

    4904. 

  4904. 			global $conn;

    4905. 

  4905. 			$dt1 = date("Y-m-d H:i:s", strtotime("- " . EWRPT_MAX_EMAIL_SENT_PERIOD . "minute"));

    4906. 

  4906. 			$dt2 = date("Y-m-d H:i:s");

    4907. 

  4907. 			$sEmailSql = "SELECT COUNT(*) FROM " . ewrpt_QuotedName(EWRPT_EMAIL_LOG_TABLE_NAME) .

    4908. 

  4908. 				" WHERE " . ewrpt_QuotedName(EWRPT_EMAIL_LOG_FIELD_NAME_DATETIME) .

    4909. 

  4909. 				" BETWEEN " . ewrpt_QuotedValue($dt1, EWRPT_DATATYPE_DATE) . " AND " . ewrpt_QuotedValue($dt2, EWRPT_DATATYPE_DATE) .

    4910. 

  4910. 				" AND " . ewrpt_QuotedName(EWRPT_EMAIL_LOG_FIELD_NAME_IP) . 

    4911. 

  4911. 				" = " . ewrpt_QuotedValue($ip, EWRPT_DATATYPE_STRING);

    4912. 

  4912. 			$rscnt = $conn->Execute($sEmailSql);

    4913. 

  4913. 			if ($rscnt) {

    4914. 

  4914. 				$_SESSION[EWRPT_EXPORT_EMAIL_COUNTER] = ($rscnt->RecordCount()>1) ? $rscnt->RecordCount() : $rscnt->fields[0];

    4915. 

  4915. 				$rscnt->Close();

    4916. 

  4916. 			} else {

    4917. 

  4917. 				$_SESSION[EWRPT_EXPORT_EMAIL_COUNTER] = 0;

    4918. 

  4918. 			}

    4919. 

  4919. 

    4920. 

  4920. 		// Load from log file

    4921. 

  4921. 		} else {

    4922. 

  4922. 			$pfx = "email";

    4923. 

  4923. 			$sTab = "\t";

    4924. 

  4924. 			$sFolder = EWRPT_UPLOAD_DEST_PATH;

    4925. 

  4925. 			$randomkey = TEAencrypt(date("Ymd"), EWRPT_RANDOM_KEY);

    4926. 

  4926. 			$sFn = $pfx . "_" . date("Ymd") . "_" . $randomkey . ".txt";

    4927. 

  4927. 			$filename = ewrpt_UploadPathEx(TRUE, $sFolder) . $sFn;

    4928. 

  4928. 			if (file_exists($filename)) {

    4929. 

  4929. 				$arLines = file($filename);

    4930. 

  4930. 				$cnt = 0;

    4931. 

  4931. 				foreach ($arLines as $line) {

    4932. 

  4932. 					if ($line <> "") {

    4933. 

  4933. 						list($dtwrk, $ipwrk, $senderwrk, $recipientwrk, $subjectwrk, $messagewrk) = explode($sTab, $line);

    4934. 

  4934. 						$timediff = intval((strtotime("now") - strtotime($dtwrk,0))/60);

    4935. 

  4935. 						if ($ipwrk == $ip && $timediff < EWRPT_MAX_EMAIL_SENT_PERIOD) $cnt++;

    4936. 

  4936. 					}

    4937. 

  4937. 				}

    4938. 

  4938. 				$_SESSION[EWRPT_EXPORT_EMAIL_COUNTER] = $cnt;

    4939. 

  4939. 			} else {

    4940. 

  4940. 				$_SESSION[EWRPT_EXPORT_EMAIL_COUNTER] = 0;

    4941. 

  4941. 			}

    4942. 

  4942. 		}

    4943. 

  4943. 	}

    4944. 

  4944. 	if (!isset($_SESSION[EWRPT_EXPORT_EMAIL_COUNTER]))

    4945. 

  4945. 		$_SESSION[EWRPT_EXPORT_EMAIL_COUNTER] = 0;

    4946. 

  4946. 	return intval($_SESSION[EWRPT_EXPORT_EMAIL_COUNTER]);

    4947. 

  4947. }

    4948. 

  4948. 

    4949. 

  4949. // Add email log

    4950. 

  4950. function ewrpt_AddEmailLog($sender, $recipient, $subject, $message) {

    4951. 

  4951. 	$_SESSION[EWRPT_EXPORT_EMAIL_COUNTER]++;

    4952. 

  4952. 

    4953. 

  4953. 	// Save to email log

    4954. 

  4954. 	if (EWRPT_EMAIL_WRITE_LOG) {

    4955. 

  4955. 		$dt = date("Y-m-d H:i:s");

    4956. 

  4956. 		$ip = ewrpt_ServerVar("REMOTE_ADDR");

    4957. 

  4957. 		$senderwrk = ewrpt_TruncateText($sender);

    4958. 

  4958. 		$recipientwrk = ewrpt_TruncateText($recipient);

    4959. 

  4959. 		$subjectwrk = ewrpt_TruncateText($subject);

    4960. 

  4960. 		$messagewrk = ewrpt_TruncateText($message);

    4961. 

  4961. 

    4962. 

  4962. 		// Save to database

    4963. 

  4963. 		if (EWRPT_EMAIL_WRITE_LOG_TO_DATABASE) {

    4964. 

  4964. 			global $conn;

    4965. 

  4965. 			$sEmailSql = "INSERT INTO " . ewrpt_QuotedName(EWRPT_EMAIL_LOG_TABLE_NAME) .

    4966. 

  4966. 				" (" . ewrpt_QuotedName(EWRPT_EMAIL_LOG_FIELD_NAME_DATETIME) . ", " .

    4967. 

  4967. 				ewrpt_QuotedName(EWRPT_EMAIL_LOG_FIELD_NAME_IP) . ", " .

    4968. 

  4968. 				ewrpt_QuotedName(EWRPT_EMAIL_LOG_FIELD_NAME_SENDER) . ", " .

    4969. 

  4969. 				ewrpt_QuotedName(EWRPT_EMAIL_LOG_FIELD_NAME_RECIPIENT) . ", " .

    4970. 

  4970. 				ewrpt_QuotedName(EWRPT_EMAIL_LOG_FIELD_NAME_SUBJECT) . ", " .

    4971. 

  4971. 				ewrpt_QuotedName(EWRPT_EMAIL_LOG_FIELD_NAME_MESSAGE) . ") VALUES (" .

    4972. 

  4972. 				ewrpt_QuotedValue($dt, EWRPT_DATATYPE_DATE) . ", " .

    4973. 

  4973. 				ewrpt_QuotedValue($ip, EWRPT_DATATYPE_STRING) . ", " .

    4974. 

  4974. 				ewrpt_QuotedValue($senderwrk, EWRPT_DATATYPE_STRING) . ", " .

    4975. 

  4975. 				ewrpt_QuotedValue($recipientwrk, EWRPT_DATATYPE_STRING) . ", " .

    4976. 

  4976. 				ewrpt_QuotedValue($subjectwrk, EWRPT_DATATYPE_STRING) . ", " .

    4977. 

  4977. 				ewrpt_QuotedValue($messagewrk, EWRPT_DATATYPE_STRING) . ")";

    4978. 

  4978. 			$conn->Execute($sEmailSql);

    4979. 

  4979. 

    4980. 

  4980. 		// Save to log file

    4981. 

  4981. 		} else {

    4982. 

  4982. 			$pfx = "email";

    4983. 

  4983. 			$sTab = "\t";

    4984. 

  4984. 			$sHeader = "date/time" . $sTab . "ip" . $sTab . "sender" . $sTab . "recipient" . $sTab . "subject" . $sTab . "message";

    4985. 

  4985. 			$sMsg = $dt . $sTab . $ip . $sTab . $senderwrk . $sTab . $recipientwrk . $sTab . $subjectwrk . $sTab . $messagewrk;

    4986. 

  4986. 			$sFolder = EWRPT_UPLOAD_DEST_PATH;

    4987. 

  4987. 			$randomkey = TEAencrypt(date("Ymd"), EWRPT_RANDOM_KEY);

    4988. 

  4988. 			$sFn = $pfx . "_" . date("Ymd") . "_" . $randomkey . ".txt";

    4989. 

  4989. 			$filename = ewrpt_UploadPathEx(TRUE, $sFolder) . $sFn;

    4990. 

  4990. 			if (file_exists($filename)) {

    4991. 

  4991. 				$fileHandler = fopen($filename, "a+b");

    4992. 

  4992. 			} else {

    4993. 

  4993. 				$fileHandler = fopen($filename, "a+b");

    4994. 

  4994. 				fwrite($fileHandler,$sHeader."\r\n");

    4995. 

  4995. 			}

    4996. 

  4996. 			fwrite($fileHandler, $sMsg."\r\n");

    4997. 

  4997. 			fclose($fileHandler);

    4998. 

  4998. 		}

    4999. 

  4999. 	}

    5000. 

  5000. }

    5001. 

  5001. 

    5002. 

  5002. function ewrpt_TruncateText($v) {

    5003. 

  5003. 	$maxlen = EWRPT_EMAIL_LOG_SIZE_LIMIT;

    5004. 

  5004. 	$v = str_replace("\r\n", " ", $v);

    5005. 

  5005. 	$v = str_replace("\t", " ", $v);

    5006. 

  5006. 	if (strlen($v) > $maxlen)

    5007. 

  5007. 		$v = substr($v, 0, $maxlen-3) . "...";

    5008. 

  5008. 	return $v;

    5009. 

  5009. }

    5010. 

  5010. 

    5011. 

  5011. // Read global debug message

    5012. 

  5012. function ewrpt_DebugMsg() {

    5013. 

  5013. 	global $gsDebugMsg;

    5014. 

  5014. 	return ($gsDebugMsg <> "") ? "<p>" . $gsDebugMsg . "</p>" : "";

    5015. 

  5015. }

    5016. 

  5016. 

    5017. 

  5017. // Write global debug message

    5018. 

  5018. function ewrpt_SetDebugMsg($v, $newline = TRUE) {

    5019. 

  5019. 	global $gsDebugMsg;

    5020. 

  5020. 	if ($newline && $gsDebugMsg <> "")

    5021. 

  5021. 		$gsDebugMsg .= "<br>";

    5022. 

  5022. 	$gsDebugMsg .=  $v;

    5023. 

  5023. }

    5024. 

  5024. 

    5025. 

  5025. /**

    5026. 

  5026.  * Functions for converting encoding

    5027. 

  5027.  */

    5028. 

  5028. 

    5029. 

  5029. function ewrpt_ConvertToUtf8($str) {

    5030. 

  5030. 	return ewrpt_Convert(EWRPT_ENCODING, "UTF-8", $str);

    5031. 

  5031. }

    5032. 

  5032. 

    5033. 

  5033. function ewrpt_ConvertFromUtf8($str) {

    5034. 

  5034. 	return ewrpt_Convert("UTF-8", EWRPT_ENCODING, $str);

    5035. 

  5035. }

    5036. 

  5036. 

    5037. 

  5037. function ewrpt_Convert($from, $to, $str) {

    5038. 

  5038. 	if ($from != "" && $to != "" && strtoupper($from) != strtoupper($to)) {

    5039. 

  5039. 		if (function_exists("iconv")) {

    5040. 

  5040. 			return iconv($from, $to, $str);

    5041. 

  5041. 		} elseif (function_exists("mb_convert_encoding")) {

    5042. 

  5042. 			return mb_convert_encoding($str, $to, $from);

    5043. 

  5043. 		} else {

    5044. 

  5044. 			return $str;

    5045. 

  5045. 		}

    5046. 

  5046. 	} else {

    5047. 

  5047. 		return $str;

    5048. 

  5048. 	}

    5049. 

  5049. }

    5050. 

  5050. 

    5051. 

  5051. // Encode value for single-quoted JavaScript string

    5052. 

  5052. function ewrpt_JsEncode($val) {

    5053. 

  5053. 	$val = str_replace("\\", "\\\\", strval($val));

    5054. 

  5054. 	$val = str_replace("'", "\\'", $val);

    5055. 

  5055. 	$val = str_replace("\r\n", "<br>", $val);

    5056. 

  5056. 	$val = str_replace("\r", "<br>", $val);

    5057. 

  5057. 	$val = str_replace("\n", "<br>", $val);

    5058. 

  5058. 	return $val;

    5059. 

  5059. }

    5060. 

  5060. 

    5061. 

  5061. // Encode value for double-quoted Javascript string

    5062. 

  5062. function ewrpt_JsEncode2($val) {

    5063. 

  5063. 	$val = str_replace("\\", "\\\\", strval($val));

    5064. 

  5064. 	$val = str_replace("\"", "\\\"", $val);

    5065. 

  5065. 	$val = str_replace("\r\n", "<br>", $val);

    5066. 

  5066. 	$val = str_replace("\r", "<br>", $val);

    5067. 

  5067. 	$val = str_replace("\n", "<br>", $val);

    5068. 

  5068. 	return $val;

    5069. 

  5069. }

    5070. 

  5070. 

    5071. 

  5071. // Get current page name

    5072. 

  5072. function ewrpt_CurrentPage() {

    5073. 

  5073. 	return ewrpt_GetPageName(ewrpt_ScriptName());

    5074. 

  5074. }

    5075. 

  5075. 

    5076. 

  5076. // Get page name

    5077. 

  5077. function ewrpt_GetPageName($url) {

    5078. 

  5078. 	$PageName = "";

    5079. 

  5079. 	if ($url <> "") {

    5080. 

  5080. 		$PageName = $url;

    5081. 

  5081. 		$p = strpos($PageName, "?");

    5082. 

  5082. 		if ($p !== FALSE)

    5083. 

  5083. 			$PageName = substr($PageName, 0, $p); // Remove QueryString

    5084. 

  5084. 		$p = strrpos($PageName, "/");

    5085. 

  5085. 		if ($p !== FALSE)

    5086. 

  5086. 			$PageName = substr($PageName, $p+1); // Remove path

    5087. 

  5087. 	}

    5088. 

  5088. 	return $PageName;

    5089. 

  5089. }

    5090. 

  5090. 

    5091. 

  5091. // Adjust text for caption

    5092. 

  5092. function ewrpt_BtnCaption($Caption) {

    5093. 

  5093. 	$Min = 10;

    5094. 

  5094. 	if (strlen($Caption) < $Min) {

    5095. 

  5095. 		$Pad = abs(intval(($Min - strlen($Caption))/2*-1));

    5096. 

  5096. 		$Caption = str_repeat(" ", $Pad) . $Caption . str_repeat(" ", $Pad);

    5097. 

  5097. 	}

    5098. 

  5098. 	return $Caption;

    5099. 

  5099. }

    5100. 

  5100. 

    5101. 

  5101. // Get script name (function name is prefix with "ew_" only for compatibility with PHPMaker)

    5102. 

  5102. function ew_ScriptName() {

    5103. 

  5103. 	$sn = ewrpt_ServerVar("PHP_SELF");

    5104. 

  5104. 	if (empty($sn)) $sn = ewrpt_ServerVar("SCRIPT_NAME");

    5105. 

  5105. 	if (empty($sn)) $sn = ewrpt_ServerVar("ORIG_PATH_INFO");

    5106. 

  5106. 	if (empty($sn)) $sn = ewrpt_ServerVar("ORIG_SCRIPT_NAME");

    5107. 

  5107. 	if (empty($sn)) $sn = ewrpt_ServerVar("REQUEST_URI");

    5108. 

  5108. 	if (empty($sn)) $sn = ewrpt_ServerVar("URL");

    5109. 

  5109. 	if (empty($sn)) $sn = "UNKNOWN";

    5110. 

  5110. 	return $sn;

    5111. 

  5111. }

    5112. 

  5112. 

    5113. 

  5113. // Get server variable by name

    5114. 

  5114. function ewrpt_ServerVar($Name) {

    5115. 

  5115. 	$str = @$_SERVER[$Name];

    5116. 

  5116. 	if (empty($str)) $str = @$_ENV[$Name];

    5117. 

  5117. 	return $str;

    5118. 

  5118. }

    5119. 

  5119. 

    5120. 

  5120. // YUI files host

    5121. 

  5121. function ewrpt_YuiHost() {

    5122. 

  5122. 

    5123. 

  5123. 	// Use files online

    5124. 

  5124. 	if (ewrpt_IsHttps()) {

    5125. 

  5125. 		return "https://ajax.googleapis.com/ajax/libs/yui/2.9.0/";

    5126. 

  5126. 	} else {

    5127. 

  5127. 		return "http://yui.yahooapis.com/2.9.0/";

    5128. 

  5128. 	}

    5129. 

  5129. }

    5130. 

  5130. 

    5131. 

  5131. // jQuery files host

    5132. 

  5132. function ewrpt_jQueryHost() {

    5133. 

  5133. 

    5134. 

  5134. 	// Use files online

    5135. 

  5135. 	if (ewrpt_IsHttps()) {

    5136. 

  5136. 		return "https://ajax.googleapis.com/ajax/libs/jquery/1.7.1/";

    5137. 

  5137. 	} else {

    5138. 

  5138. 		return "http://ajax.googleapis.com/ajax/libs/jquery/1.7.1/";

    5139. 

  5139. 	}

    5140. 

  5140. }

    5141. 

  5141. 

    5142. 

  5142. // Check if HTTPS

    5143. 

  5143. function ewrpt_IsHttps() {

    5144. 

  5144. 	return (ewrpt_ServerVar("HTTPS") <> "" && ewrpt_ServerVar("HTTPS") <> "off");

    5145. 

  5145. }

    5146. 

  5146. 

    5147. 

  5147. // Encrypt password

    5148. 

  5148. function ewrpt_EncryptPassword($input, $salt = '') {

    5149. 

  5149. 	return (strval($salt) <> "") ? md5($input . $salt) . ":" . $salt : md5($input);

    5150. 

  5150. }

    5151. 

  5151. 

    5152. 

  5152. // Compare password

    5153. 

  5153. // Note: If salted, password must be stored in '<hashedstring>:<salt>' format

    5154. 

  5154. function ewrpt_ComparePassword($pwd, $input) {

    5155. 

  5155. 	@list($crypt, $salt) = explode(":", $pwd, 2);

    5156. 

  5156. 	if (EWRPT_CASE_SENSITIVE_PASSWORD) {

    5157. 

  5157. 		if (EWRPT_ENCRYPTED_PASSWORD) {

    5158. 

  5158. 			return ($pwd == ewrpt_EncryptPassword($input, @$salt));

    5159. 

  5159. 		} else {

    5160. 

  5160. 			return ($pwd == $input);

    5161. 

  5161. 		}

    5162. 

  5162. 	} else {

    5163. 

  5163. 		if (EWRPT_ENCRYPTED_PASSWORD) {

    5164. 

  5164. 			return ($pwd == ewrpt_EncryptPassword(strtolower($input), @$salt));

    5165. 

  5165. 		} else {

    5166. 

  5166. 			return (strtolower($pwd) == strtolower($input));

    5167. 

  5167. 		}

    5168. 

  5168. 	}

    5169. 

  5169. }

    5170. 

  5170. 

    5171. 

  5171. // Get domain URL

    5172. 

  5172. function ewrpt_DomainUrl() {

    5173. 

  5173. 	$sUrl = "http";

    5174. 

  5174. 	$bSSL = (ewrpt_ServerVar("HTTPS") <> "" && ewrpt_ServerVar("HTTPS") <> "off");

    5175. 

  5175. 	$sPort = strval(ewrpt_ServerVar("SERVER_PORT"));

    5176. 

  5176. 	$defPort = ($bSSL) ? "443" : "80";

    5177. 

  5177. 	$sPort = ($sPort == $defPort) ? "" : ":$sPort";

    5178. 

  5178. 	$sUrl .= ($bSSL) ? "s" : "";

    5179. 

  5179. 	$sUrl .= "://";

    5180. 

  5180. 	$sUrl .= ewrpt_ServerVar("SERVER_NAME") . $sPort;

    5181. 

  5181. 	return $sUrl;

    5182. 

  5182. }

    5183. 

  5183. 

    5184. 

  5184. // Get full URL

    5185. 

  5185. function ewrpt_FullUrl() {

    5186. 

  5186. 	return ewrpt_DomainUrl() . ewrpt_ScriptName();

    5187. 

  5187. }

    5188. 

  5188. 

    5189. 

  5189. // Get current URL

    5190. 

  5190. function ewrpt_CurrentUrl() {

    5191. 

  5191. 	$s = ewrpt_ScriptName();

    5192. 

  5192. 	$q = ewrpt_ServerVar("QUERY_STRING");

    5193. 

  5193. 	if ($q <> "") $s .= "?" . $q;

    5194. 

  5194. 	return $s;

    5195. 

  5195. }

    5196. 

  5196. 

    5197. 

  5197. // Convert to full URL

    5198. 

  5198. function ewrpt_ConvertFullUrl($url) {

    5199. 

  5199. 	if ($url == "") return "";

    5200. 

  5200. 	if (strpos($url, "://") === FALSE && strpos($url, "\\") === FALSE) {

    5201. 

  5201. 		$sUrl = ewrpt_FullUrl();

    5202. 

  5202. 		return substr($sUrl, 0, strrpos($sUrl, "/")+1) . $url;

    5203. 

  5203. 	} else {

    5204. 

  5204. 		return $url;

    5205. 

  5205. 	}

    5206. 

  5206. }

    5207. 

  5207. 

    5208. 

  5208. // Get script name

    5209. 

  5209. function ewrpt_ScriptName() {

    5210. 

  5210. 	$sn = ewrpt_ServerVar("PHP_SELF");

    5211. 

  5211. 	if (empty($sn)) $sn = ewrpt_ServerVar("SCRIPT_NAME");

    5212. 

  5212. 	if (empty($sn)) $sn = ewrpt_ServerVar("ORIG_PATH_INFO");

    5213. 

  5213. 	if (empty($sn)) $sn = ewrpt_ServerVar("ORIG_SCRIPT_NAME");

    5214. 

  5214. 	if (empty($sn)) $sn = ewrpt_ServerVar("REQUEST_URI");

    5215. 

  5215. 	if (empty($sn)) $sn = ewrpt_ServerVar("URL");

    5216. 

  5216. 	if (empty($sn)) $sn = "UNKNOWN";

    5217. 

  5217. 	return $sn;

    5218. 

  5218. }

    5219. 

  5219. 

    5220. 

  5220. // Remove XSS

    5221. 

  5221. function ewrpt_RemoveXSS($val) {

    5222. 

  5222. 

    5223. 

  5223. 	// remove all non-printable characters. CR(0a) and LF(0b) and TAB(9) are allowed

    5224. 

  5224. 	// this prevents some character re-spacing such as <java\0script>

    5225. 

  5225. 	// note that you have to handle splits with \n, \r, and \t later since they *are* allowed in some inputs

    5226. 

  5226. 

    5227. 

  5227. 	$val = preg_replace('/([\x00-\x08][\x0b-\x0c][\x0e-\x20])/', '', $val);

    5228. 

  5228. 

    5229. 

  5229. 	// straight replacements, the user should never need these since they're normal characters

    5230. 

  5230. 	// this prevents like <IMG SRC=&#X40&#X61&#X76&#X61&#X73&#X63&#X72&#X69&#X70&#X74&#X3A&#X61&#X6C&#X65&#X72&#X74&#X28&#X27&#X58&#X53&#X53&#X27&#X29>

    5231. 

  5231. 

    5232. 

  5232. 	$search = 'abcdefghijklmnopqrstuvwxyz';

    5233. 

  5233. 	$search .= 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';

    5234. 

  5234. 	$search .= '1234567890!@#$%^&*()';

    5235. 

  5235. 	$search .= '~`";:?+/={}[]-_|\'\\';

    5236. 

  5236. 	for ($i = 0; $i < strlen($search); $i++) {

    5237. 

  5237. 

    5238. 

  5238. 		// ;? matches the ;, which is optional

    5239. 

  5239. 		// 0{0,7} matches any padded zeros, which are optional and go up to 8 chars

    5240. 

  5240. 		// &#x0040 @ search for the hex values

    5241. 

  5241. 

    5242. 

  5242. 		$val = preg_replace('/(&#[x|X]0{0,8}'.dechex(ord($search[$i])).';?)/i', $search[$i], $val); // with a ;

    5243. 

  5243. 

    5244. 

  5244. 		// &#00064 @ 0{0,7} matches '0' zero to seven times

    5245. 

  5245. 		$val = preg_replace('/(&#0{0,8}'.ord($search[$i]).';?)/', $search[$i], $val); // with a ;

    5246. 

  5246. 	}

    5247. 

  5247. 

    5248. 

  5248. 	// now the only remaining whitespace attacks are \t, \n, and \r 

    5249. 

  5249. 	$ra = $GLOBALS["EWRPT_XSS_ARRAY"]; // Note: Customize $EWRPT_XSS_ARRAY in ewrcfg*.php

    5250. 

  5250. 	$found = true; // keep replacing as long as the previous round replaced something

    5251. 

  5251. 	while ($found == true) {

    5252. 

  5252. 		$val_before = $val;

    5253. 

  5253. 		for ($i = 0; $i < sizeof($ra); $i++) {

    5254. 

  5254. 			$pattern = '/';

    5255. 

  5255. 			for ($j = 0; $j < strlen($ra[$i]); $j++) { 

    5256. 

  5256. 				if ($j > 0) {

    5257. 

  5257. 					$pattern .= '('; 

    5258. 

  5258. 					$pattern .= '(&#[x|X]0{0,8}([9][a][b]);?)?'; 

    5259. 

  5259. 					$pattern .= '|(&#0{0,8}([9][10][13]);?)?'; 

    5260. 

  5260. 					$pattern .= ')?'; 

    5261. 

  5261. 				}

    5262. 

  5262. 				$pattern .= $ra[$i][$j];

    5263. 

  5263. 			}

    5264. 

  5264. 			$pattern .= '/i';

    5265. 

  5265. 			$replacement = substr($ra[$i], 0, 2).'<x>'.substr($ra[$i], 2); // add in <> to nerf the tag

    5266. 

  5266. 			$val = preg_replace($pattern, $replacement, $val); // filter out the hex tags

    5267. 

  5267. 			if ($val_before == $val) {

    5268. 

  5268. 

    5269. 

  5269. 				// no replacements were made, so exit the loop

    5270. 

  5270. 				$found = false;

    5271. 

  5271. 			}

    5272. 

  5272. 		}

    5273. 

  5273. 	}

    5274. 

  5274. 	return $val;

    5275. 

  5275. }

    5276. 

  5276. 

    5277. 

  5277. // Load selection from a filter clause

    5278. 

  5278. function ewrpt_LoadSelectionFromFilter(&$fld, $filter, &$sel) {

    5279. 

  5279. 	$sel = "";

    5280. 

  5280. 	if ($filter <> "") {

    5281. 

  5281. 		$sSql = ewrpt_BuildReportSql($fld->SqlSelect, "", "", "", $fld->SqlOrderBy, $filter, "");

    5282. 

  5282. 		ewrpt_LoadArrayFromSql($sSql, $sel);

    5283. 

  5283. 	}

    5284. 

  5284. }

    5285. 

  5285. 

    5286. 

  5286. // Build dropdown filter

    5287. 

  5287. function ewrpt_BuildDropDownFilter(&$fld, &$FilterClause, $FldOpr) {

    5288. 

  5288. 	$FldVal = $fld->DropDownValue;

    5289. 

  5289. 	$sSql = "";

    5290. 

  5290. 	if (is_array($FldVal)) {

    5291. 

  5291. 		foreach ($FldVal as $val) {

    5292. 

  5292. 			$sWrk = ewrpt_GetDropDownfilter($fld, $val, $FldOpr);

    5293. 

  5293. 			if ($sWrk <> "") {

    5294. 

  5294. 				if ($sSql <> "")

    5295. 

  5295. 					$sSql .= " OR " . $sWrk;

    5296. 

  5296. 				else

    5297. 

  5297. 					$sSql = $sWrk;

    5298. 

  5298. 			}

    5299. 

  5299. 		}

    5300. 

  5300. 	} else {

    5301. 

  5301. 		$sSql = ewrpt_GetDropDownfilter($fld, $FldVal, $FldOpr);

    5302. 

  5302. 	}

    5303. 

  5303. 	if ($sSql <> "") {

    5304. 

  5304. 		if ($FilterClause <> "") $FilterClause = "(" . $FilterClause . ") AND ";

    5305. 

  5305. 		$FilterClause .= "(" . $sSql . ")";

    5306. 

  5306. 	}

    5307. 

  5307. }

    5308. 

  5308. 

    5309. 

  5309. function ewrpt_GetDropDownfilter(&$fld, $FldVal, $FldOpr) {

    5310. 

  5310. 	$FldName = $fld->FldName;

    5311. 

  5311. 	$FldExpression = $fld->FldExpression;

    5312. 

  5312. 	$FldDataType = $fld->FldDataType;

    5313. 

  5313. 	$sWrk = "";

    5314. 

  5314. 	if ($FldVal == EWRPT_NULL_VALUE) {

    5315. 

  5315. 		$sWrk = $FldExpression . " IS NULL";

    5316. 

  5316. 	} elseif ($FldVal == EWRPT_NOT_NULL_VALUE) {

    5317. 

  5317. 		$sWrk = $FldExpression . " IS NOT NULL";

    5318. 

  5318. 	} elseif ($FldVal == EWRPT_EMPTY_VALUE) {

    5319. 

  5319. 		$sWrk = $FldExpression . " = ''";

    5320. 

  5320. 	} else {

    5321. 

  5321. 		if (substr($FldVal, 0, 2) == "@@") {

    5322. 

  5322. 			$sWrk = ewrpt_GetCustomFilter($fld, $FldVal);

    5323. 

  5323. 		} else {

    5324. 

  5324. 			if ($FldVal <> "" && $FldVal <> EWRPT_INIT_VALUE && $FldVal <> EWRPT_ALL_VALUE) {

    5325. 

  5325. 				if ($FldDataType == EWRPT_DATATYPE_DATE && $FldOpr <> "") {

    5326. 

  5326. 					$sWrk = ewrpt_DateFilterString($FldOpr, $FldVal, $FldDataType);

    5327. 

  5327. 				} else {

    5328. 

  5328. 					$sWrk = ewrpt_FilterString("=", $FldVal, $FldDataType);

    5329. 

  5329. 				}

    5330. 

  5330. 			}

    5331. 

  5331. 			if ($sWrk <> "") $sWrk = $FldExpression . $sWrk;

    5332. 

  5332. 		}

    5333. 

  5333. 	}

    5334. 

  5334. 	return $sWrk;

    5335. 

  5335. }

    5336. 

  5336. 

    5337. 

  5337. // Get extended filter

    5338. 

  5338. function ewrpt_BuildExtendedFilter(&$fld, &$FilterClause) {

    5339. 

  5339. 	$FldName = $fld->FldName;

    5340. 

  5340. 	$FldExpression = $fld->FldExpression;

    5341. 

  5341. 	$FldDataType = $fld->FldDataType;

    5342. 

  5342. 	$FldDateTimeFormat = $fld->FldDateTimeFormat;

    5343. 

  5343. 	$FldVal1 = $fld->SearchValue;

    5344. 

  5344. 	$FldOpr1 = $fld->SearchOperator;

    5345. 

  5345. 	$FldCond = $fld->SearchCondition;

    5346. 

  5346. 	$FldVal2 = $fld->SearchValue2;

    5347. 

  5347. 	$FldOpr2 = $fld->SearchOperator2;

    5348. 

  5348. 	$sWrk = "";

    5349. 

  5349. 	$FldOpr1 = strtoupper(trim($FldOpr1));

    5350. 

  5350. 	if ($FldOpr1 == "") $FldOpr1 = "=";

    5351. 

  5351. 	$FldOpr2 = strtoupper(trim($FldOpr2));

    5352. 

  5352. 	if ($FldOpr2 == "") $FldOpr2 = "=";

    5353. 

  5353. 	$wrkFldVal1 = $FldVal1;

    5354. 

  5354. 	$wrkFldVal2 = $FldVal2;

    5355. 

  5355. 	if ($FldDataType == EWRPT_DATATYPE_BOOLEAN) {

    5356. 

  5356. 		if (EWRPT_IS_MSACCESS) {

    5357. 

  5357. 			if ($wrkFldVal1 <> "") $wrkFldVal1 = ($wrkFldVal1 == "1") ? "True" : "False";

    5358. 

  5358. 			if ($wrkFldVal2 <> "") $wrkFldVal2 = ($wrkFldVal2 == "1") ? "True" : "False";

    5359. 

  5359. 		} else {

    5360. 

  5360. 

    5361. 

  5361. 			//if ($wrkFldVal1 <> "") $wrkFldVal1 = ($wrkFldVal1 == "1") ? EWRPT_TRUE_STRING : EWRPT_FALSE_STRING;

    5362. 

  5362. 			//if ($wrkFldVal2 <> "") $wrkFldVal2 = ($wrkFldVal2 == "1") ? EWRPT_TRUE_STRING : EWRPT_FALSE_STRING;

    5363. 

  5363. 

    5364. 

  5364. 			if ($wrkFldVal1 <> "") $wrkFldVal1 = ($wrkFldVal1 == "1") ? "1" : "0";

    5365. 

  5365. 			if ($wrkFldVal2 <> "") $wrkFldVal2 = ($wrkFldVal2 == "1") ? "1" : "0";

    5366. 

  5366. 		}

    5367. 

  5367. 	} elseif ($FldDataType == EWRPT_DATATYPE_DATE) {

    5368. 

  5368. 		if ($wrkFldVal1 <> "") $wrkFldVal1 = ewrpt_UnFormatDateTime($wrkFldVal1, $FldDateTimeFormat);

    5369. 

  5369. 		if ($wrkFldVal2 <> "") $wrkFldVal2 = ewrpt_UnFormatDateTime($wrkFldVal2, $FldDateTimeFormat);

    5370. 

  5370. 	}

    5371. 

  5371. 	if ($FldOpr1 == "BETWEEN") {

    5372. 

  5372. 		$IsValidValue = ($FldDataType <> EWRPT_DATATYPE_NUMBER ||

    5373. 

  5373. 			($FldDataType == EWRPT_DATATYPE_NUMBER && is_numeric($wrkFldVal1) && is_numeric($wrkFldVal2)));

    5374. 

  5374. 		if ($wrkFldVal1 <> "" && $wrkFldVal2 <> "" && $IsValidValue)

    5375. 

  5375. 			$sWrk = $FldExpression . " BETWEEN " . ewrpt_QuotedValue($wrkFldVal1, $FldDataType) .

    5376. 

  5376. 				" AND " . ewrpt_QuotedValue($wrkFldVal2, $FldDataType);

    5377. 

  5377. 	} elseif ($FldVal1 == EWRPT_NULL_VALUE || $FldOpr1 == "IS NULL") {

    5378. 

  5378.         $sWrk = $FldExpression . " IS NULL";

    5379. 

  5379.     } elseif ($FldVal1 == EWRPT_NOT_NULL_VALUE || $FldOpr1 == "IS NOT NULL") {

    5380. 

  5380.         $sWrk = $FldExpression . " IS NOT NULL";

    5381. 

  5381. 	} else {

    5382. 

  5382. 		$IsValidValue = ($FldDataType <> EWRPT_DATATYPE_NUMBER ||

    5383. 

  5383. 			($FldDataType == EWRPT_DATATYPE_NUMBER && is_numeric($wrkFldVal1)));

    5384. 

  5384. 		if ($wrkFldVal1 <> "" && $IsValidValue && ewrpt_IsValidOpr($FldOpr1, $FldDataType))

    5385. 

  5385. 			$sWrk = $FldExpression . ewrpt_FilterString($FldOpr1, $wrkFldVal1, $FldDataType);

    5386. 

  5386. 		$IsValidValue = ($FldDataType <> EWRPT_DATATYPE_NUMBER ||

    5387. 

  5387. 			($FldDataType == EWRPT_DATATYPE_NUMBER && is_numeric($wrkFldVal2)));

    5388. 

  5388. 		if ($wrkFldVal2 <> "" && $IsValidValue && ewrpt_IsValidOpr($FldOpr2, $FldDataType)) {

    5389. 

  5389. 			if ($sWrk <> "")

    5390. 

  5390. 				$sWrk .= " " . (($FldCond == "OR") ? "OR" : "AND") . " ";

    5391. 

  5391. 			$sWrk .= $FldExpression . ewrpt_FilterString($FldOpr2, $wrkFldVal2, $FldDataType);

    5392. 

  5392. 		}

    5393. 

  5393. 	}

    5394. 

  5394. 	if ($sWrk <> "") {

    5395. 

  5395. 		if ($FilterClause <> "") $FilterClause .= " AND ";

    5396. 

  5396. 		$FilterClause .= "(" . $sWrk . ")";

    5397. 

  5397. 	}

    5398. 

  5398. }

    5399. 

  5399. 

    5400. 

  5400. // Return filter string

    5401. 

  5401. function ewrpt_FilterString($FldOpr, $FldVal, $FldType) {

    5402. 

  5402. 	if ($FldOpr == "LIKE" || $FldOpr == "NOT LIKE") {

    5403. 

  5403. 		return " " . $FldOpr . " " . ewrpt_QuotedValue("%$FldVal%", $FldType);

    5404. 

  5404. 	} elseif ($FldOpr == "STARTS WITH") {

    5405. 

  5405. 		return " LIKE " . ewrpt_QuotedValue("$FldVal%", $FldType);

    5406. 

  5406. 	} else {

    5407. 

  5407. 		return " $FldOpr " . ewrpt_QuotedValue($FldVal, $FldType);

    5408. 

  5408. 	}

    5409. 

  5409. }

    5410. 

  5410. 

    5411. 

  5411. // Return date search string

    5412. 

  5412. function ewrpt_DateFilterString($FldOpr, $FldVal, $FldType) {

    5413. 

  5413. 	$wrkVal1 = ewrpt_DateVal($FldOpr, $FldVal, 1);

    5414. 

  5414. 	$wrkVal2 = ewrpt_DateVal($FldOpr, $FldVal, 2);

    5415. 

  5415. 	if ($wrkVal1 <> "" && $wrkVal2 <> "") {

    5416. 

  5416. 		return " BETWEEN " . ewrpt_QuotedValue($wrkVal1, $FldType) . " AND " . ewrpt_QuotedValue($wrkVal2, $FldType);

    5417. 

  5417. 	} else {

    5418. 

  5418. 		return "";

    5419. 

  5419. 	}

    5420. 

  5420. }

    5421. 

  5421. 

    5422. 

  5422. /**

    5423. 

  5423.  * Validation functions

    5424. 

  5424.  */

    5425. 

  5425. 

    5426. 

  5426. // Check date format

    5427. 

  5427. // format: std/us/euro

    5428. 

  5428. function ewrpt_CheckDateEx($value, $format, $sep) {

    5429. 

  5429. 	if (strval($value) == "")	return TRUE;

    5430. 

  5430. 	while (strpos($value, "  ") !== FALSE)

    5431. 

  5431. 		$value = str_replace("  ", " ", $value);

    5432. 

  5432. 	$value = trim($value);

    5433. 

  5433. 	$arDT = explode(" ", $value);

    5434. 

  5434. 	if (count($arDT) > 0) {

    5435. 

  5435. 		$wrksep = "\\$sep";

    5436. 

  5436. 		switch ($format) {

    5437. 

  5437. 			case "std":

    5438. 

  5438. 				$pattern = '/^([0-9]{4})' . $wrksep . '([0]?[1-9]|[1][0-2])' . $wrksep . '([0]?[1-9]|[1|2][0-9]|[3][0|1])$/';

    5439. 

  5439. 				break;

    5440. 

  5440. 			case "stdshort":

    5441. 

  5441. 				$pattern = '/^([0-9]{2})' . $wrksep . '([0]?[1-9]|[1][0-2])' . $wrksep . '([0]?[1-9]|[1|2][0-9]|[3][0|1])$/';

    5442. 

  5442. 				break;

    5443. 

  5443. 			case "us":

    5444. 

  5444. 				$pattern = '/^([0]?[1-9]|[1][0-2])' . $wrksep . '([0]?[1-9]|[1|2][0-9]|[3][0|1])' . $wrksep . '([0-9]{4})$/';

    5445. 

  5445. 				break;

    5446. 

  5446. 			case "usshort":

    5447. 

  5447. 				$pattern = '/^([0]?[1-9]|[1][0-2])' . $wrksep . '([0]?[1-9]|[1|2][0-9]|[3][0|1])' . $wrksep . '([0-9]{2})$/';

    5448. 

  5448. 				break;

    5449. 

  5449. 			case "euro":

    5450. 

  5450. 				$pattern = '/^([0]?[1-9]|[1|2][0-9]|[3][0|1])' . $wrksep . '([0]?[1-9]|[1][0-2])' . $wrksep . '([0-9]{4})$/';

    5451. 

  5451. 				break;

    5452. 

  5452. 			case "euroshort":

    5453. 

  5453. 				$pattern = '/^([0]?[1-9]|[1|2][0-9]|[3][0|1])' . $wrksep . '([0]?[1-9]|[1][0-2])' . $wrksep . '([0-9]{2})$/';

    5454. 

  5454. 				break;

    5455. 

  5455. 		}

    5456. 

  5456. 		if (!preg_match($pattern, $arDT[0])) return FALSE;

    5457. 

  5457. 		$arD = explode(EWRPT_DATE_SEPARATOR, $arDT[0]);

    5458. 

  5458. 		switch ($format) {

    5459. 

  5459. 			case "std":

    5460. 

  5460. 			case "stdshort":

    5461. 

  5461. 				$sYear = ewrpt_UnformatYear($arD[0]);

    5462. 

  5462. 				$sMonth = $arD[1];

    5463. 

  5463. 				$sDay = $arD[2];

    5464. 

  5464. 				break;

    5465. 

  5465. 			case "us":

    5466. 

  5466. 			case "usshort":

    5467. 

  5467. 				$sYear = ewrpt_UnformatYear($arD[2]);

    5468. 

  5468. 				$sMonth = $arD[0];

    5469. 

  5469. 				$sDay = $arD[1];

    5470. 

  5470. 				break;

    5471. 

  5471. 			case "euro":

    5472. 

  5472. 			case "euroshort":

    5473. 

  5473. 				$sYear = ewrpt_UnformatYear($arD[2]);

    5474. 

  5474. 				$sMonth = $arD[1];

    5475. 

  5475. 				$sDay = $arD[0];

    5476. 

  5476. 				break;

    5477. 

  5477. 		}

    5478. 

  5478. 		if (!ewrpt_CheckDay($sYear, $sMonth, $sDay)) return FALSE;

    5479. 

  5479. 	}

    5480. 

  5480. 	if (count($arDT) > 1 && !ewrpt_CheckTime($arDT[1])) return FALSE;

    5481. 

  5481. 	return TRUE;

    5482. 

  5482. }

    5483. 

  5483. 

    5484. 

  5484. // Unformat 2 digit year to 4 digit year

    5485. 

  5485. function ewrpt_UnformatYear($yr) {

    5486. 

  5486. 	if (strlen($yr) == 2) {

    5487. 

  5487. 		if ($yr > EWRPT_UNFORMAT_YEAR)

    5488. 

  5488. 			return "19" . $yr;

    5489. 

  5489. 		else

    5490. 

  5490. 			return "20" . $yr;

    5491. 

  5491. 	} else {

    5492. 

  5492. 		return $yr;

    5493. 

  5493. 	}

    5494. 

  5494. }

    5495. 

  5495. 

    5496. 

  5496. // Check Date format (yyyy/mm/dd)

    5497. 

  5497. function ewrpt_CheckDate($value) {

    5498. 

  5498. 	return ewrpt_CheckDateEx($value, "std", EWRPT_DATE_SEPARATOR);

    5499. 

  5499. }

    5500. 

  5500. 

    5501. 

  5501. // Check Date format (yy/mm/dd)

    5502. 

  5502. function ewrpt_CheckShortDate($value) {

    5503. 

  5503. 	return ewrpt_CheckDateEx($value, "stdshort", EWRPT_DATE_SEPARATOR);

    5504. 

  5504. }

    5505. 

  5505. 

    5506. 

  5506. // Check US Date format (mm/dd/yyyy)

    5507. 

  5507. function ewrpt_CheckUSDate($value) {

    5508. 

  5508. 	return ewrpt_CheckDateEx($value, "us", EWRPT_DATE_SEPARATOR);

    5509. 

  5509. }

    5510. 

  5510. 

    5511. 

  5511. // Check US Date format (mm/dd/yy)

    5512. 

  5512. function ewrpt_CheckShortUSDate($value) {

    5513. 

  5513. 	return ewrpt_CheckDateEx($value, "usshort", EWRPT_DATE_SEPARATOR);

    5514. 

  5514. }

    5515. 

  5515. 

    5516. 

  5516. // Check Euro Date format (dd/mm/yyyy)

    5517. 

  5517. function ewrpt_CheckEuroDate($value) {

    5518. 

  5518. 	return ewrpt_CheckDateEx($value, "euro", EWRPT_DATE_SEPARATOR);

    5519. 

  5519. }

    5520. 

  5520. 

    5521. 

  5521. // Check Euro Date format (dd/mm/yy)

    5522. 

  5522. function ewrpt_CheckShortEuroDate($value) {

    5523. 

  5523. 	return ewrpt_CheckDateEx($value, "euroshort", EWRPT_DATE_SEPARATOR);

    5524. 

  5524. }

    5525. 

  5525. 

    5526. 

  5526. // Check day

    5527. 

  5527. function ewrpt_CheckDay($checkYear, $checkMonth, $checkDay) {

    5528. 

  5528. 	$maxDay = 31;

    5529. 

  5529. 	if ($checkMonth == 4 || $checkMonth == 6 ||	$checkMonth == 9 || $checkMonth == 11) {

    5530. 

  5530. 		$maxDay = 30;

    5531. 

  5531. 	} elseif ($checkMonth == 2)	{

    5532. 

  5532. 		if ($checkYear % 4 > 0) {

    5533. 

  5533. 			$maxDay = 28;

    5534. 

  5534. 		} elseif ($checkYear % 100 == 0 && $checkYear % 400 > 0) {

    5535. 

  5535. 			$maxDay = 28;

    5536. 

  5536. 		} else {

    5537. 

  5537. 			$maxDay = 29;

    5538. 

  5538. 		}

    5539. 

  5539. 	}

    5540. 

  5540. 	return ewrpt_CheckRange($checkDay, 1, $maxDay);

    5541. 

  5541. }

    5542. 

  5542. 

    5543. 

  5543. // Check integer

    5544. 

  5544. function ewrpt_CheckInteger($value) {

    5545. 

  5545. 	if (strval($value) == "")	return TRUE;

    5546. 

  5546. 	return preg_match('/^\-?\+?[0-9]+$/', $value);

    5547. 

  5547. }

    5548. 

  5548. 

    5549. 

  5549. // Check number range

    5550. 

  5550. function ewrpt_NumberRange($value, $min, $max) {

    5551. 

  5551. 	if ((!is_null($min) && $value < $min) ||

    5552. 

  5552. 		(!is_null($max) && $value > $max))

    5553. 

  5553. 		return FALSE;

    5554. 

  5554. 	return TRUE;

    5555. 

  5555. }

    5556. 

  5556. 

    5557. 

  5557. // Check number

    5558. 

  5558. function ewrpt_CheckNumber($value) {

    5559. 

  5559. 	if (strval($value) == "")	return TRUE;

    5560. 

  5560. 	return is_numeric(trim($value));

    5561. 

  5561. }

    5562. 

  5562. 

    5563. 

  5563. // Check range

    5564. 

  5564. function ewrpt_CheckRange($value, $min, $max) {

    5565. 

  5565. 	if (strval($value) == "")	return TRUE;

    5566. 

  5566. 	if (!ewrpt_CheckNumber($value)) return FALSE;

    5567. 

  5567. 	return ewrpt_NumberRange($value, $min, $max);

    5568. 

  5568. }

    5569. 

  5569. 

    5570. 

  5570. // Check time

    5571. 

  5571. function ewrpt_CheckTime($value) {

    5572. 

  5572. 	if (strval($value) == "")	return TRUE;

    5573. 

  5573. 	return preg_match('/^(0[0-9]|1[0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9]$/', $value);

    5574. 

  5574. }

    5575. 

  5575. 

    5576. 

  5576. // Check US phone number

    5577. 

  5577. function ewrpt_CheckPhone($value) {

    5578. 

  5578. 	if (strval($value) == "")	return TRUE;

    5579. 

  5579. 	return preg_match('/^\(\d{3}\) ?\d{3}( |-)?\d{4}|^\d{3}( |-)?\d{3}( |-)?\d{4}$/', $value);

    5580. 

  5580. }

    5581. 

  5581. 

    5582. 

  5582. // Check US zip code

    5583. 

  5583. function ewrpt_CheckZip($value) {

    5584. 

  5584. 	if (strval($value) == "")	return TRUE;

    5585. 

  5585. 	return preg_match('/^\d{5}$|^\d{5}-\d{4}$/', $value);

    5586. 

  5586. }

    5587. 

  5587. 

    5588. 

  5588. // Check credit card

    5589. 

  5589. function ewrpt_CheckCreditCard($value, $type="") {

    5590. 

  5590. 	if (strval($value) == "")	return TRUE;

    5591. 

  5591. 	$creditcard = array("visa" => "/^4\d{3}[ -]?\d{4}[ -]?\d{4}[ -]?\d{4}$/",

    5592. 

  5592. 		"mastercard" => "/^5[1-5]\d{2}[ -]?\d{4}[ -]?\d{4}[ -]?\d{4}$/",

    5593. 

  5593. 		"discover" => "/^6011[ -]?\d{4}[ -]?\d{4}[ -]?\d{4}$/",

    5594. 

  5594. 		"amex" => "/^3[4,7]\d{13}$/",

    5595. 

  5595. 		"diners" => "/^3[0,6,8]\d{12}$/",

    5596. 

  5596. 		"bankcard" => "/^5610[ -]?\d{4}[ -]?\d{4}[ -]?\d{4}$/",

    5597. 

  5597. 		"jcb" => "/^[3088|3096|3112|3158|3337|3528]\d{12}$/",

    5598. 

  5598. 		"enroute" => "/^[2014|2149]\d{11}$/",

    5599. 

  5599. 		"switch" => "/^[4903|4911|4936|5641|6333|6759|6334|6767]\d{12}$/");

    5600. 

  5600. 	if (empty($type))	{

    5601. 

  5601. 		$match = FALSE;

    5602. 

  5602. 		foreach ($creditcard as $type => $pattern) {

    5603. 

  5603. 			if (@preg_match($pattern, $value) == 1) {

    5604. 

  5604. 				$match = TRUE;

    5605. 

  5605. 				break;

    5606. 

  5606. 			}

    5607. 

  5607. 		}

    5608. 

  5608. 		return ($match) ? ewrpt_CheckSum($value) : FALSE;

    5609. 

  5609. 	}	else {

    5610. 

  5610. 		if (!preg_match($creditcard[strtolower(trim($type))], $value)) return FALSE;

    5611. 

  5611. 		return ewrpt_CheckSum($value);

    5612. 

  5612. 	}

    5613. 

  5613. }

    5614. 

  5614. 

    5615. 

  5615. // Check sum

    5616. 

  5616. function ewrpt_CheckSum($value) {

    5617. 

  5617. 	$value = str_replace(array('-',' '), array('',''), $value);

    5618. 

  5618. 	$checksum = 0;

    5619. 

  5619. 	for ($i=(2-(strlen($value) % 2)); $i<=strlen($value); $i+=2)

    5620. 

  5620. 		$checksum += (int)($value[$i-1]);

    5621. 

  5621.   for ($i=(strlen($value)%2)+1; $i <strlen($value); $i+=2) {

    5622. 

  5622. 	  $digit = (int)($value[$i-1]) * 2;

    5623. 

  5623. 		$checksum += ($digit < 10) ? $digit : ($digit-9);

    5624. 

  5624.   }

    5625. 

  5625. 	return ($checksum % 10 == 0);

    5626. 

  5626. }

    5627. 

  5627. 

    5628. 

  5628. // Check US social security number

    5629. 

  5629. function ewrpt_CheckSSC($value) {

    5630. 

  5630. 	if (strval($value) == "")	return TRUE;

    5631. 

  5631. 	return preg_match('/^(?!000)([0-6]\d{2}|7([0-6]\d|7[012]))([ -]?)(?!00)\d\d\3(?!0000)\d{4}$/', $value);

    5632. 

  5632. }

    5633. 

  5633. 

    5634. 

  5634. // Check emails

    5635. 

  5635. function ewrpt_CheckEmailList($value, $email_cnt) {

    5636. 

  5636. 	if (strval($value) == "")	return TRUE;

    5637. 

  5637. 	$emailList = str_replace(",", ";", $value);

    5638. 

  5638. 	$arEmails = explode(";", $emailList);

    5639. 

  5639. 	$cnt = count($arEmails);

    5640. 

  5640. 	if ($cnt > $email_cnt && $email_cnt > 0)

    5641. 

  5641. 		return FALSE;

    5642. 

  5642. 	foreach ($arEmails as $email) {

    5643. 

  5643. 		if (!ewrpt_CheckEmail($email))

    5644. 

  5644. 			return FALSE;

    5645. 

  5645. 	}

    5646. 

  5646. 	return TRUE;

    5647. 

  5647. }

    5648. 

  5648. 

    5649. 

  5649. // Check email

    5650. 

  5650. function ewrpt_CheckEmail($value) {

    5651. 

  5651. 	if (strval($value) == "")	return TRUE;

    5652. 

  5652. 

    5653. 

  5653. 	//return preg_match('/^[A-Za-z0-9\._\-+]+@[A-Za-z0-9_\-+]+(\.[A-Za-z0-9_\-+]+)+$/', trim($value));

    5654. 

  5654. 	return preg_match('/^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,6}$/i', trim($value));

    5655. 

  5655. }

    5656. 

  5656. 

    5657. 

  5657. // Check GUID

    5658. 

  5658. function ewrpt_CheckGUID($value) {

    5659. 

  5659. 	if (strval($value) == "")	return TRUE;

    5660. 

  5660. 	$p1 = '/^{{1}([0-9a-fA-F]){8}-([0-9a-fA-F]){4}-([0-9a-fA-F]){4}-([0-9a-fA-F]){4}-([0-9a-fA-F]){12}}{1}$/';

    5661. 

  5661. 	$p2 = '/^([0-9a-fA-F]){8}-([0-9a-fA-F]){4}-([0-9a-fA-F]){4}-([0-9a-fA-F]){4}-([0-9a-fA-F]){12}$/';

    5662. 

  5662. 	return preg_match($p1, $value) || preg_match($p2, $value);

    5663. 

  5663. }

    5664. 

  5664. 

    5665. 

  5665. // Check by preg

    5666. 

  5666. function ewrpt_CheckByRegEx($value, $pattern) {

    5667. 

  5667. 	if (strval($value) == "") return TRUE;

    5668. 

  5668. 	return preg_match($pattern, $value);

    5669. 

  5669. }

    5670. 

  5670. 

    5671. 

  5671. /**

    5672. 

  5672.  * End Validation functions

    5673. 

  5673.  */

    5674. 

  5674. 

    5675. 

  5675. // Upload path

    5676. 

  5676. // If PhyPath is TRUE(1), return physical path on the server

    5677. 

  5677. // If PhyPath is FALSE(0), return relative URL

    5678. 

  5678. function ewrpt_UploadPathEx($PhyPath, $DestPath) {

    5679. 

  5679. 	if ($PhyPath) {

    5680. 

  5680. 		$Path = ewrpt_PathCombine(ewrpt_AppRoot(), str_replace("/", EWRPT_PATH_DELIMITER, $DestPath), TRUE);

    5681. 

  5681. 	} else {

    5682. 

  5682. 		$Path = EWRPT_ROOT_RELATIVE_PATH;

    5683. 

  5683. 		$Path = str_replace("\\\\", "/", $Path);

    5684. 

  5684. 		$Path = str_replace("\\", "/", $Path);

    5685. 

  5685. 		$Path = ewrpt_PathCombine(ewrpt_IncludeTrailingDelimiter($Path, FALSE), $DestPath, FALSE);

    5686. 

  5686. 	}

    5687. 

  5687. 	return ewrpt_IncludeTrailingDelimiter($Path, $PhyPath);

    5688. 

  5688. }

    5689. 

  5689. 

    5690. 

  5690. // Get a temp folder for temp file

    5691. 

  5691. function ewrpt_TmpFolder() {

    5692. 

  5692. 	$tmpfolder = NULL;

    5693. 

  5693. 	$folders = array();

    5694. 

  5694. 	if (EWRPT_IS_WINDOWS) {

    5695. 

  5695. 		$folders[] = ewrpt_ServerVar("TEMP");

    5696. 

  5696. 		$folders[] = ewrpt_ServerVar("TMP");

    5697. 

  5697. 	} else {

    5698. 

  5698. 		if (EWRPT_UPLOAD_TMP_PATH <> "") $folders[] = ewrpt_AppRoot() . str_replace("/", EWRPT_PATH_DELIMITER, EWRPT_UPLOAD_TMP_PATH);

    5699. 

  5699. 		$folders[] = '/tmp';

    5700. 

  5700. 	}

    5701. 

  5701. 	if (ini_get('upload_tmp_dir')) {

    5702. 

  5702. 		$folders[] = ini_get('upload_tmp_dir');

    5703. 

  5703. 	}

    5704. 

  5704. 	foreach ($folders as $folder) {

    5705. 

  5705. 		if (!$tmpfolder && is_dir($folder)) {

    5706. 

  5706. 			$tmpfolder = $folder;

    5707. 

  5707. 		}

    5708. 

  5708. 	}

    5709. 

  5709. 

    5710. 

  5710. 	//if ($tmpfolder) $tmpfolder = ewrpt_IncludeTrailingDelimiter($tmpfolder, TRUE);

    5711. 

  5711. 	return $tmpfolder;

    5712. 

  5712. }

    5713. 

  5713. 

    5714. 

  5714. // Application root

    5715. 

  5715. function ewrpt_AppRoot() {

    5716. 

  5716. 

    5717. 

  5717. 	// 1. use root relative path

    5718. 

  5718. 	if (EWRPT_ROOT_RELATIVE_PATH <> "") {

    5719. 

  5719. 		$Path = realpath(EWRPT_ROOT_RELATIVE_PATH);

    5720. 

  5720. 		$Path = str_replace("\\\\", EWRPT_PATH_DELIMITER, $Path);

    5721. 

  5721. 	}

    5722. 

  5722. 

    5723. 

  5723. 	// 2. if empty, use the document root if available

    5724. 

  5724. 	if (empty($Path)) $Path = ewrpt_ServerVar("DOCUMENT_ROOT");

    5725. 

  5725. 

    5726. 

  5726. 	// 3. if empty, use current folder

    5727. 

  5727. 	if (empty($Path)) $Path = realpath(".");

    5728. 

  5728. 

    5729. 

  5729. 	// 4. use custom path, uncomment the following line and enter your path

    5730. 

  5730. 	// e.g. $Path = 'C:\Inetpub\wwwroot\MyWebRoot'; // Windows

    5731. 

  5731. 	//$Path = 'enter your path here';

    5732. 

  5732. 

    5733. 

  5733. 	if (empty($Path)) die("Path of website root unknown.");

    5734. 

  5734. 	return ewrpt_IncludeTrailingDelimiter($Path, TRUE);

    5735. 

  5735. }

    5736. 

  5736. 

    5737. 

  5737. // Get path relative to application root

    5738. 

  5738. function ewrpt_ServerMapPath($Path) {

    5739. 

  5739. 	return ewrpt_PathCombine(ewrpt_AppRoot(), $Path, TRUE);

    5740. 

  5740. }

    5741. 

  5741. 

    5742. 

  5742. // Get path relative to a base path

    5743. 

  5743. function ewrpt_PathCombine($BasePath, $RelPath, $PhyPath) {

    5744. 

  5744. 	$BasePath = ewrpt_RemoveTrailingDelimiter($BasePath, $PhyPath);

    5745. 

  5745. 	if ($PhyPath) {

    5746. 

  5746. 		$Delimiter = EWRPT_PATH_DELIMITER;

    5747. 

  5747. 		$RelPath = str_replace('/', EWRPT_PATH_DELIMITER, $RelPath);

    5748. 

  5748. 		$RelPath = str_replace('\\', EWRPT_PATH_DELIMITER, $RelPath);

    5749. 

  5749. 	} else {

    5750. 

  5750. 		$Delimiter = '/';

    5751. 

  5751. 		$RelPath = str_replace('\\', '/', $RelPath);

    5752. 

  5752. 	}

    5753. 

  5753. 	if ($RelPath == '.' || $RelPath == '..') $RelPath .= $Delimiter;

    5754. 

  5754. 	$p1 = strpos($RelPath, $Delimiter);

    5755. 

  5755. 	$Path2 = "";

    5756. 

  5756. 	while ($p1 !== FALSE) {

    5757. 

  5757. 		$Path = substr($RelPath, 0, $p1 + 1);

    5758. 

  5758. 		if ($Path == $Delimiter || $Path == ".$Delimiter") {

    5759. 

  5759. 

    5760. 

  5760. 			// Skip

    5761. 

  5761. 		} elseif ($Path == "..$Delimiter") {

    5762. 

  5762. 			$p2 = strrpos($BasePath, $Delimiter);

    5763. 

  5763. 			if ($p2 !== FALSE) $BasePath = substr($BasePath, 0, $p2);

    5764. 

  5764. 		} else {

    5765. 

  5765. 			$Path2 .= $Path;

    5766. 

  5766. 		}

    5767. 

  5767. 		$RelPath = substr($RelPath, $p1+1);

    5768. 

  5768. 		if ($RelPath === FALSE)

    5769. 

  5769. 			$RelPath = "";

    5770. 

  5770. 		$p1 = strpos($RelPath, $Delimiter);

    5771. 

  5771. 	}

    5772. 

  5772. 	return ewrpt_IncludeTrailingDelimiter($BasePath, $PhyPath) . $Path2 . $RelPath;

    5773. 

  5773. }

    5774. 

  5774. 

    5775. 

  5775. // Remove the last delimiter for a path

    5776. 

  5776. function ewrpt_RemoveTrailingDelimiter($Path, $PhyPath) {

    5777. 

  5777. 	$Delimiter = ($PhyPath) ? EWRPT_PATH_DELIMITER : '/';

    5778. 

  5778. 	while (substr($Path, -1) == $Delimiter)

    5779. 

  5779. 		$Path = substr($Path, 0, strlen($Path)-1);

    5780. 

  5780. 	return $Path;

    5781. 

  5781. }

    5782. 

  5782. 

    5783. 

  5783. // Include the last delimiter for a path

    5784. 

  5784. function ewrpt_IncludeTrailingDelimiter($Path, $PhyPath) {

    5785. 

  5785. 	$Path = ewrpt_RemoveTrailingDelimiter($Path, $PhyPath);

    5786. 

  5786. 	$Delimiter = ($PhyPath) ? EWRPT_PATH_DELIMITER : '/';

    5787. 

  5787. 	return $Path . $Delimiter;

    5788. 

  5788. }

    5789. 

  5789. 

    5790. 

  5790. // Create folder

    5791. 

  5791. function ewrpt_CreateFolder($dir, $mode = 0777) {

    5792. 

  5792. 	if ($dir == "")

    5793. 

  5793. 		return TRUE;

    5794. 

  5794. 	if (is_dir($dir) || @mkdir($dir, $mode))

    5795. 

  5795. 		return TRUE;

    5796. 

  5796. 	if (!ewrpt_CreateFolder(dirname($dir), $mode))

    5797. 

  5797. 		return FALSE;

    5798. 

  5798. 	return @mkdir($dir, $mode);

    5799. 

  5799. }

    5800. 

  5800. 

    5801. 

  5801. // Save file

    5802. 

  5802. function ewrpt_SaveFile($folder, $fn, $filedata) {

    5803. 

  5803. 	$res = FALSE;

    5804. 

  5804. 	if (ewrpt_CreateFolder($folder)) {

    5805. 

  5805. 		if ($handle = fopen($folder . $fn, 'w')) { // P6

    5806. 

  5806. 			$res = fwrite($handle, $filedata);

    5807. 

  5807.     	fclose($handle);

    5808. 

  5808. 		}

    5809. 

  5809. 		if ($res)

    5810. 

  5810. 			chmod($folder . $fn, EWRPT_UPLOADED_FILE_MODE);

    5811. 

  5811. 	}

    5812. 

  5812. 	return $res;

    5813. 

  5813. }

    5814. 

  5814. 

    5815. 

  5815. // Init array

    5816. 

  5816. function &ewrpt_InitArray($len, $value) {

    5817. 

  5817. 	if ($len > 0)

    5818. 

  5818. 		$ar = array_fill(0, $len, $value);

    5819. 

  5819. 	else

    5820. 

  5820. 		$ar = array();

    5821. 

  5821. 	return $ar;

    5822. 

  5822. }

    5823. 

  5823. 

    5824. 

  5824. // Init 2D array

    5825. 

  5825. function &ewrpt_Init2DArray($len1, $len2, $value) {

    5826. 

  5826. 	return ewrpt_InitArray($len1, ewrpt_InitArray($len2, $value));

    5827. 

  5827. }

    5828. 

  5828. 

    5829. 

  5829. // function to generate random number

    5830. 

  5830. function ewrpt_Random() {

    5831. 

  5831. 	return mt_rand();

    5832. 

  5832. }

    5833. 

  5833. 

    5834. 

  5834. // Convert string to float

    5835. 

  5835. function ewrpt_StrToFloat($v) {

    5836. 

  5836. 	$v = str_replace(" ", "", $v);	

    5837. 

  5837. 	if (!EWRPT_USE_DEFAULT_LOCALE) extract(localeconv()); // PHP 4 >= 4.0.5

    5838. 

  5838. 	if (empty($decimal_point)) $decimal_point = EWRPT_DEFAULT_DECIMAL_POINT;

    5839. 

  5839. 	$v = str_replace($decimal_point, ".", $v);

    5840. 

  5840. 	return $v;

    5841. 

  5841. }

    5842. 

  5842. 

    5843. 

  5843. // Convert different data type value

    5844. 

  5844. function ewrpt_Conv($v, $t) {

    5845. 

  5845. 	switch ($t) {

    5846. 

  5846. 	case 2:

    5847. 

  5847. 	case 3:

    5848. 

  5848. 	case 16:

    5849. 

  5849. 	case 17:

    5850. 

  5850. 	case 18:

    5851. 

  5851. 	case 19: // adSmallInt/adInteger/adTinyInt/adUnsignedTinyInt/adUnsignedSmallInt

    5852. 

  5852. 		return (is_null($v)) ? NULL : intval($v);

    5853. 

  5853. 	case 4:

    5854. 

  5854. 	Case 5:

    5855. 

  5855. 	case 6:

    5856. 

  5856. 	case 131:

    5857. 

  5857. 	case 139: // adSingle/adDouble/adCurrency/adNumeric/adVarNumeric

    5858. 

  5858. 		return (is_null($v)) ? NULL : (float)$v;

    5859. 

  5859. 	default:

    5860. 

  5860. 		return (is_null($v)) ? NULL : $v;

    5861. 

  5861. 	}

    5862. 

  5862. }

    5863. 

  5863. 

    5864. 

  5864. // Convert byte array to binary string

    5865. 

  5865. function ewrpt_BytesToStr($bytes) {

    5866. 

  5866. 	$str = "";

    5867. 

  5867. 	foreach ($bytes as $byte)

    5868. 

  5868. 		$str .= chr($byte);

    5869. 

  5869. 	return $str;

    5870. 

  5870. }

    5871. 

  5871. 

    5872. 

  5872. // Create temp image file from binary data

    5873. 

  5873. function ewrpt_TmpImage(&$filedata) {

    5874. 

  5874. 	global $gTmpImages;

    5875. 

  5875. 

    5876. 

  5876. //  $f = tempnam(ew_TmpFolder(), "tmp");

    5877. 

  5877. 	$folder = ewrpt_AppRoot() . EWRPT_UPLOAD_DEST_PATH;

    5878. 

  5878. 	$f = tempnam($folder, "tmp");

    5879. 

  5879. 	$handle = fopen($f, 'w+');

    5880. 

  5880. 	fwrite($handle, $filedata);

    5881. 

  5881. 	fclose($handle);

    5882. 

  5882. 	$info = getimagesize($f);

    5883. 

  5883. 	switch ($info[2]) {

    5884. 

  5884. 	case 1:

    5885. 

  5885. 		rename($f, $f .= '.gif'); break;

    5886. 

  5886. 	case 2:

    5887. 

  5887. 		rename($f, $f .= '.jpg'); break;

    5888. 

  5888. 	case 3:

    5889. 

  5889. 		rename($f, $f .= '.png'); break;

    5890. 

  5890. 	default:

    5891. 

  5891. 		return "";

    5892. 

  5892. 	}

    5893. 

  5893. 	$tmpimage = basename($f);

    5894. 

  5894. 	$gTmpImages[] = $tmpimage;

    5895. 

  5895. 	return EWRPT_UPLOAD_DEST_PATH . $tmpimage;

    5896. 

  5896. }

    5897. 

  5897. 

    5898. 

  5898. // Delete temp images

    5899. 

  5899. function ewrpt_DeleteTmpImages() {

    5900. 

  5900. 	global $gTmpImages;

    5901. 

  5901. 	foreach ($gTmpImages as $tmpimage)

    5902. 

  5902. 		@unlink(ewrpt_AppRoot() . EWRPT_UPLOAD_DEST_PATH . $tmpimage);

    5903. 

  5903. }

    5904. 

  5904. 

    5905. 

  5905. // Create temp file

    5906. 

  5906. function ewrpt_TmpFile($file) {

    5907. 

  5907. 	global $gTmpImages;

    5908. 

  5908. 	if (file_exists($file)) { // Copy only

    5909. 

  5909. 

    5910. 

  5910. //  	$f = tempnam(ew_TmpFolder(), "tmp");

    5911. 

  5911. 		$folder = ewrpt_AppRoot() . EWRPT_UPLOAD_DEST_PATH;

    5912. 

  5912. 		$f = tempnam($folder, "tmp");

    5913. 

  5913. 		@unlink($f);

    5914. 

  5914. 		$info = pathinfo($file);

    5915. 

  5915. 		if ($info["extension"] <> "")

    5916. 

  5916. 			$f .= "." . $info["extension"];

    5917. 

  5917. 		copy($file, $f);

    5918. 

  5918. 		$tmpimage = basename($f);

    5919. 

  5919. 		$gTmpImages[] = $tmpimage;

    5920. 

  5920. 		return EWRPT_UPLOAD_DEST_PATH . $tmpimage;

    5921. 

  5921. 	} else {

    5922. 

  5922. 		return "";

    5923. 

  5923. 	}

    5924. 

  5924. }

    5925. 

  5925. ?>

    5926. 

  5926. <?php

    5927. 

  5927. 

    5928. 

  5928. /**

    5929. 

  5929.  * Functions for image resize

    5930. 

  5930.  */

    5931. 

  5931. 

    5932. 

  5932. // Resize binary to thumbnail

    5933. 

  5933. function ewrpt_ResizeBinary($filedata, &$width, &$height, $quality) {

    5934. 

  5934. 	return TRUE; // No resize

    5935. 

  5935. }

    5936. 

  5936. 

    5937. 

  5937. // Resize file to thumbnail file

    5938. 

  5938. function ewrpt_ResizeFile($fn, $tn, &$width, &$height, $quality) {

    5939. 

  5939. 	if (file_exists($fn)) { // Copy only

    5940. 

  5940. 		return ($fn <> $tn) ? copy($fn, $tn) : TRUE;

    5941. 

  5941. 	} else {

    5942. 

  5942. 		return FALSE;

    5943. 

  5943. 	}

    5944. 

  5944. }

    5945. 

  5945. 

    5946. 

  5946. // Resize file to binary

    5947. 

  5947. function ewrpt_ResizeFileToBinary($fn, &$width, &$height, $quality) {

    5948. 

  5948. 	return file_get_contents($fn); // Return original file content only

    5949. 

  5949. }

    5950. 

  5950. ?>

    5951. 

  5951.