PageRenderTime 50ms CodeModel.GetById 13ms RepoModel.GetById 1ms app.codeStats 0ms

/application/core/MY_Model.php

https://bitbucket.org/matyhaty/senses-designertravelv3
PHP | 1285 lines | 896 code | 205 blank | 184 comment | 102 complexity | 859d1c6f47ecba94879ff92962a91d22 MD5 | raw file
Possible License(s): LGPL-2.1, GPL-2.0 
    

  1. <?php

    2. 

  2. 

    3. 

  3. require APPPATH . 'controllers/cache_controller.php';

    4. 

  4. 

    5. 

  5. class MY_Model extends DataMapper

    6. 

  6. {

    7. 

  7. 

    8. 

  8. 	public $cache_id = '';

    9. 

  9. 	public $dm_object = null;

    10. 

  10. 

    11. 

  11. 	function __construct($id = null)

    12. 

  12. 	{

    13. 

  13. 		$cache = new Cache_Controller();

    14. 

  14. 		$this -> cache = $cache -> getCache();

    15. 

  15. 		parent::__construct($id);

    16. 

  16. 		$this -> dm_object = '';

    17. 

  17. 	}

    18. 

  18. 

    19. 

  19. 	protected function create_db()

    20. 

  20. 	{

    21. 

  21. 		$CI = &get_instance();

    22. 

  22. 		$CI -> teamleaf -> create_db($this -> table, $this -> has_one, $this -> has_many);

    23. 

  23. 	}

    24. 

  24. 

    25. 

  25. 	/*

    26. 

  26. 	 public function getTimelineTransaction($transactionID, $cacheType = 'file', $recreate = true)

    27. 

  27. 	 {

    28. 

  28. 	 $CI = &get_instance();

    29. 

  29. 	 $this -> cache_id = 'view/tasktimelines/[View Cache - Timeline-' . $transactionID . ']';

    30. 

  30. 	 $limit = 5;

    31. 

  31. 	 switch($cacheType)

    32. 

  32. 	 {

    33. 

  33. 	 // START - FILE CACHE

    34. 

  34. 	 // ------------------------------------------------------------------------------------

    35. 

  35. 

    36. 

  36. 	 case 'file' :

    37. 

  37. 	 $cacheLength = 3600;

    38. 

  38. 	 $cache = $this -> cache -> file -> get($this -> cache_id);

    39. 

  39. 	 if ($cache && !$recreate)

    40. 

  40. 	 {

    41. 

  41. 	 $CI -> firephp -> info("Timeline Cache Loaded for: " . $this -> cache_id);

    42. 

  42. 	 return $cache;

    43. 

  43. 	 }

    44. 

  44. 	 else

    45. 

  45. 	 {

    46. 

  46. 	 $CI -> firephp -> info("Creating Timeline Cache for: " . $this -> cache_id);

    47. 

  47. 	 $timeline = new Timeline();

    48. 

  48. 	 $view = $timeline -> createTimelineTransactionMarkup($transactionID);

    49. 

  49. 	 $this -> cache -> file -> save($this -> cache_id, $view, $cacheLength);

    50. 

  50. 	 return $view;

    51. 

  51. 	 }

    52. 

  52. 	 }

    53. 

  53. 	 }

    54. 

  54. 	 */

    55. 

  55. 	public function getObjectv2($array, $model, $id = null, $parentObject = null, $cacheType = 'file')

    56. 

  56. 	{

    57. 

  57. 

    58. 

  58. 		/*****

    59. 

  59. 		 *

    60. 

  60. 		 * Formatting notes

    61. 

  61. 		 * ----------------

    62. 

  62. 		 *

    63. 

  63. 		 * WHERE

    64. 

  64. 		 * Pass an Array of

    65. 

  65. 		 * $arr['field'] = field name to check against

    66. 

  66. 		 * $arr['value] = value

    67. 

  67. 		 *

    68. 

  68. 		 * WHERE IN

    69. 

  69. 		 * Pass an Array of

    70. 

  70. 		 * $arr['field'] = field name to check against

    71. 

  71. 		 * $arr['values] Aarray of values (key not required)

    72. 

  72. 		 *

    73. 

  73. 		 *

    74. 

  74. 		 */

    75. 

  75. 

    76. 

  76. 		$CI = &get_instance();

    77. 

  77. 

    78. 

  78. 		// BUILD CACHE ID

    79. 

  79. 		// ------------------------------------------------------------------------------------

    80. 

  80. 		$this -> cache_id = 'database/[' . $model . '-' . $id . ']';

    81. 

  81. 		if ($parentObject)

    82. 

  82. 		{

    83. 

  83. 			$parent = $parentObject -> model;

    84. 

  84. 			$this -> cache_id = 'database/[' . $model . '-' . $id . ']';

    85. 

  85. 			$this -> cache_id .= '[ON_PARENT-' . $parent . '-with-ID-of-' . $parentObject -> id . ']';
    86. 

  86. 		}

    87. 

  87. 

    88. 

  88. 		foreach ($array as $key => $value)

    89. 

  89. 		{

    90. 

  90. 			//$CI -> firephp -> info("ARRAY VALUES: " . $key .'----'.$value);

    91. 

  91. 			switch($key)

    92. 

  92. 			{

    93. 

  93. 				case 'where' :

    94. 

  94. 					if (is_array($value))

    95. 

  95. 					{

    96. 

  96. 						$this -> cache_id .= '___Where--';

    97. 

  97. 						foreach ($value as $sk => $sv)

    98. 

  98. 						{

    99. 

  99. 							$this -> cache_id .= $sk . '-' . $sv . '-';

    100. 

  100. 						}

    101. 

  101. 					}

    102. 

  102. 					break;

    103. 

  103. 

    104. 

  104. 				case 'or_where' :

    105. 

  105. 					if (is_array($value))

    106. 

  106. 					{

    107. 

  107. 						//print_r($value);

    108. 

  108. 						$this -> cache_id .= '___OrWhere--';

    109. 

  109. 						foreach ($value['values'] as $svk => $svV)

    110. 

  110. 						{

    111. 

  111. 							$this -> cache_id .= '-' . $svk . '-' . $svV . '-';

    112. 

  112. 						}

    113. 

  113. 					}

    114. 

  114. 					break;

    115. 

  115. 

    116. 

  116. 				case 'or_like' :

    117. 

  117. 					if (is_array($value))

    118. 

  118. 					{

    119. 

  119. 						//print_r($value);

    120. 

  120. 						$this -> cache_id .= '___OrLike--' . $value['field'] . '-';

    121. 

  121. 						foreach ($value['values'] as $svk => $svV)

    122. 

  122. 						{

    123. 

  123. 							$this -> cache_id .= '-' . $svk . '-' . $svV . '-';

    124. 

  124. 						}

    125. 

  125. 					}

    126. 

  126. 					break;

    127. 

  127. 

    128. 

  128. 				case 'wherein' :

    129. 

  129. 					if (is_array($value))

    130. 

  130. 					{

    131. 

  131. 						$this -> cache_id .= '___WhereIn--' . $value['field'] . '-hasTheValues-';

    132. 

  132. 						foreach ($value['values'] as $whereinvals)

    133. 

  133. 						{

    134. 

  134. 							$this -> cache_id .= $whereinvals . '-or-';

    135. 

  135. 						}

    136. 

  136. 					}

    137. 

  137. 					break;

    138. 

  138. 

    139. 

  139. 				case 'wherein2' :

    140. 

  140. 					if (is_array($value))

    141. 

  141. 					{

    142. 

  142. 						$this -> cache_id .= '___WhereIn2--' . $value['field'] . '-hasTheValues-';

    143. 

  143. 						foreach ($value['values'] as $whereinvals)

    144. 

  144. 						{

    145. 

  145. 							$this -> cache_id .= $whereinvals . '-or-';

    146. 

  146. 						}

    147. 

  147. 					}

    148. 

  148. 					break;

    149. 

  149. 

    150. 

  150. 				case 'sort' :

    151. 

  151. 					if (is_array($value))

    152. 

  152. 					{

    153. 

  153. 						$this -> cache_id .= '___Orderby--';

    154. 

  154. 						foreach ($value as $sk => $sv)

    155. 

  155. 						{

    156. 

  156. 							$this -> cache_id .= $sk . '-' . $sv . '-';

    157. 

  157. 						}

    158. 

  158. 					}

    159. 

  159. 					break;

    160. 

  160. 

    161. 

  161. 				case 'limit' :

    162. 

  162. 					$this -> cache_id .= '___Limit--' . $value;

    163. 

  163. 					break;

    164. 

  164. 

    165. 

  165. 				case 'groupby' :

    166. 

  166. 					$this -> cache_id .= '___Groupby--' . $value;

    167. 

  167. 					break;

    168. 

  168. 

    169. 

  169. 				case 'orderby' :

    170. 

  170. 					$this -> cache_id .= '___Orderby--';

    171. 

  171. 					foreach ($value as $orderKey => $orderValue)

    172. 

  172. 					{

    173. 

  173. 						$this -> cache_id .= $orderKey . '=' . $orderValue . '-';

    174. 

  174. 					}

    175. 

  175. 					break;

    176. 

  176. 			}

    177. 

  177. 		}

    178. 

  178. 

    179. 

  179. 		// END -- BUILD CACHE ID

    180. 

  180. 		// ------------------------------------------------------------------------------------

    181. 

  181. 

    182. 

  182. 		switch($cacheType)

    183. 

  183. 		{

    184. 

  184. 			case 'db' :

    185. 

  185. 				$CI -> firephp -> warn("Forced DB: " . $this -> cache_id);

    186. 

  186. 				if ($parentObject)

    187. 

  187. 				{

    188. 

  188. 					$parentObject -> $model -> get();

    189. 

  189. 					$this -> dm_object = $parentObject -> $model;

    190. 

  190. 				}

    191. 

  191. 				else

    192. 

  192. 				{

    193. 

  193. 					$this -> dm_object -> get();

    194. 

  194. 				}

    195. 

  195. 				break;

    196. 

  196. 

    197. 

  197. 			// START - FILE CACHE

    198. 

  198. 			// ------------------------------------------------------------------------------------

    199. 

  199. 

    200. 

  200. 			case 'file' :

    201. 

  201. 				$cacheLength = 3600;

    202. 

  202. 				$cache = $this -> cache -> file -> get($this -> cache_id);

    203. 

  203. 				if ($cache)

    204. 

  204. 				{

    205. 

  205. 					$CI -> firephp -> info("File Cache Loaded for: " . $this -> cache_id);

    206. 

  206. 					$this -> dm_object = new $model();

    207. 

  207. 					$this -> dm_object = $this -> dm_object -> all_from_array($cache);

    208. 

  208. 				}

    209. 

  209. 				else

    210. 

  210. 				{

    211. 

  211. 

    212. 

  212. 					if ($parentObject)

    213. 

  213. 					{

    214. 

  214. 						foreach ($array as $key => $value)

    215. 

  215. 						{

    216. 

  216. 							switch($key)

    217. 

  217. 							{

    218. 

  218. 								case 'where' :

    219. 

  219. 									$this -> addWhereClause($parentObject -> $model, $value);

    220. 

  220. 									break;

    221. 

  221. 								case 'or_where' :

    222. 

  222. 									$this -> addOrWhereClause($parentObject -> $model, $value);

    223. 

  223. 									break;

    224. 

  224. 

    225. 

  225. 								case 'or_like' :

    226. 

  226. 									$this -> addOrLikeClause($parentObject -> $model, $value);

    227. 

  227. 									break;

    228. 

  228. 

    229. 

  229. 								case 'wherein' :

    230. 

  230. 									$this -> addWhereInClause($parentObject -> $model, $value);

    231. 

  231. 									break;

    232. 

  232. 

    233. 

  233. 								case 'wherein2' :

    234. 

  234. 									$this -> addWhereInClause($parentObject -> $model, $value);

    235. 

  235. 									break;

    236. 

  236. 

    237. 

  237. 								case 'sort' :

    238. 

  238. 									$this -> addSortClause($parentObject -> $model, $value);

    239. 

  239. 									break;

    240. 

  240. 

    241. 

  241. 								case 'limit' :

    242. 

  242. 									$this -> addLimitClause($parentObject -> $model, $value);

    243. 

  243. 									break;

    244. 

  244. 								case 'groupby' :

    245. 

  245. 									$this -> addGroupByClause($parentObject -> $model, $value);

    246. 

  246. 									break;

    247. 

  247. 								case 'orderby' :

    248. 

  248. 									$CI -> firephp -> info("ORDER BY CALLED");

    249. 

  249. 									$this -> addOrderByClause($parentObject -> $model, $value);

    250. 

  250. 									break;

    251. 

  251. 							}

    252. 

  252. 						}

    253. 

  253. 

    254. 

  254. 						if ($id)

    255. 

  255. 						{

    256. 

  256. 							$CI -> firephp -> info("ID PASSED");

    257. 

  257. 							$this -> addWhereClause($parentObject -> model, array('id' => $id));

    258. 

  258. 						}

    259. 

  259. 

    260. 

  260. 						$parentObject -> $model -> get();

    261. 

  261. 						$this -> dm_object = $parentObject -> $model;

    262. 

  262. 						$arr = $this -> dm_object -> all_to_array();

    263. 

  263. 						$this -> cache -> file -> save($this -> cache_id, $arr, $cacheLength);

    264. 

  264. 						$this -> dm_object = $parentObject -> $model;

    265. 

  265. 						$CI -> firephp -> info("No Cache for: " . $this -> cache_id . ' A cache has been created');

    266. 

  266. 					}

    267. 

  267. 

    268. 

  268. 					// NO PARENT

    269. 

  269. 					else

    270. 

  270. 					{

    271. 

  271. 						$this -> dm_object = new $model();

    272. 

  272. 

    273. 

  273. 						if ($id)

    274. 

  274. 						{

    275. 

  275. 							$CI -> firephp -> info("ID PASSED");

    276. 

  276. 							$this -> addWhereClause($this -> dm_object, array('id' => $id));

    277. 

  277. 						}

    278. 

  278. 						foreach ($array as $key => $value)

    279. 

  279. 						{

    280. 

  280. 							switch($key)

    281. 

  281. 							{

    282. 

  282. 								case 'where' :

    283. 

  283. 									$this -> addWhereClause($this -> dm_object, $value);

    284. 

  284. 									break;

    285. 

  285. 

    286. 

  286. 								case 'or_where' :

    287. 

  287. 									$this -> addOrWhereClause($this -> dm_object, $value);

    288. 

  288. 									break;

    289. 

  289. 

    290. 

  290. 								case 'or_like' :

    291. 

  291. 									$this -> addOrLikeClause($this -> dm_object, $value);

    292. 

  292. 									break;

    293. 

  293. 

    294. 

  294. 								case 'wherein' :

    295. 

  295. 									$this -> addWhereInClause($this -> dm_object, $value);

    296. 

  296. 									break;

    297. 

  297. 

    298. 

  298. 								case 'wherein2' :

    299. 

  299. 									$this -> addWhereInClause($this -> dm_object, $value);

    300. 

  300. 									break;

    301. 

  301. 

    302. 

  302. 								case 'sort' :

    303. 

  303. 									$this -> addSortClause($this -> dm_object, $value);

    304. 

  304. 									break;

    305. 

  305. 

    306. 

  306. 								case 'limit' :

    307. 

  307. 									$this -> addLimitClause($this -> dm_object, $value);

    308. 

  308. 									break;

    309. 

  309. 								case 'groupby' :

    310. 

  310. 									$this -> addGroupByClause($this -> dm_object, $value);

    311. 

  311. 									break;

    312. 

  312. 								case 'orderby' :

    313. 

  313. 									$this -> addOrderByClause($this -> dm_object, $value);

    314. 

  314. 									break;

    315. 

  315. 							}

    316. 

  316. 						}

    317. 

  317. 						$this -> dm_object -> get();

    318. 

  318. 						$arr = $this -> dm_object -> all_to_array();

    319. 

  319. 						$this -> cache -> file -> save($this -> cache_id, $arr, $cacheLength);

    320. 

  320. 						$CI -> firephp -> info("No Cache for: " . $this -> cache_id . ' A cache has been created');

    321. 

  321. 						//$CI -> firephp -> info('LAST:'. $this -> dm_object -> check_last_query());

    322. 

  322. 					}

    323. 

  323. 

    324. 

  324. 				}

    325. 

  325. 				break;

    326. 

  326. 		}

    327. 

  327. 

    328. 

  328. 		// return this , which includes the dm_object

    329. 

  329. 		$this -> dm_object -> cache_id = $this -> cache_id;

    330. 

  330. 		return $this;

    331. 

  331. 	}

    332. 

  332. 

    333. 

  333. 	/**

    334. 

  334. 	 * Get a data mapper, if it is cached return the cached version!

    335. 

  335. 	 *

    336. 

  336. 	 * @param String $model

    337. 

  337. 	 * @param Int $id

    338. 

  338. 	 * @param DataMapper $parentbject

    339. 

  339. 	 * @param Boolean $from_db

    340. 

  340. 	 * @param Array $where

    341. 

  341. 	 */

    342. 

  342. 	public function getObject($model, $id, DataMapper $parentObject = null, $from_db = false, $where = '', $sort = '', $whereInObject = null, $limit = null, $whereIn = null)

    343. 

  343. 	{

    344. 

  344. 		$CI = &get_instance();

    345. 

  345. 		if (!$parentObject)

    346. 

  346. 		{

    347. 

  347. 			$this -> cache_id = 'database/[' . $model . '-' . $id . ']';

    348. 

  348. 			if (is_array($where))

    349. 

  349. 			{

    350. 

  350. 				$this -> cache_id .= '___WHERE_' . implode('_', $where) . '_' . implode('_', array_flip($where));

    351. 

  351. 			}

    352. 

  352. 

    353. 

  353. 			if (is_array($whereIn))

    354. 

  354. 			{

    355. 

  355. 				$str = '___WHERE-IN__field-' . $whereIn['field'];

    356. 

  356. 

    357. 

  357. 				foreach ($whereIn['values'] as $v)

    358. 

  358. 				{

    359. 

  359. 					$str .= '_id-' . $v;

    360. 

  360. 				}

    361. 

  361. 				$this -> cache_id .= $str;

    362. 

  362. 			}

    363. 

  363. 

    364. 

  364. 			if (is_array($whereInObject))

    365. 

  365. 			{

    366. 

  366. 				if (isset($whereInObject['object']) && isset($whereInObject['column']) && isset($whereInObject['value']))

    367. 

  367. 				{

    368. 

  368. 					// do stuff

    369. 

  369. 					$whereinmodel = $whereInObject['object'];

    370. 

  370. 					@$this -> cache_id .= '___WHEREIN_' . $whereinmodel . '__column-' . $whereInObject['column'] . '_value-' . $whereInObject['value'];

    371. 

  371. 				}

    372. 

  372. 				else

    373. 

  373. 				{

    374. 

  374. 					$CI -> firephp -> error("Error - included related used, or bad where in called - this is not supported. Cache id so far: " . $this -> cache_id);

    375. 

  375. 					//$from_db = true;

    376. 

  376. 				}

    377. 

  377. 			}

    378. 

  378. 			if ($sort)

    379. 

  379. 			{

    380. 

  380. 				$this -> cache_id .= '___SORT_' . '_' . implode('_', array_flip($sort));

    381. 

  381. 			}

    382. 

  382. 			if ($limit)

    383. 

  383. 			{

    384. 

  384. 				$this -> cache_id .= '___LIMIT_' . $limit;

    385. 

  385. 			}

    386. 

  386. 

    387. 

  387. 			//check the cache

    388. 

  388. 			if ($from_db)

    389. 

  389. 			{

    390. 

  390. 				$CI -> firephp -> warn("No Cache. Forced DB [P]: " . $this -> cache_id);

    391. 

  391. 				$this -> dm_object = new $model($id);

    392. 

  392. 

    393. 

  393. 				if (is_array($sort))

    394. 

  394. 				{

    395. 

  395. 					$this -> addSortClause($this -> dm_object, $sort);

    396. 

  396. 				}

    397. 

  397. 

    398. 

  398. 				if (is_array($where))

    399. 

  399. 				{

    400. 

  400. 					$this -> addWhereClause($this -> dm_object, $where);

    401. 

  401. 				}

    402. 

  402. 

    403. 

  403. 				if (is_array($whereIn))

    404. 

  404. 				{

    405. 

  405. 					$this -> addWhereInClause($this -> dm_object, $whereIn);

    406. 

  406. 				}

    407. 

  407. 

    408. 

  408. 				if ($limit)

    409. 

  409. 				{

    410. 

  410. 					$this -> addLimitClause($this -> dm_object, $limit);

    411. 

  411. 				}

    412. 

  412. 

    413. 

  413. 				if (is_array($whereInObject))

    414. 

  414. 				{

    415. 

  415. 					if (isset($whereInObject['object']) && isset($whereInObject['column']) && isset($whereInObject['value']))

    416. 

  416. 					{

    417. 

  417. 						$this -> addWhereInRelatedClause($this -> dm_object, $whereInObject);

    418. 

  418. 					}

    419. 

  419. 					else

    420. 

  420. 					{

    421. 

  421. 						$CI -> firephp -> error("Error - included related used, or bad where in called - this is not supported. Cache id so far: " . $this -> cache_id);

    422. 

  422. 					}

    423. 

  423. 				}

    424. 

  424. 				//echo('<div class="cachefeedback"> Calling from the DB for the '. $model .' <br>ID '.$id.'  Cache ID: '.$this->cache_id.'</div>');

    425. 

  425. 				$this -> dm_object -> get();

    426. 

  426. 

    427. 

  427. 			}

    428. 

  428. 			else

    429. 

  429. 			{

    430. 

  430. 				$cache = $this -> cache -> file -> get($this -> cache_id);

    431. 

  431. 				if ($cache)

    432. 

  432. 				{

    433. 

  433. 					//$cache = unserialize($cache);

    434. 

  434. 					$CI -> firephp -> info("Cache Loaded [P]: " . $this -> cache_id);

    435. 

  435. 					//$CI->firephp->info("Cache Type: " . $cache);

    436. 

  436. 					$this -> dm_object = new $model();

    437. 

  437. 					//$CI->firephp->info("Model: " . $model);

    438. 

  438. 					//$CI->firephp->info("Cache RAW for ".$this->cache_id." : " . print_r($cache, true));

    439. 

  439. 					$this -> dm_object = $this -> dm_object -> all_from_array($cache);

    440. 

  440. 					//$CI->firephp->info("Cache DM: " . print_r($this->dm_object, true));

    441. 

  441. 

    442. 

  442. 					//$this->dm_object = $tempModel;

    443. 

  443. 					//$CI->firephp->info("CACHE: ".$this->dm_object->all);

    444. 

  444. 

    445. 

  445. 				}

    446. 

  446. 

    447. 

  447. 				else

    448. 

  448. 				{

    449. 

  449. 					$CI -> firephp -> info("No Cache. Getting and creating [P]: " . $this -> cache_id);

    450. 

  450. 					//echo( '<hr> Creating a cache for model '. $model .' <br>ID '.$id    );

    451. 

  451. 					// we DO NOT have a cache...

    452. 

  452. 					$this -> dm_object = new $model();

    453. 

  453. 					if ($id)

    454. 

  454. 					{

    455. 

  455. 						$this -> addWhereClause($this -> dm_object, array('id' => $id));

    456. 

  456. 					}

    457. 

  457. 

    458. 

  458. 					if (is_array($sort))

    459. 

  459. 					{

    460. 

  460. 						$this -> addSortClause($this -> dm_object, $sort);

    461. 

  461. 					}

    462. 

  462. 

    463. 

  463. 					if (is_array($where))

    464. 

  464. 					{

    465. 

  465. 						$this -> addWhereClause($this -> dm_object, $where);

    466. 

  466. 					}

    467. 

  467. 

    468. 

  468. 					if (is_array($whereIn))

    469. 

  469. 					{

    470. 

  470. 						$this -> addWhereInClause($this -> dm_object, $whereIn);

    471. 

  471. 					}

    472. 

  472. 

    473. 

  473. 					if ($limit)

    474. 

  474. 					{

    475. 

  475. 						$this -> addLimitClause($this -> dm_object, $limit);

    476. 

  476. 					}

    477. 

  477. 

    478. 

  478. 					if (is_array($whereInObject))

    479. 

  479. 					{

    480. 

  480. 						if (isset($whereInObject['object']) && isset($whereInObject['column']) && isset($whereInObject['value']))

    481. 

  481. 						{

    482. 

  482. 							$this -> addWhereInRelatedClause($this -> dm_object, $whereInObject);

    483. 

  483. 						}

    484. 

  484. 						else

    485. 

  485. 						{

    486. 

  486. 							$CI -> firephp -> error("Error - included related used, or bad where in called - this is not supported. Cache id so far: " . $this -> cache_id);

    487. 

  487. 						}

    488. 

  488. 					}

    489. 

  489. 					$this -> dm_object -> get();

    490. 

  490. 					//

    491. 

  491. 					$arr = $this -> dm_object -> all_to_array();

    492. 

  492. 					//print_r($arr);

    493. 

  493. 					//$CI->firephp->info("Cache save: ".$this->cache_id." : " . print_r($arr, true));

    494. 

  494. 					$this -> cache -> file -> save($this -> cache_id, $arr, 3600);

    495. 

  495. 					//echo('<div class="cachefeedback"> Creating a cache for the '. $model .' <br>ID '.$id.' Cache ID: '.$this->cache_id.'</div>');

    496. 

  496. 

    497. 

  497. 					//$CI->firephp->info("NO CACHE: ".$this->dm_object->all);

    498. 

  498. 				}

    499. 

  499. 

    500. 

  500. 			}

    501. 

  501. 			// datamapper is inside;

    502. 

  502. 			//$CI->firephp->info("Returning -this- Marker 1: " );

    503. 

  503. 			return $this;

    504. 

  504. 		}

    505. 

  505. 

    506. 

  506. 		else

    507. 

  507. 		{

    508. 

  508. 

    509. 

  509. 			$parent = $parentObject -> model;

    510. 

  510. 			$this -> cache_id = 'database/[' . $model . '-' . $id . ']';

    511. 

  511. 			$this -> cache_id .= '___ON_PARENT_' . $parent . '-with-ID-of-' . $parentObject -> id;

    512. 

  512. 

    513. 

  513. 			if (is_array($where))

    514. 

  514. 			{

    515. 

  515. 				@$this -> cache_id .= '___WHERE_' . implode('_', $where) . '_' . implode('_', array_flip($where));

    516. 

  516. 			}

    517. 

  517. 

    518. 

  518. 			if (is_array($whereIn))

    519. 

  519. 			{

    520. 

  520. 				$str = '___WHERE-IN__field-' . $whereIn['field'];

    521. 

  521. 

    522. 

  522. 				foreach ($whereIn['values'] as $v)

    523. 

  523. 				{

    524. 

  524. 					$str .= '_id-' . $v;

    525. 

  525. 				}

    526. 

  526. 				$this -> cache_id .= $str;

    527. 

  527. 			}

    528. 

  528. 

    529. 

  529. 			if (is_array($whereInObject))

    530. 

  530. 			{

    531. 

  531. 				if (isset($whereInObject['object']) && isset($whereInObject['column']) && isset($whereInObject['value']))

    532. 

  532. 				{

    533. 

  533. 					$CI -> firephp -> error("Error - WHERE IN cannot be called on a parent");

    534. 

  534. 				}

    535. 

  535. 				else

    536. 

  536. 				{

    537. 

  537. 					$CI -> firephp -> error("Error - included related used, or bad where in called - this is not supported. Cache id so far: " . $this -> cache_id);

    538. 

  538. 				}

    539. 

  539. 			}

    540. 

  540. 

    541. 

  541. 			if ($sort)

    542. 

  542. 			{

    543. 

  543. 				$this -> cache_id .= '___SORT_' . '_' . implode('_', array_flip($sort));

    544. 

  544. 			}

    545. 

  545. 

    546. 

  546. 			if ($limit)

    547. 

  547. 			{

    548. 

  548. 				$this -> cache_id .= '___LIMIT_' . implode('_', $limit);

    549. 

  549. 			}

    550. 

  550. 

    551. 

  551. 			//echo $this->cache_id.'<br/>';

    552. 

  552. 			//echo $this->cache->file->get( $this->cache_id );

    553. 

  553. 			// cache id based on model parent combo

    554. 

  554. 			if ($from_db)

    555. 

  555. 			{

    556. 

  556. 				$CI -> firephp -> info("No Cache. Forced DB: " . $this -> cache_id);

    557. 

  557. 				//$parentObject->$model->get();

    558. 

  558. 				if (is_array($where))

    559. 

  559. 				{

    560. 

  560. 					$this -> addWhereClause($parentObject -> $model, $where);

    561. 

  561. 				}

    562. 

  562. 

    563. 

  563. 				if (is_array($whereIn))

    564. 

  564. 				{

    565. 

  565. 					$this -> addWhereInClause($this -> dm_object, $whereIn);

    566. 

  566. 				}

    567. 

  567. 

    568. 

  568. 				if (is_array($sort))

    569. 

  569. 				{

    570. 

  570. 					$this -> addSortClause($this -> dm_object, $sort);

    571. 

  571. 				}

    572. 

  572. 

    573. 

  573. 				if ($limit)

    574. 

  574. 				{

    575. 

  575. 					$this -> addLimitClause($this -> dm_object, $limit);

    576. 

  576. 				}

    577. 

  577. 

    578. 

  578. 				$parentObject -> $model -> get();

    579. 

  579. 				$this -> dm_object = $parentObject -> $model;

    580. 

  580. 				//echo('<div class="cachefeedback"> Calling from DB for the '. $model .' <br>ID '.$id.' Parent model ' . $parent.'</div>');

    581. 

  581. 			}

    582. 

  582. 

    583. 

  583. 			if ($cache = $this -> cache -> file -> get($this -> cache_id))

    584. 

  584. 			{

    585. 

  585. 				$CI -> firephp -> info("Cache Loaded: " . $this -> cache_id);

    586. 

  586. 				$this -> dm_object = new $model();

    587. 

  587. 				//$CI->firephp->info("Model: " . $model);

    588. 

  588. 				//$CI->firephp->info("Cache RAW for ".$this->cache_id." : " . print_r($cache, true));

    589. 

  589. 				$this -> dm_object -> all_from_array($cache, '');

    590. 

  590. 				//$CI->firephp->info("ID: " . $this->dm_object->id);

    591. 

  591. 			}

    592. 

  592. 

    593. 

  593. 			else

    594. 

  594. 			{

    595. 

  595. 				$CI -> firephp -> info("No Cache. Getting and creating: " . $this -> cache_id);

    596. 

  596. 				//echo 'failled to load cache';

    597. 

  597. 				//$parentObject->$model->get();

    598. 

  598. 				if (is_array($where))

    599. 

  599. 				{

    600. 

  600. 					$this -> addWhereClause($parentObject -> $model, $where);

    601. 

  601. 				}

    602. 

  602. 

    603. 

  603. 				if (is_array($whereIn))

    604. 

  604. 				{

    605. 

  605. 					$this -> addWhereInClause($parentObject -> $model, $whereIn);

    606. 

  606. 				}

    607. 

  607. 

    608. 

  608. 				if (is_array($sort))

    609. 

  609. 				{

    610. 

  610. 					$this -> addSortClause($parentObject -> $model, $sort);

    611. 

  611. 				}

    612. 

  612. 

    613. 

  613. 				if ($limit)

    614. 

  614. 				{

    615. 

  615. 					$this -> addLimitClause($parentObject -> $model, $limit);

    616. 

  616. 				}

    617. 

  617. 

    618. 

  618. 				$parentObject -> $model -> get();

    619. 

  619. 				$this -> dm_object = $parentObject -> $model;

    620. 

  620. 				// Save the cache file

    621. 

  621. 				$arr = $this -> dm_object -> all_to_array();

    622. 

  622. 				$this -> cache -> file -> save($this -> cache_id, $arr, 3600);

    623. 

  623. 			}

    624. 

  624. 

    625. 

  625. 			return $this;

    626. 

  626. 		}

    627. 

  627. 

    628. 

  628. 	}

    629. 

  629. 

    630. 

  630. 	private function addWhereClause(DataMapper &$dm_object, array $where)

    631. 

  631. 	{

    632. 

  632. 		foreach ($where as $field => $condition)

    633. 

  633. 		{

    634. 

  634. 			$dm_object -> where($field, $condition);

    635. 

  635. 		}

    636. 

  636. 		//print_R( get_class_methods( $dm_object) );

    637. 

  637. 		//print_R(  $dm_object->get_sql() );

    638. 

  638. 

    639. 

  639. 		return true;

    640. 

  640. 	}

    641. 

  641. 

    642. 

  642. 	private function addOrWhereClause(DataMapper &$dm_object, array $where)

    643. 

  643. 	{

    644. 

  644. 		$CI = &get_instance();

    645. 

  645. 		$count = 1;

    646. 

  646. 		$CI -> firephp -> error("Error - OR WHERE");

    647. 

  647. 		$dm_object -> group_start();

    648. 

  648. 		foreach ($where['values'] as $svK => $svV)

    649. 

  649. 		{

    650. 

  650. 			if ($count)

    651. 

  651. 			{

    652. 

  652. 				log_message("error", '<br/>WHERE ' . $svK . ' is ' . $svV);

    653. 

  653. 				$dm_object -> where($svK, $svV);

    654. 

  654. 				$count = 0;

    655. 

  655. 			}

    656. 

  656. 			else

    657. 

  657. 			{

    658. 

  658. 				log_message("error", '<br/>OR WHERE ' . $svK . ' is ' . $svV);

    659. 

  659. 				$dm_object -> or_where($svK, $svV);

    660. 

  660. 			}

    661. 

  661. 

    662. 

  662. 		}

    663. 

  663. 		$dm_object -> group_end();

    664. 

  664. 

    665. 

  665. 		return true;

    666. 

  666. 	}

    667. 

  667. 

    668. 

  668. 	private function addOrLikeClause(DataMapper &$dm_object, array $where)

    669. 

  669. 	{

    670. 

  670. 		$CI = &get_instance();

    671. 

  671. 		$count = 1;

    672. 

  672. 		$CI -> firephp -> error("Error - OR LIKE");

    673. 

  673. 		$dm_object -> group_start();

    674. 

  674. 		foreach ($where['values'] as $svK => $svV)

    675. 

  675. 		{

    676. 

  676. 			if ($count)

    677. 

  677. 			{

    678. 

  678. 				log_message("error", '<br/>LIKE ' . $svK . ' is ' . $svV);

    679. 

  679. 				$dm_object -> like($svK, $svV);

    680. 

  680. 				$count = 0;

    681. 

  681. 			}

    682. 

  682. 			else

    683. 

  683. 			{

    684. 

  684. 				log_message("error", '<br/>OR LIKE ' . $svK . ' is ' . $svV);

    685. 

  685. 				$dm_object -> or_like($svK, $svV);

    686. 

  686. 			}

    687. 

  687. 

    688. 

  688. 		}

    689. 

  689. 		$dm_object -> group_end();

    690. 

  690. 

    691. 

  691. 		return true;

    692. 

  692. 	}

    693. 

  693. 

    694. 

  694. 	private function addWhereInClause(DataMapper &$dm_object, array $whereIn)

    695. 

  695. 	{

    696. 

  696. 		$field = $whereIn['field'];

    697. 

  697. 		$values = $whereIn['values'];

    698. 

  698. 		$dm_object -> where_in($field, $values);

    699. 

  699. 		return true;

    700. 

  700. 	}

    701. 

  701. 

    702. 

  702. 	private function addWhereInRelatedClause(DataMapper &$dm_object, array $wherein)

    703. 

  703. 	{

    704. 

  704. 		$dm_object -> where_in_related($wherein['object'], $wherein['column'], $wherein['value']);

    705. 

  705. 		//print_R( get_class_methods( $dm_object) );

    706. 

  706. 		//print_R(  $dm_object->get_sql() );

    707. 

  707. 

    708. 

  708. 		return true;

    709. 

  709. 	}

    710. 

  710. 

    711. 

  711. 	private function addSortClause(DataMapper &$dm_object, array $sort)

    712. 

  712. 	{

    713. 

  713. 		foreach ($sort as $field => $condition)

    714. 

  714. 		{

    715. 

  715. 			$dm_object -> order_by($field, $condition);

    716. 

  716. 		}

    717. 

  717. 		//print_R( get_class_methods( $dm_object) );

    718. 

  718. 		//print_R(  $dm_object->get_sql() );

    719. 

  719. 

    720. 

  720. 		return true;

    721. 

  721. 	}

    722. 

  722. 

    723. 

  723. 	private function addLimitClause(DataMapper &$dm_object, $limit)

    724. 

  724. 	{

    725. 

  725. 

    726. 

  726. 		$dm_object -> limit($limit);

    727. 

  727. 

    728. 

  728. 		//print_R( get_class_methods( $dm_object) );

    729. 

  729. 		//print_R(  $dm_object->get_sql() );

    730. 

  730. 

    731. 

  731. 		return true;

    732. 

  732. 	}

    733. 

  733. 

    734. 

  734. 	private function addOrderByClause(DataMapper &$dm_object, $arr)

    735. 

  735. 	{

    736. 

  736. 		$CI = &get_instance();

    737. 

  737. 		foreach ($arr as $key => $value)

    738. 

  738. 		{

    739. 

  739. 			$CI -> firephp -> info("OREDERBY INSIDE: ARRAY VALUES: " . $key . '----' . $value);

    740. 

  740. 			$dm_object -> order_by($key, $value);

    741. 

  741. 		}

    742. 

  742. 

    743. 

  743. 		//print_R( get_class_methods( $dm_object) );

    744. 

  744. 		//print_R(  $dm_object->get_sql() );

    745. 

  745. 

    746. 

  746. 		return true;

    747. 

  747. 	}

    748. 

  748. 

    749. 

  749. 	private function addGroupByClause(DataMapper &$dm_object, $group)

    750. 

  750. 	{

    751. 

  751. 

    752. 

  752. 		$dm_object -> group_by($group);

    753. 

  753. 

    754. 

  754. 		//print_R( get_class_methods( $dm_object) );

    755. 

  755. 		//print_R(  $dm_object->get_sql() );

    756. 

  756. 

    757. 

  757. 		return true;

    758. 

  758. 	}

    759. 

  759. 

    760. 

  760. 	private function addIncludeRelatedClause(DataMapper &$dm_object, array $include_related)

    761. 

  761. 	{

    762. 

  762. 		foreach ($include_related as $condition)

    763. 

  763. 		{

    764. 

  764. 			$dm_object -> include_related($condition, '*', true, true);

    765. 

  765. 		}

    766. 

  766. 		//echo $field;

    767. 

  767. 		//print_R( get_class_methods( $dm_object) );

    768. 

  768. 		//print_R(  $dm_object->get_sql() );

    769. 

  769. 

    770. 

  770. 		return true;

    771. 

  771. 	}

    772. 

  772. 

    773. 

  773. 	final function removeCachedObject($model, $id, DataMapper $parentObject = null, $where = '', $sort = '', $include_related = '', $limit = '')

    774. 

  774. 	{

    775. 

  775. 		$CI = &get_instance();

    776. 

  776. 		if (!$parentObject)

    777. 

  777. 		{

    778. 

  778. 			$this -> cache_id = 'database/[' . $model . '-' . $id . ']';

    779. 

  779. 			if (is_array($where))

    780. 

  780. 			{

    781. 

  781. 				@$this -> cache_id .= '___WHERE_' . implode('_', $where) . '_' . implode('_', array_flip($where));

    782. 

  782. 			}

    783. 

  783. 

    784. 

  784. 			if (is_array($include_related))

    785. 

  785. 			{

    786. 

  786. 				@$this -> cache_id .= '___INCLUDERELATED_' . implode('_', $include_related) . '_' . implode('_', array_flip($include_related));

    787. 

  787. 			}

    788. 

  788. 			if ($sort)

    789. 

  789. 			{

    790. 

  790. 				$this -> cache_id .= '___SORT_' . '_' . implode('_', array_flip($sort));

    791. 

  791. 			}

    792. 

  792. 

    793. 

  793. 			if ($limit)

    794. 

  794. 			{

    795. 

  795. 				$this -> cache_id .= '___LIMIT_' . $limit;

    796. 

  796. 			}

    797. 

  797. 

    798. 

  798. 		}

    799. 

  799. 		else

    800. 

  800. 		{

    801. 

  801. 			$parent = $parentObject -> model;

    802. 

  802. 			$this -> cache_id = 'database/[' . $model . '-' . $id . ']';

    803. 

  803. 			$this -> cache_id .= '___ON_PARENT_' . $parent . '-with-ID-of-' . $parentObject -> id;

    804. 

  804. 

    805. 

  805. 			if (is_array($where))

    806. 

  806. 			{

    807. 

  807. 				@$this -> cache_id .= '___WHERE_' . implode('_', $where) . '_' . implode('_', array_flip($where));

    808. 

  808. 			}

    809. 

  809. 

    810. 

  810. 			if (is_array($include_related))

    811. 

  811. 			{

    812. 

  812. 				@$this -> cache_id .= '___INCLUDERELATED_' . implode('_', $include_related) . '_' . implode('_', array_flip($include_related));

    813. 

  813. 			}

    814. 

  814. 			if ($sort)

    815. 

  815. 			{

    816. 

  816. 				$this -> cache_id .= '___SORT_' . '_' . implode('_', array_flip($sort));

    817. 

  817. 			}

    818. 

  818. 

    819. 

  819. 			if ($limit)

    820. 

  820. 			{

    821. 

  821. 				$this -> cache_id .= '___LIMIT_' . $limit;

    822. 

  822. 			}

    823. 

  823. 		}

    824. 

  824. 

    825. 

  825. 		//$CI->firephp->error("Cache about to be deleted: ".$this->cache_id);

    826. 

  826. 		//log_message('error', "Cache about to be deleted: ".$this->cache_id);

    827. 

  827. 		if (@$this -> cache -> file -> delete($this -> cache_id))

    828. 

  828. 		{

    829. 

  829. 			$CI -> firephp -> info("Cache deleted successfully: " . $this -> cache_id);

    830. 

  830. 			return true;

    831. 

  831. 		}

    832. 

  832. 		else

    833. 

  833. 		{

    834. 

  834. 			$CI -> firephp -> error("Cache failed to delete: " . $this -> cache_id);

    835. 

  835. 			return false;

    836. 

  836. 		}

    837. 

  837. 

    838. 

  838. 	}

    839. 

  839. 

    840. 

  840. 	function dm_timestamp()

    841. 

  841. 	{

    842. 

  842. 		$timestamp = (DataMapper::$config['local_time']) ? date(DataMapper::$config['timestamp_format']) : gmdate(DataMapper::$config['timestamp_format']);

    843. 

  843. 		return (DataMapper::$config['unix_timestamp']) ? strtotime($timestamp) : $timestamp;

    844. 

  844. 	}

    845. 

  845. 

    846. 

  846. 	function timeline($object, $userID, $timestamp, $data, $newCreation = false)

    847. 

  847. 	{

    848. 

  848. 		//log_message('error', 'Timeline Call with Object of:'.get_class($object).'    $data of: '.get_class($data));

    849. 

  849. 		//log_message('error', '$data of: '.$data->exists());

    850. 

  850. 

    851. 

  851. 		if ($data && strtolower(get_class($data)) != 'my_model')

    852. 

  852. 		{

    853. 

  853. 			log_message('error', 'we have data and $data is not my_model');

    854. 

  854. 			log_message('error', '$data is: ' . get_class($data) . ' with id of: ' . $data -> id);

    855. 

  855. 			log_message('error', '$object is: ' . get_class($object) . ' with id of: ' . $object -> id);

    856. 

  856. 			$dataModelName = get_class($data);

    857. 

  857. 

    858. 

  858. 			if (0)//$object -> is_related_to($dataModelName, $data->id))

    859. 

  859. 			{

    860. 

  860. 				// already related, no change

    861. 

  861. 				log_message('error', 'already related, no change');

    862. 

  862. 			}

    863. 

  863. 			else

    864. 

  864. 			{

    865. 

  865. 				log_message('error', 'not related, in else');

    866. 

  866. 				$modelName = get_class($object);

    867. 

  867. 				log_message('error', 'we have model name: ' . $modelName);

    868. 

  868. 				$transactionID = uniqid(rand(), true);

    869. 

  869. 				//log_message('error', 'Data is??? ' . get_class($data));

    870. 

  870. 				$tr = new Timeline();

    871. 

  871. 				$tr -> related_model = get_class($data);

    872. 

  872. 				$tr -> related_model_id = $data -> id;

    873. 

  873. 				$tr -> model = $modelName;

    874. 

  874. 				$tr -> model_id = $object -> id;

    875. 

  875. 				$tr -> updated_by = $userID;

    876. 

  876. 				$tr -> updated = $timestamp;

    877. 

  877. 				$tr -> created = $timestamp;

    878. 

  878. 				$tr -> created_by = $userID;

    879. 

  879. 				$tr -> transactionID = $transactionID;

    880. 

  880. 				$tr -> type = 'relationship';

    881. 

  881. 

    882. 

  882. 				log_message('error', 'timeline - about to save');

    883. 

  883. 				$tr -> save();

    884. 

  884. 				log_message('error', 'change - timeline changed');

    885. 

  885. 				$newTimelineMarkup = $tr -> createTimelineTransactionMarkup($tr);

    886. 

  886. 			}

    887. 

  887. 		}

    888. 

  888. 		else

    889. 

  889. 		{

    890. 

  890. 			//log_message('error', 'invlaid data, no relation');

    891. 

  891. 			$modelName = get_class($object);

    892. 

  892. 			$oldObject = new $modelName($object -> id);

    893. 

  893. 			$transactionID = uniqid(rand(), true);

    894. 

  894. 

    895. 

  895. 			// AUDIT TABKEL

    896. 

  896. 			$fields = $this -> db -> list_fields($object -> table);

    897. 

  897. 			//log_message('error', 'OldObject Exists?: ' . $oldObject -> exists());

    898. 

  898. 			//log_message('error', 'OldObject ID?: ' . $oldObject -> id);

    899. 

  899. 			//log_message('error', 'OldObject Updated?: ' . $oldObject -> updated);

    900. 

  900. 

    901. 

  901. 			// If it has never been updated before, it must be a new one (for some reason the object already exists, when using DMZ-fromarray)

    902. 

  902. 			if (!$newCreation)

    903. 

  903. 			{

    904. 

  904. 				foreach ($fields as $field)

    905. 

  905. 				{

    906. 

  906. 					//log_message('error', $object -> $field . '<Object oldObject->' . $oldObject -> $field . ' Field->' . $field);

    907. 

  907. 

    908. 

  908. 					if ($object -> $field != $oldObject -> $field)

    909. 

  909. 					{

    910. 

  910. 						// We have a change!

    911. 

  911. 						$t = new Timeline();

    912. 

  912. 						$t -> oldValue = (string)$oldObject -> $field;

    913. 

  913. 						$t -> newValue = $object -> $field;

    914. 

  914. 						$t -> field = $field;

    915. 

  915. 						$t -> type = 'update';

    916. 

  916. 						$t -> transactionID = $transactionID;

    917. 

  917. 

    918. 

  918. 						$t -> model = $modelName;

    919. 

  919. 						$t -> model_id = $object -> id;

    920. 

  920. 

    921. 

  921. 						if ($data)

    922. 

  922. 						{

    923. 

  923. 							$t -> related_model = get_class($data);

    924. 

  924. 							$t -> related_model_id = $data -> id;

    925. 

  925. 						}

    926. 

  926. 

    927. 

  927. 						$t -> updated_by = $userID;

    928. 

  928. 						$t -> updated = $timestamp;

    929. 

  929. 						$t -> created = $timestamp;

    930. 

  930. 						$t -> created_by = $userID;

    931. 

  931. 

    932. 

  932. 						$t -> save();

    933. 

  933. 

    934. 

  934. 						$ti = new Timeline();

    935. 

  935. 						$newTimelineMarkup = $ti -> createTimelineTransactionMarkup($t);

    936. 

  936. 

    937. 

  937. 					}

    938. 

  938. 

    939. 

  939. 				}

    940. 

  940. 			}

    941. 

  941. 			else

    942. 

  942. 			{

    943. 

  943. 				// This is new creation

    944. 

  944. 				$t = new Timeline();

    945. 

  945. 

    946. 

  946. 				$t -> type = 'creation';

    947. 

  947. 				$t -> transactionID = $transactionID;

    948. 

  948. 				$t -> model = $modelName;

    949. 

  949. 				$t -> model_id = $object -> id;

    950. 

  950. 				$t -> updated_by = $userID;

    951. 

  951. 				$t -> updated = $timestamp;

    952. 

  952. 				$t -> created = $timestamp;

    953. 

  953. 				$t -> created_by = $userID;

    954. 

  954. 				$t -> save();

    955. 

  955. 				$ti = new Timeline();

    956. 

  956. 				$newTimelineMarkup = $ti -> createTimelineTransactionMarkup($t);
    957. 

  957. 			}

    958. 

  958. 		}

    959. 

  959. 

    960. 

  960. 	}

    961. 

  961. 

    962. 

  962. 	/**

    963. 

  963. 	 * Sorta overload, so we can add some custom save fields

    964. 

  964. 	 *

    965. 

  965. 	 * @param unknown_type $data

    966. 

  966. 	 */

    967. 

  967. 	function save($data = null)

    968. 

  968. 	{

    969. 

  969. 		//print_r($data);

    970. 

  970. 		$this -> CI = get_instance();

    971. 

  971. 		$this -> user = $this -> CI -> user;

    972. 

  972. 

    973. 

  973. 		$timestamp = $this -> dm_timestamp();

    974. 

  974. 		//(DataMapper::$config['local_time']) ? date(DataMapper::$config['timestamp_format']) : gmdate(DataMapper::$config['timestamp_format']);

    975. 

  975. 

    976. 

  976. 		if ($this -> id)

    977. 

  977. 		{

    978. 

  978. 			$this -> updated_by = $this -> user -> id;

    979. 

  979. 			$this -> updated = $timestamp;

    980. 

  980. 		}

    981. 

  981. 		else

    982. 

  982. 		{

    983. 

  983. 			$this -> created = $timestamp;

    984. 

  984. 			$this -> created_by = $this -> user -> id;

    985. 

  985. 		}

    986. 

  986. 

    987. 

  987. 		// Check table fields are all there.......

    988. 

  988. 		if (ENVIRONMENT == 'development')

    989. 

  989. 		{

    990. 

  990. 			$fields = array();

    991. 

  991. 			$ok = true;

    992. 

  992. 			if (!$this -> db -> field_exists('updated', $this -> table))

    993. 

  993. 			{

    994. 

  994. 				$ok = false;

    995. 

  995. 				log_message('error', 'updated field did not exist.');

    996. 

  996. 

    997. 

  997. 				$fields['updated'] = array('type' => 'datetime', );

    998. 

  998. 

    999. 

  999. 			}

    1000. 

  1000. 			if (!$this -> db -> field_exists('updated_by', $this -> table))

    1001. 

  1001. 			{

    1002. 

  1002. 				$ok = false;

    1003. 

  1003. 				log_message('error', 'updated by field did not exist.');

    1004. 

  1004. 

    1005. 

  1005. 				$fields['updated_by'] = array(

    1006. 

  1006. 					'type' => 'INT',

    1007. 

  1007. 					'constraint' => 6,

    1008. 

  1008. 				);

    1009. 

  1009. 			}

    1010. 

  1010. 			if (!$this -> db -> field_exists('created', $this -> table))

    1011. 

  1011. 			{

    1012. 

  1012. 				$ok = false;

    1013. 

  1013. 				log_message('error', 'created field did not exist.');

    1014. 

  1014. 

    1015. 

  1015. 				$fields['created'] = array('type' => 'datetime', );

    1016. 

  1016. 

    1017. 

  1017. 			}

    1018. 

  1018. 			if (!$this -> db -> field_exists('created_by', $this -> table))

    1019. 

  1019. 			{

    1020. 

  1020. 				$ok = false;

    1021. 

  1021. 				log_message('error', 'created by field did not exist.');

    1022. 

  1022. 

    1023. 

  1023. 				$fields['created_by'] = array(

    1024. 

  1024. 					'type' => 'INT',

    1025. 

  1025. 					'constraint' => 6,

    1026. 

  1026. 				);

    1027. 

  1027. 			}

    1028. 

  1028. 

    1029. 

  1029. 			if (!$ok)

    1030. 

  1030. 			{

    1031. 

  1031. 				log_message('error', 'Updating Table: ' . $this -> table . '  Adding fields: ' . print_r($fields, 1));

    1032. 

  1032. 				$this -> CI -> load -> dbforge();

    1033. 

  1033. 				$this -> CI -> dbforge -> add_column($this -> table, $fields);

    1034. 

  1034. 			}

    1035. 

  1035. 		}

    1036. 

  1036. 		// End developement check

    1037. 

  1037. 

    1038. 

  1038. 		// Get Changes

    1039. 

  1039. 		if ($this -> table != 'timelines')

    1040. 

  1040. 		{

    1041. 

  1041. 			if ($this -> created && $this -> updated)

    1042. 

  1042. 			{

    1043. 

  1043. 				$this -> timeline($this, $this -> user -> id, $timestamp, $data);

    1044. 

  1044. 				$res = parent::save($data);

    1045. 

  1045. 			}

    1046. 

  1046. 			else

    1047. 

  1047. 			{

    1048. 

  1048. 				// This is a new object, and thus we need to save it first, so we can get its ID

    1049. 

  1049. 				$res = parent::save($data);

    1050. 

  1050. 				$this -> timeline($this, $this -> user -> id, $timestamp, $data, true);

    1051. 

  1051. 			}

    1052. 

  1052. 		}

    1053. 

  1053. 		else

    1054. 

  1054. 		{

    1055. 

  1055. 			// do not timeline a timelines save! Recursive!

    1056. 

  1056. 			$res = parent::save($data);

    1057. 

  1057. 		}

    1058. 

  1058. 

    1059. 

  1059. 		return $res;

    1060. 

  1060. 

    1061. 

  1061. 	}

    1062. 

  1062. 

    1063. 

  1063. 	public function search(array $data, DataMapper $dmObject, $where = '')

    1064. 

  1064. 	{

    1065. 

  1065. 

    1066. 

  1066. 		$search = $data['search'];

    1067. 

  1067. 		$dmObject -> or_like('title', $search);

    1068. 

  1068. 		$dmObject -> or_like('description', $search);

    1069. 

  1069. 		if ($where)

    1070. 

  1070. 		{

    1071. 

  1071. 			if (is_array($where))

    1072. 

  1072. 			{

    1073. 

  1073. 

    1074. 

  1074. 				foreach ($where as $k => $w)

    1075. 

  1075. 				{

    1076. 

  1076. 					$sql[] = $k . ' = "' . $w . '"';

    1077. 

  1077. 				}

    1078. 

  1078. 				$where = '( ' . implode(' AND ', $sql) . ')';

    1079. 

  1079. 			}

    1080. 

  1080. 

    1081. 

  1081. 			$dmObject -> having($where);

    1082. 

  1082. 		}

    1083. 

  1083. 		$dmObject -> get();

    1084. 

  1084. 

    1085. 

  1085. 		return $dmObject;

    1086. 

  1086. 	}

    1087. 

  1087. 

    1088. 

  1088. 	public function getItems($type, $model, $sort, $where = null, $include_related = null, $returnArray = false)

    1089. 

  1089. 	{

    1090. 

  1090. 

    1091. 

  1091. 		// if its a post, we should search the DB

    1092. 

  1092. 		if (isset($_GET['search']))

    1093. 

  1093. 		{

    1094. 

  1094. 			// check if user is sorting

    1095. 

  1095. 			if ($sort)

    1096. 

  1096. 			{

    1097. 

  1097. 				//add sort clause

    1098. 

  1098. 				$model -> order_by("created", $sort);

    1099. 

  1099. 			}

    1100. 

  1100. 			$data['search'] = $_GET['search'];

    1101. 

  1101. 			if ($returnArray)

    1102. 

  1102. 			{

    1103. 

  1103. 				return $model -> search($data, $model, $where, $include_related) -> all_to_array();

    1104. 

  1104. 			}

    1105. 

  1105. 			return $model -> search($data, $model, $where, $include_related);

    1106. 

  1106. 			// search using parent function, generic across the board

    1107. 

  1107. 		}

    1108. 

  1108. 		else// just return either cached or sorted results

    1109. 

  1109. 		{

    1110. 

  1110. 

    1111. 

  1111. 			if ($returnArray)

    1112. 

  1112. 			{

    1113. 

  1113. 				return $model -> getObject($type, null, null, true, $where, $include_related, $sort) -> dm_object -> all_to_array();

    1114. 

  1114. 			}

    1115. 

  1115. 			return $model -> getObject($type, null, null, true, $where, $include_related, $sort) -> dm_object;

    1116. 

  1116. 

    1117. 

  1117. 			// get the default cached list of item, return as array

    1118. 

  1118. 		}

    1119. 

  1119. 	}

    1120. 

  1120. 

    1121. 

  1121. 	public function more($id, $model)

    1122. 

  1122. 	{

    1123. 

  1123. 

    1124. 

  1124. 		return $model -> where('id >' . $id) -> order_by("created", 'asc') -> limit(3) -> get();

    1125. 

  1125. 

    1126. 

  1126. 	}

    1127. 

  1127. 

    1128. 

  1128. 	public function getCachedActivity()

    1129. 

  1129. 	{

    1130. 

  1130. 

    1131. 

  1131. 		$cacheID = 'activity_cache';

    1132. 

  1132. 		// set the cache id

    1133. 

  1133. 

    1134. 

  1134. 		return $this -> cache -> file -> get($cacheID);

    1135. 

  1135. 

    1136. 

  1136. 	}

    1137. 

  1137. 

    1138. 

  1138. 	public function commentCacheActivity($type, $arr, array $comment)

    1139. 

  1139. 	{

    1140. 

  1140. 

    1141. 

  1141. 		$cacheID = 'activity_cache';

    1142. 

  1142. 		// set the cache id

    1143. 

  1143. 

    1144. 

  1144. 		if (!$arr['id'])

    1145. 

  1145. 		{

    1146. 

  1146. 			throw new Exception('No id found in the datamapper object, there must be an ID');

    1147. 

  1147. 			// if there was no id throw an exception as, it should never passs here with out having an id

    1148. 

  1148. 		}

    1149. 

  1149. 

    1150. 

  1150. 		if (!$arr['created_by'])

    1151. 

  1151. 		{

    1152. 

  1152. 			throw new Exception('No created_by int found in the datamapper object, there must be an created by value');

    1153. 

  1153. 			// if there was no id throw an exception as, it should never passs here with out having an id

    1154. 

  1154. 		}

    1155. 

  1155. 		// check the datamapper object

    1156. 

  1156. 

    1157. 

  1157. 		$activityCache = $this -> cache -> file -> get($cacheID);

    1158. 

  1158. 		// get the activity cache

    1159. 

  1159. 

    1160. 

  1160. 		$activityCache[$type . '_' . $arr['id']][$arr['created_by']][$type][$arr['id']]['comments'][] = $comment;

    1161. 

  1161. 		// instead of just having a numerical index combine both type and id so it will always be unque, iner lvels keys also contain this info

    1162. 

  1162. 

    1163. 

  1163. 		// time used as a way of making it possible to sort

    1164. 

  1164. 

    1165. 

  1165. 		$activityCache[$type . '_' . $arr['id']][$arr['created_by']][$type][$arr['id']][time()] = $arr;

    1166. 

  1166. 		//    ^			^		^		  ^

    1167. 

  1167. 		//createdby// //type// //item_id// //order//

    1168. 

  1168. 		// set up updated cached object

    1169. 

  1169. 

    1170. 

  1170. 		$this -> cache -> file -> save($cacheID, $activityCache, 1000000);

    1171. 

  1171. 		// save the cache

    1172. 

  1172. 

    1173. 

  1173. 		return true;

    1174. 

  1174. 

    1175. 

  1175. 	}

    1176. 

  1176. 

    1177. 

  1177. 	public function updateCacheActivity($type, array $arr)

    1178. 

  1178. 	{

    1179. 

  1179. 

    1180. 

  1180. 		$cacheID = 'activity_cache';

    1181. 

  1181. 		// set the cache id

    1182. 

  1182. 

    1183. 

  1183. 		if (!$arr['id'])

    1184. 

  1184. 		{

    1185. 

  1185. 			throw new Exception('No id found in the datamapper object, there must be an ID');

    1186. 

  1186. 			// if there was no id throw an exception as, it should never passs here with out having an id

    1187. 

  1187. 		}

    1188. 

  1188. 

    1189. 

  1189. 		if (!$arr['created_by'])

    1190. 

  1190. 		{

    1191. 

  1191. 			throw new Exception('No created_by int found in the datamapper object, there must be an created by value');

    1192. 

  1192. 			// if there was no id throw an exception as, it should never passs here with out having an id

    1193. 

  1193. 		}

    1194. 

  1194. 		// check the datamapper object

    1195. 

  1195. 

    1196. 

  1196. 		$activityCache = $this -> cache -> file -> get($cacheID);

    1197. 

  1197. 		// get the activity cache

    1198. 

  1198. 

    1199. 

  1199. 		$arr['likes'] = 0;

    1200. 

  1200. 		$arr['comments'] = array();

    1201. 

  1201. 		// instead of just having a numerical index combine both type and id so it will always be unque, iner lvels keys also contain this info

    1202. 

  1202. 

    1203. 

  1203. 		// time used as a way of making it possible to sort

    1204. 

  1204. 

    1205. 

  1205. 		unset($activityCache[$type . '_' . $arr['id']][$arr['created_by']][$type][$arr['id']]);

    1206. 

  1206. 

    1207. 

  1207. 		$activityCache[$type . '_' . $arr['id']][$arr['created_by']][$type][$arr['id']][time()] = $arr;

    1208. 

  1208. 		//    ^			^		^		  ^

    1209. 

  1209. 		//createdby// //type// //item_id// //order//

    1210. 

  1210. 		// set up updated cached object

    1211. 

  1211. 

    1212. 

  1212. 		$this -> cache -> file -> save($cacheID, $activityCache, 1000000);

    1213. 

  1213. 		// save the cache

    1214. 

  1214. 

    1215. 

  1215. 		return true;

    1216. 

  1216. 	}

    1217. 

  1217. 

    1218. 

  1218. 	public function removeCacheActivity($type, $id)

    1219. 

  1219. 	{

    1220. 

  1220. 

    1221. 

  1221. 		$activityCache = $this -> cache -> file -> get($cacheID);

    1222. 

  1222. 		// get the activity cache

    1223. 

  1223. 

    1224. 

  1224. 		unset($activityCache[$type . '_' . $id]);

    1225. 

  1225. 

    1226. 

  1226. 		$this -> cache -> file -> save($cacheID, $activityCache);

    1227. 

  1227. 

    1228. 

  1228. 	}

    1229. 

  1229. 

    1230. 

  1230. 	public function createCacheActivity($type, array $arr)

    1231. 

  1231. 	{

    1232. 

  1232. 

    1233. 

  1233. 		$cacheID = 'activity_cache';

    1234. 

  1234. 		// set the cache id

    1235. 

  1235. 

    1236. 

  1236. 		if (!$arr['id'])

    1237. 

  1237. 		{

    1238. 

  1238. 			throw new Exception('No id found in the datamapper object, there must be an ID');

    1239. 

  1239. 			// if there was no id throw an exception as, it should never passs here with out having an id

    1240. 

  1240. 		}

    1241. 

  1241. 

    1242. 

  1242. 		if (!$arr['created_by'])

    1243. 

  1243. 		{

    1244. 

  1244. 			throw new Exception('No created_by int found in the datamapper object, there must be an created by value');

    1245. 

  1245. 			// if there was no id throw an exception as, it should never passs here with out having an id

    1246. 

  1246. 		}

    1247. 

  1247. 		// check the datamapper object

    1248. 

  1248. 

    1249. 

  1249. 		$activityCache = $this -> cache -> file -> get($cacheID);

    1250. 

  1250. 		// get the activity cache

    1251. 

  1251. 

    1252. 

  1252. 		$arr['likes'] = 0;

    1253. 

  1253. 		$arr['comments'] = array();

    1254. 

  1254. 		// instead of just having a numerical index combine both type and id so it will always be unque, iner lvels keys also contain this info

    1255. 

  1255. 		$activityCache[$type . '_' . $arr['id']][$arr['created_by']][$type][$arr['id']][time()] = $arr;

    1256. 

  1256. 		//    ^			^		^		  ^

    1257. 

  1257. 		//createdby// //type// //item_id// //order//

    1258. 

  1258. 		// set up updated cached object

    1259. 

  1259. 

    1260. 

  1260. 		$this -> cache -> file -> save($cacheID, $activityCache, 1000000);

    1261. 

  1261. 		// save the cache

    1262. 

  1262. 

    1263. 

  1263. 		return true;

    1264. 

  1264. 

    1265. 

  1265. 	}

    1266. 

  1266. 

    1267. 

  1267. }

    1268. 

  1268. 

    1269. 

  1269. /**

    1270. 

  1270.  * So we dont have to rename all the classes

    1271. 

  1271.  *

    1272. 

  1272.  */

    1273. 

  1273. class Base_model extends MY_Model

    1274. 

  1274. {

    1275. 

  1275. 	function __construct($id = null)

    1276. 

  1276. 	{

    1277. 

  1277. 		parent::__construct($id);

    1278. 

  1278. 	}

    1279. 

  1279. 

    1280. 

  1280. 	function __destruct()

    1281. 

  1281. 	{

    1282. 

  1282. 

    1283. 

  1283. 	}

    1284. 

  1284. 

    1285. 

  1285. }

    1286. 

  1286.