private static SwaggerSchema GetDtoSchema(ServiceInfo serviceInfo, ServiceDtoInfo dtoInfo)
{
var propertiesObject = new OurDictionary <string, SwaggerSchema>();
foreach (var fieldInfo in dtoInfo.Fields)
{
SwaggerSchema propertyObject = GetTypeSchema <SwaggerSchema>(serviceInfo.GetFieldType(fieldInfo));
if (propertyObject.Ref == null)
{
propertyObject.Description = GetSummaryOrNull(fieldInfo);
propertyObject.Obsolete = GetObsoleteOrNull(fieldInfo);
}
propertiesObject[fieldInfo.Name] = propertyObject;
}
return(new SwaggerSchema
{
Type = SwaggerSchemaType.Object,
Description = GetSummaryOrNull(dtoInfo),
Properties = propertiesObject,
Obsolete = GetObsoleteOrNull(dtoInfo),
Remarks = GetRemarksOrNull(dtoInfo),
});
}
private static object ConvertJTokenToObject(JToken token)
{
if (token is JValue)
{
return(((JValue)token).Value);
}
if (token is JArray)
{
return(token.AsEnumerable().Select(ConvertJTokenToObject).ToList());
}
if (token is JObject)
{
var dictionary = new OurDictionary <string, object>();
foreach (var property in token.AsEnumerable().Cast <JProperty>())
{
dictionary[property.Name] = ConvertJTokenToObject(property.Value);
}
return(dictionary);
}
throw new InvalidOperationException("Unexpected token: " + token);
}
/// <summary>
/// Generates Swagger (OpenAPI 2.0) for a service definition.
/// </summary>
public SwaggerService GenerateSwaggerService(ServiceInfo service)
{
var httpServiceInfo = HttpServiceInfo.Create(service);
var swaggerService = new SwaggerService
{
Swagger = SwaggerUtility.SwaggerVersion,
Info = new SwaggerInfo
{
Identifier = service.Name,
Title = GetSummaryOrNull(service) ?? service.Name,
Description = GetRemarksOrNull(service),
Version = service.TryGetAttribute("info")?.TryGetParameterValue("version") ?? "0.0.0",
CodeGen = CodeGenUtility.GetCodeGenComment(GeneratorName ?? ""),
},
};
var defaultBaseUri = httpServiceInfo.Url;
if (defaultBaseUri != null)
{
var baseUri = new Uri(defaultBaseUri);
swaggerService.Host = baseUri.Host;
swaggerService.Schemes = new[] { baseUri.Scheme };
string basePath = baseUri.PathAndQuery;
if (!string.IsNullOrEmpty(basePath) && basePath != "/")
{
swaggerService.BasePath = baseUri.PathAndQuery;
}
}
var paths = new OurDictionary <string, SwaggerOperations>();
foreach (var httpMethodInfo in httpServiceInfo.Methods)
{
AddMethodToPaths(paths, service, httpMethodInfo);
}
swaggerService.Paths = paths;
var dtoInfos = new OurDictionary <string, ServiceDtoInfo>();
foreach (var httpMethodInfo in httpServiceInfo.Methods)
{
if (httpMethodInfo.RequestBodyField != null)
{
AddDtos(dtoInfos, GetDtosForType(service.GetFieldType(httpMethodInfo.RequestBodyField.ServiceField) !));
}
AddDto(dtoInfos, TryCreateMethodRequestBodyType(httpMethodInfo)?.Dto);
foreach (var httpResponseInfo in httpMethodInfo.ValidResponses)
{
if (httpResponseInfo.BodyField != null)
{
AddDtos(dtoInfos, GetDtosForType(service.GetFieldType(httpResponseInfo.BodyField.ServiceField) !));
}
AddDto(dtoInfos, TryCreateMethodResponseBodyType(httpMethodInfo, httpResponseInfo)?.Dto);
}
}
while (true)
{
var dtoCount = dtoInfos.Count;
foreach (var field in dtoInfos.Values.SelectMany(x => x.Fields).ToList())
{
AddDtos(dtoInfos, GetDtosForType(service.GetFieldType(field) !));
}
if (dtoCount == dtoInfos.Count)
{
break;
}
}
var definitions = new OurDictionary <string, SwaggerSchema>();
foreach (var dtoInfo in dtoInfos.Values)
{
definitions[dtoInfo.Name] = GetDtoSchema(service, dtoInfo);
}
swaggerService.Definitions = definitions.Count == 0 ? null : definitions;
return(swaggerService);
}
private static void AddMethodToPaths(IDictionary <string, SwaggerOperations> paths, ServiceInfo service, HttpMethodInfo httpMethodInfo)
{
var methodInfo = httpMethodInfo.ServiceMethod;
SwaggerOperations operations;
if (!paths.TryGetValue(httpMethodInfo.Path, out operations))
{
paths[httpMethodInfo.Path] = operations = new SwaggerOperations();
}
var operation = new SwaggerOperation
{
Summary = GetSummaryOrNull(methodInfo),
Description = GetRemarksOrNull(methodInfo),
OperationId = methodInfo.Name,
Deprecated = GetObsoleteOrNull(methodInfo),
};
if (httpMethodInfo.RequestNormalFields.Count != 0 || httpMethodInfo.RequestBodyField != null)
{
operation.Consumes = new[] { "application/json" }
}
;
if (httpMethodInfo.ValidResponses.Any(x => (x.NormalFields != null && x.NormalFields.Count != 0) || (x.BodyField != null && service.GetFieldType(x.BodyField.ServiceField).Kind != ServiceTypeKind.Boolean)))
{
operation.Produces = new[] { "application/json" }
}
;
var parameters = new List <SwaggerParameter>();
foreach (var httpPathInfo in httpMethodInfo.PathFields)
{
parameters.Add(CreateSwaggerParameter(service, httpPathInfo.ServiceField, SwaggerParameterKind.Path, httpPathInfo.Name));
}
foreach (var httpQueryInfo in httpMethodInfo.QueryFields)
{
parameters.Add(CreateSwaggerParameter(service, httpQueryInfo.ServiceField, SwaggerParameterKind.Query, httpQueryInfo.Name));
}
foreach (var httpHeaderInfo in httpMethodInfo.RequestHeaderFields)
{
parameters.Add(CreateSwaggerParameter(service, httpHeaderInfo.ServiceField, SwaggerParameterKind.Header, httpHeaderInfo.Name));
}
var requestBodyFieldType = httpMethodInfo.RequestBodyField == null ? null : service.GetFieldType(httpMethodInfo.RequestBodyField.ServiceField);
if (requestBodyFieldType != null && requestBodyFieldType.Kind != ServiceTypeKind.Boolean)
{
parameters.Add(CreateSwaggerRequestBodyParameter(requestBodyFieldType, "request", httpMethodInfo.RequestBodyField.ServiceField.Summary));
}
else if (httpMethodInfo.RequestNormalFields.Count != 0)
{
parameters.Add(CreateSwaggerRequestBodyParameter(TryCreateMethodRequestBodyType(httpMethodInfo), "request"));
}
if (parameters.Count != 0)
{
operation.Parameters = parameters;
}
var responses = new OurDictionary <string, SwaggerResponse>();
foreach (var validResponse in httpMethodInfo.ValidResponses)
{
string statusCodeString = ((int)validResponse.StatusCode).ToString(CultureInfo.InvariantCulture);
var bodyField = validResponse.BodyField;
var bodyFieldType = bodyField == null ? null : service.GetFieldType(bodyField.ServiceField);
if (bodyField != null)
{
responses[statusCodeString] = CreateSwaggerResponse(bodyFieldType, bodyField.ServiceField.Name, bodyField.ServiceField.Summary);
}
else if (validResponse.NormalFields != null && validResponse.NormalFields.Count != 0)
{
responses[statusCodeString] = CreateSwaggerResponse(TryCreateMethodResponseBodyType(httpMethodInfo, validResponse));
}
else
{
responses[statusCodeString] = CreateSwaggerResponse();
}
}
operation.Responses = responses;
string httpMethod = httpMethodInfo.Method.ToString().ToLowerInvariant();
switch (httpMethod)
{
case "get":
operations.Get = operation;
break;
case "post":
operations.Post = operation;
break;
case "put":
operations.Put = operation;
break;
case "delete":
operations.Delete = operation;
break;
case "options":
operations.Options = operation;
break;
case "head":
operations.Head = operation;
break;
case "patch":
operations.Patch = operation;
break;
default:
throw new InvalidOperationException("Unexpected HTTP method: " + httpMethod);
}
}
