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\Requests\API\Project\UpdateLinkAssetsRequest;
use App\Http\Resources\API\AssetRequirementResource;
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\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;
use Illuminate\Support\Facades\DB;

class ProjectController extends Controller
{
    /**
     * Display a listing of the resource.
     */
    public function index(Request $request)
    {
        $projectAsset = Project::filter($request->all())->simplePaginate();
        return ProjectResource::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)
    {

        $requirementIds = $request->get("requirement_id",[]);
        $project = Project::findOrFail($id);


        if(! $requirementIds){
            return $this->forbidden("Please select the correct requirement");
        }

//        $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");
//        }
        DB::transaction(function () use ($requirementIds,$project) {
            foreach ($requirementIds as $requirementId) {
                ProjectRequirement::query()->firstOrCreate([
                    'project_id' => $project->id,
                    'requirement_id' => $requirementId,
                ]);
            }
        });


        return $this->noContent();
    }

    public function unlinkRequirement(UnlinkRequirementRequest $request, string $id)
    {

        $requirementIds = $request->get("requirement_id",[]);
        $project = Project::findOrFail($id);

        if (! $requirementIds) {
            return $this->forbidden("Please select the correct requirement");
        }

        if($project->requirements->isEmpty()){
            return $this->forbidden("Project has no associated requirements");
        }

        DB::transaction(function () use ($requirementIds,$project) {
            foreach ($requirementIds as $requirement) {
                ProjectRequirement::query()->where([
                    'project_id' => $project->id,
                    'requirement_id' => $requirement,
                ])->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())->whereNotIn('id', $project->requirements?->pluck('id')->toArray())->simplePaginate()
            : [];

        return AssetRequirementResource::collection($requirements);
    }

    public function updateLinkAssets(UpdateLinkAssetsRequest $request,string $project_id)
    {
        $project = Project::find($project_id);
        if (is_null($project)){
        return   $this->badRequest('project does not exist');
        }
        $assetsIds = $request->assets;
        DB::transaction(function () use ($project_id,$assetsIds) {
            ProjectAsset::where('project_id', $project_id)->delete();
            foreach ($assetsIds as $assetId) {
                ProjectAsset::create([
                    'project_id' => $project_id,
                    'asset_id' => $assetId,
                ]);
            }
        });
        return $this->noContent();
    }
}