PageRenderTime 57ms CodeModel.GetById 19ms RepoModel.GetById 0ms app.codeStats 1ms

/classphp/flourish/fActiveRecord.php

https://github.com/jsuarez/Lexer
PHP | 2603 lines | 1584 code | 428 blank | 591 comment | 365 complexity | d1c640ab2b1ebdece3e32da01731f6a2 MD5 | raw file

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

    

  1. <?php

    2. 

  2. /**

    3. 

  3.  * An [http://en.wikipedia.org/wiki/Active_record_pattern active record pattern] base class

    4. 

  4.  * 

    5. 

  5.  * This class uses fORMSchema to inspect your database and provides an

    6. 

  6.  * OO interface to a single database table. The class dynamically handles

    7. 

  7.  * method calls for getting, setting and other operations on columns. It also

    8. 

  8.  * dynamically handles retrieving and storing related records.

    9. 

  9.  * 

    10. 

  10.  * @copyright  Copyright (c) 2007-2009 Will Bond, others

    11. 

  11.  * @author     Will Bond [wb] <will@flourishlib.com>

    12. 

  12.  * @author     Will Bond, iMarc LLC [wb-imarc] <will@imarc.net>

    13. 

  13.  * @license    http://flourishlib.com/license

    14. 

  14.  * 

    15. 

  15.  * @package    Flourish

    16. 

  16.  * @link       http://flourishlib.com/fActiveRecord

    17. 

  17.  * 

    18. 

  18.  * @version    1.0.0b45

    19. 

  19.  * @changes    1.0.0b45  Added support for `!~`, `&~`, `><` and OR comparisons to ::checkConditions(), made object handling in ::checkConditions() more robust [wb, 2009-09-21]

    20. 

  20.  * @changes    1.0.0b44  Updated code for new fValidationException API [wb, 2009-09-18]

    21. 

  21.  * @changes    1.0.0b43  Updated code for new fRecordSet API [wb, 2009-09-16]

    22. 

  22.  * @changes    1.0.0b42  Corrected a grammar bug in ::hash() [wb, 2009-09-09]

    23. 

  23.  * @changes    1.0.0b41  Fixed a bug in the last version that would cause issues with classes containing a custom class to table mapping [wb, 2009-09-01]

    24. 

  24.  * @changes    1.0.0b40  Added a check to the configuration part of ::__construct() to ensure modelled tables have primary keys [wb, 2009-08-26]

    25. 

  25.  * @changes    1.0.0b39  Changed `set{ColumnName}()` methods to return the record for method chaining, fixed a bug with loading by multi-column unique constraints, fixed a bug with ::load() [wb, 2009-08-26]

    26. 

  26.  * @changes    1.0.0b38  Updated ::changed() to do a strict comparison when at least one value is NULL [wb, 2009-08-17]

    27. 

  27.  * @changes    1.0.0b37  Changed ::__construct() to allow any Iterator object instead of just fResult [wb, 2009-08-12]

    28. 

  28.  * @changes    1.0.0b36  Fixed a bug with setting NULL values from v1.0.0b33 [wb, 2009-08-10]

    29. 

  29.  * @changes    1.0.0b35  Fixed a bug with unescaping data in ::loadFromResult() from v1.0.0b33 [wb, 2009-08-10]

    30. 

  30.  * @changes    1.0.0b34  Added the ability to compare fActiveRecord objects in ::checkConditions() [wb, 2009-08-07]

    31. 

  31.  * @changes    1.0.0b33  Performance enhancements to ::__call() and ::__construct() [wb, 2009-08-07] 

    32. 

  32.  * @changes    1.0.0b32  Changed ::delete() to remove auto-incrementing primary keys after the post::delete() hook [wb, 2009-07-29]

    33. 

  33.  * @changes    1.0.0b31  Fixed a bug with loading a record by a multi-column primary key, fixed one-to-one relationship API [wb, 2009-07-21]

    34. 

  34.  * @changes    1.0.0b30  Updated ::reflect() for new fORM::callReflectCallbacks() API [wb, 2009-07-13]

    35. 

  35.  * @changes    1.0.0b29  Updated to use new fORM::callInspectCallbacks() method [wb, 2009-07-13]

    36. 

  36.  * @changes    1.0.0b28  Fixed a bug where records would break the identity map at the end of ::store() [wb, 2009-07-09]

    37. 

  37.  * @changes    1.0.0b27  Changed ::hash() from a protected method to a static public/internal method that requires the class name for non-fActiveRecord values [wb, 2009-07-09]

    38. 

  38.  * @changes    1.0.0b26  Added ::checkConditions() from fRecordSet [wb, 2009-07-08]

    39. 

  39.  * @changes    1.0.0b25  Updated ::validate() to use new fORMValidation API, including new message search/replace functionality [wb, 2009-07-01]

    40. 

  40.  * @changes    1.0.0b24  Changed ::validate() to remove duplicate validation messages [wb, 2009-06-30]

    41. 

  41.  * @changes    1.0.0b23  Updated code for new fORMValidation::validateRelated() API [wb, 2009-06-26]

    42. 

  42.  * @changes    1.0.0b22  Added support for the $formatting parameter to encode methods on char, text and varchar columns [wb, 2009-06-19]

    43. 

  43.  * @changes    1.0.0b21  Performance tweaks and updates for fORM and fORMRelated API changes [wb, 2009-06-15]

    44. 

  44.  * @changes    1.0.0b20  Changed replacement values in preg_replace() calls to be properly escaped [wb, 2009-06-11]

    45. 

  45.  * @changes    1.0.0b19  Added `list{RelatedRecords}()` methods, updated code for new fORMRelated API [wb, 2009-06-02]

    46. 

  46.  * @changes    1.0.0b18  Changed ::store() to use new fORMRelated::store() method [wb, 2009-06-02]

    47. 

  47.  * @changes    1.0.0b17  Added some missing parameter information to ::reflect() [wb, 2009-06-01]

    48. 

  48.  * @changes    1.0.0b16  Fixed bugs in ::__clone() and ::replicate() related to recursive relationships [wb-imarc, 2009-05-20]

    49. 

  49.  * @changes    1.0.0b15  Fixed an incorrect variable reference in ::store() [wb, 2009-05-06]

    50. 

  50.  * @changes    1.0.0b14  ::store() no longer tries to get an auto-incrementing ID from the database if a value was set [wb, 2009-05-02]

    51. 

  51.  * @changes    1.0.0b13  ::delete(), ::load(), ::populate() and ::store() now return the record to allow for method chaining [wb, 2009-03-23]

    52. 

  52.  * @changes    1.0.0b12  ::set() now removes commas from integers and floats to prevent validation issues [wb, 2009-03-22]

    53. 

  53.  * @changes    1.0.0b11  ::encode() no longer adds commas to floats [wb, 2009-03-22]

    54. 

  54.  * @changes    1.0.0b10  ::__wakeup() no longer registers the record as the definitive copy in the identity map [wb, 2009-03-22]

    55. 

  55.  * @changes    1.0.0b9   Changed ::__construct() to populate database default values when a non-existing record is instantiated [wb, 2009-01-12]

    56. 

  56.  * @changes    1.0.0b8   Fixed ::exists() to properly detect cases when an existing record has one or more NULL values in the primary key [wb, 2009-01-11]

    57. 

  57.  * @changes    1.0.0b7   Fixed ::__construct() to not trigger the post::__construct() hook when force-configured [wb, 2008-12-30]

    58. 

  58.  * @changes    1.0.0b6   ::__construct() now accepts an associative array matching any unique key or primary key, fixed the post::__construct() hook to be called once for each record [wb, 2008-12-26]

    59. 

  59.  * @changes    1.0.0b5   Fixed ::replicate() to use plural record names for related records [wb, 2008-12-12]

    60. 

  60.  * @changes    1.0.0b4   Added ::replicate() to allow cloning along with related records [wb, 2008-12-12]

    61. 

  61.  * @changes    1.0.0b3   Changed ::__clone() to clone objects contains in the values and cache arrays [wb, 2008-12-11]

    62. 

  62.  * @changes    1.0.0b2   Added the ::__clone() method to properly duplicate a record [wb, 2008-12-04]

    63. 

  63.  * @changes    1.0.0b    The initial implementation [wb, 2007-08-04]

    64. 

  64.  */

    65. 

  65. abstract class fActiveRecord

    66. 

  66. {

    67. 

  67. 	// The following constants allow for nice looking callbacks to static methods

    68. 

  68. 	const assign          = 'fActiveRecord::assign';

    69. 

  69. 	const changed         = 'fActiveRecord::changed';

    70. 

  70. 	const checkConditions = 'fActiveRecord::checkConditions';

    71. 

  71. 	const forceConfigure  = 'fActiveRecord::forceConfigure';

    72. 

  72. 	const hasOld          = 'fActiveRecord::hasOld';

    73. 

  73. 	const reset           = 'fActiveRecord::reset';

    74. 

  74. 	const retrieveOld     = 'fActiveRecord::retrieveOld';

    75. 

  75. 	

    76. 

  76. 	

    77. 

  77. 	/**

    78. 

  78. 	 * Caches callbacks for methods

    79. 

  79. 	 * 

    80. 

  80. 	 * @var array

    81. 

  81. 	 */

    82. 

  82. 	static protected $callback_cache = array();

    83. 

  83. 	

    84. 

  84. 	/**

    85. 

  85. 	 * An array of flags indicating a class has been configured

    86. 

  86. 	 * 

    87. 

  87. 	 * @var array

    88. 

  88. 	 */

    89. 

  89. 	static protected $configured = array();

    90. 

  90. 	

    91. 

  91. 	

    92. 

  92. 	/**

    93. 

  93. 	 * Maps objects via their primary key

    94. 

  94. 	 * 

    95. 

  95. 	 * @var array

    96. 

  96. 	 */

    97. 

  97. 	static protected $identity_map = array();

    98. 

  98. 	

    99. 

  99. 	

    100. 

  100. 	/**

    101. 

  101. 	 * Caches method name parsings

    102. 

  102. 	 * 

    103. 

  103. 	 * @var array

    104. 

  104. 	 */

    105. 

  105. 	static protected $method_name_cache = array();

    106. 

  106. 	

    107. 

  107. 	

    108. 

  108. 	/**

    109. 

  109. 	 * Keeps track of the recursive call level of replication so we can clear the map

    110. 

  110. 	 * 

    111. 

  111. 	 * @var integer

    112. 

  112. 	 */

    113. 

  113. 	static protected $replicate_level = 0;

    114. 

  114. 	

    115. 

  115. 	

    116. 

  116. 	/**

    117. 

  117. 	 * Keeps a list of records that have been replicated

    118. 

  118. 	 * 

    119. 

  119. 	 * @var array

    120. 

  120. 	 */

    121. 

  121. 	static protected $replicate_map = array();

    122. 

  122. 	

    123. 

  123. 	/**

    124. 

  124. 	 * Contains a list of what columns in each class need to be unescaped and what data type they are

    125. 

  125. 	 * 

    126. 

  126. 	 * @var array

    127. 

  127. 	 */

    128. 

  128. 	static protected $unescape_map = array();

    129. 

  129. 	

    130. 

  130. 	

    131. 

  131. 	/**

    132. 

  132. 	 * Sets a value to the `$values` array, preserving the old value in `$old_values`

    133. 

  133. 	 *

    134. 

  134. 	 * @internal

    135. 

  135. 	 * 

    136. 

  136. 	 * @param  array  &$values      The current values

    137. 

  137. 	 * @param  array  &$old_values  The old values

    138. 

  138. 	 * @param  string $column       The column to set

    139. 

  139. 	 * @param  mixed  $value        The value to set

    140. 

  140. 	 * @return void

    141. 

  141. 	 */

    142. 

  142. 	static public function assign(&$values, &$old_values, $column, $value)

    143. 

  143. 	{

    144. 

  144. 		if (!isset($old_values[$column])) {

    145. 

  145. 			$old_values[$column] = array();

    146. 

  146. 		}

    147. 

  147. 		

    148. 

  148. 		$old_values[$column][] = $values[$column];

    149. 

  149. 		$values[$column]       = $value;	

    150. 

  150. 	}

    151. 

  151. 	

    152. 

  152. 	

    153. 

  153. 	/**

    154. 

  154. 	 * Checks to see if a value has changed

    155. 

  155. 	 *

    156. 

  156. 	 * @internal

    157. 

  157. 	 * 

    158. 

  158. 	 * @param  array  &$values      The current values

    159. 

  159. 	 * @param  array  &$old_values  The old values

    160. 

  160. 	 * @param  string $column       The column to check

    161. 

  161. 	 * @return boolean  If the value for the column specified has changed

    162. 

  162. 	 */

    163. 

  163. 	static public function changed(&$values, &$old_values, $column)

    164. 

  164. 	{

    165. 

  165. 		if (!isset($old_values[$column])) {

    166. 

  166. 			return FALSE;

    167. 

  167. 		}

    168. 

  168. 		

    169. 

  169. 		// We do a strict comparison when one of the values is NULL since

    170. 

  170. 		// NULL is almost always meant to be distinct from 0, FALSE, etc

    171. 

  171. 		if ($old_values[$column][0] === NULL || $values[$column] === NULL) {

    172. 

  172. 			return $old_values[$column][0] !== $values[$column];	

    173. 

  173. 		}

    174. 

  174. 		

    175. 

  175. 		return $old_values[$column][0] != $values[$column];	

    176. 

  176. 	}

    177. 

  177. 	

    178. 

  178. 	

    179. 

  179. 	/**

    180. 

  180. 	 * Checks to see if a record matches a condition

    181. 

  181. 	 * 

    182. 

  182. 	 * @internal

    183. 

  183. 	 * 

    184. 

  184. 	 * @param  string $operator  The record to check

    185. 

  185. 	 * @param  mixed  $value     The value to compare to

    186. 

  186. 	 * @param  mixed $result     The result of the method call(s)

    187. 

  187. 	 * @return boolean  If the comparison was successful

    188. 

  188. 	 */

    189. 

  189. 	static private function checkCondition($operator, $value, $result)

    190. 

  190. 	{

    191. 

  191. 		$was_array = is_array($value);

    192. 

  192. 		if (!$was_array) { $value = array($value); }

    193. 

  193. 		foreach ($value as $i => $_value) {

    194. 

  194. 			if (is_object($_value)) {

    195. 

  195. 				if ($_value instanceof fActiveRecord) {

    196. 

  196. 					continue;

    197. 

  197. 				}

    198. 

  198. 				if (method_exists($_value, '__toString')) {

    199. 

  199. 					$value[$i] = $_value->__toString();

    200. 

  200. 				}	

    201. 

  201. 			}	

    202. 

  202. 		}

    203. 

  203. 		if (!$was_array) { $value = $value[0]; }

    204. 

  204. 		

    205. 

  205. 		$was_array = is_array($result);

    206. 

  206. 		if (!$was_array) { $result = array($result); }

    207. 

  207. 		foreach ($result as $i => $_result) {

    208. 

  208. 			if (is_object($_result)) {

    209. 

  209. 				if ($_result instanceof fActiveRecord) {

    210. 

  210. 					continue;

    211. 

  211. 				}

    212. 

  212. 				if (method_exists($_result, '__toString')) {

    213. 

  213. 					$result[$i] = $_result->__toString();

    214. 

  214. 				}	

    215. 

  215. 			}	

    216. 

  216. 		}

    217. 

  217. 		if (!$was_array) { $result = $result[0]; }

    218. 

  218. 		

    219. 

  219. 		$match_all   = $operator == '&~';

    220. 

  220. 		$negate_like = $operator == '!~';

    221. 

  221. 		

    222. 

  222. 		switch ($operator) {

    223. 

  223. 			case '&~':

    224. 

  224. 			case '!~':

    225. 

  225. 			case '~':

    226. 

  226. 				if (!$match_all && !$negate_like && !is_array($value) && is_array($result)) {

    227. 

  227. 					$value = fORMDatabase::parseSearchTerms($value, TRUE);

    228. 

  228. 				}	

    229. 

  229. 					

    230. 

  230. 				settype($value, 'array');

    231. 

  231. 				settype($result, 'array');

    232. 

  232. 				

    233. 

  233. 				if (count($result) > 1) {

    234. 

  234. 					foreach ($value as $_value) {

    235. 

  235. 						$found = FALSE;

    236. 

  236. 						foreach ($result as $_result) {

    237. 

  237. 							if (fUTF8::ipos($_result, $_value) !== FALSE) {

    238. 

  238. 								$found = TRUE;

    239. 

  239. 							}

    240. 

  240. 						}

    241. 

  241. 						if (!$found) {

    242. 

  242. 							return FALSE;

    243. 

  243. 						}	

    244. 

  244. 					}

    245. 

  245. 				} else {

    246. 

  246. 					$found = FALSE;

    247. 

  247. 					foreach ($value as $_value) {

    248. 

  248. 						if (fUTF8::ipos($result[0], $_value) !== FALSE) {

    249. 

  249. 							$found = TRUE;

    250. 

  250. 						} elseif ($match_all) {

    251. 

  251. 							return FALSE;

    252. 

  252. 						}

    253. 

  253. 					}

    254. 

  254. 					if ((!$negate_like && !$found) || ($negate_like && $found)) {

    255. 

  255. 						return FALSE;

    256. 

  256. 					}

    257. 

  257. 				}    

    258. 

  258. 				break;

    259. 

  259. 			

    260. 

  260. 			case '=':

    261. 

  261. 				if ($value instanceof fActiveRecord && $result instanceof fActiveRecord) {

    262. 

  262. 					if (get_class($value) != get_class($result) || !$value->exists() || !$result->exists() || self::hash($value) != self::hash($result)) {

    263. 

  263. 						return FALSE;

    264. 

  264. 					}

    265. 

  265. 					

    266. 

  266. 				} elseif (is_array($value) && !in_array($result, $value)) {

    267. 

  267. 					return FALSE;

    268. 

  268. 						

    269. 

  269. 				} elseif (!is_array($value) && $result != $value) {

    270. 

  270. 					return FALSE;	

    271. 

  271. 				}

    272. 

  272. 				break;

    273. 

  273. 				

    274. 

  274. 			case '!':

    275. 

  275. 				if ($value instanceof fActiveRecord && $result instanceof fActiveRecord) {

    276. 

  276. 					if (get_class($value) == get_class($result) && $value->exists() && $result->exists() && self::hash($value) == self::hash($result)) {

    277. 

  277. 						return FALSE;

    278. 

  278. 					}

    279. 

  279. 					

    280. 

  280. 				} elseif (is_array($value) && in_array($result, $value)) {

    281. 

  281. 					return FALSE;	

    282. 

  282. 					

    283. 

  283. 				} elseif (!is_array($value) && $result == $value) {

    284. 

  284. 					return FALSE;	

    285. 

  285. 				}

    286. 

  286. 				break;

    287. 

  287. 			

    288. 

  288. 			case '<':

    289. 

  289. 				if ($result >= $value) {

    290. 

  290. 					return FALSE;	

    291. 

  291. 				}

    292. 

  292. 				break;

    293. 

  293. 			

    294. 

  294. 			case '<=':

    295. 

  295. 				if ($result > $value) {

    296. 

  296. 					return FALSE;	

    297. 

  297. 				}

    298. 

  298. 				break;

    299. 

  299. 			

    300. 

  300. 			case '>':

    301. 

  301. 				if ($result <= $value) {

    302. 

  302. 					return FALSE;	

    303. 

  303. 				}

    304. 

  304. 				break;

    305. 

  305. 			

    306. 

  306. 			case '>=':

    307. 

  307. 				if ($result < $value) {

    308. 

  308. 					return FALSE;	

    309. 

  309. 				}

    310. 

  310. 				break;

    311. 

  311. 		}

    312. 

  312. 		

    313. 

  313. 		return TRUE;		

    314. 

  314. 	}

    315. 

  315. 	

    316. 

  316. 	

    317. 

  317. 	/**

    318. 

  318. 	 * Checks to see if a record matches all of the conditions

    319. 

  319. 	 * 

    320. 

  320. 	 * @internal

    321. 

  321. 	 * 

    322. 

  322. 	 * @param  fActiveRecord $record      The record to check

    323. 

  323. 	 * @param  array         $conditions  The conditions to check - see fRecordSet::filter() for format details

    324. 

  324. 	 * @return boolean  If the record meets all conditions

    325. 

  325. 	 */

    326. 

  326. 	static public function checkConditions($record, $conditions)

    327. 

  327. 	{

    328. 

  328. 		foreach ($conditions as $method => $value) {

    329. 

  329. 			

    330. 

  330. 			// Split the operator off of the end of the method name

    331. 

  331. 			if (in_array(substr($method, -2), array('<=', '>=', '!=', '<>', '!~', '&~', '><'))) {

    332. 

  332. 				$operator = strtr(

    333. 

  333. 					substr($method, -2),

    334. 

  334. 					array(

    335. 

  335. 						'<>' => '!',

    336. 

  336. 						'!=' => '!'

    337. 

  337. 					)

    338. 

  338. 				);

    339. 

  339. 				$method   = substr($method, 0, -2);

    340. 

  340. 			} else {

    341. 

  341. 				$operator = substr($method, -1);

    342. 

  342. 				$method   = substr($method, 0, -1);

    343. 

  343. 			}

    344. 

  344. 			

    345. 

  345. 			if (preg_match('#(?<!\|)\|(?!\|)#', $method)) {

    346. 

  346. 				

    347. 

  347. 				$methods   = explode('|', $method);

    348. 

  348. 				$values    = $value;

    349. 

  349. 				$operators = array();

    350. 

  350. 				

    351. 

  351. 				foreach ($methods as &$_method) {

    352. 

  352. 					if (in_array(substr($_method, -2), array('<=', '>=', '!=', '<>', '!~', '&~', '><'))) {

    353. 

  353. 						$operators[] = strtr(

    354. 

  354. 							substr($_method, -2),

    355. 

  355. 							array(

    356. 

  356. 								'<>' => '!',

    357. 

  357. 								'!=' => '!'

    358. 

  358. 							)

    359. 

  359. 						);

    360. 

  360. 						$_method     = substr($_method, 0, -2);

    361. 

  361. 					} elseif (!ctype_alnum(substr($_method, -1))) {

    362. 

  362. 						$operators[] = substr($_method, -1);

    363. 

  363. 						$_method     = substr($_method, 0, -1);

    364. 

  364. 					}

    365. 

  365. 				}

    366. 

  366. 				$operators[] = $operator;

    367. 

  367. 				

    368. 

  368. 				

    369. 

  369. 				if (sizeof($operators) == 1) {

    370. 

  370. 				

    371. 

  371. 					// Handle fuzzy searches

    372. 

  372. 					if ($operator == '~') {

    373. 

  373. 					

    374. 

  374. 						$results = array();

    375. 

  375. 						foreach ($methods as $method) {

    376. 

  376. 							$results[] = $record->$method();	

    377. 

  377. 						}

    378. 

  378. 						if (!self::checkCondition($operator, $value, $results)) {

    379. 

  379. 							return FALSE;	

    380. 

  380. 						}

    381. 

  381. 					

    382. 

  382. 					// Handle intersection

    383. 

  383. 					} elseif ($operator == '><') {

    384. 

  384. 						

    385. 

  385. 						if (sizeof($methods) != 2 || sizeof($values) != 2) {

    386. 

  386. 							throw new fProgrammerException(

    387. 

  387. 								'The intersection operator, %s, requires exactly two methods and two values',

    388. 

  388. 								$operator

    389. 

  389. 							);	

    390. 

  390. 						}

    391. 

  391. 									

    392. 

  392. 						$results    = array();

    393. 

  393. 						$results[0] = $record->{$methods[0]}();

    394. 

  394. 						$results[1] = $record->{$methods[1]}();

    395. 

  395. 						

    396. 

  396. 						if ($results[1] === NULL && $values[1] === NULL) {

    397. 

  397. 							if (!self::checkCondition('=', $values[0], $results[0])) {

    398. 

  398. 								return FALSE;

    399. 

  399. 							}

    400. 

  400. 							

    401. 

  401. 							

    402. 

  402. 						} else {

    403. 

  403. 							

    404. 

  404. 							$starts_between_values = FALSE;

    405. 

  405. 							$overlaps_value_1      = FALSE;

    406. 

  406. 							

    407. 

  407. 							if ($values[1] !== NULL) {

    408. 

  408. 								$start_lt_value_1      = self::checkCondition('<', $values[0], $results[0]);

    409. 

  409. 								$start_gt_value_2      = self::checkCondition('>', $values[1], $results[0]);

    410. 

  410. 								$starts_between_values = !$start_lt_value_1 && !$start_gt_value_2;

    411. 

  411. 							}

    412. 

  412. 							if ($results[1] !== NULL) {

    413. 

  413. 								$start_gt_value_1 = self::checkCondition('>', $values[0], $results[0]);

    414. 

  414. 								$end_lt_value_1   = self::checkCondition('<', $values[0], $results[1]);

    415. 

  415. 								$overlaps_value_1 = !$start_gt_value_1 && !$end_lt_value_1;

    416. 

  416. 							}

    417. 

  417. 							

    418. 

  418. 							if (!$starts_between_values && !$overlaps_value_1) {

    419. 

  419. 								return FALSE;

    420. 

  420. 							}

    421. 

  421. 						}

    422. 

  422. 					

    423. 

  423. 					} else {

    424. 

  424. 						throw new fProgrammerException(

    425. 

  425. 							'An invalid comparison operator, %s, was specified for multiple columns',

    426. 

  426. 							$operator

    427. 

  427. 						);

    428. 

  428. 					}

    429. 

  429. 					

    430. 

  430. 				// Handle OR conditions

    431. 

  431. 				} else {

    432. 

  432. 					

    433. 

  433. 					if (sizeof($methods) != sizeof($values)) {

    434. 

  434. 						throw new fProgrammerException(

    435. 

  435. 							'When performing an %1$s comparison there must be an equal number of methods and values, however there are not',

    436. 

  436. 							'OR',

    437. 

  437. 							sizeof($methods),

    438. 

  438. 							sizeof($values)

    439. 

  439. 						);

    440. 

  440. 					}

    441. 

  441. 					

    442. 

  442. 					if (sizeof($methods) != sizeof($operators)) {

    443. 

  443. 						throw new fProgrammerException(

    444. 

  444. 							'When performing an %s comparison there must be a comparison operator for each column, however one or more is missing',

    445. 

  445. 							'OR'

    446. 

  446. 						);

    447. 

  447. 					}

    448. 

  448. 					

    449. 

  449. 					$results    = array();

    450. 

  450. 					$iterations = sizeof($methods);

    451. 

  451. 					for ($i=0; $i<$iterations; $i++) {

    452. 

  452. 						$results[] = self::checkCondition($operators[$i], $values[$i], $record->{$methods[$i]}());

    453. 

  453. 					}

    454. 

  454. 					

    455. 

  455. 					if (!array_filter($results)) {

    456. 

  456. 						return FALSE;	

    457. 

  457. 					}

    458. 

  458. 					

    459. 

  459. 				}

    460. 

  460. 				

    461. 

  461. 			// Single method comparisons	

    462. 

  462. 			} else {

    463. 

  463. 				$result = $record->$method();

    464. 

  464. 				if (!self::checkCondition($operator, $value, $result)) {

    465. 

  465. 					return FALSE;	

    466. 

  466. 				}

    467. 

  467. 			}	

    468. 

  468. 		}

    469. 

  469. 		

    470. 

  470. 		return TRUE;

    471. 

  471. 	}

    472. 

  472. 	

    473. 

  473. 	

    474. 

  474. 	/**

    475. 

  475. 	 * Composes text using fText if loaded

    476. 

  476. 	 * 

    477. 

  477. 	 * @param  string  $message    The message to compose

    478. 

  478. 	 * @param  mixed   $component  A string or number to insert into the message

    479. 

  479. 	 * @param  mixed   ...

    480. 

  480. 	 * @return string  The composed and possible translated message

    481. 

  481. 	 */

    482. 

  482. 	static protected function compose($message)

    483. 

  483. 	{

    484. 

  484. 		$args = array_slice(func_get_args(), 1);

    485. 

  485. 		

    486. 

  486. 		if (class_exists('fText', FALSE)) {

    487. 

  487. 			return call_user_func_array(

    488. 

  488. 				array('fText', 'compose'),

    489. 

  489. 				array($message, $args)

    490. 

  490. 			);

    491. 

  491. 		} else {

    492. 

  492. 			return vsprintf($message, $args);

    493. 

  493. 		}

    494. 

  494. 	}

    495. 

  495. 	

    496. 

  496. 	

    497. 

  497. 	/**

    498. 

  498. 	 * Ensures that ::configure() has been called for the class

    499. 

  499. 	 *

    500. 

  500. 	 * @internal

    501. 

  501. 	 * 

    502. 

  502. 	 * @param  string $class  The class to configure

    503. 

  503. 	 * @return void

    504. 

  504. 	 */

    505. 

  505. 	static public function forceConfigure($class)

    506. 

  506. 	{

    507. 

  507. 		if (isset(self::$configured[$class])) {

    508. 

  508. 			return;	

    509. 

  509. 		}

    510. 

  510. 		new $class();

    511. 

  511. 	}

    512. 

  512. 	

    513. 

  513. 	

    514. 

  514. 	/**

    515. 

  515. 	 * Takes a row of data or a primary key and makes a hash from the primary key

    516. 

  516. 	 * 

    517. 

  517. 	 * @internal

    518. 

  518. 	 * 

    519. 

  519. 	 * @param  fActiveRecord|array|string|int $record   An fActiveRecord object, an array of the records data, an array of primary key data or a scalar primary key value

    520. 

  520. 	 * @param  string                         $class    The class name, if $record isn't an fActiveRecord

    521. 

  521. 	 * @return string|NULL  A hash of the record's primary key value or NULL if the record doesn't exist yet

    522. 

  522. 	 */

    523. 

  523. 	static public function hash($record, $class=NULL)

    524. 

  524. 	{

    525. 

  525. 		if ($record instanceof fActiveRecord && !$record->exists()) {

    526. 

  526. 			return NULL;	

    527. 

  527. 		}

    528. 

  528. 		

    529. 

  529. 		if ($class === NULL) {

    530. 

  530. 			if (!$record instanceof fActiveRecord) {

    531. 

  531. 				throw new fProgrammerException(

    532. 

  532. 					'The class of the record must be provided if the record specified is not an instance of fActiveRecord'

    533. 

  533. 				);

    534. 

  534. 			}

    535. 

  535. 			$class = get_class($record);	

    536. 

  536. 		}

    537. 

  537. 		

    538. 

  538. 		$pk_columns = fORMSchema::retrieve()->getKeys(fORM::tablize($class), 'primary');

    539. 

  539. 		

    540. 

  540. 		// Build an array of just the primary key data

    541. 

  541. 		$pk_data = array();

    542. 

  542. 		foreach ($pk_columns as $pk_column) {

    543. 

  543. 			if ($record instanceof fActiveRecord) {

    544. 

  544. 				$value = (self::hasOld($record->old_values, $pk_column)) ? self::retrieveOld($record->old_values, $pk_column) : $record->values[$pk_column];

    545. 

  545. 			

    546. 

  546. 			} elseif (is_array($record)) {

    547. 

  547. 				$value = $record[$pk_column];

    548. 

  548. 			

    549. 

  549. 			} else {

    550. 

  550. 				$value = $record;	

    551. 

  551. 			}

    552. 

  552. 			

    553. 

  553. 			$pk_data[$pk_column] = fORM::scalarize(

    554. 

  554. 				$class,

    555. 

  555. 				$pk_column,

    556. 

  556. 				$value

    557. 

  557. 			);

    558. 

  558. 			

    559. 

  559. 			if (is_numeric($pk_data[$pk_column]) || is_object($pk_data[$pk_column])) {

    560. 

  560. 				$pk_data[$pk_column] = (string) $pk_data[$pk_column];	

    561. 

  561. 			}

    562. 

  562. 		}

    563. 

  563. 		

    564. 

  564. 		return md5(serialize($pk_data));

    565. 

  565. 	}

    566. 

  566. 	

    567. 

  567. 	

    568. 

  568. 	/**

    569. 

  569. 	 * Checks to see if an old value exists for a column 

    570. 

  570. 	 *

    571. 

  571. 	 * @internal

    572. 

  572. 	 * 

    573. 

  573. 	 * @param  array  &$old_values  The old values

    574. 

  574. 	 * @param  string $column       The column to set

    575. 

  575. 	 * @return boolean  If an old value for that column exists

    576. 

  576. 	 */

    577. 

  577. 	static public function hasOld(&$old_values, $column)

    578. 

  578. 	{

    579. 

  579. 		return array_key_exists($column, $old_values);

    580. 

  580. 	}

    581. 

  581. 	

    582. 

  582. 	

    583. 

  583. 	/**

    584. 

  584. 	 * Resets the configuration of the class

    585. 

  585. 	 * 

    586. 

  586. 	 * @internal

    587. 

  587. 	 * 

    588. 

  588. 	 * @return void

    589. 

  589. 	 */

    590. 

  590. 	static public function reset()

    591. 

  591. 	{

    592. 

  592. 		self::$callback_cache    = array();

    593. 

  593. 		self::$configured        = array();

    594. 

  594. 		self::$identity_map      = array();

    595. 

  595. 		self::$method_name_cache = array();

    596. 

  596. 		self::$unescape_map      = array();

    597. 

  597. 	}

    598. 

  598. 	

    599. 

  599. 	

    600. 

  600. 	/**

    601. 

  601. 	 * Retrieves the oldest value for a column or all old values

    602. 

  602. 	 *

    603. 

  603. 	 * @internal

    604. 

  604. 	 * 

    605. 

  605. 	 * @param  array   &$old_values  The old values

    606. 

  606. 	 * @param  string  $column       The column to get

    607. 

  607. 	 * @param  mixed   $default      The default value to return if no value exists

    608. 

  608. 	 * @param  boolean $return_all   Return the array of all old values for this column instead of just the oldest

    609. 

  609. 	 * @return mixed  The old value for the column

    610. 

  610. 	 */

    611. 

  611. 	static public function retrieveOld(&$old_values, $column, $default=NULL, $return_all=FALSE)

    612. 

  612. 	{

    613. 

  613. 		if (!isset($old_values[$column])) {

    614. 

  614. 			return $default;	

    615. 

  615. 		}

    616. 

  616. 		

    617. 

  617. 		if ($return_all === TRUE) {

    618. 

  618. 			return $old_values[$column];	

    619. 

  619. 		}

    620. 

  620. 		

    621. 

  621. 		return $old_values[$column][0];

    622. 

  622. 	}

    623. 

  623. 	

    624. 

  624. 	

    625. 

  625. 	/**

    626. 

  626. 	 * A data store for caching data related to a record, the structure of this is completely up to the developer using it

    627. 

  627. 	 * 

    628. 

  628. 	 * @var array

    629. 

  629. 	 */

    630. 

  630. 	protected $cache = array();

    631. 

  631. 	

    632. 

  632. 	/**

    633. 

  633. 	 * The old values for this record

    634. 

  634. 	 * 

    635. 

  635. 	 * Column names are the keys, but a column key will only be present if a

    636. 

  636. 	 * value has changed. The value associated with each key is an array of

    637. 

  637. 	 * old values with the first entry being the oldest value. The static 

    638. 

  638. 	 * methods ::assign(), ::changed(), ::hasOld() and ::retrieveOld() are the

    639. 

  639. 	 * best way to interact with this array.

    640. 

  640. 	 * 

    641. 

  641. 	 * @var array

    642. 

  642. 	 */

    643. 

  643. 	protected $old_values = array();

    644. 

  644. 	

    645. 

  645. 	/**

    646. 

  646. 	 * Records that are related to the current record via some relationship

    647. 

  647. 	 * 

    648. 

  648. 	 * This array is used to cache related records so that a database query

    649. 

  649. 	 * is not required each time related records are accessed. The fORMRelated

    650. 

  650. 	 * class handles most of the interaction with this array.

    651. 

  651. 	 * 

    652. 

  652. 	 * @var array

    653. 

  653. 	 */

    654. 

  654. 	protected $related_records = array();

    655. 

  655. 	

    656. 

  656. 	/**

    657. 

  657. 	 * The values for this record

    658. 

  658. 	 * 

    659. 

  659. 	 * This array always contains every column in the database table as a key

    660. 

  660. 	 * with the value being the current value. 

    661. 

  661. 	 * 

    662. 

  662. 	 * @var array

    663. 

  663. 	 */

    664. 

  664. 	protected $values = array();

    665. 

  665. 	

    666. 

  666. 	

    667. 

  667. 	/**

    668. 

  668. 	 * Handles all method calls for columns, related records and hook callbacks

    669. 

  669. 	 * 

    670. 

  670. 	 * Dynamically handles `get`, `set`, `prepare`, `encode` and `inspect`

    671. 

  671. 	 * methods for each column in this record. Method names are in the form

    672. 

  672. 	 * `verbColumName()`.

    673. 

  673. 	 * 

    674. 

  674. 	 * This method also handles `associate`, `build`, `count` and `link` verbs

    675. 

  675. 	 * for records in many-to-many relationships; `build`, `count` and

    676. 

  676. 	 * `populate` verbs for all related records in one-to-many relationships

    677. 

  677. 	 * and the `create` verb for all related records in *-to-one relationships.

    678. 

  678. 	 * 

    679. 

  679. 	 * Method callbacks registered through fORM::registerActiveRecordMethod()

    680. 

  680. 	 * will be delegated via this method.

    681. 

  681. 	 * 

    682. 

  682. 	 * @param  string $method_name  The name of the method called

    683. 

  683. 	 * @param  array  $parameters   The parameters passed

    684. 

  684. 	 * @return mixed  The value returned by the method called

    685. 

  685. 	 */

    686. 

  686. 	public function __call($method_name, $parameters)

    687. 

  687. 	{

    688. 

  688. 		$class = get_class($this);

    689. 

  689. 		

    690. 

  690. 		if (!isset(self::$callback_cache[$class][$method_name])) {

    691. 

  691. 			if (!isset(self::$callback_cache[$class])) {

    692. 

  692. 				self::$callback_cache[$class] = array();

    693. 

  693. 			}	

    694. 

  694. 			$callback = fORM::getActiveRecordMethod($class, $method_name);

    695. 

  695. 			self::$callback_cache[$class][$method_name] = $callback ? $callback : FALSE;

    696. 

  696. 		}

    697. 

  697. 		

    698. 

  698. 		if ($callback = self::$callback_cache[$class][$method_name]) {

    699. 

  699. 			return call_user_func_array(

    700. 

  700. 				$callback,

    701. 

  701. 				array(

    702. 

  702. 					$this,

    703. 

  703. 					&$this->values,

    704. 

  704. 					&$this->old_values,

    705. 

  705. 					&$this->related_records,

    706. 

  706. 					&$this->cache,

    707. 

  707. 					$method_name,

    708. 

  708. 					$parameters

    709. 

  709. 				)

    710. 

  710. 			);

    711. 

  711. 		}

    712. 

  712. 		

    713. 

  713. 		if (!isset(self::$method_name_cache[$method_name])) {

    714. 

  714. 			list ($action, $subject) = fORM::parseMethod($method_name);

    715. 

  715. 			self::$method_name_cache[$method_name] = array(

    716. 

  716. 				'action'  => $action,

    717. 

  717. 				'subject' => $subject

    718. 

  718. 			);	

    719. 

  719. 		} else {

    720. 

  720. 			$action  = self::$method_name_cache[$method_name]['action'];

    721. 

  721. 			$subject = self::$method_name_cache[$method_name]['subject'];	

    722. 

  722. 		}

    723. 

  723. 		

    724. 

  724. 		switch ($action) {

    725. 

  725. 			

    726. 

  726. 			// Value methods

    727. 

  727. 			case 'get':

    728. 

  728. 				return $this->get($subject);

    729. 

  729. 				

    730. 

  730. 			case 'encode':

    731. 

  731. 				if (isset($parameters[0])) {

    732. 

  732. 					return $this->encode($subject, $parameters[0]);

    733. 

  733. 				}

    734. 

  734. 				return $this->encode($subject);

    735. 

  735. 			

    736. 

  736. 			case 'prepare':

    737. 

  737. 				if (isset($parameters[0])) {

    738. 

  738. 					return $this->prepare($subject, $parameters[0]);

    739. 

  739. 				}

    740. 

  740. 				return $this->prepare($subject);

    741. 

  741. 			

    742. 

  742. 			case 'inspect':

    743. 

  743. 				if (isset($parameters[0])) {

    744. 

  744. 					return $this->inspect($subject, $parameters[0]);

    745. 

  745. 				}

    746. 

  746. 				return $this->inspect($subject);

    747. 

  747. 			

    748. 

  748. 			case 'set':

    749. 

  749. 				if (sizeof($parameters) < 1) {

    750. 

  750. 					throw new fProgrammerException(

    751. 

  751. 						'The method, %s(), requires at least one parameter',

    752. 

  752. 						$method_name

    753. 

  753. 					);

    754. 

  754. 				}

    755. 

  755. 				return $this->set($subject, $parameters[0]);

    756. 

  756. 			

    757. 

  757. 			// Related data methods

    758. 

  758. 			case 'associate':

    759. 

  759. 				if (sizeof($parameters) < 1) {

    760. 

  760. 					throw new fProgrammerException(

    761. 

  761. 						'The method, %s(), requires at least one parameter',

    762. 

  762. 						$method_name

    763. 

  763. 					);

    764. 

  764. 				}

    765. 

  765. 				

    766. 

  766. 				$table   = fORM::tablize($class);

    767. 

  767. 				$records = $parameters[0];

    768. 

  768. 				$route   = isset($parameters[1]) ? $parameters[1] : NULL;

    769. 

  769. 				$plural  = FALSE;

    770. 

  770. 				

    771. 

  771. 				// one-to-many relationships need to use plural forms

    772. 

  772. 				if (in_array($subject, fORMSchema::retrieve()->getTables())) {

    773. 

  773. 					if (fORMSchema::isOneToOne($table, $subject, $route)) {

    774. 

  774. 						throw new fProgrammerException(

    775. 

  775. 							'The table %1$s is not in a %2$srelationship with the table %3$s',

    776. 

  776. 							$table,

    777. 

  777. 							'*-to-many ',

    778. 

  778. 							$subject

    779. 

  779. 						); 		

    780. 

  780. 					}

    781. 

  781. 					$subject = fGrammar::singularize($subject);

    782. 

  782. 					$plural  = TRUE;

    783. 

  783. 				}

    784. 

  784. 				$subject = fGrammar::camelize($subject, TRUE);

    785. 

  785. 				

    786. 

  786. 				// This handles one-to-many and many-to-many relationships

    787. 

  787. 				if ($plural) {

    788. 

  788. 					return fORMRelated::associateRecords($class, $this->related_records, $subject, $records, $route);

    789. 

  789. 				}

    790. 

  790. 				

    791. 

  791. 				// This handles one-to-one relationships

    792. 

  792. 				return fORMRelated::associateRecord($class, $this->related_records, $subject, $records, $route);

    793. 

  793. 			

    794. 

  794. 			case 'build':

    795. 

  795. 				$subject = fGrammar::singularize($subject);

    796. 

  796. 				$subject = fGrammar::camelize($subject, TRUE);

    797. 

  797. 				

    798. 

  798. 				if (isset($parameters[0])) {

    799. 

  799. 					return fORMRelated::buildRecords($class, $this->values, $this->related_records, $subject, $parameters[0]);

    800. 

  800. 				}

    801. 

  801. 				return fORMRelated::buildRecords($class, $this->values, $this->related_records, $subject);

    802. 

  802. 			

    803. 

  803. 			case 'count':

    804. 

  804. 				$subject = fGrammar::singularize($subject);

    805. 

  805. 				$subject = fGrammar::camelize($subject, TRUE);

    806. 

  806. 				

    807. 

  807. 				if (isset($parameters[0])) {

    808. 

  808. 					return fORMRelated::countRecords($class, $this->values, $this->related_records, $subject, $parameters[0]);

    809. 

  809. 				}

    810. 

  810. 				return fORMRelated::countRecords($class, $this->values, $this->related_records, $subject);

    811. 

  811. 			

    812. 

  812. 			case 'create':

    813. 

  813. 				$subject = fGrammar::camelize($subject, TRUE);

    814. 

  814. 				

    815. 

  815. 				if (isset($parameters[0])) {

    816. 

  816. 					return fORMRelated::createRecord($class, $this->values, $this->related_records, $subject, $parameters[0]);

    817. 

  817. 				}

    818. 

  818. 				return fORMRelated::createRecord($class, $this->values, $this->related_records, $subject);

    819. 

  819. 			 

    820. 

  820. 			case 'inject':

    821. 

  821. 				if (sizeof($parameters) < 1) {

    822. 

  822. 					throw new fProgrammerException(

    823. 

  823. 						'The method, %s(), requires at least one parameter',

    824. 

  824. 						$method_name

    825. 

  825. 					);

    826. 

  826. 				}

    827. 

  827. 				

    828. 

  828. 				$subject = fGrammar::singularize($subject);

    829. 

  829. 				$subject = fGrammar::camelize($subject, TRUE);

    830. 

  830. 				 

    831. 

  831. 				if (isset($parameters[1])) {

    832. 

  832. 					return fORMRelated::setRecordSet($class, $this->related_records, $subject, $parameters[0], $parameters[1]);

    833. 

  833. 				}

    834. 

  834. 				return fORMRelated::setRecordSet($class, $this->related_records, $subject, $parameters[0]);

    835. 

  835. 

    836. 

  836. 			case 'link':

    837. 

  837. 				$subject = fGrammar::singularize($subject);

    838. 

  838. 				$subject = fGrammar::camelize($subject, TRUE);

    839. 

  839. 				

    840. 

  840. 				if (isset($parameters[0])) {

    841. 

  841. 					return fORMRelated::linkRecords($class, $this->related_records, $subject, $parameters[0]);

    842. 

  842. 				}

    843. 

  843. 				return fORMRelated::linkRecords($class, $this->related_records, $subject);

    844. 

  844. 			

    845. 

  845. 			case 'list':

    846. 

  846. 				$subject = fGrammar::singularize($subject);

    847. 

  847. 				$subject = fGrammar::camelize($subject, TRUE);

    848. 

  848. 				

    849. 

  849. 				if (isset($parameters[0])) {

    850. 

  850. 					return fORMRelated::getPrimaryKeys($class, $this->values, $this->related_records, $subject, $parameters[0]);

    851. 

  851. 				}

    852. 

  852. 				return fORMRelated::getPrimaryKeys($class, $this->values, $this->related_records, $subject);

    853. 

  853. 			

    854. 

  854. 			case 'populate':

    855. 

  855. 				$table = fORM::tablize($class);

    856. 

  856. 				$route = isset($parameters[0]) ? $parameters[0] : NULL;

    857. 

  857. 				

    858. 

  858. 				// one-to-many relationships need to use plural forms

    859. 

  859. 				if (in_array($subject, fORMSchema::retrieve()->getTables())) {

    860. 

  860. 					if (fORMSchema::isOneToOne($table, $subject, $route)) {

    861. 

  861. 						throw new fProgrammerException(

    862. 

  862. 							'The table %1$s is not in a%2$srelationship with the table %3$s',

    863. 

  863. 							$table,

    864. 

  864. 							' one-to-many ',

    865. 

  865. 							$subject

    866. 

  866. 						); 		

    867. 

  867. 					}

    868. 

  868. 					$subject = fGrammar::singularize($subject);

    869. 

  869. 				}

    870. 

  870. 				

    871. 

  871. 				$subject = fGrammar::camelize($subject, TRUE);

    872. 

  872. 				

    873. 

  873. 				return fORMRelated::populateRecords($class, $this->related_records, $subject, $route);

    874. 

  874. 			

    875. 

  875. 			case 'tally':

    876. 

  876. 				if (sizeof($parameters) < 1) {

    877. 

  877. 					throw new fProgrammerException(

    878. 

  878. 						'The method, %s(), requires at least one parameter',

    879. 

  879. 						$method_name

    880. 

  880. 					);

    881. 

  881. 				}

    882. 

  882. 				

    883. 

  883. 				$subject = fGrammar::singularize($subject);

    884. 

  884. 				$subject = fGrammar::camelize($subject, TRUE);

    885. 

  885. 				

    886. 

  886. 				if (isset($parameters[1])) {

    887. 

  887. 					return fORMRelated::setCount($class, $this->related_records, $subject, $parameters[0], $parameters[1]);

    888. 

  888. 				}

    889. 

  889. 				return fORMRelated::setCount($class, $this->related_records, $subject, $parameters[0]);

    890. 

  890. 			

    891. 

  891. 			// Error handler

    892. 

  892. 			default:

    893. 

  893. 				throw new fProgrammerException(

    894. 

  894. 					'Unknown method, %s(), called',

    895. 

  895. 					$method_name

    896. 

  896. 				);

    897. 

  897. 		}

    898. 

  898. 	}

    899. 

  899. 	

    900. 

  900. 	

    901. 

  901. 	/**

    902. 

  902. 	 * Creates a clone of a record

    903. 

  903. 	 * 

    904. 

  904. 	 * If the record has an auto incrementing primary key, the primary key will

    905. 

  905. 	 * be erased in the clone. If the primary key is not auto incrementing,

    906. 

  906. 	 * the primary key will be left as-is in the clone. In either situation the

    907. 

  907. 	 * clone will return `FALSE` from the ::exists() method until ::store() is

    908. 

  908. 	 * called.

    909. 

  909. 	 * 

    910. 

  910. 	 * @internal

    911. 

  911. 	 * 

    912. 

  912. 	 * @return fActiveRecord

    913. 

  913. 	 */

    914. 

  914. 	public function __clone()

    915. 

  915. 	{

    916. 

  916. 		$class = get_class($this);

    917. 

  917. 		

    918. 

  918. 		// Copy values and cache, making sure objects are cloned to prevent reference issues

    919. 

  919. 		$temp_values  = $this->values;

    920. 

  920. 		$new_values   = array();

    921. 

  921. 		$this->values =& $new_values;

    922. 

  922. 		foreach ($temp_values as $column => $value) {

    923. 

  923. 			$this->values[$column] = fORM::replicate($class, $column, $value);

    924. 

  924. 		}

    925. 

  925. 		

    926. 

  926. 		$temp_cache  = $this->cache;

    927. 

  927. 		$new_cache   = array();

    928. 

  928. 		$this->cache =& $new_cache;

    929. 

  929. 		foreach ($temp_cache as $key => $value) {

    930. 

  930. 			if (is_object($value)) {

    931. 

  931. 				$this->cache[$key] = clone $value;

    932. 

  932. 			} else {

    933. 

  933. 				$this->cache[$key] = $value;

    934. 

  934. 			}		

    935. 

  935. 		}

    936. 

  936. 		

    937. 

  937. 		// Related records are purged

    938. 

  938. 		$new_related_records   = array();

    939. 

  939. 		$this->related_records =& $new_related_records;

    940. 

  940. 		

    941. 

  941. 		// Old values are changed to look like the record is non-existant

    942. 

  942. 		$new_old_values   = array();

    943. 

  943. 		$this->old_values =& $new_old_values;

    944. 

  944. 		

    945. 

  945. 		foreach (array_keys($this->values) as $key) {

    946. 

  946. 			$this->old_values[$key] = array(NULL);

    947. 

  947. 		}

    948. 

  948. 		

    949. 

  949. 		// If we have a single auto incrementing primary key, remove the value

    950. 

  950. 		$table      = fORM::tablize($class);

    951. 

  951. 		$pk_columns = fORMSchema::retrieve()->getKeys($table, 'primary');

    952. 

  952. 		

    953. 

  953. 		if (sizeof($pk_columns) == 1 && fORMSchema::retrieve()->getColumnInfo($table, $pk_columns[0], 'auto_increment')) {

    954. 

  954. 			$this->values[$pk_columns[0]] = NULL;

    955. 

  955. 			unset($this->old_values[$pk_columns[0]]);

    956. 

  956. 		}		

    957. 

  957. 	}

    958. 

  958. 	

    959. 

  959. 	

    960. 

  960. 	/**

    961. 

  961. 	 * Creates a new record or loads one from the database - if a primary key or unique key is provided the record will be loaded

    962. 

  962. 	 * 

    963. 

  963. 	 * @throws fNotFoundException  When the record specified by `$key` can not be found in the database

    964. 

  964. 	 * 

    965. 

  965. 	 * @param  mixed $key  The primary key or unique key value(s) - single column primary keys will accept a scalar value, all others must be an associative array of `(string) {column} => (mixed) {value}`

    966. 

  966. 	 * @return fActiveRecord

    967. 

  967. 	 */

    968. 

  968. 	public function __construct($key=NULL)

    969. 

  969. 	{

    970. 

  970. 		$class = get_class($this);

    971. 

  971. 		

    972. 

  972. 		// If the features of this class haven't been set yet, do it

    973. 

  973. 		if (!isset(self::$configured[$class])) {

    974. 

  974. 			$this->configure();

    975. 

  975. 			self::$configured[$class] = TRUE;

    976. 

  976. 			

    977. 

  977. 			$table = fORM::tablize($class);

    978. 

  978. 			if (!fORMSchema::retrieve()->getKeys($table, 'primary')) {

    979. 

  979. 				throw new fProgrammerException(

    980. 

  980. 					'The database table %1$s (being modelled by the class %2$s) does not appear to have a primary key defined. %3$s and %4$s will not work properly without a primary key.',

    981. 

  981. 					$table,

    982. 

  982. 					$class,

    983. 

  983. 					'fActiveRecord',

    984. 

  984. 					'fRecordSet'

    985. 

  985. 				);	

    986. 

  986. 			}

    987. 

  987. 			

    988. 

  988. 			// If the configuration was forced, prevent the post::__construct() hook from

    989. 

  989. 			// being triggered since it is not really a real record instantiation

    990. 

  990. 			$trace = array_slice(debug_backtrace(), 0, 2);

    991. 

  991. 			

    992. 

  992. 			$is_forced = sizeof($trace) == 2;

    993. 

  993. 			$is_forced = $is_forced && $trace[1]['function'] == 'forceConfigure';

    994. 

  994. 			$is_forced = $is_forced && isset($trace[1]['class']);

    995. 

  995. 			$is_forced = $is_forced && $trace[1]['type'] == '::';

    996. 

  996. 			$is_forced = $is_forced && in_array($trace[1]['class'], array('fActiveRecord', $class));

    997. 

  997. 			

    998. 

  998. 			if ($is_forced) {

    999. 

  999. 				return;	

    1000. 

  1000. 			}

    1001. 

  1001. 		}

    1002. 

  1002. 		

    1003. 

  1003. 		if (!isset(self::$callback_cache[$class]['__construct'])) {

    1004. 

  1004. 			if (!isset(self::$callback_cache[$class])) {

    1005. 

  1005. 				self::$callback_cache[$class] = array();

    1006. 

  1006. 			}

    1007. 

  1007. 			$callback = fORM::getActiveRecordMethod($class, '__construct');

    1008. 

  1008. 			self::$callback_cache[$class]['__construct'] = $callback ? $callback : FALSE;	

    1009. 

  1009. 		}

    1010. 

  1010. 		if ($callback = self::$callback_cache[$class]['__construct']) {

    1011. 

  1011. 			return $this->__call($callback);

    1012. 

  1012. 		}

    1013. 

  1013. 		

    1014. 

  1014. 		// Handle loading by a result object passed via the fRecordSet class

    1015. 

  1015. 		if ($key instanceof Iterator) {

    1016. 

  1016. 			

    1017. 

  1017. 			if ($this->loadFromResult($key)) {

    1018. 

  1018. 				return;

    1019. 

  1019. 			}

    1020. 

  1020. 		

    1021. 

  1021. 		// Handle loading an object from the database

    1022. 

  1022. 		} elseif ($key !== NULL) {

    1023. 

  1023. 			

    1024. 

  1024. 			$table      = fORM::tablize($class);

    1025. 

  1025. 			$pk_columns = fORMSchema::retrieve()->getKeys($table, 'primary');

    1026. 

  1026. 			

    1027. 

  1027. 			// If the primary key does not look properly formatted, check to see if it is a UNIQUE key

    1028. 

  1028. 			$is_unique_key = FALSE;

    1029. 

  1029. 			if (is_array($key) && (sizeof($pk_columns) == 1 || array_diff(array_keys($key), $pk_columns))) {

    1030. 

  1030. 				$unique_keys = fORMSchema::retrieve()->getKeys($table, 'unique');

    1031. 

  1031. 				$key_keys    = array_keys($key);

    1032. 

  1032. 				foreach ($unique_keys as $unique_key) {

    1033. 

  1033. 					if (!array_diff($key_keys, $unique_key)) {

    1034. 

  1034. 						$is_unique_key = TRUE;

    1035. 

  1035. 					}

    1036. 

  1036. 				}	

    1037. 

  1037. 			}

    1038. 

  1038. 			

    1039. 

  1039. 			$wrong_keys = is_array($key) && array_diff(array_keys($key), $pk_columns);

    1040. 

  1040. 			$wrong_type = !is_array($key) && (sizeof($pk_columns) != 1 || !is_scalar($key));

    1041. 

  1041. 			

    1042. 

  1042. 			// If we didn't find a UNIQUE key and primary key doesn't look right we fail

    1043. 

  1043. 			if (!$is_unique_key && ($wrong_keys || $wrong_type)) {

    1044. 

  1044. 				throw new fProgrammerException(

    1045. 

  1045. 					'An invalidly formatted primary or unique key was passed to this %s object',

    1046. 

  1046. 					fORM::getRecordName($class)

    1047. 

  1047. 				);

    1048. 

  1048. 			}

    1049. 

  1049. 			

    1050. 

  1050. 			if ($is_unique_key) {

    1051. 

  1051. 				

    1052. 

  1052. 				$result = $this->fetchResultFromUniqueKey($key);

    1053. 

  1053. 				if ($this->loadFromResult($result)) {

    1054. 

  1054. 					return;	

    1055. 

  1055. 				}

    1056. 

  1056. 				

    1057. 

  1057. 			} else {

    1058. 

  1058. 				

    1059. 

  1059. 				$hash = self::hash($key, $class);

    1060. 

  1060. 				if ($this->loadFromIdentityMap($key, $hash)) {

    1061. 

  1061. 					return;

    1062. 

  1062. 				}

    1063. 

  1063. 				

    1064. 

  1064. 				// Assign the primary key values for loading

    1065. 

  1065. 				if (is_array($key)) {

    1066. 

  1066. 					foreach ($pk_columns as $pk_column) {

    1067. 

  1067. 						$this->values[$pk_column] = $key[$pk_column];

    1068. 

  1068. 					}

    1069. 

  1069. 				} else {

    1070. 

  1070. 					$this->values[$pk_columns[0]] = $key;

    1071. 

  1071. 				}

    1072. 

  1072. 				

    1073. 

  1073. 				$this->load();

    1074. 

  1074. 			}

    1075. 

  1075. 			

    1076. 

  1076. 		// Create an empty array for new objects

    1077. 

  1077. 		} else {

    1078. 

  1078. 			$column_info = fORMSchema::retrieve()->getColumnInfo(fORM::tablize($class));

    1079. 

  1079. 			foreach ($column_info as $column => $info) {

    1080. 

  1080. 				$this->values[$column] = NULL;

    1081. 

  1081. 				if ($info['default'] !== NULL) {

    1082. 

  1082. 					self::assign(

    1083. 

  1083. 						$this->values,

    1084. 

  1084. 						$this->old_values,

    1085. 

  1085. 						$column,

    1086. 

  1086. 						fORM::objectify($class, $column, $info['default'])

    1087. 

  1087. 					);	

    1088. 

  1088. 				}

    1089. 

  1089. 			}

    1090. 

  1090. 		}

    1091. 

  1091. 		

    1092. 

  1092. 		fORM::callHookCallbacks(

    1093. 

  1093. 			$this,

    1094. 

  1094. 			'post::__construct()',

    1095. 

  1095. 			$this->values,

    1096. 

  1096. 			$this->old_values,

    1097. 

  1097. 			$this->related_records,

    1098. 

  1098. 			$this->cache

    1099. 

  1099. 		);

    1100. 

  1100. 	}

    1101. 

  1101. 	

    1102. 

  1102. 	

    1103. 

  1103. 	/**

    1104. 

  1104. 	 * All requests that hit this method should be requests for callbacks

    1105. 

  1105. 	 * 

    1106. 

  1106. 	 * @internal

    1107. 

  1107. 	 * 

    1108. 

  1108. 	 * @param  string $method  The method to create a callback for

    1109. 

  1109. 	 * @return callback  The callback for the method requested

    1110. 

  1110. 	 */

    1111. 

  1111. 	public function __get($method)

    1112. 

  1112. 	{

    1113. 

  1113. 		return array($this, $method);		

    1114. 

  1114. 	}

    1115. 

  1115. 	

    1116. 

  1116. 	

    1117. 

  1117. 	/**

    1118. 

  1118. 	 * Configure itself when coming out of the session. Records from the session are NOT hooked into the identity map.

    1119. 

  1119. 	 * 

    1120. 

  1120. 	 * @internal

    1121. 

  1121. 	 * 

    1122. 

  1122. 	 * @return void

    1123. 

  1123. 	 */

    1124. 

  1124. 	public function __wakeup()

    1125. 

  1125. 	{

    1126. 

  1126. 		$class = get_class($this);

    1127. 

  1127. 		

    1128. 

  1128. 		if (!isset(self::$configured[$class])) {

    1129. 

  1129. 			$this->configure();

    1130. 

  1130. 			self::$configured[$class] = TRUE;

    1131. 

  1131. 		}		

    1132. 

  1132. 	}

    1133. 

  1133. 	

    1134. 

  1134. 	

    1135. 

  1135. 	/**

    1136. 

  1136. 	 * Allows the programmer to set features for the class

    1137. 

  1137. 	 * 

    1138. 

  1138. 	 * This method is only called once per page load for each class.

    1139. 

  1139. 	 * 

    1140. 

  1140. 	 * @return void

    1141. 

  1141. 	 */

    1142. 

  1142. 	protected function configure()

    1143. 

  1143. 	{

    1144. 

  1144. 	}

    1145. 

  1145. 	

    1146. 

  1146. 	

    1147. 

  1147. 	/**

    1148. 

  1148. 	 * Creates the SQL to insert this record

    1149. 

  1149. 	 *

    1150. 

  1150. 	 * @param  array $sql_values  The SQL-formatted values for this record

    1151. 

  1151. 	 * @return string  The SQL insert statement

    1152. 

  1152. 	 */

    1153. 

  1153. 	protected function constructInsertSQL($sql_values)

    1154. 

  1154. 	{

    1155. 

  1155. 		$sql = 'INSERT INTO ' . fORM::tablize(get_class($this)) . ' (';

    1156. 

  1156. 		

    1157. 

  1157. 		$columns = '';

    1158. 

  1158. 		$values  = '';

    1159. 

  1159. 		

    1160. 

  1160. 		$column_num = 0;

    1161. 

  1161. 		foreach ($sql_values as $column => $sql_value) {

    1162. 

  1162. 			if ($column_num) { $columns .= ', '; $values .= ', '; }

    1163. 

  1163. 			$columns .= $column;

    1164. 

  1164. 			$values  .= $sql_value;

    1165. 

  1165. 			$column_num++;

    1166. 

  1166. 		}

    1167. 

  1167. 		$sql .= $columns . ') VALUES (' . $values . ')';

    1168. 

  1168. 		return $sql;

    1169. 

  1169. 	}

    1170. 

  1170. 	

    1171. 

  1171. 	

    1172. 

  1172. 	/**

    1173. 

  1173. 	 * Creates the SQL to update this record

    1174. 

  1174. 	 *

    1175. 

  1175. 	 * @param  array $sql_values  The SQL-formatted values for this record

    1176. 

  1176. 	 * @return string  The SQL update statement

    1177. 

  1177. 	 */

    1178. 

  1178. 	protected function constructUpdateSQL($sql_values)

    1179. 

  1179. 	{

    1180. 

  1180. 		$table = fORM::tablize(get_class($this));

    1181. 

  1181. 		

    1182. 

  1182. 		$sql = 'UPDATE ' . $table . ' SET ';

    1183. 

  1183. 		$column_num = 0;

    1184. 

  1184. 		foreach ($sql_values as $column => $sql_value) {

    1185. 

  1185. 			if ($column_num) { $sql .= ', '; }

    1186. 

  1186. 			$sql .= $column . ' = ' . $sql_value;

    1187. 

  1187. 			$column_num++;

    1188. 

  1188. 		}

    1189. 

  1189. 		

    1190. 

  1190. 		$sql .= ' WHERE ' . fORMDatabase::createPrimaryKeyWhereClause($table, $table, $this->values, $this->old_values);

    1191. 

  1191. 		

    1192. 

  1192. 		return $sql;

    1193. 

  1193. 	}

    1194. 

  1194. 	

    1195. 

  1195. 	

    1196. 

  1196. 	/**

    1197. 

  1197. 	 * Deletes a record from the database, but does not destroy the object

    1198. 

  1198. 	 * 

    1199. 

  1199. 	 * This method will start a database transaction if one is not already active.

    1200. 

  1200. 	 * 

    1201. 

  1201. 	 * @return fActiveRecord  The record object, to allow for method chaining

    1202. 

  1202. 	 */

    1203. 

  1203. 	public function delete()

    1204. 

  1204. 	{

    1205. 

  1205. 		$class = get_class($this);

    1206. 

  1206. 		

    1207. 

  1207. 		if (fORM::getActiveRecordMethod($class, 'delete')) {

    1208. 

  1208. 			return $this->__call('delete', array());

    1209. 

  1209. 		}

    1210. 

  1210. 		

    1211. 

  1211. 		if (!$this->exists()) {

    1212. 

  1212. 			throw new fProgrammerException(

    1213. 

  1213. 				'This %s object does not yet exist in the database, and thus can not be deleted',

    1214. 

  1214. 				fORM::getRecordName($class)

    1215. 

  1215. 			);

    1216. 

  1216. 		}

    1217. 

  1217. 		

    1218. 

  1218. 		fORM::callHookCallbacks(

    1219. 

  1219. 			$this,

    1220. 

  1220. 			'pre::delete()',

    1221. 

  1221. 			$this->values,

    1222. 

  1222. 			$this->old_values,

    1223. 

  1223. 			$this->related_records,

    1224. 

  1224. 			$this->cache

    1225. 

  1225. 		);

    1226. 

  1226. 		

    1227. 

  1227. 		$table = fORM::tablize($class);

    1228. 

  1228. 		

    1229. 

  1229. 		$inside_db_transaction = fORMDatabase::retrieve()->isInsideTransaction();

    1230. 

  1230. 		

    1231. 

  1231. 		try {

    1232. 

  1232. 			

    1233. 

  1233. 			if (!$inside_db_transaction) {

    1234. 

  1234. 				fORMDatabase::retrieve()->translatedQuery('BEGIN');

    1235. 

  1235. 			}

    1236. 

  1236. 			

    1237. 

  1237. 			fORM::callHookCallbacks(

    1238. 

  1238. 				$this,

    1239. 

  1239. 				'post-begin::delete()',

    1240. 

  1240. 				$this->values,

    1241. 

  1241. 				$this->old_values,

    1242. 

  1242. 				$this->related_records,

    1243. 

  1243. 				$this->cache

    1244. 

  1244. 			);

    1245. 

  1245. 			

    1246. 

  1246. 			// Check to ensure no foreign dependencies prevent deletion

    1247. 

  1247. 			$one_to_many_relationships  = fORMSchema::retrieve()->getRelationships($table, 'one-to-many');

    1248. 

  1248. 			$many_to_many_relationships = fORMSchema::retrieve()->getRelationships($table, 'many-to-many');

    1249. 

  1249. 			

    1250. 

  1250. 			$relationships = array_merge($one_to_many_relationships, $many_to_many_relationships);

    1251. 

  1251. 			$records_sets_to_delete = array();

    1252. 

  1252. 			

    1253. 

  1253. 			$restriction_messages = array();

    1254. 

  1254. 			

    1255. 

  1255. 			foreach ($relationships as $relationship) {

    1256. 

  1256. 				

    1257. 

  1257. 				// Figure out how to check for related records

    1258. 

  1258. 				$type = (isset($relationship['join_table'])) ? 'many-to-many' : 'one-to-many';

    1259. 

  1259. 				$route = fORMSchema::getRouteNameFromRelationship($type, $relationship);

    1260. 

  1260. 				

    1261. 

  1261. 				$related_class   = fORM::classize($relationship['related_table']);

    1262. 

  1262. 				$related_objects = fGrammar::pluralize($related_class);

    1263. 

  1263. 				$method          = 'build' . $related_objects;

    1264. 

  1264. 				

    1265. 

  1265. 				// Grab the related records

    1266. 

  1266. 				$record_set = $this->$method($route);

    1267. 

  1267. 				

    1268. 

  1268. 				// If there are none, we can just move on

    1269. 

  1269. 				if (!$record_set->count()) {

    1270. 

  1270. 					continue;

    1271. 

  1271. 				}

    1272. 

  1272. 				

    1273. 

  1273. 				if ($type == 'one-to-many' && $relationship['on_delete'] == 'cascade') {

    1274. 

  1274. 					$records_sets_to_delete[] = $record_set;

    1275. 

  1275. 				}

    1276. 

  1276. 				

    1277. 

  1277. 				if ($relationship['on_delete'] == 'restrict' || $relationship['on_delete'] == 'no_action') {

    1278. 

  1278. 					

    1279. 

  1279. 					// Otherwise we have a restriction

    1280. 

  1280. 					$related_class_name  = fORM::classize($relationship['related_table']);

    1281. 

  1281. 					$related_record_name = fORM::getRecordName($related_class_name);

    1282. 

  1282. 					$related_record_name = fGrammar::pluralize($related_record_name);

    1283. 

  1283. 					

    1284. 

  1284. 					$restriction_messages[] = self::compose("One or more %s references it", $related_record_name);

    1285. 

  1285. 				}

    1286. 

  1286. 			}

    1287. 

  1287. 			

    1288. 

  1288. 			if ($restriction_messages) {

    1289. 

  1289. 				throw new fValidationException(

    1290. 

  1290. 					self::compose('This %s can not be deleted because:', fORM::getRecordName($class)),

    1291. 

  1291. 					$restriction_messages

    1292. 

  1292. 				);

    1293. 

  1293. 			}

    1294. 

  1294. 			

    1295. 

  1295. 			

    1296. 

  1296. 			// Delete this record

    1297. 

  1297. 			$sql    = 'DELETE FROM ' . $table . ' WHERE ' . fORMDatabase::createPrimaryKeyWhereClause($table, $table, $this->values, $this->old_values);

    1298. 

  1298. 			$result = fORMDatabase::retrieve()->translatedQuery($sql);

    1299. 

  1299. 			

    1300. 

  1300. 			

    1301. 

  1301. 			// Delete related records

    1302. 

  1302. 			foreach ($records_sets_to_delete as $record_set) {

    1303. 

  1303. 				foreach ($record_set as $record) {

    1304. 

  1304. 					if ($record->exists()) {

    1305. 

  1305. 						$record->delete();

    1306. 

  1306. 					}

    1307. 

  1307. 				}

    1308. 

  1308. 			}

    1309. 

  1309. 			

    1310. 

  1310. 			fORM::callHookCallbacks(

    1311. 

  1311. 				$this,

    1312. 

  1312. 				'pre-commit::delete()',

    1313. 

  1313. 				$this->values,

    1314. 

  1314. 				$this->old_values,

    1315. 

  1315. 				$this->related_records,

    1316. 

  1316. 				$this->cache

    1317. 

  1317. 			);

    1318. 

  1318. 			

    1319. 

  1319. 			if (!$inside_db_transaction) {

    1320. 

  1320. 				fORMDatabase::retrieve()->translatedQuery('COMMIT');

    1321. 

  1321. 			}

    1322. 

  1322. 			

    1323. 

  1323. 			fORM::callHookCallbacks(

    1324. 

  1324. 				$this,

    1325. 

  1325. 				'post-commit::delete()',

    1326. 

  1326. 				$this->values,

    1327. 

  1327. 				$this->old_values,

    1328. 

  1328. 				$this->related_records,

    1329. 

  1329. 				$this->cache

    1330. 

  1330. 			);

    1331. 

  1331. 			

    1332. 

  1332. 		} catch (fException $e) {

    1333. 

  1333. 			

    1334. 

  1334. 			if (!$inside_db_transaction) {

    1335. 

  1335. 				fORMDatabase::retrieve()->translatedQuery('ROLLBACK');

    1336. 

  1336. 			}

    1337. 

  1337. 			

    1338. 

  1338. 			fORM::callHookCallbacks(

    1339. 

  1339. 				$this,

    1340. 

  1340. 				'post-rollback::delete()',

    1341. 

  1341. 				$this->values,

    1342. 

  1342. 				$this->old_values,

    1343. 

  1343. 				$this->related_records,

    1344. 

  1344. 				$this->cache

    1345. 

  1345. 			);

    1346. 

  1346. 			

    1347. 

  1347. 			// Check to see if the validation exception came from a related record, and fix the message

    1348. 

  1348. 			if ($e instanceof fValidationException) {

    1349. 

  1349. 				$message = $e->getMessage();

    1350. 

  1350. 				$search  = self::compose('This %s can not be deleted because:', fORM::getRecordName($class));

    1351. 

  1351. 				if (stripos($message, $search) === FALSE) {

    1352. 

  1352. 					$regex       = self::compose('This %s can not be deleted because:', '__');

    1353. 

  1353. 					$regex_parts = explode('__', $regex);

    1354. 

  1354. 					$regex       = '#(' . preg_quote($regex_parts[0], '#') . ').*?(' . preg_quote($regex_parts[0], '#') . ')#';

    1355. 

  1355. 					

    1356. 

  1356. 					$message = preg_replace($regex, '\1' . strtr(fORM::getRecordName($class), array('\\' => '\\\\', '$' => '\\$')) . '\2', $message);

    1357. 

  1357. 					

    1358. 

  1358. 					$find          = self::compose("One or more %s references it", '__');

    1359. 

  1359. 					$find_parts    = explode('__', $find);

    1360. 

  1360. 					$find_regex    = '#' . preg_quote($find_parts[0], '#') . '(.*?)' . preg_quote($find_parts[1], '#') . '#';

    1361. 

  1361. 					

    1362. 

  1362. 					$replace       = self::compose("One or more %s indirectly references it", '__');

    1363. 

  1363. 					$replace_parts = explode('__', $replace);

    1364. 

  1364. 					$replace_regex = strtr($replace_parts[0], array('\\' => '\\\\', '$' => '\\$')) . '\1' . strtr($replace_parts[1], array('\\' => '\\\\', '$' => '\\$'));

    1365. 

  1365. 					

    1366. 

  1366. 					$message = preg_replace($find_regex, $replace_regex, $regex);

    1367. 

  1367. 					throw new fValidationException($message);

    1368. 

  1368. 				}

    1369. 

  1369. 			}

    1370. 

  1370. 			

    1371. 

  1371. 			throw $e;

    1372. 

  1372. 		}

    1373. 

  1373. 		

    1374. 

  1374. 		fORM::callHookCallbacks(

    1375. 

  1375. 			$this,

    1376. 

  1376. 			'post::delete()',

    1377. 

  1377. 			$this->values,

    1378. 

  1378. 			$this->old_values,

    1379. 

  1379. 			$this->related_records,

    1380. 

  1380. 			$this->cache

    1381. 

  1381. 		);

    1382. 

  1382. 		

    1383. 

  1383. 		// If we just deleted an object that has an auto-incrementing primary key,

    1384. 

  1384. 		// lets delete that value from the object since it is no longer valid

    1385. 

  1385. 		$pk_columns  = fORMSchema::retrieve()->getKeys($table, 'primary');

    1386. 

  1386. 		if (sizeof($pk_columns) == 1 && fORMSchema::retrieve()->getColumnInfo($table, $pk_columns[0], 'auto_increment')) {

    1387. 

  1387. 			$this->values[$pk_columns[0]] = NULL;

    1388. 

  1388. 			unset($this->old_values[$pk_columns[0]]);

    1389. 

  1389. 		}

    1390. 

  1390. 		

    1391. 

  1391. 		return $this;

    1392. 

  1392. 	}

    1393. 

  1393. 	

    1394. 

  1394. 	

    1395. 

  1395. 	/**

    1396. 

  1396. 	 * Retrieves a value from the record and prepares it for output into an HTML form element.

    1397. 

  1397. 	 * 

    1398. 

  1398. 	 * Below are the transformations performed:

    1399. 

  1399. 	 *  

    1400. 

  1400. 	 *  - **varchar, char, text**: will run through fHTML::encode(), if `TRUE` is passed the text will be run through fHTML::convertNewLinks() and fHTML::makeLinks()

    1401. 

  1401. 	 *  - **float**: takes 1 parameter to specify the number of decimal places

    1402. 

  1402. 	 *  - **date, time, timestamp**: `format()` will be called on the fDate/fTime/fTimestamp object with the 1 parameter specified

    1403. 

  1403. 	 *  - **objects**: the object will be converted to a string by `__toString()` or a `(string)` cast and then will be run through fHTML::encode()

    1404. 

  1404. 	 *  - **all other data types**: the value will be run through fHTML::encode()

    1405. 

  1405. 	 * 

    1406. 

  1406. 	 * @param  string $column      The name of the column to retrieve

    1407. 

  1407. 	 * @param  string $formatting  The formatting string

    1408. 

  1408. 	 * @return string  The encoded value for the column specified

    1409. 

  1409. 	 */

    1410. 

  1410. 	protected function encode($column, $formatting=NULL)

    1411. 

  1411. 	{

    1412. 

  1412. 		if (!array_key_exists($column, $this->values)) {

    1413. 

  1413. 			throw new fProgrammerException(

    1414. 

  1414. 				'The column specified, %s, does not exist',

    1415. 

  1415. 				$column

    1416. 

  1416. 			);

    1417. 

  1417. 		}

    1418. 

  1418. 		

    1419. 

  1419. 		$table       = fORM::tablize(get_class($this));

    1420. 

  1420. 		$column_type = fORMSchema::retrieve()->getColumnInfo($table, $column, 'type');

    1421. 

  1421. 		

    1422. 

  1422. 		// Ensure the programmer is calling the function properly

    1423. 

  1423. 		if ($column_type == 'blob') {

    1424. 

  1424. 			throw new fProgrammerException(

    1425. 

  1425. 				'The column specified, %s, does not support forming because it is a blob column',

    1426. 

  1426. 				$column

    1427. 

  1427. 			);

    1428. 

  1428. 		}

    1429. 

  1429. 		

    1430. 

  1430. 		if ($formatting !== NULL && in_array($column_type, array('boolean', 'integer'))) {

    1431. 

  1431. 			throw new fProgrammerException(

    1432. 

  1432. 				'The column specified, %s, does not support any formatting options',

    1433. 

  1433. 				$column

    1434. 

  1434. 			);

    1435. 

  1435. 		}

    1436. 

  1436. 		

    1437. 

  1437. 		// Grab the value for empty value checking

    1438. 

  1438. 		$method_name = 'get' . fGrammar::camelize($column, TRUE);

    1439. 

  1439. 		$value       = $this->$method_name();

    1440. 

  1440. 		

    1441. 

  1441. 		// Date/time objects

    1442. 

  1442. 		if (is_object($value) && in_array($column_type, array('date', 'time', 'timestamp'))) {

    1443. 

  1443. 			if ($formatting === NULL) {

    1444. 

  1444. 				throw new fProgrammerException(

    1445. 

  1445. 					'The column specified, %s, requires one formatting parameter, a valid date() formatting string',

    1446. 

  1446. 					$column

    1447. 

  1447. 				);

    1448. 

  1448. 			}

    1449. 

  1449. 			$value = $value->format($formatting);

    1450. 

  1450. 		}

    1451. 

  1451. 		

    1452. 

  1452. 		// Other objects

    1453. 

  1453. 		if (is_object($value) && is_callable(array($value, '__toString'))) {

    1454. 

  1454. 			$value = $value->__toString();

    1455. 

  1455. 		} elseif (is_object($value)) {

    1456. 

  1456. 			$value = (string) $value;	

    1457. 

  1457. 		}

    1458. 

  1458. 		

    1459. 

  1459. 		// Make sure we don't mangle a non-float value

    1460. 

  1460. 		if ($column_type == 'float' && is_numeric($value)) {

    1461. 

  1461. 			$column_decimal_places = fORMSchema::retrieve()->getColumnInfo($table, $column, 'decimal_places');

    1462. 

  1462. 			

    1463. 

  1463. 			// If the user passed in a formatting value, use it

    1464. 

  1464. 			if ($formatting !== NULL && is_numeric($formatting)) {

    1465. 

  1465. 				$decimal_places = (int) $formatting;

    1466. 

  1466. 				

    1467. 

  1467. 			// If the column has a pre-defined number of decimal places, use that

    1468. 

  1468. 			} elseif ($column_decimal_places !== NULL) {

    1469. 

  1469. 				$decimal_places = $column_decimal_places;

    1470. 

  1470. 			

    1471. 

  1471. 			// This figures out how many decimal places are part of the current value

    1472. 

  1472. 			} else {

    1473. 

  1473. 				$value_parts    = explode('.', $value);

    1474. 

  1474. 				$decimal_places = (!isset($value_parts[1])) ? 0 : strlen($value_parts[1]);

    1475. 

  1475. 			}

    1476. 

  1476. 			

    1477. 

  1477. 			return number_format($value, $decimal_places, '.', '');

    1478. 

  1478. 		}

    1479. 

  1479. 		

    1480. 

  1480. 		// Turn line-breaks into breaks for text fields and add links

    1481. 

  1481. 		if ($formatting === TRUE && in_array($column_type, array('varchar', 'char', 'text'))) {

    1482. 

  1482. 			return fHTML::makeLinks(fHTML::convertNewlines(fHTML::encode($value)));

    1483. 

  1483. 		}

    1484. 

  1484. 		

    1485. 

  1485. 		// Anything that has gotten to here is a string value or is not the proper data type for the column that contains it

    1486. 

  1486. 		return fHTML::encode($value);

    1487. 

  1487. 	}

    1488. 

  1488. 	

    1489. 

  1489. 	

    1490. 

  1490. 	/**

    1491. 

  1491. 	 * Checks to see if the record exists in the database

    1492. 

  1492. 	 * 

    1493. 

  1493. 	 * @return boolean  If the record exists in the database

    1494. 

  1494. 	 */

    1495. 

  1495. 	public function exists()

    1496. 

  1496. 	{

    1497. 

  1497. 		$class = get_class($this);

    1498. 

  1498. 		

    1499. 

  1499. 		if (fORM::getActiveRecordMethod($class, 'exists')) {

    1500. 

  1500. 			return $this->__call('exists', array());

    1501. 

  1501. 		}

    1502. 

  1502. 		

    1503. 

  1503. 		$pk_columns = fORMSchema::retrieve()->getKeys(fORM::tablize($class), 'primary');

    1504. 

  1504. 		$exists     = FALSE;

    1505. 

  1505. 		

    1506. 

  1506. 		foreach ($pk_columns as $pk_column) {

    1507. 

  1507. 			$has_old = self::hasOld($this->old_values, $pk_column);

    1508. 

  1508. 			if (($has_old && self::retrieveOld($this->old_values, $pk_column) !== NULL) || (!$has_old && $this->values[$pk_column] !== NULL)) {

    1509. 

  1509. 				$exists = TRUE;

    1510. 

  1510. 			}

    1511. 

  1511. 		}

    1512. 

  1512. 		

    1513. 

  1513. 		return $exists;

    1514. 

  1514. 	}

    1515. 

  1515. 	

    1516. 

  1516. 	

    1517. 

  1517. 	/**

    1518. 

  1518. 	 * Loads a record from t…
    1519.

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