App\Repository\SubstitutionRepository

Complexity

Total Complexity

22

Size/Duplication

Total Lines	245
Duplicated Lines	0 %

Test Coverage

Coverage

22.96%

Importance

Changes

0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	findOneByExternalId()	0	4	1
A	findAllByDate()	0	26	2
A	remove()	0	3	1
A	findOneById()	0	4	1
A	findAll()	0	4	1
A	persist()	0	3	1
A	findAllForTeacher()	0	25	1
A	findAllForRooms()	0	15	1
A	countAllForTeacher()	0	2	1
A	removeBetween()	0	9	1
A	countAllForStudyGroups()	0	2	1
A	countAllForGrade()	0	2	1
A	findAllForGrade()	0	25	1
A	findAllForStudyGroups()	0	44	5
A	getDefaultQueryBuilder()	0	20	2
A	countAllByDate()	0	2	1

<?php

namespace App\Repository;

use App\Entity\Grade;
use App\Entity\Room;
use App\Entity\StudyGroup;
use App\Entity\StudyGroupType;
use App\Entity\Substitution;
use App\Entity\Teacher;
use App\Utils\ArrayUtils;
use DateTime;
use Doctrine\ORM\QueryBuilder;

class SubstitutionRepository extends AbstractTransactionalRepository implements SubstitutionRepositoryInterface {

    public function findOneById(int $id): ?Substitution {
        return $this->em->getRepository(Substitution::class)
            ->findOneBy([
                'id' => $id
            ]);
    }

    public function findOneByExternalId(string $externalId): ?Substitution {
        return $this->em->getRepository(Substitution::class)
            ->findOneBy([
                'externalId' => $externalId
            ]);
    }

    /**
     * @inheritDoc
     */
    public function findAll() {
        return $this->getDefaultQueryBuilder(null)

The expression return $this->getDefaultQueryBuilder(null)->getQuery()->getResult() also could return the type integer which is incompatible with the return type mandated by App\Repository\SubstitutionRepositoryInterface::findAll() of App\Entity\Substitution[].

            ->getQuery()
            ->getResult();
    }

    /**
     * @return Substitution[]
     */
    public function findAllByDate(DateTime $date, bool $excludeNonStudentSubstitutions = false) {
        if($excludeNonStudentSubstitutions === false) {
            return $this->getDefaultQueryBuilder($date)

The expression return $this->getDefaultQueryBuilder($date)->getQuery()->getResult() also could return the type integer which is incompatible with the documented return type App\Entity\Substitution[].

                ->getQuery()
                ->getResult();
        }

        $qbInner = $this->em->createQueryBuilder();
        $qbInner->select('sInner.id')
            ->from(Substitution::class, 'sInner')
            ->leftJoin('sInner.studyGroups', 'sgInner')
            ->leftJoin('sInner.replacementStudyGroups', 'rsgInner');

        $qbInner->where(
            $qbInner->expr()->andX(
                $qbInner->expr()->isNull('sgInner.id'),
                $qbInner->expr()->isNull('rsgInner.id')
            )
        );

        $qb = $this->getDefaultQueryBuilder($date);
        $qb->andWhere(
            $qb->expr()->notIn('s.id', $qbInner->getDQL())
        );

        return $qb->getQuery()->getResult();

The expression return $qb->getQuery()->getResult() also could return the type integer which is incompatible with the documented return type App\Entity\Substitution[].

    }

    public function persist(Substitution $substitution): void {
        $this->em->persist($substitution);
        $this->flushIfNotInTransaction();
    }

    public function remove(Substitution $substitution): void {
        $this->em->remove($substitution);
        $this->flushIfNotInTransaction();
    }

    public function removeBetween(DateTime $start, DateTime $end): int {
        return $this->em->createQueryBuilder()

The expression return $this->em->createQueryBuilder()->delete(App\Entity\Substitution::class, 's')->where('s.date >= :start')->andWhere('s.date <= :end')->setParameter('start', $start)->setParameter('end', $end)->getQuery()->execute() could return the type array<mixed,mixed> which is incompatible with the type-hinted return integer. Consider adding an additional type-check to rule them out.

            ->delete(Substitution::class, 's')
            ->where('s.date >= :start')
            ->andWhere('s.date <= :end')
            ->setParameter('start', $start)
            ->setParameter('end', $end)
            ->getQuery()
            ->execute();
    }

    /**
     * @inheritDoc
     */
    public function findAllForStudyGroups(array $studyGroups, ?DateTime $date = null) {
        $ids = array_map(fn(StudyGroup $studyGroup) => $studyGroup->getId(), $studyGroups);

        /** @var StudyGroup|null $gradeStudyGroup */
        $gradeStudyGroup = ArrayUtils::first($studyGroups, fn(StudyGroup $studyGroup) => $studyGroup->getType() === StudyGroupType::Grade);
        /** @var Grade|null $grade */
        $grade = $gradeStudyGroup != null ? $gradeStudyGroup->getGrades()->first() : null;
        $gradeId = $grade !== null ? $grade->getId() : null;

        $qbInner = $this->em->createQueryBuilder();
        $qbInner->select('sInner.id')
            ->from(Substitution::class, 'sInner')
            ->leftJoin('sInner.studyGroups', 'sgInner')
            ->leftJoin('sInner.replacementStudyGroups', 'rsgInner')
            ->leftJoin('sInner.replacementGrades', 'rgInner');

        if($gradeId !== null) {
            $qbInner->where(
                $qbInner->expr()->orX(
                    $qbInner->expr()->in('sgInner.id', ':ids'),
                    $qbInner->expr()->in('rsgInner.id', ':ids'),
                    $qbInner->expr()->eq('rgInner.id', ':gradeId')
                )
            );
        } else {
            $qbInner->where(
                $qbInner->expr()->orX(
                    $qbInner->expr()->in('sgInner.id', ':ids'),
                    $qbInner->expr()->in('rsgInner.id', ':ids')
                )
            );
        }

        $qb = $this->getDefaultQueryBuilder($date);
        $qb->andWhere(
            $qb->expr()->in('s.id', $qbInner->getDQL())
        );
        $qb->setParameter('ids', $ids);

        if($gradeId !== null) {
            $qb->setParameter('gradeId', $gradeId);
        }

        return $qb->getQuery()->getResult();

The expression return $qb->getQuery()->getResult() also could return the type integer which is incompatible with the return type mandated by App\Repository\SubstitutionRepositoryInterface::findAllForStudyGroups() of App\Entity\Substitution[].

    }

    /**
     * @inheritDoc
     */
    public function findAllForTeacher(Teacher $teacher, ?DateTime $date = null) {
        $qbInner = $this->em->createQueryBuilder();
        $qbInner->select('sInner.id')
            ->from(Substitution::class, 'sInner')
            ->leftJoin('sInner.teachers', 'tInner')
            ->leftJoin('sInner.replacementTeachers', 'rtInner');

        $regExp = '[[:<:]]' . $teacher->getAcronym() . '[[:>:]]';

        $qbInner->where(
            $qbInner->expr()->orX(
                'tInner.id = :id',
                'rtInner.id = :id',
                'REGEXP(sInner.remark, :regexp) = true'
            )
        );

        $qb = $this->getDefaultQueryBuilder($date);
        $qb->andWhere(
            $qb->expr()->in('s.id', $qbInner->getDQL())
        );
        $qb->setParameter('id', $teacher->getId());
        $qb->setParameter('regexp', $regExp);

        return $qb->getQuery()->getResult();

The expression return $qb->getQuery()->getResult() also could return the type integer which is incompatible with the return type mandated by App\Repository\SubstitutionRepositoryInterface::findAllForTeacher() of App\Entity\Substitution[].

    }

    /**
     * @inheritDoc
     */
    public function findAllForGrade(Grade $grade, ?DateTime $date = null) {
        $qbInner = $this->em->createQueryBuilder();
        $qbInner->select('sInner.id')
            ->from(Substitution::class, 'sInner')
            ->leftJoin('sInner.studyGroups', 'sgInner')
            ->leftJoin('sInner.replacementStudyGroups', 'rsgInner')
            ->leftJoin('sgInner.grades', 'sggInner')
            ->leftJoin('rsgInner.grades', 'rsggInner')
            ->leftJoin('sInner.replacementGrades', 'rgInner');

        $qbInner->where(
            $qbInner->expr()->orX(
                $qbInner->expr()->eq('sggInner.id', ':id'),
                $qbInner->expr()->eq('rsggInner.id', ':id'),
                $qbInner->expr()->eq('rgInner.id', ':id')
            )
        );

        $qb = $this->getDefaultQueryBuilder($date);
        $qb->andWhere(
            $qb->expr()->in('s.id', $qbInner->getDQL())
        );
        $qb->setParameter('id', $grade->getId());

        return $qb->getQuery()->getResult();

The expression return $qb->getQuery()->getResult() also could return the type integer which is incompatible with the return type mandated by App\Repository\SubstitutionRepositoryInterface::findAllForGrade() of App\Entity\Substitution[].

    }

    /**
     * @inheritDoc
     */
    public function findAllForRooms(array $rooms, ?DateTime $date): array {
        $roomIds = array_filter(array_map(fn(Room $room) => $room->getId(), $rooms), fn($input) => !empty($input));

        $qb = $this->getDefaultQueryBuilder($date);
        $qb->leftJoin('s.replacementRooms', 'r')
            ->leftJoin('s.rooms', 'rr')
            ->andWhere(
            $qb->expr()->orX(
                $qb->expr()->in('r.id', ':roomIds'),
                $qb->expr()->in('rr.id', ':roomIds')
            )
        );
        $qb->setParameter('roomIds', $roomIds);

        return $qb->getQuery()->getResult();

The expression return $qb->getQuery()->getResult() could return the type integer which is incompatible with the type-hinted return array. Consider adding an additional type-check to rule them out.

    }

    private function getDefaultQueryBuilder(DateTime $date = null): QueryBuilder {
        $qb = $this->em->createQueryBuilder();

        $qb->select(['s', 't', 'rt', 'sg', 'rsg', 'rg'])
            ->from(Substitution::class, 's')
            ->leftJoin('s.teachers', 't')
            ->leftJoin('s.replacementTeachers', 'rt')
            ->leftJoin('s.studyGroups', 'sg')
            ->leftJoin('s.replacementStudyGroups', 'rsg')
            ->leftJoin('s.replacementGrades', 'rg')
            ->orderBy('s.date', 'asc')
            ->orderBy('s.lessonStart', 'asc');

        if($date !== null) {
            $qb
                ->where('s.date = :date')
                ->setParameter('date', $date);
        }

        return $qb;
    }

    /*
     * TODO: The following methods need improvement -> count in database!
     */
    public function countAllByDate(DateTime $date): int {
        return count($this->findAllByDate($date));
    }

    public function countAllForStudyGroups(array $studyGroups, ?DateTime $date = null): int {
        return count($this->findAllForStudyGroups($studyGroups, $date));

It seems like $this->findAllForStudyGroups($studyGroups, $date) can also be of type integer; however, parameter $value of count() does only seem to accept Countable|array, maybe add an additional type check?

    }

    public function countAllForTeacher(Teacher $teacher, ?DateTime $date = null): int {
        return count($this->findAllForTeacher($teacher, $date));

It seems like $this->findAllForTeacher($teacher, $date) can also be of type integer; however, parameter $value of count() does only seem to accept Countable|array, maybe add an additional type check?

    }

    public function countAllForGrade(Grade $grade, ?DateTime $date = null): int {
        return count($this->findAllForGrade($grade, $date));

It seems like $this->findAllForGrade($grade, $date) can also be of type integer; however, parameter $value of count() does only seem to accept Countable|array, maybe add an additional type check?

    }
}