KanbanGit/app/Http/Controllers/ProjectController.php

<?php

namespace App\Http\Controllers;

use App\Actions\Permissions\PermissionService;
use App\Actions\ProjectTicketMetadata\InitializeProjectTicketMetadata;
use App\Enums\Permission;
use App\Http\Requests\DeleteProjectRequest;
use App\Http\Requests\StoreProjectRequest;
use App\Http\Requests\SyncProjectPermissionsRequest;
use App\Http\Resources\PermissionOptionResource;
use App\Http\Resources\ProjectResource;
use App\Http\Resources\TeamResource;
use App\Http\Resources\TicketPriorityResource;
use App\Http\Resources\TicketResource;
use App\Http\Resources\TicketStatusResource;
use App\Http\Resources\TicketTypeResource;
use App\Http\Resources\UserResource;
use App\Models\Project;
use App\Models\Team;
use App\Models\Ticket;
use App\Models\User;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Arr;
use Inertia\Inertia;
use Inertia\Response;

class ProjectController extends Controller
{
    public function __construct(
        private readonly InitializeProjectTicketMetadata $initializeProjectTicketMetadata,
        private readonly PermissionService $permissionService,
    ) {}

    public function index(Request $request): Response
    {
        $user = $request->user();

        $projectQuery = Project::query()
            ->orderByDesc('id');

        if (! $this->permissionService->allows($user, Permission::GlobalAdmin)) {
            $viewableProjectIds = $this->permissionService->viewableProjectIds($user);

            if ($viewableProjectIds === []) {
                return Inertia::render('projects/Index', [
                    'projects' => ProjectResource::collection(collect())->resolve(),
                    'status' => session('status'),
                ]);
            }

            $projectQuery->whereIn('id', $viewableProjectIds);
        }

        return Inertia::render('projects/Index', [
            'projects' => ProjectResource::collection($projectQuery->get())->resolve(),
            'status' => session('status'),
        ]);
    }

    public function create(Request $request): Response
    {
        abort_unless(
            $this->permissionService->allows($request->user(), Permission::ProjectCreate),
            403,
        );

        return Inertia::render('projects/Create');
    }

    public function store(StoreProjectRequest $request): RedirectResponse
    {
        $project = Project::query()->create($request->validated());
        $this->initializeProjectTicketMetadata->handle($project);
        $this->permissionService->grant($request->user(), Permission::ProjectAdmin, $project);

        return to_route('projects.show', $project);
    }

    public function show(Request $request, Project $project): Response
    {
        $user = $request->user();

        abort_unless(
            $this->permissionService->allows($user, Permission::ProjectRead, $project),
            403,
        );

        return Inertia::render('projects/Show', [
            'canManageAccess' => $this->permissionService->allows($user, Permission::ProjectAdmin, $project),
            'project' => ProjectResource::make($project)->resolve(),
        ]);
    }

    public function backlog(Request $request, Project $project): Response
    {
        $user = $request->user();

        abort_unless(
            $this->permissionService->allows($user, Permission::ProjectRead, $project),
            403,
        );

        $canManageTickets = $this->permissionService->allows($user, Permission::ProjectWrite, $project);

        return Inertia::render('projects/Backlog', [
            'backlogTicketStatuses' => TicketStatusResource::collection(
                $project->ticketStatuses()
                    ->whereNull('board_column_id')
                    ->get(),
            )->resolve(),
            'canCreateTickets' => $canManageTickets,
            'canEditTickets' => $canManageTickets,
            'project' => ProjectResource::make($project)->resolve(),
            'status' => session('status'),
            'ticketStatusOptions' => TicketStatusResource::collection(
                $project->ticketStatuses()
                    ->with('boardColumn')
                    ->get(),
            )->resolve(),
            'ticketPriorities' => TicketPriorityResource::collection($project->ticketPriorities()->get())->resolve(),
            'ticketTypes' => TicketTypeResource::collection($project->ticketTypes()->get())->resolve(),
            'tickets' => TicketResource::collection(
                Ticket::query()
                    ->with([
                        'ticketPriority',
                        'ticketStatus.allowedTargetStatuses.boardColumn',
                        'ticketStatus.boardColumn',
                        'ticketType',
                    ])
                    ->where('project_id', $project->id)
                    ->whereHas('ticketStatus', fn ($query) => $query->whereNull('board_column_id'))
                    ->orderByDesc('sequence_number')
                    ->get(),
            )->resolve(),
            'users' => UserResource::collection(
                User::query()
                    ->orderBy('name')
                    ->get(),
            )->resolve(),
        ]);
    }

    public function general(Request $request, Project $project): Response
    {
        return Inertia::render('projects/settings/General', [
            'project' => ProjectResource::make($project)->resolve(),
            'status' => session('status'),
        ]);
    }

    public function access(Request $request, Project $project): Response
    {
        $user = $request->user();
        abort_unless(
            $this->permissionService->allows($user, Permission::ProjectAdmin, $project),
            403,
        );

        return Inertia::render('projects/Access', [
            'directPermissions' => $this->permissionService->assignmentMap(User::class, $project),
            'permissionOptions' => PermissionOptionResource::collection(
                $this->permissionService->permissionOptions(User::class, Project::class),
            )->resolve(),
            'project' => ProjectResource::make($project)->resolve(),
            'status' => session('status'),
            'teamPermissions' => $this->permissionService->assignmentMap(Team::class, $project),
            'teams' => TeamResource::collection(
                Team::query()
                    ->with('users')
                    ->orderBy('name')
                    ->get(),
            )->resolve(),
            'users' => UserResource::collection(
                User::query()
                    ->orderBy('name')
                    ->get(),
            )->resolve(),
        ]);
    }

    public function updateUserPermissions(
        SyncProjectPermissionsRequest $request,
        Project $project,
        User $user,
    ): RedirectResponse {

        abort_unless(
            $this->permissionService->allows($request->user(), Permission::ProjectAdmin, $project),
            403,
        );

        $validated = $request->validated();
        $permissions = Arr::get($validated, 'permissions', []);

        $this->permissionService->sync($user, $project, $permissions);

        return to_route('projects.access', $project)
            ->with('status', "{$user->name} permissions were updated.");
    }

    public function updateTeamPermissions(
        SyncProjectPermissionsRequest $request,
        Project $project,
        Team $team,
    ): RedirectResponse {
        abort_unless(
            $this->permissionService->allows($request->user(), Permission::ProjectAdmin, $project),
            403,
        );

        $validated = $request->validated();
        $permissions = Arr::get($validated, 'permissions', []);

        $this->permissionService->sync($team, $project, $permissions);

        return to_route('projects.access', $project)
            ->with('status', "{$team->name} permissions were updated.");
    }

    public function destroy(DeleteProjectRequest $request, Project $project): RedirectResponse
    {
        $request->validated();

        $projectName = $project->name;

        $project->delete();

        return to_route('projects.index')
            ->with('status', "Project {$projectName} was deleted.");
    }
}