/// <summary>
/// Build composite types from definitions
/// </summary>
public virtual void BuildCompositeTypes()
{
// Load any external references
foreach (var reference in ServiceDefinition.ExternalReferences)
{
string[] splitReference = reference.Split(new[] { '#' }, StringSplitOptions.RemoveEmptyEntries);
Debug.Assert(splitReference.Length == 2);
string filePath = splitReference[0];
string externalDefinition = Settings.FileSystem.ReadFileAsText(filePath);
ServiceDefinition external = SwaggerParser.Parse(externalDefinition);
external.Definitions.ForEach(d => ServiceDefinition.Definitions[d.Key] = d.Value);
}
// Build service types and validate allOf
if (ServiceDefinition.Definitions != null)
{
foreach (var schemaName in ServiceDefinition.Definitions.Keys.ToArray())
{
var schema = ServiceDefinition.Definitions[schemaName];
schema.GetBuilder(this).BuildServiceType(schemaName);
Resolver.ExpandAllOf(schema);
var parent = string.IsNullOrEmpty(schema.Extends.StripDefinitionPath())
? null
: ServiceDefinition.Definitions[schema.Extends.StripDefinitionPath()];
if (parent != null &&
!AncestorsHaveProperties(parent.Properties, parent.Extends.StripDefinitionPath()))
{
throw ErrorManager.CreateError(Resources.InvalidAncestors, schemaName);
}
}
}
}
public static ServiceDefinition Load(string path, IFileSystem fileSystem)
{
if (fileSystem == null)
{
throw new ArgumentNullException("fileSystem");
}
return(SwaggerParser.Parse(fileSystem.ReadFileAsText(path)));
}
public override ServiceClient Build()
{
Logger.LogInfo(Resources.ParsingSwagger);
ServiceDefinition = SwaggerParser.Load(Settings.Input, Settings.FileSystem);
Logger.LogInfo(Resources.GeneratingClient);
// Update settings
UpdateSettings();
InitializeClientModel();
BuildCompositeTypes();
// Build client parameters
foreach (var swaggerParameter in ServiceDefinition.Parameters.Values)
{
var parameter = ((ParameterBuilder)swaggerParameter.GetBuilder(this)).Build();
var clientProperty = new Property();
clientProperty.LoadFrom(parameter);
ServiceClient.Properties.Add(clientProperty);
}
// Build methods
foreach (var path in ServiceDefinition.Paths.Concat(ServiceDefinition.CustomPaths))
{
foreach (var verb in path.Value.Keys)
{
var operation = path.Value[verb];
if (string.IsNullOrWhiteSpace(operation.OperationId))
{
throw ErrorManager.CreateError(
string.Format(CultureInfo.InvariantCulture,
Resources.OperationIdMissing,
verb,
path.Key));
}
var methodName = GetMethodName(operation);
var methodGroup = GetMethodGroup(operation);
if (verb.ToHttpMethod() != HttpMethod.Options)
{
string url = path.Key;
if (url.Contains("?"))
{
url = url.Substring(0, url.IndexOf('?'));
}
var method = BuildMethod(verb.ToHttpMethod(), url, methodName, operation);
method.Group = methodGroup;
ServiceClient.Methods.Add(method);
if (method.DefaultResponse.Body is CompositeType)
{
ServiceClient.ErrorTypes.Add((CompositeType)method.DefaultResponse.Body);
}
}
else
{
Logger.LogWarning(Resources.OptionsNotSupported);
}
}
}
// Set base type
foreach (var typeName in GeneratedTypes.Keys)
{
var objectType = GeneratedTypes[typeName];
if (ExtendedTypes.ContainsKey(typeName))
{
objectType.BaseModelType = GeneratedTypes[ExtendedTypes[typeName]];
}
ServiceClient.ModelTypes.Add(objectType);
}
return(ServiceClient);
}
