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));
}
