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\ScalarValues\BasicScalarValueFactory;
use ILIAS\BackgroundTasks\Implementation\Values\ThunkValue;
use ILIAS\BackgroundTasks\Task;
use ILIAS\BackgroundTasks\Task\UserInteraction\Option;
use ILIAS\BackgroundTasks\Types\Type;
use ILIAS\BackgroundTasks\Value;

abstract class AbstractTask implements Task
{
    use BasicScalarValueFactory;

    public const MAIN_REMOVE = 'bt_main_remove';
    public const MAIN_ABORT = 'bt_main_abort';
    protected array $input = [];
    protected \ILIAS\BackgroundTasks\Value $output;

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

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

        foreach ($expectedTypes as $i => $expectedType) {
            $givenType = $this->extractType($values[$i]);
            if (!$givenType->isExtensionOf($expectedType)) {
                throw new InvalidArgumentException("Types did not match when setting input for "
                    . static::class
                    . ". Expected type $expectedType given type $givenType.");
            }
        }
    }

    protected function extractType($value): Type
    {
        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(): Value
    {
        $thunk = new ThunkValue($this->getOutputType());
        $thunk->setParentTask($this);

        return $thunk;
    }

    private function getValues($values): array
    {
        $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(): array
    {
        return $this->input;
    }

    public function getType(): string
    {
        return static::class;
    }

    public function unfoldTask(): array
    {
        $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(): Option
    {
        return new UserInteractionOption('remove', self::MAIN_REMOVE);
    }

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