public OperationGroupEntity Transform(SwaggerModel swaggerModel, RestApiRootItemViewModel viewModel, ConcurrentDictionary <string, ConcurrentBag <Operation> > groupOperations, string version)
{
var serviceId = swaggerModel.Metadata.GetValueFromMetaData <string>("x-internal-service-id");
var serviceName = swaggerModel.Metadata.GetValueFromMetaData <string>("x-internal-service-name");
var groupName = swaggerModel.Metadata.GetValueFromMetaData <string>("x-internal-toc-name");
var subgroupName = swaggerModel.Metadata.GetValueFromMetaData <string>("x-internal-sub-group-name");
var productUid = swaggerModel.Metadata.GetValueFromMetaData <string>("x-internal-product-uid");
var basePath = swaggerModel.BasePath;
var apiVersion = swaggerModel.Info.Version;
var groupId = Utility.TrimUId($"{Utility.GetHostWithBasePathUId(swaggerModel.Host, productUid, basePath)}.{serviceId}.{subgroupName}.{groupName}")?.ToLower();
ConcurrentBag <Operation> operations;
var key = string.IsNullOrEmpty(version) ? groupId : $"{version}_{groupId}";
if (groupOperations.TryGetValue(key, out operations))
{
if (operations.Count() > 0)
{
return(new OperationGroupEntity
{
Id = groupId,
ApiVersion = apiVersion,
Name = groupName,
Operations = operations.OrderBy(p => p.Id).ToList(),
Service = serviceName,
Summary = GetSummary(swaggerModel, viewModel)
});
}
}
return(null);
}
private IList <IHtmlTemplate> TryGenerateTemplateInstances(SwaggerModel swaggerModel, out string explanation)
{
List <IHtmlTemplate> htmlTemplateInstances = new List <IHtmlTemplate>();
var assemblyDescription = new AssemlyDescription(_assemblyDescription, swaggerModel.AssemblyName);
if (!assemblyDescription.IsValid(out explanation))
{
return(null);
}
htmlTemplateInstances.Add(assemblyDescription);
var controllerTemplateInstances = TryGenerateControllerTemplateInstances(out explanation, swaggerModel.ControllerClasses);
if (controllerTemplateInstances == null)
{
return(null);
}
htmlTemplateInstances.AddRange(controllerTemplateInstances);
var dataModelInstances = TryGenerateDataModelTemplateInstance(out explanation, swaggerModel.DataTypes);
if (dataModelInstances == null)
{
return(null);
}
htmlTemplateInstances.AddRange(dataModelInstances);
explanation = null;
return(htmlTemplateInstances);
}
private OperationInfo[] GetOperationList(SwaggerModel model)
{
return
((from path in model.Paths
from operation in path.Value
select GetOperation(model.BasePath, path.Key, operation.Key, operation.Value))
.ToArray());
}
public static AndroidGenerator Create(string json)
{
AndroidGenerator g = new AndroidGenerator();
g.Model = SwaggerModel.From(json);
return(g);
}
public ActionResult Hypercube(CodeModel model)
{
var swagger = SwaggerModel.From(model.Text);
return(Json(new {
}));
}
protected override string GetSummary(SwaggerModel swaggerModel, RestApiRootItemViewModel viewModel)
{
var groupName = swaggerModel.Metadata.GetValueFromMetaData <string>("x-internal-toc-name");
var tag = viewModel.Tags?.FirstOrDefault(t => t.Name == groupName);
if (!string.IsNullOrEmpty(tag?.Description))
{
return(tag?.Description);
}
return(Utility.GetSummary(viewModel.Summary, viewModel.Description));
}
internal static void Main(string[] args)
{
if (args.Length == 0)
{
GiveIntrodocutionDescription();
DescribeAllDocumentGenerators();
return;
}
var documentTypes = DocumentGenerators.Select(d => d.FileType).ToArray();
var reader = new CommandLineArgumentReader(args, documentTypes);
if (!reader.IsValid(out string explanation))
{
WriteErrorLine("Invalid arguments");
WriteErrorLine(explanation);
GiveIntrodocutionDescription();
DescribeAllDocumentGenerators();
return;
}
Debug.Assert(explanation == null);
var argumentProperties = reader.GetArgumentPropertiesIfValidated();
var documentGeneratorToUse = DocumentGenerators.First(d => d.FileType == argumentProperties.FileType);
if (!documentGeneratorToUse.TryInitialize(out string nextExplanation))
{
WriteErrorLine("Initialisation error");
WriteErrorLine(nextExplanation);
return;
}
Debug.Assert(nextExplanation == null);
SwaggerModel swaggerModel = GetSwaggerModel(argumentProperties.InputFileName);
if (swaggerModel == null)
{
return;
}
if (!documentGeneratorToUse.TryGenerateOutputFile(swaggerModel, argumentProperties.OutputFileName, out string generationIssue))
{
WriteErrorLine("Generation error");
WriteErrorLine(generationIssue);
return;
}
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("-----------------------------------------------------------");
Console.WriteLine($"Successfully created {argumentProperties.OutputFileName}");
Console.ResetColor();
}
private static void CheckOperationId(SwaggerModel swagger, string fileName)
{
if (swagger.Paths != null)
{
foreach (var path in swagger.Paths)
{
foreach (var operation in path.Value.Metadata)
{
if (operation.Value is JObject jObject && !jObject.TryGetValue(OperationIdKey, out JToken operationId))
{
throw new DocfxException($"{OperationIdKey} should exist in operation '{operation.Key}' of path '{path.Key}' for swagger file '{fileName}'");
}
}
}
}
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseHsts();
}
// SWAGGER CONFIGURATIONS
var swaggerModel = new SwaggerModel();
Configuration.GetSection(nameof(SwaggerModel)).Bind(swaggerModel);
app.UseSwagger(option =>
{
option.RouteTemplate = swaggerModel.JsonRoute;
});
app.UseSwaggerUI(option =>
{
option.SwaggerEndpoint(swaggerModel.UIEndpoint, swaggerModel.Description);
});
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthentication();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllerRoute(
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}");
});
}
public bool TryGenerateOutputFile(SwaggerModel swaggerModel, string outPutFile, out string explanation)
{
if (swaggerModel == null)
{
explanation = "No data model received";
return(false);
}
if (String.IsNullOrEmpty(outPutFile))
{
explanation = "No output file received";
return(false);
}
var directory = Path.GetDirectoryName(outPutFile);
if (String.IsNullOrEmpty(directory))
{
explanation = $"The directory of outputfile {outPutFile} is not valid";
return(false);
}
var htmlInstances = TryGenerateTemplateInstances(swaggerModel, out explanation);
if (htmlInstances == null)
{
return(false);
}
var fullContent = String.Join('\n', htmlInstances.Select(h => h.GenerateHtml()));
try
{
File.WriteAllText(outPutFile, fullContent);
}
catch (Exception e)
{
explanation = $"Error while writing file {outPutFile}: {e.Message}";
return(false);
}
explanation = null;
return(true);
}
public static RestApiRootItemViewModel FromSwaggerModel(SwaggerModel swagger)
{
var uid = GetUid(swagger);
var vm = new RestApiRootItemViewModel
{
Name = swagger.Info.Title,
Uid = uid,
HtmlId = GetHtmlId(uid),
Metadata = swagger.Metadata,
Description = swagger.Description,
Summary = swagger.Summary,
Children = new List <RestApiChildItemViewModel>(),
Raw = swagger.Raw,
Tags = new List <RestApiTagViewModel>()
};
if (swagger.Tags != null)
{
foreach (var tag in swagger.Tags)
{
vm.Tags.Add(new RestApiTagViewModel
{
Name = tag.Name,
Description = tag.Description,
HtmlId = string.IsNullOrEmpty(tag.BookmarkId) ? GetHtmlId(tag.Name) : tag.BookmarkId, // Fall back to tag name's html id
Metadata = tag.Metadata,
Uid = GetUidForTag(uid, tag)
});
}
}
if (swagger.Paths != null)
{
foreach (var path in swagger.Paths)
{
var commonParameters = path.Value.Parameters;
foreach (var op in path.Value.Metadata)
{
// fetch operations from metadata
if (OperationNames.Contains(op.Key, StringComparer.OrdinalIgnoreCase))
{
var opJObject = op.Value as JObject;
if (opJObject == null)
{
throw new InvalidOperationException($"Value of {op.Key} should be JObject");
}
// convert operation from JObject to OperationObject
var operation = opJObject.ToObject <OperationObject>();
var parameters = GetParametersForOperation(operation.Parameters, commonParameters);
var itemUid = GetUidForOperation(uid, operation);
var itemVm = new RestApiChildItemViewModel
{
Path = path.Key,
OperationName = op.Key,
Tags = operation.Tags,
OperationId = operation.OperationId,
HtmlId = GetHtmlId(itemUid),
Uid = itemUid,
Metadata = operation.Metadata,
Description = operation.Description,
Summary = operation.Summary,
Parameters = parameters?.Select(s => new RestApiParameterViewModel
{
Description = s.Description,
Name = s.Name,
Metadata = s.Metadata
}).ToList(),
Responses = operation.Responses?.Select(s => new RestApiResponseViewModel
{
Metadata = s.Value.Metadata,
Description = s.Value.Description,
Summary = s.Value.Summary,
HttpStatusCode = s.Key,
Examples = s.Value.Examples?.Select(example => new RestApiResponseExampleViewModel
{
MimeType = example.Key,
Content = example.Value != null ? JsonUtility.Serialize(example.Value) : null,
}).ToList(),
}).ToList(),
};
// TODO: line number
if (swagger.Metadata.TryGetValue(Constants.PropertyName.Source, out object value))
{
itemVm.Metadata[Constants.PropertyName.Source] = value;
}
else
{
itemVm.Metadata[Constants.PropertyName.Source] = null;
}
vm.Children.Add(itemVm);
}
}
}
}
return(vm);
}
private static string GetUid(SwaggerModel swagger)
{
return(GenerateUid(swagger.Host, swagger.BasePath, swagger.Info.Title, swagger.Info.Version));
}
private static SwaggerInfo Cleanup(SwaggerModel obj)
{
SwaggerInfo result = new SwaggerInfo();
result.ApiVersion = obj.ApiVersion;
// Set up alternative version numbers: This one does not permit dashes
result.ApiVersionPeriodsOnly = result.ApiVersion.Replace("-", ".");
// Set up alternative version numbers: This one permits only three segments
var sb = new StringBuilder();
int numPeriods = 0;
foreach (char c in obj.ApiVersion)
{
if (c == '.')
{
numPeriods++;
}
if (numPeriods > 3 || c == '-')
{
break;
}
sb.Append(c);
}
result.ApiVersionThreeSegmentsOnly = sb.ToString();
// Loop through all paths and spit them out to the console
foreach (var path in (from p in obj.paths orderby p.Key select p))
{
foreach (var verb in path.Value)
{
// Set up our API
MethodInfo api = new MethodInfo();
api.URI = path.Key;
api.HttpVerb = verb.Key;
api.Summary = verb.Value.summary;
api.Description = verb.Value.description;
api.Params = new List <ParameterInfo>();
api.Category = verb.Value.tags.FirstOrDefault();
api.Name = verb.Value.operationId;
// Now figure out all the URL parameters
foreach (var parameter in verb.Value.parameters)
{
// Construct parameter
var pi = ResolveType(parameter);
// Query String Parameters
if (parameter.paramIn == "query")
{
pi.ParameterLocation = ParameterLocationType.QueryString;
// URL Path parameters
}
else if (parameter.paramIn == "path")
{
pi.ParameterLocation = ParameterLocationType.UriPath;
// Body parameters
}
else if (parameter.paramIn == "body")
{
pi.ParamName = "model";
pi.ParameterLocation = ParameterLocationType.RequestBody;
api.BodyParam = pi;
}
else if (parameter.paramIn == "header")
{
pi.ParameterLocation = ParameterLocationType.Header;
}
else if (parameter.paramIn == "formData")
{
pi.ParameterLocation = ParameterLocationType.FormData;
}
else
{
throw new Exception("Unrecognized parameter location: " + parameter.paramIn);
}
api.Params.Add(pi);
// Is this property an enum?
if (parameter.EnumDataType != null)
{
ExtractEnum(result.Enums, parameter);
}
}
// Now figure out the response type
SwaggerResult ok = null;
if (verb.Value.responses.TryGetValue("200", out ok))
{
api.ResponseType = ok.schema == null ? null : ok.schema.type;
api.ResponseTypeName = ResolveTypeName(ok.schema);
}
else if (verb.Value.responses.TryGetValue("201", out ok))
{
api.ResponseType = ok.schema == null ? null : ok.schema.type;
api.ResponseTypeName = ResolveTypeName(ok.schema);
}
// Ensure that body parameters are always last for consistency
if (api.BodyParam != null)
{
api.Params.Remove(api.BodyParam);
api.Params.Add(api.BodyParam);
}
// Done with this API
result.Methods.Add(api);
}
}
// Loop through all the schemas
foreach (var def in obj.definitions)
{
var m = new ModelInfo()
{
SchemaName = def.Key,
Comment = def.Value.description,
Example = def.Value.example,
Description = def.Value.description,
Required = def.Value.required,
Type = def.Value.type,
Properties = new List <ParameterInfo>()
};
foreach (var prop in def.Value.properties)
{
if (!prop.Value.required && def.Value.required != null)
{
prop.Value.required = def.Value.required.Contains(prop.Key);
}
// Construct property
var pi = ResolveType(prop.Value);
pi.ParamName = prop.Key;
m.Properties.Add(pi);
// Is this property an enum?
if (prop.Value.EnumDataType != null)
{
ExtractEnum(result.Enums, prop.Value);
}
}
result.Models.Add(m);
}
//// Now add the enums we know we need.
//// Because of the complex way this Dictionary<> is rendered in Swagger, it's hard to pick up the correct values.
//var tat = (from e in result.Enums where e.EnumDataType == "TransactionAddressType" select e).FirstOrDefault();
//if (tat == null) {
// tat = new EnumInfo()
// {
// EnumDataType = "TransactionAddressType",
// Items = new List<EnumItem>()
// };
// result.Enums.Add(tat);
//}
//tat.AddItem("ShipFrom", "This is the location from which the product was shipped");
//tat.AddItem("ShipTo", "This is the location to which the product was shipped");
//tat.AddItem("PointOfOrderAcceptance", "Location where the order was accepted; typically the call center, business office where purchase orders are accepted, server locations where orders are processed and accepted");
//tat.AddItem("PointOfOrderOrigin", "Location from which the order was placed; typically the customer's home or business location");
//tat.AddItem("SingleLocation", "Only used if all addresses for this transaction were identical; e.g. if this was a point-of-sale physical transaction");
// Here's your processed API
return(result);
}
protected override string GetSummary(SwaggerModel swaggerModel, RestApiRootItemViewModel viewModel)
{
return(Utility.GetSummary(viewModel.Summary, viewModel.Description));
}
private static OkapiInfo Cleanup(SwaggerModel obj)
{
OkapiInfo result = new OkapiInfo();
result.ApiVersion = obj.ApiVersion;
// Set up alternative version numbers: This one does not permit dashes
result.ApiVersionPeriodsOnly = result.ApiVersion.Replace("-", ".");
// Set up alternative version numbers: This one permits only three segments
var sb = new StringBuilder();
int numPeriods = 0;
foreach (char c in obj.ApiVersion)
{
if (c == '.')
{
numPeriods++;
}
if (numPeriods > 3 || c == '-')
{
break;
}
sb.Append(c);
}
result.ApiVersionThreeSegmentsOnly = sb.ToString();
// Loop through all paths and spit them out to the console
foreach (var path in (from p in obj.paths orderby p.Key select p))
{
foreach (var verb in path.Value)
{
// Set up our API
var api = new OkapiMethodInfo();
api.URI = path.Key;
api.HttpVerb = verb.Key;
api.Summary = verb.Value.summary;
api.Description = verb.Value.description;
api.Params = new List <OkapiParameterInfo>();
api.Category = verb.Value.tags.FirstOrDefault();
api.Name = verb.Value.operationId;
// Now figure out all the URL parameters
foreach (var parameter in verb.Value.parameters)
{
// Construct parameter
var pi = ResolveType(parameter);
// Query String Parameters
if (parameter.paramIn == "query")
{
pi.ParameterLocation = ParameterLocationType.QueryString;
// URL Path parameters
}
else if (parameter.paramIn == "path")
{
pi.ParameterLocation = ParameterLocationType.UriPath;
// Body parameters
}
else if (parameter.paramIn == "body")
{
pi.ParamName = "model";
pi.ParameterLocation = ParameterLocationType.RequestBody;
api.BodyParam = pi;
}
else if (parameter.paramIn == "header")
{
pi.ParameterLocation = ParameterLocationType.Header;
}
else if (parameter.paramIn == "formData")
{
pi.ParameterLocation = ParameterLocationType.FormData;
}
else
{
throw new Exception("Unrecognized parameter location: " + parameter.paramIn);
}
api.Params.Add(pi);
// Is this property an enum?
if (parameter.EnumDataType != null)
{
ExtractEnum(result.Enums, parameter);
}
}
// Now figure out the response type
SwaggerResult ok = null;
if (verb.Value.responses.TryGetValue("200", out ok))
{
api.ResponseType = ok.schema == null ? null : ok.schema.type;
api.ResponseTypeName = ResolveTypeName(ok.schema);
}
else if (verb.Value.responses.TryGetValue("201", out ok))
{
api.ResponseType = ok.schema == null ? null : ok.schema.type;
api.ResponseTypeName = ResolveTypeName(ok.schema);
}
// Ensure that body parameters are always last for consistency
if (api.BodyParam != null)
{
api.Params.Remove(api.BodyParam);
api.Params.Add(api.BodyParam);
}
// Done with this API
result.Methods.Add(api);
}
}
// Loop through all the schemas
foreach (var def in obj.definitions)
{
var m = new OkapiModelInfo()
{
SchemaName = def.Key,
Comment = def.Value.description,
Example = def.Value.example,
Description = def.Value.description,
Required = def.Value.required,
Type = def.Value.type,
Properties = new List <OkapiParameterInfo>()
};
foreach (var prop in def.Value.properties)
{
if (!prop.Value.required && def.Value.required != null)
{
prop.Value.required = def.Value.required.Contains(prop.Key);
}
// Construct property
var pi = ResolveType(prop.Value);
pi.ParamName = prop.Key;
m.Properties.Add(pi);
// Is this property an enum?
if (prop.Value.EnumDataType != null)
{
ExtractEnum(result.Enums, prop.Value);
}
}
result.Models.Add(m);
}
// Here's your processed API
return(result);
}
private static void ParseModel(IDictionary <string, SwaggerModel> models, Type modelType)
{
if (IsSwaggerScalarType(modelType))
{
return;
}
var modelId = modelType.Name;
if (models.ContainsKey(modelId))
{
return;
}
var model = new SwaggerModel
{
Id = modelId,
Properties = new Dictionary <string, ModelProperty>()
};
models[model.Id] = model;
foreach (var prop in modelType.GetProperties())
{
var apiMemberAttributes = GetAttributesOfType <ApiMemberAttribute>(prop);
var allApiDocAttributes =
apiMemberAttributes.Where(
attr => prop.Name.Equals(attr.Name, StringComparison.InvariantCultureIgnoreCase))
.ToList();
var apiDoc = allApiDocAttributes.FirstOrDefault(attr => attr.ParameterType == "body");
if (allApiDocAttributes.Any() && apiDoc == null)
{
continue;
}
var propertyType = prop.PropertyType;
var modelProp = new ModelProperty
{
Type = GetSwaggerTypeName(propertyType),
Required = !IsNullable(propertyType)
};
if (IsListType(propertyType))
{
modelProp.Type = SwaggerType.Array;
var listItemType = GetListElementType(propertyType);
modelProp.Items = new Dictionary <string, string>
{
{
IsSwaggerScalarType(listItemType)
? "type"
: "$ref",
GetSwaggerTypeName(listItemType)
}
};
ParseModel(models, listItemType);
}
else if (propertyType.IsEnum)
{
modelProp.Type = SwaggerType.String;
modelProp.AllowableValues = new ParameterAllowableValues
{
Values = Enum.GetNames(propertyType),
ValueType = "LIST"
};
}
else
{
ParseModel(models, propertyType);
}
var descriptionAttr = prop.FirstAttribute <DescriptionAttribute>();
if (descriptionAttr != null)
{
modelProp.Description = descriptionAttr.Description;
}
if (apiDoc != null)
{
modelProp.Description = apiDoc.Description;
}
var allowableValues = prop.FirstAttribute <ApiAllowableValuesAttribute>();
if (allowableValues != null)
{
modelProp.AllowableValues = GetAllowableValue(allowableValues);
}
model.Properties[GetModelPropertyName(prop)] = modelProp;
}
}
public bool TryGenerateOutputFile(SwaggerModel swaggerModel, string outPutFile, out string explanation)
{
return(_fullHtmlGenerator.TryGenerateOutputFile(swaggerModel, outPutFile, out explanation));
}
private SwaggerModel BuildSwaggerModel()
{
var model = new SwaggerModel
{
AssemblyName = "MyAssemblyName",
DataTypes = new List <DataType>()
{
new DataType
{
Name = "MyName1",
Summary = "Summary1",
Properties = new List <DataProperty>
{
new DataProperty
{
Name = "Property1",
Summary = "SummaryP1"
},
new DataProperty
{
Name = "Property2",
Summary = "SummaryP2"
},
}
},
new DataType
{
Name = "MyName2",
Summary = "Summary2"
}
},
ControllerClasses = new List <ControllerClass>
{
new ControllerClass
{
Name = "ControllerName1",
ControllerMethods = new List <ControllerMethod>
{
new ControllerMethod
{
Name = "Method1",
Summary = "Summary1",
Returns = "Return1",
Arguments = new List <Argument>
{
new Argument
{
Name = "ArgumentName1",
Description = "Description1",
Type = new DataType
{
Name = "System.String"
}
},
new Argument
{
Name = "ArgumentName2",
Description = "Description2",
Type = new DataType
{
Name = "System.int"
}
}
}
},
new ControllerMethod
{
Name = "Method2",
Summary = "Summary2",
Returns = "Return2",
Arguments = new List <Argument>
{
new Argument
{
Name = "2ArgumentName1",
Description = "2Description1",
Type = new DataType
{
Name = "System.Bool"
}
},
new Argument
{
Name = "2ArgumentName2",
Description = "2Description2",
Type = new DataType
{
Name = "System.Int64"
}
}
}
}
}
},
new ControllerClass
{
Name = "ControllerName2"
},
}
};
return(model);
}
protected abstract string GetSummary(SwaggerModel swaggerModel, RestApiRootItemViewModel viewModel);
private static ApiModel ParseSwagger(SwaggerModel obj)
{
ApiModel result = new ApiModel();
// Loop through all paths and spit them out to the console
foreach (var path in (from p in obj.paths orderby p.Key select p))
{
foreach (var verb in path.Value)
{
// Set up our API
ApiInfo api = new ApiInfo();
api.URI = path.Key;
api.HttpVerb = verb.Key;
api.Comment = verb.Value.summary;
api.Params = new List <ParameterInfo>();
api.QueryParams = new List <ParameterInfo>();
api.Category = verb.Value.tags.FirstOrDefault();
api.OperationId = verb.Value.operationId.Replace("ApiV2", "");
// Now figure out all the URL parameters
foreach (var parameter in verb.Value.parameters)
{
// Query String Parameters
if (parameter.paramIn == "query")
{
api.QueryParams.Add(new ParameterInfo()
{
Comment = parameter.description ?? "",
ParamName = parameter.name,
TypeName = ResolveType(parameter, parameter.schema)
});
// URL Path parameters
}
else if (parameter.paramIn == "path")
{
api.Params.Add(new ParameterInfo()
{
Comment = parameter.description ?? "",
ParamName = parameter.name,
TypeName = ResolveType(parameter, parameter.schema)
});
// Body parameters
}
else if (parameter.paramIn == "body")
{
api.BodyParam = new ParameterInfo()
{
Comment = parameter.description ?? "",
ParamName = "model",
TypeName = ResolveType(parameter, parameter.schema)
};
}
// Is this property an enum?
if (parameter.EnumDataType != null)
{
ExtractEnum(result.Enums, parameter);
}
}
// Now figure out the response type
SwaggerResult ok = null;
if (verb.Value.responses.TryGetValue("200", out ok))
{
api.TypeName = ResolveType(null, ok.schema);
}
else if (verb.Value.responses.TryGetValue("201", out ok))
{
api.TypeName = ResolveType(null, ok.schema);
}
// Done with this API
result.Methods.Add(api);
}
}
// Loop through all the schemas
foreach (var def in obj.definitions)
{
var m = new ModelInfo()
{
SchemaName = def.Key,
Comment = def.Value.description,
Properties = new List <ParameterInfo>()
};
foreach (var prop in def.Value.properties)
{
if (!prop.Value.required && def.Value.required != null)
{
prop.Value.required = def.Value.required.Contains(prop.Key);
}
m.Properties.Add(new ParameterInfo()
{
Comment = prop.Value.description,
ParamName = prop.Key,
TypeName = ResolveType(prop.Value, null)
});
// Is this property an enum?
if (prop.Value.EnumDataType != null)
{
ExtractEnum(result.Enums, prop.Value);
}
}
result.Models.Add(m);
}
// Now add the enums we know we need.
// Because of the complex way this Dictionary<> is rendered in Swagger, it's hard to pick up the correct values.
var tat = new EnumInfo()
{
EnumDataType = "TransactionAddressType",
Items = new List <EnumItem>()
};
tat.AddItem("ShipFrom", "This is the location from which the product was shipped");
tat.AddItem("ShipTo", "This is the location to which the product was shipped");
tat.AddItem("PointOfOrderAcceptance", "Location where the order was accepted; typically the call center, business office where purchase orders are accepted, server locations where orders are processed and accepted");
tat.AddItem("PointOfOrderOrigin", "Location from which the order was placed; typically the customer's home or business location");
tat.AddItem("SingleLocation", "Only used if all addresses for this transaction were identical; e.g. if this was a point-of-sale physical transaction");
result.Enums.Add(tat);
// Here's your processed API
return(result);
}
