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 $tree;
        public $ilUser;
        
        // Wrapped static ilObjectFactory of ILIAS.
        public $object_factory;
        // Cache for study programmes
        static public $study_programme_cache = null;
        
        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->tree = $tree;
                $this->ilUser = $ilUser;

                $this->object_factory = ilObjectFactoryWrapper::singleton();
                self::initStudyProgrammeCache();
        }
        
        static public function initStudyProgrammeCache() {
                if (self::$study_programme_cache === null) {
                        self::$study_programme_cache = ilObjStudyProgrammeCache::singleton();
                }
        }
        
        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;
        }
        
        
        static public 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);
        }
        
        static public 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

        static public 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->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);
                }, array_values($assignments)); // use array values since we want keys 0...
        }
        
        public function getAssignments() {
                return array_map(function($ass) {
                        return new ilStudyProgrammeUserAssignment($ass);
                }, 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) {
                require_once("./Modules/StudyProgramme/classes/class.ilStudyProgrammeUserProgress.php");
                return ilStudyProgrammeUserProgress::getInstancesForUser($this->getId(), $a_user_id);
        }
        
        public function getProgressForAssignment($a_assignment_id) {
                require_once("./Modules/StudyProgramme/classes/class.ilStudyProgrammeUserProgress.php");
                return ilStudyProgrammeUserProgress::getInstanceForAssignment($this->getId(), $a_assignment_id);
        }
        
        public function addMissingProgresses() {
                foreach ($this->getAssignments() as $ass) {
                        $ass->addMissingProgresses();
                }
        }
        
        public function getProgresses() {
                require_once("./Modules/StudyProgramme/classes/class.ilStudyProgrammeUserProgress.php");
                return ilStudyProgrammeUserProgress::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 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();
        }
        
        static public 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);
                        }
                }
        }
        
        static protected 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);
                }
        }
        
        static protected 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() {
                $subtype = $this->getSubType();

                if($subtype) {
                        if(is_file($subtype->getIconPath(true))) {
                                $icon = $subtype->getIconPath(true);
                                $this->saveIcons($icon);
                        } else {
                                $this->removeCustomIcon();
                        }
                } else {
                        $this->removeCustomIcon();
                }
        }
        
        // HOOKS
        
        static public 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'");
        }

        // REWRITES FROM PARENT

        function saveIcons($a_custom_icon)
        {
                global $DIC;
                $ilDB = $DIC['ilDB'];

                $this->createContainerDirectory();
                $cont_dir = $this->getContainerDirectory();
                $file_name = "";
                if ($a_custom_icon != "")
                {
                        $file_name = $cont_dir."/icon_custom.svg";

                        ilUtil::moveUploadedFile($a_custom_icon, "icon_custom.svg", $file_name, true, "copy");

                        if ($file_name != "" && is_file($file_name))
                        {
                                ilContainer::_writeContainerSetting($this->getId(), "icon_custom", 1);
                        }
                        else
                        {
                                ilContainer::_writeContainerSetting($this->getId(), "icon_custom", 0);
                        }
                }
        }
}

?>