public void Deserialize_ShouldBeAbleToHandle_NullDateTimeValues() { var response = new RestResponse { Content = "[{\"closed_at\":null}]" }; var serializer = new CustomJsonSerializer(); var issues = serializer.Deserialize<List<Issue>>(response); Assert.IsNull(issues[0].ClosedAt); }
public void DeserializeBadOperationId() { var json = "{\"$type\":\"OperationId\",\"Value\":-50}"; var operationId = _serializer.Deserialize(json) as OperationId; operationId.Value.Should().Be(-50); }
/// <summary> /// Invoke a synchronous service with the specified payload. The method call block until the method return. /// </summary> /// <typeparam name="TI">The payload type.</typeparam> /// <typeparam name="TO">The return type.</typeparam> /// <param name="serviceName">The name of the service, as configured in Argilla.Node.ServiceName.</param> /// <param name="payload">The payload used for invoke the service.</param> /// <returns></returns> public static TO Invoke <TI, TO>(string serviceName, TI payload) { TO outputValue = default; PayloadSync payloadSync = new PayloadSync() { Payload = payload }; string json = CustomJsonSerializer.Serialize(payloadSync); Exception lastException = null; try { Endpoint endpoint = GetFreeEndpoint(serviceName); string jsonResult = HttpHelper.Post(endpoint.EndpointSync, json); outputValue = CustomJsonSerializer.Deserialize <TO>(jsonResult); lastException = null; } catch (Exception ex) { logger.Error(ex.Message); ResolveResponse resolveResponse = Resolve(serviceName); foreach (Endpoint endpoint in resolveResponse.Endpoints) { try { string jsonResult = HttpHelper.Post(endpoint.EndpointSync, json); outputValue = CustomJsonSerializer.Deserialize <TO>(jsonResult); lastException = null; break; } catch (Exception e) { lastException = e; } } } if (lastException != null) { logger.Error(lastException, lastException.Message); throw lastException; } logger.Debug(String.Format("Output value: {0}", outputValue)); return(outputValue); }
public RegisterResponse Unregister(RegisterRequest registerRequest) { string resolverBaseAddress = ArgillaSettings.Current.Resolver.BaseAddress.EndsWith("/") ? ArgillaSettings.Current.Resolver.BaseAddress : ArgillaSettings.Current.Resolver.BaseAddress + "/"; string resolverAddress = resolverBaseAddress + "unregister"; string json = CustomJsonSerializer.Serialize(registerRequest); logger.Debug(String.Format("Registration request: {0}", json)); string result = HttpHelper.Post(resolverAddress, json); return(CustomJsonSerializer.Deserialize <RegisterResponse>(result)); }
/// <summary> /// Deserializes from JSON converting all JARRAYS to associative /// arrays... /// </summary> /// <typeparam name="TType"></typeparam> /// <param name="value"></param> /// <returns></returns> public static object DeserializeObject(string value, Type targetType) { using (var strReader = new StringReader(value)) { using (var jsonReader = new CustomJsonTextReader(strReader)) { var resolver = new CustomContractResolver(); var serializer = new CustomJsonSerializer { ContractResolver = resolver, ObjectCreationHandling = ObjectCreationHandling.Replace }; object unserialized = serializer.Deserialize(jsonReader, targetType); return(unserialized); } } }
public ResolveResponse Resolve(string serviceName) { string resolverBaseAddress = ArgillaSettings.Current.Resolver.BaseAddress.EndsWith("/") ? ArgillaSettings.Current.Resolver.BaseAddress : ArgillaSettings.Current.Resolver.BaseAddress + "/"; string resolverAddress = resolverBaseAddress + "resolve"; logger.Info(String.Format("Resolve service {0} on {1}", serviceName, resolverAddress)); string result = HttpHelper.Post(resolverAddress, CustomJsonSerializer.Serialize(new ResolveRequest() { ServiceName = serviceName })); logger.Debug(String.Format("Resove result: {0}", result)); return(CustomJsonSerializer.Deserialize <ResolveResponse>(result)); }
public ActionResult Callback([FromBody] PayloadSync payload) { string content = CustomJsonSerializer.Serialize(payload.Payload); MethodInfo methodInfo = ArgillaSettings.Current.MessageReceivedHandler; ParameterInfo[] pis = methodInfo.GetParameters(); ParameterInfo argumentPI = pis[0]; Type t = pis[0].ParameterType; object o = CustomJsonSerializer.Deserialize(content, t); object a = ArgillaSettings.Current.MessageReceivedHandler.Invoke(null, new[] { o }); string result = CustomJsonSerializer.Serialize(a); return(new ContentResult() { Content = result, ContentType = "application/json", StatusCode = 200 }); }
internal static void Process(Object o) { PayloadAsync payload = o as PayloadAsync; if (payload == null) { throw new PayloadNullException(); } if (ArgillaSettings.Current.MessageReceivedHandler == null) { throw new CallbackNullException(); } string jsonArgument = CustomJsonSerializer.Serialize(payload.Payload); logger.Info(String.Format("Json argument: {0}", jsonArgument)); MethodInfo methodInfo = ArgillaSettings.Current.MessageReceivedHandler; ParameterInfo[] pis = methodInfo.GetParameters(); ParameterInfo argumentPI = pis[0]; Type t = pis[0].ParameterType; object argument = CustomJsonSerializer.Deserialize(jsonArgument, t); object a = ArgillaSettings.Current.MessageReceivedHandler.Invoke(null, new[] { argument }); payload.Payload = a; string json = CustomJsonSerializer.Serialize(payload); logger.Info(String.Format("Json: {0}", json)); string result = HttpHelper.Post(payload.UrlCallback, json); logger.Info(String.Format("Result: {0}", result)); }
/// <summary> /// Handles the request. /// </summary> /// <param name="action">The action.</param> /// <returns></returns> protected Func <dynamic, dynamic> HandleRequest(Func <dynamic, dynamic> action) { return((arg) => { dynamic lockdown = this.HandleLockdown(arg); if (lockdown != null) { return lockdown; } dynamic result = null; try { if (this.Request.Headers.ContentType.Contains("application/json")) { bool error = false; try { using (var sr = new StreamReader(this.Request.Body)) using (var jr = new JsonTextReader(sr)) { arg.body = _Serializer.Deserialize(jr); } } catch (Exception) { error = true; } if (error) // cannot read normally { // try reading without type handling this.Request.Body.Position = 0; try { using (var sr = new StreamReader(this.Request.Body)) using (var jr = new JsonTextReader(sr)) { var ser = JsonSerializer.Create(new JsonSerializerSettings() { TypeNameHandling = TypeNameHandling.None }); arg.body = ser.Deserialize(jr); } } catch (Exception) { throw new InvalidOperationException("JSON is malformed."); } } } result = action(arg); } catch (UnauthorizedAccessException) { return 403; } catch (InvalidOperationException ex) { this.Context.Items["Exception"] = ex; return this.Negotiate .WithStatusCode(400) .WithModel(new { Code = 400, ExceptionType = ex.GetType().Name, Message = ex.Message }); } catch (Exception ex) { this.Context.Items["Exception"] = ex; return this.Negotiate .WithStatusCode(500) .WithModel(new { Code = 500, ExceptionType = ex.GetType().Name, Message = ex.Message }); } if (result is Nancy.Responses.Negotiation.Negotiator) { var negotiator = result as Nancy.Responses.Negotiation.Negotiator; if (negotiator.NegotiationContext.Headers.ContainsKey("Content-Type")) { if (negotiator.NegotiationContext.Headers["Content-Type"] == "application/json") { negotiator.NegotiationContext.Headers["Cache-Control"] = "no-store"; negotiator.NegotiationContext.Headers["Expires"] = "Mon, 26 Jul 1997 05:00:00 GMT"; negotiator.NegotiationContext.Headers["Vary"] = "*"; } } } return result; }); }
public override Task <BaseObject> Read() => _serializer.Deserialize(_reader);
public static void OnAsyncCompleted(Object o) { Greeting greeting = CustomJsonSerializer.Deserialize <Greeting>((string)o); logger.Info(string.Format("OnAsyncCompleted: {0}", greeting.Message)); }