private void Initialize(Assembly functionsAssembly, string routePrefix)
{
var methods = functionsAssembly.GetTypes()
.SelectMany(t => t.GetMethods())
.Where(m => m.GetCustomAttributes(typeof(FunctionNameAttribute), false).Any())
.ToList();
IList <ApiDescriptionGroup> apiDescrGroup = new List <ApiDescriptionGroup>();
foreach (MethodInfo methodInfo in methods)
{
if (!TryGetHttpTrigger(methodInfo, out var triggerAttribute))
{
continue;
}
var functionAttr = (FunctionNameAttribute)methodInfo.GetCustomAttribute(typeof(FunctionNameAttribute), false);
var prefix = string.IsNullOrWhiteSpace(routePrefix) ? "" : $"{routePrefix.TrimEnd('/')}/";
var route = $"{prefix}{(!string.IsNullOrWhiteSpace(triggerAttribute.Route) ? triggerAttribute.Route : functionAttr.Name)}";
var verbs = triggerAttribute.Methods ?? new[] { "get", "post", "delete", "head", "patch", "put", "options" };
var items = new List <ApiDescription>();
foreach (string verb in verbs)
{
var description = CreateDescription(methodInfo, route, functionAttr, verb);
items.Add(description);
}
var group = new ApiDescriptionGroup(functionAttr.Name, items);
apiDescrGroup.Add(group);
}
// TODO: is Version necessery?
ApiDescriptionGroups = new ApiDescriptionGroupCollection(new ReadOnlyCollection <ApiDescriptionGroup>(apiDescrGroup), 1);
}
public DocumentFilterContext(
ApiDescriptionGroupCollection apiDescriptionsGroups,
ISchemaRegistry schemaRegistry)
{
ApiDescriptionsGroups = apiDescriptionsGroups;
SchemaRegistry = schemaRegistry;
}
/// <summary>Generates a Swagger specification for the given <see cref="ApiDescriptionGroupCollection"/>.</summary>
/// <param name="apiDescriptionGroups"><see cref="ApiDescriptionGroup"/>.</param>
/// <returns>The <see cref="SwaggerDocument" />.</returns>
/// <exception cref="InvalidOperationException">The operation has more than one body parameter.</exception>
public async Task <SwaggerDocument> GenerateAsync(ApiDescriptionGroupCollection apiDescriptionGroups)
{
var apiDescriptions = apiDescriptionGroups.Items.SelectMany(g => g.Items);
var document = await CreateDocumentAsync(apiDescriptionGroups).ConfigureAwait(false);
var schemaResolver = new SwaggerSchemaResolver(document, Settings);
var apiGroups = apiDescriptions.Where(apiDescription => apiDescription.ActionDescriptor is ControllerActionDescriptor)
.Select(apiDescription => new Tuple <ApiDescription, MethodInfo>(apiDescription, ((ControllerActionDescriptor)apiDescription.ActionDescriptor).MethodInfo))
.GroupBy(item => item.Item2.DeclaringType);
foreach (var controllerApiDescriptionGroup in apiGroups)
{
await GenerateForControllerAsync(document, controllerApiDescriptionGroup.Key, controllerApiDescriptionGroup, new SwaggerGenerator(_schemaGenerator, Settings, schemaResolver), schemaResolver).ConfigureAwait(false);
}
document.GenerateOperationIds();
var controllerTypes = apiGroups.Select(k => k.Key);
foreach (var processor in Settings.DocumentProcessors)
{
await processor.ProcessAsync(new DocumentProcessorContext(document, controllerTypes, schemaResolver, _schemaGenerator, Settings));
}
return(document);
}
/// <summary>Generates a Swagger specification for the given <see cref="ApiDescriptionGroupCollection"/>.</summary>
/// <param name="apiDescriptionGroups">The <see cref="ApiDescriptionGroupCollection"/>.</param>
/// <returns>The <see cref="OpenApiDocument" />.</returns>
/// <exception cref="InvalidOperationException">The operation has more than one body parameter.</exception>
public async Task <OpenApiDocument> GenerateAsync(ApiDescriptionGroupCollection apiDescriptionGroups)
{
var apiDescriptions = apiDescriptionGroups.Items
.Where(group =>
Settings.ApiGroupNames == null ||
Settings.ApiGroupNames.Length == 0 ||
Settings.ApiGroupNames.Contains(group.GroupName))
.SelectMany(g => g.Items)
.Where(apiDescription => apiDescription.ActionDescriptor is ControllerActionDescriptor)
.ToArray();
var document = await CreateDocumentAsync().ConfigureAwait(false);
var schemaResolver = new OpenApiSchemaResolver(document, Settings);
var apiGroups = apiDescriptions
.Select(apiDescription => new Tuple <ApiDescription, ControllerActionDescriptor>(apiDescription, (ControllerActionDescriptor)apiDescription.ActionDescriptor))
.GroupBy(item => item.Item2.ControllerTypeInfo.AsType())
.ToArray();
var usedControllerTypes = GenerateForControllers(document, apiGroups, schemaResolver);
document.GenerateOperationIds();
var controllerTypes = apiGroups.Select(k => k.Key).ToArray();
foreach (var processor in Settings.DocumentProcessors)
{
processor.Process(new DocumentProcessorContext(document, controllerTypes, usedControllerTypes, schemaResolver, Settings.SchemaGenerator, Settings));
}
Settings.PostProcess?.Invoke(document);
return(document);
}
private ApiDescriptionGroupModelCollection GetCollection(ApiDescriptionGroupCollection apiGroups)
{
var items = apiGroups
.Items
.Select(CreateApiDescriptionGroupModel)
.OrderBy(o => o.GroupName)
.ToList()
.AsReadOnly();
return(new ApiDescriptionGroupModelCollection(items, apiGroups.Version)
{
Description = _serverOptions.Description
});
}
protected async Task <OpenApiDocument> GenerateDocumentAsync(AspNetCoreOpenApiDocumentGeneratorSettings settings, params Type[] controllerTypes)
{
var generator = new AspNetCoreOpenApiDocumentGenerator(settings);
var provider = TestServer.Host.Services.GetRequiredService <IApiDescriptionGroupCollectionProvider>();
var controllerTypeNames = controllerTypes.Select(t => t.FullName);
var groups = new ApiDescriptionGroupCollection(provider.ApiDescriptionGroups.Items
.Select(i => new ApiDescriptionGroup(i.GroupName, i.Items.Where(u => controllerTypeNames.Contains(((ControllerActionDescriptor)u.ActionDescriptor).ControllerTypeInfo.FullName)).ToList())).ToList(),
provider.ApiDescriptionGroups.Version);
var document = await generator.GenerateAsync(groups);
return(document);
}
private async Task <SwaggerDocument> CreateDocumentAsync(ApiDescriptionGroupCollection apiDescriptionGroups)
{
var document = !string.IsNullOrEmpty(Settings.DocumentTemplate) ? await SwaggerDocument.FromJsonAsync(Settings.DocumentTemplate).ConfigureAwait(false) : new SwaggerDocument();
document.Generator = $"NSwag v{SwaggerDocument.ToolchainVersion} (NJsonSchema v{JsonSchema4.ToolchainVersion})";
document.Info = new SwaggerInfo
{
Title = Settings.Title,
Description = Settings.Description,
Version = Settings.Version,
};
return(document);
}
/// <summary>Generates a Swagger specification for the given <see cref="ApiDescriptionGroupCollection"/>.</summary>
/// <param name="apiDescriptionGroups">The <see cref="ApiDescriptionGroupCollection"/>.</param>
/// <returns>The <see cref="SwaggerDocument" />.</returns>
/// <exception cref="InvalidOperationException">The operation has more than one body parameter.</exception>
public async Task <SwaggerDocument> GenerateAsync(ApiDescriptionGroupCollection apiDescriptionGroups)
{
var apiDescriptions = apiDescriptionGroups.Items
.Where(i =>
Settings.ApiGroupNames == null ||
Settings.ApiGroupNames.Length == 0 ||
Settings.ApiGroupNames.Contains(i.GroupName))
.SelectMany(g => g.Items);
var document = await CreateDocumentAsync().ConfigureAwait(false);
var schemaResolver = new SwaggerSchemaResolver(document, Settings);
var apiGroups = apiDescriptions.Where(apiDescription => apiDescription.ActionDescriptor is ControllerActionDescriptor)
.Select(apiDescription => new Tuple <ApiDescription, ControllerActionDescriptor>(apiDescription, (ControllerActionDescriptor)apiDescription.ActionDescriptor))
.GroupBy(item => item.Item2.ControllerTypeInfo.AsType())
.ToArray();
var usedControllerTypes = new List <Type>();
foreach (var controllerApiDescriptionGroup in apiGroups)
{
var generator = new SwaggerGenerator(_schemaGenerator, Settings, schemaResolver);
var isIncluded = await GenerateForControllerAsync(document, controllerApiDescriptionGroup.Key, controllerApiDescriptionGroup, generator, schemaResolver).ConfigureAwait(false);
if (isIncluded)
{
usedControllerTypes.Add(controllerApiDescriptionGroup.Key);
}
}
document.GenerateOperationIds();
var controllerTypes = apiGroups.Select(k => k.Key).ToArray();
foreach (var processor in Settings.DocumentProcessors)
{
await processor.ProcessAsync(new DocumentProcessorContext(document, controllerTypes, usedControllerTypes, schemaResolver, _schemaGenerator, Settings));
}
return(document);
}
private void PrepareServices(List <ApiDescription> apis, ApiDescriptionGroupCollection data)
{
var contexts = _platform.Definitions.Services.Select(i
=> (context: i.Value.Context, definition: i.Value)).GroupBy(i => i.context).ToList();
foreach (var domain in contexts)
{
foreach (var service in domain.Select(i => i.definition))
{
var type = service.ServiceType;
var serviceInterface = type.GetInterfaces()
.FirstOrDefault(i => typeof(IService).IsAssignableFrom(i));
apis.Add(CreateApiDescription(TypeExtensions.GetContextName(serviceInterface), service.ServiceType,
service.MethodName, serviceInterface, "PUT",
service.Parameters.Select(p => (p.Name, p.ParameterType)).ToList(),
service.ReturnType));
}
}
var descriptionGroupList = new List <ApiDescriptionGroup> {
new("Platformex", apis)
};
descriptionGroupList.AddRange(data.Items);
}
private ApiDescriptionGroupModelCollection GetCollection(ApiDescriptionGroupCollection apiGroups)
{
var apiDescriptions = new List <ApiDescription>();
foreach (var apiDescriptionGroup in apiGroups.Items)
{
foreach (var apiDescription in apiDescriptionGroup.Items)
{
apiDescriptions.Add(apiDescription);
}
}
var items = apiDescriptions.GroupBy(a => a.GroupName ?? (a.ActionDescriptor as ControllerActionDescriptor)?.ControllerName)
.Select(g => new ApiDescriptionGroup(g.Key, new List <ApiDescription>(g).AsReadOnly()))
.Select(CreateApiDescriptionGroupModel)
.OrderBy(o => o.GroupName)
.ToList()
.AsReadOnly();
return(new ApiDescriptionGroupModelCollection(items, apiGroups.Version)
{
Description = _serverOptions.Description
});
}
/// <summary>
/// 生成前端API文件
/// </summary>
private static string GenWebAPI(ApiDescriptionGroupCollection groups)
{
var remoteServiceList = new List <RemoteServiceEntity>();
foreach (var group in groups.Items)
{
foreach (var item in group.Items)
{
if (item.ActionDescriptor is ControllerActionDescriptor controllerActionDescriptor)
{
remoteServiceList.Add(new RemoteServiceEntity
{
Area = controllerActionDescriptor.RouteValues.NotNullGetValue("area") ?? "",
HttpMethod = string.IsNullOrEmpty(item.HttpMethod) ? GetHttpMethodFromStartWith(controllerActionDescriptor.MethodInfo.Name) : item.HttpMethod,
ResModule = controllerActionDescriptor.ControllerName,
MethodBehavior = controllerActionDescriptor.ActionName,
RelativePath = item.RelativePath.Substring(4),
});
}
}
}
//把Area有值的放上面
remoteServiceList = remoteServiceList.OrderBy(e => e.ResModule).ThenBy(e => e.MethodBehavior).ThenByDescending(e => e.Area).ToList();
var sb = new StringBuilder();
//开始写入
sb.AppendLine("/*****************");
sb.AppendLine("* ");
sb.AppendLine("* 平台数据API列表");
sb.AppendLine("* ");
sb.AppendLine("* @后台自动生成");
sb.AppendLine("* "+ DateTimeHandler.CurrentTime.ToShortDateString());
sb.AppendLine("* ");
sb.AppendLine("*****************/");
sb.AppendLine("window._Api = {};");
sb.AppendLine();
var sOldModule = "";
var moduleList = new List <string>();
var nIndex = 0;
foreach (var item in remoteServiceList)
{
nIndex++;
if (moduleList.Contains(item.ResModule + item.MethodBehavior))
{
continue;
}
moduleList.Add(item.ResModule + item.MethodBehavior);
if (sOldModule != item.ResModule)
{
if (sOldModule != "")
{
sb.AppendLine("};");
}
sb.AppendLine("window._Api." + item.ResModule + " = {");
}
sb.AppendLine(" " + item.MethodBehavior + " : function (data) {");
sb.AppendLine($" return Req.{item.HttpMethod.Substring(0, 1).ToUpper() + item.HttpMethod.Substring(1).ToLower()}('/{item.RelativePath}', data);");
sb.Append(" }");
if (nIndex < remoteServiceList.Count)
{
if (remoteServiceList[nIndex].ResModule == item.ResModule)
{
sb.Append(",");
}
}
sb.AppendLine();
sOldModule = item.ResModule;
}
sb.AppendLine("};");
return(sb.ToString());
}
public FunctionApiDescriptionProvider(
IOptions <Option> functionsOptions,
SwashBuckleStartupConfig startupConfig,
IModelMetadataProvider modelMetadataProvider,
IOutputFormatter outputFormatter,
IOptions <HttpOptions> httOptions)
{
_option = functionsOptions.Value;
_modelMetadataProvider = modelMetadataProvider;
_outputFormatter = outputFormatter;
var methods = startupConfig.Assembly.GetTypes()
.SelectMany(t => t.GetMethods())
.Where(m => m.GetCustomAttributes(typeof(FunctionNameAttribute), false).Any())
.ToArray();
var apiDescGroups = new Dictionary <string, List <ApiDescription> >();
foreach (var methodInfo in methods)
{
if (!TryGetHttpTrigger(methodInfo, out var triggerAttribute))
{
continue;
}
var functionAttr =
(FunctionNameAttribute)methodInfo.GetCustomAttribute(typeof(FunctionNameAttribute), false);
var apiExplorerSettingsAttribute =
(ApiExplorerSettingsAttribute)methodInfo.GetCustomAttribute(typeof(ApiExplorerSettingsAttribute), false);
var prefix = string.IsNullOrWhiteSpace(httOptions.Value.RoutePrefix) ? "" : $"{httOptions.Value.RoutePrefix.TrimEnd('/')}/";
var route =
$"{prefix}{(!string.IsNullOrWhiteSpace(triggerAttribute.Route) ? triggerAttribute.Route : functionAttr.Name)}";
var routes = new List <(string Route, string RemoveParamName)>();
var regex = new Regex("/\\{(?<paramName>\\w+)\\?\\}$");
var match = regex.Match(route);
if (match.Success && match.Captures.Count == 1)
{
routes.Add((route.Replace(match.Value, "").Replace("//", "/"), match.Groups["paramName"].ToString()));
routes.Add((route.Replace(match.Value, match.Value.Replace("?", "")), ""));
}
else
{
routes.Add((route, ""));
}
var verbs = triggerAttribute.Methods ??
new[] { "get", "post", "delete", "head", "patch", "put", "options" };
for (var index = 0; index < routes.Count; index++)
{
var r = routes[index];
var apiName = functionAttr.Name + (index == 0 ? "" : $"-{index}");
var items = verbs.Select(verb =>
CreateDescription(methodInfo, r.Route, functionAttr, apiExplorerSettingsAttribute, verb, triggerAttribute.AuthLevel, r.RemoveParamName)).ToArray();
string groupName =
(items.FirstOrDefault()?.ActionDescriptor as ControllerActionDescriptor)?.ControllerName ?? apiName;
if (!apiDescGroups.ContainsKey(groupName))
{
apiDescGroups[groupName] = new List <ApiDescription>();
}
apiDescGroups[groupName].AddRange(items);
}
}
ApiDescriptionGroups =
new ApiDescriptionGroupCollection(
new ReadOnlyCollection <ApiDescriptionGroup>(
apiDescGroups.Select(kv => new ApiDescriptionGroup(kv.Key, kv.Value)).ToList()
), 1);
}
public async Task SwaggerDocumentIsGeneratedForCustomCreatedApiDescriptions()
{
//// Arrange
var generator = new AspNetCoreOpenApiDocumentGenerator(new AspNetCoreOpenApiDocumentGeneratorSettings());
var apiDescriptions = new[]
{
new ApiDescription
{
ActionDescriptor = new ActionDescriptor(),
},
new ApiDescription
{
ActionDescriptor = new ControllerActionDescriptor
{
ControllerTypeInfo = typeof(CustomController).GetTypeInfo(),
MethodInfo = typeof(CustomController).GetMethod(nameof(CustomController.FindModel)),
AttributeRouteInfo = new AttributeRouteInfo
{
Template = "api/test/{id}",
},
ControllerName = "Test",
ActionName = "Find",
},
HttpMethod = "Get",
RelativePath = "api/test/{id}",
ParameterDescriptions =
{
new ApiParameterDescription
{
Name = "id",
Source = BindingSource.Path,
Type = typeof(int),
},
},
SupportedResponseTypes =
{
new ApiResponseType
{
Type = typeof(TestModel),
StatusCode = 200,
}
},
},
new ApiDescription
{
ActionDescriptor = new ControllerActionDescriptor
{
ControllerTypeInfo = typeof(CustomController).GetTypeInfo(),
MethodInfo = typeof(CustomController).GetMethod(nameof(CustomController.Delete)),
ControllerName = "Test",
ActionName = "DeleteModel",
},
HttpMethod = "Delete",
RelativePath = "api/test",
ParameterDescriptions =
{
new ApiParameterDescription
{
Name = "id",
Source = BindingSource.Query,
Type = typeof(int),
},
},
SupportedResponseTypes =
{
new ApiResponseType
{
Type = typeof(StatusCodeResult),
StatusCode = 201,
}
},
},
new ApiDescription
{
ActionDescriptor = new ControllerActionDescriptor
{
ControllerTypeInfo = typeof(CustomController).GetTypeInfo(),
MethodInfo = typeof(CustomController).GetMethod(nameof(CustomController.Update)),
AttributeRouteInfo = new AttributeRouteInfo
{
Template = "api/test/{id}",
},
ControllerName = "Test",
ActionName = "Update",
},
HttpMethod = "Put",
RelativePath = "api/test/{id}",
ParameterDescriptions =
{
new ApiParameterDescription
{
Type = typeof(int),
Name = "id",
Source = BindingSource.Path,
},
new ApiParameterDescription
{
Type = typeof(TestModel),
Name = "model",
Source = BindingSource.Body,
},
},
SupportedResponseTypes =
{
new ApiResponseType
{
Type = typeof(Task <TestModel>),
StatusCode = 200,
}
},
},
};
var apiDescriptionGroupCollection = new ApiDescriptionGroupCollection(
new[] { new ApiDescriptionGroup(string.Empty, apiDescriptions) },
version: 1);
//// Act
var document = await generator.GenerateAsync(apiDescriptionGroupCollection);
//// Assert
Assert.Collection(
document.Operations.OrderBy(o => o.Method.ToString()),
operation =>
{
Assert.Equal("/api/test", operation.Path);
Assert.Equal(OpenApiOperationMethod.Delete, operation.Method);
},
operation =>
{
Assert.Equal("/api/test/{id}", operation.Path);
Assert.Equal(OpenApiOperationMethod.Get, operation.Method);
Assert.Single(operation.Operation.Responses);
var response = operation.Operation.Responses["200"];
var definition = document.Definitions.First(f => f.Value == response.Schema?.ActualSchema);
Assert.Equal(nameof(TestModel), definition.Key);
},
operation =>
{
Assert.Equal("/api/test/{id}", operation.Path);
Assert.Equal(OpenApiOperationMethod.Put, operation.Method);
});
}
private List <ApiDescriptionGroup> PrepareQueries(
List <ApiDescription> apis,
ApiDescriptionGroupCollection data)
{
foreach (var domain in _metadata.Contexts)
{
foreach (var query in domain.Queries)
{
var type = query.Type;
var name = query.Name;
var str = _options.BasePath.Trim('/') + "/" + query.Name;
var genericInterface = ReflectionExtensions.GetSubclassOfRawGenericInterface(typeof(IQuery <>), type);
if (!(genericInterface == null))
{
var genericArgument = genericInterface.GetGenericArguments()[0];
var apiDescription1 = new ApiDescription();
var apiDescription2 = apiDescription1;
var actionDescriptor1 = new ControllerActionDescriptor();
actionDescriptor1.ActionConstraints = new List <IActionConstraintMetadata>
{
new HttpMethodActionConstraint(new[]
{
"POST"
})
};
actionDescriptor1.ActionName = name;
actionDescriptor1.ControllerName = "context";
actionDescriptor1.DisplayName = name;
actionDescriptor1.Parameters = new List <ParameterDescriptor>
{
new ParameterDescriptor
{
Name = "query",
ParameterType = type
}
};
actionDescriptor1.MethodInfo = new CustomMethodInfo(name, type);
actionDescriptor1.ControllerTypeInfo = type.GetTypeInfo();
actionDescriptor1.RouteValues = new Dictionary <System.String, System.String>
{
{
"controller",
domain.Name
}
};
var actionDescriptor2 = actionDescriptor1;
apiDescription2.ActionDescriptor = actionDescriptor2;
apiDescription1.HttpMethod = "POST";
apiDescription1.RelativePath = str;
apiDescription1.SupportedResponseTypes.Add(new ApiResponseType
{
StatusCode = 200,
Type = genericArgument
});
var apiDescription3 = apiDescription1;
((List <ApiParameterDescription>)apiDescription3.ParameterDescriptions).Add(new ApiParameterDescription
{
Name = "query",
Type = type,
Source = BindingSource.Body
});
apis.Add(apiDescription3);
}
}
}
var descriptionGroupList = new List <ApiDescriptionGroup> {
new ApiDescriptionGroup("R3", apis)
};
descriptionGroupList.AddRange(data.Items);
return(descriptionGroupList);
}
private List <ApiDescriptionGroup> PrepareQueries(List <ApiDescription> apis, ApiDescriptionGroupCollection data)
{
foreach (var query in _platform.Definitions.Queries.Select(i => i.Value))
{
apis.Add(CreateApiDescription("Queries", query.QueryType,
query.Name, query.QueryType, "POST",
query.QueryType.GetProperties().Select(p => (p.Name, p.PropertyType)).ToList(),
query.ResultType));
}
var descriptionGroupList = new List <ApiDescriptionGroup> {
new("Platformex", apis)
};
descriptionGroupList.AddRange(data.Items);
return(descriptionGroupList);
}
public FakeApiDescriptionGroupCollectionProvider()
{
groups = new List <ApiDescriptionGroup>();
groupsCollection = new ApiDescriptionGroupCollection(groups, 1);
actions = new List <ApiDescription>();
}
public void AddApiDescriptionGroupCollection(ApiDescriptionGroupCollection apiDescriptionGroupCollection)
{
apiDescriptionGroups.AddRange(apiDescriptionGroupCollection.Items);
}
