private async Task <ClientSignedResponse> SignWrapper <T>(ServerSignedRequest <T> request, Func <T, Task <ClientResponse> > func) where T : IClientCallback
{
ServerResponse <T> sins = new ServerResponse <T>();
try
{
PaymentGatewayClient cl = PaymentGatewayClientFactory.GetClient(request.Object.Object.Client);
if (cl == null)
{
throw new ResultCodeException(ResultCodes.ClientServerError, ("en", $"Unable to locate PaymentGatewayClient for client '{request.Object.Object.Client}'."), ("es", $"No puedo encontrar una clase que defina a PaymentGatewayClient con el client '{request.Object.Object.Client}'."));
}
using (var scope = new FlowingOperationContextScope(cl.InnerChannel))
{
sins = await cl.UnwrapRequest(request).ContinueOnScope(scope);
}
if (sins.ResultCode != ResultCodes.Ok)
{
return(GenerateError(sins, request.Object.Object.Client));
}
if (CallbackImplementation == null)
{
throw new ResultCodeException(ResultCodes.ClientServerError, ("en", "Callback message lost.There is no ICallback implementation"), ("es", "Mensaje del callback pedido. No hay implementacion de ICallback"));
}
ClientResponse cr = await func(sins.Response);
cr.Client = request.Object.Object.Client;
return(CertificateHelperFactory.Instance.SignClient <ClientSignedResponse, ClientResponse>(cr.Client, cr));
}
catch (Exception e)
{
sins.PopulateFromException(e, Logger);
return(GenerateError(sins, request.Object.Object.Client));
}
}
public static void PopulateFromException(this ServerResponse resp, Exception exception, ILog log = null)
{
if (exception is ResultCodeException)
{
resp.PopulateFromException((ResultCodeException)exception, log);
return;
}
resp.ResultCode = ResultCodes.SystemError;
resp.I18NErrorMessages = new Dictionary <string, string>
{
{ "en", "System Error, please try later" },
{ "es", "Error del Sistema, pruebe nuevamente mas tarde" }
};
resp.ErrorMessage = resp.I18NErrorMessages["en"];
log?.ErrorException(resp.ErrorMessage, exception);
}
internal async Task <ServerResponse> UnwrapResponse(ServerSignedResponse resp)
{
ServerResponse response = new ServerResponse();
try
{
SignatureHelper c = await GetSignatureHelper(resp.Object.Fingerprint, response);
return(c.Verify <ServerSignedResponse, ServerResponse>(resp));
}
catch (Exception e)
{
response.PopulateFromException(e, Logger);
return(response);
}
}
internal async Task <ServerResponse <T> > UnwrapRequest <T>(ServerSignedRequest <T> resp)
{
ServerResponse <T> response = new ServerResponse <T>();
try
{
SignatureHelper c = await GetSignatureHelper(resp.Object.Fingerprint, response);
T obj = c.Verify <ServerSignedRequest <T>, T>(resp);
return(new ServerResponse <T> {
ResultCode = ResultCodes.Ok, Response = obj
});
}
catch (Exception e)
{
response.PopulateFromException(e, Logger);
return(response);
}
}
private async Task <ServerResponse> OnlyRunOnIntranet(Func <Task <ServerResponse> > func)
{
if (Properties.Settings.Default.EnableTesting)
{
return(await func());
}
try
{
string ip = null;
MessageProperties prop = OperationContext.Current?.IncomingMessageProperties;
if (prop != null)
{
if (prop.ContainsKey(RemoteEndpointMessageProperty.Name))
{
RemoteEndpointMessageProperty endpoint = prop[RemoteEndpointMessageProperty.Name] as RemoteEndpointMessageProperty;
if (endpoint != null)
{
ip = endpoint.Address;
}
}
}
if (ip == null)
{
ip = HttpContext.Current.Request.UserHostAddress;
}
if (ip == null)
{
throw new ResultCodeException(ResultCodes.SystemError, ("en", "Unable to get incoming ip"), ("es", "No puedo obtener el ip de origen"));
}
if (IsIntranet(ip))
{
return(await func());
}
throw new ResultCodeException(ResultCodes.Forbidden, ("en", "Not allowed to request from Internet"), ("es", "No se puede llamar a este servicio desde internet"));
}
catch (Exception e)
{
ServerResponse s = new ServerResponse();
s.PopulateFromException(e, Logger);
return(s);
}
}
