protected virtual JsonPrimitiveContract CreatePrimitiveContract(Type objectType)
{
JsonPrimitiveContract jsonPrimitiveContract = new JsonPrimitiveContract(objectType);
this.InitializeContract(jsonPrimitiveContract);
return(jsonPrimitiveContract);
}
private string GetPropertyName(JsonWriter writer, object name, JsonContract contract, out bool escape)
{
string propertyName;
if (contract.ContractType == JsonContractType.Primitive)
{
JsonPrimitiveContract primitiveContract = (JsonPrimitiveContract)contract;
if (primitiveContract.TypeCode == PrimitiveTypeCode.DateTime || primitiveContract.TypeCode == PrimitiveTypeCode.DateTimeNullable)
{
escape = false;
StringWriter sw = new StringWriter(CultureInfo.InvariantCulture);
DateTimeUtils.WriteDateTimeString(sw, (DateTime)name, writer.DateFormatHandling, writer.DateFormatString, writer.Culture);
return(sw.ToString());
}
else
{
escape = true;
return(Convert.ToString(name, CultureInfo.InvariantCulture));
}
}
else if (TryConvertToString(name, name.GetType(), out propertyName))
{
escape = true;
return(propertyName);
}
else
{
escape = true;
return(name.ToString());
}
}
private string GetPropertyName(JsonWriter writer, object name, JsonContract contract, out bool escape)
{
if (contract.ContractType == JsonContractType.Primitive)
{
JsonPrimitiveContract jsonPrimitiveContract = (JsonPrimitiveContract)contract;
if (jsonPrimitiveContract.TypeCode == PrimitiveTypeCode.DateTime || jsonPrimitiveContract.TypeCode == PrimitiveTypeCode.DateTimeNullable)
{
escape = false;
StringWriter stringWriter = new StringWriter(CultureInfo.InvariantCulture);
DateTimeUtils.WriteDateTimeString(stringWriter, (DateTime)name, writer.DateFormatHandling, writer.DateFormatString, writer.Culture);
return(stringWriter.ToString());
}
if (jsonPrimitiveContract.TypeCode == PrimitiveTypeCode.DateTimeOffset || jsonPrimitiveContract.TypeCode == PrimitiveTypeCode.DateTimeOffsetNullable)
{
escape = false;
StringWriter stringWriter2 = new StringWriter(CultureInfo.InvariantCulture);
DateTimeUtils.WriteDateTimeOffsetString(stringWriter2, (DateTimeOffset)name, writer.DateFormatHandling, writer.DateFormatString, writer.Culture);
return(stringWriter2.ToString());
}
escape = true;
return(Convert.ToString(name, CultureInfo.InvariantCulture));
}
else
{
string result;
if (JsonSerializerInternalWriter.TryConvertToString(name, name.GetType(), out result))
{
escape = true;
return(result);
}
escape = true;
return(name.ToString());
}
}
protected virtual JsonPrimitiveContract CreatePrimitiveContract(Type objectType)
{
JsonPrimitiveContract contract = new JsonPrimitiveContract(objectType);
this.method_7(contract);
return(contract);
}
private void SerializePrimitive(JsonWriter writer, object value, JsonPrimitiveContract contract, JsonProperty member, JsonContainerContract containerContract, JsonProperty containerProperty)
{
if (contract.UnderlyingType == typeof(byte[]))
{
bool includeTypeDetails = ShouldWriteType(TypeNameHandling.Objects, contract, member, containerContract, containerProperty);
if (includeTypeDetails)
{
writer.WriteStartObject();
WriteTypeProperty(writer, contract.CreatedType);
writer.WritePropertyName(JsonTypeReflector.ValuePropertyName);
if (contract.IsNullable)
{
writer.WriteValue(value, true);
}
else
{
writer.WriteValue(value);
}
writer.WriteEndObject();
return;
}
}
if (contract.IsNullable)
{
writer.WriteValue(value, true);
}
else
{
writer.WriteValue(value);
}
}
private void SerializePrimitive(JsonWriter writer, object value, JsonPrimitiveContract contract, JsonProperty member, JsonContainerContract containerContract, JsonProperty containerProperty)
{
if (contract.UnderlyingType == typeof (byte[]))
{
bool includeTypeDetails = ShouldWriteType(TypeNameHandling.Objects, contract, member, containerContract, containerProperty);
if (includeTypeDetails)
{
writer.WriteStartObject();
WriteTypeProperty(writer, contract.CreatedType);
writer.WritePropertyName(JsonTypeReflector.ValuePropertyName);
if (contract.IsNullable)
writer.WriteValue(value, true);
else
writer.WriteValue(value);
writer.WriteEndObject();
return;
}
}
if (contract.IsNullable)
writer.WriteValue(value, true);
else
writer.WriteValue(value);
}
private void SerializePrimitive(JsonWriter writer, object value, JsonPrimitiveContract contract, JsonProperty member, JsonContainerContract containerContract, JsonProperty containerProperty)
{
if (contract.UnderlyingType == typeof (byte[]) && this.ShouldWriteType(TypeNameHandling.Objects, (JsonContract) contract, member, containerContract, containerProperty))
{
writer.WriteStartObject();
this.WriteTypeProperty(writer, contract.CreatedType);
writer.WritePropertyName("$value");
writer.WriteValue(value);
writer.WriteEndObject();
}
else
writer.WriteValue(value);
}
private void SerializePrimitive(JsonWriter writer, object value, JsonPrimitiveContract contract, JsonProperty member, JsonContract collectionValueContract)
{
if (contract.UnderlyingType != typeof(byte[]) || !this.ShouldWriteType(TypeNameHandling.Objects, contract, member, collectionValueContract))
{
writer.WriteValue(value);
return;
}
writer.WriteStartObject();
this.WriteTypeProperty(writer, contract.CreatedType);
writer.WritePropertyName("$value");
writer.WriteValue(value);
writer.WriteEndObject();
}
private void SerializePrimitive(JsonWriter writer, object value, JsonPrimitiveContract contract, JsonProperty member, JsonContainerContract containerContract, JsonProperty containerProperty)
{
if (contract.TypeCode != PrimitiveTypeCode.Bytes || !this.ShouldWriteType(TypeNameHandling.Objects, contract, member, containerContract, containerProperty))
{
JsonWriter.WriteValue(writer, contract.TypeCode, value);
return;
}
writer.WriteStartObject();
this.WriteTypeProperty(writer, contract.CreatedType);
writer.WritePropertyName("$value", false);
JsonWriter.WriteValue(writer, contract.TypeCode, value);
writer.WriteEndObject();
}
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 void SerializePrimitive(JsonWriter writer, object value, JsonPrimitiveContract contract, JsonProperty member, JsonContainerContract containerContract, JsonProperty containerProperty)
{
if (contract.UnderlyingType == typeof(byte[]) && this.ShouldWriteType(TypeNameHandling.Objects, (JsonContract)contract, member, containerContract, containerProperty))
{
writer.WriteStartObject();
this.WriteTypeProperty(writer, contract.CreatedType);
writer.WritePropertyName("$value");
writer.WriteValue(value);
writer.WriteEndObject();
}
else
{
writer.WriteValue(value);
}
}
private string GetPropertyName(JsonWriter writer, DictionaryEntry entry, JsonContract contract, out bool escape)
{
object key = entry.Key;
string propertyName;
JsonPrimitiveContract primitiveContract = contract as JsonPrimitiveContract;
if (primitiveContract != null)
{
if (primitiveContract.TypeCode == PrimitiveTypeCode.DateTime || primitiveContract.TypeCode == PrimitiveTypeCode.DateTimeNullable)
{
escape = false;
StringWriter sw = new StringWriter(CultureInfo.InvariantCulture);
DateTimeUtils.WriteDateTimeString(sw, (DateTime)key, writer.DateFormatHandling, writer.DateFormatString, writer.Culture);
return(sw.ToString());
}
#if !NET20
else if (primitiveContract.TypeCode == PrimitiveTypeCode.DateTimeOffset || primitiveContract.TypeCode == PrimitiveTypeCode.DateTimeOffsetNullable)
{
escape = false;
StringWriter sw = new StringWriter(CultureInfo.InvariantCulture);
DateTimeUtils.WriteDateTimeOffsetString(sw, (DateTimeOffset)key, writer.DateFormatHandling, writer.DateFormatString, writer.Culture);
return(sw.ToString());
}
#endif
else
{
escape = true;
return(Convert.ToString(key, CultureInfo.InvariantCulture));
}
}
else if (TryConvertToString(key, key.GetType(), out propertyName))
{
escape = true;
return(propertyName);
}
else
{
escape = true;
return(key.ToString());
}
}
public void TryGetItemSerializationInfo_should_throw_when_contract_has_a_converter()
{
var wrappedSerializer = new Newtonsoft.Json.JsonSerializer();
var intContract = new Newtonsoft.Json.Serialization.JsonPrimitiveContract(typeof(int))
{
Converter = Substitute.For<Newtonsoft.Json.JsonConverter>()
};
wrappedSerializer.ContractResolver = new DictionaryContractResolver(
new Dictionary<Type, JsonContract>
{
{ typeof(int), intContract }
});
var subject = new JsonDotNetSerializer<int[]>(wrappedSerializer);
BsonSerializationInfo info;
Action action = () => subject.TryGetItemSerializationInfo(out info);
action.ShouldThrow<BsonSerializationException>().And.Message.Contains("has a Converter");
}
public void TryGetItemSerializationInfo_should_throw_when_contract_has_a_converter()
{
var wrappedSerializer = new Newtonsoft.Json.JsonSerializer();
var intContract = new Newtonsoft.Json.Serialization.JsonPrimitiveContract(typeof(int))
{
Converter = Substitute.For <Newtonsoft.Json.JsonConverter>()
};
wrappedSerializer.ContractResolver = new DictionaryContractResolver(
new Dictionary <Type, JsonContract>
{
{ typeof(int), intContract }
});
var subject = new JsonSerializerAdapter <int[]>(wrappedSerializer);
BsonSerializationInfo info;
Action action = () => subject.TryGetItemSerializationInfo(out info);
action.ShouldThrow <BsonSerializationException>().And.Message.Contains("has a Converter");
}
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 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 string GetPropertyName(
JsonWriter writer,
object name,
JsonContract contract,
out bool escape)
{
if (contract.ContractType == JsonContractType.Primitive)
{
JsonPrimitiveContract primitiveContract = (JsonPrimitiveContract)contract;
if (primitiveContract.TypeCode == PrimitiveTypeCode.DateTime || primitiveContract.TypeCode == PrimitiveTypeCode.DateTimeNullable)
{
DateTime dateTime = DateTimeUtils.EnsureDateTime((DateTime)name, writer.DateTimeZoneHandling);
escape = false;
StringWriter stringWriter = new StringWriter((IFormatProvider)CultureInfo.InvariantCulture);
DateTimeUtils.WriteDateTimeString((TextWriter)stringWriter, dateTime, writer.DateFormatHandling, writer.DateFormatString, writer.Culture);
return(stringWriter.ToString());
}
if (primitiveContract.TypeCode == PrimitiveTypeCode.DateTimeOffset || primitiveContract.TypeCode == PrimitiveTypeCode.DateTimeOffsetNullable)
{
escape = false;
StringWriter stringWriter = new StringWriter((IFormatProvider)CultureInfo.InvariantCulture);
DateTimeUtils.WriteDateTimeOffsetString((TextWriter)stringWriter, (DateTimeOffset)name, writer.DateFormatHandling, writer.DateFormatString, writer.Culture);
return(stringWriter.ToString());
}
escape = true;
return(Convert.ToString(name, (IFormatProvider)CultureInfo.InvariantCulture));
}
string s;
if (JsonSerializerInternalWriter.TryConvertToString(name, name.GetType(), out s))
{
escape = true;
return(s);
}
escape = true;
return(name.ToString());
}
private Schema CreateEnumSchema(JsonPrimitiveContract primitiveContract, Type type)
{
var stringEnumConverter = primitiveContract.Converter as StringEnumConverter
?? _jsonSerializerSettings.Converters.OfType<StringEnumConverter>().FirstOrDefault();
if (_describeAllEnumsAsStrings || stringEnumConverter != null || _autoRestEnumSupport != null)
{
var camelCase = _describeStringEnumsInCamelCase
|| (stringEnumConverter != null && stringEnumConverter.CamelCaseText);
return new Schema
{
type = "string",
@enum = camelCase
? type.GetEnumNamesForSerialization().Select(name => name.ToCamelCase()).ToArray()
: type.GetEnumNamesForSerialization(),
xmsenum = _autoRestEnumSupport != null ? new MSEnumExtension
{
name = type.Name,
modelAsString = _autoRestEnumSupport == AutoRestEnumSupportType.StaticStrings,
} : null
};
}
return new Schema
{
type = "integer",
format = "int32",
@enum = type.GetEnumValues().Cast<object>().ToArray()
};
}
// Token: 0x06000BEE RID: 3054
// RVA: 0x000466EC File Offset: 0x000448EC
private void SerializePrimitive(JsonWriter writer, object value, JsonPrimitiveContract contract, JsonProperty member, JsonContainerContract containerContract, JsonProperty containerProperty)
{
if (contract.TypeCode == PrimitiveTypeCode.Bytes && this.ShouldWriteType(TypeNameHandling.Objects, contract, member, containerContract, containerProperty))
{
writer.WriteStartObject();
this.WriteTypeProperty(writer, contract.CreatedType);
writer.WritePropertyName("$value", false);
JsonWriter.WriteValue(writer, contract.TypeCode, value);
writer.WriteEndObject();
return;
}
JsonWriter.WriteValue(writer, contract.TypeCode, value);
}
/// <summary>
/// Creates a <see cref="JsonPrimitiveContract"/> for the given type.
/// </summary>
/// <param name="objectType">Type of the object.</param>
/// <returns>A <see cref="JsonPrimitiveContract"/> for the given type.</returns>
protected virtual JsonPrimitiveContract CreatePrimitiveContract(Type objectType)
{
JsonPrimitiveContract contract = new JsonPrimitiveContract(objectType);
InitializeContract(contract);
return contract;
}
protected virtual JsonPrimitiveContract CreatePrimitiveContract(Type objectType)
{
JsonPrimitiveContract primitiveContract = new JsonPrimitiveContract(objectType);
this.InitializeContract((JsonContract) primitiveContract);
return primitiveContract;
}
private string GetPropertyName(JsonWriter writer, object name, JsonContract contract, out bool escape)
{
if (contract.ContractType == JsonContractType.Primitive)
{
JsonPrimitiveContract primitiveContract = (JsonPrimitiveContract)contract;
switch (primitiveContract.TypeCode)
{
case PrimitiveTypeCode.DateTime:
case PrimitiveTypeCode.DateTimeNullable:
{
DateTime dt = DateTimeUtils.EnsureDateTime((DateTime)name, writer.DateTimeZoneHandling);
escape = false;
StringWriter sw = new StringWriter(CultureInfo.InvariantCulture);
DateTimeUtils.WriteDateTimeString(sw, dt, writer.DateFormatHandling, writer.DateFormatString, writer.Culture);
return(sw.ToString());
}
#if HAVE_DATE_TIME_OFFSET
case PrimitiveTypeCode.DateTimeOffset:
case PrimitiveTypeCode.DateTimeOffsetNullable:
{
escape = false;
StringWriter sw = new StringWriter(CultureInfo.InvariantCulture);
DateTimeUtils.WriteDateTimeOffsetString(sw, (DateTimeOffset)name, writer.DateFormatHandling, writer.DateFormatString, writer.Culture);
return(sw.ToString());
}
#endif
case PrimitiveTypeCode.Double:
case PrimitiveTypeCode.DoubleNullable:
{
double d = (double)name;
escape = false;
return(d.ToString("R", CultureInfo.InvariantCulture));
}
case PrimitiveTypeCode.Single:
case PrimitiveTypeCode.SingleNullable:
{
float f = (float)name;
escape = false;
return(f.ToString("R", CultureInfo.InvariantCulture));
}
default:
{
escape = true;
if (primitiveContract.IsEnum && EnumUtils.TryToString(primitiveContract.NonNullableUnderlyingType, name, null, out string enumName))
{
return(enumName);
}
return(Convert.ToString(name, CultureInfo.InvariantCulture));
}
}
}
else if (TryConvertToString(name, name.GetType(), out string propertyName))
{
escape = true;
return(propertyName);
}
else
{
escape = true;
return(name.ToString());
}
}
private object CreateObject(JsonReader reader, Type objectType, JsonContract contract, JsonProperty member, object existingValue)
{
CheckedRead(reader);
string text = null;
if (reader.TokenType == JsonToken.PropertyName)
{
bool flag;
do
{
string a = reader.Value.ToString();
if (string.Equals(a, "$ref", StringComparison.Ordinal))
{
CheckedRead(reader);
if (reader.TokenType != JsonToken.String && reader.TokenType != JsonToken.Null)
{
throw new JsonSerializationException("JSON reference {0} property must have a string or null value.".FormatWith(CultureInfo.InvariantCulture, "$ref"));
}
string text2 = ((reader.Value != null) ? reader.Value.ToString() : null);
CheckedRead(reader);
if (text2 != null)
{
if (reader.TokenType == JsonToken.PropertyName)
{
throw new JsonSerializationException("Additional content found in JSON reference object. A JSON reference object should only have a {0} property.".FormatWith(CultureInfo.InvariantCulture, "$ref"));
}
return(base.Serializer.ReferenceResolver.ResolveReference(this, text2));
}
flag = true;
}
else if (string.Equals(a, "$type", StringComparison.Ordinal))
{
CheckedRead(reader);
string text3 = reader.Value.ToString();
CheckedRead(reader);
if ((member?.TypeNameHandling ?? base.Serializer.TypeNameHandling) != 0)
{
ReflectionUtils.SplitFullyQualifiedTypeName(text3, out var typeName, out var assemblyName);
Type type;
try
{
type = base.Serializer.Binder.BindToType(assemblyName, typeName);
}
catch (Exception innerException)
{
throw new JsonSerializationException("Error resolving type specified in JSON '{0}'.".FormatWith(CultureInfo.InvariantCulture, text3), innerException);
}
if (type == null)
{
throw new JsonSerializationException("Type specified in JSON '{0}' was not resolved.".FormatWith(CultureInfo.InvariantCulture, text3));
}
if (!(objectType?.IsAssignableFrom(type) ?? true))
{
throw new JsonSerializationException("Type specified in JSON '{0}' is not compatible with '{1}'.".FormatWith(CultureInfo.InvariantCulture, type.AssemblyQualifiedName, objectType.AssemblyQualifiedName));
}
objectType = type;
contract = GetContractSafe(type);
}
flag = true;
}
else if (string.Equals(a, "$id", StringComparison.Ordinal))
{
CheckedRead(reader);
text = ((reader.Value != null) ? reader.Value.ToString() : null);
CheckedRead(reader);
flag = true;
}
else
{
if (string.Equals(a, "$values", StringComparison.Ordinal))
{
CheckedRead(reader);
object result = CreateList(reader, objectType, contract, member, existingValue, text);
CheckedRead(reader);
return(result);
}
flag = false;
}
}while (flag && reader.TokenType == JsonToken.PropertyName);
}
if (!HasDefinedType(objectType))
{
return(CreateJObject(reader));
}
if (contract == null)
{
throw new JsonSerializationException("Could not resolve type '{0}' to a JsonContract.".FormatWith(CultureInfo.InvariantCulture, objectType));
}
JsonDictionaryContract jsonDictionaryContract = contract as JsonDictionaryContract;
if (jsonDictionaryContract != null)
{
if (existingValue == null)
{
return(CreateAndPopulateDictionary(reader, jsonDictionaryContract, text));
}
return(PopulateDictionary(jsonDictionaryContract.CreateWrapper(existingValue), reader, jsonDictionaryContract, text));
}
JsonObjectContract jsonObjectContract = contract as JsonObjectContract;
if (jsonObjectContract != null)
{
if (existingValue == null)
{
return(CreateAndPopulateObject(reader, jsonObjectContract, text));
}
return(PopulateObject(existingValue, reader, jsonObjectContract, text));
}
JsonPrimitiveContract jsonPrimitiveContract = contract as JsonPrimitiveContract;
if (jsonPrimitiveContract != null && reader.TokenType == JsonToken.PropertyName && string.Equals(reader.Value.ToString(), "$value", StringComparison.Ordinal))
{
CheckedRead(reader);
object result2 = CreateValueInternal(reader, objectType, jsonPrimitiveContract, member, existingValue);
CheckedRead(reader);
return(result2);
}
JsonISerializableContract jsonISerializableContract = contract as JsonISerializableContract;
if (jsonISerializableContract != null)
{
return(CreateISerializable(reader, jsonISerializableContract, text));
}
throw new JsonSerializationException("Cannot deserialize JSON object into type '{0}'.".FormatWith(CultureInfo.InvariantCulture, objectType));
}
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.GetEnumNames().Select(name => name.ToCamelCase()).ToArray()
: type.GetEnumNames()
};
}
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)
{
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)
{
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" };
}
}
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;
}
