/**
* @inheritdoc
*/
public function visit(TreeNodeInterface $node, &$data)
{
$struct = $this->contentTypeService->newFieldDefinitionCreateStruct('', '');
$this->fillValueObject($struct, $data);
// Get position from node index (starts from 1)
$struct->position = $node->getIndex() + 1;
return $struct;
}
/**
* Instantiates a field definition create struct
*
* @param string $fieldTypeIdentifier the required field type identifier
* @param string $identifier the required identifier for the field definition
*
* @return \eZ\Publish\API\Repository\Values\ContentType\FieldDefinitionCreateStruct
*/
public function newFieldDefinitionCreateStruct($identifier, $fieldTypeIdentifier)
{
return $this->service->newFieldDefinitionCreateStruct($identifier, $fieldTypeIdentifier);
}
/**
* Parse input structure.
*
* @param array $data
* @param \eZ\Publish\Core\REST\Common\Input\ParsingDispatcher $parsingDispatcher
*
* @throws \eZ\Publish\Core\REST\Common\Exceptions\Parser If an error is found while parsing
*
* @return \eZ\Publish\API\Repository\Values\ContentType\FieldDefinitionCreateStruct
*/
public function parse(array $data, ParsingDispatcher $parsingDispatcher)
{
if (!array_key_exists('identifier', $data)) {
throw new Exceptions\Parser("Missing 'identifier' element for FieldDefinitionCreate.");
}
if (!array_key_exists('fieldType', $data)) {
throw new Exceptions\Parser("Missing 'fieldType' element for FieldDefinitionCreate.");
}
$fieldDefinitionCreate = $this->contentTypeService->newFieldDefinitionCreateStruct($data['identifier'], $data['fieldType']);
// @todo XSD says that descriptions is mandatory, but content type can be created without it
if (array_key_exists('names', $data)) {
if (!is_array($data['names']) || !array_key_exists('value', $data['names']) || !is_array($data['names']['value'])) {
throw new Exceptions\Parser("Invalid 'names' element for FieldDefinitionCreate.");
}
$fieldDefinitionCreate->names = $this->parserTools->parseTranslatableList($data['names']);
}
// @todo XSD says that descriptions is mandatory, but content type can be created without it
if (array_key_exists('descriptions', $data)) {
if (!is_array($data['descriptions']) || !array_key_exists('value', $data['descriptions']) || !is_array($data['descriptions']['value'])) {
throw new Exceptions\Parser("Invalid 'descriptions' element for FieldDefinitionCreate.");
}
$fieldDefinitionCreate->descriptions = $this->parserTools->parseTranslatableList($data['descriptions']);
}
// @todo XSD says that fieldGroup is mandatory, but content type can be created without it
if (array_key_exists('fieldGroup', $data)) {
$fieldDefinitionCreate->fieldGroup = $data['fieldGroup'];
}
// @todo XSD says that position is mandatory, but content type can be created without it
if (array_key_exists('position', $data)) {
$fieldDefinitionCreate->position = (int) $data['position'];
}
// @todo XSD says that isTranslatable is mandatory, but content type can be created without it
if (array_key_exists('isTranslatable', $data)) {
$fieldDefinitionCreate->isTranslatable = $this->parserTools->parseBooleanValue($data['isTranslatable']);
}
// @todo XSD says that isRequired is mandatory, but content type can be created without it
if (array_key_exists('isRequired', $data)) {
$fieldDefinitionCreate->isRequired = $this->parserTools->parseBooleanValue($data['isRequired']);
}
// @todo XSD says that isInfoCollector is mandatory, but content type can be created without it
if (array_key_exists('isInfoCollector', $data)) {
$fieldDefinitionCreate->isInfoCollector = $this->parserTools->parseBooleanValue($data['isInfoCollector']);
}
// @todo XSD says that isSearchable is mandatory, but content type can be created without it
if (array_key_exists('isSearchable', $data)) {
$fieldDefinitionCreate->isSearchable = $this->parserTools->parseBooleanValue($data['isSearchable']);
}
// @todo XSD says that defaultValue is mandatory, but content type can be created without it
if (array_key_exists('defaultValue', $data)) {
try {
$fieldDefinitionCreate->defaultValue = $this->fieldTypeParser->parseValue($data['fieldType'], $data['defaultValue']);
} catch (Exception $e) {
throw new Exceptions\Parser("Invalid 'defaultValue' element for FieldDefinitionCreate.", 0, $e);
}
}
if (array_key_exists('validatorConfiguration', $data)) {
$fieldDefinitionCreate->validatorConfiguration = $this->fieldTypeParser->parseValidatorConfiguration($data['fieldType'], $data['validatorConfiguration']);
}
if (array_key_exists('fieldSettings', $data)) {
$fieldDefinitionCreate->fieldSettings = $this->fieldTypeParser->parseFieldSettings($data['fieldType'], $data['fieldSettings']);
}
return $fieldDefinitionCreate;
}
/**
* Helper function to create field definitions based to be added to a new/existing content type.
*
* @todo Add translation support if needed
* @param ContentTypeService $contentTypeService
* @param array $attribute
* @return \eZ\Publish\API\Repository\Values\ContentType\FieldDefinitionCreateStruct
* @throws \Exception
*/
private function createFieldDefinition(ContentTypeService $contentTypeService, array $attribute)
{
if (!isset($attribute['identifier']) || !isset($attribute['type'])) {
throw new \Exception("Keys 'type' and 'identifier' are mandatory to define a new field in a field type");
}
$fieldDefinition = $contentTypeService->newFieldDefinitionCreateStruct($attribute['identifier'], $attribute['type']);
foreach ($attribute as $key => $value) {
switch ($key) {
case 'name':
$fieldDefinition->names = array($this->getLanguageCode() => $value);
break;
case 'description':
$fieldDefinition->descriptions = array($this->getLanguageCode() => $value);
break;
case 'required':
$fieldDefinition->isRequired = $value;
break;
case 'searchable':
$fieldDefinition->isSearchable = $value;
break;
case 'info-collector':
$fieldDefinition->isInfoCollector = $value;
break;
case 'disable-translation':
$fieldDefinition->isTranslatable = !$value;
break;
case 'category':
$fieldDefinition->fieldGroup = $value == 'default' ? 'content' : $value;
break;
case 'default-value':
$fieldDefinition->defaultValue = $value;
break;
case 'field-settings':
$fieldDefinition->fieldSettings = $this->getFieldSettings($value);
break;
case 'validator-configuration':
$fieldDefinition->validatorConfiguration = $value;
break;
}
}
return $fieldDefinition;
}
