class.ilObjAssessmentFolder.php

Go to the documentation of this file.

<?php
/* Copyright (c) 1998-2013 ILIAS open source, Extended GPL, see docs/LICENSE */
 
require_once "./Services/Object/classes/class.ilObject.php";
require_once 'Modules/TestQuestionPool/classes/class.ilAssQuestionProcessLocker.php';
 
class ilObjAssessmentFolder extends ilObject
{
        const ADDITIONAL_QUESTION_CONTENT_EDITING_MODE_PAGE_OBJECT_DISABLED = 0;
        const ADDITIONAL_QUESTION_CONTENT_EDITING_MODE_PAGE_OBJECT_ENABLED = 1;
 
        const ASS_PROC_LOCK_MODE_NONE = 'none';
        const ASS_PROC_LOCK_MODE_FILE = 'file';
        const ASS_PROC_LOCK_MODE_DB = 'db';
 
        const SETTINGS_KEY_SKL_TRIG_NUM_ANSWERS_BARRIER = 'ass_skl_trig_num_answ_barrier';
        const DEFAULT_SKL_TRIG_NUM_ANSWERS_BARRIER = 1;
        
        var $setting;
        
        public function __construct($a_id = 0,$a_call_by_reference = true)
        {
                include_once "./Services/Administration/classes/class.ilSetting.php";
                $this->setting = new ilSetting("assessment");
                $this->type = "assf";
                parent::__construct($a_id,$a_call_by_reference);
        }
 
        function update()
        {
                if (!parent::update())
                {
                        return false;
                }
 
                // put here object specific stuff
 
                return true;
        }
 
        public static function getSkillTriggerAnswerNumberBarrier()
        {
                require_once 'Services/Administration/classes/class.ilSetting.php';
                $assSettings = new ilSetting('assessment');
                
                return $assSettings->get(
                        self::SETTINGS_KEY_SKL_TRIG_NUM_ANSWERS_BARRIER,
                        self::DEFAULT_SKL_TRIG_NUM_ANSWERS_BARRIER
                );
        }
 
        function delete()
        {
                // always call parent delete function first!!
                if (!parent::delete())
                {
                        return false;
                }
 
                //put here your module specific stuff
 
                return true;
        }
 
        function _enableAssessmentLogging($a_enable)
        {
                $setting = new ilSetting("assessment");
 
                if ($a_enable)
                {
                        $setting->set("assessment_logging", 1);
                }
                else
                {
                        $setting->set("assessment_logging", 0);
                }
        }
 
        function _setLogLanguage($a_language)
        {
                $setting = new ilSetting("assessment");
 
                $setting->set("assessment_log_language", $a_language);
        }
 
        public static function _enabledAssessmentLogging()
        {
                $setting = new ilSetting("assessment");
 
                return (boolean) $setting->get("assessment_logging");
        }
        
        public static function _getForbiddenQuestionTypes()
        {
                $setting = new ilSetting("assessment");
                $types = $setting->get("forbidden_questiontypes");
                $result = array();
                if (strlen(trim($types)) == 0)
                {
                        $result = array();
                }
                else
                {
                        $result = unserialize($types);
                }
                return $result;
        }
 
        function _setForbiddenQuestionTypes($a_types)
        {
                $setting = new ilSetting("assessment");
                $types = "";
                if (is_array($a_types) && (count($a_types) > 0))
                {
                        $types = serialize($a_types);
                }
                $setting->set("forbidden_questiontypes", $types);
        }
        
        public static function _getLogLanguage()
        {
                $setting = new ilSetting("assessment");
 
                $lang = $setting->get("assessment_log_language");
                if (strlen($lang) == 0)
                {
                        $lang = "en";
                }
                return $lang;
        }
        
        public static function _mananuallyScoreableQuestionTypesExists()
        {
                if( count(self::_getManualScoring()) > 0 )
                {
                        return true;
                }
                
                return false;
        }
 
        public static function _getManualScoring()
        {
                $setting = new ilSetting("assessment");
 
                $types = $setting->get("assessment_manual_scoring");
                return explode(",", $types);
        }
 
        public static function _getManualScoringTypes()
        {
                global $ilDB;
                
                $result = $ilDB->query("SELECT * FROM qpl_qst_type");
                $dbtypes = array();
                while ($row = $ilDB->fetchAssoc($result))
                {
                        $dbtypes[$row["question_type_id"]] = $row["type_tag"];
                }
                $setting = new ilSetting("assessment");
                $types = $setting->get("assessment_manual_scoring");
                $ids = explode(",", $types);
                foreach ($ids as $key => $value)
                {
                        $ids[$key] = $dbtypes[$value];
                }
                return $ids;
        }
 
        function _setManualScoring($type_ids)
        {
                $setting = new ilSetting("assessment");
                if ((!is_array($type_ids)) || (count($type_ids) == 0))
                {
                        $setting->delete("assessment_manual_scoring");
                }
                else
                {
                        $setting->set("assessment_manual_scoring", implode($type_ids, ","));
                }
        }
 
        public static function getScoringAdjustableQuestions()
        {
                $setting = new ilSetting("assessment");
 
                $types = $setting->get("assessment_scoring_adjustment");
                return explode(",", $types);
        }
        
        public static function setScoringAdjustableQuestions($type_ids)
        {
                $setting = new ilSetting("assessment");
                if ((!is_array($type_ids)) || (count($type_ids) == 0))
                {
                        $setting->delete("assessment_scoring_adjustment");
                }
                else
                {
                        $setting->set("assessment_scoring_adjustment", implode($type_ids, ","));
                }
        }
 
        public static function getScoringAdjustmentEnabled()
        {
                $setting = new ilSetting("assessment");
                return $setting->get('assessment_adjustments_enabled');
        }
 
        public static function setScoringAdjustmentEnabled($active)
        {
                $setting = new ilSetting('assessment');
                $setting->set('assessment_adjustments_enabled', (bool) $active);
        }
 
        public static function _addLog($user_id, $object_id, $logtext, $question_id = "", $original_id = "", $test_only = FALSE, $test_ref_id = NULL)
        {
                global $ilUser, $ilDB;
                if (strlen($question_id) == 0) $question_id = NULL;
                if (strlen($original_id) == 0) $original_id = NULL;
                if (strlen($test_ref_id) == 0) $test_ref_id = NULL;
                $only = ($test_only == TRUE) ? 1 : 0;
                $next_id = $ilDB->nextId('ass_log');
                $affectedRows = $ilDB->manipulateF("INSERT INTO ass_log (ass_log_id, user_fi, obj_fi, logtext, question_fi, original_fi, test_only, ref_id, tstamp) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s)",
                        array('integer', 'integer', 'integer', 'text', 'integer', 'integer', 'text', 'integer', 'integer'),
                        array(
                                $next_id,
                                $user_id,
                                $object_id,
                                $logtext,
                                $question_id,
                                $original_id,
                                $only,
                                $test_ref_id,
                                time()
                        )
                );
        }
        
        public static function getLog($ts_from, $ts_to, $test_id, $test_only = FALSE)
        {
                global $ilDB;
                
                $log = array();
                if ($test_only == TRUE)
                {
                        $result = $ilDB->queryF("SELECT * FROM ass_log WHERE obj_fi = %s AND tstamp > %s AND tstamp < %s AND test_only = %s ORDER BY tstamp",
                                array('integer','integer','integer','text'),
                                array(
                                        $test_id,
                                        $ts_from,
                                        $ts_to,
                                        1
                                )
                        );
                }
                else
                {
                        $result = $ilDB->queryF("SELECT * FROM ass_log WHERE obj_fi = %s AND tstamp > %s AND tstamp < %s ORDER BY tstamp",
                                array('integer','integer','integer'),
                                array(
                                        $test_id,
                                        $ts_from,
                                        $ts_to
                                )
                        );
                }
                while ($row = $ilDB->fetchAssoc($result))
                {
                        if (!array_key_exists($row["tstamp"], $log))
                        {
                                $log[$row["tstamp"]] = array();
                        }
                        array_push($log[$row["tstamp"]], $row);
                }
                krsort($log);
                // flatten array
                $log_array = array();
                foreach ($log as $key => $value)
                {
                        foreach ($value as $index => $row)
                        {
                                array_push($log_array, $row);
                        }
                }
                return $log_array;
        }
        
        public static function _getLog($ts_from, $ts_to, $test_id, $test_only = FALSE)
        {
                global $ilDB;
                
                $log = array();
                if ($test_only == TRUE)
                {
                        $result = $ilDB->queryF("SELECT * FROM ass_log WHERE obj_fi = %s AND tstamp > %s AND tstamp < %s AND test_only = %s ORDER BY tstamp",
                                array('integer', 'integer', 'integer', 'text'),
                                array($test_id, $ts_from, $ts_to, 1)
                        );
                }
                else
                {
                        $result = $ilDB->queryF("SELECT * FROM ass_log WHERE obj_fi = %s AND tstamp > %s AND tstamp < %s ORDER BY tstamp",
                                array('integer', 'integer', 'integer'),
                                array($test_id, $ts_from, $ts_to)
                        );
                }
                while ($row = $ilDB->fetchAssoc($result))
                {
                        if (!array_key_exists($row["tstamp"], $log))
                        {
                                $log[$row["tstamp"]] = array();
                        }
                        $type_href = "";
                        if (array_key_exists("ref_id", $row))
                        {
                                if ($row["ref_id"] > 0)
                                {
                                        $type = ilObject::_lookupType($row['ref_id'], true);
                                        switch ($type)
                                        {
                                                case "tst":
                                                        $type_href = sprintf("goto.php?target=tst_%s&amp;client_id=" . CLIENT_ID, $row["ref_id"]);
                                                        break;
                                                case "cat":
                                                        $type_href = sprintf("goto.php?target=cat_%s&amp;client_id=" . CLIENT_ID, $row["ref_id"]);
                                                        break;
                                        }
                                }
                        }
                        $row["href"] = $type_href;
                        array_push($log[$row["tstamp"]], $row);
                }
                krsort($log);
                // flatten array
                $log_array = array();
                foreach ($log as $key => $value)
                {
                        foreach ($value as $index => $row)
                        {
                                array_push($log_array, $row);
                        }
                }
                return $log_array;
        }
        
        function getNrOfLogEntries($test_obj_id)
        {
                global $ilDB;
                $result = $ilDB->queryF("SELECT COUNT(obj_fi) logcount FROM ass_log WHERE obj_fi = %s",
                        array('integer'),
                        array($test_obj_id)
                );
                if ($result->numRows())
                {
                        $row = $ilDB->fetchAssoc($result);
                        return $row["logcount"];
                }
                else
                {
                        return 0;
                }
        }
        
        function getFullPath($ref_id)
        {
                global $tree;
                $path = $tree->getPathFull($ref_id);
                $pathelements = array();
                foreach ($path as $id => $data)
                {
                        if ($id == 0)
                        {
                                array_push($pathelements, ilUtil::prepareFormOutput($this->lng->txt("repository")));
                        }
                        else
                        {
                                array_push($pathelements, "<a href=\"./goto.php?target=" . $data["type"] . "_" . $data["ref_id"] . "&amp;client=" . CLIENT_ID . "\">" .
                                        ilUtil::prepareFormOutput($data["title"]) . "</a>");
                        }
                }
                return implode("&nbsp;&gt;&nbsp;", $pathelements);
        }
        
        function deleteLogEntries($a_array)
        {
                global $ilDB;
                global $ilUser;
                
                foreach ($a_array as $object_id)
                {
                        $affectedRows = $ilDB->manipulateF("DELETE FROM ass_log WHERE obj_fi = %s",
                                array('integer'),
                                array($object_id)
                        );
                        self::_addLog($ilUser->getId(), $object_id, $this->lng->txt("assessment_log_deleted"));
                }
        }
        
        public static function isAdditionalQuestionContentEditingModePageObjectEnabled()
        {
                require_once 'Modules/TestQuestionPool/classes/class.assQuestion.php';
                
                global $ilSetting;
                
                $isPageEditorEnabled = $ilSetting->get(
                                'enable_tst_page_edit', self::ADDITIONAL_QUESTION_CONTENT_EDITING_MODE_PAGE_OBJECT_DISABLED
                );
                
                return $isPageEditorEnabled;
        }
        
        public function getAssessmentProcessLockMode()
        {
                return $this->setting->get('ass_process_lock_mode', self::ASS_PROC_LOCK_MODE_NONE);
        }
 
        public function setAssessmentProcessLockMode($lockMode)
        {
                $this->setting->set('ass_process_lock_mode', $lockMode);
        }
        
        public static function getValidAssessmentProcessLockModes()
        {
                return array(self::ASS_PROC_LOCK_MODE_NONE, self::ASS_PROC_LOCK_MODE_FILE, self::ASS_PROC_LOCK_MODE_DB);
        }
        
        public function getSkillTriggeringNumAnswersBarrier()
        {
                return $this->setting->get(
                        'ass_skl_trig_num_answ_barrier', self::DEFAULT_SKL_TRIG_NUM_ANSWERS_BARRIER
                );
        }
        
        public function setSkillTriggeringNumAnswersBarrier($skillTriggeringNumAnswersBarrier)
        {
                $this->setting->set('ass_skl_trig_num_answ_barrier', $skillTriggeringNumAnswersBarrier);
        }
 
        public function setExportEssayQuestionsWithHtml($value)
        {
                $this->setting->set('export_essay_qst_with_html', $value);
        }
 
        public function getExportEssayQuestionsWithHtml()
        {
                return $this->setting->get('export_essay_qst_with_html');
        }
        
        public function fetchScoringAdjustableTypes($allQuestionTypes)
        {
                require_once 'Modules/TestQuestionPool/classes/class.assQuestionGUI.php';
                $scoringAdjustableQuestionTypes = array();
                
                foreach($allQuestionTypes as $type => $typeData)
                {
                        $questionGui = assQuestionGUI::_getQuestionGUI($typeData['type_tag']);
                        
                        if( $this->questionSupportsScoringAdjustment($questionGui) )
                        {
                                $scoringAdjustableQuestionTypes[$type] = $typeData;
                        }
                }
                
                return $scoringAdjustableQuestionTypes;
        }
        
        private function questionSupportsScoringAdjustment(\assQuestionGUI $question_object)
        {
                return ($question_object instanceof ilGuiQuestionScoringAdjustable
                        || $question_object instanceof ilGuiAnswerScoringAdjustable)
                && ($question_object->object instanceof ilObjQuestionScoringAdjustable
                        || $question_object->object instanceof ilObjAnswerScoringAdjustable);
        }
}