class.ilTestRandomQuestionSetSourcePoolDefinitionList.php

Go to the documentation of this file.

<?php
/* Copyright (c) 1998-2013 ILIAS open source, Extended GPL, see docs/LICENSE */
 
require_once 'Modules/Test/classes/class.ilTestRandomQuestionSetNonAvailablePool.php';
class ilTestRandomQuestionSetSourcePoolDefinitionList implements Iterator
{
    protected $db = null;
 
    protected $testOBJ = null;
 
    private $sourcePoolDefinitions = array();
 
    private $sourcePoolDefinitionFactory = null;
 
    protected $lostPools = array();
 
    protected $trashedPools = array();
 
    public function __construct(ilDBInterface $db, ilObjTest $testOBJ, ilTestRandomQuestionSetSourcePoolDefinitionFactory $sourcePoolDefinitionFactory)
    {
        $this->db = $db;
        $this->testOBJ = $testOBJ;
        $this->sourcePoolDefinitionFactory = $sourcePoolDefinitionFactory;
    }
 
    public function addDefinition(ilTestRandomQuestionSetSourcePoolDefinition $sourcePoolDefinition)
    {
        $this->sourcePoolDefinitions[ $sourcePoolDefinition->getId() ] = $sourcePoolDefinition;
    }
 
    protected function addLostPool(ilTestRandomQuestionSetNonAvailablePool $lostPool)
    {
        $this->lostPools[$lostPool->getId()] = $lostPool;
    }
 
    public function isLostPool($poolId)
    {
        return isset($this->lostPools[$poolId]);
    }
 
    public function hasLostPool()
    {
        return (bool) count($this->lostPools);
    }
 
    public function getLostPools()
    {
        return $this->lostPools;
    }
 
    public function getLostPool($poolId)
    {
        if ($this->isLostPool($poolId)) {
            return $this->lostPools[$poolId];
        }
 
        return null;
    }
 
    public function isTrashedPool($poolId)
    {
        return isset($this->trashedPools[$poolId]);
    }
 
    public function hasTrashedPool()
    {
        return (bool) count($this->trashedPools);
    }
 
    public function getTrashedPools()
    {
        return $this->trashedPools;
    }
 
    public function setTrashedPools($trashedPools)
    {
        $this->trashedPools = $trashedPools;
    }
 
    // hey: fixRandomTestBuildable - provide single definitions, quantities distribution likes to deal with objects
 
    public function hasDefinition($sourcePoolDefinitionId)
    {
        return $this->getDefinition($sourcePoolDefinitionId) !== null;
    }
 
    public function getDefinition($sourcePoolDefinitionId)
    {
        if (isset($this->sourcePoolDefinitions[$sourcePoolDefinitionId])) {
            return $this->sourcePoolDefinitions[$sourcePoolDefinitionId];
        }
 
        return null;
    }
 
    public function getDefinitionBySourcePoolId($sourcePoolId)
    {
        foreach ($this as $definition) {
            if ($definition->getPoolId() != $sourcePoolId) {
                continue;
            }
 
            return $definition;
        }
 
        throw new InvalidArgumentException('invalid source pool id given');
    }
 
    public function getDefinitionIds()
    {
        return array_keys($this->sourcePoolDefinitions);
    }
 
    public function getDefinitionCount()
    {
        return count($this->sourcePoolDefinitions);
    }
    // hey.
 
    public function loadDefinitions()
    {
        $query = "
                        SELECT tst_rnd_quest_set_qpls.*, odat.obj_id pool_id, odat.title actual_pool_title, tree.child
                        FROM tst_rnd_quest_set_qpls
                        LEFT JOIN object_data odat
                        ON odat.obj_id = pool_fi
                        LEFT JOIN object_reference oref
                        ON oref.obj_id = pool_fi
                        LEFT JOIN tree
                        ON tree = %s
                        AND child = oref.ref_id
                        WHERE test_fi = %s
                        ORDER BY sequence_pos ASC
                ";
 
        $res = $this->db->queryF($query, array('integer', 'integer'), array(1, $this->testOBJ->getTestId()));
 
        $handledDefinitions = array();
        $trashedPools = array();
 
        while ($row = $this->db->fetchAssoc($res)) {
            $sourcePoolDefinition = $this->sourcePoolDefinitionFactory->getEmptySourcePoolDefinition();
            $sourcePoolDefinition->initFromArray($row);
 
            if (!isset($handledDefinitions[$sourcePoolDefinition->getId()])) {
                $this->addDefinition($sourcePoolDefinition);
                $handledDefinitions[$sourcePoolDefinition->getId()] = $sourcePoolDefinition->getId();
 
                $trashedPool = new ilTestRandomQuestionSetNonAvailablePool();
                $trashedPool->assignDbRow($row);
 
                $trashedPool->setUnavailabilityStatus(
                    ilTestRandomQuestionSetNonAvailablePool::UNAVAILABILITY_STATUS_TRASHED
                );
 
                $trashedPools[$trashedPool->getId()] = $trashedPool;
            }
 
            if (!$this->isLostPool($row['pool_id'])
                && !$row['pool_id']) {
                $lostPool = new ilTestRandomQuestionSetNonAvailablePool();
                $lostPool->assignDbRow($row);
 
                $lostPool->setUnavailabilityStatus(
                    ilTestRandomQuestionSetNonAvailablePool::UNAVAILABILITY_STATUS_LOST
                );
 
                $this->addLostPool($lostPool);
 
                if (isset($trashedPools[$lostPool->getId()])) {
                    unset($trashedPools[$lostPool->getId()]);
                }
            }
 
            if (isset($row['actual_pool_title'])
                && $sourcePoolDefinition->getPoolTitle() !== $row['actual_pool_title']) {
                $sourcePoolDefinition->setPoolTitle($row['actual_pool_title']);
                $sourcePoolDefinition->saveToDb();
            }
 
            if ($row['child']) {
                unset($trashedPools[$row['pool_id']]);
            }
        }
 
        $this->setTrashedPools($trashedPools);
    }
 
    public function saveDefinitions()
    {
        foreach ($this as $sourcePoolDefinition) {
            $sourcePoolDefinition->saveToDb();
        }
    }
 
    public function cloneDefinitionsForTestId($testId)
    {
        $definitionIdMap = array();
 
        foreach ($this as $definition) {
            $originalId = $definition->getId();
            $definition->cloneToDbForTestId($testId);
            $cloneId = $definition->getId();
 
            $definitionIdMap[$originalId] = $cloneId;
        }
 
        return $definitionIdMap;
    }
 
    public function deleteDefinitions()
    {
        $query = "DELETE FROM tst_rnd_quest_set_qpls WHERE test_fi = %s";
        $this->db->manipulateF($query, array('integer'), array($this->testOBJ->getTestId()));
    }
 
    public function reindexPositions()
    {
        $positionIndex = array();
 
        foreach ($this as $definition) {
            $positionIndex[ $definition->getId() ] = $definition->getSequencePosition();
        }
 
        asort($positionIndex);
 
        $i = 1;
 
        foreach ($positionIndex as $definitionId => $definitionPosition) {
            $positionIndex[$definitionId] = $i++;
        }
 
        foreach ($this as $definition) {
            $definition->setSequencePosition($positionIndex[$definition->getId()]);
        }
    }
 
    public function getNextPosition()
    {
        return (count($this->sourcePoolDefinitions) + 1);
    }
 
    public function getInvolvedSourcePoolIds()
    {
        $involvedSourcePoolIds = array();
 
        foreach ($this as $definition) {
            $involvedSourcePoolIds[ $definition->getPoolId() ] = $definition->getPoolId();
        }
 
        return array_values($involvedSourcePoolIds);
    }
 
    public function getQuestionAmount()
    {
        $questionAmount = 0;
 
        foreach ($this as $definition) {
            $questionAmount += $definition->getQuestionAmount();
        }
 
        return $questionAmount;
    }
 
    public function savedDefinitionsExist()
    {
        $query = "SELECT COUNT(*) cnt FROM tst_rnd_quest_set_qpls WHERE test_fi = %s";
        $res = $this->db->queryF($query, array('integer'), array($this->testOBJ->getTestId()));
 
        $row = $this->db->fetchAssoc($res);
 
        return $row['cnt'] > 0;
    }
 
    public function hasTaxonomyFilters()
    {
        foreach ($this as $definition) {
            // fau: taxFilter/typeFilter - new check for existing taxonomy filter
            if (count($definition->getMappedTaxonomyFilter())) {
                return true;
            }
            #if( $definition->getMappedFilterTaxId() && $definition->getMappedFilterTaxNodeId() )
            #{
            #   return true;
            #}
            // fau.
        }
 
        return false;
    }
 
    // fau: taxFilter/typeFilter - check for existing type filters
    public function hasTypeFilters()
    {
        foreach ($this as $definition) {
            if (count($definition->getTypeFilter())) {
                return true;
            }
        }
        return false;
    }
    // fau.
 
    public function areAllUsedPoolsAvailable()
    {
        if ($this->hasLostPool()) {
            return false;
        }
 
        if ($this->hasTrashedPool()) {
            return false;
        }
 
        return true;
    }
 
    public function rewind()
    {
        return reset($this->sourcePoolDefinitions);
    }
 
    public function current()
    {
        return current($this->sourcePoolDefinitions);
    }
 
    public function key()
    {
        return key($this->sourcePoolDefinitions);
    }
 
    public function next()
    {
        return next($this->sourcePoolDefinitions);
    }
 
    public function valid()
    {
        return key($this->sourcePoolDefinitions) !== null;
    }
 
    public function getNonAvailablePools()
    {
        //echo get_class($this->getTrashedPools()[0]);
        return array_merge($this->getTrashedPools(), $this->getLostPools());
    }
}