App\Core\Utility\Form

Complexity

Total Complexity

50

Size/Duplication

Total Lines	464
Duplicated Lines	0 %

Importance

Changes

0

24 Methods

Rating	Name	Duplication	Size	Complexity
A	oldpasswordOptions()	0	9	1
A	datetimeControl()	0	8	1
A	typeFromArray()	0	3	1
A	typeFromBoolean()	0	3	1
A	passwordOptions()	0	7	1
A	endDateOptions()	0	3	1
A	enumControl()	0	18	4
A	jsonControl()	0	7	1
A	getMethod()	0	9	2
A	dateControl()	0	8	1
A	confirmpasswordOptions()	0	11	1
B	typeFromString()	0	13	7
A	checkboxControl()	0	31	6
A	titleOptions()	0	5	1
A	typeFromInteger()	0	3	1
A	startDateOptions()	0	3	1
B	controlTypeFromSchema()	0	20	8
A	typeFromNumber()	0	3	1
A	typeFromObject()	0	3	1
A	langOptions()	0	14	3
A	control()	0	8	2
A	statusOptions()	0	11	1
A	textareaControl()	0	7	1
A	customControlOptions()	0	8	2

<?php
/**
 * BEdita, API-first content management framework
 * Copyright 2018 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\Core\Utility;

use Cake\Core\Configure;
use Cake\Utility\Hash;
use Cake\Utility\Inflector;

class Form
{
    /**
     * Schema property types
     */
    public const SCHEMA_PROPERTY_TYPES = ['string', 'number', 'integer', 'boolean', 'array', 'object'];

    /**
     * Custom controls
     */
    public const CUSTOM_CONTROLS = [
        'confirm-password',
        'end_date',
        'lang',
        'old_password',
        'password',
        'start_date',
        'status',
        'title',
    ];

    /**
     * Control types
     */
    public const CONTROL_TYPES = ['json', 'textarea', 'date-time', 'date', 'checkbox', 'enum'];

    /**
     * Get control by schema, control type, and value
     *
     * @param array $schema Object schema array.
     * @param string $type Control type.
     * @param mixed|null $value Property value.
     * @return array
     */
    public static function control(array $schema, string $type, $value) : array
    {
        if (!in_array($type, Form::CONTROL_TYPES)) {
            return compact('type', 'value');
        }
        $method = Form::getMethod(sprintf('%sControl', $type));

        return call_user_func_array($method, [$value, $schema]);
    }

    /**
     * Control for json data
     *
     * @param mixed|null $value Property value.
     * @return array
     */
    protected static function jsonControl($value) : array
    {
        return [
            'type' => 'textarea',
            'v-jsoneditor' => 'true',
            'class' => 'json',
            'value' => json_encode($value),
        ];
    }

    /**
     * Control for textarea
     *
     * @param mixed|null $value Property value.
     * @return array
     */
    protected static function textareaControl($value) : array
    {
        return [
            'type' => 'textarea',
            'v-richeditor' => 'true',
            'ckconfig' => 'configNormal',
            'value' => $value,
        ];
    }

    /**
     * Control for datetime
     *
     * @param mixed|null $value Property value.
     * @return array
     */
    protected static function datetimeControl($value) : array
    {
        return [
            'type' => 'text',
            'v-datepicker' => 'true',
            'date' => 'true',
            'time' => 'true',
            'value' => $value,
        ];
    }

    /**
     * Control for date
     *
     * @param mixed|null $value Property value.
     * @return array
     */
    protected static function dateControl($value) : array
    {
        return [
            'type' => 'text',
            'v-datepicker' => 'true',
            'date' => 'true',
            'time' => 'false',
            'value' => $value,
        ];
    }

    /**
     * Control for checkbox
     *
     * @param mixed|null $value Property value.
     * @param array $schema Object schema array.
     * @return array
     */
    protected static function checkboxControl($value, array $schema) : array
    {
        if (empty($schema['oneOf'])) {
            return [
                'type' => 'checkbox',
                'checked' => (bool)$value,
            ];
        }

        $options = [];
        foreach ($schema['oneOf'] as $one) {
            if (!empty($one['type']) && ($one['type'] === 'array')) {
                $options = array_map(
                    function ($value) {
                        return ['value' => $value, 'text' => Inflector::humanize($value)];
                    },
                    (array)Hash::extract($one, 'items.enum')
                );
            }
        }
        if (!empty($options)) {
            return [
                'type' => 'select',
                'options' => $options,
                'multiple' => 'checkbox',
            ];
        }

        return [
            'type' => 'checkbox',
            'checked' => (bool)$value,
        ];
    }

    /**
     * Control for enum
     *
     * @param mixed|null $value Property value.
     * @param array $schema Object schema array.
     * @return array
     */
    protected static function enumControl($value, array $schema) : array
    {
        if (!empty($schema['oneOf'])) {
            foreach ($schema['oneOf'] as $one) {
                if (!empty($one['enum'])) {
                    $schema['enum'] = $one['enum'];
                    array_unshift($schema['enum'], '');
                }
            }
        }

        return [
            'type' => 'select',
            'options' => array_map(
                function ($value) {
                    return ['value' => $value, 'text' => Inflector::humanize($value)];
                },
                $schema['enum']
            ),
        ];
    }

    /**
     * Infer control type from property schema
     * Possible return values:
     *
     *   'text'
     *   'date-time'
     *   'date'
     *   'textarea'
     *   'enum'
     *   'number'
     *   'checkbox'
     *   'json'
     *
     * @param mixed $schema The property schema
     * @return string
     */
    public static function controlTypeFromSchema($schema) : string
    {
        if (!is_array($schema)) {
            return 'text';
        }
        if (!empty($schema['oneOf'])) {
            foreach ($schema['oneOf'] as $subSchema) {
                if (!empty($subSchema['type']) && $subSchema['type'] === 'null') {
                    continue;
                }

                return Form::controlTypeFromSchema($subSchema);
            }
        }
        if (empty($schema['type']) || !in_array($schema['type'], Form::SCHEMA_PROPERTY_TYPES)) {
            return 'text';
        }
        $method = Form::getMethod(sprintf('typeFrom%s', ucfirst($schema['type'])));

        return call_user_func_array($method, [$schema]);
    }

    /**
     * Get controls option by property name.
     *
     * @param string $name The field name.
     * @return array
     */
    public static function customControlOptions($name) : array
    {
        if (!in_array($name, Form::CUSTOM_CONTROLS)) {
            return [];
        }
        $method = Form::getMethod(sprintf('%sOptions', $name));

        return call_user_func_array($method, []);
    }

    /**
     * Options for lang
     * If available, use config `Project.I18n.languages`
     *
     * @return array
     */
    protected static function langOptions() : array
    {
        $languages = Configure::read('Project.I18n.languages');
        if (empty($languages)) {
            return [
                'type' => 'text',
            ];
        }
        $options = [];
        foreach ($languages as $key => $description) {
            $options[] = ['value' => $key, 'text' => __($description)];
        }

        return ['type' => 'select'] + compact('options');
    }

    /**
     * Options for `start_date`
     *
     * @return array
     */
    protected static function startDateOptions() : array
    {
        return static::datetimeControl(null);
    }

    /**
     * Options for `end_date`
     *
     * @return array
     */
    protected static function endDateOptions() : array
    {
        return static::datetimeControl(null);
    }

    /**
     * Options for `status` (radio).
     *
     *   - On ('on')
     *   - Draft ('draft')
     *   - Off ('off')
     *
     * @return array
     */
    protected static function statusOptions() : array
    {
        return [
            'type' => 'radio',
            'options' => [
                ['value' => 'on', 'text' => __('On')],
                ['value' => 'draft', 'text' => __('Draft')],
                ['value' => 'off', 'text' => __('Off')],
            ],
            'templateVars' => [
                'containerClass' => 'status',
            ],
        ];
    }

    /**
     * Options for old password
     *
     * @return array
     */
    protected static function oldpasswordOptions() : array
    {
        return [
            'class' => 'password',
            'label' => __('Current password'),
            'placeholder' => __('current password'),
            'autocomplete' => 'current-password',
            'type' => 'password',
            'default' => '',
        ];
    }

    /**
     * Options for password
     *
     * @return array
     */
    protected static function passwordOptions() : array
    {
        return [
            'class' => 'password',
            'placeholder' => __('new password'),
            'autocomplete' => 'new-password',
            'default' => '',
        ];
    }

    /**
     * Options for confirm password
     *
     * @return array
     */
    protected static function confirmpasswordOptions() : array
    {
        return [
            'label' => __('Retype password'),
            'id' => 'confirm_password',
            'name' => 'confirm-password',
            'class' => 'confirm-password',
            'placeholder' => __('confirm password'),
            'autocomplete' => 'new-password',
            'default' => '',
            'type' => 'password',
        ];
    }

    /**
     * Options for title
     *
     * @return array
     */
    protected static function titleOptions() : array
    {
        return [
            'class' => 'title',
            'type' => 'text',
        ];
    }

    /**
     * Get control type per string, according to schema property data.
     * Possibilities:
     *
     *    format 'date-time' => 'date-time'
     *    format 'date' => 'date'
     *    contentMediaType => 'textarea'
     *    schema.enum is an array => 'enum'
     *
     * Return 'text' otherwise.
     *
     * @param array $schema The property schema
     * @return string
     */
    protected static function typeFromString(array $schema) : string
    {
        if (!empty($schema['format']) && in_array($schema['format'], ['date', 'date-time'])) {
            return $schema['format'];
        }
        if (!empty($schema['contentMediaType']) && $schema['contentMediaType'] === 'text/html') {
            return 'textarea';
        }
        if (!empty($schema['enum']) && is_array($schema['enum'])) {
            return 'enum';
        }

        return 'text';
    }

    /**
     * Return the type for number: 'number'
     *
     * @param array $schema Object schema array.
     * @return string
     */
    protected static function typeFromNumber(array $schema) : string
    {
        return 'number';
    }

    /**
     * Return the type for integer: 'number'
     *
     * @param array $schema Object schema array.
     * @return string
     */
    protected static function typeFromInteger(array $schema) : string
    {
        return 'number';
    }

    /**
     * Return the type for boolean: 'checkbox'
     *
     * @param array $schema Object schema array.
     * @return string
     */
    protected static function typeFromBoolean(array $schema) : string
    {
        return 'checkbox';
    }

    /**
     * Return the type for array: 'checkbox'
     *
     * @param array $schema Object schema array.
     * @return string
     */
    protected static function typeFromArray(array $schema) : string
    {
        return 'checkbox';
    }

    /**
     * Return the type for object: 'json'
     *
     * @param array $schema Object schema array.
     * @return string
     */
    protected static function typeFromObject(array $schema) : string
    {
        return 'json';
    }

    /**
     * Return method [Form::class, $methodName], if it's callable.
     * Otherwise, throw \InvalidArgumentException
     *
     * @param string $name The method name
     * @return array
     */
    public static function getMethod(string $name) : array
    {
        $methodName = Inflector::variable(str_replace('-', '_', $name));
        $method = [Form::class, $methodName];
        if (!is_callable($method)) {
            throw new \InvalidArgumentException(sprintf('Method "%s" is not callable', $methodName));
        }

        return $method;
    }
}