internal static Response ConvertTo(VoidResponse voidResponse)
{
var response = new Response();
voidResponse.WriteBaseProperties(response);
var properties = new List <PaymentProperty>();
if (response.Properties != null)
{
properties.AddRange(response.Properties);
}
var voidRespnseProperties = new List <PaymentProperty>();
PaymentUtilities.AddPropertyIfPresent(voidRespnseProperties, GenericNamespace.VoidResponse, VoidResponseProperties.CardType, voidResponse.CardType);
PaymentUtilities.AddPropertyIfPresent(voidRespnseProperties, GenericNamespace.VoidResponse, VoidResponseProperties.Last4Digits, voidResponse.Last4Digit);
PaymentUtilities.AddPropertyIfPresent(voidRespnseProperties, GenericNamespace.VoidResponse, VoidResponseProperties.UniqueCardId, voidResponse.UniqueCardId);
PaymentUtilities.AddPropertyIfPresent(voidRespnseProperties, GenericNamespace.VoidResponse, VoidResponseProperties.ProviderTransactionId, voidResponse.ProviderTransactionId);
PaymentUtilities.AddPropertyIfPresent(voidRespnseProperties, GenericNamespace.VoidResponse, VoidResponseProperties.ResponseCode, voidResponse.ResponseCode);
PaymentUtilities.AddPropertyIfPresent(voidRespnseProperties, GenericNamespace.VoidResponse, VoidResponseProperties.CurrencyCode, voidResponse.CurrencyCode);
PaymentUtilities.AddPropertyIfPresent(voidRespnseProperties, GenericNamespace.VoidResponse, VoidResponseProperties.VoidResult, voidResponse.VoidResult);
PaymentUtilities.AddPropertyIfPresent(voidRespnseProperties, GenericNamespace.VoidResponse, VoidResponseProperties.ProviderMessage, voidResponse.ProviderMessage);
PaymentUtilities.AddPropertyIfPresent(voidRespnseProperties, GenericNamespace.VoidResponse, VoidResponseProperties.TransactionType, voidResponse.TransactionType);
PaymentUtilities.AddPropertyIfPresent(voidRespnseProperties, GenericNamespace.VoidResponse, VoidResponseProperties.TransactionDateTime, voidResponse.TransactionDateTime);
properties.Add(new PaymentProperty(GenericNamespace.VoidResponse, VoidResponseProperties.Properties, voidRespnseProperties.ToArray()));
response.Properties = properties.ToArray();
return(response);
}
private static bool SetSpecialTypes <TResponse>(byte[] bytes, IMemoryStreamFactory memoryStreamFactory, out TResponse cs)
where TResponse : class, IElasticsearchResponse, new()
{
cs = null;
var responseType = typeof(TResponse);
if (!SpecialTypes.Contains(responseType))
{
return(false);
}
if (responseType == typeof(StringResponse))
{
cs = new StringResponse(bytes.Utf8String()) as TResponse;
}
else if (responseType == typeof(BytesResponse))
{
cs = new BytesResponse(bytes) as TResponse;
}
else if (responseType == typeof(VoidResponse))
{
cs = new VoidResponse() as TResponse;
}
else if (responseType == typeof(DynamicResponse))
{
using (var ms = memoryStreamFactory.Create(bytes))
{
var body = LowLevelRequestResponseSerializer.Instance.Deserialize <DynamicDictionary>(ms);
cs = new DynamicResponse(body) as TResponse;
}
}
return(cs != null);
}
public VoidResponse VoidTransaction(string authorizationId)
{
VoidResponse response;
if (_repo.TryGetAuthorization(authorizationId, out var authorization))
{
if (authorization.IsVoid)
{
response = new VoidResponse(authorization.Currency, authorization.AmountCaptured)
{
IsError = true, Message = $"{authorization.CardNumber}: Unable to void transaction as it is already void"
};
}
else
{
_repo.VoidTransaction(authorizationId);
response = new VoidResponse(authorization.Currency, authorization.AmountCaptured)
{
Message = $"{authorization.CardNumber}: Transaction voided successfully"
};
}
}
else
{
response = new VoidResponse(string.Empty, -1)
{
IsError = true, Message = $"Invalid authorization Id - {authorizationId}"
};
}
return(response);
}
public void VoidSale_Error_Transaction()
{
var errorVoidResponse = new VoidResponse
{
HttpStatus = HttpStatusCode.BadRequest,
Links = null,
ReasonCode = 0,
Status = 0,
ReasonMessage = null,
ErrorDataCollection = new List <Error>()
{
new Error
{
Code = 500,
Message = "Internal Server Error"
}
}
};
_mockRestClient.Setup(m => m.Execute <VoidResponse>(It.IsAny <IRestRequest>())).Returns(new RestResponse <VoidResponse>()
{
StatusCode = HttpStatusCode.BadRequest,
Content = new JsonSerializer().Serialize(errorVoidResponse),
Data = errorVoidResponse
});
var response = _service.Void(Guid.NewGuid(), MerchantAuthenticationHelper.CreateMerchantAuthentication(), VoidTransactionHelper.CreateValidVoidRequest());
response.ErrorDataCollection.Count.Should().BeGreaterThan(0);
response.HttpStatus.Should().Be(HttpStatusCode.BadRequest);
response.ReasonCode.Should().Be(0);
response.ReasonMessage.Should().BeNull();
response.Status.Should().Be(0);
response.Links.Should().BeNull();
}
public async void Run_SimpleVoidTest()
{
ShowTestOnTerminal("SimpleVoid");
AuthorizationRequest setupRequest = new AuthorizationRequest
{
Pan = "4111111111111111",
ExpMonth = "12",
ExpYear = "2025",
Amount = "25.55",
Test = true,
TransactionRef = Guid.NewGuid().ToString("N"),
};
output.WriteLine("Setup request: {0}", setupRequest);
AuthorizationResponse setupResponse = await blockchyp.ChargeAsync(setupRequest);
output.WriteLine("Setup Response: {0}", setupResponse);
VoidRequest request = new VoidRequest
{
TransactionId = setupResponse.TransactionId,
Test = true,
};
output.WriteLine("Request: {0}", request);
VoidResponse response = await blockchyp.VoidAsync(request);
output.WriteLine("Response: {0}", response);
Assert.True(response.Success, "response.Success");
Assert.True(response.Approved, "response.Approved");
}
public VoidResponse Salvar()
{
var response = new VoidResponse();
response.AddMensagem(TipoDeMensagem.Erro, "Erro ao tentar incluir Pessoa.");
return(response);
}
public async Task Should_return_response_if_successful(
CastleConfiguration configuration)
{
var response = new VoidResponse();
Task <VoidResponse> Send() => Task.FromResult(response);
var result = await Track.Execute(Send, configuration);
result.Should().Be(response);
}
public void VoidResponse_should_be_a_singleton(
VoidResponse aVoidResponse,
VoidResponse anotherVoidResponse)
{
"Given a VoidResponse instance"
.Given(() => aVoidResponse = VoidResponse.Instance);
"And another VoidResponse instance"
.And(() => anotherVoidResponse = VoidResponse.Instance);
"Then they should be referentially equal to each other"
.Then(() => aVoidResponse.Should().BeSameAs(anotherVoidResponse));
}
private async Task ShouldVoidPayment_IdempotencyKey()
{
var voidResponse = new VoidResponse();
_apiClient.Setup(apiClient =>
apiClient.Post <VoidResponse>(PaymentsPath + "/payment_id/voids", _authorization,
null,
CancellationToken.None, "test"))
.ReturnsAsync(() => voidResponse);
IPaymentsClient paymentsClient = new PaymentsClient(_apiClient.Object, _configuration.Object);
var response = await paymentsClient.VoidPayment("payment_id", null, "test");
response.ShouldNotBeNull();
}
private async Task ShouldVoidPayment()
{
var voidRequest = new VoidRequest();
var voidResponse = new VoidResponse();
_apiClient.Setup(apiClient =>
apiClient.Post <VoidResponse>("klarna-external/orders/id/voids", _authorization,
voidRequest,
CancellationToken.None, null))
.ReturnsAsync(() => voidResponse);
var klarnaClient = new KlarnaClient(_apiClient.Object, _configuration.Object);
var response = await klarnaClient.VoidPayment("id", voidRequest, CancellationToken.None);
response.ShouldNotBeNull();
}
private static bool SetSpecialTypes <TResponse>(string mimeType, byte[] bytes, IMemoryStreamFactory memoryStreamFactory, out TResponse cs)
where TResponse : class, IElasticsearchResponse, new()
{
cs = null;
var responseType = typeof(TResponse);
if (!SpecialTypes.Contains(responseType))
{
return(false);
}
if (responseType == typeof(StringResponse))
{
cs = new StringResponse(bytes.Utf8String()) as TResponse;
}
else if (responseType == typeof(BytesResponse))
{
cs = new BytesResponse(bytes) as TResponse;
}
else if (responseType == typeof(VoidResponse))
{
cs = new VoidResponse() as TResponse;
}
else if (responseType == typeof(DynamicResponse))
{
//if not json store the result under "body"
if (mimeType != RequestData.MimeType)
{
var dictionary = new DynamicDictionary();
dictionary["body"] = new DynamicValue(bytes.Utf8String());
cs = new DynamicResponse(dictionary) as TResponse;
}
else
{
using (var ms = memoryStreamFactory.Create(bytes))
{
var body = LowLevelRequestResponseSerializer.Instance.Deserialize <DynamicDictionary>(ms);
cs = new DynamicResponse(body) as TResponse;
}
}
}
return(cs != null);
}
public VoidResponse Void(Guid paymentId, MerchantAuthentication merchantAuthentication, VoidRequest voidRequest)
{
var restRequest = new RestRequest(@"sales/{paymentId}/void", Method.PUT)
{
RequestFormat = DataFormat.Json
};
AddHeaders(restRequest, merchantAuthentication);
restRequest.AddUrlSegment("paymentId", paymentId.ToString());
if (voidRequest.Amount != null)
{
restRequest.AddQueryParameter("amount", voidRequest.Amount.ToString());
}
var response = RestClient.Execute <VoidResponse>(restRequest);
VoidResponse voidResponse = null;
if (response.StatusCode == HttpStatusCode.OK)
{
voidResponse = JsonConvert.DeserializeObject <VoidResponse>(response.Content);
}
else if (response.StatusCode == HttpStatusCode.BadRequest)
{
voidResponse = new VoidResponse {
ErrorDataCollection = JsonDeserializer.Deserialize <List <Error> >(response)
}
}
;
else
{
voidResponse = new VoidResponse();
}
voidResponse.HttpStatus = response.StatusCode;
return(voidResponse);
}
public override string VoidOrder(int OrderNumber)
{
String result = String.Empty;
DB.ExecuteSQL("update orders set VoidTXCommand=NULL, VoidTXResult=NULL where OrderNumber=" + OrderNumber.ToString());
String TransID = String.Empty;
using (var con = new SqlConnection(DB.GetDBConn()))
{
con.Open();
using (var rs = DB.GetRS("select * from orders with (NOLOCK) where OrderNumber=" + OrderNumber.ToString(), con))
{
if (rs.Read())
{
// If you are voiding a transaction that has been reauthorized,
// use the ID from the original authorization, and not the reauthorization.
TransID = Regex.Match(DB.RSField(rs, "AuthorizationPNREF"), "(?<=AUTH=)[0-9A-Z]+", RegexOptions.Compiled).ToString();
}
}
}
if (TransID.Length == 0 || TransID == "0")
{
result = "Invalid or Empty Transaction ID";
}
else
{
try
{
DoVoidReq VoidReq = new DoVoidReq();
DoVoidRequestType VoidRequestType = new DoVoidRequestType();
DoVoidResponseType VoidResponse;
VoidRequestType.AuthorizationID = TransID;
VoidRequestType.Version = API_VER;
VoidReq.DoVoidRequest = VoidRequestType;
VoidResponse = (DoVoidResponseType)IPayPal.DoVoid(VoidReq);
//if (LogToErrorTable)
//{
// PayPalController.Log(XmlCommon.SerializeObject(VoidReq, VoidReq.GetType()), "DoVoid Request");
// PayPalController.Log(XmlCommon.SerializeObject(VoidResponse, VoidResponse.GetType()), "DoVoid Response");
//}
DB.ExecuteSQL("update orders set VoidTXCommand=" + DB.SQuote(XmlCommon.SerializeObject(VoidReq, VoidReq.GetType()))
+ ", VoidTXResult=" + DB.SQuote(XmlCommon.SerializeObject(VoidResponse, VoidResponse.GetType())) + " where OrderNumber=" + OrderNumber.ToString());
if (VoidResponse != null && VoidResponse.Ack.ToString().StartsWith("success", StringComparison.InvariantCultureIgnoreCase))
{
result = AppLogic.ro_OK;
}
else
{
if (VoidResponse.Errors != null)
{
bool first = true;
for (int ix = 0; ix < VoidResponse.Errors.Length; ix++)
{
if (!first)
{
result += ", ";
}
result += "Error: [" + VoidResponse.Errors[ix].ErrorCode + "] " + VoidResponse.Errors[ix].LongMessage;
first = false;
}
}
}
}
catch
{
result = "NO RESPONSE FROM GATEWAY!";
}
}
return(result);
}
public void OnVoidTransactionResponse(VoidResponse response)
{
foreach (POSOrder order in Store.Orders)
{
foreach (POSPayment payment in order.Payments)
{
payment.PaymentStatus = POSPayment.Status.VOIDED;
break;
}
}
uiThread.Send(delegate (object state) {
VoidButton.Enabled = false;
}, null);
}
