KanbanGit/app/Http/Controllers/ProjectController.php

<?php

namespace App\Http\Controllers;

use App\Actions\Permissions\PermissionService;
use App\Actions\Projects\BuildProjectBacklogPayload;
use App\Actions\Projects\CreateProject;
use App\Actions\Projects\DeleteProject;
use App\Actions\Projects\DuplicateProjectConfiguration;
use App\Actions\Projects\ListVisibleProjects;
use App\Actions\Projects\ResolveProjectTemplateState;
use App\Actions\Projects\UpdateProjectTemplateLink;
use App\Enums\Permission;
use App\Http\Requests\DeleteProjectRequest;
use App\Http\Requests\ResetProjectTemplateRequest;
use App\Http\Requests\StoreProjectRequest;
use App\Http\Requests\SwitchProjectTemplateRequest;
use App\Http\Requests\SyncProjectPermissionsRequest;
use App\Http\Resources\PermissionOptionResource;
use App\Http\Resources\ProjectResource;
use App\Http\Resources\ProjectTemplateResource;
use App\Http\Resources\TeamResource;
use App\Http\Resources\UserResource;
use App\Models\Project;
use App\Models\ProjectTemplate;
use App\Models\Team;
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 BuildProjectBacklogPayload $buildProjectBacklogPayload,
        private readonly CreateProject $createProject,
        private readonly DeleteProject $deleteProject,
        private readonly DuplicateProjectConfiguration $duplicateProjectConfiguration,
        private readonly ListVisibleProjects $listVisibleProjects,
        private readonly PermissionService $permissionService,
        private readonly ResolveProjectTemplateState $resolveProjectTemplateState,
        private readonly UpdateProjectTemplateLink $updateProjectTemplateLink,
    ) {}

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

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

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

        $sourceTemplates = ProjectTemplate::query()
            ->published()
            ->with('sourceProject')
            ->orderBy('name')
            ->get();
        $selectedTemplateId = $request->integer('template');

        return Inertia::render('projects/Create', [
            'copyAreaOptions' => DuplicateProjectConfiguration::copyAreaOptions(),
            'sourceProjects' => ProjectResource::collection(
                $this->listVisibleProjects->handle($request->user()),
            )->resolve(),
            'sourceTemplates' => ProjectTemplateResource::collection($sourceTemplates)->resolve(),
            'selectedSourceTemplateId' => $sourceTemplates->contains('id', $selectedTemplateId)
                ? $selectedTemplateId
                : null,
        ]);
    }

    public function store(StoreProjectRequest $request): RedirectResponse
    {
        $project = $this->createProject->handle($request->validated(), $request->user());

        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(),
            'templateState' => $this->resolveProjectTemplateState->handle($project),
        ]);
    }

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

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

        return Inertia::render(
            'projects/Backlog',
            $this->buildProjectBacklogPayload->handle($project, $user, session('status')),
        );
    }

    public function general(Request $request, Project $project): Response
    {
        return Inertia::render('projects/settings/General', [
            'project' => ProjectResource::make($project)->resolve(),
            'sourceTemplates' => ProjectTemplateResource::collection(
                ProjectTemplate::query()
                    ->published()
                    ->with('sourceProject')
                    ->orderBy('name')
                    ->get(),
            )->resolve(),
            'status' => session('status'),
            'templateState' => $this->resolveProjectTemplateState->handle($project),
        ]);
    }

    public function switchTemplate(SwitchProjectTemplateRequest $request, Project $project): RedirectResponse
    {
        $validated = $request->validated();
        $template = ProjectTemplate::query()
            ->published()
            ->findOrFail((int) Arr::get($validated, 'source_template_id'));

        $this->updateProjectTemplateLink->switch($project, $template);

        return to_route('projects.settings.general', $project)
            ->with('status', "{$project->name} now uses the {$template->name} template.");
    }

    public function resetTemplate(ResetProjectTemplateRequest $request, Project $project): RedirectResponse
    {
        $validated = $request->validated();

        $template = $project->projectTemplate;

        abort_if($template === null, 422, 'This project has no linked template to reset.');

        $configuration = $this->duplicateProjectConfiguration->normalizeConfiguration(
            $template->configuration_snapshot ?? [],
        );
        $areas = array_values(Arr::get($validated, 'areas', array_keys($configuration)));
        $statusReplacements = Arr::get($validated, 'status_replacements', []);

        $this->updateProjectTemplateLink->reset(
            $project->load('projectTemplate'),
            $areas,
            $statusReplacements,
        );

        $status = Arr::has($validated, 'areas')
            ? "Selected settings were reset to the {$template->name} template."
            : "{$project->name} was reset to the {$template->name} template baseline.";

        return back()->with('status', $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 = $this->deleteProject->handle($project);

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