public static void FromApiResource(this JsonApiCollectionDocument document, IEnumerable data, JsonApiResource apiResource, string baseUrl = null)
{
if (data == null)
{
return;
}
var resourceObjects = new List <JsonApiResourceObject>();
foreach (var item in data)
{
var rObject = new JsonApiResourceObject();
rObject.FromApiResource(item, apiResource, baseUrl);
resourceObjects.Add(rObject);
}
document.Data = resourceObjects;
if (!string.IsNullOrWhiteSpace(baseUrl))
{
document.Links = new JsonApiLinksObject
{
Self = new JsonApiLink
{
Href = $"{baseUrl}{apiResource.UrlPath}"
}
};
}
}
public static JsonApiCollectionDocument CreateDocumentFromApiResource <T>(IEnumerable data, string baseUrl = null) where T : JsonApiResource
{
var apiResource = Activator.CreateInstance <T>();
var document = new JsonApiCollectionDocument();
document.FromApiResource(data, apiResource, baseUrl);
return(document);
}
public static IEnumerable <TResult> ToObjectCollection <TResult, TResource>(this JsonApiCollectionDocument document) where TResource : JsonApiResource
{
var primaryResourceObjects = document.Data;
if (primaryResourceObjects == null)
{
throw new Exception("Json document contains no data.");
}
return(primaryResourceObjects.Select(r => r.ToObject <TResult, TResource>()).ToList());
}
public void JsonApiCollectionDocument_DataArray()
{
var data = GetSomeData();
var testApiDocument = new JsonApiCollectionDocument <Firma>(data);
string jsonString = JsonConvert.SerializeObject(testApiDocument, Formatting.Indented);
var result = JsonConvert.DeserializeObject <JsonApiCollectionDocument <Firma> >(jsonString);
Assert.IsNotNull(result);
var deserialzedModel = result.ToObject();
Assert.IsNotNull(deserialzedModel);
Assert.AreEqual(deserialzedModel.Count(), data.Count());
}
public void TestMethod1()
{
var modelIdNull = new arr();
var modelIdNotNull = new arr {
Id = 112314, MyProperty = "muh"
};
var docIdNull = new JsonApiCollectionDocument <arr>(modelIdNull);
var docIdNotNull = new JsonApiCollectionDocument <arr>(modelIdNotNull);
var jsonIdNull = JsonConvert.SerializeObject(docIdNull);
var jsonIdNotNull = JsonConvert.SerializeObject(docIdNotNull);
var resultIdNull = JsonConvert.DeserializeObject <arr>(jsonIdNull);
var resultIdNotNull = JsonConvert.DeserializeObject <arr>(jsonIdNotNull);
}
/// <summary>
/// Extracts apiResource to an <see cref="IEnumerable{T}"/> of type targetType.
/// </summary>
/// <param name="document"></param>
/// <param name="apiResource"></param>
/// <param name="targetType"></param>
/// <returns></returns>
internal static object ToObjectInternal(this JsonApiCollectionDocument document, JsonApiResource apiResource, Type targetType)
{
if (targetType.IsNonStringEnumerable())
{
throw new Exception("Do not use a collection as target type!");
}
var primaryResourceObjects = document.Data;
if (primaryResourceObjects == null)
{
throw new Exception("Json document contains no data.");
}
var method = typeof(JsonApiCollectionDocumentExtensions).GetMethod(nameof(Cast), BindingFlags.Static | BindingFlags.NonPublic)?.MakeGenericMethod(targetType);
return(method.Invoke(null, new object[] { primaryResourceObjects, apiResource }));
}
public void JsonApiCollectionDocument_TestIncludeToMany()
{
//var model = GetSomeData().FirstOrDefault();
var model = new Firma
{
Id = Guid.NewGuid().ToString(),
FirmenName = "bitbird",
FahrZeuge = new List <Fahrzeug> {
new Fahrzeug {
Id = Guid.NewGuid().ToString(), Kilometerstand = 4000
}, new Fahrzeug {
Id = Guid.NewGuid().ToString(), Kilometerstand = 10000
}
},
Fahrer = new Fahrer {
Id = Guid.NewGuid().ToString(), Name = "Christian", Keys = new List <string> {
"key0", "key1", "key2"
}
}
};
var testApiDocument = new JsonApiCollectionDocument <Firma>(model, new List <PropertyInfo>
{
model.GetType().GetProperty(nameof(model.Fahrer)), model.GetType().GetProperty(nameof(model.FahrZeuge))
});
JsonSerializerSettings settings = new JsonSerializerSettings()
{
Formatting = Formatting.Indented
};
string jsonString = JsonConvert.SerializeObject(testApiDocument, settings);
System.Diagnostics.Debug.WriteLine(jsonString);
var result = JsonConvert.DeserializeObject <JsonApiCollectionDocument <Firma> >(jsonString, settings);
var deserialzedModel = result.ToObject()?.FirstOrDefault();
Assert.IsNotNull(deserialzedModel);
Assert.AreEqual(deserialzedModel.FahrZeuge.Count(), model.FahrZeuge.Count());
Assert.AreEqual(deserialzedModel.FahrZeuge.First().Id, model.FahrZeuge.First().Id);
}
public void JsonApiCollectionDocument_TestNestedIncludes()
{
// A has a reference to B
// B has a reference to C
// B AND C ARE INCLUDED
var data = new ClassA
{
Id = Guid.NewGuid().ToString(),
AName = "A",
BReference = new ClassB
{
Id = Guid.NewGuid().ToString(),
BName = "B",
CReference = new ClassC
{
Id = Guid.NewGuid().ToString(),
CName = "C"
}
}
};
var doc = new JsonApiCollectionDocument <ClassA>(data);
doc.Included = new JsonApiResourceObjectDictionary();
doc.Included.AddResource(new JsonApiResourceObject().FromObject(data.BReference));
doc.Included.AddResource(new JsonApiResourceObject().FromObject(data.BReference.CReference));
string jsonString = JsonConvert.SerializeObject(doc, Formatting.Indented);
var deserializedDocument = JsonConvert.DeserializeObject <JsonApiCollectionDocument <ClassA> >(jsonString);
var aResource = deserializedDocument.Data.FirstOrDefault();
Assert.IsNotNull(aResource);
var aObject = aResource.ToObject <ClassA>();
Assert.IsNotNull(aObject);
aObject.BReference = deserializedDocument.Included.GetResource(aObject.BReference.Id, aObject.BReference.GetJsonApiClassName()).ToObject <ClassB>();
Assert.IsTrue(aObject.BReference.BName == data.BReference.BName);
aObject.BReference.CReference = deserializedDocument.Included.GetResource(aObject.BReference.CReference.Id, aObject.BReference.CReference.GetJsonApiClassName()).ToObject <ClassC>();
Assert.IsTrue(aObject.BReference.CReference.CName == data.BReference.CReference.CName);
}
public void JsonApiCollectionDocument_TestRelationshipIdentifiers()
{
var model = GetSomeData().FirstOrDefault();
var testApiDocument = new JsonApiCollectionDocument <Firma>(model);
var settings = new JsonSerializerSettings
{
Formatting = Formatting.Indented
};
var jsonString = JsonConvert.SerializeObject(testApiDocument, settings);
var result = JsonConvert.DeserializeObject <JsonApiCollectionDocument <Firma> >(jsonString, settings);
var deserialzedModel = result.ToObject()?.FirstOrDefault();
Console.WriteLine($"{nameof(model )}{Environment.NewLine}{JToken.Parse(JsonConvert.SerializeObject(model ))}{Environment.NewLine}");
Console.WriteLine($"{nameof(testApiDocument )}{Environment.NewLine}{JToken.Parse(JsonConvert.SerializeObject(testApiDocument ))}{Environment.NewLine}");
Console.WriteLine($"{nameof(jsonString )}{Environment.NewLine}{JToken.Parse(JsonConvert.SerializeObject(jsonString ))}{Environment.NewLine}");
Console.WriteLine($"{nameof(result )}{Environment.NewLine}{JToken.Parse(JsonConvert.SerializeObject(result ))}{Environment.NewLine}");
Console.WriteLine($"{nameof(deserialzedModel)}{Environment.NewLine}{JToken.Parse(JsonConvert.SerializeObject(deserialzedModel))}{Environment.NewLine}");
Assert.IsNotNull(deserialzedModel);
Assert.AreEqual(deserialzedModel.Fahrer.Id, model?.Fahrer.Id);
Assert.AreEqual(deserialzedModel.FahrZeuge.Count(), model?.FahrZeuge.Count());
}
public void JsonApiCollectionDocument_TestPrimitveArray()
{
var list = new List <string> {
"data1", "data2", "data3"
};
var data = new Fahrer {
Id = "123", Name = "hansi", Keys = list
};
var testApiDocument = new JsonApiCollectionDocument <Fahrer>(data);
string jsonString = JsonConvert.SerializeObject(testApiDocument);
var result = JsonConvert.DeserializeObject <JsonApiCollectionDocument <Fahrer> >(jsonString);
Assert.IsNotNull(result);
var deserialzedModel = result.ToObject()?.FirstOrDefault();
Assert.IsNotNull(deserialzedModel);
Assert.AreEqual(list.Count, deserialzedModel.Keys.Count());
for (int i = 0; i < list.Count; i++)
{
Assert.AreEqual(list[i], deserialzedModel.Keys.ElementAt(i));
}
}
public void JsonApiCollectionDocument_TestSelfLinks()
{
// create test data
var model = GetSomeData();
// setup Query url
Uri queryUri = (new UriBuilder {
Host = "localhost", Path = "api/firma"
}).Uri;
// create JsonDocument
var jsonDocument = new JsonApiCollectionDocument <Firma>(model, new List <PropertyInfo> {
typeof(Firma).GetProperty(nameof(Firma.Fahrer))
}, queryUri);
jsonDocument.Links.Related = new JsonApiLink("test", 1);
var jsonString = JsonConvert.SerializeObject(jsonDocument, Formatting.Indented);
var result = JsonConvert.DeserializeObject <JsonApiCollectionDocument <Firma> >(jsonString);
Assert.IsNotNull(result);
var deserialzedModel = result.ToObject();
Assert.IsNotNull(deserialzedModel);
}
public void JsonApiCollectionDocument_TestInclude()
{
var model = GetSomeData().FirstOrDefault();
var testApiDocument = new JsonApiCollectionDocument <Firma>(model, new List <PropertyInfo> {
model.GetType().GetProperty(nameof(model.Fahrer))
});
JsonSerializerSettings settings = new JsonSerializerSettings()
{
Formatting = Formatting.Indented
};
string jsonString = JsonConvert.SerializeObject(testApiDocument, settings);
System.Diagnostics.Debug.WriteLine(jsonString);
var result = JsonConvert.DeserializeObject <JsonApiCollectionDocument <Firma> >(jsonString, settings);
var deserializedModel = result.ToObject()?.FirstOrDefault();
Assert.IsNotNull(deserializedModel);
Assert.AreEqual(deserializedModel.Fahrer.Name, model.Fahrer.Name);
Assert.AreEqual(deserializedModel.Fahrer.Keys.Count(), model.Fahrer.Keys.Count());
}
public static object GetIncludedResource(this JsonApiCollectionDocument document, object id, Type type, JsonApiResource apiResource)
{
return(document.Included?.GetResource(id, apiResource)?.ToObject(apiResource, type));
}
public static TResult GetIncludedResource <TResult>(this JsonApiCollectionDocument document, object id, JsonApiResource apiResource) where TResult : class
{
return((TResult)document.GetIncludedResource(id, typeof(TResult), apiResource));
}
public static TResult GetIncludedResource <TResult, TResultApiResource>(this JsonApiCollectionDocument document, object id) where TResultApiResource : JsonApiResource where TResult : class
{
return((TResult)document.GetIncludedResource(id, typeof(TResult), Activator.CreateInstance <TResultApiResource>()));
}
internal static object ToObjectInternal(this JsonApiCollectionDocument document, JsonApiResource apiResource, Type targetType, out Func <int, string, bool> foundAttributes)
{
foundAttributes = (idx, attrName) => (document.Data.ElementAt(idx)?.Attributes?.ContainsKey(attrName.ToJsonAttributeName()) ?? false) || (document.Data.ElementAt(idx)?.Relationships?.ContainsKey(attrName.ToRelationshipName(apiResource.GetType())) ?? false);
return(document.ToObjectInternal(apiResource, targetType));
}
public static IEnumerable <TResult> ToObjectCollection <TResult, TResource>(this JsonApiCollectionDocument document, TResource resource, out Func <int, string, bool> foundAttributes) where TResource : JsonApiResource
{
foundAttributes = (idx, attrName) => (document.Data.ElementAt(idx)?.Attributes?.ContainsKey(attrName.ToJsonAttributeName()) ?? false) || (document.Data.ElementAt(idx)?.Relationships?.ContainsKey(attrName.ToRelationshipName <TResource>()) ?? false);
return(document.ToObjectCollection <TResult, TResource>(resource));
}
private async Task WriteJsonOutputAsync(
[NotNull] HttpResponse context,
[NotNull] Encoding selectedEncoding,
[CanBeNull] object modelData,
[NotNull] Type modelDataType,
[NotNull] JsonApiResource modelResource,
[CanBeNull] QueryInfo queryInfo)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (selectedEncoding == null)
{
throw new ArgumentNullException(nameof(selectedEncoding));
}
if (modelDataType == null)
{
throw new ArgumentNullException(nameof(modelDataType));
}
if (modelResource == null)
{
throw new ArgumentNullException(nameof(modelResource));
}
var meta = new JsonApiMetaData();
if (modelData is IQueryResult queryResult)
{
meta.PageCount = queryResult.PageCount;
meta.RecordCount = queryResult.RecordCount;
modelData = queryResult.Data;
}
IJsonApiDocument document;
if (modelData is IEnumerable collectionValue)
{
var apiCollectionDocument = new JsonApiCollectionDocument();
apiCollectionDocument.FromApiResource(collectionValue, modelResource);
document = apiCollectionDocument;
}
else
{
var apiDocument = new JsonApiDocument();
apiDocument.FromApiResource(modelData, modelResource);
document = apiDocument;
}
document.Meta = meta;
if (queryInfo?.Includes != null)
{
foreach (var include in queryInfo.Includes)
{
document.IncludeRelation(modelResource, modelData, include);
}
}
var serializer = JsonSerializer.Create(JsonSerializerSettings);
using (var streamWriter = new StreamWriter(context.Body, selectedEncoding))
{
serializer.Serialize(streamWriter, document, document.GetType());
await streamWriter.FlushAsync();
}
}
/// <inheritdoc/>
protected override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
var result = await base.SendAsync(request, cancellationToken);
if (!(request.Properties.TryGetValue(nameof(JsonApiAttribute.ReturnResourceGetter), out var resourceUntyped) && resourceUntyped is JsonApiResource resource))
{
return(result);
}
if (!result.IsSuccessStatusCode)
{
return(result);
}
if (!(result.Content is ObjectContent objectContent))
{
return(result);
}
var meta = new JsonApiMetaData();
BenchmarkCollection benchmarks = null;
if (request.Properties.TryGetValue(nameof(BenchmarkCollection), out var benchmarksObj) &&
benchmarksObj is BenchmarkCollection foundBenchmarks)
{
benchmarks = foundBenchmarks;
}
try
{
Func <string> serializeDocument;
using (benchmarks.CreateBenchmark("ConvertToJsonApiDoc"))
{
string overridePrimaryType = null;
var value = objectContent.Value;
if (value is IJsonApiOverridePrimaryType jsonApiOverridePrimaryType)
{
value = jsonApiOverridePrimaryType.Data;
overridePrimaryType = jsonApiOverridePrimaryType.Type;
}
if (value is IQueryResult queryResult)
{
meta.PageCount = queryResult.PageCount;
meta.RecordCount = queryResult.RecordCount;
value = queryResult.Data;
}
IJsonApiDocument document;
if (value is IEnumerable collectionValue)
{
var apiCollectionDocument = new JsonApiCollectionDocument();
apiCollectionDocument.FromApiResource(collectionValue, resource);
if (overridePrimaryType != null)
{
foreach (var primaryDataEntry in apiCollectionDocument.Data)
{
primaryDataEntry.Type = overridePrimaryType;
}
}
document = apiCollectionDocument;
serializeDocument = () => JsonConvert.SerializeObject(apiCollectionDocument, Config.Formatter.SerializerSettings);
}
else
{
var apiDocument = new JsonApiDocument();
apiDocument.FromApiResource(value, resource);
if (overridePrimaryType != null)
{
apiDocument.Data.Type = overridePrimaryType;
}
document = apiDocument;
serializeDocument = () => JsonConvert.SerializeObject(apiDocument, Config.Formatter.SerializerSettings);
}
if (request.Properties.TryGetValue(nameof(QueryInfo), out var queryInfoUntyped) && queryInfoUntyped is QueryInfo queryInfo && queryInfo.Includes != null)
{
foreach (var include in queryInfo.Includes)
{
document.IncludeRelation(resource, value, include);
}
}
document.Meta = meta;
}
meta.Benchmarks = benchmarks?.Benchmarks?.Select(b => $"{b.Name}:{b.Duration}");
#if DEBUG
var benchmarkSerialization = new BenchmarkCollection();
using (benchmarkSerialization.CreateBenchmark("Serialization"))
{
#endif
result.Content = new StringContent(serializeDocument(), Encoding.UTF8, "application/vnd.api+json");
#if DEBUG
}
foreach (var benchmark in benchmarkSerialization.Benchmarks)
{
Debug.WriteLine($"{benchmark.Name} took {benchmark.Duration} ms");
}
#endif
return(result);
}
catch (Exception e)
{
return(e.ToJsonApiErrorResponseMessage());
}
}
