public void Order_LeaseEncode()
{
var leaseExpires = DateTimeOffset.UtcNow + new TimeSpan(0, 5, 0);
var encode = OpenActiveSerializer.Serialize(new OrderQuote {
Lease = new Lease {
LeaseExpires = leaseExpires
}
});
var expectedLeaseJson = "{" +
"\"@context\":\"https://openactive.io/\"," +
"\"@type\":\"OrderQuote\"," +
"\"lease\":{" +
"\"@type\":\"Lease\"," +
$"\"leaseExpires\":\"{leaseExpires.ToString("yyyy-MM-ddTHH\\:mm\\:sszzz")}\"" +
"}" +
"}";
output.WriteLine(encode);
output.WriteLine(expectedLeaseJson);
Assert.Equal(expectedLeaseJson, encode);
var decode = OpenActiveSerializer.Deserialize <OrderQuote>(encode);
// Truncate milliseconds from leaseExpires
Assert.Equal(leaseExpires.AddTicks(-(leaseExpires.Ticks % TimeSpan.TicksPerSecond)), decode.Lease.LeaseExpires);
}
public void BetaOpportunity_Serialize()
{
var encode = OpenActiveSerializer.Serialize(this.opportunity);
output.WriteLine(encode);
Assert.Equal(this.jsonOpportunity, encode);
}
public void ToString_Serialize_Null()
{
var encode = OpenActiveSerializer.Serialize((ScheduledSession)null);
output.WriteLine(encode);
Assert.Equal("null", encode);
}
public void SessionSeries_Nested_EncodeDecode()
{
// Should recognise embedded identical subclasses when deserialising
var encode = OpenActiveSerializer.Serialize(nestedEvent);
output.WriteLine(encode);
Assert.Equal(nestedJson, encode);
}
public void BetaOpportunity_Deserialize()
{
var decode = OpenActiveSerializer.Deserialize <SessionSeries>(jsonOpportunity);
Assert.NotNull(decode);
Assert.NotNull(decode.AffiliatedLocation);
Assert.Equal("Santa Clara City Library, Central Park Library", decode.AffiliatedLocation.Name);
}
public void DeserializeRpdePage()
{
var page = OpenActiveSerializer.DeserializeRpdePage <SessionSeries>(this.jsonRpde);
var json = OpenActiveSerializer.SerializeRpdePage <SessionSeries>(page);
output.WriteLine(json);
Assert.Equal(this.jsonRpde, json);
}
public void DeserializeRpdePageEveryoneActive()
{
var page = OpenActiveSerializer.DeserializeRpdePage(this.jsonRpdeEveryoneActive);
var json = OpenActiveSerializer.SerializeRpdePage(page);
output.WriteLine(json);
Assert.Equal(this.jsonRpdeEveryoneActive.Replace("http://schema", "https://schema").Replace("http://openactive", "https://openactive").Replace("\"type\"", "\"@type\"").Replace("\"id\":", "\"@id\":").Replace("\"id\" :", "\"id\":").Replace("[\"https://openactive.io/\"]", "\"https://openactive.io/\""), json);
}
public void OrderQuote_EncodeDecode()
{
var decode = OpenActiveSerializer.Deserialize <OrderQuote>(json);
var encode = OpenActiveSerializer.Serialize(decode);
output.WriteLine(json);
output.WriteLine(encode);
Assert.Equal(json, encode);
}
public void ToString_EncodeDecode_SameAs()
{
var decode = OpenActiveSerializer.Deserialize <Organization>(organizationJson);
var encode = OpenActiveSerializer.Serialize(decode);
output.WriteLine(organizationJson);
output.WriteLine(encode);
Assert.Equal(organizationJson, encode);
}
public void BetaOpportunity_EncodeDecode()
{
var decode = OpenActiveSerializer.Deserialize <SessionSeries>(jsonOpportunity);
var encode = OpenActiveSerializer.Serialize(decode);
output.WriteLine(jsonOpportunity);
output.WriteLine(encode);
Assert.Equal(jsonOpportunity, encode);
}
public void Order_EncodeDecode()
{
var decode = OpenActiveSerializer.Deserialize <Order>(complexJson);
var encode = OpenActiveSerializer.Serialize(decode);
output.WriteLine(complexJson);
output.WriteLine(encode);
Assert.Equal(complexJson, encode);
}
public void ScheduledSession_EmbeddedEvent_EncodeDecode()
{
var decode = OpenActiveSerializer.Deserialize <ScheduledSession>(embeddedEventJson);
var encode = OpenActiveSerializer.Serialize(decode);
output.WriteLine(embeddedEventJson);
output.WriteLine(encode);
Assert.Equal(embeddedEventJson, encode);
}
public void SessionSeries_EncodeDecode()
{
// Should recognise subclasses of Event when deserialising
var decode = OpenActiveSerializer.Deserialize <SessionSeries>(json);
var encode = OpenActiveSerializer.Serialize(decode);
output.WriteLine(json);
output.WriteLine(encode);
Assert.Equal(json, encode);
}
public void ToString_TestInterfaceAction_DeserializeClass()
{
var decode = OpenActiveSerializer.Deserialize <ReplacementSimulateAction>(jsonAction);
Assert.NotNull(decode);
var decodeTyped = decode.Object.GetClass <Order>();
Assert.NotNull(decodeTyped);
Assert.Equal(new Uri("https://localhost:44396/api/openbooking/order-proposals/cacb58f6-50b5-570f-951f-acfba3d06986"), decodeTyped.Id);
}
public void ToString_EncodeDecodeList()
{
var originalList = "[{\"@type\":\"Concept\",\"@id\":\"https://openactive.io/facility-types#37bbed12-270b-42b1-9af2-70f0273990dd\",\"inScheme\":\"https://openactive.io/facility-types\",\"prefLabel\":\"Grass\"}]";
var decodeList = OpenActiveSerializer.DeserializeList <Concept>(originalList);
var encodeList = OpenActiveSerializer.SerializeList(decodeList);
output.WriteLine(originalList);
output.WriteLine(encodeList);
//Assert.Equal("https://openactive.io/facility-types#37bbed12-270b-42b1-9af2-70f0273990dd", decodeList.First().Id?.ToString());
Assert.Equal(originalList, encodeList);
}
public void OrderQuote_Deserialize_Accessors()
{
OrderQuote orderQuote = OpenActiveSerializer.Deserialize <OrderQuote>(json);
Assert.Equal(new Uri("https://www.example.com/offer/1"), orderQuote.OrderedItem[0].AcceptedOffer.Object.Id);
Assert.Equal(new Uri("https://www.example.com/sessionseries/1"), orderQuote.OrderedItem[0].OrderedItem.Object.Id);
Assert.Equal(new Uri("https://www.example.com/seller/1"), orderQuote.Seller.Object.Id);
Assert.Equal(BrokerType.ResellerBroker, orderQuote.BrokerRole);
Assert.Equal("Alan Peacock Way", orderQuote?.Broker?.Address?.StreetAddress);
Assert.Equal("Geoff", orderQuote.Customer.GivenName);
}
public void ToString_EncodeDecode()
{
var original = "{\"@context\":\"https://openactive.io/\",\"@type\":\"Concept\",\"@id\":\"https://openactive.io/facility-types#37bbed12-270b-42b1-9af2-70f0273990dd\",\"inScheme\":\"https://openactive.io/facility-types\",\"prefLabel\":\"Grass\"}";
var decode = OpenActiveSerializer.Deserialize <Concept>(original);
var encode = OpenActiveSerializer.Serialize(decode);
//output.WriteLine(decode.Id?.ToString());
output.WriteLine(original);
output.WriteLine(encode);
//Assert.Equal("https://openactive.io/facility-types#37bbed12-270b-42b1-9af2-70f0273990dd", decode.Id?.ToString());
Assert.Equal(original, encode);
}
public void OrderQuote_EncodeDecode()
{
var decode = OpenActiveSerializer.Deserialize <OrderQuote>(json);
var encode = OpenActiveSerializer.Serialize(decode);
// Should cast this to ScheduledSession instead of Event
Assert.IsType <ScheduledSession>(decode.OrderedItem[0].OrderedItem.Object);
output.WriteLine(json);
output.WriteLine(encode);
Assert.Equal(json, encode);
}
public ResponseContent ProcessOrderCreationB(string clientId, Uri sellerId, string uuid, string orderJson)
{
// Note B will never contain OrderItem level errors, and any issues that occur will be thrown as exceptions.
// If C1 and C2 are used correctly, B should not fail except in very exceptional cases.
Order order = OpenActiveSerializer.Deserialize <Order>(orderJson);
if (order == null || order.GetType() != typeof(Order))
{
throw new OpenBookingException(new UnexpectedOrderTypeError(), "Order is required for B");
}
return(ResponseContent.OpenBookingResponse(OpenActiveSerializer.Serialize(ValidateFlowRequest <Order>(clientId, sellerId, FlowStage.B, uuid, OrderType.Order, order)), HttpStatusCode.OK));
}
public void DeserializeRpdePage()
{
var page = OpenActiveSerializer.DeserializeRpdePage(this.jsonRpde);
var json = OpenActiveSerializer.SerializeRpdePage(page);
// Check known kinds are correctly deseralised
Assert.Equal(RpdeKind.SessionSeries, page.Items[0].Kind);
Assert.Equal("unknown_kind", page.Items[1].Kind);
output.WriteLine(json);
Assert.Equal(this.jsonRpde, json);
}
public void ScheduledSession_ReferencedEvent_Deserialize()
{
// Should recognise subclasses of Event when deserialising
var decode = OpenActiveSerializer.Deserialize <ScheduledSession>(referencedEventJson);
output.WriteLine(referencedEventJson);
output.WriteLine("");
output.WriteLine(decode.ToString());
// Test superEvent
Assert.True(decode.SuperEvent.HasValue);
Assert.Equal(new Uri("https://opensessions.io/api/session-series/1402CBP20150217"), decode.SuperEvent.IdReference);
Assert.Null(decode.SuperEvent.Object);
}
public void ScheduledSession_EventWithNull_Deserialize()
{
// Should recognise subclasses of Event when deserialising
var decode = OpenActiveSerializer.Deserialize <ScheduledSession>(eventJson);
output.WriteLine(eventJson);
output.WriteLine("");
output.WriteLine(decode.ToString());
// Test superEvent
Assert.False(decode.SuperEvent.HasValue);
Assert.Null(decode.SuperEvent.IdReference);
Assert.Null(decode.SuperEvent.Object);
}
public void ScheduledSession_EmbeddedEvent_Deserialize()
{
// Should recognise subclasses of Event when deserialising
var decode = OpenActiveSerializer.Deserialize <ScheduledSession>(embeddedEventJson);
output.WriteLine(embeddedEventJson);
output.WriteLine("");
output.WriteLine(decode.ToString());
// Test superEvent
Assert.True(decode.SuperEvent.HasValue);
Assert.NotNull(decode.SuperEvent.Object);
Assert.Equal("Super!", decode.SuperEvent.Object.Name);
}
private ResponseContent ProcessCheckpoint(string clientId, Uri sellerId, string uuid, string orderQuoteJson, FlowStage flowStage, OrderType orderType)
{
OrderQuote orderQuote = OpenActiveSerializer.Deserialize <OrderQuote>(orderQuoteJson);
if (orderQuote == null || orderQuote.GetType() != typeof(OrderQuote))
{
throw new OpenBookingException(new UnexpectedOrderTypeError(), "OrderQuote is required for C1 and C2");
}
var orderResponse = ValidateFlowRequest <OrderQuote>(clientId, sellerId, flowStage, uuid, orderType, orderQuote);
// Return a 409 status code if any OrderItem level errors exist
return(ResponseContent.OpenBookingResponse(OpenActiveSerializer.Serialize(orderResponse),
orderResponse.OrderedItem.Exists(x => x.Error?.Count > 0) ? HttpStatusCode.Conflict : HttpStatusCode.OK));
}
// Note opportunityType is required here to facilitate routing to the correct store to handle the request
public ResponseContent CreateTestData(string opportunityType, string eventJson)
{
Event @event = OpenActiveSerializer.Deserialize <ScheduledSession>(eventJson);
// Returns a matching Event subclass that will only include "@type" and "@id" properties
var createdEvent = this.CreateTestDataItem((OpportunityType)Enum.Parse(typeof(OpportunityType), opportunityType, true), @event);
if (createdEvent.Type != @event.Type)
{
throw new OpenBookingException(new OpenBookingError(), "Type of created test Event does not match type of requested Event");
}
return(ResponseContent.OpenBookingResponse(OpenActiveSerializer.Serialize(createdEvent), HttpStatusCode.OK));
}
public async Task <ResponseContent> GetOrderStatus(string clientId, Uri sellerId, string uuidString)
{
var(orderId, sellerIdComponents, seller) = await ConstructIdsFromRequest(clientId, sellerId, uuidString, OrderType.Order);
var result = await ProcessGetOrderStatus(orderId, sellerIdComponents, seller);
if (result == null)
{
throw new OpenBookingException(new UnknownOrderError());
}
else
{
return(ResponseContent.OpenBookingResponse(OpenActiveSerializer.Serialize(result), HttpStatusCode.OK));
}
}
/// <summary>
/// Writes the object retrieved from <see cref="Schema.NET.Thing"/> when one is found.
/// </summary>
/// <param name="writer">The JSON writer.</param>
/// <param name="value">The value to write.</param>
/// <param name="serializer">The JSON serializer.</param>
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
if (value == null)
{
writer.WriteNull();
}
else if (value is Schema.NET.Thing thing)
{
writer.WriteRawValue(OpenActiveSerializer.Serialize(thing));
}
else
{
throw new NotImplementedException();
}
}
public void ToString_Dataset_DataTime_Truncated()
{
// Should truncate milliseconds for recognised OpenActive types
DateTimeOffset timeWithMilliseconds = new DateTime(2012, 1, 1, 12, 00, 00, 100);
Dataset @dataset = new OpenActive.NET.Dataset
{
DatePublished = timeWithMilliseconds, // OpenActive type: should truncate
DateCreated = timeWithMilliseconds, // schema.org type: should not truncate
DateModified = timeWithMilliseconds // OpenActive type: should truncate
};
var serializedDataset = OpenActiveSerializer.Serialize(@dataset);
output.WriteLine(OpenActiveSerializer.Serialize(@dataset));
Assert.Equal("{\"@context\":\"https://openactive.io/\",\"@type\":\"Dataset\",\"dateModified\":\"2012-01-01T12:00:00+00:00\",\"datePublished\":\"2012-01-01T12:00:00+00:00\",\"dateCreated\":\"2012-01-01T12:00:00.1+00:00\"}", serializedDataset);
}
public async Task <ResponseContent> ProcessOrderProposalCreationP(string clientId, Uri sellerId, string uuidString, string orderJson)
{
// Note B will never contain OrderItem level errors, and any issues that occur will be thrown as exceptions.
// If C1 and C2 are used correctly, P should not fail except in very exceptional cases.
OrderProposal order = OpenActiveSerializer.Deserialize <OrderProposal>(orderJson);
if (order == null || order.GetType() != typeof(OrderProposal))
{
throw new OpenBookingException(new UnexpectedOrderTypeError(), "OrderProposal is required for P");
}
var(orderId, sellerIdComponents, seller) = await ConstructIdsFromRequest(clientId, sellerId, uuidString, OrderType.OrderProposal);
using (await asyncDuplicateLock.LockAsync(GetParallelLockKey(orderId)))
{
return(ResponseContent.OpenBookingResponse(OpenActiveSerializer.Serialize(await ProcessFlowRequest(ValidateFlowRequest <OrderProposal>(orderId, sellerIdComponents, seller, FlowStage.P, order), order)), HttpStatusCode.Created));
}
}
async Task <ResponseContent> IBookingEngine.TriggerTestAction(string actionJson)
{
OpenBookingSimulateAction action = OpenActiveSerializer.Deserialize <OpenBookingSimulateAction>(actionJson);
if (action == null)
{
throw new OpenBookingException(new OpenBookingError(), "Invalid type specified. Type must subclass OpenBookingSimulateAction.");
}
if (!action.Object.HasValue || ((Schema.NET.JsonLdObject)action.Object.Value).Id == null)
{
throw new OpenBookingException(new OpenBookingError(), "Invalid OpenBookingSimulateAction object specified.");
}
await this.TriggerTestAction(action, settings.OrderIdTemplate);
return(ResponseContent.OpenBookingNoContentResponse());
}
