/// <summary>
/// Generates JsonSerializerSettings for given lenient parsing setting
/// </summary>
/// <param name="lenient"></param>
/// <param name="userPropertiesWhiteList"></param>
/// <returns></returns>
public static JsonSerializerSettings GetJsonSerializerSettings(this LenientParsing lenient, HashSet <string> userPropertiesWhiteList)
{
List <JsonConverter> converters = new List <JsonConverter>();
foreach (LenientParsing lp in Enum.GetValues(typeof(LenientParsing)))
{
if (lenient.HasFlag(lp))
{
switch (lp)
{
case LenientParsing.DateTime:
if (!lenient.HasFlag(LenientParsing.SetInitialDateIfNull))
{
converters.Add(new LenientDateTimeConverter());
}
else
{
converters.Add(new LenientDateTimeConverter(new DateTimeOffset()));
}
break;
case LenientParsing.EnumList:
converters.Add(new LenientEnumListConverter());
break;
case LenientParsing.Bo4eUri:
converters.Add(new LenientBo4eUriConverter());
break;
case LenientParsing.StringToInt:
converters.Add(new LenientStringToIntConverter());
break;
// case LenientParsing.EmptyLists:
// converters.Add(new LenientRequiredListConverter());
// break;
// no default case because NONE and MOST_LENIENT do not come up with more converters
}
}
}
IContractResolver contractResolver;
if (userPropertiesWhiteList.Count > 0)
{
contractResolver = new UserPropertiesDataContractResolver(userPropertiesWhiteList);
}
else
{
contractResolver = new DefaultContractResolver();
}
JsonSerializerSettings settings = new JsonSerializerSettings
{
Converters = converters,
DateParseHandling = DateParseHandling.None,
ContractResolver = contractResolver
};
return(settings);
}
public void TestVertragStringToInt()
{
// first test serialization of complete business object
JObject json;
using (StreamReader r = new StreamReader("BoMapperTests/Vertrag_lenient_String.json"))
{
string jsonString = r.ReadToEnd();
json = JsonConvert.DeserializeObject <JObject>(jsonString);
}
LenientParsing lenients = LenientParsing.StringToInt;
Vertrag v = JsonConvert.DeserializeObject <Vertrag>(json["input"].ToString(), lenients.GetJsonSerializerSettings());
Assert.AreEqual(v.Vertragskonditionen.AnzahlAbschlaege, 12);
}
public static BusinessObject MapObject(string businessObjectName, JObject jobject, HashSet <string> userPropertiesWhiteList, LenientParsing lenient = LenientParsing.Strict)
{
return(MapObject(GetTypeForBoName(businessObjectName), jobject, userPropertiesWhiteList, lenient));
}
/// <summary>
/// <see cref="MapObject(Type, JObject, HashSet{string}, LenientParsing)"/>
/// </summary>
public static BusinessObjectType MapObject <BusinessObjectType>(JObject jobject, LenientParsing lenient = LenientParsing.Strict)
{
return((BusinessObjectType)Convert.ChangeType(MapObject(typeof(BusinessObjectType), jobject, lenient), typeof(BusinessObjectType)));
}
/// <summary>
/// <see cref="MapObject(Type, JObject, HashSet{string}, LenientParsing)"/> with empty user properties white list
/// </summary>
public static BusinessObject MapObject(Type businessObjectType, JObject jobject, LenientParsing lenient = LenientParsing.Strict)
{
return(MapObject(businessObjectType, jobject, new HashSet <string>(), lenient));
}
/// <summary>
/// <see cref="MapObject(string, JObject, HashSet{string}, LenientParsing)"/> with empty user properties white list
/// </summary>
public static BusinessObject MapObject(string businessObjectName, JObject jobject, LenientParsing lenient = LenientParsing.Strict)
{
return(MapObject(GetTypeForBoName(businessObjectName), jobject, new HashSet <string>(), lenient));
}
/// <summary>
/// shortcut for <see cref="MapObject(string, JObject, LenientParsing)"/> iff <paramref name="jobject"/> has key 'boTyp'
/// </summary>
/// <param name="jobject">business object json</param>
/// <param name="lenient">lenient parsing flags</param>
/// <param name="userPropertiesWhiteList">white list of non BO4E standard field you'd like to have de-serialised</param>
/// <returns><see cref="MapObject(string, JObject, LenientParsing)"/></returns>
public static BusinessObject MapObject(JObject jobject, HashSet <string> userPropertiesWhiteList, LenientParsing lenient = LenientParsing.Strict)
{
if (jobject["boTyp"] == null)
{
throw new ArgumentNullException("boTyp", "Either call MapObject(JObject) with a Business Object containing the mandatory 'boTyp' key or explicitly name the Object");
}
Type businessObjectType = GetTypeForBoName(jobject["boTyp"].ToString());
return(MapObject(businessObjectType, jobject, userPropertiesWhiteList, lenient));
}
/// <summary>
/// <see cref="MapObject(Type, JObject, HashSet{string}, LenientParsing)"/>
/// </summary>
/// <typeparam name="BusinessObjectType">type of return value</typeparam>
/// <param name="jobject"><see cref="MapObject(Type, JObject, HashSet{string}, LenientParsing)"/></param>
/// <param name="userPropertiesWhiteList"><see cref="MapObject(Type, JObject, HashSet{string}, LenientParsing)"/></param>
/// <param name="lenient"><see cref="MapObject(Type, JObject, HashSet{string}, LenientParsing)"/></param>
/// <returns><see cref="MapObject(Type, JObject, HashSet{string}, LenientParsing)"/></returns>
public static BusinessObjectType MapObject <BusinessObjectType>(JObject jobject, HashSet <string> userPropertiesWhiteList, LenientParsing lenient = LenientParsing.Strict)
{
Type businessObjectType = typeof(BusinessObjectType);
return((BusinessObjectType)Convert.ChangeType(MapObject(businessObjectType, jobject, userPropertiesWhiteList, lenient), typeof(BusinessObjectType)));
}
public static BusinessObject MapObject(Type businessObjectType, JObject jobject, HashSet <string> userPropertiesWhiteList, LenientParsing lenient = LenientParsing.Strict)
{
if (!businessObjectType.IsSubclassOf(typeof(BusinessObject)))
{
throw new ArgumentException("Mapping is only allowed for types derived from BO4E.BO.BusinessObject");
}
else if (businessObjectType != null)
{
if (lenient == LenientParsing.Strict && userPropertiesWhiteList.Count == 0)
{
return((BusinessObject)jobject.ToObject(businessObjectType));
}
else
{
var settings = lenient.GetJsonSerializerSettings();
return((BusinessObject)JsonConvert.DeserializeObject(jobject.ToString(), businessObjectType, settings));
}
}
else
{
return(null);
}
}
public void TestBoMapping()
{
string[] files = Directory.GetFiles($"BoMapperTests/", "*.json");
foreach (string file in files)
{
JObject json;
using (StreamReader r = new StreamReader(file))
{
string jsonString = r.ReadToEnd();
json = JsonConvert.DeserializeObject <JObject>(jsonString);
}
Assert.IsNotNull(json["objectName"], $"You have to specify the object name in test file {file}");
LenientParsing lenients = LenientParsing.Strict; // default
if (json["lenientDateTime"] != null && (bool)json["lenientDateTime"])
{
lenients |= LenientParsing.DateTime;
}
if (json["lenientEnumList"] != null && (bool)json["lenientEnumList"])
{
lenients |= LenientParsing.EnumList;
}
if (json["lenientBo4eUri"] != null && (bool)json["lenientBo4eUri"])
{
lenients |= LenientParsing.Bo4eUri;
}
if (json["lenientStringToInt"] != null && (bool)json["lenientStringToInt"])
{
lenients |= LenientParsing.StringToInt;
}
BusinessObject bo;
try
{
bo = JsonConvert.DeserializeObject <BusinessObject>(json["input"].ToString(), lenients.GetJsonSerializerSettings());
}
catch (Exception e) when(e is ArgumentException || e is JsonSerializationException)
{
bo = BoMapper.MapObject(json["objectName"].ToString(), (JObject)json["input"], lenients);
}
string regularOutputString = JsonConvert.SerializeObject(bo, new StringEnumConverter());
if (bo.GetType() == typeof(Rechnung))
{
continue; // todo: fix this!
}
/*if (json["input"]["boTyp"] != null)
* {
* //BusinessObject bo2 = BoMapper.MapObject((JObject)json["input"], lenients);
* BusinessObject bo2 = JsonConvert.DeserializeObject<BusinessObject>(json["input"].ToString(), BoMapper.GetJsonSerializerSettings(lenients));
* //string regularOutputString2 = JsonConvert.SerializeObject(bo2, new StringEnumConverter());
* Assert.AreEqual(bo, bo2);
* switch (json["input"]["boTyp"].ToString().ToLower())
* {
* case "energiemenge":
* //Assert.AreEqual((Energiemenge)bo, BoMapper.MapObject<Energiemenge>((JObject)json["input"], lenients));
* Assert.AreEqual((Energiemenge)bo, JsonConvert.DeserializeObject<Energiemenge>(json["input"].ToString(), BoMapper.GetJsonSerializerSettings(lenients)));
* break;
* case "messlokation":
* //Assert.AreEqual((Messlokation)bo, BoMapper.MapObject<Messlokation>((JObject)json["input"], lenients));
* Assert.AreEqual((Messlokation)bo, JsonConvert.DeserializeObject<Messlokation>(json["input"].ToString(), BoMapper.GetJsonSerializerSettings(lenients)));
* break;
* // add more if you feel like
* }
* }*/
HashSet <string> whitelist;
if (json["userPropWhiteList"] != null)
{
whitelist = new HashSet <string>(JArray.FromObject(json["userPropWhiteList"]).ToObject <List <string> >());
}
else
{
whitelist = new HashSet <string>();
}
if (lenients == LenientParsing.Strict)
{
foreach (LenientParsing lenient in Enum.GetValues(typeof(LenientParsing)))
{
// strict mappings must also work with lenient mapping
BusinessObject boLenient;
try
{
boLenient = JsonConvert.DeserializeObject <BusinessObject>(json["input"].ToString(), lenient.GetJsonSerializerSettings(whitelist));
}
catch (ArgumentException)
{
boLenient = BoMapper.MapObject(json["objectName"].ToString(), (JObject)json["input"], whitelist, lenient);
}
catch (JsonSerializationException jse)
{
Assert.IsTrue(false, $"Unexpected {nameof(JsonSerializationException)} in file {file}: {jse.Message}");
throw jse;
}
//string dateLenietOutputString = JsonConvert.SerializeObject(boLenient, new StringEnumConverter());
//if (whitelist.Count ==0) {
//Assert.AreEqual(regularOutputString, dateLenietOutputString);
//}
//else
// {
// Assert.AreEqual(regularOutputString, dateLenietOutputString);
//}
}
}
else
{
// non-strict test cases are designed such that they are not parseble in strict mode.
// bool exceptionThrown;
// try
//{
// BusinessObject boStrict = BoMapper.MapObject(json["objectName"].ToString(), (JObject)json["input"], LenientParsing.Strict);
// exceptionThrown = false;
//}
//catch (Exception)
//{
// exceptionThrown = true;
// }
//Assert.IsTrue(exceptionThrown);
}
}
}
/// <summary>
/// <inheritdoc cref="GetJsonSerializerSettings(LenientParsing, HashSet{string})"/>
/// </summary>
/// <param name="lenient"></param>
/// <returns></returns>
public static JsonSerializerSettings GetJsonSerializerSettings(this LenientParsing lenient)
{
return(GetJsonSerializerSettings(lenient, new HashSet <string>()));
}
