1
|
|
|
<?php defined('SYSPATH') OR die('No direct script access.'); |
2
|
|
|
/** |
3
|
|
|
* Jam Model |
4
|
|
|
* |
5
|
|
|
* Jam_Model is the class all models must extend. It handles |
6
|
|
|
* various CRUD operations and relationships to other models. |
7
|
|
|
* |
8
|
|
|
* @package Jam |
9
|
|
|
* @category Models |
10
|
|
|
* @author Ivan Kerin |
11
|
|
|
* @copyright (c) 2011-2012 Despark Ltd. |
12
|
|
|
* @license http://www.opensource.org/licenses/isc-license.txt |
13
|
|
|
*/ |
14
|
|
|
abstract class Kohana_Jam_Validated extends Model implements Serializable { |
15
|
|
|
|
16
|
|
|
/** |
17
|
|
|
* @var array The original data set on the object |
18
|
|
|
*/ |
19
|
|
|
protected $_original = array(); |
20
|
|
|
|
21
|
|
|
/** |
22
|
|
|
* @var array Data that's changed since the object was loaded |
23
|
|
|
*/ |
24
|
|
|
protected $_changed = array(); |
25
|
|
|
|
26
|
|
|
/** |
27
|
|
|
* @var array Data that's already been retrieved is cached |
28
|
|
|
*/ |
29
|
|
|
protected $_retrieved = array(); |
30
|
|
|
|
31
|
|
|
/** |
32
|
|
|
* @var array Unmapped data that is still accessible |
33
|
|
|
*/ |
34
|
|
|
protected $_unmapped = array(); |
35
|
|
|
|
36
|
|
|
/** |
37
|
|
|
* @var boolean Whether or not the model is validating |
38
|
|
|
*/ |
39
|
|
|
protected $_is_validating = FALSE; |
40
|
|
|
|
41
|
|
|
/** |
42
|
|
|
* @var Jam_Meta A copy of this object's meta object |
43
|
|
|
*/ |
44
|
|
|
protected $_meta = NULL; |
45
|
|
|
|
46
|
|
|
/** |
47
|
|
|
* @var Boolean A flag that keeps track of whether or not the model is valid |
48
|
|
|
*/ |
49
|
|
|
protected $_errors = NULL; |
50
|
|
|
|
51
|
|
|
/** |
52
|
|
|
* Constructor. |
53
|
|
|
* |
54
|
|
|
* A key can be passed to automatically load a model by its |
55
|
|
|
* unique key. |
56
|
|
|
* |
57
|
|
|
* @param mixed|null $key |
|
|
|
|
58
|
|
|
*/ |
59
|
437 |
|
public function __construct($meta_name = NULL) |
60
|
|
|
{ |
61
|
437 |
|
if ($meta_name === NULL) |
62
|
|
|
{ |
63
|
432 |
|
$meta_name = $this; |
64
|
|
|
} |
65
|
|
|
|
66
|
|
|
// Load the object's meta data for quick access |
67
|
437 |
|
$this->_meta = Jam::meta($meta_name); |
68
|
|
|
|
69
|
437 |
|
$this->_original = $this->meta()->defaults(); |
|
|
|
|
70
|
437 |
|
} |
71
|
|
|
|
72
|
|
|
/** |
73
|
|
|
* Gets the value of a field. |
74
|
|
|
* |
75
|
|
|
* Unlike Jam_Model::get(), values that are returned are cached |
76
|
|
|
* until they are changed and relationships are automatically select()ed. |
77
|
|
|
* |
78
|
|
|
* @see get() |
79
|
|
|
* @param string $name The name or alias of the field you're retrieving |
80
|
|
|
* @return mixed |
81
|
|
|
*/ |
82
|
147 |
|
public function &__get($name) |
83
|
|
|
{ |
84
|
147 |
|
if ( ! array_key_exists($name, $this->_retrieved)) |
85
|
|
|
{ |
86
|
145 |
|
$this->_retrieved[$name] = $this->get($name); |
87
|
|
|
} |
88
|
|
|
|
89
|
147 |
|
return $this->_retrieved[$name]; |
90
|
|
|
} |
91
|
|
|
|
92
|
|
|
/** |
93
|
|
|
* Sets the value of a field. |
94
|
|
|
* |
95
|
|
|
* @see set() |
96
|
|
|
* @param string $name The name of the field you're setting |
97
|
|
|
* @param mixed $value The value you're setting |
98
|
|
|
* @return void |
99
|
|
|
*/ |
100
|
78 |
|
public function __set($name, $value) |
101
|
|
|
{ |
102
|
|
|
// Being set by mysql_fetch_object, store the values for the constructor |
103
|
78 |
|
if (empty($this->_original)) |
104
|
|
|
{ |
105
|
|
|
$this->_preload_data[$name] = $value; |
|
|
|
|
106
|
|
|
return; |
107
|
|
|
} |
108
|
|
|
|
109
|
78 |
|
$this->set($name, $value); |
110
|
78 |
|
} |
111
|
|
|
|
112
|
|
|
/** |
113
|
|
|
* Passes unknown methods along to the behaviors. |
114
|
|
|
* |
115
|
|
|
* @param string $method |
116
|
|
|
* @param array $args |
117
|
|
|
* @return mixed |
118
|
|
|
**/ |
119
|
34 |
|
public function __call($method, $args) |
120
|
|
|
{ |
121
|
34 |
|
return $this->meta()->events()->trigger_callback('model', $this, $method, $args); |
122
|
|
|
} |
123
|
|
|
|
124
|
|
|
/** |
125
|
|
|
* Returns true if $name is a field of the model or an unmapped column. |
126
|
|
|
* |
127
|
|
|
* This does not conform to the standard of returning FALSE if the |
128
|
|
|
* property is set but the value is NULL. Rather this acts more like |
129
|
|
|
* property_exists. |
130
|
|
|
* |
131
|
|
|
* @param string $name |
132
|
|
|
* @return boolean |
133
|
|
|
*/ |
134
|
|
|
public function __isset($name) |
135
|
|
|
{ |
136
|
|
|
return (bool) ($this->meta()->field($name) OR array_key_exists($name, $this->_unmapped)); |
137
|
|
|
} |
138
|
|
|
|
139
|
|
|
/** |
140
|
|
|
* This doesn't unset fields. Rather, it sets them to their original |
141
|
|
|
* value. Unmapped, changed, and retrieved values are unset. |
142
|
|
|
* |
143
|
|
|
* In essence, unsetting a field sets it as if you never made any changes |
144
|
|
|
* to it, and clears the cache if the value has been retrieved with those changes. |
145
|
|
|
* |
146
|
|
|
* @param string $name |
147
|
|
|
* @return void |
148
|
|
|
*/ |
149
|
|
|
public function __unset($name) |
150
|
|
|
{ |
151
|
|
|
unset($this->_changed[$name]); |
152
|
|
|
unset($this->_retrieved[$name]); |
153
|
|
|
|
154
|
|
|
// We can safely delete this no matter what |
155
|
|
|
unset($this->_unmapped[$name]); |
156
|
|
|
} |
157
|
|
|
|
158
|
|
|
/** |
159
|
|
|
* Returns a string representation of the model in the |
160
|
|
|
* form of `Model_Name (id)` or `Model_Name (NULL)` if |
161
|
|
|
* the model is not loaded. |
162
|
|
|
* |
163
|
|
|
* This is designed to be useful for debugging. |
164
|
|
|
* |
165
|
|
|
* @return string |
166
|
|
|
*/ |
167
|
|
|
public function __toString() |
168
|
|
|
{ |
169
|
|
|
return (string) get_class($this).'('.($this->is_valid() ? 'Valid' : 'Not Valid').')'; |
170
|
|
|
} |
171
|
|
|
|
172
|
|
|
/** |
173
|
|
|
* Gets the value for a field. |
174
|
|
|
* |
175
|
|
|
* @param string $name The field's name |
176
|
|
|
* @return array|mixed |
177
|
|
|
*/ |
178
|
216 |
|
public function get($name) |
179
|
|
|
{ |
180
|
216 |
|
if ($field = $this->_meta->field($name)) |
181
|
|
|
{ |
182
|
|
|
// Alias the name to its actual name |
183
|
205 |
|
$name = $field->name; |
184
|
|
|
|
185
|
205 |
|
if (array_key_exists($name, $this->_changed)) |
186
|
|
|
{ |
187
|
46 |
|
return $field->get($this, $this->_changed[$name], TRUE); |
|
|
|
|
188
|
|
|
} |
189
|
|
|
else |
190
|
|
|
{ |
191
|
205 |
|
return $this->original($name); |
192
|
|
|
} |
193
|
|
|
} |
194
|
|
|
// Return unmapped data from custom queries |
195
|
25 |
|
elseif ($this->unmapped($name)) |
196
|
|
|
{ |
197
|
23 |
|
return $this->_unmapped[$name]; |
198
|
|
|
} |
199
|
10 |
|
} |
200
|
|
|
|
201
|
|
|
/** |
202
|
|
|
* Returns the original value of a field, before it was changed. |
203
|
|
|
* |
204
|
|
|
* This method—combined with get(), which first searches for changed |
205
|
|
|
* values—is useful for comparing changes that occurred on a model. |
206
|
|
|
* |
207
|
|
|
* @param string $field The field's or alias name |
|
|
|
|
208
|
|
|
* @return mixed |
209
|
|
|
*/ |
210
|
208 |
|
public function original($field_name = NULL) |
211
|
|
|
{ |
212
|
208 |
|
if ($field_name === NULL) |
213
|
|
|
return $this->_original; |
214
|
|
|
|
215
|
208 |
|
if ($field = $this->_meta->field($field_name)) |
216
|
|
|
{ |
217
|
208 |
|
return $field->get($this, $this->_original[$field_name], FALSE); |
|
|
|
|
218
|
|
|
} |
219
|
|
|
} |
220
|
|
|
|
221
|
|
|
/** |
222
|
|
|
* Returns an array of values in the fields. |
223
|
|
|
* |
224
|
|
|
* You can pass an array of field names to retrieve |
225
|
|
|
* only the values for those fields: |
226
|
|
|
* |
227
|
|
|
* $model->as_array(array('id', 'name', 'status')); |
228
|
|
|
* |
229
|
|
|
* @param array $fields |
230
|
|
|
* @return array |
231
|
|
|
*/ |
232
|
10 |
|
public function as_array(array $fields = NULL) |
233
|
|
|
{ |
234
|
10 |
|
$fields = $fields ? $fields : array_keys($this->_meta->fields()); |
235
|
10 |
|
$result = array(); |
236
|
|
|
|
237
|
10 |
|
foreach ($fields as $field) |
238
|
|
|
{ |
239
|
10 |
|
$result[$field] = $this->__get($field); |
240
|
|
|
} |
241
|
|
|
|
242
|
10 |
|
return $result; |
243
|
|
|
} |
244
|
|
|
|
245
|
|
|
/** |
246
|
|
|
* Set preloaded values, without changing the save, loaded and changed flags |
247
|
|
|
* @param array|string $values |
248
|
|
|
* @param mixed $value |
249
|
|
|
* @return $this |
250
|
|
|
*/ |
251
|
13 |
|
public function retrieved($values, $value = NULL) |
252
|
|
|
{ |
253
|
|
|
// Accept retrieved('name', 'value'); |
254
|
13 |
|
if ( ! is_array($values)) |
255
|
|
|
{ |
256
|
13 |
|
$values = array($values => $value); |
257
|
|
|
} |
258
|
|
|
|
259
|
13 |
|
$this->_retrieved = Arr::merge($this->_retrieved, $values); |
260
|
|
|
|
261
|
13 |
|
return $this; |
262
|
|
|
} |
263
|
|
|
/** |
264
|
|
|
* Sets the value of a field. |
265
|
|
|
* |
266
|
|
|
* You can pass an array of key => value pairs |
267
|
|
|
* to set multiple fields at the same time: |
268
|
|
|
* |
269
|
|
|
* $model->set(array( |
270
|
|
|
* 'field1' => 'value', |
271
|
|
|
* 'field2' => 'value', |
272
|
|
|
* .... |
273
|
|
|
* )); |
274
|
|
|
* |
275
|
|
|
* @param array|string $values |
276
|
|
|
* @param string $value |
277
|
|
|
* @return $this |
278
|
|
|
*/ |
279
|
94 |
|
public function set($values, $value = NULL) |
280
|
|
|
{ |
281
|
|
|
// Accept set('name', 'value'); |
282
|
94 |
|
if ( ! is_array($values)) |
283
|
|
|
{ |
284
|
|
|
$values = array($values => $value); |
285
|
|
|
} |
286
|
|
|
|
287
|
94 |
|
foreach ($values as $key => & $value) |
288
|
|
|
{ |
289
|
92 |
|
if ($field = $this->meta()->field($key)) |
290
|
|
|
{ |
291
|
79 |
|
if ($value !== $this->{$field->name}) |
292
|
|
|
{ |
293
|
57 |
|
$this->_changed[$field->name] = $field->set($this, $value, TRUE); |
|
|
|
|
294
|
|
|
|
295
|
57 |
|
if (array_key_exists($field->name, $this->_retrieved)) |
296
|
|
|
{ |
297
|
79 |
|
unset($this->_retrieved[$field->name]); |
298
|
|
|
} |
299
|
|
|
} |
300
|
|
|
} |
301
|
35 |
|
elseif (property_exists($this, $key)) |
302
|
|
|
{ |
303
|
1 |
|
$this->$key = $value; |
304
|
|
|
} |
305
|
|
|
else |
306
|
|
|
{ |
307
|
35 |
|
unset($this->_retrieved[$key]); |
308
|
92 |
|
$this->_unmapped[$key] = $value; |
309
|
|
|
} |
310
|
|
|
} |
311
|
|
|
|
312
|
94 |
|
return $this; |
313
|
|
|
} |
314
|
|
|
|
315
|
21 |
|
public function is_valid() |
316
|
|
|
{ |
317
|
21 |
|
return count($this->errors()) == 0; |
318
|
|
|
} |
319
|
|
|
|
320
|
|
|
/** |
321
|
|
|
* Validates the current model's data |
322
|
|
|
* |
323
|
|
|
* @throws Jam_Exception_Validation |
324
|
|
|
* @param Validation|null $extra_validation |
|
|
|
|
325
|
|
|
* @return bool |
326
|
|
|
*/ |
327
|
21 |
|
public function check($force = FALSE) |
328
|
|
|
{ |
329
|
21 |
|
$this->_is_validating = TRUE; |
330
|
|
|
// Run validation only when new or changed |
331
|
21 |
|
if ($this->changed() OR $force) |
332
|
|
|
{ |
333
|
|
|
// Reset the errors before checking |
334
|
21 |
|
$this->_errors = FALSE; |
335
|
|
|
|
336
|
21 |
|
$this->meta()->events()->trigger('model.before_check', $this, array($this->_changed)); |
337
|
|
|
|
338
|
21 |
|
$this->meta()->execute_validators($this, $force); |
|
|
|
|
339
|
|
|
|
340
|
21 |
|
$this->meta()->events()->trigger('model.after_check', $this, array($this->_changed)); |
341
|
|
|
} |
342
|
|
|
|
343
|
21 |
|
$this->_is_validating = FALSE; |
344
|
|
|
|
345
|
21 |
|
return $this->is_valid(); |
346
|
|
|
} |
347
|
|
|
|
348
|
21 |
|
public function check_insist() |
349
|
|
|
{ |
350
|
21 |
|
if ( ! $this->check()) |
351
|
1 |
|
throw new Jam_Exception_Validation('There was an error validating the :model: :errors', $this); |
352
|
|
|
|
353
|
20 |
|
return $this; |
354
|
|
|
} |
355
|
|
|
|
356
|
|
|
/** |
357
|
|
|
* Override this function to add custom validation after the validators. |
358
|
|
|
* Having an empty validate function allow safely calling parent::validate() |
359
|
|
|
* when extending models. |
360
|
|
|
* |
361
|
|
|
* You need to set errors with: |
362
|
|
|
* $this->errors()->add('field', 'error_name'); |
363
|
|
|
* |
364
|
|
|
* @link http://git.io/5I47Tw docs |
365
|
|
|
*/ |
366
|
|
|
public function validate() {} |
367
|
|
|
|
368
|
|
|
/** |
369
|
|
|
* Get the errors from the previous check, if you provide a name, will return the errors only for that name |
370
|
|
|
* Automatically loads the error messages file from messages/jam-validation/<model_name> |
371
|
|
|
* If there are no errors yet - return NULL |
372
|
|
|
* |
373
|
|
|
* @param string $name the name of the field to get errors of |
374
|
|
|
* @return Jam_Errors|string[]|NULL |
375
|
|
|
*/ |
376
|
201 |
|
public function errors($name = NULL) |
377
|
|
|
{ |
378
|
201 |
|
if ( ! $this->_errors) |
379
|
|
|
{ |
380
|
201 |
|
$this->_errors = new Jam_Errors($this, $this->meta()->errors_filename()); |
|
|
|
|
381
|
|
|
} |
382
|
|
|
|
383
|
201 |
|
if ($name !== NULL) |
384
|
3 |
|
return $this->_errors->messages($name); |
385
|
|
|
|
386
|
200 |
|
return $this->_errors; |
|
|
|
|
387
|
|
|
} |
388
|
|
|
|
389
|
|
|
/** |
390
|
|
|
* Removes any changes made to a model. |
391
|
|
|
* |
392
|
|
|
* This method only works on loaded models. |
393
|
|
|
* |
394
|
|
|
* @return $this |
395
|
|
|
*/ |
396
|
|
|
public function revert() |
397
|
|
|
{ |
398
|
|
|
$this->_errors = NULL; |
399
|
|
|
|
400
|
|
|
$this->_changed = |
401
|
|
|
$this->_retrieved = array(); |
402
|
|
|
|
403
|
|
|
return $this; |
404
|
|
|
} |
405
|
|
|
|
406
|
|
|
/** |
407
|
|
|
* Sets a model to its original state, as if freshly instantiated |
408
|
|
|
* |
409
|
|
|
* @return $this |
410
|
|
|
*/ |
411
|
197 |
|
public function clear() |
412
|
|
|
{ |
413
|
197 |
|
$this->_errors = NULL; |
414
|
|
|
|
415
|
197 |
|
$this->_changed = |
416
|
197 |
|
$this->_retrieved = |
417
|
197 |
|
$this->_unmapped = array(); |
418
|
|
|
|
419
|
197 |
|
$this->_original = $this->_meta->defaults(); |
|
|
|
|
420
|
|
|
|
421
|
197 |
|
return $this; |
422
|
|
|
} |
423
|
|
|
|
424
|
|
|
/** |
425
|
|
|
* Whether or not the model is in the process of being validated |
426
|
|
|
* |
427
|
|
|
* @return boolean |
428
|
|
|
*/ |
429
|
7 |
|
public function is_validating() |
430
|
|
|
{ |
431
|
7 |
|
return ($this->_is_validating OR $this->_is_saving); |
|
|
|
|
432
|
|
|
} |
433
|
|
|
|
434
|
|
|
/** |
435
|
|
|
* Returns whether or not the particular $field has changed. |
436
|
|
|
* |
437
|
|
|
* If $field is NULL, the method returns whether or not any |
438
|
|
|
* data whatsoever was changed on the model. |
439
|
|
|
* |
440
|
|
|
* @param string $field |
|
|
|
|
441
|
|
|
* @return boolean |
442
|
|
|
*/ |
443
|
59 |
|
public function changed($name = NULL) |
444
|
|
|
{ |
445
|
59 |
|
if ($name) |
446
|
|
|
{ |
447
|
40 |
|
return array_key_exists($name, $this->_changed); |
448
|
|
|
} |
449
|
|
|
else |
450
|
|
|
{ |
451
|
47 |
|
return (bool) $this->_changed; |
452
|
|
|
} |
453
|
|
|
} |
454
|
|
|
|
455
|
|
|
/** |
456
|
|
|
* Returns the value of the model's primary key |
457
|
|
|
* |
458
|
|
|
* @return mixed |
459
|
|
|
*/ |
460
|
148 |
|
public function id() |
461
|
|
|
{ |
462
|
148 |
|
return $this->get($this->meta()->primary_key()); |
|
|
|
|
463
|
|
|
} |
464
|
|
|
|
465
|
|
|
/** |
466
|
|
|
* Returns the value of the model's name key |
467
|
|
|
* |
468
|
|
|
* @return mixed |
469
|
|
|
*/ |
470
|
18 |
|
public function name() |
471
|
|
|
{ |
472
|
18 |
|
return $this->get($this->meta()->name_key()); |
|
|
|
|
473
|
|
|
} |
474
|
|
|
|
475
|
|
|
/** |
476
|
|
|
* Returns the model's meta object |
477
|
|
|
* |
478
|
|
|
* @return Jam_Meta |
479
|
|
|
*/ |
480
|
752 |
|
public function meta() |
481
|
|
|
{ |
482
|
752 |
|
if ( ! $this->_meta) |
483
|
|
|
throw new Kohana_Exception('Model for class :class does not have a meta', array(':class' => get_class($this))); |
484
|
|
|
|
485
|
752 |
|
return $this->_meta; |
486
|
|
|
} |
487
|
|
|
|
488
|
26 |
|
public function unmapped($name) |
489
|
|
|
{ |
490
|
26 |
|
return array_key_exists($name, $this->_unmapped); |
491
|
|
|
} |
492
|
|
|
|
493
|
|
|
|
494
|
|
|
public function serialize() |
495
|
|
|
{ |
496
|
|
|
return serialize(array( |
497
|
|
|
'original' => $this->_original, |
498
|
|
|
'changed' => $this->_changed, |
499
|
|
|
'unmapped' => $this->_unmapped, |
500
|
|
|
)); |
501
|
|
|
} |
502
|
|
|
|
503
|
|
|
public function unserialize($data) |
504
|
|
|
{ |
505
|
|
|
$data = unserialize($data); |
506
|
|
|
$this->_meta = Jam::meta($this); |
507
|
|
|
$this->_original = $data['original']; |
508
|
|
|
$this->_changed = $data['changed']; |
509
|
|
|
$this->_unmapped = $data['unmapped']; |
510
|
|
|
} |
511
|
|
|
} |
512
|
|
|
|
This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function.
Consider the following example. The parameter
$italy
is not defined by the methodfinale(...)
.The most likely cause is that the parameter was removed, but the annotation was not.