protected virtual IEnumerable <string> GetPaymentChanges(PaymentIn payment, PaymentIn modifiedPayment)
{
var result = new List <string>();
result.AddRange(GetAddressChanges(payment, new[] { payment.BillingAddress }, new[] { modifiedPayment.BillingAddress }));
return(result);
}
public static PaymentIn ToCoreModel(this PaymentInEntity entity, IEnumerable <PaymentMethod> paymentMethods)
{
if (entity == null)
{
throw new ArgumentNullException("entity");
}
var retVal = new PaymentIn();
retVal.InjectFrom(entity);
retVal.Currency = (CurrencyCodes)Enum.Parse(typeof(CurrencyCodes), entity.Currency);
retVal.PaymentStatus = EnumUtility.SafeParse <PaymentStatus>(entity.Status, PaymentStatus.Custom);
if (entity.Addresses != null && entity.Addresses.Any())
{
retVal.BillingAddress = entity.Addresses.First().ToCoreModel();
}
if (paymentMethods != null)
{
retVal.PaymentMethod = paymentMethods.FirstOrDefault(x => String.Equals(x.Code, entity.GatewayCode, StringComparison.InvariantCultureIgnoreCase));
}
return(retVal);
}
public static PaymentIn ToWebModel(this VirtoCommerceOrderModuleWebModelPaymentIn paymentIn, IEnumerable <Currency> availCurrencies, Language language)
{
var webModel = new PaymentIn();
var currency = availCurrencies.FirstOrDefault(x => x.Equals(paymentIn.Currency)) ?? new Currency(language, paymentIn.Currency);
webModel.InjectFrom(paymentIn);
if (paymentIn.ChildrenOperations != null)
{
webModel.ChildrenOperations = paymentIn.ChildrenOperations.Select(co => co.ToWebModel(availCurrencies, language)).ToList();
}
webModel.Currency = currency;
if (paymentIn.DynamicProperties != null)
{
webModel.DynamicProperties = paymentIn.DynamicProperties.Select(dp => dp.ToWebModel()).ToList();
}
webModel.Sum = new Money(paymentIn.Sum ?? 0, currency);
webModel.Tax = new Money(paymentIn.Tax ?? 0, currency);
return(webModel);
}
public DatatransBeforeCapturePaymentEvent(CustomerOrder order, PaymentIn payment, NameValueCollection parameters, DatatransAirlineData airlineData)
{
Order = order;
Payment = payment;
Parameters = parameters;
AirlineData = airlineData;
}
private static string[] GetPaymentChanges(PaymentIn payment, PaymentIn modifiedPayment)
{
var retVal = new List <string>();
retVal.AddRange(GetAddressChanges(payment, new[] { payment.BillingAddress }, new[] { modifiedPayment.BillingAddress }));
return(retVal.ToArray());
}
public virtual orderDto.PaymentIn ToOrderPaymentInDto(PaymentIn payment)
{
var retVal = new orderDto.PaymentIn();
retVal.InjectFrom <NullableAndEnumValueInjecter>(payment);
retVal.Sum = (double)payment.Sum.Amount;
retVal.Currency = payment.Currency.Code;
retVal.PaymentStatus = payment.Status;
if (payment.BillingAddress != null)
{
retVal.BillingAddress = payment.BillingAddress.ToOrderAddressDto();
}
if (payment.DynamicProperties != null)
{
retVal.DynamicProperties = payment.DynamicProperties.Select(ToOrderDynamicPropertyDto).ToList();
}
//if (payment.GatewayCode != null)
//{
// var a = retVal.GatewayCode;
//}
return(retVal);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
object retVal = null;
var workContext = _workContextAccessor.WorkContext;
var obj = JObject.Load(reader);
var currencyCode = obj.SelectToken("currency.code");
if (currencyCode == null)
{
currencyCode = obj.SelectToken("currency");
}
var currency = workContext.CurrentCurrency;
if (currencyCode != null)
{
currency = workContext.AllCurrencies.FirstOrDefault(x => x.Equals(currencyCode.Value <string>()));
}
if (objectType == typeof(Shipment))
{
retVal = new Shipment(currency);
}
else if (objectType == typeof(PaymentIn))
{
retVal = new PaymentIn(currency);
}
serializer.Populate(obj.CreateReader(), retVal);
return(retVal);
}
public virtual PaymentIn ToOrderInPayment(orderDto.PaymentIn paymentIn, IEnumerable <Currency> availCurrencies, Language language)
{
var currency = availCurrencies.FirstOrDefault(x => x.Equals(paymentIn.Currency)) ?? new Currency(language, paymentIn.Currency);
var retVal = new PaymentIn(currency);
retVal.InjectFrom(paymentIn);
if (paymentIn.BillingAddress != null)
{
retVal.BillingAddress = paymentIn.BillingAddress.ToAddress();
}
if (paymentIn.DynamicProperties != null)
{
retVal.DynamicProperties = paymentIn.DynamicProperties.Select(ToDynamicProperty).ToList();
}
retVal.Sum = new Money(paymentIn.Sum ?? 0, currency);
if (paymentIn.PaymentMethod != null)
{
retVal.GatewayCode = paymentIn.PaymentMethod.Code;
}
return(retVal);
}
public async Task <ActionResult <CustomerOrder> > CreatePayment([FromBody] PaymentIn payment)
{
if (payment == null)
{
return(BadRequest($"{nameof(payment)} is required"));
}
if (string.IsNullOrEmpty(payment.OrderId))
{
return(BadRequest($"{nameof(payment.OrderId)} is required"));
}
var customerOrder = await _customerOrderService.GetByIdAsync(payment.OrderId);
if (customerOrder == null)
{
return(BadRequest($"order with id: {nameof(payment.OrderId)} is not found"));
}
var authorizationResult = await _authorizationService.AuthorizeAsync(User, customerOrder, new OrderAuthorizationRequirement(ModuleConstants.Security.Permissions.Update));
if (!authorizationResult.Succeeded)
{
return(Unauthorized());
}
await _paymentService.SaveChangesAsync(new[] { payment });
return(Ok(payment));
}
public static PaymentIn ToWebModel(this VirtoCommerceOrderModuleWebModelPaymentIn paymentIn)
{
var webModel = new PaymentIn();
var currency = new Currency(EnumUtility.SafeParse(paymentIn.Currency, CurrencyCodes.USD));
webModel.InjectFrom(paymentIn);
if (paymentIn.ChildrenOperations != null)
{
webModel.ChildrenOperations = paymentIn.ChildrenOperations.Select(co => co.ToWebModel()).ToList();
}
webModel.Currency = currency;
if (paymentIn.DynamicProperties != null)
{
webModel.DynamicProperties = paymentIn.DynamicProperties.Select(dp => dp.ToWebModel()).ToList();
}
webModel.Sum = new Money(paymentIn.Sum ?? 0, currency.Code);
webModel.Tax = new Money(paymentIn.Tax ?? 0, currency.Code);
return(webModel);
}
public static PaymentIn ToOrderInPayment(this orderDto.PaymentIn paymentIn, IEnumerable <Currency> availCurrencies, Language language)
{
var currency = availCurrencies.FirstOrDefault(x => x.Equals(paymentIn.Currency)) ?? new Currency(language, paymentIn.Currency);
var retVal = new PaymentIn(currency)
{
CancelledDate = paymentIn.CancelledDate,
CancelReason = paymentIn.CancelReason,
Comment = paymentIn.Comment,
CustomerId = paymentIn.CustomerId,
CustomerName = paymentIn.CustomerName,
GatewayCode = paymentIn.GatewayCode,
Id = paymentIn.Id,
IncomingDate = paymentIn.IncomingDate,
IsApproved = paymentIn.IsApproved,
IsCancelled = paymentIn.IsCancelled,
CreatedBy = paymentIn.CreatedBy,
CreatedDate = paymentIn.CreatedDate,
ModifiedDate = paymentIn.ModifiedDate,
ModifiedBy = paymentIn.ModifiedBy,
Number = paymentIn.Number
};
retVal.IsCancelled = paymentIn.IsCancelled;
retVal.Number = paymentIn.Number;
retVal.OperationType = paymentIn.OperationType;
retVal.OrganizationId = paymentIn.OrganizationId;
retVal.OrganizationName = paymentIn.OrganizationName;
retVal.OuterId = paymentIn.OuterId;
retVal.ParentOperationId = paymentIn.ParentOperationId;
retVal.Purpose = paymentIn.Purpose;
retVal.Status = paymentIn.Status;
retVal.CapturedDate = paymentIn.CapturedDate;
retVal.AuthorizedDate = paymentIn.AuthorizedDate;
retVal.VoidedDate = paymentIn.VoidedDate;
retVal.OrderId = paymentIn.OrderId;
if (paymentIn.BillingAddress != null)
{
retVal.BillingAddress = paymentIn.BillingAddress.ToAddress();
}
if (paymentIn.DynamicProperties != null)
{
retVal.DynamicProperties = paymentIn.DynamicProperties.Select(ToDynamicProperty).ToList();
}
retVal.Sum = new Money(paymentIn.Sum ?? 0, currency);
if (paymentIn.PaymentMethod != null)
{
retVal.GatewayCode = paymentIn.PaymentMethod.Code;
retVal.PaymentMethodType = paymentIn.PaymentMethod.PaymentMethodType;
}
return(retVal);
}
private RefundTransactionReq GetRefundTransactionRequest(PaymentIn payment)
{
var retVal = new RefundTransactionReq();
retVal.RefundTransactionRequest = new RefundTransactionRequestType();
retVal.RefundTransactionRequest.TransactionID = payment.OuterId;
//retVal.RefundTransactionRequest.Amount
return(retVal);
}
protected virtual Task <CustomerOrderAggregate> RemoveExistingPaymentAsync([DisallowNull] PaymentIn payment)
{
var existingPayment = !payment.IsTransient() ? Order.InPayments.FirstOrDefault(s => s.Id == payment.Id) : null;
if (existingPayment != null)
{
Order.InPayments.Remove(existingPayment);
}
return(Task.FromResult(this));
}
private DoCaptureReq GetDoCaptureRequest(PaymentIn payment)
{
var retVal = new DoCaptureReq();
retVal.DoCaptureRequest = new DoCaptureRequestType();
retVal.DoCaptureRequest.Amount = new BasicAmountType(GetPaypalCurrency(payment.Currency.ToString()), FormatMoney(payment.Sum));
retVal.DoCaptureRequest.AuthorizationID = payment.OuterId;
retVal.DoCaptureRequest.CompleteType = CompleteCodeType.COMPLETE;
return(retVal);
}
/// <summary>
/// Updates the payment in.
/// </summary>
/// <param name="paymentIn">The payment in.</param>
/// <returns>The <see cref="Task"/> containing the API response with <see cref="PaymentIn"/>.</returns>
public virtual Task <ApiResponse <PaymentIn> > UpdateAsync(PaymentIn paymentIn)
{
if (paymentIn == null)
{
throw new ArgumentNullException(nameof(paymentIn));
}
var requestContext = PrepareRequestContext(method: Method.PUT, path: $"{Path}/{paymentIn.Id}")
.WithBody(Serialize(paymentIn));
return(CallAsync <PaymentIn>(requestContext));
}
public void CancelOrderPayment(PaymentIn payment)
{
var paymentOrder = Order.InPayments.FirstOrDefault(x => x.Number.EqualsInvariant(payment.Number));
if (paymentOrder != null)
{
paymentOrder.IsCancelled = payment.IsCancelled;
paymentOrder.CancelReason = payment.CancelReason;
paymentOrder.CancelledDate = payment.CancelledDate;
paymentOrder.Status = payment.Status;
}
}
public static orderDto.PaymentIn ToOrderPaymentInDto(this PaymentIn payment)
{
var retVal = new orderDto.PaymentIn
{
CancelledDate = payment.CancelledDate,
CancelReason = payment.CancelReason,
Comment = payment.Comment,
CustomerId = payment.CustomerId,
CustomerName = payment.CustomerName,
GatewayCode = payment.GatewayCode,
Id = payment.Id,
IncomingDate = payment.IncomingDate,
IsApproved = payment.IsApproved,
IsCancelled = payment.IsCancelled,
CreatedBy = payment.CreatedBy,
CreatedDate = payment.CreatedDate,
ModifiedDate = payment.ModifiedDate,
ModifiedBy = payment.ModifiedBy,
Number = payment.Number
};
retVal.IsCancelled = payment.IsCancelled;
retVal.Number = payment.Number;
retVal.OperationType = payment.OperationType;
retVal.OrganizationId = payment.OrganizationId;
retVal.OrganizationName = payment.OrganizationName;
retVal.OuterId = payment.OuterId;
retVal.ParentOperationId = payment.ParentOperationId;
retVal.Purpose = payment.Purpose;
retVal.Status = payment.Status;
retVal.Sum = (double)payment.Sum.Amount;
retVal.Currency = payment.Currency.Code;
retVal.PaymentStatus = payment.Status;
if (payment.BillingAddress != null)
{
retVal.BillingAddress = payment.BillingAddress.ToOrderAddressDto();
}
if (payment.DynamicProperties != null)
{
retVal.DynamicProperties = payment.DynamicProperties.Select(ToOrderDynamicPropertyDto).ToList();
}
//if (payment.GatewayCode != null)
//{
// var a = retVal.GatewayCode;
//}
return(retVal);
}
protected virtual void CalculatePaymentTotals(PaymentIn payment)
{
if (payment == null)
{
throw new ArgumentNullException(nameof(payment));
}
var taxFactor = 1 + payment.TaxPercentRate;
payment.Total = payment.Price - payment.DiscountAmount;
payment.TotalWithTax = payment.Total * taxFactor;
payment.PriceWithTax = payment.Price * taxFactor;
payment.DiscountAmountWithTax = payment.DiscountAmount * taxFactor;
payment.TaxTotal = payment.Total * payment.TaxPercentRate;
}
public void ConfirmOrderPayment(PaymentIn payment)
{
var paymentOrder = Order.InPayments.FirstOrDefault(x => x.Number.EqualsInvariant(payment.Number));
if (paymentOrder == null)
{
paymentOrder = payment;
Order.InPayments.Add(paymentOrder);
}
else
{
paymentOrder.BillingAddress = payment.BillingAddress;
}
}
protected virtual void CalculatePaymentTotals(PaymentIn payment)
{
if (payment == null)
{
throw new ArgumentNullException(nameof(payment));
}
var taxFactor = 1 + payment.TaxPercentRate;
payment.Total = payment.Price - payment.DiscountAmount;
payment.TotalWithTax = payment.Total * taxFactor;
payment.PriceWithTax = payment.Price * taxFactor;
payment.DiscountAmountWithTax = payment.DiscountAmount * taxFactor;
payment.TaxTotal = payment.Total * payment.TaxPercentRate;
//For backward compatibility store in sum only payment amount instead of self total
//payment.Sum = payment.Total;
}
public override object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
{
if (controllerContext == null)
{
throw new ArgumentNullException("controllerContext");
}
if (!controllerContext.HttpContext.Request.ContentType.StartsWith("application/json", StringComparison.OrdinalIgnoreCase))
{
return(null);
}
var workContext = _workContextFactory();
var currencyCode = bindingContext.ValueProvider.GetValue("currency.code");
if (currencyCode == null)
{
currencyCode = bindingContext.ValueProvider.GetValue("currency");
}
if (currencyCode == null)
{
throw new ArgumentNullException("PaymentIn.Currency");
}
var currency = workContext.AllCurrencies.FirstOrDefault(x => x.Equals(currencyCode.RawValue));
object retVal = null;
var type = typeof(T);
if (type == typeof(Shipment))
{
retVal = new Shipment(currency);
}
else if (type == typeof(PaymentIn))
{
retVal = new PaymentIn(currency);
}
controllerContext.HttpContext.Request.InputStream.Seek(0, SeekOrigin.Begin);
var reader = new StreamReader(controllerContext.HttpContext.Request.InputStream);
var bodyText = reader.ReadToEnd();
var settings = new JsonSerializerSettings();
settings.Converters.Add(new MoneyJsonConverter(workContext.AllCurrencies));
settings.Converters.Add(new CurrencyJsonConverter(workContext.AllCurrencies));
JsonConvert.PopulateObject(bodyText, retVal, settings);
return(retVal);
}
public void CalculateTotals_ClearAllItems_TotalsMustBeZero()
{
var item1 = new LineItem {
Price = 10.99m, DiscountAmount = 1.33m, TaxPercentRate = 0.12m, Fee = 0.33m, Quantity = 2
};
var item2 = new LineItem {
Price = 55.22m, DiscountAmount = 5.89m, TaxPercentRate = 0.12m, Fee = 0.12m, Quantity = 5
};
var item3 = new LineItem {
Price = 88.45m, DiscountAmount = 10.78m, TaxPercentRate = 0.12m, Fee = 0.08m, Quantity = 12
};
var payment = new PaymentIn {
Price = 44.52m, DiscountAmount = 10, TaxPercentRate = 0.12m
};
var shipment = new Shipment {
Price = 22.0m, DiscountAmount = 5m, TaxPercentRate = 0.12m
};
var order = new CustomerOrder
{
TaxPercentRate = 0.12m,
Items = new List <LineItem> {
item1, item2, item3
},
InPayments = new List <PaymentIn> {
payment
},
Shipments = new List <Shipment> {
shipment
}
};
var totalsCalculator = new DefaultCustomerOrderTotalsCalculator();
totalsCalculator.CalculateTotals(order);
Assert.Equal(1400.07m, order.Total);
order.Items.Clear();
order.Shipments.Clear();
order.InPayments.Clear();
totalsCalculator.CalculateTotals(order);
Assert.Equal(0m, order.Total);
}
public static PaymentIn ToCoreModel(this PaymentInEntity entity)
{
if (entity == null)
{
throw new ArgumentNullException("entity");
}
var retVal = new PaymentIn();
retVal.InjectFrom(entity);
retVal.Currency = (CurrencyCodes)Enum.Parse(typeof(CurrencyCodes), entity.Currency);
retVal.PaymentStatus = EnumUtility.SafeParse <PaymentStatus>(entity.Status, PaymentStatus.Custom);
if (entity.Addresses != null && entity.Addresses.Any())
{
retVal.BillingAddress = entity.Addresses.First().ToCoreModel();
}
return(retVal);
}
public PaymentIn MapTo(PaymentIn payment)
{
payment ??= AbstractTypeFactory <PaymentIn> .TryCreateInstance();
if (Id?.IsSpecified == true)
{
payment.Id = Id.Value;
}
if (OuterId?.IsSpecified == true)
{
payment.OuterId = OuterId.Value;
}
if (PaymentGatewayCode?.IsSpecified == true)
{
payment.GatewayCode = PaymentGatewayCode.Value;
}
if (Currency?.IsSpecified == true)
{
payment.Currency = Currency.Value;
}
if (Price?.IsSpecified == true)
{
payment.Price = Price.Value;
}
if (Amount?.IsSpecified == true)
{
payment.Sum = Amount.Value;
}
if (BillingAddress?.IsSpecified == true)
{
payment.BillingAddress = BillingAddress.Value?.MapTo(payment.BillingAddress) ?? null;
}
return(payment);
}
public void CreateNewPayment_CheckThatNewPaymentStored()
{
var existingOrderNumber = "CU1508131823004";
var orderApi = GetOrderApiClient();
var orderDto = orderApi.OrderModule.GetByNumber(existingOrderNumber);
var currency = new Currency(new Language("en-US"), "USD");
var payment = new PaymentIn(currency)
{
GatewayCode = "DefaultManualPaymentMethod",
Sum = new Money(1219.19, currency),
CustomerId = GetTestWorkContext().CurrentCustomer.Id,
Purpose = "test payment"
};
var initialCount = orderDto.InPayments.Count;
orderDto.InPayments.Add(payment.ToOrderPaymentInDto());
orderApi.OrderModule.Update(orderDto);
Assert.Equal(initialCount + 1, orderDto.InPayments.Count);
}
public static PaymentIn ToCoreModel(this coreModel.Payment payment)
{
if (payment == null)
{
throw new ArgumentNullException("payment");
}
var retVal = new PaymentIn();
retVal.InjectFrom(payment);
retVal.Currency = payment.Currency;
retVal.GatewayCode = payment.PaymentGatewayCode;
retVal.Sum = payment.Amount;
if (payment.BillingAddress != null)
{
retVal.BillingAddress = payment.BillingAddress.ToCoreModel();
}
return(retVal);
}
public static PaymentInEntity ToDataModel(this PaymentIn paymentIn, CustomerOrderEntity orderEntity)
{
if (paymentIn == null)
{
throw new ArgumentNullException("paymentIn");
}
var retVal = new PaymentInEntity();
retVal.InjectFrom(paymentIn);
retVal.Currency = paymentIn.Currency.ToString();
retVal.Status = paymentIn.PaymentStatus.ToString();
if (paymentIn.BillingAddress != null)
{
retVal.Addresses = new ObservableCollection <AddressEntity>(new AddressEntity[] { paymentIn.BillingAddress.ToDataModel() });
}
return(retVal);
}
private PayRequest CreatePaypalRequest(CustomerOrder order, PaymentIn payment, string url)
{
var receivers = new List <Receiver>();
receivers.Add(new Receiver {
amount = payment.Sum, email = "*****@*****.**", invoiceId = payment.Id
});
PayRequest retVal = new PayRequest
{
requestEnvelope = new RequestEnvelope {
errorLanguage = "en_US"
},
currencyCode = order.Currency.ToString(),
receiverList = new ReceiverList(receivers),
actionType = "PAY",
cancelUrl = string.Format("{0}/{1}?cancel=true&orderId={2}", url, PaypalPaymentRedirectRelativePath, order.Id) + "&paykey=${paykey}",
returnUrl = string.Format("{0}/{1}?cancel=false&orderId={2}", url, PaypalPaymentRedirectRelativePath, order.Id) + "&paykey=${paykey}"
};
return(retVal);
}
public async Task <ActionResult> AddOrUpdateOrderPayment(string orderNumber, PaymentIn payment)
{
if (payment.Sum.Amount == 0)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Valid payment amount is required"));
}
//Need to lock to prevent concurrent access to same object
using (await AsyncLock.GetLockByKey(GetAsyncLockKey(orderNumber, WorkContext)).LockAsync())
{
var orderDto = await GetOrderDtoByNumber(orderNumber);
var paymentDto = orderDto.InPayments.FirstOrDefault(x => x.Id.EqualsInvariant(payment.Id));
if (paymentDto == null)
{
paymentDto = payment.ToOrderPaymentInDto();
paymentDto.CustomerId = WorkContext.CurrentCustomer.Id;
paymentDto.CustomerName = WorkContext.CurrentCustomer.FullName;
paymentDto.Status = "New";
orderDto.InPayments.Add((orderModel.PaymentIn)paymentDto);
}
else
{
paymentDto.BillingAddress = payment.BillingAddress != null?payment.BillingAddress.ToOrderAddressDto() : null;
}
await _orderApi.OrderModule.UpdateAsync(orderDto);
//Need to return payment with generated id
orderDto = await _orderApi.OrderModule.GetByIdAsync(orderDto.Id);
if (string.IsNullOrEmpty(paymentDto.Id))
{
//Because we don't know the new payment id we need to get latest payment with same gateway code
paymentDto = orderDto.InPayments.Where(x => x.GatewayCode.EqualsInvariant(payment.GatewayCode)).OrderByDescending(x => x.CreatedDate).FirstOrDefault();
}
return(Json(paymentDto));
}
}
public static PaymentInEntity ToDataModel(this PaymentIn paymentIn)
{
if (paymentIn == null)
{
throw new ArgumentNullException("paymentIn");
}
var retVal = new PaymentInEntity();
retVal.InjectFrom(paymentIn);
retVal.Currency = paymentIn.Currency.ToString();
if (paymentIn.Properties != null)
{
retVal.Properties = new ObservableCollection <OperationPropertyEntity>(paymentIn.Properties.Select(x => x.ToDataModel()));
}
if (paymentIn.BillingAddress != null)
{
retVal.Addresses = new ObservableCollection <AddressEntity>(new AddressEntity[] { paymentIn.BillingAddress.ToDataModel() });
}
return(retVal);
}
