Файловый менеджер - Редактировать - /var/www/html/mediawiki-1.43.1/includes/ParamValidator/TypeDef/ArrayDef.php
Ðазад
<?php namespace MediaWiki\ParamValidator\TypeDef; use InvalidArgumentException; use JsonSchema\Constraints\Constraint; use JsonSchema\Validator; use LogicException; use Wikimedia\Message\DataMessageValue; use Wikimedia\ParamValidator\TypeDef; /** * Type definition for array structures, typically * used for validating JSON request bodies. * * Failure codes: * - 'notarray': The value is not an array. * * @since 1.42 */ class ArrayDef extends TypeDef { /** * (object) Schema settings. * */ public const PARAM_SCHEMA = 'param-schema'; public function supportsArrays() { return true; } public function validate( $name, $value, array $settings, array $options ) { if ( !is_array( $value ) ) { // Message used: paramvalidator-notarray $this->failure( 'notarray', $name, $value, $settings, $options ); } if ( isset( $settings[ self::PARAM_SCHEMA ] ) ) { $schema = $settings[ self::PARAM_SCHEMA ]; if ( !isset( $schema[ 'type' ] ) ) { throw new InvalidArgumentException( "Schema type not set " ); } $types = (array)$schema['type']; foreach ( $types as $type ) { // @todo: start using JsonSchemaTrait::normalizeJsonSchema // so we can also support the "list" and "map" types if ( ( $type !== 'object' ) && ( $type !== 'array' ) ) { throw new LogicException( 'Invalid data type' ); } } $validator = new Validator(); $validator->validate( $value, $schema, Constraint::CHECK_MODE_TYPE_CAST | Constraint::CHECK_MODE_APPLY_DEFAULTS ); if ( !$validator->isValid() ) { $errorCode = 'schema-validation-failed'; foreach ( $validator->getErrors() as $error ) { $message = DataMessageValue::new( "paramvalidator-$errorCode", [ $error[ 'message' ] ], $errorCode, [ 'schema-validation-error' => $error ] ); $this->failure( $message, $name, $value, $settings, $options ); } } } return $value; } public function stringifyValue( $name, $value, array $settings, array $options ) { if ( !is_array( $value ) ) { return parent::stringifyValue( $name, $value, $settings, $options ); } return json_encode( $value ); } /** * Returns a JSON Schema of type array, with the input schema for each array item. * * If $itemSchema is a string, it must be a valid JSON type, and all list entries will be * validated to be of that type. * * If $itemSchema is an array, it must represent a valid schema, and all list entries will * be validated to be of that schema. Nested lists are supported, as are lists of maps and * more complicated schemas. * * Examples: * A list of integers, like [ 1, 2, 3 ] * ArrayDef::makeListSchema( "integer" ) * A list of strings, where each value must be either "a" or "b", like [ "a", "a", "b", "b" ] * * ArrayDef::makeListSchema( [ 'enum' => [ 'a', 'b' ] ] ) * A list of lists of strings, like [ [ "foo", 'bar" ], [ "baz", "qux" ] ] * ArrayDef::makeListSchema( ArrayDef::makeListSchema( "string" ) ) * * @since 1.43 * * @param array|string $itemSchema * * @return array */ public static function makeListSchema( $itemSchema ): array { return [ 'type' => 'array', 'items' => static::normalizeSchema( $itemSchema ) ]; } /** * Returns a JSON Schema of type object, with the input schema for each array item. * * If $entrySchema is a string, it must be a valid JSON type, and all map entries will be * validated to be of that type. * * If $entrySchema is an array, it must represent a valid schema, and all map entries will * be validated to be of that schema. Nested maps are supported, as are maps of lists and * more complicated schemas * * Examples: * A map of integers, like [ 'key1' => 1, 'key2' => 2, 'key3' => 3 ] * ArrayDef::makeMapSchema( "integer" ) * A map of where each value must be 0 or 1, like [ 'key1' => 1, 'key2' => 1, 'key3' => 0 ] * ArrayDef::makeMapSchema( [ 'enum' => [ 0, 1 ] ] ) * A map of maps, like [ 'k1' => [ 'k2' => 'a' ], 'k3' => [ 'k4' => 'b', 'k5' => 'c' ] ] * ArrayDef::makeMapSchema( ArrayDef::makeMapSchema( "string" ) ) * * @since 1.43 * * @param array|string $entrySchema * * @return array */ public static function makeMapSchema( $entrySchema ): array { return [ 'type' => 'object', 'additionalProperties' => static::normalizeSchema( $entrySchema ) ]; } /** * Returns a JSON Schema of type object, with properties defined by the function params. * * Any input schemas must either be a string corresponding to valid JSON types, or valid * schemas. Nested schemas are supported. * * Examples: * An object with required parameters "a" and "b", where "a" must be an integer and "b" can * have one of the values "x", "y", or "z", no optional parameters, and additional parameters * are disallowed: * ArrayDef::makeObjectSchema( [ 'a' => 'integer', 'b' => [ 'enum' => [ 'x', 'y', 'z' ] ] ] ) * The same object, but parameter "b" is optional: * ArrayDef::makeObjectSchema( [ 'a' => 'integer' ], [ 'b' => [ 'enum' => [ 'x', 'y', 'z' ] ] ] ) * An object with no required properties, an optional property "a" of type string, with * arbitrary additional properties allowed (effectively, an arbitrary object, but if "a" * is present, it must be a string): * ArrayDef::makeObjectSchema( [ ], [ 'a' => 'string' ], true ) * @since 1.43 * * @param array $required properties that are required to be present, as name/schema pairs * @param array $optional properties that may or may not be present, as name/schema pairs * @param array|bool|string $additional schema additional properties must match, or false * to disallow additional properties, or true to allow arbitrary additional properties * * @return array */ public static function makeObjectSchema( array $required = [], array $optional = [], $additional = false ): array { $schema = [ 'type' => 'object' ]; if ( $required ) { foreach ( $required as $propertyName => $propertySchema ) { $schema['required'][] = $propertyName; $schema['properties'][$propertyName] = static::normalizeSchema( $propertySchema ); } } if ( $optional ) { foreach ( $optional as $propertyName => $propertySchema ) { if ( isset( $schema['properties'][$propertyName] ) ) { throw new InvalidArgumentException( "Property {$propertyName} defined as both required and optional" ); } $schema['properties'][$propertyName] = static::normalizeSchema( $propertySchema ); } } // The easiest way to allow all extra properties is to not specify additionalProperties if ( $additional !== true ) { // A value of false disallows additional properties if ( $additional === false ) { $schema['additionalProperties'] = false; } else { $schema['additionalProperties'] = static::normalizeSchema( $additional ); } } return $schema; } /** * Returns a representation of the input schema * * If $schema is a string, it must be a valid JSON type. * If $schema is an array, it must represent a valid schema. * * @param array|string $schema * * @return array */ private static function normalizeSchema( $schema ): array { if ( is_array( $schema ) ) { return $schema; } else { return [ 'type' => $schema ]; } } }
| ver. 1.1 | |
.
| PHP 8.4.18 | Ð“ÐµÐ½ÐµÑ€Ð°Ñ†Ð¸Ñ Ñтраницы: 0 |
proxy
|
phpinfo
|
ÐаÑтройка