/// <summary>
/// Sets the list-type property on the <paramref name="target"/> object using the <see cref="JsonConverter"/>
/// for collection items specified on the <paramref name="jsonProperty"/> (<see cref="JsonProperty.ItemConverter"/>).
/// </summary>
/// <param name="target">The target object being mapped.</param>
/// <param name="jsonProperty">The property to populate.</param>
/// <param name="token">The array containing the values to convert.</param>
/// <param name="propertyContract"></param>
/// <param name="serializer"></param>
protected virtual void SetPropertyUsingItemConverter(object target, JsonProperty jsonProperty, JArray token, JsonContract propertyContract, JsonSerializer serializer)
{
var list = CreateNewList(propertyContract);
if (list == null)
{
throw new JsonSerializationException(
$"Unsupported property type {propertyContract.CreatedType.Name} when using ItemConverter with {nameof(JsonPathAttribute)}.");
}
using (var reader = token.CreateReader())
{
// Advance reader to start of array
reader.Read();
while (reader.Read() && reader.TokenType != JsonToken.EndArray)
{
list.Add(jsonProperty.ItemConverter.ReadJson(reader, jsonProperty.PropertyType, null, serializer));
}
if (propertyContract.CreatedType.IsArray)
{
var array = (Array)Activator.CreateInstance(propertyContract.CreatedType, list.Count);
list.CopyTo(array, 0);
list = array;
}
SetPropertyValue(target, list, jsonProperty, serializer);
}
}
public override object ReadJson(
JsonReader reader,
Type objectType, object existingValue,
JsonSerializer serializer)
{
JObject eventsObject = JObject.Load(reader);
Dictionary <EventType, AbstractSdkEventV1[]> eventsDictionary =
new Dictionary <EventType, AbstractSdkEventV1[]>();
foreach (JProperty property in eventsObject.Properties())
{
string eventName = property.Name;
EventType eventType = (EventType)Enum.Parse(this._eventType, eventName, true);
JToken eventValue = property.Value;
JArray eventObject = JArray.Load(eventValue.CreateReader());
AbstractSdkEventV1[] eventsArray = (AbstractSdkEventV1[])serializer.Deserialize(
eventObject.CreateReader(),
this._arrayTypeMap[eventType]
);
eventsDictionary.Add(eventType, eventsArray);
}
return(eventsDictionary);
}
public override Dictionary <string, string> ReadJson(
JsonReader reader,
Type objectType,
Dictionary <string, string> existingValue,
bool hasExistingValue,
JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.StartArray)
{
existingValue = existingValue == null ?
new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase)
: new Dictionary <string, string>(existingValue, StringComparer.OrdinalIgnoreCase);
JArray array = JArray.Load(reader);
List <KeyValuePair <string, string> > target = new List <KeyValuePair <string, string> >();
serializer.Populate(array.CreateReader(), target);
foreach (var item in target)
{
if (!existingValue.ContainsKey(item.Key))
{
existingValue.Add(item.Key, item.Value);
}
}
return(existingValue);
}
return(new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase));
}
JsonReader Downloads()
{
// array-1 of array-2 where array-2 is package-id first element and remaining elements are 2 element array of version, downloads
// e.g. [["package-a",["1.0",100],["2.0",150]],["package-b",["1.0",64],["2.0",128],["3.5",256]]]
var downloads = new JArray();
return(downloads.CreateReader());
}
JsonReader Curatedfeeds()
{
// array-1 of array-2 where array-2 is feed-name first element and array of package-id second element
// e.g. [["feed-x",["package-a","package-b"]],["feed-y,["package-a","package-b","package-c"]]]
var curatedfeeds = new JArray();
return(curatedfeeds.CreateReader());
}
JsonReader Owners()
{
// array-1 of array-2 where array-2 is package-id first element and array of owners second element
// e.g. [["package-a",["owner-x","owner-y"]],["package-b",["owner-z"]]]
var owners = new JArray();
return(owners.CreateReader());
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
TransactionReceiptTrx transactionReceiptTrx = (TransactionReceiptTrx)value;
JArray array = new JArray();
array.Add(JToken.Parse(transactionReceiptTrx.index.ToString()));
array.Add(JToken.Parse(JsonConvert.SerializeObject(transactionReceiptTrx.trx)));
writer.WriteToken(array.CreateReader());
}
public override object ReadJson(JsonReader reader,
Type objectType, object existingValue,
JsonSerializer serializer)
{
JArray jsonArray = JArray.Load(reader);
var deserialized = (List <T>)Activator.CreateInstance(typeof(List <T>));
serializer.Populate(jsonArray.CreateReader(), deserialized);
return(deserialized as IList <I>);
}
public override object ReadJson(JsonReader reader,
Type objectType, object existingValue,
JsonSerializer serializer)
{
JArray jsonArray = JArray.Load(reader);
var deserialized = (List <T>)Activator.CreateInstance(typeof(List <T>));
serializer.Populate(jsonArray.CreateReader(), deserialized);
List <I> interfaceList = new List <I>(deserialized.Cast <I>());
if (interfaceList.Any())
{
return(interfaceList);
}
return(null);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
try
{
if (reader.TokenType == JsonToken.Null)
{
return(null);
}
Type genericType = objectType.GetGenericArguments()[0];
// load jObject
JArray jObject = JArray.Load(reader);
// Create target object for Json => list of operations, typed to genericType
var genericOperation = typeof(Operation <>);
var concreteOperationType = genericOperation.MakeGenericType(genericType);
var genericList = typeof(List <>);
var concreteList = genericList.MakeGenericType(concreteOperationType);
var targetOperations = Activator.CreateInstance(concreteList);
//Create a new reader for this jObject, and set all properties to match the original reader.
JsonReader jObjectReader = jObject.CreateReader();
jObjectReader.Culture = reader.Culture;
jObjectReader.DateParseHandling = reader.DateParseHandling;
jObjectReader.DateTimeZoneHandling = reader.DateTimeZoneHandling;
jObjectReader.FloatParseHandling = reader.FloatParseHandling;
// Populate the object properties
serializer.Populate(jObjectReader, targetOperations);
// container target: the typed JsonPatchDocument.
var container = Activator.CreateInstance(objectType, targetOperations);
return(container);
}
catch (Exception ex)
{
throw new JsonPatchException(
new JsonPatchError(null, null, "The JsonPatchDocument was malformed and could not be parsed."), ex, 400);
}
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (objectType != typeof(JsonPatchDocument))
{
throw new ArgumentException("ObjectType must be of type JsonPatchDocument", "objectType");
}
try
{
if (reader.TokenType == JsonToken.Null)
{
return(null);
}
// load jObject
JArray jObject = JArray.Load(reader);
// Create target object for Json => list of operations
var targetOperations = new List <Operation>();
// Create a new reader for this jObject, and set all properties
// to match the original reader.
JsonReader jObjectReader = jObject.CreateReader();
jObjectReader.Culture = reader.Culture;
jObjectReader.DateParseHandling = reader.DateParseHandling;
jObjectReader.DateTimeZoneHandling = reader.DateTimeZoneHandling;
jObjectReader.FloatParseHandling = reader.FloatParseHandling;
// Populate the object properties
serializer.Populate(jObjectReader, targetOperations);
// container target: the JsonPatchDocument.
var container = Activator.CreateInstance(objectType, targetOperations);
return(container);
}
catch (Exception ex)
{
throw new JsonPatchException("The JsonPatchDocument was malformed and could not be parsed.", ex);
}
}
/// <summary>
/// Read json and converts it.
/// </summary>
/// <param name="reader">Reader.</param>
/// <param name="objectType">Object type.</param>
/// <param name="existingValue">Existing value.</param>
/// <param name="serializer">Serializer.</param>
/// <returns></returns>
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
JArray jArray = null;
if (reader.TokenType == JsonToken.StartArray)
{
jArray = JArray.Load(reader);
}
else
{
JObject jsonObject = JObject.Load(reader);
JToken jToken = jsonObject.GetValue(
"value",
StringComparison.OrdinalIgnoreCase);
if (null == jToken)
{
return(serializer.Deserialize(reader, objectType));
}
jArray = jToken as JArray;
}
if (null == jArray)
{
return(serializer.Deserialize(reader, objectType));
}
Type type = objectType.GetGenericArguments()[0];
Type listType = typeof(List <>);
Type genericListType = listType.MakeGenericType(type);
object instance = Activator.CreateInstance(genericListType);
serializer.Populate(
jArray.CreateReader(),
instance);
return(instance);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
List <IContent> result = new List <IContent>();
if (reader.TokenType == JsonToken.Null)
{
return(result);
}
JArray ja = JArray.Load(reader);
//Create a new reader for this jObject, and set all properties to match the original reader.
JsonReader jObjectReader = ja.CreateReader();
jObjectReader.Culture = reader.Culture;
jObjectReader.DateParseHandling = reader.DateParseHandling;
jObjectReader.DateTimeZoneHandling = reader.DateTimeZoneHandling;
jObjectReader.FloatParseHandling = reader.FloatParseHandling;
// Populate the object properties
_serializer.Populate(jObjectReader, result);
return(result);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
return(null);
}
if (reader.TokenType == JsonToken.StartObject)
{
var token = JToken.Load(reader);
token = new JArray(token.SelectTokens("records[*].record"));
using (var subReader = token.CreateReader())
{
while (subReader.TokenType == JsonToken.None)
{
subReader.Read();
}
return(base.ReadJson(subReader, objectType, existingValue, serializer)); // Use base class to convert
}
}
else
{
return(base.ReadJson(reader, objectType, existingValue, serializer));
}
}
private async Task <List <Meta> > ProcessMetaAsync(List <object> data)
{
bool codeValuesBlock = false;
int i = 0;
JArray tempJA = new JArray();
List <Meta> layerMeta = new List <Meta>();
StringBuilder sb = new StringBuilder();
StringWriter sw = new StringWriter(sb);
JsonWriter writer = new JsonTextWriter(sw);
try
{
JObject jObj = JsonUtils.MergeJSON <object>(data);
tempJA = (JArray)jObj["fields"];
JsonReader reader = tempJA.CreateReader();
await writer.WriteStartArrayAsync();
while (reader.Read())
{
if (codeValuesBlock == false)
{
if (reader.Value != null)
{
if (reader.TokenType == JsonToken.PropertyName)
{
if (reader.Value.ToString() == "domain")
{
codeValuesBlock = true;
if (jObj["fields"][i]["domain"].HasValues)
{
var something = "";
try
{
something = jObj["fields"][i]["domain"]["codedValues"].ToString();
await writer.WritePropertyNameAsync("domain");
await writer.WriteRawValueAsync(something);
await writer.WritePropertyNameAsync("range");
}
catch (NullReferenceException e)
{
await writer.WritePropertyNameAsync("range");
something = jObj["fields"][i]["domain"]["range"].ToString();
await writer.WriteRawValueAsync(something);
await writer.WritePropertyNameAsync("domain");
}
await writer.WriteStartArrayAsync();
await writer.WriteEndArrayAsync();
await writer.WriteEndObjectAsync();
}
else
{
await writer.WritePropertyNameAsync("domain");
await writer.WriteStartArrayAsync();
await writer.WriteEndArrayAsync();
await writer.WritePropertyNameAsync("range");
await writer.WriteStartArrayAsync();
await writer.WriteEndArrayAsync();
await writer.WriteEndObjectAsync();
codeValuesBlock = false;
}
i++;
}
else
{
if (reader.Value.ToString() == "name")
{
await writer.WriteStartObjectAsync();
}
await writer.WritePropertyNameAsync(reader.Value.ToString());
}
}
else
{
await writer.WriteValueAsync(reader.Value.ToString());
}
}
}
else
{
if (reader.Depth == 1)
{
codeValuesBlock = false;
}
}
}
await writer.WriteEndAsync();
layerMeta = JsonConvert.DeserializeObject <List <Meta> >(sw.ToString());
writer.Close();
}
catch (Exception e)
{
writer.Close();
}
//from appsettings.[env].json
string[] excludesList = _config.GetSection("excludeFilters").Get <string[]>();
layerMeta = layerMeta.Where(m => !excludesList.Any(e => e.ToLower() == m.name.ToLower())).ToList();
return(layerMeta);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
object result = null;
var jObj = serializer.Deserialize <JObject>(reader);
if (jObj.ContainsKey("_type"))
{
//获取实际类型
var typeValue = jObj["_type"];
var type = Type.GetType(typeValue.ToString());
typeValue.Remove();
var typeReader = jObj.CreateReader();
//反序列化为实际类型
result = serializer.Deserialize(typeReader, type);
}
else
{
switch (jObj.Type)
{
case JTokenType.Array:
//转换成JArray，数组最后一个为类型字符串
JArray arrayValue = JArray.Parse(jObj.ToString());
if (arrayValue.Count == 0)
{
throw new Exception("object Deserialize to array need typeinfo");
}
var type = Type.GetType(arrayValue[arrayValue.Count - 1].ToString());
arrayValue.RemoveAt(arrayValue.Count - 1);
var typeReader = arrayValue.CreateReader();
//反序列化为实际类型
result = serializer.Deserialize(typeReader, type);
break;
case JTokenType.Boolean:
//反序列化为实际类型
result = serializer.Deserialize <bool>(reader);
break;
case JTokenType.Date:
//反序列化为实际类型
result = serializer.Deserialize <DateTime>(reader);
break;
case JTokenType.Float:
//反序列化为实际类型
result = serializer.Deserialize <decimal>(reader);
break;
case JTokenType.Guid:
//反序列化为实际类型
result = serializer.Deserialize <Guid>(reader);
break;
case JTokenType.String:
//反序列化为实际类型
result = serializer.Deserialize <string>(reader);
break;
case JTokenType.Integer:
//反序列化为实际类型
result = serializer.Deserialize <int>(reader);
break;
default:
result = null;
break;
}
}
return(result);
}
