/ php-ppcms/includes/classes/base.item.class.php

http://php-ppcms.googlecode.com/ · PHP · 1129 lines · 955 code · 134 blank · 40 comment · 330 complexity · dbe140563ca13f5bcb3b27f25e6efd80 MD5 · raw file 

    

  1. <?php

    2. 

  2. /***************************************************************

    3. 

  3. *  Copyright notice

    4. 

  4. *  (c) 2009, jianyuzhu@gmail.com

    5. 

  5. *  All rights reserved

    6. 

  6. *  This script is part of the PPEMI project.

    7. 

  7. ***************************************************************/

    8. 

  8. 

    9. 

  9. class BaseItemBase extends Base {

    10. 

  10. 	var $table = '';

    11. 

  11. 	var $prefix = '';

    12. 

  12. 	var $pkey = 'id';

    13. 

  13. 	var $fkey = '';

    14. 

  14. 	

    15. 

  15. 	//

    16. 

  16. 	var $_table_owner_field = 'owner';

    17. 

  17. 	var $_table_owner_prefix = '';

    18. 

  18. 	var $_table_owner_usable = true;

    19. 

  19. 	var $_table_status_usable = true;

    20. 

  20. 	var $_table_status_value = '1';

    21. 

  21. 	var $_table_link_usable = false;

    22. 

  22. 	var $_table_link_gfield = 'name';

    23. 

  23. 	

    24. 

  24. 	//

    25. 

  25. 	var $format = true;

    26. 

  26. 	var $format_check = false;

    27. 

  27. 	var $format_prefix = 'field_';

    28. 

  28. 	var $item_link = false;

    29. 

  29. 	var $item_link_owner = false;

    30. 

  30. 	var $item_fields = array('id', 'name', 'link');

    31. 

  31. 	var $list_fields = array();

    32. 

  32. 	var $search_fields = array('name');

    33. 

  33. 	var $search_type = 'or';

    34. 

  34. 	var $sort_order = false;

    35. 

  35. 	var $sort_fields = array('sort_order+', 'id+');

    36. 

  36. 	var $sort_group = false;

    37. 

  37. 	var $sort_groups = array('name');

    38. 

  38. 	var $sort_query = array();

    39. 

  39. 	var $filter_fields = array();

    40. 

  40. 	var $filter_map = array();

    41. 

  41. 	var $filter_query = array();

    42. 

  42. 	

    43. 

  43. 	//

    44. 

  44. 	var $filters = array();

    45. 

  45. 	var $triggers = array();

    46. 

  46. 	

    47. 

  47. 	//constructor

    48. 

  48. 	function BaseItemBase($table = '') {

    49. 

  49. 		parent::Base();

    50. 

  50. 		

    51. 

  51. 		if( $table != '' ) {

    52. 

  52. 			$this->table = $table;

    53. 

  53. 		}

    54. 

  54. 	}

    55. 

  55. 	

    56. 

  56. 	function setProperty($name, $value = '') {

    57. 

  57. 		if( is_array($name) ) {

    58. 

  58. 			foreach($name as $k => $v) {

    59. 

  59. 				$this->$k = $v;

    60. 

  60. 			}

    61. 

  61. 		} else {

    62. 

  62. 			$this->$name = $value;

    63. 

  63. 		}

    64. 

  64. 	}

    65. 

  65. 	

    66. 

  66. 	function getProperty($name) {

    67. 

  67. 		if( isset($this->$name) ) {

    68. 

  68. 			return $this->$name;

    69. 

  69. 		}

    70. 

  70. 		

    71. 

  71. 		return NULL;

    72. 

  72. 	}

    73. 

  73. 	

    74. 

  74. 	function property($data) {

    75. 

  75. 		if( is_array($data) ) {

    76. 

  76. 			return $this->setProperty($data);

    77. 

  77. 		} else {

    78. 

  78. 			return $this->getProperty($data);

    79. 

  79. 		}

    80. 

  80. 	}

    81. 

  81. 	

    82. 

  82. 	function _pk($check = false) {

    83. 

  83. 		if( $check == true && $this->format == true ) {

    84. 

  84. 			return $this->pkey;

    85. 

  85. 		}

    86. 

  86. 		

    87. 

  87. 		return $this->prefix . $this->pkey;

    88. 

  88. 	}

    89. 

  89. 	

    90. 

  90. 	function _pf($field, $check = false) {

    91. 

  91. 		if( $check == true && $this->format == true ) {

    92. 

  92. 			return $field;

    93. 

  93. 		}

    94. 

  94. 		

    95. 

  95. 		return $this->prefix . $field;

    96. 

  96. 	}

    97. 

  97. 	

    98. 

  98. 	function setFilterQuery($name, $value = '') {

    99. 

  99. 		if( is_array($name) ) {

    100. 

  100. 			$this->filter_query = $name;

    101. 

  101. 		} else {

    102. 

  102. 			$this->filter_query[$name] = $value;

    103. 

  103. 		}

    104. 

  104. 	}

    105. 

  105. 	

    106. 

  106. 	//methods

    107. 

  107. 	function getItems($filter = '', $check = 0, $limit = true) {

    108. 

  108. 		$query_field_str = '*';

    109. 

  109. 		if( is_array($this->list_fields) && sizeof($this->list_fields) > 0 ) {

    110. 

  110. 			$query_field_str = implode(', ', $this->list_fields);

    111. 

  111. 		}

    112. 

  112. 		

    113. 

  113. 		$query_str = "";

    114. 

  114. 		$query_str .= $this->_get_query_str($filter, $check);

    115. 

  115. 		

    116. 

  116. 		$query_group_str = "";

    117. 

  117. 		if( $this->sort_group == true && !empty($this->sort_groups) ) {

    118. 

  118. 			$query_group_str .= " group by ";

    119. 

  119. 			foreach($this->sort_groups as $k => $v) {

    120. 

  120. 				$query_group_str .= $k . ", ";

    121. 

  121. 			}

    122. 

  122. 			$query_group_str = substr($query_group_str, 0, -2);

    123. 

  123. 		}

    124. 

  124. 		

    125. 

  125. 		$query_order_str = "";

    126. 

  126. 		if( $this->sort_order == true ) {

    127. 

  127. 			$this->_get_query_order_sort();

    128. 

  128. 			if( is_array($this->sort_fields) ) {

    129. 

  129. 				$query_order_str = " order by ";

    130. 

  130. 				$i = 0;

    131. 

  131. 				foreach($this->sort_fields as $k => $v) {

    132. 

  132. 					if( substr($v, 0, 1) == '=' ) {

    133. 

  133. 						$v = substr($v, 1);

    134. 

  134. 					} else {

    135. 

  135. 						$v = $this->prefix . $v;

    136. 

  136. 					}

    137. 

  137. 					if( substr($v, -1) == '-' ) {

    138. 

  138. 						$as = 'desc';

    139. 

  139. 						$v = substr($v, 0, -1);

    140. 

  140. 					} elseif( substr($v, -1) == '+' ) {

    141. 

  141. 						$as = 'asc';

    142. 

  142. 						$v = substr($v, 0, -1);

    143. 

  143. 					} else {

    144. 

  144. 						$as = 'asc';

    145. 

  145. 					}

    146. 

  146. 					if( $i > 0 ) {

    147. 

  147. 						$query_order_str .= ", ";

    148. 

  148. 					}

    149. 

  149. 					$query_order_str .= " " . $v . " " . $as;

    150. 

  150. 					$i++;

    151. 

  151. 				}

    152. 

  152. 			} else {

    153. 

  153. 				$query_order_str = " order by " . $this->prefix . "sort_order asc";

    154. 

  154. 			}

    155. 

  155. 		}

    156. 

  156. 		

    157. 

  157. 		$query_limit_str = "";

    158. 

  158. 		if( $limit == true ) {

    159. 

  159. 			$query_limit_str = $this->getQueryLimitStr();

    160. 

  160. 		}

    161. 

  161. 		

    162. 

  162. 		$query = "select " . $query_field_str . " from " . $this->table . " where " . $this->_query_owner_rt() . " " 

    163. 

  163. 				. $query_str . $query_group_str . $query_order_str . $query_limit_str;

    164. 

  164. 		$rows = $this->adb->getRows($query);

    165. 

  165. 		

    166. 

  166. 		if( $this->format == true ) {

    167. 

  167. 			for($i=0, $n=sizeof($rows); $i<$n; $i++) {

    168. 

  168. 				$rows[$i] = $this->_post_field($rows[$i], '', $this->prefix, $this->format_check);

    169. 

  169. 			}

    170. 

  170. 		}

    171. 

  171. 		

    172. 

  172. 		return $rows;

    173. 

  173. 	}

    174. 

  174. 	

    175. 

  175. 	function getItemsTotal($filter = '', $check = 0) {

    176. 

  176. 		$query_str = "";

    177. 

  177. 		$query_str .= $this->_get_query_str($filter, $check);

    178. 

  178. 		

    179. 

  179. 		return $this->adb->getCountA($this->table, " " . $this->_query_owner_rt() . " " . $query_str . " ");

    180. 

  180. 	}

    181. 

  181. 	

    182. 

  182. 	function getItemsStats($filter = '', $check = 0, $type = 'count', $field = '+id') {

    183. 

  183. 		if( !in_array($type, array('count', 'sum', 'min', 'max', 'avg')) ) {

    184. 

  184. 			return false;

    185. 

  185. 		}

    186. 

  186. 		$query_str = "";

    187. 

  187. 		$query_str .= $this->_get_query_str($filter, $check);

    188. 

  188. 		

    189. 

  189. 		$query_group_str = "";

    190. 

  190. 		if( $this->sort_group == true && !empty($this->sort_groups) ) {

    191. 

  191. 			$query_group_str .= " group by ";

    192. 

  192. 			foreach($this->sort_groups as $k => $v) {

    193. 

  193. 				$query_group_str .= $k . ", ";

    194. 

  194. 			}

    195. 

  195. 			$query_group_str = substr($query_group_str, 0, -2);

    196. 

  196. 		}		

    197. 

  197. 		

    198. 

  198. 		if( $field == '' ) {

    199. 

  199. 			$field = '*';

    200. 

  200. 		} elseif( substr($field, 0, 1) == '=' ) {

    201. 

  201. 			$field = substr($field, 1);

    202. 

  202. 		} elseif( substr($field, 0, 1) == '+' ) {

    203. 

  203. 			$field = $this->prefix . substr($field, 1);

    204. 

  204. 		} elseif( substr($field, 0, 1) == '-' ) {

    205. 

  205. 			$field = $this->prefix . substr($field, 1);

    206. 

  206. 		} elseif( substr($field, 0, 1) == '_' ) {

    207. 

  207. 			$field = $this->prefix . substr($field, 1);

    208. 

  208. 		} else {

    209. 

  209. 			$field = $this->prefix . substr($field, 1);

    210. 

  210. 		}

    211. 

  211. 		

    212. 

  212. 		$query = "select " . $type . " (" . $field . ") as count from " . $this->table . " where " . $this->_query_owner_rt() . " " 

    213. 

  213. 				. $query_str . $query_group_str;

    214. 

  214. 		

    215. 

  215. 		return $this->adb->getCount($query);

    216. 

  216. 	}

    217. 

  217. 	

    218. 

  218. 	function getItemsIDs($filter = '', $check = 0, $limit = true) {

    219. 

  219. 		$items = $this->getItems($filter, $check, $limit);

    220. 

  220. 		$pf = $this->prefix;

    221. 

  221. 		if( $this->format == true ) {

    222. 

  222. 			$pf = '';

    223. 

  223. 		}

    224. 

  224. 		$pk = $pf . 'id';

    225. 

  225. 		$ids = array();

    226. 

  226. 		for($i=0, $n=sizeof($items); $i<$n; $i++) {

    227. 

  227. 			$ids[] = $items[$i][$pk];

    228. 

  228. 		}

    229. 

  229. 		

    230. 

  230. 		return $ids;

    231. 

  231. 	}

    232. 

  232. 	

    233. 

  233. 	function getItemsFormat($filter = '', $check = 0, $limit = true, $field = '') {

    234. 

  234. 		$items = $this->getItems($filter, $check, $limit);

    235. 

  235. 		$pf = $this->prefix;

    236. 

  236. 		if( $this->format == true ) {

    237. 

  237. 			$pf = '';

    238. 

  238. 		}

    239. 

  239. 		$itemsf = array();

    240. 

  240. 		for($i=0, $n=sizeof($items); $i<$n; $i++) {

    241. 

  241. 			$f1 = $pf . 'id';

    242. 

  242. 			$f2 = $pf . 'id';

    243. 

  243. 			$f3 = 0;

    244. 

  244. 			if( is_array($field) && sizeof($field) >= 2 ) {

    245. 

  245. 				$f1 = $field['0'];

    246. 

  246. 				$f2 = $field['1'];

    247. 

  247. 				if( substr($f1, 0, 1) == '=' ) {

    248. 

  248. 					$f1 = substr($f1, 1);

    249. 

  249. 				} elseif( substr($f1, 0, 1) == '_' ) {

    250. 

  250. 					$f1 = $pf . substr($f1, 1);

    251. 

  251. 				} else {

    252. 

  252. 					$f1 = $pf . $f1;

    253. 

  253. 				}

    254. 

  254. 				if( substr($f2, 0, 1) == '=' ) {

    255. 

  255. 					$f2 = substr($f2, 1);

    256. 

  256. 				} elseif( substr($f2, 0, 1) == '_' ) {

    257. 

  257. 					$f2 = $pf . substr($f2, 1);

    258. 

  258. 				} else {

    259. 

  259. 					$f2 = $pf . $f2;

    260. 

  260. 				}

    261. 

  261. 			} elseif( $field != '' ) {

    262. 

  262. 				$f2 = $field;

    263. 

  263. 				if( substr($f2, 0, 1) == '=' ) {

    264. 

  264. 					$f2 = substr($f2, 1);

    265. 

  265. 				} elseif( substr($f2, 0, 1) == '_' ) {

    266. 

  266. 					$f2 = $pf . substr($f2, 1);

    267. 

  267. 				} else {

    268. 

  268. 					$f2 = $pf . $f2;

    269. 

  269. 				}

    270. 

  270. 			} elseif( isset($items[$i][$pf . 'name']) && strlen($items[$i][$pf . 'name']) > 0 ) {

    271. 

  271. 				$f2 = $pf . 'name';

    272. 

  272. 			} elseif( isset($items[$i][$pf . 'subject']) && strlen($items[$i][$pf . 'subject']) > 0 ) {

    273. 

  273. 				$f2 = $pf . 'subject';

    274. 

  274. 			}

    275. 

  275. 			$itemsf[$items[$i][$f1]] = $items[$i][$f2];

    276. 

  276. 		}

    277. 

  277. 		

    278. 

  278. 		return $itemsf;

    279. 

  279. 	}

    280. 

  280. 	

    281. 

  281. 	function getLatestItems($limit_length = 5) {

    282. 

  282. 		if( $limit_length <= 0 ) {

    283. 

  283. 			$limit_length = 5;

    284. 

  284. 		}

    285. 

  285. 		$query = "select * from " . $this->table . " where " . $this->_query_owner_rt() . " " 

    286. 

  286. 				. " order by " . $this->prefix . "id desc " 

    287. 

  287. 				. " limit " . (int)$limit_length;

    288. 

  288. 		

    289. 

  289. 		return $this->adb->getRows($query);

    290. 

  290. 	}

    291. 

  291. 	

    292. 

  292. 	//

    293. 

  293. 	function checkItem($value, $type = 'id', $check = 0) {

    294. 

  294. 		$value = func_db_input($value);

    295. 

  295. 		

    296. 

  296. 		if( is_array($this->item_fields) && sizeof($this->item_fields) > 0 ) {

    297. 

  297. 			if( isset($this->item_fields[$type]) ) {

    298. 

  298. 				$field = $this->item_fields[$type];

    299. 

  299. 				if( substr($field, 0, 1) != '_' && substr($field, 0, 1) != '=' ) {

    300. 

  300. 					$field = '_' . $field;

    301. 

  301. 				}

    302. 

  302. 			} elseif( in_array($type, $this->item_fields) ) {

    303. 

  303. 				$field = '_' . $type;

    304. 

  304. 			}

    305. 

  305. 		}

    306. 

  306. 		if( substr($type, 0, 1) == '_' || substr($type, 0, 1) == '=' ) {

    307. 

  307. 			$field = $type;

    308. 

  308. 		} elseif( in_array($type, array('id', 'key', 'link', 'name', 'subject', 'value', 'code')) ) {

    309. 

  309. 			$field = '_' . $type;

    310. 

  310. 			if( $type == 'id' ) {

    311. 

  311. 				$value = intval($value);

    312. 

  312. 			}

    313. 

  313. 		} else {

    314. 

  314. 			return false;

    315. 

  315. 		}

    316. 

  316. 		if( substr($field, 0, 1) == '_' ) {

    317. 

  317. 			$field = $this->prefix . substr($field, 1);

    318. 

  318. 		} elseif( substr($field, 0, 1) == '=' ) {

    319. 

  319. 			$field = substr($field, 1);

    320. 

  320. 		} else {

    321. 

  321. 			$field = $this->prefix . $field;

    322. 

  322. 		}

    323. 

  323. 		

    324. 

  324. 		$query = "select count(*) as count from " . $this->table . " where " . $this->_query_owner_rt() 

    325. 

  325. 				. " and " . $field . " = '" . $value . "'";

    326. 

  326. 		

    327. 

  327. 		return $this->adb->checkCount($query);

    328. 

  328. 	}

    329. 

  329. 	

    330. 

  330. 	function getItem($value, $type = 'id', $check = 0) {

    331. 

  331. 		$value = func_db_input($value);

    332. 

  332. 		

    333. 

  333. 		$this->doEvents("getItemBefore", $value, $type, $check);

    334. 

  334. 		if( $check == -1 ) {

    335. 

  335. 			//

    336. 

  336. 		} elseif( $this->_table_status_usable == true ) {

    337. 

  337. 			$query_str .= " and " . $this->prefix . "status = 1";

    338. 

  338. 		}

    339. 

  339. 		if( is_array($this->item_fields) && sizeof($this->item_fields) > 0 ) {

    340. 

  340. 			if( isset($this->item_fields[$type]) ) {

    341. 

  341. 				$field = $this->item_fields[$type];

    342. 

  342. 				if( substr($field, 0, 1) != '_' && substr($field, 0, 1) != '=' ) {

    343. 

  343. 					$field = '_' . $field;

    344. 

  344. 				}

    345. 

  345. 			} elseif( in_array($type, $this->item_fields) ) {

    346. 

  346. 				$field = '_' . $type;

    347. 

  347. 			}

    348. 

  348. 		}

    349. 

  349. 		if( substr($type, 0, 1) == '_' || substr($type, 0, 1) == '=' ) {

    350. 

  350. 			$field = $type;

    351. 

  351. 		} elseif( in_array($type, array('id', 'key', 'link', 'name', 'subject', 'value', 'code')) ) {

    352. 

  352. 			$field = '_' . $type;

    353. 

  353. 			if( $type == 'id' ) {

    354. 

  354. 				$value = intval($value);

    355. 

  355. 			}

    356. 

  356. 		} else {

    357. 

  357. 			return false;

    358. 

  358. 		}

    359. 

  359. 		if( substr($field, 0, 1) == '_' ) {

    360. 

  360. 			$field = $this->prefix . substr($field, 1);

    361. 

  361. 		} elseif( substr($field, 0, 1) == '=' ) {

    362. 

  362. 			$field = substr($field, 1);

    363. 

  363. 		} else {

    364. 

  364. 			$field = $this->prefix . $field;

    365. 

  365. 		}

    366. 

  366. 		$query_str .= " and " . $field . " = '" . $value . "'";

    367. 

  367. 		$query = "select * from " . $this->table . " where " . $this->_query_owner_rt() . " " . $query_str;

    368. 

  368. 		

    369. 

  369. 		$item = $this->adb->getRow($query);

    370. 

  370. 		if( $this->format == true ) {

    371. 

  371. 			$item = $this->_post_field($item, '', $this->prefix, $this->format_check);

    372. 

  372. 		}

    373. 

  373. 		$this->doEvents("getItemAfter", $value, $type, $check, $item);

    374. 

  374. 		$item = $this->doEvents("formatItem", $item);

    375. 

  375. 		

    376. 

  376. 		return $item;

    377. 

  377. 	}

    378. 

  378. 	

    379. 

  379. 	function getItemBy($value, $type = 'id', $check = 0) {

    380. 

  380. 		$value = func_db_input($value);

    381. 

  381. 		

    382. 

  382. 		$this->doEvents("getItemBefore", $value, $type, $check);

    383. 

  383. 		if( $check == -1 ) {

    384. 

  384. 			//

    385. 

  385. 		} elseif( $this->_table_status_usable == true ) {

    386. 

  386. 			$query_str .= " and " . $this->prefix . "status = 1";

    387. 

  387. 		}

    388. 

  388. 		if( in_array($type, array('id', 'link')) ) {

    389. 

  389. 			$field = $this->prefix . $type;

    390. 

  390. 		} elseif( substr($type, 0, 1) == '=' ) {

    391. 

  391. 			$field = substr($type, 1);

    392. 

  392. 		} else {

    393. 

  393. 			$field = $this->prefix . $type;

    394. 

  394. 		}

    395. 

  395. 		$query = "select * from " . $this->table . " where " . $this->_query_owner_rt() . " " 

    396. 

  396. 				. " and " . $field . " = '" . $value . "'";

    397. 

  397. 		

    398. 

  398. 		$item = $this->adb->getRow($query);

    399. 

  399. 		if( $this->format == true ) {

    400. 

  400. 			$item = $this->_post_field($item, '', $this->prefix, $this->format_check);

    401. 

  401. 		}

    402. 

  402. 		$this->doEvents("getItemAfter", $value, $type, $check, $item);

    403. 

  403. 		$item = $this->doEvents("formatItem", $item);

    404. 

  404. 		

    405. 

  405. 		return $item;

    406. 

  406. 	}

    407. 

  407. 	

    408. 

  408. 	function getPreviousItem($value, $type = 'id', $check = 0) {

    409. 

  409. 		$query_str = "";

    410. 

  410. 		if( $check == -1 ) {

    411. 

  411. 			//

    412. 

  412. 		} elseif( $this->_table_status_usable == true ) {

    413. 

  413. 			$query_str .= " and " . $this->prefix . "status = 1";

    414. 

  414. 		}

    415. 

  415. 		$query_order_str = " order by " . $this->prefix . "id desc ";

    416. 

  416. 		$query_limit_str = " limit 1";

    417. 

  417. 		

    418. 

  418. 		if( $type != 'id' ) {

    419. 

  419. 			$item = $this->getItem($value, $type, -1);

    420. 

  420. 			if( $this->format == true ) {

    421. 

  421. 				$value = $item['id'];

    422. 

  422. 			} else {

    423. 

  423. 				$value = $item[$this->prefix . 'id'];

    424. 

  424. 			}

    425. 

  425. 		}

    426. 

  426. 		if( $value > 0 ) {

    427. 

  427. 			$query = "select * from " . $this->table . " where " . $this->prefix . "id < '" . (int)$value . "' " 

    428. 

  428. 					. $query_str . $query_order_str . $query_limit_str;

    429. 

  429. 			

    430. 

  430. 			$item = $this->adb->getRow($query);

    431. 

  431. 			if( $this->format == true ) {

    432. 

  432. 				$item = $this->_post_field($item, '', $this->prefix, $this->format_check);

    433. 

  433. 			}

    434. 

  434. 			

    435. 

  435. 			return $item;

    436. 

  436. 		}

    437. 

  437. 		

    438. 

  438. 		return false;

    439. 

  439. 	}

    440. 

  440. 	

    441. 

  441. 	function getNextItem($value, $type = 'id', $check = 0) {

    442. 

  442. 		$query_str = "";

    443. 

  443. 		if( $check == -1 ) {

    444. 

  444. 			//

    445. 

  445. 		} elseif( $this->_table_status_usable == true ) {

    446. 

  446. 			$query_str .= " and " . $this->prefix . "status = 1";

    447. 

  447. 		}

    448. 

  448. 		$query_order_str = " order by " . $this->prefix . "id asc ";

    449. 

  449. 		$query_limit_str = " limit 1";

    450. 

  450. 		

    451. 

  451. 		if( $type != 'id' ) {

    452. 

  452. 			$item = $this->getItem($value, $type, -1);

    453. 

  453. 			if( $this->format == true ) {

    454. 

  454. 				$value = $item['id'];

    455. 

  455. 			} else {

    456. 

  456. 				$value = $item[$this->prefix . 'id'];

    457. 

  457. 			}

    458. 

  458. 		}

    459. 

  459. 		if( $value > 0 ) {

    460. 

  460. 			$query = "select * from " . $this->table . " where " . $this->prefix . "id > '" . (int)$value . "' " 

    461. 

  461. 					. $query_str . $query_order_str . $query_limit_str;

    462. 

  462. 			

    463. 

  463. 			$item = $this->adb->getRow($query);

    464. 

  464. 			if( $this->format == true ) {

    465. 

  465. 				$item = $this->_post_field($item, '', $this->prefix, $this->format_check);

    466. 

  466. 			}

    467. 

  467. 			

    468. 

  468. 			return $item;

    469. 

  469. 		}

    470. 

  470. 		

    471. 

  471. 		return false;

    472. 

  472. 	}

    473. 

  473. 	

    474. 

  474. 	function addItem($data_array) {

    475. 

  475. 		if( !$this->_not_null($data_array) || !is_array($data_array) ) {

    476. 

  476. 			return false;

    477. 

  477. 		}

    478. 

  478. 		

    479. 

  479. 		$this->doEvents("addItemBefore", $data_array);

    480. 

  480. 		$data_array = func_db_input($data_array);

    481. 

  481. 		$data_array = $this->_post_field($data_array, $this->prefix, $this->format_prefix, $this->format_check);

    482. 

  482. 		//

    483. 

  483. 		$data_array = $this->doEvents("addItemFilter", $data_array);

    484. 

  484. 		//

    485. 

  485. 		if( $this->_table_owner_usable == true ) {

    486. 

  486. 			if( $this->_table_owner_prefix == '=' ) {

    487. 

  487. 				$p = '';

    488. 

  488. 			} elseif( $this->_table_owner_prefix == '+' ) {

    489. 

  489. 				$p = $this->prefix;

    490. 

  490. 			} elseif( $this->_table_owner_prefix == '' ) {

    491. 

  491. 				$p = $this->prefix;

    492. 

  492. 			} else {

    493. 

  493. 				$p = $this->_table_owner_prefix;

    494. 

  494. 			}

    495. 

  495. 			$data_array[$p . $this->_table_owner_field] = $this->owner;

    496. 

  496. 		}

    497. 

  497. 		$data_array[$this->prefix . 'date_added'] = 'now()';

    498. 

  498. 		$data_array[$this->prefix . 'added_by'] = $this->_get_current_user();

    499. 

  499. 		$data_array[$this->prefix . 'status'] = $this->_table_status_value;

    500. 

  500. 		

    501. 

  501. 		//$items_id = $this->adb->insertA($this->table, $data_array);

    502. 

  502. 		$items_id = $this->_insert($this->table, $data_array);

    503. 

  503. 		$this->doEvents("addItemAfter", $data_array, $items_id);

    504. 

  504. 		

    505. 

  505. 		//

    506. 

  506. 		if( $items_id > 0 && $this->item_link == true ) {

    507. 

  507. 			$name = isset($data_array[$this->prefix . 'subject']) ? $data_array[$this->prefix . 'subject'] : '';

    508. 

  508. 			if( $name == '' ) {

    509. 

  509. 				$name = isset($data_array[$this->prefix . 'name']) ? $data_array[$this->prefix . 'name'] : '';

    510. 

  510. 			}

    511. 

  511. 			$this->_generate_item_link($items_id, $name, $data_array[$this->prefix . 'link']);

    512. 

  512. 		}

    513. 

  513. 		

    514. 

  514. 		return $items_id;

    515. 

  515. 	}

    516. 

  516. 	

    517. 

  517. 	function addItems($data_array) {

    518. 

  518. 		$items_ids = array();

    519. 

  519. 		if( is_array($data_array) ) {

    520. 

  520. 			foreach($data_array as $k => $v) {

    521. 

  521. 				$items_ids[] = $this->addItem($v);

    522. 

  522. 			}

    523. 

  523. 		}

    524. 

  524. 		

    525. 

  525. 		return $items_ids;

    526. 

  526. 	}

    527. 

  527. 	

    528. 

  528. 	function addItemsB($data_array) {

    529. 

  529. 		$items_ids = array();

    530. 

  530. 		if( is_array($data_array) ) {

    531. 

  531. 			foreach($data_array as $k => $v) {

    532. 

  532. 				if( isset($v[$this->prefix . 'id']) && $v[$this->prefix . 'id'] > 0 ) {

    533. 

  533. 					$id = $v[$this->prefix . 'id'];

    534. 

  534. 					unset($v[$this->prefix . 'id']);

    535. 

  535. 					

    536. 

  536. 					$this->updateItem($id, $v);

    537. 

  537. 					$items_ids[] = $id;

    538. 

  538. 				} else {

    539. 

  539. 					$items_ids[] = $this->addItem($v);

    540. 

  540. 				}

    541. 

  541. 			}

    542. 

  542. 		}

    543. 

  543. 		

    544. 

  544. 		return $items_ids;

    545. 

  545. 	}

    546. 

  546. 	

    547. 

  547. 	function updateItem($items_id, $data_array, $params = '') {

    548. 

  548. 		if( !$this->_not_null($items_id) || !$this->_not_null($data_array) || !is_array($data_array) ) {

    549. 

  549. 			return false;

    550. 

  550. 		}

    551. 

  551. 		

    552. 

  552. 		$this->doEvents("updateItemBefore", $items_id, $data_array);

    553. 

  553. 		$data_array = func_db_input($data_array);

    554. 

  554. 		$data_array = $this->_post_field($data_array, $this->prefix, $this->format_prefix, $this->format_check);

    555. 

  555. 		//

    556. 

  556. 		$data_array = $this->doEvents("updateItemFilter", $items_id, $data_array);

    557. 

  557. 		//

    558. 

  558. 		$data_array[$this->prefix . 'last_modified'] = 'now()';

    559. 

  559. 		$data_array[$this->prefix . 'modified_by'] = $this->_get_current_user();

    560. 

  560. 		

    561. 

  561. 		$params = ($params == '') ? "" : " and " . $params;

    562. 

  562. 		$params = "" . $this->_query_owner_rt() . " and " . $this->prefix . "id = '" . (int)$items_id . "'" . $params;

    563. 

  563. 		//$result = $this->adb->updateA($this->table, $data_array, $params);

    564. 

  564. 		$result = $this->_update($this->table, $data_array, $params);

    565. 

  565. 		$this->doEvents("updateItemAfter", $data_array, $items_id, $result);

    566. 

  566. 		

    567. 

  567. 		return $result;

    568. 

  568. 	}

    569. 

  569. 	

    570. 

  570. 	function updateItems($items_ids, $data_array, $params = '') {

    571. 

  571. 		if( is_array($items_ids) ) {

    572. 

  572. 			$params = ($params == '') ? "" : " and " . $params;

    573. 

  573. 			if( sizeof($items_ids) > 30 ) {

    574. 

  574. 				foreach($items_ids as $k => $items_id) {

    575. 

  575. 					$this->_update($this->table, $data_array, "" . $this->_query_owner_rt() . " and " . $this->prefix . "id = '" . (int)$items_id . "'" . $params);

    576. 

  576. 				}

    577. 

  577. 			} else {

    578. 

  578. 				$query_ids = "'" . implode("', '", array_values($items_ids)) . "'";

    579. 

  579. 				$this->_update($this->table, $data_array, "" . $this->_query_owner_rt() . " and " . $this->prefix . "id in (" . $query_ids . ")" . $params);

    580. 

  580. 			}

    581. 

  581. 		}

    582. 

  582. 	}

    583. 

  583. 	

    584. 

  584. 	function updateItemsF($items_ids, $field, $value = '') {

    585. 

  585. 		$fs = array(

    586. 

  586. 				'top' => array('flag_top', '1'), 

    587. 

  587. 				'recommend' => array('flag_recommend', '1'), 

    588. 

  588. 				'untop' => array('falg_top', '0'), 

    589. 

  589. 				'unrecommend' => array('flag_recommend', '0'), 

    590. 

  590. 				'statusopen' => array('status', '1'), 

    591. 

  591. 				'statusclose' => array('status', '0'),

    592. 

  592. 					);

    593. 

  593. 		if( $field && isset($fs[$field]) ) {

    594. 

  594. 			$data_array = array($this->prefix . $fs[$field]['0'] => $fs[$field]['1']);

    595. 

  595. 			

    596. 

  596. 			return $this->updateItems($items_ids, $data_array);

    597. 

  597. 		}

    598. 

  598. 		return false;

    599. 

  599. 	}

    600. 

  600. 	

    601. 

  601. 	function updateItemsCategory($items_ids, $categories_id) {

    602. 

  602. 		if( is_array($items_ids) ) {

    603. 

  603. 			if( sizeof($items_ids) > 30 ) {

    604. 

  604. 				foreach($items_ids as $k => $items_id) {

    605. 

  605. 					$this->adb->update("update " . $this->table . " set " . $this->prefix . "cid = '" . (int)$categories_id . "' where " . $this->prefix . "id = '" . (int)$items_id . "'");

    606. 

  606. 				}

    607. 

  607. 			} else {

    608. 

  608. 				$query_ids = "'" . implode("', '", array_values($items_ids)) . "'";

    609. 

  609. 				return $this->adb->update("update " . $this->table . " set " . $this->prefix . "cid = '" . (int)$categories_id . "' where " . $this->prefix . "id in (" . $query_ids . ")");

    610. 

  610. 			}

    611. 

  611. 		}

    612. 

  612. 	}

    613. 

  613. 	

    614. 

  614. 	function updateCategoryItemstoNewCategory($categories_id, $categories_id_new) {

    615. 

  615. 		return $this->adb->update("update " . $this->table . " set " . $this->prefix . "cid = '" . (int)$categories_id_new . "' where " . $this->prefix . "cid = '" . (int)$categories_id . "'");

    616. 

  616. 	}

    617. 

  617. 	

    618. 

  618. 	function updateItemsByFilter($data_array, $filter = '', $check = 0) {

    619. 

  619. 		$query_str = "";

    620. 

  620. 		$query_str .= $this->_get_query_str($filter, $check);

    621. 

  621. 		

    622. 

  622. 		$check = $this->getItemsTotal($filter, $check);

    623. 

  623. 		if( $check == 0 ) {

    624. 

  624. 			return false;

    625. 

  625. 		}

    626. 

  626. 		

    627. 

  627. 		return $this->_update($this->table, $data_array, " " . $this->_query_owner_rt() . " " . $query_str . " ");

    628. 

  628. 	}

    629. 

  629. 	

    630. 

  630. 	function deleteItem($items_id) {

    631. 

  631. 		if( !$this->_not_null($items_id) ) {

    632. 

  632. 			return false;

    633. 

  633. 		}

    634. 

  634. 		

    635. 

  635. 		$this->doEvents("deleteItemBefore", $items_id);

    636. 

  636. 		$this->adb->deleteA($this->table, " " . $this->_query_owner_rt() . " and " . $this->prefix . "id = '" . (int)$items_id . "'");

    637. 

  637. 		$this->doEvents("deleteItemAfter", $items_id);

    638. 

  638. 		

    639. 

  639. 		return true;

    640. 

  640. 	}

    641. 

  641. 	

    642. 

  642. 	function deleteItems($items_ids) {

    643. 

  643. 		if( is_string($items_ids) && strpos($items_ids, ',') !== false ) {

    644. 

  644. 			$items_ids = explode(',', $items_ids);

    645. 

  645. 		}

    646. 

  646. 		$this->doEvents("deleteItemsBefore", $items_ids);

    647. 

  647. 		if( is_array($items_ids) ) {

    648. 

  648. 			$this->_delete_ins($this->table, $this->prefix . 'id', $items_ids);

    649. 

  649. 		}

    650. 

  650. 		$this->doEvents("deleteItemsAfter", $items_ids);

    651. 

  651. 	}

    652. 

  652. 	

    653. 

  653. 	function setItemsStatus($items_ids, $status = 1) {

    654. 

  654. 		if( is_array($items_ids) ) {

    655. 

  655. 			$this->_update_ins($this->table, "" . $this->prefix . "status = '" . (int)$status . "'", $this->prefix . 'id', $items_ids);

    656. 

  656. 		}

    657. 

  657. 	}

    658. 

  658. 	

    659. 

  659. 	//

    660. 

  660. 	function check($items_id) {

    661. 

  661. 		$count = $this->adb->getCountA($this->table, $this->prefix . "id = '" . (int)$items_id . "'");

    662. 

  662. 		

    663. 

  663. 		return ($count > 0) ? true : false;

    664. 

  664. 	}

    665. 

  665. 	

    666. 

  666. 	function get($items_id) {

    667. 

  667. 		return $this->adb->getRowA($this->table, $this->prefix . "id = '" . (int)$items_id . "'");

    668. 

  668. 	}

    669. 

  669. 	

    670. 

  670. 	function add($data_array) {

    671. 

  671. 		if( !$this->_not_null($data_array) || !is_array($data_array) ) {

    672. 

  672. 			return false;

    673. 

  673. 		}

    674. 

  674. 		

    675. 

  675. 		$data_array = func_db_input($data_array);

    676. 

  676. 		$data_array = $this->_post_field($data_array, $this->prefix, $this->format_prefix, $this->format_check);

    677. 

  677. 		

    678. 

  678. 		$data_array[$this->prefix . 'date_added'] = 'now()';

    679. 

  679. 		$data_array[$this->prefix . 'added_by'] = $this->_get_current_user();

    680. 

  680. 		$data_array[$this->prefix . 'status'] = $this->_table_status_value;

    681. 

  681. 		

    682. 

  682. 		return $this->adb->insertA($this->table, $data_array);

    683. 

  683. 	}

    684. 

  684. 	

    685. 

  685. 	function update($items_id, $data_array) {

    686. 

  686. 		if( !$this->_not_null($items_id) ) {

    687. 

  687. 			return false;

    688. 

  688. 		}

    689. 

  689. 		

    690. 

  690. 		$data_array = func_db_input($data_array);

    691. 

  691. 		$data_array = $this->_post_field($data_array, $this->prefix, $this->format_prefix, $this->format_check);

    692. 

  692. 		

    693. 

  693. 		$data_array[$this->prefix . 'last_modified'] = 'now()';

    694. 

  694. 		$data_array[$this->prefix . 'modified_by'] = $this->_get_current_user();

    695. 

  695. 		

    696. 

  696. 		return $this->adb->updateA($this->table, $data_array, $this->prefix . "id = '" . (int)$items_id . "'");

    697. 

  697. 	}

    698. 

  698. 	

    699. 

  699. 	function delete($items_id) {

    700. 

  700. 		return $this->adb->deleteA($this->table, $this->prefix . "id = '" . (int)$items_id . "'");

    701. 

  701. 	}

    702. 

  702. 	

    703. 

  703. 	//private

    704. 

  704. 	function _get_query_str($filter = '', $check = 0) {

    705. 

  705. 		$query_str = "";

    706. 

  706. 		if( $check == -1 ) {

    707. 

  707. 			$query_str .= "";

    708. 

  708. 		} elseif( $this->_table_status_usable == true ) {

    709. 

  709. 			$query_str .= " and " . $this->prefix . "status = 1";

    710. 

  710. 		}

    711. 

  711. 		if( is_array($filter) ) {

    712. 

  712. 			$filter = func_db_input($filter);

    713. 

  713. 			if( is_array($this->filter_query) ) {

    714. 

  714. 				$filter = array_merge($filter, $this->filter_query);

    715. 

  715. 			}

    716. 

  716. 			if( is_array($this->filters) ) {

    717. 

  717. 				foreach($this->filters as $k => $v) {

    718. 

  718. 					$filter[$k] = $v;

    719. 

  719. 				}

    720. 

  720. 			}

    721. 

  721. 			//

    722. 

  722. 			if( isset($filter['keyword']) && $this->_not_null($filter['keyword']) == true ) {

    723. 

  723. 				if( is_array($this->search_fields) ) {

    724. 

  724. 					if( $this->search_type != 'or' ) {

    725. 

  725. 						$this->search_type = 'and';

    726. 

  726. 					}

    727. 

  727. 					$i = 0;

    728. 

  728. 					$query_str .= " and ( ";

    729. 

  729. 					foreach($this->search_fields as $k => $field) {

    730. 

  730. 						if( $i > 0 ) {

    731. 

  731. 							$query_str .= " " . $this->search_type . " ";

    732. 

  732. 						}

    733. 

  733. 						$query_str .= " " . $this->prefix . $field . " like '%" . $filter['keyword'] . "%' ";

    734. 

  734. 						$i++;

    735. 

  735. 					}

    736. 

  736. 					$query_str .= " ) ";

    737. 

  737. 				} elseif( is_string($this->search_fields) ) {

    738. 

  738. 					$query_str .= " and " . $this->prefix . $this->search_fields . " like '%" . $filter['keyword'] . "%' ";

    739. 

  739. 				}

    740. 

  740. 			}

    741. 

  741. 			if( isset($filter['ids']) && $this->_not_null($filter['ids']) == true ) {

    742. 

  742. 				if( is_array($filter['ids']) ) {

    743. 

  743. 					$query_str .= " and " . $this->prefix . "id in (" . $this->_implode(', ', $filter['ids']) . ") ";

    744. 

  744. 				} else {

    745. 

  745. 					$query_str .= " and " . $this->prefix . "id = '" . (int)$filter['ids'] . "' ";

    746. 

  746. 				}

    747. 

  747. 			}

    748. 

  748. 			if( isset($filter['parent']) && $this->_not_null($filter['parent']) == true ) {

    749. 

  749. 				if( is_array($filter['parent']) ) {

    750. 

  750. 					$query_str .= " and " . $this->prefix . "parent in (" . $this->_implode(', ', $filter['parent']) . ") ";

    751. 

  751. 				} else {

    752. 

  752. 					$query_str .= " and " . $this->prefix . "parent = '" . (int)$filter['parent'] . "' ";

    753. 

  753. 				}

    754. 

  754. 			}

    755. 

  755. 			if( isset($filter['category']) ) {

    756. 

  756. 				if( is_array($filter['category']) ) {

    757. 

  757. 					$query_str .= " and categories_id in (" . $this->_implode(', ', $filter['category']) . ") ";

    758. 

  758. 				} else {

    759. 

  759. 					$query_str .= " and categories_id = '" . (int)$filter['category'] . "' ";

    760. 

  760. 				}

    761. 

  761. 			}

    762. 

  762. 			if( isset($filter['nocategory']) && $filter['nocategory'] > 0 ) {

    763. 

  763. 				$query_str .= " and categories_id = '0' ";

    764. 

  764. 			}

    765. 

  765. 			if( is_array($this->filter_fields) && sizeof($this->filter_fields) > 0 ) {

    766. 

  766. 				$qt = $this->_get_query_type();

    767. 

  767. 				foreach($filter as $k => $v) {

    768. 

  768. 					if( is_array($this->filter_map) && isset($this->filter_map[$k]) ) {

    769. 

  769. 						$k = $this->filter_map[$k];

    770. 

  770. 					}

    771. 

  771. 					if( in_array($k, $this->filter_fields) ) {

    772. 

  772. 						$t = '';

    773. 

  773. 						$p = $this->prefix;

    774. 

  774. 						if( strpos($k, ':') !== false ) {

    775. 

  775. 							$ks = explode(':', $k);

    776. 

  776. 							$k = $ks['0'];

    777. 

  777. 							$t = $ks['1'];

    778. 

  778. 							if( sizeof($ks) > 2 ) {

    779. 

  779. 								$p = $ks['2'];

    780. 

  780. 							}

    781. 

  781. 						}

    782. 

  782. 						if( substr($k, 0, 1) == '=' ) {

    783. 

  783. 							$k = substr($k, 1);

    784. 

  784. 							$p = '';

    785. 

  785. 						}

    786. 

  786. 						if( !in_array($t, $qt) ) {

    787. 

  787. 							$t = '';

    788. 

  788. 						}

    789. 

  789. 						if( in_array($t, array('=', '>', '>=', '<', '<=', '!=')) ) {

    790. 

  790. 							if( $v === 'now()' || $v === 'now' ) {

    791. 

  791. 								$query_str .= " and " . $p . $k . " " . $t . " now() ";

    792. 

  792. 							} else {

    793. 

  793. 								$query_str .= " and " . $p . $k . " " . $t . " '" . $v . "' ";

    794. 

  794. 							}

    795. 

  795. 						} elseif( in_array($t, array('[]', '[)', '(]', '()')) ) {

    796. 

  796. 							if( is_array($v) ) {

    797. 

  797. 								$t1 = substr($t, 0, 1);

    798. 

  798. 								$t2 = substr($t, 1, 1);

    799. 

  799. 								if( $t1 == '[' ) {

    800. 

  800. 									$t1 = '<=';

    801. 

  801. 								} elseif( $t1 == '(' ) {

    802. 

  802. 									$t1 = '<';

    803. 

  803. 								}

    804. 

  804. 								if( $t2 == '[' ) {

    805. 

  805. 									$t2 = '<=';

    806. 

  806. 								} elseif( $t1 == '(' ) {

    807. 

  807. 									$t2 = '<';

    808. 

  808. 								}

    809. 

  809. 								

    810. 

  810. 								$query_str .= " and " . $p . $k . " " . $t1 . " '" . $v['0'] . "' ";

    811. 

  811. 								$query_str .= " and " . $p . $k . " " . $t2 . " '" . $v['1'] . "' ";

    812. 

  812. 							}

    813. 

  813. 						} elseif( in_array($t, array('like', 'notlike', '%like%', '%like', 'like%',)) ) {

    814. 

  814. 							if( $t == 'notlike' ) {

    815. 

  815. 								$query_str .= " and " . $p . $k . " not like '%" . $v . "%' ";

    816. 

  816. 							} else {

    817. 

  817. 								$query_str .= " and " . $p . $k . " like '%" . $v . "%' ";

    818. 

  818. 							}

    819. 

  819. 						} else {

    820. 

  820. 							if( $v === 'now()' || $v === 'now' ) {

    821. 

  821. 								$query_str .= " and " . $p . $k . " < now() ";

    822. 

  822. 							} elseif( is_array($v) && sizeof($v) > 0 ) {

    823. 

  823. 								$query_str .= " and " . $p . $k . " in ('" . implode("','", $v) . "') ";

    824. 

  824. 							} elseif( is_int($v) ) {

    825. 

  825. 								$query_str .= " and " . $p . $k . " = '" . $v . "' ";

    826. 

  826. 							} elseif( is_numeric($v) ) {

    827. 

  827. 								$query_str .= " and " . $p . $k . " = '" . $v . "' ";

    828. 

  828. 							} elseif( is_string($v) ) {

    829. 

  829. 								$query_str .= " and " . $p . $k . " like '%" . $v . "%' ";

    830. 

  830. 							} else {

    831. 

  831. 								$query_str .= " and " . $p . $k . " like '%" . $v . "%' ";

    832. 

  832. 							}

    833. 

  833. 						}

    834. 

  834. 					}

    835. 

  835. 				}

    836. 

  836. 			}

    837. 

  837. 		}

    838. 

  838. 		//

    839. 

  839. 		$query_str .= $this->_get_query_str_custom($filter, $check);

    840. 

  840. 		

    841. 

  841. 		return $query_str;

    842. 

  842. 	}

    843. 

  843. 	

    844. 

  844. 	function _get_query_str_custom($filter = '', $check = 0) {

    845. 

  845. 		return "";

    846. 

  846. 	}

    847. 

  847. 	

    848. 

  848. 	function _get_query_order_sort($order_by = '', $order_sort = '') {

    849. 

  849. 		if( $order_by == '' ) {

    850. 

  850. 			$order_by = $this->query_order_by;

    851. 

  851. 		}

    852. 

  852. 		if( $order_sort == '' ) {

    853. 

  853. 			$order_sort = $this->query_order_sort;

    854. 

  854. 		}

    855. 

  855. 		if( $order_by != '' && $order_sort != '' ) {

    856. 

  856. 			if( $order_by == 'dateadded' ) {

    857. 

  857. 				$order_by = 'date_added';

    858. 

  858. 			} elseif( $order_by == 'sortorder' ) {

    859. 

  859. 				$order_by = 'sort_order';

    860. 

  860. 			}

    861. 

  861. 			//

    862. 

  862. 			$sort_query = array();

    863. 

  863. 			if( !is_array($this->sort_query) && is_array($this->sort_fields) ) {

    864. 

  864. 				foreach($this->sort_fields as $k => $v) {

    865. 

  865. 					if( substr($v, -1, 1) == '+' || substr($v, -1, 1) == '-' ) {

    866. 

  866. 						$sort_query[] = substr($v, 0, -1);

    867. 

  867. 					}

    868. 

  868. 				}

    869. 

  869. 			} else {

    870. 

  870. 				$sort_query = $this->sort_query;

    871. 

  871. 			}

    872. 

  872. 			if( is_array($sort_query) && in_array($order_by, $sort_query) ) {

    873. 

  873. 				$sort_fields = array($order_by . ($order_sort == 'desc' ? '+' : '-'));

    874. 

  874. 				$this->sort_fields = $sort_fields;

    875. 

  875. 			}

    876. 

  876. 		}

    877. 

  877. 	}

    878. 

  878. 	

    879. 

  879. 	function _query_owner_rt($pf = '') {

    880. 

  880. 		if( $this->_table_owner_usable == true ) {

    881. 

  881. 			if( $this->_table_owner_prefix == '=' ) {

    882. 

  882. 				$p = '';

    883. 

  883. 			} elseif( $this->_table_owner_prefix == '+' ) {

    884. 

  884. 				$p = $this->prefix;

    885. 

  885. 			} elseif( $this->_table_owner_prefix == '' ) {

    886. 

  886. 				$p = $this->prefix;

    887. 

  887. 			} else {

    888. 

  888. 				$p = $this->_table_owner_prefix;

    889. 

  889. 			}

    890. 

  890. 			if( $pf != '' ) {

    891. 

  891. 				$p = $pf . '.' . $p;

    892. 

  892. 			}

    893. 

  893. 			

    894. 

  894. 			return $this->_query_owner($p . $this->_table_owner_field);

    895. 

  895. 		}

    896. 

  896. 		

    897. 

  897. 		return " 1 ";

    898. 

  898. 	}

    899. 

  899. 	

    900. 

  900. 	function _get_query_type() {

    901. 

  901. 		$query_type = array(

    902. 

  902. 				'=', '>', '>=', '<', '<=', '!=',

    903. 

  903. 				'[]', '()', '[)', '(]',

    904. 

  904. 				'like', 'notlike', '%like%', '%like', 'like%',

    905. 

  905. 				'regexp', 'notregexp',

    906. 

  906. 					);

    907. 

  907. 		return $query_type;

    908. 

  908. 	}

    909. 

  909. 	

    910. 

  910. 	//

    911. 

  911. 	function _generate_item_link($items_id, $items_name = '', $items_link = '') {

    912. 

  912. 		if( $items_link == '' && $items_name != '' ) {

    913. 

  913. 			$items_link = $this->_filter_link($items_name);

    914. 

  914. 		}

    915. 

  915. 		if( $this->_not_null($items_link) ) {

    916. 

  916. 			$items_link = func_db_input($items_link);

    917. 

  917. 			if( $this->item_link_owner == true ) {

    918. 

  918. 				$query = "select count(*) as count from " . $this->table . " where " . $this->_query_owner_rt() . " " 

    919. 

  919. 						. " and " . $this->prefix . "id != '" . (int)$items_id . "' " 

    920. 

  920. 						. " and " . $this->prefix . "link = '" . $items_link . "'";

    921. 

  921. 			} else {

    922. 

  922. 				$query = "select count(*) as count from " . $this->table . " where " . $this->prefix . "id != '" . (int)$items_id . "' " 

    923. 

  923. 						. " and " . $this->prefix . "link = '" . $items_link . "'";

    924. 

  924. 			}

    925. 

  925. 			$count = $this->adb->getCount($query);

    926. 

  926. 			if( $count == 0 ) {

    927. 

  927. 				$this->updateItem($items_id, array('_link' => $items_link));

    928. 

  928. 				return true;

    929. 

  929. 			}

    930. 

  930. 		}

    931. 

  931. 		$items_link = $this->_filter_link($items_name);

    932. 

  932. 		$items_link = $this->_rand_link($items_id, $items_link);

    933. 

  933. 		

    934. 

  934. 		$this->_generate_item_link($items_id, $items_name, $items_link);

    935. 

  935. 		

    936. 

  936. 		return true;

    937. 

  937. 	}

    938. 

  938. 	

    939. 

  939. 	//

    940. 

  940. 	//Event

    941. 

  941. 	function doEvents() {

    942. 

  942. 		$_args = func_get_args();

    943. 

  943. 		$_argc = func_num_args();

    944. 

  944. 		if( $_argc == 0 ) {

    945. 

  945. 			return false;

    946. 

  946. 		}

    947. 

  947. 		$method = array_shift($_args);

    948. 

  948. 		$params = $_args;

    949. 

  949. 		$method = 'on' . ucfirst($method);

    950. 

  950. 		if( method_exists($this, $method) ) {

    951. 

  951. 			//if( $params == '' ) {

    952. 

  952. 			//	$this->$method();

    953. 

  953. 			//} else {

    954. 

  954. 			//	$this->$method($params);

    955. 

  955. 			//}

    956. 

  956. 			if( $_argc == 1 ) {

    957. 

  957. 				$result = call_user_func_array(array($this, $method));

    958. 

  958. 			} elseif( strstr($method, 'Filter') !== false && sizeof($params) == 1 ) {

    959. 

  959. 				//$result = call_user_func_array(array($this, $method), array(&$params['0']));

    960. 

  960. 				$result = $this->$method($params['0']);

    961. 

  961. 			} else {

    962. 

  962. 				$result = call_user_func_array(array($this, $method), $params);

    963. 

  963. 			}

    964. 

  964. 		}

    965. 

  965. 		

    966. 

  966. 		return $result;

    967. 

  967. 	}

    968. 

  968. 	

    969. 

  969. 	function doTrigger($trigger, $params) {

    970. 

  970. 		if( $trigger['type'] == 'cm' ) {

    971. 

  971. 			if( $trigger['class_file'] != '' && file_exists(CONFIG_PATH . CONFIG_DIR_CLASSES . $trigger['class_file']) ) {

    972. 

  972. 				include_once(CONFIG_PATH . CONFIG_DIR_CLASSES . $trigger['class_file']);

    973. 

  973. 			}

    974. 

  974. 			$cmObj = new $trigger['class_name']();

    975. 

  975. 			$vs = call_user_func_array(array($cmObj, $trigger['method']), $params);

    976. 

  976. 		} elseif( $trigger['type'] == 'm' ) {

    977. 

  977. 			$vs = call_user_func_array(array($this, $trigger['method']), $params);

    978. 

  978. 		} elseif( $trigger['type'] == 'f' ) {

    979. 

  979. 			$vs = call_user_func_array($trigger['function'], $params);

    980. 

  980. 		}	

    981. 

  981. 	}

    982. 

  982. 	

    983. 

  983. 	function onAddItemBefore() {

    984. 

  984. 		return true;

    985. 

  985. 	}

    986. 

  986. 	

    987. 

  987. 	function onAddItemFilter($data_array) {

    988. 

  988. 		$fb = $this->onAddItemFilterBind($data_array);

    989. 

  989. 		if( is_array($fb) ) {

    990. 

  990. 			foreach($fb as $k => $v) {

    991. 

  991. 				if( substr($k, 0, 1) == '_' ) {

    992. 

  992. 					$data_array[$this->prefix . substr($k, 1)] = $v;

    993. 

  993. 				} elseif( substr($k, 0, 1) == '=' ) {

    994. 

  994. 					$data_array[substr($k, 1)] = $v;

    995. 

  995. 				} else {

    996. 

  996. 					$data_array[$k] = $v;

    997. 

  997. 				}

    998. 

  998. 			}

    999. 

  999. 		}

    1000. 

  1000. 		//

    1001. 

  1001. 		$fc = $this->onAddItemFilterClean($data_array);

    1002. 

  1002. 		if( is_array($fc) ) {

    1003. 

  1003. 			foreach($fc as $k => $v) {

    1004. 

  1004. 				if( substr($k, 0, 1) == '_' ) {

    1005. 

  1005. 					$k = $this->prefix . substr($k, 1);

    1006. 

  1006. 				} elseif( substr($k, 0, 1) == '=' ) {

    1007. 

  1007. 					$k = substr($k, 1);

    1008. 

  1008. 				}

    1009. 

  1009. 				if( isset($data_array[$k]) ) {

    1010. 

  1010. 					unset($data_array[$k]);

    1011. 

  1011. 				}

    1012. 

  1012. 			}

    1013. 

  1013. 		}

    1014. 

  1014. 		

    1015. 

  1015. 		return $data_array;

    1016. 

  1016. 	}

    1017. 

  1017. 	

    1018. 

  1018. 	function onAddItemFilterBind($data_array) {

    1019. 

  1019. 		return false;

    1020. 

  1020. 	}

    1021. 

  1021. 	

    1022. 

  1022. 	function onAddItemFilterClean($data_array) {

    1023. 

  1023. 		return false;

    1024. 

  1024. 	}

    1025. 

  1025. 	

    1026. 

  1026. 	function onAddItemAfter($data_array, $items_id) {

    1027. 

  1027. 		if( isset($this->triggers['additemafter']) ) {

    1028. 

  1028. 			$trigger = $this->triggers['additemafter'];

    1029. 

  1029. 			$params = func_get_args();

    1030. 

  1030. 			

    1031. 

  1031. 			if( $trigger['type'] == 'cm' ) {

    1032. 

  1032. 				if( $trigger['class_file'] != '' && file_exists(CONFIG_PATH . CONFIG_DIR_CLASSES . $trigger['class_file']) ) {

    1033. 

  1033. 					include_once(CONFIG_PATH . CONFIG_DIR_CLASSES . $trigger['class_file']);

    1034. 

  1034. 				}

    1035. 

  1035. 				$cmObj = new $trigger['class_name']();

    1036. 

  1036. 				$vs = call_user_func_array(array($cmObj, $trigger['method']), $params);

    1037. 

  1037. 			} elseif( $trigger['type'] == 'm' ) {

    1038. 

  1038. 				$vs = call_user_func_array(array($this, $trigger['method']), $params);

    1039. 

  1039. 			} elseif( $trigger['type'] == 'f' ) {

    1040. 

  1040. 				$vs = call_user_func_array($trigger['function'], $params);

    1041. 

  1041. 			}

    1042. 

  1042. 		}

    1043. 

  1043. 		

    1044. 

  1044. 		return true;

    1045. 

  1045. 	}

    1046. 

  1046. 	

    1047. 

  1047. 	function onUpdateItemBefore($items_id, $data_array) {

    1048. 

  1048. 		return true;

    1049. 

  1049. 	}

    1050. 

  1050. 	

    1051. 

  1051. 	function onUpdateItemFilter($items_id, $data_array) {

    1052. 

  1052. 		$fb = $this->onUpdateItemFilterBind($items_id, $data_array);

    1053. 

  1053. 		if( is_array($fb) ) {

    1054. 

  1054. 			foreach($fb as $k => $v) {

    1055. 

  1055. 				if( substr($k, 0, 1) == '_' ) {

    1056. 

  1056. 					$data_array[$this->prefix . substr($k, 1)] = $v;

    1057. 

  1057. 				} elseif( substr($k, 0, 1) == '=' ) {

    1058. 

  1058. 					$data_array[substr($k, 1)] = $v;

    1059. 

  1059. 				} else {

    1060. 

  1060. 					$data_array[$k] = $v;

    1061. 

  1061. 				}

    1062. 

  1062. 			}

    1063. 

  1063. 		}

    1064. 

  1064. 		//

    1065. 

  1065. 		$fc = $this->onUpdateItemFilterClean($items_id, $data_array);

    1066. 

  1066. 		if( is_array($fc) ) {

    1067. 

  1067. 			foreach($fc as $k => $v) {

    1068. 

  1068. 				if( substr($k, 0, 1) == '_' ) {

    1069. 

  1069. 					$k = $this->prefix . substr($k, 1);

    1070. 

  1070. 				} elseif( substr($k, 0, 1) == '=' ) {

    1071. 

  1071. 					$k = substr($k, 1);

    1072. 

  1072. 				}

    1073. 

  1073. 				if( isset($data_array[$k]) ) {

    1074. 

  1074. 					unset($data_array[$k]);

    1075. 

  1075. 				}

    1076. 

  1076. 			}

    1077. 

  1077. 		}

    1078. 

  1078. 		

    1079. 

  1079. 		return $data_array;

    1080. 

  1080. 	}

    1081. 

  1081. 	

    1082. 

  1082. 	function onUpdateItemFilterBind($items_id, $data_array) {

    1083. 

  1083. 		return false;

    1084. 

  1084. 	}

    1085. 

  1085. 	

    1086. 

  1086. 	function onUpdateItemFilterClean($items_id, $data_array) {

    1087. 

  1087. 		return false;

    1088. 

  1088. 	}

    1089. 

  1089. 	

    1090. 

  1090. 	function onUpdateItemAfter($items_id, $data_array, $result) {

    1091. 

  1091. 		if( isset($this->triggers['updateitemafter']) ) {

    1092. 

  1092. 			$trigger = $this->triggers['updateitemafter'];

    1093. 

  1093. 			$params = func_get_args();

    1094. 

  1094. 			

    1095. 

  1095. 			$this->doTrigger($trigger, $params);

    1096. 

  1096. 		}

    1097. 

  1097. 		return true;

    1098. 

  1098. 	}

    1099. 

  1099. 	

    1100. 

  1100. 	function onDeleteItemBefore($items_id) {

    1101. 

  1101. 		return true;

    1102. 

  1102. 	}

    1103. 

  1103. 	

    1104. 

  1104. 	function onDeleteItemAfter($items_id) {

    1105. 

  1105. 		return true;

    1106. 

  1106. 	}

    1107. 

  1107. 	

    1108. 

  1108. 	function onGetItemBefore($value, $type, $check) {

    1109. 

  1109. 		return true;

    1110. 

  1110. 	}

    1111. 

  1111. 	

    1112. 

  1112. 	function onGetItemAfter($value, $type, $check, $item) {

    1113. 

  1113. 		return true;

    1114. 

  1114. 	}

    1115. 

  1115. 	

    1116. 

  1116. 	function onGetItemsBefore() {

    1117. 

  1117. 		return true;

    1118. 

  1118. 	}

    1119. 

  1119. 	

    1120. 

  1120. 	function onGetItemsAfter() {

    1121. 

  1121. 		return true;

    1122. 

  1122. 	}

    1123. 

  1123. 	

    1124. 

  1124. 	function onFormatItem($item) {

    1125. 

  1125. 		return $item;

    1126. 

  1126. 	}

    1127. 

  1127. }

    1128. 

  1128. //

    1129. 

  1129. ?>
    1130.