/** * @param \eZ\Publish\Core\FieldType\Selection\Value $value * @param \eZ\Publish\API\Repository\Values\ContentType\FieldDefinition $fieldDefinition * @param string $languageCode * * @return string */ public function getFieldName(SPIValue $value, FieldDefinition $fieldDefinition, $languageCode) { if (empty($value->selection)) { return ''; } $names = []; $fieldSettings = $fieldDefinition->getFieldSettings(); foreach ($value->selection as $optionIndex) { if (isset($fieldSettings['options'][$optionIndex])) { $names[] = $fieldSettings['options'][$optionIndex]; } } return implode(' ', $names); }
/** * Validates a field based on the validators in the field definition. * * @throws \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException * * @param \eZ\Publish\API\Repository\Values\ContentType\FieldDefinition $fieldDefinition The field definition of the field * @param \eZ\Publish\Core\FieldType\EmailAddress\Value $fieldValue The field value for which an action is performed * * @return \eZ\Publish\SPI\FieldType\ValidationError[] */ public function validate(FieldDefinition $fieldDefinition, SPIValue $fieldValue) { $errors = array(); if ($this->isEmptyValue($fieldValue)) { return $errors; } $validatorConfiguration = $fieldDefinition->getValidatorConfiguration(); $constraints = isset($validatorConfiguration['EmailAddressValidator']) ? $validatorConfiguration['EmailAddressValidator'] : array(); $validator = new EmailAddressValidator(); $validator->initializeWithConstraints($constraints); if (!$validator->validate($fieldValue)) { return $validator->getMessage(); } return array(); }
/** * Validates a field based on the validators in the field definition * * @throws \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException * * @param \eZ\Publish\API\Repository\Values\ContentType\FieldDefinition $fieldDefinition The field definition of the field * @param \eZ\Publish\Core\FieldType\TextLine\Value $fieldValue The field value for which an action is performed * * @return \eZ\Publish\SPI\FieldType\ValidationError[] */ public function validate(FieldDefinition $fieldDefinition, SPIValue $fieldValue) { $validationErrors = array(); if ($this->isEmptyValue($fieldValue)) { return $validationErrors; } $validatorConfiguration = $fieldDefinition->getValidatorConfiguration(); $constraints = isset($validatorConfiguration['StringLengthValidator']) ? $validatorConfiguration['StringLengthValidator'] : array(); if (isset($constraints['maxStringLength']) && $constraints['maxStringLength'] !== false && $constraints['maxStringLength'] !== 0 && strlen($fieldValue->text) > $constraints['maxStringLength']) { $validationErrors[] = new ValidationError("The string can not exceed %size% character.", "The string can not exceed %size% characters.", array("size" => $constraints['maxStringLength']), 'text'); } if (isset($constraints['minStringLength']) && $constraints['minStringLength'] !== false && $constraints['minStringLength'] !== 0 && strlen($fieldValue->text) < $constraints['minStringLength']) { $validationErrors[] = new ValidationError("The string can not be shorter than %size% character.", "The string can not be shorter than %size% characters.", array("size" => $constraints['minStringLength']), 'text'); } return $validationErrors; }
/** * Validates a field based on the validators in the field definition. * * @throws \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException * * @param \eZ\Publish\API\Repository\Values\ContentType\FieldDefinition $fieldDefinition The field definition of the field * @param \eZ\Publish\Core\FieldType\Float\Value $fieldValue The field value for which an action is performed * * @return \eZ\Publish\SPI\FieldType\ValidationError[] */ public function validate(FieldDefinition $fieldDefinition, SPIValue $fieldValue) { $validationErrors = array(); if ($this->isEmptyValue($fieldValue)) { return $validationErrors; } $validatorConfiguration = $fieldDefinition->getValidatorConfiguration(); $constraints = isset($validatorConfiguration['FloatValueValidator']) ? $validatorConfiguration['FloatValueValidator'] : array(); $validationErrors = array(); if (isset($constraints['maxFloatValue']) && $constraints['maxFloatValue'] !== null && $fieldValue->value > $constraints['maxFloatValue']) { $validationErrors[] = new ValidationError('The value can not be higher than %size%.', null, array('%size%' => $constraints['maxFloatValue']), 'value'); } if (isset($constraints['minFloatValue']) && $constraints['minFloatValue'] !== null && $fieldValue->value < $constraints['minFloatValue']) { $validationErrors[] = new ValidationError('The value can not be lower than %size%.', null, array('%size%' => $constraints['minFloatValue']), 'value'); } return $validationErrors; }
/** * Returns default field options, created from given $fieldDefinition and $languageCode * * @param \eZ\Publish\API\Repository\Values\ContentType\FieldDefinition $fieldDefinition * @param string $languageCode * @param null|\eZ\Publish\API\Repository\Values\Content\Content $content * * @return array */ protected function getDefaultFieldOptions(FieldDefinition $fieldDefinition, $languageCode, Content $content = null) { $options = array(); $options["label"] = $fieldDefinition->getName($languageCode); $options["required"] = $fieldDefinition->isRequired; $options["ezforms"]["description"] = $fieldDefinition->getDescription($languageCode); $options["ezforms"]["language_code"] = $languageCode; $options["ezforms"]["fielddefinition"] = $fieldDefinition; if ($content !== null) { $options["ezforms"]["content"] = $content; } $options["constraints"] = array(); if ($fieldDefinition->isRequired) { $options["constraints"][] = new Constraints\NotBlank(); } return $options; }
/** * Validates a field based on the validators in the field definition * * @throws \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException * * @param \eZ\Publish\API\Repository\Values\ContentType\FieldDefinition $fieldDefinition The field definition of the field * @param \eZ\Publish\Core\FieldType\Integer\Value $fieldValue The field value for which an action is performed * * @return \eZ\Publish\SPI\FieldType\ValidationError[] */ public function validate(FieldDefinition $fieldDefinition, SPIValue $fieldValue) { $validationErrors = array(); if ($this->isEmptyValue($fieldValue)) { return $validationErrors; } $validatorConfiguration = $fieldDefinition->getValidatorConfiguration(); $constraints = isset($validatorConfiguration['IntegerValueValidator']) ? $validatorConfiguration['IntegerValueValidator'] : array(); $validationErrors = array(); // 0 and False are unlimited value for maxIntegerValue if (isset($constraints['maxIntegerValue']) && $constraints['maxIntegerValue'] !== 0 && $constraints['maxIntegerValue'] !== false && $fieldValue->value > $constraints['maxIntegerValue']) { $validationErrors[] = new ValidationError("The value can not be higher than %size%.", null, array("size" => $constraints['maxIntegerValue'])); } if (isset($constraints['minIntegerValue']) && $constraints['minIntegerValue'] !== false && $fieldValue->value < $constraints['minIntegerValue']) { $validationErrors[] = new ValidationError("The value can not be lower than %size%.", null, array("size" => $constraints['minIntegerValue'])); } return $validationErrors; }
/** * Validates a field based on the validators in the field definition * * @throws \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException * * @param \eZ\Publish\API\Repository\Values\ContentType\FieldDefinition $fieldDefinition The field definition of the field * @param \eZ\Publish\Core\FieldType\BinaryBase\Value $fieldValue The field value for which an action is performed * * @return \eZ\Publish\SPI\FieldType\ValidationError[] */ public function validate(FieldDefinition $fieldDefinition, SPIValue $fieldValue) { $errors = array(); if ($this->isEmptyValue($fieldValue)) { return $errors; } foreach ((array) $fieldDefinition->getValidatorConfiguration() as $validatorIdentifier => $parameters) { switch ($validatorIdentifier) { // @todo There is a risk if we rely on a user built Value, since the FileSize // property can be set manually, making this validation pointless case 'FileSizeValidator': if (!isset($parameters['maxFileSize']) || $parameters['maxFileSize'] == false) { // No file size limit break; } // Database stores maxFileSize in MB if ($parameters['maxFileSize'] * 1024 * 1024 < $fieldValue->fileSize) { $errors[] = new ValidationError("The file size cannot exceed %size% byte.", "The file size cannot exceed %size% bytes.", array("size" => $parameters['maxFileSize'])); } break; } } return $errors; }
/** * Renders the HTML for the settings for the given field definition * $definition * * @param \eZ\Publish\API\Repository\Values\ContentType\FieldDefinition $definition * @return string */ public function renderFieldDefinitionSettings(FieldDefinition $definition) { if (!$this->template instanceof Twig_Template) { $tpl = reset($this->renderFieldDefinitionSettingsResources); $this->template = $this->environment->loadTemplate($tpl['template']); } $parameters = array('fielddefinition' => $definition, 'settings' => $definition->getFieldSettings()); return $this->template->renderBlock($this->getRenderFieldDefinitionSettingsBlockName($definition), $parameters, $this->getBlockByFieldDefinition($definition)); }
/** * Validates a field based on the validators in the field definition * * @throws \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException * * @param \eZ\Publish\API\Repository\Values\ContentType\FieldDefinition $fieldDefinition The field definition of the field * @param \eZ\Publish\Core\FieldType\Image\Value $fieldValue The field value for which an action is performed * * @return \eZ\Publish\SPI\FieldType\ValidationError[] */ public function validate(FieldDefinition $fieldDefinition, SPIValue $fieldValue) { $errors = array(); if ($this->isEmptyValue($fieldValue)) { return $errors; } if (isset($fieldValue->inputUri) && !getimagesize($fieldValue->inputUri)) { $errors[] = new ValidationError("A valid image file is required."); } // BC: Check if file is a valid image if the value of 'id' matches a local file if (isset($fieldValue->id) && file_exists($fieldValue->id) && !getimagesize($fieldValue->id)) { $errors[] = new ValidationError("A valid image file is required."); } foreach ((array) $fieldDefinition->getValidatorConfiguration() as $validatorIdentifier => $parameters) { switch ($validatorIdentifier) { case 'FileSizeValidator': if (!isset($parameters['maxFileSize']) || $parameters['maxFileSize'] == false) { // No file size limit break; } // Database stores maxFileSize in MB if ($parameters['maxFileSize'] * 1024 * 1024 < $fieldValue->fileSize) { $errors[] = new ValidationError("The file size cannot exceed %size% byte.", "The file size cannot exceed %size% bytes.", array("size" => $parameters['maxFileSize'])); } break; } } return $errors; }
/** * Validates field value against 'isMultiple' setting. * * Does not use validators. * * @throws \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException * * @param \eZ\Publish\API\Repository\Values\ContentType\FieldDefinition $fieldDefinition The field definition of the field * @param \eZ\Publish\Core\FieldType\Country\Value $fieldValue The field value for which an action is performed * * @return \eZ\Publish\SPI\FieldType\ValidationError[] */ public function validate(FieldDefinition $fieldDefinition, SPIValue $fieldValue) { $validationErrors = array(); if ($this->isEmptyValue($fieldValue)) { return $validationErrors; } $fieldSettings = $fieldDefinition->getFieldSettings(); if ((!isset($fieldSettings["isMultiple"]) || $fieldSettings["isMultiple"] === false) && count($fieldValue->countries) > 1) { $validationErrors[] = new ValidationError("Field definition does not allow multiple countries to be selected.", null, array()); } foreach ($fieldValue->countries as $alpha2 => $countryInfo) { if (!isset($this->countriesInfo[$alpha2])) { $validationErrors[] = new ValidationError("Country with Alpha2 code '%alpha2%' is not defined in FieldType settings.", null, array("alpha2" => $alpha2)); } } return $validationErrors; }
/** * Validates field value against 'isMultiple' and 'options' settings. * * Does not use validators. * * @throws \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException * * @param \eZ\Publish\API\Repository\Values\ContentType\FieldDefinition $fieldDefinition The field definition of the field * @param \eZ\Publish\Core\FieldType\Selection\Value $fieldValue The field value for which an action is performed * * @return \eZ\Publish\SPI\FieldType\ValidationError[] */ public function validate(FieldDefinition $fieldDefinition, SPIValue $fieldValue) { $validationErrors = array(); if ($this->isEmptyValue($fieldValue)) { return $validationErrors; } $fieldSettings = $fieldDefinition->getFieldSettings(); if ((!isset($fieldSettings['isMultiple']) || $fieldSettings['isMultiple'] === false) && count($fieldValue->selection) > 1) { $validationErrors[] = new ValidationError('Field definition does not allow multiple options to be selected.', null, array(), 'selection'); } foreach ($fieldValue->selection as $optionIndex) { if (!isset($fieldSettings['options'][$optionIndex])) { $validationErrors[] = new ValidationError('Option with index %index% does not exist in the field definition.', null, array('%index%' => $optionIndex), 'selection'); } } return $validationErrors; }
/** * @param FieldDefinition $fieldDefinition * @param array $params * @param int $type Either self::VIEW or self::EDIT * * @return string */ private function renderFieldDefinition(FieldDefinition $fieldDefinition, array $params, $type) { if (is_string($this->baseTemplate)) { $this->baseTemplate = $this->twig->loadTemplate($this->baseTemplate); } $params += ['fielddefinition' => $fieldDefinition, 'settings' => $fieldDefinition->getFieldSettings()]; return $this->baseTemplate->renderBlock($this->getRenderFieldDefinitionBlockName($fieldDefinition->fieldTypeIdentifier, $type), $this->twig->mergeGlobals($params), $this->getBlocksByFieldDefinition($fieldDefinition, $type)); }
/** * Builds SPIFieldDefinition object using API FieldDefinitionUpdateStruct * and API FieldDefinition * * @throws \eZ\Publish\API\Repository\Exceptions\ContentTypeFieldDefinitionValidationException if validator configuration or * field setting do not validate * * @param \eZ\Publish\API\Repository\Values\ContentType\FieldDefinitionUpdateStruct $fieldDefinitionUpdateStruct * @param \eZ\Publish\API\Repository\Values\ContentType\FieldDefinition $fieldDefinition * * @return \eZ\Publish\SPI\Persistence\Content\Type\FieldDefinition */ protected function buildSPIFieldDefinitionUpdate(FieldDefinitionUpdateStruct $fieldDefinitionUpdateStruct, APIFieldDefinition $fieldDefinition) { /** @var $fieldType \eZ\Publish\SPI\FieldType\FieldType */ $fieldType = $this->repository->getFieldTypeService()->buildFieldType($fieldDefinition->fieldTypeIdentifier); $validatorConfiguration = $fieldDefinitionUpdateStruct->validatorConfiguration === null ? $fieldDefinition->validatorConfiguration : $fieldDefinitionUpdateStruct->validatorConfiguration; $fieldSettings = $fieldDefinitionUpdateStruct->fieldSettings === null ? $fieldDefinition->fieldSettings : $fieldDefinitionUpdateStruct->fieldSettings; $validationErrors = array(); if ($fieldDefinitionUpdateStruct->isSearchable && !$fieldType->isSearchable()) { $validationErrors[] = new ValidationError("FieldType '{$fieldDefinition->fieldTypeIdentifier}' is not searchable"); } $validationErrors = array_merge($validationErrors, $fieldType->validateValidatorConfiguration($validatorConfiguration), $fieldType->validateFieldSettings($fieldSettings)); if (!empty($validationErrors)) { throw new ContentTypeFieldDefinitionValidationException($validationErrors); } $spiFieldDefinition = new SPIFieldDefinition(array("id" => $fieldDefinition->id, "fieldType" => $fieldDefinition->fieldTypeIdentifier, "name" => $fieldDefinitionUpdateStruct->names === null ? $fieldDefinition->getNames() : $fieldDefinitionUpdateStruct->names, "description" => $fieldDefinitionUpdateStruct->descriptions === null ? $fieldDefinition->getDescriptions() : $fieldDefinitionUpdateStruct->descriptions, "identifier" => $fieldDefinitionUpdateStruct->identifier === null ? $fieldDefinition->identifier : $fieldDefinitionUpdateStruct->identifier, "fieldGroup" => $fieldDefinitionUpdateStruct->fieldGroup === null ? $fieldDefinition->fieldGroup : $fieldDefinitionUpdateStruct->fieldGroup, "position" => $fieldDefinitionUpdateStruct->position === null ? $fieldDefinition->position : $fieldDefinitionUpdateStruct->position, "isTranslatable" => $fieldDefinitionUpdateStruct->isTranslatable === null ? $fieldDefinition->isTranslatable : $fieldDefinitionUpdateStruct->isTranslatable, "isRequired" => $fieldDefinitionUpdateStruct->isRequired === null ? $fieldDefinition->isRequired : $fieldDefinitionUpdateStruct->isRequired, "isInfoCollector" => $fieldDefinitionUpdateStruct->isInfoCollector === null ? $fieldDefinition->isInfoCollector : $fieldDefinitionUpdateStruct->isInfoCollector, "isSearchable" => $fieldDefinitionUpdateStruct->isSearchable === null ? $fieldDefinition->isSearchable : $fieldDefinitionUpdateStruct->isSearchable)); $spiFieldDefinition->fieldTypeConstraints->validators = $validatorConfiguration; $spiFieldDefinition->fieldTypeConstraints->fieldSettings = $fieldSettings; $spiFieldDefinition->defaultValue = $fieldType->toPersistenceValue($fieldType->acceptValue($fieldDefinitionUpdateStruct->defaultValue)); return $spiFieldDefinition; }
/** * Validates a field based on the validators in the field definition * * Does not use validators. * * @throws \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException * * @param \eZ\Publish\API\Repository\Values\ContentType\FieldDefinition $fieldDefinition The field definition of the field * @param \eZ\Publish\Core\FieldType\ISBN\Value $fieldValue The field value for which an action is performed * * @return \eZ\Publish\SPI\FieldType\ValidationError[] */ public function validate(FieldDefinition $fieldDefinition, SPIValue $fieldValue) { $validationErrors = array(); if ($this->isEmptyValue($fieldValue)) { return $validationErrors; } $fieldSettings = $fieldDefinition->getFieldSettings(); $isbnTestNumber = preg_replace("/[\\s|\\-]/", "", trim($fieldValue->isbn)); // Check if value and settings are inline if ((!isset($fieldSettings["isISBN13"]) || $fieldSettings["isISBN13"] === false) && strlen($isbnTestNumber) !== 10) { $validationErrors[] = new ValidationError("ISBN-10 must be 10 character length", null, array()); } else { if (strlen($isbnTestNumber) === 10) { if (!$this->validateISBNChecksum($isbnTestNumber)) { $validationErrors[] = new ValidationError("ISBN value must be in a valid ISBN-10 format", null, array()); } } else { if (!$this->validateISBN13Checksum($isbnTestNumber, $error)) { $validationErrors[] = new ValidationError($error, null, array()); } } } return $validationErrors; }