public void TestRefund()
{
var gw = PaymentGatewayFactory.CreateInstance("PayDollar");
var settings = new PaymentGatewaySettings();
gw.Init(settings);
gw.Test();
//keep confidential info else where in purpose
var o = System.IO.File.ReadAllText(@"D:\TestCase\PayDollar\trans1.json");
var card = System.IO.File.ReadAllText(@"D:\TestCase\PayDollar\card.json");
var m = new Money();
m.Currency = "344";//hkd
m.Amount = 1;
var cc = JsonConvert.DeserializeObject <CreditCard>(card);
var options = JsonConvert.DeserializeObject <PayDollarPaymentOptions>(o);
var r = gw.Purchase(m, cc, options);
PayDollarPaymentResult result = (PayDollarPaymentResult)r;
Assert.AreEqual(result.SuccessCode, "0", "payDollar Purchase failed");
var cr = gw.Refund(m, result.GatewayRef, options);
PayDollarPaymentResult refundResult = (PayDollarPaymentResult)cr;
Assert.AreEqual(refundResult.SuccessCode, "0", "payDollar Refund failed");
}
public void PreparePayment(Invoice invoice)
{
PaymentGatewayFactory factory = new PaymentGatewayFactory();
this.gateway = factory.CreatePaymentGateway(invoice);
this.gateway.PaymentGranularity(invoice);
}
public void MakePayment(PaymentMethod method, Order product, PaymentPayload paymentpayload)
{
PaymentGatewayFactory factory = new PaymentGatewayFactory();
// this.gateway = factory.CreatePaymentGateway(method);
//this.gateway.MakePayment(product,paymentpayload);
}
public void ExpensivePayment_MakePayment_ReturnBool()
{
// Arrange
var retval = new PaymentGatewayFactory().CheapPayments.MakePayment();
// Assert
retval.GetType().Should().BeSameAs(typeof(bool));
}
public void ExpensivePayment_CheckValidity_ReturnBool()
{
// Arrange
var retval = new PaymentGatewayFactory().ExpensivePayments.CheckAvailability();
// Assert
retval.GetType().Should().BeSameAs(typeof(bool));
}
public void MakePayment(PaymentMethod method, Product product)
{
PaymentGatewayFactory factory = new PaymentGatewayFactory();
gateway = factory.CreatePaymentGateway(method, product);
gateway.MakePayment(product);
}
public Payment(IPaymentGateway paymentGateway, PaymentContext paymentContext)
{
_PaymentContext = paymentContext;
_Encryption = new RSAEncryption();
_PaymentGatewayFactory = new PaymentGatewayFactory();
_PeopleRepo = new GenericRepository <Person>(paymentGateway, paymentContext);
_CardInfoRepo = new GenericRepository <CardInformation>(paymentGateway, paymentContext);
_TransactionRepo = new GenericRepository <Transactions>(paymentGateway, paymentContext);
}
public async Task <bool> ProcessPayment(ProcessPaymentModel model)
{
try
{
//Adding Payment
var payment = new Payment
{
CreditCardNumber = model.CreditCardNumber,
CardHolder = model.CardHolder,
ExpirationDate = model.ExpirationDate,
SecurityCode = model.SecurityCode,
Amount = model.Amount
};
_uow.Add(payment);
await _uow.CommitAsync();
//Adding Payment Status as Initial - Pending
var paymentStatus = new PaymentStatus
{
PaymentId = payment.Id,
StatusId = (int)TransactionStatus.Pending
};
_uow.Add(paymentStatus);
paymentStatus = new PaymentStatus()
{
PaymentId = payment.Id
};
var factory = new PaymentGatewayFactory();
IPaymentGateway paymentGateway = factory.GetPaymentGateway(model.Amount);
if (await paymentGateway.ProcessPayment())
{
paymentStatus.StatusId = (int)TransactionStatus.Processed;
}
else
{
paymentStatus.StatusId = (int)TransactionStatus.Failed;
}
_uow.Add(paymentStatus);
await _uow.CommitAsync();
return(true);
}
catch (Exception ex)
{
throw new BadRequestException(ex.Message);
}
}
public void GetPaymentGateway_VerifyMethodCallOfCheapGateway(decimal amount, string status)
{
PaymentStatus expected;
Enum.TryParse <PaymentStatus>(status, out expected);
mockCheapGateway.Setup(x => x.ProceessAmount(amount)).Returns(expected);
mockExpensiveGateway.Setup(x => x.ProceessAmount(amount)).Returns(expected);
mockPremiumGateway.Setup(x => x.ProceessAmount(amount)).Returns(expected);
sut = new PaymentGatewayFactory(mockCheapGateway.Object, mockExpensiveGateway.Object, mockPremiumGateway.Object);
sut.GetPaymentGateway(amount);
mockCheapGateway.Verify(x => x.ProceessAmount(amount), Times.Once);
}
public void GetPaymentGateway_WithStatus(decimal amount, string status)
{
PaymentStatus expected;
Enum.TryParse <PaymentStatus>(status, out expected);
mockCheapGateway.Setup(x => x.ProceessAmount(amount)).Returns(expected);
mockExpensiveGateway.Setup(x => x.ProceessAmount(amount)).Returns(expected);
mockPremiumGateway.Setup(x => x.ProceessAmount(amount)).Returns(expected);
sut = new PaymentGatewayFactory(mockCheapGateway.Object, mockExpensiveGateway.Object, mockPremiumGateway.Object);
var result = sut.GetPaymentGateway(amount);
Assert.Equal(expected, result);
}
private static Dictionary <int, Lazy <b::PaymentGateway> > CreateProductPaymentGatewayDictionary()
{
var dict = new Dictionary <int, Lazy <b::PaymentGateway> >();
using (var context = new DOMEntities())
{
foreach (var ppg in context.ProductPaymentGateways)
{
Func <b::PaymentGateway> func = () => PaymentGatewayFactory.Create(ppg.PaymentGatewayId);
dict.Add(ppg.ProductId, new Lazy <b::PaymentGateway>(func));
}
}
return(dict);
}
public async Task ProcessPendingPayments()
{
IList <PaymentProcess> pendingPayment = await GetPendingPayments();
IPaymentGatewayFactory _paymentFactory = new PaymentGatewayFactory();
foreach (PaymentProcess _payment in pendingPayment)
{
// Payment Condition
if (_payment.Amount > 500)
{
// IPremium Payment Gateway
if (_paymentFactory.PremiumPayments.MakePayment())
{
_payment.Status = PaymentStatus.PROCESSED;
_payment.Tries = _payment.Tries + 1;
_ = await this.UpdateAsync(_payment);
}
else
{
_payment.Status = PaymentStatus.PENDING;
_payment.Tries = _payment.Tries + 1;
if (_payment.Tries == 3)
{
_payment.Status = PaymentStatus.FAILED;
}
_ = await this.UpdateAsync(_payment);
}
_ = _context.SaveChangesAsync();
continue;
}
if (_payment.Amount < 21)
{
// ICheap Payment Gateway
if (_paymentFactory.CheapPayments.MakePayment())
{
_payment.Status = PaymentStatus.PROCESSED;
_payment.Tries = _payment.Tries + 1;
_ = await this.UpdateAsync(_payment);
}
else
{
_payment.Status = PaymentStatus.FAILED;
_payment.Tries = _payment.Tries + 1;
_ = await this.UpdateAsync(_payment);
}
_ = _context.SaveChangesAsync();
continue;
}
if (_payment.Amount <= 500)
{
// Check Expensive payment availability
if (_paymentFactory.ExpensivePayments.CheckAvailability() && _paymentFactory.ExpensivePayments.MakePayment())
{
_payment.Status = PaymentStatus.PROCESSED;
_payment.Tries = _payment.Tries + 1;
_ = await this.UpdateAsync(_payment);
}
// Try ICheap Payment Gateway
else if (_paymentFactory.CheapPayments.MakePayment())
{
_payment.Status = PaymentStatus.PROCESSED;
_payment.Tries = _payment.Tries + 1;
_ = await this.UpdateAsync(_payment);
}
else
{
_payment.Status = PaymentStatus.FAILED;
_payment.Tries = _payment.Tries + 1;
_ = await this.UpdateAsync(_payment);
}
_ = _context.SaveChangesAsync();
continue;
}
}
}
