public void ShouldNotReturnFaultedPaymentFromCache()
{
Guid paymentId = Guid.Empty;
try
{
Guid merchantPaymentRequestId = Guid.NewGuid();
PaymentRequest request = GetValidPaymentRequest();
request.MerchantPaymentRequestId = merchantPaymentRequestId;
string message = "Insufficient Funds";
var response = new TransactionResponse
{
Status = false,
Message = message
};
_bankClient.ProcessTransaction(Arg.Do <TransactionRequest>(x => paymentId = x.PaymentGatewayTxId)).Returns(x => throw new Exception("Network Error"));
PaymentResponse txResponse = _service.ProcessPayment(request);
Assert.Fail();
}
catch (Exception e)
{
Assert.That(e.Message.ToLowerInvariant().Contains("network"));
}
PaymentDetailsResponse details = _service.GetPaymentDetails(_merchantId, paymentId);
Assert.That(paymentId, Is.Not.EqualTo(Guid.Empty));
Assert.That(details, Is.Null);
}
private void AssetProcessDetails(PaymentDetailsResponse details, PaymentRequest request, PaymentResponse txResponse, Guid expectedMerchantPaymentRequestId,
Guid bankTransactionId, bool expectedIsSuccess = true, string expectedErrorMessage = null)
{
//verify status
Assert.That(details.Status, Is.EqualTo(expectedIsSuccess));
//verify ids
Assert.That(details.MerchantId, Is.EqualTo(_merchantId));
Assert.That(details.MerchantPaymentRequestId, Is.EqualTo(expectedMerchantPaymentRequestId));
Assert.That(details.PaymentGatewayTxId, Is.EqualTo(txResponse.PaymentGatewayTxId));
Assert.That(details.BankTransactionId, Is.EqualTo(bankTransactionId));
//other fields
Assert.That(details.Amount, Is.EqualTo(request.Amount));
Assert.That(details.Cvv, Is.EqualTo(request.CVV));
Assert.That(details.ExpiryMonthDate, Is.EqualTo(request.ExpiryMonthDate));
Assert.That(details.Ccy, Is.EqualTo(request.Ccy));
//assert masked card number
Assert.That(details.MaskedCardNumber.StartsWith("XXXX"));
Assert.That(details.MaskedCardNumber.EndsWith("XXXX"));
Assert.That(request.CardNumber.Contains(details.MaskedCardNumber.Replace("X", string.Empty)));
Assert.That(details.Message, Is.EqualTo(expectedErrorMessage));
}
/// <summary>
/// Gets execution status of a payment by PayKey
/// </summary>
/// <param name="payKey"></param>
/// <returns></returns>
public PaymentExecStatusSEnum GetPaymentExecutionStatus(string payKey)
{
Check.Require(string.IsNullOrEmpty(payKey) == false, "PayPalService.GetPaymentStatus: PayKey is required.");
PaymentDetailsRequest request = new PaymentDetailsRequest(new RequestEnvelope("en_US"));
request.payKey = payKey;
Dictionary <string, string> configurationMap = FWUtils.ConfigUtils.GetAppSettings().Paypal.GetAcctAndConfig();
AdaptivePaymentsService service = new AdaptivePaymentsService(configurationMap);
PaymentDetailsResponse response = service.PaymentDetails(request);
string ack = response.responseEnvelope.ack.ToString().Trim().ToUpper();
// if no error happened
if (!ack.Equals(AckCode.FAILURE.ToString()) &&
!ack.Equals(AckCode.FAILUREWITHWARNING.ToString()))
{
PaymentExecStatusSEnum execStatus = new PaymentExecStatusSEnum(response.status);
return(execStatus);
}
else
{
throw new UserException(GetPayPalErrorString(response.error));
}
}
private void RetreivePreviousPayment()
{
using (WebClient wc = new WebClient())
{
try
{
wc.Headers.Add(HttpRequestHeader.ContentType, "application/json");
string response = wc.DownloadString($@"{_apiRootUri}/details?merchantId={SelectedTransaction.Merchant.Id}&paymentId={SelectedTransaction.GatewayPaymentId}");
PaymentDetailsResponse paymentResponse = JsonConvert.DeserializeObject <PaymentDetailsResponse>(response);
CurrentPreviousPayment = new PreviousPaymentDetails
{
Amount = paymentResponse.Amount,
Cvv = paymentResponse.Cvv,
Expiry = paymentResponse.ExpiryMonthDate,
MaskedCardNumber = paymentResponse.MaskedCardNumber,
PaymentId = paymentResponse.PaymentGatewayTxId,
Status = paymentResponse.Status,
TransactionId = paymentResponse.BankTransactionId,
Message = paymentResponse.Message
};
}
catch (Exception e)
{
MessageBox.Show(e.Message);
}
}
}
/**
* AUTO_GENERATED
*/
public PaymentDetailsResponse PaymentDetails(PaymentDetailsRequest paymentDetailsRequest, string apiUserName)
{
string response = Call("PaymentDetails", paymentDetailsRequest.ToNVPString(""), apiUserName);
NVPUtil util = new NVPUtil();
return(PaymentDetailsResponse.CreateInstance(util.ParseNVPString(response), "", -1));
}
public void PaymentDetails()
{
PaymentDetailsSample sample = new PaymentDetailsSample();
PaymentDetailsResponse responsePaymentDetails = sample.PaymentDetailsAPIOperation();
Assert.IsNotNull(responsePaymentDetails);
Assert.IsNotNull(responsePaymentDetails.status);
}
/// <summary>
///
/// </summary>
///<param name="paymentDetailsRequest"></param>
///<param name="credential">An explicit ICredential object that you want to authenticate this call against</param>
public PaymentDetailsResponse PaymentDetails(PaymentDetailsRequest paymentDetailsRequest, ICredential credential)
{
IAPICallPreHandler apiCallPreHandler = new PlatformAPICallPreHandler(this.config, paymentDetailsRequest.ToNVPString(string.Empty), ServiceName, "PaymentDetails", credential);
((PlatformAPICallPreHandler)apiCallPreHandler).SDKName = SDKName;
((PlatformAPICallPreHandler)apiCallPreHandler).SDKVersion = SDKVersion;
((PlatformAPICallPreHandler)apiCallPreHandler).PortName = "AdaptivePayments";
NVPUtil util = new NVPUtil();
return(PaymentDetailsResponse.CreateInstance(util.ParseNVPString(Call(apiCallPreHandler)), string.Empty, -1));
}
public void ShouldReturnProcessedFailPaymentFromCache()
{
Guid merchantPaymentRequestId = Guid.NewGuid();
PaymentRequest request = GetValidPaymentRequest();
request.MerchantPaymentRequestId = merchantPaymentRequestId;
string message = "Insufficient Funds";
var response = new TransactionResponse
{
Status = false,
Message = message
};
_bankClient.ProcessTransaction(Arg.Is <TransactionRequest>(x => x.CardNumber == request.CardNumber && x.Amount == request.Amount)).Returns(response);
PaymentResponse txResponse = _service.ProcessPayment(request);
PaymentDetailsResponse details = _service.GetPaymentDetails(_merchantId, txResponse.PaymentGatewayTxId);
AssetProcessDetails(details, request, txResponse, merchantPaymentRequestId, Guid.Empty, false, message);
}
public void ShouldReturnProcessedSuccessPaymentFromCache()
{
Guid bankingTransactionId = Guid.NewGuid();
Guid merchantPaymentRequestId = Guid.NewGuid();
PaymentRequest request = GetValidPaymentRequest();
request.MerchantPaymentRequestId = merchantPaymentRequestId;
var response = new TransactionResponse
{
BankTransactionId = bankingTransactionId,
Status = true,
};
_bankClient.ProcessTransaction(Arg.Is <TransactionRequest>(x => x.CardNumber == request.CardNumber && x.Amount == request.Amount)).Returns(response);
var txResponse = _service.ProcessPayment(request);
PaymentDetailsResponse details = _service.GetPaymentDetails(_merchantId, txResponse.PaymentGatewayTxId);
AssetProcessDetails(details, request, txResponse, merchantPaymentRequestId, bankingTransactionId);
}
public IActionResult GetPaymentDetails(Guid merchantId, Guid paymentId)
{
try
{
_logger.LogInformation($"Processing {nameof(GetPaymentDetails)} merchantId:{merchantId} paymentId:{paymentId}");
PaymentDetailsResponse response = this._paymentGatewayService.GetPaymentDetails(merchantId, paymentId);
if (response == null)
{
_logger.LogInformation($"Processed {nameof(GetPaymentDetails)} merchantId:{merchantId} paymentId:{paymentId}. No match found!");
return(NotFound());
}
_logger.LogInformation($"Processed {nameof(GetPaymentDetails)} merchantId:{merchantId} paymentId:{paymentId}");
return(new OkObjectResult(response));
}
catch (Exception e)
{
_logger.LogError(e, $"Operation {nameof(GetPaymentDetails)} errored. merchandId:{merchantId} paymentId:{paymentId}");
return(new StatusCodeResult((int)HttpStatusCode.InternalServerError));
}
}
/// <summary>
/// Handle PaymentDetails API call
/// </summary>
/// <param name="context"></param>
private void PaymentDetails(HttpContext context)
{
NameValueCollection parameters = context.Request.Params;
PaymentDetailsRequest req = new PaymentDetailsRequest(new RequestEnvelope("en_US"));
// set optional parameters
if (parameters["payKey"] != "")
req.payKey = parameters["payKey"];
if (parameters["transactionId"] != "")
req.transactionId = parameters["transactionId"];
if (parameters["trackingId"] != "")
req.trackingId = parameters["trackingId"];
// All set. Fire the request
AdaptivePaymentsService service = new AdaptivePaymentsService();
PaymentDetailsResponse resp = null;
try
{
resp = service.PaymentDetails(req);
}
catch (System.Exception e)
{
context.Response.Write(e.Message);
return;
}
// Display response values.
Dictionary<string, string> keyResponseParams = new Dictionary<string, string>();
string redirectUrl = null;
if (!(resp.responseEnvelope.ack == AckCode.FAILURE) &&
!(resp.responseEnvelope.ack == AckCode.FAILUREWITHWARNING))
{
keyResponseParams.Add("Pay key", resp.payKey);
keyResponseParams.Add("Payment execution status", resp.status);
keyResponseParams.Add("Sender email", resp.senderEmail);
}
displayResponse(context, "PaymentDetails", keyResponseParams, service.getLastRequest(), service.getLastResponse(),
resp.error, redirectUrl);
}
private static bool PaypalHandleBuyerPaidAndWeNeedToVerify(ITradelrRepository repository)
{
bool haveChanges = false;
var paymentsNeededVerifying = repository.GetPayments(PaymentMethodType.Paypal, PaymentStatus.Charging);
foreach (var payment in paymentsNeededVerifying)
{
var configurationMap = Configuration.GetAcctAndConfig();
var service = new AdaptivePaymentsService(configurationMap);
var detailsRequest = new PaymentDetailsRequest
{
payKey = payment.redirectUrl.ToPayPalPayKey(),
requestEnvelope = new RequestEnvelope
{
errorLanguage
=
"en_US"
},
trackingId = payment.reference
};
PaymentDetailsResponse resp = null;
bool haveError = false;
try
{
resp = service.PaymentDetails(detailsRequest);
}
catch (Exception ex)
{
var affectedInvoice = payment.order;
Syslog.Write(
string.Format(
"Failed to process payment for order {0}, payment amount of {1} deleted",
affectedInvoice.id, payment.paidAmount));
Syslog.Write(ex);
haveError = true;
}
if (!haveError && resp.responseEnvelope.ack == AckCode.SUCCESS)
{
var transaction = new Transaction(payment.order, repository, null);
switch (resp.status)
{
case "COMPLETED":
transaction.UpdatePaymentStatus(payment, PaymentStatus.Accepted);
transaction.AddPaidAmount(payment.paidAmount); // <------- order status is updated inside here
// send download links if digital order
if (transaction.HasDigitalOrderItems())
{
transaction.SendDownloadLinksEmail();
}
haveChanges = true;
break;
case "ERROR":
transaction.UpdatePaymentStatus(payment, PaymentStatus.Declined);
haveChanges = true;
break;
case "EXPIRED":
repository.DeletePayment(payment);
haveChanges = true;
break;
}
}
}
return(haveChanges);
}
private static bool checkPayPal()
{
if (!String.IsNullOrEmpty(SessionVariables.UserName))
{
if (checkForUpdate())
{
PaymentDetailsResponse responsePaymentDetails = new PaymentDetailsResponse();
try
{
// # PaymentDetailsRequest
// The code for the language in which errors are returned
RequestEnvelope envelopeRequest = new RequestEnvelope();
envelopeRequest.errorLanguage = "en_US";
// PaymentDetailsRequest which takes,
// `Request Envelope` - Information common to each API operation, such
// as the language in which an error message is returned.
PaymentDetailsRequest requestPaymentDetails = new PaymentDetailsRequest(envelopeRequest);
// You must specify either,
//
// * `Pay Key` - The pay key that identifies the payment for which you want to retrieve details. This is the pay key returned in the PayResponse message.
// * `Transaction ID` - The PayPal transaction ID associated with the payment. The IPN message associated with the payment contains the transaction ID.
// `payDetailsRequest.transactionId = transactionId`
// * `Tracking ID` - The tracking ID that was specified for this payment in the PayRequest message.
// `requestPaymentDetails.trackingId = trackingId`
requestPaymentDetails.payKey = SessionVariables.paymentKey;
// Create the service wrapper object to make the API call
AdaptivePaymentsService service = new AdaptivePaymentsService();
// # API call
// Invoke the PaymentDetails method in service wrapper object
responsePaymentDetails = service.PaymentDetails(requestPaymentDetails);
if (responsePaymentDetails != null)
{
// Response envelope acknowledgement
string acknowledgement = "PaymentDetails API Operation - ";
acknowledgement += responsePaymentDetails.responseEnvelope.ack.ToString();
Console.WriteLine(acknowledgement + "\n");
// # Success values
if (responsePaymentDetails.responseEnvelope.ack.ToString().Trim().ToUpper().Equals("SUCCESS"))
{
// The status of the payment. Possible values are:
//
// * CREATED - The payment request was received; funds will be
// transferred once the payment is approved
// * COMPLETED - The payment was successful
// * INCOMPLETE - Some transfers succeeded and some failed for a
// parallel payment or, for a delayed chained payment, secondary
// receivers have not been paid
// * ERROR - The payment failed and all attempted transfers failed
// or all completed transfers were successfully reversed
// * REVERSALERROR - One or more transfers failed when attempting
// to reverse a payment
// * PROCESSING - The payment is in progress
// * PENDING - The payment is awaiting processing
if (responsePaymentDetails.status == "COMPLETED")
{
updatePayTable();
return(true);
}
}
// # Error Values
else
{
return(false);
//List<ErrorData> errorMessages = responsePaymentDetails.error;
//foreach (ErrorData error in errorMessages)
//{
//}
}
}
}
// # Exception log
catch (System.Exception ex)
{
return(false);
// Log the exception message
}
}
else
{
return(false);
}
}
return(false);
}
