public void Casing(JsonNamingStrategy strategy)
{
var settings = new JsonSettings
{
NamingStrategy = strategy
};
var obj = new
{
Name = "John",
Age = 33,
BirthDate = new DateTime(2000, 01, 01),
Dictionary = new Dictionary <String, String>
{
["SomeProperty"] = "Test",
["AnotherOneBytesTheDust"] = "Another One Bytes the Dust"
}
};
var json = JsonConvert.Serialize(obj, settings: settings);
var deserialized = JsonConvert.DeserializeAnonymous(json, obj, settings);
Assert.Equal(obj.Name, deserialized.Name);
Assert.Equal(obj.Age, deserialized.Age);
Assert.Equal(obj.BirthDate, deserialized.BirthDate);
Assert.Equal(obj.Dictionary, deserialized.Dictionary);
}
public static async Task <T> ReadAsJsonAsync <T>(this HttpContent content,
JsonNamingStrategy namingStrategy = JsonNamingStrategy.Default)
{
var stringContent = await content.ReadAsStringAsync();
return(NewtonsoftJsonSerializer.Create(namingStrategy).Deserialize <T>(stringContent));
}
public async Task <SheetValidationResult> Validate(string url, int sheetIndex = 0,
JsonNamingStrategy jsonNamingStrategy = JsonNamingStrategy.None,
string[] headerMap = null, bool ignoreFirstRow = true)
{
loaded = true;
ignoreFirst = ignoreFirstRow;
namingStrategy = jsonNamingStrategy;
map = headerMap;
var sheet = await reader.LoadSheet(url, sheetIndex, map);
if (sheet == null)
{
return(SheetValidationResult.SheetNotPresent());
}
var request = new SheetOnTypeParseRequest
{
MappingOptions = new SheetMappingOptions
{
Ignore = ignoreFirst,
Map = headerMap,
IndexAsId = true
},
NamingStrategy = namingStrategy,
RootType = typeof(T),
Sheet = sheet
};
sheetValidationResult = await sheetValidator.Validate(request);
return(sheetValidationResult);
}
public static NewtonsoftJsonSerializer Create(JsonNamingStrategy namingStrategy)
{
Newtonsoft.Json.Serialization.NamingStrategy chosenStrategy;
switch (namingStrategy)
{
case JsonNamingStrategy.Default:
chosenStrategy = new DefaultNamingStrategy();
break;
case JsonNamingStrategy.CamelCase:
chosenStrategy = new CamelCaseNamingStrategy();
break;
case JsonNamingStrategy.SnakeCase:
chosenStrategy = new SnakeCaseNamingStrategy();
break;
default:
throw new ArgumentOutOfRangeException(
$"Unhandled JsonNamingStrategy: {namingStrategy}");
}
return(new NewtonsoftJsonSerializer(new Newtonsoft.Json.JsonSerializer()
{
NullValueHandling = NullValueHandling.Ignore,
Formatting = Formatting.None,
ContractResolver = new DefaultContractResolver()
{
NamingStrategy = chosenStrategy
}
}));
}
public async Task <ICollection <RowParseResultTyped <T> > > ReadAll(string url, int sheetIndex = 0,
JsonNamingStrategy jsonNamingStrategy = JsonNamingStrategy.None,
string[] headerMap = null, bool ignoreFirstRow = true, bool ignoreEmpty = true)
{
if (!loaded)
{
await Load(url, sheetIndex, jsonNamingStrategy, headerMap, ignoreFirstRow);
}
var results = new List <RowParseResultTyped <T> >();
var found = false;
do
{
var(hasResult, result) = await Read();
found = hasResult;
if (!found)
{
continue;
}
if (ignoreEmpty && result.Row.Cells.All(c => c.Value == null || c.ToString() == ""))
{
continue;
}
results.Add(result);
} while (found);
return(results);
}
string SerializeToJsonConformantName(string input)
{
string _input = input;
if (string.IsNullOrWhiteSpace(_input))
{
_input = DefaultPropertyName;
}
return(JsonNamingStrategy?.GetPropertyName(_input, false) ?? _input);
}
public async Task Load(string url, int sheetIndex = 0,
JsonNamingStrategy jsonNamingStrategy = JsonNamingStrategy.None,
string[] headerMap = null, bool ignoreFirstRow = true)
{
var validationResult = await Validate(url, sheetIndex, jsonNamingStrategy, headerMap, ignoreFirstRow);
if (validationResult.HasErrors)
{
throw new InvalidOperationException("Sheet is invalid");
}
}
public static string Transform(this string s, JsonNamingStrategy strategy) =>
strategy switch
{
public RestClientEx(string baseUrl, JsonNamingStrategy namingStrategy)
: base(baseUrl)
{
SetSerializer(NewtonsoftJsonSerializer.Create(namingStrategy));
}
public IRestRequest AddJsonBody(Object obj, JsonNamingStrategy namingStrategy)
{
base.RequestFormat = DataFormat.Json;
base.JsonSerializer = NewtonsoftJsonSerializer.Create(namingStrategy);
return(base.AddJsonBody(obj));
}
public JsonNameTable(JsonNamingStrategy namingStrategy)
{
m_namingStrategy = namingStrategy;
}
internal JsonPropertyCollection(JsonNamingStrategy namingStrategy)
{
NameTable = new JsonNameTable <TOwner>(namingStrategy);
}
public JsonContent(object content, JsonNamingStrategy namingStrategy, Encoding encoding, string mediaType)
: base(NewtonsoftJsonSerializer.Create(namingStrategy).Serialize(content),
encoding, mediaType)
{
}
public ReadOnlySpan <Byte> GetBytes(JsonNamingStrategy strategy)
{
ref var bytes = ref m_bytes[(Byte)strategy];
public static RestClientEx ClientFactory(string baseUrl,
JsonNamingStrategy naming = JsonNamingStrategy.Default)
{
return(new RestClientEx(baseUrl, naming));
}
public ExcelRowValidateOnTypeRequest(RowRecord row, Type onType, JsonNamingStrategy namingStrategy = JsonNamingStrategy.None)
{
this.row = row;
this.onType = onType;
this.NamingStrategy = namingStrategy;
}
public static Type GetEnumerablePropertyType(this Type payloadType, string propertyName, JsonNamingStrategy namingStrategy)
{
var property = payloadType.GetProperties().Where(x => x.Name == propertyName.Transform(namingStrategy)).FirstOrDefault();
if (property == null)
{
return(null);
}
if (property.PropertyType == typeof(string))
{
return(null);
}
var type = property.PropertyType;
if (type.IsArray)
{
return(type.GetElementType());
}
return(type.GetInterfaces()
.Where(t => t.IsGenericType &&
t.GetGenericTypeDefinition() == typeof(IEnumerable <>))
.Select(t => t.GetGenericArguments() [0]).FirstOrDefault());
}
public JsonContent(object content, JsonNamingStrategy namingStrategy)
: base(NewtonsoftJsonSerializer.Create(namingStrategy).Serialize(content),
Encoding.UTF8, JsonMediaType)
{
}
