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);
}
}
}
}
}
/// <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);
}
}
}
}
}
}
internal static OpenApiArray ToOpenApiArray(this IEnumerable <string> input)
{
var result = new OpenApiArray();
result.AddRange(input.Select(x => new OpenApiString(x)));
return(result);
}
protected virtual void AttachBasicProps(OpenApiSchema schema, OpenApiObject xProps,
OpenApiObject templateOptions, LinkGenerator linkGenerator)
{
if (ClassName != null)
{
xProps["className"] = OpenApiExtensions.ToOpenApi(ClassName);
}
if (DefaultValue != null)
{
xProps["defaultValue"] = OpenApiExtensions.ToOpenApi(DefaultValue);
}
if (Wrappers != null)
{
var arr = new OpenApiArray();
arr.AddRange(from object o in Wrappers select OpenApiExtensions.ToOpenApi(o));
xProps["wrappers"] = arr;
}
if (Disabled)
{
templateOptions["disabled"] = OpenApiExtensions.ToOpenApi(true);
}
}
public static IOpenApiAny ToOpenApi(object obj)
{
if (obj is IOpenApiAny objOa)
{
return(objOa);
}
switch (obj)
{
case string s:
return(new OpenApiString(s));
case int i:
return(new OpenApiInteger(i));
case bool b:
return(new OpenApiBoolean(b));
case float f:
return(new OpenApiFloat(f));
case double d:
return(new OpenApiDouble(d));
case Enum e:
return(ToOpenApi(e.GetCustomValue()));
case IEnumerable enumerable:
var arr = new OpenApiArray();
arr.AddRange(from object o in enumerable select ToOpenApi(o));
return(arr);
default:
throw new KnownException("Can't find any specific open api type for " + obj.GetType());
}
}
public void Apply(OpenApiSchema schema, SchemaFilterContext context)
{
if (context.Type == null)
{
return;
}
var type = Nullable.GetUnderlyingType(context.Type) ?? context.Type;
if (!type.IsEnum || schema.Extensions.ContainsKey("x-enumNames"))
{
return;
}
var enumNames = new OpenApiArray();
enumNames.AddRange(Enum.GetNames(type).Select(_ => new OpenApiString(_)));
schema.Extensions.Add("x-enumNames", enumNames);
schema.Extensions.Add(
"x-ms-enum",
new OpenApiObject
{
["name"] = new OpenApiString(type.Name),
["modelAsString"] = new OpenApiBoolean(true)
}
);
}
internal static OpenApiArray ToOpenApiArray(this IEnumerable <IOpenApiAny> input)
{
var result = new OpenApiArray();
result.AddRange(input);
return(result);
}
internal override IDictionary <string, IOpenApiAny> ToDictionary()
{
var children = new OpenApiObject();
if (Types != null && Types.Any())
{
var types = new OpenApiArray();
types.AddRange(Types.Select(x => new OpenApiString(x)));
children[TypesKey] = types;
}
if (VpcEndpointIds != null && VpcEndpointIds.Any())
{
var vpcIds = new OpenApiArray();
vpcIds.AddRange(VpcEndpointIds.Select(x => new OpenApiString(x)));
children[VpcEndpointIdsKey] = vpcIds;
}
return(new Dictionary <string, IOpenApiAny>()
{
{ EndpointConfigurationRootKey, children }
});
}
public void Apply(OpenApiOperation operation, OperationFilterContext context)
{
var allowAnonymous = context.ApiDescription.CustomAttributes().OfType <AllowAnonymousAttribute>().Any();
if (!allowAnonymous)
{
operation.Security.Add(new OpenApiSecurityRequirement
{
{
new OpenApiSecurityScheme
{
Reference = new OpenApiReference
{
Id = "Bearer",
Type = ReferenceType.SecurityScheme
}
},
new List <string>()
}
});
}
var attr = context.MethodInfo.GetCustomAttribute <UserClaimsAttribute>(true);
if (attr == null)
{
return;
}
if (attr.Permissions != UserPermissions.None)
{
var array = new OpenApiArray();
array.AddRange(attr.PermissionFlags.Select(p => new OpenApiString(p.ToString())));
operation.Extensions["x-permissions"] = array;
}
if (attr.Reputation > 0)
{
operation.Extensions["x-reputation"] = new OpenApiDouble(attr.Reputation);
}
operation.Extensions["x-unrestricted"] = new OpenApiBoolean(attr.Unrestricted);
operation.Parameters.Add(new OpenApiParameter
{
Name = "reason",
In = ParameterLocation.Query,
Required = attr.Reason,
AllowEmptyValue = false,
Description = "Reason for performing this action.",
Schema = new OpenApiSchema
{
Type = "string",
MinLength = UserClaimsAttribute.MinReasonLength
}
});
}
public void Apply(OpenApiSchema schema, SchemaFilterContext context)
{
var typeInfo = context.Type.GetTypeInfo();
var enumsArray = new OpenApiArray();
if (typeInfo.IsEnum)
{
var names = Enum.GetNames(context.Type).Select(name => new OpenApiString(name)).ToList();
enumsArray.AddRange(names);
if (!schema.Extensions.ContainsKey("x-enumNames") && enumsArray.Any())
{
schema.Extensions.Add("x-enumNames", enumsArray);
}
return;
}
// add "x-enumNames" for schema with generic types
if (typeInfo.IsGenericType && !schema.Extensions.ContainsKey("x-enumNames"))
{
foreach (var genericArgumentType in typeInfo.GetGenericArguments())
{
if (genericArgumentType.IsEnum)
{
if (schema.Properties?.Count > 0)
{
foreach (var schemaProperty in schema.Properties)
{
var schemaPropertyValue = schemaProperty.Value;
var propertySchema = context.SchemaRepository.Schemas.FirstOrDefault(s => schemaPropertyValue.AllOf.FirstOrDefault(a => a.Reference.Id == s.Key) != null).Value;
if (propertySchema != null)
{
var names = Enum.GetNames(genericArgumentType).Select(name => new OpenApiString(name));
enumsArray.AddRange(names);
if (!schemaPropertyValue.Extensions.ContainsKey("x-enumNames") && enumsArray.Any())
{
schemaPropertyValue.Extensions.Add("x-enumNames", enumsArray);
}
}
}
}
}
}
}
}
public void Apply(OpenApiSchema schema, SchemaFilterContext context)
{
if (context.Type.IsEnum)
{
var names = new OpenApiArray();
names.AddRange(Enum.GetNames(context.Type).Select(x => new OpenApiString(x)));
schema.Extensions.Add(new KeyValuePair <string, IOpenApiExtension>("x-enum-varnames", names));
}
}
public void Apply(OpenApiSchema schema, SchemaFilterContext context)
{
if (context.Type.IsEnum)
{
var array = new OpenApiArray();
array.AddRange(Enum.GetNames(context.Type).Select(n => new OpenApiString(n)));
schema.Extensions.Add("x-enumNames", array);
}
}
private static OpenApiArray ToOpenApiArray(Type type, object instance)
{
var itemType = GetAnyElementType(type);
var array = default(OpenApiArray);
if (itemType != null)
{
array = new OpenApiArray();
array.AddRange(((IEnumerable)instance).Cast <object>().Select(x => GetStructValue(itemType ?? x.GetType(), x) ?? ToOpenApiAny(itemType ?? x.GetType(), x)));
}
return(array);
}
internal override IDictionary <string, IOpenApiAny> ToDictionary()
{
var children = new OpenApiObject();
if (AllowOrigins != null && AllowOrigins.Any())
{
var allowOrigins = new OpenApiArray();
allowOrigins.AddRange(AllowOrigins.Select(x => new OpenApiString(x)));
children[AllowOriginsKey] = allowOrigins;
}
if (AllowCredentials.HasValue)
{
children[AllowCredentialsKey] = new OpenApiBoolean(AllowCredentials.Value);
}
if (ExposeHeaders != null && ExposeHeaders.Any())
{
var exposeHeaders = new OpenApiArray();
exposeHeaders.AddRange(ExposeHeaders.Select(x => new OpenApiString(x)));
children[ExposeHeadersKey] = exposeHeaders;
}
if (MaxAge.HasValue)
{
children[MaxAgeKey] = new OpenApiInteger(MaxAge.Value);
}
if (AllowMethods != null && AllowMethods.Any())
{
var allowMethods = new OpenApiArray();
allowMethods.AddRange(AllowMethods.Select(x => new OpenApiString(x)));
children[AllowMethodsKey] = allowMethods;
}
if (AllowHeaders != null && AllowHeaders.Any())
{
var allowHeaders = new OpenApiArray();
allowHeaders.AddRange(AllowHeaders.Select(x => new OpenApiString(x)));
children[AllowHeadersKey] = allowHeaders;
}
return(new Dictionary <string, IOpenApiAny>()
{
{ CORSRootKey, children }
});
}
public void Apply(OpenApiSchema schema, SchemaFilterContext context)
{
if (!TypeHelper.IsSerializeAttribute(context.Type) &&
!TypeHelper.IsEnumerable(context.Type) &&
context.Type != typeof(object))
{
//if (context.Type.Name == "UserReg")
//{ }
schema.Type = "object";
schema.Properties.Clear();
schema.AdditionalPropertiesAllowed = true;
OpenApiSchema baseSchema = GetBaseSchema(context);
if (baseSchema != null)
{
schema.AllOf = new List <OpenApiSchema> {
baseSchema
};
}
if (TypeHelper.IsBaseType(context.Type, typeof(DBItem)))
{
var table = DBTable.GetTableAttributeInherit(context.Type);
if (table != null)
{
ApplyTable(schema, context, table);
return;
}
}
ApplyObject(schema, context);
}
else if (context.Type.IsEnum)
{
var items = EnumItem.GetEnumItems(context.Type);
var namesArray = new OpenApiArray();
namesArray.AddRange(items.Select(p => new OpenApiString(p.Name)));
schema.Extensions.Add("x-enumNames", namesArray);
var textArray = new OpenApiArray();
textArray.AddRange(items.Select(p => new OpenApiString(p.Text)));
schema.Extensions.Add("x-enumMembers", textArray);
if (context.Type.GetCustomAttribute <FlagsAttribute>() != null)
{
schema.Extensions.Add("x-flags", new OpenApiInteger(Enum.GetValues(context.Type).Cast <int>().First()));
}
}
}
public void Apply(OpenApiSchema schema, SchemaFilterContext context)
{
var type = Nullable.GetUnderlyingType(context.Type) ?? context.Type;
if (!type.IsEnum || schema.Extensions.ContainsKey("x-enumNames"))
{
return;
}
var enumNames = new OpenApiArray();
enumNames.AddRange(Enum.GetNames(type).Select(_ => new OpenApiString(_)));
schema.Extensions.Add("x-enumNames", enumNames);
}
private static void AddEnumSpec(Type type, ParameterFilterContext context)
{
var schema = context.SchemaRepository.Schemas.GetOrAdd($"#/definitions/{type.Name}", () =>
context.SchemaGenerator.GenerateSchema(type, context.SchemaRepository)
);
if (schema.Reference == null || !type.IsEnum)
{
return;
}
var enumNames = new OpenApiArray();
enumNames.AddRange(Enum.GetNames(type).Select(_ => new OpenApiString(_)));
schema.Extensions.Add("x-enumNames", enumNames);
}
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);
}
public void Apply(OpenApiOperation operation, OperationFilterContext context)
{
var attr = context.ApiDescription.CustomAttributes().OfType <RequireUserAttribute>().LastOrDefault();
if (attr == null)
{
return;
}
if (attr.Permissions != UserPermissions.None)
{
var array = new OpenApiArray();
array.AddRange(attr.Permissions.ToFlags().Select(p => new OpenApiString(p.ToString())));
operation.Extensions["x-permissions"] = array;
}
if (attr.Unrestricted)
{
operation.Extensions["x-unrestricted"] = new OpenApiBoolean(attr.Unrestricted);
}
}
/// <summary>
/// Apply the filter.
/// </summary>
/// <param name="schema"><see cref="OpenApiSchema"/>.</param>
/// <param name="context"><see cref="SchemaFilterContext"/>.</param>
public void Apply(OpenApiSchema schema, SchemaFilterContext context)
{
if (!this._applyFiler)
{
return;
}
var typeInfo = context.Type.GetTypeInfo();
var enumsArray = new OpenApiArray();
var enumsDescriptionsArray = new OpenApiArray();
if (typeInfo.IsEnum)
{
var names = Enum.GetNames(context.Type).Select(name => new OpenApiString(name)).ToList();
enumsArray.AddRange(names);
if (!schema.Extensions.ContainsKey("x-enumNames") && enumsArray.Any())
{
schema.Extensions.Add("x-enumNames", enumsArray);
}
if (this._includeXEnumDescriptions)
{
enumsDescriptionsArray.AddRange(EnumTypeExtensions.GetEnumValuesDescription(context.Type, this._descriptionSources, this._xmlNavigators, this._includeXEnumRemarks));
if (!schema.Extensions.ContainsKey("x-enumDescriptions") && enumsDescriptionsArray.Any())
{
schema.Extensions.Add("x-enumDescriptions", enumsDescriptionsArray);
}
}
return;
}
// add "x-enumNames" for schema with generic types
if (typeInfo.IsGenericType && !schema.Extensions.ContainsKey("x-enumNames"))
{
foreach (var genericArgumentType in typeInfo.GetGenericArguments())
{
if (genericArgumentType.IsEnum)
{
if (schema.Properties?.Count > 0)
{
foreach (var schemaProperty in schema.Properties)
{
var schemaPropertyValue = schemaProperty.Value;
var propertySchema = context.SchemaRepository.Schemas.FirstOrDefault(s => schemaPropertyValue.AllOf.FirstOrDefault(a => a.Reference.Id == s.Key) != null).Value;
if (propertySchema != null)
{
var names = Enum.GetNames(genericArgumentType).Select(name => new OpenApiString(name));
enumsArray.AddRange(names);
if (!schemaPropertyValue.Extensions.ContainsKey("x-enumNames") && enumsArray.Any())
{
schemaPropertyValue.Extensions.Add("x-enumNames", enumsArray);
}
if (this._includeXEnumDescriptions)
{
enumsDescriptionsArray.AddRange(EnumTypeExtensions.GetEnumValuesDescription(genericArgumentType, this._descriptionSources, this._xmlNavigators, this._includeXEnumRemarks));
if (!schemaPropertyValue.Extensions.ContainsKey("x-enumDescriptions") && enumsDescriptionsArray.Any())
{
schemaPropertyValue.Extensions.Add("x-enumDescriptions", enumsDescriptionsArray);
}
}
var description = propertySchema.AddEnumValuesDescription(this._includeXEnumDescriptions);
if (description != null)
{
if (schemaPropertyValue.Description == null)
{
schemaPropertyValue.Description = description;
}
else if (!schemaPropertyValue.Description.Contains(description))
{
schemaPropertyValue.Description += description;
}
}
}
}
}
}
}
}
if (schema.Properties?.Count > 0)
{
foreach (var schemaProperty in schema.Properties)
{
var schemaPropertyValue = schemaProperty.Value;
var propertySchema = context.SchemaRepository.Schemas.FirstOrDefault(s => schemaPropertyValue.AllOf.FirstOrDefault(a => a.Reference.Id == s.Key) != null).Value;
var description = propertySchema?.AddEnumValuesDescription(this._includeXEnumDescriptions);
if (description != null)
{
if (schemaPropertyValue.Description == null)
{
schemaPropertyValue.Description = description;
}
else if (!schemaPropertyValue.Description.Contains(description))
{
schemaPropertyValue.Description += description;
}
}
}
}
}
