1 | <?php |
||
2 | /** |
||
3 | * This file is part of the Divergence package. |
||
4 | * |
||
5 | * (c) Henry Paradiz <[email protected]> |
||
6 | * |
||
7 | * For the full copyright and license information, please view the LICENSE |
||
8 | * file that was distributed with this source code. |
||
9 | */ |
||
10 | |||
11 | namespace Divergence\Controllers; |
||
12 | |||
13 | use Exception; |
||
14 | use Divergence\Helpers\JSON; |
||
15 | use Divergence\Responders\JsonBuilder; |
||
16 | use Divergence\Responders\TwigBuilder; |
||
17 | use Divergence\IO\Database\MySQL as DB; |
||
18 | use Divergence\Responders\JsonpBuilder; |
||
19 | use Psr\Http\Message\ResponseInterface; |
||
20 | use Psr\Http\Message\ServerRequestInterface; |
||
21 | use Divergence\Models\ActiveRecord as ActiveRecord; |
||
22 | |||
23 | /** |
||
24 | * RecordsRequestHandler - A REST API for Divergence ActiveRecord |
||
25 | * |
||
26 | * @package Divergence |
||
27 | * @author Henry Paradiz <[email protected]> |
||
28 | * @author Chris Alfano <[email protected]> |
||
29 | */ |
||
30 | abstract class RecordsRequestHandler extends RequestHandler |
||
31 | { |
||
32 | public $config; |
||
33 | |||
34 | public static $recordClass; |
||
35 | public $accountLevelRead = false; |
||
36 | public $accountLevelBrowse = 'Staff'; |
||
37 | public $accountLevelWrite = 'Staff'; |
||
38 | public $accountLevelAPI = false; |
||
39 | public $browseOrder = false; |
||
40 | public $browseConditions = false; |
||
41 | public $browseLimitDefault = false; |
||
42 | public $editableFields = false; |
||
43 | public $searchConditions = false; |
||
44 | public $calledClass = __CLASS__; |
||
45 | |||
46 | 73 | public function __construct() |
|
47 | { |
||
48 | 73 | $this->responseBuilder = TwigBuilder::class; |
|
49 | } |
||
50 | |||
51 | /** |
||
52 | * Start of routing for this controller. |
||
53 | * Methods in this execution path will always respond either as an error or a normal response. |
||
54 | * Responsible for detecting JSON or JSONP response modes. |
||
55 | */ |
||
56 | 38 | public function handle(ServerRequestInterface $request): ResponseInterface |
|
57 | { |
||
58 | // save static class |
||
59 | 38 | $this->calledClass = get_called_class(); |
|
60 | |||
61 | // handle JSON requests |
||
62 | 38 | if ($this->peekPath() == 'json') { |
|
63 | 36 | $this->shiftPath(); |
|
64 | |||
65 | // check access for API response modes |
||
66 | 36 | $this->responseBuilder = JsonBuilder::class; |
|
67 | |||
68 | 36 | if (in_array($this->responseBuilder, [JsonBuilder::class,JsonpBuilder::class])) { |
|
69 | 36 | if (!$this->checkAPIAccess()) { |
|
70 | 3 | return $this->throwAPIUnAuthorizedError(); |
|
71 | } |
||
72 | } |
||
73 | } |
||
74 | |||
75 | 35 | return $this->handleRecordsRequest(); |
|
76 | } |
||
77 | |||
78 | 35 | public function handleRecordsRequest($action = false): ResponseInterface |
|
79 | { |
||
80 | 35 | switch ($action ? $action : $action = $this->shiftPath()) { |
|
81 | 35 | case 'save': |
|
82 | 5 | { |
|
83 | 5 | return $this->handleMultiSaveRequest(); |
|
84 | 5 | } |
|
85 | |||
86 | 30 | case 'destroy': |
|
87 | 3 | { |
|
88 | 3 | return $this->handleMultiDestroyRequest(); |
|
89 | 3 | } |
|
90 | |||
91 | 27 | case 'create': |
|
92 | 3 | { |
|
93 | 3 | return $this->handleCreateRequest(); |
|
94 | 3 | } |
|
95 | |||
96 | 24 | case '': |
|
97 | case false: |
||
98 | 11 | { |
|
99 | 11 | return $this->handleBrowseRequest(); |
|
100 | 11 | } |
|
101 | |||
102 | default: |
||
103 | 13 | { |
|
104 | 13 | if ($Record = $this->getRecordByHandle($action)) { |
|
105 | 13 | return $this->handleRecordRequest($Record); |
|
106 | 13 | } else { |
|
107 | 13 | return $this->throwRecordNotFoundError(); |
|
108 | 13 | } |
|
109 | 13 | } |
|
110 | } |
||
111 | } |
||
112 | |||
113 | 14 | public function getRecordByHandle($handle) |
|
114 | { |
||
115 | 14 | $className = static::$recordClass; |
|
116 | 14 | if (method_exists($className, 'getByHandle')) { |
|
117 | 13 | return $className::getByHandle($handle); |
|
118 | } |
||
119 | } |
||
120 | |||
121 | 11 | public function prepareBrowseConditions($conditions = []) |
|
122 | { |
||
123 | 11 | if ($this->browseConditions) { |
|
124 | 2 | if (!is_array($this->browseConditions)) { |
|
0 ignored issues
–
show
introduced
by
Loading history...
|
|||
125 | 1 | $this->browseConditions = [$this->browseConditions]; |
|
126 | } |
||
127 | 2 | $conditions = array_merge($this->browseConditions, $conditions); |
|
128 | } |
||
129 | 11 | return $conditions; |
|
130 | } |
||
131 | |||
132 | 11 | public function prepareDefaultBrowseOptions() |
|
133 | { |
||
134 | 11 | if (!isset($_REQUEST['offset'])) { |
|
135 | 10 | if (isset($_REQUEST['start'])) { |
|
136 | 1 | if (is_numeric($_REQUEST['start'])) { |
|
137 | 1 | $_REQUEST['offset'] = $_REQUEST['start']; |
|
138 | } |
||
139 | } |
||
140 | } |
||
141 | |||
142 | 11 | $limit = !empty($_REQUEST['limit']) && is_numeric($_REQUEST['limit']) ? $_REQUEST['limit'] : $this->browseLimitDefault; |
|
143 | 11 | $offset = !empty($_REQUEST['offset']) && is_numeric($_REQUEST['offset']) ? $_REQUEST['offset'] : false; |
|
144 | |||
145 | 11 | $options = [ |
|
146 | 11 | 'limit' => $limit, |
|
147 | 11 | 'offset' => $offset, |
|
148 | 11 | 'order' => $this->browseOrder, |
|
149 | 11 | ]; |
|
150 | |||
151 | 11 | return $options; |
|
152 | } |
||
153 | |||
154 | 12 | public function handleBrowseRequest($options = [], $conditions = [], $responseID = null, $responseData = []): ResponseInterface |
|
155 | { |
||
156 | 12 | if (!$this->checkBrowseAccess(func_get_args())) { |
|
157 | 1 | return $this->throwUnauthorizedError(); |
|
158 | } |
||
159 | |||
160 | 11 | $conditions = $this->prepareBrowseConditions($conditions); |
|
161 | |||
162 | 11 | $options = $this->prepareDefaultBrowseOptions(); |
|
163 | |||
164 | // process sorter |
||
165 | 11 | if (!empty($_REQUEST['sort'])) { |
|
166 | 3 | $sort = json_decode($_REQUEST['sort'], true); |
|
167 | 3 | if (!$sort || !is_array($sort)) { |
|
168 | 1 | return $this->respond('error', [ |
|
169 | 1 | 'success' => false, |
|
170 | 1 | 'failed' => [ |
|
171 | 1 | 'errors' => 'Invalid sorter.', |
|
172 | 1 | ], |
|
173 | 1 | ]); |
|
174 | } |
||
175 | |||
176 | 2 | if (is_array($sort)) { |
|
0 ignored issues
–
show
|
|||
177 | 2 | foreach ($sort as $field) { |
|
178 | 2 | $options['order'][$field['property']] = $field['direction']; |
|
179 | } |
||
180 | } |
||
181 | } |
||
182 | |||
183 | // process filter |
||
184 | 10 | if (!empty($_REQUEST['filter'])) { |
|
185 | 2 | $filter = json_decode($_REQUEST['filter'], true); |
|
186 | 2 | if (!$filter || !is_array($filter)) { |
|
187 | 1 | return $this->respond('error', [ |
|
188 | 1 | 'success' => false, |
|
189 | 1 | 'failed' => [ |
|
190 | 1 | 'errors' => 'Invalid filter.', |
|
191 | 1 | ], |
|
192 | 1 | ]); |
|
193 | } |
||
194 | |||
195 | 1 | foreach ($filter as $field) { |
|
196 | 1 | $conditions[$field['property']] = $field['value']; |
|
197 | } |
||
198 | } |
||
199 | |||
200 | 9 | $className = static::$recordClass; |
|
201 | |||
202 | 9 | return $this->respond( |
|
203 | 9 | isset($responseID) ? $responseID : $this->getTemplateName($className::$pluralNoun), |
|
204 | 9 | array_merge($responseData, [ |
|
205 | 9 | 'success' => true, |
|
206 | 9 | 'data' => $className::getAllByWhere($conditions, $options), |
|
207 | 9 | 'conditions' => $conditions, |
|
208 | 9 | 'total' => DB::foundRows(), |
|
209 | 9 | 'limit' => $options['limit'], |
|
210 | 9 | 'offset' => $options['offset'], |
|
211 | 9 | ]) |
|
212 | 9 | ); |
|
213 | } |
||
214 | |||
215 | |||
216 | 12 | public function handleRecordRequest(ActiveRecord $Record, $action = false) |
|
217 | { |
||
218 | 12 | if (!$this->checkReadAccess($Record)) { |
|
219 | 2 | return $this->throwUnauthorizedError(); |
|
220 | } |
||
221 | |||
222 | 10 | switch ($action ? $action : $action = $this->shiftPath()) { |
|
223 | 10 | case '': |
|
224 | case false: |
||
225 | 3 | { |
|
226 | 3 | $className = static::$recordClass; |
|
227 | |||
228 | 3 | return $this->respond($this->getTemplateName($className::$singularNoun), [ |
|
229 | 3 | 'success' => true, |
|
230 | 3 | 'data' => $Record, |
|
231 | 3 | ]); |
|
232 | 3 | } |
|
233 | |||
234 | 7 | case 'edit': |
|
235 | 4 | { |
|
236 | 4 | return $this->handleEditRequest($Record); |
|
237 | 4 | } |
|
238 | |||
239 | 3 | case 'delete': |
|
240 | 2 | { |
|
241 | 2 | return $this->handleDeleteRequest($Record); |
|
242 | 2 | } |
|
243 | |||
244 | default: |
||
245 | 1 | { |
|
246 | 1 | return $this->onRecordRequestNotHandled($Record, $action); |
|
247 | 1 | } |
|
248 | } |
||
249 | } |
||
250 | |||
251 | |||
252 | 8 | public function prepareResponseModeJSON($methods = []) |
|
253 | { |
||
254 | 8 | if ($this->responseBuilder === JsonBuilder::class && in_array($_SERVER['REQUEST_METHOD'], $methods)) { |
|
255 | 8 | $JSONData = JSON::getRequestData(); |
|
256 | 8 | if (is_array($JSONData)) { |
|
257 | 4 | $_REQUEST = $JSONData; |
|
258 | } |
||
259 | } |
||
260 | } |
||
261 | |||
262 | 6 | public function getDatumRecord($datum) |
|
263 | { |
||
264 | 6 | $className = static::$recordClass; |
|
265 | 6 | $PrimaryKey = $className::getPrimaryKey(); |
|
266 | 6 | if (empty($datum[$PrimaryKey])) { |
|
267 | 4 | $record = new $className::$defaultClass(); |
|
268 | 4 | $this->onRecordCreated($record, $datum); |
|
269 | } else { |
||
270 | 2 | if (!$record = $className::getByID($datum[$PrimaryKey])) { |
|
271 | 1 | throw new Exception('Record not found'); |
|
272 | } |
||
273 | } |
||
274 | 6 | return $record; |
|
275 | } |
||
276 | |||
277 | 6 | public function processDatumSave($datum) |
|
278 | { |
||
279 | // get record |
||
280 | 6 | $Record = $this->getDatumRecord($datum); |
|
281 | |||
282 | // check write access |
||
283 | 6 | if (!$this->checkWriteAccess($Record)) { |
|
284 | 1 | throw new Exception('Write access denied'); |
|
285 | } |
||
286 | |||
287 | // apply delta |
||
288 | 5 | $this->applyRecordDelta($Record, $datum); |
|
289 | |||
290 | // call template function |
||
291 | 5 | $this->onBeforeRecordValidated($Record, $datum); |
|
292 | |||
293 | // try to save record |
||
294 | try { |
||
295 | // call template function |
||
296 | 5 | $this->onBeforeRecordSaved($Record, $datum); |
|
297 | |||
298 | 5 | $Record->save(); |
|
299 | |||
300 | // call template function |
||
301 | 4 | $this->onRecordSaved($Record, $datum); |
|
302 | |||
303 | 4 | return (!$Record::fieldExists('Class') || get_class($Record) == $Record->Class) ? $Record : $Record->changeClass(); |
|
304 | 1 | } catch (Exception $e) { |
|
305 | 1 | throw $e; |
|
306 | } |
||
307 | } |
||
308 | |||
309 | 5 | public function handleMultiSaveRequest(): ResponseInterface |
|
310 | { |
||
311 | 5 | $className = static::$recordClass; |
|
312 | |||
313 | 5 | $this->prepareResponseModeJSON(['POST','PUT']); |
|
314 | |||
315 | 5 | if (!empty($_REQUEST['data'])) { |
|
316 | 4 | if ($className::fieldExists(key($_REQUEST['data']))) { |
|
317 | 1 | $_REQUEST['data'] = [$_REQUEST['data']]; |
|
318 | } |
||
319 | } |
||
320 | |||
321 | |||
322 | 5 | if (empty($_REQUEST['data']) || !is_array($_REQUEST['data'])) { |
|
323 | 1 | return $this->respond('error', [ |
|
324 | 1 | 'success' => false, |
|
325 | 1 | 'failed' => [ |
|
326 | 1 | 'errors' => 'Save expects "data" field as array of records.', |
|
327 | 1 | ], |
|
328 | 1 | ]); |
|
329 | } |
||
330 | |||
331 | 4 | $results = []; |
|
332 | 4 | $failed = []; |
|
333 | |||
334 | 4 | foreach ($_REQUEST['data'] as $datum) { |
|
335 | try { |
||
336 | 4 | $results[] = $this->processDatumSave($datum); |
|
337 | 1 | } catch (Exception $e) { |
|
338 | 1 | $failed[] = [ |
|
339 | 1 | 'record' => $datum, |
|
340 | 1 | 'errors' => $e->getMessage(), |
|
341 | 1 | ]; |
|
342 | 1 | continue; |
|
343 | } |
||
344 | } |
||
345 | |||
346 | |||
347 | 4 | return $this->respond($this->getTemplateName($className::$pluralNoun).'Saved', [ |
|
348 | 4 | 'success' => count($results) || !count($failed), |
|
349 | 4 | 'data' => $results, |
|
350 | 4 | 'failed' => $failed, |
|
351 | 4 | ]); |
|
352 | } |
||
353 | |||
354 | 5 | public function processDatumDestroy($datum) |
|
355 | { |
||
356 | 5 | $className = static::$recordClass; |
|
357 | 5 | $PrimaryKey = $className::getPrimaryKey(); |
|
358 | |||
359 | // get record |
||
360 | 5 | if (is_numeric($datum)) { |
|
361 | 1 | $recordID = $datum; |
|
362 | 4 | } elseif (!empty($datum[$PrimaryKey]) && is_numeric($datum[$PrimaryKey])) { |
|
363 | 3 | $recordID = $datum[$PrimaryKey]; |
|
364 | } else { |
||
365 | 1 | throw new Exception($PrimaryKey.' missing'); |
|
366 | } |
||
367 | |||
368 | 4 | if (!$Record = $className::getByField($PrimaryKey, $recordID)) { |
|
369 | 2 | throw new Exception($PrimaryKey.' not found'); |
|
370 | } |
||
371 | |||
372 | // check write access |
||
373 | 4 | if (!$this->checkWriteAccess($Record)) { |
|
374 | 1 | throw new Exception('Write access denied'); |
|
375 | } |
||
376 | |||
377 | 3 | if ($Record->destroy()) { |
|
378 | 2 | return $Record; |
|
379 | } else { |
||
380 | throw new Exception('Destroy failed'); |
||
381 | } |
||
382 | } |
||
383 | |||
384 | 3 | public function handleMultiDestroyRequest(): ResponseInterface |
|
385 | { |
||
386 | 3 | $className = static::$recordClass; |
|
387 | |||
388 | 3 | $this->prepareResponseModeJSON(['POST','PUT','DELETE']); |
|
389 | |||
390 | 3 | if (!empty($_REQUEST['data'])) { |
|
391 | 2 | if ($className::fieldExists(key($_REQUEST['data']))) { |
|
392 | $_REQUEST['data'] = [$_REQUEST['data']]; |
||
393 | } |
||
394 | } |
||
395 | |||
396 | 3 | if (empty($_REQUEST['data']) || !is_array($_REQUEST['data'])) { |
|
397 | 1 | return $this->respond('error', [ |
|
398 | 1 | 'success' => false, |
|
399 | 1 | 'failed' => [ |
|
400 | 1 | 'errors' => 'Save expects "data" field as array of records.', |
|
401 | 1 | ], |
|
402 | 1 | ]); |
|
403 | } |
||
404 | |||
405 | 2 | $results = []; |
|
406 | 2 | $failed = []; |
|
407 | |||
408 | 2 | foreach ($_REQUEST['data'] as $datum) { |
|
409 | try { |
||
410 | 2 | $results[] = $this->processDatumDestroy($datum); |
|
411 | 2 | } catch (Exception $e) { |
|
412 | 2 | $failed[] = [ |
|
413 | 2 | 'record' => $datum, |
|
414 | 2 | 'errors' => $e->getMessage(), |
|
415 | 2 | ]; |
|
416 | 2 | continue; |
|
417 | } |
||
418 | } |
||
419 | |||
420 | 2 | return $this->respond($this->getTemplateName($className::$pluralNoun).'Destroyed', [ |
|
421 | 2 | 'success' => count($results) || !count($failed), |
|
422 | 2 | 'data' => $results, |
|
423 | 2 | 'failed' => $failed, |
|
424 | 2 | ]); |
|
425 | } |
||
426 | |||
427 | |||
428 | 3 | public function handleCreateRequest(ActiveRecord $Record = null): ResponseInterface |
|
429 | { |
||
430 | // save static class |
||
431 | 3 | $this->calledClass = get_called_class(); |
|
432 | |||
433 | 3 | if (!$Record) { |
|
434 | 3 | $className = static::$recordClass; |
|
435 | 3 | $Record = new $className::$defaultClass(); |
|
436 | } |
||
437 | |||
438 | // call template function |
||
439 | 3 | $this->onRecordCreated($Record, $_REQUEST); |
|
440 | |||
441 | 3 | return $this->handleEditRequest($Record); |
|
442 | } |
||
443 | |||
444 | 7 | public function handleEditRequest(ActiveRecord $Record): ResponseInterface |
|
445 | { |
||
446 | 7 | $className = static::$recordClass; |
|
447 | |||
448 | 7 | if (!$this->checkWriteAccess($Record)) { |
|
449 | 1 | return $this->throwUnauthorizedError(); |
|
450 | } |
||
451 | |||
452 | 6 | if (in_array($_SERVER['REQUEST_METHOD'], ['POST','PUT'])) { |
|
453 | 5 | if ($this->responseBuilder === JsonBuilder::class) { |
|
454 | 5 | $_REQUEST = JSON::getRequestData(); |
|
455 | 5 | if (isset($_REQUEST['data']) && is_array($_REQUEST['data'])) { |
|
456 | 2 | $_REQUEST = $_REQUEST['data']; |
|
457 | } |
||
458 | } |
||
459 | 5 | $_REQUEST = $_REQUEST ? $_REQUEST : $_POST; |
|
460 | |||
461 | // apply delta |
||
462 | 5 | $this->applyRecordDelta($Record, $_REQUEST); |
|
463 | |||
464 | // call template function |
||
465 | 5 | $this->onBeforeRecordValidated($Record, $_REQUEST); |
|
466 | |||
467 | // validate |
||
468 | 5 | if ($Record->validate()) { |
|
469 | // call template function |
||
470 | 5 | $this->onBeforeRecordSaved($Record, $_REQUEST); |
|
471 | |||
472 | try { |
||
473 | // save session |
||
474 | 5 | $Record->save(); |
|
475 | 1 | } catch (Exception $e) { |
|
476 | 1 | return $this->respond('Error', [ |
|
477 | 1 | 'success' => false, |
|
478 | 1 | 'failed' => [ |
|
479 | 1 | 'errors' => $e->getMessage(), |
|
480 | 1 | ], |
|
481 | 1 | ]); |
|
482 | } |
||
483 | |||
484 | // call template function |
||
485 | 4 | $this->onRecordSaved($Record, $_REQUEST); |
|
486 | |||
487 | // fire created response |
||
488 | 4 | $responseID = $this->getTemplateName($className::$singularNoun).'Saved'; |
|
489 | 4 | $responseData = [ |
|
490 | 4 | 'success' => true, |
|
491 | 4 | 'data' => $Record, |
|
492 | 4 | ]; |
|
493 | 4 | return $this->respond($responseID, $responseData); |
|
494 | } |
||
495 | |||
496 | // fall through back to form if validation failed |
||
497 | } |
||
498 | |||
499 | 1 | $responseID = $this->getTemplateName($className::$singularNoun).'Edit'; |
|
500 | 1 | $responseData = [ |
|
501 | 1 | 'success' => false, |
|
502 | 1 | 'data' => $Record, |
|
503 | 1 | ]; |
|
504 | |||
505 | 1 | return $this->respond($responseID, $responseData); |
|
506 | } |
||
507 | |||
508 | |||
509 | 3 | public function handleDeleteRequest(ActiveRecord $Record): ResponseInterface |
|
510 | { |
||
511 | 3 | $className = static::$recordClass; |
|
512 | |||
513 | 3 | if (!$this->checkWriteAccess($Record)) { |
|
514 | 1 | return $this->throwUnauthorizedError(); |
|
515 | } |
||
516 | |||
517 | 2 | if ($_SERVER['REQUEST_METHOD'] == 'POST') { |
|
518 | 1 | $data = $Record->data; |
|
519 | 1 | $Record->destroy(); |
|
520 | |||
521 | // call cleanup function after delete |
||
522 | 1 | $this->onRecordDeleted($Record, $data); |
|
523 | |||
524 | // fire created response |
||
525 | 1 | return $this->respond($this->getTemplateName($className::$singularNoun).'Deleted', [ |
|
526 | 1 | 'success' => true, |
|
527 | 1 | 'data' => $Record, |
|
528 | 1 | ]); |
|
529 | } |
||
530 | |||
531 | 1 | return $this->respond('confirm', [ |
|
532 | 1 | 'question' => 'Are you sure you want to delete this '.$className::$singularNoun.'?', |
|
533 | 1 | 'data' => $Record, |
|
534 | 1 | ]); |
|
535 | } |
||
536 | |||
537 | // access control template functions |
||
538 | 11 | public function checkBrowseAccess($arguments) |
|
539 | { |
||
540 | 11 | return true; |
|
541 | } |
||
542 | |||
543 | 22 | public function checkReadAccess(ActiveRecord $Record) |
|
544 | { |
||
545 | 22 | return true; |
|
546 | } |
||
547 | |||
548 | 16 | public function checkWriteAccess(ActiveRecord $Record) |
|
549 | { |
||
550 | 16 | return true; |
|
551 | } |
||
552 | |||
553 | 29 | public function checkAPIAccess() |
|
554 | { |
||
555 | 29 | return true; |
|
556 | } |
||
557 | |||
558 | 6 | public function throwUnauthorizedError(): ResponseInterface |
|
559 | { |
||
560 | 6 | return $this->respond('Unauthorized', [ |
|
561 | 6 | 'success' => false, |
|
562 | 6 | 'failed' => [ |
|
563 | 6 | 'errors' => 'Login required.', |
|
564 | 6 | ], |
|
565 | 6 | ]); |
|
566 | } |
||
567 | |||
568 | 3 | public function throwAPIUnAuthorizedError(): ResponseInterface |
|
569 | { |
||
570 | 3 | return $this->respond('Unauthorized', [ |
|
571 | 3 | 'success' => false, |
|
572 | 3 | 'failed' => [ |
|
573 | 3 | 'errors' => 'API access required.', |
|
574 | 3 | ], |
|
575 | 3 | ]); |
|
576 | } |
||
577 | |||
578 | 3 | public function throwNotFoundError(): ResponseInterface |
|
579 | { |
||
580 | 3 | return $this->respond('error', [ |
|
581 | 3 | 'success' => false, |
|
582 | 3 | 'failed' => [ |
|
583 | 3 | 'errors' => 'Record not found.', |
|
584 | 3 | ], |
|
585 | 3 | ]); |
|
586 | } |
||
587 | |||
588 | 1 | public function onRecordRequestNotHandled(ActiveRecord $Record, $action): ResponseInterface |
|
589 | { |
||
590 | 1 | return $this->respond('error', [ |
|
591 | 1 | 'success' => false, |
|
592 | 1 | 'failed' => [ |
|
593 | 1 | 'errors' => 'Malformed request.', |
|
594 | 1 | ], |
|
595 | 1 | ]); |
|
596 | } |
||
597 | |||
598 | |||
599 | |||
600 | 25 | public function getTemplateName($noun) |
|
601 | { |
||
602 | 25 | return preg_replace_callback('/\s+([a-zA-Z])/', function ($matches) { |
|
603 | 3 | return strtoupper($matches[1]); |
|
604 | 25 | }, $noun); |
|
605 | } |
||
606 | |||
607 | 11 | public function applyRecordDelta(ActiveRecord $Record, $data) |
|
608 | { |
||
609 | 11 | if (is_array($this->editableFields)) { |
|
0 ignored issues
–
show
|
|||
610 | 1 | $Record->setFields(array_intersect_key($data, array_flip($this->editableFields))); |
|
611 | } else { |
||
612 | 10 | $Record->setFields($data); |
|
613 | } |
||
614 | } |
||
615 | |||
616 | // event template functions |
||
617 | 7 | protected function onRecordCreated(ActiveRecord $Record, $data) |
|
618 | { |
||
619 | 7 | } |
|
620 | 10 | protected function onBeforeRecordValidated(ActiveRecord $Record, $data) |
|
621 | { |
||
622 | 10 | } |
|
623 | 10 | protected function onBeforeRecordSaved(ActiveRecord $Record, $data) |
|
624 | { |
||
625 | 10 | } |
|
626 | 1 | protected function onRecordDeleted(ActiveRecord $Record, $data) |
|
627 | { |
||
628 | 1 | } |
|
629 | 8 | protected function onRecordSaved(ActiveRecord $Record, $data) |
|
630 | { |
||
631 | 8 | } |
|
632 | |||
633 | 2 | protected function throwRecordNotFoundError() |
|
634 | { |
||
635 | 2 | return $this->throwNotFoundError(); |
|
636 | } |
||
637 | } |
||
638 |