App\Http\Controllers\Api\ExperienceSkillsController

Complexity

Total Complexity

18

Size/Duplication

Total Lines	143
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	destroy()	0	3	1
B	store()	0	39	6
A	batchUpdate()	0	15	2
A	update()	0	8	1
A	batchStore()	0	36	5
A	indexForApplicant()	0	4	1
A	batchDestroy()	0	11	2

<?php
namespace App\Http\Controllers\Api;

use App\Http\Controllers\Controller;
use App\Http\Requests\BatchStoreExperienceSkill;
use App\Http\Requests\BatchUpdateExperienceSkill;
use App\Http\Requests\StoreExperienceSkill;
use App\Models\Applicant;
use App\Models\ExperienceSkill;
use App\Models\Experience;
use Illuminate\Http\Request;
use Illuminate\Http\Resources\Json\JsonResource;
use Illuminate\Support\Facades\DB;

class ExperienceSkillsController extends Controller
{
    public function indexForApplicant(Applicant $applicant)
    {
        $experienceSkills = $applicant->experienceSkillsQuery()->get();
        return JsonResource::collection($experienceSkills);
    }

    public function store(StoreExperienceSkill $request)
    {
        $validatedData = $request->validated();
        // Restore soft deleted experienceSkill if it exists, otherwise create a new one.
        $softDeletedExperienceSkill = ExperienceSkill::onlyTrashed()
            ->where([
            ['skill_id', $validatedData['skill_id']],
            ['experience_id', $validatedData['experience_id']],
            ['experience_type', $validatedData['experience_type']]
        ])->first();

        // Attach skill to applicant if not already attached.
        $experience = new Experience();
        $experienceInstance = $experience->getExperienceInstance($validatedData['experience_type'], $validatedData['experience_id']);
        $applicantInstance = $experience->getApplicantInstance($experienceInstance);
        if ($applicantInstance !== null) {
            $skillApplicantRelationshipExists = $applicantInstance->skills()
            ->where('skills.id', $validatedData['skill_id'])
            ->exists();
            if ($skillApplicantRelationshipExists !== true) {
                $applicantInstance->skills()->attach($validatedData['skill_id']);
            }
        }

        if ($softDeletedExperienceSkill) {
            if ($validatedData['justification'] !== null && $validatedData['justification'] !== '') {
                $softDeletedExperienceSkill->justification = $validatedData['justification'];
            }
            $softDeletedExperienceSkill->restore();
            $softDeletedExperienceSkill->save();
            return new JsonResource($softDeletedExperienceSkill->fresh());
        } else {
            $experienceSkill = new ExperienceSkill($validatedData);
            $experienceSkill->skill_id = $validatedData['skill_id'];
            $experienceSkill->experience_id = $validatedData['experience_id'];
            $experienceSkill->experience_type = $validatedData['experience_type'];
            $experienceSkill->justification = $validatedData['justification'];
            $experienceSkill->save();
            return new JsonResource($experienceSkill->fresh());
        }
    }

    public function update(Request $request, ExperienceSkill $experienceSkill)
    {
        $validatedData = $request->validate([
            'justification' => 'nullable|string',
        ]);
        $experienceSkill->fill($validatedData);
        $experienceSkill->save();
        return new JsonResource($experienceSkill->fresh());
    }

    public function destroy(ExperienceSkill $experienceSkill)
    {
        $experienceSkill->delete();
    }

    /**
     * Create many new ExperienceSkills at once.
     *
     * @param BatchStoreExperienceSkill $request
     * @return void
     */
    public function batchStore(BatchStoreExperienceSkill $request)
    {
        $validatedResult = $request->validated();
        $newExperienceSkills = collect($validatedResult);

The function collect was not found. Maybe you did not declare it correctly or list all dependencies?

        $response = [];

        DB::transaction(function () use ($newExperienceSkills, &$response) {
            foreach ($newExperienceSkills as $newExperienceSkill) {
                // Restore soft deleted experienceSkill if it exists, otherwise create a new one.
                $softDeletedExperienceSkill = ExperienceSkill::withTrashed()
                    ->where([
                    ['skill_id', $newExperienceSkill['skill_id']],
                    ['experience_id', $newExperienceSkill['experience_id']],
                    ['experience_type', $newExperienceSkill['experience_type']]
                ])->first();
                if ($softDeletedExperienceSkill) {
                    $softDeletedExperienceSkill->restore();
                    if ($newExperienceSkill['justification'] !== null && $newExperienceSkill['justification'] !== '') {
                        $softDeletedExperienceSkill->justification = $newExperienceSkill['justification'];
                    }
                    $softDeletedExperienceSkill->save();
                    array_push($response, $softDeletedExperienceSkill);
                } else {
                    $experienceSkill = new ExperienceSkill($newExperienceSkill);
                    $experienceSkill->skill_id = $newExperienceSkill['skill_id'];
                    $experienceSkill->experience_id = $newExperienceSkill['experience_id'];
                    $experienceSkill->experience_type = $newExperienceSkill['experience_type'];
                    $experienceSkill->justification = $newExperienceSkill['justification'];
                    $experienceSkill->save();
                    $experienceSkill->fresh();
                    array_push($response, $experienceSkill);
                }
            }
        }, 3); // Retry transaction up to three times if deadlock occurs.

        return JsonResource::collection($response);
    }

    /**
     * Update many existing ExperienceSkills at once.
     *
     * @param BatchUpdateExperienceSkill $request
     * @return void
     */
    public function batchUpdate(BatchUpdateExperienceSkill $request)
    {
        $validatedResult = $request->validated();
        $inputData = collect($validatedResult);

The function collect was not found. Maybe you did not declare it correctly or list all dependencies?

        $experienceSkills = ExperienceSkill::whereIn('id', $inputData->pluck('id')->all())->get();

        DB::transaction(function () use ($experienceSkills, $inputData) {
            foreach ($experienceSkills as $experienceSkill) {
                $updatedExperienceSkill = $inputData->firstWhere('id', $experienceSkill->id);
                $experienceSkill->fill($updatedExperienceSkill);
                $experienceSkill->save();
            }
        }, 3); // Retry transaction up to three times if deadlock occurs.

        return JsonResource::collection($experienceSkills->fresh());
    }

    public function batchDestroy(Request $request)
    {
        $experienceSkillIds = $request->validate([
            '*.id' => 'required|exists:App\Models\ExperienceSkill,id',
        ]);
        $experienceSkills = ExperienceSkill::whereIn('id', $experienceSkillIds);
        foreach ($experienceSkills as $experienceSkill) {
            $this->authorize('delete', $experienceSkill);
        }
        $experienceSkills->delete();
        return response()->json(['success' => 'success'], 200);

The function response was not found. Maybe you did not declare it correctly or list all dependencies?

    }
}