class.SkillProfileCompletionManager.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
namespace ILIAS\Skill\Profile;
 
use ILIAS\Container\Skills\ContainerSkill;
use ILIAS\Skill\GapAnalysisSkill;
 
class SkillProfileCompletionManager
{
    protected SkillProfileManager $profile_manager;
    protected SkillProfileCompletionDBRepository $profile_completion_repo;
    protected \ilTree $tree_service;
    protected \ilObjectDefinition $obj_definition;
 
    public function __construct(
        SkillProfileManager $profile_manager,
        ?SkillProfileCompletionDBRepository $profile_completion_repo = null
    ) {
        global $DIC;
 
        $this->profile_manager = $profile_manager;
        $this->profile_completion_repo = ($profile_completion_repo)
            ?: $DIC->skills()->internal()->repo()->getProfileCompletionRepo();
        $this->tree_service = $DIC->repositoryTree();
        $this->obj_definition = $DIC["objDefinition"];
    }
 
    public function getActualMaxLevels(
        int $user_id,
        array $skills,
        string $gap_mode = "",
        string $gap_mode_type = "",
        int $gap_mode_obj_id = 0,
        string $trigger_user = ""
    ): array {
        // get actual levels for gap analysis
        $actual_levels = [];
        foreach ($skills as $sk) {
            $bs = new \ilBasicSkill($sk->getBaseSkillId());
            if ($gap_mode == "max_per_type") {
                $max = $bs->getMaxLevelPerType($sk->getTrefId(), $gap_mode_type, $user_id);
            } elseif ($gap_mode == "max_per_object") {
                if ($this->obj_definition->isContainer(\ilObject::_lookupType($gap_mode_obj_id))) {
                    $sub_objects = $this->tree_service->getSubTree(
                        $this->tree_service->getNodeData((int) current(\ilObject::_getAllReferences($gap_mode_obj_id))),
                        false,
                        \ilObjectLP::getSupportedObjectTypes()
                    );
                    $max = 0;
                    foreach ($sub_objects as $ref_id) {
                        $obj_id = \ilContainerReference::_lookupObjectId($ref_id);
                        $max_tmp = $bs->getMaxLevelPerObject($sk->getTrefId(), $obj_id, $user_id, 0, $trigger_user);
                        if ($max_tmp > $max) {
                            $max = $max_tmp;
                        }
                    }
                } else {
                    $max = $bs->getMaxLevelPerObject($sk->getTrefId(), $gap_mode_obj_id, $user_id, 0, $trigger_user);
                }
            } else {
                $max = $bs->getMaxLevel($sk->getTrefId(), $user_id);
            }
            $actual_levels[$sk->getBaseSkillId()][$sk->getTrefId()] = $max;
        }
 
        return $actual_levels;
    }
 
    public function getLastLevelPerObjectAndTriggerUser(
        int $user_id,
        array $skills,
        int $obj_id,
        string $trigger_user
    ): array {
        // get actual levels for gap analysis
        $last_levels = [];
        foreach ($skills as $sk) {
            $bs = new \ilBasicSkill($sk->getBaseSkillId());
            $last = $bs->getLastLevelEntryOfUser(
                $sk->getTrefId(),
                $user_id,
                $obj_id,
                0,
                $trigger_user
            );
            $last_levels[$sk->getBaseSkillId()][$sk->getTrefId()] = $last;
        }
        return $last_levels;
    }
 
    public function getActualLastLevels(
        int $user_id,
        array $skills,
        string $gap_mode = "",
        string $gap_mode_type = "",
        int $gap_mode_obj_id = 0
    ): array {
        // todo for coming feature
        return [];
    }
 
    public function getActualNextLevelFulfilments(
        int $user_id,
        array $skills,
        string $gap_mode = "",
        string $gap_mode_type = "",
        int $gap_mode_obj_id = 0
    ): array {
        // get actual next level fulfilments for gap analysis
        $fuls = [];
        foreach ($skills as $sk) {
            $bs = new \ilBasicSkill($sk->getBaseSkillId());
            if ($gap_mode == "max_per_type") {
                $perc = $bs->getNextLevelFulfilmentPerType($sk->getTrefId(), $gap_mode_type, $user_id);
            } elseif ($gap_mode == "max_per_object") {
                $perc = $bs->getNextLevelFulfilmentPerObject($sk->getTrefId(), $gap_mode_obj_id, $user_id);
            } else {
                $perc = $bs->getNextLevelFulfilment($sk->getTrefId(), $user_id);
            }
            $fuls[$sk->getBaseSkillId()][$sk->getTrefId()] = $perc;
        }
 
        return $fuls;
    }
 
    public function getProfileProgress(int $user_id, int $profile_id): int
    {
        $profile_levels = $this->profile_manager->getSkillLevels($profile_id);
        $actual_levels = $this->getActualMaxLevels($user_id, $profile_levels);
 
        $profile_count = 0;
        $achieved_count = 0;
        foreach ($profile_levels as $level) {
            if (isset($actual_levels[$level->getBaseSkillId()][$level->getTrefId()]) &&
                $actual_levels[$level->getBaseSkillId()][$level->getTrefId()] >= $level->getLevelId()) {
                $achieved_count++;
            }
            $profile_count++;
        }
        if ($profile_count == 0) {
            return 0;
        }
        $progress = $achieved_count / $profile_count * 100;
 
        return (int) $progress;
    }
 
    public function isProfileFulfilled(int $user_id, int $profile_id): bool
    {
        if ($this->getProfileProgress($user_id, $profile_id) == 100) {
            return true;
        }
        return false;
    }
 
    public function getAllProfileCompletionsForUser(int $user_id): array
    {
        $user_profiles = $this->profile_manager->getProfilesOfUser($user_id);
        $profile_comps = [];
        foreach ($user_profiles as $p) {
            if ($this->isProfileFulfilled($user_id, $p->getId())) {
                $profile_comps[$p->getId()] = true;
            } else {
                $profile_comps[$p->getId()] = false;
            }
        }
 
        return $profile_comps;
    }
 
    public function getEntries(int $user_id, int $profile_id): array
    {
        return $this->profile_completion_repo->getEntries($user_id, $profile_id);
    }
 
    public function getFulfilledEntriesForUser(int $user_id): array
    {
        return $this->profile_completion_repo->getFulfilledEntriesForUser($user_id);
    }
 
    public function getAllEntriesForUser(int $user_id): array
    {
        return $this->profile_completion_repo->getAllEntriesForUser($user_id);
    }
 
    public function getAllEntriesForProfile(int $profile_id): array
    {
        return $this->profile_completion_repo->getAllEntriesForProfile($profile_id);
    }
 
    public function writeCompletionEntryForAllProfilesOfUser(int $user_id): void
    {
        $completions = $this->getAllProfileCompletionsForUser($user_id);
        foreach ($completions as $profile_id => $fulfilled) {
            if ($fulfilled) {
                $this->profile_completion_repo->addFulfilmentEntry($user_id, $profile_id);
            } else {
                $this->profile_completion_repo->addNonFulfilmentEntry($user_id, $profile_id);
            }
        }
    }
 
    public function writeCompletionEntryForSingleProfileOfUser(int $user_id, int $profile_id): void
    {
        if ($this->isProfileFulfilled($user_id, $profile_id)) {
            $this->profile_completion_repo->addFulfilmentEntry($user_id, $profile_id);
        } else {
            $this->profile_completion_repo->addNonFulfilmentEntry($user_id, $profile_id);
        }
    }
 
    public function writeCompletionEntryForAllAssignedUsersOfProfile(int $profile_id): void
    {
        $users = $this->profile_manager->getAssignedUserIdsIncludingRoleAssignments($profile_id);
        foreach ($users as $user_id) {
            $this->writeCompletionEntryForSingleProfileOfUser($user_id, $profile_id);
        }
    }
 
    public function writeCompletionEntryForRole(int $role_id, int $profile_id): void
    {
        $r_users = $this->profile_manager->getAssignedUsersForRole($role_id);
        foreach ($r_users as $user_id) {
            $this->writeCompletionEntryForSingleProfileOfUser($user_id, $profile_id);
        }
    }
 
    public function deleteEntriesForProfile(int $profile_id): void
    {
        $this->profile_completion_repo->deleteEntriesForProfile($profile_id);
    }
 
    public function deleteEntriesForUser(int $user_id): void
    {
        $this->profile_completion_repo->deleteEntriesForUser($user_id);
    }
}