private void ProcessModels(ApiDeclaration apiDeclaration, GenerationContext dataContext)
{
foreach (KeyValuePair <string, ModelObject> modelObject in apiDeclaration.Models)
{
if (!dataContext.DataModels.ContainsKey(modelObject.Key))
{
DataModelContext dataModelContext = new DataModelContext
{
ID = modelObject.Value.ID
};
dataModelContext.SubTypes.AddRange(modelObject.Value.SubTypes);
foreach (KeyValuePair <string, PropertyObject> propertyObject in modelObject.Value.Properties)
{
ParameterContext parameter = new ParameterContext {
Name = propertyObject.Key
};
InitParameterFromDataTypeObject(parameter, propertyObject.Value);
dataModelContext.Propeties.Add(propertyObject.Key, parameter);
}
dataContext.DataModels.Add(modelObject.Key, dataModelContext);
}
}
}
private static void ApiSpec(ApiDeclaration declaration, string apiPath, Action <ApiSpec> applyAssertions)
{
var apiSpec = declaration.Apis
.Single(api => api.Path == apiPath);
applyAssertions(apiSpec);
}
private static void Api(ApiDeclaration declaration, string apiPath, Action <Api> applyAssertions)
{
var api = declaration.Apis
.Single(a => a.Path == apiPath);
applyAssertions(api);
}
private void ProcessOperations(ApiDeclaration apiDeclaration, GenerationContext dataContext)
{
OperationGroupContext operationGroupContext = new OperationGroupContext {
Name = apiDeclaration.ResourcePath.NormalizeName()
};
foreach (ApiObject apiObject in apiDeclaration.Apis)
{
string operationPath = apiObject.Path;
foreach (OperationObject operation in apiObject.Operations)
{
OperationContext operationContext = new OperationContext
{
RelativeUrl = $"{apiDeclaration.BasePath}{operationPath}",
Method = operation.Method.ToString(),
Name = operation.NickName
};
InitParameterFromDataTypeObject(operationContext, operation);
foreach (ParameterObject parameterObject in operation.Parameters)
{
ParameterContext parameter = new ParameterContext
{
Name = parameterObject.Name
};
InitParameterFromDataTypeObject(parameter, parameterObject);
switch (parameterObject.ParamType)
{
case ParamType.Path:
operationContext.PathParameters.Add(parameter);
break;
case ParamType.Query:
operationContext.QueryParameters.Add(parameter);
break;
case ParamType.Body:
operationContext.BodyParameter = parameter;
break;
case ParamType.Header:
case ParamType.Form:
break;
default:
throw new ArgumentOutOfRangeException();
}
}
operationGroupContext.Operations.Add(operationContext);
}
}
dataContext.Groups.Add(operationGroupContext);
}
private static string GetSubType(ApiDeclaration swaggerResource, string subTypeName)
{
var subType =
swaggerResource.Models.SingleOrDefault(
x => x.Value.SubTypes != null && x.Value.SubTypes.Contains(subTypeName)).Key;
return(subType);
}
private async Task ProcessResource(Resource resource, GenerationContext commonContext)
{
Uri uri = new Uri(context.Url);
// TODO: refactor this
string relativeUrl = resource.Path.Replace("{format}", context.Format.ToString().ToLower()).Replace("/", "");
string apiDeclarationUrl = $"http://{uri.Authority}{String.Join("", uri.Segments.Take(uri.Segments.Length - 1))}{relativeUrl}";
ApiDeclaration apiDeclaration = await communicationService.SendRequestAsync <ApiDeclaration>(apiDeclarationUrl);
Task processOperationTask = Task.Run(() => ProcessOperations(apiDeclaration, commonContext));
Task processModelTask = Task.Run(() => ProcessModels(apiDeclaration, commonContext));
await Task.WhenAll(processOperationTask, processModelTask);
}
private static EndpointModel CreateEndpoint(ApiDeclaration apiDeclaration, SwaggerModel.ResourceListing.Api resourceListingApi)
{
var types = apiDeclaration.models.Values.Select(model => new TypeModel
{
Name = model.id,
}).ToList();
types.ForEach((type) =>
{
var model = apiDeclaration.models[type.Name];
type.Properties = model.properties.Select(kvp =>
{
var name = kvp.Key;
var property = kvp.Value;
var typeIsList = property.type == "array";
return(new PropertyModel
{
Name = name,
Description = property.description,
TypeIsList = typeIsList,
Type = typeIsList
? types.FirstOrDefault(t => t.Name == property.items._ref) ?? GetPrimitiveType(property.items.type, property.items.format)
: types.FirstOrDefault(t => t.Name == property._ref) ?? GetPrimitiveType(property.type, property.format),
IsRequired = model.required != null && model.required.Contains(name)
});
}).OrderBy(p => p.Name).ToList();
});
return(new EndpointModel
{
Description = resourceListingApi.description,
Name = apiDeclaration.resourcePath.ToPascalCase(),
BasePath = apiDeclaration.basePath,
ResourcePath = apiDeclaration.resourcePath,
Routes = apiDeclaration.apis.SelectMany(
api => api.operations.Select(
o => CreateRouteModel(o, api, types)
)
).OrderBy(r => r.Name).ToList(),
Types = types
});
}
public ApiDeclaration GetApiDeclaration(string resourcePath)
{
var routeData = RetrieveSwaggerRouteData()
.Where(d => d.ResourcePath == resourcePath)
.ToList();
var apiDeclaration = new ApiDeclaration
{
BasePath = new Uri("/", UriKind.Relative),
Apis = routeData.GroupBy(d => d.ApiPath).Select(GetApi).OrderBy(api => api.Path)
};
var modelsData = RetrieveSwaggerModelData();
var modelsForRoutes = GetModelsForRoutes(routeData, modelsData);
apiDeclaration.Models = modelsForRoutes.SelectMany(m => m.ToModel(modelsData))
.OrderBy(m => m.Id)
.ToDictionary(m => m.Id, m => m);
return(apiDeclaration);
}
public ApiDeclaration GetApiDeclaration(string resourcePath, string sBasePath)
{
var routeData = _metadataProvider.RetrieveSwaggerRouteData()
.Where(d => d.ResourcePath == resourcePath)
.ToList();
var apiDeclaration = new ApiDeclaration
{
//BasePath = new Uri("/test", UriKind.Relative),//PetrK, we need something like this!
BasePath = new Uri(sBasePath, UriKind.Relative),
Apis = routeData.GroupBy(d => d.ApiPath).Select(GetApi).OrderBy(api => api.Path)
};
var modelsData = _metadataProvider.RetrieveSwaggerModelData();
var modelsForRoutes = GetModelsForRoutes(routeData, modelsData);
apiDeclaration.Models = modelsForRoutes.SelectMany(m => m.ToModel(modelsData))
.GroupBy(m => m.Id)
.Select(g => g.First())
.OrderBy(m => m.Id)
.ToDictionary(m => m.Id, m => m);
return(apiDeclaration);
}
private static void Model(ApiDeclaration declaration, string id, Action <ModelSpec> applyAssertions)
{
var modelSpec = declaration.Models[id];
applyAssertions(modelSpec);
}
private static void Model(ApiDeclaration declaration, string id, Action <DataType> applyAssertions)
{
var model = declaration.Models[id];
applyAssertions(model);
}
public SwaggerConverter(ApiDeclaration root) : base(root)
{
}
public static string GetResourceName(this ApiDeclaration apiDeclaration)
{
return(apiDeclaration.resourcePath.Replace("/", " ").ToPascalCase().Trim());
}
protected BaseSwaggerConverter(ApiDeclaration api)
{
Root = api;
}
