ilAssQuestionSkillAssignmentNormalizer.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
namespace ILIAS\TestQuestionPool\ExportImport\Normalize\Normalizer;
 
use ILIAS\TestQuestionPool\ExportImport\Foundation\Normalize\Normalizer;
use ILIAS\TestQuestionPool\ExportImport\Foundation\Normalize\Transformations;
use ILIAS\TestQuestionPool\ExportImport\Foundation\Normalize\Envelopes\Id;
use ILIAS\TestQuestionPool\ExportImport\Foundation\Normalize\NormalizingException;
 
class ilAssQuestionSkillAssignmentNormalizer implements Normalizer
{
    public function __construct(
        private readonly Transformations $tt,
        private readonly \ilDBInterface $db
    ) {
    }
 
    #[\Override]
    public function normalize($value): array|float|bool|int|string|null
    {
        if (!($value instanceof \ilAssQuestionSkillAssignment)) {
            throw new NormalizingException('Invalid value', $value);
        }
 
        $normalized = [
            'parent_id' => $this->tt->normalize(new Id($value->getParentObjId(), 'object')),
            'question_id' => $this->tt->normalize(new Id($value->getQuestionId(), 'question')),
            'base_id' => $this->tt->normalize(new Id($value->getSkillBaseId(), 'skill_base')),
            'tref_id' => $this->tt->normalize(new Id($value->getSkillTrefId(), 'skill_tref')),
            'original_title' => $value->getSkillTitle(),
            'original_path' => $value->getSkillPath(),
            'eval_mode' => $value->getEvalMode(),
        ];
 
        switch ($value->getEvalMode()) {
            case \ilAssQuestionSkillAssignment::EVAL_MODE_BY_QUESTION_RESULT:
                $normalized['points'] = $value->getSkillPoints();
                break;
 
            case \ilAssQuestionSkillAssignment::EVAL_MODE_BY_QUESTION_SOLUTION:
                $normalized['solution_comparison_expressions'] = $this->normalizeExpressionList($value);
                break;
        }
        return $normalized;
    }
 
    private function normalizeExpressionList(\ilAssQuestionSkillAssignment $value): array
    {
        $value->initSolutionComparisonExpressionList();
 
        $list = [];
        foreach ($value->getSolutionComparisonExpressionList()->get() as $expression) {
            $list[] = [
                'points' => $expression->getPoints(),
                'expression' => $expression->getExpression(),
                'order_index' => $expression->getOrderIndex(),
            ];
        }
 
        return $list;
    }
 
    #[\Override]
    public function denormalize(array|float|bool|int|string|null $value, string $type): \ilAssQuestionSkillAssignment
    {
        if ($type !== \ilAssQuestionSkillAssignment::class) {
            throw new NormalizingException("Invalid type for ilAssQuestionSkillAssignment: {$type}");
        }
 
        $assignment = new \ilAssQuestionSkillAssignment($this->db);
        $assignment->setParentObjId($this->tt->denormalize($value['parent_id'], Id::class)->getId());
        $assignment->setQuestionId($this->tt->denormalize($value['question_id'], Id::class)->getId());
        $assignment->setSkillBaseId($this->tt->denormalize($value['base_id'], Id::class)->getId());
        $assignment->setSkillTrefId($this->tt->denormalize($value['tref_id'], Id::class)->getId());
        $assignment->setSkillTitle($this->tt->string($value['original_title']));
        $assignment->setSkillPath($this->tt->string($value['original_path']));
        $assignment->setEvalMode($this->tt->string($value['eval_mode']));
        $assignment->initSolutionComparisonExpressionList();
 
        switch ($assignment->getEvalMode()) {
            case \ilAssQuestionSkillAssignment::EVAL_MODE_BY_QUESTION_RESULT:
                $assignment->setSkillPoints($this->tt->int($value['points']));
                break;
 
            case \ilAssQuestionSkillAssignment::EVAL_MODE_BY_QUESTION_SOLUTION:
                $list = $assignment->getSolutionComparisonExpressionList();
                foreach ($value['solution_comparison_expressions'] as $normalized) {
                    $list->add($this->denormalizeExpression($normalized, $assignment));
                }
                break;
        }
 
        return $assignment;
    }
 
    private function denormalizeExpression(
        array $normalized,
        \ilAssQuestionSkillAssignment $assignment
    ): \ilAssQuestionSolutionComparisonExpression {
        $expression = new \ilAssQuestionSolutionComparisonExpression();
        $expression->setQuestionId($assignment->getQuestionId());
        $expression->setSkillBaseId($assignment->getSkillBaseId());
        $expression->setSkillTrefId($assignment->getSkillTrefId());
 
        $expression->setOrderIndex($this->tt->int($normalized['order_index']));
        $expression->setExpression($this->tt->string($normalized['expression']));
        $expression->setPoints($this->tt->int($normalized['points']));
 
        return $expression;
    }
}