ilAssLacCompositeValidator.php

Go to the documentation of this file.

<?php

require_once "Modules/TestQuestionPool/classes/questions/LogicalAnswerCompare/Expressions/ilAssLacResultOfAnswerOfQuestionExpression.php";
require_once "Modules/TestQuestionPool/classes/questions/LogicalAnswerCompare/Exception/ilAssLacExpressionNotSupportedByQuestion.php";
require_once "Modules/TestQuestionPool/classes/questions/LogicalAnswerCompare/Exception/ilAssLacQuestionNotExist.php";
require_once "Modules/TestQuestionPool/classes/questions/LogicalAnswerCompare/Exception/ilAssLacOperatorNotSupportedByExpression.php";
require_once "Modules/TestQuestionPool/classes/questions/LogicalAnswerCompare/Exception/ilAssLacUnsupportedExpression.php";
require_once "Modules/TestQuestionPool/classes/questions/LogicalAnswerCompare/Exception/ilAssLacUnsupportedOperation.php";
require_once "Modules/TestQuestionPool/classes/questions/LogicalAnswerCompare/Exception/ilAssLacAnswerIndexNotExist.php";
require_once "Modules/TestQuestionPool/classes/questions/LogicalAnswerCompare/Exception/ilAssLacQuestionNotReachable.php";
require_once "Modules/TestQuestionPool/classes/questions/LogicalAnswerCompare/Exception/ilAssLacAnswerValueNotExist.php";
require_once "Modules/TestQuestionPool/classes/questions/LogicalAnswerCompare/Exception/ilAssLacUnableToParseCondition.php";
require_once "Modules/TestQuestionPool/classes/questions/LogicalAnswerCompare/Exception/ilAssLacDuplicateElement.php";

class ilAssLacCompositeValidator
{

        protected $object_loader;

        public function __construct($object_loader)
        {
                $this->object_loader = $object_loader;
        }

        public function validate(ilAssLacAbstractComposite $composite)
        {
                if(count($composite->nodes) > 0)
                {
                        $this->validate($composite->nodes[0]);
                        $this->validate($composite->nodes[1]);
                        $this->validateSubTree($composite);
                }

                return;
        }

        private function validateSubTree(ilAssLacAbstractComposite $composite)
        {
                if($composite->nodes[0] instanceof ilAssLacQuestionExpressionInterface &&
                        $composite->nodes[1] instanceof ilAssLacSolutionExpressionInterface
                ){
                        $question_expression = $composite->nodes[0];
                        $answer_expression = $composite->nodes[1];
                        $question_index = $composite->nodes[0]->getQuestionIndex();
                        $answer_index = null;
                        $question = $this->object_loader->getQuestion($question_index);

                        $this->checkQuestionExists($question, $question_index);
                        //$this->checkQuestionIsReachable($question, $question_index);

                        if($this->isResultOfAnswerExpression($question_expression))
                        {
                                $answer_index = $question_expression->getAnswerIndex()-1;
                                $this->checkIfAnswerIndexOfQuestionExists($question, $question_index, $answer_index);
                        }
                        if($answer_expression instanceof ilAssLacNumberOfResultExpression && !($question instanceof assClozeTest))
                        {
                                $this->checkIfAnswerIndexOfQuestionExists($question, $question_index, $answer_expression->getNumericValue()-1);
                        }

                        $this->checkAnswerExpressionExist($question->getExpressionTypes(), $answer_expression, $question_index);
                        $this->checkOperatorExistForExpression($question->getOperators($answer_expression::$identifier), $answer_expression, $composite::$pattern);

                        if($answer_expression instanceof ilAssLacOrderingResultExpression &&
                                ($question instanceof assOrderingHorizontal || $question instanceof assOrderingQuestion )
                        )
                        {
                                foreach($answer_expression->getOrdering() as $order)
                                {
                                        $count = 0;
                                        foreach($answer_expression->getOrdering() as $element)
                                        {
                                                if($element == $order)
                                                {
                                                        $count++;
                                                }
                                        }
                                        if($count > 1)
                                        {
                                                throw new ilAssLacDuplicateElement($order);
                                        }

                                        $this->checkIfAnswerIndexOfQuestionExists($question, $question_index, $order-1);
                                }
                        }
                        if($question instanceof assClozeTest)
                        {
                                $this->validateClozeTest($answer_index, $question, $answer_expression, $question_index);
                        }
                        elseif(
                                $answer_expression instanceof ilAssLacPercentageResultExpression &&
                                $this->isResultOfAnswerExpression($question_expression) &&
                                !($question instanceof assFormulaQuestion)
                        )
                        {
                                throw new ilAssLacExpressionNotSupportedByQuestion($answer_expression->getValue(), $question_index . "[". ($answer_index+1) . "]");
                        }
                }
                elseif(
                        ($composite->nodes[0] instanceof ilAssLacAbstractOperation &&
                        $composite->nodes[1] instanceof ilAssLacExpressionInterface) ||
                        ($composite->nodes[0] instanceof ilAssLacExpressionInterface &&
                        $composite->nodes[1] instanceof ilAssLacAbstractOperation) ||
                        ($composite->nodes[0] instanceof ilAssLacSolutionExpressionInterface)
                )
                {
                        throw new ilAssLacUnableToParseCondition("");
                }
        }

        private function validateClozeTest($answer_index, $question, $answer_expression, $question_index)
        {
                if($answer_index !== null)
                {
                        $options = $question->getAvailableAnswerOptions($answer_index);
                        $found = false;
                        switch($options->getType())
                        {
                                case 0: // text
                                        if(
                                                $answer_expression instanceof ilAssLacStringResultExpression
                                        )
                                        {
                                                $found = true;
                                        }

                                        break;
                                case 1: // select

                                        if($answer_expression instanceof ilAssLacStringResultExpression)
                                        {
                                                foreach($options->getItems($this->getNonShuffler()) as $item)
                                                {
                                                        if($item->getAnswertext() == $answer_expression->getText())
                                                        {
                                                                $found = true;
                                                        }
                                                }
                                        }
                                        elseif($answer_expression instanceof ilAssLacNumberOfResultExpression)
                                        {

                                                foreach($options->getItems($question->getShuffler()) as $item)
                                                {
                                                        if($item->getOrder() == $answer_expression->getNumericValue()-1)
                                                        {
                                                                $found = true;
                                                        }
                                                }
                                        }
                                break;
                                case 2: // numeric
                                        if($answer_expression instanceof ilAssLacNumericResultExpression)
                                        {
                                                $found = true;
                                        }
                                break;
                        }

                        if($answer_expression instanceof ilAssLacEmptyAnswerExpression)
                        {
                                $found = true;
                        }
                        if(!$found && !($answer_expression instanceof ilAssLacPercentageResultExpression))
                        {
                                throw new ilAssLacAnswerValueNotExist($question_index, $answer_expression->getValue(), $answer_index+1);
                        }

                }
        }

        private function checkIfAnswerIndexOfQuestionExists($question, $question_index, $answer_index)
        {
                $answer_options = $question->getAvailableAnswerOptions($answer_index);
                if($answer_options == null)
                {
                        throw new ilAssLacAnswerIndexNotExist($question_index, $answer_index+1);
                }
        }

        private function checkQuestionExists($question, $index)
        {
                if($question == null)
                {
                        throw new ilAssLacQuestionNotExist($index);
                }
        }

        private function isResultOfAnswerExpression($expression)
        {
                if( $expression instanceof ilAssLacResultOfAnswerOfQuestionExpression )
                {
                        return true;
                }

                if( $expression instanceof ilAssLacResultOfAnswerOfCurrentQuestionExpression )
                {
                        return true;
                }

                return false;
        }

        private function checkAnswerExpressionExist($expressions, $answer_expression, $question_index)
        {
                if(!in_array($answer_expression::$identifier, $expressions))
                {
                        throw new ilAssLacExpressionNotSupportedByQuestion($answer_expression->getValue(), $question_index);
                }
        }

        private function checkOperatorExistForExpression($operators, $answer_expression, $pattern)
        {
                if(!in_array($pattern, $operators))
                {
                        throw new ilAssLacOperatorNotSupportedByExpression($answer_expression->getValue(),$pattern);
                }
        }
        
        protected function getNonShuffler()
        {
                require_once 'Services/Randomization/classes/class.ilArrayElementOrderKeeper.php';
                return new ilArrayElementOrderKeeper();
        }
}