export_question_qti() - Code Metrics - Inspection of "Quiz: Add new question type Multiple Answer Dropdo..." - chamilo/chamilo-lms - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — 1.11.x (#4360)

by Angel Fernando Quiroz

created 2022-08-10 16:29 UTC

export_question_qti() B

↳ Parent: Project

Complexity

Conditions	6
Paths	9

Size

Total Lines	29
Code Lines	20

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	20
c	1
b	0
f	0
dl	0
loc	29
rs	8.9777
cc	6
nc	9
nop	2

<?php

/* For licensing terms, see /license.txt */

/**
 * @author Claro Team <[email protected]>
 * @author Yannick Warnier <[email protected]>
 */
require __DIR__.'/qti2_classes.php';

/**
 * An IMS/QTI item. It corresponds to a single question.
 * This class allows export from Claroline to IMS/QTI2.0 XML format of a single question.
 * It is not usable as-is, but must be subclassed, to support different kinds of questions.
 *
 * Every start_*() and corresponding end_*(), as well as export_*() methods return a string.
 *
 * note: Attached files are NOT exported.
 */
class ImsAssessmentItem
{
    /**
     * @var Ims2Question
     */
    public $question;
    /**
     * @var string
     */
    public $questionIdent;
    /**
     * @var ImsAnswerInterface
     */
    public $answer;

    /**
     * Constructor.
     *
     * @param Ims2Question $question ims2Question object we want to export
     */
    public function __construct($question)
    {
        $this->question = $question;
        $this->answer = $this->question->setAnswer();
        $this->questionIdent = 'QST_'.$question->iid;
    }

    /**
     * Start the XML flow.
     *
     * This opens the <item> block, with correct attributes.
     */
    public function start_item()
    {
        $categoryTitle = '';
        if (!empty($this->question->category)) {
            $category = new TestCategory();
            $category = $category->getCategory($this->question->category);
            if ($category) {

                $categoryTitle = htmlspecialchars(formatExerciseQtiText($category->name));
            }
        }

        return '<assessmentItem xmlns="http://www.imsglobal.org/xsd/imsqti_v2p1"
                xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                xsi:schemaLocation="http://www.imsglobal.org/xsd/imsqti_v2p1 imsqti_v2p1.xsd"
                identifier="'.$this->questionIdent.'"
                title = "'.htmlspecialchars(formatExerciseQtiText($this->question->selectTitle())).'"
                category = "'.$categoryTitle.'"
        >'."\n";
    }

    /**
     * End the XML flow, closing the </item> tag.
     */
    public function end_item()
    {
        return "</assessmentItem>\n";
    }

    /**
     * Start the itemBody.
     */
    public function start_item_body()
    {
        return '  <itemBody>'."\n";
    }

    /**
     * End the itemBody part.
     */
    public function end_item_body()
    {
        return "  </itemBody>\n";
    }

    /**
     * add the response processing template used.
     */
    public function add_response_processing()
    {
        return '  <responseProcessing template="http://www.imsglobal.org/question/qti_v2p1/rptemplates/map_correct"/>'."\n";
    }

    /**
     * Export the question as an IMS/QTI Item.
     *
     * This is a default behaviour, some classes may want to override this.
     *
     * @return string string, the XML flow for an Item
     */
    public function export($standalone = false)
    {
        $head = $foot = '';
        if ($standalone) {
            $head = '<?xml version="1.0" encoding="UTF-8" standalone="no"?>'."\n";
        }

        //TODO understand why answer might be a non-object sometimes
        if (!is_object($this->answer)) {
            return $head;
        }

        return $head
            .$this->start_item()
            .$this->answer->imsExportResponsesDeclaration($this->questionIdent, $this->question)
            .$this->start_item_body()
            .$this->answer->imsExportResponses(
                $this->questionIdent,
                $this->question->question,
                $this->question->description,
                $this->question->getPictureFilename()
            )
            .$this->end_item_body()
            .$this->add_response_processing()
            .$this->end_item()
            .$foot;
    }
}

/**
 * This class represents an entire exercise to be exported in IMS/QTI.
 * It will be represented by a single <section> containing several <item>.
 *
 * Some properties cannot be exported, as IMS does not support them :
 *   - type (one page or multiple pages)
 *   - start_date and end_date
 *   - max_attempts
 *   - show_answer
 *   - anonymous_attempts
 *
 * @author Amand Tihon <[email protected]>
 */
class ImsSection
{
    public $exercise;

    /**
     * Constructor.
     *
     * @param Exercise $exe The Exercise instance to export
     *
     * @author Amand Tihon <[email protected]>
     */
    public function __construct($exe)
    {
        $this->exercise = $exe;
    }

    public function start_section()
    {
        return '<section
            ident = "EXO_'.$this->exercise->selectId().'"
            title = "'.cleanAttribute(formatExerciseQtiDescription($this->exercise->selectTitle())).'"
        >'."\n";
    }

    public function end_section()
    {
        return "</section>\n";
    }

    public function export_duration()
    {
        if ($max_time = $this->exercise->selectTimeLimit()) {
            // return exercise duration in ISO8601 format.
            $minutes = floor($max_time / 60);
            $seconds = $max_time % 60;

            return '<duration>PT'.$minutes.'M'.$seconds."S</duration>\n";
        } else {
            return '';
        }
    }

    /**
     * Export the presentation (Exercise's description).
     *
     * @author Amand Tihon <[email protected]>
     */
    public function export_presentation()
    {
        return "<presentation_material><flow_mat><material>\n"
             .'  <mattext><![CDATA['.formatExerciseQtiDescription($this->exercise->selectDescription())."]]></mattext>\n"
             ."</material></flow_mat></presentation_material>\n";
    }

    /**
     * Export the ordering information.
     * Either sequential, through all questions, or random, with a selected number of questions.
     *
     * @author Amand Tihon <[email protected]>
     */
    public function export_ordering()
    {
        $out = '';
        if ($n = $this->exercise->getShuffle()) {
            $out .= "<selection_ordering>"
                 ."  <selection>\n"
                 ."    <selection_number>".$n."</selection_number>\n"
                 ."  </selection>\n"
                 .'  <order order_type="Random" />'
                 ."\n</selection_ordering>\n";
        } else {
            $out .= '<selection_ordering sequence_type="Normal">'."\n"
                 ."  <selection />\n"
                 ."</selection_ordering>\n";
        }

        return $out;
    }

    /**
     * Export the questions, as a succession of <items>.
     *
     * @author Amand Tihon <[email protected]>
     */
    public function exportQuestions()
    {
        $out = '';
        foreach ($this->exercise->selectQuestionList() as $q) {
            $out .= export_question_qti($q, false);
        }

        return $out;
    }

    /**
     * Export the exercise in IMS/QTI.
     *
     * @param bool $standalone wether it should include XML tag and DTD line
     *
     * @return string string containing the XML flow
     *
     * @author Amand Tihon <[email protected]>
     */
    public function export($standalone)
    {
        $head = $foot = '';
        if ($standalone) {
            $head = '<?xml version = "1.0" encoding = "UTF-8" standalone = "no"?>'."\n"
                  .'<!DOCTYPE questestinterop SYSTEM "ims_qtiasiv2p1.dtd">'."\n"
                  ."<questestinterop>\n";
            $foot = "</questestinterop>\n";
        }

        return $head
             .$this->start_section()
             .$this->export_duration()
             .$this->export_presentation()
             .$this->export_ordering()
             .$this->exportQuestions()
             .$this->end_section()
             .$foot;
    }
}

/*
    Some quick notes on identifiers generation.
    The IMS format requires some blocks, like items, responses, feedbacks, to be uniquely
    identified.
    The unicity is mandatory in a single XML, of course, but it's prefered that the identifier stays
    coherent for an entire site.

    Here's the method used to generate those identifiers.
    Question identifier :: "QST_" + <Question Id from the DB> + "_" + <Question numeric type>
    Response identifier :: <Question identifier> + "_A_" + <Response Id from the DB>
    Condition identifier :: <Question identifier> + "_C_" + <Response Id from the DB>
    Feedback identifier :: <Question identifier> + "_F_" + <Response Id from the DB>
*/
/**
 * Class ImsItem.
 *
 * An IMS/QTI item. It corresponds to a single question.
 * This class allows export from Claroline to IMS/QTI XML format.
 * It is not usable as-is, but must be subclassed, to support different kinds of questions.
 *
 * Every start_*() and corresponding end_*(), as well as export_*() methods return a string.
 *
 * warning: Attached files are NOT exported.
 *
 * @author Amand Tihon <[email protected]>
 */
class ImsItem
{
    public $question;
    public $questionIdent;
    public $answer;

    /**
     * Constructor.
     *
     * @param Question $question the Question object we want to export
     *
     * @author Anamd Tihon
     */
    public function __construct($question)
    {
        $this->question = $question;
        $this->answer = $question->answer;
        $this->questionIdent = 'QST_'.$question->selectId();
    }

    /**
     * Start the XML flow.
     *
     * This opens the <item> block, with correct attributes.
     *
     * @author Amand Tihon <[email protected]>
     */
    public function start_item()
    {
        return '<item title="'.cleanAttribute(formatExerciseQtiDescription($this->question->selectTitle())).'" ident="'.$this->questionIdent.'">'."\n";
    }

    /**
     * End the XML flow, closing the </item> tag.
     *
     * @author Amand Tihon <[email protected]>
     */
    public function end_item()
    {
        return "</item>\n";
    }

    /**
     * Create the opening, with the question itself.
     *
     * This means it opens the <presentation> but doesn't close it, as this is the role of end_presentation().
     * In between, the export_responses from the subclass should have been called.
     *
     * @author Amand Tihon <[email protected]>
     */
    public function start_presentation()
    {
        return '<presentation label="'.$this->questionIdent.'"><flow>'."\n"
            .'<material><mattext>'.formatExerciseQtiDescription($this->question->selectDescription())."</mattext></material>\n";
    }

    /**
     * End the </presentation> part, opened by export_header.
     *
     * @author Amand Tihon <[email protected]>
     */
    public function end_presentation()
    {
        return "</flow></presentation>\n";
    }

    /**
     * Start the response processing, and declare the default variable, SCORE, at 0 in the outcomes.
     *
     * @author Amand Tihon <[email protected]>
     */
    public function start_processing()
    {
        return '<resprocessing><outcomes><decvar vartype="Integer" defaultval="0" /></outcomes>'."\n";
    }

    /**
     * End the response processing part.
     *
     * @author Amand Tihon <[email protected]>
     */
    public function end_processing()
    {
        return "</resprocessing>\n";
    }

    /**
     * Export the question as an IMS/QTI Item.
     *
     * This is a default behaviour, some classes may want to override this.
     *
     * @param bool $standalone Boolean stating if it should be exported as a stand-alone question
     *
     * @return string string, the XML flow for an Item
     *
     * @author Amand Tihon <[email protected]>
     */
    public function export($standalone = false)
    {
        global $charset;
        $head = $foot = '';

        if ($standalone) {
            $head = '<?xml version = "1.0" encoding = "'.$charset.'" standalone = "no"?>'."\n"
                  .'<!DOCTYPE questestinterop SYSTEM "ims_qtiasiv2p1.dtd">'."\n"
                  ."<questestinterop>\n";
            $foot = "</questestinterop>\n";
        }

        return $head
            .$this->start_item()
            .$this->start_presentation()
            .$this->answer->imsExportResponses($this->questionIdent)
            .$this->end_presentation()
            .$this->start_processing()
            .$this->answer->imsExportProcessing($this->questionIdent)
            .$this->end_processing()
            .$this->answer->imsExportFeedback($this->questionIdent)
            .$this->end_item()
            .$foot;
    }
}

/**
 * Send a complete exercise in IMS/QTI format, from its ID.
 *
 * @param int  $exerciseId The exercise to export
 * @param bool $standalone wether it should include XML tag and DTD line
 *
 * @return string XML as a string, or an empty string if there's no exercise with given ID
 */
function export_exercise_to_qti($exerciseId, $standalone = true)
{
    $exercise = new Exercise();
    if (!$exercise->read($exerciseId)) {
        return '';
    }
    $ims = new ImsSection($exercise);

    return $ims->export($standalone);
}

/**
 * Returns the XML flow corresponding to one question.
 *
 * @param int  $questionId
 * @param bool $standalone (ie including XML tag, DTD declaration, etc)
 *
 * @return string
 */
function export_question_qti($questionId, $standalone = true)
{
    $question = new Ims2Question();
    $qst = $question->read($questionId);
    if (!$qst) {

        return '';
    }

    $isValid = $qst instanceof UniqueAnswer
        || $qst instanceof MultipleAnswer

        || $qst instanceof FreeAnswer

        || $qst instanceof MultipleAnswerDropdown

    ;

    if (!$isValid) {
        return '';
    }

    $question->iid = $qst->iid;
    $question->type = $qst->type;
    $question->question = $qst->question;
    $question->description = $qst->description;
    $question->weighting = $qst->weighting;
    $question->position = $qst->position;
    $question->picture = $qst->picture;
    $question->category = $qst->category;
    $ims = new ImsAssessmentItem($question);

    return $ims->export($standalone);
}

/**
 * Clean text like a description.
 */
function formatExerciseQtiDescription($text)
{
    $entities = api_html_entity_decode($text);

    return htmlspecialchars($entities);
}

/**
 * Clean titles.
 *
 * @param $text
 *
 * @return string
 */
function formatExerciseQtiText($text)
{
    return htmlspecialchars($text);
}

/**
 * @param string $text
 *
 * @return string
 */
function cleanAttribute($text)
{
    return $text;
}


1			<?php
2
3			/* For licensing terms, see /license.txt */
4
5			/**
6			* @author Claro Team <[email protected]>
7			* @author Yannick Warnier <[email protected]>
8			*/
9			require __DIR__.'/qti2_classes.php';
10
11			/**
12			* An IMS/QTI item. It corresponds to a single question.
13			* This class allows export from Claroline to IMS/QTI2.0 XML format of a single question.
14			* It is not usable as-is, but must be subclassed, to support different kinds of questions.
15			*
16			* Every start_() and corresponding end_(), as well as export_*() methods return a string.
17			*
18			* note: Attached files are NOT exported.
19			*/
20			class ImsAssessmentItem
21			{
22			/**
23			* @var Ims2Question
24			*/
25			public $question;
26			/**
27			* @var string
28			*/
29			public $questionIdent;
30			/**
31			* @var ImsAnswerInterface
32			*/
33			public $answer;
34
35			/**
36			* Constructor.
37			*
38			* @param Ims2Question $question ims2Question object we want to export
39			*/
40			public function __construct($question)
41			{
42			$this->question = $question;
43			$this->answer = $this->question->setAnswer();
44			$this->questionIdent = 'QST_'.$question->iid;
45			}
46
47			/**
48			* Start the XML flow.
49			*
50			* This opens the <item> block, with correct attributes.
51			*/
52			public function start_item()
53			{
54			$categoryTitle = '';
55			if (!empty($this->question->category)) {
56			$category = new TestCategory();
57			$category = $category->getCategory($this->question->category);
58			if ($category) {
			0 ignored issues – show introduced 2018-10-19 10:24 UTC by Report Bug Copy Issue Report `$category` is of type `TestCategory`, thus it always evaluated to `true`. Loading history...
59			$categoryTitle = htmlspecialchars(formatExerciseQtiText($category->name));
60			}
61			}
62
63			return '<assessmentItem xmlns="http://www.imsglobal.org/xsd/imsqti_v2p1"
64			xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
65			xsi:schemaLocation="http://www.imsglobal.org/xsd/imsqti_v2p1 imsqti_v2p1.xsd"
66			identifier="'.$this->questionIdent.'"
67			title = "'.htmlspecialchars(formatExerciseQtiText($this->question->selectTitle())).'"
68			category = "'.$categoryTitle.'"
69			>'."\n";
70			}
71
72			/**
73			* End the XML flow, closing the </item> tag.
74			*/
75			public function end_item()
76			{
77			return "</assessmentItem>\n";
78			}
79
80			/**
81			* Start the itemBody.
82			*/
83			public function start_item_body()
84			{
85			return ' <itemBody>'."\n";
86			}
87
88			/**
89			* End the itemBody part.
90			*/
91			public function end_item_body()
92			{
93			return " </itemBody>\n";
94			}
95
96			/**
97			* add the response processing template used.
98			*/
99			public function add_response_processing()
100			{
101			return ' <responseProcessing template="http://www.imsglobal.org/question/qti_v2p1/rptemplates/map_correct"/>'."\n";
102			}
103
104			/**
105			* Export the question as an IMS/QTI Item.
106			*
107			* This is a default behaviour, some classes may want to override this.
108			*
109			* @return string string, the XML flow for an Item
110			*/
111			public function export($standalone = false)
112			{
113			$head = $foot = '';
114			if ($standalone) {
115			$head = '<?xml version="1.0" encoding="UTF-8" standalone="no"?>'."\n";
116			}
117
118			//TODO understand why answer might be a non-object sometimes
119			if (!is_object($this->answer)) {
120			return $head;
121			}
122
123			return $head
124			.$this->start_item()
125			.$this->answer->imsExportResponsesDeclaration($this->questionIdent, $this->question)
126			.$this->start_item_body()
127			.$this->answer->imsExportResponses(
128			$this->questionIdent,
129			$this->question->question,
130			$this->question->description,
131			$this->question->getPictureFilename()
132			)
133			.$this->end_item_body()
134			.$this->add_response_processing()
135			.$this->end_item()
136			.$foot;
137			}
138			}
139
140			/**
141			* This class represents an entire exercise to be exported in IMS/QTI.
142			* It will be represented by a single <section> containing several <item>.
143			*
144			* Some properties cannot be exported, as IMS does not support them :
145			* - type (one page or multiple pages)
146			* - start_date and end_date
147			* - max_attempts
148			* - show_answer
149			* - anonymous_attempts
150			*
151			* @author Amand Tihon <[email protected]>
152			*/
153			class ImsSection
154			{
155			public $exercise;
156
157			/**
158			* Constructor.
159			*
160			* @param Exercise $exe The Exercise instance to export
161			*
162			* @author Amand Tihon <[email protected]>
163			*/
164			public function __construct($exe)
165			{
166			$this->exercise = $exe;
167			}
168
169			public function start_section()
170			{
171			return '<section
172			ident = "EXO_'.$this->exercise->selectId().'"
173			title = "'.cleanAttribute(formatExerciseQtiDescription($this->exercise->selectTitle())).'"
174			>'."\n";
175			}
176
177			public function end_section()
178			{
179			return "</section>\n";
180			}
181
182			public function export_duration()
183			{
184			if ($max_time = $this->exercise->selectTimeLimit()) {
185			// return exercise duration in ISO8601 format.
186			$minutes = floor($max_time / 60);
187			$seconds = $max_time % 60;
188
189			return '<duration>PT'.$minutes.'M'.$seconds."S</duration>\n";
190			} else {
191			return '';
192			}
193			}
194
195			/**
196			* Export the presentation (Exercise's description).
197			*
198			* @author Amand Tihon <[email protected]>
199			*/
200			public function export_presentation()
201			{
202			return "<presentation_material><flow_mat><material>\n"
203			.' <mattext><![CDATA['.formatExerciseQtiDescription($this->exercise->selectDescription())."]]></mattext>\n"
204			."</material></flow_mat></presentation_material>\n";
205			}
206
207			/**
208			* Export the ordering information.
209			* Either sequential, through all questions, or random, with a selected number of questions.
210			*
211			* @author Amand Tihon <[email protected]>
212			*/
213			public function export_ordering()
214			{
215			$out = '';
216			if ($n = $this->exercise->getShuffle()) {
217			$out .= "<selection_ordering>"
218			." <selection>\n"
219			." <selection_number>".$n."</selection_number>\n"
220			." </selection>\n"
221			.' <order order_type="Random" />'
222			."\n</selection_ordering>\n";
223			} else {
224			$out .= '<selection_ordering sequence_type="Normal">'."\n"
225			." <selection />\n"
226			."</selection_ordering>\n";
227			}
228
229			return $out;
230			}
231
232			/**
233			* Export the questions, as a succession of <items>.
234			*
235			* @author Amand Tihon <[email protected]>
236			*/
237			public function exportQuestions()
238			{
239			$out = '';
240			foreach ($this->exercise->selectQuestionList() as $q) {
241			$out .= export_question_qti($q, false);
242			}
243
244			return $out;
245			}
246
247			/**
248			* Export the exercise in IMS/QTI.
249			*
250			* @param bool $standalone wether it should include XML tag and DTD line
251			*
252			* @return string string containing the XML flow
253			*
254			* @author Amand Tihon <[email protected]>
255			*/
256			public function export($standalone)
257			{
258			$head = $foot = '';
259			if ($standalone) {
260			$head = '<?xml version = "1.0" encoding = "UTF-8" standalone = "no"?>'."\n"
261			.'<!DOCTYPE questestinterop SYSTEM "ims_qtiasiv2p1.dtd">'."\n"
262			."<questestinterop>\n";
263			$foot = "</questestinterop>\n";
264			}
265
266			return $head
267			.$this->start_section()
268			.$this->export_duration()
269			.$this->export_presentation()
270			.$this->export_ordering()
271			.$this->exportQuestions()
272			.$this->end_section()
273			.$foot;
274			}
275			}
276
277			/*
278			Some quick notes on identifiers generation.
279			The IMS format requires some blocks, like items, responses, feedbacks, to be uniquely
280			identified.
281			The unicity is mandatory in a single XML, of course, but it's prefered that the identifier stays
282			coherent for an entire site.
283
284			Here's the method used to generate those identifiers.
285			Question identifier :: "QST_" + <Question Id from the DB> + "_" + <Question numeric type>
286			Response identifier :: <Question identifier> + "_A_" + <Response Id from the DB>
287			Condition identifier :: <Question identifier> + "_C_" + <Response Id from the DB>
288			Feedback identifier :: <Question identifier> + "_F_" + <Response Id from the DB>
289			*/
290			/**
291			* Class ImsItem.
292			*
293			* An IMS/QTI item. It corresponds to a single question.
294			* This class allows export from Claroline to IMS/QTI XML format.
295			* It is not usable as-is, but must be subclassed, to support different kinds of questions.
296			*
297			* Every start_() and corresponding end_(), as well as export_*() methods return a string.
298			*
299			* warning: Attached files are NOT exported.
300			*
301			* @author Amand Tihon <[email protected]>
302			*/
303			class ImsItem
304			{
305			public $question;
306			public $questionIdent;
307			public $answer;
308
309			/**
310			* Constructor.
311			*
312			* @param Question $question the Question object we want to export
313			*
314			* @author Anamd Tihon
315			*/
316			public function __construct($question)
317			{
318			$this->question = $question;
319			$this->answer = $question->answer;
320			$this->questionIdent = 'QST_'.$question->selectId();
321			}
322
323			/**
324			* Start the XML flow.
325			*
326			* This opens the <item> block, with correct attributes.
327			*
328			* @author Amand Tihon <[email protected]>
329			*/
330			public function start_item()
331			{
332			return '<item title="'.cleanAttribute(formatExerciseQtiDescription($this->question->selectTitle())).'" ident="'.$this->questionIdent.'">'."\n";
333			}
334
335			/**
336			* End the XML flow, closing the </item> tag.
337			*
338			* @author Amand Tihon <[email protected]>
339			*/
340			public function end_item()
341			{
342			return "</item>\n";
343			}
344
345			/**
346			* Create the opening, with the question itself.
347			*
348			* This means it opens the <presentation> but doesn't close it, as this is the role of end_presentation().
349			* In between, the export_responses from the subclass should have been called.
350			*
351			* @author Amand Tihon <[email protected]>
352			*/
353			public function start_presentation()
354			{
355			return '<presentation label="'.$this->questionIdent.'"><flow>'."\n"
356			.'<material><mattext>'.formatExerciseQtiDescription($this->question->selectDescription())."</mattext></material>\n";
357			}
358
359			/**
360			* End the </presentation> part, opened by export_header.
361			*
362			* @author Amand Tihon <[email protected]>
363			*/
364			public function end_presentation()
365			{
366			return "</flow></presentation>\n";
367			}
368
369			/**
370			* Start the response processing, and declare the default variable, SCORE, at 0 in the outcomes.
371			*
372			* @author Amand Tihon <[email protected]>
373			*/
374			public function start_processing()
375			{
376			return '<resprocessing><outcomes><decvar vartype="Integer" defaultval="0" /></outcomes>'."\n";
377			}
378
379			/**
380			* End the response processing part.
381			*
382			* @author Amand Tihon <[email protected]>
383			*/
384			public function end_processing()
385			{
386			return "</resprocessing>\n";
387			}
388
389			/**
390			* Export the question as an IMS/QTI Item.
391			*
392			* This is a default behaviour, some classes may want to override this.
393			*
394			* @param bool $standalone Boolean stating if it should be exported as a stand-alone question
395			*
396			* @return string string, the XML flow for an Item
397			*
398			* @author Amand Tihon <[email protected]>
399			*/
400			public function export($standalone = false)
401			{
402			global $charset;
403			$head = $foot = '';
404
405			if ($standalone) {
406			$head = '<?xml version = "1.0" encoding = "'.$charset.'" standalone = "no"?>'."\n"
407			.'<!DOCTYPE questestinterop SYSTEM "ims_qtiasiv2p1.dtd">'."\n"
408			."<questestinterop>\n";
409			$foot = "</questestinterop>\n";
410			}
411
412			return $head
413			.$this->start_item()
414			.$this->start_presentation()
415			.$this->answer->imsExportResponses($this->questionIdent)
416			.$this->end_presentation()
417			.$this->start_processing()
418			.$this->answer->imsExportProcessing($this->questionIdent)
419			.$this->end_processing()
420			.$this->answer->imsExportFeedback($this->questionIdent)
421			.$this->end_item()
422			.$foot;
423			}
424			}
425
426			/**
427			* Send a complete exercise in IMS/QTI format, from its ID.
428			*
429			* @param int $exerciseId The exercise to export
430			* @param bool $standalone wether it should include XML tag and DTD line
431			*
432			* @return string XML as a string, or an empty string if there's no exercise with given ID
433			*/
434			function export_exercise_to_qti($exerciseId, $standalone = true)
435			{
436			$exercise = new Exercise();
437			if (!$exercise->read($exerciseId)) {
438			return '';
439			}
440			$ims = new ImsSection($exercise);
441
442			return $ims->export($standalone);
443			}
444
445			/**
446			* Returns the XML flow corresponding to one question.
447			*
448			* @param int $questionId
449			* @param bool $standalone (ie including XML tag, DTD declaration, etc)
450			*
451			* @return string
452			*/
453			function export_question_qti($questionId, $standalone = true)
454			{
455			$question = new Ims2Question();
456			$qst = $question->read($questionId);
457			if (!$qst) {
			0 ignored issues – show introduced 2018-10-19 10:24 UTC by Report Bug Copy Issue Report `$qst` is of type `Ims2Question`, thus it always evaluated to `true`. Loading history...
458			return '';
459			}
460
461			$isValid = $qst instanceof UniqueAnswer
462			\|\| $qst instanceof MultipleAnswer
			0 ignored issues – show introduced 2019-05-07 17:40 UTC by Report Bug Copy Issue Report `$qst` is never a sub-type of `MultipleAnswer`. Loading history...
463			\|\| $qst instanceof FreeAnswer
			0 ignored issues – show introduced 2019-05-07 17:40 UTC by Report Bug Copy Issue Report `$qst` is never a sub-type of `FreeAnswer`. Loading history...
464			\|\| $qst instanceof MultipleAnswerDropdown
			0 ignored issues – show introduced 2022-08-10 16:37 UTC by Report Bug Copy Issue Report `$qst` is never a sub-type of `MultipleAnswerDropdown`. Loading history...
465			;
466
467			if (!$isValid) {
468			return '';
469			}
470
471			$question->iid = $qst->iid;
472			$question->type = $qst->type;
473			$question->question = $qst->question;
474			$question->description = $qst->description;
475			$question->weighting = $qst->weighting;
476			$question->position = $qst->position;
477			$question->picture = $qst->picture;
478			$question->category = $qst->category;
479			$ims = new ImsAssessmentItem($question);
480
481			return $ims->export($standalone);
482			}
483
484			/**
485			* Clean text like a description.
486			*/
487			function formatExerciseQtiDescription($text)
488			{
489			$entities = api_html_entity_decode($text);
490
491			return htmlspecialchars($entities);
492			}
493
494			/**
495			* Clean titles.
496			*
497			* @param $text
498			*
499			* @return string
500			*/
501			function formatExerciseQtiText($text)
502			{
503			return htmlspecialchars($text);
504			}
505
506			/**
507			* @param string $text
508			*
509			* @return string
510			*/
511			function cleanAttribute($text)
512			{
513			return $text;
514			}
515

chamilo / chamilo-lms

Pull Request — 1.11.x (#4360)

export_question_qti() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like