def parameters(self): """ Combined path-level and operation-level parameters. Any $refs are resolved here. Note that this implementation differs from the spec in that we only use the _name_ of a parameter to consider its uniqueness, not the name and location. This is because we end up passing parameters to the handler by name anyway, so any duplicate names, even if they had different locations, would be horribly mangled. :rtype: list[dict] """ parameters = OrderedDict() for source in ( self.path.mapping.get('parameters', ()), self.data.get('parameters', {}), ): source = maybe_resolve(source, self.router.resolve_reference) for parameter in source: parameter = maybe_resolve(parameter, self.router.resolve_reference) parameters[parameter['name']] = parameter return list(parameters.values())
def _get_regular_parameters(self): for source in ( self.path.mapping.get('parameters', ()), self.data.get('parameters', {}), ): source = maybe_resolve(source, self.api.resolve_reference) for parameter in source: parameter_data = maybe_resolve(parameter, self.api.resolve_reference) parameter = self.parameter_class(data=parameter_data, operation=self, api=self.api) yield parameter
def cast_parameter_value(api_info, parameter, value): if parameter.get('type') == 'array': if not isinstance(value, list): # could be a list already if collection format was multi splitter = COLLECTION_FORMAT_SPLITTERS.get(parameter.get('collectionFormat', 'csv')) if not splitter: raise NotImplementedError('unsupported collection format in %r' % parameter) value = splitter(value) items = parameter['items'] value = [cast_parameter_value(api_info, items, item) for item in value] if 'schema' in parameter: schema = maybe_resolve(parameter['schema'], api_info.router.resolve_reference) jsonschema.validate(value, schema, resolver=api_info.router.resolver) if 'discriminator' in schema: # Swagger Polymorphism support type = value[schema['discriminator']] actual_type = '#/definitions/%s' % type schema = api_info.router.resolve_reference(actual_type) jsonschema.validate(value, schema, resolver=api_info.router.resolver) return value value = cast_primitive_value(parameter, value) jsonschema_validation_object = { key: parameter[key] for key in parameter if key in OPENAPI_JSONSCHEMA_VALIDATION_KEYS } if jsonschema_validation_object: jsonschema.validate(value, jsonschema_validation_object) return value
def validate_schema(schema, api, value): schema = maybe_resolve(schema, resolve=api.resolve_reference) jsonschema.validate( value, schema, cls=LepoDraft4Validator, resolver=api.resolver, ) if 'discriminator' in schema: # Swagger/OpenAPI 3 Polymorphism support discriminator = schema['discriminator'] if isinstance(discriminator, dict): # OpenAPI 3 type = value[discriminator['propertyName']] if 'mapping' in discriminator: actual_type = discriminator['mapping'][type] else: actual_type = '#/components/schemas/%s' % type else: type = value[discriminator] actual_type = '#/definitions/%s' % type schema = api.resolve_reference(actual_type) jsonschema.validate( value, schema, cls=LepoDraft4Validator, resolver=api.resolver, ) return value
def get_path(self, path): """ Construct a Path object from a path string. The Path string must be declared in the API. :type path: str :rtype: lepo.path.Path """ mapping = maybe_resolve(self.api['paths'][path], self.resolve_reference) return self.path_class(router=self, path=path, mapping=mapping)
def _get_body_parameter(self): for source in ( self.path.mapping.get('requestBody'), self.data.get('requestBody'), ): if source: source = maybe_resolve(source, self.api.resolve_reference) body_parameter = self.body_parameter_class(data=source, operation=self, api=self.api) # TODO: Document x-lepo-body-name body_parameter.name = self.data.get('x-lepo-body-name', body_parameter.name) return body_parameter
def get_path_mapping(self, path): return maybe_resolve(self.doc['paths'][path], self.resolve_reference)
def validate_schema(self, api, value): schema = maybe_resolve(self.schema, resolve=api.resolve_reference) return validate_schema(schema, api, value)
def schema(self): schema = self.data['schema'] schema = maybe_resolve( schema, resolve=(self.api.resolve_reference if self.api else None)) return OpenAPI3Schema(schema)