public static Token extractPaylod(string _token)
{
string jsonPayload = "";
Token tokenPayload = null;
try
{
IJsonSerializer serializer = new JsonNetSerializer();
IDateTimeProvider provider = new UtcDateTimeProvider();
IJwtValidator validator = new JwtValidator(serializer, provider);
IBase64UrlEncoder urlEncoder = new JwtBase64UrlEncoder();
IJwtDecoder decoder = new JwtDecoder(serializer, validator, urlEncoder);
string secret = ConfigurationManager.AppSettings["key"].ToString();
jsonPayload = decoder.Decode(_token, secret, verify: true);
tokenPayload = serializer.Deserialize <Token>(jsonPayload);
//Console.WriteLine(json);
}
catch (TokenExpiredException)
{
Console.WriteLine("Token has expired");
}
catch (SignatureVerificationException)
{
Console.WriteLine("Token has invalid signature");
}
return(tokenPayload);
}
public ActivationPolicy GetActivationPolicy(long deviceId)
{
ActivationPolicy activationPolicy = null;
bearerToken = new Authentication().GetBearerToken(Scope.Activation, deviceId);
var url = appSettingsReader.GetValue("serverBase", typeof(string)).ToString() + appSettingsReader.GetValue("actPolicyEndpoint", typeof(string)).ToString();
using (var httpClient = new HttpClient())
{
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", bearerToken.AccessToken);
httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
httpClient.DefaultRequestHeaders.Add("X-ActivationId", appSettingsReader.GetValue("deviceActivationId", typeof(string)).ToString());
Console.WriteLine(url);
HttpResponseMessage response = httpClient.GetAsync(url).Result;
IJsonSerializer serializer = new JsonNetSerializer();
using (var responseStream = response.Content.ReadAsStreamAsync().Result)
{
if (responseStream == null)
{
return(null);
}
using (var streamReader = new StreamReader(responseStream))
{
var responseContent = streamReader.ReadToEnd();
Console.WriteLine(responseContent);
activationPolicy = serializer.Deserialize <ActivationPolicy>(responseContent);
}
}
}
return(activationPolicy);
}
public async Task <bool> TrainModel()
{
try
{
var command = new Command
{
Id = EnvelopeId.NewId(),
To = Node.Parse("*****@*****.**"),
Uri = new LimeUri("/models"),
Method = CommandMethod.Set,
Resource = new ModelTraining()
};
var envelopeSerializer = new JsonNetSerializer();
var commandString = envelopeSerializer.Serialize(command);
var httpContent = new StringContent(commandString, Encoding.UTF8, "application/json");
HttpResponseMessage response = await _client.PostAsync("/commands", httpContent);
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
var envelopeResult = (Command)envelopeSerializer.Deserialize(responseBody);
return(true);
}
catch (HttpRequestException e)
{
Console.WriteLine("\nException Caught!");
Console.WriteLine("Message :{0} ", e.Message);
return(false);
}
}
private async Task <Command> RunCommandAsync(Command command)
{
var commandString = _envelopeSerializer.Serialize(command);
using (var httpContent = new StringContent(commandString, Encoding.UTF8, "application/json"))
{
try
{
var response = await _client.PostAsync("/commands", httpContent);
response.EnsureSuccessStatusCode();
var responseBody = await response.Content.ReadAsStringAsync();
return((Command)_envelopeSerializer.Deserialize(responseBody));
}
catch (Exception ex)
{
Console.WriteLine("INNER");
Console.WriteLine(ex.InnerException);
Console.WriteLine();
Console.WriteLine();
throw;
}
}
}
public void Can_Compression()
{
var serialize = new JsonNetSerializer();
var foo = TestHelper.GetFoo();
var output1 = new MemoryStream();
var output2 = new MemoryStream();
serialize.Serialize(foo, output1);
var rtl1 = output1.ToArray();
//compress
var gzip = new GZipStream(output2, CompressionLevel.Fastest);
StreamWriter sw2 = new StreamWriter(gzip);
serialize.Serialize(foo, sw2);
sw2.Dispose();
var rtl2 = output2.ToArray();
//comparing the size
Assert.True(rtl2.Length < rtl1.Length);
//decompress
var gzip2 = new GZipStream(new MemoryStream(rtl2), CompressionMode.Decompress);
StreamReader sr = new StreamReader(gzip2);
var foo2 = serialize.Deserialize <Foo>(sr);
Assert.Equal(foo.ToString(), foo2.ToString());
}
public void CanCloneJsonSerializedModel()
{
var model = new CloneModel {
IntProperty = 1,
StringProperty = "test",
ListProperty = new List <int> {
1
},
ObjectProperty = new CloneModel {
IntProperty = 1
}
};
var serializer = new JsonNetSerializer();
var result = serializer.SerializeToBytes(model);
var deserialized = serializer.Deserialize <CloneModel>(result);
Assert.Equal(model.IntProperty, deserialized.IntProperty);
Assert.Equal(model.StringProperty, deserialized.StringProperty);
Assert.Equal(model.ListProperty, deserialized.ListProperty);
var dm = ((JToken)deserialized.ObjectProperty).ToObject <CloneModel>();
Assert.Equal(((CloneModel)model.ObjectProperty).IntProperty, dm.IntProperty);
var cloned = deserialized.DeepClone();
Assert.Equal(model.IntProperty, cloned.IntProperty);
Assert.Equal(model.StringProperty, cloned.StringProperty);
Assert.Equal(model.ListProperty, cloned.ListProperty);
var cdm = ((JToken)cloned.ObjectProperty).ToObject <CloneModel>();
Assert.Equal(((CloneModel)model.ObjectProperty).IntProperty, cdm.IntProperty);
}
public bool BindModel(HttpActionContext actionContext, ModelBindingContext bindingContext)
{
var json = actionContext.Request.Content.ReadAsStringAsync().Result;
bindingContext.Model = _serializer.Deserialize(json);
return(bindingContext.Model != null);
}
/// <summary>
/// 用JWT套件解碼Token
/// </summary>
/// <param name="token"></param>
/// <returns></returns>
public static Token DecodeToken(string token)
{
try
{
IJsonSerializer serializer = new JsonNetSerializer();
var provider = new UtcDateTimeProvider();
IJwtValidator validator = new JwtValidator(serializer, provider);
IBase64UrlEncoder urlEncoder = new JwtBase64UrlEncoder();
IJwtAlgorithm algorithm = new HMACSHA256Algorithm(); // symmetric
IJwtDecoder decoder = new JwtDecoder(serializer, validator, urlEncoder, algorithm);
var json = decoder.Decode(token, cKey, verify: true);
var payload = serializer.Deserialize <Token>(json);
return(payload);
}
catch (TokenExpiredException ex)
{
Log.Error(new Exception("Token has expired", ex));
}
catch (SignatureVerificationException ex)
{
Log.Error(new Exception("Token has invalid signature", ex));
}
return(null);
}
public void Can_Compression() {
var serialize = new JsonNetSerializer();
var foo = TestHelper.GetFoo();
var output1 = new MemoryStream();
var output2 = new MemoryStream();
serialize.Serialize(foo, output1);
var rtl1 = output1.ToArray();
//compress
var gzip = new GZipStream(output2, CompressionLevel.Fastest);
StreamWriter sw2 = new StreamWriter(gzip);
serialize.Serialize(foo, sw2);
sw2.Dispose();
var rtl2 = output2.ToArray();
//comparing the size
Assert.True(rtl2.Length < rtl1.Length);
//decompress
var gzip2 = new GZipStream(new MemoryStream(rtl2), CompressionMode.Decompress);
StreamReader sr = new StreamReader(gzip2);
var foo2 = serialize.Deserialize<Foo>(sr);
Assert.Equal(foo.ToString(), foo2.ToString());
}
/// <summary>
/// jwt解密
/// </summary>
/// <returns></returns>
public static T JwtDecrypt <T>(HttpControllerContext context)
{
IEnumerable <string> values;
context.Request.Headers.TryGetValues("token", out values);
string token = values.First();
try
{
IJsonSerializer serializer = new JsonNetSerializer();
IDateTimeProvider provider = new UtcDateTimeProvider();
IJwtValidator validator = new JwtValidator(serializer, provider);
IBase64UrlEncoder urlEncoder = new JwtBase64UrlEncoder();
IJwtDecoder decoder = new JwtDecoder(serializer, validator, urlEncoder);
var json = decoder.Decode(token, secret, verify: true);
return(serializer.Deserialize <T>(json));
}
catch (TokenExpiredException)
{
return(default(T));
}
catch (SignatureVerificationException)
{
return(default(T));
}
}
// POST api/values
public void Post([FromBody] JObject jsonObject)
{
var envelopeSerializer = new JsonNetSerializer();
var notification = envelopeSerializer.Deserialize(jsonObject.ToString());
Console.WriteLine("Received Notification");
}
public List <string> GetIKTokenFromStr(string key)
{
string s = "/db_materialture/_analyze?analyzer=ik_smart&text=" + key;
var result = Client.Get(s);
var serializer = new JsonNetSerializer();
var list = serializer.Deserialize(result, typeof(ik)) as ik;
return(list.tokens.Select(c => c.token).ToList());
}
public void ShouldHandleHeartbeat()
{
using (var heartbeat = new RequestSocket(HeartbeatEndpoint))
{
var payload = _eventSerializer.Serializer.Serialize(Heartbeat.Query);
heartbeat.SendFrame(payload);
var hasResponse = heartbeat.TryReceiveFrameBytes(TimeSpan.FromMilliseconds(1000), out var responseBytes);
Assert.IsTrue(hasResponse);
var response = _serializer.Deserialize <Heartbeat>(responseBytes);
Assert.IsNotNull(response);
Assert.AreEqual(HeartbeatType.Pong, response.Type);
}
}
/// <summary>
/// 将搜索词语用ik分词，返回分词结果的集合
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
private List <string> GetIKTokenFromStr(string key)
{
string s = $"_analyze?analyzer=ik_max_word&pretty=true&text={key}";
var result = _client.Get(s);
var serializer = new JsonNetSerializer();
var list = serializer.Deserialize(result, typeof(ik)) as ik;
return(list.tokens.Select(c => c.token).ToList());
}
//将语句用ik分词，返回分词结果的集合
private List <string> GetIKTokenFromStr(string key)
{
string s = "/db_test/_analyze?analyzer=ik";
var result = Client.Post(s, "{" + key + "}");
var serializer = new JsonNetSerializer();
var list = serializer.Deserialize(result, typeof(ik)) as ik;
return(list.tokens.Select(c => c.token).ToList());
}
public void TestSerialize()
{
var serializer = new JsonNetSerializer();
var message = new CacheEventMessage("1", "Beaver0", CacheEventType.Get);
var data = serializer.Serialize(message);
var deserialized = serializer.Deserialize <CacheEventMessage>(data);
Assert.AreEqual(message, deserialized);
}
public async Task <DocumentCollection> GetAllDocumentKeysAsync(BucketNamespace bucketNamespace = BucketNamespace.Document)
{
string @namespace;
switch (bucketNamespace)
{
case BucketNamespace.Document:
@namespace = "buckets";
break;
case BucketNamespace.Resource:
@namespace = "resources";
break;
case BucketNamespace.Profile:
@namespace = "profile";
break;
default:
@namespace = "buckets";
break;
}
try
{
var command = new Command
{
Id = EnvelopeId.NewId(),
To = Node.Parse("*****@*****.**"),
Uri = new LimeUri($"/{@namespace}/"),
Method = CommandMethod.Get
};
var documentSerializer = new DocumentSerializer();
var envelopeSerializer = new JsonNetSerializer();
var commandString = envelopeSerializer.Serialize(command);
var httpContent = new StringContent(commandString, Encoding.UTF8, "application/json");
HttpResponseMessage response = await _client.PostAsync("/commands", httpContent);
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
var envelopeResult = (Command)envelopeSerializer.Deserialize(responseBody);
return(envelopeResult.Resource as DocumentCollection);
}
catch (HttpRequestException e)
{
Console.WriteLine("\nException Caught!");
Console.WriteLine("Message :{0} ", e.Message);
return(null);
}
}
public void GivenAJSONContainingATopicMessage_ICanGetATopicMessageResponseObject()
{
var json = SerializedMessages.ResourceManager.GetString("TopicMessageResponseJSON");
var serializer = new JsonNetSerializer();
var topicMessage = serializer.Deserialize <TopicMessageResponse>(json);
Assert.NotNull(topicMessage);
Assert.Equal(-1, topicMessage.MessageId);
}
protected TMessage Unwrap(BrokeredMessage message)
{
var tMessage = default(TMessage);
var type = typeof(TMessage);
var serializer = new JsonNetSerializer();
var obj = serializer.Deserialize(message, type);
tMessage = (obj as TMessage);
return(tMessage);
}
public void BlazorTypeInfoSerializerTest()
{
var serializer = new JsonNetSerializer().ToTyped <Box <DateTime> >();
var serialized = serializer.Serialize(new Box <DateTime>(DateTime.Now));
Out.WriteLine(serialized);
var deserialized = serializer.Deserialize(serialized);
Out.WriteLine(deserialized.Value.ToString());
}
public static Dictionary <string, object> Verify(string token)
{
IJsonSerializer serializer = new JsonNetSerializer();
IBase64UrlEncoder urlEncoder = new JwtBase64UrlEncoder();
var segments = token.Split('.');
if (segments.Length != 3)
{
throw new Exception("token invalid");
}
var header = serializer.Deserialize <Dictionary <string, string> >(
System.Text.Encoding.UTF8.GetString(urlEncoder.Decode(segments[0])));
if (header["alg"] != "EK256K")
{
throw new Exception("alg should be EK256K but got " + header["alg"]);
}
var payload = serializer.Deserialize <Dictionary <string, object> >(
System.Text.Encoding.UTF8.GetString(urlEncoder.Decode(segments[1])));
var signature = urlEncoder.Decode(segments[2]);
var empty = new Account();
var recoveredAddress = empty.Recover(segments[0] + "." + segments[1], signature, false);
var secretOrPublicKey = payload["iss"].ToString();
var expectedAddress = Account.PublicKeyToAddress(secretOrPublicKey.HexToByteArray());
if (recoveredAddress != expectedAddress)
{
throw new Exception(recoveredAddress + " signed the signature but we are expecting " + expectedAddress);
}
if (payload["iss"].ToString() != secretOrPublicKey)
{
throw new Exception("issuer of the token does not match " + secretOrPublicKey);
}
return(payload);
}
public void can_serialize_and_deserialize()
{
// arrange
var sut = new JsonNetSerializer();
var expectedResult = AutoFixture.Create <GameOver>();
// act
var result = (GameOver)sut.Deserialize(sut.Serialize(expectedResult), typeof(GameOver));
//assert
result.Should().BeEquivalentTo(expectedResult);
}
public void ModelManagerTestReplication()
{
IWorldData worldData = new WorldData();
ISerializer serializer = new JsonNetSerializer();
var replication = new WorldReplication(worldData, new JsonCastObject());
var replicationWrote = replication.WriteWhole();
var serialized = serializer.Serialize(replicationWrote);
serializer.Deserialize(serialized, out object deserialized);
replication.Read(deserialized);
}
public BearerAccessToken GetBearerToken(Scope scope, long deviceId)
{
BearerAccessToken bearerToken = null;
string jwtToken = GetJwtToken(scope, deviceId);
Console.WriteLine($"JWT Token: {jwtToken}");
var username = appSettingsReader.GetValue("username", typeof(string)).ToString();
var password = appSettingsReader.GetValue("password", typeof(string)).ToString();
var url = appSettingsReader.GetValue("serverBase", typeof(string)).ToString() + appSettingsReader.GetValue("authEndpoint", typeof(string)).ToString();
var data = new Dictionary <string, string>
{
{ "grant_type", "client_credentials" },
{ "client_assertion_type", "urn:ietf:params:oauth:client-assertion-type:jwt-bearer" },
{ "client_assertion", jwtToken },
{ "scope", scope == Scope.Activation ? "oracle/iot/activation" : "" }
}.AsEnumerable();
using (var httpClient = new HttpClient())
{
var content = new FormUrlEncodedContent(data);
content.Headers.Clear();
content.Headers.Add("Content-Type", "application/x-www-form-urlencoded");
String authHeader = System.Convert.ToBase64String(ASCIIEncoding.ASCII.GetBytes(username + ":" + password));
//httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", authHeader);
httpClient.DefaultRequestHeaders.Add("Authorization", "Basic " + authHeader);
httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
HttpResponseMessage response = httpClient.PostAsync(url, content).Result;
IJsonSerializer serializer = new JsonNetSerializer();
using (var responseStream = response.Content.ReadAsStreamAsync().Result)
{
if (responseStream == null)
{
return(null);
}
using (var streamReader = new StreamReader(responseStream))
{
var responseContent = streamReader.ReadToEnd();
Console.WriteLine(responseContent);
bearerToken = serializer.Deserialize <BearerAccessToken>(responseContent);
Console.WriteLine($"Bearer {bearerToken.AccessToken}");
}
}
}
return(bearerToken);
}
public void TestMessageIsSerializable()
{
var msg = new DurableMessageBusTests.TestDurableEvent("0");
var serializer = new JsonNetSerializer();
var serialized = serializer.SerializeToStream(msg);
var deserialized = serializer.Deserialize <DurableMessageBusTests.TestDurableEvent>(serialized);
Assert.That(deserialized, Is.Not.Null);
Assert.That(deserialized.Payload, Is.EqualTo(msg.Payload));
Assert.That(deserialized.AcknowledgmentId, Is.EqualTo(msg.AcknowledgmentId));
Assert.That(deserialized.Version, Is.EqualTo(msg.Version));
}
private async Task <Command> RunCommandAsync(Command command)
{
var commandString = _envelopeSerializer.Serialize(command);
using (var httpContent = new StringContent(commandString, Encoding.UTF8, "application/json"))
{
var response = await _client.PostAsync("/commands", httpContent);
response.EnsureSuccessStatusCode();
var responseBody = await response.Content.ReadAsStringAsync();
return((Command)_envelopeSerializer.Deserialize(responseBody));
}
}
/// <inheritdoc />
public Task<IMultiSearchResponse> MultiSearchAsync(IMultiSearchRequest request)
{
return this.Dispatcher.DispatchAsync<IMultiSearchRequest, MultiSearchRequestParameters, MultiSearchResponse, IMultiSearchResponse>(
request,
(p, d) =>
{
var converter = CreateMultiSearchDeserializer(p);
var serializer = new JsonNetSerializer(this.ConnectionSettings, converter);
var json = serializer.SerializeToBytes(p).Utf8String();
var creator = new MultiSearchCreator((r, s) => serializer.Deserialize<MultiSearchResponse>(s));
request.RequestParameters.DeserializationOverride(creator);
return this.LowLevelDispatch.MsearchDispatchAsync<MultiSearchResponse>(p, json);
}
);
}
/// <summary>
/// 解密token为token结构
/// </summary>
/// <param name="encodetokenStr"></param>
/// <returns></returns>
public static TokenClaims DecodeToken(string encodetokenStr)
{
IJsonSerializer serializer = new JsonNetSerializer();
IDateTimeProvider provider = new UtcDateTimeProvider();
IJwtValidator validator = new JwtValidator(serializer, provider);
IBase64UrlEncoder urlEncoder = new JwtBase64UrlEncoder();
IJwtDecoder decoder = new JwtDecoder(serializer, validator, urlEncoder);
var json = decoder.Decode(encodetokenStr, ConfigHelper.GetConfig <string>("jwtsecret"), verify: true);//token为之前生成的字符串
TokenPayload paload = serializer.Deserialize <TokenPayload>(json);
return(new TokenClaims()
{
TokenPayload = paload
});
}
public void GivenAJSONContainingADownstreamMessage_ICanGetADOwnstreamMessageResponseObject()
{
var json = SerializedMessages.ResourceManager.GetString("DownstreamMessageResponseJSON");
var serializer = new JsonNetSerializer();
var downstreamMessage = serializer.Deserialize <DownstreamMessageResponse>(json);
Assert.NotNull(downstreamMessage);
Assert.Equal(216, downstreamMessage.MulticastId);
Assert.Equal(3, downstreamMessage.Success);
Assert.Equal(3, downstreamMessage.Failure);
Assert.Equal(1, downstreamMessage.CanonicalIds);
Assert.Equal(6, downstreamMessage.Results.Count);
}
private static bool TryLoadNewestJson <T>(string cacheDir, out T data)
{
DirectoryInfo dir = new DirectoryInfo(cacheDir);
var files = dir.GetFiles().ToList();
if (files.Count > 0)
{
files.Sort((f1, f2) => f2.LastWriteTime.CompareTo(f1.LastWriteTime));
var file = files.First();
Console.WriteLine("Loading Mock-Response from " + file.FullName);
data = jsonNetSerializer.Deserialize <T>(file.OpenText().ReadToEnd());
return(true);
}
data = default(T);
return(false);
}
public async Task <AnalysisResponse> Analyse(string analysisRequest)
{
if (analysisRequest == null)
{
throw new ArgumentNullException(nameof(analysisRequest));
}
try
{
var command = new Command
{
Id = EnvelopeId.NewId(),
To = Node.Parse("*****@*****.**"),
Uri = new LimeUri("/analysis"),
Method = CommandMethod.Set,
Resource = new AnalysisRequest
{
Text = analysisRequest
}
};
var documentSerializer = new DocumentSerializer();
var envelopeSerializer = new JsonNetSerializer();
var commandString = envelopeSerializer.Serialize(command);
var httpContent = new StringContent(commandString, Encoding.UTF8, "application/json");
HttpResponseMessage response = await _client.PostAsync("/commands", httpContent);
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
var envelopeResult = (Command)envelopeSerializer.Deserialize(responseBody);
return(envelopeResult.Resource as AnalysisResponse);
}
catch (HttpRequestException e)
{
Console.WriteLine("\nException Caught!");
Console.WriteLine("Message :{0} ", e.Message);
return(null);
}
}
/// <summary>
/// 解密token为token结构
/// </summary>
/// <param name="encodetokenStr"></param>
/// <returns></returns>
public static TokenClaims DecodeToken(string encodetokenStr)
{
try
{
IJsonSerializer serializer = new JsonNetSerializer();
IDateTimeProvider provider = new UtcDateTimeProvider();
IJwtValidator validator = new JwtValidator(serializer, provider);
IBase64UrlEncoder urlEncoder = new JwtBase64UrlEncoder();
IJwtDecoder decoder = new JwtDecoder(serializer, validator, urlEncoder);
var json = decoder.Decode(encodetokenStr, TokenConfig.JwtKey, verify: true);//token为之前生成的字符串
TokenClaims claim = serializer.Deserialize <TokenClaims>(json);
return(claim);
}
catch (Exception ex)
{
ToolFactory.LogHelper.Error("解密token发生异常", ex);
throw ex;
}
}
public void Deserializes()
{
// arrange
var expectedResult = new SerializerWorks
{
BecauseItsAwesome = true,
Inception = new SerializerWorks {
BecauseItsAwesome = true
}
};
var input = "{\"BecauseItsAwesome\":true,\"Inception\":{\"BecauseItsAwesome\":true}}";
var sut = new JsonNetSerializer();
// act
var result = sut.Deserialize(input, expectedResult.GetType());
// assert
result.ShouldBeEquivalentTo(expectedResult);
}
private List<JsonWeek> GetJsonSchedule()
{
if (this._jsonWeeks == null)
{
this._jsonWeeks = new List<string>()
{
// day 1 day 2 day 3 day 4 day 5 day 6 day 7
@"[{'AE':[1,2]}, {'AE':[3,4]}, {'AE':[5,1]}, {'AE':[2,3]}, {'AE':[4,5]}, {'AE':[1,2]}, {'AE':[3,4]}]",
@"[{'AE':[5,1]}, {'AE':[2,3]}, {'AE':[4,5]}, {'AE':[1,2]}, {'AE':[3,4]}, {'AE':[5,1]}, {'AE':[2,3]}]",
@"[{'AE':[4,5]}, {'AE':[1,2]}, {'AE':[3,4]}, {'AE':[5,1]}, {'AE':[2,3]}, {'AE':[4,5]}, {'AE':[1,2]}]",
@"[{'AE':[3,4]}, {'AE':[5,1]}, {'AE':[2,3]}, {'AE':[4,5]}, {'AE':[1,2]}, {'AE':[3,4]}, {'AE':[5,1]}]",
};
}
JsonNetSerializer serializer = new JsonNetSerializer();
List<JsonWeek> JsonSchedule = new List<JsonWeek>();
foreach (string jsonWeek in this._jsonWeeks)
{
JsonSchedule.Add(new JsonWeek(serializer.Deserialize<List<JsonDay>>(jsonWeek)));
}
return JsonSchedule;
}
private List<JsonWeek> GetJsonSchedule()
{
// day 1 day 2 day 3 day 4 day 5 day 6 day 7
string jsonWeek1 = @"[{'AE':[1,2]}, {'AE':[3,4]}, {'AE':[5,1]}, {'AE':[2,3]}, {'AE':[4,5]}, {'AE':[1,2]}, {'AE':[3,4]}]";
string jsonWeek2 = @"[{'AE':[5,1]}, {'AE':[2,3]}, {'AE':[4,5]}, {'AE':[1,2]}, {'AE':[3,4]}, {'AE':[5,1]}, {'AE':[2,3]}]";
string jsonWeek3 = @"[{'AE':[4,5]}, {'AE':[1,2]}, {'AE':[3,4]}, {'AE':[5,1]}, {'AE':[2,3]}, {'AE':[4,5]}, {'AE':[1,2]}]";
string jsonWeek4 = @"[{'AE':[3,4]}, {'AE':[5,1]}, {'AE':[2,3]}, {'AE':[4,5]}, {'AE':[1,2]}, {'AE':[3,4]}, {'AE':[5,1]}]";
JsonNetSerializer serializer = new JsonNetSerializer();
List<JsonWeek> JsonSchedule = new List<JsonWeek>();
JsonSchedule.Add(new JsonWeek(serializer.Deserialize<List<JsonDay>>(jsonWeek1)));
JsonSchedule.Add(new JsonWeek(serializer.Deserialize<List<JsonDay>>(jsonWeek2)));
JsonSchedule.Add(new JsonWeek(serializer.Deserialize<List<JsonDay>>(jsonWeek3)));
JsonSchedule.Add(new JsonWeek(serializer.Deserialize<List<JsonDay>>(jsonWeek4)));
return JsonSchedule;
}
