From 91ff6d7683a1833a7b0758f6de6c26325b4ee708 Mon Sep 17 00:00:00 2001
From: Richard Klees <richard.klees@concepts-and-training.de>
Date: Fri, 27 Sep 2024 08:52:00 +0200
Subject: [PATCH] Component: add Activities

---
 cli/entry_point.php                           |  39 ++++
 components/ILIAS/Component/Component.php      |  11 +
 .../Component/src/Activities/Activity.php     |  74 +++++++
 .../Component/src/Activities/ActivityImpl.php |  33 +++
 .../Component/src/Activities/ActivityType.php |  27 +++
 .../Activities/ListActivitiesEntryPoint.php   |  44 ++++
 .../ILIAS/Component/src/Activities/Query.php  |  32 +++
 .../ILIAS/Component/src/Activities/README.md  | 190 ++++++++++++++++++
 .../Component/src/Activities/Repository.php   |  34 ++++
 .../src/Activities/StaticRepository.php       |  71 +++++++
 .../tests/Activities/StaticRepositoryTest.php | 167 +++++++++++++++
 components/ILIAS/Setup/Setup.php              |   3 +
 .../ILIAS/Setup/src/Activities/GetStatus.php  |  48 +++++
 13 files changed, 773 insertions(+)
 create mode 100644 cli/entry_point.php
 create mode 100644 components/ILIAS/Component/src/Activities/Activity.php
 create mode 100644 components/ILIAS/Component/src/Activities/ActivityImpl.php
 create mode 100644 components/ILIAS/Component/src/Activities/ActivityType.php
 create mode 100644 components/ILIAS/Component/src/Activities/ListActivitiesEntryPoint.php
 create mode 100644 components/ILIAS/Component/src/Activities/Query.php
 create mode 100644 components/ILIAS/Component/src/Activities/README.md
 create mode 100644 components/ILIAS/Component/src/Activities/Repository.php
 create mode 100644 components/ILIAS/Component/src/Activities/StaticRepository.php
 create mode 100644 components/ILIAS/Component/tests/Activities/StaticRepositoryTest.php
 create mode 100644 components/ILIAS/Setup/src/Activities/GetStatus.php

diff --git a/cli/entry_point.php b/cli/entry_point.php
new file mode 100644
index 000000000000..b38d55b4e5c2
--- /dev/null
+++ b/cli/entry_point.php
@@ -0,0 +1,39 @@
+<?php
+
+/**
+ * This file is part of ILIAS, a powerful learning management system
+ * published by ILIAS open source e-Learning e.V.
+ *
+ * ILIAS is licensed with the GPL-3.0,
+ * see https://www.gnu.org/licenses/gpl-3.0.en.html
+ * You should have received a copy of said license along with the
+ * source code, too.
+ *
+ * If this is not the case or you just want to try ILIAS, you'll find
+ * us at:
+ * https://www.ilias.de
+ * https://github.com/ILIAS-eLearning
+ *
+ *********************************************************************/
+
+declare(strict_types=1);
+
+$info = <<<INFO
+Hello there.
+
+This calls an arbitrary entrypoint of ILIAS for testing purpose. For more informations
+about entrypoints, have a look into `components/ILIAS/Component/src/EntryPoint.php`.
+
+INFO;
+
+if (count($argv) !== 3) {
+    echo $info;
+    die("php cli/entry_point.php \$bootstrap \$name\n");
+}
+
+$bootstrap = $argv[1];
+$entry_point = $argv[2];
+
+require_once(__DIR__ . "/../artifacts/bootstrap_$bootstrap.php");
+
+exit(entry_point($entry_point));
diff --git a/components/ILIAS/Component/Component.php b/components/ILIAS/Component/Component.php
index c6e2000512ae..c0cea15a0749 100644
--- a/components/ILIAS/Component/Component.php
+++ b/components/ILIAS/Component/Component.php
@@ -32,7 +32,18 @@ public function init(
         array | \ArrayAccess &$pull,
         array | \ArrayAccess &$internal,
     ): void {
+        $define[] = Component\Activities\Repository::class;
+
+        $implement[Component\Activities\Repository::class] = static fn() =>
+            new Component\Activities\StaticRepository(
+                $seek[Component\Activities\Activity::class]
+            );
+
         $contribute[Component\EntryPoint::class] = static fn() => new Component\EntryPoint\HelloWorld("Component/HelloWorld");
+        $contribute[Component\EntryPoint::class] = static fn() =>
+            new Component\Activities\ListActivitiesEntryPoint(
+                $use[Component\Activities\Repository::class]
+            );
 
         $contribute[\ILIAS\Setup\Agent::class] = static fn() =>
             new \ilComponentsSetupAgent(
diff --git a/components/ILIAS/Component/src/Activities/Activity.php b/components/ILIAS/Component/src/Activities/Activity.php
new file mode 100644
index 000000000000..4c054ee0b2e3
--- /dev/null
+++ b/components/ILIAS/Component/src/Activities/Activity.php
@@ -0,0 +1,74 @@
+<?php
+
+/**
+ * This file is part of ILIAS, a powerful learning management system
+ * published by ILIAS open source e-Learning e.V.
+ *
+ * ILIAS is licensed with the GPL-3.0,
+ * see https://www.gnu.org/licenses/gpl-3.0.en.html
+ * You should have received a copy of said license along with the
+ * source code, too.
+ *
+ * If this is not the case or you just want to try ILIAS, you'll find
+ * us at:
+ * https://www.ilias.de
+ * https://github.com/ILIAS-eLearning
+ *
+ *********************************************************************/
+
+declare(strict_types=1);
+
+namespace ILIAS\Component\Activities;
+
+use ILIAS\Component\Dependencies\Name;
+use ILIAS\UI\Component\Input\Control\Form\FormInput;
+use ILIAS\Data\Result;
+
+/**
+ * An Activity is an action on the domain layer action of a component.
+ *
+ * This defines the interface to any activity. When implementing Activities,
+ * you should use one of these base classes:
+ *
+ *
+ *
+ */
+interface Activity
+{
+    /**
+     * Shall return classname of the Activity, wrapped in Name.
+     */
+    public function getName(): Name;
+
+    public function getType(): ActivityType;
+
+    public function getDescription(): string; // shall be TextHandling/Markdown some day
+
+    public function getInputDescription(): FormInput; // might better be ILIAS/UI/Input/Input, but we would need to promote many properties there before.
+
+    /**
+     * This shall check if the given user is allowed to perform the activity based
+     * on business rules of this component. This shall, for example, check if the
+     * given user may add this other user to a course based on RBAC and position
+     * permissions, but this shall not check overall business rules such as: root
+     * may do everything. This shall not cause any observable side effects.
+     *
+     * @param mixed $parameters whatever the `FormInput` from `getInputDescription` produces.
+     */
+    public function isAllowedToPerform(int $usr_id, mixed $parameters): bool;
+
+    /**
+     * This shall perform the activity. This shall not check if a user is allowed to perform the activity.
+     *
+     * @throws any SPL Exception (https://www.php.net/manual/en/spl.exceptions.php)
+     * @param mixed $parameters whatever the `FormInput` from `getInputDescription` produces.
+     */
+    public function perform(mixed $parameters): mixed;
+
+    /**
+     * Grinds the $raw_parameters through the input description, checks if the users
+     * is allowed to perform the action as requested and, if so, then attempts to
+     * performs it. Wraps the result and possible errors in the `Result` type.
+     */
+    public function maybePerformAs(int $usr_id, array $raw_parameters): Result;
+}
diff --git a/components/ILIAS/Component/src/Activities/ActivityImpl.php b/components/ILIAS/Component/src/Activities/ActivityImpl.php
new file mode 100644
index 000000000000..7af091b41abe
--- /dev/null
+++ b/components/ILIAS/Component/src/Activities/ActivityImpl.php
@@ -0,0 +1,33 @@
+<?php
+
+/**
+ * This file is part of ILIAS, a powerful learning management system
+ * published by ILIAS open source e-Learning e.V.
+ *
+ * ILIAS is licensed with the GPL-3.0,
+ * see https://www.gnu.org/licenses/gpl-3.0.en.html
+ * You should have received a copy of said license along with the
+ * source code, too.
+ *
+ * If this is not the case or you just want to try ILIAS, you'll find
+ * us at:
+ * https://www.ilias.de
+ * https://github.com/ILIAS-eLearning
+ *
+ *********************************************************************/
+
+declare(strict_types=1);
+
+namespace ILIAS\Component\Activities;
+
+/**
+ * Basic Implementation for Activities. Use Command or Query for more speficism
+ * instead.
+ */
+abstract class ActivityImpl implements Activity
+{
+    public function getName(): \ILIAS\Component\Dependencies\Name
+    {
+        return new \ILIAS\Component\Dependencies\Name(static::class);
+    }
+}
diff --git a/components/ILIAS/Component/src/Activities/ActivityType.php b/components/ILIAS/Component/src/Activities/ActivityType.php
new file mode 100644
index 000000000000..21b9105035b0
--- /dev/null
+++ b/components/ILIAS/Component/src/Activities/ActivityType.php
@@ -0,0 +1,27 @@
+<?php
+
+/**
+ * This file is part of ILIAS, a powerful learning management system
+ * published by ILIAS open source e-Learning e.V.
+ *
+ * ILIAS is licensed with the GPL-3.0,
+ * see https://www.gnu.org/licenses/gpl-3.0.en.html
+ * You should have received a copy of said license along with the
+ * source code, too.
+ *
+ * If this is not the case or you just want to try ILIAS, you'll find
+ * us at:
+ * https://www.ilias.de
+ * https://github.com/ILIAS-eLearning
+ *
+ *********************************************************************/
+
+declare(strict_types=1);
+
+namespace ILIAS\Component\Activities;
+
+enum ActivityType: string
+{
+    case Command = "command";
+    case Query = "query";
+}
diff --git a/components/ILIAS/Component/src/Activities/ListActivitiesEntryPoint.php b/components/ILIAS/Component/src/Activities/ListActivitiesEntryPoint.php
new file mode 100644
index 000000000000..1406c3409fa1
--- /dev/null
+++ b/components/ILIAS/Component/src/Activities/ListActivitiesEntryPoint.php
@@ -0,0 +1,44 @@
+<?php
+
+/**
+ * This file is part of ILIAS, a powerful learning management system
+ * published by ILIAS open source e-Learning e.V.
+ *
+ * ILIAS is licensed with the GPL-3.0,
+ * see https://www.gnu.org/licenses/gpl-3.0.en.html
+ * You should have received a copy of said license along with the
+ * source code, too.
+ *
+ * If this is not the case or you just want to try ILIAS, you'll find
+ * us at:
+ * https://www.ilias.de
+ * https://github.com/ILIAS-eLearning
+ *
+ *********************************************************************/
+
+declare(strict_types=1);
+
+namespace ILIAS\Component\Activities;
+
+use ILIAS\Component\EntryPoint;
+use ILIAS\Component\Component;
+
+/**
+ * A simple entrypoint that just says hello, for testing and documentation
+ * purpose.
+ */
+class ListActivitiesEntryPoint extends EntryPoint\Base
+{
+    public function __construct(
+        protected Repository $repository
+    ) {
+        parent::__construct(self::class);
+    }
+
+    public function enter(): int
+    {
+        echo join("\n", array_keys(iterator_to_array($this->repository->getActivitiesByName("/.*/"))));
+        echo "\n";
+        return 0;
+    }
+}
diff --git a/components/ILIAS/Component/src/Activities/Query.php b/components/ILIAS/Component/src/Activities/Query.php
new file mode 100644
index 000000000000..e4636a126566
--- /dev/null
+++ b/components/ILIAS/Component/src/Activities/Query.php
@@ -0,0 +1,32 @@
+<?php
+
+/**
+ * This file is part of ILIAS, a powerful learning management system
+ * published by ILIAS open source e-Learning e.V.
+ *
+ * ILIAS is licensed with the GPL-3.0,
+ * see https://www.gnu.org/licenses/gpl-3.0.en.html
+ * You should have received a copy of said license along with the
+ * source code, too.
+ *
+ * If this is not the case or you just want to try ILIAS, you'll find
+ * us at:
+ * https://www.ilias.de
+ * https://github.com/ILIAS-eLearning
+ *
+ *********************************************************************/
+
+declare(strict_types=1);
+
+namespace ILIAS\Component\Activities;
+
+/**
+ * Basic class for Queries.
+ */
+abstract class Query extends ActivityImpl
+{
+    public function getType(): \ILIAS\Component\Activities\ActivityType
+    {
+        return ActivityType::Query;
+    }
+}
diff --git a/components/ILIAS/Component/src/Activities/README.md b/components/ILIAS/Component/src/Activities/README.md
new file mode 100644
index 000000000000..ef9d654e40ca
--- /dev/null
+++ b/components/ILIAS/Component/src/Activities/README.md
@@ -0,0 +1,190 @@
+# Activities
+
+## Abstract
+
+The aim of the facilities in this folder is to allow to build a discernible layer
+where developers can find "Activities" with objects and services in the system.
+
+**An Activity is a way in which a user would want to use our system or the a
+subsystem thereof.** Hence, Activities target the domain layer of our system
+and the various subsystems and make the things that user do there referenceable.
+Examples for activities would be things like: "Create a Course", "Add Members to
+a Group", "Make a Test available.".
+
+These examples, superficially, might look as if they could be mapped onto according
+calls on existing objects, such as `ilObjCourse::create`, `ilParticipants::addMember`
+or `ilObjTest::setOnline`. But in reality this is not the case. When users say they
+want to create a course, they do no only mean to programmatically "Create a ilObjCourse"
+PHP-object. The object needs to be put in the Repository somewhere. Permissions need
+to be checked. Same for "Add Members to a Group". This is what the "Domain" of our
+software is, in difference to the programming that we use to implement that domain.
+
+By explicitly introducing Activities via a common framework, the system and its
+components gain a lot of benefits:
+
+* Activities offer a way to present a domain level API to other developers, webservices
+  and end users in a machine-readable way.
+* Activities offer a documentation in the ILIAS GUI for end users to take advantage
+  of the available services e.g. in webservice integrations or workflow definitions.
+* Activities to maintain such APIs in the components where they arise but still
+  present them to the complete system in a consumer agnostic way.
+
+## Design
+
+From the perspective of a component, every [**Activity**](./Activity.php) is provided
+as the general way to use the component, together with according information and
+facilities to make actual use of the activity. Activities have a name that is the
+class name of the activity. They have a description in markdown format that shall
+give additional information about the Activity that can not be derived from its name.
+Activities describe their input as a FormInput from the UI framework, which is a
+common and widely useful way to talk about user inputs to the system. The central
+functions of any `Activity` are one function to check the permission for a given
+user to perform a certain activity and the method to actually perform it.
+
+Activities are contributed to the system via the [according mechanisms of the
+component framework](docs/development/components-and-directories.md#contribute-to-service-or-functionality).
+Activities can use then use the mechanisms from the component framework to use
+facilities from other components. An Activity can and should also use activities
+from other components, if it requires cooperation from other domains. Depending
+on the case at hand, the implementor should then decide if a permission check for
+the Activity at hand should or should not delegate to checks to sub permissions.
+Any dependency of an Activity should be introduced via dependency injection.
+
+Activities come in two flavors:
+
+* A `Command` changes the state of the system, but does not return data from the
+  system. It can and should of course return information e.g. regarding the success
+  of the state change. And it can and should of course use data from the system
+  to perform the command.
+* A `Query` returns data from the system, but does not induce state changes. A state
+  change is understood as a change in the business data of the system, even queries
+  could e.g. cause entries in logs.
+
+This differentiation is important to allow the system to make various decisions,
+such as:
+
+* If the Activity is performed via an HTTP endpoint: Would it be GET or POST?
+* Can I reorder this sequence of Activities without changing meaning?
+* Can I cache the results of that Activity? Do I expect the same results upon
+  performing the same Activity twice?
+
+That means that implementors of Activities should carefully decide which type an
+Activity actually has to prevent side effects.
+
+The flavors are represented as a property on activities to allow the framework to
+combine activities. Some `Query` that returns a list of users and some `Command`
+that acts on one user could be combined to a `Command` that act on multiple users.
+Facilities to allow for combinations won't be implemented in the first iterations
+on the framework, though.
+
+## Usage
+
+### As User of a Specific Activity
+
+For many use cases you will want to perform a specific activity. A table of members,
+for example, will need a specific `Query` to get the data for this exact table. If
+we want to do something with a row in that table, we also should know which exact
+`Command` it is that should be performed.
+
+For this cases, you most likely should [pull](docs/development/components-and-directories.md#pull-code)
+the required Activity as a dependency into the location where you need it, e.g.
+a GUI class. You will need this exact `Activity` after all, not any similar `Activity`
+or a some stand in.
+
+If the `Activity` at hand is an activity of your component, or some very closely
+related component, you might already have the correct `$parameters` at hand anyway
+and you could use `isAllowedToPerform` and `perform` in appropriate locations. An
+activity "Remove Member" for example, belongs to the component that shows the table
+of members.
+
+If the components are only losely related, you might be better of using `maybePerformAs`
+with the parameters provided as primitives in an array. This method will internally
+mangle the parameters accordingly via the `InputDescription`. This should be more
+robust with regards to changes in the other component, such as changes in internal
+data representation or inputs that are accepted. "Send Mail to Member" for example,
+could be considered an activity from a losely related component for our member table.
+
+### As User of Generic Activities
+
+For some use cases, you won't be interested in any specific `Activity` but instead
+you will want to have access to all activities provided by the system. Just similar
+to the Kitchen Sink, we may want to build an automated documentation about all
+available activities some day.
+
+For this case, you most likely will want to use the [`Repository`](components/ILIAS/Component/src/Activities/Repository.php)
+of activities. The Repository will allow you to select some or all Activities from
+the system.
+
+To deal with a single but generic `Activity` from the `Repository`, keep in mind
+that the input to the `Activity` as described by `getInputDescription` is a quite
+generic tool, although being defined in terms of the UI framework:
+
+* the `FormInput` can be used verbatim to collect input from users via the GUI
+* `FormInput` supports input in JSON format, so it should be simple to use it when
+  serialization comes into play
+* `FormInputs` provide information about the single fields that can be used as
+  a description of the expected inputs
+* `FormInput` can be used to get appropriatly represented data to be used as
+  `$parameters` for `isAllowedToPerform` and `perform` without needing to know
+  the actual content or representation of said data
+
+By using the `Repository` and the information and methods from a single `Activity`,
+you should be able to get a firm grip on each and every `Activity` in the system
+without the requirement to actually know any `Activity` individually.
+
+### As Implementor
+
+Please take the documentation in `Activity` seriously. The methods in every `Activity`
+have a specific relation to each other that need to be maintained to allow the
+coherent usage of activities, be it specific activities or generic activities as
+described above. This e.g. means:
+
+* If an input is accepted by `getInputDescription` it shall not make `isAllowedToPerform` or `perform` crash.
+* `maybePerformAs` shall use `getInputDescription`, `isAllowedToPerform` and `perform`
+ in a very specific pattern.
+* If `getType` is `Query`, perform shouldn't cause side effects.
+
+To simplify the implementation, the documentation for the class lists some base
+classes that could be used for the implementation.
+
+If you have implemented activities for your component you should integrate them
+with the system according to the [existing integration mechanisms](docs/development/components-and-directories.md):
+
+* You should [provide them with as specific name](docs/development/components-and-directories.md#pull-code), so other components can pull them.
+* You should [contribute them to the system](docs/development/components-and-directories.md#contribute-to-service-or-functionality) so generic facilities such as the `Repository` can discover them as well.
+
+## Introduction to the System
+
+Currently (in late 2024), the Activities only exist as an idea in this readme and
+some code to support the usage of them. But this is very thin, as there are no
+actual Activities on the one hand but also no users of the Activities on the other
+hand. We do not aim to implement all possible Activities at once, neither we expect
+that all possible Activities will be implemented ever.
+
+The next phase, after this general idea and the supporting code is approved by the
+community, we aim to:
+
+* implement a webservice interface over the activities
+* pick one specific component (currently we think Study Programme) and implement
+  some useful Activities for the Study Programme
+
+This should showcase how the Activities are useful, but also should provide actual
+value and lay the groundwork to quickly provide more value by adding additional
+activities.
+
+We also will be looking to replace the current SOAP implementation with an Activity
+based implementation and provide the according actions as Activities.
+
+In this process we will also introduce the Activities that we implement into the
+according GUIs to demonstrate how Activities also will provide value from a code
+maintenance perspective.
+
+Once this phase is finished, we will leave it to the community to create further
+momentum. If we can demonstrate the value of the Activities and the connected implementations,
+it will be as easy as never before to expose functionality via webservice. We expect
+to create a win/win situation, where funding will be available for new Activities and
+developers will be eager to move code from GUIs to Activities as well.
+
+We also expect interesting new uses of Activities to arise that could be implemented
+as proof-of-concept components without the ILIAS community as a component provided
+by a vendor, or be included in existing ILIAS infrastructure.
diff --git a/components/ILIAS/Component/src/Activities/Repository.php b/components/ILIAS/Component/src/Activities/Repository.php
new file mode 100644
index 000000000000..a9a3cbf16815
--- /dev/null
+++ b/components/ILIAS/Component/src/Activities/Repository.php
@@ -0,0 +1,34 @@
+<?php
+
+/**
+ * This file is part of ILIAS, a powerful learning management system
+ * published by ILIAS open source e-Learning e.V.
+ *
+ * ILIAS is licensed with the GPL-3.0,
+ * see https://www.gnu.org/licenses/gpl-3.0.en.html
+ * You should have received a copy of said license along with the
+ * source code, too.
+ *
+ * If this is not the case or you just want to try ILIAS, you'll find
+ * us at:
+ * https://www.ilias.de
+ * https://github.com/ILIAS-eLearning
+ *
+ *********************************************************************/
+
+declare(strict_types=1);
+
+namespace ILIAS\Component\Activities;
+
+use ILIAS\Data\Range;
+
+interface Repository
+{
+    /**
+     * Get all activities where the name matches the provided regexp.
+     *
+     * @param string $name_matcher as preg_match can understand
+     * @return Iterator<string, Activity> where keys are the name
+     */
+    public function getActivitiesByName(string $name_matcher, ?ActivityType $type = null, ?Range $range = null): \Iterator;
+}
diff --git a/components/ILIAS/Component/src/Activities/StaticRepository.php b/components/ILIAS/Component/src/Activities/StaticRepository.php
new file mode 100644
index 000000000000..f02846cc175f
--- /dev/null
+++ b/components/ILIAS/Component/src/Activities/StaticRepository.php
@@ -0,0 +1,71 @@
+<?php
+
+/**
+ * This file is part of ILIAS, a powerful learning management system
+ * published by ILIAS open source e-Learning e.V.
+ *
+ * ILIAS is licensed with the GPL-3.0,
+ * see https://www.gnu.org/licenses/gpl-3.0.en.html
+ * You should have received a copy of said license along with the
+ * source code, too.
+ *
+ * If this is not the case or you just want to try ILIAS, you'll find
+ * us at:
+ * https://www.ilias.de
+ * https://github.com/ILIAS-eLearning
+ *
+ *********************************************************************/
+
+declare(strict_types=1);
+
+namespace ILIAS\Component\Activities;
+
+use ILIAS\Data\Range;
+
+class StaticRepository implements Repository
+{
+    protected array $activities = [];
+
+    /**
+     * @param array<Activity> $ativities
+     */
+    public function __construct(
+        array $activities
+    ) {
+        foreach ($activities as $activity) {
+            if (!($activity instanceof Activity)) {
+                throw new \InvalidArgumentException(
+                    "Expected `Activity`, got: " . get_class($activity)
+                );
+            }
+            $this->activities[(string) $activity->getName()] = $activity;
+        }
+    }
+
+    public function getActivitiesByName(string $name_matcher, ?ActivityType $type = null, ?Range $range = null): \Iterator
+    {
+        if ($range !== null) {
+            [$start, $length] = $range->unpack();
+        } else {
+            [$start, $length] = [0, PHP_INT_MAX];
+        }
+
+        foreach ($this->activities as $name => $activity) {
+            if ($type !== null && $activity->getType() !== $type) {
+                continue;
+            }
+            if (preg_match($name_matcher, $name)) {
+                if ($start <= 0) {
+                    $length--;
+                    yield $name => $activity;
+                }
+            }
+
+            $start--;
+
+            if ($length === 0) {
+                break;
+            }
+        }
+    }
+}
diff --git a/components/ILIAS/Component/tests/Activities/StaticRepositoryTest.php b/components/ILIAS/Component/tests/Activities/StaticRepositoryTest.php
new file mode 100644
index 000000000000..79b72534f994
--- /dev/null
+++ b/components/ILIAS/Component/tests/Activities/StaticRepositoryTest.php
@@ -0,0 +1,167 @@
+<?php
+
+/**
+ * This file is part of ILIAS, a powerful learning management system
+ * published by ILIAS open source e-Learning e.V.
+ *
+ * ILIAS is licensed with the GPL-3.0,
+ * see https://www.gnu.org/licenses/gpl-3.0.en.html
+ * You should have received a copy of said license along with the
+ * source code, too.
+ *
+ * If this is not the case or you just want to try ILIAS, you'll find
+ * us at:
+ * https://www.ilias.de
+ * https://github.com/ILIAS-eLearning
+ *
+ *********************************************************************/
+
+declare(strict_types=1);
+
+namespace ILIAS\Component\Tests\Activities;
+
+use PHPUnit\Framework\TestCase;
+use ILIAS\Component\Activities\StaticRepository;
+use ILIAS\Component\Activities\Activity;
+use ILIAS\Component\Activities\ActivityType;
+use ILIAS\Component\Dependencies\Name;
+
+class StaticRepositoryTest extends TestCase
+{
+    public function testEmptyRepository(): void
+    {
+        $repository = new StaticRepository([]);
+
+        $this->assertEquals([], iterator_to_array($repository->getActivitiesByName("%.*%")));
+    }
+
+    public function testKeyIsName(): void
+    {
+        $name = "\\ILIAS\\Component\\Tests\\SomeActivity";
+
+        $activity = $this->createMock(Activity::class);
+        $activity
+            ->method("getName")
+            ->willReturn(new Name($name));
+
+        $repository = new StaticRepository([$activity]);
+
+        $activities = iterator_to_array($repository->getActivitiesByName("%.*%"));
+
+        $this->assertEquals($activity, $activities[$name]);
+    }
+
+    public function testGetActivitiesByNameNoMatch(): void
+    {
+        $name = "\\ILIAS\\Component\\Tests\\SomeActivity";
+
+        $activity = $this->createMock(Activity::class);
+        $activity
+            ->method("getName")
+            ->willReturn(new Name($name));
+
+        $repository = new StaticRepository([$activity]);
+
+        $activities = iterator_to_array($repository->getActivitiesByName("%Foo%"));
+
+        $this->assertEquals([], $activities);
+    }
+
+    public function testGetActivitiesByNameMatch(): void
+    {
+        $name = "\\ILIAS\\Component\\Tests\\SomeActivity";
+
+        $activity = $this->createMock(Activity::class);
+        $activity
+            ->method("getName")
+            ->willReturn(new Name($name));
+
+        $repository = new StaticRepository([$activity]);
+
+        $activities = iterator_to_array($repository->getActivitiesByName("%.*Some.*%"));
+
+        $this->assertEquals($activity, $activities[$name]);
+    }
+
+    public function testGetActivitiesByTypeNoMatch(): void
+    {
+        $name = "\\ILIAS\\Component\\Tests\\SomeActivity";
+
+        $activity = $this->createMock(Activity::class);
+        $activity
+            ->method("getName")
+            ->willReturn(new Name($name));
+        $activity
+            ->method("getType")
+            ->willReturn(ActivityType::Command);
+
+        $repository = new StaticRepository([$activity]);
+
+        $activities = iterator_to_array($repository->getActivitiesByName("%.*%", ActivityType::Query));
+
+        $this->assertEquals([], $activities);
+    }
+
+    public function testGetActivitiesByTypeMatch(): void
+    {
+        $name = "\\ILIAS\\Component\\Tests\\SomeActivity";
+
+        $activity = $this->createMock(Activity::class);
+        $activity
+            ->method("getName")
+            ->willReturn(new Name($name));
+        $activity
+            ->method("getType")
+            ->willReturn(ActivityType::Command);
+
+        $repository = new StaticRepository([$activity]);
+
+        $activities = iterator_to_array($repository->getActivitiesByName("%.*%", ActivityType::Command));
+
+        $this->assertEquals([$activity], array_values($activities));
+    }
+
+    public function testGetActivitiesInRange(): void
+    {
+        $name = "\\ILIAS\\Component\\Tests\\SomeActivity";
+
+        $activity = $this->createMock(Activity::class);
+        $activity
+            ->method("getName")
+            ->willReturnOnConsecutiveCalls(
+                new Name($name . "1"),
+                new Name($name . "2"),
+                new Name($name . "3"),
+                new Name($name . "4"),
+                new Name($name . "5")
+            );
+
+        $repository = new StaticRepository([$activity, $activity, $activity, $activity, $activity]);
+
+        $activities = iterator_to_array($repository->getActivitiesByName("%.*%", null, new \ILIAS\Data\Range(0, 3)));
+
+        $this->assertEquals([$activity, $activity, $activity], array_values($activities));
+    }
+
+    public function testGetActivitiesInRange2(): void
+    {
+        $name = "\\ILIAS\\Component\\Tests\\SomeActivity";
+
+        $activity = $this->createMock(Activity::class);
+        $activity
+            ->method("getName")
+            ->willReturnOnConsecutiveCalls(
+                new Name($name . "1"),
+                new Name($name . "2"),
+                new Name($name . "3"),
+                new Name($name . "4"),
+                new Name($name . "5")
+            );
+
+        $repository = new StaticRepository([$activity, $activity, $activity, $activity, $activity]);
+
+        $activities = iterator_to_array($repository->getActivitiesByName("%.*%", null, new \ILIAS\Data\Range(3, 3)));
+
+        $this->assertEquals([$activity, $activity], array_values($activities));
+    }
+}
diff --git a/components/ILIAS/Setup/Setup.php b/components/ILIAS/Setup/Setup.php
index a9f43efbbddf..7588849e00b3 100644
--- a/components/ILIAS/Setup/Setup.php
+++ b/components/ILIAS/Setup/Setup.php
@@ -50,6 +50,9 @@ public function init(
                 $pull[\ILIAS\Data\Factory::class]
             );
 
+        $contribute[\ILIAS\Component\Activities\Activity::class] = static fn() =>
+            new \ILIAS\Setup\Activities\GetStatus();
+
         $internal["command.install"] = static fn() =>
             new \ILIAS\Setup\CLI\InstallCommand(
                 $internal["agent_finder"],
diff --git a/components/ILIAS/Setup/src/Activities/GetStatus.php b/components/ILIAS/Setup/src/Activities/GetStatus.php
new file mode 100644
index 000000000000..1257af6e2fe9
--- /dev/null
+++ b/components/ILIAS/Setup/src/Activities/GetStatus.php
@@ -0,0 +1,48 @@
+<?php
+
+/**
+ * This file is part of ILIAS, a powerful learning management system
+ * published by ILIAS open source e-Learning e.V.
+ *
+ * ILIAS is licensed with the GPL-3.0,
+ * see https://www.gnu.org/licenses/gpl-3.0.en.html
+ * You should have received a copy of said license along with the
+ * source code, too.
+ *
+ * If this is not the case or you just want to try ILIAS, you'll find
+ * us at:
+ * https://www.ilias.de
+ * https://github.com/ILIAS-eLearning
+ *
+ *********************************************************************/
+
+declare(strict_types=1);
+
+namespace ILIAS\Setup\Activities;
+
+use ILIAS\Component\Dependencies\Name;
+use ILIAS\UI\Component\Input\Control\Form\FormInput;
+use ILIAS\Data\Result;
+
+class GetStatus extends \ILIAS\Component\Activities\Query
+{
+    public function getDescription(): string
+    {
+    }
+
+    public function getInputDescription(): \ILIAS\UI\Component\Input\Control\Form\FormInput
+    {
+    }
+
+    public function isAllowedToPerform(int $usr_id, mixed $parameters): bool
+    {
+    }
+
+    public function perform(mixed $parameters): mixed
+    {
+    }
+
+    public function maybePerformAs(int $usr_id, array $raw_parameters): Result
+    {
+    }
+}