internal static OpenApiOperation LoadOperation(ParseNode node)
{
// Reset these temp storage parameters for each operation.
node.Context.SetTempStorage(TempStorageKeys.BodyParameter, null);
node.Context.SetTempStorage(TempStorageKeys.FormParameters, null);
node.Context.SetTempStorage(TempStorageKeys.OperationProduces, null);
node.Context.SetTempStorage(TempStorageKeys.OperationConsumes, null);
var mapNode = node.CheckMapNode("Operation");
var operation = new OpenApiOperation();
ParseMap(mapNode, operation, _operationFixedFields, _operationPatternFields);
// Build request body based on information determined while parsing OpenApiOperation
var bodyParameter = node.Context.GetFromTempStorage <OpenApiParameter>(TempStorageKeys.BodyParameter);
if (bodyParameter != null)
{
operation.RequestBody = CreateRequestBody(node.Context, bodyParameter);
}
else
{
var formParameters = node.Context.GetFromTempStorage <List <OpenApiParameter> >(TempStorageKeys.FormParameters);
if (formParameters != null)
{
operation.RequestBody = CreateFormBody(node.Context, formParameters);
}
}
return(operation);
}
public static OpenApiSecurityRequirement LoadSecurityRequirement(ParseNode node)
{
var mapNode = node.CheckMapNode("security");
var securityRequirement = new OpenApiSecurityRequirement();
foreach (var property in mapNode)
{
var scheme = LoadSecuritySchemeByReference(
mapNode.Context,
mapNode.Diagnostic,
property.Name);
var scopes = property.Value.CreateSimpleList(value => value.GetScalarValue());
if (scheme != null)
{
securityRequirement.Add(scheme, scopes);
}
else
{
node.Diagnostic.Errors.Add(
new OpenApiError(node.Context.GetLocation(), $"Scheme {property.Name} is not found"));
}
}
return(securityRequirement);
}
public static OpenApiSchema LoadSchema(ParseNode node)
{
var mapNode = node.CheckMapNode(OpenApiConstants.Schema);
var pointer = mapNode.GetReferencePointer();
if (pointer != null)
{
return(new OpenApiSchema()
{
UnresolvedReference = true,
Reference = node.Context.VersionService.ConvertToOpenApiReference(pointer, ReferenceType.Schema)
});
}
var schema = new OpenApiSchema();
foreach (var propertyNode in mapNode)
{
propertyNode.ParseField(schema, _schemaFixedFields, _schemaPatternFields);
}
ProcessAnyFields(mapNode, schema, _schemaAnyFields);
ProcessAnyListFields(mapNode, schema, _schemaAnyListFields);
return(schema);
}
public static OpenApiResponse LoadResponse(ParseNode node)
{
var mapNode = node.CheckMapNode("response");
var pointer = mapNode.GetReferencePointer();
if (pointer != null)
{
return(mapNode.GetReferencedObject <OpenApiResponse>(ReferenceType.Response, pointer));
}
var response = new OpenApiResponse();
foreach (var property in mapNode)
{
property.ParseField(response, _responseFixedFields, _responsePatternFields);
}
foreach (var mediaType in response.Content.Values)
{
if (mediaType.Schema != null)
{
ProcessAnyFields(mapNode, mediaType, _mediaTypeAnyFields);
}
}
return(response);
}
internal static OpenApiOperation LoadOperation(ParseNode node)
{
var mapNode = node.CheckMapNode("OpenApiOperation");
var operation = new OpenApiOperation();
ParseMap(mapNode, operation, _operationFixedFields, _operationPatternFields);
// Build request body based on information determined while parsing OpenApiOperation
var bodyParameter = node.Context.GetFromTempStorage <OpenApiParameter>("bodyParameter");
if (bodyParameter != null)
{
operation.RequestBody = CreateRequestBody(node.Context, bodyParameter);
}
else
{
var formParameters = node.Context.GetFromTempStorage <List <OpenApiParameter> >("formParameters");
if (formParameters != null)
{
operation.RequestBody = CreateFormBody(formParameters);
}
}
return(operation);
}
public static OpenApiParameter LoadParameter(ParseNode node, bool evenBody)
{
// Reset the local variables every time this method is called.
_in = null;
var mapNode = node.CheckMapNode("parameter");
var pointer = mapNode.GetReferencePointer();
if (pointer != null)
{
return(mapNode.GetReferencedObject <OpenApiParameter>(ReferenceType.Parameter, pointer));
}
var parameter = new OpenApiParameter();
ParseMap(mapNode, parameter, _parameterFixedFields, _parameterPatternFields);
var schema = node.Context.GetFromTempStorage <OpenApiSchema>("schema");
if (schema != null)
{
parameter.Schema = schema;
node.Context.SetTempStorage("schema", null);
}
if (_in == null && !evenBody)
{
return(null); // Don't include Form or Body parameters in OpenApiOperation.Parameters list
}
return(parameter);
}
private static void LoadExamples(OpenApiResponse response, ParseNode node)
{
var mapNode = node.CheckMapNode("examples");
foreach (var mediaTypeNode in mapNode)
{
LoadExample(response, mediaTypeNode.Name, mediaTypeNode.Value);
}
}
public static OpenApiComponents LoadComponents(ParseNode node)
{
var mapNode = node.CheckMapNode("components");
var components = new OpenApiComponents();
ParseMap(mapNode, components, _componentsFixedFields, _componentsPatternFields);
return(components);
}
public static OpenApiServerVariable LoadServerVariable(ParseNode node)
{
var mapNode = node.CheckMapNode("serverVariable");
var serverVariable = new OpenApiServerVariable();
ParseMap(mapNode, serverVariable, _serverVariableFixedFields, _serverVariablePatternFields);
return(serverVariable);
}
public static OpenApiResponses LoadResponses(ParseNode node)
{
var mapNode = node.CheckMapNode("Responses");
var domainObject = new OpenApiResponses();
ParseMap(mapNode, domainObject, _responsesFixedFields, _responsesPatternFields);
return(domainObject);
}
internal static OpenApiLicense LoadLicense(ParseNode node)
{
var mapNode = node.CheckMapNode("License");
var license = new OpenApiLicense();
ParseMap(mapNode, license, _licenseFixedFields, _licensePatternFields);
return(license);
}
public static OpenApiInfo LoadInfo(ParseNode node)
{
var mapNode = node.CheckMapNode("Info");
var info = new OpenApiInfo();
ParseMap(mapNode, info, _infoFixedFields, _infoPatternFields);
return(info);
}
public static OpenApiPathItem LoadPathItem(ParseNode node)
{
var mapNode = node.CheckMapNode("PathItem");
var pathItem = new OpenApiPathItem();
ParseMap(mapNode, pathItem, _pathItemFixedFields, _pathItemPatternFields);
return(pathItem);
}
internal static OpenApiOperation LoadOperation(ParseNode node)
{
var mapNode = node.CheckMapNode("Operation");
var operation = new OpenApiOperation();
ParseMap(mapNode, operation, _operationFixedFields, _operationPatternFields);
return(operation);
}
public static OpenApiExternalDocs LoadExternalDocs(ParseNode node)
{
var mapNode = node.CheckMapNode("externalDocs");
var externalDocs = new OpenApiExternalDocs();
ParseMap(mapNode, externalDocs, _externalDocsFixedFields, _externalDocsPatternFields);
return(externalDocs);
}
public static OpenApiPaths LoadPaths(ParseNode node)
{
var mapNode = node.CheckMapNode("Paths");
var domainObject = new OpenApiPaths();
ParseMap(mapNode, domainObject, _pathsFixedFields, _pathsPatternFields);
return(domainObject);
}
public static OpenApiServer LoadServer(ParseNode node)
{
var mapNode = node.CheckMapNode("server");
var server = new OpenApiServer();
ParseMap(mapNode, server, _serverFixedFields, _serverPatternFields);
return(server);
}
public static OpenApiDiscriminator LoadDiscriminator(ParseNode node)
{
var mapNode = node.CheckMapNode("discriminator");
var discriminator = new OpenApiDiscriminator();
foreach (var property in mapNode)
{
property.ParseField(discriminator, _discriminatorFixedFields, _discriminatorPatternFields);
}
return(discriminator);
}
public static OpenApiTag LoadTag(ParseNode n)
{
var mapNode = n.CheckMapNode("tag");
var domainObject = new OpenApiTag();
foreach (var propertyNode in mapNode)
{
propertyNode.ParseField(domainObject, _tagFixedFields, _tagPatternFields);
}
return(domainObject);
}
public static OpenApiInfo LoadInfo(ParseNode node)
{
var mapNode = node.CheckMapNode("Info");
var info = new OpenApiInfo();
var required = new List <string> {
"title", "version"
};
ParseMap(mapNode, info, InfoFixedFields, InfoPatternFields, required);
return(info);
}
public static OpenApiEncoding LoadEncoding(ParseNode node)
{
var mapNode = node.CheckMapNode("encoding");
var encoding = new OpenApiEncoding();
foreach (var property in mapNode)
{
property.ParseField(encoding, _encodingFixedFields, _encodingPatternFields);
}
return(encoding);
}
public static OpenApiOAuthFlows LoadOAuthFlows(ParseNode node)
{
var mapNode = node.CheckMapNode("OAuthFlows");
var oAuthFlows = new OpenApiOAuthFlows();
foreach (var property in mapNode)
{
property.ParseField(oAuthFlows, _oAuthFlowsFixedFileds, _oAuthFlowsPatternFields);
}
return(oAuthFlows);
}
public static OpenApiMediaType LoadMediaType(ParseNode node)
{
var mapNode = node.CheckMapNode(OpenApiConstants.Content);
var mediaType = new OpenApiMediaType();
ParseMap(mapNode, mediaType, _mediaTypeFixedFields, _mediaTypePatternFields);
ProcessAnyFields(mapNode, mediaType, _mediaTypeAnyFields);
ProcessAnyMapFields(mapNode, mediaType, _mediaTypeAnyMapOpenApiExampleFields);
return(mediaType);
}
public static OpenApiSecurityScheme LoadSecurityScheme(ParseNode node)
{
var mapNode = node.CheckMapNode("securityScheme");
var securityScheme = new OpenApiSecurityScheme();
foreach (var property in mapNode)
{
property.ParseField(securityScheme, _securitySchemeFixedFields, _securitySchemePatternFields);
}
return(securityScheme);
}
public static OpenApiOAuthFlow LoadOAuthFlow(ParseNode node)
{
var mapNode = node.CheckMapNode("OAuthFlow");
var oauthFlow = new OpenApiOAuthFlow();
foreach (var property in mapNode)
{
property.ParseField(oauthFlow, _oAuthFlowFixedFileds, _oAuthFlowPatternFields);
}
return(oauthFlow);
}
public static OpenApiXml LoadXml(ParseNode node)
{
var mapNode = node.CheckMapNode("xml");
var xml = new OpenApiXml();
foreach (var property in mapNode)
{
property.ParseField(xml, _xmlFixedFields, _xmlPatternFields);
}
return(xml);
}
public static OpenApiMediaType LoadMediaType(ParseNode node)
{
var mapNode = node.CheckMapNode(OpenApiConstants.Content);
if (!mapNode.Any())
{
return(null);
}
var mediaType = new OpenApiMediaType();
ParseMap(mapNode, mediaType, _mediaTypeFixedFields, _mediaTypePatternFields);
return(mediaType);
}
public static OpenApiSecurityScheme LoadSecurityScheme(ParseNode node)
{
// Reset the local variables every time this method is called.
// TODO: Change _flow to a tempStorage variable to make the deserializer thread-safe.
_flowValue = null;
_flow = new OpenApiOAuthFlow();
var mapNode = node.CheckMapNode("securityScheme");
var securityScheme = new OpenApiSecurityScheme();
foreach (var property in mapNode)
{
property.ParseField(securityScheme, _securitySchemeFixedFields, _securitySchemePatternFields);
}
// Put the Flow object in the right Flows property based on the string in "flow"
if (_flowValue == OpenApiConstants.Implicit)
{
securityScheme.Flows = new OpenApiOAuthFlows
{
Implicit = _flow
};
}
else if (_flowValue == OpenApiConstants.Password)
{
securityScheme.Flows = new OpenApiOAuthFlows
{
Password = _flow
};
}
else if (_flowValue == OpenApiConstants.Application)
{
securityScheme.Flows = new OpenApiOAuthFlows
{
ClientCredentials = _flow
};
}
else if (_flowValue == OpenApiConstants.AccessCode)
{
securityScheme.Flows = new OpenApiOAuthFlows
{
AuthorizationCode = _flow
};
}
return(securityScheme);
}
public static OpenApiLink LoadLink(ParseNode node)
{
var mapNode = node.CheckMapNode("link");
var link = new OpenApiLink();
var pointer = mapNode.GetReferencePointer();
if (pointer != null)
{
return(mapNode.GetReferencedObject <OpenApiLink>(ReferenceType.Link, pointer));
}
ParseMap(mapNode, link, _linkFixedFields, _linkPatternFields);
return(link);
}
public static OpenApiCallback LoadCallback(ParseNode node)
{
var mapNode = node.CheckMapNode("callback");
var pointer = mapNode.GetReferencePointer();
if (pointer != null)
{
return(mapNode.GetReferencedObject <OpenApiCallback>(ReferenceType.Callback, pointer));
}
var domainObject = new OpenApiCallback();
ParseMap(mapNode, domainObject, _callbackFixedFields, _callbackPatternFields);
return(domainObject);
}
