ilAssLacCompositeEvaluator.php

Go to the documentation of this file.

<?php

class ilAssLacCompositeEvaluator {

        protected $object_loader;

        protected $activeId;

        protected $pass;

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

        public function evaluate(ilAssLacAbstractComposite $composite)
        {
                if(count($composite->nodes) > 0)
                {
                        $composite->nodes[0] = $this->evaluate($composite->nodes[0]);
                        $composite->nodes[1] = $this->evaluate($composite->nodes[1]);
                        $composite = $this->evaluateSubTree($composite);
                }
                return $composite;
        }

        private function evaluateSubTree(ilAssLacAbstractComposite $composite)
        {
                $result = false;
                if($composite->nodes[0] instanceof ilAssLacExpressionInterface &&
                        $composite->nodes[1] instanceof ilAssLacExpressionInterface
                ){
                        $question = $this->object_loader->getQuestion($composite->nodes[0]->getQuestionIndex());
                        $rightNode = $composite->nodes[1];

                        $index = $this->isInstanceOfAnswerIndexProvidingExpression($composite) ? $composite->nodes[0]->getAnswerIndex(): null;

                        $solutions = $question->getUserQuestionResult($this->activeId,$this->pass);

                        if($question instanceof assClozeTest)
                        {
                                // @todo for Thomas J.: Move to interface / implement in concrete class (req. for future releases)
                                $result = $solutions->getSolutionForKey($index);
                                $gap    = $question->getAvailableAnswerOptions($index-1);

                                if($rightNode instanceof ilAssLacStringResultExpression)
                                {
                                        if($gap->getType() == 1)
                                        {
                                                $answer = $gap->getItem($result['value'] - 1);
                                                $solutions->removeByKey($index);
                                                $solutions->addKeyValue($index, $answer->getAnswertext());
                                        }
                                }
                                else if(
                                        $rightNode instanceof ilAssLacPercentageResultExpression &&
                                        $composite->nodes[0] instanceof ilAssLacResultOfAnswerOfQuestionExpression)
                                {
                                        $answers = $gap->getItems();
                                        $max_points = 0;
                                        foreach($answers as $answer)
                                        {
                                                if($max_points < $answer->getPoints())
                                                {
                                                        $max_points = $answer->getPoints();
                                                }
                                        }

                                        $item           = null;
                                        $reached_points = null;
                                        // @todo for Thomas J.: Maybe handle identical scoring for every type
                                        switch($gap->getType())
                                        {
                                                case CLOZE_TEXT:
                                                        for($order = 0; $order < $gap->getItemCount(); $order++)
                                                        {
                                                                $answer      = $gap->getItem($order);
                                                                $item_points = $question->getTextgapPoints($answer->getAnswertext(), $result['value'], $answer->getPoints());
                                                                if($item_points > $reached_points) $reached_points = $item_points;
                                                        }
                                                        break;

                                                case CLOZE_NUMERIC:
                                                        for($order = 0; $order < $gap->getItemCount(); $order++)
                                                        {
                                                                $answer      = $gap->getItem($order);
                                                                $item_points = $question->getNumericgapPoints($answer->getAnswertext(), $result["value"], $answer->getPoints(), $answer->getLowerBound(), $answer->getUpperBound());
                                                                if($item_points > $reached_points) $reached_points = $item_points;
                                                        }
                                                        break;

                                                case CLOZE_SELECT:
                                                        if($result['value'] != null)
                                                        {
                                                                $answer         = $gap->getItem($result['value'] - 1);
                                                                $reached_points = $answer->getPoints();
                                                        }
                                                        break;
                                        }

                                        $percentage = 0;
                                        if($max_points != 0 && $reached_points !== null)
                                        {
                                                $percentage = (int)(($reached_points / $max_points) * 100);
                                        }
                                        $solutions->setReachedPercentage($percentage);
                                }
                        }

                        if(
                                $question instanceof assFormulaQuestion &&
                                $rightNode instanceof ilAssLacPercentageResultExpression &&
                                $this->isInstanceOfAnswerIndexProvidingExpression($composite->nodes[0])
                        )
                        {
                                // @todo for Thomas J.: Move to interface / implement in concrete class (req. for future releases)
                                $result = $solutions->getSolutionForKey($index);
                                $answer = $question->getAvailableAnswerOptions($index-1);

                                $unit = $solutions->getSolutionForKey($index . "_unit");
                                $key = null;
                                if(is_array($unit))
                                {
                                        $key = $unit['value'];
                                }

                                $max_points = $answer->getPoints();
                                $points = $answer->getReachedPoints($question->getVariables(), $question->getResults(), $result["value"], $key, $question->getUnitrepository()->getUnits());

                                $percentage = 0;
                                if($max_points != 0)
                                {
                                        $percentage = (int)(($points/$max_points)*100);
                                }
                                $solutions->setReachedPercentage($percentage);
                        }

                        $result = $rightNode->checkResult($solutions,$composite->getPattern(),$index);
                }
                else
                {
                        switch($composite->getPattern())
                        {
                                case "&":
                                        $result = $composite->nodes[0] && $composite->nodes[1];
                                        break;
                                case "|":
                                        $result = $composite->nodes[0] || $composite->nodes[1];
                                        break;
                                default:
                                        $result = false;
                        }
                }

                if($composite->isNegated())
                {
                        return !$result;
                }
                return $result;
        }

        private function isInstanceOfAnswerIndexProvidingExpression(ilAssLacAbstractComposite $composite)
        {
                if($composite->nodes[0] instanceof ilAssLacResultOfAnswerOfQuestionExpression)
                {
                        return true;
                }

                if($composite->nodes[0] instanceof ilAssLacResultOfAnswerOfCurrentQuestionExpression)
                {
                        return true;
                }
                
                return false;
        }
}