refactor(php): inject IL10N into FieldValueService and translate throws with literal strings

Signed-off-by: Vitor Mattos <1079143+vitormattos@users.noreply.github.com>

Author: vitormattos

lib/Service/FieldValueService.php

@@ -24,6 +24,7 @@
 use OCA\ProfileFields\Workflow\Event\ProfileFieldVisibilityUpdatedEvent;
 use OCA\ProfileFields\Workflow\ProfileFieldValueWorkflowSubject;
 use OCP\EventDispatcher\IEventDispatcher;
+use OCP\IL10N;
 
 class FieldValueService {
 	private const SEARCH_OPERATOR_EQ = 'eq';
@@ -33,6 +34,7 @@ class FieldValueService {
 	public function __construct(
 		private FieldValueMapper $fieldValueMapper,
 		private IEventDispatcher $eventDispatcher,
+		private IL10N $l10n,
 	) {
 	}
 
@@ -51,7 +53,7 @@ public function upsert(
 		$valueJson = $this->encodeValue($normalizedValue);
 		$visibility = $currentVisibility ?? FieldExposurePolicy::from($definition->getExposurePolicy())->initialVisibility()->value;
 		if (!FieldVisibility::isValid($visibility)) {
-			throw new InvalidArgumentException('current_visibility is not supported');
+			throw new InvalidArgumentException($this->l10n->t('current_visibility is not supported'));
 		}
 
 		$entity = $this->fieldValueMapper->findByFieldDefinitionIdAndUserUid($definition->getId(), $userUid) ?? new FieldValue();
@@ -143,16 +145,16 @@ public function searchByDefinition(
 		int $offset,
 	): array {
 		if ($limit < 1 || $limit > self::SEARCH_MAX_LIMIT) {
-			throw new InvalidArgumentException(sprintf('limit must be between 1 and %d', self::SEARCH_MAX_LIMIT));
+			throw new InvalidArgumentException($this->l10n->t('limit must be between 1 and %d', [self::SEARCH_MAX_LIMIT]));
 		}
 
 		if ($offset < 0) {
-			throw new InvalidArgumentException('offset must be greater than or equal to 0');
+			throw new InvalidArgumentException($this->l10n->t('offset must be greater than or equal to 0'));
 		}
 
 		$normalizedOperator = strtolower(trim($operator));
 		if (!in_array($normalizedOperator, [self::SEARCH_OPERATOR_EQ, self::SEARCH_OPERATOR_CONTAINS], true)) {
-			throw new InvalidArgumentException('search operator is not supported');
+			throw new InvalidArgumentException($this->l10n->t('search operator is not supported'));
 		}
 
 		$searchValue = $this->normalizeSearchValue($definition, $normalizedOperator, $rawValue);
@@ -175,12 +177,12 @@ public function searchByDefinition(
 
 	public function updateVisibility(FieldDefinition $definition, string $userUid, string $updatedByUid, string $currentVisibility): FieldValue {
 		if (!FieldVisibility::isValid($currentVisibility)) {
-			throw new InvalidArgumentException('current_visibility is not supported');
+			throw new InvalidArgumentException($this->l10n->t('current_visibility is not supported'));
 		}
 
 		$entity = $this->fieldValueMapper->findByFieldDefinitionIdAndUserUid($definition->getId(), $userUid);
 		if ($entity === null) {
-			throw new InvalidArgumentException('field value not found');
+			throw new InvalidArgumentException($this->l10n->t('field value not found'));
 		}
 
 		$previousValue = $this->extractScalarValue($entity->getValueJson());
@@ -227,7 +229,7 @@ public function serializeForResponse(FieldValue $value): array {
 	 */
 	private function normalizeTextValue(array|string|int|float|bool $rawValue): array {
 		if (is_array($rawValue)) {
-			throw new InvalidArgumentException('text fields expect a scalar value');
+			throw new InvalidArgumentException($this->l10n->t('text fields expect a scalar value'));
 		}
 
 		return ['value' => trim((string)$rawValue)];
@@ -239,13 +241,13 @@ private function normalizeTextValue(array|string|int|float|bool $rawValue): arra
 	 */
 	private function normalizeSelectValue(array|string|int|float|bool $rawValue, FieldDefinition $definition): array {
 		if (!is_string($rawValue)) {
-			throw new InvalidArgumentException('select fields expect a string value');
+			throw new InvalidArgumentException($this->l10n->t('select fields expect a string value'));
 		}
 
 		$value = trim($rawValue);
 		$options = json_decode($definition->getOptions() ?? '[]', true);
 		if (!in_array($value, $options, true)) {
-			throw new InvalidArgumentException(sprintf('"%s" is not a valid option for this field', $value));
+			throw new InvalidArgumentException($this->l10n->t('"%s" is not a valid option for this field', [$value]));
 		}
 
 		return ['value' => $value];
@@ -257,7 +259,7 @@ private function normalizeSelectValue(array|string|int|float|bool $rawValue, Fie
 	 */
 	private function normalizeNumberValue(array|string|int|float|bool $rawValue): array {
 		if (is_array($rawValue) || is_bool($rawValue) || !is_numeric($rawValue)) {
-			throw new InvalidArgumentException('number fields expect a numeric value');
+			throw new InvalidArgumentException($this->l10n->t('number fields expect a numeric value'));
 		}
 
 		return ['value' => str_contains((string)$rawValue, '.') ? (float)$rawValue : (int)$rawValue];
@@ -270,7 +272,7 @@ private function encodeValue(array $value): string {
 		try {
 			return json_encode($value, JSON_THROW_ON_ERROR);
 		} catch (JsonException $exception) {
-			throw new InvalidArgumentException('value_json could not be encoded', 0, $exception);
+			throw new InvalidArgumentException($this->l10n->t('value_json could not be encoded'), 0, $exception);
 		}
 	}
 
@@ -281,11 +283,11 @@ private function decodeValue(string $valueJson): array {
 		try {
 			$decoded = json_decode($valueJson, true, 512, JSON_THROW_ON_ERROR);
 		} catch (JsonException $exception) {
-			throw new InvalidArgumentException('value_json could not be decoded', 0, $exception);
+			throw new InvalidArgumentException($this->l10n->t('value_json could not be decoded'), 0, $exception);
 		}
 
 		if (!is_array($decoded)) {
-			throw new InvalidArgumentException('value_json must decode to an object payload');
+			throw new InvalidArgumentException($this->l10n->t('value_json must decode to an object payload'));
 		}
 
 		return $decoded;
@@ -326,13 +328,13 @@ private function normalizeSearchValue(FieldDefinition $definition, string $opera
 		}
 
 		if (FieldType::from($definition->getType()) !== FieldType::TEXT) {
-			throw new InvalidArgumentException('contains operator is only supported for text fields');
+			throw new InvalidArgumentException($this->l10n->t('contains operator is only supported for text fields'));
 		}
 
 		$normalized = $this->normalizeValue($definition, $rawValue);
 		$value = $normalized['value'] ?? null;
 		if (!is_string($value) || $value === '') {
-			throw new InvalidArgumentException('contains operator requires a non-empty text value');
+			throw new InvalidArgumentException($this->l10n->t('contains operator requires a non-empty text value'));
 		}
 
 		return ['value' => $value];