PropertyHelper::translationsMap() - Code Metrics - Inspection of "Merge pull request #1225 from didoda/feat/fast-cre..." - bedita/manager - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( b1bbae...a2502b )

by Dante

created 2025-02-17 10:49 UTC

PropertyHelper::translationsMap() B

↳ Parent: PropertyHelper

Complexity

Conditions	7
Paths	3

Size

Total Lines	51
Code Lines	38

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	1	Features	0

Metric	Value
cc	7
eloc	38
c	1
b	1
f	0
nc	3
nop	0
dl	0
loc	51
rs	8.3786

How to fix Long Method

<?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 (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 = (string)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 = [];
                    $properties = (array)Configure::read(sprintf('Properties'));
                    $removeKeys = ['_element', '_hide', '_keep'];
                    foreach ($properties as $name => $prop) {
                        $keys[] = $name;
                        $keys = array_merge($keys, (array)Hash::get($prop, 'fastCreate.all', []));
                        $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 (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 = (string)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			$properties = (array)Configure::read(sprintf('Properties'));
214			$removeKeys = ['_element', '_hide', '_keep'];
215			foreach ($properties as $name => $prop) {
216			$keys[] = $name;
217			$keys = array_merge($keys, (array)Hash::get($prop, 'fastCreate.all', []));
218			$groups = array_keys((array)Hash::get($prop, 'view', []));
219			$addKeys = array_reduce($groups, function ($carry, $group) use ($prop, $removeKeys) {
220			$carry[] = $group;
221			$groupKeys = (array)Hash::get($prop, sprintf('view.%s', $group), []);
222			$groupKeys = array_filter(
223			$groupKeys,
224			function ($val, $key) use ($removeKeys) {
225			return is_string($val) && !in_array($key, $removeKeys);
226			},
227			ARRAY_FILTER_USE_BOTH
228			);
229
230			return array_merge($carry, $groupKeys);
231			}, []);
232			$keys = array_merge($keys, $addKeys);
233			}
234			$keys = array_map(function ($key) {
235			return is_array($key) ? array_key_first($key) : $key;
236			}, $keys);
237			$keys = array_diff($keys, $removeKeys);
238			$keys = array_unique($keys);
239			$keys = array_map(function ($key) {
240			return strpos($key, '/') !== false ? substr($key, strrpos($key, '/') + 1) : $key;
241			}, $keys);
242			sort($keys);
243			foreach ($keys as $key) {
244			$map[$key] = (string)Translate::get($key);
245			}
246
247			return $map;
248			}
249			);
250			} catch (\Throwable $e) {
251			$map = [];
252			}
253
254			return $map;
255			}
256
257			/**
258			* Return fast create fields per module map.
259			*
260			* @return array
261			*/
262			public function fastCreateFieldsMap(): array
263			{
264			$defaultTitleType = Configure::read('UI.richeditor.title', []) ? 'textarea' : 'string';
265			$map = [];
266			$properties = (array)Configure::read(sprintf('Properties'));
267			$uploadable = $this->getView()->get('uploadable', []);
268			$defaults = [
269			'objects' => [
270			'all' => [['title' => $defaultTitleType], 'status', 'description'],
271			'required' => ['status', 'title'],
272			],
273			'media' => [
274			'all' => [['title' => $defaultTitleType], 'status', 'name'],
275			'required' => ['name', 'status', 'title'],
276			],
277			];
278			foreach ($properties as $name => $prop) {
279			$cfg = (array)Hash::get($prop, 'fastCreate', []);
280			$defaultFieldMap = in_array($name, $uploadable) ? $defaults['media'] : $defaults['objects'];
281			$fields = (array)Hash::get($cfg, 'all', $defaultFieldMap['all']);
282			$required = (array)Hash::get($cfg, 'required', $defaultFieldMap['required']);
283			$map[$name] = compact('fields', 'required');
284			}
285
286			return $map;
287			}
288
289			/**
290			* Return html for fast create form fields.
291			*
292			* @param string $type The object type
293			* @param string $prefix The prefix
294			* @return string The html for form fields
295			*/
296			public function fastCreateFields(string $type, string $prefix): string
297			{
298			$cfg = (array)Configure::read(sprintf('Properties.%s.fastCreate', $type));
299			$fields = (array)Hash::get($cfg, 'all', ['status', 'title', 'description']);
300			$required = (array)Hash::get($cfg, 'required', ['status', 'title']);
301			$html = '';
302			$jsonKeys = [];
303			$ff = [];
304			foreach ($fields as $field => $fieldType) {
305			$field = is_numeric($field) ? $fieldType : $field;
306			$fieldClass = !in_array($field, $required) ? 'fastCreateField' : 'fastCreateField required';
307			$fieldOptions = [
308			'id' => sprintf('%s%s', $prefix, $field),
309			'class' => $fieldClass,
310			'data-name' => $field,
311			'key' => sprintf('%s-%s', $type, $field),
312			];
313			if ($field === 'date_ranges') {
314			$html .= $this->dateRange($type, $fieldOptions);
315			continue;
316			}
317			if ($fieldType === 'json') {
318			$jsonKeys[] = $field;
319			}
320			$this->prepareFieldOptions($field, $fieldType, $fieldOptions);
321
322			$html .= $this->control($field, '', $fieldOptions, $type);
323			$ff[] = $field;
324			}
325			$jsonKeys = array_unique(array_merge($jsonKeys, (array)Configure::read('_jsonKeys')));
326			$jsonKeys = array_intersect($jsonKeys, $ff);
327
328			if (!empty($jsonKeys)) {
329			$html .= $this->Form->control('_jsonKeys', ['type' => 'hidden', 'value' => implode(',', $jsonKeys)]);
330			}
331
332			return $html;
333			}
334
335			/**
336			* Prepare field options for field.
337			*
338			* @param string $field The field name
339			* @param string\|null $fieldType The field type, if any
340			* @param array $fieldOptions The field options
341			* @return void
342			*/
343			public function prepareFieldOptions(string $field, ?string $fieldType, array &$fieldOptions): void
344			{
345			$method = '';
346			if (!empty($fieldType) && in_array($fieldType, Control::CONTROL_TYPES)) {
347			$methodInfo = Form::getMethod(Control::class, $fieldType);
348			$className = (string)Hash::get($methodInfo, 0);
349			$method = (string)Hash::get($methodInfo, 1);
350			$preserveClass = Hash::get($fieldOptions, 'class', '');
351			$fieldOptions = array_merge($fieldOptions, $className::$method([]));
352			$fieldOptions['class'] .= ' ' . $preserveClass;
353			$fieldOptions['class'] = trim($fieldOptions['class']);
354			}
355			if ($field === 'status') {
356			$fieldOptions['v-model'] = 'object.attributes.status';
357			}
358			}
359
360			/**
361			* Return html for date range fields.
362			*
363			* @param string $type The object type
364			* @param array $options The options
365			* @return string The html for date range fields
366			*/
367			public function dateRange(string $type, array $options): string
368			{
369			$optionsFrom = array_merge($options, [
370			'id' => 'start_date_0',
371			'name' => 'date_ranges[0][start_date]',
372			'v-datepicker' => 'true',
373			'date' => 'true',
374			'time' => 'true',
375			'daterange' => 'true',
376			]);
377			$optionsTo = array_merge($options, [
378			'id' => 'end_date_0',
379			'name' => 'date_ranges[0][end_date]',
380			'v-datepicker' => 'true',
381			'date' => 'true',
382			'time' => 'true',
383			'daterange' => 'true',
384			]);
385			$optionsAllDay = array_merge($options, [
386			'id' => 'all_day_0',
387			'name' => 'date_ranges[0][params][all_day]',
388			'type' => 'checkbox',
389			]);
390			$from = $this->control(__('From'), '', $optionsFrom, $type);
391			$to = $this->control(__('To'), '', $optionsTo, $type);
392			$allDay = $this->control(__('All day'), '', $optionsAllDay, $type);
393
394			return sprintf('<div class="date-ranges-item mb-1"><div>%s%s%s</div></div>', $from, $to, $allDay);
395			}
396			}
397

bedita / manager

Push — master ( b1bbae...a2502b )

PropertyHelper::translationsMap() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like