PropertyHelper::control() - Code Metrics - bedita/manager - Measure and Improve Code Quality continuously with Scrutinizer

PropertyHelper::control() B
last analyzed 2025-08-12 07:29 UTC

↳ Parent: PropertyHelper

Complexity

Conditions	10
Paths	32

Size

Total Lines	22
Code Lines	15

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	10
eloc	15
nc	32
nop	4
dl	0
loc	22
rs	7.6666
c	0
b	0
f	0

How to fix Complexity

<?php
/**
 * BEdita, API-first content management framework
 * Copyright 2020 ChannelWeb Srl, Chialab Srl
 *
 * This file is part of BEdita: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published
 * by the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * See LICENSE.LGPL or <http://gnu.org/licenses/lgpl-3.0.html> for more details.
 */
namespace App\View\Helper;

use App\Form\Control;
use App\Form\Form;
use App\Utility\CacheTools;
use App\Utility\Translate;
use Cake\Cache\Cache;
use Cake\Core\Configure;
use Cake\Utility\Hash;
use Cake\View\Helper;

/**
 * Helper class to generate properties html
 *
 * @property \App\View\Helper\SchemaHelper $Schema The schema helper
 * @property \Cake\View\Helper\FormHelper $Form The form helper
 */
class PropertyHelper extends Helper
{
    /**
     * List of helpers used by this helper
     *
     * @var array
     */
    public $helpers = ['Form', 'Schema'];

    /**
     * Special paths to retrieve properties from related resources
     *
     * @var array
     */
    public const RELATED_PATHS = [
        'file_name' => 'relationships.streams.data.0.attributes.file_name',
        'mime_type' => 'relationships.streams.data.0.attributes.mime_type',
        'file_size' => 'relationships.streams.data.0.meta.file_size',
    ];

    /**
     * Special properties having their own custom schema type
     *
     * @var array
     */
    public const SPECIAL_PROPS_TYPE = [
        'categories' => 'categories',
        'relations' => 'relations',
        'file_size' => 'byte',
    ];

    /**
     * Generates a form control element for an object property by name, value and options.
     * Use SchemaHelper (@see \App\View\Helper\SchemaHelper) to get control options by schema model.
     * Use FormHelper (@see \Cake\View\Helper\FormHelper::control) to render control.
     *
     * @param string $name The property name
     * @param mixed|null $value The property value
     * @param array $options The form element options, if any
     * @param string|null $type The object or resource type, for others schemas
     * @return string
     */
    public function control(string $name, $value, array $options = [], ?string $type = null): string
    {
        $forceReadonly = !empty(Hash::get($options, 'readonly'));
        $controlOptions = $this->Schema->controlOptions($name, $value, $this->schema($name, $type));
        $controlOptions['label'] = $this->fieldLabel($name, $type);
        $readonly = Hash::get($controlOptions, 'readonly') || $forceReadonly;
        if ($readonly === true && array_key_exists('html', $controlOptions)) {
            $controlOptions['html'] = str_replace('readonly="false"', 'readonly="true"', $controlOptions['html']);
            $controlOptions['html'] = str_replace(':readonly=false', ':readonly=true', $controlOptions['html']);
        }
        if ($readonly === true && array_key_exists('v-datepicker', $controlOptions)) {
            unset($controlOptions['v-datepicker']);
        }
        if (!$readonly && Hash::get($controlOptions, 'class') === 'json' || Hash::get($controlOptions, 'type') === 'json') {
            $jsonKeys = (array)Configure::read('_jsonKeys');
            Configure::write('_jsonKeys', array_merge($jsonKeys, [$name]));
        }
        if (Hash::check($controlOptions, 'html')) {
            return (string)Hash::get($controlOptions, 'html', '');
        }

        return $this->Form->control($name, array_merge($controlOptions, $options));
    }

    /**
     * Generates a form control for translation property
     *
     * @param string $name The property name
     * @param mixed|null $value The property value
     * @param array $options The form element options, if any
     * @return string
     */
    public function translationControl(string $name, $value, array $options = []): string
    {
        $formControlName = sprintf('translated_fields[%s]', $name);
        $controlOptions = $this->Schema->controlOptions($name, $value, $this->schema($name, null));
        if (array_key_exists('html', $controlOptions)) {
            $controlOptions['html'] = str_replace(sprintf('name="%s"', $name), sprintf('name="%s"', $formControlName), $controlOptions['html']);
        }
        $controlOptions['label'] = $this->fieldLabel($name, null);
        $readonly = Hash::get($controlOptions, 'readonly');
        if ($readonly === true && array_key_exists('v-datepicker', $controlOptions)) {
            unset($controlOptions['v-datepicker']);
        }
        if (Hash::get($controlOptions, 'class') === 'json' || Hash::get($controlOptions, 'type') === 'json') {
            $jsonKeys = (array)Configure::read('_jsonKeys');
            Configure::write('_jsonKeys', array_merge($jsonKeys, [$formControlName]));
        }
        if (Hash::check($controlOptions, 'html')) {
            return (string)Hash::get($controlOptions, 'html', '');
        }

        return $this->Form->control($formControlName, array_merge($controlOptions, $options));
    }

    /**
     * Return label for field by name and type.
     * If there's a config for the field and type, return it.
     * Return translation of name, otherwise.
     *
     * @param string $name The field name
     * @param string|null $type The object type
     * @return string
     */
    public function fieldLabel(string $name, ?string $type = null): string
    {
        $defaultLabel = (string)Translate::get($name);
        $t = empty($type) ? $this->getView()->get('objectType') : $type;
        if (empty($t)) {
            return $defaultLabel;
        }
        $key = sprintf('Properties.%s.options.%s.label', $t, $name);

        return (string)Configure::read($key, $defaultLabel);
    }

    /**
     * JSON Schema array of property name
     *
     * @param string $name The property name
     * @param string|null $objectType The object or resource type to use as schema
     * @return array|null
     */
    public function schema(string $name, ?string $objectType = null): ?array
    {
        $schema = (array)$this->_View->get('schema');
        if (!empty($objectType)) {
            $schemas = (array)$this->_View->get('schemasByType');
            $schema = (array)Hash::get($schemas, $objectType);
        }
        if (Hash::check(self::SPECIAL_PROPS_TYPE, $name)) {
            return array_filter([
                'type' => Hash::get(self::SPECIAL_PROPS_TYPE, $name),
                $name => Hash::get($schema, sprintf('%s', $name)),
            ]);
        }
        $res = Hash::get($schema, sprintf('properties.%s', $name));

        return $res === null ? null : (array)$res;
    }

    /**
     * Get formatted property value of a resource or object.
     *
     * @param array $resource Resource or object data
     * @param string $property Property name
     * @return string
     */
    public function value(array $resource, string $property): string
    {
        $paths = array_filter([
            $property,
            sprintf('attributes.%s', $property),
            sprintf('meta.%s', $property),
            (string)Hash::get(self::RELATED_PATHS, $property),
        ]);
        $value = '';
        foreach ($paths as $path) {
            if (Hash::check($resource, $path)) {
                $value = Hash::get($resource, $path);
                break;
            }
        }

        return $this->Schema->format($value, $this->schema($property));
    }

    /**
     * Return translations for object fields and more.
     *
     * @return array
     */
    public function translationsMap(): array
    {
        try {
            $key = CacheTools::cacheKey('translationsMap');
            $map = Cache::remember(
                $key,
                function () {
                    $map = [];
                    $keys = [];
                    Configure::load('properties');
                    $properties = (array)Configure::read('DefaultProperties');
                    $removeKeys = ['_element', '_hide', '_keep'];
                    foreach ($properties as $name => $prop) {
                        $keys[] = trim($name);
                        $keys = array_merge($keys, (array)Hash::get($prop, 'fastCreate.all', []));
                        $keys = array_merge($keys, (array)Hash::get($prop, 'index', []));
                        $keys = array_merge($keys, (array)Hash::get($prop, 'filter', []));
                        $groups = array_keys((array)Hash::get($prop, 'view', []));
                        $addKeys = array_reduce($groups, function ($carry, $group) use ($prop, $removeKeys) {
                            $carry[] = $group;
                            $groupKeys = (array)Hash::get($prop, sprintf('view.%s', $group), []);
                            $groupKeys = array_filter(
                                $groupKeys,
                                function ($val, $key) use ($removeKeys) {
                                    return is_string($val) && !in_array($key, $removeKeys);
                                },
                                ARRAY_FILTER_USE_BOTH
                            );

                            return array_merge($carry, $groupKeys);
                        }, []);
                        $keys = array_merge($keys, $addKeys);
                    }
                    $keys = array_map(function ($key) {
                        return is_array($key) ? array_key_first($key) : $key;
                    }, $keys);
                    $keys = array_diff($keys, $removeKeys);
                    $keys = array_unique($keys);
                    $keys = array_map(function ($key) {
                        return strpos($key, '/') !== false ? substr($key, strrpos($key, '/') + 1) : $key;
                    }, $keys);
                    $properties = (array)Configure::read(sprintf('Properties'));
                    foreach ($properties as $name => $prop) {
                        $keys[] = trim($name);
                        $keys = array_merge($keys, (array)Hash::get($prop, 'fastCreate.all', []));
                        $keys = array_merge($keys, (array)Hash::get($prop, 'index', []));
                        $keys = array_merge($keys, (array)Hash::get($prop, 'filter', []));
                        $groups = array_keys((array)Hash::get($prop, 'view', []));
                        $addKeys = array_reduce($groups, function ($carry, $group) use ($prop, $removeKeys) {
                            $carry[] = $group;
                            $groupKeys = (array)Hash::get($prop, sprintf('view.%s', $group), []);
                            $groupKeys = array_filter(
                                $groupKeys,
                                function ($val, $key) use ($removeKeys) {
                                    return is_string($val) && !in_array($key, $removeKeys);
                                },
                                ARRAY_FILTER_USE_BOTH
                            );

                            return array_merge($carry, $groupKeys);
                        }, []);
                        $keys = array_merge($keys, $addKeys);
                    }
                    $keys = array_map(function ($key) {
                        return is_array($key) ? array_key_first($key) : $key;
                    }, $keys);
                    $keys = array_diff($keys, $removeKeys);
                    $keys = array_unique($keys);
                    $keys = array_map(function ($key) {
                        return strpos($key, '/') !== false ? substr($key, strrpos($key, '/') + 1) : $key;
                    }, $keys);
                    sort($keys);
                    foreach ($keys as $key) {
                        $map[$key] = (string)Translate::get($key);
                    }

                    return $map;
                }
            );
        } catch (\Throwable $e) {
            $map = [];
        }

        return $map;
    }

    /**
     * Return fast create fields per module map.
     *
     * @return array
     */
    public function fastCreateFieldsMap(): array
    {
        $defaultTitleType = Configure::read('UI.richeditor.title', []) ? 'textarea' : 'string';
        $map = [];
        $properties = (array)Configure::read(sprintf('Properties'));
        $uploadable = $this->getView()->get('uploadable', []);
        $defaults = [
            'objects' => [
                'all' => [['title' => $defaultTitleType], 'status', 'description'],
                'required' => ['status', 'title'],
            ],
            'media' => [
                'all' => [['title' => $defaultTitleType], 'status', 'name'],
                'required' => ['name', 'status', 'title'],
            ],
        ];
        foreach ($properties as $name => $prop) {
            $cfg = (array)Hash::get($prop, 'fastCreate', []);
            $defaultFieldMap = in_array($name, $uploadable) ? $defaults['media'] : $defaults['objects'];
            $fields = (array)Hash::get($cfg, 'all', $defaultFieldMap['all']);
            $required = (array)Hash::get($cfg, 'required', $defaultFieldMap['required']);
            $map[$name] = compact('fields', 'required');
        }

        return $map;
    }

    /**
     * Return html for fast create form fields.
     *
     * @param string $type The object type
     * @param string $prefix The prefix
     * @return string The html for form fields
     */
    public function fastCreateFields(string $type, string $prefix): string
    {
        $cfg = (array)Configure::read(sprintf('Properties.%s.fastCreate', $type));
        $fields = (array)Hash::get($cfg, 'all', ['status', 'title', 'description']);
        $required = (array)Hash::get($cfg, 'required', ['status', 'title']);
        $html = '';
        $jsonKeys = [];
        $ff = [];
        foreach ($fields as $field => $fieldType) {
            $field = is_numeric($field) ? $fieldType : $field;
            $fieldClass = !in_array($field, $required) ? 'fastCreateField' : 'fastCreateField required';
            $fieldOptions = [
                'id' => sprintf('%s%s', $prefix, $field),
                'class' => $fieldClass,
                'data-name' => $field,
                'key' => sprintf('%s-%s', $type, $field),
            ];
            if ($field === 'date_ranges') {
                $html .= $this->dateRange($type, $fieldOptions);
                continue;
            }
            if ($fieldType === 'json') {
                $jsonKeys[] = $field;
            }
            $this->prepareFieldOptions($field, $fieldType, $fieldOptions);

            $html .= $this->control($field, '', $fieldOptions, $type);
            $ff[] = $field;
        }
        $jsonKeys = array_unique(array_merge($jsonKeys, (array)Configure::read('_jsonKeys')));
        $jsonKeys = array_intersect($jsonKeys, $ff);

        if (!empty($jsonKeys)) {
            $html .= $this->Form->control('_jsonKeys', ['type' => 'hidden', 'value' => implode(',', $jsonKeys)]);
        }

        return $html;
    }

    /**
     * Prepare field options for field.
     *
     * @param string $field The field name
     * @param string|null $fieldType The field type, if any
     * @param array $fieldOptions The field options
     * @return void
     */
    public function prepareFieldOptions(string $field, ?string $fieldType, array &$fieldOptions): void
    {
        $method = '';
        if (!empty($fieldType) && in_array($fieldType, Control::CONTROL_TYPES)) {
            $methodInfo = Form::getMethod(Control::class, $fieldType);
            $className = (string)Hash::get($methodInfo, 0);
            $method = (string)Hash::get($methodInfo, 1);
            $preserveClass = Hash::get($fieldOptions, 'class', '');
            $fieldOptions = array_merge($fieldOptions, $className::$method([]));
            $fieldOptions['class'] .= ' ' . $preserveClass;
            $fieldOptions['class'] = trim($fieldOptions['class']);
        }
        if ($field === 'status') {
            $fieldOptions['v-model'] = 'object.attributes.status';
        }
    }

    /**
     * Return html for date range fields.
     *
     * @param string $type The object type
     * @param array $options The options
     * @return string The html for date range fields
     */
    public function dateRange(string $type, array $options): string
    {
        $optionsFrom = array_merge($options, [
            'id' => 'start_date_0',
            'name' => 'date_ranges[0][start_date]',
            'v-datepicker' => 'true',
            'date' => 'true',
            'time' => 'true',
            'daterange' => 'true',
        ]);
        $optionsTo = array_merge($options, [
            'id' => 'end_date_0',
            'name' => 'date_ranges[0][end_date]',
            'v-datepicker' => 'true',
            'date' => 'true',
            'time' => 'true',
            'daterange' => 'true',
        ]);
        $optionsAllDay = array_merge($options, [
            'id' => 'all_day_0',
            'name' => 'date_ranges[0][params][all_day]',
            'type' => 'checkbox',
        ]);
        $from = $this->control(__('From'), '', $optionsFrom, $type);
        $to = $this->control(__('To'), '', $optionsTo, $type);
        $allDay = $this->control(__('All day'), '', $optionsAllDay, $type);

        return sprintf('<div class="date-ranges-item mb-1"><div>%s%s%s</div></div>', $from, $to, $allDay);
    }
}


1			<?php
2			/**
3			* BEdita, API-first content management framework
4			* Copyright 2020 ChannelWeb Srl, Chialab Srl
5			*
6			* This file is part of BEdita: you can redistribute it and/or modify
7			* it under the terms of the GNU Lesser General Public License as published
8			* by the Free Software Foundation, either version 3 of the License, or
9			* (at your option) any later version.
10			*
11			* See LICENSE.LGPL or <http://gnu.org/licenses/lgpl-3.0.html> for more details.
12			*/
13			namespace App\View\Helper;
14
15			use App\Form\Control;
16			use App\Form\Form;
17			use App\Utility\CacheTools;
18			use App\Utility\Translate;
19			use Cake\Cache\Cache;
20			use Cake\Core\Configure;
21			use Cake\Utility\Hash;
22			use Cake\View\Helper;
23
24			/**
25			* Helper class to generate properties html
26			*
27			* @property \App\View\Helper\SchemaHelper $Schema The schema helper
28			* @property \Cake\View\Helper\FormHelper $Form The form helper
29			*/
30			class PropertyHelper extends Helper
31			{
32			/**
33			* List of helpers used by this helper
34			*
35			* @var array
36			*/
37			public $helpers = ['Form', 'Schema'];
38
39			/**
40			* Special paths to retrieve properties from related resources
41			*
42			* @var array
43			*/
44			public const RELATED_PATHS = [
45			'file_name' => 'relationships.streams.data.0.attributes.file_name',
46			'mime_type' => 'relationships.streams.data.0.attributes.mime_type',
47			'file_size' => 'relationships.streams.data.0.meta.file_size',
48			];
49
50			/**
51			* Special properties having their own custom schema type
52			*
53			* @var array
54			*/
55			public const SPECIAL_PROPS_TYPE = [
56			'categories' => 'categories',
57			'relations' => 'relations',
58			'file_size' => 'byte',
59			];
60
61			/**
62			* Generates a form control element for an object property by name, value and options.
63			* Use SchemaHelper (@see \App\View\Helper\SchemaHelper) to get control options by schema model.
64			* Use FormHelper (@see \Cake\View\Helper\FormHelper::control) to render control.
65			*
66			* @param string $name The property name
67			* @param mixed\|null $value The property value
68			* @param array $options The form element options, if any
69			* @param string\|null $type The object or resource type, for others schemas
70			* @return string
71			*/
72			public function control(string $name, $value, array $options = [], ?string $type = null): string
73			{
74			$forceReadonly = !empty(Hash::get($options, 'readonly'));
75			$controlOptions = $this->Schema->controlOptions($name, $value, $this->schema($name, $type));
76			$controlOptions['label'] = $this->fieldLabel($name, $type);
77			$readonly = Hash::get($controlOptions, 'readonly') \|\| $forceReadonly;
78			if ($readonly === true && array_key_exists('html', $controlOptions)) {
79			$controlOptions['html'] = str_replace('readonly="false"', 'readonly="true"', $controlOptions['html']);
80			$controlOptions['html'] = str_replace(':readonly=false', ':readonly=true', $controlOptions['html']);
81			}
82			if ($readonly === true && array_key_exists('v-datepicker', $controlOptions)) {
83			unset($controlOptions['v-datepicker']);
84			}
85			if (!$readonly && Hash::get($controlOptions, 'class') === 'json' \|\| Hash::get($controlOptions, 'type') === 'json') {
86			$jsonKeys = (array)Configure::read('_jsonKeys');
87			Configure::write('_jsonKeys', array_merge($jsonKeys, [$name]));
88			}
89			if (Hash::check($controlOptions, 'html')) {
90			return (string)Hash::get($controlOptions, 'html', '');
91			}
92
93			return $this->Form->control($name, array_merge($controlOptions, $options));
94			}
95
96			/**
97			* Generates a form control for translation property
98			*
99			* @param string $name The property name
100			* @param mixed\|null $value The property value
101			* @param array $options The form element options, if any
102			* @return string
103			*/
104			public function translationControl(string $name, $value, array $options = []): string
105			{
106			$formControlName = sprintf('translated_fields[%s]', $name);
107			$controlOptions = $this->Schema->controlOptions($name, $value, $this->schema($name, null));
108			if (array_key_exists('html', $controlOptions)) {
109			$controlOptions['html'] = str_replace(sprintf('name="%s"', $name), sprintf('name="%s"', $formControlName), $controlOptions['html']);
110			}
111			$controlOptions['label'] = $this->fieldLabel($name, null);
112			$readonly = Hash::get($controlOptions, 'readonly');
113			if ($readonly === true && array_key_exists('v-datepicker', $controlOptions)) {
114			unset($controlOptions['v-datepicker']);
115			}
116			if (Hash::get($controlOptions, 'class') === 'json' \|\| Hash::get($controlOptions, 'type') === 'json') {
117			$jsonKeys = (array)Configure::read('_jsonKeys');
118			Configure::write('_jsonKeys', array_merge($jsonKeys, [$formControlName]));
119			}
120			if (Hash::check($controlOptions, 'html')) {
121			return (string)Hash::get($controlOptions, 'html', '');
122			}
123
124			return $this->Form->control($formControlName, array_merge($controlOptions, $options));
125			}
126
127			/**
128			* Return label for field by name and type.
129			* If there's a config for the field and type, return it.
130			* Return translation of name, otherwise.
131			*
132			* @param string $name The field name
133			* @param string\|null $type The object type
134			* @return string
135			*/
136			public function fieldLabel(string $name, ?string $type = null): string
137			{
138			$defaultLabel = (string)Translate::get($name);
139			$t = empty($type) ? $this->getView()->get('objectType') : $type;
140			if (empty($t)) {
141			return $defaultLabel;
142			}
143			$key = sprintf('Properties.%s.options.%s.label', $t, $name);
144
145			return (string)Configure::read($key, $defaultLabel);
146			}
147
148			/**
149			* JSON Schema array of property name
150			*
151			* @param string $name The property name
152			* @param string\|null $objectType The object or resource type to use as schema
153			* @return array\|null
154			*/
155			public function schema(string $name, ?string $objectType = null): ?array
156			{
157			$schema = (array)$this->_View->get('schema');
158			if (!empty($objectType)) {
159			$schemas = (array)$this->_View->get('schemasByType');
160			$schema = (array)Hash::get($schemas, $objectType);
161			}
162			if (Hash::check(self::SPECIAL_PROPS_TYPE, $name)) {
163			return array_filter([
164			'type' => Hash::get(self::SPECIAL_PROPS_TYPE, $name),
165			$name => Hash::get($schema, sprintf('%s', $name)),
166			]);
167			}
168			$res = Hash::get($schema, sprintf('properties.%s', $name));
169
170			return $res === null ? null : (array)$res;
171			}
172
173			/**
174			* Get formatted property value of a resource or object.
175			*
176			* @param array $resource Resource or object data
177			* @param string $property Property name
178			* @return string
179			*/
180			public function value(array $resource, string $property): string
181			{
182			$paths = array_filter([
183			$property,
184			sprintf('attributes.%s', $property),
185			sprintf('meta.%s', $property),
186			(string)Hash::get(self::RELATED_PATHS, $property),
187			]);
188			$value = '';
189			foreach ($paths as $path) {
190			if (Hash::check($resource, $path)) {
191			$value = Hash::get($resource, $path);
192			break;
193			}
194			}
195
196			return $this->Schema->format($value, $this->schema($property));
197			}
198
199			/**
200			* Return translations for object fields and more.
201			*
202			* @return array
203			*/
204			public function translationsMap(): array
205			{
206			try {
207			$key = CacheTools::cacheKey('translationsMap');
208			$map = Cache::remember(
209			$key,
210			function () {
211			$map = [];
212			$keys = [];
213			Configure::load('properties');
214			$properties = (array)Configure::read('DefaultProperties');
215			$removeKeys = ['_element', '_hide', '_keep'];
216			foreach ($properties as $name => $prop) {
217			$keys[] = trim($name);
218			$keys = array_merge($keys, (array)Hash::get($prop, 'fastCreate.all', []));
219			$keys = array_merge($keys, (array)Hash::get($prop, 'index', []));
220			$keys = array_merge($keys, (array)Hash::get($prop, 'filter', []));
221			$groups = array_keys((array)Hash::get($prop, 'view', []));
222			$addKeys = array_reduce($groups, function ($carry, $group) use ($prop, $removeKeys) {
223			$carry[] = $group;
224			$groupKeys = (array)Hash::get($prop, sprintf('view.%s', $group), []);
225			$groupKeys = array_filter(
226			$groupKeys,
227			function ($val, $key) use ($removeKeys) {
228			return is_string($val) && !in_array($key, $removeKeys);
229			},
230			ARRAY_FILTER_USE_BOTH
231			);
232
233			return array_merge($carry, $groupKeys);
234			}, []);
235			$keys = array_merge($keys, $addKeys);
236			}
237			$keys = array_map(function ($key) {
238			return is_array($key) ? array_key_first($key) : $key;
239			}, $keys);
240			$keys = array_diff($keys, $removeKeys);
241			$keys = array_unique($keys);
242			$keys = array_map(function ($key) {
243			return strpos($key, '/') !== false ? substr($key, strrpos($key, '/') + 1) : $key;
244			}, $keys);
245			$properties = (array)Configure::read(sprintf('Properties'));
246			foreach ($properties as $name => $prop) {
247			$keys[] = trim($name);
248			$keys = array_merge($keys, (array)Hash::get($prop, 'fastCreate.all', []));
249			$keys = array_merge($keys, (array)Hash::get($prop, 'index', []));
250			$keys = array_merge($keys, (array)Hash::get($prop, 'filter', []));
251			$groups = array_keys((array)Hash::get($prop, 'view', []));
252			$addKeys = array_reduce($groups, function ($carry, $group) use ($prop, $removeKeys) {
253			$carry[] = $group;
254			$groupKeys = (array)Hash::get($prop, sprintf('view.%s', $group), []);
255			$groupKeys = array_filter(
256			$groupKeys,
257			function ($val, $key) use ($removeKeys) {
258			return is_string($val) && !in_array($key, $removeKeys);
259			},
260			ARRAY_FILTER_USE_BOTH
261			);
262
263			return array_merge($carry, $groupKeys);
264			}, []);
265			$keys = array_merge($keys, $addKeys);
266			}
267			$keys = array_map(function ($key) {
268			return is_array($key) ? array_key_first($key) : $key;
269			}, $keys);
270			$keys = array_diff($keys, $removeKeys);
271			$keys = array_unique($keys);
272			$keys = array_map(function ($key) {
273			return strpos($key, '/') !== false ? substr($key, strrpos($key, '/') + 1) : $key;
274			}, $keys);
275			sort($keys);
276			foreach ($keys as $key) {
277			$map[$key] = (string)Translate::get($key);
278			}
279
280			return $map;
281			}
282			);
283			} catch (\Throwable $e) {
284			$map = [];
285			}
286
287			return $map;
288			}
289
290			/**
291			* Return fast create fields per module map.
292			*
293			* @return array
294			*/
295			public function fastCreateFieldsMap(): array
296			{
297			$defaultTitleType = Configure::read('UI.richeditor.title', []) ? 'textarea' : 'string';
298			$map = [];
299			$properties = (array)Configure::read(sprintf('Properties'));
300			$uploadable = $this->getView()->get('uploadable', []);
301			$defaults = [
302			'objects' => [
303			'all' => [['title' => $defaultTitleType], 'status', 'description'],
304			'required' => ['status', 'title'],
305			],
306			'media' => [
307			'all' => [['title' => $defaultTitleType], 'status', 'name'],
308			'required' => ['name', 'status', 'title'],
309			],
310			];
311			foreach ($properties as $name => $prop) {
312			$cfg = (array)Hash::get($prop, 'fastCreate', []);
313			$defaultFieldMap = in_array($name, $uploadable) ? $defaults['media'] : $defaults['objects'];
314			$fields = (array)Hash::get($cfg, 'all', $defaultFieldMap['all']);
315			$required = (array)Hash::get($cfg, 'required', $defaultFieldMap['required']);
316			$map[$name] = compact('fields', 'required');
317			}
318
319			return $map;
320			}
321
322			/**
323			* Return html for fast create form fields.
324			*
325			* @param string $type The object type
326			* @param string $prefix The prefix
327			* @return string The html for form fields
328			*/
329			public function fastCreateFields(string $type, string $prefix): string
330			{
331			$cfg = (array)Configure::read(sprintf('Properties.%s.fastCreate', $type));
332			$fields = (array)Hash::get($cfg, 'all', ['status', 'title', 'description']);
333			$required = (array)Hash::get($cfg, 'required', ['status', 'title']);
334			$html = '';
335			$jsonKeys = [];
336			$ff = [];
337			foreach ($fields as $field => $fieldType) {
338			$field = is_numeric($field) ? $fieldType : $field;
339			$fieldClass = !in_array($field, $required) ? 'fastCreateField' : 'fastCreateField required';
340			$fieldOptions = [
341			'id' => sprintf('%s%s', $prefix, $field),
342			'class' => $fieldClass,
343			'data-name' => $field,
344			'key' => sprintf('%s-%s', $type, $field),
345			];
346			if ($field === 'date_ranges') {
347			$html .= $this->dateRange($type, $fieldOptions);
348			continue;
349			}
350			if ($fieldType === 'json') {
351			$jsonKeys[] = $field;
352			}
353			$this->prepareFieldOptions($field, $fieldType, $fieldOptions);
354
355			$html .= $this->control($field, '', $fieldOptions, $type);
356			$ff[] = $field;
357			}
358			$jsonKeys = array_unique(array_merge($jsonKeys, (array)Configure::read('_jsonKeys')));
359			$jsonKeys = array_intersect($jsonKeys, $ff);
360
361			if (!empty($jsonKeys)) {
362			$html .= $this->Form->control('_jsonKeys', ['type' => 'hidden', 'value' => implode(',', $jsonKeys)]);
363			}
364
365			return $html;
366			}
367
368			/**
369			* Prepare field options for field.
370			*
371			* @param string $field The field name
372			* @param string\|null $fieldType The field type, if any
373			* @param array $fieldOptions The field options
374			* @return void
375			*/
376			public function prepareFieldOptions(string $field, ?string $fieldType, array &$fieldOptions): void
377			{
378			$method = '';
379			if (!empty($fieldType) && in_array($fieldType, Control::CONTROL_TYPES)) {
380			$methodInfo = Form::getMethod(Control::class, $fieldType);
381			$className = (string)Hash::get($methodInfo, 0);
382			$method = (string)Hash::get($methodInfo, 1);
383			$preserveClass = Hash::get($fieldOptions, 'class', '');
384			$fieldOptions = array_merge($fieldOptions, $className::$method([]));
385			$fieldOptions['class'] .= ' ' . $preserveClass;
386			$fieldOptions['class'] = trim($fieldOptions['class']);
387			}
388			if ($field === 'status') {
389			$fieldOptions['v-model'] = 'object.attributes.status';
390			}
391			}
392
393			/**
394			* Return html for date range fields.
395			*
396			* @param string $type The object type
397			* @param array $options The options
398			* @return string The html for date range fields
399			*/
400			public function dateRange(string $type, array $options): string
401			{
402			$optionsFrom = array_merge($options, [
403			'id' => 'start_date_0',
404			'name' => 'date_ranges[0][start_date]',
405			'v-datepicker' => 'true',
406			'date' => 'true',
407			'time' => 'true',
408			'daterange' => 'true',
409			]);
410			$optionsTo = array_merge($options, [
411			'id' => 'end_date_0',
412			'name' => 'date_ranges[0][end_date]',
413			'v-datepicker' => 'true',
414			'date' => 'true',
415			'time' => 'true',
416			'daterange' => 'true',
417			]);
418			$optionsAllDay = array_merge($options, [
419			'id' => 'all_day_0',
420			'name' => 'date_ranges[0][params][all_day]',
421			'type' => 'checkbox',
422			]);
423			$from = $this->control(__('From'), '', $optionsFrom, $type);
424			$to = $this->control(__('To'), '', $optionsTo, $type);
425			$allDay = $this->control(__('All day'), '', $optionsAllDay, $type);
426
427			return sprintf('<div class="date-ranges-item mb-1"><div>%s%s%s</div></div>', $from, $to, $allDay);
428			}
429			}
430

bedita / manager

PropertyHelper::control() B last analyzed 2025-08-12 07:29 UTC

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like

PropertyHelper::control() B
last analyzed 2025-08-12 07:29 UTC