class.ilTestSkillEvaluation.php

Go to the documentation of this file.

<?php

declare(strict_types=1);

use ILIAS\Skill\Service\SkillProfileService;
use ILIAS\Skill\Service\SkillPersonalService;
use ILIAS\Test\Logging\TestLogger;

class ilTestSkillEvaluation
{
    private ilAssQuestionSkillAssignmentList $skillQuestionAssignmentList;
    private ilTestSkillLevelThresholdList $skillLevelThresholdList;
    private array $questions = [];
    private array $maxPointsByQuestion = [];
    private array $reachedPointsByQuestion;
    private array $skillPointAccounts;
    private array $reachedSkillLevels;
    private int $userId;
    private int $activeId;
    private int $pass;
    private int $numRequiredBookingsForSkillTriggering;


    public function __construct(
        private ilDBInterface $db,
        private TestLogger $logger,
        int $test_id,
        private int $refId,
        private SkillProfileService $skill_profile_service,
        private SkillPersonalService $skill_personal_service
    ) {
        $this->skillQuestionAssignmentList = new ilAssQuestionSkillAssignmentList($this->db);

        $this->skillLevelThresholdList = new ilTestSkillLevelThresholdList($this->db);
        $this->skillLevelThresholdList->setTestId($test_id);
    }

    public function getUserId(): int
    {
        return $this->userId;
    }

    public function setUserId($userId)
    {
        $this->userId = $userId;
    }

    public function getActiveId(): int
    {
        return $this->activeId;
    }

    public function setActiveId($activeId)
    {
        $this->activeId = $activeId;
    }

    public function getPass(): int
    {
        return $this->pass;
    }

    public function setPass($pass)
    {
        $this->pass = $pass;
    }

    public function getNumRequiredBookingsForSkillTriggering(): int
    {
        return $this->numRequiredBookingsForSkillTriggering;
    }

    public function setNumRequiredBookingsForSkillTriggering(int $numRequiredBookingsForSkillTriggering): void
    {
        $this->numRequiredBookingsForSkillTriggering = $numRequiredBookingsForSkillTriggering;
    }

    public function init(ilAssQuestionList $questionList)
    {
        $this->skillQuestionAssignmentList->setParentObjId($questionList->getParentObjId());
        $this->skillQuestionAssignmentList->loadFromDb();

        $this->skillLevelThresholdList->loadFromDb();

        $this->initTestQuestionData($questionList);
    }

    public function evaluate(array $test_results): void
    {
        $this->reset();

        $this->initTestResultData($test_results);

        $this->drawUpSkillPointAccounts();
        $this->evaluateSkillPointAccounts();
    }

    public function getReachedSkillLevels(): array
    {
        return $this->reachedSkillLevels;
    }

    private function reset()
    {
        $this->reachedPointsByQuestion = [];
        $this->skillPointAccounts = [];
        $this->reachedSkillLevels = [];
    }

    private function initTestQuestionData(ilAssQuestionList $questionList)
    {
        foreach ($questionList->getQuestionDataArray() as $questionData) {
            $this->questions[] = $questionData['question_id'];

            $this->maxPointsByQuestion[ $questionData['question_id'] ] = $questionData['points'];
        }
    }

    private function initTestResultData($testResults)
    {
        foreach ($testResults as $key => $result) {
            if ($key === 'pass' || $key === 'test') { // note: key int 0 IS == 'pass' or 'buxtehude'
                continue;
            }

            $this->reachedPointsByQuestion[ $result['qid'] ] = $result['reached'];
        }
    }

    private function drawUpSkillPointAccounts()
    {
        foreach ($this->questions as $question_id) {
            if (!$this->isAnsweredQuestion($question_id)) {
                continue;
            }

            $assignments = $this->skillQuestionAssignmentList->getAssignmentsByQuestionId($question_id);

            foreach ($assignments as $assignment) {
                if ($assignment->hasEvalModeBySolution()) {
                    $reached_skill_points = $this->determineReachedSkillPointsWithSolutionCompare(
                        $assignment->getSolutionComparisonExpressionList()
                    );
                } else {
                    $maxTestPoints = $this->maxPointsByQuestion[$question_id];
                    $reachedTestPoints = $this->reachedPointsByQuestion[$question_id];

                    $reached_skill_points = $this->calculateReachedSkillPointsFromTestPoints(
                        $assignment->getSkillPoints(),
                        $maxTestPoints,
                        $reachedTestPoints
                    );
                }

                $this->bookToSkillPointAccount(
                    $assignment->getSkillBaseId(),
                    $assignment->getSkillTrefId(),
                    $assignment->getMaxSkillPoints(),
                    $reached_skill_points
                );
            }
        }
    }

    private function isAnsweredQuestion($questionId): bool
    {
        return isset($this->reachedPointsByQuestion[$questionId]);
    }

    private function determineReachedSkillPointsWithSolutionCompare(
        ilAssQuestionSolutionComparisonExpressionList $expression_list
    ): ?int {
        $question_provider = new ilAssLacQuestionProvider();
        $question_provider->setQuestionId($expression_list->getQuestionId());

        foreach ($expression_list->get() as $expression) {
            $condition_composite = (new ilAssLacConditionParser())->parse(
                $expression->getExpression()
            );

            $composite_evaluator = new ilAssLacCompositeEvaluator(
                $question_provider,
                $this->getActiveId(),
                $this->getPass()
            );
            if ($composite_evaluator->evaluate($condition_composite)) {
                return $expression->getPoints();
            }
        }

        return 0;
    }

    private function calculateReachedSkillPointsFromTestPoints($skill_points, $max_test_points, $reached_test_points): float
    {
        if ($reached_test_points < 0) {
            $reached_test_points = 0;
        }

        $factor = 0;

        if ($max_test_points > 0) {
            $factor = $reached_test_points / $max_test_points;
        }

        return ($skill_points * $factor);
    }

    private function bookToSkillPointAccount($skill_base_id, $skill_tref_id, $max_skill_points, $reached_skill_points): void
    {
        $skill_key = $skill_base_id . ':' . $skill_tref_id;

        if (!isset($this->skillPointAccounts[$skill_key])) {
            $this->skillPointAccounts[$skill_key] = new ilTestSkillPointAccount();
        }

        $this->skillPointAccounts[$skill_key]->addBooking($max_skill_points, $reached_skill_points);
    }

    private function evaluateSkillPointAccounts()
    {
        foreach ($this->skillPointAccounts as $skill_key => $skill_point_account) {
            if (!$this->doesNumBookingsExceedRequiredBookingsBarrier($skill_point_account)) {
                continue;
            }

            list($skill_base_id, $skill_tref_id) = explode(':', $skill_key);

            $skill = new ilBasicSkill((int) $skill_base_id);
            $levels = $skill->getLevelData();

            $reached_level_id = null;
            foreach ($levels as $level) {
                $threshold = $this->skillLevelThresholdList->getThreshold($skill_base_id, $skill_tref_id, $level['id']);

                if (!($threshold instanceof ilTestSkillLevelThreshold) || !$threshold->getThreshold()) {
                    continue;
                }

                if ($skill_point_account->getTotalReachedSkillPercent() < $threshold->getThreshold()) {
                    break;
                }

                $reached_level_id = $level['id'];
            }

            $this->reachedSkillLevels[] = [
                'sklBaseId' => $skill_base_id, 'sklTrefId' => $skill_tref_id, 'sklLevelId' => $reached_level_id
            ];
        }
    }

    private function doesNumBookingsExceedRequiredBookingsBarrier(ilTestSkillPointAccount $skillPointAccount): bool
    {
        return $skillPointAccount->getNumBookings() >= $this->getNumRequiredBookingsForSkillTriggering();
    }

    public function handleSkillTriggering()
    {
        foreach ($this->getReachedSkillLevels() as $reachedSkillLevel) {
            $this->invokeSkillLevelTrigger((int) $reachedSkillLevel['sklLevelId'], (int) $reachedSkillLevel['sklTrefId']);

            if ($reachedSkillLevel['sklTrefId'] > 0) {
                $this->skill_personal_service->addPersonalSkill($this->getUserId(), (int) $reachedSkillLevel['sklTrefId']);
            } else {
                $this->skill_personal_service->addPersonalSkill($this->getUserId(), (int) $reachedSkillLevel['sklBaseId']);
            }
        }
        //write profile completion entries if fulfilment status has changed
        $this->skill_profile_service->writeCompletionEntryForAllProfiles($this->getUserId());
    }

    private function invokeSkillLevelTrigger(int $skillLevelId, int $skillTrefId)
    {
        ilBasicSkill::writeUserSkillLevelStatus(
            $skillLevelId,
            $this->getUserId(),
            $this->refId,
            $skillTrefId,
            ilBasicSkill::ACHIEVED,
            true,
            false,
            (string) $this->getPass()
        );

        $this->logger->info(
            "refId={$this->refId} / usrId={$this->getUserId()} / levelId={$skillLevelId} / trefId={$skillTrefId}"
        );
    }

    public function getSkillsMatchingNumAnswersBarrier(): array
    {
        $skillsMatchingNumAnswersBarrier = [];

        foreach ($this->skillPointAccounts as $skillKey => $skillPointAccount) {
            if ($this->doesNumBookingsExceedRequiredBookingsBarrier($skillPointAccount)) {
                list($skillBaseId, $skillTrefId) = explode(':', $skillKey);

                $skillsMatchingNumAnswersBarrier[$skillKey] = [
                    'base_skill_id' => (int) $skillBaseId,
                    'tref_id' => (int) $skillTrefId
                ];
            }
        }

        return $skillsMatchingNumAnswersBarrier;
    }

    public function getSkillsInvolvedByAssignment(): array
    {
        $uniqueSkills = [];

        foreach ($this->skillQuestionAssignmentList->getUniqueAssignedSkills() as $skill) {
            $skillKey = $skill['skill_base_id'] . ':' . $skill['skill_tref_id'];

            $uniqueSkills[$skillKey] = [
                'base_skill_id' => (int) $skill['skill_base_id'],
                'tref_id' => (int) $skill['skill_tref_id']
            ];
        }

        return $uniqueSkills;
    }

    public function isAssignedSkill($skillBaseId, $skillTrefId)
    {
        $this->skillQuestionAssignmentList->isAssignedSkill($skillBaseId, $skillTrefId);
    }

    public function getAssignedSkillMatchingSkillProfiles(): array
    {
        $matchingSkillProfiles = [];

        $usersProfiles = $this->skill_profile_service->getProfilesOfUser($this->getUserId());

        foreach ($usersProfiles as $profileData) {
            $assignedSkillLevels = $this->skill_profile_service->getSkillLevels($profileData->getId());

            foreach ($assignedSkillLevels as $assignedSkillLevel) {
                $skillBaseId = $assignedSkillLevel->getBaseSkillId();
                $skillTrefId = $assignedSkillLevel->getTrefId();

                if ($this->skillQuestionAssignmentList->isAssignedSkill($skillBaseId, $skillTrefId)) {
                    $matchingSkillProfiles[$profileData->getId()] = $profileData->getTitle();
                }
            }
        }

        return $matchingSkillProfiles;
    }

    public function noProfileMatchingAssignedSkillExists(array $availableSkillProfiles): bool
    {
        $noProfileMatchingSkills = $this->skillQuestionAssignmentList->getUniqueAssignedSkills();

        foreach ($availableSkillProfiles as $skillProfileId => $skillProfileTitle) {
            $profile = $this->skill_profile_service->getProfile($skillProfileId);
            $assignedSkillLevels = $this->skill_profile_service->getSkillLevels($profile->getId());

            foreach ($assignedSkillLevels as $assignedSkillLevel) {
                $skillBaseId = $assignedSkillLevel->getBaseSkillId();
                $skillTrefId = $assignedSkillLevel->getTrefId();

                if ($this->skillQuestionAssignmentList->isAssignedSkill($skillBaseId, $skillTrefId)) {
                    unset($noProfileMatchingSkills["{$skillBaseId}:{$skillTrefId}"]);
                }
            }
        }

        return $noProfileMatchingSkills !== [];
    }
}