feat: add multiselect profile field type

lib/Enum/FieldType.php

@@ -13,6 +13,7 @@ enum FieldType: string {
 	case TEXT = 'text';
 	case NUMBER = 'number';
 	case SELECT = 'select';
+	case MULTISELECT = 'multiselect';
 
 	/**
 	 * @return list<string>
@@ -22,6 +23,7 @@ public static function values(): array {
 			self::TEXT->value,
 			self::NUMBER->value,
 			self::SELECT->value,
+			self::MULTISELECT->value,
 		];
 	}
 

lib/ResponseDefinitions.php

@@ -10,7 +10,7 @@
 namespace OCA\ProfileFields;
 
 /**
- * @psalm-type ProfileFieldsType = 'text'|'number'|'select'
+ * @psalm-type ProfileFieldsType = 'text'|'number'|'select'|'multiselect'
  * @psalm-type ProfileFieldsVisibility = 'private'|'users'|'public'
  * @psalm-type ProfileFieldsEditPolicy = 'admins'|'users'
  * @psalm-type ProfileFieldsExposurePolicy = 'hidden'|'private'|'users'|'public'

lib/Service/FieldDefinitionValidator.php

@@ -29,7 +29,7 @@ class FieldDefinitionValidator {
 	 * @return array{
 	 *     field_key: non-empty-string,
 	 *     label: non-empty-string,
-	 *     type: 'text'|'number'|'select',
+	 *     type: 'text'|'number'|'select'|'multiselect',
 	 *     edit_policy: 'admins'|'users',
 	 *     exposure_policy: 'hidden'|'private'|'users'|'public',
 	 *     sort_order: int,
@@ -78,12 +78,13 @@ public function validate(array $definition): array {
 	 * @return list<string>|null
 	 */
 	private function validateOptions(string $type, mixed $options): ?array {
-		if ($type !== FieldType::SELECT->value) {
+		$isSelectLike = in_array($type, [FieldType::SELECT->value, FieldType::MULTISELECT->value], true);
+		if (!$isSelectLike) {
 			return null;
 		}
 
 		if (!is_array($options) || count($options) === 0) {
-			throw new InvalidArgumentException('select fields require at least one option');
+			throw new InvalidArgumentException($type . ' fields require at least one option');
 		}
 
 		$normalized = [];

lib/Service/FieldValueService.php

@@ -107,6 +107,7 @@ public function normalizeValue(FieldDefinition $definition, array|string|int|flo
 			FieldType::TEXT => $this->normalizeTextValue($rawValue),
 			FieldType::NUMBER => $this->normalizeNumberValue($rawValue),
 			FieldType::SELECT => $this->normalizeSelectValue($rawValue, $definition),
+			FieldType::MULTISELECT => $this->normalizeMultiSelectValue($rawValue, $definition),
 		};
 	}
 
@@ -255,6 +256,36 @@ private function normalizeSelectValue(array|string|int|float|bool $rawValue, Fie
 		return ['value' => $value];
 	}
 
+	/**
+	 * @param array<string, mixed>|scalar $rawValue
+	 * @return array{value: list<string>}
+	 */
+	private function normalizeMultiSelectValue(array|string|int|float|bool $rawValue, FieldDefinition $definition): array {
+		if (!is_array($rawValue) || !array_is_list($rawValue)) {
+			throw new InvalidArgumentException($this->l10n->t('Multiselect fields require one or more configured option values.'));
+		}
+
+		$options = json_decode($definition->getOptions() ?? '[]', true);
+		$normalized = [];
+		foreach ($rawValue as $candidate) {
+			if (!is_string($candidate) || trim($candidate) === '') {
+				throw new InvalidArgumentException($this->l10n->t('Multiselect fields require one or more configured option values.'));
+			}
+
+			$value = trim($candidate);
+			if (!in_array($value, $options, true)) {
+				// TRANSLATORS %s is an invalid option value provided by the user.
+				throw new InvalidArgumentException($this->l10n->t('"%s" is not a valid option for this field', [$value]));
+			}
+
+			if (!in_array($value, $normalized, true)) {
+				$normalized[] = $value;
+			}
+		}
+
+		return ['value' => $normalized];
+	}
+
 	/**
 	 * @param array<string, mixed>|scalar $rawValue
 	 * @return array{value: int|float}

lib/Workflow/UserProfileFieldCheck.php

@@ -106,7 +106,11 @@ public function validateCheck($operator, $value) {
 
 		if ($this->operatorRequiresValue((string)$operator)) {
 			try {
-				$this->fieldValueService->normalizeValue($definition, $config['value']);
+				if (FieldType::from($definition->getType()) === FieldType::MULTISELECT) {
+					$this->normalizeExpectedMultiSelectOperand($definition, $config['value']);
+				} else {
+					$this->fieldValueService->normalizeValue($definition, $config['value']);
+				}
 			} catch (InvalidArgumentException $exception) {
 				throw new \UnexpectedValueException($this->l10n->t('The configured comparison value is invalid'), 4, $exception);
 			}
@@ -163,6 +167,7 @@ private function isOperatorSupported(FieldDefinition $definition, string $operat
 			FieldType::TEXT => self::TEXT_OPERATORS,
 			FieldType::NUMBER => self::NUMBER_OPERATORS,
 			FieldType::SELECT => self::SELECT_OPERATORS,
+			FieldType::MULTISELECT => self::SELECT_OPERATORS,
 		};
 
 		return in_array($operator, $operators, true);
@@ -172,19 +177,38 @@ private function operatorRequiresValue(string $operator): bool {
 		return !in_array($operator, [self::OPERATOR_IS_SET, self::OPERATOR_IS_NOT_SET], true);
 	}
 
-	private function extractActualValue(?FieldValue $value): string|int|float|bool|null {
+	/**
+	 * @return string|int|float|bool|list<string>|null
+	 */
+	private function extractActualValue(?FieldValue $value): string|int|float|bool|array|null {
 		if ($value === null) {
 			return null;
 		}
 
 		$serialized = $this->fieldValueService->serializeForResponse($value);
 		$payload = $serialized['value']['value'] ?? null;
 
-		return is_array($payload) || is_object($payload) ? null : $payload;
+		if (is_array($payload) && array_is_list($payload)) {
+			$normalized = [];
+			foreach ($payload as $candidate) {
+				if (is_string($candidate)) {
+					$normalized[] = $candidate;
+				}
+			}
+
+			return $normalized;
+		}
+
+		return is_object($payload) ? null : $payload;
 	}
 
-	private function evaluate(FieldDefinition $definition, string $operator, string|int|float|bool|null $expectedRawValue, string|int|float|bool|null $actualValue): bool {
-		$isSet = $actualValue !== null && $actualValue !== '';
+	/**
+	 * @param string|int|float|bool|list<string>|null $actualValue
+	 */
+	private function evaluate(FieldDefinition $definition, string $operator, string|int|float|bool|null $expectedRawValue, string|int|float|bool|array|null $actualValue): bool {
+		$isSet = $actualValue !== null
+			&& $actualValue !== ''
+			&& (!is_array($actualValue) || count($actualValue) > 0);
 		if ($operator === self::OPERATOR_IS_SET) {
 			return $isSet;
 		}
@@ -195,20 +219,60 @@ private function evaluate(FieldDefinition $definition, string $operator, string|
 			return false;
 		}
 
+		$fieldType = FieldType::from($definition->getType());
+
+		if ($fieldType === FieldType::MULTISELECT) {
+			if (!is_array($actualValue)) {
+				return false;
+			}
+
+			$expectedValue = $this->normalizeExpectedMultiSelectOperand($definition, $expectedRawValue);
+
+			return $this->evaluateMultiSelectOperator($operator, $expectedValue, $actualValue);
+		}
+
 		$normalizedExpected = $this->fieldValueService->normalizeValue($definition, $expectedRawValue);
 		$expectedValue = $normalizedExpected['value'] ?? null;
 
-		return match (FieldType::from($definition->getType())) {
+		return match ($fieldType) {
 			FieldType::TEXT,
 			FieldType::SELECT => $this->evaluateTextOperator($operator, (string)$expectedValue, (string)$actualValue),
 			FieldType::NUMBER => $this->evaluateNumberOperator(
 				$operator,
 				$this->normalizeNumericComparisonOperand($expectedValue),
 				$this->normalizeNumericComparisonOperand($actualValue),
 			),
+			FieldType::MULTISELECT => false,
 		};
 	}
 
+	/**
+	 * @param list<string> $actualValues
+	 */
+	private function evaluateMultiSelectOperator(string $operator, string $expectedValue, array $actualValues): bool {
+		$contains = in_array($expectedValue, $actualValues, true);
+
+		return match ($operator) {
+			'is' => $contains,
+			'!is' => !$contains,
+			default => false,
+		};
+	}
+
+	private function normalizeExpectedMultiSelectOperand(FieldDefinition $definition, string|int|float|bool|null $expectedRawValue): string {
+		if (!is_string($expectedRawValue)) {
+			throw new InvalidArgumentException('multiselect comparison value must be one configured option');
+		}
+
+		$value = trim($expectedRawValue);
+		$options = json_decode($definition->getOptions() ?? '[]', true);
+		if ($value === '' || !is_array($options) || !in_array($value, $options, true)) {
+			throw new InvalidArgumentException('multiselect comparison value must be one configured option');
+		}
+
+		return $value;
+	}
+
 	private function normalizeNumericComparisonOperand(string|int|float|bool|null $value): int|float {
 		if (is_int($value) || is_float($value)) {
 			return $value;

openapi-administration.json

@@ -198,7 +198,8 @@
                 "enum": [
                     "text",
                     "number",
-                    "select"
+                    "select",
+                    "multiselect"
                 ]
             },
             "ValuePayload": {

openapi-full.json

@@ -273,7 +273,8 @@
                 "enum": [
                     "text",
                     "number",
-                    "select"
+                    "select",
+                    "multiselect"
                 ]
             },
             "ValuePayload": {

openapi.json

@@ -144,7 +144,8 @@
                 "enum": [
                     "text",
                     "number",
-                    "select"
+                    "select",
+                    "multiselect"
                 ]
             },
             "ValuePayload": {