class.ilObjStudyProgramme.php

Go to the documentation of this file.

<?php

/* Copyright (c) 2015 Richard Klees <richard.klees@concepts-and-training.de> Extended GPL, see docs/LICENSE */

require_once("./Services/Container/classes/class.ilContainer.php");
require_once('./Services/Container/classes/class.ilContainerSorting.php');
require_once("./Modules/StudyProgramme/classes/model/class.ilStudyProgramme.php");
require_once("./Modules/StudyProgramme/classes/class.ilObjectFactoryWrapper.php");
require_once("./Modules/StudyProgramme/classes/interfaces/interface.ilStudyProgrammeLeaf.php");
require_once("./Modules/StudyProgramme/classes/exceptions/class.ilStudyProgrammeTreeException.php");
require_once("./Modules/StudyProgramme/classes/class.ilObjStudyProgrammeCache.php");

class ilObjStudyProgramme extends ilContainer
{
    protected $settings; // ilStudyProgramme | null
    protected $parent; // ilObjStudyProgramme | null | false
    protected $children; // [ilObjStudyProgramme] | null
    protected $lp_children; // [ilStudyProgrammeLeaf] | null;

    // GLOBALS from ILIAS
    public $webdir;
    public $tree;
    public $ilUser;

    // Wrapped static ilObjectFactory of ILIAS.
    public $object_factory;
    // Cache for study programmes
    public static $study_programme_cache = null;

    protected $sp_user_progress_db;

    public function __construct($a_id = 0, $a_call_by_reference = true)
    {
        $this->type = "prg";
        $this->settings = null;
        parent::__construct($a_id, $a_call_by_reference);

        $this->clearParentCache();
        $this->clearChildrenCache();
        $this->clearLPChildrenCache();

        global $DIC;
        $tree = $DIC['tree'];
        $ilUser = $DIC['ilUser'];
        $this->webdir = $DIC->filesystem()->web();
        $this->tree = $tree;
        $this->ilUser = $ilUser;

        $this->object_factory = ilObjectFactoryWrapper::singleton();
        self::initStudyProgrammeCache();
    }

    public static function initStudyProgrammeCache()
    {
        if (self::$study_programme_cache === null) {
            self::$study_programme_cache = ilObjStudyProgrammeCache::singleton();
        }
    }

    public function getStudyProgrammeUserProgressDB()
    {
        if (!$this->sp_user_progress_db) {
            $this->sp_user_progress_db = static::_getStudyProgrammeUserProgressDB();
        }
        return $this->sp_user_progress_db;
    }

    public static function _getStudyProgrammeUserProgressDB()
    {
        require_once("./Modules/StudyProgramme/classes/class.ilStudyProgrammeUserProgressDB.php");
        static $sp_user_progress_db = null;
        if ($sp_user_progress_db === null) {
            $sp_user_progress_db = new ilStudyProgrammeUserProgressDB();
        }
        return $sp_user_progress_db;
    }


    protected function clearParentCache()
    {
        // This is not initialized, but we need null if there is no parent.
        $this->parent = false;
    }

    protected function clearChildrenCache()
    {
        $this->children = null;
    }

    protected function clearLPChildrenCache()
    {
        $this->lp_children = null;
    }


    public static function getInstanceByRefId($a_ref_id)
    {
        require_once("Modules/StudyProgramme/classes/class.ilObjStudyProgrammeCache.php");
        if (self::$study_programme_cache === null) {
            self::initStudyProgrammeCache();
        }
        return self::$study_programme_cache->getInstanceByRefId($a_ref_id);
    }

    public static function createInstance()
    {
        $obj = new ilObjStudyProgramme();
        $obj->create();
        $obj->createReference();
        self::$study_programme_cache->addInstance($obj);
        return $obj;
    }


    // CRUD

    protected function readSettings()
    {
        if ($this->settings !== null) {
            throw new ilException("ilObjStudyProgramme::loadSettings: already loaded.");
        }
        $id = $this->getId();
        if (!$id) {
            throw new ilException("ilObjStudyProgramme::loadSettings: no id.");
        }
        $this->settings = new ilStudyProgramme($this->getId());
    }

    protected function createSettings()
    {
        if ($this->settings !== null) {
            throw new ilException("ilObjStudyProgramme::createSettings: already loaded.");
        }

        $id = $this->getId();
        if (!$id) {
            throw new ilException("ilObjStudyProgramme::loadSettings: no id.");
        }
        $this->settings = ilStudyProgramme::createForObject($this);
    }

    protected function updateSettings()
    {
        if ($this->settings === null) {
            throw new ilException("ilObjStudyProgramme::updateSettings: no settings loaded.");
        }
        $this->settings->update();
    }

    protected function deleteSettings()
    {
        if ($this->settings === null) {
            throw new Exception("ilObjStudyProgramme::deleteSettings: no settings loaded.");
        }
        $this->settings->delete();
    }

    protected function deleteAssignments()
    {
        foreach ($this->getAssignments() as $ass) {
            $ass->delete();
        }
    }

    public function read()
    {
        parent::read();
        $this->readSettings();
    }


    public function create()
    {
        $id = parent::create();
        $this->createSettings();

        return $id;
    }


    public function update()
    {
        parent::update();

        // Update selection for advanced meta data of the type
        if ($this->getSubType()) {
            ilAdvancedMDRecord::saveObjRecSelection($this->getId(), 'prg_type', $this->getSubType()->getAssignedAdvancedMDRecordIds());
        } else {
            // If no type is assigned, delete relations by passing an empty array
            ilAdvancedMDRecord::saveObjRecSelection($this->getId(), 'prg_type', array());
        }

        $this->updateSettings();
    }

    public function delete()
    {
        // always call parent delete function first!!
        if (!parent::delete()) {
            return false;
        }

        $this->deleteSettings();
        try {
            $this->deleteAssignments();
        } catch (ilStudyProgrammeTreeException $e) {
            // This would be the case when SP is in trash (#17797)
        }

        return true;
    }

    // GETTERS AND SETTERS

    public function getLastChange()
    {
        return $this->settings->getLastChange();
    }

    public function getPoints()
    {
        return $this->settings->getPoints();
    }

    public function setPoints($a_points)
    {
        $this->settings->setPoints($a_points);
        $this->updateLastChange();
        return $this;
    }

    public function getLPMode()
    {
        return $this->settings->getLPMode();
    }

    public function adjustLPMode()
    {
        if ($this->getAmountOfLPChildren() > 0) {
            $this->settings->setLPMode(ilStudyProgramme::MODE_LP_COMPLETED)
                           ->update();
        } else {
            if ($this->getAmountOfChildren() > 0) {
                $this->settings->setLPMode(ilStudyProgramme::MODE_POINTS)
                               ->update();
            } else {
                $this->settings->setLPMode(ilStudyProgramme::MODE_UNDEFINED)
                               ->update();
            }
        }
    }

    public function getStatus()
    {
        return $this->settings->getStatus();
    }

    public function setStatus($a_status)
    {
        $this->settings->setStatus($a_status);
        $this->updateLastChange();
        return $this;
    }

    public function isActive()
    {
        return $this->getStatus() == ilStudyProgramme::STATUS_ACTIVE;
    }

    public function getSubtypeId()
    {
        return $this->settings->getSubtypeId();
    }


    public function setSubtypeId($a_subtype_id)
    {
        $this->settings->setSubtypeId($a_subtype_id);
        return $this;
    }

    public function getSubType()
    {
        if (!in_array($this->getSubtypeId(), array("-", "0"))) {
            $subtype_id = $this->getSubtypeId();
            return new ilStudyProgrammeType($subtype_id);
        }

        return null;
    }

    // TREE NAVIGATION

    public static function getAllChildren($a_ref_id)
    {
        $ret = array();
        $root = self::getInstanceByRefId($a_ref_id);
        $root_id = $root->getId();
        $root->applyToSubTreeNodes(function ($prg) use (&$ret, $root_id) {
            // exclude root node of subtree.
            if ($prg->getId() == $root_id) {
                return;
            }
            $ret[] = $prg;
        });
        return $ret;
    }

    public function getChildren()
    {
        $this->throwIfNotInTree();

        if ($this->children === null) {
            $ref_ids = $this->tree->getChildsByType($this->getRefId(), "prg");

            // apply container sorting to tree
            $sorting = ilContainerSorting::_getInstance($this->getId());
            $ref_ids = $sorting->sortItems(array('prg' => $ref_ids));
            $ref_ids = $ref_ids['prg'];

            $this->children = array_map(function ($node_data) {
                return ilObjStudyProgramme::getInstanceByRefId($node_data["child"]);
            }, $ref_ids);
        }

        return $this->children;
    }

    public function getParent()
    {
        if ($this->parent === false) {
            $this->throwIfNotInTree();
            $parent_data = $this->tree->getParentNodeData($this->getRefId());
            if ($parent_data["type"] != "prg") {
                $this->parent = null;
            } else {
                $this->parent = ilObjStudyProgramme::getInstanceByRefId($parent_data["ref_id"]);
            }
        }
        return $this->parent;
    }

    public function getParents()
    {
        $current = $this;
        $parents = array();
        while (true) {
            $current = $current->getParent();
            if ($current === null) {
                return array_reverse($parents);
            }
            $parents[] = $current;
        }
    }

    public function hasChildren()
    {
        return $this->getAmountOfChildren() > 0;
    }

    public function getAmountOfChildren()
    {
        return count($this->getChildren());
    }

    public function getDepth()
    {
        $cur = $this;
        $count = 0;
        while ($cur = $cur->getParent()) {
            $count++;
        }
        return $count;
    }

    public function getRoot()
    {
        $parents = $this->getParents();
        return $parents[0];
    }

    public function getLPChildren()
    {
        $this->throwIfNotInTree();

        if ($this->lp_children === null) {
            $this->lp_children = array();

            // TODO: find a better way to get all elements except StudyProgramme-children
            $ref_ids = $this->tree->getChildsByType($this->getRefId(), "crsr");

            // apply container sorting to tree
            $sorting = ilContainerSorting::_getInstance($this->getId());
            $ref_ids = $sorting->sortItems(array('crs_ref' => $ref_ids));
            $ref_ids = $ref_ids['crs_ref'];

            $lp_children = array_map(function ($node_data) {
                $lp_obj = $this->object_factory->getInstanceByRefId($node_data["child"]);

                // filter out all StudyProgramme instances
                return ($lp_obj instanceof $this)? null : $lp_obj;
            }, $ref_ids);

            $this->lp_children = array_filter($lp_children);
        }
        return $this->lp_children;
    }

    public function getLPChildrenIds()
    {
        return array_map(function ($child) {
            return $child->getId();
        }, $this->getLPChildren());
    }

    public function getAmountOfLPChildren()
    {
        return count($this->getLPChildren());
    }

    public function hasLPChildren()
    {
        return ($this->getAmountOfLPChildren() > 0);
    }

    protected function throwIfNotInTree()
    {
        if (!$this->tree->isInTree($this->getRefId())) {
            throw new ilStudyProgrammeTreeException("This program is not in tree.");
        }
    }

    // QUERIES ON SUBTREE

    public function applyToSubTreeNodes(Closure $fun)
    {
        $this->throwIfNotInTree();

        if ($fun($this) !== false) {
            foreach ($this->getChildren() as $child) {
                $child->applyToSubTreeNodes($fun);
            }
        }
    }

    public function getCompletedCourses($a_user_id)
    {
        require_once("Services/ContainerReference/classes/class.ilContainerReference.php");
        require_once("Services/Tracking/classes/class.ilLPStatus.php");

        $node_data = $this->tree->getNodeData($this->getRefId());
        $crsrs = $this->tree->getSubTree($node_data, true, "crsr");

        $completed_crss = array();
        foreach ($crsrs as $ref) {
            $crs_id = ilContainerReference::_lookupTargetId($ref["obj_id"]);
            if (ilLPStatus::_hasUserCompleted($crs_id, $a_user_id)) {
                $completed_crss[] = array( "crs_id" => $crs_id
                                         , "prg_ref_id" => $ref["parent"]
                                         , "crsr_ref_id" => $ref["child"]
                                         , "crsr_id" => $ref["obj_id"]
                                         , "title" => ilContainerReference::_lookupTargetTitle($ref["obj_id"])
                                         );
            }
        }

        return $completed_crss;
    }

    // TREE MANIPULATION

    public function addNode(ilObjStudyProgramme $a_prg)
    {
        $this->throwIfNotInTree();

        if ($this->getLPMode() == ilStudyProgramme::MODE_LP_COMPLETED) {
            throw new ilStudyProgrammeTreeException("Program already contains leafs.");
        }

        if ($this->tree->isInTree($a_prg->getRefId())) {
            throw new ilStudyProgrammeTreeException("Other program already is in tree.");
        }

        if ($a_prg->getRefId() === null) {
            $a_prg->createReference();
        }
        $a_prg->putInTree($this->getRefId());
        return $this;
    }

    protected function nodeInserted(ilObjStudyProgramme $a_prg)
    {
        if ($this->getLPMode() == ilStudyProgramme::MODE_LP_COMPLETED) {
            throw new ilStudyProgrammeTreeException("Program already contains leafs.");
        }

        if ($this->settings->getLPMode() !== ilStudyProgramme::MODE_POINTS) {
            $this->settings->setLPMode(ilStudyProgramme::MODE_POINTS)
                           ->update();
        }

        $this->clearChildrenCache();
        $this->addMissingProgresses();
    }

    public function putInTree($a_parent_ref)
    {
        $res = parent::putInTree($a_parent_ref);

        if (ilObject::_lookupType($a_parent_ref, true) == "prg") {
            $par = ilObjStudyProgramme::getInstanceByRefId($a_parent_ref);
            $par->nodeInserted($this);
        }

        return $res;
    }

    public function removeNode(ilObjStudyProgramme $a_prg)
    {
        if ($a_prg->getParent()->getId() !== $this->getId()) {
            throw new ilStudyProgrammeTreeException("This is no parent of the given programm.");
        }

        if (!$a_prg->canBeRemoved()) {
            throw new ilStudyProgrammeTreeException("The node has relevant assignments.");
        }

        // *sigh*...
        $node_data = $this->tree->getNodeData($a_prg->getRefId());
        $this->tree->deleteTree($node_data);
        $a_prg->clearParentCache();
        $this->clearChildrenCache();

        return $this;
    }

    public function canBeRemoved()
    {
        foreach ($this->getProgresses() as $progress) {
            if ($progress->getStatus() != ilStudyProgrammeProgress::STATUS_NOT_RELEVANT) {
                return false;
            }
            if ($progress->getLastChangeBy() !== null) {
                return false;
            }
        }
        return true;
    }

    public function addLeaf(/*ilStudyProgrammeLeaf*/ $a_leaf)
    {
        $this->throwIfNotInTree();

        if ($this->hasChildren()) {
            throw new ilStudyProgrammeTreeException("Program already contains other programm nodes.");
        }

        if ($a_leaf->getRefId() === null) {
            $a_leaf->createReference();
        }
        $a_leaf->putInTree($this->getRefId());
        $this->clearLPChildrenCache();

        $this->settings->setLPMode(ilStudyProgramme::MODE_LP_COMPLETED);
        $this->update();

        return $this;
    }

    public function removeLeaf(/*ilStudyProgrammeLeaf*/ $a_leaf)
    {
        if (self::getParentId($a_leaf) !== $this->getId()) {
            throw new ilStudyProgrammeTreeException("This is no parent of the given leaf node.");
        }

        $node_data = $this->tree->getNodeData($a_leaf->getRefId());
        $this->tree->deleteTree($node_data);
        $this->clearLPChildrenCache();

        return $this;
    }

    public function moveTo(ilObjStudyProgramme $a_new_parent)
    {
        global $DIC;
        $rbacadmin = $DIC['rbacadmin'];

        if ($parent = $this->getParent()) {

            // TODO: check if there some leafs in the new parent

            $this->tree->moveTree($this->getRefId(), $a_new_parent->getRefId());
            // necessary to clean up permissions
            $rbacadmin->adjustMovedObjectPermissions($this->getRefId(), $parent->getRefId());

            // TODO: lp-progress needs to be updated

            // clear caches on different nodes
            $this->clearParentCache();

            $parent->clearChildrenCache();
            $parent->clearLPChildrenCache();

            $a_new_parent->clearChildrenCache();
            $a_new_parent->clearLPChildrenCache();
        }

        return $this;
    }

    // USER ASSIGNMENTS

    public function assignUser($a_usr_id, $a_assigning_usr_id = null)
    {
        require_once("./Modules/StudyProgramme/classes/class.ilStudyProgrammeUserAssignment.php");
        require_once("./Modules/StudyProgramme/classes/model/class.ilStudyProgrammeAssignment.php");
        require_once("./Modules/StudyProgramme/classes/model/class.ilStudyProgrammeProgress.php");
        require_once("./Modules/StudyProgramme/classes/class.ilStudyProgrammeEvents.php");

        if ($this->settings === null) {
            throw new ilException("ilObjStudyProgramme::assignUser: Program was not properly created.'");
        }

        if ($this->getStatus() != ilStudyProgramme::STATUS_ACTIVE) {
            throw new ilException("ilObjStudyProgramme::assignUser: Can't assign user to program '"
                                 . $this->getId() . "', since it's not in active status.");
        }

        if ($a_assigning_usr_id === null) {
            $a_assigning_usr_id = $this->ilUser->getId();
        }

        $ass_mod = ilStudyProgrammeAssignment::createFor($this->settings, $a_usr_id, $a_assigning_usr_id);
        $ass = new ilStudyProgrammeUserAssignment($ass_mod, $this->getStudyProgrammeUserProgressDB());

        $this->applyToSubTreeNodes(function (ilObjStudyProgramme $node) use ($ass_mod, $a_assigning_usr_id) {
            $progress = $node->createProgressForAssignment($ass_mod);
            if ($node->getStatus() != ilStudyProgramme::STATUS_ACTIVE) {
                $progress->setStatus(ilStudyProgrammeProgress::STATUS_NOT_RELEVANT)
                         ->update();
            }
        });

        ilStudyProgrammeEvents::userAssigned($ass);

        return $ass;
    }

    public function removeAssignment(ilStudyProgrammeUserAssignment $a_assignment)
    {
        require_once("./Modules/StudyProgramme/classes/class.ilStudyProgrammeEvents.php");

        if ($a_assignment->getStudyProgramme()->getId() != $this->getId()) {
            throw new ilException("ilObjStudyProgramme::removeAssignment: Assignment '"
                                 . $a_assignment->getId() . "' does not belong to study "
                                 . "program '" . $this->getId() . "'.");
        }

        ilStudyProgrammeEvents::userDeassigned($a_assignment);

        $a_assignment->delete();

        return $this;
    }

    public function hasAssignmentOf($a_user_id)
    {
        return $this->getAmountOfAssignmentsOf($a_user_id) > 0;
    }

    public function getAmountOfAssignmentsOf($a_user_id)
    {
        return count($this->getAssignmentsOf($a_user_id));
    }

    public function getAssignmentsOf($a_user_id)
    {
        require_once("./Modules/StudyProgramme/classes/class.ilStudyProgrammeUserAssignment.php");

        $prg_ids = $this->getIdsFromNodesOnPathFromRootToHere();
        $assignments = ilStudyProgrammeAssignment::where(array( "usr_id" => $a_user_id
                                                                 , "root_prg_id" => $prg_ids
                                                           ))
                                                    ->orderBy("last_change", "DESC")
                                                    ->get();
        return array_map(function ($ass) {
            return new ilStudyProgrammeUserAssignment($ass, $this->getStudyProgrammeUserProgressDB());
        }, array_values($assignments)); // use array values since we want keys 0...
    }

    public function getAssignments()
    {
        return array_map(function ($ass) {
            return new ilStudyProgrammeUserAssignment($ass, $this->getStudyProgrammeUserProgressDB());
        }, array_values($this->getAssignmentsRaw())); // use array values since we want keys 0...
    }

    public function hasAssignments()
    {
        return count($this->getAssignments()) > 0;
    }

    public function updateAllAssignments()
    {
        $assignments = ilStudyProgrammeUserAssignment::getInstancesForProgram($this->getId());
        foreach ($assignments as $ass) {
            $ass->updateFromProgram();
        }
        return $this;
    }

    // USER PROGRESS

    public function createProgressForAssignment(ilStudyProgrammeAssignment $ass)
    {
        return ilStudyProgrammeProgress::createFor($this->settings, $ass);
    }

    public function getProgressesOf($a_user_id)
    {
        return $this->getStudyProgrammeUserProgressDB()->getInstancesForUser($this->getId(), $a_user_id);
    }

    public function getProgressForAssignment($a_assignment_id)
    {
        return $this->getStudyProgrammeUserProgressDB()->getInstanceForAssignment($this->getId(), $a_assignment_id);
    }

    public function addMissingProgresses()
    {
        foreach ($this->getAssignments() as $ass) {
            $ass->addMissingProgresses();
        }
    }

    public function getProgresses()
    {
        return $this->getStudyProgrammeUserProgressDB()->getInstancesForProgram($this->getId());
    }

    public function hasProgresses()
    {
        return count($this->getProgresses()) > 0;
    }

    public function hasRelevantProgresses()
    {
        foreach ($this->getProgresses() as $progress) {
            if ($progress->isRelevant()) {
                return true;
            }
        }
        return false;
    }

    public function getIdsOfUsersWithRelevantProgress()
    {
        $returns = array();
        foreach ($this->getProgresses() as $progress) {
            if ($progress->isRelevant()) {
                $returns[] = $progress->getUserId();
            }
        }
        return array_unique($returns);
    }

    public function getIdsOfUsersWithCompletedProgress()
    {
        $returns = array();
        foreach ($this->getProgresses() as $progress) {
            if ($progress->isSuccessful()) {
                $returns[] = $progress->getUserId();
            }
        }
        return array_unique($returns);
    }

    public function getIdsOfUsersWithFailedProgress()
    {
        $returns = array();
        foreach ($this->getProgresses() as $progress) {
            $progress->recalculateFailedToDeadline();
            if ($progress->isFailed()) {
                $returns[] = $progress->getUserId();
            }
        }
        return array_unique($returns);
    }

    public function getIdsOfUsersWithNotCompletedAndRelevantProgress()
    {
        $returns = array();
        foreach ($this->getProgresses() as $progress) {
            if ($progress->isRelevant() && !$progress->isSuccessful()) {
                $returns[] = $progress->getUserId();
            }
        }
        return array_unique($returns);
    }

    // HELPERS

    protected function updateLastChange()
    {
        $this->settings->updateLastChange();
        if ($parent = $this->getParent()) {
            $parent->updateLastChange();
        }
        $this->update();
    }

    protected function getIdsFromNodesOnPathFromRootToHere()
    {
        $prg_ids = array_map(function ($par) {
            return $par->getId();
        }, $this->getParents());
        $prg_ids[] = $this->getId();
        return $prg_ids;
    }

    protected function getAssignmentsRaw()
    {
        require_once("./Modules/StudyProgramme/classes/class.ilStudyProgrammeUserAssignment.php");
        $prg_ids = $this->getIdsFromNodesOnPathFromRootToHere();
        return ilStudyProgrammeAssignment::where(array( "root_prg_id" => $prg_ids))
                                                ->orderBy("last_change", "DESC")
                                                ->get();
    }

    public static function setProgressesCompletedFor($a_obj_id, $a_user_id)
    {
        // We only use courses via crs_refs
        $type = ilObject::_lookupType($a_obj_id);
        if ($type == "crs") {
            require_once("Services/ContainerReference/classes/class.ilContainerReference.php");
            $crs_reference_obj_ids = ilContainerReference::_lookupSourceIds($a_obj_id);
            foreach ($crs_reference_obj_ids as $obj_id) {
                foreach (ilObject::_getAllReferences($obj_id) as $ref_id) {
                    self::setProgressesCompletedIfParentIsProgrammeInLPCompletedMode($ref_id, $obj_id, $a_user_id);
                }
            }
        } else {
            foreach (ilObject::_getAllReferences($a_obj_id) as $ref_id) {
                self::setProgressesCompletedIfParentIsProgrammeInLPCompletedMode($ref_id, $a_obj_id, $a_user_id);
            }
        }
    }

    protected static function setProgressesCompletedIfParentIsProgrammeInLPCompletedMode($a_ref_id, $a_obj_id, $a_user_id)
    {
        global $DIC; // TODO: replace this by a settable static for testing purpose?
        $tree = $DIC['tree'];
        $node_data = $tree->getParentNodeData($a_ref_id);
        if ($node_data["type"] !== "prg") {
            return;
        }
        self::initStudyProgrammeCache();
        $prg = ilObjStudyProgramme::getInstanceByRefId($node_data["child"]);
        if ($prg->getLPMode() != ilStudyProgramme::MODE_LP_COMPLETED) {
            return;
        }
        foreach ($prg->getProgressesOf($a_user_id) as $progress) {
            $progress->setLPCompleted($a_obj_id, $a_user_id);
        }
    }

    protected static function getParentId(ilObject $a_object)
    {
        global $DIC;
        $tree = $DIC['tree'];
        if (!$tree->isInTree($a_object->getRefId())) {
            return null;
        }

        $nd = $tree->getParentNodeData($a_object->getRefId());
        return $nd["obj_id"];
    }

    public function getRawSettings()
    {
        return $this->settings;
    }

    public function updateCustomIcon()
    {
        global $DIC;

        $customIconFactory = $DIC['object.customicons.factory'];
        $customIcon = $customIconFactory->getByObjId($this->getId(), $this->getType());

        $subtype = $this->getSubType();

        if ($subtype) {
            if ($this->webdir->has($subtype->getIconPath(true))) {
                $icon = $subtype->getIconPath(true);
                $customIcon->saveFromSourceFile($icon);
            } else {
                $customIcon->remove();
            }
        } else {
            $customIcon->remove();
        }
    }

    // HOOKS

    public static function getCreatableSubObjects($a_subobjects, $a_ref_id)
    {
        if ($a_ref_id === null) {
            return $a_subobjects;
        }

        if (ilObject::_lookupType($a_ref_id, true) != "prg") {
            throw new ilException("Ref-Id '$a_ref_id' does not belong to a study programme object.");
        }

        $parent = ilObjStudyProgramme::getInstanceByRefId($a_ref_id);

        $mode = $parent->getLPMode();

        switch ($mode) {
            case ilStudyProgramme::MODE_UNDEFINED:
                return $a_subobjects;
            case ilStudyProgramme::MODE_POINTS:
                return array("prg" => $a_subobjects["prg"]);
            case ilStudyProgramme::MODE_LP_COMPLETED:
                unset($a_subobjects["prg"]);
                return $a_subobjects;
        }

        throw new ilException("Undefined mode for study programme: '$mode'");
    }
}