class.ilECSCourseCreationHandler.php

Go to the documentation of this file.

<?php

include_once './Services/WebServices/ECS/classes/Mapping/class.ilECSNodeMappingSettings.php';
include_once './Services/WebServices/ECS/classes/Tree/class.ilECSCmsData.php';
include_once './Services/WebServices/ECS/classes/class.ilECSParticipantSettings.php';

/* Copyright (c) 1998-2009 ILIAS open source, Extended GPL, see docs/LICENSE */

class ilECSCourseCreationHandler
{
    protected $log;


    private $server = null;
    private $mapping = null;
    private $course_url = null;
    private $object_created = false;
    private $courses_created = array();
    
    private $mid;
    

    public function __construct(ilECSSetting $server, $a_mid)
    {
        $this->log = $GLOBALS['DIC']->logger()->wsrv();
        
        $this->server = $server;
        $this->mid = $a_mid;
        $this->mapping = ilECSNodeMappingSettings::getInstanceByServerMid($this->getServer()->getServerId(), $this->getMid());
        
        include_once './Services/WebServices/ECS/classes/Course/class.ilECSCourseUrl.php';
        $this->course_url = new ilECSCourseUrl();
    }
    
    
    public function getServer()
    {
        return $this->server;
    }
    
    public function getMapping()
    {
        return $this->mapping;
    }
    
    public function getCourseUrl()
    {
        return $this->course_url;
    }
    
    public function isObjectCreated()
    {
        return $this->object_created;
    }
    
    public function setObjectCreated($a_status)
    {
        $this->object_created = $a_status;
    }
    
    protected function getCreatedCourses()
    {
        return $this->courses_created;
    }
    
    public function getMid()
    {
        return $this->mid;
    }
    
    public function handle($a_content_id, $course)
    {
        // prepare course url
        // if any object (course group) will be created, a list of all course urls
        // will be sent to ecs.
        $this->setObjectCreated(false);
        $this->getCourseUrl()->setECSId($a_content_id);
        
        
        if ($this->getMapping()->isAttributeMappingEnabled()) {
            $this->log->debug('Handling advanced attribute mapping');
            return $this->doAttributeMapping($a_content_id, $course);
        }
        
        if ($this->getMapping()->isAllInOneCategoryEnabled()) {
            $this->log->debug('Handling course all in one category setting');
            $this->doSync($a_content_id, $course, ilObject::_lookupObjId($this->getMapping()->getAllInOneCategory()));
            return true;
        }

        $parent_obj_id = $this->syncParentContainer($a_content_id, $course);
        if ($parent_obj_id) {
            $this->log->info('Using already mapped category: ' . ilObject::_lookupTitle($parent_obj_id));
            $this->doSync($a_content_id, $course, $parent_obj_id);
            return true;
        }
        $this->log->info('Using course default category');
        $this->doSync($a_content_id, $course, ilObject::_lookupObjId($this->getMapping()->getDefaultCourseCategory()));
        return true;
    }
    
    protected function doAttributeMapping($a_content_id, $course)
    {
        // Check if course is already created
        $course_id = $course->lectureID;
        $obj_id = $this->getImportId($course_id);
        
        if ($obj_id) {
            // do update
            $this->log->debug('Performing update of already imported course.');
            
            $refs = ilObject::_getAllReferences($obj_id);
            $ref = end($refs);
            
            $this->doSync(
                $a_content_id,
                $course,
                ilObject::_lookupObjId($GLOBALS['tree']->getParentId($ref))
            );
            return true;
        }
        
        // Get all rules
        $matching_rules =  [];
        include_once './Services/WebServices/ECS/classes/Course/class.ilECSCourseMappingRule.php';
        foreach (ilECSCourseMappingRule::getRuleRefIds($this->getServer()->getServerId(), $this->getMid()) as $ref_id) {
            $matching_index = ilECSCourseMappingRule::isMatching(
                $course,
                $this->getServer()->getServerId(),
                $this->getMid(),
                $ref_id
            );
            if (strcmp($matching_index, '0') !== 0) {
                $matching_rules[$matching_index] = $ref_id;
            }
        }
        ksort($matching_rules);
        
        $this->log->dump($matching_rules);
        
        if (!count($matching_rules)) {
            // Put course in default category
            $this->log->debug('No matching attribute mapping rule found.');
            $this->log->info('Using course default category');
            $this->doSync($a_content_id, $course, ilObject::_lookupObjId($this->getMapping()->getDefaultCourseCategory()));
            return true;
        }
        
        $this->log->debug('Matching rules:');
        $this->log->dump($matching_rules, ilLogLevel::DEBUG);
        
        $all_parent_refs = [];
        foreach ($matching_rules as $matching_rule) {
            $this->log->debug('Handling matching rule: ' . $matching_rule);
            $parent_refs = ilECSCourseMappingRule::doMappings($course, $this->getServer()->getServerId(), $this->getMid(), $matching_rule);
            // map according mapping rules
            $this->log->debug('Adding parent references: ');
            $this->log->dump($parent_refs);
            
            if (count($parent_refs)) {
                $all_parent_refs = array_unique(array_merge($all_parent_refs, $parent_refs));
            }
        }
        
        // parent refs are an array of created categories
        // the first ref should contain the main course or parallel courses.
        // all other refs wil contain course references.
        $first = true;
        foreach ($all_parent_refs as $category_ref) {
            if ($first) {
                $this->log->debug('Creating new course instance in: ' . $category_ref);
                $this->doSync($a_content_id, $course, ilObject::_lookupObjId($category_ref));
                $first = false;
                continue;
            } else {
                $this->log->debug('Creating new course reference instance in: ' . $category_ref);
                $this->createCourseReferenceObjects($category_ref);
            }
        }
        return true;
    }
    
    protected function createCourseReferenceObjects($a_parent_ref_id)
    {
        foreach ($this->getCreatedCourses() as $ref_id) {
            include_once './Modules/CourseReference/classes/class.ilObjCourseReference.php';
            $crsr = new ilObjCourseReference();
            $crsr->setOwner(SYTEM_USER_ID);
            $crsr->setTargetRefId($ref_id);
            $crsr->setTargetId(ilObject::_lookupObjId($ref_id));
            $crsr->create();
            $crsr->update();
            $crsr->createReference();
            $crsr->putInTree($a_parent_ref_id);
            $crsr->setPermissions($a_parent_ref_id);
            
            $this->log->debug('Created new course reference in : ' . ilObject::_lookupTitle(ilObject::_lookupObjId($a_parent_ref_id)));
            $this->log->debug('Created new course reference for : ' . ilObject::_lookupTitle(ilObject::_lookupObjId($ref_id)));
        }
    }
    
    protected function syncParentContainer($a_content_id, $course)
    {
        if (!is_array($course->allocations)) {
            $GLOBALS['ilLog']->write(__METHOD__ . ': No allocation in course defined.');
            return 0;
        }
        if (!$course->allocations[0]->parentID) {
            $GLOBALS['ilLog']->write(__METHOD__ . ': No allocation parent in course defined.');
            return 0;
        }
        $parent_id = $course->allocations[0]->parentID;
        
        include_once './Services/WebServices/ECS/classes/Tree/class.ilECSCmsData.php';
        $parent_tid = ilECSCmsData::lookupFirstTreeOfNode($this->getServer()->getServerId(), $this->getMid(), $parent_id);
        return $this->syncNodetoTop($parent_tid, $parent_id);
    }
    
    protected function syncNodeToTop($tree_id, $cms_id)
    {
        $obj_id = $this->getImportId($cms_id);
        if ($obj_id) {
            // node already imported
            return $obj_id;
        }

        $tobj_id = ilECSCmsData::lookupObjId(
            $this->getServer()->getServerId(),
            $this->getMid(),
            $tree_id,
            $cms_id
        );
        
        // node is not imported
        $GLOBALS['ilLog']->write(__METHOD__ . ': ecs node with id ' . $cms_id . ' is not imported for mid ' . $this->getMid() . ' tree_id ' . $tree_id);
        
        // check for mapping: if mapping is available create category
        include_once './Services/WebServices/ECS/classes/Mapping/class.ilECSNodeMappingAssignment.php';
        $ass = new ilECSNodeMappingAssignment(
            $this->getServer()->getServerId(),
            $this->getMid(),
            $tree_id,
            $tobj_id
        );
        
        if ($ass->isMapped()) {
            $GLOBALS['ilLog']->write(__METHOD__ . ': node is mapped');
            return $this->syncCategory($tobj_id, $ass->getRefId());
        }
        
        // Start recursion to top
        include_once './Services/WebServices/ECS/classes/Tree/class.ilECSCmsTree.php';
        $tree = new ilECSCmsTree($tree_id);
        $parent_tobj_id = $tree->getParentId($tobj_id);
        if ($parent_tobj_id) {
            $cms_ids = ilECSCmsData::lookupCmsIds(array($parent_tobj_id));
            $obj_id = $this->syncNodeToTop($tree_id, $cms_ids[0]);
        }
        
        if ($obj_id) {
            $refs = ilObject::_getAllReferences($obj_id);
            $ref_id = end($refs);
            return $this->syncCategory($tobj_id, $ref_id);
        }
        return 0;
    }
    
    protected function syncCategory($tobj_id, $parent_ref_id)
    {
        include_once './Services/WebServices/ECS/classes/Tree/class.ilECSCmsData.php';
        $data = new ilECSCmsData($tobj_id);
        
        include_once './Modules/Category/classes/class.ilObjCategory.php';
        $cat = new ilObjCategory();
        $cat->setOwner(SYSTEM_USER_ID);
        $cat->setTitle($data->getTitle());
        $cat->create(); // true for upload
        $cat->createReference();
        $cat->putInTree($parent_ref_id);
        $cat->setPermissions($parent_ref_id);
        $cat->deleteTranslation($GLOBALS['lng']->getDefaultLanguage());
        $cat->addTranslation(
            $data->getTitle(),
            $cat->getLongDescription(),
            $GLOBALS['lng']->getDefaultLanguage(),
            1
        );
            
        // set imported
        $import = new ilECSImport(
            $this->getServer()->getServerId(),
            $cat->getId()
        );
        $import->setMID($this->getMid());
        $import->setContentId($data->getCmsId());
        $import->setImported(true);
        $import->save();
        
        return $cat->getId();
    }

    protected function doSync($a_content_id, $course, $a_parent_obj_id)
    {
        // Check if course is already created
        $course_id = $course->lectureID;
        $this->getCourseUrl()->setCmsLectureId($course_id);
        
        $obj_id = $this->getImportId($course_id);
        
        $this->log->debug('Found obj_id ' . $obj_id . ' for course_id ' . $course_id);
        
        // Handle parallel groups
        if ($obj_id) {
            // update multiple courses/groups according to parallel scenario
            $this->log->debug('Group scenario ' . $course->groupScenario);
            include_once './Services/WebServices/ECS/classes/Mapping/class.ilECSMappingUtils.php';
            switch ((int) $course->groupScenario) {
                case ilECSMappingUtils::PARALLEL_GROUPS_IN_COURSE:
                    $this->log->debug('Performing update for parallel groups in course.');
                    $this->updateParallelGroups($a_content_id, $course, $obj_id);
                    break;
                
                case ilECSMappingUtils::PARALLEL_ALL_COURSES:
                    $this->log->debug('Performing update for parallel courses.');
                    $this->updateParallelCourses($a_content_id, $course, $a_parent_obj_id);
                    break;
                
                case ilECSMappingUtils::PARALLEL_ONE_COURSE:
                default:
                    // nothing to do
                    break;
                
            }
            
            // do update
            $this->updateCourseData($course, $obj_id);
        } else {
            include_once './Services/WebServices/ECS/classes/Mapping/class.ilECSMappingUtils.php';
            switch ((int) $course->groupScenario) {
                case ilECSMappingUtils::PARALLEL_GROUPS_IN_COURSE:
                    $this->log->debug('Parallel scenario "groups in courses".');
                    $crs = $this->createCourseData($course);
                    $crs = $this->createCourseReference($crs, $a_parent_obj_id);
                    $this->setImported($course_id, $crs, $a_content_id);

                    // Create parallel groups under crs
                    $this->createParallelGroups($a_content_id, $course, $crs->getRefId());
                    break;
                
                case ilECSMappingUtils::PARALLEL_COURSES_FOR_LECTURERS:
                    $this->log->debug('Parallel scenario "Courses foreach Lecturer".');
                    // Import empty to store the ecs ressource id (used for course member update).
                    $this->setImported($course_id, null, $a_content_id);
                    break;

                case ilECSMappingUtils::PARALLEL_ALL_COURSES:
                    $this->log->debug('Parallel scenario "Many courses".');
                    $refs = ilObject::_getAllReferences($a_parent_obj_id);
                    $ref = end($refs);
                    // do not create master course for this scenario
                    //$crs = $this->createCourseData($course);
                    //$this->createCourseReference($crs, $a_parent_obj_id);
                    //$this->setImported($course_id, $crs, $a_content_id);
                    $this->createParallelCourses($a_content_id, $course, $ref);
                    break;
                    
                default:
                case ilECSMappingUtils::PARALLEL_ONE_COURSE:
                    $this->log->debug('Parallel scenario "One Course".');
                    $crs = $this->createCourseData($course);
                    $this->createCourseReference($crs, $a_parent_obj_id);
                    $this->setImported($course_id, $crs, $a_content_id);
                    break;
                
                    
            }
        }
        // finally update course urls
        $this->handleCourseUrlUpdate();
        return true;
    }
    
    protected function createParallelCourses($a_content_id, $course, $parent_ref)
    {
        foreach ((array) $course->groups as $group) {
            $this->createParallelCourse($a_content_id, $course, $group, $parent_ref);
        }
        return true;
    }
    
    protected function createParallelCourse($a_content_id, $course, $group, $parent_ref)
    {
        if ($this->getImportId($course->lectureID, $group->id)) {
            $this->log->debug('Parallel course already created');
            return false;
        }
        
        include_once './Modules/Course/classes/class.ilObjCourse.php';
        $course_obj = new ilObjCourse();
        $course_obj->setOwner(SYSTEM_USER_ID);
        $title = $course->title;
        if (strlen($group->title)) {
            $title .= ' (' . $group->title . ')';
        }
        $this->log->debug('Creating new parallel course instance from ecs : ' . $title);
        $course_obj->setTitle($title);
        $course_obj->setSubscriptionMaxMembers((int) $group->maxParticipants);
        $course_obj->create();
        
        $this->createCourseReference($course_obj, ilObject::_lookupObjId($parent_ref));
        $this->setImported($course->lectureID, $course_obj, $a_content_id, $group->id);
        $this->setObjectCreated(true);
        return true;
    }
    
    protected function updateParallelCourses($a_content_id, $course, $parent_obj)
    {
        $parent_refs = ilObject::_getAllReferences($parent_obj);
        $parent_ref = end($parent_refs);
        
        foreach ((array) $course->groups as $group) {
            $title = $course->title;
            if (strlen($group->title)) {
                $title .= ' (' . $group->title . ')';
            }
            
            $obj_id = $this->getImportId($course->lectureID, $group->id);
            $this->log->debug('Imported obj id is ' . $obj_id);
            if (!$obj_id) {
                $this->createParallelCourse($a_content_id, $course, $group, $parent_ref);
            } else {
                $course_obj = ilObjectFactory::getInstanceByObjId($obj_id, false);
                if ($course_obj instanceof ilObjCourse) {
                    $this->log->debug('New title is ' . $title);
                    $course_obj->setTitle($title);
                    $course_obj->setSubscriptionMaxMembers($group->maxParticipants);
                    $course_obj->update();
                }
            }
            $this->addUrlEntry($this->getImportId($course->lectureID, $group->ID));
        }
        return true;
    }
    
    
    
    protected function createParallelGroups($a_content_id, $course, $parent_ref)
    {
        foreach ((array) $course->groups as $group) {
            $this->createParallelGroup($a_content_id, $course, $group, $parent_ref);
        }
        return true;
    }

    protected function createParallelGroup($a_content_id, $course, $group, $parent_ref)
    {
        include_once './Modules/Group/classes/class.ilObjGroup.php';
        $group_obj = new ilObjGroup();
        $group_obj->setOwner(SYSTEM_USER_ID);
        $title = strlen($group->title) ? $group->title : $course->title;
        $group_obj->setTitle($title);
        $group_obj->setMaxMembers((int) $group->maxParticipants);
        $group_obj->create();
        $group_obj->createReference();
        $group_obj->putInTree($parent_ref);
        $group_obj->setPermissions($parent_ref);
        $group_obj->updateGroupType(GRP_TYPE_CLOSED);
        $this->setImported($course->lectureID, $group_obj, $a_content_id, $group->id);
        $this->setObjectCreated(true);
    }


    protected function updateParallelGroups($a_content_id, $course, $parent_obj)
    {
        $parent_refs = ilObject::_getAllReferences($parent_obj);
        $parent_ref = end($parent_refs);
        
        foreach ((array) $course->groups as $group) {
            $obj_id = $this->getImportId($course->lectureID, $group->id);
            $this->log->debug('Imported obj id is ' . $obj_id);
            if (!$obj_id) {
                $this->createParallelGroup($a_content_id, $course, $group, $parent_ref);
            } else {
                $group_obj = ilObjectFactory::getInstanceByObjId($obj_id, false);
                if ($group_obj instanceof ilObjGroup) {
                    $title = strlen($group->title) ? $group->title : $course->title;
                    $GLOBALS['ilLog']->write(__METHOD__ . ': New title is ' . $title);
                    $group_obj->setTitle($title);
                    $group_obj->setMaxMembers((int) $group->maxParticipants);
                    $group_obj->update();
                }
            }
            $this->addUrlEntry($this->getImportId($course->lectureID, $group->id));
        }
    }
    
    protected function getImportId($a_content_id, $a_sub_id = null)
    {
        include_once './Services/WebServices/ECS/classes/class.ilECSImport.php';
        return ilECSImport::lookupObjIdByContentId(
            $this->getServer()->getServerId(),
            $this->getMid(),
            $a_content_id,
            $a_sub_id
        );
    }
    
    protected function updateCourseData($course, $obj_id)
    {
        // do update
        $refs = ilObject::_getAllReferences($obj_id);
        $ref_id = end($refs);
        $crs_obj = ilObjectFactory::getInstanceByRefId($ref_id, false);
        if (!$crs_obj instanceof ilObject) {
            $GLOBALS['ilLog']->write(__METHOD__ . ': Cannot instantiate course instance');
            return true;
        }
            
        // Update title
        $title = $course->title;
        $GLOBALS['ilLog']->write(__METHOD__ . ': new title is : ' . $title);
            
        $crs_obj->setTitle($title);
        $crs_obj->update();
        return true;
    }
    
    protected function createCourseData($course)
    {
        include_once './Modules/Course/classes/class.ilObjCourse.php';
        $course_obj = new ilObjCourse();
        $course_obj->setOwner(SYSTEM_USER_ID);
        $title = $course->title;
        $GLOBALS['ilLog']->write(__METHOD__ . ': Creating new course instance from ecs : ' . $title);
        $course_obj->setTitle($title);
        $course_obj->create();
        return $course_obj;
    }
    
    protected function createCourseReference($crs, $a_parent_obj_id)
    {
        $ref_ids = ilObject::_getAllReferences($a_parent_obj_id);
        $ref_id = end($ref_ids);
        
        $crs->createReference();
        $crs->putInTree($ref_id);
        $crs->setPermissions($ref_id);
        
        $this->setObjectCreated(true);
        $this->addUrlEntry($crs->getId());
        
        $this->courses_created[] = $crs->getRefId();
        
        return $crs;
    }
    
    protected function setImported($a_content_id, $object, $a_ecs_id = 0, $a_sub_id = null)
    {
        include_once './Services/WebServices/ECS/classes/class.ilECSImport.php';
        $import = new ilECSImport(
            $this->getServer()->getServerId(),
            is_object($object) ? $object->getId() : 0
        );

        
        $import->setSubId($a_sub_id);
        $import->setMID($this->getMid());
        $import->setEContentId($a_ecs_id);
        $import->setContentId($a_content_id);
        $import->setImported(true);
        $import->save();
        return true;
    }
    
    protected function addUrlEntry($a_obj_id)
    {
        $refs = ilObject::_getAllReferences($a_obj_id);
        $ref_id = end($refs);
        
        if (!$ref_id) {
            return false;
        }
        include_once './Services/WebServices/ECS/classes/Course/class.ilECSCourseLmsUrl.php';
        $lms_url = new ilECSCourseLmsUrl();
        $lms_url->setTitle(ilObject::_lookupTitle($a_obj_id));
        
        include_once './Services/Link/classes/class.ilLink.php';
        $lms_url->setUrl(ilLink::_getLink($ref_id));
        $this->getCourseUrl()->addLmsCourseUrls($lms_url);
    }
    
    protected function handleCourseUrlUpdate()
    {
        $GLOBALS['ilLog']->write(__METHOD__ . ': Starting course url update');
        if ($this->isObjectCreated()) {
            $GLOBALS['ilLog']->write(__METHOD__ . ': Sending new course group url');
            $this->getCourseUrl()->send($this->getServer(), $this->getMid());
        } else {
            $GLOBALS['ilLog']->write(__METHOD__ . ': No courses groups created. Aborting');
        }
    }
}