eZ\Publish\Core\REST\Server\Input\Parser\FieldDefinitionCreate::parse PHP Метод

    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;
    }

 /**
  * Parse input structure.
  *
  * @param array $data
  * @param \eZ\Publish\Core\REST\Common\Input\ParsingDispatcher $parsingDispatcher
  *
  * @return \eZ\Publish\API\Repository\Values\ContentType\ContentTypeCreateStruct
  */
 public function parse(array $data, ParsingDispatcher $parsingDispatcher)
 {
     if (!array_key_exists('identifier', $data)) {
         throw new Exceptions\Parser("Missing 'identifier' element for ContentTypeCreate.");
     }
     $contentTypeCreateStruct = $this->contentTypeService->newContentTypeCreateStruct($data['identifier']);
     if (!array_key_exists('mainLanguageCode', $data)) {
         throw new Exceptions\Parser("Missing 'mainLanguageCode' element for ContentTypeCreate.");
     }
     $contentTypeCreateStruct->mainLanguageCode = $data['mainLanguageCode'];
     if (array_key_exists('remoteId', $data)) {
         $contentTypeCreateStruct->remoteId = $data['remoteId'];
     }
     if (array_key_exists('urlAliasSchema', $data)) {
         $contentTypeCreateStruct->urlAliasSchema = $data['urlAliasSchema'];
     }
     // @todo XSD says that nameSchema is mandatory, but it is not in create struct
     if (array_key_exists('nameSchema', $data)) {
         $contentTypeCreateStruct->nameSchema = $data['nameSchema'];
     }
     // @todo XSD says that isContainer is mandatory, but it is not in create struct
     if (array_key_exists('isContainer', $data)) {
         $contentTypeCreateStruct->isContainer = $this->parserTools->parseBooleanValue($data['isContainer']);
     }
     // @todo XSD says that defaultSortField is mandatory, but it is not in create struct
     if (array_key_exists('defaultSortField', $data)) {
         $contentTypeCreateStruct->defaultSortField = $this->parserTools->parseDefaultSortField($data['defaultSortField']);
     }
     // @todo XSD says that defaultSortOrder is mandatory, but it is not in create struct
     if (array_key_exists('defaultSortOrder', $data)) {
         $contentTypeCreateStruct->defaultSortOrder = $this->parserTools->parseDefaultSortOrder($data['defaultSortOrder']);
     }
     // @todo XSD says that defaultAlwaysAvailable is mandatory, but it is not in create struct
     if (array_key_exists('defaultAlwaysAvailable', $data)) {
         $contentTypeCreateStruct->defaultAlwaysAvailable = $this->parserTools->parseBooleanValue($data['defaultAlwaysAvailable']);
     }
     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 ContentTypeCreate.");
         }
         $contentTypeCreateStruct->names = $this->parserTools->parseTranslatableList($data['names']);
     }
     // @todo XSD says that descriptions is mandatory, but content type can be created without descriptions
     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 ContentTypeCreate.");
         }
         $contentTypeCreateStruct->descriptions = $this->parserTools->parseTranslatableList($data['descriptions']);
     }
     // @todo 1: XSD says that modificationDate is mandatory, but it is not in create struct
     // @todo 2: mismatch between XSD naming and create struct naming
     if (array_key_exists('modificationDate', $data)) {
         $contentTypeCreateStruct->creationDate = new DateTime($data['modificationDate']);
     }
     if (array_key_exists('User', $data)) {
         if (!array_key_exists('_href', $data['User'])) {
             throw new Exceptions\Parser("Missing '_href' attribute for User element in ContentTypeCreate.");
         }
         $contentTypeCreateStruct->creatorId = $this->requestParser->parseHref($data['User']['_href'], 'userId');
     }
     if (!array_key_exists('FieldDefinitions', $data)) {
         throw new Exceptions\Parser("Missing 'FieldDefinitions' element for ContentTypeCreate.");
     }
     if (!is_array($data['FieldDefinitions']) || !array_key_exists('FieldDefinition', $data['FieldDefinitions']) || !is_array($data['FieldDefinitions']['FieldDefinition'])) {
         throw new Exceptions\Parser("Invalid 'FieldDefinitions' element for ContentTypeCreate.");
     }
     // With no field definitions given and when ContentType is immediately published we must return HTTP 400 BadRequest,
     // instead of relying on service to throw InvalidArgumentException
     if (isset($data['__publish']) && $data['__publish'] === true && empty($data['FieldDefinitions']['FieldDefinition'])) {
         throw new Exceptions\Parser('ContentTypeCreate should provide at least one field definition.');
     }
     foreach ($data['FieldDefinitions']['FieldDefinition'] as $fieldDefinitionData) {
         if (!is_array($fieldDefinitionData)) {
             throw new Exceptions\Parser("Invalid 'FieldDefinition' element for ContentTypeCreate.");
         }
         $contentTypeCreateStruct->addFieldDefinition($this->fieldDefinitionCreateParser->parse($fieldDefinitionData, $parsingDispatcher));
     }
     return $contentTypeCreateStruct;
 }