App\Services\Validation\ApplicationValidator

Complexity

Total Complexity

21

Size/Duplication

Total Lines	169
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	assetSkillsComplete()	0	2	1
A	basicsValidator()	0	27	3
A	arrayMapKeys()	0	6	2
A	skillsValidator()	0	25	4
A	essentialSkillsComplete()	0	2	1
A	experienceValidator()	0	3	1
A	basicsComplete()	0	3	1
A	essentialSkillsValidator()	0	2	1
A	affirmationValidator()	0	14	1
A	validate()	0	32	1
A	affirmationComplete()	0	2	1
A	addNestedValidatorRules()	0	9	1
A	assetSkillsValidator()	0	2	1
A	experienceComplete()	0	2	1

<?php

Missing file doc comment

namespace App\Services\Validation;

use App\Models\JobApplication;
use Illuminate\Support\Facades\Validator;
use Illuminate\Validation\Rule;
use Illuminate\Validation\Validator as BaseValidator;
use App\Models\Lookup\CitizenshipDeclaration;
use App\Models\Lookup\CriteriaType;
use App\Models\Lookup\VeteranStatus;
use App\Models\Lookup\PreferredLanguage;
use App\Services\Validation\Rules\ContainsObjectWithAttributeRule;
use App\Services\Validation\JobApplicationAnswerValidator;

class ApplicationValidator {

Missing doc comment for class ApplicationValidator

Opening brace of a class must be on the line after the definition

    protected $citizenship_ids;
    protected $veteran_status_ids;
    protected $preferred_language_ids;

    public function __construct() {

Missing doc comment for function __construct()

        $this->citizenship_ids = CitizenshipDeclaration::all()->pluck('id')->toArray();
        $this->veteran_status_ids = VeteranStatus::all()->pluck('id')->toArray();
        $this->preferred_language_ids = PreferredLanguage::all()->pluck('id')->toArray();
    }

    public function validate(JobApplication $application) {

Missing doc comment for function validate()

        $backendRules = [
            'job_poster_id' => 'required',
            'application_status_id' => 'required',
            'applicant_id' => 'required'
        ];

        $rules = array_merge(
            $backendRules,
            //$this->basicsValidator($application)->getRules(),
            $this->experienceValidator($application)->getRules(),
            //$this->essentialSkillsValidator($application)->getRules(),
            $this->affirmationValidator($application)->getRules()
        );

        $data = $application->toArray();

        // Combining and simplifiying error messages
        $rules = array_merge(
            $rules,
            ['application_step_1' => 'required|boolean|accepted'],
            ['application_step_3' => 'required|boolean|accepted']
        );
        $data = array_merge(
            $data,
            ['application_step_1' => $this->basicsComplete($application)],
            ['application_step_3' => $this->essentialSkillsComplete($application)]
        );

        //Validate basic data is filled in
        Validator::make($data, $rules)->validate();
    }

    protected function arrayMapKeys($fn, $array) {

Missing doc comment for function arrayMapKeys()

        $newArray = [];
        foreach($array as $key => $value) {

Expected "foreach (...) {\n"; found "foreach(...) {\n"

            $newArray[$fn($key)] = $value;
        }
        return $newArray;
    }

    protected function addNestedValidatorRules($nestedAttribute, $validatorRules, $rules = []) {

Missing doc comment for function addNestedValidatorRules()

        // prepend the attribute name of each validator rule with the nested attribute name
        $newRules = $this->arrayMapKeys(function($key) use ($nestedAttribute) {

The opening parenthesis of a multi-line function call should be the last content on the line.

                return implode('.', [$nestedAttribute, $key]);
            },

Closing brace indented incorrectly; expected 8 spaces, found 12

            $validatorRules);

For multi-line function calls, the closing parenthesis should be on a new line.

        //Merge new rules with old rules
        $rules = array_merge($rules, $newRules);
        return $rules;
    }

    public function basicsValidator(JobApplication $application) {

Missing doc comment for function basicsValidator()

        // Validate the fields common to every application
        $rules = [
            'citizenship_declaration_id' => ['required', Rule::in($this->citizenship_ids)],
            'veteran_status_id' => ['required', Rule::in($this->veteran_status_ids)],
            'preferred_language_id' => ['required', Rule::in($this->preferred_language_ids)],
        ];

        //Load application answers so they are included in application->toArray()
        $application->load('job_application_answers');

        // Validate that each question has been answered
        $jobPosterQuestionRules = [];
        foreach($application->job_poster->job_poster_questions as $question) {

Expected "foreach (...) {\n"; found "foreach(...) {\n"

            $jobPosterQuestionRules[] = new ContainsObjectWithAttributeRule('job_poster_question_id', $question->id);
        }
        $rules['job_application_answers'] = $jobPosterQuestionRules;
        $answerValidatorFactory = new JobApplicationAnswerValidator($application);

        //Validate that each answer is complete
        foreach($application->job_application_answers as $key=>$answer) {

Expected "foreach (...) {\n"; found "foreach(...) {\n"

            $attribute = implode('.', ['job_application_answers', $key]);
            $rules = $this->addNestedValidatorRules($attribute, $answerValidatorFactory->rules(), $rules);
        }

        $validator = Validator::make($application->toArray(), $rules);
        return $validator;
    }

    public function basicsComplete(JobApplication $application) {

Missing doc comment for function basicsComplete()

        $validator = $this->basicsValidator($application);
        return $validator->passes();
    }

    public function experienceValidator(JobApplication $application) {

Missing doc comment for function experienceValidator()

        $rules = ['experience_saved' => 'required|boolean|accepted'];
        return Validator::make($application->toArray(), $rules);
    }

    public function experienceComplete(JobApplication $application) {

Missing doc comment for function experienceComplete()

        return $this->experienceValidator($application)->passes();
    }

    protected function skillsValidator(JobApplication $application, $criteria_type) {

Missing doc comment for function skillsValidator()

        $rules = [];

        $skillDeclarationRules = [];
        $criteriaTypeId = CriteriaType::where('name', $criteria_type)->firstOrFail()->id;
        foreach($application->job_poster->criteria->where('criteria_type_id', $criteriaTypeId) as $criteria) {

Expected "foreach (...) {\n"; found "foreach(...) {\n"

            //Validate that every essential skill has a corresponding declaration
            $skillDeclarationRules[] = new ContainsObjectWithAttributeRule('skill_id', $criteria->skill_id);
        }
        $rules['skill_declarations'] = $skillDeclarationRules;
        $application->applicant->load('skill_declarations');

        //Validate that those declarations are complete
        $skilDeclarationValidatorFactory = new SkillDeclarationValidator($application->applicant);
        $relevantSkillIds = $application->job_poster->criteria->where('criteria_type_id', $criteriaTypeId)->pluck('skill_id');
        foreach( $application->skill_declarations as $key=>$declaration) {

Expected "foreach (...) {\n"; found "foreach(...) {\n"

            if ($relevantSkillIds->contains($declaration->skill_id)) {
                $attribute = implode('.', ['skill_declarations', $key]);
                $skillDeclarationValidator = $skilDeclarationValidatorFactory->validator($declaration);

The method validator() does not exist on App\Services\Validation\SkillDeclarationValidator. Did you maybe mean validate()?

                $rules = $this->addNestedValidatorRules($attribute, $skillDeclarationValidator->getRules(), $rules);
            }
        }

        $validator = Validator::make($application->toArray(), $rules);
        return $validator;
    }

    public function essentialSkillsValidator(JobApplication $application) {

Missing doc comment for function essentialSkillsValidator()

        return $this->skillsValidator($application, 'essential');
    }

    public function essentialSkillsComplete(JobApplication $application) {

Missing doc comment for function essentialSkillsComplete()

        return $this->essentialSkillsValidator($application)->passes();
    }

    public function assetSkillsValidator(JobApplication $application) {

Missing doc comment for function assetSkillsValidator()

        return $this->skillsValidator($application, 'asset');
    }

    public function assetSkillsComplete(JobApplication $application) {

Missing doc comment for function assetSkillsComplete()

        return $this->assetSkillsValidator($application)->passes();
    }

    public function affirmationValidator(JobApplication $application) {

Missing doc comment for function affirmationValidator()

        $rules = [
            'submission_signature' => [
                'required',
                'string',
                'max:191',
            ],
            'submission_date' => [
                'required',
                'string',
                'max:191',
           ]
        ];
        return Validator::make($application->toArray(), $rules);
    }

    public function affirmationComplete(JobApplication $application) {

Missing doc comment for function affirmationComplete()

        return $this->affirmationValidator($application)->passes();
    }
}