autocde2.0/app/Http/Controllers/API/ProjectController.php

<?php

namespace App\Http\Controllers\API;

use App\Http\Controllers\Controller;
use App\Http\Requests\API\Project\CreateOrUpdateRequest;
use App\Http\Requests\API\Project\LinkRequirementByPlanRequest;
use App\Http\Requests\API\Project\LinkRequirementRequest;
use App\Http\Requests\API\Project\PostponeRequest;
use App\Http\Requests\API\Project\UnlinkRequirementRequest;
use App\Http\Resources\API\ProjectAssetResource;
use App\Http\Resources\API\ProjectDetailResource;
use App\Http\Resources\API\SimplePlanResource;
use App\Http\Resources\API\ProjectRequirementResource;
use App\Http\Resources\API\ProjectResource;
use App\Http\Resources\API\RequirementResource;
use App\Models\Asset;
use App\Models\Enums\ObjectAction;
use App\Models\Enums\ProjectStatus;
use App\Models\Plan;
use App\Models\Project;
use App\Models\ProjectAsset;
use App\Models\ProjectPlan;
use App\Models\ProjectRequirement;
use App\Models\Requirement;
use App\Repositories\ActionRepository;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;

class ProjectController extends Controller
{
    /**
     * Display a listing of the resource.
     */
    public function index(Request $request)
    {

        $projectAsset = ProjectAsset::filter($request->all())->simplePaginate();
        foreach ($projectAsset as $item){
                $item->project = Project::find($item->project_id);
                $item->asset = Asset::find($item->asset_id);
        }
        return ProjectAssetResource::collection($projectAsset);
    }

    /**
     * Store a newly created resource in storage.
     */
    public function store(CreateOrUpdateRequest $request)
    {
        $project = new Project();

        $project->mergeFillable([
            'company_id', 'created_by'
        ]);

        $project->fill([
            ...$request->all(),
            'company_id' => Auth::user()->company_id,
            'created_by' => Auth::id(),
            'whitelist' => $request->whitelist ? sprintf(",%s", implode(',', $request->whitelist)) : null,
        ]);

        $project->save();

        ActionRepository::createByProject($project, ObjectAction::CREATED);

        if ($request->has("assets")) {
            foreach ($request->get("assets", []) as $assetId) {
                ProjectAsset::create([
                    'project_id' => $project->id,
                    'asset_id' => $assetId,
                ]);
            }
        }

        if ($request->has("plans")) {
            foreach ($request->get("plans", []) as $planId) {
                ProjectPlan::create([
                    'project_id' => $project->id,
                    'plan_id' => $planId,
                ]);
            }
        }

        return $this->created();
    }

    /**
     * Display the specified resource.
     */
    public function show(string $id)
    {
        $project = Project::findOrFail($id);

        return new ProjectDetailResource($project);
    }

    /**
     * Update the specified resource in storage.
     */
    public function update(CreateOrUpdateRequest $request, string $id)
    {
        $project = Project::findOrFail($id);

        $project->fill([
            ...$request->all(),
            'whitelist' => $request->whitelist ? sprintf(",%s", implode(',', $request->whitelist)) : null,
        ]);

        $project->save();

        ActionRepository::createByProject($project, ObjectAction::EDITED);

        if ($request->has("assets")) {
            ProjectAsset::where('project_id', $project->id)->delete();

            foreach ($request->get("assets", []) as $assetId) {
                ProjectAsset::create([
                    'project_id' => $project->id,
                    'asset_id' => $assetId,
                ]);
            }
        }

        if ($request->has("plans")) {
            ProjectPlan::where('project_id', $project->id)->delete();

            foreach ($request->get("plans", []) as $planId) {
                ProjectPlan::create([
                    'project_id' => $project->id,
                    'plan_id' => $planId,
                ]);
            }
        }

        return $this->noContent();
    }

    /**
     * Remove the specified resource from storage.
     */
    public function destroy(string $id)
    {
        $project = Project::findOrFail($id);

        $project->delete();

        ActionRepository::createByProject($project, ObjectAction::DELETED);

        return $this->noContent();
    }

    public function closed(Request $request, string $id)
    {
        $project = Project::findOrFail($id);

        $project->status = ProjectStatus::CLOSED->value;
        $project->save();

        ActionRepository::createByProject($project, ObjectAction::CLOSED, $request->get("comment"));

        return $this->noContent();
    }

    public function start(Request $request, string $id)
    {
        $project = Project::findOrFail($id);

        $project->status = ProjectStatus::DOING->value;
        $project->save();

        ActionRepository::createByProject($project, ObjectAction::STARTED, $request->get("comment"));

        return $this->noContent();
    }

    public function pause(Request $request, string $id)
    {
        $project = Project::findOrFail($id);

        $project->status = ProjectStatus::PAUSE->value;
        $project->save();

        ActionRepository::createByProject($project, ObjectAction::PAUSED, $request->get("comment"));

        return $this->noContent();
    }

    /**
     * 延期
     *
     * @param PostponeRequest $request
     * @param string $id
     * @return \Illuminate\Http\Response
     */
    public function postpone(PostponeRequest $request, string $id)
    {
        $project = Project::findOrFail($id);

        $project->fill($request->only([
            'begin', 'end'
        ]));
        $project->save();

        ActionRepository::createByProject($project, ObjectAction::DELAY, $request->get("comment"));

        return $this->noContent();
    }

    public function linkRequirement(LinkRequirementRequest $request, string $id)
    {
        $project = Project::findOrFail($id);

        $requirement = Requirement::findOrFail($request->requirement_id);

        $exists = ProjectAsset::query()
            ->where('project_id', $project->id)
            ->where('asset_id', $requirement->asset_id)
            ->count();
        if (! $exists) {
            return $this->forbidden("Please select the correct requirement");
        }

        ProjectRequirement::query()->firstOrCreate([
            'project_id' => $project->id,
            'requirement_id' => $requirement->id,
        ]);

        return $this->noContent();
    }

    public function unlinkRequirement(UnlinkRequirementRequest $request, string $id)
    {
        $project = Project::findOrFail($id);

        $requirement = Requirement::findOrFail($request->requirement_id);

        $exists = ProjectAsset::query()
            ->where('project_id', $project->id)
            ->where('asset_id', $requirement->asset_id)
            ->count();
        if (! $exists) {
            return $this->forbidden("Please select the correct requirement");
        }

        ProjectRequirement::query()->where([
            'project_id' => $project->id,
            'requirement_id' => $requirement->id,
        ])->delete();

        return $this->noContent();
    }

    public function linkRequirementByPlan(LinkRequirementByPlanRequest $request, string $id)
    {
        $project = Project::findOrFail($id);

        $plan = Plan::findOrFail($request->plan_id);

        foreach ($plan->requirements as $requirement) {
            ProjectRequirement::query()->firstOrCreate([
                'project_id' => $project->id, 'requirement_id' => $requirement->id,
            ]);
        }

        return $this->noContent();
    }

    public function plan(string $id)
    {
        $project = Project::findOrFail($id);

        return SimplePlanResource::collection($project->plans);
    }

    public function requirement(string $id)
    {
        $project = Project::findOrFail($id);

        $requirements = $project->requirements()->with(['createdBy'])->simplePaginate();

        return ProjectRequirementResource::collection($requirements);
    }

    public function notLinkAssetRequirement(string $id)
    {
        $project = Project::findOrFail($id);

        $requirements = $project->assets
            ? Requirement::query()->whereIn('asset_id', $project->assets?->pluck('id')->toArray())->simplePaginate()
            : [];

        return RequirementResource::collection($requirements);
    }
}