BasicPersistence.php

Go to the documentation of this file.

<?php

namespace ILIAS\BackgroundTasks\Implementation\Persistence;

use ILIAS\BackgroundTasks\Bucket;
use ILIAS\BackgroundTasks\BucketMeta;
use ILIAS\BackgroundTasks\Exceptions\BucketNotFoundException;
use ILIAS\BackgroundTasks\Exceptions\SerializationException;
use ILIAS\BackgroundTasks\Implementation\Bucket\BasicBucket;
use ILIAS\BackgroundTasks\Implementation\Bucket\BasicBucketMeta;
use ILIAS\BackgroundTasks\Persistence;
use ILIAS\BackgroundTasks\Task;
use ILIAS\BackgroundTasks\Value;
use ILIAS\BackgroundTasks\Implementation\Bucket\State;

class BasicPersistence implements Persistence
{

    protected static $instance;
    protected static $buckets = [];
    protected $bucketHashToObserverContainerId;
    protected $taskHashToTaskContainerId;
    protected $valueHashToValueContainerId;
    protected static $tasks = [];
    protected $connector = null;


    public static function instance(\ilDBInterface $db) : \ILIAS\BackgroundTasks\Implementation\Persistence\BasicPersistence
    {
        if (!isset(self::$instance)) {
            self::$instance = new BasicPersistence($db);
        }

        return self::$instance;
    }
    public function __construct(\ilDBInterface $db)
    {
        $this->db = $db;
        $this->valueHashToValueContainerId = new \SplObjectStorage();
        $this->bucketHashToObserverContainerId = new \SplObjectStorage();
        $this->taskHashToTaskContainerId = new \SplObjectStorage();
    }

    protected function gc() : void
    {
        $this->db->manipulateF(
            "DELETE FROM il_bt_bucket WHERE user_id = %s AND (state = %s OR state = %s)",
            ['integer', 'integer', 'integer'],
            [defined('ANONYMOUS_USER_ID') ? \ANONYMOUS_USER_ID : 13, State::FINISHED, State::USER_INTERACTION]
        );
    }

    public function setConnector(\arConnector $c) : void
    {
        $this->connector = $c;
    }


    public function saveBucketAndItsTasks(Bucket $bucket)
    {
        $bucket->checkIntegrity();

        $this->saveObserver($bucket);
    }


    public function updateBucket(Bucket $bucket)
    {
        $bucketContainer = new BucketContainer($this->getBucketContainerId($bucket), $this->connector);

        // The basic information about the task.
        $bucketContainer->setUserId($bucket->getUserId());
        $bucketContainer->setState($bucket->getState());
        $bucketContainer->setTotalNumberoftasks(count($bucket->getTask()->unfoldTask()));
        $bucketContainer->setPercentage($bucket->getOverallPercentage());
        $bucketContainer->setTitle($bucket->getTitle());
        $bucketContainer->setLastHeartbeat($bucket->getLastHeartbeat());
        $bucketContainer->setDescription($bucket->getDescription());
        $bucketContainer->setCurrentTaskid($this->getTaskContainerId($bucket->getCurrentTask()));
        $bucketContainer->setRootTaskid($this->getTaskContainerId($bucket->getTask()));

        // Save and store the container to bucket instance.
        $bucketContainer->update();
    }


    public function getBucketIdsOfUser($user_id, $order_by = "id", $order_direction = "ASC")
    {
        // Garbage Collection
        $this->gc();

        return BucketContainer::where(['user_id' => $user_id])
            ->orderBy($order_by, $order_direction)
            ->getArray(null, 'id');
    }


    public function getBucketMetaOfUser($user_id)
    {
        $buckets = BucketContainer::where(['user_id' => $user_id])->get();
        $bucketMetas = array_map(function (BucketContainer $bucketContainer) {
            $bucketMeta = new BasicBucketMeta();

            $bucketMeta->setUserId($bucketContainer->getUserId());
            $bucketMeta->setState($bucketContainer->getState());
            $bucketMeta->setTitle($bucketContainer->getTitle());
            $bucketMeta->setDescription($bucketContainer->getDescription());
            $bucketMeta->setOverallPercentage($bucketContainer->getPercentage());

            return $bucketMeta;
        }, $buckets);

        return $bucketMetas;
    }


    public function getBucketIdsByState($state)
    {
        $buckets = BucketContainer::where(['state' => $state])->get();
        $ids = array_map(function (BucketContainer $bucket_container) {
            return $bucket_container->getId();
        }, $buckets);

        return $ids;
    }


    protected function saveObserver(Bucket $bucket)
    {
        // If the instance has a known container we use it, otherwise we create a new container.
        if ($this->bucketHashToObserverContainerId->contains($bucket)) {
            $bucketContainer = new BucketContainer($this->bucketHashToObserverContainerId[$bucket], $this->connector);
        } else {
            $bucketContainer = new BucketContainer(0, $this->connector);
        }

        // The basic information about the task.
        $bucketContainer->setUserId($bucket->getUserId());
        $bucketContainer->setState($bucket->getState());
        $bucketContainer->setTitle($bucket->getTitle());
        $bucketContainer->setDescription($bucket->getDescription());
        $bucketContainer->setTotalNumberoftasks(count($bucket->getTask()->unfoldTask()));
        $bucketContainer->setPercentage($bucket->getOverallPercentage());

        // We want to store the bucket ID in every sub task and value. Thus we need to create an id if not available yet.
        if (!$bucketContainer->getId()) {
            $bucketContainer->create();
        }

        // The recursive part.
        $this->saveTask($bucket->getTask(), $bucketContainer->getId());
        if (!$bucket->getCurrentTask()) {
            $bucket->setCurrentTask($bucket->getTask());
        }
        $bucketContainer->setCurrentTaskid($this->getTaskContainerId($bucket->getCurrentTask()));
        $bucketContainer->setRootTaskid($this->getTaskContainerId($bucket->getTask()));

        // Save and store the container to bucket instance.
        $bucketContainer->save();
        $this->bucketHashToObserverContainerId[$bucket] = $bucketContainer->getId();
    }


    protected function saveTask(Task $task, $bucketId)
    {
        // If the instance has a known container we use it, otherwise we create a new container.
        if ($this->taskHashToTaskContainerId->contains($task)) {
            $taskContainer = new TaskContainer($this->taskHashToTaskContainerId[$task], $this->connector);
        } else {
            $taskContainer = new TaskContainer(0, $this->connector);
        }

        // The basic information about the task.
        $taskContainer->setType($task->getType());
        $taskContainer->setBucketId($bucketId);
        $reflection = new \ReflectionClass(get_class($task));
        $taskContainer->setClassName(get_class($task));
        // bugfix mantis 23503
        $absolute_class_path = $reflection->getFileName();
        // $relative_class_path = str_replace(ILIAS_ABSOLUTE_PATH,".",$absolute_class_path);
        $taskContainer->setClassPath($reflection->getFileName());

        // Recursivly save the inputs and link them to this task.
        foreach ($task->getInput() as $k => $input) {
            $this->saveValue($input, $bucketId, $k);
        }
        $this->saveValueToTask($task, $taskContainer, $bucketId);

        // Save and store the container to the task instance.
        $taskContainer->save();
        $this->taskHashToTaskContainerId[$task] = $taskContainer->getId();
    }


    protected function saveValueToTask(Task $task, TaskContainer $taskContainer, $bucketId)
    {
        // If we have previous values to task associations we delete them.
        if ($taskContainer->getId()) {
            $olds = ValueToTaskContainer::where(['task_id' => $taskContainer->getId()])->get();
            foreach ($olds as $old) {
                $old->delete();
            }
        } else {
            // We need a valid ID to link the inputs
            $taskContainer->save();
        }

        // We create the new 1 to n relation.
        foreach ($task->getInput() as $k => $inputValue) {
            $v = new ValueToTaskContainer(0, $this->connector);
            $v->setTaskId($taskContainer->getId());
            $v->setPosition($k);
            $v->setBucketId($bucketId);
            $v->setValueId($this->getValueContainerId($inputValue));
            $v->save();
        }
    }


    protected function saveValue(Value $value, $bucketId, $position)
    {
        // If we have previous values to task associations we delete them.
        if ($this->valueHashToValueContainerId->contains($value)) {
            $valueContainer = new ValueContainer($this->valueHashToValueContainerId[$value], $this->connector);
        } else {
            $valueContainer = new ValueContainer(0, $this->connector);
        }

        // Save information about the value
        $reflection = new \ReflectionClass(get_class($value));
        $valueContainer->setClassName(get_class($value));
        // bugfix mantis 23503
        // $absolute_class_path = $reflection->getFileName();
        // $relative_class_path = str_replace(ILIAS_ABSOLUTE_PATH,".",$absolute_class_path);
        // $valueContainer->setClassPath($relative_class_path);
        $valueContainer->setType($value->getType());
        $valueContainer->setHasParenttask($value->hasParentTask());
        $valueContainer->setBucketId($bucketId);
        $valueContainer->setPosition($position);
        $valueContainer->setHash($value->getHash());
        $valueContainer->setSerialized($value->serialize());

        // If the value is a thunk value we also store its parent.
        if ($value->hasParentTask()) {
            $this->saveTask($value->getParentTask(), $bucketId);
            $valueContainer->setParentTaskid($this->getTaskContainerId($value->getParentTask()));
        }

        // We save the container and store the instance to container association.
        $valueContainer->save();
        $this->valueHashToValueContainerId->attach($value, $valueContainer->getId());
    }


    public function getBucketContainerId(Bucket $bucket)
    {
        if (!$this->bucketHashToObserverContainerId->contains(($bucket))) {
            throw new SerializationException("Could not resolve container id of task: "
                . print_r($bucket, true));
        }

        return $this->bucketHashToObserverContainerId[$bucket];
    }


    protected function getTaskContainerId(Task $task)
    {
        if (!$this->taskHashToTaskContainerId->contains($task)) {
            throw new SerializationException("Could not resolve container id of task: "
                . print_r($task, true));
        }

        return $this->taskHashToTaskContainerId[$task];
    }


    protected function getValueContainerId($value) : int
    {
        if (!$this->valueHashToValueContainerId->contains($value)) {
            throw new SerializationException("Could not resolve container id of value: "
                . print_r($value, true));
        }

        return (int) $this->valueHashToValueContainerId[$value];
    }


    public function loadBucket($bucket_id)
    {
        if (isset(self::$buckets[$bucket_id])) {
            return self::$buckets[$bucket_id];
        }
        $bucketContainer = BucketContainer::find($bucket_id);
        if (!$bucketContainer) {
            throw new BucketNotFoundException("The requested bucket with container id $bucket_id could not be found in the database.");
        }
        $bucket = new BasicBucket();

        $bucket->setUserId($bucketContainer->getUserId());
        $bucket->setState($bucketContainer->getState());
        $bucket->setTitle($bucketContainer->getTitle());
        $bucket->setDescription($bucketContainer->getDescription());
        $bucket->setOverallPercentage($bucketContainer->getPercentage());
        $bucket->setLastHeartbeat($bucketContainer->getLastHeartbeat());
        $bucket->setTask($this->loadTask($bucketContainer->getRootTaskid(), $bucket, $bucketContainer));

        $this->bucketHashToObserverContainerId[$bucket] = $bucket_id;

        return $bucket;
    }


    private function loadTask($taskContainerId, Bucket $bucket, BucketContainer $bucketContainer)
    {
        global $DIC;
        $factory = $DIC->backgroundTasks()->taskFactory();
        $taskContainer = TaskContainer::find($taskContainerId);
        $task = $factory->createTask($taskContainer->getClassName());

        // Bugfix 0023775
        // Added additional orderBy for the id to ensure that the items are returned in the right order.

        $valueToTasks = ValueToTaskContainer::where(['task_id' => $taskContainerId])
                                            ->orderBy('task_id')
                                            ->orderBy('position')
                                            ->orderBy('id')
                                            ->get();
        $inputs = [];
        foreach ($valueToTasks as $valueToTask) {
            $inputs[] = $this->loadValue($valueToTask->getValueId(), $bucket, $bucketContainer);
        }
        $task->setInput($inputs);

        if ($taskContainerId == $bucketContainer->getCurrentTaskid()) {
            $bucket->setCurrentTask($task);
        }

        $this->taskHashToTaskContainerId[$task] = $taskContainerId;

        return $task;
    }


    private function loadValue($valueContainerId, Bucket $bucket, BucketContainer $bucketContainer)
    {
        global $DIC;
        $factory = $DIC->backgroundTasks()->injector();

        $valueContainer = ValueContainer::find($valueContainerId);
        $value = $factory->createInstance($valueContainer->getClassName());

        $value->unserialize($valueContainer->getSerialized());
        if ($valueContainer->getHasParenttask()) {
            $value->setParentTask($this->loadTask($valueContainer->getParentTaskid(), $bucket, $bucketContainer));
        }

        $this->valueHashToValueContainerId[$value] = $valueContainerId;

        return $value;
    }


    public function deleteBucketById($bucket_id)
    {
//        return;
        $buckets = BucketContainer::where(['id' => $bucket_id])->get();
        array_map(function (\ActiveRecord $item) {
            $item->delete();
        }, $buckets);

        $tasks = TaskContainer::where(['bucket_id' => $bucket_id])->get();
        array_map(function (\ActiveRecord $item) {
            $item->delete();
        }, $tasks);

        $values = ValueContainer::where(['bucket_id' => $bucket_id])->get();
        array_map(function (\ActiveRecord $item) {
            $item->delete();
        }, $values);

        $valueToTasks = ValueToTaskContainer::where(['bucket_id' => $bucket_id])->get();
        array_map(function (\ActiveRecord $item) {
            $item->delete();
        }, $valueToTasks);
    }


    public function deleteBucket($bucket)
    {
        $id = $this->getBucketContainerId($bucket);
        $this->deleteBucketById($id);
        $this->bucketHashToObserverContainerId->detach($bucket);
    }


    public function loadBuckets($bucket_container_id)
    {
        $buckets = [];
        foreach ($bucket_container_id as $bucket_id) {
            try {
                $buckets[] = $this->loadBucket($bucket_id);
            } catch (\Throwable $t) {
                // there seem to be a problem with this container, we must delete it
                $this->deleteBucketById($bucket_id);
            }
        }

        return $buckets;
    }
}