AbstractTask.php

Go to the documentation of this file.

<?php

namespace ILIAS\BackgroundTasks\Implementation\Tasks;

use ILIAS\BackgroundTasks\Exceptions\InvalidArgumentException;
use ILIAS\BackgroundTasks\Implementation\Tasks\UserInteraction\UserInteractionOption;
use ILIAS\BackgroundTasks\Implementation\Values\PrimitiveValueWrapperFactory;
use ILIAS\BackgroundTasks\Implementation\Values\ScalarValues\BasicScalarValueFactory;
use ILIAS\BackgroundTasks\Implementation\Values\ThunkValue;
use ILIAS\BackgroundTasks\Task;
use ILIAS\BackgroundTasks\Value;

abstract class AbstractTask implements Task
{
    use BasicScalarValueFactory;
    const MAIN_REMOVE = 'bt_main_remove';
    const MAIN_ABORT = 'bt_main_abort';
    protected $input = [];
    protected $output;


    public function setInput(array $values)
    {
        $this->input = $this->getValues($values);
        $this->checkTypes($this->input);
    }


    protected function checkTypes($values)
    {
        $expectedTypes = $this->getInputTypes();

        for ($i = 0; $i < count($expectedTypes); $i++) {
            $expectedType = $expectedTypes[$i];
            $givenType = $this->extractType($values[$i]);
            if (!$givenType->isExtensionOf($expectedType)) {
                throw new InvalidArgumentException("Types did not match when setting input for "
                                                   . get_called_class()
                                                   . ". Expected type $expectedType given type $givenType.");
            }
        }
    }


    protected function extractType($value)
    {
        if (is_a($value, Value::class)) {
            return $value->getType();
        }
        if (is_a($value, Task::class)) {
            ;
        }

        return $value->getOutputType();

        throw new InvalidArgumentException("Input values must be tasks or Values (extend BT\\Task or BT\\Value).");
    }


    public function getOutput()
    {
        $thunk = new ThunkValue($this->getOutputType());
        $thunk->setParentTask($this);

        return $thunk;
    }


    private function getValues($values)
    {
        $inputs = [];

        foreach ($values as $value) {
            if ($value instanceof Task) {
                $inputs[] = $value->getOutput();
            } elseif ($value instanceof Value) {
                $inputs[] = $value;
            } else {
                $inputs[] = $this->wrapScalar($value);
            }
        }

        return $inputs;
    }


    public function getInput()
    {
        return $this->input;
    }


    public function getType()
    {
        return get_called_class();
    }


    public function unfoldTask()
    {
        $list = [ $this ];
        foreach ($this->getInput() as $input) {
            if (is_a($input, ThunkValue::class)) {
                $list = array_merge($list, $input->getParentTask()->unfoldTask());
            }
        }

        return $list;
    }


    public function getRemoveOption()
    {
        return new UserInteractionOption('remove', self::MAIN_REMOVE);
    }


    public function getAbortOption()
    {
        return new UserInteractionOption('abort', self::MAIN_ABORT);
    }
}