inc.soap_functions.php

Go to the documentation of this file.

<?php
 
use ILIAS\OrgUnit\Webservices\SOAP\AddUserIdToPositionInOrgUnit;
use ILIAS\OrgUnit\Webservices\SOAP\EmployeePositionId;
use ILIAS\OrgUnit\Webservices\SOAP\ImportOrgUnitTree;
use ILIAS\OrgUnit\Webservices\SOAP\OrgUnitTree;
use ILIAS\OrgUnit\Webservices\SOAP\PositionIds;
use ILIAS\OrgUnit\Webservices\SOAP\PositionTitle;
use ILIAS\OrgUnit\Webservices\SOAP\RemoveUserIdFromPositionInOrgUnit;
use ILIAS\OrgUnit\Webservices\SOAP\SuperiorPositionId;
use ILIAS\OrgUnit\Webservices\SOAP\UserIdsOfPosition;
use ILIAS\OrgUnit\Webservices\SOAP\UserIdsOfPositionAndOrgUnit;
 
class ilSoapFunctions
{
    // These functions are wrappers for soap, since it cannot register methods inside classes
 
    public static function login(string $client, string $username, string $password)
    {
        $sua = new ilSoapUserAdministration();
        return $sua->login($client, $username, $password);
    }
 
    public static function logout(string $sid)
    {
        $sua = new ilSoapUserAdministration();
        return $sua->logout($sid);
    }
 
    public static function lookupUser(string $sid, string $user_name)
    {
        $sua = new ilSoapUserAdministration();
        return $sua->lookupUser($sid, $user_name);
    }
 
    public static function addCourse(string $sid, int $target_id, string $crs_xml)
    {
        $sca = new ilSoapCourseAdministration();
        return $sca->addCourse($sid, $target_id, $crs_xml);
    }
 
    public static function deleteCourse(string $sid, int $course_id)
    {
        $sca = new ilSoapCourseAdministration();
        return $sca->deleteCourse($sid, $course_id);
    }
 
    public static function assignCourseMember(
        string $sid,
        int $course_id,
        int $user_id,
        string $type,
        ?bool $notification =  null,
        ?bool $contact_person = null,
        ?bool $blocked = null
    )
    {
        $sca = new ilSoapCourseAdministration();
        return $sca->assignCourseMember($sid, $course_id, $user_id, $type, $notification, $contact_person, $blocked);
    }
 
    public static function isAssignedToCourse(string $sid, int $course_id, int $user_id)
    {
        $sca = new ilSoapCourseAdministration();
        return $sca->isAssignedToCourse($sid, $course_id, $user_id);
    }
 
    public static function excludeCourseMember(string $sid, int $course_id, int $user_id)
    {
        $sca = new ilSoapCourseAdministration();
        return $sca->excludeCourseMember($sid, $course_id, $user_id);
    }
 
    public static function getCourseXML(string $sid, int $course_id)
    {
        $sca = new ilSoapCourseAdministration();
        return $sca->getCourseXML($sid, $course_id);
    }
 
    public static function updateCourse(string $sid, int $course_id, string $xml)
    {
        $sca = new ilSoapCourseAdministration();
        return $sca->updateCourse($sid, $course_id, $xml);
    }
 
    public static function getObjIdByImportId(string $sid, string $import_id)
    {
        $soa = new ilSoapObjectAdministration();
        return $soa->getObjIdByImportId($sid, $import_id);
    }
 
    public static function getRefIdsByImportId(string $sid, string $import_id)
    {
        $soa = new ilSoapObjectAdministration();
        return $soa->getRefIdsByImportId($sid, $import_id);
    }
 
    public static function getRefIdsByObjId(string $sid, int $object_id)
    {
        $soa = new ilSoapObjectAdministration();
        return $soa->getRefIdsByObjId($sid, $object_id);
    }
 
    public static function getObjectByReference(string $sid, int $a_ref_id, ?int $user_id = null)
    {
        $soa = new ilSoapObjectAdministration();
        return $soa->getObjectByReference($sid, $a_ref_id, $user_id);
    }
 
    public static function getObjectsByTitle(string $sid, string $a_title, ?int $user_id = null)
    {
        $soa = new ilSoapObjectAdministration();
        return $soa->getObjectsByTitle($sid, $a_title, $user_id);
    }
 
    public static function addObject(string $sid, int $a_target_id, string $a_xml)
    {
        $soa = new ilSoapObjectAdministration();
        return $soa->addObject($sid, $a_target_id, $a_xml);
    }
 
    public static function addReference(string $sid, int $a_source_id, int $a_target_id)
    {
        $soa = new ilSoapObjectAdministration();
        return $soa->addReference($sid, $a_source_id, $a_target_id);
    }
 
    public static function deleteObject(string $sid, int $reference_id)
    {
        $soa = new ilSoapObjectAdministration();
        return $soa->deleteObject($sid, $reference_id);
    }
 
    public static function removeFromSystemByImportId(string $sid, string $import_id)
    {
        $soa = new ilSoapObjectAdministration();
        return $soa->removeFromSystemByImportId($sid, $import_id);
    }
 
    public static function updateObjects(string $sid, string $obj_xml)
    {
        $soa = new ilSoapObjectAdministration();
        return $soa->updateObjects($sid, $obj_xml);
    }
 
    public static function searchObjects(string $sid, array $types, string $key, string $combination, ?int $user_id = null)
    {
        $soa = new ilSoapObjectAdministration();
        return $soa->searchObjects($sid, $types, $key, $combination, $user_id);
    }
 
    public static function getTreeChilds(string $sid, int $ref_id, ?array $types = null, ?int $user_id = null)
    {
        $soa = new ilSoapObjectAdministration();
        return $soa->getTreeChilds($sid, $ref_id, $types, $user_id);
    }
 
    public static function getXMLTree(string $sid, int $ref_id, ?array $types = null, ?int $user_id = null)
    {
        $soa = new ilSoapObjectAdministration();
        return $soa->getXMLTree($sid, $ref_id, $types, $user_id);
    }
 
    public static function getOperations(string $sid)
    {
        $soa = new ilSoapRBACAdministration();
        return $soa->getOperations($sid);
    }
 
    public static function addUserRoleEntry(string $sid, int $user_id, int $role_id)
    {
        $soa = new ilSoapRBACAdministration();
        return $soa->addUserRoleEntry($sid, $user_id, $role_id);
    }
 
    public static function deleteUserRoleEntry(string $sid, int $user_id, int $role_id)
    {
        $soa = new ilSoapRBACAdministration();
        return $soa->deleteUserRoleEntry($sid, $user_id, $role_id);
    }
 
    public static function revokePermissions(string $sid, int $ref_id, int $role_id)
    {
        $soa = new ilSoapRBACAdministration();
        return $soa->revokePermissions($sid, $ref_id, $role_id);
    }
 
    public static function grantPermissions(string $sid, int $ref_id, int $role_id, array $permissions)
    {
        $soa = new ilSoapRBACAdministration();
        return $soa->grantPermissions($sid, $ref_id, $role_id, $permissions);
    }
 
    public static function getLocalRoles(string $sid, int $ref_id)
    {
        $soa = new ilSoapRBACAdministration();
        return $soa->getLocalRoles($sid, $ref_id);
    }
 
    public static function getUserRoles(string $sid, int $user_id)
    {
        $soa = new ilSoapRBACAdministration();
        return $soa->getUserRoles($sid, $user_id);
    }
 
    public static function deleteRole(string $sid, int $role_id)
    {
        $soa = new ilSoapRBACAdministration();
        return $soa->deleteRole($sid, $role_id);
    }
 
    public static function addRole(string $sid, int $target_id, string $obj_xml)
    {
        $soa = new ilSoapRBACAdministration();
        return $soa->addRole($sid, $target_id, $obj_xml);
    }
 
    public static function addRoleFromTemplate(string $sid, int $target_id, string $obj_xml, int $template_id)
    {
        $soa = new ilSoapRBACAdministration();
        return $soa->addRoleFromTemplate($sid, $target_id, $obj_xml, $template_id);
    }
 
    public static function getObjectTreeOperations(string $sid, int $ref_id, int $user_id)
    {
        $soa = new ilSoapRBACAdministration();
        return $soa->getObjectTreeOperations($sid, $ref_id, $user_id);
    }
 
    public static function addGroup(string $sid, int $target_id, string $group_xml)
    {
        $soa = new ilSoapGroupAdministration();
        return $soa->addGroup($sid, $target_id, $group_xml);
    }
 
    public static function groupExists(string $sid, string $title)
    {
        $soa = new ilSoapGroupAdministration();
        return $soa->groupExists($sid, $title);
    }
 
    public static function getGroup(string $sid, int $ref_id)
    {
        $soa = new ilSoapGroupAdministration();
        return $soa->getGroup($sid, $ref_id);
    }
 
    public static function assignGroupMember(string $sid, int $group_id, int $user_id, string $type)
    {
        $sca = new ilSoapGroupAdministration();
        return $sca->assignGroupMember($sid, $group_id, $user_id, $type);
    }
 
    public static function isAssignedToGroup(string $sid, int $group_id, int $user_id)
    {
        $sca = new ilSoapGroupAdministration();
        return $sca->isAssignedToGroup($sid, $group_id, $user_id);
    }
 
    public static function excludeGroupMember(string $sid, int $group_id, int $user_id)
    {
        $sca = new ilSoapGroupAdministration();
        return $sca->excludeGroupMember($sid, $group_id, $user_id);
    }
 
    public static function ilClone(string $sid, int $copy_identifier)
    {
        $sou = new ilSoapUtils();
        $sou->disableSOAPCheck();
        $sou->ignoreUserAbort();
        return $sou->ilClone($sid, $copy_identifier);
    }
 
    public static function ilCloneDependencies(string $sid, int $copy_identifier)
    {
        $sou = new ilSoapUtils();
        $sou->disableSOAPCheck();
        $sou->ignoreUserAbort();
        return $sou->ilCloneDependencies($sid, $copy_identifier);
    }
 
    public static function saveQuestion(string $sid, int $active_id, int $question_id, int $pass, array $solution)
    {
        $sass = new ilSoapTestAdministration();
        return $sass->saveQuestion($sid, $active_id, $question_id, $pass, $solution);
    }
 
    public static function saveQuestionSolution(string $sid, int $active_id, int $question_id, int $pass, int $solution)
    {
        $sass = new ilSoapTestAdministration();
        return $sass->saveQuestionSolution($sid, $active_id, $question_id, $pass, $solution);
    }
 
    public static function getQuestionSolution(string $sid, int $active_id, int $question_id, int $pass)
    {
        $sass = new ilSoapTestAdministration();
        return $sass->getQuestionSolution($sid, $active_id, $question_id, $pass);
    }
 
    public static function getTestUserData(string $sid, int $active_id)
    {
        $sass = new ilSoapTestAdministration();
        return $sass->getTestUserData($sid, $active_id);
    }
 
    public static function getNrOfQuestionsInPass(string $sid, int $active_id, int $pass)
    {
        $sass = new ilSoapTestAdministration();
        return $sass->getNrOfQuestionsInPass($sid, $active_id, $pass);
    }
 
    public static function getPositionOfQuestion(string $sid, int $active_id, int $question_id, int $pass)
    {
        $sass = new ilSoapTestAdministration();
        return $sass->getPositionOfQuestion($sid, $active_id, $question_id, $pass);
    }
 
    public static function getPreviousReachedPoints(string $sid, int $active_id, int $question_id, int $pass)
    {
        $sass = new ilSoapTestAdministration();
        return $sass->getPreviousReachedPoints($sid, $active_id, $question_id, $pass);
    }
 
    public static function saveTempFileAsMediaObject(string $sid, string $name, string $tmp_name)
    {
        $sou = new ilSoapUtils();
        $sou->disableSOAPCheck();
        return $sou->saveTempFileAsMediaObject($sid, $name, $tmp_name);
    }
 
    public static function getMobsOfObject(string $sid, string $a_type, int $a_id)
    {
        $sou = new ilSoapUtils();
        $sou->disableSOAPCheck();
        return $sou->getMobsOfObject($sid, $a_type, $a_id);
    }
 
    public static function getStructureObjects(string $sid, int $ref_id)
    {
        $sca = new ilSOAPStructureObjectAdministration();
        return $sca->getStructureObjects($sid, $ref_id);
    }
 
    public static function getRoles(string $sid, string $role_type, int $id)
    {
        $soa = new ilSoapRBACAdministration();
        return $soa->getRoles($sid, $role_type, $id);
    }
 
    public static function importUsers(string $sid, int $folder_id, string $usr_xml, int $conflict_rule, bool $send_account_mail)
    {
        $sua = new ilSoapUserAdministration();
        return $sua->importUsers($sid, $folder_id, $usr_xml, $conflict_rule, $send_account_mail);
    }
 
    public static function getUsersForContainer(string $sid, int $ref_id, bool $attach_roles, int $active)
    {
        $sua = new ilSoapUserAdministration();
        return $sua->getUsersForContainer($sid, $ref_id, $attach_roles, $active);
    }
 
    public static function getUsersForRole(string $sid, int $role_id, bool $attach_roles, int $active)
    {
        $sua = new ilSoapUserAdministration();
        return $sua->getUserForRole($sid, $role_id, $attach_roles, $active);
    }
 
    public static function searchUser(string $sid, array $a_keyfields, string $query_operator, array $a_keyvalues, bool $attach_roles, int $active)
    {
        $sua = new ilSoapUserAdministration();
        return $sua->searchUser($sid, $a_keyfields, $query_operator, $a_keyvalues, $attach_roles, $active);
    }
 
    public static function hasNewMail(string $sid)
    {
        $sua = new ilSoapUserAdministration();
        return $sua->hasNewMail($sid);
    }
 
    public static function getExerciseXML(string $sid, int $ref_id, int $attachFileContentsMode)
    {
        $sta = new ilSoapExerciseAdministration();
        return $sta->getExerciseXML($sid, $ref_id, $attachFileContentsMode);
    }
 
    public static function updateExercise(string $sid, int $ref_id, string $xml)
    {
        $sta = new ilSoapExerciseAdministration();
        return $sta->updateExercise($sid, $ref_id, $xml);
    }
 
    public static function addExercise(string $sid, int $ref_id, string $xml)
    {
        $sta = new ilSoapExerciseAdministration();
        return $sta->addExercise($sid, $ref_id, $xml);
    }
 
    public static function getFileXML(string $sid, int $ref_id, int $attachFileContentsMode)
    {
        $sta = new ilSoapFileAdministration();
        return $sta->getFileXML($sid, $ref_id, $attachFileContentsMode);
    }
 
    public static function updateFile(string $sid, int $ref_id, string $xml)
    {
        $sta = new ilSoapFileAdministration();
        return $sta->updateFile($sid, $ref_id, $xml);
    }
 
    public static function addFile(string $sid, int $ref_id, string $xml)
    {
        $sta = new ilSoapFileAdministration();
        return $sta->addFile($sid, $ref_id, $xml);
    }
 
    public static function getObjIdsByRefIds(string $sid, array $ref_ids)
    {
        $soa = new ilSoapObjectAdministration();
        return $soa->getObjIdsByRefIds($sid, $ref_ids);
    }
 
    public static function getUserXML(string $sid, array $user_ids, bool $attach_roles)
    {
        $sua = new ilSoapUserAdministration();
        return $sua->getUserXML($sid, $user_ids, $attach_roles);
    }
 
    public static function updateGroup(string $sid, int $ref_id, string $grp_xml)
    {
        $sua = new ilSoapGroupAdministration();
        return $sua->updateGroup($sid, $ref_id, $grp_xml);
    }
 
    public static function getIMSManifestXML(string $sid, int $ref_id)
    {
        $sua = new ilSoapSCORMAdministration();
        return $sua->getIMSManifestXML($sid, $ref_id);
    }
 
    public static function hasSCORMCertificate(string $sid, int $ref_id, int $usr_id)
    {
        $sua = new ilSoapSCORMAdministration();
        return $sua->hasSCORMCertificate($sid, $ref_id, $usr_id);
    }
 
    public static function copyObject(string $sid, string $copy_settings_xml)
    {
        $soa = new ilSoapObjectAdministration();
        return $soa->copyObject($sid, $copy_settings_xml);
    }
 
    public static function startBackgroundTaskWorker(string $sid)
    {
        $soa = new ilSoapBackgroundTasksAdministration();
        return $soa->runAsync($sid);
    }
 
    public static function moveObject(string $sid, int $ref_id, int $target_id)
    {
        $soa = new ilSoapObjectAdministration();
        return $soa->moveObject($sid, $ref_id, $target_id);
    }
 
    public static function getTestResults(string $sid, int $ref_id, bool $sum_only)
    {
        $soa = new ilSoapTestAdministration();
        return $soa->getTestResults($sid, $ref_id, $sum_only);
    }
 
    public static function removeTestResults(string $sid, int $ref_id, array $a_user_ids)
    {
        $soa = new ilSoapTestAdministration();
        return $soa->removeTestResults($sid, $ref_id, $a_user_ids);
    }
 
    public static function getCoursesForUser(string $sid, string $parameters)
    {
        $soc = new ilSoapCourseAdministration();
        return $soc->getCoursesForUser($sid, $parameters);
    }
 
    public static function getGroupsForUser(string $sid, string $parameters)
    {
        $soc = new ilSoapGroupAdministration();
        return $soc->getGroupsForUser($sid, $parameters);
    }
 
    public static function getPathForRefId(string $sid, int $ref_id)
    {
        $soa = new ilSoapObjectAdministration();
        return $soa->getPathForRefId($sid, $ref_id);
    }
 
    public static function searchRoles(string $sid, string $key, string $combination, string $role_type)
    {
        $roa = new ilSoapRBACAdministration();
        return $roa->searchRoles($sid, $key, $combination, $role_type);
    }
 
    public static function getInstallationInfoXML(): string
    {
        $roa = new ilSoapAdministration();
        return $roa->getInstallationInfoXML();
    }
 
    public static function getClientInfoXML(string $clientid)
    {
        $roa = new ilSoapAdministration();
        return $roa->getClientInfoXML($clientid);
    }
 
    public static function buildHTTPPath(bool $use_module_depending_path = true): string
    {
        if (($_SERVER['HTTPS'] ?? '') === 'on') {
            $protocol = 'https://';
        } else {
            $protocol = 'http://';
        }
 
        $host = $_SERVER['HTTP_HOST'] ?? '';
        $path = dirname($_SERVER['REQUEST_URI'] ?? '');
 
        // dirname cuts the last directory from a directory path e.g content/classes return content
        if ($use_module_depending_path && defined('ILIAS_MODULE')) {
            $module = ilFileUtils::removeTrailingPathSeparators(ILIAS_MODULE);
            $dirs = array_filter(explode('/', $module));
            foreach ($dirs as $dir) {
                $path = dirname($path);
            }
        }
 
        return ilFileUtils::removeTrailingPathSeparators($protocol . $host . $path);
    }
 
    public static function getSCORMCompletionStatus(string $sid, int $usr_id, int $a_ref_id)
    {
        $sua = new ilSoapSCORMAdministration();
        return $sua->getSCORMCompletionStatus($sid, $usr_id, $a_ref_id);
    }
 
    public static function getUserIdBySid(string $sid)
    {
        $sua = new ilSoapUserAdministration();
        return $sua->getUserIdBySid($sid);
    }
 
    public static function readWebLink(string $sid, int $ref_id)
    {
        $swa = new ilSoapWebLinkAdministration();
        return $swa->readWebLink($sid, $ref_id);
    }
 
    public static function createWebLink(string $sid, int $ref_id, string $xml)
    {
        $swa = new ilSoapWebLinkAdministration();
        return $swa->createWebLink($sid, $ref_id, $xml);
    }
 
    public static function updateWebLink(string $sid, int $ref_id, string $xml)
    {
        $swa = new ilSoapWebLinkAdministration();
        return $swa->updateWebLink($sid, $ref_id, $xml);
    }
 
    public static function deleteExpiredDualOptInUserObjects(string $sid, int $usr_id): bool
    {
        $sou = new ilSoapUtils();
        $sou->disableSOAPCheck();
        $sou->ignoreUserAbort();
        return $sou->deleteExpiredDualOptInUserObjects($sid, $usr_id);
    }
 
    public static function deleteProgress(string $sid, array $ref_ids, array $usr_ids, array $type_filter, array $progress_filter)
    {
        $sla = new ilSoapLearningProgressAdministration();
        return $sla->deleteProgress($sid, $ref_ids, $usr_ids, $type_filter, $progress_filter);
    }
 
    public static function getLearningProgressChanges(string $sid, string $timestamp, bool $include_ref_ids, array $type_filter)
    {
        $s = new ilSoapLearningProgressAdministration();
        return $s->getLearningProgressChanges($sid, $timestamp, $include_ref_ids, $type_filter);
    }
 
    public static function getProgressInfo(string $sid, int $ref_id, array $progress_filter)
    {
        $sla = new ilSoapLearningProgressAdministration();
        return $sla->getProgressInfo($sid, $ref_id, $progress_filter);
    }
 
    public static function exportDataCollectionContent(string $sid, int $data_collection_id, ?int $table_id = null, string $format = "xls", ?string $filepath = null)
    {
        $dcl = new ilSoapDataCollectionAdministration();
        return $dcl->exportDataCollectionContent($sid, $data_collection_id, $table_id, $format, $filepath);
    }
 
    public static function addUserToPositionInOrgUnit(...$params)
    {
        $h = new AddUserIdToPositionInOrgUnit();
        return $h->execute($params);
    }
 
    public static function getEmployeePositionId(...$params)
    {
        $h = new EmployeePositionId();
        return $h->execute($params);
    }
 
    public static function importOrgUnitsSimpleXML(...$params)
    {
        $h = new ImportOrgUnitTree();
        return $h->execute($params);
    }
 
    public static function getOrgUnitsSimpleXML(...$params)
    {
        $h = new OrgUnitTree();
        return $h->execute($params);
    }
 
    public static function getPositionIds(...$params)
    {
        $h = new PositionIds();
        return $h->execute($params);
    }
 
    public static function getPositionTitle(...$params)
    {
        $h = new PositionTitle();
        return $h->execute($params);
    }
 
    public static function removeUserFromPositionInOrgUnit(...$params)
    {
        $h = new RemoveUserIdFromPositionInOrgUnit();
        return $h->execute($params);
    }
 
    public static function getSuperiorPositionId(...$params)
    {
        $h = new SuperiorPositionId();
        return $h->execute($params);
    }
 
    public static function getUserIdsOfPosition(...$params)
    {
        $h = new UserIdsOfPosition();
        return $h->execute($params);
    }
 
    public function getUserIdsOfPositionAndOrgUnit(...$params)
    {
        $h = new UserIdsOfPositionAndOrgUnit();
        return $h->execute($params);
    }
 
    public function __call($name, $arguments)
    {
        // SoapHookPlugins need the client-ID submitted
        // no initialized ILIAS => no request wrapper available.
        if (!isset($_GET['client_id'])) {
            throw new SoapFault('SOAP-ENV:Server', "Function '$name' does not exist");
        }
        // Note: We need to bootstrap ILIAS in order to get $ilPluginAdmin and load the soap plugins.
        // We MUST use a context that does not handle authentication at this point (session is checked by SOAP).
        ilContext::init(ilContext::CONTEXT_SOAP_NO_AUTH);
        ilInitialisation::initILIAS();
        ilContext::init(ilContext::CONTEXT_SOAP);
        global $DIC;
        $soapHook = new ilSoapHook($DIC['component.factory']);
        // Method name may be invoked with namespace e.g. 'myMethod' vs 'ns:myMethod'
        if (strpos($name, ':') !== false) {
            [$_, $name] = explode(':', $name);
        }
        $method = $soapHook->getMethodByName($name);
        if ($method) {
            try {
                return $method->execute($arguments);
            } catch (ilSoapPluginException $e) {
                throw new SoapFault('SOAP-ENV:Server', $e->getMessage());
            }
        }
        throw new SoapFault('SOAP-ENV:Server', "Function '$name' does not exist");
    }
}