Add stock images, closes #2482

Closes #2482

Merge request studip/studip!1788

app/controllers/stock_images.php

+<?php
+
+class StockImagesController extends AuthenticatedController
+{
+    /**
+     * Common tasks for all actions.
+     */
+    public function before_filter(&$action, &$args)
+    {
+        parent::before_filter($action, $args);
+
+        URLHelper::removeLinkParam('cid');
+        $GLOBALS['perm']->check('admin');
+
+        if (Navigation::hasItem('/contents/stock_images')) {
+            Navigation::activateItem('/contents/stock_images');
+        }
+        \PageLayout::setTitle(_('Verwaltung des Bilder-Pools'));
+        $this->setSidebar();
+    }
+
+    /**
+     * Administration view for banner
+     */
+    public function index_action(): void
+    {
+    }
+
+    /**
+     * Setup the sidebar
+     */
+    protected function setSidebar(): void
+    {
+        $sidebar = \Sidebar::Get();
+        $sidebar->addWidget(new \VueWidget('stock-images-widget'));
+    }
+}

app/views/stock_images/index.php

+<div class="stock-images"></div>

cli/studip

@@ -65,7 +65,7 @@ $commands = [
     Commands\User\GetUser::class,
 ];
 $creator = function ($command) {
-    return new $command();
+    return app($command);
 };
 $application->addCommands(array_map($creator, $commands));
 $application->run();

composer.json

@@ -59,7 +59,8 @@
         "symfony/polyfill-php74": "^1.27",
         "symfony/polyfill-php80": "^1.27",
         "symfony/polyfill-php81": "^1.27",
-        "phpowermove/docblock": "^2.0"
+        "phpowermove/docblock": "^2.0",
+        "ksubileau/color-thief-php": "^2.0"
     },
     "replace": {
         "symfony/polyfill-php54": "*",

db/migrations/5.4.7_create_stock_images_table.php

+<?php
+
+class CreateStockImagesTable extends Migration
+{
+    public function description()
+    {
+        return 'create table for stock images';
+    }
+
+    public function up()
+    {
+        $db = DBManager::get();
+        $query =
+            "CREATE TABLE IF NOT EXISTS `stock_images` (
+             `id` int(11) NOT NULL AUTO_INCREMENT,
+
+             `title` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
+             `description` text CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
+             `license` text CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
+             `author` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
+
+             `mime_type` varchar(64) CHARACTER SET latin1 COLLATE latin1_bin NOT NULL,
+             `size` int(10) UNSIGNED NOT NULL,
+             `width` int(10) UNSIGNED NOT NULL,
+             `height` int(10) UNSIGNED NOT NULL,
+             `palette` text CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
+             `tags` text CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
+
+             `mkdate` int(11) UNSIGNED NOT NULL,
+             `chdate` int(11) UNSIGNED NOT NULL,
+
+             PRIMARY KEY (`id`))";
+        $db->exec($query);
+    }
+
+    public function down()
+    {
+        $db = DBManager::get();
+        $db->exec('DROP TABLE IF EXISTS `stock_images`');
+    }
+}

db/migrations/5.4.8_add_image_type_to_structural_elements.php

+<?php
+
+class AddImageTypeToStructuralElements extends Migration
+{
+    public function description()
+    {
+        return 'Add field `image_type` to table `cw_structural_elements`';
+    }
+
+    public function up()
+    {
+        $db = DBManager::get();
+        $db->exec(
+            sprintf(
+                'ALTER TABLE `cw_structural_elements` ' .
+                    'ADD `image_type` ENUM("%s", "%s") NOT NULL DEFAULT "%1$s" AFTER `image_id`',
+                \FileRef::class,
+                \StockImage::class
+            )
+        );
+    }
+
+    public function down()
+    {
+        $db = DBManager::get();
+        $db->exec('ALTER TABLE `cw_structural_elements` DROP `image_type`');
+    }
+}

lib/classes/JsonApi/RouteMap.php

@@ -132,6 +132,7 @@ class RouteMap
         $this->addAuthenticatedLtiRoutes($group);
         $this->addAuthenticatedMessagesRoutes($group);
         $this->addAuthenticatedNewsRoutes($group);
+        $this->addAuthenticatedStockImagesRoutes($group);
         $this->addAuthenticatedStudyAreasRoutes($group);
         $this->addAuthenticatedTreeRoutes($group);
         $this->addAuthenticatedWikiRoutes($group);
@@ -597,6 +598,17 @@ class RouteMap
         $group->delete('/forum-entries/{id}', Routes\Forum\ForumEntriesDelete::class);
     }
 
+    private function addAuthenticatedStockImagesRoutes(RouteCollectorProxy $group): void
+    {
+        $group->get('/stock-images', Routes\StockImages\StockImagesIndex::class);
+        $group->post('/stock-images', Routes\StockImages\StockImagesCreate::class);
+        $group->get('/stock-images/{id}', Routes\StockImages\StockImagesShow::class);
+        $group->patch('/stock-images/{id}', Routes\StockImages\StockImagesUpdate::class);
+        $group->delete('/stock-images/{id}', Routes\StockImages\StockImagesDelete::class);
+
+        $group->post('/stock-images/{id}/blob', Routes\StockImages\StockImagesUpload::class);
+    }
+
     private function addRelationship(RouteCollectorProxy $group, string $url, string $handler): void
     {
         $group->map(['GET', 'PATCH', 'POST', 'DELETE'], $url, $handler);

lib/classes/JsonApi/Routes/Courseware/StructuralElementsImageDelete.php

@@ -21,11 +21,13 @@ class StructuralElementsImageDelete extends NonJsonApiController
             throw new AuthorizationFailedException();
         }
 
-        if ($structuralElement->image) {
+        // remove existing image
+        if (is_a($structuralElement->image, \FileRef::class)) {
             $structuralElement->image->getFileType()->delete();
         }
 
         $structuralElement->image_id = null;
+        $structuralElement->image_type = \FileRef::class;
         $structuralElement->store();
 
         return $response->withStatus(204);

lib/classes/JsonApi/Routes/Courseware/StructuralElementsImageUpload.php

@@ -34,12 +34,13 @@ class StructuralElementsImageUpload extends NonJsonApiController
         $fileRef = $this->handleUpload($request, $publicFolder, $structuralElement);
 
         // remove existing image
-        if ($structuralElement->image) {
+        if (is_a($structuralElement->image, \FileRef::class)) {
             $structuralElement->image->getFileType()->delete();
         }
 
         // refer to newly uploaded image
         $structuralElement->image_id = $fileRef->id;
+        $structuralElement->image_type = \FileRef::class;
         $structuralElement->store();
 
         return $response->withStatus(201);

lib/classes/JsonApi/Routes/Courseware/StructuralElementsUpdate.php

@@ -8,6 +8,8 @@ use JsonApi\Errors\RecordNotFoundException;
 use JsonApi\JsonApiController;
 use JsonApi\Routes\ValidationTrait;
 use JsonApi\Schemas\Courseware\StructuralElement as StructuralElementSchema;
+use JsonApi\Schemas\FileRef as FileRefSchema;
+use JsonApi\Schemas\StockImage as StockImageSchema;
 use Psr\Http\Message\ResponseInterface as Response;
 use Psr\Http\Message\ServerRequestInterface as Request;
 
@@ -83,6 +85,17 @@ class StructuralElementsUpdate extends JsonApiController
                 }
             }
         }
+
+        $imageRelationship = 'data.relationships.' . StructuralElementSchema::REL_IMAGE;
+        if (self::arrayHas($json, $imageRelationship)) {
+            $relation = self::arrayGet($json, $imageRelationship);
+            if (isset($relation['data']['type'])) {
+                $validTypes = [FileRefSchema::TYPE, StockImageSchema::TYPE];
+                if (!in_array($relation['data']['type'], $validTypes)) {
+                    return 'Relationship `image` can only be of type ' . join(', ', $validTypes);
+                }
+            }
+        }
     }
 
     private function getParentFromJson($json)
@@ -114,7 +127,7 @@ class StructuralElementsUpdate extends JsonApiController
 
             foreach ($attributes as $jsonKey) {
                 $sormKey = strtr($jsonKey, '-', '_');
-                if ($val = self::arrayGet($json, 'data.attributes.'.$jsonKey, '')) {
+                if ($val = self::arrayGet($json, 'data.attributes.' . $jsonKey, '')) {
                     $resource->$sormKey = $val;
                 }
             }
@@ -133,10 +146,73 @@ class StructuralElementsUpdate extends JsonApiController
                 $resource->parent_id = $parent->id;
             }
 
+            // update image
+            $this->updateImage($resource, $json);
+
             $resource->editor_id = $user->id;
             $resource->store();
 
             return $resource;
         });
     }
+
+    private function updateImage(StructuralElement $resource, array $json): void
+    {
+        if (!$this->imageNeedsUpdate($resource, $json)) {
+            return;
+        }
+
+        $currentImage = $resource->image;
+        list($imageType, $imageId) = $this->getImageRelationshipData($json);
+
+        // remove current image
+        if (!$imageType && !$imageId) {
+            if (is_a($currentImage, \FileRef::class)) {
+                $currentImage->getFileType()->delete();
+            }
+            $resource->image_id = null;
+            $resource->image_type = null;
+        } elseif ($imageType === StockImageSchema::TYPE) {
+            $stockImageExists = \StockImage::countBySQL('id = ?', [$imageId]);
+            if (!$stockImageExists) {
+                throw new RecordNotFoundException('Could not find that stock image.');
+            }
+            $resource->image_id = $imageId;
+            $resource->image_type = \StockImage::class;
+        } elseif ($imageType === FileRefSchema::TYPE) {
+            throw new \RuntimeException('Not yet implemented.');
+        }
+    }
+
+    private function getImageRelationshipData(array $json): array
+    {
+        $imageRelationship = 'data.relationships.' . StructuralElementSchema::REL_IMAGE;
+        if (!self::arrayHas($json, $imageRelationship)) {
+            throw new \RuntimeException('Missing relationship `image`');
+        }
+        $relation = self::arrayGet($json, $imageRelationship);
+
+        return [self::arrayGet($relation, 'data.type'), self::arrayGet($relation, 'data.id')];
+    }
+
+    private function imageNeedsUpdate(StructuralElement $resource, array $json): bool
+    {
+        $imageRelationship = 'data.relationships.' . StructuralElementSchema::REL_IMAGE;
+        if (!self::arrayHas($json, $imageRelationship)) {
+            return false;
+        }
+
+        $currentImage = $resource->image;
+        list($imageType, $imageId) = $this->getImageRelationshipData($json);
+
+        if (!$currentImage) {
+            return (bool) $imageId;
+        }
+
+        $currentImageSchema = $this->getSchema($currentImage);
+
+        return ($currentImage && !$imageId)
+            || $currentImageSchema::TYPE !== $imageType
+            || $currentImage->id != $imageId;
+    }
 }

lib/classes/JsonApi/Routes/StockImages/Authority.php

+<?php
+
+namespace JsonApi\Routes\StockImages;
+
+use StockImage;
+use User;
+
+class Authority
+{
+    /**
+     * @SuppressWarnings(PHPMD.UnusedFormalParameter)
+     */
+    public static function canIndexStockImages(User $user): bool
+    {
+        return true;
+    }
+
+    /**
+     * @SuppressWarnings(PHPMD.UnusedFormalParameter)
+     */
+    public static function canShowStockImage(User $user, StockImage $resource): bool
+    {
+        return true;
+    }
+
+    /**
+     * @SuppressWarnings(PHPMD.Superglobals)
+     */
+    public static function canCreateStockImage(User $user): bool
+    {
+        return $GLOBALS['perm']->have_perm('admin', $user->id);
+    }
+
+    /**
+     * @SuppressWarnings(PHPMD.UnusedFormalParameter)
+     */
+    public static function canUpdateStockImage(User $user, StockImage $resource): bool
+    {
+        return self::canCreateStockImage($user);
+    }
+
+    /**
+     * @SuppressWarnings(PHPMD.UnusedFormalParameter)
+     */
+    public static function canUploadStockImage(User $user, StockImage $resource): bool
+    {
+        return self::canCreateStockImage($user);
+    }
+
+    /**
+     * @SuppressWarnings(PHPMD.UnusedFormalParameter)
+     */
+    public static function canDeleteStockImage(User $user, StockImage $resource): bool
+    {
+        return self::canCreateStockImage($user);
+    }
+}

lib/classes/JsonApi/Routes/StockImages/StockImagesCreate.php

+<?php
+
+namespace JsonApi\Routes\StockImages;
+
+use JsonApi\Errors\AuthorizationFailedException;
+use JsonApi\Errors\RecordNotFoundException;
+use JsonApi\JsonApiController;
+use JsonApi\Routes\ValidationTrait;
+use JsonApi\Schemas\StockImage as ResourceSchema;
+use Psr\Http\Message\ResponseInterface as Response;
+use Psr\Http\Message\ServerRequestInterface as Request;
+use StockImage;
+use User;
+
+/**
+ * Creates a stock image.
+ */
+class StockImagesCreate extends JsonApiController
+{
+    use ValidationTrait;
+    use ValidationHelpers;
+
+    /**
+     * @SuppressWarnings(PHPMD.UnusedFormalParameter)
+     */
+    public function __invoke(Request $request, Response $response, $args): Response
+    {
+        $json = $this->validate($request, $resource);
+        $user = $this->getUser($request);
+        if (!Authority::canCreateStockImage($user, $resource)) {
+            throw new AuthorizationFailedException();
+        }
+        $resource = $this->createResource($json);
+
+        return $this->getContentResponse($resource);
+    }
+
+    /**
+     * @SuppressWarnings(PHPMD.UnusedFormalParameter)
+     */
+    protected function validateResourceDocument($json, $data)
+    {
+        if (!self::arrayHas($json, 'data')) {
+            return 'Missing `data` member at document´s top level.';
+        }
+
+        if (ResourceSchema::TYPE !== self::arrayGet($json, 'data.type')) {
+            return 'Wrong `type` member of document´s `data`.';
+        }
+
+        $errors = iterator_to_array(self::requiredAttributes($json, ['title', 'description', 'author', 'license']));
+        if (!empty($errors)) {
+            return current($errors);
+        }
+
+        // optional attribute `tags` has to be an array
+        if (self::arrayHas($json, 'data.attributes.tags')) {
+            $tags = self::arrayGet($json, 'data.attributes.tags', []);
+            if (!is_array($tags) || !array_is_list($tags)) {
+                return 'Attribute `tags` has to be a list of strings.';
+            }
+        }
+    }
+
+    protected static function requiredAttributes($json, $keys)
+    {
+        foreach ($keys as $key) {
+            $path = 'data.attributes.' . $key;
+            $value = self::arrayGet($json, $path, '');
+            if (empty($value)) {
+                yield sprintf('Missing or empty attribute `%s`', $key);
+            }
+        }
+    }
+
+    private function createResource(array $json): StockImage
+    {
+        $resource = new StockImage();
+        $resource->setData(
+            array_merge(
+                self::getAttributeDefaults(),
+                self::getAttributeUpdates($json, ['title', 'description', 'author', 'license']),
+                self::getTags($json)
+            )
+        );
+        $resource->store();
+
+        return $resource;
+    }
+
+    private static function getAttributeDefaults(): iterable
+    {
+        return [
+            'height' => 0,
+            'mime_type' => '',
+            'size' => 0,
+            'width' => 0,
+            'tags' => '[]',
+        ];
+    }
+}

lib/classes/JsonApi/Routes/StockImages/StockImagesDelete.php

+<?php
+
+namespace JsonApi\Routes\StockImages;
+
+use JsonApi\Errors\AuthorizationFailedException;
+use JsonApi\Errors\RecordNotFoundException;
+use JsonApi\JsonApiController;
+use Psr\Http\Message\ResponseInterface as Response;
+use Psr\Http\Message\ServerRequestInterface as Request;
+use StockImage;
+use User;
+
+/**
+ * Deletes one stock image.
+ */
+class StockImagesDelete extends JsonApiController
+{
+    public function __invoke(Request $request, Response $response, $args): Response
+    {
+        $resource = StockImage::find($args['id']);
+        if (!$resource) {
+            throw new RecordNotFoundException();
+        }
+
+        if (!Authority::canDeleteStockImage($this->getUser($request), $resource)) {
+            throw new AuthorizationFailedException();
+        }
+        $resource->delete();
+
+        return $this->getCodeResponse(204);
+    }
+}

lib/classes/JsonApi/Routes/StockImages/StockImagesIndex.php

+<?php
+
+namespace JsonApi\Routes\StockImages;
+
+use JsonApi\Errors\AuthorizationFailedException;
+use JsonApi\Errors\RecordNotFoundException;
+use JsonApi\JsonApiController;
+use Psr\Http\Message\ResponseInterface as Response;
+use Psr\Http\Message\ServerRequestInterface as Request;
+
+/**
+ * Displays all stock images.
+ */
+class StockImagesIndex extends JsonApiController
+{
+    protected $allowedPagingParameters = ['offset', 'limit'];
+
+    /**
+     * @SuppressWarnings(PHPMD.UnusedFormalParameter)
+     */
+    public function __invoke(Request $request, Response $response): Response
+    {
+        if (!Authority::canIndexStockImages($this->getUser($request))) {
+            throw new AuthorizationFailedException();
+        }
+
+        list($offset, $limit) = $this->getOffsetAndLimit();
+        $total = \StockImage::countBySQL('1');
+        $stockImages = \StockImage::findBySQL("1 ORDER BY title ASC LIMIT {$offset}, {$limit}");
+
+        return $this->getPaginatedContentResponse($stockImages, $total);
+    }
+}

lib/classes/JsonApi/Routes/StockImages/StockImagesShow.php

+<?php
+
+namespace JsonApi\Routes\StockImages;
+
+use JsonApi\Errors\AuthorizationFailedException;
+use JsonApi\Errors\RecordNotFoundException;
+use JsonApi\JsonApiController;
+use Psr\Http\Message\ResponseInterface as Response;
+use Psr\Http\Message\ServerRequestInterface as Request;
+
+/**
+ * Displays one stock image.
+ */
+class StockImagesShow extends JsonApiController
+{
+    public function __invoke(Request $request, Response $response, $args): Response
+    {
+        $resource = \StockImage::find($args['id']);
+        if (!$resource) {
+            throw new RecordNotFoundException();
+        }
+
+        if (!Authority::canShowStockImage($this->getUser($request), $resource)) {
+            throw new AuthorizationFailedException();
+        }
+
+        return $this->getContentResponse($resource);
+    }
+}

lib/classes/JsonApi/Routes/StockImages/StockImagesUpdate.php

+<?php
+
+namespace JsonApi\Routes\StockImages;
+
+use JsonApi\Errors\AuthorizationFailedException;
+use JsonApi\Errors\RecordNotFoundException;
+use JsonApi\JsonApiController;
+use JsonApi\Routes\ValidationTrait;
+use JsonApi\Schemas\StockImage as ResourceSchema;
+use Psr\Http\Message\ResponseInterface as Response;
+use Psr\Http\Message\ServerRequestInterface as Request;
+use StockImage;
+use User;
+
+/**
+ * Updates a stock image.
+ */
+class StockImagesUpdate extends JsonApiController
+{
+    use ValidationTrait;
+    use ValidationHelpers;
+
+    /**
+     * @SuppressWarnings(PHPMD.UnusedFormalParameter)
+     */
+    public function __invoke(Request $request, Response $response, $args): Response
+    {
+        $resource = StockImage::find($args['id']);
+        if (!$resource) {
+            throw new RecordNotFoundException();
+        }
+
+        $json = $this->validate($request, $resource);
+        $user = $this->getUser($request);
+        if (!Authority::canUpdateStockImage($user, $resource)) {
+            throw new AuthorizationFailedException();
+        }
+        $resource = $this->updateResource($resource, $json);
+
+        return $this->getContentResponse($resource);
+    }
+
+    /**
+     * @SuppressWarnings(PHPMD.UnusedFormalParameter)
+     */
+    protected function validateResourceDocument($json, $data)
+    {
+        if (!self::arrayHas($json, 'data')) {
+            return 'Missing `data` member at document´s top level.';
+        }
+
+        if (ResourceSchema::TYPE !== self::arrayGet($json, 'data.type')) {
+            return 'Wrong `type` member of document´s `data`.';
+        }
+
+        if (!self::arrayHas($json, 'data.id')) {
+            return 'Document must have an `id`.';
+        }
+
+        $errors = iterator_to_array(self::nonEmptyAttributes($json, ['title', 'description', 'author', 'license']));
+        if (!empty($errors)) {
+            return current($errors);
+        }
+
+        // optional attribute `tags` has to be an array
+        if (self::arrayHas($json, 'data.attributes.tags')) {
+            $tags = self::arrayGet($json, 'data.attributes.tags', []);
+            if (!is_array($tags) || !array_is_list($tags)) {
+                return 'Attribute `tags` has to be a list of strings.';
+            }
+        }
+    }
+
+    protected static function nonEmptyAttributes($json, $keys)
+    {
+        foreach ($keys as $key) {
+            $path = 'data.attributes.' . $key;
+            if (self::arrayHas($json, $path)) {
+                $value = self::arrayGet($json, $path);
+                if (empty($value)) {
+                    yield sprintf('Attribute `%s` must not be empty', $key);
+                }
+            }
+        }
+    }
+
+    private function updateResource(StockImage $resource, array $json): void
+    {
+        $updates = array_merge(
+            self::getAttributeUpdates($json, ['title', 'description', 'author', 'license']),
+            self::getTags($json)
+        );
+        $resource->setData($updates);
+        $resource->store();
+    }
+}

lib/classes/JsonApi/Routes/StockImages/StockImagesUpload.php

+<?php
+
+namespace JsonApi\Routes\StockImages;
+
+use JsonApi\Errors\AuthorizationFailedException;
+use JsonApi\Errors\BadRequestException;
+use JsonApi\Errors\RecordNotFoundException;
+use JsonApi\NonJsonApiController;
+use Psr\Http\Message\ResponseInterface as Response;
+use Psr\Http\Message\ServerRequestInterface as Request;
+use Slim\Psr7\UploadedFile;
+use Studip\StockImages\Scaler;
+use Studip\StockImages\PaletteCreator;
+
+class StockImagesUpload extends NonJsonApiController
+{
+    /**
+     * @SuppressWarnings(PHPMD.UnusedFormalParameter)
+     */
+    public function __invoke(Request $request, Response $response, $args): Response
+    {
+        $resource = \StockImage::find($args['id']);
+        if (!$resource) {
+            throw new RecordNotFoundException();
+        }
+
+        if (!Authority::canUploadStockImage($this->getUser($request), $resource)) {
+            throw new AuthorizationFailedException();
+        }
+
+        $this->handleUpload($request, $resource);
+        $this->processStockImage($resource);
+
+        return $this->redirectToStockImage($response, $resource);
+    }
+
+    private function handleUpload(Request $request, \StockImage $resource): void
+    {
+        $uploadedFile = $this->getUploadedFile($request);
+        if (UPLOAD_ERR_OK !== $uploadedFile->getError()) {
+            $error = $this->getErrorString($uploadedFile->getError());
+            throw new BadRequestException($error);
+        }
+
+        $error = self::validate($uploadedFile);
+        if (!empty($error)) {
+            throw new BadRequestException($error);
+        }
+
+        $resource->mime_type = $uploadedFile->getClientMediaType();
+        $resource->size = $uploadedFile->getSize();
+        $uploadedFile->moveTo($resource->getPath());
+
+        $imageSize = getimagesize($resource->getPath());
+        $resource->width = $imageSize[0];
+        $resource->height = $imageSize[1];
+
+        $resource->store();
+    }
+
+    private function getUploadedFile(Request $request): UploadedFile
+    {
+        $files = iterator_to_array($this->getUploadedFiles($request));
+
+        if (0 === count($files)) {
+            throw new BadRequestException('File upload required.');
+        }
+
+        if (count($files) > 1) {
+            throw new BadRequestException('Multiple file upload not possible.');
+        }
+
+        $uploadedFile = reset($files);
+        if (UPLOAD_ERR_OK !== $uploadedFile->getError()) {
+            throw new BadRequestException('Upload error.');
+        }
+
+        return $uploadedFile;
+    }
+
+    /**
+     * @return iterable<UploadedFile> a list of uploaded files
+     */
+    private function getUploadedFiles(Request $request): iterable
+    {
+        foreach ($request->getUploadedFiles() as $item) {
+            if (!is_array($item)) {
+                yield $item;
+                continue;
+            }
+            foreach ($item as $file) {
+                yield $file;
+            }
+        }
+    }
+
+    private function getErrorString(int $errNo): string
+    {
+        $errors = [
+            UPLOAD_ERR_OK => 'There is no error, the file uploaded with success',
+            UPLOAD_ERR_INI_SIZE => 'The uploaded file exceeds the upload_max_filesize directive in php.ini',
+            UPLOAD_ERR_FORM_SIZE => 'The uploaded file exceeds the MAX_FILE_SIZE directive that was specified in the HTML form',
+            UPLOAD_ERR_PARTIAL => 'The uploaded file was only partially uploaded',
+            UPLOAD_ERR_NO_FILE => 'No file was uploaded',
+            UPLOAD_ERR_NO_TMP_DIR => 'Missing a temporary folder',
+            UPLOAD_ERR_CANT_WRITE => 'Failed to write file to disk.',
+            UPLOAD_ERR_EXTENSION => 'A PHP extension stopped the file upload.',
+        ];
+
+        return $errors[$errNo] ?? '';
+    }
+
+    /**
+     * @return string|null null, if the file is valid, otherwise a string containing the error
+     */
+    private function validate(UploadedFile $file)
+    {
+        $mimeType = $file->getClientMediaType();
+        if (!in_array($mimeType, ['image/gif', 'image/jpeg', 'image/png', 'image/webp'])) {
+            return 'Unsupported media type.';
+        }
+    }
+
+    /**
+     * @SuppressWarnings(PHPMD.Superglobals)
+     */
+    private function redirectToStockImage(Response $response, \StockImage $stockImage): Response
+    {
+        $pathinfo = $this->getSchema($stockImage)
+            ->getSelfLink($stockImage)
+            ->getStringRepresentation($this->container->get('json-api-integration-urlPrefix'));
+        $old = \URLHelper::setBaseURL($GLOBALS['ABSOLUTE_URI_STUDIP']);
+        $url = \URLHelper::getURL($pathinfo, [], true);
+        \URLHelper::setBaseURL($old);
+
+        return $response->withHeader('Location', $url)->withStatus(201);
+    }
+
+    private function processStockImage(\StockImage $resource): void
+    {
+        $scaler = new Scaler();
+        $scaler($resource);
+        $paletteCreator = new PaletteCreator();
+        $paletteCreator($resource);
+    }
+}

lib/classes/JsonApi/Routes/StockImages/ValidationHelpers.php

+<?php
+
+namespace JsonApi\Routes\StockImages;
+
+trait ValidationHelpers
+{
+    protected static function getAttributeUpdates($json, iterable $keys): iterable
+    {
+        return array_reduce(
+            $keys,
+            function ($memo, $key) use ($json) {
+                $path = 'data.attributes.' . $key;
+                if (self::arrayHas($json, $path)) {
+                    $memo[$key] = self::arrayGet($json, $path);
+                }
+                return $memo;
+            },
+            []
+        );
+    }
+
+    protected static function getTags($json): iterable
+    {
+        return ['tags' => json_encode(self::arrayGet($json, 'data.attributes.tags', []))];
+    }
+}

lib/classes/JsonApi/SchemaMap.php

@@ -40,6 +40,7 @@ class SchemaMap
             \SemType::class => Schemas\SemType::class,
             \SeminarCycleDate::class => Schemas\SeminarCycleDate::class,
             \Statusgruppen::class => Schemas\StatusGroup::class,
+            \StockImage::class => Schemas\StockImage::class,
             \JsonApi\Models\Studip::class => Schemas\Studip::class,
             \JsonApi\Models\StudipProperty::class => Schemas\StudipProperty::class,
             \StudipComment::class => Schemas\StudipComment::class,