private void CreateArrayOrListObject(string name, object value, Type type, Type nestedType,
OpenApiObject openApiObject)
{
if (value == null)
{
openApiObject.Add(name, new OpenApiNull());
return;
}
var arrayObject = new OpenApiArray();
foreach (var item in value as IEnumerable)
{
if (nestedType.IsSimpleType())
{
var node = CreateOpenApiObject(nestedType, item);
arrayObject.Add(node);
}
else
{
var arrayItemObject = new OpenApiObject();
var properties = nestedType.GetProperties(BindingFlags.Public | BindingFlags.Instance);
foreach (var property in properties)
{
var nodeValue = property.GetValue(item);
ConvertRec(GetName(property.Name), nodeValue, property.PropertyType, arrayItemObject);
}
arrayObject.Add(arrayItemObject);
}
}
openApiObject.Add(GetName(name), arrayObject);
}
public void Apply(OpenApiSchema schema, SchemaFilterContext context)
{
var type = context.Type;
if (type.IsEnum)
{
var values = Enum.GetValues(type);
var valueArr = new OpenApiArray();
foreach (var value in values)
{
var item = new OpenApiObject
{
["name"] = new OpenApiString(Enum.GetName(type, value)),
["value"] = new OpenApiString(value.ToString())
};
valueArr.Add(item);
}
schema.Extensions.Add(
"x-ms-enum",
new OpenApiObject
{
["name"] = new OpenApiString(type.Name),
["modelAsString"] = new OpenApiBoolean(true),
["values"] = valueArr
}
);
}
}
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)
}
);
}
/// <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);
}
}
}
}
}
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());
}
}
private static IOpenApiAny GetTypeNameForExample(IEdmTypeReference edmTypeReference)
{
switch (edmTypeReference.TypeKind())
{
case EdmTypeKind.Primitive:
if (edmTypeReference.IsBoolean())
{
return(new OpenApiBoolean(true));
}
else
{
return(new OpenApiString(edmTypeReference.AsPrimitive().PrimitiveDefinition().Name));
}
case EdmTypeKind.Entity:
case EdmTypeKind.Complex:
case EdmTypeKind.Enum:
OpenApiObject obj = new OpenApiObject();
obj["@odata.type"] = new OpenApiString(edmTypeReference.FullName());
return(obj);
case EdmTypeKind.Collection:
OpenApiArray array = new OpenApiArray();
IEdmTypeReference elementType = edmTypeReference.AsCollection().ElementType();
array.Add(GetTypeNameForExample(elementType));
return(array);
case EdmTypeKind.Untyped:
case EdmTypeKind.TypeDefinition:
case EdmTypeKind.EntityReference:
default:
throw new OpenApiException("Not support for the type kind " + edmTypeReference.TypeKind());
}
}
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);
}
}
internal static OpenApiArray ToOpenApiArray(this IEnumerable <string> input)
{
var result = new OpenApiArray();
result.AddRange(input.Select(x => new OpenApiString(x)));
return(result);
}
internal static OpenApiArray ToOpenApiArray(this IEnumerable <IOpenApiAny> input)
{
var result = new OpenApiArray();
result.AddRange(input);
return(result);
}
public override OpenApiObject GetCustomOpenApiConfig(LinkGenerator linkGenerator)
{
var baseConfig = base.GetCustomOpenApiConfig(linkGenerator);
var types = new OpenApiArray();
if (CanSelectExisting)
{
types.Add(new OpenApiObject
{
{ "type", new OpenApiString("autocomplete") }, { "label", new OpenApiString("Existing") },
{ "validation", new OpenApiArray {
new OpenApiString("required-from-list")
} }
});
// types.Add(new OpenApiObject
// {
// {"type", new OpenApiString("select")}, {"label", new OpenApiString("Existing S")},
// {"validation", new OpenApiArray {new OpenApiString("required-from-list")}}
// });
}
if (CanAddNewOrEdit)
{
types.Add(new OpenApiObject
{
{ "type", new OpenApiString("subGroup") }, { "label", new OpenApiString("+ Add new / Edit") },
{ "keepFieldGroup", new OpenApiBoolean(true) }
});
}
baseConfig["fieldTypes"] = types;
return(baseConfig);
}
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 async Task WriteOpenApiArrayAsJsonWorks(bool produceTerseOutput)
{
// Arrange
var openApiObject = new OpenApiObject
{
{ "stringProp", new OpenApiString("stringValue1") },
{ "objProp", new OpenApiObject() },
{
"arrayProp",
new OpenApiArray
{
new OpenApiBoolean(false)
}
}
};
var array = new OpenApiArray
{
new OpenApiBoolean(false),
openApiObject,
new OpenApiString("stringValue2")
};
var actualJson = WriteAsJson(array, produceTerseOutput);
// Assert
await Verifier.Verify(actualJson).UseParameters(produceTerseOutput);
}
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)
{
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);
}
}
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));
}
}
private bool TryParse(JsonElement token, out IOpenApiAny?any)
{
any = null;
switch (token.ValueKind)
{
case JsonValueKind.Array:
var array = new OpenApiArray();
foreach (var value in token.EnumerateArray())
{
if (TryParse(value, out var child))
{
array.Add(child);
}
}
any = array;
return(true);
case JsonValueKind.False:
any = new OpenApiBoolean(false);
return(true);
case JsonValueKind.True:
any = new OpenApiBoolean(true);
return(true);
case JsonValueKind.Number:
any = new OpenApiDouble(token.GetDouble());
return(true);
case JsonValueKind.String:
any = new OpenApiString(token.GetString());
return(true);
case JsonValueKind.Object:
var obj = new OpenApiObject();
foreach (var child in token.EnumerateObject())
{
if (TryParse(child.Value, out var value))
{
obj[child.Name] = value;
}
}
any = obj;
return(true);
case JsonValueKind.Null:
case JsonValueKind.Undefined:
default:
return(false);
}
}
public override IOpenApiAny ParseIntoAny()
{
var array = new OpenApiArray();
foreach (var node in childNodes)
{
array.Add(node.ParseIntoAny());
}
return(array);
}
/// <summary>
/// Create a <see cref="OpenApiArray"/>
/// </summary>
/// <returns>The created Any object.</returns>
public override IOpenApiAny CreateAny()
{
var array = new OpenApiArray();
foreach (var node in this)
{
array.Add(node.CreateAny());
}
return(array);
}
private static IOpenApiAny CreateOpenApiArray(JsonElement jsonElement)
{
var openApiArray = new OpenApiArray();
foreach (var item in jsonElement.EnumerateArray())
{
openApiArray.Add(CreateFromJsonElement(item));
}
return(openApiArray);
}
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);
}
static public IOpenApiAny GetExample(Type parameter, TypeMaps maps, OpenApiComponents components)
{
if (components.Schemas.ContainsKey(parameter.Name))
{
return(components.Schemas[parameter.Name].Example);
}
if (maps.ContainsMap(parameter))
{
return(maps.GetMap(parameter).OpenApiExample);
}
else if (parameter == typeof(string))
{
int randomNum = new Random().Next() % 3;
var words = new string[] { "foo", "bar", "baz" };
return(new OpenApiString(words[randomNum]));
}
else if (IsNumericType(parameter))
{
int randomNum = new Random().Next() % 400;
return(new OpenApiInteger(randomNum));
}
else if (parameter == typeof(bool))
{
int randomNum = new Random().Next() % 1;
return(new OpenApiBoolean(randomNum == 0));
}
else if (parameter.GetInterfaces().Contains(typeof(IEnumerable)))
{
var exampleArr = new OpenApiArray();
int randomNum = new Random().Next() % 3;
for (int _ = 0; _ < randomNum + 1; _++)
{
var innerType = parameter.GetElementType() ?? parameter.GenericTypeArguments[0];
exampleArr.Add(GetExample(innerType, maps, components));
}
return(exampleArr);
}
else
{
if (parameter.GetProperties().Length == 0)
{
return(new OpenApiNull());
}
var example = new OpenApiObject();
foreach (var prop in parameter.GetProperties())
{
example.Add(prop.Name, GetExample(prop.PropertyType, maps, components));
}
return(example);
}
}
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)
{
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);
}
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()));
}
}
}
/// <inheritdoc/>
protected override void SetExtensions(OpenApiPathItem item)
{
if (!Context.Settings.ShowMsDosGroupPath)
{
return;
}
IList <ODataPath> samePaths = new List <ODataPath>();
foreach (var path in Context.AllPaths.Where(p => p.Kind == ODataPathKind.NavigationProperty && p != Path))
{
bool lastIsKeySegment = path.LastSegment is ODataKeySegment;
if (LastSegmentIsKeySegment != lastIsKeySegment)
{
continue;
}
ODataNavigationSourceSegment navigationSourceSegment = path.FirstSegment as ODataNavigationSourceSegment;
if (NavigationSource != navigationSourceSegment.NavigationSource)
{
continue;
}
ODataNavigationPropertySegment npSegment = path.LastSegment as ODataNavigationPropertySegment;
if (npSegment == null)
{
npSegment = path.Segments[path.Count - 2] as ODataNavigationPropertySegment;
}
if (NavigationProperty != npSegment.NavigationProperty)
{
continue;
}
samePaths.Add(path);
}
if (samePaths.Any())
{
OpenApiArray array = new OpenApiArray();
OpenApiConvertSettings settings = Context.Settings.Clone();
settings.EnableKeyAsSegment = Context.KeyAsSegment;
foreach (var p in samePaths)
{
array.Add(new OpenApiString(p.GetPathItemName(settings)));
}
item.Extensions.Add(Constants.xMsDosGroupPath, array);
}
}
private static IOpenApiAny CreateOpenApiArray(JsonElement jsonElement)
{
var openApiArray = new OpenApiArray();
foreach (var item in jsonElement.EnumerateArray())
{
var json = item.ValueKind == JsonValueKind.String
? $"\"{item}\""
: item.ToString();
openApiArray.Add(CreateFromJson(json));
}
return(openApiArray);
}
private static IOpenApiAny CreateOpenApiArray(IEnumerable <JsonElement> jsonElements)
{
var openApiArray = new OpenApiArray();
foreach (var jsonElement in jsonElements)
{
var json = jsonElement.ValueKind == JsonValueKind.String
? $"\"{jsonElement}\""
: jsonElement.ToString();
openApiArray.Add(CreateFromJson(json));
}
return(openApiArray);
}
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);
}
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);
}
