diff options
Diffstat (limited to 'lib/ilias_interface/ConnectedIlias.php')
| -rw-r--r-- | lib/ilias_interface/ConnectedIlias.php | 1370 |
1 files changed, 1370 insertions, 0 deletions
diff --git a/lib/ilias_interface/ConnectedIlias.php b/lib/ilias_interface/ConnectedIlias.php new file mode 100644 index 0000000..5b9c1bf --- /dev/null +++ b/lib/ilias_interface/ConnectedIlias.php @@ -0,0 +1,1370 @@ +<?php +# Lifter007: TODO +# Lifter003: TODO +# Lifter010: TODO + +/** +* main-class for connected systems +* +* This class contains the main methods of the ilias-interface to connect ILIAS installations. +* +* @author Arne Schröder <schroeder@data-quest.de> +* @access public +* @modulegroup ilias_interface_modules +* @module ConnectedIlias +* @package ILIAS-Interface +*/ +class ConnectedIlias +{ + const CRS_NOTIFICATION= '1'; + const CRS_NO_NOTIFICATION= '2'; + const CRS_ADMIN_ROLE= '1'; + const CRS_MEMBER_ROLE= '2'; + const CRS_TUTOR_ROLE= '3'; + const CRS_PASSED_VALUE= '0'; + + const OPERATION_VISIBLE= 'visible'; + const OPERATION_READ= 'read'; + const OPERATION_WRITE= 'write'; + const OPERATION_COPY= 'copy'; + const OPERATION_DELETE= 'delete'; + const OPERATION_EDIT_LEARNING_PROGRESS = 'edit_learning_progress'; + const OPERATION_VIEW_TEST_STATISTICS = 'tst_statistics'; + const OPERATION_READ_LEARNING_PROGRESS = 'read_learning_progress'; + const OPERATION_EDIT_SUBMISSION_GRADES = 'edit_submissions_grades'; + const OPERATION_VIEW_TEST_RESULTS = 'tst_results'; + + public $index; + public $ilias_config; + public $ilias_interface_config; + public $ilias_int_version; + public $global_roles; + public $crs_roles; + public $error; + + public $soap_client; + public $course_modules; + public $user; + public $user_modules; + + public $operations; + public $user_operations; + public $allowed_operations; + public $tree_allowed_operations; + + /** + * constructor + * + * ILIAS connection main class + * @access + * @param string $index ilias installation index + */ + public function __construct($index) + { + // load settings + $this->index = $index; + $this->error = []; + $this->global_roles = [4,5,14]; + $this->loadSettings(); + $this->crs_roles = [ + "autor" => "member", + "tutor" => "tutor", + "dozent" => "admin", + "admin" => "admin", + "root" => "admin" + ]; + $this->user_operations = [self::OPERATION_VISIBLE, self::OPERATION_READ]; + $this->operations = []; + $this->course_modules = []; + $this->user_modules = []; + + // set ILIAS version as integer value + $this->ilias_int_version = $this->getIntVersion($this->ilias_config['version']); + + // init soap client + $this->soap_client = new IliasSoap($this->index, $this->ilias_config['url'].'/webservice/soap/server.php?wsdl', $this->ilias_config['client'], $this->ilias_int_version, $this->ilias_config['admin'], $this->ilias_config['admin_pw']); + $this->soap_client->setCachingStatus($this->ilias_interface_config['cache']); + + // init current user (only if ILIAS installation is active) + if ($this->ilias_config['is_active']) { + $this->user = new IliasUser($this->index, $this->ilias_config['version']); + // create account automatically if it doesn't exist + if (! $this->user->isConnected()) { + $this->soap_client->setCachingStatus(false); + $this->soap_client->clearCache(); + $this->newUser(); + } else { + NotificationCenter::addObserver($this, "updateUser", "UserDidUpdate"); + } + // create user category if user has ILIAS author permission + if ($GLOBALS['perm']->have_perm($this->ilias_config['author_perm']) && ! $this->ilias_config['category_create_on_add_module'] && ! $this->user->getCategory()) { + $this->soap_client->setCachingStatus(false); + $this->soap_client->clearCache(); + $this->newUserCategory(); + } + } + } + + /** + * get ILIAS version as int + * + * converts ILIAS version to int value + * @access public + * @return string messages + */ + public static function getIntVersion($version) + { + $version_array = explode('.', $version); + return ((int)$version_array[0]*10000) + ((int)$version_array[1]*100) + ((int)$version_array[2]); + } + + /** + * load ILIAS settings from config table + */ + public function loadSettings() + { + $this->ilias_interface_config = Config::get()->ILIAS_INTERFACE_BASIC_SETTINGS; + + $ilias_configs = Config::get()->ILIAS_INTERFACE_SETTINGS; + $this->ilias_config = $ilias_configs[$this->index]; + } + + /** + * store settings + * + * stores current ILIAS settings to config table. + * @access public + */ + public function storeSettings() + { + $ilias_configs = Config::get()->ILIAS_INTERFACE_SETTINGS; + $ilias_configs[$this->index] = $this->ilias_config; + Config::get()->store('ILIAS_INTERFACE_SETTINGS', $ilias_configs); + } + + + /** + * get ILIAS info + * + * checks ILIAS base settings + * @access public + * @param string $url + * @return array info + */ + public static function getIliasInfo($url) + { + $info = []; + // check if url exists + $check = @get_headers($url . 'login.php'); + if (strpos($check[0], '200') === false) { + return $info; + } else { + $info['url'] = $url; + } + $soap_client = new IliasSoap('new', $url.'/webservice/soap/server.php?wsdl'); + $soap_client->setCachingStatus(false); + if ($client_info = $soap_client->getInstallationInfoXML()) { + $info = array_merge($info, $client_info); + } + return $info; + } + + /** + * get soap methods + * + * returns array of available soap methods + * @access public + * @return array soap method names + */ + public function getSoapMethods() + { + // fetch all available SOAP methods + $soap_methods = []; + if (is_callable([$this->soap_client->soap_client, '__getfunctions'])) { + $soap_methods_raw = $this->soap_client->soap_client->__getfunctions(); + foreach ($soap_methods_raw as $method) { + $method_array = explode(' ', $method); + preg_match_all('/\${1}[^, )]*/', $method, $param_array); + preg_match('/[^(]*/', $method_array[1], $method_name); + $soap_methods[$method_name[0]] = []; + foreach ($param_array[0] as $par) { + $soap_methods[$method_name[0]][] = substr($par, 1); + } + } + } else { + $proxy = $this->soap_client->soap_client->getProxyClassCode(); + preg_match_all('/function{1}[^{]*/', $proxy, $soap_methods_raw); + foreach ($soap_methods_raw[0] as $method) { + $method_array = explode(' ', $method); + preg_match_all('/\${1}[^, )]*/', $method, $param_array); + preg_match('/[^(]*/', $method_array[1], $method_name); + $soap_methods[$method_name[0]] = []; + foreach ($param_array[0] as $par) { + $soap_methods[$method_name[0]][] = substr($par, 1);; + } + } + } + return $soap_methods; + } + + /** + * get connection status + * + * checks connection settings + * @access public + * @return string messages + */ + public function getConnectionSettingsStatus() + { + // check ILIAS version + if (($this->ilias_int_version < 30000)) { + $this->error[] = _('Die ILIAS-Version ist ungültig.'); + return false; + } + + // check if url exists + $check = @get_headers($this->ilias_config['url'] . 'webservice/soap/server.php'); + if (strpos($check[0], '200') === false) { + $this->error[] = sprintf(_('Die URL "%s" ist nicht erreichbar.'), $this->ilias_config['url']); + return false; + } + + // check soap connection + $res = $this->soap_client->loginAdmin(); + if (!$res) { + $this->error[] = sprintf(_('Anmelden mit dem Account "%s" in der %s-Installation ist fehlgeschlagen.'), $this->ilias_config['admin'], $this->ilias_config['name']); + return false; + } + + return true; + } + + /** + * get content status + * + * checks content settings + * @access public + * @return string messages + */ + public function getContentSettingsStatus() + { + if (!$this->ilias_config['root_category']) { + // check category + if (!$this->ilias_config['root_category_name']) { + $this->error[] = _("Die ILIAS-Kategorie für Stud.IP-Inhalte wurde noch nicht festgelegt."); + return false; + } + $category = $this->soap_client->getReferenceByTitle($this->ilias_config['root_category_name'], 'cat'); + if (!$category) { + $this->error[] = sprintf(_("Die Kategorie \"%s\" wurde nicht gefunden."), $this->ilias_config['root_category_name']); + return false; + } + if ($category) { + $this->ilias_config['root_category'] = $category; + + // check user data category + if (! $this->ilias_config['user_data_category']) { + $object_data["title"] = sprintf(_("User-Daten")); + $object_data["description"] = _("Hier befinden sich die persönlichen Ordner der Stud.IP-User."); + $object_data["type"] = "cat"; + $object_data["owner"] = $this->soap_client->lookupUser($this->ilias_config['admin']); + $user_cat = $this->soap_client->addObject($object_data, $this->ilias_config['root_category']); + if ($user_cat != false) { + $this->ilias_config['user_data_category'] = $user_cat; + } else { + $this->error[] = sprintf(_("Die Kategorie \"%s\" konnte nicht angelegt werden."), $object_data["title"]); + return false; + } + } + $this->storeSettings(); + } + } + + return true; + } + + /** + * get permissions status + * + * checks permissions settings + * @access public + * @return string messages + */ + public function getPermissionsSettingsStatus() + { + // check role template + if (!$this->ilias_config['author_role_name']) { + $this->error[] = _("Das Rollen-Template für die persönliche Kategorie wurde noch nicht festgelegt."); + return false; + } + $role_template = $this->soap_client->getObjectByTitle( $this->ilias_config['author_role_name'], "rolt" ); + if ($role_template == false) { + $this->error[] = sprintf(_("Das Rollen-Template mit dem Namen \"%s\" wurde im System %s nicht gefunden."), htmlReady($this->ilias_config['author_role_name']), htmlReady($this->getName())); + return false; + } + if (is_array($role_template)) + { + $this->ilias_config['author_role'] = $role_template["obj_id"]; + $this->ilias_config['author_role_name'] = $role_template["title"]; + $this->storeSettings(); + } + return true; + } + + /** + * create new user-account + * + * creates new ILIAS user account + * @access public + * @return boolean returns false + */ + public function newUser() + { + if (!$this->user->studip_login) { + return false; + } + $user_data = $this->user->getUserArray(); + $user_data["login"] = $this->ilias_config['user_prefix'].$user_data["login"]; + + $user_exists = $this->soap_client->lookupUser($user_data["login"]); + //automatische Zuordnung von bestehenden Ilias Accounts + //nur wenn ldap Modus benutzt wird und Stud.IP Nutzer passendes ldap plugin hat + if ($user_exists && + ! $this->ilias_config['user_prefix'] && + $this->ilias_config['ldap_enable'] && + ($this->user->auth_plugin != 'standard') && + ($this->user->auth_plugin == $this->ilias_config['ldap_enable'])) { + $this->user->id = $user_exists; + $this->user->login = $user_data["login"]; + $this->user->setConnection($this->user->getUserType(), true); + PageLayout::postSuccess(sprintf(_("Verbindung mit Nutzer ID %s wiederhergestellt."), $this->user->id)); + return true; + } elseif ($user_exists) { + $this->error[] = sprintf(_('Externer Account konnte nicht angelegt werden. Es existiert bereits ein User mit dem Login %s in %s'), $user_data["login"], $this->ilias_config['name']); + return false; + } elseif ($this->ilias_config['no_account_updates']) { + $this->error[] = sprintf(_('Sie haben noch keinen ILIAS-Account. Loggen Sie sich zuerst in %s ein, um ILIAS-Lernobjekte in Stud.IP nutzen zu können.'), "<a href=\"".$this->ilias_config['url']."\">".$this->ilias_config['name']."</a>"); + return false; + } elseif (! $this->ilias_config['user_prefix'] && + $this->ilias_config['ldap_enable'] && + ($this->user->auth_plugin != 'standard') && + ($this->user->auth_plugin == $this->ilias_config['ldap_enable'])) { + $user_data['external_account'] = $this->user->studip_login; + $auth_plugin = StudipAuthAbstract::getInstance($this->user->auth_plugin); + if ($auth_plugin instanceof StudipAuthLdap) { + $user_data['auth_mode'] = 'ldap'; + } elseif ($auth_plugin instanceof StudipAuthCAS) { + $user_data['auth_mode'] = 'cas'; + } elseif ($auth_plugin instanceof StudipAuthShib) { + $user_data['auth_mode'] = 'shibboleth'; + } + } + + // set role according to Stud.IP perm + if (User::findCurrent()->perms === 'root') { + $role_id = 2; + } else { + $role_id = 4; + } + $this->soap_client->setCachingStatus(false); + $this->soap_client->clearCache(); + $user_id = $this->soap_client->addUser($user_data, $role_id); + if ($user_id != false) + { + $this->user->id = $user_id; + $this->user->login = $this->ilias_config['user_prefix'].$this->user->studip_login; + + $this->user->setConnection(IliasUser::USER_TYPE_CREATED); + return true; + } + return false; + } + + /** + * update given user account + * + * updates ILIAS user data + * @access public + * @param $user Stud.IP user object + * @return boolean returns false + */ + public function updateUser($user) + { + if (! is_object($user)) { + return false; + } + $update_user = new IliasUser($this->index, $this->ilias_config['version'], $user->id); + // don't update ldap user + if (! $this->ilias_config['user_prefix'] && + $this->ilias_config['ldap_enable'] && + ($update_user->auth_plugin != 'standard') && + ($update_user->auth_plugin == $this->ilias_config['ldap_enable'])) { + return true; + } elseif ($this->ilias_config['no_account_updates']) { + return true; + } + // if user is manually connected don't update user data + if ($update_user->getUserType() == IliasUser::USER_TYPE_ORIGINAL) { + return true; + } + $this->soap_client->setCachingStatus(false); + $this->soap_client->clearCache(); + if ($update_user->isConnected() && $update_user->id && $this->soap_client->lookupUser($update_user->login)) { + $user_data = $update_user->getUserArray(); + $user_data["login"] = $this->ilias_config['user_prefix'].$user_data["login"]; + + // set role according to Stud.IP perm + if ($user->perms == "root") { + $role_id = 2; + } else { + $role_id = 4; + } + + $user_id = $this->soap_client->addUser($user_data, $role_id); + if ($user_id != false) { + $update_user->login = $user_data["login"]; + $update_user->setConnection(IliasUser::USER_TYPE_CREATED); + return true; + } + } + return false; + } + + /** + * delete given user account + * + * deletes ILIAS user data + * @access public + * @param $user Stud.IP user object + * @return boolean returns false + */ + public function deleteUser($user) + { + if (! is_object($user)) { + return false; + } + $delete_user = new IliasUser($this->index, $this->ilias_config['version'], $user->id); + // if user is manually connected don't remove user + if ($delete_user->getUserType() == IliasUser::USER_TYPE_ORIGINAL) { + return true; + } + $this->soap_client->setCachingStatus(false); + $this->soap_client->clearCache(); + if ($delete_user->isConnected() && $delete_user->id && $this->soap_client->lookupUser($delete_user->login)) { + $deleted = $this->soap_client->deleteUser($delete_user->id); + if ($deleted) { + $query = "DELETE FROM auth_extern WHERE studip_user_id = ? AND external_user_system_type = ?"; + $statement = DBManager::get()->prepare($query); + $statement->execute([ + (string)$user->id, + (string)$this->index + ]); + return true; + } + } + return false; + } + + /** + * delete given course + * + * deletes ILIAS course data + * @access public + * @param $course Stud.IP course object + * @return boolean returns false + */ + public function deleteCourse($course) + { + if (! is_object($course)) { + return false; + } + + $crs_id = IliasObjectConnections::getConnectionModuleId($course->id, 'crs', $this->index); + if (! $crs_id) { + return false; + } + + $this->soap_client->setCachingStatus(false); + $this->soap_client->clearCache(); + $deleted = $this->soap_client->deleteObject($crs_id); + if ($deleted) { + IliasObjectConnections::DeleteAllConnections($course->id, $this->index); + return true; + } + return false; + } + + /** + * create new user category + * + * creates new ILIAS user account + * @access public + * @return boolean returns false + */ + public function newUserCategory() + { + if (!$this->user->isConnected()) { + return false; + } + $this->soap_client->setCachingStatus(false); + $this->soap_client->clearCache(); + + // data for user category in ILIAS + $object_data["title"] = sprintf(_("Eigene Daten von %s (%s)."), $this->user->getName(), $this->user->getId()); + $object_data["description"] = sprintf(_("Hier befinden sich die persönlichen Lernmodule des Benutzers %s."), $this->user->getName()); + $object_data["type"] = "cat"; + $object_data["owner"] = $this->user->getId(); + + // check if category already exists + $cat = $this->soap_client->getReferenceByTitle($object_data["title"]); + if (($cat != false) && $this->soap_client->checkReferenceById($cat) ) { + $this->user->category = $cat; + } else { + // add new user category at main user data category in ILIAS + $this->user->category = $this->soap_client->addObject($object_data, $this->ilias_config['user_data_category']); + } + if ($this->ilias_config['category_to_desktop'] && $this->user->category) { + $this->soap_client->addDesktopItems($this->user->getId(), [$this->user->category]); + } + + // store data + if ($this->user->category != false) { + $this->user->setConnection($this->user->getUserType()); + } else { + $this->error[] = _('ILIAS-User-Kategorie konnte nicht angelegt werden.'); + return false; + } + + // personal user role in ILIAS + $role_data["title"] = "studip_usr" . $this->user->getId() . "_cat" . $this->user->category; + $role_data["description"] = sprintf(_("User-Rolle von %s. Diese Rolle wurde von Stud.IP generiert."), $this->user->getName()); + $role_id = $this->soap_client->getObjectByTitle($role_data["title"], "role"); + if ($role_id == false) { + $role_id = $this->soap_client->addRoleFromTemplate($role_data, $this->user->getCategory(), $this->ilias_config['author_role']); + } + $this->soap_client->addUserRoleEntry($this->user->getId(), $role_id); + + // delete permissions for all global roles (User, Guest, Anonymous) for this category + foreach ($this->global_roles as $key => $role) { + $this->soap_client->revokePermissions($role, $this->user->category); + } + return true; + } + + /** + * get ILIAS user full name + * + * returns full name of given ILIAS user ID + * @access public + * @param $user_id ILIAS user id + * @return string full name + */ + public function getUserFullname($user_id) + { + return $this->soap_client->getUserFullname($user_id); + } + + /** + * get ILIAS path + * + * returns full path for given ILIAS ref ID + * @access public + * @param $ref_id ILIAS reference id + * @return string path + */ + public function getPath($ref_id) + { + return $this->soap_client->getPath($ref_id); + } + + /** + * get structure + * + * returns structure for given ILIAS lm ID + * @access public + * @param $ref_id ILIAS reference id + * @return string path + */ + public function getStructure($ref_id) + { + return $this->soap_client->getStructure($ref_id); + } + + /** + * get supported module types + * + * returns all active module types for current ILIAS installation + * @access public + */ + public static function getsupportedModuleTypes() + { + return [ +// 'cat' => _('Kategorie'), +// 'crs' => _('Kurs'), + 'webr' => _('Weblink'), + 'htlm' => _('HTML-Lernmodul'), + 'sahs' => _('SCORM/AICC-Lernmodul'), + 'lm' => _('ILIAS-Lernmodul'), + 'glo' => _('Glossar'), + 'tst' => _('Test'), + 'svy' => _('Umfrage'), + 'exc' => _('Übung') + ]; + } + + /** + * get active module types + * + * returns all active module types for current ILIAS installation + * @access public + */ + public function getAllowedModuleTypes() + { + return $this->ilias_config['modules']; + } + + /** + * check is module type is allowed + * + * returns true if module type is allowed for current ILIAS installation + * @access public + */ + public function isAllowedModuleType($module_type) + { + return (boolean)$this->ilias_config['modules'][$module_type]; + } + + /** + * get existing ilias indices + * + * loads existing indices of all ilias installations from database + * @access public + */ + public static function getExistingIndices() + { + $query = "SELECT DISTINCT external_user_system_type FROM auth_extern ORDER BY external_user_system_type ASC"; + return DBManager::get()->fetchGrouped($query); + } + + /** + * get user modules + * + * returns content modules from current users private category + * @access public + * @return array list of content modules + */ + public function getUserModules() + { + if (count($this->user_modules)) { + return $this->user_modules; + } + $types = []; + foreach ($this->getAllowedModuleTypes() as $type => $name) { + $types[] = $type; + } + if ($this->user->getCategory() == false) { + return []; + } + $result = $this->soap_client->getTreeChilds($this->user->getCategory(), $types, $this->user->getId()); + $obj_ids = []; + if (is_array($result)) { + foreach($result as $key => $object_data) { + $this->user_modules[$key] = new IliasModule($key, $object_data, $this->index, $this->ilias_int_version); + } + } + return $this->user_modules; + } + + + /** + * get module + * + * returns module instance by ID + * @access public + * @param string $module_id ILIAS ref id + * @return instance of IliasModule + */ + public function getModule($module_id) + { + $object_data = $this->soap_client->getObjectByReference($module_id, $this->user->getId()); + $module = new IliasModule($module_id, $object_data, $this->index, $this->ilias_int_version); + return $module; + } + + /** + * Helper function to fetch children including objects in folders + * The typo in the function name, 'childs', is intentional to reflect the name of the ILIAS-SOAP call. + * + * @access public + * @param string $parent_id + * @return array result + */ + public function getChilds($parent_id) { + $types[] = 'fold'; + if (isset($this->ilias_config['modules']) && $this->ilias_config['modules']) { + foreach ($this->ilias_config['modules'] as $type => $name) { + $types[] = $type; + } + $result = $this->soap_client->getTreeChilds($parent_id, $types); + $user_result = $this->soap_client->getTreeChilds($parent_id, $types, $this->user->getId()); + + if ($result) { + foreach($result as $ref_id => $data) { + if ($data['type'] == 'fold') { + unset($result[$ref_id]); + $result = $result + $this->getChilds($ref_id); + } else { + $result[$ref_id]['accessInfo'] = $user_result[$ref_id]['accessInfo']; + $result[$ref_id]['references'][$ref_id] = $user_result[$ref_id]['references'][$ref_id]; + } + } + } + } + + if (isset($result) && is_array($result)) { + return $result; + } else { + return []; + } + } + + /** + * check connected modules and update connections + * + * checks if there are modules in the course that are not connected to the seminar + * @access public + * @param string $course_id course-id + * @return boolean successful + */ + public function updateCourseConnections($course_id) + { + $this->soap_client->setCachingStatus(false); + // fetch childs + $result = $this->getChilds($course_id); + + if (is_array($result)) { + $check = DBManager::get()->prepare("SELECT 1 FROM object_contentmodules WHERE object_id = ? AND module_id = ? AND system_type = ? AND module_type = ?"); + $found = []; + $added = 0; + $deleted = 0; + foreach($result as $ref_id => $data) { + if (($data['accessInfo'] == 'granted') || ($this->ilias_interface_config['show_offline'] && $data['offline'])) { + $this->course_modules[$ref_id] = new IliasModule($ref_id, $data, $this->index, $this->ilias_int_version); + } + $check->execute([Context::getId(), $ref_id, $this->index, $data["type"]]); + if (!$check->fetch()) { + IliasObjectConnections::setConnection(Context::getId(), $ref_id, $data["type"], $this->index); + $added++; + } + $found[] = $ref_id . '_' . $data["type"]; + } + $to_delete = DBManager::get()->prepare("SELECT module_id,module_type FROM object_contentmodules WHERE module_type <> 'crs' AND object_id = ? AND system_type = ? AND CONCAT_WS('_', module_id,module_type) NOT IN (?)"); + $to_delete->execute([Context::getId(), $this->index, count($found) ? $found : ['']]); + while ($row = $to_delete->fetch(PDO::FETCH_ASSOC)) { + IliasObjectConnections::unsetConnection(Context::getId(), $row["module_id"], $row["module_type"], $this->index); + $deleted++; + } + return true; + } + return false; + } + + /** + * set module connection + * + * sets module connection to course + * @access public + * @param string $studip_course_id studip range id + * @param string $module_id ILIAS ref id + * @param string $module_type type of ILIAS module + * @param string $connection_mode copy or reference + * @param string $write_permission_level write permission for new module requires this perm (autor, tutor, dozent, never) + * @return boolean successful + */ + public function setCourseModuleConnection($studip_course_id, $module_id, $module_type, $connection_mode, $write_permission_level) + { + $object_data = $this->soap_client->getObjectByReference($module_id, $this->user->getId()); + $module = new IliasModule($module_id, $object_data, $this->index, $this->ilias_int_version); + if (!$module->isAllowed('start')) { + return false; + } + if (!$module->isAllowed('copy') && !$module->isAllowed('edit')) { + $this->error[] = _("Keine Berechtigung zum Kopieren des Lernobjekts!"); + return false; + } + + $crs_id = IliasObjectConnections::getConnectionModuleId($studip_course_id, "crs", $this->index); + $this->soap_client->setCachingStatus(false); + $this->soap_client->clearCache(); + + if (! $crs_id) { + // if no course entry create new course + $crs_id = $this->addCourse($studip_course_id); + } elseif ($crs_id AND ($this->soap_client->getObjectByReference($crs_id) == false)) { + // if course entry is invalid create new course + IliasObjectConnections::unsetConnection($studip_course_id, $crs_id, "crs", $this->index); + $this->error[] = sprintf(_('Der zugeordnete ILIAS-Kurs (ID %s) existiert nicht mehr. Ein neuer Kurs wurde angelegt.'), $crs_id); + $crs_id = $this->addCourse($studip_course_id); + } + + if ($crs_id == false) { + return false; + } + + if ($connection_mode == 'copy') { + $ref_id = $this->soap_client->copyObject($module_id, $crs_id); + } elseif ($connection_mode == 'reference') { + $ref_id = $this->soap_client->addReference($module_id, $crs_id); + } + if (! $ref_id) { + $this->error[] = _("Zuordnungs-Fehler: Lernobjekt konnte nicht angelegt werden."); + return false; + } + // set permissions for course roles + $local_roles = $this->soap_client->getLocalRoles($crs_id); + $member_operations = $this->getOperationArray([self::OPERATION_VISIBLE, self::OPERATION_READ]); + $admin_operations = $this->getOperationArray([self::OPERATION_VISIBLE, self::OPERATION_READ, self::OPERATION_WRITE, self::OPERATION_COPY, self::OPERATION_DELETE]); + $admin_operations_no_delete = $this->getOperationArray([self::OPERATION_VISIBLE, self::OPERATION_READ, self::OPERATION_WRITE, self::OPERATION_COPY]); + $admin_operations_readonly = $this->getOperationArray([self::OPERATION_VISIBLE, self::OPERATION_READ, self::OPERATION_DELETE]); + switch ($module_type) { + case 'tst': + $admin_operations = array_merge($admin_operations, $this->getOperationArray([self::OPERATION_EDIT_LEARNING_PROGRESS, self::OPERATION_VIEW_TEST_STATISTICS, self::OPERATION_READ_LEARNING_PROGRESS, self::OPERATION_VIEW_TEST_RESULTS])); + $admin_operations_no_delete = array_merge($admin_operations_no_delete, $this->getOperationArray([self::OPERATION_EDIT_LEARNING_PROGRESS, self::OPERATION_VIEW_TEST_STATISTICS, self::OPERATION_READ_LEARNING_PROGRESS, self::OPERATION_VIEW_TEST_RESULTS])); + $admin_operations_readonly = array_merge($admin_operations_readonly, $this->getOperationArray([self::OPERATION_VIEW_TEST_STATISTICS, self::OPERATION_READ_LEARNING_PROGRESS, self::OPERATION_VIEW_TEST_RESULTS])); + break; + case 'lm': + case 'sahs': + case 'htlm': + $admin_operations = array_merge($admin_operations, $this->getOperationArray([self::OPERATION_EDIT_LEARNING_PROGRESS, self::OPERATION_READ_LEARNING_PROGRESS])); + $admin_operations_no_delete = array_merge($admin_operations_no_delete, $this->getOperationArray([self::OPERATION_EDIT_LEARNING_PROGRESS, self::OPERATION_READ_LEARNING_PROGRESS])); + $admin_operations_readonly = array_merge($admin_operations_readonly, $this->getOperationArray([self::OPERATION_READ_LEARNING_PROGRESS])); + break; + case 'exc': + $admin_operations = array_merge($admin_operations, $this->getOperationArray([self::OPERATION_EDIT_LEARNING_PROGRESS, self::OPERATION_READ_LEARNING_PROGRESS, self::OPERATION_EDIT_SUBMISSION_GRADES])); + $admin_operations_no_delete = array_merge($admin_operations_no_delete, $this->getOperationArray([self::OPERATION_EDIT_LEARNING_PROGRESS, self::OPERATION_READ_LEARNING_PROGRESS, self::OPERATION_EDIT_SUBMISSION_GRADES])); + $admin_operations_readonly = array_merge($admin_operations_readonly, $this->getOperationArray([self::OPERATION_READ_LEARNING_PROGRESS])); + break; + } + foreach ($local_roles as $key => $role_data) { + // check only if local role is il_crs_member, -tutor or -admin + if (mb_strpos($role_data["title"], "il_crs_") === 0) { + if(mb_strpos($role_data["title"], 'il_crs_member') === 0){ + $operations = ($write_permission_level == "autor") ? $admin_operations_no_delete : $member_operations; + } elseif(mb_strpos($role_data["title"], 'il_crs_tutor') === 0){ + $operations = (($write_permission_level == "tutor") || ($write_permission_level == "autor")) ? $admin_operations : $admin_operations_readonly; + } elseif(mb_strpos($role_data["title"], 'il_crs_admin') === 0){ + $operations = (($write_permission_level == "dozent") || ($write_permission_level == "tutor") || ($write_permission_level == "autor")) ? $admin_operations : $admin_operations_readonly; + } else { + continue; + } + $this->soap_client->revokePermissions($role_data["obj_id"], $ref_id); + $this->soap_client->grantPermissions($operations, $role_data["obj_id"], $ref_id); + } + } + // store object connection + if ($ref_id) { + IliasObjectConnections::setConnection($studip_course_id, $ref_id, $module_type, $this->index); + return true; + } + return false; + } + + + /** + * unset module connection + * + * unsets ILIAS module connection with course + * @access public + * @param string $studip_course_id studip range id + * @param string $module_id ILIAS ref id + * @param string $module_type type of ILIAS module + */ + public function unsetCourseModuleConnection($studip_course_id, $module_id, $module_type) + { + $this->soap_client->setCachingStatus(false); + $this->soap_client->deleteObject($module_id); + IliasObjectConnections::unsetConnection($studip_course_id, $module_id, $module_type, $this->index); + } + + /** + * add course module + * + * adds module instance to list of course modules + * @access public + */ + public function addCourseModule($module_id, $module_data) + { + $object_data = $this->soap_client->getObjectByReference($module_id, $this->user->getId()); + $this->course_modules[$module_id] = new IliasModule($module_id, $object_data, $this->index, $this->ilias_int_version); + $this->course_modules[$module_id]->setConnectionType(true); + } + + /** + * get course modules + * + * returns all added course module instances + * @access public + */ + public function getCourseModules() + { + return $this->course_modules; + } + + /** + * create course + * + * creates new ilias course + * @access public + * @param string $studip_course_id seminar-id + * @return string|false|null + */ + public function addCourse($studip_course_id) + { + $crs_id = IliasObjectConnections::getConnectionModuleId($studip_course_id, "crs", $this->index); + $this->soap_client->setCachingStatus(false); + $this->soap_client->clearCache(); + + if (!$crs_id) { + $seminar = Seminar::getInstance($studip_course_id); + // on error use root category + $ref_id = $this->ilias_config['root_category']; + if ($this->ilias_config['cat_semester'] == 'outer') { + // category for semester above institute + $semester_ref_id = IliasObjectConnections::getConnectionModuleId($seminar->start_semester->getId(), 'cat', $this->index); + if (!$semester_ref_id) { + $object_data['title'] = $seminar->getStartSemesterName(); + $object_data['description'] = sprintf(_('Hier befinden sich die Veranstaltungsdaten zum Semester "%s".'), $seminar->getStartSemesterName()); + $object_data['type'] = 'cat'; + $object_data['owner'] = $this->soap_client->LookupUser($this->ilias_config['admin']); + $semester_ref_id = $this->soap_client->addObject($object_data, $ref_id); + if ($semester_ref_id) { + // store institute category + IliasObjectConnections::setConnection($seminar->start_semester->getId(), $semester_ref_id, 'cat', $this->index); + } else { + $this->error[] = sprintf(_('ILIAS-Kategorie %s konnte nicht angelegt werden.'), $object_data['title']); + } + } + if ($semester_ref_id) { + $ref_id = $semester_ref_id; + // category for home institute below semester + $home_institute = Institute::find($seminar->getInstitutId()); + if ($home_institute) { + $institute_ref_id = IliasObjectConnections::getConnectionModuleId(md5($seminar->start_semester->getId().$home_institute->getId()), "cat", $this->index); + } + if (!$institute_ref_id) { + $object_data['title'] = $home_institute->name; + $object_data['description'] = sprintf(_('Hier befinden sich die Veranstaltungsdaten zur Stud.IP-Einrichtung "%s".'), $home_institute->name); + $object_data['type'] = 'cat'; + $object_data['owner'] = $this->soap_client->LookupUser($this->ilias_config['admin']); + $institute_ref_id = $this->soap_client->addObject($object_data, $ref_id); + if ($institute_ref_id) { + // store institute category + IliasObjectConnections::setConnection(md5($seminar->start_semester->getId().$home_institute->getId()), $institute_ref_id, "cat", $this->index); + } + } + if ($institute_ref_id) { + $ref_id = $institute_ref_id; + } else { + $this->error[] = sprintf(_('ILIAS-Kategorie %s konnte nicht angelegt werden.'), $object_data['title']); + } + } + } elseif ($this->ilias_config['cat_semester'] === 'inner' || $this->ilias_config['cat_semester'] === 'none') { + // category for home institute + $home_institute = Institute::find($seminar->getInstitutId()); + if ($home_institute) { + $institute_ref_id = IliasObjectConnections::getConnectionModuleId($home_institute->getId(), "cat", $this->index); + } + if (!$institute_ref_id) { + $object_data['title'] = $home_institute->name; + $object_data['description'] = sprintf(_('Hier befinden sich die Veranstaltungsdaten zur Stud.IP-Einrichtung "%s".'), $home_institute->name); + $object_data['type'] = 'cat'; + $object_data['owner'] = $this->soap_client->LookupUser($this->ilias_config['admin']); + $institute_ref_id = $this->soap_client->addObject($object_data, $ref_id); + if ($institute_ref_id) { + // store institute category + IliasObjectConnections::setConnection($home_institute->getId(), $institute_ref_id, "cat", $this->index); + } else { + $this->error[] = sprintf(_('ILIAS-Kategorie %s konnte nicht angelegt werden.'), $object_data["title"]); + } + } + if ($institute_ref_id) { + $ref_id = $institute_ref_id; + if ($this->ilias_config['cat_semester'] === 'inner') { + // category for semester below institute + $institute_semester_ref_id = IliasObjectConnections::getConnectionModuleId(md5($home_institute->getId().$seminar->start_semester->getId()), 'cat', $this->index); + if (!$institute_semester_ref_id) { + $object_data['title'] = $seminar->getStartSemesterName(); + $object_data['description'] = sprintf(_('Hier befinden sich die Veranstaltungsdaten zum Semester "%s".'), $seminar->getStartSemesterName()); + $object_data['type'] = 'cat'; + $object_data['owner'] = $this->soap_client->LookupUser($this->ilias_config['admin']); + $institute_semester_ref_id= $this->soap_client->addObject($object_data, $ref_id); + if ($institute_semester_ref_id) { + // store institute category + IliasObjectConnections::setConnection(md5($home_institute->getId().$seminar->start_semester->getId()), $institute_semester_ref_id, 'cat', $this->index); + } + } + if ($institute_semester_ref_id) { + $ref_id = $institute_semester_ref_id; + } else { + $this->error[] = sprintf(_('ILIAS-Kategorie %s konnte nicht angelegt werden.'), $object_data["title"]); + } + } + } + } + + // create course + $lang_array = explode('_', Config::get()->DEFAULT_LANGUAGE); + $course_data['language'] = $lang_array[0]; + if ($this->ilias_config['course_semester'] === 'old' || $this->ilias_config['course_semester'] === 'old_bracket') { + $course_data['title'] = sprintf(_('Stud.IP-Veranstaltung "%s"'), $seminar->getName()); + } else { + $course_data['title'] = sprintf(_('%s'), $seminar->getName()); + } + if ($this->ilias_config['course_semester'] === 'old_bracket' || $this->ilias_config['course_semester'] === 'bracket') { + $course_data['title'] .= ' ('.$seminar->getStartSemesterName().')'; + } + if ($this->ilias_config['course_veranstaltungsnummer']) { + $course_data['title'] .= ' '.$seminar->VeranstaltungsNummer; + } + $course_data['description'] = sprintf(_('Dieser Kurs enthält die Lernobjekte der Stud.IP-Veranstaltung "%s".'), $seminar->getName()); + $crs_id = $this->soap_client->addCourse($course_data, $ref_id); + if (!$crs_id) { + $this->error[] = _('ILIAS-Kurs konnte nicht angelegt werden.'); + return false; + } + IliasObjectConnections::setConnection($studip_course_id, $crs_id, 'crs', $this->index); + + // Rollen zuordnen + $this->CheckUserCoursePermissions($crs_id); + return $crs_id; + } + + return null; + } + + /** + * check user + * + * checks if ILIAS user exists, creates new user if not + * @access public + * @return boolean returns user status + */ + public function checkUser() + { + if ($this->user->getId()) { + $user_exists = $this->soap_client->getUser($this->user->getId()); + if (!is_array($user_exists)) { + $admin_user_id = $this->soap_client->lookupUser($this->ilias_config['admin']); + $admin_user_exists = $this->soap_client->getUser($admin_user_id); + if (is_array($admin_user_exists)) { + $this->user->unsetConnection(true); + if ($this->newUser()) { + PageLayout::postSuccess(_("Neue Verknüpfung zu ILIAS-User angelegt.")); + } + } + } else return true; + } + return false; + } + + /** + * check user permissions + * + * checks user permissions for connected course and changes setting if necessary + * @access public + * @param string $ilias_course_id course-id + * @return boolean returns false on error + */ + public function checkUserCoursePermissions($ilias_course_id = "") + { + if (($ilias_course_id == "") || ($this->user->getId() == "")) { + return false; + } + + if ($GLOBALS['user']->perms == 'root') { + return true; + } + + // check if user still exists + $this->checkUser(); + + // get course role folder and local roles + $user_roles = $this->soap_client->getUserRoles($this->user->getId()); + $local_roles = $this->soap_client->getLocalRoles($ilias_course_id); + $active_role = ""; + $proper_role = ""; + $user_crs_role = $this->crs_roles[$GLOBALS["perm"]->get_studip_perm(Context::getId())]; + if (is_array($local_roles)) { + foreach ($local_roles as $key => $role_data) { + // check only if local role is il_crs_member, -tutor or -admin + if (! (mb_strpos($role_data["title"], "_crs_") === false)) { + if ( in_array( $role_data["obj_id"], $user_roles ) ) { + $active_role = $role_data["obj_id"]; + } + if ( mb_strpos( $role_data["title"], $user_crs_role) > 0 ) { + $proper_role = $role_data["obj_id"]; + } + } + } + } + + // is user already course-member? otherwise add member with proper role + $is_member = $this->soap_client->isMember( $this->user->getId(), $ilias_course_id); + if (!$is_member) { + $member_data["usr_id"] = $this->user->getId(); + $member_data["ref_id"] = $ilias_course_id; + $member_data["status"] = self::CRS_NO_NOTIFICATION; + $type = ""; + switch ($user_crs_role) + { + case "admin": + $member_data["role"] = self::CRS_ADMIN_ROLE; + $type = "Admin"; + break; + case "tutor": + $member_data["role"] = self::CRS_TUTOR_ROLE; + $type = "Tutor"; + break; + case "member": + $member_data["role"] = self::CRS_MEMBER_ROLE; + $type = "Member"; + break; + default: + } + $member_data["passed"] = self::CRS_PASSED_VALUE; + if ($type != "") { + $this->soap_client->addMember( $this->user->getId(), $type, $ilias_course_id); + } + } + + // check if user has proper local role + // if not, change it + if ($active_role != $proper_role) { + if ($active_role) { + $this->soap_client->deleteUserRoleEntry( $this->user->getId(), $active_role); + } + + if ($proper_role) { + $this->soap_client->addUserRoleEntry( $this->user->getId(), $proper_role); + } + } + + if (! $this->getUserModuleViewPermission($ilias_course_id)) { + return false; + } + + return true; + } + + /** + * get user permissions for ILIAS module + * + * returns allowed operations for current user and given module + * @access public + * @param string $module_id module-id + * @return boolean returns false on error + */ + public function getUserModuleViewPermission($module_id) + { + $this->allowed_operations = []; + $this->tree_allowed_operations = $this->soap_client->getObjectTreeOperations( + $module_id, + $this->user->getId() + ); + if (! is_array($this->tree_allowed_operations)) { + return false; + } + + $view_permission = false; + if ((in_array($this->operations[self::OPERATION_READ], $this->tree_allowed_operations)) && (in_array($this->operations[self::OPERATION_VISIBLE], $this->tree_allowed_operations))) { + $view_permission = true; + } + return $view_permission; + } + + /** + * get operation + * + * returns id for given operation-string + * @access public + * @param string $operation operation + * @return integer operation-id + */ + public function getOperation($operation) + { + // get operation IDs + if (!count($this->operations)) { + $this->operations = $this->soap_client->getOperations(); + } + + return $this->operations[$operation]; + } + + /** + * get operation-ids + * + * returns an array of operation-ids + * @access public + * @param string $operation operation + * @return array operation-ids + */ + public function getOperationArray($operation) + { + // get operation IDs + if (!count($this->operations)) { + $this->operations = $this->soap_client->getOperations(); + } + + $ops_array = []; + if (is_array($operation)) { + foreach ($operation as $key => $operation_name) { + if (array_key_exists($operation_name, $this->operations)) { + $ops_array[] = $this->operations[$operation_name]; + } + } + } + return $ops_array; + } + + /** + * get name of ILIAS installation + * + * returns name of cms + * @access public + * @return string name + */ + public function getName() + { + return $this->ilias_config['name']; + } + + /** + * get index of ILIAS installation + * + * returns index of ILIAS installation + * @access public + * @return string type + */ + public function getIndex() + { + return $this->index; + } + + /** + * get url of ILIAS installation + * + * returns url of ILIAS installation + * @access public + * @return string path + */ + public function getAbsolutePath() + { + return $this->ilias_config['url']; + } + + /** + * get target file of ILIAS installation + * + * returns target file of ILIAS installation + * @access public + * @return string target file + */ + public function getTargetFile() + { + return $this->ilias_config['url'].'studip_referrer.php'; + } + + /** + * get active-setting + * + * returns true, if ILIAS installation is active + * @access public + * @return boolean active-setting + */ + public function isActive() + { + return $this->ilias_config['is_active']; + } + + /** + * get client-id + * + * returns client-id + * @access public + * @return string client-id + */ + public function getClientId() + { + return $this->ilias_config['client']; + } + + /** + * get user prefix + * + * returns user prefix + * @access public + * @return string user prefix + */ + public function getUserPrefix() + { + return $this->ilias_config['user_prefix']; + } + + /** + * get errors + * + * returns array of error strings. + * @access public + * @return array of error strings + */ + public function getError() + { + return $this->error; + } + + /** + * search ILIAS modules + * + * performs search for ILIAS modules + * @access public + * @return boolean returns false + */ + public function searchModules($search_key) + { + $types = []; + foreach ($this->getAllowedModuleTypes() as $type => $name) { + $types[] = $type; + } + $search_modules = []; + + $result = $this->soap_client->searchObjects($types, $search_key, "and", $this->user->getId()); + if ($result) { + foreach($result as $key => $object_data) { + // set every single reference as part of the result + foreach ($object_data['references'] as $ref_id => $reference) { + $search_modules[$ref_id] = new IliasModule($ref_id, $object_data, $this->index, $this->ilias_int_version); + } + } + } + return $search_modules; + } + + public function deleteConnectedModules($object_id){ + return IliasObjectConnections::DeleteAllConnections($object_id, $this->index); + } + + /** + * @param string $ilias_user_id + * @return IliasUser|void + */ + public function getConnectedUser(string $ilias_user_id) + { + $user_id = DBManager::get()->fetchColumn( + "SELECT studip_user_id FROM auth_extern WHERE external_user_id = ? AND external_user_system_type = ?", + [$ilias_user_id, $this->index] + ); + if ($user_id) { + return new IliasUser($this->index, $this->ilias_config['version'], $user_id); + } + } +} |