PageRenderTime 68ms CodeModel.GetById 22ms RepoModel.GetById 1ms app.codeStats 0ms

/classphp/flourish/fActiveRecord.php

https://github.com/jsuarez/Lexer
PHP | 2603 lines | 1584 code | 428 blank | 591 comment | 365 complexity | d1c640ab2b1ebdece3e32da01731f6a2 MD5 | raw 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 the database based on a UNIQUE key

    1519. 

  1519. 	 * 

    1520. 

  1520. 	 * @throws fNotFoundException

    1521. 

  1521. 	 * 

    1522. 

  1522. 	 * @param  array $values  The UNIQUE key values to try and load with

    1523. 

  1523. 	 * @return void

    1524. 

  1524. 	 */

    1525. 

  1525. 	protected function fetchResultFromUniqueKey($values)

    1526. 

  1526. 	{		

    1527. 

  1527. 		$class = get_class($this);

    1528. 

  1528. 		try {

    1529. 

  1529. 			if ($values === array_combine(array_keys($values), array_fill(0, sizeof($values), NULL))) {

    1530. 

  1530. 				throw new fExpectedException('The values specified for the unique key are all NULL');	

    1531. 

  1531. 			}

    1532. 

  1532. 			

    1533. 

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

    1534. 

  1534. 			$sql = 'SELECT * FROM ' . $table . ' WHERE ';

    1535. 

  1535. 			$conditions = array();

    1536. 

  1536. 			foreach ($values as $column => $value) {

    1537. 

  1537. 				$conditions[] = $column . fORMDatabase::escapeBySchema($table, $column, $value, '=');	

    1538. 

  1538. 			}

    1539. 

  1539. 			$sql .= join(' AND ', $conditions);

    1540. 

  1540. 		

    1541. 

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

    1542. 

  1542. 			$result->tossIfNoRows();

    1543. 

  1543. 			

    1544. 

  1544. 		} catch (fExpectedException $e) {

    1545. 

  1545. 			throw new fNotFoundException(

    1546. 

  1546. 				'The %s requested could not be found',

    1547. 

  1547. 				fORM::getRecordName($class)

    1548. 

  1548. 			);

    1549. 

  1549. 		}

    1550. 

  1550. 		

    1551. 

  1551. 		return $result;

    1552. 

  1552. 	}

    1553. 

  1553. 	

    1554. 

  1554. 	

    1555. 

  1555. 	/**

    1556. 

  1556. 	 * Retrieves a value from the record

    1557. 

  1557. 	 * 

    1558. 

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

    1559. 

  1559. 	 * @return mixed  The value for the column specified

    1560. 

  1560. 	 */

    1561. 

  1561. 	protected function get($column)

    1562. 

  1562. 	{

    1563. 

  1563. 		if (!isset($this->values[$column]) && !array_key_exists($column, $this->values)) {

    1564. 

  1564. 			throw new fProgrammerException(

    1565. 

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

    1566. 

  1566. 				$column

    1567. 

  1567. 			);

    1568. 

  1568. 		}

    1569. 

  1569. 		return $this->values[$column];

    1570. 

  1570. 	}

    1571. 

  1571. 	

    1572. 

  1572. 	

    1573. 

  1573. 	/**

    1574. 

  1574. 	 * Retrieves information about a column

    1575. 

  1575. 	 * 

    1576. 

  1576. 	 * @param  string $column   The name of the column to inspect

    1577. 

  1577. 	 * @param  string $element  The metadata element to retrieve

    1578. 

  1578. 	 * @return mixed  The metadata array for the column, or the metadata element specified

    1579. 

  1579. 	 */

    1580. 

  1580. 	protected function inspect($column, $element=NULL)

    1581. 

  1581. 	{

    1582. 

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

    1583. 

  1583. 			throw new fProgrammerException(

    1584. 

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

    1585. 

  1585. 				$column

    1586. 

  1586. 			);

    1587. 

  1587. 		}

    1588. 

  1588. 		

    1589. 

  1589. 		$info = fORMSchema::retrieve()->getColumnInfo(fORM::tablize(get_class($this)), $column);

    1590. 

  1590. 		

    1591. 

  1591. 		if (!in_array($info['type'], array('varchar', 'char', 'text'))) {

    1592. 

  1592. 			unset($info['valid_values']);

    1593. 

  1593. 			unset($info['max_length']);

    1594. 

  1594. 		}

    1595. 

  1595. 		

    1596. 

  1596. 		if ($info['type'] != 'float') {

    1597. 

  1597. 			unset($info['decimal_places']);

    1598. 

  1598. 		}

    1599. 

  1599. 		

    1600. 

  1600. 		if ($info['type'] != 'integer') {

    1601. 

  1601. 			unset($info['auto_increment']);

    1602. 

  1602. 		}

    1603. 

  1603. 		

    1604. 

  1604. 		$info['feature'] = NULL;

    1605. 

  1605. 		

    1606. 

  1606. 		fORM::callInspectCallbacks(get_class($this), $column, $info);

    1607. 

  1607. 		

    1608. 

  1608. 		if ($element) {

    1609. 

  1609. 			if (!isset($info[$element])) {

    1610. 

  1610. 				throw new fProgrammerException(

    1611. 

  1611. 					'The element specified, %1$s, is invalid. Must be one of: %2$s.',

    1612. 

  1612. 					$element,

    1613. 

  1613. 					join(', ', array_keys($info))

    1614. 

  1614. 				);

    1615. 

  1615. 			}

    1616. 

  1616. 			return $info[$element];

    1617. 

  1617. 		}

    1618. 

  1618. 		

    1619. 

  1619. 		return $info;

    1620. 

  1620. 	}

    1621. 

  1621. 	

    1622. 

  1622. 	

    1623. 

  1623. 	/**

    1624. 

  1624. 	 * Loads a record from the database

    1625. 

  1625. 	 * 

    1626. 

  1626. 	 * @throws fNotFoundException  When the record could not be found in the database

    1627. 

  1627. 	 * 

    1628. 

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

    1629. 

  1629. 	 */

    1630. 

  1630. 	public function load()

    1631. 

  1631. 	{

    1632. 

  1632. 		$class = get_class($this);

    1633. 

  1633. 		

    1634. 

  1634. 		if (fORM::getActiveRecordMethod($class, 'load')) {

    1635. 

  1635. 			return $this->__call('load', array());

    1636. 

  1636. 		}

    1637. 

  1637. 		

    1638. 

  1638. 		try {

    1639. 

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

    1640. 

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

    1641. 

  1641. 		

    1642. 

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

    1643. 

  1643. 			$result->tossIfNoRows();

    1644. 

  1644. 			

    1645. 

  1645. 		} catch (fExpectedException $e) {

    1646. 

  1646. 			throw new fNotFoundException(

    1647. 

  1647. 				'The %s requested could not be found',

    1648. 

  1648. 				fORM::getRecordName($class)

    1649. 

  1649. 			);

    1650. 

  1650. 		}

    1651. 

  1651. 		

    1652. 

  1652. 		$this->loadFromResult($result, TRUE);

    1653. 

  1653. 		

    1654. 

  1654. 		return $this;

    1655. 

  1655. 	}

    1656. 

  1656. 	

    1657. 

  1657. 	

    1658. 

  1658. 	/**

    1659. 

  1659. 	 * Loads a record from the database directly from a result object

    1660. 

  1660. 	 * 

    1661. 

  1661. 	 * @param  Iterator $result               The result object to use for loading the current object

    1662. 

  1662. 	 * @param  boolean  $ignore_identity_map  If the identity map should be ignored and the values loaded no matter what

    1663. 

  1663. 	 * @return boolean  If the record was loaded from the identity map

    1664. 

  1664. 	 */

    1665. 

  1665. 	protected function loadFromResult($result, $ignore_identity_map=FALSE)

    1666. 

  1666. 	{

    1667. 

  1667. 		$class = get_class($this);

    1668. 

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

    1669. 

  1669. 		$row   = $result->current();

    1670. 

  1670. 		

    1671. 

  1671. 		$db = fORMDatabase::retrieve();

    1672. 

  1672. 		

    1673. 

  1673. 		if (!isset(self::$unescape_map[$class])) {

    1674. 

  1674. 			self::$unescape_map[$class] = array();

    1675. 

  1675. 			$column_info                = fORMSchema::retrieve()->getColumnInfo($table);

    1676. 

  1676. 			

    1677. 

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

    1678. 

  1678. 				if (in_array($info['type'], array('blob', 'boolean', 'date', 'time', 'timestamp'))) {

    1679. 

  1679. 					self::$unescape_map[$class][$column] = $info['type'];

    1680. 

  1680. 				}

    1681. 

  1681. 			}	

    1682. 

  1682. 		}

    1683. 

  1683. 		

    1684. 

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

    1685. 

  1685. 		foreach ($pk_columns as $column) {

    1686. 

  1686. 			$value = $row[$column];

    1687. 

  1687. 			if ($value !== NULL && isset(self::$unescape_map[$class][$column])) {

    1688. 

  1688. 				$value = $db->unescape(self::$unescape_map[$class][$column], $value);

    1689. 

  1689. 			}	

    1690. 

  1690. 			

    1691. 

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

    1692. 

  1692. 			unset($row[$column]);

    1693. 

  1693. 		}

    1694. 

  1694. 		

    1695. 

  1695. 		$hash = self::hash($this->values, $class);

    1696. 

  1696. 		if (!$ignore_identity_map && $this->loadFromIdentityMap($this->values, $hash)) {

    1697. 

  1697. 			return TRUE;

    1698. 

  1698. 		}

    1699. 

  1699. 		

    1700. 

  1700. 		foreach ($row as $column => $value) {

    1701. 

  1701. 			if ($value !== NULL && isset(self::$unescape_map[$class][$column])) {

    1702. 

  1702. 				$value = $db->unescape(self::$unescape_map[$class][$column], $value);

    1703. 

  1703. 			}

    1704. 

  1704. 			

    1705. 

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

    1706. 

  1706. 		}

    1707. 

  1707. 		

    1708. 

  1708. 		// Save this object to the identity map

    1709. 

  1709. 		if (!isset(self::$identity_map[$class])) {

    1710. 

  1710. 			self::$identity_map[$class] = array(); 		

    1711. 

  1711. 		}

    1712. 

  1712. 		self::$identity_map[$class][$hash] = $this;

    1713. 

  1713. 		

    1714. 

  1714. 		fORM::callHookCallbacks(

    1715. 

  1715. 			$this,

    1716. 

  1716. 			'post::loadFromResult()',

    1717. 

  1717. 			$this->values,

    1718. 

  1718. 			$this->old_values,

    1719. 

  1719. 			$this->related_records,

    1720. 

  1720. 			$this->cache

    1721. 

  1721. 		);

    1722. 

  1722. 		

    1723. 

  1723. 		return FALSE;

    1724. 

  1724. 	}

    1725. 

  1725. 	

    1726. 

  1726. 	

    1727. 

  1727. 	/**

    1728. 

  1728. 	 * Tries to load the object (via references to class vars) from the fORM identity map

    1729. 

  1729. 	 * 

    1730. 

  1730. 	 * @param  array  $row   The data source for the primary key values

    1731. 

  1731. 	 * @param  string $hash  The unique hash for this record

    1732. 

  1732. 	 * @return boolean  If the load was successful

    1733. 

  1733. 	 */

    1734. 

  1734. 	protected function loadFromIdentityMap($row, $hash)

    1735. 

  1735. 	{

    1736. 

  1736. 		$class = get_class($this);

    1737. 

  1737. 		

    1738. 

  1738. 		if (!isset(self::$identity_map[$class])) {

    1739. 

  1739. 			return FALSE;

    1740. 

  1740. 		}

    1741. 

  1741. 		

    1742. 

  1742. 		if (!isset(self::$identity_map[$class][$hash])) {

    1743. 

  1743. 			return FALSE;

    1744. 

  1744. 		}

    1745. 

  1745. 		

    1746. 

  1746. 		$object = self::$identity_map[$class][$hash];

    1747. 

  1747. 		

    1748. 

  1748. 		// If we got a result back, it is the object we are creating

    1749. 

  1749. 		$this->cache           = &$object->cache;

    1750. 

  1750. 		$this->values          = &$object->values;

    1751. 

  1751. 		$this->old_values      = &$object->old_values;

    1752. 

  1752. 		$this->related_records = &$object->related_records;

    1753. 

  1753. 		return TRUE;

    1754. 

  1754. 	}

    1755. 

  1755. 	

    1756. 

  1756. 	

    1757. 

  1757. 	/**

    1758. 

  1758. 	 * Sets the values for this record by getting values from the request through the fRequest class

    1759. 

  1759. 	 * 

    1760. 

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

    1761. 

  1761. 	 */

    1762. 

  1762. 	public function populate()

    1763. 

  1763. 	{

    1764. 

  1764. 		$class = get_class($this);

    1765. 

  1765. 		

    1766. 

  1766. 		if (fORM::getActiveRecordMethod($class, 'populate')) {

    1767. 

  1767. 			return $this->__call('populate', array());

    1768. 

  1768. 		}

    1769. 

  1769. 		

    1770. 

  1770. 		fORM::callHookCallbacks(

    1771. 

  1771. 			$this,

    1772. 

  1772. 			'pre::populate()',

    1773. 

  1773. 			$this->values,

    1774. 

  1774. 			$this->old_values,

    1775. 

  1775. 			$this->related_records,

    1776. 

  1776. 			$this->cache

    1777. 

  1777. 		);

    1778. 

  1778. 		

    1779. 

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

    1780. 

  1780. 		

    1781. 

  1781. 		$column_info = fORMSchema::retrieve()->getColumnInfo($table);

    1782. 

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

    1783. 

  1783. 			if (fRequest::check($column)) {

    1784. 

  1784. 				$method = 'set' . fGrammar::camelize($column, TRUE);

    1785. 

  1785. 				$this->$method(fRequest::get($column));

    1786. 

  1786. 			}

    1787. 

  1787. 		}

    1788. 

  1788. 		

    1789. 

  1789. 		fORM::callHookCallbacks(

    1790. 

  1790. 			$this,

    1791. 

  1791. 			'post::populate()',

    1792. 

  1792. 			$this->values,

    1793. 

  1793. 			$this->old_values,

    1794. 

  1794. 			$this->related_records,

    1795. 

  1795. 			$this->cache

    1796. 

  1796. 		);

    1797. 

  1797. 		

    1798. 

  1798. 		return $this;

    1799. 

  1799. 	}

    1800. 

  1800. 	

    1801. 

  1801. 	

    1802. 

  1802. 	/**

    1803. 

  1803. 	 * Retrieves a value from the record and prepares it for output into html.

    1804. 

  1804. 	 * 

    1805. 

  1805. 	 * Below are the transformations performed:

    1806. 

  1806. 	 * 

    1807. 

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

    1808. 

  1808. 	 *  - **boolean**: will return `'Yes'` or `'No'`

    1809. 

  1809. 	 *  - **integer**: will add thousands/millions/etc. separators

    1810. 

  1810. 	 *  - **float**: will add thousands/millions/etc. separators and takes 1 parameter to specify the number of decimal places

    1811. 

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

    1812. 

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

    1813. 

  1813. 	 * 

    1814. 

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

    1815. 

  1815. 	 * @param  mixed  $formatting  The formatting parameter, if applicable

    1816. 

  1816. 	 * @return string  The formatted value for the column specified

    1817. 

  1817. 	 */

    1818. 

  1818. 	protected function prepare($column, $formatting=NULL)

    1819. 

  1819. 	{

    1820. 

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

    1821. 

  1821. 			throw new fProgrammerException(

    1822. 

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

    1823. 

  1823. 				$column

    1824. 

  1824. 			);

    1825. 

  1825. 		}

    1826. 

  1826. 		

    1827. 

  1827. 		$column_info = fORMSchema::retrieve()->getColumnInfo(fORM::tablize(get_class($this)), $column);

    1828. 

  1828. 		$column_type = $column_info['type'];

    1829. 

  1829. 		

    1830. 

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

    1831. 

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

    1832. 

  1832. 			throw new fProgrammerException(

    1833. 

  1833. 				'The column specified, %s, can not be prepared because it is a blob column',

    1834. 

  1834. 				$column

    1835. 

  1835. 			);

    1836. 

  1836. 		}

    1837. 

  1837. 		

    1838. 

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

    1839. 

  1839. 			throw new fProgrammerException(

    1840. 

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

    1841. 

  1841. 				$column

    1842. 

  1842. 			);

    1843. 

  1843. 		}

    1844. 

  1844. 		

    1845. 

  1845. 		// Grab the value for empty value checking

    1846. 

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

    1847. 

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

    1848. 

  1848. 		

    1849. 

  1849. 		// Date/time objects

    1850. 

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

    1851. 

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

    1852. 

  1852. 				throw new fProgrammerException(

    1853. 

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

    1854. 

  1854. 					$column

    1855. 

  1855. 				);

    1856. 

  1856. 			}

    1857. 

  1857. 			return $value->format($formatting);

    1858. 

  1858. 		}

    1859. 

  1859. 		

    1860. 

  1860. 		// Other objects

    1861. 

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

    1862. 

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

    1863. 

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

    1864. 

  1864. 			$value = (string) $value;	

    1865. 

  1865. 		}

    1866. 

  1866. 		

    1867. 

  1867. 		// Ensure the value matches the data type specified to prevent mangling

    1868. 

  1868. 		if ($column_type == 'boolean' && is_bool($value)) {

    1869. 

  1869. 			return ($value) ? 'Yes' : 'No';

    1870. 

  1870. 		}

    1871. 

  1871. 		

    1872. 

  1872. 		if ($column_type == 'integer' && is_numeric($value)) {

    1873. 

  1873. 			return number_format($value, 0, '', ',');

    1874. 

  1874. 		}

    1875. 

  1875. 		

    1876. 

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

    1877. 

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

    1878. 

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

    1879. 

  1879. 				$decimal_places = (int) $formatting;

    1880. 

  1880. 				

    1881. 

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

    1882. 

  1882. 			} elseif ($column_info['decimal_places'] !== NULL) {

    1883. 

  1883. 				$decimal_places = $column_info['decimal_places'];

    1884. 

  1884. 			

    1885. 

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

    1886. 

  1886. 			} else {

    1887. 

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

    1888. 

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

    1889. 

  1889. 			}

    1890. 

  1890. 			

    1891. 

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

    1892. 

  1892. 		}

    1893. 

  1893. 		

    1894. 

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

    1895. 

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

    1896. 

  1896. 			return fHTML::makeLinks(fHTML::convertNewlines(fHTML::prepare($value)));

    1897. 

  1897. 		}

    1898. 

  1898. 		

    1899. 

  1899. 		// Anything that has gotten to here is a string value, or is not the

    1900. 

  1900. 		// proper data type for the column, so we just make sure it is marked

    1901. 

  1901. 		// up properly for display in HTML

    1902. 

  1902. 		return fHTML::prepare($value);

    1903. 

  1903. 	}

    1904. 

  1904. 	

    1905. 

  1905. 	

    1906. 

  1906. 	/**

    1907. 

  1907. 	 * Generates a pre-formatted block of text containing the method signatures for all methods (including dynamic ones)

    1908. 

  1908. 	 * 

    1909. 

  1909. 	 * @param  boolean $include_doc_comments  If the doc block comments for each method should be included

    1910. 

  1910. 	 * @return string  A preformatted block of text with the method signatures and optionally the doc comment

    1911. 

  1911. 	 */

    1912. 

  1912. 	public function reflect($include_doc_comments=FALSE)

    1913. 

  1913. 	{

    1914. 

  1914. 		$signatures = array();

    1915. 

  1915. 		

    1916. 

  1916. 		$class        = get_class($this);

    1917. 

  1917. 		$columns_info = fORMSchema::retrieve()->getColumnInfo(fORM::tablize($class));

    1918. 

  1918. 		foreach ($columns_info as $column => $column_info) {

    1919. 

  1919. 			$camelized_column = fGrammar::camelize($column, TRUE);

    1920. 

  1920. 			

    1921. 

  1921. 			// Get and set methods

    1922. 

  1922. 			$signature = '';

    1923. 

  1923. 			if ($include_doc_comments) {

    1924. 

  1924. 				$fixed_type = $column_info['type'];

    1925. 

  1925. 				if ($fixed_type == 'blob') {

    1926. 

  1926. 					$fixed_type = 'string';

    1927. 

  1927. 				}

    1928. 

  1928. 				if ($fixed_type == 'date') {

    1929. 

  1929. 					$fixed_type = 'fDate';

    1930. 

  1930. 				}

    1931. 

  1931. 				if ($fixed_type == 'timestamp') {

    1932. 

  1932. 					$fixed_type = 'fTimestamp';

    1933. 

  1933. 				}

    1934. 

  1934. 				if ($fixed_type == 'time') {

    1935. 

  1935. 					$fixed_type = 'fTime';

    1936. 

  1936. 				}

    1937. 

  1937. 				

    1938. 

  1938. 				$signature .= "/**\n";

    1939. 

  1939. 				$signature .= " * Gets the current value of " . $column . "\n";

    1940. 

  1940. 				$signature .= " * \n";

    1941. 

  1941. 				$signature .= " * @return " . $fixed_type . "  The current value\n";

    1942. 

  1942. 				$signature .= " */\n";

    1943. 

  1943. 			}

    1944. 

  1944. 			$get_method = 'get' . $camelized_column;

    1945. 

  1945. 			$signature .= 'public function ' . $get_method . '()';

    1946. 

  1946. 			

    1947. 

  1947. 			$signatures[$get_method] = $signature;

    1948. 

  1948. 			

    1949. 

  1949. 			

    1950. 

  1950. 			$signature = '';

    1951. 

  1951. 			if ($include_doc_comments) {

    1952. 

  1952. 				$fixed_type = $column_info['type'];

    1953. 

  1953. 				if ($fixed_type == 'blob') {

    1954. 

  1954. 					$fixed_type = 'string';

    1955. 

  1955. 				}

    1956. 

  1956. 				if ($fixed_type == 'date') {

    1957. 

  1957. 					$fixed_type = 'fDate|string';

    1958. 

  1958. 				}

    1959. 

  1959. 				if ($fixed_type == 'timestamp') {

    1960. 

  1960. 					$fixed_type = 'fTimestamp|string';

    1961. 

  1961. 				}

    1962. 

  1962. 				if ($fixed_type == 'time') {

    1963. 

  1963. 					$fixed_type = 'fTime|string';

    1964. 

  1964. 				}

    1965. 

  1965. 				

    1966. 

  1966. 				$signature .= "/**\n";

    1967. 

  1967. 				$signature .= " * Sets the value for " . $column . "\n";

    1968. 

  1968. 				$signature .= " * \n";

    1969. 

  1969. 				$signature .= " * @param  " . $fixed_type . " \$" . $column . "  The new value\n";

    1970. 

  1970. 				$signature .= " * @return void\n";

    1971. 

  1971. 				$signature .= " */\n";

    1972. 

  1972. 			}

    1973. 

  1973. 			$set_method = 'set' . $camelized_column;

    1974. 

  1974. 			$signature .= 'public function ' . $set_method . '($' . $column . ')';

    1975. 

  1975. 			

    1976. 

  1976. 			$signatures[$set_method] = $signature;

    1977. 

  1977. 			

    1978. 

  1978. 			

    1979. 

  1979. 			// The encode method

    1980. 

  1980. 			$signature = '';

    1981. 

  1981. 			if ($include_doc_comments) {

    1982. 

  1982. 				$signature .= "/**\n";

    1983. 

  1983. 				$signature .= " * Encodes the value of " . $column . " for output into an HTML form\n";

    1984. 

  1984. 				$signature .= " * \n";

    1985. 

  1985. 				

    1986. 

  1986. 				if (in_array($column_info['type'], array('time', 'timestamp', 'date'))) {

    1987. 

  1987. 					$signature .= " * @param  string \$date_formatting_string  A date() compatible formatting string\n";

    1988. 

  1988. 				}

    1989. 

  1989. 				if (in_array($column_info['type'], array('float'))) {

    1990. 

  1990. 					$signature .= " * @param  integer \$decimal_places  The number of decimal places to include - if not specified will default to the precision of the column or the current value\n";

    1991. 

  1991. 				}

    1992. 

  1992. 				

    1993. 

  1993. 				$signature .= " * @return string  The HTML form-ready value\n";

    1994. 

  1994. 				$signature .= " */\n";

    1995. 

  1995. 			}

    1996. 

  1996. 			$encode_method = 'encode' . $camelized_column;

    1997. 

  1997. 			$signature .= 'public function ' . $encode_method . '(';

    1998. 

  1998. 			if (in_array($column_info['type'], array('time', 'timestamp', 'date'))) {

    1999. 

  1999. 				$signature .= '$date_formatting_string';

    2000. 

  2000. 			}

    2001. 

  2001. 			if (in_array($column_info['type'], array('float'))) {

    2002. 

  2002. 				$signature .= '$decimal_places=NULL';

    2003. 

  2003. 			}

    2004. 

  2004. 			$signature .= ')';

    2005. 

  2005. 			

    2006. 

  2006. 			$signatures[$encode_method] = $signature;

    2007. 

  2007. 			

    2008. 

  2008. 			

    2009. 

  2009. 			// The prepare method

    2010. 

  2010. 			$signature = '';

    2011. 

  2011. 			if ($include_doc_comments) {

    2012. 

  2012. 				$signature .= "/**\n";

    2013. 

  2013. 				$signature .= " * Prepares the value of " . $column . " for output into HTML\n";

    2014. 

  2014. 				$signature .= " * \n";

    2015. 

  2015. 				

    2016. 

  2016. 				if (in_array($column_info['type'], array('time', 'timestamp', 'date'))) {

    2017. 

  2017. 					$signature .= " * @param  string \$date_formatting_string  A date() compatible formatting string\n";

    2018. 

  2018. 				}

    2019. 

  2019. 				if (in_array($column_info['type'], array('float'))) {

    2020. 

  2020. 					$signature .= " * @param  integer \$decimal_places  The number of decimal places to include - if not specified will default to the precision of the column or the current value\n";

    2021. 

  2021. 				}

    2022. 

  2022. 				if (in_array($column_info['type'], array('varchar', 'char', 'text'))) {

    2023. 

  2023. 					$signature .= " * @param  boolean \$create_links_and_line_breaks  Will cause links to be automatically converted into [a] tags and line breaks into [br] tags \n";

    2024. 

  2024. 				}

    2025. 

  2025. 				

    2026. 

  2026. 				$signature .= " * @return string  The HTML-ready value\n";

    2027. 

  2027. 				$signature .= " */\n";

    2028. 

  2028. 			}

    2029. 

  2029. 			$prepare_method = 'prepare' . $camelized_column;

    2030. 

  2030. 			$signature .= 'public function ' . $prepare_method . '(';

    2031. 

  2031. 			if (in_array($column_info['type'], array('time', 'timestamp', 'date'))) {

    2032. 

  2032. 				$signature .= '$date_formatting_string';

    2033. 

  2033. 			}

    2034. 

  2034. 			if (in_array($column_info['type'], array('float'))) {

    2035. 

  2035. 				$signature .= '$decimal_places=NULL';

    2036. 

  2036. 			}

    2037. 

  2037. 			if (in_array($column_info['type'], array('varchar', 'char', 'text'))) {

    2038. 

  2038. 				$signature .= '$create_links_and_line_breaks=FALSE';

    2039. 

  2039. 			}

    2040. 

  2040. 			$signature .= ')';

    2041. 

  2041. 			

    2042. 

  2042. 			$signatures[$prepare_method] = $signature;

    2043. 

  2043. 			

    2044. 

  2044. 			

    2045. 

  2045. 			// The inspect method

    2046. 

  2046. 			$signature = '';

    2047. 

  2047. 			if ($include_doc_comments) {

    2048. 

  2048. 				$signature .= "/**\n";

    2049. 

  2049. 				$signature .= " * Returns metadata about " . $column . "\n";

    2050. 

  2050. 				$signature .= " * \n";

    2051. 

  2051. 				$elements = array('type', 'not_null', 'default');

    2052. 

  2052. 				if (in_array($column_info['type'], array('varchar', 'char', 'text'))) {

    2053. 

  2053. 					$elements[] = 'valid_values';

    2054. 

  2054. 					$elements[] = 'max_length';

    2055. 

  2055. 				}

    2056. 

  2056. 				if ($column_info['type'] == 'float') {

    2057. 

  2057. 					$elements[] = 'decimal_places';

    2058. 

  2058. 				}

    2059. 

  2059. 				if ($column_info['type'] == 'integer') {

    2060. 

  2060. 					$elements[] = 'auto_increment';

    2061. 

  2061. 				}

    2062. 

  2062. 				$signature .= " * @param  string \$element  The element to return. Must be one of: '" . join("', '", $elements) . "'.\n";

    2063. 

  2063. 				$signature .= " * @return mixed  The metadata array or a single element\n";

    2064. 

  2064. 				$signature .= " */\n";

    2065. 

  2065. 			}

    2066. 

  2066. 			$inspect_method = 'inspect' . $camelized_column;

    2067. 

  2067. 			$signature .= 'public function ' . $inspect_method . '($element=NULL)';

    2068. 

  2068. 			

    2069. 

  2069. 			$signatures[$inspect_method] = $signature;

    2070. 

  2070. 		}

    2071. 

  2071. 		

    2072. 

  2072. 		fORMRelated::reflect($class, $signatures, $include_doc_comments);

    2073. 

  2073. 		

    2074. 

  2074. 		fORM::callReflectCallbacks($class, $signatures, $include_doc_comments);

    2075. 

  2075. 		

    2076. 

  2076. 		$reflection = new ReflectionClass($class);

    2077. 

  2077. 		$methods    = $reflection->getMethods();

    2078. 

  2078. 		

    2079. 

  2079. 		foreach ($methods as $method) {

    2080. 

  2080. 			$signature = '';

    2081. 

  2081. 			

    2082. 

  2082. 			if (!$method->isPublic() || $method->getName() == '__call') {

    2083. 

  2083. 				continue;

    2084. 

  2084. 			}

    2085. 

  2085. 			

    2086. 

  2086. 			if ($method->isFinal()) {

    2087. 

  2087. 				$signature .= 'final ';

    2088. 

  2088. 			}

    2089. 

  2089. 			

    2090. 

  2090. 			if ($method->isAbstract()) {

    2091. 

  2091. 				$signature .= 'abstract ';

    2092. 

  2092. 			}

    2093. 

  2093. 			

    2094. 

  2094. 			if ($method->isStatic()) {

    2095. 

  2095. 				$signature .= 'static ';

    2096. 

  2096. 			}

    2097. 

  2097. 			

    2098. 

  2098. 			$signature .= 'public function ';

    2099. 

  2099. 			

    2100. 

  2100. 			if ($method->returnsReference()) {

    2101. 

  2101. 				$signature .= '&';

    2102. 

  2102. 			}

    2103. 

  2103. 			

    2104. 

  2104. 			$signature .= $method->getName();

    2105. 

  2105. 			$signature .= '(';

    2106. 

  2106. 			

    2107. 

  2107. 			$parameters = $method->getParameters();

    2108. 

  2108. 			foreach ($parameters as $parameter) {

    2109. 

  2109. 				if (substr($signature, -1) == '(') {

    2110. 

  2110. 					$signature .= '';

    2111. 

  2111. 				} else {

    2112. 

  2112. 					$signature .= ', ';

    2113. 

  2113. 				}

    2114. 

  2114. 				

    2115. 

  2115. 				if ($parameter->isArray()) {

    2116. 

  2116. 					$signature .= 'array ';	

    2117. 

  2117. 				}

    2118. 

  2118. 				if ($parameter->getClass()) {

    2119. 

  2119. 					$signature .= $parameter->getClass()->getName() . ' ';	

    2120. 

  2120. 				}

    2121. 

  2121. 				if ($parameter->isPassedByReference()) {

    2122. 

  2122. 					$signature .= '&';	

    2123. 

  2123. 				}

    2124. 

  2124. 				$signature .= '$' . $parameter->getName();

    2125. 

  2125. 				

    2126. 

  2126. 				if ($parameter->isDefaultValueAvailable()) {

    2127. 

  2127. 					$val = var_export($parameter->getDefaultValue(), TRUE);

    2128. 

  2128. 					if ($val == 'true') {

    2129. 

  2129. 						$val = 'TRUE';

    2130. 

  2130. 					}

    2131. 

  2131. 					if ($val == 'false') {

    2132. 

  2132. 						$val = 'FALSE';

    2133. 

  2133. 					}

    2134. 

  2134. 					if (is_array($parameter->getDefaultValue())) {

    2135. 

  2135. 						$val = preg_replace('#array\s+\(\s+#', 'array(', $val);

    2136. 

  2136. 						$val = preg_replace('#,(\r)?\n  #', ', ', $val);

    2137. 

  2137. 						$val = preg_replace('#,(\r)?\n\)#', ')', $val);

    2138. 

  2138. 					}

    2139. 

  2139. 					$signature .= '=' . $val;

    2140. 

  2140. 				}

    2141. 

  2141. 			}

    2142. 

  2142. 			

    2143. 

  2143. 			$signature .= ')';

    2144. 

  2144. 			

    2145. 

  2145. 			if ($include_doc_comments) {

    2146. 

  2146. 				$comment = $method->getDocComment();

    2147. 

  2147. 				$comment = preg_replace('#^\t+#m', '', $comment);

    2148. 

  2148. 				$signature = $comment . "\n" . $signature;

    2149. 

  2149. 			}

    2150. 

  2150. 			$signatures[$method->getName()] = $signature;

    2151. 

  2151. 		}

    2152. 

  2152. 		

    2153. 

  2153. 		ksort($signatures);

    2154. 

  2154. 		

    2155. 

  2155. 		return join("\n\n", $signatures);

    2156. 

  2156. 	}

    2157. 

  2157. 	

    2158. 

  2158. 	

    2159. 

  2159. 	/**

    2160. 

  2160. 	 * Generates a clone of the current record, removing any auto incremented primary key value and allowing for replicating related records

    2161. 

  2161. 	 * 

    2162. 

  2162. 	 * This method will accept three different sets of parameters:

    2163. 

  2163. 	 * 

    2164. 

  2164. 	 *  - No parameters: this object will be cloned

    2165. 

  2165. 	 *  - A single `TRUE` value: this object plus all many-to-many associations and all child records (recursively) will be cloned

    2166. 

  2166. 	 *  - Any number of plural related record class names: the many-to-many associations or child records that correspond to the classes specified will be cloned

    2167. 

  2167. 	 * 

    2168. 

  2168. 	 * The class names specified can be a simple class name if there is only a

    2169. 

  2169. 	 * single route between the two corresponding database tables. If there is 

    2170. 

  2170. 	 * more than one route between the two tables, the class name should be

    2171. 

  2171. 	 * substituted with a string in the format `'RelatedClass{route}'`.

    2172. 

  2172. 	 * 

    2173. 

  2173. 	 * @param  string $related_class  The plural related class to replicate - see method description for details

    2174. 

  2174. 	 * @param  string ...

    2175. 

  2175. 	 * @return fActiveRecord  The cloned record

    2176. 

  2176. 	 */

    2177. 

  2177. 	public function replicate($related_class=NULL)

    2178. 

  2178. 	{

    2179. 

  2179. 		fActiveRecord::$replicate_level++;

    2180. 

  2180. 		

    2181. 

  2181. 		$class = get_class($this);

    2182. 

  2182. 		$hash  = self::hash($this->values, $class);

    2183. 

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

    2184. 

  2184. 			

    2185. 

  2185. 		// If the object has not been replicated yet, do it now

    2186. 

  2186. 		if (!isset(fActiveRecord::$replicate_map[$class])) {

    2187. 

  2187. 			fActiveRecord::$replicate_map[$class] = array();

    2188. 

  2188. 		}

    2189. 

  2189. 		if (!isset(fActiveRecord::$replicate_map[$class][$hash])) {

    2190. 

  2190. 			fActiveRecord::$replicate_map[$class][$hash] = clone $this;

    2191. 

  2191. 			

    2192. 

  2192. 			// We need the primary key to get a hash, otherwise certain recursive relationships end up losing members

    2193. 

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

    2194. 

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

    2195. 

  2195. 				fActiveRecord::$replicate_map[$class][$hash]->values[$pk_columns[0]] = $this->values[$pk_columns[0]];

    2196. 

  2196. 			}

    2197. 

  2197. 			

    2198. 

  2198. 		}

    2199. 

  2199. 		$clone = fActiveRecord::$replicate_map[$class][$hash];

    2200. 

  2200. 		

    2201. 

  2201. 		$parameters = func_get_args();

    2202. 

  2202. 		

    2203. 

  2203. 		$recursive                  = FALSE;

    2204. 

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

    2205. 

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

    2206. 

  2206. 		

    2207. 

  2207. 		

    2208. 

  2208. 		// When just TRUE is passed we recursively replicate all related records

    2209. 

  2209. 		if (sizeof($parameters) == 1 && $parameters[0] === TRUE) {

    2210. 

  2210. 			$parameters = array();

    2211. 

  2211. 			$recursive  = TRUE;

    2212. 

  2212. 			

    2213. 

  2213. 			foreach ($many_to_many_relationships as $relationship) {

    2214. 

  2214. 				$parameters[] = fGrammar::pluralize(fORM::classize($relationship['related_table'])) . '{' . $relationship['join_table'] . '}'; 		

    2215. 

  2215. 			}

    2216. 

  2216. 			foreach ($one_to_many_relationships as $relationship) {

    2217. 

  2217. 				$parameters[] = fGrammar::pluralize(fORM::classize($relationship['related_table'])) . '{' . $relationship['related_column'] . '}'; 		

    2218. 

  2218. 			}			

    2219. 

  2219. 		}

    2220. 

  2220. 		

    2221. 

  2221. 		$record_sets = array();

    2222. 

  2222. 		

    2223. 

  2223. 		foreach ($parameters as $parameter) {

    2224. 

  2224. 			

    2225. 

  2225. 			// Parse the Class{route} strings

    2226. 

  2226. 			if (strpos($parameter, '{') !== FALSE) {

    2227. 

  2227. 				$brace         = strpos($parameter, '{');

    2228. 

  2228. 				$related_class = fGrammar::singularize(substr($parameter, 0, $brace));

    2229. 

  2229. 				$related_table = fORM::tablize($related_class);

    2230. 

  2230. 				$route         = substr($parameter, $brace+1, -1);

    2231. 

  2231. 			} else {

    2232. 

  2232. 				$related_class = fGrammar::singularize($parameter);

    2233. 

  2233. 				$related_table = fORM::tablize($related_class);

    2234. 

  2234. 				$route         = fORMSchema::getRouteName($table, $related_table);

    2235. 

  2235. 			}

    2236. 

  2236. 			

    2237. 

  2237. 			// Determine the kind of relationship

    2238. 

  2238. 			$many_to_many = FALSE;

    2239. 

  2239. 			$one_to_many  = FALSE;

    2240. 

  2240. 			

    2241. 

  2241. 			foreach ($many_to_many_relationships as $relationship) {

    2242. 

  2242. 				if ($relationship['related_table'] == $related_table && $relationship['join_table'] == $route) {

    2243. 

  2243. 					$many_to_many = TRUE;	

    2244. 

  2244. 					break;

    2245. 

  2245. 				}

    2246. 

  2246. 			}

    2247. 

  2247. 			

    2248. 

  2248. 			foreach ($one_to_many_relationships as $relationship) {

    2249. 

  2249. 				if ($relationship['related_table'] == $related_table && $relationship['related_column'] == $route) {

    2250. 

  2250. 					$one_to_many = TRUE;

    2251. 

  2251. 					break;

    2252. 

  2252. 				}	

    2253. 

  2253. 			}

    2254. 

  2254. 			

    2255. 

  2255. 			if (!$many_to_many && !$one_to_many) {

    2256. 

  2256. 				throw new fProgrammerException(

    2257. 

  2257. 					'The related class specified, %1$s, does not appear to be in a many-to-many or one-to-many relationship with %$2s',

    2258. 

  2258. 					$parameter,

    2259. 

  2259. 					get_class($this)

    2260. 

  2260. 				);	

    2261. 

  2261. 			}

    2262. 

  2262. 			

    2263. 

  2263. 			// Get the related records

    2264. 

  2264. 			$record_set = fORMRelated::buildRecords($class, $this->values, $this->related_records, $related_class, $route);

    2265. 

  2265. 			

    2266. 

  2266. 			// One-to-many records need to be replicated, possibly recursively

    2267. 

  2267. 			if ($one_to_many) {

    2268. 

  2268. 				if ($recursive) {

    2269. 

  2269. 					$records = $record_set->call('replicate', TRUE);

    2270. 

  2270. 				} else {

    2271. 

  2271. 					$records = $record_set->call('replicate');

    2272. 

  2272. 				}

    2273. 

  2273. 				$record_set = fRecordSet::buildFromArray($related_class, $records);

    2274. 

  2274. 				$record_set->call(

    2275. 

  2275. 					'set' . fGrammar::camelize($route, TRUE),

    2276. 

  2276. 					NULL

    2277. 

  2277. 				);	

    2278. 

  2278. 			}

    2279. 

  2279. 			

    2280. 

  2280. 			// Cause the related records to be associated with the new clone

    2281. 

  2281. 			fORMRelated::associateRecords($class, $clone->related_records, $related_class, $record_set, $route);

    2282. 

  2282. 		}

    2283. 

  2283. 		

    2284. 

  2284. 		fActiveRecord::$replicate_level--;

    2285. 

  2285. 		if (!fActiveRecord::$replicate_level) {

    2286. 

  2286. 			// This removes the primary keys we had added back in for proper duplicate detection

    2287. 

  2287. 			foreach (fActiveRecord::$replicate_map as $class => $records) {

    2288. 

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

    2289. 

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

    2290. 

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

    2291. 

  2291. 					continue;

    2292. 

  2292. 				}

    2293. 

  2293. 				foreach ($records as $hash => $record) {

    2294. 

  2294. 					$record->values[$pk_columns[0]] = NULL;		

    2295. 

  2295. 				}	

    2296. 

  2296. 			}

    2297. 

  2297. 			fActiveRecord::$replicate_map = array();	

    2298. 

  2298. 		}

    2299. 

  2299. 		

    2300. 

  2300. 		return $clone;

    2301. 

  2301. 	}

    2302. 

  2302. 	

    2303. 

  2303. 	

    2304. 

  2304. 	/**

    2305. 

  2305. 	 * Sets a value to the record

    2306. 

  2306. 	 * 

    2307. 

  2307. 	 * @param  string $column  The column to set the value to

    2308. 

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

    2309. 

  2309. 	 * @return fActiveRecord  This record, to allow for method chaining

    2310. 

  2310. 	 */

    2311. 

  2311. 	protected function set($column, $value)

    2312. 

  2312. 	{

    2313. 

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

    2314. 

  2314. 			throw new fProgrammerException(

    2315. 

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

    2316. 

  2316. 				$column

    2317. 

  2317. 			);

    2318. 

  2318. 		}

    2319. 

  2319. 		

    2320. 

  2320. 		// We consider an empty string to be equivalent to NULL

    2321. 

  2321. 		if ($value === '') {

    2322. 

  2322. 			$value = NULL;

    2323. 

  2323. 		}

    2324. 

  2324. 		

    2325. 

  2325. 		$class = get_class($this);

    2326. 

  2326. 		$value = fORM::objectify($class, $column, $value);

    2327. 

  2327. 		

    2328. 

  2328. 		// Float and int columns that look like numbers with commas will have the commas removed

    2329. 

  2329. 		if (is_string($value)) {

    2330. 

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

    2331. 

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

    2332. 

  2332. 			if (in_array($type, array('integer', 'float')) && preg_match('#^(\d+,)+\d+(\.\d+)?$#', $value)) {

    2333. 

  2333. 				$value = str_replace(',', '', $value);

    2334. 

  2334. 			}

    2335. 

  2335. 		}

    2336. 

  2336. 		

    2337. 

  2337. 		self::assign($this->values, $this->old_values, $column, $value);

    2338. 

  2338. 		

    2339. 

  2339. 		return $this;

    2340. 

  2340. 	}

    2341. 

  2341. 	

    2342. 

  2342. 	

    2343. 

  2343. 	/**

    2344. 

  2344. 	 * Stores a record in the database, whether existing or new

    2345. 

  2345. 	 * 

    2346. 

  2346. 	 * This method will start database and filesystem transactions if they have

    2347. 

  2347. 	 * not already been started.

    2348. 

  2348. 	 * 

    2349. 

  2349. 	 * @throws fValidationException  When ::validate() throws an exception

    2350. 

  2350. 	 * 

    2351. 

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

    2352. 

  2352. 	 */

    2353. 

  2353. 	public function store()

    2354. 

  2354. 	{

    2355. 

  2355. 		$class = get_class($this);

    2356. 

  2356. 		

    2357. 

  2357. 		if (fORM::getActiveRecordMethod($class, 'store')) {

    2358. 

  2358. 			return $this->__call('store', array());

    2359. 

  2359. 		}

    2360. 

  2360. 		

    2361. 

  2361. 		fORM::callHookCallbacks(

    2362. 

  2362. 			$this,

    2363. 

  2363. 			'pre::store()',

    2364. 

  2364. 			$this->values,

    2365. 

  2365. 			$this->old_values,

    2366. 

  2366. 			$this->related_records,

    2367. 

  2367. 			$this->cache

    2368. 

  2368. 		);

    2369. 

  2369. 		

    2370. 

  2370. 		try {

    2371. 

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

    2372. 

  2372. 			$column_info = fORMSchema::retrieve()->getColumnInfo($table);

    2373. 

  2373. 			

    2374. 

  2374. 			// New auto-incrementing records require lots of special stuff, so we'll detect them here

    2375. 

  2375. 			$new_autoincrementing_record = FALSE;

    2376. 

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

    2377. 

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

    2378. 

  2378. 				

    2379. 

  2379. 				if (sizeof($pk_columns) == 1 && $column_info[$pk_columns[0]]['auto_increment'] && !$this->values[$pk_columns[0]]) {

    2380. 

  2380. 					$new_autoincrementing_record = TRUE;

    2381. 

  2381. 					$pk_column = $pk_columns[0];

    2382. 

  2382. 				}

    2383. 

  2383. 			}

    2384. 

  2384. 			

    2385. 

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

    2386. 

  2386. 			

    2387. 

  2387. 			if (!$inside_db_transaction) {

    2388. 

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

    2389. 

  2389. 			}

    2390. 

  2390. 			

    2391. 

  2391. 			fORM::callHookCallbacks(

    2392. 

  2392. 				$this,

    2393. 

  2393. 				'post-begin::store()',

    2394. 

  2394. 				$this->values,

    2395. 

  2395. 				$this->old_values,

    2396. 

  2396. 				$this->related_records,

    2397. 

  2397. 				$this->cache

    2398. 

  2398. 			);

    2399. 

  2399. 			

    2400. 

  2400. 			$this->validate();

    2401. 

  2401. 			

    2402. 

  2402. 			fORM::callHookCallbacks(

    2403. 

  2403. 				$this,

    2404. 

  2404. 				'post-validate::store()',

    2405. 

  2405. 				$this->values,

    2406. 

  2406. 				$this->old_values,

    2407. 

  2407. 				$this->related_records,

    2408. 

  2408. 				$this->cache

    2409. 

  2409. 			);

    2410. 

  2410. 			

    2411. 

  2411. 			// Storing main table

    2412. 

  2412. 			

    2413. 

  2413. 			$sql_values = array();

    2414. 

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

    2415. 

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

    2416. 

  2416. 				$sql_values[$column] = fORMDatabase::escapeBySchema($table, $column, $value);

    2417. 

  2417. 			}

    2418. 

  2418. 			

    2419. 

  2419. 			// Most databases don't like the auto incrementing primary key to be set to NULL

    2420. 

  2420. 			if ($new_autoincrementing_record && $sql_values[$pk_column] == 'NULL') {

    2421. 

  2421. 				unset($sql_values[$pk_column]);

    2422. 

  2422. 			}

    2423. 

  2423. 			

    2424. 

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

    2425. 

  2425. 				$sql = $this->constructInsertSQL($sql_values);

    2426. 

  2426. 			} else {

    2427. 

  2427. 				$sql = $this->constructUpdateSQL($sql_values);

    2428. 

  2428. 			}

    2429. 

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

    2430. 

  2430. 			

    2431. 

  2431. 			

    2432. 

  2432. 			// If there is an auto-incrementing primary key, grab the value from the database

    2433. 

  2433. 			if ($new_autoincrementing_record) {

    2434. 

  2434. 				$this->set($pk_column, $result->getAutoIncrementedValue());

    2435. 

  2435. 			}

    2436. 

  2436. 			

    2437. 

  2437. 			

    2438. 

  2438. 			// Storing *-to-many relationships

    2439. 

  2439. 			fORMRelated::store($class, $this->values, $this->related_records);

    2440. 

  2440. 			

    2441. 

  2441. 			

    2442. 

  2442. 			fORM::callHookCallbacks(

    2443. 

  2443. 				$this,

    2444. 

  2444. 				'pre-commit::store()',

    2445. 

  2445. 				$this->values,

    2446. 

  2446. 				$this->old_values,

    2447. 

  2447. 				$this->related_records,

    2448. 

  2448. 				$this->cache

    2449. 

  2449. 			);

    2450. 

  2450. 			

    2451. 

  2451. 			if (!$inside_db_transaction) {

    2452. 

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

    2453. 

  2453. 			}

    2454. 

  2454. 			

    2455. 

  2455. 			fORM::callHookCallbacks(

    2456. 

  2456. 				$this,

    2457. 

  2457. 				'post-commit::store()',

    2458. 

  2458. 				$this->values,

    2459. 

  2459. 				$this->old_values,

    2460. 

  2460. 				$this->related_records,

    2461. 

  2461. 				$this->cache

    2462. 

  2462. 			);

    2463. 

  2463. 			

    2464. 

  2464. 		} catch (fException $e) {

    2465. 

  2465. 			

    2466. 

  2466. 			if (!$inside_db_transaction) {

    2467. 

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

    2468. 

  2468. 			}

    2469. 

  2469. 			

    2470. 

  2470. 			fORM::callHookCallbacks(

    2471. 

  2471. 				$this,

    2472. 

  2472. 				'post-rollback::store()',

    2473. 

  2473. 				$this->values,

    2474. 

  2474. 				$this->old_values,

    2475. 

  2475. 				$this->related_records,

    2476. 

  2476. 				$this->cache

    2477. 

  2477. 			);

    2478. 

  2478. 			

    2479. 

  2479. 			if ($new_autoincrementing_record && self::hasOld($this->old_values, $pk_column)) {

    2480. 

  2480. 				$this->values[$pk_column] = self::retrieveOld($this->old_values, $pk_column);

    2481. 

  2481. 				unset($this->old_values[$pk_column]);

    2482. 

  2482. 			}

    2483. 

  2483. 			

    2484. 

  2484. 			throw $e;

    2485. 

  2485. 		}

    2486. 

  2486. 		

    2487. 

  2487. 		fORM::callHookCallbacks(

    2488. 

  2488. 			$this,

    2489. 

  2489. 			'post::store()',

    2490. 

  2490. 			$this->values,

    2491. 

  2491. 			$this->old_values,

    2492. 

  2492. 			$this->related_records,

    2493. 

  2493. 			$this->cache

    2494. 

  2494. 		);

    2495. 

  2495. 		

    2496. 

  2496. 		$was_new = !$this->exists();

    2497. 

  2497. 		

    2498. 

  2498. 		// If we got here we succefully stored, so update old values to make exists() work

    2499. 

  2499. 		foreach ($this->values as $column => $value) {

    2500. 

  2500. 			$this->old_values[$column] = array($value);

    2501. 

  2501. 		}

    2502. 

  2502. 		

    2503. 

  2503. 		// If the object was just inserted into the database, save it to the identity map

    2504. 

  2504. 		if ($was_new) {

    2505. 

  2505. 			$hash = self::hash($this->values, $class);

    2506. 

  2506. 			

    2507. 

  2507. 			if (!isset(self::$identity_map[$class])) {

    2508. 

  2508. 				self::$identity_map[$class] = array(); 		

    2509. 

  2509. 			}

    2510. 

  2510. 			self::$identity_map[$class][$hash] = $this;		

    2511. 

  2511. 		}

    2512. 

  2512. 		

    2513. 

  2513. 		return $this;

    2514. 

  2514. 	}

    2515. 

  2515. 	

    2516. 

  2516. 	

    2517. 

  2517. 	/**

    2518. 

  2518. 	 * Validates the values of the record against the database and any additional validation rules

    2519. 

  2519. 	 * 

    2520. 

  2520. 	 * @throws fValidationException  When the record, or one of the associated records, violates one of the validation rules for the class or can not be properly stored in the database

    2521. 

  2521. 	 * 

    2522. 

  2522. 	 * @param  boolean $return_messages  If an array of validation messages should be returned instead of an exception being thrown

    2523. 

  2523. 	 * @return void|array  If $return_messages is TRUE, an array of validation messages will be returned

    2524. 

  2524. 	 */

    2525. 

  2525. 	public function validate($return_messages=FALSE)

    2526. 

  2526. 	{

    2527. 

  2527. 		$class = get_class($this);

    2528. 

  2528. 		

    2529. 

  2529. 		if (fORM::getActiveRecordMethod($class, 'validate')) {

    2530. 

  2530. 			return $this->__call('validate', array($return_messages));

    2531. 

  2531. 		}

    2532. 

  2532. 		

    2533. 

  2533. 		$validation_messages = array();

    2534. 

  2534. 		

    2535. 

  2535. 		fORM::callHookCallbacks(

    2536. 

  2536. 			$this,

    2537. 

  2537. 			'pre::validate()',

    2538. 

  2538. 			$this->values,

    2539. 

  2539. 			$this->old_values,

    2540. 

  2540. 			$this->related_records,

    2541. 

  2541. 			$this->cache,

    2542. 

  2542. 			$validation_messages

    2543. 

  2543. 		);

    2544. 

  2544. 		

    2545. 

  2545. 		// Validate the local values

    2546. 

  2546. 		$local_validation_messages = fORMValidation::validate($this, $this->values, $this->old_values);

    2547. 

  2547. 		

    2548. 

  2548. 		// Validate related records

    2549. 

  2549. 		$related_validation_messages = fORMValidation::validateRelated($this, $this->values, $this->related_records);

    2550. 

  2550. 		

    2551. 

  2551. 		$validation_messages = array_merge($validation_messages, $local_validation_messages, $related_validation_messages);

    2552. 

  2552. 		

    2553. 

  2553. 		fORM::callHookCallbacks(

    2554. 

  2554. 			$this,

    2555. 

  2555. 			'post::validate()',

    2556. 

  2556. 			$this->values,

    2557. 

  2557. 			$this->old_values,

    2558. 

  2558. 			$this->related_records,

    2559. 

  2559. 			$this->cache,

    2560. 

  2560. 			$validation_messages

    2561. 

  2561. 		);

    2562. 

  2562. 		

    2563. 

  2563. 		$validation_messages = array_unique($validation_messages);

    2564. 

  2564. 		

    2565. 

  2565. 		$validation_messages = fORMValidation::replaceMessages($class, $validation_messages);

    2566. 

  2566. 		$validation_messages = fORMValidation::reorderMessages($class, $validation_messages);

    2567. 

  2567. 		

    2568. 

  2568. 		if ($return_messages) {

    2569. 

  2569. 			return $validation_messages;

    2570. 

  2570. 		}

    2571. 

  2571. 		

    2572. 

  2572. 		if (!empty($validation_messages)) {

    2573. 

  2573. 			throw new fValidationException(

    2574. 

  2574. 				'The following problems were found:',

    2575. 

  2575. 				$validation_messages

    2576. 

  2576. 			);

    2577. 

  2577. 		}

    2578. 

  2578. 	}

    2579. 

  2579. }

    2580. 

  2580. 

    2581. 

  2581. 

    2582. 

  2582. 

    2583. 

  2583. /**

    2584. 

  2584.  * Copyright (c) 2007-2009 Will Bond <will@flourishlib.com>, others

    2585. 

  2585.  * 

    2586. 

  2586.  * Permission is hereby granted, free of charge, to any person obtaining a copy

    2587. 

  2587.  * of this software and associated documentation files (the "Software"), to deal

    2588. 

  2588.  * in the Software without restriction, including without limitation the rights

    2589. 

  2589.  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

    2590. 

  2590.  * copies of the Software, and to permit persons to whom the Software is

    2591. 

  2591.  * furnished to do so, subject to the following conditions:

    2592. 

  2592.  * 

    2593. 

  2593.  * The above copyright notice and this permission notice shall be included in

    2594. 

  2594.  * all copies or substantial portions of the Software.

    2595. 

  2595.  * 

    2596. 

  2596.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

    2597. 

  2597.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

    2598. 

  2598.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

    2599. 

  2599.  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

    2600. 

  2600.  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

    2601. 

  2601.  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

    2602. 

  2602.  * THE SOFTWARE.

    2603. 

  2603.  */
    2604.