ldc-groupe/app/Http/Requests/Back/UpdateDynamicFieldRequest.php

<?php

namespace App\Http\Requests\Back;

use App\Enums\DynamicFieldTypes;
use App\Models\PageConfig;
use Illuminate\Foundation\Http\FormRequest;
use Illuminate\Support\Str;
use Illuminate\Validation\ValidationException;
use Uwil\LaravelCommon\Helpers\ToolboxHelper;

abstract class UpdateDynamicFieldRequest extends FormRequest
{
    /** @var \App\Models\PageConfig|null $configModel */
    private $configModel = null;

    /** @var string $fieldName */
    private $fieldName = "content";

    /**
     * Determine if the user is authorized to make this request.
     *
     * @return boolean
     */
    public function authorize(): bool
    {
        return auth('backend')->check();
    }

    /**
     * Prepare the data for validation.
     *
     * @return void
     */
    protected function prepareForValidation(): void
    {
        $this->configModel = PageConfig::query()->whereKey($this->input('config_id'))->firstOrFail();
    }

    /**
     * Get the validation rules that apply to the request.
     *
     * @return array
     * @phpcs:disable Generic.Metrics.CyclomaticComplexity.TooHigh
     * @phpcs:disable Generic.Metrics.NestingLevel.TooHigh
     */
    public function rules(): array
    {
        // phpcs:enable
        $rules = [];
        foreach ($this->configModel->config as $input) {
            $ruleKey = "$this->fieldName.$input[key]";
            switch ($input['type']) {
                case DynamicFieldTypes::string->value:
                    $rules = array_merge($rules, [
                        $ruleKey => $this->compileValidate('required|string|min:3', $input)
                    ]);
                    break;
                case DynamicFieldTypes::text->value:
                    $mergeRules = $this->compileValidate('required|string|min:15', $input);
                    $mergeRules = collect($mergeRules)
                        ->map(function ($rule) {
                            if (\strpos($rule, 'max:') !== false) {
                                $max = \intval(str_replace('max:', '', $rule));
                                return function ($attribute, $value, $fail) use ($max) {
                                    if (\strlen(\strip_tags($value)) > $max) {
                                        $fail("$attribute ne doit pas excéder $max caractères");
                                    }
                                };
                            }
                            return $rule;
                        })->all();
                    $rules      = array_merge($rules, [
                        $ruleKey => $mergeRules
                    ]);
                    break;
                case DynamicFieldTypes::number->value:
                    $rules = array_merge($rules, [
                        $ruleKey => $this->compileValidate('required|numeric', $input)
                    ]);
                    break;
                case DynamicFieldTypes::boolean->value:
                    $all    = $this->all();
                    $nested = ToolboxHelper::dotStringToNestedArray(
                        $ruleKey,
                        $this->input($ruleKey) ? true : false
                    );
                    $all    = ToolboxHelper::arrayMergeRecursiveDistinct($all, $nested);
                    $this->merge($all);
                    $rules = array_merge($rules, [
                        $ruleKey => $this->compileValidate('boolean', $input)
                    ]);
                    break;
                case DynamicFieldTypes::url->value:
                    $rules = array_merge($rules, [
                        $ruleKey => [
                            'required',
                            'url',
                            // @phpcs:ignore Generic.CodeAnalysis.UnusedFunctionParameter.FoundInExtendedClassBeforeLastUsed
                            function ($attribute, $value, $fail) {
                                try {
                                    ToolboxHelper::assertNoInternalUrls($attribute, $value);
                                    ToolboxHelper::assertNoInternalBoUrls($attribute, $value);
                                } catch (ValidationException $e) {
                                    $fail(collect($e->errors())->first()[0]);
                                }
                            }
                        ]
                    ]);
                    break;
                case DynamicFieldTypes::email->value:
                    $rules = array_merge($rules, [
                        $ruleKey => $this->compileValidate('required|email|min:3', $input)
                    ]);
                    break;
            } //end switch
        } //end foreach
        return $rules;
    }

    /**
     * Get custom attributes for validator errors.
     *
     * @return array
     */
    public function attributes(): array
    {
        $attributes = [];
        foreach ($this->configModel->config as $input) {
            $attributeKey = "$this->fieldName.$input[key]";
            $attributes   = array_merge($attributes, [
                $attributeKey => Str::lower($input['label']),
            ]);
        }
        return $attributes;
    }

    /**
     * Merge native validations and custom validations.
     *
     * @param string|array $inputTypeValidate
     * @param array        $input
     * @return array
     * @phpcs:disable Generic.Metrics.CyclomaticComplexity.TooHigh
     */
    private function compileValidate(string|array $inputTypeValidate, array $input): array
    {
        // phpcs:enable
        if (\is_string($inputTypeValidate)) {
            $inputTypeValidate = explode('|', $inputTypeValidate);
        }
        /** @var array|string */
        $inputValidate = \collect($input)->get('validation', $input);
        $inputValidate = \is_string($inputValidate) ? explode('|', $inputValidate) : $inputValidate;
        foreach ($inputValidate as $validate) {
            if (!\in_array($validate, $inputTypeValidate)) {
                $inputTypeValidate[] = $validate;
            }
        }

        $rules = \collect($inputTypeValidate)->unique()->sort(function ($valueA, $valueB) {
            $valueA = $this->ruleHasToComeFirst($valueA);
            $valueB = $this->ruleHasToComeFirst($valueB);
            return $valueA - $valueB;
        });

        $hasRequire     = $rules->first(fn($rule) => $rule === 'required') ? true : false;
        $hasRequireCond = $rules->first(fn($rule) => \strpos($rule, 'required_') !== false) ? true : false;
        $hasNullable    = $rules->first(fn($rule) => \strpos($rule, 'nullable') !== false) ? true : false;
        $hasSometime    = $rules->first(fn($rule) => \strpos($rule, 'sometimes') !== false) ? true : false;
        $hasPresent     = $rules->first(fn($rule) => \strpos($rule, 'present') !== false) ? true : false;

        if ($hasRequire and ($hasRequireCond or $hasNullable or $hasSometime or $hasPresent)) {
            $rules = $rules->reject(fn($rule) => $rule === 'required');
        }
        return $rules->all();
    }

    /**
     * Does the rule need to come first ?
     *
     * @param string $rule
     * @return integer
     */
    private function ruleHasToComeFirst(string $rule): int
    {
        $rule    = \collect(\explode(':', $rule, 2))->filter()->first(null, '');
        $rules   = \collect([
            'required_if',
            'required_unless',
            'required_with',
            'required_with_all',
            'required_without',
            'required_without_all',
            'required_with_all',
            'missing',
            'missing_if',
            'missing_unless',
            'missing_with',
            'missing_with_all',
            'nullable',
            'sometimes',
            'present',
            'required'
        ]);
        $itemKey = $rules->search(fn(string $firstRule) =>  \strpos($rule, $firstRule) === 0);
        if (\is_bool($itemKey)) {
            return $rules->count() + 1;
        }
        return $itemKey;
    }
}