/
Behavior.php
162 lines (154 loc) · 4.63 KB
/
Behavior.php
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
<?php
/**
* CakePHP(tm) : Rapid Development Framework (http://cakephp.org)
* Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
*
* Licensed under The MIT License
* For full copyright and license information, please see the LICENSE.txt
* Redistributions of files must retain the above copyright notice.
*
* @copyright Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
* @link http://cakephp.org CakePHP(tm) Project
* @since CakePHP(tm) v 3.0.0
* @license MIT License (http://www.opensource.org/licenses/mit-license.php)
*/
namespace Cake\ORM;
use Cake\Event\EventListener;
/**
* Base class for behaviors.
*
* Behaviors allow you to simulate mixins, and create
* reusable blocks of application logic, that can be reused across
* several models. Behaviors also provide a way to hook into model
* callbacks and augment their behavior.
*
* ### Mixin methods
*
* Behaviors can provide mixin like features by declaring public
* methods. These methods will be accessible on the tables the
* behavior has been added to.
*
* {{{
* function doSomething($arg1, $arg2) {
* // do something
* }
* }}}
*
* Would be called like `$table->doSomething($arg1, $arg2);`.
*
* ## Callback methods
*
* Behaviors can listen to any events fired on a Table. By default
* CakePHP provides a number of lifecycle events your behaviors can
* listen to:
*
* - `beforeFind(Event $event, Query $query)`
* Fired before a query is converted into SQL.
*
* - `beforeDelete(Event $event, Entity $entity)`
* Fired before an entity is deleted.
*
* - `afterDelete(Event $event, Entity $entity)`
* Fired after an entity has been deleted. The entity parameter
* will contain the entity state from before it was deleted.
*
* - `beforeSave(Event $event, Entity $entity)`
* Fired before an entity is saved. In the case where
* multiple entities are being saved, one event will be fired
* for each entity.
*
* - `afterSave(Event $event, Entity $entity)`
* Fired after an entity is saved. The saved entity will be provided
* as a parameter.
*
* In addition to the core events, behaviors can respond to any
* event fired from your Table classes including custom application
* specific ones.
*
* You can set the priority of a behaviors callbacks by using the
* `priority` setting when attaching a behavior. This will set the
* priority for all the callbacks a behavior provides.
*
* ## Finder methods
*
* Behaviors can provide finder methods that hook into a Table's
* find() method. Custom finders are a great way to provide preset
* queries that relate to your behavior. For example a SluggableBehavior
* could provide a find('slugged') finder. Behavior finders
* are implemented the same as other finders. Any method
* starting with `find` will be setup as a finder. Your finder
* methods should expect the following arguments:
*
* {{{
* findSlugged(Query $query, array $options = [])
* }}}
*
*
* @see Cake\ORM\Table::addBehavior()
* @see Cake\Event\EventManager
*/
class Behavior implements EventListener {
/**
* Contains configuration settings.
*
* @var array
*/
protected $_settings = [];
/**
* Constructor
*
* Does not retain a reference to the Table object. If you need this
* you should override the constructor.
*
* @param Table $table The table this behavior is attached to.
* @param array $settings The settings for this behavior.
*/
public function __construct(Table $table, array $settings = []) {
$this->_settings = $settings;
}
/**
* Read the settings being used.
*
* @return array
*/
public function settings() {
return $this->_settings;
}
/**
* Get the Model callbacks this behavior is interested in.
*
* By defining one of the callback methods a behavior is assumed
* to be interested in the related event.
*
* Override this method if you need to add non-conventional event listeners.
* Or if you want you behavior to listen to non-standard events.
*
* @return array
*/
public function implementedEvents() {
$eventMap = [
'Model.beforeFind' => 'beforeFind',
'Model.beforeSave' => 'beforeSave',
'Model.afterSave' => 'afterSave',
'Model.beforeDelete' => 'beforeDelete',
'Model.afterDelete' => 'afterDelete',
];
$settings = $this->settings();
$priority = isset($settings['priority']) ? $settings['priority'] : null;
$events = [];
foreach ($eventMap as $event => $method) {
if (!method_exists($this, $method)) {
continue;
}
if ($priority === null) {
$events[$event] = $method;
} else {
$events[$event] = [
'callable' => $method,
'priority' => $priority
];
}
}
return $events;
}
}