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