App\Validator\TuitionResolvableValidator

Complexity

Total Complexity

12

Size/Duplication

Total Lines	73
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

3 Methods

Rating	Name	Duplication	Size	Complexity
B	validate()	0	38	9
A	findTuition()	0	17	2
A	__construct()	0	3	1

<?php

namespace App\Validator;

use App\Entity\Section;
use App\Entity\Tuition;
use App\Repository\TuitionRepositoryInterface;
use App\Request\Data\TimetableLessonData;
use App\Section\SectionResolverInterface;
use App\Settings\ImportSettings;
use Symfony\Component\Validator\Constraint;
use Symfony\Component\Validator\ConstraintValidator;
use Symfony\Component\Validator\Exception\UnexpectedTypeException;

class TuitionResolvableValidator extends ConstraintValidator {

    private array $cache = [ ];

    public function __construct(private readonly SectionResolverInterface $sectionResolver,
                                private readonly TuitionRepositoryInterface $tuitionRepository,
                                private readonly ImportSettings $importSettings) { }

    public function validate(mixed $value, Constraint $constraint) {
        if(!$value instanceof TimetableLessonData) {
            throw new UnexpectedTypeException($value, TimetableLessonData::class);
        }

        if(!$constraint instanceof TuitionResolvable) {
            throw new UnexpectedTypeException($constraint, TuitionResolvable::class);
        }

        if(empty($value->getSubject()) || count($value->getGrades()) === 0 || count($value->getTeachers()) === 0) {
            return;
        }

        if(in_array($value->getSubject(), $this->importSettings->getSubjectsWithoutTuition())) {
            return;
        }

        $section = $this->sectionResolver->getSectionForDate($value->getDate());

It seems like $value->getDate() can also be of type null; however, parameter $dateTime of App\Section\SectionResolverInterface::getSectionForDate() does only seem to accept DateTime, maybe add an additional type check?

        $tuition = $this->findTuition($value->getGrades(), $value->getTeachers(), $value->getSubject(), $section);

It seems like $section can also be of type null; however, parameter $section of App\Validator\TuitionResolvableValidator::findTuition() does only seem to accept App\Entity\Section, maybe add an additional type check?

        if(count($tuition) === 0) {
            $this->context
                ->buildViolation($constraint->notMatchedmessage)
                ->setParameter('{{ subject }}', $value->getSubject())
                ->setParameter('{{ teachers }}', implode(', ', $value->getTeachers()))
                ->setParameter('{{ grades }}', implode(', ', $value->getGrades()))
                ->addViolation();
        }

        if(count($tuition) > 1) {
            $this->context
                ->buildViolation($constraint->ambiguousMessage)
                ->setParameter('{{ subject }}', $value->getSubject())
                ->setParameter('{{ teachers }}', implode(', ', $value->getTeachers()))
                ->setParameter('{{ grades }}', implode(', ', $value->getGrades()))
                ->addViolation();
        }

        // tuition resolved :)
    }

    /**
     * @param string[] $grades
     * @param string[] $teachers
     * @return Tuition[]
     */
    private function findTuition(array $grades, array $teachers, string $subjectOrCourse, Section $section): array {
        sort($grades);
        sort($teachers);

        $key = sprintf(
            '%d-%s-%s-%s',
            $section->getId(),
            implode('~', $grades),
            implode('~', $teachers),
            $subjectOrCourse
        );

        if(!isset($this->cache[$key])) {
            $this->cache[$key] = $this->tuitionRepository->findAllByGradeTeacherAndSubjectOrCourse($grades, $teachers, $subjectOrCourse, $section);
        }

        return $this->cache[$key];
    }
}