class.ilECSMappingSettingsGUI.php

Go to the documentation of this file.

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

include_once './Services/WebServices/ECS/classes/class.ilECSSetting.php';

/* 
 * Class for ECS node and directory mapping settings
 *
 * @author Stefan Meyer <smeyer.ilias@gmx.de>
 * @version $ID$
 *
 * @ingroup ServicesWebServicesECS
 * @ilCtrl_isCalledBy ilECSMappingSettingsGUI: ilECSSettingsGUI
 */
class ilECSMappingSettingsGUI
{
        const TAB_DIRECTORY = 1;
        const TAB_COURSE = 2;
        
        protected $log;

        private $container = null;
        private $server = null;
        private $mid = null;

        protected $lng = null;
        protected $ctrl = null;

        public function __construct($settingsContainer, $server_id, $mid)
        {
                global $lng,$ilCtrl;
                
                $this->log = $GLOBALS['DIC']->logger()->wsrv();

                $this->container = $settingsContainer;
                $this->server = ilECSSetting::getInstanceByServerId($server_id);
                $this->mid = $mid;
                $this->lng = $lng;
                $this->lng->loadLanguageModule('ecs');
                $this->ctrl = $ilCtrl;
        }

        public function getContainer()
        {
                return $this->container;
        }

        public function getServer()
        {
                return $this->server;
        }

        public function getMid()
        {
                return $this->mid;
        }
        
        public function executeCommand()
        {
                global $ilCtrl;

                $GLOBALS['tpl']->setTitle($this->lng->txt('ecs_campus_connect_title'));

                $this->ctrl->saveParameter($this,'server_id');
                $this->ctrl->saveParameter($this,'mid');
                $this->ctrl->saveParameter($this,'tid');

                $next_class = $this->ctrl->getNextClass($this);
                $cmd = $this->ctrl->getCmd();

                $this->setTabs();
                switch($next_class)
                {
                        default:
                                if(!$cmd)
                                {
                                        $cmd = "cStart";
                                }
                                $this->$cmd();
                                break;
                }

                $GLOBALS['tpl']->setTitle($this->getServer()->getTitle());
                $GLOBALS['tpl']->setDescription('');

                return true;
        }

        public function cancel()
        {
                $GLOBALS['ilCtrl']->returnToParent($this);
        }
        
        
        
        
        

        protected function cStart()
        {
                include_once './Services/WebServices/ECS/classes/Mapping/class.ilECSNodeMappingSettings.php';
                if(ilECSNodeMappingSettings::getInstanceByServerMid($this->getServer()->getServerId(),$this->getMid())->isCourseAllocationEnabled())
                {
                        return $this->cInitOverview();
                }
                return $this->cSettings();
        }

        protected function dStart()
        {
                include_once './Services/WebServices/ECS/classes/Mapping/class.ilECSNodeMappingSettings.php';
                if(ilECSNodeMappingSettings::getInstanceByServerMid($this->getServer()->getServerId(),$this->getMid())->isDirectoryMappingEnabled())
                {
                        return $this->dTrees();
                }
                return $this->dSettings();
        }
        
        protected function cInitOverview($form = null, $current_attribute = null)
        {
                global $ilTabs;
                
                $current_node = (array) (($_REQUEST['lnodes']) ? $_REQUEST['lnodes'] : ROOT_FOLDER_ID);
                $current_node = end($current_node);
                
                $this->ctrl->setParameter($this,'lnodes',$current_node);
                
                $this->setSubTabs(self::TAB_COURSE);
                $ilTabs->activateTab('ecs_crs_allocation');
                $ilTabs->activateSubTab('cInitTree');
                
                $GLOBALS['tpl']->addBlockFile('ADM_CONTENT','adm_content','tpl.ecs_cmap_overview.html','Services/WebServices/ECS');
                
                $explorer = $this->cShowLocalExplorer();
                if(!$form instanceof ilPropertyFormGUI)
                {
                        include_once './Services/WebServices/ECS/classes/Course/class.ilECSCourseMappingRule.php';
                        include_once './Services/WebServices/ECS/classes/Course/class.ilECSCourseAttributes.php';
                        
                        if($current_attribute === null)
                        {
                                // check request
                                $current_attribute = (string) $_REQUEST['ecs_ca'];
                                if(!$current_attribute)
                                {
                                        $existing = ilECSCourseMappingRule::lookupLastExistingAttribute(
                                                        $this->getServer()->getServerId(),
                                                        $this->getMid(),
                                                        $current_node
                                        );

                                        $current_attribute = 
                                                $existing ? 
                                                $existing :
                                                '';
                                        /*
                                                ilECSCourseAttributes::getInstance(
                                                                $this->getServer()->getServerId(),
                                                                $this->getMid())->getFirstAttributeName()
                                                );
                                        */
                                }
                        }
                        $form = $this->cInitMappingForm($current_node,$current_attribute);
                }
                
                $GLOBALS['tpl']->setVariable('TFORM_ACTION',$this->ctrl->getFormAction($this));
                $GLOBALS['tpl']->setVariable('LOCAL_EXPLORER',$explorer->getOutput());
                $GLOBALS['tpl']->setVariable('MAPPING_FORM',$form->getHTML());
        }
        
        protected function cAddAttribute()
        {
                include_once './Services/WebServices/ECS/classes/Course/class.ilECSCourseAttributes.php';
                $next_attribute = ilECSCourseAttributes::getInstance($this->getServer()->getServerId(), $this->getMid())->getNextAttributeName((string) $_REQUEST['ecs_ca']);
                $this->cInitOverview(NULL, $next_attribute);
        }
        
        protected function cDeleteAttribute()
        {
                include_once './Services/WebServices/ECS/classes/Course/class.ilECSCourseAttributes.php';
                $prev_attribute = ilECSCourseAttributes::getInstance($this->getServer()->getServerId(), $this->getMid())->getPreviousAttributeName((string) $_REQUEST['ecs_ca']);
                $this->cInitOverview(NULL, $prev_attribute);
        }
        
        protected function cShowLocalExplorer()
        {
                global $tree;

                include_once './Services/WebServices/ECS/classes/Mapping/class.ilECSNodeMappingLocalExplorer.php';
                $explorer = new ilECSNodeMappingLocalExplorer(
                                $this->ctrl->getLinkTarget($this,'cInitOverview'),
                                $this->getServer()->getServerId(),
                                $this->getMid()
                );
                $explorer->setPostVar('lnodes[]');

                $lnodes = (array) $_REQUEST['lnodes'];
                $checked_node = array_pop($lnodes);
                if((int) $_REQUEST['lid'])
                {
                        $checked_node = (int) $_REQUEST['lid'];
                }

                if($checked_node)
                {
                        $explorer->setCheckedItems(array($checked_node));
                }
                else
                {
                        $explorer->setCheckedItems(array(ROOT_FOLDER_ID));
                }
                $explorer->setTargetGet('lref_id');
                $explorer->setSessionExpandVariable('lexpand');
                $explorer->setExpand((int) $_GET['lexpand']);
                $explorer->setExpandTarget($this->ctrl->getLinkTarget($this,'cInitOverview'));
                $explorer->setOutput(0);
                return $explorer;
        }
        
        protected function cInitMappingForm($current_node,$current_attribute)
        {
                include_once './Services/WebServices/ECS/classes/Course/class.ilECSCourseAttributes.php';
                $attributes_obj = ilECSCourseAttributes::getInstance($this->getServer()->getServerId(), $this->getMid());
                
                include_once './Services/Form/classes/class.ilPropertyFormGUI.php';
                $form = new ilPropertyFormGUI();
                $form->setTableWidth("100%");
                $this->ctrl->setParameter($this,'ecs_ca',$current_attribute);
                $form->setFormAction($this->ctrl->getFormAction($this));
                $this->ctrl->setParameter($this,'ecs_ca','');
                
                $form->setTitle($this->lng->txt('ecs_cmap_mapping_form_title') .' '.ilObject::_lookupTitle(ilObject::_lookupObjId($current_node)));
                
                // Iterate through all current attributes
                $attributes = $attributes_obj->getAttributeSequence($current_attribute);
                foreach($attributes as $att_name)
                {
                        include_once './Services/WebServices/ECS/classes/Course/class.ilECSCourseMappingRule.php';
                        $rule = ilECSCourseMappingRule::getInstanceByAttribute($this->getServer()->getServerId(), $this->getMid(), $current_node, $att_name);
                        
                        $section = new ilFormSectionHeaderGUI();
                        $section->setTitle($this->lng->txt('ecs_cmap_att_'.$att_name));
                        
                        // Filter
                        $form->addItem($section);
                        
                        $isfilter = new ilRadioGroupInputGUI($this->lng->txt('ecs_cmap_form_filter'),$att_name.'_is_filter');
                        $isfilter->setValue($rule->isFilterEnabled() ? 1 : 0);
                        
                        $all_values = new ilRadioOption($this->lng->txt('ecs_cmap_form_all_values'),0);
                        $isfilter->addOption($all_values);
                        
                        $use_filter = new ilRadioOption($this->lng->txt('ecs_cmap_form_filter_by_values'),1);
                        $filter = new ilTextInputGUI('',$att_name.'_filter');
                        $filter->setInfo($this->lng->txt('ecs_cmap_form_filter_info'));
                        $filter->setSize(50);
                        $filter->setMaxLength(512);
                        $filter->setRequired(true);
                        $filter->setValue($rule->getFilter());
                        $use_filter->addSubItem($filter);
                        
                        $isfilter->addOption($use_filter);
                        
                        $form->addItem($isfilter);

                        // Create subdirs
                        $subdirs = new ilCheckboxInputGUI($this->lng->txt('ecs_cmap_form_create_subdirs'),$att_name.'_subdirs');
                        $subdirs->setChecked($rule->isSubdirCreationEnabled());
                        $subdirs->setValue(1);
                        
                        // Subdir types (disabled in spec)
                        /*
                        $subdir_type = new ilRadioGroupInputGUI($this->lng->txt('ecs_cmap_form_subdir_type'), $att_name.'_subdir_type');
                        $subdir_type->setValue($rule->getSubDirectoryType());
                        
                        $value = new ilRadioOption($this->lng->txt('ecs_cmap_form_subdir_value'),  ilECSCourseMappingRule::SUBDIR_VALUE);
                        $subdir_type->addOption($value);

                        $name = new ilRadioOption($this->lng->txt('ecs_cmap_form_subdir_name'),  ilECSCourseMappingRule::SUBDIR_ATTRIBUTE_NAME);
                        $subdir_type->addOption($name);
                        
                        $subdirs->addSubItem($subdir_type);
                        */
                        $form->addItem($subdirs);
                        
                        // Directory relations
                        /*
                        $upper_attributes = ilECSCourseAttributes::getInstance(
                                        $this->getServer()->getServerId(),
                                        $this->getMid())->getUpperAttributes($att_name);
                        
                        if($upper_attributes)
                        {
                                $dir_relation = new ilRadioGroupInputGUI($this->lng->txt('ecs_cmap_form_dir_relation'),$att_name.'_dir_relation');

                                $current_dir = new ilRadioOption($this->lng->txt('ecs_cmap_form_current_dir'),'');
                                $dir_relation->addOption($current_dir);
                        }
                        foreach($upper_attributes as $subdir_name)
                        {
                                $subdir = new ilRadioOption($this->lng->txt('ecs_cmap_att_'.$subdir_name),$subdir_name);
                                $dir_relation->addOption($subdir);
                        }
                        if($upper_attributes)
                        {
                                $dir_relation->setValue((string) $rule->getDirectory());
                                $form->addItem($dir_relation);
                        }
                        */
                }
                
                // add list of attributes
                $hidden_atts = new ilHiddenInputGUI('attributes');
                $hidden_atts->setValue(implode(',',$attributes));
                $form->addItem($hidden_atts);
                                

                if($current_attribute)
                {
                        $form->addCommandButton('cSaveOverview',$this->lng->txt('save'));
                }
                
                if($attributes_obj->getNextAttributeName($current_attribute))
                {
                        $form->addCommandButton('cAddAttribute', $this->lng->txt('ecs_cmap_add_attribute_btn'));
                }
                if($attributes_obj->getPreviousAttributeName($current_attribute))
                {
                        $form->addCommandButton('cDeleteAttribute', $this->lng->txt('ecs_cmap_delete_attribute_btn'));
                }
                if(ilECSCourseMappingRule::hasRules(
                                $this->getServer()->getServerId(),
                                $this->getMid(),
                                $current_node
                ))
                {
                        $form->addCommandButton('cDeleteRulesOfNode', $this->lng->txt('ecs_cmap_delete_rule'));
                }
                
                #$form->addCommandButton('cInitOverview', $this->lng->txt('cancel'));
                
                $form->setShowTopButtons(false);

                return $form;
        }
        
        protected function cSaveOverview()
        {
                $current_node = (int) $_REQUEST['lnodes'];
                $current_att = (string) $_REQUEST['ecs_ca'];
                $form = $this->cInitMappingForm($current_node, $current_att);
                                
                if($form->checkInput())
                {
                        // save ...
                        $all_attributes = explode(',',$form->getInput('attributes'));
                        foreach((array) $all_attributes as $att_name)
                        {
                                $rule = ilECSCourseMappingRule::getInstanceByAttribute(
                                                $this->getServer()->getServerId(), 
                                                $this->getMid(), 
                                                $current_node, 
                                                $att_name);
                                $rule->setServerId($this->getServer()->getServerId());
                                $rule->setMid($this->getMid());
                                $rule->setRefId($current_node);
                                $rule->setAttribute($att_name);
                                $rule->enableFilter($form->getInput($att_name.'_is_filter'));
                                $rule->setFilter($form->getInput($att_name.'_filter'));
                                $rule->enableSubdirCreation($form->getInput($att_name.'_subdirs'));
                                //$rule->setSubDirectoryType($form->getInput($att_name.'_subdir_type'));
                                //$rule->setDirectory($form->getInput($att_name.'_dir_relation'));
                                
                                if($rule->getRuleId())
                                {
                                        $rule->update();
                                }
                                else
                                {
                                        $rule->save();
                                }
                        }
                        
                        ilUtil::sendSuccess($this->lng->txt('settings_saved'),true);
                        $this->ctrl->setParameter($this,'lnodes',$current_node);
                        $this->ctrl->redirect($this,'cInitOverview');
                }
                
                $form->setValuesByPost();
                ilUtil::sendFailure($this->lng->txt('err_check_input'));
                $this->cInitOverview($form, $current_att);
        }
        
        protected function cDeleteRulesOfNode()
        {
                $current_node = (int) $_REQUEST['lnodes'];
                
                include_once './Services/WebServices/ECS/classes/Course/class.ilECSCourseMappingRule.php';
                $rules = ilECSCourseMappingRule::getRulesOfRefId(
                                $this->getServer()->getServerId(),
                                $this->getMid(),
                                $current_node);
                
                foreach($rules as $rid)
                {
                        $rule = new ilECSCourseMappingRule($rid);
                        $rule->delete();
                }
                ilUtil::sendSuccess($this->lng->txt('settings_saved'),true);
                $this->ctrl->redirect($this,'cInitOverview');
        }


        

        protected function cSettings(ilPropertyFormGUI $form = NULL)
        {
                global $ilTabs;
                
                $this->setSubTabs(self::TAB_COURSE);
                $ilTabs->activateTab('ecs_crs_allocation');
                $ilTabs->activateSubTab('cSettings');

                if(!$form instanceof ilPropertyFormGUI)
                {
                        $form = $this->initFormCSettings();
                }

                $GLOBALS['tpl']->setContent($form->getHTML());

                return true;
        }

        protected function initFormCSettings()
        {
                include_once './Services/WebServices/ECS/classes/Mapping/class.ilECSNodeMappingSettings.php';
                
                include_once './Services/Form/classes/class.ilPropertyFormGUI.php';
                $form = new ilPropertyFormGUI();
                $form->setFormAction($this->ctrl->getFormAction($this));
                $form->setTitle($this->lng->txt('settings'));

                // individual course allocation
                $check = new ilCheckboxInputGUI($this->lng->txt('ecs_cmap_enable'), 'enabled');
                $check->setChecked(ilECSNodeMappingSettings::getInstanceByServerMid($this->getServer()->getServerId(),$this->getMid())->isCourseAllocationEnabled());
                $form->addItem($check);
                
                
                // add default container
                $imp = new ilCustomInputGUI($this->lng->txt('ecs_cmap_def_cat'),'default_cat');
                $imp->setRequired(true);

                $tpl = new ilTemplate('tpl.ecs_import_id_form.html',true,true,'Services/WebServices/ECS');
                $tpl->setVariable('SIZE',5);
                $tpl->setVariable('MAXLENGTH',11);
                $tpl->setVariable('POST_VAR','default_cat');
                
                $default = ilECSNodeMappingSettings::getInstanceByServerMid($this->getServer()->getServerId(),$this->getMid())->getDefaultCourseCategory();
                $tpl->setVariable('PROPERTY_VALUE',$default);

                if($default)
                {
                        include_once './Services/Tree/classes/class.ilPathGUI.php';
                        $path = new ilPathGUI();
                        $path->enableTextOnly(false);
                        $path->enableHideLeaf(false);
                        $tpl->setVariable('COMPLETE_PATH',$path->getPath(ROOT_FOLDER_ID, $default));
                }

                $imp->setHtml($tpl->get());
                $imp->setInfo($this->lng->txt('ecs_cmap_def_cat_info'));
                $form->addItem($imp);

                // all in one category
                $allinone = new ilCheckboxInputGUI($this->lng->txt('ecs_cmap_all_in_one'),'allinone');
                $allinone->setChecked(ilECSNodeMappingSettings::getInstanceByServerMid($this->getServer()->getServerId(),$this->getMid())->isAllInOneCategoryEnabled());
                $allinone->setInfo($this->lng->txt('ecs_cmap_all_in_one_info'));
                
                $allinone_cat = new ilCustomInputGUI($this->lng->txt('ecs_cmap_all_in_one_cat'),'allinone_cat');
                $allinone_cat->setRequired(true);

                $tpl = new ilTemplate('tpl.ecs_import_id_form.html',true,true,'Services/WebServices/ECS');
                $tpl->setVariable('SIZE',5);
                $tpl->setVariable('MAXLENGTH',11);
                $tpl->setVariable('POST_VAR','allinone_cat');
                
                $cat = ilECSNodeMappingSettings::getInstanceByServerMid($this->getServer()->getServerId(),$this->getMid())->getAllInOneCategory();
                $tpl->setVariable('PROPERTY_VALUE',$cat);
                if($cat)
                {
                        include_once './Services/Tree/classes/class.ilPathGUI.php';
                        $path = new ilPathGUI();
                        $path->enableTextOnly(false);
                        $path->enableHideLeaf(false);
                        $tpl->setVariable('COMPLETE_PATH',$path->getPath(ROOT_FOLDER_ID, $default));
                }
                
                $allinone_cat->setHtml($tpl->get());
                $allinone->addSubItem($allinone_cat);
                $form->addItem($allinone);
                
                // multiple attributes
                $multiple = new ilCheckboxInputGUI($this->lng->txt('ecs_cmap_multiple_atts'),'multiple');
                $multiple->setChecked(ilECSNodeMappingSettings::getInstanceByServerMid($this->getServer()->getServerId(),$this->getMid())->isAttributeMappingEnabled());

                // attribute selection
                include_once './Services/WebServices/ECS/classes/Mapping/class.ilECSMappingUtils.php';
                include_once './Services/WebServices/ECS/classes/Course/class.ilECSCourseAttributes.php';
                $attributes = new ilSelectInputGUI($this->lng->txt('ecs_cmap_attributes'),'atts');
                $attributes->setMulti(true);
                $attributes->setValue(
                                ilECSCourseAttributes::getInstance(
                                                $this->getServer()->getServerId(), 
                                                $this->getMid()
                                )->getAttributeValues());
                $attributes->setRequired(true);
                $attributes->setOptions(ilECSMappingUtils::getCourseMappingFieldSelectOptions());
                $multiple->addSubItem($attributes);

                $form->addItem($multiple);
                
                // role mapping
                $rm = new ilFormSectionHeaderGUI();
                $rm->setTitle($this->lng->txt('ecs_role_mappings'));
                $form->addItem($rm);
                
                // auth type
                $auth_type = new ilSelectInputGUI($this->lng->txt('ecs_member_auth_type'), 'auth_mode');
                $auth_type->setOptions(ilECSMappingUtils::getAuthModeSelection());
                $auth_type->setRequired(true);
                $auth_type->setValue(ilECSNodeMappingSettings::getInstanceByServerMid($this->getServer()->getServerId(), $this->getMid())->getAuthMode());
                $form->addItem($auth_type);
                
                $mapping_defs = ilECSNodeMappingSettings::getInstanceByServerMid($this->getServer()->getServerId(),$this->getMid())->getRoleMappings();
                
                include_once './Services/WebServices/ECS/classes/Mapping/class.ilECSMappingUtils.php';
                foreach(ilECSMappingUtils::getRoleMappingInfo() as $name => $info)
                {
                        $role_map = new ilTextInputGUI($this->lng->txt($info['lang']),$name);
                        $role_map->setValue($mapping_defs[$name]);
                        $role_map->setSize(32);
                        $role_map->setMaxLength(64);
                        $role_map->setRequired($info['required']);
                        $form->addItem($role_map);
                }
                
                $form->addCommandButton('cUpdateSettings',$this->lng->txt('save'));
                $form->addCommandButton('cSettings', $this->lng->txt('cancel'));

                return $form;
        }

        protected function dSettings(ilPropertyFormGUI $form = NULL)
        {
                global $ilTabs;

                include_once './Services/WebServices/ECS/classes/Mapping/class.ilECSNodeMappingAssignments.php';
                $this->setSubTabs(self::TAB_DIRECTORY);
                $ilTabs->activateTab('ecs_dir_allocation');
                $ilTabs->activateSubTab('dSettings');

                include_once './Services/Form/classes/class.ilPropertyFormGUI.php';
                if(!$form instanceof ilPropertyFormGUI)
                {
                        $form = $this->initFormDSettings();
                }

                $GLOBALS['tpl']->setContent($form->getHTML());

                return true;
        }
        
        protected function cUpdateSettings()
        {
                $form = $this->initFormCSettings();
                if($form->checkInput())
                {
                        include_once './Services/WebServices/ECS/classes/Mapping/class.ilECSNodeMappingSettings.php';
                        $settings = ilECSNodeMappingSettings::getInstanceByServerMid($this->getServer()->getServerId(),$this->getMid());
                        $settings->enableCourseAllocation($form->getInput('enabled'));
                        $settings->setDefaultCourseCategory($form->getInput('default_cat'));
                        $settings->enableAllInOne($form->getInput('allinone'));
                        $settings->setAllInOneCategory($form->getInput('allinone_cat'));
                        $settings->enableAttributeMapping($form->getInput('multiple'));
                        $settings->setAuthMode($form->getInput('auth_mode'));
                        
                        
                        $role_mappings = array();
                        foreach(ilECSMappingUtils::getRoleMappingInfo() as $name => $info)
                        {
                                $role_mappings[$name] = $form->getInput($name);
                        }
                        $settings->setRoleMappings($role_mappings);
                        $settings->update();
                        
                        // store attribute settings
                        include_once './Services/WebServices/ECS/classes/Course/class.ilECSCourseAttributes.php';
                        $attributes = new ilECSCourseAttributes($this->getServer()->getServerId(),$this->getMid());
                        $attributes->delete();
                        
                        $form_atts = $form->getInput('atts');
                        
                        foreach($form_atts as $name)
                        {
                                if(!$name)
                                {
                                        continue;
                                }
                                
                                $att = new ilECSCourseAttribute();
                                $att->setServerId($this->getServer()->getServerId());
                                $att->setMid($this->getMid());
                                $att->setName($name);
                                $att->save();
                        }
                        
                        //$att = new ilECSCourseAttribute();
                        //$att->setName($a_name)
                        
                        ilUtil::sendSuccess($this->lng->txt('settings_saved'),true);
                        $GLOBALS['ilCtrl']->redirect($this,'cSettings');
                }
                ilUtil::sendFailure($this->lng->txt('err_check_input'));
                $form->setValuesByPost();
                $this->cSettings($form);
        }
        
        protected function cAttributes()
        {
                global $ilTabs;
                
                $this->setSubTabs(self::TAB_COURSE);
                $ilTabs->setTabActive('ecs_crs_allocation');
                $ilTabs->setSubTabActive('cAttributes');
                
                include_once './Services/WebServices/ECS/classes/Course/class.ilECSCourseAttributesTableGUI.php';
                $table = new ilECSCourseAttributesTableGUI(
                                $this,
                                'attributes',
                                $this->getServer()->getServerId(),
                                $this->getMid()
                );
                $table->init();
                $table->parse(
                                ilECSCourseAttributes::getInstance(
                                                $this->getServer()->getServerId(), 
                                                $this->getMid())->getAttributes());
                
                $GLOBALS['tpl']->setContent($table->getHTML());
        }
        
        

        protected function dUpdateSettings()
        {
                global $ilCtrl;

                $form = $this->initFormDSettings();
                if($form->checkInput())
                {
                        include_once './Services/WebServices/ECS/classes/Mapping/class.ilECSNodeMappingSettings.php';
                        $settings = ilECSNodeMappingSettings::getInstanceByServerMid($this->getServer()->getServerId(),$this->getMid());
                        $settings->enableDirectoryMapping((bool) $form->getInput('active'));
                        $settings->enableEmptyContainerCreation(!$form->getInput('empty'));
                        $settings->update();
                        ilUtil::sendSuccess($this->lng->txt('settings_saved'),true);
                }
                else
                {
                        ilUtil::sendFailure($this->lng->txt('err_check_input'),true);
                        $form->setValuesByPost();
                }
                $ilCtrl->redirect($this,'dSettings');
        }

        protected function initFormDSettings()
        {
                include_once './Services/WebServices/ECS/classes/Mapping/class.ilECSNodeMappingSettings.php';
                include_once './Services/Form/classes/class.ilPropertyFormGUI.php';

                $form = new ilPropertyFormGUI();
                $form->setFormAction($this->ctrl->getFormAction($this));
                $form->setTitle($this->lng->txt('general_settings'));

                $active = new ilCheckboxInputGUI($this->lng->txt('ecs_node_mapping_activate'), 'active');
                $active->setChecked(ilECSNodeMappingSettings::getInstanceByServerMid($this->getServer()->getServerId(),$this->getMid())->isDirectoryMappingEnabled());
                $form->addItem($active);

                $create_empty = new ilCheckboxInputGUI($this->lng->txt('ecs_node_mapping_create_empty'), 'empty');
                $create_empty->setChecked(!ilECSNodeMappingSettings::getInstanceByServerMid($this->getServer()->getServerId(),$this->getMid())->isEmptyContainerCreationEnabled());
                $create_empty->setInfo($this->lng->txt('ecs_node_mapping_create_empty_info'));
                $form->addItem($create_empty);

                $form->addCommandButton('dUpdateSettings',$this->lng->txt('save'));
                $form->addCommandButton('cancel', $this->lng->txt('cancel'));

                return $form;
        }

        protected function dTrees()
        {
                global $ilToolbar;
                
                $this->setSubTabs(self::TAB_DIRECTORY);
                $GLOBALS['ilTabs']->activateSubTab('dTrees');
                $GLOBALS['ilTabs']->activateTab('ecs_dir_allocation');
                
                $ilToolbar->addButton(
                                $this->lng->txt('ecs_sync_trees'),
                                $this->ctrl->getLinkTarget($this, 'dSynchronizeTrees'));

                include_once './Services/WebServices/ECS/classes/Mapping/class.ilECSNodeMappingTreeTableGUI.php';

                $dtreeTable = new ilECSNodeMappingTreeTableGUI(
                        $this->getServer()->getServerId(),
                        $this->getMid(),
                        $this,
                        'dtree');


                $dtreeTable->parse();
                $GLOBALS['tpl']->setContent($dtreeTable->getHTML());
                return true;
        }

        protected function dConfirmDeleteTree()
        {
                $this->setSubTabs(self::TAB_DIRECTORY);
                $GLOBALS['ilTabs']->activateSubTab('dTrees');
                $GLOBALS['ilTabs']->activateTab('ecs_dir_allocation');

                include_once './Services/Utilities/classes/class.ilConfirmationGUI.php';
                include_once './Services/WebServices/ECS/classes/Tree/class.ilECSCmsData.php';

                $confirm = new ilConfirmationGUI();
                $confirm->setFormAction($this->ctrl->getFormAction($this));
                $confirm->setHeaderText($this->lng->txt('ecs_confirm_delete_tree'));

                $confirm->addItem(
                        'tid',
                        (int) $_REQUEST['tid'],
                        ilECSCmsData::lookupTitle(
                                $this->getServer()->getServerId(),
                                $this->getMid(),
                                (int) $_REQUEST['tid']
                        )
                );
                $confirm->setConfirm($this->lng->txt('delete'), 'dDeleteTree');
                $confirm->setCancel($this->lng->txt('cancel'), 'dTrees');

                $GLOBALS['tpl']->setContent($confirm->getHTML());
        }

        protected function dDeleteTree()
        {
                include_once './Services/WebServices/ECS/classes/Tree/class.ilECSCmsData.php';
                include_once './Services/WebServices/ECS/classes/Tree/class.ilECSCmsTree.php';

                $GLOBALS['ilLog']->write('Deleting tree');

                $tree = new ilECSCmsTree((int) $_REQUEST['tid']);
                $tree->deleteTree($tree->getNodeData(ilECSCmsTree::lookupRootId((int) $_REQUEST['tid'])));

                
                
                // also delete import information
                include_once './Services/WebServices/ECS/classes/class.ilECSImport.php';
                ilECSImport::deleteRessources(
                                $this->getServer()->getServerId(),
                                $this->getMid(),
                                ilECSCmsData::lookupCmsIdsOfTree(
                                                $this->getServer()->getServerId(),
                                                $this->getMid(),
                                                (int) $_REQUEST['tid']
                                )
                );
                                
                $data = new ilECSCmsData();
                $data->setServerId($this->getServer()->getServerId());
                $data->setMid($this->getMid());
                $data->setTreeId((int) $_REQUEST['tid']);
                $data->deleteTree();


                include_once './Services/WebServices/ECS/classes/Mapping/class.ilECSNodeMappingAssignments.php';
                ilECSNodeMappingAssignments::deleteMappings(
                        $this->getServer()->getServerId(),
                        $this->getMid(),
                        (int) $_REQUEST['tid']
                );

                ilUtil::sendSuccess($this->lng->txt('ecs_cms_tree_deleted'),true);
                $this->ctrl->redirect($this,'dTrees');
        }

        protected function dEditTree(ilPropertyFormGUI $form = null)
        {
                $GLOBALS['tpl']->addBlockFile('ADM_CONTENT','adm_content','tpl.ecs_edit_tree.html','Services/WebServices/ECS');

                $this->ctrl->saveParameter($this,'cid');

                $GLOBALS['ilTabs']->clearTargets();
                $GLOBALS['ilTabs']->setBack2Target(
                        $this->lng->txt('ecs_back_settings'),
                        $this->ctrl->getLinkTarget($this,'cancel')
                );
                $GLOBALS['ilTabs']->setBackTarget(
                        $this->lng->txt('ecs_cms_dir_tree'),
                        $this->ctrl->getLinkTarget($this,'dTrees')
                );
                
                $GLOBALS['tpl']->setVariable('LEGEND',$GLOBALS['lng']->txt('ecs_status_legend'));
                $GLOBALS['tpl']->setVariable('PENDING_UNMAPPED',$GLOBALS['lng']->txt('ecs_status_pending_unmapped'));
                $GLOBALS['tpl']->setVariable('PENDING_UNMAPPED_DISCON',$GLOBALS['lng']->txt('ecs_status_pending_unmapped_discon'));
                $GLOBALS['tpl']->setVariable('PENDING_UNMAPPED_NONDISCON',$GLOBALS['lng']->txt('ecs_status_pending_unmapped_nondiscon'));
                $GLOBALS['tpl']->setVariable('MAPPED',$GLOBALS['lng']->txt('ecs_status_mapped'));
                $GLOBALS['tpl']->setVariable('DELETED',$GLOBALS['lng']->txt('ecs_status_deleted'));

                $form = $this->dInitFormTreeSettings($form);
                $GLOBALS['tpl']->setVariable('GENERAL_FORM',$form->getHTML());
                $GLOBALS['tpl']->setVariable('TFORM_ACTION',$this->ctrl->getFormAction($this,'dEditTree'));

                $explorer = $this->dShowLocalExplorer();
                $this->dShowCmsExplorer($explorer);
        }

        protected function dInitFormTreeSettings(ilPropertyFormGUI $form = null)
        {
                include_once './Services/WebServices/ECS/classes/Mapping/class.ilECSMappingUtils.php';
                include_once './Services/WebServices/ECS/classes/Tree/class.ilECSCmsTree.php';

                if($form instanceof ilPropertyFormGUI)
                {
                        return $form;
                }

                include_once './Services/WebServices/ECS/classes/Mapping/class.ilECSNodeMappingAssignment.php';
                $assignment = new ilECSNodeMappingAssignment(
                        $this->getServer()->getServerId(),
                        $this->getMid(),
                        (int) $_REQUEST['tid'],
                        0
                );

                include_once './Services/Form/classes/class.ilPropertyFormGUI.php';
                $form = new ilPropertyFormGUI();
                $form->setFormAction($this->ctrl->getFormAction($this,'dEditTree'));
                $form->setTitle($this->lng->txt('general_settings'));
                $form->addCommandButton('dUpdateTreeSettings', $this->lng->txt('save'));
                $form->addCommandButton('dTrees', $this->lng->txt('cancel'));
                $form->setTableWidth('30%');

                // CMS id (readonly)
                include_once './Services/WebServices/ECS/classes/Tree/class.ilECSCmsData.php';
                $cmsid = new ilNumberInputGUI($this->lng->txt('ecs_cms_id'), 'cmsid');
                $cmsid->setValue(
                                ilECSCmsData::lookupCmsId(ilECSCmsTree::lookupRootId((int) $_REQUEST['tid']))
                );
                $cmsid->setDisabled(true);
                $cmsid->setSize(7);
                $cmsid->setMaxLength(12);
                $form->addItem($cmsid);


                $mapping_status = ilECSMappingUtils::lookupMappingStatus(
                        $this->getServer()->getServerId(),
                        $this->getMid(),
                        (int) $_REQUEST['tid']);
                $mapping_advanced = ($mapping_status != ilECSMappingUtils::MAPPED_MANUAL ? true : false);

                // Status (readonly)
                $status = new ilNonEditableValueGUI($this->lng->txt('status'), '');
                $status->setValue(ilECSMappingUtils::mappingStatusToString($mapping_status));
                $form->addItem($status);

                // title update
                $title = new ilCheckboxInputGUI($this->lng->txt('ecs_title_updates'), 'title');
                $title->setValue(1);
                $title->setChecked($assignment->isTitleUpdateEnabled());
                #$title->setInfo($this->lng->txt('ecs_title_update_info'));
                $form->addItem($title);


                $position = new ilCheckboxInputGUI($this->lng->txt('ecs_position_updates'), 'position');
                $position->setDisabled(!$mapping_advanced);
                $position->setChecked($mapping_advanced && $assignment->isPositionUpdateEnabled());
                $position->setValue(1);
                #$position->setInfo($this->lng->txt('ecs_position_update_info'));
                $form->addItem($position);

                $tree = new ilCheckboxInputGUI($this->lng->txt('ecs_tree_updates'), 'tree');
                $tree->setDisabled(!$mapping_advanced);
                $tree->setChecked($mapping_advanced && $assignment->isTreeUpdateEnabled());
                $tree->setValue(1);
                #$tree->setInfo($this->lng->txt('ecs_tree_update_info'));
                $form->addItem($tree);

                return $form;
        }

        protected function dUpdateTreeSettings()
        {
                include_once './Services/WebServices/ECS/classes/Mapping/class.ilECSNodeMappingAssignment.php';
                include_once './Services/WebServices/ECS/classes/Tree/class.ilECSCmsTree.php';
                $assignment = new ilECSNodeMappingAssignment(
                        $this->getServer()->getServerId(),
                        $this->getMid(),
                        (int) $_REQUEST['tid'],
                        0
                );
                $assignment->setRefId(0);
                $assignment->setObjId(0);

                $form = $this->dInitFormTreeSettings();
                if($form->checkInput())
                {
                        $assignment->enableTitleUpdate($form->getInput('title'));
                        $assignment->enableTreeUpdate($form->getInput('tree'));
                        $assignment->enablePositionUpdate($form->getInput('position'));
                        $assignment->update();

                        ilUtil::sendSuccess($this->lng->txt('settings_saved',true));
                        $this->ctrl->redirect($this,'dEditTree');
                }

                $form->setValuesByPost();
                ilUtil::sendFailure($this->lng->txt('err_check_input'));
                $this->dEditTree($form);
                return true;
        }
        
        protected function dSynchronizeTree()
        {
                include_once './Services/WebServices/ECS/classes/Tree/class.ilECSCmsTreeSynchronizer.php';
                $sync = new ilECSCmsTreeSynchronizer(
                                $this->getServer(),
                                $this->mid,
                                (int) $_REQUEST['tid']
                        );
                $sync->sync();
                ilUtil::sendSuccess($this->lng->txt('ecs_cms_tree_synchronized'),true);
                $this->ctrl->redirect($this,'dTrees');
        }
        
        protected function dSynchronizeTrees()
        {
                include_once './Services/WebServices/ECS/classes/Tree/class.ilECSDirectoryTreeConnector.php';

                $this->log->dump('Start synchronizing cms directory trees');
                
                try
                {
                        $connector = new ilECSDirectoryTreeConnector($this->getServer());
                        $res = $connector->getDirectoryTrees();
                        
                        $this->log->dump($res, ilLogLevel::DEBUG);
                        
                        foreach((array) $res->getLinkIds() as $cms_id)
                        {
                                include_once './Services/WebServices/ECS/classes/class.ilECSEventQueueReader.php';
                                include_once './Services/WebServices/ECS/classes/class.ilECSEvent.php';
                                $event = new ilECSEventQueueReader($this->getServer()->getServerId());
                                $event->add(
                                        ilECSEventQueueReader::TYPE_DIRECTORY_TREES,
                                        $cms_id,
                                        ilECSEvent::UPDATED
                                );
                        }
                        $this->ctrl->redirect($this,'dTrees');
                }
                catch(Exception $e)
                {
                        ilUtil::sendFailure($e->getMessage(),true);
                        $this->ctrl->redirect($this,'dTrees');
                }
        }

        protected function dShowLocalExplorer()
        {
                global $tree;

                include_once './Services/WebServices/ECS/classes/Mapping/class.ilECSNodeMappingLocalExplorer.php';
                $explorer = new ilECSNodeMappingLocalExplorer(
                                $this->ctrl->getLinkTarget($this,'dEditTree'),
                                $this->getServer()->getServerId(),
                                $this->getMid()
                );
                $explorer->setPostVar('lnodes[]');

                $lnodes = (array) $_REQUEST['lnodes'];
                $checked_node = array_pop($lnodes);
                if((int) $_REQUEST['lid'])
                {
                        $checked_node = (int) $_REQUEST['lid'];
                }

                if($checked_node)
                {
                        $explorer->setCheckedItems(array($checked_node));
                }
                else
                {
                        $explorer->setCheckedItems(array(ROOT_FOLDER_ID));
                }
                $explorer->setTargetGet('lref_id');
                $explorer->setSessionExpandVariable('lexpand');
                $explorer->setExpand((int) $_GET['lexpand']);
                $explorer->setExpandTarget($this->ctrl->getLinkTarget($this,'dEditTree'));
                $explorer->setOutput(0);
                $GLOBALS['tpl']->setVariable('LOCAL_EXPLORER',$explorer->getOutput());

                return $explorer;
        }

        protected function dShowCmsExplorer(ilExplorer $localExplorer)
        {
                global $tree;

                include_once './Services/WebServices/ECS/classes/Tree/class.ilECSCmsTree.php';
                include_once './Services/WebServices/ECS/classes/Mapping/class.ilECSNodeMappingCmsExplorer.php';
                include_once './Services/WebServices/ECS/classes/Mapping/class.ilECSNodeMappingAssignments.php';

                $explorer = new ilECSNodeMappingCmsExplorer(
                        $this->ctrl->getLinkTarget($this,'dEditTree'),
                        $this->getServer()->getServerId(),
                        $this->getMid(),
                        (int) $_REQUEST['tid']
                );
                $explorer->setRoot(ilECSCmsTree::lookupRootId((int) $_REQUEST['tid']));
                $explorer->setTree(
                        new ilECSCmsTree(
                                (int) $_REQUEST['tid']
                        )
                );
                $explorer->setPostVar('rnodes[]');

                // Read checked items from mapping of checked items in local explorer
                $active_node = $tree->getRootId();
                foreach($localExplorer->getCheckedItems() as $ref_id)
                {
                        $explorer->setCheckedItems(
                                ilECSNodeMappingAssignments::lookupMappedItemsForRefId(
                                        $this->getServer()->getServerId(),
                                        $this->getMid(),
                                        (int) $_REQUEST['tid'],
                                        $ref_id
                                )
                        );
                        $active_node = $ref_id;
                }


                include_once './Services/WebServices/ECS/classes/Mapping/class.ilECSNodeMappingAssignments.php';
                include_once './Services/WebServices/ECS/classes/Tree/class.ilECSCmsTree.php';
                $cmsTree = new ilECSCmsTree((int) $_REQUEST['tid']);
                foreach(ilECSNodeMappingAssignments::lookupAssignmentsByRefId(
                        $this->getServer()->getServerId(),
                        $this->getMid(),
                        (int) $_REQUEST['tid'],
                        $active_node
                        ) as $cs_id)
                {
                        foreach($cmsTree->getPathId($cs_id) as $path_id)
                        {
                                #$explorer->setExpand($path_id);
                        }
                }

                $explorer->setTargetGet('rref_id');
                $explorer->setSessionExpandVariable('rexpand');

                #if((int) $_REQUEST['rexpand'])
                {
                        $explorer->setExpand((int) $_GET['rexpand']);
                }
                $explorer->setExpandTarget($this->ctrl->getLinkTarget($this,'dEditTree'));
                $explorer->setOutput(0);
                $GLOBALS['tpl']->setVariable('REMOTE_EXPLORER',$explorer->getOutput());

        }

        protected function dInitEditTree()
        {
                include_once './Services/WebServices/ECS/classes/Tree/class.ilECSCmsData.php';
                ilECSCmsData::updateStatus(
                        $this->getServer()->getServerId(),
                        $this->getMid(),
                        (int) $_REQUEST['tid']
                );
                return $this->dEditTree();
        }


        protected function dMap()
        {
                if(!$_POST['lnodes'])
                {
                        ilUtil::sendFailure($this->lng->txt('select_one'),true);
                        $this->ctrl->redirect($this,'dEditTree');
                }

                $ref_id = end($_POST['lnodes']);

                include_once './Services/WebServices/ECS/classes/Mapping/class.ilECSNodeMappingAssignments.php';
                ilECSNodeMappingAssignments::deleteDisconnectableMappings(
                        $this->getServer()->getServerId(),
                        $this->getMid(),
                        (int) $_REQUEST['tid'],
                        $ref_id
                );


                $nodes = (array) $_POST['rnodes'];
                $nodes = (array) array_reverse($nodes);

                include_once './Services/WebServices/ECS/classes/Mapping/class.ilECSNodeMappingAssignment.php';
                include_once './Services/WebServices/ECS/classes/Mapping/class.ilECSNodeMappingAssignments.php';
                include_once './Services/WebServices/ECS/classes/Tree/class.ilECSCmsTree.php';
                foreach($nodes as $cms_id)
                {
                        $assignment = new ilECSNodeMappingAssignment(
                                $this->getServer()->getServerId(),
                                $this->getMid(),
                                (int) $_REQUEST['tid'],
                                (int) $cms_id
                        );
                        $assignment->setRefId($ref_id);
                        $assignment->setObjId(ilObject::_lookupObjId($ref_id));
                        $assignment->enablePositionUpdate(false);
                        $assignment->enableTreeUpdate(false);
                        $assignment->enableTitleUpdate(ilECSNodeMappingAssignments::lookupDefaultTitleUpdate(
                                $this->getServer()->getServerId(),
                                $this->getMid(),
                                (int) $_REQUEST['tid']
                        ));
                        $assignment->update();

                        // Delete subitems mappings for cms subtree
                        $cmsTree = new ilECSCmsTree((int) $_REQUEST['tid']);
                        $childs = $cmsTree->getSubTreeIds($cms_id);

                        ilECSNodeMappingAssignments::deleteMappingsByCsId(
                                $this->getServer()->getServerId(),
                                $this->getMid(),
                                (int) $_REQUEST['tid'],
                                $childs
                        );

                }

                ilECSCmsData::updateStatus(
                        $this->getServer()->getServerId(),
                        $this->getMid(),
                        (int) $_REQUEST['tid']
                );

                // Save parameter cid
                $this->ctrl->setParameter($this,'lid',(int) $ref_id);

                ilUtil::sendSuccess($this->lng->txt('settings_saved'),true);
                $this->ctrl->redirect($this,'dEditTree');
        }

        protected function dMappingOverview()
        {
                $this->setSubTabs(self::TAB_DIRECTORY);
                $GLOBALS['ilTabs']->activateSubTab('dMappingOverview');
                $GLOBALS['ilTabs']->activateTab('ecs_dir_allocation');
        }
        
        

        protected function setTabs()
        {
                global $ilTabs;

                include_once './Services/WebServices/ECS/classes/class.ilECSParticipantSettings.php';
                
                $ilTabs->clearTargets();
                $ilTabs->setBackTarget(
                        $this->lng->txt('ecs_back_settings'),
                        $this->ctrl->getParentReturn($this)
                );
                // Directories are only visible for import type campus managment.
                if(ilECSParticipantSettings::loookupCmsMid($this->getServer()->getServerId()) == $this->getMid())
                {
                        $ilTabs->addTab(
                                'ecs_dir_allocation',
                                $this->lng->txt('ecs_dir_alloc'),
                                $this->ctrl->getLinkTarget($this,'dSettings')
                        );
                }
                
                $ilTabs->addTab(
                        'ecs_crs_allocation',
                        $this->lng->txt('ecs_crs_alloc'),
                        $this->ctrl->getLinkTarget($this,'cStart')
                );
        }

        protected function setSubTabs($a_tab)
        {
                global $ilTabs;

                if($a_tab == self::TAB_DIRECTORY)
                {
                        $ilTabs->addSubTab(
                                'dMappingOverview',
                                $this->lng->txt('ecs_cc_mapping_overview'),
                                $this->ctrl->getLinkTarget($this,'dMappingOverview')
                        );
                        $ilTabs->addSubTab(
                                'dTrees',
                                $this->lng->txt('ecs_cms_dir_tree'),
                                $this->ctrl->getLinkTarget($this,'dTrees')
                        );
                        $ilTabs->addSubTab(
                                'dSettings',
                                $this->lng->txt('settings'),
                                $this->ctrl->getLinkTarget($this,'dSettings')
                        );
                }
                if($a_tab == self::TAB_COURSE)
                {
                        // Check if attributes are available
                        include_once './Services/WebServices/ECS/classes/Course/class.ilECSCourseAttributes.php';
                        $atts = ilECSCourseAttributes::getInstance($this->getServer()->getServerId(), $this->getMid());

                        include_once './Services/WebServices/ECS/classes/Mapping/class.ilECSNodeMappingSettings.php';
                        if(ilECSNodeMappingSettings::getInstanceByServerMid($this->getServer()->getServerId(),$this->getMid())->isCourseAllocationEnabled())
                        {
                                $ilTabs->addSubTab(
                                        'cInitTree',
                                        $this->lng->txt('ecs_cmap_overview'),
                                        $this->ctrl->getLinkTarget($this,'cInitOverview')
                                );
                        }

                        $ilTabs->addSubTab(
                                'cSettings',
                                $this->lng->txt('settings'),
                                $this->ctrl->getLinkTarget($this,'cSettings')
                        );

                }
        }
}
?>