public void LoadActiveOrders(Client client, PaymentStateEnum paymentState = default)
{
IQueryable <ActiveOrder> orders = context.Entry(client).Collection(p => p.ActiveOrders).Query();
if (paymentState != 0)
{
orders = orders.Where(p => p.PaymentState == paymentState);
}
orders.Load();
}
public IEnumerable <ActiveOrderDTO> FindClientActiveOrders(string phoneNumber, PaymentStateEnumDTO paymentState = default)
{
Client client = UnitOfWork.Clients.FindByPhoneNumber(phoneNumber);
if (!(client is null))
{
PaymentStateEnum state = Mapper.Map <PaymentStateEnum>(paymentState);
UnitOfWork.Clients.LoadActiveOrders(client);
return(Mapper.Map <List <ActiveOrder>, IEnumerable <ActiveOrderDTO> >(client.ActiveOrders));
}
return(new List <ActiveOrderDTO>());
}
public void LoadActiveOrders(Client client, PaymentStateEnum paymentState = default)
{
IQueryable <ActiveOrder> orders = context.Entry(client).Collection(p => p.ActiveOrders).Query()
.Include(p => p.HotelRoom).ThenInclude(p => p.TypeComfort)
.Include(p => p.HotelRoom).ThenInclude(p => p.TypeSize);
if (paymentState != 0)
{
orders = orders.Where(p => p.PaymentState == paymentState);
}
orders.Load();
//context.Entry(client).Collection(p => p.ActiveOrders).Query().Where(p => p.PaymentState == paymentState).Load();
}
/// <summary>
/// Initializes a new instance of the <see cref="Payment" /> class.
/// </summary>
/// <param name="Id">he unique, permanent, Afterpay-generated Order ID.</param>
/// <param name="Token">Checkout token that was used to complete payment.</param>
/// <param name="Status">An order status.</param>
/// <param name="Created">The UTC timestamp of when the payment was completed, in ISO 8601 format.</param>
/// <param name="OriginalAmount">Total amount charged to the consumer for the order.</param>
/// <param name="OpenToCaptureAmount">Remaining amount that can be captured. Will always be zero for Immediate Payment Flow orders.</param>
/// <param name="PaymentState">Current state for capturing payments.</param>
/// <param name="MerchantReference">The merchant's order id/reference that this payment corresponds to.</param>
/// <param name="Order">Order.</param>
/// <param name="Metadata">Metadata.</param>
/// <param name="ReceiptNumber">ReceiptNumber (required).</param>
public Payment(string Id = default(string), string Token = default(string), StatusEnum Status = default(StatusEnum), string Created = default(string),
Money OriginalAmount = default(Money), Money OpenToCaptureAmount = default(Money), PaymentStateEnum PaymentState = default(PaymentStateEnum),
string MerchantReference = default(string), List <Refund> Refunds = default(List <Refund>), OrderDetails OrderDetails = default(OrderDetails), List <PaymentEvent> Events = default(List <PaymentEvent>))
{
this.Id = Id;
this.Token = Token;
this.Created = Created;
this.OriginalAmount = OriginalAmount;
this.OpenToCaptureAmount = OpenToCaptureAmount;
this.MerchantReference = MerchantReference;
this.Refunds = Refunds;
this.OrderDetails = OrderDetails;
this.Events = Events;
}
public async Task Test_PaymentRequestService_Pay(PaymentRequestDto paymentRequestDto, PaymentStateDto cheapGatewayResponseDto, int timesCheapGatewayCalled, PaymentStateDto expensiveGatewayResponseDto, int timesExpensiveGatewayCalled, PaymentStateEnum expectedPaymentStateEnum)
{
//arrange
_cheapPaymentGateway.Setup(s => s.ProcessPayment(paymentRequestDto)).Returns(cheapGatewayResponseDto);
_expensivePaymentGateway.Setup(s => s.ProcessPayment(paymentRequestDto)).Returns(expensiveGatewayResponseDto);
//act
var paymentStateDto = await _paymentRequestService.Pay(paymentRequestDto);
//assert
Assert.IsNotNull(paymentStateDto);
Assert.AreEqual(paymentStateDto.PaymentState, expectedPaymentStateEnum);
_cheapPaymentGateway.Verify(s => s.ProcessPayment(paymentRequestDto), Times.Exactly(timesCheapGatewayCalled));
_expensivePaymentGateway.Verify(s => s.ProcessPayment(paymentRequestDto), Times.Exactly(timesExpensiveGatewayCalled));
}
public void PaymentProcessPremium(PaymentDto paymentDto, PaymentState paymentState, PaymentStateEnum state)
{
//arrange
_expensivePaymentGateway.Setup(x => x.PaymentProcessExpensive(paymentDto)).Returns(state);
//act
var paymentStateResult = _paymentGateWay.PaymentProcess(paymentDto, paymentState);
//assert
if (state == PaymentStateEnum.Failed)
{
_expensivePaymentGateway.Verify(x => x.PaymentProcessExpensive(paymentDto), Times.Exactly(3));
}
else
{
_expensivePaymentGateway.Verify(x => x.PaymentProcessExpensive(paymentDto), Times.Once);
}
Assert.AreEqual(paymentStateResult.State, state.ToString());
}
public void ExpensiveProcessCheapGateWay(PaymentDto paymentDto, PaymentState paymentState, PaymentStateEnum state, int callExpensive, int callCheap, PaymentStateEnum CheapState, PaymentStateEnum Expacted)
{
//arrange
_expensivePaymentGateway.Setup(x => x.PaymentProcessExpensive(paymentDto)).Returns(state);
_cheapPaymentGateway.Setup(s => s.PaymentProcessCheap(paymentDto)).Returns(CheapState);
//act
var paymentStateResult = _paymentGateWay.PaymentProcess(paymentDto, paymentState);
//assert
_expensivePaymentGateway.Verify(x => x.PaymentProcessExpensive(paymentDto), Times.Exactly(callExpensive));
_cheapPaymentGateway.Verify(x => x.PaymentProcessCheap(paymentDto), Times.Exactly(callCheap));
Assert.AreEqual(paymentStateResult.State, Expacted.ToString());
}
public void PaymentProcessCheapGateWay(PaymentDto paymentDto, PaymentState paymentState, PaymentStateEnum state)
{
//arrange
_cheapPaymentGateway.Setup(x => x.PaymentProcessCheap(paymentDto)).Returns(state);
//act
var paymentStateResult = _paymentGateWay.PaymentProcess(paymentDto, paymentState);
//assert
_cheapPaymentGateway.Verify(x => x.PaymentProcessCheap(paymentDto), Times.Once());
Assert.AreEqual(paymentStateResult.State, state.ToString());
}
