Feature/extensible metadata properties

Classes/Command/AssetMetaDataMigrationCommandController.php

@@ -0,0 +1,48 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Neos\MetaData\Command;
+
+use Neos\Flow\Cli\CommandController;
+use Neos\Media\Domain\Model\Asset;
+use Neos\Media\Domain\Repository\AssetRepository;
+use Neos\MetaData\Domain\Dto\MetaDataAssetReference;
+use Neos\MetaData\Domain\Dto\MetaDataPropertyName;
+use Neos\MetaData\MetaDataManager;
+
+final class AssetMetaDataMigrationCommandController extends CommandController
+{
+    public function __construct(
+        private readonly MetaDataManager $metaDataManager,
+        private readonly AssetRepository $assetRepository,
+    ) {
+        parent::__construct();
+    }
+
+    public function migrateExistingAssetPropertiesCommand(): void
+    {
+        foreach ($this->assetRepository->findAll() as $asset) {
+            /** @var Asset $asset */
+            $title = $asset->getTitle();
+            $caption = $asset->getCaption();
+            $copyrightNotice = $asset->getCopyrightNotice();
+            $metaDataAssetReference = MetaDataAssetReference::fromAsset($asset);
+
+            if (!empty($caption)) {
+                $this->metaDataManager->setMetaDataPropertyValue(
+                    $metaDataAssetReference,
+                    MetaDataPropertyName::fromString('caption'),
+                    $asset->getCaption(),
+                );
+            }
+            if (!empty($copyrightNotice)) {
+                $this->metaDataManager->setMetaDataPropertyValue(
+                    $metaDataAssetReference,
+                    MetaDataPropertyName::fromString('copyright'),
+                    $asset->getCopyrightNotice(),
+                );
+            }
+        }
+    }
+}

Classes/Configuration/MetaDataConfigurationProvider.php

@@ -0,0 +1,14 @@
+<?php
+declare(strict_types=1);
+
+namespace Neos\MetaData\Configuration;
+
+use Neos\MetaData\Domain\Dto\MetaDataPropertyDefinitions;
+
+/**
+ * Provider for global property configuration (usually from settings (YAML))
+ */
+interface MetaDataConfigurationProvider
+{
+    public function getPropertyConfiguration(): MetaDataPropertyDefinitions;
+}

Classes/Configuration/MetaDataConfigurationProviderYamlAdapter.php

@@ -0,0 +1,59 @@
+<?php
+declare(strict_types=1);
+
+namespace Neos\MetaData\Configuration;
+
+use Neos\Flow\I18n\Translator;
+use Neos\MetaData\Domain\Dto\MetaDataEditorDefinition;
+use Neos\MetaData\Domain\Dto\MetaDataPropertyDefinition;
+use Neos\MetaData\Domain\Dto\MetaDataPropertyDefinitions;
+use Neos\MetaData\Domain\Dto\MetaDataPropertyName;
+use Neos\MetaData\Domain\Dto\MetaDataPropertyType;
+use Neos\MetaData\Domain\Dto\MetaDataPropertyUiDefinition;
+
+class MetaDataConfigurationProviderYamlAdapter implements MetaDataConfigurationProvider
+{
+    public function __construct(
+        private readonly array $propertyConfiguration,
+        private readonly Translator $translator,
+    )
+    {
+    }
+
+    public function getPropertyConfiguration(): MetaDataPropertyDefinitions
+    {
+        $propertyDefinitions = [];
+        foreach ($this->propertyConfiguration as $propertyName => $propertyDefinition) {
+            $propertyDefinitions[] = new MetaDataPropertyDefinition(
+                MetaDataPropertyName::fromString($propertyName),
+                match ($propertyDefinition['type'] ?? null) {
+                    'integer' => MetaDataPropertyType::integer,
+                    'boolean' => MetaDataPropertyType::boolean,
+                    default => MetaDataPropertyType::string,
+                },
+                $propertyDefinition['globalScope'] ?? false,
+                new MetaDataPropertyUiDefinition(
+                    $this->translatePropertyName($propertyName, $propertyDefinition['ui']['label']),
+                    MetaDataEditorDefinition::create(
+                        editorType: $propertyDefinition['ui']['editor'] ?? null,
+                        options: $propertyDefinition['ui']['editorOptions'] ?? [],
+                    )
+                )
+            );
+        }
+        return MetaDataPropertyDefinitions::create(...$propertyDefinitions);
+    }
+
+    // -----------------------
+
+    private function translatePropertyName(string $propertyName, ?string $label): string
+    {
+        if ($label === 'i18n') {
+            $translationShortHandString = sprintf('Neos.MetaData.Main.properties.%s', $propertyName);
+            return $this->translator->translateById($translationShortHandString, [], null, null, 'Main', 'Neos.MetaData') ?? $propertyName;
+        } elseif ($label !== null) {
+            return $label;
+        }
+        return $propertyName;
+    }
+}

Classes/Configuration/MetaDataConfigurationProviderYamlAdapterFactory.php

@@ -0,0 +1,21 @@
+<?php
+declare(strict_types=1);
+
+namespace Neos\MetaData\Configuration;
+
+use Neos\Flow\I18n\Translator;
+
+class MetaDataConfigurationProviderYamlAdapterFactory
+{
+    public function __construct(
+        private readonly array $propertyConfiguration,
+        private readonly Translator $translator,
+    )
+    {
+    }
+
+    public function create(): MetaDataConfigurationProvider
+    {
+        return new MetaDataConfigurationProviderYamlAdapter($this->propertyConfiguration, $this->translator);
+    }
+}

Classes/DimensionSpacePointProvider/DimensionSpacePointProvider.php

@@ -16,5 +16,5 @@ public function getDefaultDimensionSpacePoint(): MetaDataDimensionSpacePoint;
 
     public function getDimensionSpacePointChain(MetaDataDimensionSpacePoint $dimensionSpacePoint): MetaDataDimensionSpacePoints;
 
-    // public function RENAMEisDimensionSpacePointValid(MetaDataDimensionSpacePoint $dimensionSpacePoint): bool;
+    public function isDimensionSpacePointValid(MetaDataDimensionSpacePoint $dimensionSpacePoint): bool;
 }

Classes/DimensionSpacePointProvider/DimensionSpacePointProviderContentRepositoryAdapter.php

@@ -0,0 +1,108 @@
+<?php
+declare(strict_types=1);
+
+namespace Neos\MetaData\DimensionSpacePointProvider;
+
+use Neos\ContentRepository\Domain\Service\ConfigurationContentDimensionPresetSource;
+use Neos\MetaData\Domain\Dto\MetaDataDimensionSpacePoint;
+use Neos\MetaData\Domain\Dto\MetaDataDimensionSpacePoints;
+
+class DimensionSpacePointProviderContentRepositoryAdapter implements DimensionSpacePointProvider
+{
+    private ?array $allPresets = null;
+
+    public function __construct(
+        private readonly ConfigurationContentDimensionPresetSource $configurationContentDimensionPresetSource,
+    )
+    {
+    }
+
+    private function getAllPresets(): array
+    {
+        if ($this->allPresets === null) {
+            $this->allPresets = $this->configurationContentDimensionPresetSource->getAllPresets();
+        }
+        return $this->allPresets;
+    }
+
+    public function getDefaultDimensionSpacePoint(): MetaDataDimensionSpacePoint
+    {
+        return MetaDataDimensionSpacePoint::fromCoordinates([]);
+    }
+
+    public function getDimensionSpacePointChain(?MetaDataDimensionSpacePoint $dimensionSpacePoint = null): MetaDataDimensionSpacePoints
+    {
+        if ($dimensionSpacePoint === null) {
+            $dimensionSpacePoint = $this->getDefaultDimensionSpacePoint();
+        }
+
+        if ($dimensionSpacePoint->coordinates === []) {
+            return MetaDataDimensionSpacePoints::create($dimensionSpacePoint);
+        }
+
+        // For each coordinate, resolve the ordered fallback chain from the matching preset
+        $perDimensionChains = [];
+        foreach ($dimensionSpacePoint->coordinates as $dimensionName => $primaryValue) {
+            $chain = [$primaryValue]; // safe default: just the value itself
+            foreach ($this->getAllPresets()[$dimensionName]['presets'] ?? [] as $preset) {
+                if (($preset['values'][0] ?? null) === $primaryValue) {
+                    $chain = $preset['values'];
+                    break;
+                }
+            }
+            $perDimensionChains[$dimensionName] = $chain;
+        }
+
+        // Build Cartesian product of all per-dimension chains, tracking fallback distance per combo
+        $combos = [['coords' => [], 'distance' => 0]];
+        foreach ($perDimensionChains as $dimensionName => $chain) {
+            $expanded = [];
+            foreach ($combos as $combo) {
+                foreach ($chain as $index => $value) {
+                    $expanded[] = [
+                        'coords' => array_merge($combo['coords'], [$dimensionName => $value]),
+                        'distance' => $combo['distance'] + $index,
+                    ];
+                }
+            }
+            $combos = $expanded;
+        }
+
+        // Sort by total fallback distance: most specific (0) first
+        usort($combos, fn($a, $b) => $a['distance'] <=> $b['distance']);
+
+        $spacePoints = array_map(
+            fn($combo) => MetaDataDimensionSpacePoint::fromCoordinates($combo['coords']),
+            $combos
+        );
+
+        $spacePoints[] = $this->getDefaultDimensionSpacePoint();
+        return MetaDataDimensionSpacePoints::create(...$spacePoints);
+    }
+
+    public function isDimensionSpacePointValid(MetaDataDimensionSpacePoint $dimensionSpacePoint): bool
+    {
+        if (empty($this->getAllPresets())) {
+            return $dimensionSpacePoint->coordinates === [];
+        }
+
+        if (count($dimensionSpacePoint->coordinates) !== count($this->getAllPresets())) {
+            return false;
+        }
+
+        $presetIdentifiers = [];
+        foreach ($dimensionSpacePoint->coordinates as $dimensionName => $value) {
+            foreach ($this->getAllPresets()[$dimensionName]['presets'] ?? [] as $presetIdentifier => $preset) {
+                if ($preset['values'][0] === $value) {
+                    $presetIdentifiers[$dimensionName] = $presetIdentifier;
+                    break;
+                }
+            }
+            if (!isset($presetIdentifiers[$dimensionName])) {
+                return false;
+            }
+        }
+
+        return $this->configurationContentDimensionPresetSource->isPresetCombinationAllowedByConstraints($presetIdentifiers);
+    }
+}

Classes/Domain/Dto/MetaDataAssetReference.php

@@ -20,4 +20,12 @@ public function __construct(
         public string $assetId,
     ) {
     }
+
+    public static function fromAsset(Asset $asset): self
+    {
+        return new self(
+            $asset->getAssetSourceIdentifier(),
+            $asset->getIdentifier(),
+        );
+    }
 }

Classes/Domain/Dto/MetaDataDimensionSpacePoint.php

@@ -9,12 +9,12 @@
 
 /**
  * A point in the dimension space with coordinates DimensionName => DimensionValue.
- * E.g.: ["language" => "es", "country" => "ar"]
+ * E.g.: ["language" => ["es"], "country" => ["ar"]]
  */
 final readonly class MetaDataDimensionSpacePoint implements Stringable {
 
     /**
-     * @param array<string,string> $coordinates
+     * @param array<string,string[]> $coordinates
      * @param string $hash
      */
     private function __construct(
@@ -24,7 +24,7 @@ private function __construct(
     }
 
     /**
-     * @param array<string,string> $coordinates
+     * @param array<string,string[]> $coordinates
      */
     private static function hashCoordinates(array $coordinates): string
     {
@@ -38,7 +38,7 @@ private static function hashCoordinates(array $coordinates): string
     }
 
     /**
-     * @param array<string,string> $coordinates
+     * @param array<string,string[]> $coordinates
      */
     public static function fromCoordinates(array $coordinates): self
     {
@@ -50,8 +50,6 @@ public static function fromCoordinates(array $coordinates): self
 
     public function equals(self $other): bool
     {
-        \Neos\Flow\var_dump($this, 'this');
-        \Neos\Flow\var_dump($other, 'pther');
         return $this->hash === $other->hash;
     }
 

Classes/Domain/Dto/MetaDataDimensionSpacePoints.php

@@ -36,8 +36,25 @@ public function include(MetaDataDimensionSpacePoint $dimensionSpacePoint): bool
         return false;
     }
 
+    public function getByHash(string $hash): MetaDataDimensionSpacePoint|null
+    {
+        foreach ($this->spacePoints as $spacePoint) {
+            if ($spacePoint->hash === $hash) {
+                return $spacePoint;
+            }
+        }
+        return null;
+    }
+
     public function getIterator(): Traversable
     {
         yield from $this->spacePoints;
     }
+
+    public function getHashIterator(): Traversable
+    {
+        foreach ($this->spacePoints as $spacePoint) {
+            yield $spacePoint->hash;
+        }
+    }
 }

Classes/Helper/AssetMetaDataHelper.php

@@ -0,0 +1,43 @@
+<?php
+declare(strict_types=1);
+
+namespace Neos\MetaData\Helper;
+
+use Neos\Eel\ProtectedContextAwareInterface;
+use Neos\Media\Domain\Model\Asset;
+use Neos\MetaData\Domain\Dto\MetaDataAssetReference;
+use Neos\MetaData\Domain\Dto\MetaDataDimensionSpacePoint;
+use Neos\MetaData\Domain\Dto\MetaDataPropertyName;
+use Neos\MetaData\MetaDataManager;
+
+class AssetMetaDataHelper implements ProtectedContextAwareInterface
+{
+
+    public function __construct(
+        protected MetaDataManager $metaDataManager,
+    )
+    {
+    }
+
+    public function getMetaData(Asset $asset, array $coordinates = []): array
+    {
+        $propertyValues = $this->metaDataManager->getMetaDataPropertyValues(
+            MetaDataAssetReference::fromAsset($asset),
+            MetaDataDimensionSpacePoint::fromCoordinates($coordinates),
+        );
+        $result = [];
+        foreach ($propertyValues as $propertyName => $propertyValue) {
+            /** @var $propertyName MetaDataPropertyName */
+            $result[$propertyName->value] = $propertyValue;
+        }
+        return $result;
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function allowsCallOfMethod($methodName)
+    {
+        return in_array($methodName, ['getMetaData']);
+    }
+}