public void DeserializationOfListOfMessageSubscriptionPayload()
{
ISerializerService serializerService = this.serializationFixture.SerializerService;
var expectedCategoryId = "3df866bd-7e5f-47d1-bbe2-ca1d1f39a260";
string serialized = File.ReadAllText("Resources/Messages/MessageSubscriptionPayload.json");
var payload = serializerService.Deserialize <Payload>(serialized);
Assert.NotNull(payload);
var categoryCreatedPayload = payload as MessageSubscriptionPayload <Category>;
Assert.NotNull(categoryCreatedPayload);
Assert.Equal(expectedCategoryId, categoryCreatedPayload.Resource.Id);
Assert.NotNull(categoryCreatedPayload.Message);
var categoryCreatedMessage = categoryCreatedPayload.Message as CategoryCreatedMessage;
Assert.NotNull(categoryCreatedMessage);
Assert.Equal(expectedCategoryId, categoryCreatedMessage.Category.Id);
}
public void DeserializeLocalizedString()
{
ISerializerService serializerService = this.serializationFixture.SerializerService;
string serialized = @"
{
""name"": {
""en"": ""name-en"",
""en-US"": ""name-en-us""
}
}
";
var product = serializerService.Deserialize <ProductProjection>(serialized);
Assert.Equal("name-en", product.Name["en"]);
Assert.Equal("name-en-us", product.Name["en-US"]);
}
private async Task VerifyAsync(RemotableData remotableData, ISerializerService serializerService, CancellationToken cancellationToken)
{
using (var stream = new MemoryStream())
using (var writer = new ObjectWriter(stream, cancellationToken))
{
await remotableData.WriteObjectToAsync(writer, cancellationToken).ConfigureAwait(false);
stream.Position = 0;
using (var reader = ObjectReader.TryGetReader(stream, cancellationToken))
{
var value = serializerService.Deserialize <object>(remotableData.Kind, reader, cancellationToken);
var checksum = serializerService.CreateChecksum(value, cancellationToken);
Debug.Assert(checksum == remotableData.Checksum);
}
}
}
public void DeserializeCustomField()
{
ISerializerService serializerService = this.serializationFixture.SerializerService;
string serialized = @"
{
""fields"": {
""foo"": ""bar"",
""Foos"": ""Bars""
}
}
";
var customFields = serializerService.Deserialize <CustomFields>(serialized);
Assert.Equal("bar", customFields.Fields["foo"]);
Assert.Equal("Bars", customFields.Fields["Foos"]);
}
private static async Task <RemotableData> CloneAssetAsync(ISerializerService serializer, RemotableData asset)
{
using (var stream = SerializableBytes.CreateWritableStream())
using (var writer = new ObjectWriter(stream))
{
await asset.WriteObjectToAsync(writer, CancellationToken.None).ConfigureAwait(false);
stream.Position = 0;
using (var reader = ObjectReader.TryGetReader(stream))
{
var recovered = serializer.Deserialize <object>(asset.Kind, reader, CancellationToken.None);
var assetFromStorage = SolutionAsset.Create(serializer.CreateChecksum(recovered, CancellationToken.None), recovered, serializer);
Assert.Equal(asset.Checksum, assetFromStorage.Checksum);
return(assetFromStorage);
}
}
}
private static SolutionAsset CloneAsset(ISerializerService serializer, SolutionAsset asset)
{
using var stream = SerializableBytes.CreateWritableStream();
using var context = new SolutionReplicationContext();
using (var writer = new ObjectWriter(stream, leaveOpen: true))
{
serializer.Serialize(asset.Value, writer, context, CancellationToken.None);
}
stream.Position = 0;
using var reader = ObjectReader.TryGetReader(stream);
var recovered = serializer.Deserialize <object>(asset.Kind, reader, CancellationToken.None);
var assetFromStorage = new SolutionAsset(serializer.CreateChecksum(recovered, CancellationToken.None), recovered);
Assert.Equal(asset.Checksum, assetFromStorage.Checksum);
return(assetFromStorage);
}
public void MessagesDeserializationOfDifferentTypes()
{
//Deserialize 3 of messages of different types
ISerializerService serializerService = this.serializationFixture.SerializerService;
string serialized = File.ReadAllText("Resources/Messages/Messages.json");
var messages = serializerService.Deserialize <List <Message> >(serialized);
var categoryCreatedMessage = messages[0] as CategoryCreatedMessage;
var customerCreatedMessage = messages[1] as CustomerCreatedMessage;
var lineItemStateTransitionMessage = messages[2] as LineItemStateTransitionMessage;
Assert.NotNull(categoryCreatedMessage);
Assert.NotNull(categoryCreatedMessage.Category);
Assert.NotNull(customerCreatedMessage);
Assert.NotNull(customerCreatedMessage.Customer);
Assert.NotNull(lineItemStateTransitionMessage);
}
public void DeserializationOfListOfChangeSubscriptionPayloads()
{
ISerializerService serializerService = this.serializationFixture.SerializerService;
string serialized = File.ReadAllText("Resources/Messages/Payloads.json");
var payloads = serializerService.Deserialize <List <Payload> >(serialized);
Assert.NotNull(payloads);
Assert.Equal(4, payloads.Count);
var resourceCreatedPayload = payloads[0] as ResourceCreatedPayload <Customer>;
var resourceUpdatedPayload = payloads[1] as ResourceUpdatedPayload <Category>;
var resourceDeletedPayload = payloads[2] as ResourceDeletedPayload <Product>;
var customerCreatedPayload = payloads[3] as MessageSubscriptionPayload <Customer>;
Assert.NotNull(resourceCreatedPayload);
Assert.NotNull(resourceUpdatedPayload);
Assert.NotNull(resourceDeletedPayload);
Assert.NotNull(customerCreatedPayload);
Assert.Equal(2, resourceUpdatedPayload.OldVersion);
}
public async Task <Conference> GetRemoteConferenceAsync()
{
var conference = new Conference();
if (_connectivityService.IsConnected)
{
try {
var stream = await _httpService.GetResponseAsync(_appConfig.GuidebookAddress);
var guidebook = await _serializerService.Deserialize <GuidebookDto> (stream);
conference = _mapperService.MapGuidebookToConference(guidebook);
} catch (Exception) {
return(conference);
}
}
return(conference);
}
public void HighPrecisionMoneyDeserialization()
{
ISerializerService serializerService = this.serializationFixture.SerializerService;
string serialized = @"{
""type"": ""highPrecision"",
""currencyCode"": ""EUR"",
""centAmount"": 123456,
""preciseAmount"": 12345678,
""fractionDigits"": 4
}";
var deserialized = serializerService.Deserialize <BaseMoney>(serialized);
Assert.IsType <HighPrecisionMoney>(deserialized);
Assert.Equal("EUR", deserialized.CurrencyCode);
Assert.Equal(MoneyType.HighPrecision, deserialized.Type);
Assert.Equal(123456, deserialized.CentAmount);
Assert.Equal(1234.5678M, deserialized.AmountToDecimal());
Assert.Equal(4, deserialized.FractionDigits);
}
public Task Initialize()
{
ISerializerService serializer = ConceptMatrix.Services.Get <ISerializerService>();
string json = File.ReadAllText("MainOffsets.json");
MainOffsetFile file = serializer.Deserialize <MainOffsetFile>(json);
// Set the names of all the offsets for debugging.
PropertyInfo[] properties = file.GetType().GetProperties();
foreach (PropertyInfo property in properties)
{
Offset offset = (Offset)property.GetValue(file);
offset.Name = property.Name;
property.SetValue(file, offset);
}
Offsets.Main = file;
return(Task.CompletedTask);
}
public void DeserializeProductWithSetNestedAttribute()
{
ISerializerService serializerService = this.serializationFixture.SerializerService;
string productSerialized = File.ReadAllText("Resources/Types/ProductWithSetNestedAttribute.json");
var product = serializerService.Deserialize <Product>(productSerialized);
var attr = product.MasterData.Current.MasterVariant.Attributes[0];
Assert.True(attr.IsSetOfNestedAttribute());
var setOfNestedAttr = attr.ToSetOfNestedAttribute();
Assert.NotNull(setOfNestedAttr);
Assert.Equal(2, setOfNestedAttr.Value.Count);
var firstNestedAttr = setOfNestedAttr.Value.FirstOrDefault();
Assert.NotNull(firstNestedAttr);
Assert.Equal(2, firstNestedAttr.Value.Count);
Assert.True(firstNestedAttr.Value[0].IsNumberAttribute());
Assert.True(firstNestedAttr.Value[1].IsTextAttribute());
}
public async Task <Team> GetInfoAsync()
{
Team SportsTeams = null;
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri($"{Config.ApiUrl}/teams"),
Headers =
{
{ Config.ApiKeyHeader, Config.ApiKey },
{ Config.ApiHostHeader, Config.ApiHost },
},
};
var client = new HttpClient();
var response = await client.SendAsync(request);
if (response.IsSuccessStatusCode)
{
SportsTeams = _serializerService.Deserialize <Team>(await response.Content.ReadAsStringAsync());
}
return(SportsTeams);
}
public async Task <Team> GetSportsTeamsAsync()
{
Team SportsTeams = null;
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("https://sportscore1.p.rapidapi.com/teams"),
Headers =
{
{ "x-rapidapi-key", "" },
{ "x-rapidapi-host", "sportscore1.p.rapidapi.com" },
},
};
var client = new HttpClient();
var response = await client.SendAsync(request);
if (response.IsSuccessStatusCode)
{
SportsTeams = serializerService.Deserialize <Team>(await response.Content.ReadAsStringAsync());
}
return(SportsTeams);
}
private static IList <(Checksum, object)> ReadAssets(
Stream stream,
int scopeId,
ISet <Checksum> checksums,
ISerializerService serializerService,
CancellationToken cancellationToken)
{
var results = new List <(Checksum, object)>();
using var reader = ObjectReader.TryGetReader(stream, cancellationToken);
// We only get a reader for data transmitted between live processes.
// This data should always be correct as we're never persisting the data between sessions.
Contract.ThrowIfNull(reader);
var responseScopeId = reader.ReadInt32();
Contract.ThrowIfFalse(scopeId == responseScopeId);
var count = reader.ReadInt32();
Contract.ThrowIfFalse(count == checksums.Count);
for (var i = 0; i < count; i++)
{
var responseChecksum = Checksum.ReadFrom(reader);
Contract.ThrowIfFalse(checksums.Contains(responseChecksum));
var kind = (WellKnownSynchronizationKind)reader.ReadInt32();
// in service hub, cancellation means simply closed stream
var result = serializerService.Deserialize <object>(kind, reader, cancellationToken);
results.Add((responseChecksum, result));
}
return(results);
}
public async Task <ObservableCollection <Ranking> > GetRankingAync(string queue, string tier, string division)
{
if (tier == "CHALLENGER" || tier == "GRANDMASTER" || tier == "MASTER")
{
division = "I";
}
ObservableCollection <Ranking> ranking = null;
var refitClient = RestService.For <IRankingApi>(Config.NaRankingApiUrl);
var rankingResponse = await refitClient.GetRankingAync(queue, tier, division, Config.ApiKey);
if (rankingResponse.IsSuccessStatusCode)
{
var jsonRanking = await rankingResponse.Content.ReadAsStringAsync();
ranking = SerializerService.Deserialize <ObservableCollection <Ranking> >(jsonRanking);
ranking = new ObservableCollection <Ranking>(ranking.OrderByDescending(x => x.LeaguePoints));
}
return(ranking);
}
public void DeserializeAttributeListAndGetAttributeValue()
{
ISerializerService serializerService = this.serializationFixture.SerializerService;
string serialized = File.ReadAllText("Resources/Attributes/List.json");
ProductVariant deserialized = serializerService.Deserialize <ProductVariant>(serialized);
var attributes = deserialized.Attributes;
Assert.NotEmpty(attributes);
Assert.True(attributes[0].IsTextAttribute());
var textAttribute = attributes[0].ToTextAttribute();
Assert.NotNull(textAttribute);
Assert.True(attributes[1].IsEnumAttribute());
var enumAttribute = attributes[1].ToEnumAttribute();
Assert.NotNull(enumAttribute);
Assert.True(attributes[2].IsBooleanAttribute());
var boolAttribute = attributes[2].ToBooleanAttribute();
Assert.NotNull(boolAttribute);
}
public void DeserializeOfSubscriptions()
{
ISerializerService serializerService = this.serializationFixture.SerializerService;
string serialized = File.ReadAllText("Resources/Messages/Subscriptions.json");
var subscriptions = serializerService.Deserialize <List <Subscription> >(serialized);
Assert.Equal(2, subscriptions.Count);
Assert.IsType <SqsDestination>(subscriptions[0].Destination);
Assert.IsType <SnsDestination>(subscriptions[1].Destination);
var subscription1 = subscriptions[0];
var subscription2 = subscriptions[1];
Assert.IsType <PlatformFormat>(subscription1.Format);
var subscription2Format = subscription2.Format as CloudEventsFormat;
Assert.NotNull(subscription2Format);
Assert.Equal("0.1", subscription2Format.CloudEventsVersion);
Assert.Equal(SubscriptionHealthStatus.Healthy, subscription1.Status);
Assert.Equal(SubscriptionHealthStatus.TemporaryError, subscription2.Status);
Assert.Single(subscription1.Messages);
Assert.Single(subscription2.Changes);
Assert.Equal(SubscriptionResourceTypeId.Product, subscription1.Messages[0].GetResourceTypeIdAsEnum());
Assert.Equal(SubscriptionResourceTypeId.Unknown, subscription2.Changes[0].GetResourceTypeIdAsEnum());
}
public static async Task ProcessOrderCommandFunction([ServiceBusTrigger(ProcessPostCommand.CommandQueueName)] string message, ILogger logger)
{
logger.LogInformation(message);
var command = serializerService.Deserialize <ProcessPostCommand>(message);
await workerApplicationService.ProcessPostAsync(command);
}
private void HistoryProcess(MessageReceivedEventArgs message)
{
var historyReponse = _serializerService.Deserialize <HistoryResponse>(message.Message);
OnRepeater(ActionTypes.History, true, historyReponse);
}
Settings ReadSettings()
{
var content = _fileSystemService.Read(_fileName);
return(_serializerService.Deserialize <Settings>(content));
}
/// <summary>
/// Reads from.
/// </summary>
/// <param name="stream">The stream.</param>
/// <returns></returns>
public T ReadFrom(Stream stream)
{
return(serializerService.Deserialize <T>(stream));
}
