private Schema CreateEnumSchema(JsonPrimitiveContract primitiveContract, Type type)
{
var stringEnumConverter = primitiveContract.Converter as StringEnumConverter
?? _jsonSerializerSettings.Converters.OfType<StringEnumConverter>().FirstOrDefault();
if (_settings.DescribeAllEnumsAsStrings || stringEnumConverter != null)
{
var camelCase = _settings.DescribeStringEnumsInCamelCase
|| (stringEnumConverter != null && stringEnumConverter.CamelCaseText);
return new Schema
{
Type = "string",
Enum = (camelCase)
? Enum.GetNames(type).Select(name => name.ToCamelCase()).ToArray()
: Enum.GetNames(type)
};
}
return new Schema
{
Type = "integer",
Format = "int32",
Enum = Enum.GetValues(type).Cast<object>().ToArray()
};
}
private string method_35(JsonWriter jsonWriter_0, DictionaryEntry dictionaryEntry_0, JsonContract jsonContract_1, out bool bool_1)
{
string str;
object key = dictionaryEntry_0.Key;
JsonPrimitiveContract contract = jsonContract_1 as JsonPrimitiveContract;
if (contract != null)
{
if ((contract.Enum17_0 != Enum17.DateTime) && (contract.Enum17_0 != Enum17.DateTimeNullable))
{
if ((contract.Enum17_0 != Enum17.DateTimeOffset) && (contract.Enum17_0 != Enum17.DateTimeOffsetNullable))
{
bool_1 = true;
return(Convert.ToString(key, CultureInfo.InvariantCulture));
}
bool_1 = false;
StringWriter writer2 = new StringWriter(CultureInfo.InvariantCulture);
Class184.smethod_21(writer2, (DateTimeOffset)key, jsonWriter_0.DateFormatHandling, jsonWriter_0.DateFormatString, jsonWriter_0.Culture);
return(writer2.ToString());
}
bool_1 = false;
StringWriter writer = new StringWriter(CultureInfo.InvariantCulture);
Class184.smethod_16(writer, (DateTime)key, jsonWriter_0.DateFormatHandling, jsonWriter_0.DateFormatString, jsonWriter_0.Culture);
return(writer.ToString());
}
if (smethod_0(key, key.GetType(), out str))
{
bool_1 = true;
return(str);
}
bool_1 = true;
return(key.ToString());
}
private Schema CreateEnumSchema(JsonPrimitiveContract primitiveContract, Type type)
{
StringEnumConverter stringEnumConverter = (primitiveContract.Converter as StringEnumConverter) ?? this._jsonSerializerSettings.Converters.OfType <StringEnumConverter>().FirstOrDefault <StringEnumConverter>();
if (this._describeAllEnumsAsStrings || stringEnumConverter != null)
{
bool flag = this._describeStringEnumsInCamelCase || (stringEnumConverter != null && stringEnumConverter.CamelCaseText);
Schema schema = new Schema();
schema.type = "string";
Schema arg_92_0 = schema;
IList <object> arg_92_1;
if (!flag)
{
arg_92_1 = type.GetEnumNamesForSerialization();
}
else
{
arg_92_1 = (from name in type.GetEnumNamesForSerialization()
select name.ToCamelCase()).ToArray <string>();
}
arg_92_0.@enum = arg_92_1;
return(schema);
}
return(new Schema
{
type = "integer",
format = "int32",
@enum = type.GetEnumValues().Cast <object>().ToArray <object>()
});
}
public Schema CreateEnumSchema(JsonPrimitiveContract primitiveContract, Type type)
{
var stringEnumConverter = primitiveContract.Converter as StringEnumConverter
?? _jsonSerializerSettings.Converters.OfType <StringEnumConverter>().FirstOrDefault();
if (_options.DescribeAllEnumsAsStrings || stringEnumConverter != null)
{
var camelCase = _options.DescribeStringEnumsInCamelCase ||
(stringEnumConverter != null && stringEnumConverter.CamelCaseText);
var enumValues = type.GetEnumNamesForSerialization(_options.IgnoreObsoleteEnumConstants);
return(new Schema
{
type = "string",
@enum = camelCase
? enumValues.Select(name => name.ToCamelCase()).ToArray()
: enumValues
});
}
return(new Schema
{
type = "integer",
format = "int32",
@enum = type.GetEnumValuesForSerialization(_options.IgnoreObsoleteEnumConstants)
});
}
private Schema CreatePrimitiveSchema(JsonPrimitiveContract primitiveContract)
{
var type = Nullable.GetUnderlyingType(primitiveContract.UnderlyingType)
?? primitiveContract.UnderlyingType;
var typeInfo = type.GetTypeInfo();
if (typeInfo.IsEnum)
{
var converter = primitiveContract.Converter;
var describeAsString = _options.DescribeAllEnumsAsStrings ||
(converter != null && converter.GetType() == typeof(StringEnumConverter));
return(describeAsString
? new Schema {
Type = "string", Enum = Enum.GetNames(type)
}
: new Schema {
Type = "integer", Format = "int32", Enum = Enum.GetValues(type).Cast <object>().ToArray()
});
}
if (PrimitiveTypeMap.ContainsKey(type))
{
return(PrimitiveTypeMap[type]());
}
// None of the above, fallback to string
return(new Schema {
Type = "string"
});
}
private Schema CreateEnumSchema(JsonPrimitiveContract primitiveContract, Type type)
{
var stringEnumConverter = primitiveContract.Converter as StringEnumConverter
?? _jsonSerializerSettings.Converters.OfType <StringEnumConverter>().FirstOrDefault();
if (_settings.DescribeAllEnumsAsStrings || stringEnumConverter != null)
{
var camelCase = _settings.DescribeStringEnumsInCamelCase ||
(stringEnumConverter != null && stringEnumConverter.CamelCaseText);
var enumNames = type.GetFields(BindingFlags.Public | BindingFlags.Static)
.Select(f =>
{
var enumMemberAttribute = f.GetCustomAttributes().OfType <EnumMemberAttribute>().FirstOrDefault();
var serializeName = (enumMemberAttribute == null) ? f.Name : enumMemberAttribute.Value;
return(camelCase ? serializeName.ToCamelCase() : serializeName);
});
return(new Schema
{
Type = "string",
Enum = enumNames.ToArray()
});
}
return(new Schema
{
Type = "integer",
Format = "int32",
Enum = Enum.GetValues(type).Cast <object>().ToArray()
});
}
private Schema CreateEnumSchema(JsonPrimitiveContract primitiveContract, Type type)
{
var stringEnumConverter = primitiveContract.Converter as StringEnumConverter
?? _jsonSerializerSettings.Converters.OfType <StringEnumConverter>().FirstOrDefault();
if (_describeAllEnumsAsStrings || stringEnumConverter != null)
{
var camelCase = _describeStringEnumsInCamelCase ||
(stringEnumConverter != null && stringEnumConverter.CamelCaseText);
return(new Schema
{
type = "string",
@enum = camelCase
? type.GetEnumNamesForSerialization().Select(name => name.ToCamelCase()).ToArray()
: type.GetEnumNamesForSerialization()
});
}
return(new Schema
{
type = "integer",
format = "int32",
@enum = type.GetEnumValues().Cast <object>().ToArray()
});
}
private Schema CreatePrimitiveSchema(JsonPrimitiveContract primitiveContract)
{
var type = Nullable.GetUnderlyingType(primitiveContract.UnderlyingType) ?? primitiveContract.UnderlyingType;
if (type.IsEnum)
{
return(CreateEnumSchema(primitiveContract, type));
}
switch (type.FullName)
{
case "System.Int16":
case "System.UInt16":
case "System.Int32":
case "System.UInt32":
return(new Schema {
type = "integer", format = "int32"
});
case "System.Int64":
case "System.UInt64":
return(new Schema {
type = "integer", format = "int64"
});
case "System.Single":
return(new Schema {
type = "number", format = "float"
});
case "System.Double":
case "System.Decimal":
return(new Schema {
type = "number", format = "double"
});
case "System.Byte":
case "System.SByte":
return(new Schema {
type = "string", format = "byte"
});
case "System.Boolean":
return(new Schema {
type = "boolean"
});
case "System.DateTime":
case "System.DateTimeOffset":
return(new Schema {
type = "string", format = "date-time"
});
default:
return(new Schema {
type = "string"
});
}
}
public static JsonPrimitiveContract Copy(this JsonPrimitiveContract source) =>
new JsonPrimitiveContract(source.UnderlyingType)
{
Converter = source.Converter,
CreatedType = source.CreatedType,
DefaultCreator = source.DefaultCreator,
DefaultCreatorNonPublic = source.DefaultCreatorNonPublic,
IsReference = source.IsReference
};
public void CreateDefinitionSchema_Null()
{
var contract = new JsonPrimitiveContract(typeof(int));
var mock = new Mock <JsonSerializerSettings>();
var schema = new SchemaRegistry(mock.Object, new SwaggerGeneratorOptions());
Assert.Throws <InvalidOperationException>(() => schema.CreateDefinitionSchema(contract));
}
private OpenApiSchema GenerateEnumSchema(Type enumType, JsonPrimitiveContract jsonPrimitiveContract)
{
var stringEnumConverter = (jsonPrimitiveContract.Converter as StringEnumConverter)
?? JsonSerializerSettings.Converters.OfType <StringEnumConverter>().FirstOrDefault();
if (SchemaGeneratorOptions.DescribeAllEnumsAsStrings || (stringEnumConverter != null))
{
var describeInCamelCase = SchemaGeneratorOptions.DescribeStringEnumsInCamelCase
#if NETCOREAPP3_0
|| (stringEnumConverter != null && stringEnumConverter.NamingStrategy is CamelCaseNamingStrategy);
private Schema CreateEnumSchema(JsonPrimitiveContract primitiveContract, Type type)
{
var stringEnumConverter = primitiveContract.Converter as StringEnumConverter
?? _jsonSerializerSettings.Converters.OfType <StringEnumConverter>().FirstOrDefault();
var enumDesc = new System.Text.StringBuilder();
if (_options.DescribeAllEnumsAsStrings || stringEnumConverter != null)
{
var camelCase = _options.DescribeStringEnumsInCamelCase ||
(stringEnumConverter != null && stringEnumConverter.CamelCaseText);
var enumNames = type.GetFields(BindingFlags.Public | BindingFlags.Static)
.Select(f =>
{
var name = f.Name;
var enumMemberAttribute = f.GetCustomAttributes().OfType <EnumMemberAttribute>().FirstOrDefault();
if (enumMemberAttribute != null && enumMemberAttribute.Value != null)
{
name = enumMemberAttribute.Value;
}
name = camelCase ? name.ToCamelCase() : name;
if (Attribute.GetCustomAttribute(f, typeof(DescriptionAttribute)) is DescriptionAttribute descAttr)
{
enumDesc.Append($"<br/>{name}：{descAttr.Description}");
}
return(name);
});
return(new Schema
{
Type = "string",
Description = enumDesc.ToString(),
Enum = enumNames.ToArray()
});
}
else
{
type.GetFields(BindingFlags.Public | BindingFlags.Static).ToList().ForEach(f =>
{
if (Attribute.GetCustomAttribute(f, typeof(DescriptionAttribute)) is DescriptionAttribute descAttr)
{
enumDesc.Append($"<br/>{f.GetValue(null)}：{descAttr.Description}");
}
});
return(new Schema
{
Type = "integer",
Format = "int32",
Description = enumDesc.ToString(),
Enum = Enum.GetValues(type).Cast <object>().ToArray()
});
}
}
public void CreateEnumSchema_empty()
{
var contract = new JsonPrimitiveContract(typeof(int));
var mock = new Mock <JsonSerializerSettings>();
var opt = new SwaggerGeneratorOptions();
var schema = new SchemaRegistry(mock.Object, opt);
var enu = schema.CreateEnumSchema(contract, typeof(int));
Assert.IsNotNull(enu);
}
/// <inheritdoc />
public void Handle(IJsonContractRequest request)
{
if (request.dataType.IsEnum && !Attribute.IsDefined(request.dataType, typeof(FlagsAttribute)))
{
var converter = new EnumJsonConverter(request.dataType);
var contract = new JsonPrimitiveContract(request.dataType)
{
Converter = converter
};
request.Return(contract);
}
}
// Token: 0x0600098B RID: 2443 RVA: 0x00036B98 File Offset: 0x00034D98
private void method_8(JsonWriter jsonWriter_0, object object_0, JsonPrimitiveContract jsonPrimitiveContract_0, JsonProperty jsonProperty_0, JsonContainerContract jsonContainerContract_0, JsonProperty jsonProperty_1)
{
if (jsonPrimitiveContract_0.method_5() == (Enum3)40 && this.method_36(TypeNameHandling.Objects, jsonPrimitiveContract_0, jsonProperty_0, jsonContainerContract_0, jsonProperty_1))
{
jsonWriter_0.WriteStartObject();
this.method_24(jsonWriter_0, jsonPrimitiveContract_0.CreatedType);
jsonWriter_0.WritePropertyName("$value", false);
JsonWriter.smethod_2(jsonWriter_0, jsonPrimitiveContract_0.method_5(), object_0);
jsonWriter_0.WriteEndObject();
return;
}
JsonWriter.smethod_2(jsonWriter_0, jsonPrimitiveContract_0.method_5(), object_0);
}
public void CreateEnumSchema_camelCase()
{
var contract = new JsonPrimitiveContract(typeof(int));
var mock = new Mock <JsonSerializerSettings>();
var opt = new SwaggerGeneratorOptions(
describeAllEnumsAsStrings: true,
describeStringEnumsInCamelCase: true
);
var schema = new SchemaRegistry(mock.Object, opt);
var enu = schema.CreateEnumSchema(contract, typeof(int));
Assert.IsNotNull(enu);
}
private Schema CreatePrimitiveSchema(JsonPrimitiveContract primitiveContract)
{
var type = Nullable.GetUnderlyingType(primitiveContract.UnderlyingType)
?? primitiveContract.UnderlyingType;
if (type.GetTypeInfo().IsEnum)
return CreateEnumSchema(primitiveContract, type);
if (PrimitiveTypeMap.ContainsKey(type))
return PrimitiveTypeMap[type]();
// None of the above, fallback to string
return new Schema { Type = "string" };
}
private Schema CreateEnumSchema(JsonPrimitiveContract primitiveContract, Type type)
{
var stringEnumConverter = primitiveContract.Converter as StringEnumConverter
?? _jsonSerializerSettings.Converters.OfType <StringEnumConverter>().FirstOrDefault();
var camelCase = _describeStringEnumsInCamelCase ||
(stringEnumConverter != null && stringEnumConverter.CamelCaseText);
string[] names = type.GetEnumNamesForSerialization().ToArray();
if (camelCase)
{
names = names.Select(name => name.ToCamelCase()).ToArray();
}
var textEnumSchema = new Schema
{
type = "string",
@enum = names
};
var values = type.GetEnumValues().Cast <int>().ToArray();
var intEnumSchema = new Schema
{
type = "integer",
format = "int32",
@enum = values.Cast <object>().ToArray()
};
var namesAndValuesAreSame = textEnumSchema.@enum == [email protected] <string>();
if (_describeAllEnumsAsStrings || stringEnumConverter != null)
{
if (!namesAndValuesAreSame)
{
textEnumSchema.vendorExtensions.Add("x-values", intEnumSchema.@enum);
}
return(textEnumSchema);
}
if (!namesAndValuesAreSame)
{
intEnumSchema.vendorExtensions.Add("x-names", textEnumSchema.@enum);
}
return(intEnumSchema);
}
private void method_6(JsonWriter jsonWriter_0, object object_0, JsonPrimitiveContract jsonPrimitiveContract_0, JsonProperty jsonProperty_0, JsonContainerContract jsonContainerContract_0, JsonProperty jsonProperty_1)
{
if ((jsonPrimitiveContract_0.Enum17_0 == Enum17.Bytes) && this.method_33(TypeNameHandling.Objects, jsonPrimitiveContract_0, jsonProperty_0, jsonContainerContract_0, jsonProperty_1))
{
jsonWriter_0.WriteStartObject();
this.method_21(jsonWriter_0, jsonPrimitiveContract_0.CreatedType);
jsonWriter_0.WritePropertyName("$value", false);
JsonWriter.smethod_3(jsonWriter_0, jsonPrimitiveContract_0.Enum17_0, object_0);
jsonWriter_0.WriteEndObject();
}
else
{
JsonWriter.smethod_3(jsonWriter_0, jsonPrimitiveContract_0.Enum17_0, object_0);
}
}
private Schema CreatePrimitiveSchema(JsonPrimitiveContract primitiveContract)
{
Type index = primitiveContract.UnderlyingType.IsNullable()
? Nullable.GetUnderlyingType(primitiveContract.UnderlyingType)
: primitiveContract.UnderlyingType;
if (index.GetTypeInfo().IsEnum)
{
return(this.CreateEnumSchema(primitiveContract, index));
}
if (AsyncApiSchemaRegistry.PrimitiveTypeMap.ContainsKey(index))
{
return(AsyncApiSchemaRegistry.PrimitiveTypeMap[index]());
}
return(new Schema()
{
Type = "string"
});
}
private OpenApiSchema CreateEnumSchema(JsonPrimitiveContract primitiveContract, Type type)
{
var stringEnumConverter = primitiveContract.Converter as StringEnumConverter
?? _jsonSerializerSettings.Converters.OfType <StringEnumConverter>().FirstOrDefault();
if (_options.DescribeAllEnumsAsStrings || stringEnumConverter != null)
{
var camelCase = _options.DescribeStringEnumsInCamelCase ||
(stringEnumConverter != null && stringEnumConverter.CamelCaseText);
var enumNames = type.GetFields(BindingFlags.Public | BindingFlags.Static)
.Select(f =>
{
var name = f.Name;
var enumMemberAttribute = f.GetCustomAttributes().OfType <EnumMemberAttribute>().FirstOrDefault();
if (enumMemberAttribute != null && enumMemberAttribute.Value != null)
{
name = enumMemberAttribute.Value;
}
return(camelCase ? name.ToCamelCase() : name);
});
return(new OpenApiSchema
{
Type = "string",
Enum = enumNames
.Select(name => new OpenApiString(name))
.ToList <IOpenApiAny>()
});
}
return(new OpenApiSchema
{
Type = "integer",
Format = "int32",
Enum = Enum.GetValues(type).Cast <int>()
.Select(value => new OpenApiInteger(value))
.ToList <IOpenApiAny>()
});
}
private OpenApiSchema GenerateEnumSchema(JsonPrimitiveContract jsonPrimitiveContract)
{
var stringEnumConverter = (jsonPrimitiveContract.Converter as StringEnumConverter)
?? _serializerSettings.Converters.OfType <StringEnumConverter>().FirstOrDefault();
var describeAsString = Options.DescribeAllEnumsAsStrings ||
(stringEnumConverter != null);
var describeInCamelCase = Options.DescribeStringEnumsInCamelCase ||
(stringEnumConverter != null && stringEnumConverter.CamelCaseText);
var enumType = jsonPrimitiveContract.UnderlyingType;
var enumUnderlyingType = describeAsString ? typeof(string) : enumType.GetEnumUnderlyingType();
var schema = FactoryMethodMap[enumUnderlyingType]();
if (describeAsString)
{
schema.Enum = enumType.GetEnumNames()
.Distinct()
.Select(name =>
{
name = describeInCamelCase ? name.ToCamelCase() : name;
return((IOpenApiAny)(new OpenApiString(name)));
})
.ToList();
}
else
{
schema.Enum = enumType.GetEnumValues()
.Cast <object>()
.Distinct()
.Select(value =>
{
value = Convert.ChangeType(value, enumUnderlyingType);
return(OpenApiAnyFactory.TryCreateFor(schema, value, out IOpenApiAny openApiAny) ? openApiAny : null);
})
.ToList();
}
return(schema);
}
private Schema CreateEnumSchema(JsonPrimitiveContract primitiveContract, Type type)
{
StringEnumConverter stringEnumConverter = primitiveContract.Converter as StringEnumConverter ??
this._jsonSerializerSettings.Converters
.OfType <StringEnumConverter>()
.FirstOrDefault <StringEnumConverter>();
if (this._options.DescribeAllEnumsAsStrings || stringEnumConverter != null)
{
bool camelCase = this._options.DescribeStringEnumsInCamelCase ||
stringEnumConverter != null && stringEnumConverter.CamelCaseText;
IEnumerable <string> source =
((IEnumerable <FieldInfo>)type.GetFields(BindingFlags.Static | BindingFlags.Public))
.Select <FieldInfo, string>((Func <FieldInfo, string>)(f =>
{
string name = f.Name;
EnumMemberAttribute enumMemberAttribute = f.GetCustomAttributes().OfType <EnumMemberAttribute>()
.FirstOrDefault <EnumMemberAttribute>();
if (enumMemberAttribute != null && enumMemberAttribute.Value != null)
{
name = enumMemberAttribute.Value;
}
if (!camelCase)
{
return(name);
}
return(name.ToCamelCase());
}));
return(new Schema()
{
Type = "string",
Enum = source.ToArray()
});
}
return(new Schema()
{
Type = "integer",
Format = "int32",
Enum = (IList <object>)Enum.GetValues(type).Cast <object>().ToArray <object>()
});
}
private Schema CreateEnumSchema(JsonPrimitiveContract primitiveContract, Type type)
{
StringEnumConverter stringEnumConverter = ((JsonContract)primitiveContract).get_Converter() as StringEnumConverter ?? ((IEnumerable)this._jsonSerializerSettings.get_Converters()).OfType <StringEnumConverter>().FirstOrDefault <StringEnumConverter>();
if (this._describeAllEnumsAsStrings || stringEnumConverter != null)
{
bool flag = this._describeStringEnumsInCamelCase || stringEnumConverter != null && stringEnumConverter.get_CamelCaseText();
return(new Schema()
{
type = "string",
@enum = flag ? (IList <object>)((IEnumerable <string>)type.GetEnumNamesForSerialization()).Select <string, string>((Func <string, string>)(name => name.ToCamelCase())).ToArray <string>() : (IList <object>)type.GetEnumNamesForSerialization()
});
}
return(new Schema()
{
type = "integer",
format = "int32",
@enum = (IList <object>)type.GetEnumValues().Cast <object>().ToArray <object>()
});
}
private ApiModel ResolveApiPrimitive(JsonPrimitiveContract jsonPrimitiveContract)
{
var type = jsonPrimitiveContract.UnderlyingType;
if (!type.IsEnum)
{
return(new ApiPrimitive(type));
}
var stringEnumConverter = (jsonPrimitiveContract.Converter as StringEnumConverter)
?? _jsonSerializerSettings.Converters.OfType <StringEnumConverter>().FirstOrDefault();
// Temporary shim to support obsolete config options
if (stringEnumConverter == null && _options.DescribeAllEnumsAsStrings)
{
stringEnumConverter = new StringEnumConverter(_options.DescribeStringEnumsInCamelCase);
}
;
if (stringEnumConverter == null)
{
return(new ApiPrimitive(
type: type,
isStringEnum: false,
apiEnumValues: type.GetEnumValues().Cast <object>()));
}
var enumValues = type.GetFields(BindingFlags.Public | BindingFlags.Static)
.Select(field =>
{
var enumMemberAttribute = field.GetCustomAttributes <EnumMemberAttribute>().FirstOrDefault();
var memberName = enumMemberAttribute?.Value ?? field.Name;
return(GetConvertedEnumName(memberName, stringEnumConverter));
})
.Distinct();
return(new ApiPrimitive(
type: type,
isStringEnum: true,
apiEnumValues: enumValues));
}
private void SerializePrimitive(JsonWriter writer, object value, JsonPrimitiveContract contract, JsonProperty member, JsonContainerContract containerContract, JsonProperty containerProperty)
{
if (contract.TypeCode == PrimitiveTypeCode.Bytes)
{
// if type name handling is enabled then wrap the base64 byte string in an object with the type name
bool includeTypeDetails = ShouldWriteType(TypeNameHandling.Objects, contract, member, containerContract, containerProperty);
if (includeTypeDetails)
{
writer.WriteStartObject();
WriteTypeProperty(writer, contract.CreatedType);
writer.WritePropertyName(JsonTypeReflector.ValuePropertyName, false);
JsonWriter.WriteValue(writer, contract.TypeCode, value);
writer.WriteEndObject();
return;
}
}
JsonWriter.WriteValue(writer, contract.TypeCode, value);
}
private Schema CreatePrimitiveSchema(JsonPrimitiveContract primitiveContract)
{
// If Nullable<T>, use the type argument
var type = primitiveContract.UnderlyingType.IsNullable()
? Nullable.GetUnderlyingType(primitiveContract.UnderlyingType)
: primitiveContract.UnderlyingType;
if (type.GetTypeInfo().IsEnum)
{
return(CreateEnumSchema(primitiveContract, type));
}
if (PrimitiveTypeMap.ContainsKey(type))
{
return(PrimitiveTypeMap[type]());
}
// None of the above, fallback to string
return(new Schema {
Type = "string"
});
}
private Schema CreatePrimitiveSchema(JsonPrimitiveContract primitiveContract)
{
var type = Nullable.GetUnderlyingType(primitiveContract.UnderlyingType) ?? primitiveContract.UnderlyingType;
if (type.IsEnum)
{
var converter = primitiveContract.Converter;
var describeAsString = _describeAllEnumsAsStrings ||
(converter != null && converter.GetType() == typeof(StringEnumConverter));
return(describeAsString
? new Schema {
type = "string", @enum = type.GetEnumNames()
}
: new Schema {
type = "integer", format = "int32", @enum = type.GetEnumValues().Cast <object>().ToArray()
});
}
switch (type.FullName)
{
case "System.Int16":
case "System.UInt16":
case "System.Int32":
case "System.UInt32":
return(new Schema {
type = "integer", format = "int32"
});
case "System.Int64":
case "System.UInt64":
return(new Schema {
type = "integer", format = "int64"
});
case "System.Single":
return(new Schema {
type = "number", format = "float"
});
case "System.Double":
case "System.Decimal":
return(new Schema {
type = "number", format = "double"
});
case "System.Byte":
case "System.SByte":
return(new Schema {
type = "string", format = "byte"
});
case "System.Boolean":
return(new Schema {
type = "boolean"
});
case "System.DateTime":
case "System.DateTimeOffset":
return(new Schema {
type = "string", format = "date-time"
});
default:
return(new Schema {
type = "string"
});
}
}
private Schema CreatePrimitiveSchema(JsonPrimitiveContract primitiveContract)
{
Schema schema;
if (primitiveContract.PropertyInfo() != null && primitiveContract.PropertyInfo().CustomAttributes != null)
{
//var isIgnored = primitiveContract.PropertyInfo().CustomAttributes.FirstOrDefault(x => x.AttributeType == typeof(SwaggerIgnore));
var isIgnored = primitiveContract.PropertyInfo().GetCustomAttribute <SwaggerIgnore>();
if (isIgnored != null)
{
return(null);
}
//var customRouteName = primitiveContract.PropertyInfo().GetCustomAttribute<SwaggerRouteName>();
//if (customRouteName != null)
//{
// //
//}
}
var type = Nullable.GetUnderlyingType(primitiveContract.UnderlyingType) ?? primitiveContract.UnderlyingType;
if (type.IsEnum)
{
return(CreateEnumSchema(primitiveContract, type));
}
switch (type.FullName)
{
case "System.Int16":
case "System.UInt16":
case "System.Int32":
case "System.UInt32":
schema = new Schema {
type = "integer", format = "int32"
};
break;
case "System.Int64":
case "System.UInt64":
schema = new Schema {
type = "integer", format = "int64"
};
break;
case "System.Single":
schema = new Schema {
type = "number", format = "float"
};
break;
case "System.Double":
case "System.Decimal":
schema = new Schema {
type = "number", format = "double"
};
break;
case "System.Byte":
case "System.SByte":
schema = new Schema {
type = "string", format = "byte"
};
break;
case "System.Boolean":
schema = new Schema {
type = "boolean"
};
break;
case "System.DateTime":
case "System.DateTimeOffset":
schema = new Schema {
type = "string", format = "date-time"
};
break;
default:
schema = new Schema {
type = "string"
};
break;
}
schema.WithValidationProperties(primitiveContract);
return(schema);
}
private Schema CreatePrimitiveSchema(JsonPrimitiveContract primitiveContract)
{
Type underlyingType = Nullable.GetUnderlyingType(((JsonContract)primitiveContract).get_UnderlyingType());
if ((object)underlyingType == null)
{
underlyingType = ((JsonContract)primitiveContract).get_UnderlyingType();
}
Type type = underlyingType;
if (type.IsEnum)
{
return(this.CreateEnumSchema(primitiveContract, type));
}
switch (type.FullName)
{
case "System.Boolean":
return(new Schema()
{
type = "boolean"
});
case "System.Byte":
case "System.SByte":
case "System.Int16":
case "System.UInt16":
case "System.Int32":
case "System.UInt32":
return(new Schema()
{
type = "integer",
format = "int32"
});
case "System.Int64":
case "System.UInt64":
return(new Schema()
{
type = "integer",
format = "int64"
});
case "System.Single":
return(new Schema()
{
type = "number",
format = "float"
});
case "System.Double":
case "System.Decimal":
return(new Schema()
{
type = "number",
format = "double"
});
case "System.Byte[]":
return(new Schema()
{
type = "string",
format = "byte"
});
case "System.DateTime":
case "System.DateTimeOffset":
return(new Schema()
{
type = "string",
format = "date-time"
});
case "System.Guid":
return(new Schema()
{
type = "string",
format = "uuid",
example = (object)Guid.Empty
});
default:
return(new Schema()
{
type = "string"
});
}
}
// Token: 0x060009AA RID: 2474 RVA: 0x00038324 File Offset: 0x00036524
private string method_38(JsonWriter jsonWriter_0, object object_0, JsonContract jsonContract_0, out bool bool_0)
{
if (jsonContract_0.enum8_0 == (Enum8)3)
{
JsonPrimitiveContract jsonPrimitiveContract = (JsonPrimitiveContract)jsonContract_0;
switch (jsonPrimitiveContract.method_5())
{
case (Enum3)22:
case (Enum3)23:
{
float num = (float)object_0;
bool_0 = false;
return(num.ToString("R", CultureInfo.InvariantCulture));
}
case (Enum3)24:
case (Enum3)25:
{
double num2 = (double)object_0;
bool_0 = false;
return(num2.ToString("R", CultureInfo.InvariantCulture));
}
case (Enum3)26:
case (Enum3)27:
{
DateTime dateTime_ = Class25.smethod_2((DateTime)object_0, jsonWriter_0.DateTimeZoneHandling);
bool_0 = false;
StringWriter stringWriter = new StringWriter(CultureInfo.InvariantCulture);
Class25.smethod_24(stringWriter, dateTime_, jsonWriter_0.DateFormatHandling, jsonWriter_0.DateFormatString, jsonWriter_0.Culture);
return(stringWriter.ToString());
}
case (Enum3)28:
case (Enum3)29:
{
bool_0 = false;
StringWriter stringWriter2 = new StringWriter(CultureInfo.InvariantCulture);
Class25.IxisRjgvuh(stringWriter2, (DateTimeOffset)object_0, jsonWriter_0.DateFormatHandling, jsonWriter_0.DateFormatString, jsonWriter_0.Culture);
return(stringWriter2.ToString());
}
default:
{
bool_0 = true;
string result;
if (jsonPrimitiveContract.bool_2 && Class53.smethod_3(jsonPrimitiveContract.type_0, object_0, null, out result))
{
return(result);
}
return(Convert.ToString(object_0, CultureInfo.InvariantCulture));
}
}
}
else
{
string result2;
if (Class119.smethod_0(object_0, object_0.GetType(), out result2))
{
bool_0 = true;
return(result2);
}
bool_0 = true;
return(object_0.ToString());
}
}