public void Apply(IParameter parameter, ParameterFilterContext context)
{
var type = context.ParameterInfo?.ParameterType;
if (type == null)
{
return;
}
if (type.IsEnum)
{
var names = Enum.GetNames(type);
var values = Enum.GetValues(type);
var desc = "";
foreach (var value in values)
{
var intValue = Convert.ChangeType(value, Enum.GetUnderlyingType(value.GetType()));
desc += $"{intValue}={value},";
}
desc = desc.TrimEnd(',');
if (!parameter.Extensions.ContainsKey("x-enumNames"))
{
parameter.Extensions.Add("x-enumNames", names);
}
}
}
/// <summary>
/// Apply filter.
/// </summary>
/// <param name="parameter"><see cref="OpenApiParameter"/>.</param>
/// <param name="context"><see cref="ParameterFilterContext"/>.</param>
public void Apply(OpenApiParameter parameter, ParameterFilterContext context)
{
if (context.PropertyInfo != null)
{
ApplyPropertyTags(parameter, context.PropertyInfo);
}
}
/// <summary>
/// Apply the filter.
/// </summary>
/// <param name="parameter"><see cref="OpenApiParameter"/>.</param>
/// <param name="context"><see cref="ParameterFilterContext"/>.</param>
public void Apply(OpenApiParameter parameter, ParameterFilterContext context)
{
if (!this._applyFiler)
{
return;
}
var typeInfo = context.ParameterInfo?.ParameterType ?? context.PropertyInfo?.PropertyType;
if (typeInfo == null)
{
return;
}
var enumsArray = new OpenApiArray();
var enumsDescriptionsArray = new OpenApiArray();
if (typeInfo.IsEnum)
{
var names = Enum.GetNames(typeInfo).Select(name => new OpenApiString(name));
enumsArray.AddRange(names);
if (!parameter.Extensions.ContainsKey("x-enumNames") && enumsArray.Any())
{
parameter.Extensions.Add("x-enumNames", enumsArray);
}
if (this._includeXEnumDescriptions)
{
enumsDescriptionsArray.AddRange(EnumTypeExtensions.GetEnumValuesDescription(typeInfo, this._descriptionSources, this._xmlNavigators, this._includeXEnumRemarks));
if (!parameter.Extensions.ContainsKey("x-enumDescriptions") && enumsDescriptionsArray.Any())
{
parameter.Extensions.Add("x-enumDescriptions", enumsDescriptionsArray);
}
}
}
else if (typeInfo.IsGenericType && !parameter.Extensions.ContainsKey("x-enumNames"))
{
foreach (var genericArgumentType in typeInfo.GetGenericArguments())
{
if (genericArgumentType.IsEnum)
{
var names = Enum.GetNames(genericArgumentType).Select(name => new OpenApiString(name));
enumsArray.AddRange(names);
if (!parameter.Extensions.ContainsKey("x-enumNames") && enumsArray.Any())
{
parameter.Extensions.Add("x-enumNames", enumsArray);
}
if (this._includeXEnumDescriptions)
{
enumsDescriptionsArray.AddRange(EnumTypeExtensions.GetEnumValuesDescription(genericArgumentType, this._descriptionSources, this._xmlNavigators, this._includeXEnumRemarks));
if (!parameter.Extensions.ContainsKey("x-enumDescriptions") && enumsDescriptionsArray.Any())
{
parameter.Extensions.Add("x-enumDescriptions", enumsDescriptionsArray);
}
}
}
}
}
}
public void Apply(OpenApiParameter parameter, ParameterFilterContext context)
{
var typeInfo = context.ParameterInfo?.ParameterType ?? context.PropertyInfo.PropertyType;
var enumsArray = new OpenApiArray();
if (typeInfo.IsEnum)
{
var names = Enum.GetNames(typeInfo).Select(name => new OpenApiString(name));
enumsArray.AddRange(names);
if (!parameter.Extensions.ContainsKey("x-enumNames") && enumsArray.Any())
{
parameter.Extensions.Add("x-enumNames", enumsArray);
}
}
else if (typeInfo.IsGenericType && !parameter.Extensions.ContainsKey("x-enumNames"))
{
foreach (var genericArgumentType in typeInfo.GetGenericArguments())
{
if (genericArgumentType.IsEnum)
{
var names = Enum.GetNames(genericArgumentType).Select(name => new OpenApiString(name));
enumsArray.AddRange(names);
if (!parameter.Extensions.ContainsKey("x-enumNames") && enumsArray.Any())
{
parameter.Extensions.Add("x-enumNames", enumsArray);
}
}
}
}
}
private void ApplyPropertyTags(OpenApiParameter parameter, ParameterFilterContext context)
{
var propertyMemberName = XmlCommentsNodeNameHelper.GetMemberNameForFieldOrProperty(context.PropertyInfo);
var propertyNode = _xmlNavigator.SelectSingleNode($"/doc/members/member[@name='{propertyMemberName}']");
if (propertyNode == null)
{
return;
}
var summaryNode = propertyNode.SelectSingleNode("summary");
if (summaryNode != null)
{
parameter.Description = XmlCommentsTextHelper.Humanize(summaryNode.InnerXml);
}
var exampleNode = propertyNode.SelectSingleNode("example");
if (exampleNode != null)
{
var exampleAsJson = (parameter.Schema?.ResolveType(context.SchemaRepository) == "string")
? $"\"{exampleNode.InnerXml}\""
: exampleNode.InnerXml;
parameter.Example = OpenApiAnyFactory.CreateFromJson(exampleAsJson);
}
}
/// <inheritdoc/>
public void Apply(OpenApiParameter parameter, ParameterFilterContext context)
{
//
// fix current bug where properties are not added correctly
// Lookup property schema in schema repo
//
if (context.PropertyInfo != null)
{
// Query was passed a parameter with properties
var propertySchema = context.SchemaRepository.Schemas
.Where(p => p.Key.EqualsIgnoreCase(context.ParameterInfo.ParameterType.Name))
.SelectMany(p => p.Value.Properties)
.Where(p => p.Key.EqualsIgnoreCase(context.PropertyInfo.Name))
.FirstOrDefault();
if (propertySchema.Value != null)
{
// Replace parameter definition with property schema
parameter.Name = propertySchema.Key;
// Quick and dirty clone of the schema for the parameter
parameter.Schema = JsonConvertEx.DeserializeObject <OpenApiSchema>(
JsonConvertEx.SerializeObject(propertySchema.Value));
}
parameter.Required = context.PropertyInfo
.GetCustomAttributes(typeof(RequiredAttribute), true)
.Any();
AdjustSchema(context.PropertyInfo.PropertyType, parameter.Schema);
}
else if (context.ParameterInfo != null)
{
// Query was passed a parameter with properties
AdjustSchema(context.ParameterInfo.ParameterType, parameter.Schema);
}
}
public void Apply(OpenApiParameter parameter, ParameterFilterContext context)
{
if (_swaggerOptions.Schema.NameAndOrderRequestBody)
{
// Explicitly specify parameters position
// Position for store and language is unknown and they should be last, so use int.MaxValue relative values
if (context.ParameterInfo != null)
{
parameter.Extensions.Add("x-position", new OpenApiInteger(context.ParameterInfo.Position));
}
else
{
switch (parameter.Name)
{
case "store":
parameter.Extensions.Add("x-position", new OpenApiInteger(int.MaxValue - 1));
break;
case "language":
parameter.Extensions.Add("x-position", new OpenApiInteger(int.MaxValue));
break;
}
}
}
}
public void Apply(OpenApiParameter parameter, ParameterFilterContext context)
{
if (parameter == null)
{
throw new ArgumentNullException("parameter");
}
if (context == null)
{
throw new ArgumentNullException("context");
}
var paramType = context?.ParameterInfo?.ParameterType;
if (paramType == default)
{
return;
}
if (paramType.IsEnum && paramType.GetCustomAttribute <EnumMemberAttribute>() != null)
{
//parameter.Extensions.Add("x-ms-enum", new
//{
// name = paramType.Name,
// modelAsString = false,
// values = paramType.GetFields(BindingFlags.Static | BindingFlags.Public).Select(x =>
// {
// var enumMemberAttribute = x.GetCustomAttribute<EnumMemberAttribute>();
// return new
// {
// name = x.Name,
// value = enumMemberAttribute.Value,
// description = enumMemberAttribute.Value
// };
// })
//});
}
if ((paramType.IsGenericType &&
paramType.GetGenericTypeDefinition() == typeof(Nullable <>) &&
paramType.GetGenericArguments()[0].IsEnum))
{
var realType = paramType.GetGenericArguments()[0];
//parameter.Extensions.Add("x-ms-enum", new
//{
// name = realType.Name,
// modelAsString = false,
// values = realType.GetFields(BindingFlags.Static | BindingFlags.Public).Select(x =>
// {
// var enumMemberAttribute = x.GetCustomAttribute<EnumMemberAttribute>();
// return new
// {
// name = x.Name,
// value = enumMemberAttribute.Value,
// description = enumMemberAttribute.Value
// };
// })
//});
}
}
public void Apply(OpenApiParameter parameter, ParameterFilterContext context)
{
if (context.PropertyInfo == null &&
context.ApiParameterDescription.RouteInfo?.Constraints != null &&
context.ApiParameterDescription.RouteInfo.Constraints.Any(c => c is GuidRouteConstraint))
{
parameter.Schema.Format = "uuid";
}
}
public void Apply(OpenApiParameter parameter, ParameterFilterContext context)
{
var enumType = TryGetEnumType(context.ApiParameterDescription);
if (enumType != null)
{
XmsEnumExtensionApplicator.Apply(parameter.Extensions, enumType, _options);
}
}
public void Apply(IParameter parameter, ParameterFilterContext context)
{
var type = context.ApiParameterDescription.Type;
if (type.IsEnum)
{
parameter.Extensions.Add("x-ms-enum", new { name = type.Name, modelAsString = true });
}
}
public void Apply(IParameter parameter, ParameterFilterContext context)
{
if (this.options.GrainInterfaceGrainKeyAsName.TryGetValue(context.ParameterInfo.Member.DeclaringType, out GrainKeyDescription keyDescription))
{
if (context.ParameterInfo.Name == keyDescription.Name)
{
parameter.Description = keyDescription.Description;
}
}
}
/// <summary>
/// 应用参数过滤器
/// </summary>
/// <param name="parameter"></param>
/// <param name="context"></param>
public void Apply(OpenApiParameter parameter, ParameterFilterContext context)
{
if (context.ApiParameterDescription.DefaultValue == null)
{
if (context.ApiParameterDescription.Type.CanBeNullValue() == false)
{
parameter.Required = true;
}
}
}
public void Apply(OpenApiParameter parameter, ParameterFilterContext context)
{
if (context.ParameterInfo == null)
{
return;
}
var customAttributes = context.ParameterInfo.GetCustomAttributes(true);
ApplySwaggerParameterAttribute(parameter, customAttributes);
}
public void Apply(IParameter parameter, ParameterFilterContext context)
{
var parameterType = context.ApiParameterDescription.Type;
var paramDefaultValue = context.ApiParameterDescription.DefaultValue;
if (paramDefaultValue != null && parameterType.IsEnum)
{
var partialSchema = parameter as PartialSchema;
partialSchema.Default = Enum.GetName(parameterType, paramDefaultValue);
}
}
public void Apply(OpenApiParameter parameter, ParameterFilterContext context)
{
if (context.PropertyInfo != null)
{
ApplyPropertyAnnotations(parameter, context.PropertyInfo);
}
else if (context.ParameterInfo != null)
{
ApplyParamAnnotations(parameter, context.ParameterInfo);
}
}
public void Apply(OpenApiParameter parameter, ParameterFilterContext context)
{
if (parameter.In != null && parameter.Schema == null)
{
var type = context.ApiParameterDescription.Type;
if (type.IsEnum && !context.SchemaRepository.Schemas.ContainsKey(context.ApiParameterDescription.Type.Name))
{
parameter.Schema = context.SchemaRepository.AddDefinition(context.ApiParameterDescription.Type.Name,
context.SchemaGenerator.GenerateSchema(context.ApiParameterDescription.Type, context.SchemaRepository));
}
}
}
public void Apply_SetsDescription_FromPropertySummaryTag()
{
var parameter = new OpenApiParameter();
var propertyInfo = typeof(XmlAnnotatedType).GetProperty(nameof(XmlAnnotatedType.StringProperty));
var apiParameterDescription = new ApiParameterDescription {
};
var filterContext = new ParameterFilterContext(apiParameterDescription, null, null, propertyInfo: propertyInfo);
Subject().Apply(parameter, filterContext);
Assert.Equal("Summary for StringProperty", parameter.Description);
}
public void Apply(OpenApiParameter parameter, ParameterFilterContext context)
{
var type = context.ParameterInfo.ParameterType;
type.ApplyPrimitiveExtensions(parameter.Extensions);
var members = type.ApplyEnumExtensions(parameter.Extensions, context.SchemaGenerator, context.SchemaRepository);
if (members != null)
{
parameter.Description = members.Describe();
}
}
public void Apply(OpenApiParameter parameter, ParameterFilterContext context)
{
if (parameter.Name.Equals("event", StringComparison.InvariantCultureIgnoreCase))
{
using (var scope = _serviceScopeFactory.CreateScope())
{
var eventsService = scope.ServiceProvider.GetRequiredService <IEventsService>();
IEnumerable <String> events = eventsService.GetEvents().Result.Select(t => t.FullName);
parameter.Schema.Enum = events.Select(e => new OpenApiString(e)).ToList <IOpenApiAny>();
}
}
}
public void Apply(IParameter parameter, ParameterFilterContext context)
{
if (parameter is NonBodyParameter nonBodyParameter && string.IsNullOrEmpty(nonBodyParameter.Type))
{
var type = context.ApiParameterDescription.Type;
if (type.IsEnum)
{
nonBodyParameter.Type = "string";
var schema = context.SchemaRegistry.GetOrRegister(context.ApiParameterDescription.Type);
nonBodyParameter.Extensions.Add("schema", schema);
}
}
}
/// <summary>
/// 重写操作处理
/// </summary>
public void Apply(OpenApiParameter parameter, ParameterFilterContext context)
{
var type = context.ParameterInfo?.ParameterType;
if (type == null)
{
return;
}
if (type.IsEnum)
{
parameter.Description = $"{parameter.Description}{Environment.NewLine}{FormatDescription(type)}";
}
}
/// <summary>
/// 申请
/// </summary>
/// <param name="parameter">参数</param>
/// <param name="context">上下文</param>
public void Apply(OpenApiParameter parameter, ParameterFilterContext context)
{
var apiProperty = context.PropertyInfo;
var memberAttributes = apiProperty?.GetInlineOrMetadataTypeAttributes() ?? Enumerable.Empty <object>();
foreach (var attribute in memberAttributes)
{
if (attribute is DataTypeAttribute dataTypeAttribute && !string.IsNullOrWhiteSpace(dataTypeAttribute.CustomDataType))
{
parameter.Schema.Format = dataTypeAttribute.CustomDataType;
}
}
}
public void Apply_SetsDescription_FromUnderlyingGenericTypeActionParamTag()
{
var parameter = new OpenApiParameter();
var parameterInfo = typeof(FakeConstructedControllerWithXmlComments)
.GetMethod(nameof(FakeConstructedControllerWithXmlComments.ActionWithGenericTypeParameter))
.GetParameters()[0];
var apiParameterDescription = new ApiParameterDescription {
};
var filterContext = new ParameterFilterContext(apiParameterDescription, null, null, parameterInfo: parameterInfo);
Subject().Apply(parameter, filterContext);
Assert.Equal("Description for param", parameter.Description);
}
public void Apply_EnrichesParameterMetadata_IfPropertyDecoratedWithSwaggerParameterAttribute()
{
var parameter = new OpenApiParameter();
var propertyInfo = typeof(SwaggerAnnotatedType).GetProperty(nameof(SwaggerAnnotatedType.StringWithSwaggerParameterAttribute));
var filterContext = new ParameterFilterContext(
apiParameterDescription: new ApiParameterDescription(),
schemaGenerator: null,
schemaRepository: null,
propertyInfo: propertyInfo);
Subject().Apply(parameter, filterContext);
Assert.Equal("Description for StringWithSwaggerParameterAttribute", parameter.Description);
Assert.True(parameter.Required);
}
public void Apply(OpenApiParameter parameter, ParameterFilterContext context)
{
var type = Nullable.GetUnderlyingType(context.ApiParameterDescription.Type) ?? context.ApiParameterDescription.Type;
if (type.IsEnum)
{
AddEnumParamSpec(parameter, type, context);
parameter.Required = type == context.ApiParameterDescription.Type;
}
else if (type.IsArray || (type.IsGenericType && type.GetInterfaces().Contains(typeof(IEnumerable))))
{
var itemType = type.GetElementType() ?? type.GenericTypeArguments.First();
AddEnumSpec(parameter, itemType, context);
}
}
public void Apply(OpenApiParameter parameter, ParameterFilterContext context)
{
var type = context.ParameterInfo.ParameterType.UnwrapIfNullable();
if (!type.IsEnum)
{
return;
}
// TODO (2020-02-14): Need this hack to work around a serialize issue with the V2 format.
parameter.Extensions["schema"] = new OpenApiObject
{
["$ref"] = new OpenApiString("#/definitions/" + type.FullName),
};
}
public void Apply(IParameter parameter, ParameterFilterContext context)
{
var type = Nullable.GetUnderlyingType(context.ApiParameterDescription.Type) ?? context.ApiParameterDescription.Type;
if (type.IsEnum)
{
AddRef(parameter.Extensions, type, context.SchemaRegistry);
parameter.Required = type == context.ApiParameterDescription.Type;
}
else if (parameter is NonBodyParameter nonBodyParam && (type.IsArray || (type.IsGenericType && type.GetInterfaces().Contains(typeof(IEnumerable)))))
{
var itemType = type.GetElementType() ?? type.GenericTypeArguments.First();
AddRef(nonBodyParam.Items.Extensions, itemType, context.SchemaRegistry);
}
}
public void Apply(OpenApiParameter parameter, ParameterFilterContext context)
{
var type = context.ApiParameterDescription.Type;
if (type.IsEnum)
{
// parameter.Extensions.Add( "x-ms-enum", new { name = type.Name, modelAsString = false });
var obj = new OpenApiObject
{
["name"] = new OpenApiString(type.Name),
["modelAsString"] = new OpenApiBoolean(false)
};
parameter.Extensions.Add("x-ms-enum", obj);
}
}
private static void AddEnumParamSpec(OpenApiParameter parameter, Type type, ParameterFilterContext context)
{
var schema = context.SchemaGenerator.GenerateSchema(type, context.SchemaRepository);
if (schema.Reference == null)
{
return;
}
parameter.Schema = schema;
var enumNames = new OpenApiArray();
enumNames.AddRange(Enum.GetNames(type).Select(_ => new OpenApiString(_)));
schema.Extensions.Add("x-enumNames", enumNames);
}
