1 | <?php |
||
2 | /** |
||
3 | * YAWIK |
||
4 | * |
||
5 | * @filesource |
||
6 | * @copyright (c) 2013 - 2016 Cross Solution (http://cross-solution.de) |
||
7 | * @license MIT |
||
8 | */ |
||
9 | |||
10 | /** Core forms */ |
||
11 | namespace Core\Form; |
||
12 | |||
13 | use Laminas\Form\Element; |
||
14 | use Laminas\Form\FieldsetInterface; |
||
15 | use Laminas\Stdlib\PriorityList; |
||
16 | use Laminas\View\Renderer\PhpRenderer as Renderer; |
||
17 | use Core\Entity\EntityInterface; |
||
18 | use Laminas\ServiceManager\ServiceLocatorInterface; |
||
19 | |||
20 | /** |
||
21 | * Manages a group of formulars. |
||
22 | * |
||
23 | * The container is responsible for creating, populating and binding the formulars from or to |
||
24 | * the corresponding entities. |
||
25 | * |
||
26 | * Formulars are lazy loaded. So it is possible to only retrieve one formular from the container |
||
27 | * for asynchronous saving using ajax calls. |
||
28 | * |
||
29 | * @author Mathias Gelhausen <[email protected]> |
||
30 | */ |
||
31 | class Container extends Element implements |
||
32 | DisableElementsCapableInterface, |
||
33 | FormParentInterface, |
||
34 | \IteratorAggregate, |
||
35 | \Countable |
||
36 | { |
||
37 | /** |
||
38 | * Available/Loaded forms or specification. |
||
39 | * @var array |
||
40 | */ |
||
41 | protected $forms = array(); |
||
42 | |||
43 | /** |
||
44 | * Active formulars keys. |
||
45 | * |
||
46 | * Formulars which key is herein are included in the iterator. |
||
47 | * @see getIterator() |
||
48 | * @var array |
||
49 | */ |
||
50 | protected $activeForms = array(); |
||
51 | |||
52 | /** |
||
53 | * The form element manager. |
||
54 | * @var \Laminas\Form\FormElementManager\FormElementManagerV3Polyfill |
||
55 | */ |
||
56 | protected $formElementManager; |
||
57 | |||
58 | /** |
||
59 | * Entity to bind to the formulars. |
||
60 | * |
||
61 | * @var \Core\Entity\EntityInterface[] |
||
62 | */ |
||
63 | protected $entities; |
||
64 | |||
65 | /** |
||
66 | * Parameters to pass to the formulars. |
||
67 | * |
||
68 | * @var array |
||
69 | */ |
||
70 | protected $params = array(); |
||
71 | |||
72 | protected $parent; |
||
73 | |||
74 | /** |
||
75 | * @param ServiceLocatorInterface $formElementManager |
||
76 | * @return Container |
||
77 | */ |
||
78 | 22 | public function setFormElementManager(ServiceLocatorInterface $formElementManager) |
|
79 | { |
||
80 | 22 | $this->formElementManager = $formElementManager; |
|
0 ignored issues
–
show
|
|||
81 | 22 | return $this; |
|
82 | } |
||
83 | |||
84 | /** |
||
85 | * Gets an iterator to iterate over the enabled formulars. |
||
86 | * |
||
87 | * @return \ArrayIterator |
||
88 | * @see IteratorAggregate::getIterator() |
||
89 | */ |
||
90 | 1 | public function getIterator() |
|
91 | { |
||
92 | 1 | $iterator = new PriorityList(); |
|
93 | 1 | $iterator->isLIFO(false); |
|
94 | |||
95 | 1 | foreach ($this->activeForms as $key) { |
|
96 | 1 | $spec = $this->forms[$key]; |
|
97 | 1 | $priority = isset($spec['priority']) ? $spec['priority'] : 0; |
|
98 | |||
99 | 1 | $iterator->insert($key, $this->getForm($key), $priority); |
|
100 | } |
||
101 | |||
102 | 1 | return $iterator; |
|
103 | } |
||
104 | |||
105 | /** |
||
106 | * Gets the count of enabled formulars |
||
107 | * |
||
108 | * @return int |
||
109 | * @see Countable::count() |
||
110 | */ |
||
111 | public function count() |
||
112 | { |
||
113 | return count($this->activeForms); |
||
114 | } |
||
115 | |||
116 | /** |
||
117 | * @param bool $flag |
||
118 | * @return $this |
||
119 | */ |
||
120 | 2 | public function setIsDisableCapable($flag) |
|
121 | { |
||
122 | 2 | $this->options['is_disable_capable'] = $flag; |
|
123 | |||
124 | 2 | return $this; |
|
125 | } |
||
126 | |||
127 | /** |
||
128 | * @return bool |
||
129 | */ |
||
130 | 2 | public function isDisableCapable() |
|
131 | { |
||
132 | 2 | return isset($this->options['is_disable_capable']) |
|
133 | 2 | ? $this->options['is_disable_capable'] : true; |
|
134 | } |
||
135 | |||
136 | /** |
||
137 | * @param bool $flag |
||
138 | * @return $this |
||
139 | */ |
||
140 | 2 | public function setIsDisableElementsCapable($flag) |
|
141 | { |
||
142 | 2 | $this->options['is_disable_elements_capable'] = $flag; |
|
143 | |||
144 | 2 | return $this; |
|
145 | } |
||
146 | |||
147 | /** |
||
148 | * @return bool |
||
149 | */ |
||
150 | 2 | public function isDisableElementsCapable() |
|
151 | { |
||
152 | 2 | return isset($this->options['is_disable_elements_capable']) |
|
153 | 2 | ? $this->options['is_disable_elements_capable'] : true; |
|
154 | } |
||
155 | |||
156 | /** |
||
157 | * @param array $map |
||
158 | */ |
||
159 | public function disableElements(array $map) |
||
160 | { |
||
161 | foreach ($map as $key => $name) { |
||
162 | if (is_numeric($key)) { |
||
163 | if (isset($this->forms[$name])) { |
||
164 | $form = $this->getForm($name); |
||
165 | if (false !== $form->getOption('is_disable_capable')) { |
||
166 | $this->disableForm($name); |
||
167 | } |
||
168 | } |
||
169 | continue; |
||
170 | } |
||
171 | |||
172 | if (!isset($this->forms[$key])) { |
||
173 | continue; |
||
174 | } |
||
175 | |||
176 | if (isset($this->forms[$key]['__instance__'])) { |
||
177 | $form = $this->forms[$key]['__instance__']; |
||
178 | |||
179 | if ($form instanceof DisableElementsCapableInterface |
||
180 | && $form->isDisableElementsCapable() |
||
181 | ) { |
||
182 | $form->disableElements($name); |
||
183 | } |
||
184 | } |
||
185 | $this->forms[$key]['disable_elements'] = $name; |
||
186 | } |
||
187 | } |
||
188 | |||
189 | 1 | public function setOptions($options) |
|
190 | { |
||
191 | 1 | parent::setOptions($options); |
|
192 | |||
193 | 1 | if (isset($this->options['forms'])) { |
|
194 | $this->setForms($this->options['forms']); |
||
195 | } |
||
196 | |||
197 | 1 | return $this; |
|
198 | } |
||
199 | |||
200 | /** |
||
201 | * Sets formular parameters. |
||
202 | * |
||
203 | * @param array $params |
||
204 | * @return \Core\Form\Container |
||
205 | */ |
||
206 | 1 | public function setParams(array $params) |
|
207 | { |
||
208 | 1 | $this->params = array_merge($this->params, $params); |
|
209 | |||
210 | 1 | foreach ($this->forms as $form) { |
|
211 | 1 | if (isset($form['__instance__']) |
|
212 | 1 | && is_object($form['__instance__']) |
|
213 | 1 | && method_exists($form['__instance__'], 'setParams') |
|
214 | ) { |
||
215 | $form['__instance__']->setParams($params); |
||
216 | } |
||
217 | } |
||
218 | 1 | return $this; |
|
219 | } |
||
220 | |||
221 | /** |
||
222 | * Gets the formular parameters. |
||
223 | * |
||
224 | * @return array: |
||
225 | */ |
||
226 | 1 | public function getParams() |
|
227 | { |
||
228 | 1 | return $this->params; |
|
229 | } |
||
230 | |||
231 | /** |
||
232 | * Sets a formular parameter. |
||
233 | * |
||
234 | * @param string $key |
||
235 | * @param mixed $value |
||
236 | * @return \Core\Form\Container |
||
237 | */ |
||
238 | public function setParam($key, $value) |
||
239 | { |
||
240 | $this->params[$key] = $value; |
||
241 | |||
242 | foreach ($this->forms as $form) { |
||
243 | if (isset($form['__instance__']) |
||
244 | && is_object($form['__instance__']) |
||
245 | && method_exists($form['__instance__'], 'setParam') |
||
246 | ) { |
||
247 | $form['__instance__']->setParam($key, $value); |
||
248 | } |
||
249 | } |
||
250 | return $this; |
||
251 | } |
||
252 | |||
253 | /** |
||
254 | * Gets the value of a formular parameter. |
||
255 | * |
||
256 | * Returns the provided <b>$default</b> value or null, if parameter does |
||
257 | * not exist. |
||
258 | * |
||
259 | * @param string $key |
||
260 | * @param mixed $default |
||
261 | * @return mixed |
||
262 | */ |
||
263 | public function getParam($key, $default = null) |
||
264 | { |
||
265 | return isset($this->params[$key]) ? $this->params[$key] : $default; |
||
266 | } |
||
267 | |||
268 | /** |
||
269 | * Gets a specific formular. |
||
270 | * |
||
271 | * This formular will be created upon the first retrievement. |
||
272 | * If created, the formular gets passed the formular parameters set in this container. |
||
273 | * |
||
274 | * @param string $key |
||
275 | * @param bool $asInstance if set to false, the specification array is returned, and no instance created. |
||
276 | * |
||
277 | * @return null|\Core\Form\Container|\Laminas\Form\FormInterface |
||
278 | * @since 0,25 added $asInstance parameter |
||
279 | */ |
||
280 | 1 | public function getForm($key, $asInstance = true) |
|
281 | { |
||
282 | 1 | if (false !== strpos($key, '.')) { |
|
283 | 1 | list($key, $childKey) = explode('.', $key, 2); |
|
284 | 1 | $container = $this->getForm($key); |
|
285 | 1 | return $container->getForm($childKey); |
|
286 | } |
||
287 | |||
288 | 1 | if (!isset($this->forms[$key])) { |
|
289 | return null; |
||
290 | } |
||
291 | |||
292 | 1 | $form = $this->forms[$key]; |
|
293 | |||
294 | 1 | if (!$asInstance) { |
|
295 | return $form; |
||
296 | } |
||
297 | |||
298 | 1 | if (isset($form['__instance__']) && is_object($form['__instance__'])) { |
|
299 | 1 | return $form['__instance__']; |
|
300 | } |
||
301 | |||
302 | 1 | $options = isset($form['options']) ? $form['options'] : array(); |
|
303 | 1 | if (!isset($options['name'])) { |
|
304 | 1 | $options['name'] = isset($form['name']) ? $form['name'] : $key; |
|
305 | } |
||
306 | 1 | if (!isset($options['use_post_array'])) { |
|
307 | 1 | $options['use_post_array'] = true; |
|
308 | } |
||
309 | 1 | if (!isset($options['use_files_array'])) { |
|
310 | 1 | $options['use_files_array'] = false; |
|
311 | } |
||
312 | |||
313 | //@TODO: [ZF3] Passing options in $formElementManager->get is not working need to do manually set options |
||
314 | 1 | $formInstance = $this->formElementManager->get($form['type'], $options); |
|
315 | 1 | $formInstance->setOptions(array_merge($formInstance->getOptions(), $options)); |
|
316 | 1 | $formInstance->setParent($this); |
|
317 | |||
318 | 1 | if (isset($form['attributes'])) { |
|
319 | $formInstance->setAttributes($form['attributes']); |
||
320 | } |
||
321 | |||
322 | 1 | $formName = $this->formatAction($form['name']); |
|
323 | 1 | $formInstance->setName($formName); |
|
324 | 1 | $formAction = $formInstance->getAttribute('action'); |
|
325 | |||
326 | 1 | if (empty($formAction)) { |
|
327 | 1 | $formInstance->setAttribute('action', '?form=' . $formName); |
|
328 | } |
||
329 | |||
330 | // @TODO: [ZF3] which one is correct? $form[options][label] or $form[options] |
||
331 | 1 | if (isset($form['label'])) { |
|
332 | $formLabel = $form['label']; |
||
333 | 1 | } elseif (isset($form['options']['label'])) { |
|
334 | $formLabel = $form['options']['label']; |
||
335 | } |
||
336 | |||
337 | 1 | if (isset($formLabel)) { |
|
338 | $formInstance->setLabel($formLabel); |
||
339 | } |
||
340 | |||
341 | 1 | if (isset($form['disable_elements']) |
|
342 | 1 | && $formInstance instanceof DisableElementsCapableInterface |
|
343 | 1 | && $formInstance->isDisableElementsCapable() |
|
344 | ) { |
||
345 | $formInstance->disableElements($form['disable_elements']); |
||
346 | } |
||
347 | |||
348 | 1 | $entity = $this->getEntity($form['entity']); |
|
349 | 1 | if ($entity) { |
|
350 | 1 | $this->mapEntity($formInstance, $entity, isset($form['property']) ? $form['property'] : $key); |
|
351 | } |
||
352 | |||
353 | 1 | $formInstance->setParams($this->getParams()); |
|
354 | |||
355 | 1 | $this->forms[$key]['__instance__'] = $formInstance; |
|
356 | 1 | $this->forms[$key]['options'] = $options; |
|
357 | 1 | return $formInstance; |
|
358 | } |
||
359 | |||
360 | /** |
||
361 | * Execute an arbitrary action |
||
362 | * |
||
363 | * @param string $name Name of an action |
||
364 | * @param array $data Arbitrary data |
||
365 | * @return array |
||
366 | */ |
||
367 | public function executeAction($name, array $data = []) |
||
368 | { |
||
369 | if (false !== strpos($name, '.')) { |
||
370 | list($name, $childKey) = explode('.', $name, 2); |
||
371 | $container = $this->getForm($name); |
||
372 | |||
373 | // execute child container's action |
||
374 | return $container->executeAction($childKey, $data); |
||
375 | } |
||
376 | |||
377 | // this container defines no actions |
||
378 | return []; |
||
379 | } |
||
380 | |||
381 | /** |
||
382 | * Sets a form or form specification. |
||
383 | * |
||
384 | * if <b>$spec</b> is a string, it is used as form type, name is set to <b>$key</b> |
||
385 | * |
||
386 | * @param string $key |
||
387 | * @param string|array $spec |
||
388 | * @param boolean $enabled Should the formular be enabled or not |
||
389 | * |
||
390 | * @return self |
||
391 | */ |
||
392 | 6 | public function setForm($key, $spec, $enabled = true) |
|
393 | { |
||
394 | 6 | if (is_object($spec)) { |
|
395 | 1 | if ($spec instanceof FormParentInterface) { |
|
396 | 1 | $spec->setParent($this); |
|
397 | } |
||
398 | |||
399 | 1 | $spec = [ '__instance__' => $spec, 'name' => $key, 'entity' => '*' ]; |
|
400 | } |
||
401 | |||
402 | 6 | if (!is_array($spec)) { |
|
403 | 3 | $spec = array('type' => $spec, 'name' => $key); |
|
404 | } |
||
405 | 6 | if (!isset($spec['name'])) { |
|
406 | 3 | $spec['name'] = $key; |
|
407 | } |
||
408 | 6 | if (!isset($spec['entity'])) { |
|
409 | 5 | $spec['entity'] = '*'; |
|
410 | } |
||
411 | |||
412 | 6 | $this->forms[$key] = $spec; |
|
413 | |||
414 | 6 | if ($enabled) { |
|
415 | 5 | $this->enableForm($key); |
|
416 | 1 | } elseif (true === $this->activeForms) { |
|
417 | $this->activeForms = false; |
||
418 | } |
||
419 | 6 | return $this; |
|
420 | } |
||
421 | |||
422 | /** |
||
423 | * Sets formulars or specifications. |
||
424 | * |
||
425 | * <b>$forms</b> must be in the format: |
||
426 | * <pre> |
||
427 | * 'name' => [spec] |
||
428 | * </pre> |
||
429 | * |
||
430 | * <b>$spec</b> must be compatible with {@link setForm}. |
||
431 | * Additionally you can include a key 'enabled' in the spec, which will override |
||
432 | * <b>$enabled</b> only for the current formular. |
||
433 | * |
||
434 | * @param array $forms |
||
435 | * @param boolean $enabled |
||
436 | * @return \Core\Form\Container |
||
437 | */ |
||
438 | 1 | public function setForms(array $forms, $enabled = true) |
|
439 | { |
||
440 | 1 | foreach ($forms as $key => $spec) { |
|
441 | 1 | if (is_array($spec) && isset($spec['enabled'])) { |
|
442 | $currentEnabled = $spec['enabled']; |
||
443 | unset($spec['enabled']); |
||
444 | } else { |
||
445 | 1 | $currentEnabled = $enabled; |
|
446 | } |
||
447 | 1 | $this->setForm($key, $spec, $currentEnabled); |
|
448 | } |
||
449 | 1 | return $this; |
|
450 | } |
||
451 | |||
452 | /** |
||
453 | * Enables a formular. |
||
454 | * |
||
455 | * Enabled formulars are included in the {@link getIterator()} |
||
456 | * |
||
457 | * Traverses in child containers through .dot-Notation. |
||
458 | * |
||
459 | * @param string $key |
||
460 | * @return \Core\Form\Container |
||
461 | */ |
||
462 | 5 | public function enableForm($key = null) |
|
463 | { |
||
464 | 5 | if (null === $key) { |
|
465 | $this->activeForms = array_keys($this->forms); |
||
466 | return $this; |
||
467 | } |
||
468 | |||
469 | 5 | if (!is_array($key)) { |
|
470 | 5 | $key = array($key); |
|
471 | } |
||
472 | |||
473 | 5 | foreach ($key as $k) { |
|
474 | 5 | if (false !== strpos($k, '.')) { |
|
475 | // this seems not to be childkey.childform but actualkey.childkey |
||
476 | list($childKey, $childForm) = explode('.', $k, 2); |
||
477 | $child = $this->getForm($childKey); |
||
478 | $child->enableForm($childForm); |
||
479 | } else { |
||
480 | 5 | if (isset($this->forms[$k]) && !in_array($k, $this->activeForms)) { |
|
481 | 5 | $this->activeForms[] = $k; |
|
482 | } |
||
483 | } |
||
484 | } |
||
485 | |||
486 | 5 | return $this; |
|
487 | } |
||
488 | |||
489 | /** |
||
490 | * Disables a formular. |
||
491 | * |
||
492 | * @param string $key |
||
493 | * |
||
494 | * @return self |
||
495 | */ |
||
496 | public function disableForm($key = null) |
||
497 | { |
||
498 | if (null === $key) { |
||
499 | $this->activeForms = array(); |
||
500 | return $this; |
||
501 | } |
||
502 | |||
503 | if (!is_array($key)) { |
||
504 | $key = array($key); |
||
505 | } |
||
506 | |||
507 | foreach ($key as $k) { |
||
508 | if (false !== strpos($k, '.')) { |
||
509 | list($childKey, $childForm) = explode('.', $k, 2); |
||
510 | $child = $this->getForm($childKey); |
||
511 | $child->disableForm($childForm); |
||
512 | } elseif (isset($this->forms[$k]['__instance__'])) { |
||
513 | unset($this->forms[$k]['__instance__']); |
||
514 | } |
||
515 | } |
||
516 | $this->activeForms = array_filter( |
||
517 | $this->activeForms, |
||
518 | function ($item) use ($key) { |
||
519 | return !in_array($item, $key); |
||
520 | } |
||
521 | ); |
||
522 | |||
523 | return $this; |
||
524 | } |
||
525 | |||
526 | /** |
||
527 | * @param mixed $entity |
||
528 | * @param string $key |
||
529 | * @throws \InvalidArgumentException |
||
530 | * @return Container |
||
531 | */ |
||
532 | 5 | public function setEntity($entity, $key='*') |
|
533 | { |
||
534 | 5 | if (!$entity instanceof EntityInterface) { |
|
535 | throw new \InvalidArgumentException(sprintf('$entity must be instance of %s', EntityInterface::class)); |
||
536 | } |
||
537 | |||
538 | 5 | $this->entities[$key] = $entity; |
|
539 | |||
540 | 5 | foreach ($this->forms as $formKey => $form) { |
|
541 | 1 | if (isset($form['__instance__']) && is_object($form['__instance__']) && $key == $form['entity']) { |
|
542 | $this->mapEntity($form['__instance__'], $entity, isset($form['property']) ? $form['property'] : $formKey); |
||
543 | } |
||
544 | } |
||
545 | 5 | return $this; |
|
546 | } |
||
547 | |||
548 | |||
549 | /** |
||
550 | * Gets the entity. |
||
551 | * |
||
552 | * @return \Core\Entity\EntityInterface |
||
553 | */ |
||
554 | 18 | public function getEntity($key='*') |
|
555 | { |
||
556 | 18 | return isset($this->entities[$key]) ? $this->entities[$key] : null; |
|
557 | } |
||
558 | |||
559 | /** |
||
560 | * Maps entity property to forms or child containers. |
||
561 | * |
||
562 | * @param \Laminas\Form\FormInterface $form |
||
563 | * @param \Core\Entity\EntityInterface $entity |
||
564 | * @param string $property |
||
565 | * @return void |
||
566 | */ |
||
567 | 1 | protected function mapEntity($form, $entity, $property) |
|
568 | { |
||
569 | 1 | if (false === $property) { |
|
570 | return; |
||
571 | } |
||
572 | |||
573 | 1 | if (true === $property) { |
|
574 | 1 | $mapEntity = $entity; |
|
575 | 1 | } elseif ($entity->hasProperty($property) || is_callable([$entity, "get$property"])) { |
|
576 | 1 | $getter = "get$property"; |
|
577 | 1 | $mapEntity = $entity->$getter(); |
|
578 | } else { |
||
579 | return; |
||
580 | } |
||
581 | 1 | if ($form instanceof Container) { |
|
582 | 1 | $form->setEntity($mapEntity); |
|
583 | } else { |
||
584 | 1 | $form->bind($mapEntity); |
|
585 | } |
||
586 | } |
||
587 | |||
588 | /** |
||
589 | * Return isValid |
||
590 | * |
||
591 | * @return bool |
||
592 | */ |
||
593 | public function isValid() |
||
594 | { |
||
595 | $isValid = true; |
||
596 | foreach ($this->activeForms as $activeFormKey) { |
||
597 | $activeForm = $this->getForm($activeFormKey); |
||
598 | $isValid &= $activeForm->isValid(); |
||
599 | } |
||
600 | return $isValid; |
||
601 | } |
||
602 | |||
603 | /** |
||
604 | * if fieldsets there is get method to have access to any element by name |
||
605 | * this method is similar |
||
606 | * get('form') gets a form |
||
607 | * get('element') gets an element, if an element has the same name as a form, the form get's first access |
||
608 | * get('form.element') gets an element of a form, this is more efficent because it doesn't expand all forms in the container, |
||
609 | * but just the one adressed |
||
610 | * @param $key string |
||
611 | * @return null|\Laminas\Form\ElementInterface |
||
612 | */ |
||
613 | public function get($key) |
||
614 | { |
||
615 | $return = null; |
||
616 | $lastKey = null; |
||
617 | $searchIn = $this->activeForms; |
||
618 | $keySplit = explode('.', $key); |
||
619 | |||
620 | while (0 < count($keySplit)) { |
||
621 | $lastKey = array_shift($keySplit); |
||
622 | foreach ($searchIn as $activeFormKey) { |
||
623 | if ($lastKey == $activeFormKey) { |
||
624 | $searchIn = $this->getForm($activeFormKey); |
||
625 | unset($lastKey); |
||
626 | break; |
||
627 | } |
||
628 | } |
||
629 | } |
||
630 | if (!isset($lastKey) && !empty($keySplit)) { |
||
631 | $lastKey = array_shift($keySplit); |
||
632 | } |
||
633 | if (isset($lastKey) && empty($keySplit)) { |
||
634 | if ($searchIn instanceof FieldsetInterface) { |
||
635 | // has reached a fieldset to search in |
||
636 | $return = $searchIn->get($lastKey); |
||
637 | unset($lastKey); |
||
638 | } elseif (is_array($searchIn) || $searchIn instanceof \Traversable) { |
||
639 | // is probably still in the container |
||
640 | foreach ($searchIn as $activeKey) { |
||
641 | $activeForm = $this->getForm($activeKey); |
||
642 | if ($activeForm instanceof FieldsetInterface) { |
||
643 | $return = $activeForm->get($lastKey); |
||
644 | } |
||
645 | } |
||
646 | } |
||
647 | } |
||
648 | if (!isset($lastKey) && empty($keySplit) && !isset($return)) { |
||
649 | $return = $searchIn; |
||
650 | } |
||
651 | return $return; |
||
652 | } |
||
653 | |||
654 | /** |
||
655 | * @param $data |
||
656 | * @return $this |
||
657 | */ |
||
658 | public function setData($data) |
||
659 | { |
||
660 | $filteredData = array(); |
||
661 | foreach ($data as $key => $elem) { |
||
662 | if (!array_key_exists($key, $this->params) && $key != 'formName') { |
||
663 | $filteredData[$key] = $elem; |
||
664 | } |
||
665 | if ($key == 'formName' && is_string($elem)) { |
||
666 | // you can activate a specific form with postData |
||
667 | foreach ($this->activeForms as $activeFormKey) { |
||
668 | if ($activeFormKey == $elem) { |
||
669 | $this->enableForm($activeFormKey); |
||
670 | } else { |
||
671 | $this->disableForm($activeFormKey); |
||
672 | } |
||
673 | } |
||
674 | } |
||
675 | } |
||
676 | foreach ($this->activeForms as $activeFormKey) { |
||
677 | $activeForm = $this->getForm($activeFormKey); |
||
678 | $activeForm->setData($filteredData); |
||
679 | } |
||
680 | return $this; |
||
681 | } |
||
682 | |||
683 | /** |
||
684 | * @param $parent |
||
685 | * @return $this |
||
686 | */ |
||
687 | 3 | public function setParent($parent) |
|
688 | { |
||
689 | 3 | $this->parent = $parent; |
|
690 | 3 | return $this; |
|
691 | } |
||
692 | |||
693 | /** |
||
694 | * @return mixed |
||
695 | */ |
||
696 | 1 | public function getParent() |
|
697 | { |
||
698 | 1 | return $this->parent; |
|
699 | } |
||
700 | |||
701 | |||
702 | /** |
||
703 | * @return bool |
||
704 | */ |
||
705 | 8 | public function hasParent() |
|
706 | { |
||
707 | 8 | return isset($this->parent); |
|
708 | } |
||
709 | |||
710 | /** |
||
711 | * @param Renderer $renderer |
||
712 | * @return string |
||
713 | */ |
||
714 | 2 | public function renderPre(Renderer $renderer) |
|
715 | { |
||
716 | 2 | return ''; |
|
717 | } |
||
718 | |||
719 | /** |
||
720 | * @param Renderer $renderer |
||
721 | * @return string |
||
722 | */ |
||
723 | 2 | public function renderPost(Renderer $renderer) |
|
724 | { |
||
725 | 2 | return ''; |
|
726 | } |
||
727 | |||
728 | /** |
||
729 | * get the actual active Form |
||
730 | * @param bool $setDefault |
||
731 | * @return mixed|null |
||
732 | */ |
||
733 | public function getActiveFormActual($setDefault = true) |
||
734 | { |
||
735 | $key = null; |
||
736 | if (!empty($this->activeForms)) { |
||
737 | $key = $this->activeForms[0]; |
||
738 | } |
||
739 | if (!isset($key) && $setDefault) { |
||
740 | $formsAvailable = array_keys($this->forms); |
||
741 | $key = array_shift($formsAvailable); |
||
742 | } |
||
743 | return $key; |
||
744 | } |
||
745 | |||
746 | /** |
||
747 | * get the form before the actual active |
||
748 | * @return null |
||
749 | */ |
||
750 | public function getActiveFormPrevious() |
||
751 | { |
||
752 | $key = null; |
||
753 | $actualKey = $this->getActiveFormActual(); |
||
754 | if (isset($actualKey)) { |
||
755 | $forms = array_keys($this->forms); |
||
756 | $formsFlip = array_flip($forms); |
||
757 | $index = $formsFlip[$actualKey]; |
||
758 | if (0 < $index) { |
||
759 | $key = $forms[$index-1]; |
||
760 | } |
||
761 | } |
||
762 | return $key; |
||
763 | } |
||
764 | |||
765 | |||
766 | /** |
||
767 | * Gets the form after the actual active |
||
768 | * @return null |
||
769 | */ |
||
770 | public function getActiveFormNext() |
||
771 | { |
||
772 | $key = null; |
||
773 | $actualKey = $this->getActiveFormActual(); |
||
774 | if (isset($actualKey)) { |
||
775 | $forms = array_keys($this->forms); |
||
776 | $formsFlip = array_flip($forms); |
||
777 | $index = $formsFlip[$actualKey]; |
||
778 | if ($index < count($forms) - 1) { |
||
779 | $key = $forms[$index+1]; |
||
780 | } |
||
781 | } |
||
782 | return $key; |
||
783 | } |
||
784 | |||
785 | /** |
||
786 | * Format an action name |
||
787 | * |
||
788 | * @param string $name Name of an action |
||
789 | * @return string Formatted name of an action |
||
790 | */ |
||
791 | 7 | public function formatAction($name) |
|
792 | { |
||
793 | 7 | return sprintf('%s%s', $this->hasParent() ? $this->getName() . '.' : '', $name); |
|
794 | } |
||
795 | |||
796 | /** |
||
797 | * @param $key |
||
798 | * @return string|null |
||
799 | */ |
||
800 | 1 | public function getActionFor($key) |
|
801 | { |
||
802 | 1 | if (isset($this->forms[$key])) { |
|
803 | 1 | return '?form=' . $this->formatAction($this->forms[$key]['name']); |
|
804 | } |
||
805 | } |
||
806 | } |
||
807 |
Our type inference engine has found a suspicous assignment of a value to a property. This check raises an issue when a value that can be of a given class or a super-class is assigned to a property that is type hinted more strictly.
Either this assignment is in error or an instanceof check should be added for that assignment.