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

SuggestionResolver::filterAbsencesWithAreExcused() A
last analyzed 2023-06-23 11:16 UTC

↳ Parent: SuggestionResolver
Complexity

Conditions	2
Paths	1
Size

Total Lines	2
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	2
eloc	1
nc	1
nop	1
dl	0
loc	2
rs	10
c	1
b	0
f	0
<?php

namespace App\Book\AbsenceSuggestion;

use App\Dashboard\Absence\AbsenceResolver;
use App\Dashboard\AbsentExamStudent;
use App\Dashboard\AbsentStudent;
use App\Dashboard\AbsentStudentWithAbsenceNote;
use App\Entity\LessonAttendanceExcuseStatus;
use App\Entity\Student as StudentEntity;
use App\Entity\StudyGroupMembership;
use App\Entity\Tuition;
use App\Repository\ExcuseNoteRepositoryInterface;
use App\Repository\LessonAttendanceRepositoryInterface;
use App\Response\Book\AbsenceSuggestion;
use App\Response\Book\Student;
use DateTime;

class SuggestionResolver {
    public function __construct(private readonly AbsenceResolver $absenceResolver, private readonly LessonAttendanceRepositoryInterface $attendanceRepository,
                                private readonly ExcuseNoteRepositoryInterface $excuseNoteRepository) {

    }

    /**
     * @param Tuition $tuition
     * @param DateTime $date
     * @param int $lesson
     * @return AbsenceSuggestion[]
     */
    public function resolve(Tuition $tuition, DateTime $date, int $lesson): array {
        $students = $tuition->getStudyGroup()->getMemberships()->map(fn(StudyGroupMembership $membership) => $membership->getStudent())->toArray();

        $suggestions = [ ];

        $absences = $this->absenceResolver->resolve($date, $lesson, $students);

        foreach($this->filterAbsencesWithAreExcused($absences) as $absentStudent) {
            if(array_key_exists($absentStudent->getStudent()->getId(), $suggestions)) {
                continue; // prevent duplicates
            }

            $excuseStatus = ($absentStudent instanceof AbsentStudentWithAbsenceNote && $absentStudent->getAbsence()->getType()->isAlwaysExcused()) ? LessonAttendanceExcuseStatus::Excused : LessonAttendanceExcuseStatus::NotSet;

            $suggestions[$absentStudent->getStudent()->getId()] = new AbsenceSuggestion(
                $this->getStudent($absentStudent->getStudent()),
                $absentStudent->getReason()->value,
                $absentStudent->getAbsence()->getType()->getName(),
                $absentStudent->getAbsence()->getType()->isTypeWithZeroAbsenceLessons(),
                $excuseStatus
            );
        }

        foreach($this->filterAbsencesWithoutZeroAbsenceLessons($absences) as $absentStudent) {
            if(array_key_exists($absentStudent->getStudent()->getId(), $suggestions)) {
                continue; // prevent duplicates
            }

            $excuseStatus = ($absentStudent instanceof AbsentStudentWithAbsenceNote && $absentStudent->getAbsence()->getType()->isAlwaysExcused()) ? LessonAttendanceExcuseStatus::Excused : LessonAttendanceExcuseStatus::NotSet;

            $suggestions[$absentStudent->getStudent()->getId()] = new AbsenceSuggestion(
                $this->getStudent($absentStudent->getStudent()),
                $absentStudent->getReason()->value,
                $absentStudent->getAbsence()->getType()->getName(),
                false,
                $excuseStatus
            );
        }

        // Absence in previous lesson
        foreach($this->attendanceRepository->findAbsentByStudentsAndDate($students, $date) as $attendance) {
            if(array_key_exists($attendance->getStudent()->getId(), $suggestions)) {
                continue; // prevent duplicates
            }

            if($attendance->getEntry()->getLessonEnd() === $lesson - 1) {
                $suggestions[$attendance->getStudent()->getId()] = new AbsenceSuggestion(
                    $this->getStudent($attendance->getStudent()),
                    $this->getStudent(/** @scrutinizer ignore-type */ $attendance->getStudent()),
                    'absent_before'
                );
            }
        }

        // Exam
        foreach($this->filterAbsencesWithExam($absences) as $absentExamStudent) {
            if(array_key_exists($absentExamStudent->getStudent()->getId(), $suggestions)) {
                continue; // prevent duplicates
            }

            if($absentExamStudent->getExam()->getTuitions()->count() === 1 && $absentExamStudent->getExam()->getTuitions()->first() === $tuition) {
                continue; // do not show exam of current tuition
            }

            $suggestions[$absentExamStudent->getStudent()->getId()] = new AbsenceSuggestion(
                $this->getStudent($absentExamStudent->getStudent()),
                $absentExamStudent->getReason()->value,
                null,
                true,
                LessonAttendanceExcuseStatus::Excused
            );
        }

        // Absences with zero absent lessons
        foreach($this->filterAbsencesWithZeroAbsenceLessons($absences) as $absentStudent) {
            if(array_key_exists($absentStudent->getStudent()->getId(), $suggestions)) {
                continue; // prevent duplicates
            }

            $excuseStatus = ($absentStudent instanceof AbsentStudentWithAbsenceNote && $absentStudent->getAbsence()->getType()->isAlwaysExcused()) ? LessonAttendanceExcuseStatus::Excused : LessonAttendanceExcuseStatus::NotSet;

            $suggestions[$absentStudent->getStudent()->getId()] = new AbsenceSuggestion(
                $this->getStudent($absentStudent->getStudent()),
                $absentStudent->getReason()->value,
                $absentStudent->getAbsence()->getType()->getName(),
                true,
                $excuseStatus
            );
        }

        // Excuse
        foreach($this->excuseNoteRepository->findByStudentsAndDate($students, $date) as $note) {
            if(array_key_exists($note->getStudent()->getId(), $suggestions)) {
                continue; // prevent duplicates
            }

            if($note->appliesToLesson($date, $lesson)) {
                $suggestions[$note->getStudent()->getId()] = new AbsenceSuggestion(
                    $this->getStudent($note->getStudent()),
                    'excuse',
                    null,
                    false,
                    LessonAttendanceExcuseStatus::Excused
                );
            }
        }

        return array_values($suggestions);
    }

    /**
     * @param AbsentStudent[] $students
     * @return AbsentStudentWithAbsenceNote[]
     */
    private function filterAbsencesWithoutZeroAbsenceLessons(array $students): array {
        return array_filter($students, fn(AbsentStudent $absentStudent) => ($absentStudent instanceof AbsentStudentWithAbsenceNote && !$absentStudent->getAbsence()->getType()->isTypeWithZeroAbsenceLessons()));
    }

    /**
     * @param AbsentStudent[] $students
     * @return AbsentExamStudent[]
     */
    private function filterAbsencesWithExam(array $students): array {
        return array_filter($students, fn(AbsentStudent $absentStudent) => $absentStudent instanceof AbsentExamStudent);
    }

    /**
     * @param AbsentStudent[] $students
     * @return AbsentStudentWithAbsenceNote[]
     */
    private function filterAbsencesWithZeroAbsenceLessons(array $students): array {
        return array_filter($students, fn(AbsentStudent $absentStudent) => ($absentStudent instanceof AbsentStudentWithAbsenceNote && $absentStudent->getAbsence()->getType()->isTypeWithZeroAbsenceLessons()));
    }

    private function filterAbsencesWithAreExcused(array $students): array {
        return array_filter($students, fn(AbsentStudent $absentStudent) => $absentStudent instanceof AbsentStudentWithAbsenceNote && $absentStudent->getAbsence()->getType()->isAlwaysExcused());
    }

    private function getStudent(StudentEntity $entity): Student {
        return new Student($entity->getUuid()->toString(), $entity->getFirstname(), $entity->getLastname());
        return new Student($entity->getUuid()->toString(), /** @scrutinizer ignore-type */ $entity->getFirstname(), $entity->getLastname());
    }
}
SchulIT / icc

SuggestionResolver::filterAbsencesWithAreExcused() A last analyzed 2023-06-23 11:16 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

SuggestionResolver::filterAbsencesWithAreExcused() A
last analyzed 2023-06-23 11:16 UTC
