KanbanGit/app/Http/Requests/UpdateProjectTicketRequest.php

<?php

namespace App\Http\Requests;

use App\Models\Project;
use App\Models\Ticket;
use App\Models\TicketType;
use Illuminate\Contracts\Validation\ValidationRule;
use Illuminate\Foundation\Http\FormRequest;
use Illuminate\Support\Arr;
use Illuminate\Validation\Rule;
use Illuminate\Validation\Validator;

class UpdateProjectTicketRequest extends FormRequest
{
    /**
     * Determine if the user is authorized to make this request.
     */
    public function authorize(): bool
    {
        return $this->user() !== null;
    }

    /**
     * Get the validation rules that apply to the request.
     *
     * @return array<string, ValidationRule|array<mixed>|string>
     */
    public function rules(): array
    {
        /** @var Project $project */
        $project = $this->route('project');

        return [
            'acceptance_criteria' => ['nullable', 'string'],
            'blocked_comment' => ['nullable', 'string'],
            'description' => ['nullable', 'string'],
            'field_values' => ['array'],
            'field_values.*' => ['array'],
            'field_values.*.ticket_field_definition_id' => [
                'required',
                'integer',
                Rule::exists('ticket_field_definitions', 'id')->where('project_id', $project->id),
            ],
            'field_values.*.value_number' => ['nullable', 'numeric'],
            'field_values.*.value_user_id' => ['nullable', 'integer', Rule::exists('users', 'id')],
            'is_blocked' => ['required', 'boolean'],
            'parent_ticket_id' => [
                'nullable',
                'integer',
                Rule::exists('tickets', 'id')->where('project_id', $project->id),
            ],
            'ticket_priority_id' => [
                'required',
                'integer',
                Rule::exists('ticket_priorities', 'id')->where('project_id', $project->id),
            ],
            'ticket_type_id' => [
                'required',
                'integer',
                Rule::exists('ticket_types', 'id')->where('project_id', $project->id),
            ],
            'title' => ['required', 'string', 'max:255'],
        ];
    }

    /**
     * @return array<int, callable(Validator): void>
     */
    public function after(): array
    {
        return [
            function (Validator $validator): void {
                /** @var Project $project */
                $project = $this->route('project');

                /** @var Ticket $ticket */
                $ticket = $this->route('ticket');

                $parentTicketId = $this->input('parent_ticket_id');
                $parentTicketId = is_numeric($parentTicketId) ? (int) $parentTicketId : null;

                if ($parentTicketId !== null) {
                    if ($parentTicketId === $ticket->id) {
                        $validator->errors()->add('parent_ticket_id', 'A ticket cannot be its own parent.');

                        return;
                    }

                    $parentTicket = Ticket::query()
                        ->where('project_id', $project->id)
                        ->with('ticketType')
                        ->find($parentTicketId);

                    if ($parentTicket !== null && $parentTicket->ticketType?->system_key !== 'parent') {
                        $validator->errors()->add('parent_ticket_id', 'Only tickets of type Parent can be selected as a parent.');

                        return;
                    }

                    if ($parentTicket !== null && $this->createsCycle($ticket, $parentTicket)) {
                        $validator->errors()->add('parent_ticket_id', 'A ticket cannot be assigned to one of its descendants.');

                        return;
                    }
                }

                $requestedTicketTypeId = $this->input('ticket_type_id');
                $requestedTicketType = is_numeric($requestedTicketTypeId)
                    ? TicketType::query()
                        ->where('project_id', $project->id)
                        ->find((int) $requestedTicketTypeId)
                    : null;

                if (
                    $requestedTicketType?->system_key !== 'parent'
                    && $ticket->childTickets()->exists()
                ) {
                    $validator->errors()->add('ticket_type_id', 'Tickets with child tickets must keep a Parent type.');
                }

                if ($this->boolean('is_blocked') && blank($this->input('blocked_comment'))) {
                    $validator->errors()->add('blocked_comment', 'Blocked tickets require a blocker comment.');
                }
            },
        ];
    }

    /**
     * @return array{
     *     acceptance_criteria: string|null,
     *     blocked_comment: string|null,
     *     description: string|null,
     *     is_blocked: bool,
     *     parent_ticket_id: int|null,
     *     ticket_priority_id: int,
     *     ticket_type_id: int,
     *     title: string
     * }
     */
    public function ticketAttributes(): array
    {
        /** @var array{
         *     acceptance_criteria: string|null,
         *     blocked_comment: string|null,
         *     description: string|null,
         *     is_blocked: bool,
         *     parent_ticket_id: int|null,
         *     ticket_priority_id: int,
         *     ticket_type_id: int,
         *     title: string
         * } $attributes
         */
        $attributes = array_merge(
            [
                'acceptance_criteria' => null,
                'blocked_comment' => null,
                'description' => null,
                'is_blocked' => false,
                'parent_ticket_id' => null,
            ],
            Arr::only($this->validated(), [
                'acceptance_criteria',
                'blocked_comment',
                'description',
                'is_blocked',
                'parent_ticket_id',
                'ticket_priority_id',
                'ticket_type_id',
                'title',
            ]),
        );

        return $attributes;
    }

    /**
     * @return array<int, array{
     *     ticket_field_definition_id: int,
     *     value_number?: float|int|string|null,
     *     value_user_id?: int|string|null
     * }>
     */

    private function createsCycle(Ticket $ticket, Ticket $candidateParent): bool
    {
        $currentParent = $candidateParent;

        while ($currentParent !== null) {
            if ($currentParent->id === $ticket->id) {
                return true;
            }

            if ($currentParent->parent_ticket_id === null) {
                return false;
            }

            $currentParent = Ticket::query()->find($currentParent->parent_ticket_id);
        }

        return false;
    }
}