Code Coverage |
||||||||||
Lines |
Functions and Methods |
Classes and Traits |
||||||||
| Total | |
95.72% |
246 / 257 |
|
94.55% |
52 / 55 |
CRAP | |
0.00% |
0 / 1 |
| Form | |
95.72% |
246 / 257 |
|
94.55% |
52 / 55 |
144 | |
0.00% |
0 / 1 |
| __construct | |
100.00% |
7 / 7 |
|
100.00% |
1 / 1 |
4 | |||
| createFromConfig | |
100.00% |
3 / 3 |
|
100.00% |
1 / 1 |
1 | |||
| createFromFieldsetConfig | |
100.00% |
3 / 3 |
|
100.00% |
1 / 1 |
1 | |||
| createFieldset | |
100.00% |
13 / 13 |
|
100.00% |
1 / 1 |
5 | |||
| setAction | |
100.00% |
2 / 2 |
|
100.00% |
1 / 1 |
1 | |||
| setMethod | |
100.00% |
2 / 2 |
|
100.00% |
1 / 1 |
1 | |||
| getAction | |
100.00% |
1 / 1 |
|
100.00% |
1 / 1 |
1 | |||
| getMethod | |
100.00% |
1 / 1 |
|
100.00% |
1 / 1 |
1 | |||
| setAttribute | |
100.00% |
10 / 10 |
|
100.00% |
1 / 1 |
5 | |||
| setAttributes | |
100.00% |
3 / 3 |
|
100.00% |
1 / 1 |
2 | |||
| addFieldset | |
100.00% |
3 / 3 |
|
100.00% |
1 / 1 |
1 | |||
| removeFieldset | |
100.00% |
6 / 6 |
|
100.00% |
1 / 1 |
4 | |||
| getFieldset | |
100.00% |
1 / 1 |
|
100.00% |
1 / 1 |
1 | |||
| getFieldsets | |
100.00% |
1 / 1 |
|
100.00% |
1 / 1 |
1 | |||
| hasFieldsets | |
100.00% |
1 / 1 |
|
100.00% |
1 / 1 |
1 | |||
| addColumn | |
100.00% |
8 / 8 |
|
100.00% |
1 / 1 |
4 | |||
| hasColumn | |
100.00% |
3 / 3 |
|
100.00% |
1 / 1 |
2 | |||
| getColumn | |
100.00% |
3 / 3 |
|
100.00% |
1 / 1 |
2 | |||
| removeColumn | |
100.00% |
5 / 5 |
|
100.00% |
1 / 1 |
3 | |||
| getCurrent | |
100.00% |
1 / 1 |
|
100.00% |
1 / 1 |
1 | |||
| setCurrent | |
100.00% |
4 / 4 |
|
100.00% |
1 / 1 |
2 | |||
| getLegend | |
100.00% |
1 / 1 |
|
100.00% |
1 / 1 |
1 | |||
| setLegend | |
100.00% |
3 / 3 |
|
100.00% |
1 / 1 |
2 | |||
| addField | |
100.00% |
4 / 4 |
|
100.00% |
1 / 1 |
2 | |||
| addFields | |
100.00% |
3 / 3 |
|
100.00% |
1 / 1 |
2 | |||
| addFieldFromConfig | |
100.00% |
2 / 2 |
|
100.00% |
1 / 1 |
1 | |||
| addFieldsFromConfig | |
100.00% |
14 / 14 |
|
100.00% |
1 / 1 |
7 | |||
| addFieldsetsFromConfig | |
100.00% |
6 / 6 |
|
100.00% |
1 / 1 |
3 | |||
| insertFieldBefore | |
100.00% |
5 / 5 |
|
100.00% |
1 / 1 |
3 | |||
| insertFieldAfter | |
100.00% |
5 / 5 |
|
100.00% |
1 / 1 |
3 | |||
| count | |
100.00% |
4 / 4 |
|
100.00% |
1 / 1 |
2 | |||
| toArray | |
45.45% |
5 / 11 |
|
0.00% |
0 / 1 |
11.84 | |||
| getField | |
100.00% |
7 / 7 |
|
100.00% |
1 / 1 |
3 | |||
| getFields | |
100.00% |
4 / 4 |
|
100.00% |
1 / 1 |
2 | |||
| hasField | |
100.00% |
1 / 1 |
|
100.00% |
1 / 1 |
1 | |||
| hasFields | |
100.00% |
1 / 1 |
|
100.00% |
1 / 1 |
1 | |||
| removeField | |
100.00% |
4 / 4 |
|
100.00% |
1 / 1 |
3 | |||
| getFieldValue | |
100.00% |
2 / 2 |
|
100.00% |
1 / 1 |
1 | |||
| setFieldValue | |
100.00% |
4 / 4 |
|
100.00% |
1 / 1 |
3 | |||
| setFieldValues | |
100.00% |
8 / 8 |
|
100.00% |
1 / 1 |
5 | |||
| filterValue | |
100.00% |
14 / 14 |
|
100.00% |
1 / 1 |
9 | |||
| filter | |
85.71% |
6 / 7 |
|
0.00% |
0 / 1 |
4.05 | |||
| isValid | |
100.00% |
7 / 7 |
|
100.00% |
1 / 1 |
3 | |||
| getErrors | |
100.00% |
3 / 3 |
|
100.00% |
1 / 1 |
2 | |||
| getAllErrors | |
100.00% |
6 / 6 |
|
100.00% |
1 / 1 |
3 | |||
| reset | |
100.00% |
4 / 4 |
|
100.00% |
1 / 1 |
2 | |||
| clearTokens | |
50.00% |
4 / 8 |
|
0.00% |
0 / 1 |
8.12 | |||
| prepare | |
100.00% |
18 / 18 |
|
100.00% |
1 / 1 |
8 | |||
| prepareForView | |
100.00% |
4 / 4 |
|
100.00% |
1 / 1 |
2 | |||
| render | |
100.00% |
8 / 8 |
|
100.00% |
1 / 1 |
5 | |||
| __toString | |
100.00% |
1 / 1 |
|
100.00% |
1 / 1 |
1 | |||
| __set | |
100.00% |
1 / 1 |
|
100.00% |
1 / 1 |
1 | |||
| __get | |
100.00% |
1 / 1 |
|
100.00% |
1 / 1 |
1 | |||
| __isset | |
100.00% |
2 / 2 |
|
100.00% |
1 / 1 |
1 | |||
| __unset | |
100.00% |
3 / 3 |
|
100.00% |
1 / 1 |
2 | |||
| 1 | <?php |
| 2 | /** |
| 3 | * Pop PHP Framework (http://www.popphp.org/) |
| 4 | * |
| 5 | * @link https://github.com/popphp/popphp-framework |
| 6 | * @author Nick Sagona, III <dev@nolainteractive.com> |
| 7 | * @copyright Copyright (c) 2009-2024 NOLA Interactive, LLC. (http://www.nolainteractive.com) |
| 8 | * @license http://www.popphp.org/license New BSD License |
| 9 | */ |
| 10 | |
| 11 | /** |
| 12 | * @namespace |
| 13 | */ |
| 14 | namespace Pop\Form; |
| 15 | |
| 16 | use Pop\Dom\Child; |
| 17 | use Pop\Form\Element\AbstractElement; |
| 18 | use Pop\Form\Element\Input\Checkbox; |
| 19 | use Pop\Form\Element\Input\Radio; |
| 20 | use Pop\Form\Element\Input\File; |
| 21 | |
| 22 | /** |
| 23 | * Form class |
| 24 | * |
| 25 | * @category Pop |
| 26 | * @package Pop\Form |
| 27 | * @author Nick Sagona, III <dev@nolainteractive.com> |
| 28 | * @copyright Copyright (c) 2009-2024 NOLA Interactive, LLC. (http://www.nolainteractive.com) |
| 29 | * @license http://www.popphp.org/license New BSD License |
| 30 | * @version 4.0.0 |
| 31 | */ |
| 32 | |
| 33 | class Form extends Child implements FormInterface, \ArrayAccess, \Countable, \IteratorAggregate |
| 34 | { |
| 35 | |
| 36 | /** |
| 37 | * Trait declaration |
| 38 | */ |
| 39 | use FormTrait; |
| 40 | |
| 41 | /** |
| 42 | * Field fieldsets |
| 43 | * @var array |
| 44 | */ |
| 45 | protected array $fieldsets = []; |
| 46 | |
| 47 | /** |
| 48 | * Form columns |
| 49 | * @var array |
| 50 | */ |
| 51 | protected array $columns = []; |
| 52 | |
| 53 | /** |
| 54 | * Current field fieldset |
| 55 | * @var int |
| 56 | */ |
| 57 | protected int $current = 0; |
| 58 | |
| 59 | /** |
| 60 | * Constructor |
| 61 | * |
| 62 | * Instantiate the form object |
| 63 | * |
| 64 | * @param ?array $fields |
| 65 | * @param ?string $action |
| 66 | * @param string $method |
| 67 | */ |
| 68 | public function __construct(?array $fields = null, ?string $action = null, string $method = 'post') |
| 69 | { |
| 70 | if ($action === null) { |
| 71 | $action = (isset($_SERVER['REQUEST_URI'])) ? $_SERVER['REQUEST_URI'] : '#'; |
| 72 | } |
| 73 | |
| 74 | parent::__construct('form'); |
| 75 | $this->setAction($action); |
| 76 | $this->setMethod($method); |
| 77 | |
| 78 | if ($fields !== null) { |
| 79 | $this->addFields($fields); |
| 80 | } |
| 81 | } |
| 82 | |
| 83 | /** |
| 84 | * Method to create form object and fields from config |
| 85 | * |
| 86 | * @param array|FormConfig $config |
| 87 | * @param ?string $container |
| 88 | * @param ?string $action |
| 89 | * @param string $method |
| 90 | * @return Form |
| 91 | */ |
| 92 | public static function createFromConfig( |
| 93 | array|FormConfig $config, ?string $container = null, ?string $action = null, string $method = 'post' |
| 94 | ): Form |
| 95 | { |
| 96 | $form = new static(null, $action, $method); |
| 97 | $form->addFieldsFromConfig($config, $container); |
| 98 | return $form; |
| 99 | } |
| 100 | |
| 101 | /** |
| 102 | * Method to create form object and fields from config |
| 103 | * |
| 104 | * @param array|FormConfig $config |
| 105 | * @param ?string $container |
| 106 | * @param ?string $action |
| 107 | * @param string $method |
| 108 | * @return Form |
| 109 | */ |
| 110 | public static function createFromFieldsetConfig( |
| 111 | array|FormConfig $config, ?string $container = null, ?string $action = null, string $method = 'post' |
| 112 | ): Form |
| 113 | { |
| 114 | $form = new static(null, $action, $method); |
| 115 | $form->addFieldsetsFromConfig($config, $container); |
| 116 | return $form; |
| 117 | } |
| 118 | |
| 119 | /** |
| 120 | * Method to create a new fieldset object |
| 121 | * |
| 122 | * @param ?string $legend |
| 123 | * @param ?string $container |
| 124 | * @return Fieldset |
| 125 | */ |
| 126 | public function createFieldset(?string $legend = null, ?string $container = null): Fieldset |
| 127 | { |
| 128 | $fieldset = new Fieldset(); |
| 129 | if ($legend !== null) { |
| 130 | $fieldset->setLegend($legend); |
| 131 | } |
| 132 | if ($container !== null) { |
| 133 | $fieldset->setContainer($container); |
| 134 | } |
| 135 | |
| 136 | $this->addFieldset($fieldset); |
| 137 | |
| 138 | $id = ($this->getAttribute('id') !== null) ? |
| 139 | $this->getAttribute('id') . '-fieldset-' . ($this->current + 1) : 'pop-form-fieldset-' . ($this->current + 1); |
| 140 | |
| 141 | $class = ($this->getAttribute('class') !== null) ? |
| 142 | $this->getAttribute('id') . '-fieldset' : 'pop-form-fieldset'; |
| 143 | |
| 144 | $fieldset->setAttribute('id', $id); |
| 145 | $fieldset->setAttribute('class', $class); |
| 146 | |
| 147 | return $fieldset; |
| 148 | } |
| 149 | |
| 150 | /** |
| 151 | * Method to set action |
| 152 | * |
| 153 | * @param string $action |
| 154 | * @return Form |
| 155 | */ |
| 156 | public function setAction(string $action): Form |
| 157 | { |
| 158 | $this->setAttribute('action', str_replace(['?captcha=1', '&captcha=1'], ['', ''], $action)); |
| 159 | return $this; |
| 160 | } |
| 161 | |
| 162 | /** |
| 163 | * Method to set method |
| 164 | * |
| 165 | * @param string $method |
| 166 | * @return Form |
| 167 | */ |
| 168 | public function setMethod(string $method): Form |
| 169 | { |
| 170 | $this->setAttribute('method', $method); |
| 171 | return $this; |
| 172 | } |
| 173 | |
| 174 | /** |
| 175 | * Method to get action |
| 176 | * |
| 177 | * @return string|null |
| 178 | */ |
| 179 | public function getAction(): string|null |
| 180 | { |
| 181 | return $this->getAttribute('action'); |
| 182 | } |
| 183 | |
| 184 | /** |
| 185 | * Method to get method |
| 186 | * |
| 187 | * @return string|null |
| 188 | */ |
| 189 | public function getMethod(): string|null |
| 190 | { |
| 191 | return $this->getAttribute('method'); |
| 192 | } |
| 193 | |
| 194 | /** |
| 195 | * Method to set an attribute |
| 196 | * |
| 197 | * @param string $name |
| 198 | * @param mixed $value |
| 199 | * @return Form |
| 200 | */ |
| 201 | public function setAttribute(string $name, mixed $value = null): Form |
| 202 | { |
| 203 | parent::setAttribute($name, $value); |
| 204 | |
| 205 | if ($name == 'id') { |
| 206 | foreach ($this->fieldsets as $i => $fieldset) { |
| 207 | $id = $value . '-fieldset-' . ($i + 1); |
| 208 | $fieldset->setAttribute('id', $id); |
| 209 | } |
| 210 | |
| 211 | } else if ($name == 'class') { |
| 212 | foreach ($this->fieldsets as $i => $fieldset) { |
| 213 | $class = $value . '-fieldset'; |
| 214 | $fieldset->setAttribute('class', $class); |
| 215 | } |
| 216 | } |
| 217 | |
| 218 | return $this; |
| 219 | } |
| 220 | |
| 221 | /** |
| 222 | * Method to set attributes |
| 223 | * |
| 224 | * @param array $attributes |
| 225 | * @return Form |
| 226 | */ |
| 227 | public function setAttributes(array $attributes): Form |
| 228 | { |
| 229 | foreach ($attributes as $name => $value) { |
| 230 | $this->setAttribute($name, $value); |
| 231 | } |
| 232 | return $this; |
| 233 | } |
| 234 | |
| 235 | /** |
| 236 | * Method to add fieldset |
| 237 | * |
| 238 | * @param Fieldset $fieldset |
| 239 | * @return Form |
| 240 | */ |
| 241 | public function addFieldset(Fieldset $fieldset): Form |
| 242 | { |
| 243 | $this->fieldsets[] = $fieldset; |
| 244 | $this->current = count($this->fieldsets) - 1; |
| 245 | return $this; |
| 246 | } |
| 247 | |
| 248 | /** |
| 249 | * Method to remove fieldset |
| 250 | * |
| 251 | * @param int $i |
| 252 | * @return Form |
| 253 | */ |
| 254 | public function removeFieldset(int $i): Form |
| 255 | { |
| 256 | if (isset($this->fieldsets[(int)$i])) { |
| 257 | unset($this->fieldsets[(int)$i]); |
| 258 | } |
| 259 | $this->fieldsets = array_values($this->fieldsets); |
| 260 | if (!isset($this->fieldsets[$this->current])) { |
| 261 | $this->current = (count($this->fieldsets) > 0) ? count($this->fieldsets) - 1 : 0; |
| 262 | } |
| 263 | return $this; |
| 264 | } |
| 265 | |
| 266 | /** |
| 267 | * Method to get current fieldset |
| 268 | * |
| 269 | * @return Fieldset|null |
| 270 | */ |
| 271 | public function getFieldset(): Fieldset|null |
| 272 | { |
| 273 | return $this->fieldsets[$this->current] ?? null; |
| 274 | } |
| 275 | |
| 276 | /** |
| 277 | * Method to get all fieldsets |
| 278 | * |
| 279 | * @return array |
| 280 | */ |
| 281 | public function getFieldsets(): array |
| 282 | { |
| 283 | return $this->fieldsets; |
| 284 | } |
| 285 | |
| 286 | /** |
| 287 | * Method to determine if the form has fieldsets |
| 288 | * |
| 289 | * @return bool |
| 290 | */ |
| 291 | public function hasFieldsets(): bool |
| 292 | { |
| 293 | return !empty($this->fieldsets); |
| 294 | } |
| 295 | |
| 296 | /** |
| 297 | * Method to add form column |
| 298 | * |
| 299 | * @param mixed $fieldsets |
| 300 | * @param ?string $class |
| 301 | * @return Form |
| 302 | */ |
| 303 | public function addColumn(mixed $fieldsets, ?string $class = null): Form |
| 304 | { |
| 305 | if (!is_array($fieldsets)) { |
| 306 | $fieldsets = [$fieldsets]; |
| 307 | } |
| 308 | |
| 309 | foreach ($fieldsets as $i => $num) { |
| 310 | $fieldsets[$i] = (int)$num - 1; |
| 311 | } |
| 312 | |
| 313 | if ($class === null) { |
| 314 | $class = 'pop-form-column-' . (count($this->columns) + 1); |
| 315 | } |
| 316 | |
| 317 | $this->columns[$class] = $fieldsets; |
| 318 | return $this; |
| 319 | } |
| 320 | |
| 321 | /** |
| 322 | * Method to determine if form has a column |
| 323 | * |
| 324 | * @param string $class |
| 325 | * @return bool |
| 326 | */ |
| 327 | public function hasColumn(string $class): bool |
| 328 | { |
| 329 | if (is_numeric($class)) { |
| 330 | $class = 'pop-form-column-' . $class; |
| 331 | } |
| 332 | |
| 333 | return isset($this->columns[$class]); |
| 334 | } |
| 335 | |
| 336 | /** |
| 337 | * Method to get form column |
| 338 | * |
| 339 | * @param string $class |
| 340 | * @return array|null |
| 341 | */ |
| 342 | public function getColumn(string $class): array|null |
| 343 | { |
| 344 | if (is_numeric($class)) { |
| 345 | $class = 'pop-form-column-' . $class; |
| 346 | } |
| 347 | |
| 348 | return $this->columns[$class] ?? null; |
| 349 | } |
| 350 | |
| 351 | /** |
| 352 | * Method to remove form column |
| 353 | * |
| 354 | * @param string $class |
| 355 | * @return Form |
| 356 | */ |
| 357 | public function removeColumn(string $class): Form |
| 358 | { |
| 359 | if (is_numeric($class)) { |
| 360 | $class = 'pop-form-column-' . $class; |
| 361 | } |
| 362 | |
| 363 | if (isset($this->columns[$class])) { |
| 364 | unset($this->columns[$class]); |
| 365 | } |
| 366 | |
| 367 | return $this; |
| 368 | } |
| 369 | |
| 370 | /** |
| 371 | * Method to get current fieldset index |
| 372 | * |
| 373 | * @return int |
| 374 | */ |
| 375 | public function getCurrent(): int |
| 376 | { |
| 377 | return $this->current; |
| 378 | } |
| 379 | |
| 380 | /** |
| 381 | * Method to get current fieldset index |
| 382 | * |
| 383 | * @param int $i |
| 384 | * @return Form |
| 385 | */ |
| 386 | public function setCurrent(int $i): Form |
| 387 | { |
| 388 | $this->current = (int)$i; |
| 389 | if (!isset($this->fieldsets[$this->current])) { |
| 390 | $this->fieldsets[$this->current] = $this->createFieldset(); |
| 391 | } |
| 392 | return $this; |
| 393 | } |
| 394 | |
| 395 | /** |
| 396 | * Method to get the legend of the current fieldset |
| 397 | * |
| 398 | * @return string|null |
| 399 | */ |
| 400 | public function getLegend(): string|null |
| 401 | { |
| 402 | return $this->fieldsets[$this->current]?->getLegend(); |
| 403 | } |
| 404 | |
| 405 | /** |
| 406 | * Method to set the legend of the current fieldset |
| 407 | * |
| 408 | * @param string $legend |
| 409 | * @return Form |
| 410 | */ |
| 411 | public function setLegend(string $legend): Form |
| 412 | { |
| 413 | if (isset($this->fieldsets[$this->current])) { |
| 414 | $this->fieldsets[$this->current]->setLegend($legend); |
| 415 | } |
| 416 | return $this; |
| 417 | } |
| 418 | |
| 419 | /** |
| 420 | * Method to add a form field |
| 421 | * |
| 422 | * @param AbstractElement $field |
| 423 | * @param ?string $container |
| 424 | * @return Form |
| 425 | */ |
| 426 | public function addField(AbstractElement $field, ?string $container = null): Form |
| 427 | { |
| 428 | if (count($this->fieldsets) == 0) { |
| 429 | $this->createFieldset(null, $container); |
| 430 | } |
| 431 | $this->fieldsets[$this->current]->addField($field); |
| 432 | return $this; |
| 433 | } |
| 434 | |
| 435 | /** |
| 436 | * Method to add form fields |
| 437 | * |
| 438 | * @param array $fields |
| 439 | * @return Form |
| 440 | */ |
| 441 | public function addFields(array $fields): Form |
| 442 | { |
| 443 | foreach ($fields as $field) { |
| 444 | $this->addField($field); |
| 445 | } |
| 446 | return $this; |
| 447 | } |
| 448 | |
| 449 | /** |
| 450 | * Method to add a form field from a config |
| 451 | * |
| 452 | * @param string $name |
| 453 | * @param array $field |
| 454 | * @return Form |
| 455 | */ |
| 456 | public function addFieldFromConfig(string $name, array $field): Form |
| 457 | { |
| 458 | $this->addField(Fields::create($name, $field)); |
| 459 | return $this; |
| 460 | } |
| 461 | |
| 462 | /** |
| 463 | * Method to add form fields from config |
| 464 | * |
| 465 | * @param array|FormConfig $config |
| 466 | * @param ?string $container |
| 467 | * @return Form |
| 468 | */ |
| 469 | public function addFieldsFromConfig(array|FormConfig $config, ?string $container = null): Form |
| 470 | { |
| 471 | $i = 1; |
| 472 | foreach ($config as $name => $field) { |
| 473 | if (is_numeric($name) && !isset($field[$name]['type'])) { |
| 474 | $fields = []; |
| 475 | foreach ($field as $n => $f) { |
| 476 | $fields[$n] = Fields::create($n, $f); |
| 477 | } |
| 478 | if ($i > 1) { |
| 479 | $this->fieldsets[$this->current]->createGroup(); |
| 480 | } |
| 481 | if (!isset($this->fieldsets[$this->current])) { |
| 482 | $this->fieldsets[$this->current] = new Fieldset(null, $container); |
| 483 | } |
| 484 | $this->fieldsets[$this->current]->addFields($fields); |
| 485 | $i++; |
| 486 | } else { |
| 487 | $this->addField(Fields::create($name, $field), $container); |
| 488 | } |
| 489 | } |
| 490 | return $this; |
| 491 | } |
| 492 | |
| 493 | /** |
| 494 | * Method to add form fieldsets from config |
| 495 | * |
| 496 | * @param array|FormConfig $fieldsets |
| 497 | * @param ?string $container |
| 498 | * @return Form |
| 499 | */ |
| 500 | public function addFieldsetsFromConfig(array|FormConfig $fieldsets, ?string $container = null): Form |
| 501 | { |
| 502 | foreach ($fieldsets as $legend => $config) { |
| 503 | if (!is_numeric($legend)) { |
| 504 | $this->createFieldset($legend, $container); |
| 505 | } else { |
| 506 | $this->createFieldset(null, $container); |
| 507 | } |
| 508 | $this->addFieldsFromConfig($config); |
| 509 | } |
| 510 | |
| 511 | return $this; |
| 512 | } |
| 513 | |
| 514 | /** |
| 515 | * Method to insert a field before another one |
| 516 | * |
| 517 | * @param string $name |
| 518 | * @param AbstractElement $field |
| 519 | * @return Form |
| 520 | */ |
| 521 | public function insertFieldBefore(string $name, AbstractElement $field): Form |
| 522 | { |
| 523 | foreach ($this->fieldsets as $fieldset) { |
| 524 | if ($fieldset->hasField($name)) { |
| 525 | $fieldset->insertFieldBefore($name, $field); |
| 526 | break; |
| 527 | } |
| 528 | } |
| 529 | return $this; |
| 530 | } |
| 531 | |
| 532 | /** |
| 533 | * Method to insert a field after another one |
| 534 | * |
| 535 | * @param string $name |
| 536 | * @param AbstractElement $field |
| 537 | * @return Form |
| 538 | */ |
| 539 | public function insertFieldAfter(string $name, AbstractElement $field): Form |
| 540 | { |
| 541 | foreach ($this->fieldsets as $fieldset) { |
| 542 | if ($fieldset->hasField($name)) { |
| 543 | $fieldset->insertFieldAfter($name, $field); |
| 544 | break; |
| 545 | } |
| 546 | } |
| 547 | return $this; |
| 548 | } |
| 549 | |
| 550 | /** |
| 551 | * Method to get the count of elements in the form |
| 552 | * |
| 553 | * @return int |
| 554 | */ |
| 555 | public function count(): int |
| 556 | { |
| 557 | $count = 0; |
| 558 | foreach ($this->fieldsets as $fieldset) { |
| 559 | $count += $fieldset->count(); |
| 560 | } |
| 561 | return $count; |
| 562 | } |
| 563 | |
| 564 | /** |
| 565 | * Method to get the field values as an array |
| 566 | * |
| 567 | * @param array $options |
| 568 | * @return array |
| 569 | */ |
| 570 | public function toArray(array $options = []): array |
| 571 | { |
| 572 | $fieldValues = []; |
| 573 | |
| 574 | foreach ($this->fieldsets as $fieldset) { |
| 575 | $fieldValues = array_merge($fieldValues, $fieldset->toArray()); |
| 576 | } |
| 577 | |
| 578 | if (!empty($options)) { |
| 579 | if (isset($options['exclude'])) { |
| 580 | if (!is_array($options['exclude'])) { |
| 581 | $options['exclude'] = [$options['exclude']]; |
| 582 | } |
| 583 | $fieldValues = array_diff_key($fieldValues, array_flip($options['exclude'])); |
| 584 | } |
| 585 | if (isset($options['filter'])) { |
| 586 | $fieldValues = array_filter($fieldValues, $options['filter']); |
| 587 | } |
| 588 | } |
| 589 | |
| 590 | return $fieldValues; |
| 591 | } |
| 592 | |
| 593 | /** |
| 594 | * Method to get a field element object |
| 595 | * |
| 596 | * @param string $name |
| 597 | * @return AbstractElement|null |
| 598 | */ |
| 599 | public function getField(string $name): AbstractElement|null |
| 600 | { |
| 601 | $namedField = null; |
| 602 | $fields = $this->getFields(); |
| 603 | |
| 604 | foreach ($fields as $field) { |
| 605 | if ($field->getName() == $name) { |
| 606 | $namedField = $field; |
| 607 | break; |
| 608 | } |
| 609 | } |
| 610 | |
| 611 | return $namedField; |
| 612 | } |
| 613 | |
| 614 | /** |
| 615 | * Method to get field element objects |
| 616 | * |
| 617 | * @return array |
| 618 | */ |
| 619 | public function getFields(): array |
| 620 | { |
| 621 | $fields = []; |
| 622 | |
| 623 | foreach ($this->fieldsets as $fieldset) { |
| 624 | $fields = array_merge($fields, $fieldset->getAllFields()); |
| 625 | } |
| 626 | |
| 627 | return $fields; |
| 628 | } |
| 629 | |
| 630 | /** |
| 631 | * Has a field element object |
| 632 | * |
| 633 | * @param string $name |
| 634 | * @return bool |
| 635 | */ |
| 636 | public function hasField(string $name): bool |
| 637 | { |
| 638 | return ($this->getField($name) !== null); |
| 639 | } |
| 640 | |
| 641 | /** |
| 642 | * Has fields |
| 643 | * |
| 644 | * @return bool |
| 645 | */ |
| 646 | public function hasFields(): bool |
| 647 | { |
| 648 | return (!empty($this->getFields())); |
| 649 | } |
| 650 | |
| 651 | /** |
| 652 | * Method to remove a form field |
| 653 | * |
| 654 | * @param string $field |
| 655 | * @return Form |
| 656 | */ |
| 657 | public function removeField(string $field): Form |
| 658 | { |
| 659 | foreach ($this->fieldsets as $fieldset) { |
| 660 | if ($fieldset->hasField($field)) { |
| 661 | unset($fieldset[$field]); |
| 662 | } |
| 663 | } |
| 664 | return $this; |
| 665 | } |
| 666 | |
| 667 | /** |
| 668 | * Method to get a field element value |
| 669 | * |
| 670 | * @param string $name |
| 671 | * @return mixed |
| 672 | */ |
| 673 | public function getFieldValue(string $name): mixed |
| 674 | { |
| 675 | $fieldValues = $this->toArray(); |
| 676 | return $fieldValues[$name] ?? null; |
| 677 | } |
| 678 | |
| 679 | /** |
| 680 | * Method to set a field element value |
| 681 | * |
| 682 | * @param string $name |
| 683 | * @param mixed $value |
| 684 | * @return Form |
| 685 | */ |
| 686 | public function setFieldValue(string $name, mixed $value): Form |
| 687 | { |
| 688 | foreach ($this->fieldsets as $fieldset) { |
| 689 | if (isset($fieldset[$name])) { |
| 690 | $fieldset[$name] = $value; |
| 691 | } |
| 692 | } |
| 693 | return $this; |
| 694 | } |
| 695 | |
| 696 | /** |
| 697 | * Method to set field element values |
| 698 | * |
| 699 | * @param array $values |
| 700 | * @return Form |
| 701 | */ |
| 702 | public function setFieldValues(array $values): Form |
| 703 | { |
| 704 | $fields = $this->toArray(); |
| 705 | foreach ($fields as $name => $value) { |
| 706 | if (isset($values[$name]) && !($this->getField($name)->isButton())) { |
| 707 | $this->setFieldValue($name, $values[$name]); |
| 708 | } else if (!($this->getField($name)->isButton())) { |
| 709 | $this->getField($name)->resetValue(); |
| 710 | } |
| 711 | } |
| 712 | |
| 713 | $this->filter(); |
| 714 | |
| 715 | return $this; |
| 716 | } |
| 717 | |
| 718 | /** |
| 719 | * Filter value with the filters in the form object |
| 720 | * |
| 721 | * @param mixed $field |
| 722 | * @return mixed |
| 723 | */ |
| 724 | public function filterValue(mixed $field): mixed |
| 725 | { |
| 726 | if ($field instanceof AbstractElement) { |
| 727 | $name = $field->getName(); |
| 728 | $type = $field->getType(); |
| 729 | $realValue = $field->getValue(); |
| 730 | } else { |
| 731 | $type = null; |
| 732 | $name = null; |
| 733 | $realValue = $field; |
| 734 | } |
| 735 | |
| 736 | foreach ($this->filters as $filter) { |
| 737 | if ($realValue !== null) { |
| 738 | $realValue = $filter->filter($realValue, $name, $type); |
| 739 | } |
| 740 | } |
| 741 | |
| 742 | if (($field instanceof AbstractElement) && !($field instanceof Checkbox) && |
| 743 | !($field instanceof Radio) && ($realValue !== null) && ($realValue != '')) { |
| 744 | $field->setValue($realValue); |
| 745 | } |
| 746 | |
| 747 | return $realValue; |
| 748 | } |
| 749 | |
| 750 | /** |
| 751 | * Filter values with the filters in the form object |
| 752 | * |
| 753 | * @param mixed $values |
| 754 | * @return mixed |
| 755 | */ |
| 756 | public function filter(mixed $values = null): mixed |
| 757 | { |
| 758 | if ($values === null) { |
| 759 | $values = $this->getFields(); |
| 760 | } |
| 761 | |
| 762 | if (is_array($values)) { |
| 763 | foreach ($values as $key => $value) { |
| 764 | $values[$key] = $this->filterValue($value); |
| 765 | } |
| 766 | } else { |
| 767 | $values = $this->filterValue($values); |
| 768 | } |
| 769 | |
| 770 | return $values; |
| 771 | } |
| 772 | |
| 773 | /** |
| 774 | * Determine whether or not the form object is valid |
| 775 | * |
| 776 | * @return bool |
| 777 | */ |
| 778 | public function isValid(): bool |
| 779 | { |
| 780 | $result = true; |
| 781 | $fields = $this->getFields(); |
| 782 | $values = $this->toArray(); |
| 783 | |
| 784 | // Check each element for validators, validate them and return the result. |
| 785 | foreach ($fields as $field) { |
| 786 | if ($field->validate($values) == false) { |
| 787 | $result = false; |
| 788 | } |
| 789 | } |
| 790 | |
| 791 | return $result; |
| 792 | } |
| 793 | |
| 794 | /** |
| 795 | * Get form element errors for a field. |
| 796 | * |
| 797 | * @param string $name |
| 798 | * @return array |
| 799 | */ |
| 800 | public function getErrors(string $name): array |
| 801 | { |
| 802 | $field = $this->getField($name); |
| 803 | $errors = ($field !== null) ? $field->getErrors() : []; |
| 804 | |
| 805 | return $errors; |
| 806 | } |
| 807 | |
| 808 | /** |
| 809 | * Get all form element errors |
| 810 | * |
| 811 | * @return array |
| 812 | */ |
| 813 | public function getAllErrors(): array |
| 814 | { |
| 815 | $errors = []; |
| 816 | $fields = $this->getFields(); |
| 817 | foreach ($fields as $name => $field) { |
| 818 | if ($field->hasErrors()) { |
| 819 | $errors[str_replace('[]', '', $field->getName())] = $field->getErrors(); |
| 820 | } |
| 821 | } |
| 822 | |
| 823 | return $errors; |
| 824 | } |
| 825 | |
| 826 | /** |
| 827 | * Method to reset and clear any form field values |
| 828 | * |
| 829 | * @return Form |
| 830 | */ |
| 831 | public function reset(): Form |
| 832 | { |
| 833 | $fields = $this->getFields(); |
| 834 | foreach ($fields as $field) { |
| 835 | $field->resetValue(); |
| 836 | } |
| 837 | return $this; |
| 838 | } |
| 839 | |
| 840 | /** |
| 841 | * Method to clear any security tokens |
| 842 | * |
| 843 | * @return Form |
| 844 | */ |
| 845 | public function clearTokens(): Form |
| 846 | { |
| 847 | // Start a session. |
| 848 | if (session_id() == '') { |
| 849 | session_start(); |
| 850 | } |
| 851 | if ($_SESSION) { |
| 852 | if (isset($_SESSION['pop_csrf'])) { |
| 853 | unset($_SESSION['pop_csrf']); |
| 854 | } |
| 855 | if (isset($_SESSION['pop_captcha'])) { |
| 856 | unset($_SESSION['pop_captcha']); |
| 857 | } |
| 858 | } |
| 859 | |
| 860 | return $this; |
| 861 | } |
| 862 | |
| 863 | /** |
| 864 | * Prepare form object for rendering |
| 865 | * |
| 866 | * @return Form |
| 867 | */ |
| 868 | public function prepare(): Form |
| 869 | { |
| 870 | if ($this->getAttribute('id') === null) { |
| 871 | $this->setAttribute('id', 'pop-form'); |
| 872 | } |
| 873 | if ($this->getAttribute('class') === null) { |
| 874 | $this->setAttribute('class', 'pop-form'); |
| 875 | } |
| 876 | |
| 877 | if (count($this->columns) > 0) { |
| 878 | foreach ($this->columns as $class => $fieldsets) { |
| 879 | $column = new Child('div'); |
| 880 | $column->setAttribute('class', $class); |
| 881 | foreach ($fieldsets as $i) { |
| 882 | if (isset($this->fieldsets[$i])) { |
| 883 | $fieldset = $this->fieldsets[$i]; |
| 884 | $fieldset->prepare(); |
| 885 | $column->addChild($fieldset); |
| 886 | } |
| 887 | } |
| 888 | $this->addChild($column); |
| 889 | } |
| 890 | } else { |
| 891 | foreach ($this->fieldsets as $fieldset) { |
| 892 | $fieldset->prepare(); |
| 893 | $this->addChild($fieldset); |
| 894 | } |
| 895 | } |
| 896 | |
| 897 | return $this; |
| 898 | } |
| 899 | |
| 900 | /** |
| 901 | * Prepare form object for rendering with a view |
| 902 | * |
| 903 | * @return array |
| 904 | */ |
| 905 | public function prepareForView(): array |
| 906 | { |
| 907 | $formData = []; |
| 908 | |
| 909 | foreach ($this->fieldsets as $fieldset) { |
| 910 | $formData = array_merge($formData, $fieldset->prepareForView()); |
| 911 | } |
| 912 | |
| 913 | return $formData; |
| 914 | } |
| 915 | |
| 916 | /** |
| 917 | * Render the form object |
| 918 | * |
| 919 | * @param int $depth |
| 920 | * @param ?string $indent |
| 921 | * @param bool $inner |
| 922 | * @return string|null |
| 923 | */ |
| 924 | public function render(int $depth = 0, ?string $indent = null, bool $inner = false): string|null |
| 925 | { |
| 926 | if (!($this->hasChildren())) { |
| 927 | $this->prepare(); |
| 928 | } |
| 929 | |
| 930 | foreach ($this->fieldsets as $fieldset) { |
| 931 | foreach ($fieldset->getAllFields() as $field) { |
| 932 | if ($field instanceof File) { |
| 933 | $this->setAttribute('enctype', 'multipart/form-data'); |
| 934 | break; |
| 935 | } |
| 936 | } |
| 937 | } |
| 938 | |
| 939 | return parent::render($depth, $indent, $inner); |
| 940 | } |
| 941 | |
| 942 | /** |
| 943 | * Render and return the form object as a string |
| 944 | * |
| 945 | * @return string |
| 946 | */ |
| 947 | public function __toString(): string |
| 948 | { |
| 949 | return $this->render(); |
| 950 | } |
| 951 | |
| 952 | /** |
| 953 | * Set method to set the property to the value of fields[$name] |
| 954 | * |
| 955 | * @param string $name |
| 956 | * @param mixed $value |
| 957 | * @return void |
| 958 | */ |
| 959 | public function __set(string $name, mixed $value): void |
| 960 | { |
| 961 | $this->setFieldValue($name, $value); |
| 962 | } |
| 963 | |
| 964 | /** |
| 965 | * Get method to return the value of fields[$name] |
| 966 | * |
| 967 | * @param string $name |
| 968 | * @return mixed |
| 969 | */ |
| 970 | public function __get(string $name): mixed |
| 971 | { |
| 972 | return $this->getFieldValue($name); |
| 973 | } |
| 974 | |
| 975 | /** |
| 976 | * Return the isset value of fields[$name] |
| 977 | * |
| 978 | * @param string $name |
| 979 | * @return bool |
| 980 | */ |
| 981 | public function __isset(string $name): bool |
| 982 | { |
| 983 | $fieldValues = $this->toArray(); |
| 984 | return isset($fieldValues[$name]); |
| 985 | } |
| 986 | |
| 987 | /** |
| 988 | * Unset fields[$name] |
| 989 | * |
| 990 | * @param string $name |
| 991 | * @return void |
| 992 | */ |
| 993 | public function __unset(string $name): void |
| 994 | { |
| 995 | $fieldValues = $this->toArray(); |
| 996 | if (isset($fieldValues[$name])) { |
| 997 | $this->getField($name)->resetValue(); |
| 998 | } |
| 999 | } |
| 1000 | |
| 1001 | } |