class.assOrderingQuestionGUI.php

Go to the documentation of this file.

<?php
/* Copyright (c) 1998-2013 ILIAS open source, Extended GPL, see docs/LICENSE */
 
require_once './Modules/TestQuestionPool/classes/class.assQuestionGUI.php';
require_once './Modules/TestQuestionPool/interfaces/interface.ilGuiQuestionScoringAdjustable.php';
require_once './Modules/TestQuestionPool/interfaces/interface.ilGuiAnswerScoringAdjustable.php';
require_once './Modules/Test/classes/inc.AssessmentConstants.php';
 
class assOrderingQuestionGUI extends assQuestionGUI implements ilGuiQuestionScoringAdjustable, ilGuiAnswerScoringAdjustable
{
        public $object;
        
        public $old_ordering_depth = array();
        public $leveled_ordering = array();
 
        private $clearAnswersOnWritingPostDataEnabled;
        
        public function __construct($id = -1)
        {
                parent::__construct();
                include_once "./Modules/TestQuestionPool/classes/class.assOrderingQuestion.php";
                $this->object = new assOrderingQuestion();
                if ($id >= 0)
                {
                        $this->object->loadFromDb($id);
                }
                $this->clearAnswersOnWritingPostDataEnabled = false;
        }
 
        public function setClearAnswersOnWritingPostDataEnabled($clearAnswersOnWritingPostDataEnabled)
        {
                $this->clearAnswersOnWritingPostDataEnabled = $clearAnswersOnWritingPostDataEnabled;
        }
 
        public function isClearAnswersOnWritingPostDataEnabled()
        {
                return $this->clearAnswersOnWritingPostDataEnabled;
        }
 
        public function changeToPictures()
        {
                if($this->object->getOrderingType() != OQ_NESTED_PICTURES && $this->object->getOrderingType() != OQ_PICTURES)
                {
                        $this->setClearAnswersOnWritingPostDataEnabled(true);
                }
                
                $form = $this->buildEditForm();
                $form->setValuesByPost();
                $this->persistAuthoringForm($form);
                
                $this->object->setOrderingType(OQ_PICTURES);
                $this->object->saveToDb();
                
                $form->ensureReprintableFormStructure($this->object);
                $this->renderEditForm($form);
        }
 
        public function changeToText()
        {
                if($this->object->getOrderingType() != OQ_NESTED_TERMS && $this->object->getOrderingType() != OQ_TERMS)
                {
                        $this->setClearAnswersOnWritingPostDataEnabled(true);
                }
                
                $form = $this->buildEditForm();
                $form->setValuesByPost();
                $this->persistAuthoringForm($form);
 
                $this->object->setOrderingType(OQ_TERMS);
                $this->object->saveToDb();
                
                $form->ensureReprintableFormStructure($this->object);
                $this->renderEditForm($form);
        }
 
        public function orderNestedTerms()
        {
                $this->writePostData(true);
                $this->object->setOrderingType(OQ_NESTED_TERMS);
                $this->object->saveToDb();
                
                $this->renderEditForm($this->buildEditForm());
        }
 
        public function orderNestedPictures()
        {
                $this->writePostData(true);
                $this->object->setOrderingType(OQ_NESTED_PICTURES);
                $this->object->saveToDb();
                
                $this->renderEditForm($this->buildEditForm());
        }
        
        public function removeElementImage()
        {
                $orderingInput = $this->object->buildOrderingImagesInputGui();
                $this->object->initOrderingElementAuthoringProperties($orderingInput);
 
                $form = $this->buildEditForm();
                $form->replaceFormItemByPostVar($orderingInput);
                $form->setValuesByPost();
                
                $replacementElemList = ilAssOrderingElementList::buildInstance(
                        $this->object->getId(), array()
                );
                
                $storedElementList = $this->object->getOrderingElementList();
                
                foreach($orderingInput->getElementList($this->object->getId()) as $submittedElement)
                {
                        if( $submittedElement->isImageRemovalRequest() )
                        {
                                if( $this->object->isImageFileStored($submittedElement->getContent()) )
                                {
                                        $this->object->dropImageFile($submittedElement->getContent());
                                }
                                
                                $submittedElement->setContent(null);
                        }
                        
                        if( $storedElementList->elementExistByRandomIdentifier($submittedElement->getRandomIdentifier()) )
                        {
                                $storedElement = $storedElementList->getElementByRandomIdentifier(
                                        $submittedElement->getRandomIdentifier()
                                );
                                
                                $submittedElement->setSolutionIdentifier($storedElement->getSolutionIdentifier());
                                $submittedElement->setIndentation($storedElement->getIndentation());
                        }
                        
                        $replacementElemList->addElement($submittedElement);
                }
                
                $replacementElemList->saveToDb();
                
                $orderingInput->setElementList( $replacementElemList );
                $this->renderEditForm($form);
        }
 
        public function uploadElementImage()
        {
                $orderingInput = $this->object->buildOrderingImagesInputGui();
                $this->object->initOrderingElementAuthoringProperties($orderingInput);
                
                $form = $this->buildEditForm();
                $form->replaceFormItemByPostVar($orderingInput);
                $form->setValuesByPost();
                
                if(!$orderingInput->checkInput())
                {
                        ilUtil::sendFailure($this->lng->txt('form_input_not_valid'));
                }
                
                $this->writeAnswerSpecificPostData($form);
                $this->object->getOrderingElementList()->saveToDb();
                $orderingInput->setElementList($this->object->getOrderingElementList());
                
                $this->renderEditForm($form);
        }
 
        public function writeQuestionSpecificPostData(ilPropertyFormGUI $form)
        {
                $this->object->setThumbGeometry( $_POST["thumb_geometry"] );
                $this->object->setElementHeight( $_POST["element_height"] );
                //$this->object->setOrderingType( $_POST["ordering_type"] );
                $this->object->setPoints($_POST["points"]);
        }
 
        public function writeAnswerSpecificPostData(ilPropertyFormGUI $form)
        {
                if( !is_array($_POST[assOrderingQuestion::ORDERING_ELEMENT_FORM_FIELD_POSTVAR]) )
                {
                        throw new ilTestQuestionPoolException('form submit request missing the form submit!?');
                }
                
                #$submittedElementList = $this->object->fetchSolutionListFromFormSubmissionData($_POST);
                $submittedElementList = $this->object->fetchSolutionListFromSubmittedForm($form);
                
                $replacementElementList = new ilAssOrderingElementList();
                $replacementElementList->setQuestionId($this->object->getId());
                
                $currentElementList = $this->object->getOrderingElementList();
                
                foreach($submittedElementList as $submittedElement)
                {
                        if( $this->object->hasOrderingTypeUploadSupport() )
                        {
                                if( $submittedElement->isImageUploadAvailable() )
                                {
                                        $suffix = strtolower(array_pop(explode(".", $submittedElement->getUploadImageName())));
                                        if( in_array($suffix, array("jpg", "jpeg", "png", "gif")) )
                                        {
                                                $submittedElement->setUploadImageName( $this->object->buildHashedImageFilename(
                                                        $submittedElement->getUploadImageName(), true
                                                ));
                                                
                                                $wasImageFileStored = $this->object->storeImageFile(
                                                        $submittedElement->getUploadImageFile(), $submittedElement->getUploadImageName()
                                                );
                                                
                                                if( $wasImageFileStored )
                                                {
                                                        if( $this->object->isImageFileStored( $submittedElement->getContent() ) )
                                                        {
                                                                $this->object->dropImageFile( $submittedElement->getContent() );
                                                        }
 
                                                        $submittedElement->setContent( $submittedElement->getUploadImageName() );
                                                }
                                        }
                                }
                        }
                        
                        if( $currentElementList->elementExistByRandomIdentifier($submittedElement->getRandomIdentifier()) )
                        {
                                $storedElement = $currentElementList->getElementByRandomIdentifier(
                                        $submittedElement->getRandomIdentifier()
                                );
                                
                                $submittedElement->setSolutionIdentifier($storedElement->getSolutionIdentifier());
                                
                                if( $this->isAdjustmentEditContext() || $this->object->isOrderingTypeNested() )
                                {
                                        $submittedElement->setContent($storedElement->getContent());
                                }
                                
                                if( !$this->object->isOrderingTypeNested() )
                                {
                                        $submittedElement->setIndentation($storedElement->getIndentation());
                                }
                                
                                if( $this->object->isImageReplaced($submittedElement, $storedElement) )
                                {
                                        $this->object->dropImageFile($storedElement->getContent());
                                }
                        }
                        
                        $replacementElementList->addElement($submittedElement);
                }
                
                if( $this->object->isImageOrderingType() )
                {
                        $this->object->handleThumbnailCreation($replacementElementList);
                }
                
                if( $this->isClearAnswersOnWritingPostDataEnabled() )
                {
                        $replacementElementList->clearElementContents();
                }
                
                if( $this->object->hasOrderingTypeUploadSupport() )
                {
                        $obsoleteElementList = $currentElementList->getDifferenceElementList($replacementElementList);
                        
                        foreach($obsoleteElementList as $obsoleteElement)
                        {
                                $this->object->dropImageFile($obsoleteElement->getContent());
                        }
                }
                
                $this->object->setOrderingElementList($replacementElementList);
        }
 
        public function populateAnswerSpecificFormPart(ilPropertyFormGUI $form)
        {
                $header = new ilFormSectionHeaderGUI();
                $header->setTitle($this->lng->txt('oq_header_ordering_elements'));
                $form->addItem($header);
                
                if( $this->isAdjustmentEditContext() )
                {
                        $orderingElementInput = $this->object->buildNestedOrderingElementInputGui();
                }
                else
                {
                        $orderingElementInput = $this->object->buildOrderingElementInputGui();
                }
                
                $orderingElementInput->setStylingDisabled($this->isRenderPurposePrintPdf());
                $this->object->initOrderingElementAuthoringProperties($orderingElementInput);
                
                $orderingElementInput->setElementList( $this->object->getOrderingElementList() );
                
                $form->addItem($orderingElementInput);
 
                return $form;
        }
        
        public function populateQuestionSpecificFormPart(\ilPropertyFormGUI $form)
        {
                if (!$this->object->getSelfAssessmentEditingMode())
                {
                        $element_height = new ilNumberInputGUI($this->lng->txt( "element_height" ), "element_height");
                        $element_height->setValue( $this->object->getElementHeight() );
                        $element_height->setRequired( false );
                        $element_height->setMaxLength( 6 );
                        $element_height->setMinValue( 20 );
                        $element_height->setSize( 6 );
                        $element_height->setInfo( $this->lng->txt( "element_height_info" ) );
                        $form->addItem( $element_height );
                }
 
                if( $this->object->isImageOrderingType() )
                {
                        $geometry = new ilNumberInputGUI($this->lng->txt( "thumb_geometry" ), "thumb_geometry");
                        $geometry->setValue( $this->object->getThumbGeometry() );
                        $geometry->setRequired( true );
                        $geometry->setMaxLength( 6 );
                        $geometry->setMinValue( 20 );
                        $geometry->setSize( 6 );
                        $geometry->setInfo( $this->lng->txt( "thumb_geometry_info" ) );
                        $form->addItem( $geometry );
                }
 
                // points
                $points = new ilNumberInputGUI($this->lng->txt( "points" ), "points");
                $points->allowDecimals( true );
                $points->setValue( $this->object->getPoints() );
                $points->setRequired( TRUE );
                $points->setSize( 3 );
                $points->setMinValue( 0 );
                $points->setMinvalueShouldBeGreater( true );
                $form->addItem( $points );
                
                return $form;
        }
 
        protected function writePostData($forceSaving = false)
        {
                $savingAllowed = true; // assume saving allowed first
                
                if( !$forceSaving )
                {
                        // this case seems to be a regular save call, so we consider
                        // the validation result for the decision of saving as well
                        
                        // inits {this->editForm} and performs validation
                        $form = $this->buildEditForm();
                        $form->setValuesByPost(); // manipulation and distribution of values 
                        
                        if( !$form->checkInput() ) // manipulations regular style input propeties
                        {
                                $form->prepareValuesReprintable($this->object);
                                $this->renderEditForm($form);
                                
                                // consequence of vaidation
                                $savingAllowed = false;
                        }
                }
                elseif( !$this->isSaveCommand() )
                {
                        // this case handles form workflow actions like the mode/view switching requests,
                        // so saving must not be skipped, even for inputs invalid by business rules
                        
                        $form = $this->buildEditForm();
                        $form->setValuesByPost(); // manipulation and distribution of values 
                        $form->checkInput(); // manipulations regular style input propeties
                }
                
                if( $savingAllowed )
                {
                        $this->persistAuthoringForm($form);
                        
                        return 0; // return 0 = all fine, was saved either forced or validated
                }
                
                return 1; // return 1 = something went wrong, no saving happened
        }
        
        public function editQuestion($checkonly = FALSE)
        {
                $this->renderEditForm( $this->buildEditForm() );
        }
        
        protected function buildEditForm()
        {
                require_once 'Modules/TestQuestionPool/classes/forms/class.ilAssOrderingQuestionAuthoringFormGUI.php';
                $form = new ilAssOrderingQuestionAuthoringFormGUI();
                $this->editForm = $form;
                
                $form->setFormAction($this->ctrl->getFormAction($this));
                $form->setTitle($this->outQuestionType());
                $form->setMultipart(( $this->object->getOrderingType() == OQ_PICTURES ) ? TRUE : FALSE);
                $form->setTableWidth("100%");
                $form->setId("ordering");
                // title, author, description, question, working time (assessment mode)
                $this->addBasicQuestionFormProperties($form);
                $this->populateQuestionSpecificFormPart($form);
                $this->populateAnswerSpecificFormPart($form);
                
                $this->populateTaxonomyFormSection($form);
                
                $form->addSpecificOrderingQuestionCommandButtons($this->object);
                $form->addGenericAssessmentQuestionCommandButtons($this->object);
                
                return $form;
        }
 
        function getSolutionOutput(
                $active_id,
                $pass = NULL,
                $graphicalOutput = FALSE,
                $result_output = FALSE,
                $show_question_only = TRUE,
                $show_feedback = FALSE,
                $forceCorrectSolution = FALSE,
                $show_manual_scoring = FALSE,
                $show_question_text = TRUE
        )
        {
                $solutionOrderingList = $this->object->getOrderingElementListForSolutionOutput(
                        $forceCorrectSolution, $active_id, $pass
                );
 
                $answers_gui = $this->object->buildNestedOrderingElementInputGui();
                
                if( $forceCorrectSolution )
                {
                        $answers_gui->setContext(ilAssNestedOrderingElementsInputGUI::CONTEXT_CORRECT_SOLUTION_PRESENTATION);
                }
                else
                {
                        $answers_gui->setContext(ilAssNestedOrderingElementsInputGUI::CONTEXT_USER_SOLUTION_PRESENTATION);
                }
                
                $answers_gui->setInteractionEnabled(false);
                
                $answers_gui->setElementList( $solutionOrderingList );
                
                $answers_gui->setCorrectnessTrueElementList(
                        $solutionOrderingList->getParityTrueElementList($this->object->getOrderingElementList())
                );
                
                $solution_html = $answers_gui->getHTML();
        
                $template = new ilTemplate("tpl.il_as_qpl_nested_ordering_output_solution.html", TRUE, TRUE, "Modules/TestQuestionPool");
                $template->setVariable('SOLUTION_OUTPUT', $solution_html);
                if ($show_question_text==true)
                {
                        $template->setVariable("QUESTIONTEXT", $this->object->prepareTextareaOutput($this->object->getQuestion(), TRUE));
                }
                $questionoutput = $template->get();
        
                $solutiontemplate = new ilTemplate("tpl.il_as_tst_solution_output.html",TRUE, TRUE, "Modules/TestQuestionPool");
                $solutiontemplate->setVariable("SOLUTION_OUTPUT", $questionoutput);
 
                if($show_feedback)
                {
                        $feedback = '';
                        
                        if( !$this->isTestPresentationContext() )
                        {
                                $fb = $this->getGenericFeedbackOutput($active_id, $pass);
                                $feedback .= strlen($fb) ? $fb : '';
                        }
                        
                        $fb = $this->getSpecificFeedbackOutput($active_id, $pass);
                        $feedback .=  strlen($fb) ? $fb : '';
                        
                        if (strlen($feedback))
                        {
                                $cssClass = ( $this->hasCorrectSolution($active_id, $pass) ?
                                        ilAssQuestionFeedback::CSS_CLASS_FEEDBACK_CORRECT : ilAssQuestionFeedback::CSS_CLASS_FEEDBACK_WRONG
                                );
                                
                                $solutiontemplate->setVariable("ILC_FB_CSS_CLASS", $cssClass);
                                $solutiontemplate->setVariable("FEEDBACK", $this->object->prepareTextareaOutput( $feedback, true ));
                        }
                }
 
                if( $show_question_only )
                {
                        return $solutiontemplate->get();
                }
        
                return $this->getILIASPage( $solutiontemplate->get() );
                
                // is this template still in use? it is not used at this point any longer!
                // $template = new ilTemplate("tpl.il_as_qpl_ordering_output_solution.html", TRUE, TRUE, "Modules/TestQuestionPool");
        }
        
        function getPreview($show_question_only = FALSE, $showInlineFeedback = false)
        {
                if( $this->getPreviewSession() && $this->getPreviewSession()->hasParticipantSolution() )
                {
                        $solutionOrderingElementList = unserialize(
                                $this->getPreviewSession()->getParticipantsSolution()
                        );
                }
                else
                {
                        $solutionOrderingElementList = $this->object->getShuffledOrderingElementList();
                }
                
                $answers = $this->object->buildNestedOrderingElementInputGui();
                $answers->setNestingEnabled($this->object->isOrderingTypeNested());
                $answers->setContext(ilAssNestedOrderingElementsInputGUI::CONTEXT_QUESTION_PREVIEW);
                $answers->setInteractionEnabled($this->isInteractivePresentation());
                $answers->setElementList($solutionOrderingElementList);
                
                $template = new ilTemplate("tpl.il_as_qpl_ordering_output.html", TRUE, TRUE, "Modules/TestQuestionPool");
                
                $template->setCurrentBlock('nested_ordering_output');
                $template->setVariable('NESTED_ORDERING', $answers->getHTML());
                $template->parseCurrentBlock();
                
                $template->setVariable("QUESTIONTEXT", $this->object->prepareTextareaOutput($this->object->getQuestion(), true));
                
                if( $show_question_only )
                {
                        return $template->get();
                }
                
                return $this->getILIASPage($template->get());
                
                //$this->tpl->addJavascript("./Modules/TestQuestionPool/templates/default/ordering.js");
        }
 
        // hey: prevPassSolutions - pass will be always available from now on
        public function getTestOutput($activeId, $pass, $isPostponed = FALSE, $userSolutionPost = FALSE, $inlineFeedback = false)
        // hey.
        {
                $userSolutionPost = is_array($userSolutionPost) ? $userSolutionPost : array();
                
                $orderingGUI = $this->object->buildNestedOrderingElementInputGui();
                $orderingGUI->setNestingEnabled($this->object->isOrderingTypeNested());
                
                $solutionOrderingElementList = $this->object->getSolutionOrderingElementListForTestOutput(
                        $orderingGUI, $userSolutionPost, $activeId, $pass
                );
                
                $template = new ilTemplate('tpl.il_as_qpl_ordering_output.html', TRUE, TRUE, 'Modules/TestQuestionPool');
                
                $orderingGUI->setContext(ilAssNestedOrderingElementsInputGUI::CONTEXT_USER_SOLUTION_SUBMISSION);
                $orderingGUI->setElementList( $solutionOrderingElementList );
                
                $template->setCurrentBlock('nested_ordering_output');
                $template->setVariable('NESTED_ORDERING',$orderingGUI->getHTML());
                $template->parseCurrentBlock();
 
                $template->setVariable('QUESTIONTEXT', $this->object->prepareTextareaOutput($this->object->getQuestion(), true));
 
                $pageoutput = $this->outQuestionPage('', $isPostponed, $activeId, $template->get());
 
                return $pageoutput;
        }
        
        protected function isInteractivePresentation()
        {
                if( $this->isRenderPurposePlayback() )
                {
                        return true;
                }
                
                if( $this->isRenderPurposeDemoplay() )
                {
                        return true;
                }
                
                return false;
        }
 
        function setQuestionTabs()
        {
                global $rbacsystem, $ilTabs;
 
                $ilTabs->clearTargets();
                
                $this->ctrl->setParameterByClass("ilAssQuestionPageGUI", "q_id", $_GET["q_id"]);
                include_once "./Modules/TestQuestionPool/classes/class.assQuestion.php";
                $q_type = $this->object->getQuestionType();
 
                if (strlen($q_type))
                {
                        $classname = $q_type . "GUI";
                        $this->ctrl->setParameterByClass(strtolower($classname), "sel_question_types", $q_type);
                        $this->ctrl->setParameterByClass(strtolower($classname), "q_id", $_GET["q_id"]);
                }
 
                if ($_GET["q_id"])
                {
                        if ($rbacsystem->checkAccess('write', $_GET["ref_id"]))
                        {
                                // edit page
                                $ilTabs->addTarget("edit_page",
                                        $this->ctrl->getLinkTargetByClass("ilAssQuestionPageGUI", "edit"),
                                        array("edit", "insert", "exec_pg"),
                                        "", "", false);
                        }
 
                        $this->addTab_QuestionPreview($ilTabs);
                }
 
                $force_active = false;
                if ($rbacsystem->checkAccess('write', $_GET["ref_id"]))
                {
                        $url = "";
                        if ($classname) $url = $this->ctrl->getLinkTargetByClass($classname, "editQuestion");
                        $commands = $_POST["cmd"];
                        if (is_array($commands))
                        {
                                foreach ($commands as $key => $value)
                                {
                                        if (preg_match("/^delete_.*/", $key, $matches))
                                        {
                                                $force_active = true;
                                        }
                                }
                        }
                        // edit question properties
                        $ilTabs->addTarget("edit_question",
                                $url,
                                array("orderNestedTerms","orderNestedPictures","editQuestion", "save", "saveEdit", "addanswers", "removeanswers", "changeToPictures", "uploadElementImage", "changeToText", "upanswers", "downanswers", "originalSyncForm"),
                                $classname, "", $force_active);
                }
 
                // add tab for question feedback within common class assQuestionGUI
                $this->addTab_QuestionFeedback($ilTabs);
 
                // add tab for question hint within common class assQuestionGUI
                $this->addTab_QuestionHints($ilTabs);
 
                // add tab for question's suggested solution within common class assQuestionGUI
                $this->addTab_SuggestedSolution($ilTabs, $classname);
 
                // Assessment of questions sub menu entry
                if ($_GET["q_id"])
                {
                        $ilTabs->addTarget("statistics",
                                $this->ctrl->getLinkTargetByClass($classname, "assessment"),
                                array("assessment"),
                                $classname, "");
                }
 
                $this->addBackTab($ilTabs);
        }
 
        function getSpecificFeedbackOutput($active_id, $pass)
        {
                if( !$this->object->feedbackOBJ->specificAnswerFeedbackExists($this->object->getOrderingElementList()) )
                {
                        return '';
                }
 
                $tpl = new ilTemplate('tpl.il_as_qpl_ordering_elem_fb.html', true, true, 'Modules/TestQuestionPool');
                
                foreach( $this->object->getOrderingElementList() as $element)
                {
                        $feedback = $this->object->feedbackOBJ->getSpecificAnswerFeedbackTestPresentation(
                                $this->object->getId(), $element->getPosition()
                        );
                        
                        if( $this->object->isImageOrderingType() )
                        {
                                $imgSrc = $this->object->getImagePathWeb().$element->getContent();
                                $tpl->setCurrentBlock('image');
                                $tpl->setVariable('IMG_SRC', $imgSrc);
                        }
                        else
                        {
                                $tpl->setCurrentBlock('text');
                        }
                        $tpl->setVariable('CONTENT', $element->getContent());
                        $tpl->parseCurrentBlock();
                        
                        $tpl->setCurrentBlock('element');
                        $tpl->setVariable('FEEDBACK', $feedback);
                        $tpl->parseCurrentBlock();
                }
 
                return $this->object->prepareTextareaOutput($tpl->get(), TRUE);
        }
        
        protected function persistAuthoringForm($form)
        {
                $this->writeQuestionGenericPostData();
                $this->writeQuestionSpecificPostData($form);
                $this->writeAnswerSpecificPostData($form);
                $this->saveTaxonomyAssignments();
        }
        
        private function getOldLeveledOrdering()
        {
                global $ilDB;
 
                $res = $ilDB->queryF('SELECT depth FROM qpl_a_ordering WHERE question_fi = %s ORDER BY solution_key ASC',
                        array('integer'), array($this->object->getId()));
                while($row = $ilDB->fetchAssoc($res))
                {
                        $this->old_ordering_depth[] = $row['depth'];
                }
                return $this->old_ordering_depth;
        }
 
        public function getAfterParticipationSuppressionAnswerPostVars()
        {
                return array();
        }
 
        public function getAfterParticipationSuppressionQuestionPostVars()
        {
                return array();
        }
 
        public function getAggregatedAnswersView($relevant_answers)
        {
                $aggView = $this->aggregateAnswers(
                        $relevant_answers, $this->object->getOrderingElementList()
                );
                
                return  $this->renderAggregateView($aggView)->get();
        }
 
        public function aggregateAnswers($relevant_answers_chosen, $answers_defined_on_question)
        {
                $passdata = array(); // Regroup answers into units of passes.
                foreach($relevant_answers_chosen as $answer_chosen)
                {
                        $passdata[$answer_chosen['active_fi'].'-'. $answer_chosen['pass']][$answer_chosen['value2']] = $answer_chosen['value1'];
                }
                
                $variants = array(); // Determine unique variants.
                foreach($passdata as $key => $data)
                {
                        $hash = md5(implode('-', $data));
                        $value_set = false;
                        foreach ($variants as $vkey => $variant)
                        {
                                if ($variant['hash'] == $hash)
                                {
                                        $variant['count']++;
                                        $value_set = true;
                                }
                        }
                        if (!$value_set)
                        {
                                $variants[$key]['hash'] = $hash;
                                $variants[$key]['count'] = 1;
                        }
                }
 
                $aggregate = array(); // Render aggregate from variant.
                foreach ($variants as $key => $variant_entry)
                {
                        $variant = $passdata[$key];
                        
                        foreach($variant as $variant_key => $variant_line)
                        {
                                $i = 0;
                                $aggregated_info_for_answer['count'] = $variant_entry['count'];
                                foreach ($answers_defined_on_question as $element)
                                {
                                        $i++;
                                        
                                        if($this->object->isImageOrderingType())
                                        {
                                                $element->setImageThumbnailPrefix($this->object->getThumbPrefix());
                                                $element->setImagePathWeb($this->object->getImagePathWeb());
                                                $element->setImagePathFs($this->object->getImagePath());
                                                
                                                $src = $element->getPresentationImageUrl();
                                                $alt = $element->getContent();
                                                $content = "<img src='{$src}' alt='{$alt}' title='{$alt}'/>";
                                        }
                                        else
                                        {
                                                $content = $element->getContent();
                                        }
                                        
                                        $aggregated_info_for_answer[$i . ' - ' . $content] 
                                                = $passdata[$key][$i];
                                }
                                
                        }
                        $aggregate[] = $aggregated_info_for_answer;
                }
                return $aggregate;
        }
 
        public function renderAggregateView($aggregate)
        {
                $tpl = new ilTemplate('tpl.il_as_aggregated_answers_table.html', true, true, "Modules/TestQuestionPool");
 
                foreach ($aggregate as $line_data)
                {
                        $tpl->setCurrentBlock( 'aggregaterow' );
                        $count = array_shift($line_data);
                        $html = '<ul>';
                        foreach($line_data as $key => $line)
                        {
                                $html .= '<li>'. ++$line .'&nbsp;-&nbsp;' .$key. '</li>';
                        }
                        $html .= '</ul>';
                        $tpl->setVariable( 'COUNT', $count );
                        $tpl->setVariable( 'OPTION', $html );
 
                        $tpl->parseCurrentBlock();
                }
                return $tpl;
        }
}