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;
    
    public $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);
    }

    public 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
        );
    }

    public function delete()
    {
        // always call parent delete function first!!
        if (!parent::delete()) {
            return false;
        }

        //put here your module specific stuff

        return true;
    }

    public function _enableAssessmentLogging($a_enable)
    {
        $setting = new ilSetting("assessment");

        if ($a_enable) {
            $setting->set("assessment_logging", 1);
        } else {
            $setting->set("assessment_logging", 0);
        }
    }

    public 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;
    }

    public 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 $DIC;
        $ilDB = $DIC['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;
    }

    public 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 $DIC;
        $ilUser = $DIC['ilUser'];
        $ilDB = $DIC['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 $DIC;
        $ilDB = $DIC['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 $DIC;
        $ilDB = $DIC['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;
    }
    
    public function getNrOfLogEntries($test_obj_id)
    {
        global $DIC;
        $ilDB = $DIC['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;
        }
    }
    
    public function getFullPath($ref_id)
    {
        global $DIC;
        $tree = $DIC['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);
    }
    
    public function deleteLogEntries($a_array)
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];
        $ilUser = $DIC['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 $DIC;
        $ilSetting = $DIC['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);
    }
}