/// <summary>
/// Processes the order.
/// </summary>
/// <param name="order">The order.</param>
/// <param name="parameters">The parameters.</param>
/// <returns>
/// The result.
/// </returns>
public override string ProcessOrder([NotNull] Order order, [NotNull] IDictionary <string, object> parameters)
{
Assert.ArgumentNotNull(order, "order");
Assert.ArgumentNotNull(parameters, "parameters");
Assert.IsNotNull(order.PaymentMeans, "Order payment means cannot be null.");
string paymentSystemCode = order.PaymentMeans.PaymentChannelCode;
Assert.IsNotNullOrEmpty(paymentSystemCode, "Order payment channel code cannot be null or empty.");
Assert.IsNotNull(order.ReservationTicket, "Order reservation ticket cannot be null");
PaymentProvider paymentProvider = this.paymentProviderFactory.GetProvider(paymentSystemCode);
Assert.IsTrue(paymentProvider is IReservable, "Unable to cancel amount reservation. Reservable payment provider is expected.");
IReservable reservablePaymentProvider = (IReservable)paymentProvider;
this.merchantOrderManager.Save(order);
reservablePaymentProvider.CancelReservation(paymentProvider.PaymentOption, new PaymentArgs(), order.GetReservationTicket());
ITransactionData transactionDataProvider = Context.Entity.Resolve <ITransactionData>();
string result = transactionDataProvider.GetPersistentValue(order.OrderId).ToString();
if (result == "Canceled")
{
result = SuccessfulResult;
}
return(result);
}
/// <summary>
/// Processes the specified order.
/// </summary>
/// <typeparam name="T">The order type.</typeparam>
/// <param name="order">The order instance.</param>
/// <exception cref="InvalidTypeException">The provider doesn't implement IReservable interface.</exception>
protected override void Process <T>(T order)
{
bool cancelSuccess = false;
ReservationTicket reservationTicket = new ReservationTicket(order);
PaymentArgs paymentArgs = new PaymentArgs();
PaymentProvider paymentProvider = Context.Entity.Resolve <PaymentProvider>(order.PaymentSystem.Code);
IReservable reservableProvider = paymentProvider as IReservable;
if (reservableProvider != null)
{
reservableProvider.CancelReservation(order.PaymentSystem, paymentArgs, reservationTicket);
ITransactionData transactionDataProvider = Context.Entity.Resolve <ITransactionData>();
string result = transactionDataProvider.GetPersistentValue(order.OrderNumber) as string;
if (string.Compare(result, "Canceled", StringComparison.OrdinalIgnoreCase) == 0)
{
cancelSuccess = true;
}
}
if (!cancelSuccess)
{
order.Status = Context.Entity.Resolve <OrderStatus>("Processing");
IOrderManager <Order> orderManager = Context.Entity.Resolve <IOrderManager <Order> >();
orderManager.SaveOrder(order);
}
if (reservableProvider == null)
{
throw new InvalidTypeException("The provider doesn't implement IReservable interface.");
}
}
/// <summary>
/// Processes the order.
/// </summary>
/// <param name="order">The order.</param>
/// <param name="parameters">The parameters.</param>
/// <returns>The process order.</returns>
public override string ProcessOrder([NotNull] Order order, [NotNull] IDictionary <string, object> parameters)
{
Assert.ArgumentNotNull(order, "order");
PaymentProvider paymentProviderLocal = this.GetPaymentProvider(order);
if (paymentProviderLocal is IReservable)
{
Assert.IsNotNull(order.AnticipatedMonetaryTotal, "Order anticipated monetary total cannot be null.");
decimal amountToCapture = order.AnticipatedMonetaryTotal.PayableAmount.Value;
Assert.IsNotNull(order.ReservationTicket, "Order reservation ticket cannot be null");
decimal reservedAmount = order.ReservationTicket.Amount;
Assert.IsTrue(amountToCapture > 0 && amountToCapture <= reservedAmount, "Unable to capture the order. Total payable amount exceeds the reserved amount.");
IReservable reservablePaymentProvider = (IReservable)paymentProviderLocal;
ShoppingCart shoppingCart = new ShoppingCart {
Currency = new Currency {
Code = order.PricingCurrencyCode
}, OrderNumber = order.OrderId
};
reservablePaymentProvider.Capture(paymentProviderLocal.PaymentOption, new PaymentArgs {
ShoppingCart = shoppingCart
}, order.GetReservationTicket(), amountToCapture);
string result = this.transactionDataProvider.GetPersistentValue(order.OrderId).ToString();
if (result == CapturedCode)
{
result = SuccessfulResult;
order.ReservationTicket.CapturedAmount += amountToCapture;
this.PerformActionsForSuccess(order);
}
else
{
this.RevertOrderStates(order);
}
return(result);
}
this.PerformActionsForSuccess(order);
return(SuccessfulResult);
}
