TimetableLessonsImportStrategy::persist() - Code Metrics - SchulIT/icc - Measure and Improve Code Quality continuously with Scrutinizer

TimetableLessonsImportStrategy::persist() C
last analyzed 2023-06-23 11:16 UTC

↳ Parent: TimetableLessonsImportStrategy
Complexity

Conditions	14
Paths	50
Size

Total Lines	78
Code Lines	47
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	210
Importance

Changes
Metric	Value
eloc	47
c	0
b	0
f	0
dl	0
loc	78
rs	6.2666
ccs	0
cts	39
cp	0
cc	14
nc	50
nop	2
crap	210
How to fix Long Method Complexity

<?php

namespace App\Import;

use App\Entity\Grade;
use App\Entity\Room;
use App\Entity\Section;
use App\Entity\Subject;
use App\Entity\Teacher;
use App\Entity\TimetableLesson;
use App\Entity\Tuition;
use App\Repository\GradeRepositoryInterface;
use App\Repository\RoomRepositoryInterface;
use App\Repository\SubjectRepositoryInterface;
use App\Repository\TeacherRepositoryInterface;
use App\Repository\TimetableLessonRepositoryInterface;
use App\Repository\TransactionalRepositoryInterface;
use App\Repository\TuitionRepositoryInterface;
use App\Request\Data\TimetableLessonData;
use App\Request\Data\TimetableLessonsData;
use App\Section\SectionResolver;
use App\Section\SectionResolverInterface;
use App\Utils\ArrayUtils;
use App\Utils\CollectionUtils;
use Psr\Log\LoggerInterface;
use Ramsey\Uuid\Uuid;

class TimetableLessonsImportStrategy implements ReplaceImportStrategyInterface, InitializeStrategyInterface {

    private array $gradeCache;
    private array $teacherCache;
    private array $roomCache;
    private array $subjectCache;
    private array $tuitionCache = [ ];

    public function __construct(private TimetableLessonRepositoryInterface $timetableRepository, private TuitionRepositoryInterface $tuitionRepository, private RoomRepositoryInterface $roomRepository, private TeacherRepositoryInterface $teacherRepository, private SubjectRepositoryInterface $subjectRepository, private GradeRepositoryInterface $gradeRepository, private SectionResolverInterface $sectionResolver, private LoggerInterface $logger)
    {
    }

    public function initialize($requestData): void {
        $this->gradeCache = ArrayUtils::createArrayWithKeys(
            $this->gradeRepository->findAll(),
            fn(Grade $grade) => $grade->getExternalId()
        );

        $this->teacherCache = ArrayUtils::createArrayWithKeys(
            $this->teacherRepository->findAll(),
            fn(Teacher $teacher) => $teacher->getExternalId()
        );

        $this->subjectCache = ArrayUtils::createArrayWithKeys(
            $this->subjectRepository->findAll(),
            fn(Subject $subject) => $subject->getAbbreviation()
        );

        $this->roomCache = ArrayUtils::createArrayWithKeys(
            $this->roomRepository->findAllExternal(),
            fn(Room $room) => $room->getExternalId()
        );
    }

    /**
     * @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->tuitionCache[$key])) {
            $this->tuitionCache[$key] = $this->tuitionRepository->findAllByGradeTeacherAndSubjectOrCourse($grades, $teachers, $subjectOrCourse, $section);
        }

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

    /**
     * @param TimetableLessonData $data
     * @param TimetableLessonsData $requestData
     * @throws ImportException
     */
    public function persist($data, $requestData): void {
        $entity = new TimetableLesson();

        if($data->getDate() < $requestData->getStartDate() || $data->getDate() > $requestData->getEndDate()) {
            return;
        }

        $section = $this->sectionResolver->getSectionForDate($data->getDate());
        $section = $this->sectionResolver->getSectionForDate(/** @scrutinizer ignore-type */ $data->getDate());

        if($section === null) {
            throw new SectionNotResolvableException($data->getDate());
            throw new SectionNotResolvableException(/** @scrutinizer ignore-type */ $data->getDate());
        }

        if(!empty($data->getSubject()) && count($data->getGrades()) > 0 && count($data->getTeachers()) > 0) {
            $tuitions = $this->findTuition($data->getGrades(), $data->getTeachers(), $data->getSubject(), $section);

            if (count($tuitions) === 0) {
                $entity->setTuition(null);
            } else {
                if (count($tuitions) === 1) {
                    $entity->setTuition(array_shift($tuitions));
                } else {
                    $entity->setTuition(null);
                }
            }
        } else {
            $entity->setTuition(null);
        }

        if(!empty($data->getRoom())) {
            //$room = $this->roomRepository->findOneByExternalId($data->getRoom());
            $room = $this->roomCache[$data->getRoom()] ?? null;
            $entity->setRoom($room);

            if($room === null) {
                $entity->setLocation($data->getRoom());
            }
        } else {
            $entity->setRoom(null);
        }

        if($data->getSubject() !== null) {
            //$subject = $this->subjectRepository->findOneByAbbreviation($data->getSubject());
            $subject = $this->subjectCache[$data->getSubject()] ?? null;
            $entity->setSubject($subject);
        }

        $entity->setSubjectName($data->getSubject());

        if($entity->getTuition() === null && $entity->getSubject() === null) {
            $this->logger->info(sprintf(
                'Kein Unterricht für die Stundenplanstunde mit dem Fach "%s", den Lehrkräften "%s" und Klasse(n) "%s" gefunden.',
                $data->getSubject(),
                implode(',', $data->getTeachers()),
                implode(',', $data->getGrades())
            ));
        }

        CollectionUtils::synchronize(
            $entity->getGrades(),
            ArrayUtils::findAllWithKeys($this->gradeCache, $data->getGrades()),
            //$this->gradeRepository->findAllByExternalId($data->getGrades()),
            fn(Grade $grade) => $grade->getId()
        );

        CollectionUtils::synchronize(
            $entity->getTeachers(),
            ArrayUtils::findAllWithKeys($this->teacherCache, $data->getTeachers()),
            //$teachers = $this->teacherRepository->findAllByExternalId($data->getTeachers()),
            fn(Teacher $teacher) => $teacher->getId()
        );

        $entity->setExternalId($data->getId());
        $entity->setDate($data->getDate());
        $entity->setLessonStart($data->getLessonStart());
        $entity->setLessonEnd($data->getLessonEnd());

        $this->timetableRepository->persist($entity);
    }


    /**
     * @inheritDoc
     */
    public function getRepository(): TransactionalRepositoryInterface {
        return $this->timetableRepository;
    }

    /**
     * @param TimetableLessonsData $data
     * @return TimetableLessonData[]
     */
    public function getData($data): array {
        return $data->getLessons();
    }

    /**
     * @inheritDoc
     */
    public function getEntityClassName(): string {
        return TimetableLesson::class;
    }

    /**
     * @param TimetableLessonsData $data
     */
    public function removeAll($data): void {
        $this->timetableRepository->removeStartingFrom($data->getStartDate());
        $this->timetableRepository->removeStartingFrom(/** @scrutinizer ignore-type */ $data->getStartDate());
    }
}
SchulIT / icc

TimetableLessonsImportStrategy::persist() C last analyzed 2023-06-23 11:16 UTC

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like

TimetableLessonsImportStrategy::persist() C
last analyzed 2023-06-23 11:16 UTC
