/// <summary>
/// Process a payment
/// </summary>
/// <param name="processPaymentRequest">Payment info required for an order processing</param>
/// <returns>Process payment result</returns>
public ProcessPaymentResult ProcessPayment(ProcessPaymentRequest processPaymentRequest)
{
var result = new ProcessPaymentResult();
result.AllowStoringCreditCardNumber = true;
switch (_manualPaymentSettings.TransactMode)
{
case TransactMode.Pending:
result.NewPaymentStatus = PaymentStatus.Pending;
break;
case TransactMode.Authorize:
result.NewPaymentStatus = PaymentStatus.Authorized;
break;
case TransactMode.AuthorizeAndCapture:
result.NewPaymentStatus = PaymentStatus.Paid;
break;
default:
{
result.AddError("Not supported transaction type");
return result;
}
}
return result;
}
/// <summary>
/// Process a payment
/// </summary>
/// <param name="processPaymentRequest">Payment info required for an order processing</param>
/// <returns>Process payment result</returns>
public ProcessPaymentResult ProcessPayment(ProcessPaymentRequest processPaymentRequest)
{
var result = new ProcessPaymentResult();
var orderGuid = processPaymentRequest.OrderGuid;
if (orderGuid == Guid.NewGuid())
{
result.AddError("SagePay Server transaction code does not exist!");
return result;
}
var transx = _sagePayServerTransactionService.GetSagePayServerTransactionByVendorTxCode(orderGuid.ToString());
if (transx == null)
{
result.AddError(String.Format("SagePay Server transaction code {0} does not exist.", orderGuid.ToString()));
return result;
}
if ((transx.Status == "OK") || (transx.Status == "AUTHENTICATED") || (transx.Status == "REGISTERED"))
{
if (_sagePayServerPaymentSettings.TransactType == SagePayServerPaymentSettings.TransactTypeValues.PAYMENT)
result.NewPaymentStatus = PaymentStatus.Paid;
else if (_sagePayServerPaymentSettings.TransactType == SagePayServerPaymentSettings.TransactTypeValues.DEFERRED)
result.NewPaymentStatus = PaymentStatus.Authorized;
else
result.NewPaymentStatus = PaymentStatus.Pending;
result.AuthorizationTransactionId = transx.Id.ToString();
result.AuthorizationTransactionCode = transx.VPSTxId;
result.AuthorizationTransactionResult = transx.ToString();
}
else
{
result.AddError(transx.StatusDetail);
}
return result;
}
/// <summary>
/// Process recurring payment
/// </summary>
/// <param name="processPaymentRequest">Payment info required for an order processing</param>
/// <returns>Process payment result</returns>
public ProcessPaymentResult ProcessRecurringPayment(ProcessPaymentRequest processPaymentRequest)
{
var result = new ProcessPaymentResult();
result.AllowStoringCreditCardNumber = true;
return result;
}
/// <summary>
/// Process recurring payment
/// </summary>
/// <param name="processPaymentRequest">Payment info required for an order processing</param>
/// <returns>Process payment result</returns>
public ProcessPaymentResult ProcessRecurringPayment(ProcessPaymentRequest processPaymentRequest)
{
var result = new ProcessPaymentResult();
result.AddError("Recurring payment not supported");
return result;
}
/// <summary>
/// Process recurring payment
/// </summary>
/// <param name="processPaymentRequest">Payment info required for an order processing</param>
/// <returns>Process payment result</returns>
public ProcessPaymentResult ProcessRecurringPayment(ProcessPaymentRequest processPaymentRequest)
{
var result = new ProcessPaymentResult();
var customer = _customerService.GetCustomerById(processPaymentRequest.CustomerId);
var req = new CreateRecurringPaymentsProfileReq();
req.CreateRecurringPaymentsProfileRequest = new CreateRecurringPaymentsProfileRequestType();
req.CreateRecurringPaymentsProfileRequest.Version = GetApiVersion();
var details = new CreateRecurringPaymentsProfileRequestDetailsType();
req.CreateRecurringPaymentsProfileRequest.CreateRecurringPaymentsProfileRequestDetails = details;
details.CreditCard = new CreditCardDetailsType();
details.CreditCard.CreditCardNumber = processPaymentRequest.CreditCardNumber;
details.CreditCard.CreditCardType = GetPaypalCreditCardType(processPaymentRequest.CreditCardType);
details.CreditCard.ExpMonth = processPaymentRequest.CreditCardExpireMonth;
details.CreditCard.ExpYear = processPaymentRequest.CreditCardExpireYear;
details.CreditCard.CVV2 = processPaymentRequest.CreditCardCvv2;
details.CreditCard.CardOwner = new PayerInfoType();
var country = EngineContext.Current.Resolve<ICountryService>().GetCountryById(customer.BillingAddress.CountryId);
details.CreditCard.CardOwner.PayerCountry = GetPaypalCountryCodeType(country);
details.CreditCard.CardOwner.Address = new AddressType();
details.CreditCard.CardOwner.Address.Street1 = customer.BillingAddress.Address1;
details.CreditCard.CardOwner.Address.Street2 = customer.BillingAddress.Address2;
details.CreditCard.CardOwner.Address.CityName = customer.BillingAddress.City;
if (customer.BillingAddress.StateProvinceId != 0)
{
var state = EngineContext.Current.Resolve<IStateProvinceService>().GetStateProvinceById(customer.BillingAddress.StateProvinceId);
details.CreditCard.CardOwner.Address.StateOrProvince = state.Abbreviation;
}
else
details.CreditCard.CardOwner.Address.StateOrProvince = "CA";
details.CreditCard.CardOwner.Address.Country = GetPaypalCountryCodeType(country);
details.CreditCard.CardOwner.Address.PostalCode = customer.BillingAddress.ZipPostalCode;
details.CreditCard.CardOwner.Payer = customer.BillingAddress.Email;
details.CreditCard.CardOwner.PayerName = new PersonNameType();
details.CreditCard.CardOwner.PayerName.FirstName = customer.BillingAddress.FirstName;
details.CreditCard.CardOwner.PayerName.LastName = customer.BillingAddress.LastName;
//start date
details.RecurringPaymentsProfileDetails = new RecurringPaymentsProfileDetailsType();
details.RecurringPaymentsProfileDetails.BillingStartDate = DateTime.UtcNow.ToString("s", CultureInfo.InvariantCulture);
details.RecurringPaymentsProfileDetails.ProfileReference = processPaymentRequest.OrderGuid.ToString();
//schedule
details.ScheduleDetails = new ScheduleDetailsType();
details.ScheduleDetails.Description = "Recurring payment";
details.ScheduleDetails.PaymentPeriod = new BillingPeriodDetailsType();
details.ScheduleDetails.PaymentPeriod.Amount = new BasicAmountType();
details.ScheduleDetails.PaymentPeriod.Amount.value = Math.Round(processPaymentRequest.OrderTotal, 2).ToString("N", new CultureInfo("en-us"));
details.ScheduleDetails.PaymentPeriod.Amount.currencyID = PaypalHelper.GetPaypalCurrency(_currencyService.GetCurrencyById(_currencySettings.PrimaryStoreCurrencyId));
details.ScheduleDetails.PaymentPeriod.BillingFrequency = processPaymentRequest.RecurringCycleLength;
switch (processPaymentRequest.RecurringCyclePeriod)
{
case RecurringProductCyclePeriod.Days:
details.ScheduleDetails.PaymentPeriod.BillingPeriod = BillingPeriodType.DAY;
break;
case RecurringProductCyclePeriod.Weeks:
details.ScheduleDetails.PaymentPeriod.BillingPeriod = BillingPeriodType.WEEK;
break;
case RecurringProductCyclePeriod.Months:
details.ScheduleDetails.PaymentPeriod.BillingPeriod = BillingPeriodType.MONTH;
break;
case RecurringProductCyclePeriod.Years:
details.ScheduleDetails.PaymentPeriod.BillingPeriod = BillingPeriodType.YEAR;
break;
default:
throw new NopException("Not supported cycle period");
}
details.ScheduleDetails.PaymentPeriod.TotalBillingCycles = processPaymentRequest.RecurringTotalCycles;
var service = GetService();
CreateRecurringPaymentsProfileResponseType response = service.CreateRecurringPaymentsProfile(req);
string error;
bool success = PaypalHelper.CheckSuccess(response, out error);
if (success)
{
result.NewPaymentStatus = PaymentStatus.Pending;
if (response.CreateRecurringPaymentsProfileResponseDetails != null)
{
result.SubscriptionTransactionId = response.CreateRecurringPaymentsProfileResponseDetails.ProfileID;
}
}
else
{
result.AddError(error);
}
return result;
}
protected ProcessPaymentResult AuthorizeOrSale(ProcessPaymentRequest processPaymentRequest, bool authorizeOnly)
{
var result = new ProcessPaymentResult();
var customer = _customerService.GetCustomerById(processPaymentRequest.CustomerId);
if (customer == null)
throw new Exception("Customer cannot be loaded");
var req = new DoDirectPaymentReq();
req.DoDirectPaymentRequest = new DoDirectPaymentRequestType();
req.DoDirectPaymentRequest.Version = GetApiVersion();
var details = new DoDirectPaymentRequestDetailsType();
req.DoDirectPaymentRequest.DoDirectPaymentRequestDetails = details;
details.IPAddress = _webHelper.GetCurrentIpAddress() ?? "";
if (authorizeOnly)
details.PaymentAction = PaymentActionCodeType.Authorization;
else
details.PaymentAction = PaymentActionCodeType.Sale;
//credit card
details.CreditCard = new CreditCardDetailsType();
details.CreditCard.CreditCardNumber = processPaymentRequest.CreditCardNumber;
details.CreditCard.CreditCardType = GetPaypalCreditCardType(processPaymentRequest.CreditCardType);
details.CreditCard.ExpMonthSpecified = true;
details.CreditCard.ExpMonth = processPaymentRequest.CreditCardExpireMonth;
details.CreditCard.ExpYearSpecified = true;
details.CreditCard.ExpYear = processPaymentRequest.CreditCardExpireYear;
details.CreditCard.CVV2 = processPaymentRequest.CreditCardCvv2;
details.CreditCard.CardOwner = new PayerInfoType();
details.CreditCard.CardOwner.PayerCountry = GetPaypalCountryCodeType(customer.BillingAddress.Country);
details.CreditCard.CreditCardTypeSpecified = true;
//billing address
details.CreditCard.CardOwner.Address = new AddressType();
details.CreditCard.CardOwner.Address.CountrySpecified = true;
details.CreditCard.CardOwner.Address.Street1 = customer.BillingAddress.Address1;
details.CreditCard.CardOwner.Address.Street2 = customer.BillingAddress.Address2;
details.CreditCard.CardOwner.Address.CityName = customer.BillingAddress.City;
if (customer.BillingAddress.StateProvince != null)
details.CreditCard.CardOwner.Address.StateOrProvince = customer.BillingAddress.StateProvince.Abbreviation;
else
details.CreditCard.CardOwner.Address.StateOrProvince = "CA";
details.CreditCard.CardOwner.Address.Country = GetPaypalCountryCodeType(customer.BillingAddress.Country);
details.CreditCard.CardOwner.Address.PostalCode = customer.BillingAddress.ZipPostalCode;
details.CreditCard.CardOwner.Payer = customer.BillingAddress.Email;
details.CreditCard.CardOwner.PayerName = new PersonNameType();
details.CreditCard.CardOwner.PayerName.FirstName = customer.BillingAddress.FirstName;
details.CreditCard.CardOwner.PayerName.LastName = customer.BillingAddress.LastName;
//order totals
var payPalCurrency = PaypalHelper.GetPaypalCurrency(_currencyService.GetCurrencyById(_currencySettings.PrimaryStoreCurrencyId));
details.PaymentDetails = new PaymentDetailsType();
details.PaymentDetails.OrderTotal = new BasicAmountType();
details.PaymentDetails.OrderTotal.Value = Math.Round(processPaymentRequest.OrderTotal, 2).ToString("N", new CultureInfo("en-us"));
details.PaymentDetails.OrderTotal.currencyID = payPalCurrency;
details.PaymentDetails.Custom = processPaymentRequest.OrderGuid.ToString();
details.PaymentDetails.ButtonSource = "nopCommerceCart";
//pass product names and totals to PayPal
//if (_paypalDirectPaymentSettings.PassProductNamesAndTotals)
//{
// //individual items
//var cart = customer.ShoppingCartItems
// .Where(x=>x.ShoppingCartType == ShoppingCartType.ShoppingCart)
// .LimitPerStore(processPaymentRequest.StoreId)
// .ToList();
// var cartItems = new PaymentDetailsItemType[cart.Count];
// for (int i = 0; i < cart.Count; i++)
// {
// var sc = cart[i];
// decimal taxRate = decimal.Zero;
// var customer = processPaymentRequest.Customer;
// decimal scUnitPrice = _priceCalculationService.GetUnitPrice(sc, true);
// decimal scSubTotal = _priceCalculationService.GetSubTotal(sc, true);
// decimal scUnitPriceInclTax = _taxService.GetProductPrice(sc.ProductVariant, scUnitPrice, true, customer, out taxRate);
// decimal scUnitPriceExclTax = _taxService.GetProductPrice(sc.ProductVariant, scUnitPrice, false, customer, out taxRate);
// //decimal scSubTotalInclTax = _taxService.GetProductPrice(sc.ProductVariant, scSubTotal, true, customer, out taxRate);
// //decimal scSubTotalExclTax = _taxService.GetProductPrice(sc.ProductVariant, scSubTotal, false, customer, out taxRate);
// cartItems[i] = new PaymentDetailsItemType()
// {
// Name = sc.ProductVariant.FullProductName,
// Number = sc.ProductVariant.Id.ToString(),
// Quantity = sc.Quantity.ToString(),
// Amount = new BasicAmountType()
// {
// currencyID = payPalCurrency,
// Value = scUnitPriceExclTax.ToString("N", new CultureInfo("en-us")),
// },
// Tax = new BasicAmountType()
// {
// currencyID = payPalCurrency,
// Value = (scUnitPriceInclTax - scUnitPriceExclTax).ToString("N", new CultureInfo("en-us")),
// },
// };
// };
// details.PaymentDetails.PaymentDetailsItem = cartItems;
// //other totals (undone)
// details.PaymentDetails.ItemTotal = null;
// details.PaymentDetails.ShippingTotal = null;
// details.PaymentDetails.TaxTotal = null;
// details.PaymentDetails.HandlingTotal = null;
//}
//shipping
if (customer.ShippingAddress != null)
{
if (customer.ShippingAddress.StateProvince != null && customer.ShippingAddress.Country != null)
{
var shippingAddress = new AddressType();
shippingAddress.Name = customer.ShippingAddress.FirstName + " " + customer.ShippingAddress.LastName;
shippingAddress.Street1 = customer.ShippingAddress.Address1;
shippingAddress.CityName = customer.ShippingAddress.City;
shippingAddress.StateOrProvince = customer.ShippingAddress.StateProvince.Abbreviation;
shippingAddress.PostalCode = customer.ShippingAddress.ZipPostalCode;
shippingAddress.Country = (CountryCodeType)Enum.Parse(typeof(CountryCodeType), customer.ShippingAddress.Country.TwoLetterIsoCode, true);
shippingAddress.CountrySpecified = true;
details.PaymentDetails.ShipToAddress = shippingAddress;
}
}
//send request
using (var service2 = new PayPalAPIAASoapBinding())
{
if (!_paypalDirectPaymentSettings.UseSandbox)
service2.Url = "https://api-3t.paypal.com/2.0/";
else
service2.Url = "https://api-3t.sandbox.paypal.com/2.0/";
service2.RequesterCredentials = new CustomSecurityHeaderType();
service2.RequesterCredentials.Credentials = new UserIdPasswordType();
service2.RequesterCredentials.Credentials.Username = _paypalDirectPaymentSettings.ApiAccountName;
service2.RequesterCredentials.Credentials.Password = _paypalDirectPaymentSettings.ApiAccountPassword;
service2.RequesterCredentials.Credentials.Signature = _paypalDirectPaymentSettings.Signature;
service2.RequesterCredentials.Credentials.Subject = "";
DoDirectPaymentResponseType response = service2.DoDirectPayment(req);
string error = "";
bool success = PaypalHelper.CheckSuccess(response, out error);
if (success)
{
result.AvsResult = response.AVSCode;
result.AuthorizationTransactionCode = response.CVV2Code;
if (authorizeOnly)
{
result.AuthorizationTransactionId = response.TransactionID;
result.AuthorizationTransactionResult = response.Ack.ToString();
result.NewPaymentStatus = PaymentStatus.Authorized;
}
else
{
result.CaptureTransactionId = response.TransactionID;
result.CaptureTransactionResult = response.Ack.ToString();
result.NewPaymentStatus = PaymentStatus.Paid;
}
}
else
{
result.AddError(error);
}
}
return result;
}
/// <summary>
/// Process recurring payment
/// </summary>
/// <param name="processPaymentRequest">Payment info required for an order processing</param>
/// <returns>Process payment result</returns>
public virtual ProcessPaymentResult ProcessRecurringPayment(ProcessPaymentRequest processPaymentRequest)
{
if (processPaymentRequest.OrderTotal == decimal.Zero)
{
var result = new ProcessPaymentResult()
{
NewPaymentStatus = PaymentStatus.Paid
};
return result;
}
else
{
var paymentMethod = LoadPaymentMethodBySystemName(processPaymentRequest.PaymentMethodSystemName);
if (paymentMethod == null)
throw new NopException("Payment method couldn't be loaded");
return paymentMethod.ProcessRecurringPayment(processPaymentRequest);
}
}
/// <summary>
/// Process recurring payment
/// </summary>
/// <param name="processPaymentRequest">Payment info required for an order processing</param>
/// <returns>Process payment result</returns>
public ProcessPaymentResult ProcessRecurringPayment(ProcessPaymentRequest processPaymentRequest)
{
var result = new ProcessPaymentResult();
if (!processPaymentRequest.IsRecurringPayment)
{
var customer = _customerService.GetCustomerById(processPaymentRequest.CustomerId);
var subscription = new ARBSubscriptionType();
var creditCard = new net.authorize.api.CreditCardType();
subscription.name = processPaymentRequest.OrderGuid.ToString();
creditCard.cardNumber = processPaymentRequest.CreditCardNumber;
creditCard.expirationDate = processPaymentRequest.CreditCardExpireYear + "-" + processPaymentRequest.CreditCardExpireMonth; // required format for API is YYYY-MM
creditCard.cardCode = processPaymentRequest.CreditCardCvv2;
subscription.payment = new PaymentType();
subscription.payment.Item = creditCard;
subscription.billTo = new NameAndAddressType();
subscription.billTo.firstName = customer.BillingAddress.FirstName;
subscription.billTo.lastName = customer.BillingAddress.LastName;
subscription.billTo.address = customer.BillingAddress.Address1;
//subscription.billTo.address = customer.BillingAddress.Address1 + " " + customer.BillingAddress.Address2;
subscription.billTo.city = customer.BillingAddress.City;
if (customer.BillingAddress.StateProvince != null)
{
subscription.billTo.state = customer.BillingAddress.StateProvince.Abbreviation;
}
subscription.billTo.zip = customer.BillingAddress.ZipPostalCode;
if (customer.ShippingAddress != null)
{
subscription.shipTo = new NameAndAddressType();
subscription.shipTo.firstName = customer.ShippingAddress.FirstName;
subscription.shipTo.lastName = customer.ShippingAddress.LastName;
subscription.shipTo.address = customer.ShippingAddress.Address1;
//subscription.shipTo.address = customer.ShippingAddress.Address1 + " " + customer.ShippingAddress.Address2;
subscription.shipTo.city = customer.ShippingAddress.City;
if (customer.ShippingAddress.StateProvince != null)
{
subscription.shipTo.state = customer.ShippingAddress.StateProvince.Abbreviation;
}
subscription.shipTo.zip = customer.ShippingAddress.ZipPostalCode;
}
subscription.customer = new CustomerType();
subscription.customer.email = customer.BillingAddress.Email;
subscription.customer.phoneNumber = customer.BillingAddress.PhoneNumber;
subscription.order = new OrderType();
subscription.order.description = "Recurring payment";
// Create a subscription that is leng of specified occurrences and interval is amount of days ad runs
subscription.paymentSchedule = new PaymentScheduleType();
DateTime dtNow = DateTime.UtcNow;
subscription.paymentSchedule.startDate = new DateTime(dtNow.Year, dtNow.Month, dtNow.Day);
subscription.paymentSchedule.startDateSpecified = true;
subscription.paymentSchedule.totalOccurrences = Convert.ToInt16(processPaymentRequest.RecurringTotalCycles);
subscription.paymentSchedule.totalOccurrencesSpecified = true;
var orderTotal = Math.Round(processPaymentRequest.OrderTotal, 2);
subscription.amount = orderTotal;
subscription.amountSpecified = true;
// Interval can't be updated once a subscription is created.
subscription.paymentSchedule.interval = new PaymentScheduleTypeInterval();
switch (processPaymentRequest.RecurringCyclePeriod)
{
case RecurringProductCyclePeriod.Days:
subscription.paymentSchedule.interval.length = Convert.ToInt16(processPaymentRequest.RecurringCycleLength);
subscription.paymentSchedule.interval.unit = ARBSubscriptionUnitEnum.days;
break;
case RecurringProductCyclePeriod.Weeks:
subscription.paymentSchedule.interval.length = Convert.ToInt16(processPaymentRequest.RecurringCycleLength * 7);
subscription.paymentSchedule.interval.unit = ARBSubscriptionUnitEnum.days;
break;
case RecurringProductCyclePeriod.Months:
subscription.paymentSchedule.interval.length = Convert.ToInt16(processPaymentRequest.RecurringCycleLength);
subscription.paymentSchedule.interval.unit = ARBSubscriptionUnitEnum.months;
break;
case RecurringProductCyclePeriod.Years:
subscription.paymentSchedule.interval.length = Convert.ToInt16(processPaymentRequest.RecurringCycleLength * 12);
subscription.paymentSchedule.interval.unit = ARBSubscriptionUnitEnum.months;
break;
default:
throw new NopException("Not supported cycle period");
}
using (var webService = new net.authorize.api.Service())
{
if (_authorizeNetPaymentSettings.UseSandbox)
webService.Url = "https://apitest.authorize.net/soap/v1/Service.asmx";
else
webService.Url = "https://api.authorize.net/soap/v1/Service.asmx";
var authentication = PopulateMerchantAuthentication();
var response = webService.ARBCreateSubscription(authentication, subscription);
if (response.resultCode == MessageTypeEnum.Ok)
{
result.SubscriptionTransactionId = response.subscriptionId.ToString();
result.AuthorizationTransactionCode = response.resultCode.ToString();
result.AuthorizationTransactionResult = string.Format("Approved ({0}: {1})", response.resultCode.ToString(), response.subscriptionId.ToString());
if (_authorizeNetPaymentSettings.TransactMode == TransactMode.Authorize)
{
result.NewPaymentStatus = PaymentStatus.Authorized;
}
else
{
result.NewPaymentStatus = PaymentStatus.Paid;
}
}
else
{
result.AddError(string.Format("Error processing recurring payment. {0}", GetErrors(response)));
}
}
}
return result;
}
/// <summary>
/// Process a payment
/// </summary>
/// <param name="processPaymentRequest">Payment info required for an order processing</param>
/// <returns>Process payment result</returns>
public ProcessPaymentResult ProcessPayment(ProcessPaymentRequest processPaymentRequest)
{
var result = new ProcessPaymentResult();
result.NewPaymentStatus = PaymentStatus.Pending;
result.AuthorizationTransactionId = processPaymentRequest.GoogleOrderNumber;
return result;
}
/// <summary>
/// Places an order
/// </summary>
/// <param name="processPaymentRequest">Process payment request</param>
/// <returns>Place order result</returns>
public virtual PlaceOrderResult PlaceOrder(ProcessPaymentRequest processPaymentRequest)
{
if (processPaymentRequest == null)
throw new ArgumentNullException("processPaymentRequest");
var result = new PlaceOrderResult();
try
{
if (processPaymentRequest.OrderGuid == Guid.Empty)
processPaymentRequest.OrderGuid = Guid.NewGuid();
//prepare order details
var details = PreparePlaceOrderDetails(processPaymentRequest);
#region Payment workflow
//process payment
ProcessPaymentResult processPaymentResult = null;
//skip payment workflow if order total equals zero
var skipPaymentWorkflow = details.OrderTotal == decimal.Zero;
if (!skipPaymentWorkflow)
{
var paymentMethod = _paymentService.LoadPaymentMethodBySystemName(processPaymentRequest.PaymentMethodSystemName);
if (paymentMethod == null)
throw new NopException("Payment method couldn't be loaded");
//ensure that payment method is active
if (!paymentMethod.IsPaymentMethodActive(_paymentSettings))
throw new NopException("Payment method is not active");
if (details.IsRecurringShoppingCart)
{
//recurring cart
switch (_paymentService.GetRecurringPaymentType(processPaymentRequest.PaymentMethodSystemName))
{
case RecurringPaymentType.NotSupported:
throw new NopException("Recurring payments are not supported by selected payment method");
case RecurringPaymentType.Manual:
case RecurringPaymentType.Automatic:
processPaymentResult = _paymentService.ProcessRecurringPayment(processPaymentRequest);
break;
default:
throw new NopException("Not supported recurring payment type");
}
}
else
//standard cart
processPaymentResult = _paymentService.ProcessPayment(processPaymentRequest);
}
else
//payment is not required
processPaymentResult = new ProcessPaymentResult { NewPaymentStatus = PaymentStatus.Paid };
if (processPaymentResult == null)
throw new NopException("processPaymentResult is not available");
#endregion
if (processPaymentResult.Success)
{
#region Save order details
var order = SaveOrderDetails(processPaymentRequest, processPaymentResult, details);
result.PlacedOrder = order;
//move shopping cart items to order items
foreach (var sc in details.Cart)
{
//prices
decimal taxRate;
List<Discount> scDiscounts;
decimal discountAmount;
var scUnitPrice = _priceCalculationService.GetUnitPrice(sc);
var scSubTotal = _priceCalculationService.GetSubTotal(sc, true, out discountAmount, out scDiscounts);
var scUnitPriceInclTax = _taxService.GetProductPrice(sc.Product, scUnitPrice, true, details.Customer, out taxRate);
var scUnitPriceExclTax = _taxService.GetProductPrice(sc.Product, scUnitPrice, false, details.Customer, out taxRate);
var scSubTotalInclTax = _taxService.GetProductPrice(sc.Product, scSubTotal, true, details.Customer, out taxRate);
var scSubTotalExclTax = _taxService.GetProductPrice(sc.Product, scSubTotal, false, details.Customer, out taxRate);
var discountAmountInclTax = _taxService.GetProductPrice(sc.Product, discountAmount, true, details.Customer, out taxRate);
var discountAmountExclTax = _taxService.GetProductPrice(sc.Product, discountAmount, false, details.Customer, out taxRate);
foreach (var disc in scDiscounts)
if (!details.AppliedDiscounts.ContainsDiscount(disc))
details.AppliedDiscounts.Add(disc);
//attributes
var attributeDescription = _productAttributeFormatter.FormatAttributes(sc.Product, sc.AttributesXml, details.Customer);
var itemWeight = _shippingService.GetShoppingCartItemWeight(sc);
//save order item
var orderItem = new OrderItem
{
OrderItemGuid = Guid.NewGuid(),
Order = order,
ProductId = sc.ProductId,
UnitPriceInclTax = scUnitPriceInclTax,
UnitPriceExclTax = scUnitPriceExclTax,
PriceInclTax = scSubTotalInclTax,
PriceExclTax = scSubTotalExclTax,
OriginalProductCost = _priceCalculationService.GetProductCost(sc.Product, sc.AttributesXml),
AttributeDescription = attributeDescription,
AttributesXml = sc.AttributesXml,
Quantity = sc.Quantity,
DiscountAmountInclTax = discountAmountInclTax,
DiscountAmountExclTax = discountAmountExclTax,
DownloadCount = 0,
IsDownloadActivated = false,
LicenseDownloadId = 0,
ItemWeight = itemWeight,
RentalStartDateUtc = sc.RentalStartDateUtc,
RentalEndDateUtc = sc.RentalEndDateUtc
};
order.OrderItems.Add(orderItem);
_orderService.UpdateOrder(order);
//gift cards
if (sc.Product.IsGiftCard)
{
string giftCardRecipientName;
string giftCardRecipientEmail;
string giftCardSenderName;
string giftCardSenderEmail;
string giftCardMessage;
_productAttributeParser.GetGiftCardAttribute(sc.AttributesXml, out giftCardRecipientName,
out giftCardRecipientEmail, out giftCardSenderName, out giftCardSenderEmail, out giftCardMessage);
for (var i = 0; i < sc.Quantity; i++)
{
_giftCardService.InsertGiftCard(new GiftCard
{
GiftCardType = sc.Product.GiftCardType,
PurchasedWithOrderItem = orderItem,
Amount = sc.Product.OverriddenGiftCardAmount.HasValue ? sc.Product.OverriddenGiftCardAmount.Value : scUnitPriceExclTax,
IsGiftCardActivated = false,
GiftCardCouponCode = _giftCardService.GenerateGiftCardCode(),
RecipientName = giftCardRecipientName,
RecipientEmail = giftCardRecipientEmail,
SenderName = giftCardSenderName,
SenderEmail = giftCardSenderEmail,
Message = giftCardMessage,
IsRecipientNotified = false,
CreatedOnUtc = DateTime.UtcNow
});
}
}
//inventory
_productService.AdjustInventory(sc.Product, -sc.Quantity, sc.AttributesXml);
}
//clear shopping cart
details.Cart.ToList().ForEach(sci => _shoppingCartService.DeleteShoppingCartItem(sci, false));
//discount usage history
foreach (var discount in details.AppliedDiscounts)
{
_discountService.InsertDiscountUsageHistory(new DiscountUsageHistory
{
Discount = discount,
Order = order,
CreatedOnUtc = DateTime.UtcNow
});
}
//gift card usage history
if (details.AppliedGiftCards != null)
foreach (var agc in details.AppliedGiftCards)
{
agc.GiftCard.GiftCardUsageHistory.Add(new GiftCardUsageHistory
{
GiftCard = agc.GiftCard,
UsedWithOrder = order,
UsedValue = agc.AmountCanBeUsed,
CreatedOnUtc = DateTime.UtcNow
});
_giftCardService.UpdateGiftCard(agc.GiftCard);
}
//recurring orders
if (details.IsRecurringShoppingCart)
{
//create recurring payment (the first payment)
var rp = new RecurringPayment
{
CycleLength = processPaymentRequest.RecurringCycleLength,
CyclePeriod = processPaymentRequest.RecurringCyclePeriod,
TotalCycles = processPaymentRequest.RecurringTotalCycles,
StartDateUtc = DateTime.UtcNow,
IsActive = true,
CreatedOnUtc = DateTime.UtcNow,
InitialOrder = order,
};
_orderService.InsertRecurringPayment(rp);
switch (_paymentService.GetRecurringPaymentType(processPaymentRequest.PaymentMethodSystemName))
{
case RecurringPaymentType.NotSupported:
//not supported
break;
case RecurringPaymentType.Manual:
rp.RecurringPaymentHistory.Add(new RecurringPaymentHistory
{
RecurringPayment = rp,
CreatedOnUtc = DateTime.UtcNow,
OrderId = order.Id,
});
_orderService.UpdateRecurringPayment(rp);
break;
case RecurringPaymentType.Automatic:
//will be created later (process is automated)
break;
default:
break;
}
}
#endregion
//notifications
SendNotificationsAndSaveNotes(order);
//reset checkout data
_customerService.ResetCheckoutData(details.Customer, processPaymentRequest.StoreId, clearCouponCodes: true, clearCheckoutAttributes: true);
_customerActivityService.InsertActivity("PublicStore.PlaceOrder", _localizationService.GetResource("ActivityLog.PublicStore.PlaceOrder"), order.Id);
//check order status
CheckOrderStatus(order);
//raise event
_eventPublisher.Publish(new OrderPlacedEvent(order));
if (order.PaymentStatus == PaymentStatus.Paid)
ProcessOrderPaid(order);
}
else
foreach (var paymentError in processPaymentResult.Errors)
result.AddError(string.Format(_localizationService.GetResource("Checkout.PaymentError"), paymentError));
}
catch (Exception exc)
{
_logger.Error(exc.Message, exc);
result.AddError(exc.Message);
}
#region Process errors
if (!result.Success)
{
//log errors
var logError = result.Errors.Aggregate("Error while placing order. ",
(current, next) => string.Format("{0}Error {1}: {2}. ", current, result.Errors.IndexOf(next) + 1, next));
var customer = _customerService.GetCustomerById(processPaymentRequest.CustomerId);
_logger.Error(logError, customer: customer);
}
#endregion
return result;
}
public ProcessPaymentResult ProcessPayment(ProcessPaymentRequest processPaymentRequest)
{
var result = new ProcessPaymentResult();
var customer = _customerService.GetCustomerById(processPaymentRequest.CustomerId);
// Credit Card Info
PayfirmaCreditCard cc = new PayfirmaCreditCard()
{
Number = processPaymentRequest.CreditCardNumber,
ExpMonth = processPaymentRequest.CreditCardExpireMonth,
ExpYear = processPaymentRequest.CreditCardExpireYear,
CVV2 = processPaymentRequest.CreditCardCvv2
};
// Extra Meta Data
PayfirmaMetaData payfirmaMeta = new PayfirmaMetaData();
payfirmaMeta.Firstname = customer.BillingAddress.FirstName;
payfirmaMeta.Lastname = customer.BillingAddress.LastName;
if (!String.IsNullOrEmpty(customer.BillingAddress.Company)) { payfirmaMeta.Company = customer.BillingAddress.Company; }
payfirmaMeta.Address1 = customer.BillingAddress.Address1;
if (!String.IsNullOrEmpty(customer.BillingAddress.Address2)) { payfirmaMeta.Address2 = customer.BillingAddress.Address2; }
payfirmaMeta.City = customer.BillingAddress.City;
if (customer.BillingAddress.StateProvince != null)
{
payfirmaMeta.Province = customer.BillingAddress.StateProvince.Name;
}
payfirmaMeta.PostalCode = customer.BillingAddress.ZipPostalCode;
if (customer.BillingAddress.Country != null)
{
payfirmaMeta.Country = customer.BillingAddress.Country.Name;
}
payfirmaMeta.Email = customer.BillingAddress.Email;
String currencyCode = _currencyService.GetCurrencyById(_currencySettings.PrimaryStoreCurrencyId).CurrencyCode;
payfirmaMeta.Currency = "CA$";
if (currencyCode == "USD") { payfirmaMeta.Currency = "US$"; }
payfirmaMeta.OrderId = processPaymentRequest.OrderGuid.ToString();
if (!String.IsNullOrEmpty(customer.BillingAddress.PhoneNumber)) { payfirmaMeta.Telephone = customer.BillingAddress.PhoneNumber; }
payfirmaMeta.Description = "Payment via nopCommerce.";
PayfirmaTransaction payfirma = new PayfirmaTransaction();
PayfirmaTransactionResponse payfirmaResponse;
if (_payfirmaPaymentSettings.TransactMode == TransactMode.Authorize)
{
payfirmaResponse = payfirma.ProcessAuthorize(this.PopulateMerchantCredentials(), cc, payfirmaMeta,
Convert.ToDouble(processPaymentRequest.OrderTotal), _payfirmaPaymentSettings.IsTest);
}
else
{
payfirmaResponse = payfirma.ProcessSale(this.PopulateMerchantCredentials(), cc, payfirmaMeta,
Convert.ToDouble(processPaymentRequest.OrderTotal), _payfirmaPaymentSettings.IsTest);
}
if (!String.IsNullOrEmpty(payfirmaResponse.Error))
{
result.AddError(payfirmaResponse.Error);
}
else if (!payfirmaResponse.Result)
{
result.AddError(payfirmaResponse.ResultMessage);
} else {
result.AvsResult = payfirmaResponse.AVS;
result.AuthorizationTransactionCode = payfirmaResponse.AuthCode;
result.AuthorizationTransactionId = payfirmaResponse.TransactionId;
result.AuthorizationTransactionResult = payfirmaResponse.ResultMessage;
if (_payfirmaPaymentSettings.TransactMode == TransactMode.Authorize)
{
result.NewPaymentStatus = PaymentStatus.Authorized;
}
else
{
result.NewPaymentStatus = PaymentStatus.Paid;
}
}
return result;
}
public ProcessPaymentResult ProcessPayment(ProcessPaymentRequest processPaymentRequest)
{
var result = new ProcessPaymentResult();
result.AllowStoringCreditCardNumber = true;
result.SubscriptionTransactionId = processPaymentRequest.CustomValues["yandexKassaMode"].ToString();
result.NewPaymentStatus = PaymentStatus.Pending;
return result;
}
public ProcessPaymentResult ProcessRecurringPayment(ProcessPaymentRequest processPaymentRequest)
{
var result = new ProcessPaymentResult();
result.AddError("Ежемесячная оплата не поддерживается.");
return result;
}
/// <summary>
/// Process a payment
/// </summary>
/// <param name="processPaymentRequest">Payment info required for an order processing</param>
/// <returns>Process payment result</returns>
public ProcessPaymentResult ProcessPayment(ProcessPaymentRequest processPaymentRequest)
{
var googleOrderNumber = processPaymentRequest.CustomValues.ContainsKey("GoogleOrderNumber")
? processPaymentRequest.CustomValues["GoogleOrderNumber"] as string
: "";
var result = new ProcessPaymentResult();
result.NewPaymentStatus = PaymentStatus.Pending;
result.AuthorizationTransactionId = googleOrderNumber;
return result;
}
/// <summary>
/// Process a payment right after order is created
/// </summary>
/// <param name="processPaymentRequest">Payment info required for an order processing</param>
/// <returns>Process payment result</returns>
public ProcessPaymentResult ProcessPayment(ProcessPaymentRequest processPaymentRequest)
{
var result = new ProcessPaymentResult();
var transx = _sagePayServerTransactionService.GetSagePayServerTransactionByVendorTxCode(processPaymentRequest.OrderGuid.ToString());
if (transx == null)
{
result.AddError(String.Format("SagePay Server transaction code {0} does not exist.", processPaymentRequest.OrderGuid));
return result;
}
if ((transx.Status == "OK") || (transx.Status == "AUTHENTICATED") || (transx.Status == "REGISTERED"))
{
switch (_sagePayServerPaymentSettings.TransactType)
{
case TransactTypeValues.Payment:
var releaseResult = _sagePayServerWorkflowService.ReleaseTransaction(processPaymentRequest.OrderGuid.ToString(), processPaymentRequest.OrderTotal);
if (releaseResult.Success)
{
result.NewPaymentStatus = PaymentStatus.Paid;
result.CaptureTransactionResult = releaseResult.Message;
}
else
{
result.AddError(releaseResult.Message);
}
break;
case TransactTypeValues.Deferred:
result.NewPaymentStatus = PaymentStatus.Authorized;
break;
default:
result.NewPaymentStatus = PaymentStatus.Pending;
break;
}
result.AuthorizationTransactionId = transx.Id.ToString(CultureInfo.InvariantCulture);
result.AuthorizationTransactionCode = transx.VpsTxId;
result.AuthorizationTransactionResult = transx.ToString();
}
else
{
result.AddError(transx.StatusDetail);
}
return result;
}
/// <summary>
/// Process a payment
/// </summary>
/// <param name="processPaymentRequest">Payment info required for an order processing</param>
/// <returns>Process payment result</returns>
public ProcessPaymentResult ProcessPayment(ProcessPaymentRequest processPaymentRequest)
{
var result = new ProcessPaymentResult();
var customer = _customerService.GetCustomerById(processPaymentRequest.CustomerId);
//var orderTotal = Math.Round(processPaymentRequest.OrderTotal, 2);
StripeCreditCardInfo cc = new StripeCreditCardInfo();
cc.CVC = processPaymentRequest.CreditCardCvv2;
cc.FullName = customer.BillingAddress.FirstName + " " + customer.BillingAddress.LastName;
cc.Number = processPaymentRequest.CreditCardNumber;
cc.ExpirationMonth = processPaymentRequest.CreditCardExpireMonth;
cc.ExpirationYear = processPaymentRequest.CreditCardExpireYear;
cc.AddressLine1 = customer.BillingAddress.Address1;
cc.AddressLine2 = customer.BillingAddress.Address2;
if (customer.BillingAddress.Country.TwoLetterIsoCode.ToLower() == "us")
{
cc.StateOrProvince = customer.BillingAddress.StateProvince.Abbreviation;
}
else
{
cc.StateOrProvince = "ot";
}
cc.ZipCode = customer.BillingAddress.ZipPostalCode;
cc.Country = customer.BillingAddress.Country.TwoLetterIsoCode;
StripePayment payment = new StripePayment(_stripePaymentSettings.TransactionKey);
try
{
StripeCharge charge = payment.Charge((int)(processPaymentRequest.OrderTotal * 100),
_currencyService.GetCurrencyById(_currencySettings.PrimaryStoreCurrencyId).CurrencyCode.ToLower(),
cc, string.Format("charge for {0} - {1}",
cc.FullName, processPaymentRequest.PurchaseOrderNumber));
if (charge != null)
{
result.NewPaymentStatus = PaymentStatus.Paid;
_stripePaymentSettings.TransactMode = TransactMode.AuthorizeAndCapture;
result.AuthorizationTransactionId = charge.ID;
result.AuthorizationTransactionResult = StripeChargeStatus.SUCCESS;
//need this for refund
result.AuthorizationTransactionCode = _stripePaymentSettings.TransactionKey;
}
}
catch (StripeException stripeException)
{
result.AuthorizationTransactionResult = stripeException.StripeError.Message;
result.AuthorizationTransactionCode = stripeException.StripeError.Code;
result.AuthorizationTransactionId = "-1";
result.AddError(string.Format("Declined ({0}: {1} - {2})", result.AuthorizationTransactionCode,
result.AuthorizationTransactionResult, _currencyService.GetCurrencyById(_currencySettings.PrimaryStoreCurrencyId).CurrencyCode));
}
return result;
}
public PlaceOrderResult PaypalOrderDetails(ProcessPaymentRequest processPaymentRequest)
{
//think about moving functionality of processing recurring orders (after the initial order was placed) to ProcessNextRecurringPayment() method
if (processPaymentRequest == null)
throw new ArgumentNullException("processPaymentRequest");
var result = new PlaceOrderResult();
try
{
//if (processPaymentRequest.OrderGuid == Guid.Empty)
// processPaymentRequest.OrderGuid = Guid.NewGuid();
//prepare order details
var details = PreparePlaceOrderDetails(processPaymentRequest);
#region Payment workflow
//process payment
ProcessPaymentResult processPaymentResult = null;
//skip payment workflow if order total equals zero
var skipPaymentWorkflow = details.OrderTotal == decimal.Zero;
if (!skipPaymentWorkflow)
{
var paymentMethod = _paymentService.LoadPaymentMethodBySystemName(processPaymentRequest.PaymentMethodSystemName);
if (paymentMethod == null)
throw new NopException("Payment method couldn't be loaded");
//ensure that payment method is active
if (!paymentMethod.IsPaymentMethodActive(_paymentSettings))
throw new NopException("Payment method is not active");
if (!processPaymentRequest.IsRecurringPayment)
{
if (details.IsRecurringShoppingCart)
{
//recurring cart
var recurringPaymentType = _paymentService.GetRecurringPaymentType(processPaymentRequest.PaymentMethodSystemName);
switch (recurringPaymentType)
{
case RecurringPaymentType.NotSupported:
throw new NopException("Recurring payments are not supported by selected payment method");
case RecurringPaymentType.Manual:
case RecurringPaymentType.Automatic:
processPaymentResult = _paymentService.ProcessRecurringPayment(processPaymentRequest);
break;
default:
throw new NopException("Not supported recurring payment type");
}
}
else
{
//standard cart
processPaymentResult = _paymentService.ProcessPayment(processPaymentRequest);
}
}
else
{
if (details.IsRecurringShoppingCart)
{
//Old credit card info
processPaymentRequest.CreditCardType = details.InitialOrder.AllowStoringCreditCardNumber ? _encryptionService.DecryptText(details.InitialOrder.CardType) : "";
processPaymentRequest.CreditCardName = details.InitialOrder.AllowStoringCreditCardNumber ? _encryptionService.DecryptText(details.InitialOrder.CardName) : "";
processPaymentRequest.CreditCardNumber = details.InitialOrder.AllowStoringCreditCardNumber ? _encryptionService.DecryptText(details.InitialOrder.CardNumber) : "";
processPaymentRequest.CreditCardCvv2 = details.InitialOrder.AllowStoringCreditCardNumber ? _encryptionService.DecryptText(details.InitialOrder.CardCvv2) : "";
try
{
processPaymentRequest.CreditCardExpireMonth = details.InitialOrder.AllowStoringCreditCardNumber ? Convert.ToInt32(_encryptionService.DecryptText(details.InitialOrder.CardExpirationMonth)) : 0;
processPaymentRequest.CreditCardExpireYear = details.InitialOrder.AllowStoringCreditCardNumber ? Convert.ToInt32(_encryptionService.DecryptText(details.InitialOrder.CardExpirationYear)) : 0;
}
catch { }
var recurringPaymentType = _paymentService.GetRecurringPaymentType(processPaymentRequest.PaymentMethodSystemName);
switch (recurringPaymentType)
{
case RecurringPaymentType.NotSupported:
throw new NopException("Recurring payments are not supported by selected payment method");
case RecurringPaymentType.Manual:
processPaymentResult = _paymentService.ProcessRecurringPayment(processPaymentRequest);
break;
case RecurringPaymentType.Automatic:
//payment is processed on payment gateway site
processPaymentResult = new ProcessPaymentResult();
break;
default:
throw new NopException("Not supported recurring payment type");
}
}
else
{
throw new NopException("No recurring products");
}
}
}
else
{
//payment is not required
if (processPaymentResult == null)
processPaymentResult = new ProcessPaymentResult();
processPaymentResult.NewPaymentStatus = PaymentStatus.Paid;
}
if (processPaymentResult == null)
throw new NopException("processPaymentResult is not available");
#endregion
if (processPaymentResult.Success)
{
#region Save order details
var order = new Order
{
StoreId = processPaymentRequest.StoreId,
OrderGuid = processPaymentRequest.OrderGuid,
CustomerId = details.Customer.Id,
CustomerLanguageId = details.CustomerLanguage.Id,
CustomerTaxDisplayType = details.CustomerTaxDisplayType,
CustomerIp = _webHelper.GetCurrentIpAddress(),
OrderSubtotalInclTax = details.OrderSubTotalInclTax,
OrderSubtotalExclTax = details.OrderSubTotalExclTax,
OrderSubTotalDiscountInclTax = details.OrderSubTotalDiscountInclTax,
OrderSubTotalDiscountExclTax = details.OrderSubTotalDiscountExclTax,
OrderShippingInclTax = details.OrderShippingTotalInclTax,
OrderShippingExclTax = details.OrderShippingTotalExclTax,
PaymentMethodAdditionalFeeInclTax = details.PaymentAdditionalFeeInclTax,
PaymentMethodAdditionalFeeExclTax = details.PaymentAdditionalFeeExclTax,
TaxRates = details.TaxRates,
OrderTax = details.OrderTaxTotal,
OrderTotal = details.OrderTotal,
RefundedAmount = decimal.Zero,
OrderDiscount = details.OrderDiscountAmount,
CheckoutAttributeDescription = details.CheckoutAttributeDescription,
CheckoutAttributesXml = details.CheckoutAttributesXml,
CustomerCurrencyCode = details.CustomerCurrencyCode,
CurrencyRate = details.CustomerCurrencyRate,
AffiliateId = details.AffiliateId,
OrderStatus = OrderStatus.Pending,
AllowStoringCreditCardNumber = processPaymentResult.AllowStoringCreditCardNumber,
CardType = processPaymentResult.AllowStoringCreditCardNumber ? _encryptionService.EncryptText(processPaymentRequest.CreditCardType) : string.Empty,
CardName = processPaymentResult.AllowStoringCreditCardNumber ? _encryptionService.EncryptText(processPaymentRequest.CreditCardName) : string.Empty,
CardNumber = processPaymentResult.AllowStoringCreditCardNumber ? _encryptionService.EncryptText(processPaymentRequest.CreditCardNumber) : string.Empty,
MaskedCreditCardNumber = _encryptionService.EncryptText(_paymentService.GetMaskedCreditCardNumber(processPaymentRequest.CreditCardNumber)),
CardCvv2 = processPaymentResult.AllowStoringCreditCardNumber ? _encryptionService.EncryptText(processPaymentRequest.CreditCardCvv2) : string.Empty,
CardExpirationMonth = processPaymentResult.AllowStoringCreditCardNumber ? _encryptionService.EncryptText(processPaymentRequest.CreditCardExpireMonth.ToString()) : string.Empty,
CardExpirationYear = processPaymentResult.AllowStoringCreditCardNumber ? _encryptionService.EncryptText(processPaymentRequest.CreditCardExpireYear.ToString()) : string.Empty,
PaymentMethodSystemName = processPaymentRequest.PaymentMethodSystemName,
AuthorizationTransactionId = processPaymentResult.AuthorizationTransactionId,
AuthorizationTransactionCode = processPaymentResult.AuthorizationTransactionCode,
AuthorizationTransactionResult = processPaymentResult.AuthorizationTransactionResult,
CaptureTransactionId = processPaymentResult.CaptureTransactionId,
CaptureTransactionResult = processPaymentResult.CaptureTransactionResult,
SubscriptionTransactionId = processPaymentResult.SubscriptionTransactionId,
PaymentStatus = processPaymentResult.NewPaymentStatus,
PaidDateUtc = null,
BillingAddress = details.BillingAddress,
ShippingAddress = details.ShippingAddress,
ShippingStatus = details.ShippingStatus,
ShippingMethod = details.ShippingMethodName,
PickUpInStore = details.PickUpInStore,
ShippingRateComputationMethodSystemName = details.ShippingRateComputationMethodSystemName,
CustomValuesXml = processPaymentRequest.SerializeCustomValues(),
VatNumber = details.VatNumber,
CreatedOnUtc = DateTime.UtcNow
};
//_orderService.InsertOrder(order);
result.PlacedOrder = order;
if (!processPaymentRequest.IsRecurringPayment)
{
//move shopping cart items to order items
foreach (var sc in details.Cart)
{
//prices
decimal taxRate;
Discount scDiscount;
decimal discountAmount;
decimal scUnitPrice = _priceCalculationService.GetUnitPrice(sc);
decimal scSubTotal = _priceCalculationService.GetSubTotal(sc, true, out discountAmount, out scDiscount);
decimal scUnitPriceInclTax = _taxService.GetProductPrice(sc.Product, scUnitPrice, true, details.Customer, out taxRate);
decimal scUnitPriceExclTax = _taxService.GetProductPrice(sc.Product, scUnitPrice, false, details.Customer, out taxRate);
decimal scSubTotalInclTax = _taxService.GetProductPrice(sc.Product, scSubTotal, true, details.Customer, out taxRate);
decimal scSubTotalExclTax = _taxService.GetProductPrice(sc.Product, scSubTotal, false, details.Customer, out taxRate);
decimal discountAmountInclTax = _taxService.GetProductPrice(sc.Product, discountAmount, true, details.Customer, out taxRate);
decimal discountAmountExclTax = _taxService.GetProductPrice(sc.Product, discountAmount, false, details.Customer, out taxRate);
if (scDiscount != null && !details.AppliedDiscounts.ContainsDiscount(scDiscount))
details.AppliedDiscounts.Add(scDiscount);
//attributes
string attributeDescription = _productAttributeFormatter.FormatAttributes(sc.Product, sc.AttributesXml, details.Customer);
var itemWeight = _shippingService.GetShoppingCartItemWeight(sc);
//save order item
var orderItem = new OrderItem
{
OrderItemGuid = Guid.NewGuid(),
Order = order,
ProductId = sc.ProductId,
UnitPriceInclTax = scUnitPriceInclTax,
UnitPriceExclTax = scUnitPriceExclTax,
PriceInclTax = scSubTotalInclTax,
PriceExclTax = scSubTotalExclTax,
OriginalProductCost = _priceCalculationService.GetProductCost(sc.Product, sc.AttributesXml),
AttributeDescription = attributeDescription,
AttributesXml = sc.AttributesXml,
Quantity = sc.Quantity,
DiscountAmountInclTax = discountAmountInclTax,
DiscountAmountExclTax = discountAmountExclTax,
DownloadCount = 0,
IsDownloadActivated = false,
LicenseDownloadId = 0,
ItemWeight = itemWeight,
RentalStartDateUtc = sc.RentalStartDateUtc,
RentalEndDateUtc = sc.RentalEndDateUtc
};
order.OrderItems.Add(orderItem);
//_orderService.UpdateOrder(order);
//gift cards
if (sc.Product.IsGiftCard)
{
string giftCardRecipientName, giftCardRecipientEmail,
giftCardSenderName, giftCardSenderEmail, giftCardMessage;
_productAttributeParser.GetGiftCardAttribute(sc.AttributesXml,
out giftCardRecipientName, out giftCardRecipientEmail,
out giftCardSenderName, out giftCardSenderEmail, out giftCardMessage);
for (int i = 0; i < sc.Quantity; i++)
{
var gc = new GiftCard
{
GiftCardType = sc.Product.GiftCardType,
PurchasedWithOrderItem = orderItem,
Amount = sc.Product.OverriddenGiftCardAmount.HasValue ? sc.Product.OverriddenGiftCardAmount.Value : scUnitPriceExclTax,
IsGiftCardActivated = false,
GiftCardCouponCode = _giftCardService.GenerateGiftCardCode(),
RecipientName = giftCardRecipientName,
RecipientEmail = giftCardRecipientEmail,
SenderName = giftCardSenderName,
SenderEmail = giftCardSenderEmail,
Message = giftCardMessage,
IsRecipientNotified = false,
CreatedOnUtc = DateTime.UtcNow
};
// _giftCardService.InsertGiftCard(gc);
}
}
//inventory
_productService.AdjustInventory(sc.Product, -sc.Quantity, sc.AttributesXml);
}
//clear shopping cart
//details.Cart.ToList().ForEach(sci => _shoppingCartService.DeleteShoppingCartItem(sci, false));
}
else
{
//recurring payment
var initialOrderItems = details.InitialOrder.OrderItems;
foreach (var orderItem in initialOrderItems)
{
//save item
var newOrderItem = new OrderItem
{
OrderItemGuid = Guid.NewGuid(),
Order = order,
ProductId = orderItem.ProductId,
UnitPriceInclTax = orderItem.UnitPriceInclTax,
UnitPriceExclTax = orderItem.UnitPriceExclTax,
PriceInclTax = orderItem.PriceInclTax,
PriceExclTax = orderItem.PriceExclTax,
OriginalProductCost = orderItem.OriginalProductCost,
AttributeDescription = orderItem.AttributeDescription,
AttributesXml = orderItem.AttributesXml,
Quantity = orderItem.Quantity,
DiscountAmountInclTax = orderItem.DiscountAmountInclTax,
DiscountAmountExclTax = orderItem.DiscountAmountExclTax,
DownloadCount = 0,
IsDownloadActivated = false,
LicenseDownloadId = 0,
ItemWeight = orderItem.ItemWeight,
RentalStartDateUtc = orderItem.RentalStartDateUtc,
RentalEndDateUtc = orderItem.RentalEndDateUtc
};
order.OrderItems.Add(newOrderItem);
//_orderService.UpdateOrder(order);
//gift cards
if (orderItem.Product.IsGiftCard)
{
string giftCardRecipientName, giftCardRecipientEmail,
giftCardSenderName, giftCardSenderEmail, giftCardMessage;
_productAttributeParser.GetGiftCardAttribute(orderItem.AttributesXml,
out giftCardRecipientName, out giftCardRecipientEmail,
out giftCardSenderName, out giftCardSenderEmail, out giftCardMessage);
for (int i = 0; i < orderItem.Quantity; i++)
{
var gc = new GiftCard
{
GiftCardType = orderItem.Product.GiftCardType,
PurchasedWithOrderItem = newOrderItem,
Amount = orderItem.UnitPriceExclTax,
IsGiftCardActivated = false,
GiftCardCouponCode = _giftCardService.GenerateGiftCardCode(),
RecipientName = giftCardRecipientName,
RecipientEmail = giftCardRecipientEmail,
SenderName = giftCardSenderName,
SenderEmail = giftCardSenderEmail,
Message = giftCardMessage,
IsRecipientNotified = false,
CreatedOnUtc = DateTime.UtcNow
};
//_giftCardService.InsertGiftCard(gc);
}
}
//inventory
_productService.AdjustInventory(orderItem.Product, -orderItem.Quantity, orderItem.AttributesXml);
}
}
//discount usage history
if (!processPaymentRequest.IsRecurringPayment)
foreach (var discount in details.AppliedDiscounts)
{
var duh = new DiscountUsageHistory
{
Discount = discount,
Order = order,
CreatedOnUtc = DateTime.UtcNow
};
//_discountService.InsertDiscountUsageHistory(duh);
}
//gift card usage history
if (!processPaymentRequest.IsRecurringPayment)
if (details.AppliedGiftCards != null)
foreach (var agc in details.AppliedGiftCards)
{
decimal amountUsed = agc.AmountCanBeUsed;
var gcuh = new GiftCardUsageHistory
{
GiftCard = agc.GiftCard,
UsedWithOrder = order,
UsedValue = amountUsed,
CreatedOnUtc = DateTime.UtcNow
};
agc.GiftCard.GiftCardUsageHistory.Add(gcuh);
//_giftCardService.UpdateGiftCard(agc.GiftCard);
}
//reward points history
if (details.RedeemedRewardPointsAmount > decimal.Zero)
{
_rewardPointService.AddRewardPointsHistoryEntry(details.Customer,
-details.RedeemedRewardPoints, order.StoreId,
string.Format(_localizationService.GetResource("RewardPoints.Message.RedeemedForOrder", order.CustomerLanguageId), order.Id),
order, details.RedeemedRewardPointsAmount);
//_customerService.UpdateCustomer(details.Customer);
}
//recurring orders
if (!processPaymentRequest.IsRecurringPayment && details.IsRecurringShoppingCart)
{
//create recurring payment (the first payment)
var rp = new RecurringPayment
{
CycleLength = processPaymentRequest.RecurringCycleLength,
CyclePeriod = processPaymentRequest.RecurringCyclePeriod,
TotalCycles = processPaymentRequest.RecurringTotalCycles,
StartDateUtc = DateTime.UtcNow,
IsActive = true,
CreatedOnUtc = DateTime.UtcNow,
InitialOrder = order,
};
//_orderService.InsertRecurringPayment(rp);
var recurringPaymentType = _paymentService.GetRecurringPaymentType(processPaymentRequest.PaymentMethodSystemName);
switch (recurringPaymentType)
{
case RecurringPaymentType.NotSupported:
{
//not supported
}
break;
case RecurringPaymentType.Manual:
{
//first payment
var rph = new RecurringPaymentHistory
{
RecurringPayment = rp,
CreatedOnUtc = DateTime.UtcNow,
OrderId = order.Id,
};
rp.RecurringPaymentHistory.Add(rph);
_orderService.UpdateRecurringPayment(rp);
}
break;
case RecurringPaymentType.Automatic:
{
//will be created later (process is automated)
}
break;
default:
break;
}
}
#endregion
#region Notifications & notes
//notes, messages
if (_workContext.OriginalCustomerIfImpersonated != null)
{
//this order is placed by a store administrator impersonating a customer
order.OrderNotes.Add(new OrderNote
{
Note = string.Format("Order placed by a store owner ('{0}'. ID = {1}) impersonating the customer.",
_workContext.OriginalCustomerIfImpersonated.Email, _workContext.OriginalCustomerIfImpersonated.Id),
DisplayToCustomer = false,
CreatedOnUtc = DateTime.UtcNow
});
//_orderService.UpdateOrder(order);
}
else
{
order.OrderNotes.Add(new OrderNote
{
Note = "Order placed",
DisplayToCustomer = false,
CreatedOnUtc = DateTime.UtcNow
});
//_orderService.UpdateOrder(order);
}
//send email notifications
//int orderPlacedStoreOwnerNotificationQueuedEmailId = _workflowMessageService.SendOrderPlacedStoreOwnerNotification(order, _localizationSettings.DefaultAdminLanguageId);
//if (orderPlacedStoreOwnerNotificationQueuedEmailId > 0)
//{
// order.OrderNotes.Add(new OrderNote
// {
// Note = string.Format("\"Order placed\" email (to store owner) has been queued. Queued email identifier: {0}.", orderPlacedStoreOwnerNotificationQueuedEmailId),
// DisplayToCustomer = false,
// CreatedOnUtc = DateTime.UtcNow
// });
// //_orderService.UpdateOrder(order);
//}
var orderPlacedAttachmentFilePath = _orderSettings.AttachPdfInvoiceToOrderPlacedEmail ?
_pdfService.PrintOrderToPdf(order, order.CustomerLanguageId) : null;
//var orderPlacedAttachmentFileName = _orderSettings.AttachPdfInvoiceToOrderPlacedEmail ?
// "order.pdf" : null;
//int orderPlacedCustomerNotificationQueuedEmailId = _workflowMessageService
// .SendOrderPlacedCustomerNotification(order, order.CustomerLanguageId, orderPlacedAttachmentFilePath, orderPlacedAttachmentFileName);
//if (orderPlacedCustomerNotificationQueuedEmailId > 0)
//{
// order.OrderNotes.Add(new OrderNote
// {
// Note = string.Format("\"Order placed\" email (to customer) has been queued. Queued email identifier: {0}.", orderPlacedCustomerNotificationQueuedEmailId),
// DisplayToCustomer = false,
// CreatedOnUtc = DateTime.UtcNow
// });
// //_orderService.UpdateOrder(order);
//}
//var vendors = GetVendorsInOrder(order);
//foreach (var vendor in vendors)
//{
// int orderPlacedVendorNotificationQueuedEmailId = _workflowMessageService.SendOrderPlacedVendorNotification(order, vendor, order.CustomerLanguageId);
// if (orderPlacedVendorNotificationQueuedEmailId > 0)
// {
// order.OrderNotes.Add(new OrderNote
// {
// Note = string.Format("\"Order placed\" email (to vendor) has been queued. Queued email identifier: {0}.", orderPlacedVendorNotificationQueuedEmailId),
// DisplayToCustomer = false,
// CreatedOnUtc = DateTime.UtcNow
// });
// //_orderService.UpdateOrder(order);
// }
//}
//check order status
CheckOrderStatus(order);
//reset checkout data
//if (!processPaymentRequest.IsRecurringPayment)
// _customerService.ResetCheckoutData(details.Customer, processPaymentRequest.StoreId, clearCouponCodes: true, clearCheckoutAttributes: true);
//if (!processPaymentRequest.IsRecurringPayment)
//{
// _customerActivityService.InsertActivity(
// "PublicStore.PlaceOrder",
// _localizationService.GetResource("ActivityLog.PublicStore.PlaceOrder"),
// order.Id);
//}
//raise event
//_eventPublisher.Publish(new OrderPlacedEvent(order));
if (order.PaymentStatus == PaymentStatus.Paid)
{
ProcessOrderPaid(order);
}
#endregion
}
else
{
//payment errors
foreach (var paymentError in processPaymentResult.Errors)
result.AddError(string.Format(_localizationService.GetResource("Checkout.PaymentError"), paymentError));
}
}
catch (Exception exc)
{
_logger.Error(exc.Message, exc);
result.AddError(exc.Message);
}
#region Process errors
string error = "";
for (int i = 0; i < result.Errors.Count; i++)
{
error += string.Format("Error {0}: {1}", i + 1, result.Errors[i]);
if (i != result.Errors.Count - 1)
error += ". ";
}
if (!String.IsNullOrEmpty(error))
{
//log it
string logError = string.Format("Error while placing order. {0}", error);
var customer = _customerService.GetCustomerById(processPaymentRequest.CustomerId);
_logger.Error(logError, customer: customer);
}
#endregion
return result;
}
/// <summary>
/// Process next recurring payment
/// </summary>
/// <param name="recurringPayment">Recurring payment</param>
/// <param name="paymentResult">Process payment result (info about last payment for automatic recurring payments)</param>
public virtual void ProcessNextRecurringPayment(RecurringPayment recurringPayment, ProcessPaymentResult paymentResult = null)
{
if (recurringPayment == null)
throw new ArgumentNullException("recurringPayment");
try
{
if (!recurringPayment.IsActive)
throw new NopException("Recurring payment is not active");
var initialOrder = recurringPayment.InitialOrder;
if (initialOrder == null)
throw new NopException("Initial order could not be loaded");
var customer = initialOrder.Customer;
if (customer == null)
throw new NopException("Customer could not be loaded");
var nextPaymentDate = recurringPayment.NextPaymentDate;
if (!nextPaymentDate.HasValue)
throw new NopException("Next payment date could not be calculated");
//payment info
var processPaymentRequest = new ProcessPaymentRequest
{
StoreId = initialOrder.StoreId,
CustomerId = customer.Id,
OrderGuid = Guid.NewGuid(),
InitialOrderId = initialOrder.Id,
RecurringCycleLength = recurringPayment.CycleLength,
RecurringCyclePeriod = recurringPayment.CyclePeriod,
RecurringTotalCycles = recurringPayment.TotalCycles,
};
//prepare order details
var details = PrepareRecurringOrderDetails(processPaymentRequest);
ProcessPaymentResult processPaymentResult;
//skip payment workflow if order total equals zero
var skipPaymentWorkflow = details.OrderTotal == decimal.Zero;
if (!skipPaymentWorkflow)
{
var paymentMethod = _paymentService.LoadPaymentMethodBySystemName(processPaymentRequest.PaymentMethodSystemName);
if (paymentMethod == null)
throw new NopException("Payment method couldn't be loaded");
if (!paymentMethod.IsPaymentMethodActive(_paymentSettings))
throw new NopException("Payment method is not active");
//Old credit card info
if (details.InitialOrder.AllowStoringCreditCardNumber)
{
processPaymentRequest.CreditCardType = _encryptionService.DecryptText(details.InitialOrder.CardType);
processPaymentRequest.CreditCardName = _encryptionService.DecryptText(details.InitialOrder.CardName);
processPaymentRequest.CreditCardNumber = _encryptionService.DecryptText(details.InitialOrder.CardNumber);
processPaymentRequest.CreditCardCvv2 = _encryptionService.DecryptText(details.InitialOrder.CardCvv2);
try
{
processPaymentRequest.CreditCardExpireMonth = Convert.ToInt32(_encryptionService.DecryptText(details.InitialOrder.CardExpirationMonth));
processPaymentRequest.CreditCardExpireYear = Convert.ToInt32(_encryptionService.DecryptText(details.InitialOrder.CardExpirationYear));
}
catch { }
}
//payment type
switch (_paymentService.GetRecurringPaymentType(processPaymentRequest.PaymentMethodSystemName))
{
case RecurringPaymentType.NotSupported:
throw new NopException("Recurring payments are not supported by selected payment method");
case RecurringPaymentType.Manual:
processPaymentResult = _paymentService.ProcessRecurringPayment(processPaymentRequest);
break;
case RecurringPaymentType.Automatic:
//payment is processed on payment gateway site, info about last transaction in paymentResult parameter
processPaymentResult = paymentResult ?? new ProcessPaymentResult();
break;
default:
throw new NopException("Not supported recurring payment type");
}
}
else
processPaymentResult = paymentResult ?? new ProcessPaymentResult { NewPaymentStatus = PaymentStatus.Paid };
if (processPaymentResult == null)
throw new NopException("processPaymentResult is not available");
if (processPaymentResult.Success)
{
//save order details
var order = SaveOrderDetails(processPaymentRequest, processPaymentResult, details);
foreach (var orderItem in details.InitialOrder.OrderItems)
{
//save item
var newOrderItem = new OrderItem
{
OrderItemGuid = Guid.NewGuid(),
Order = order,
ProductId = orderItem.ProductId,
UnitPriceInclTax = orderItem.UnitPriceInclTax,
UnitPriceExclTax = orderItem.UnitPriceExclTax,
PriceInclTax = orderItem.PriceInclTax,
PriceExclTax = orderItem.PriceExclTax,
OriginalProductCost = orderItem.OriginalProductCost,
AttributeDescription = orderItem.AttributeDescription,
AttributesXml = orderItem.AttributesXml,
Quantity = orderItem.Quantity,
DiscountAmountInclTax = orderItem.DiscountAmountInclTax,
DiscountAmountExclTax = orderItem.DiscountAmountExclTax,
DownloadCount = 0,
IsDownloadActivated = false,
LicenseDownloadId = 0,
ItemWeight = orderItem.ItemWeight,
RentalStartDateUtc = orderItem.RentalStartDateUtc,
RentalEndDateUtc = orderItem.RentalEndDateUtc
};
order.OrderItems.Add(newOrderItem);
_orderService.UpdateOrder(order);
//gift cards
if (orderItem.Product.IsGiftCard)
{
string giftCardRecipientName;
string giftCardRecipientEmail;
string giftCardSenderName;
string giftCardSenderEmail;
string giftCardMessage;
_productAttributeParser.GetGiftCardAttribute(orderItem.AttributesXml, out giftCardRecipientName,
out giftCardRecipientEmail, out giftCardSenderName, out giftCardSenderEmail, out giftCardMessage);
for (var i = 0; i < orderItem.Quantity; i++)
{
_giftCardService.InsertGiftCard(new GiftCard
{
GiftCardType = orderItem.Product.GiftCardType,
PurchasedWithOrderItem = newOrderItem,
Amount = orderItem.UnitPriceExclTax,
IsGiftCardActivated = false,
GiftCardCouponCode = _giftCardService.GenerateGiftCardCode(),
RecipientName = giftCardRecipientName,
RecipientEmail = giftCardRecipientEmail,
SenderName = giftCardSenderName,
SenderEmail = giftCardSenderEmail,
Message = giftCardMessage,
IsRecipientNotified = false,
CreatedOnUtc = DateTime.UtcNow
});
}
}
//inventory
_productService.AdjustInventory(orderItem.Product, -orderItem.Quantity, orderItem.AttributesXml);
}
//notifications
SendNotificationsAndSaveNotes(order);
//check order status
CheckOrderStatus(order);
//raise event
_eventPublisher.Publish(new OrderPlacedEvent(order));
if (order.PaymentStatus == PaymentStatus.Paid)
ProcessOrderPaid(order);
//next recurring payment
recurringPayment.RecurringPaymentHistory.Add(new RecurringPaymentHistory
{
RecurringPayment = recurringPayment,
CreatedOnUtc = DateTime.UtcNow,
OrderId = order.Id,
});
_orderService.UpdateRecurringPayment(recurringPayment);
}
else
{
//log errors
var logError = processPaymentResult.Errors.Aggregate("Error while processing recurring order. ",
(current, next) => string.Format("{0}Error {1}: {2}. ", current, processPaymentResult.Errors.IndexOf(next) + 1, next));
_logger.Error(logError, customer: customer);
}
}
catch (Exception exc)
{
_logger.Error(string.Format("Error while processing recurring order. {0}", exc.Message), exc);
throw;
}
}
/// <summary>
/// Process a payment
/// </summary>
/// <param name="processPaymentRequest">Payment info required for an order processing</param>
/// <returns>Process payment result</returns>
public ProcessPaymentResult ProcessPayment(ProcessPaymentRequest processPaymentRequest)
{
var result = new ProcessPaymentResult();
var customer = _customerService.GetCustomerById(processPaymentRequest.CustomerId);
var webClient = new WebClient();
var form = new NameValueCollection();
form.Add("x_login", _authorizeNetPaymentSettings.LoginId);
form.Add("x_tran_key", _authorizeNetPaymentSettings.TransactionKey);
//we should not send "x_test_request" parameter. otherwise, the transaction won't be logged in the sandbox
//if (_authorizeNetPaymentSettings.UseSandbox)
// form.Add("x_test_request", "TRUE");
//else
// form.Add("x_test_request", "FALSE");
form.Add("x_delim_data", "TRUE");
form.Add("x_delim_char", "|");
form.Add("x_encap_char", "");
form.Add("x_version", GetApiVersion());
form.Add("x_relay_response", "FALSE");
form.Add("x_method", "CC");
form.Add("x_currency_code", _currencyService.GetCurrencyById(_currencySettings.PrimaryStoreCurrencyId).CurrencyCode);
if (_authorizeNetPaymentSettings.TransactMode == TransactMode.Authorize)
form.Add("x_type", "AUTH_ONLY");
else if (_authorizeNetPaymentSettings.TransactMode == TransactMode.AuthorizeAndCapture)
form.Add("x_type", "AUTH_CAPTURE");
else
throw new NopException("Not supported transaction mode");
var orderTotal = Math.Round(processPaymentRequest.OrderTotal, 2);
form.Add("x_amount", orderTotal.ToString("0.00", CultureInfo.InvariantCulture));
form.Add("x_card_num", processPaymentRequest.CreditCardNumber);
form.Add("x_exp_date", processPaymentRequest.CreditCardExpireMonth.ToString("D2") + processPaymentRequest.CreditCardExpireYear.ToString());
form.Add("x_card_code", processPaymentRequest.CreditCardCvv2);
form.Add("x_first_name", customer.BillingAddress.FirstName);
form.Add("x_last_name", customer.BillingAddress.LastName);
form.Add("x_email", customer.BillingAddress.Email);
if (!string.IsNullOrEmpty(customer.BillingAddress.Company))
form.Add("x_company", customer.BillingAddress.Company);
form.Add("x_address", customer.BillingAddress.Address1);
form.Add("x_city", customer.BillingAddress.City);
if (customer.BillingAddress.StateProvince != null)
form.Add("x_state", customer.BillingAddress.StateProvince.Abbreviation);
form.Add("x_zip", customer.BillingAddress.ZipPostalCode);
if (customer.BillingAddress.Country != null)
form.Add("x_country", customer.BillingAddress.Country.TwoLetterIsoCode);
//x_invoice_num is 20 chars maximum. hece we also pass x_description
form.Add("x_invoice_num", processPaymentRequest.OrderGuid.ToString().Substring(0, 20));
form.Add("x_description", string.Format("Full order #{0}", processPaymentRequest.OrderGuid));
form.Add("x_customer_ip", _webHelper.GetCurrentIpAddress());
var responseData = webClient.UploadValues(GetAuthorizeNetUrl(), form);
var reply = Encoding.ASCII.GetString(responseData);
if (!String.IsNullOrEmpty(reply))
{
string[] responseFields = reply.Split('|');
switch (responseFields[0])
{
case "1":
result.AuthorizationTransactionCode = string.Format("{0},{1}", responseFields[6], responseFields[4]);
result.AuthorizationTransactionResult = string.Format("Approved ({0}: {1})", responseFields[2], responseFields[3]);
result.AvsResult = responseFields[5];
//responseFields[38];
if (_authorizeNetPaymentSettings.TransactMode == TransactMode.Authorize)
{
result.NewPaymentStatus = PaymentStatus.Authorized;
}
else
{
result.NewPaymentStatus = PaymentStatus.Paid;
}
break;
case "2":
result.AddError(string.Format("Declined ({0}: {1})", responseFields[2], responseFields[3]));
break;
case "3":
result.AddError(string.Format("Error: {0}", reply));
break;
}
}
else
{
result.AddError("Authorize.NET unknown error");
}
return result;
}
/// <summary>
/// Save order and add order notes
/// </summary>
/// <param name="processPaymentRequest">Process payment request</param>
/// <param name="processPaymentResult">Process payment result</param>
/// <param name="details">Details</param>
/// <returns>Order</returns>
protected virtual Order SaveOrderDetails(ProcessPaymentRequest processPaymentRequest,
ProcessPaymentResult processPaymentResult, PlaceOrderContainter details)
{
var order = new Order
{
StoreId = processPaymentRequest.StoreId,
OrderGuid = processPaymentRequest.OrderGuid,
CustomerId = details.Customer.Id,
CustomerLanguageId = details.CustomerLanguage.Id,
CustomerTaxDisplayType = details.CustomerTaxDisplayType,
CustomerIp = _webHelper.GetCurrentIpAddress(),
OrderSubtotalInclTax = details.OrderSubTotalInclTax,
OrderSubtotalExclTax = details.OrderSubTotalExclTax,
OrderSubTotalDiscountInclTax = details.OrderSubTotalDiscountInclTax,
OrderSubTotalDiscountExclTax = details.OrderSubTotalDiscountExclTax,
OrderShippingInclTax = details.OrderShippingTotalInclTax,
OrderShippingExclTax = details.OrderShippingTotalExclTax,
PaymentMethodAdditionalFeeInclTax = details.PaymentAdditionalFeeInclTax,
PaymentMethodAdditionalFeeExclTax = details.PaymentAdditionalFeeExclTax,
TaxRates = details.TaxRates,
OrderTax = details.OrderTaxTotal,
OrderTotal = details.OrderTotal,
RefundedAmount = decimal.Zero,
OrderDiscount = details.OrderDiscountAmount,
CheckoutAttributeDescription = details.CheckoutAttributeDescription,
CheckoutAttributesXml = details.CheckoutAttributesXml,
CustomerCurrencyCode = details.CustomerCurrencyCode,
CurrencyRate = details.CustomerCurrencyRate,
AffiliateId = details.AffiliateId,
OrderStatus = OrderStatus.Pending,
AllowStoringCreditCardNumber = processPaymentResult.AllowStoringCreditCardNumber,
CardType = processPaymentResult.AllowStoringCreditCardNumber ? _encryptionService.EncryptText(processPaymentRequest.CreditCardType) : string.Empty,
CardName = processPaymentResult.AllowStoringCreditCardNumber ? _encryptionService.EncryptText(processPaymentRequest.CreditCardName) : string.Empty,
CardNumber = processPaymentResult.AllowStoringCreditCardNumber ? _encryptionService.EncryptText(processPaymentRequest.CreditCardNumber) : string.Empty,
MaskedCreditCardNumber = _encryptionService.EncryptText(_paymentService.GetMaskedCreditCardNumber(processPaymentRequest.CreditCardNumber)),
CardCvv2 = processPaymentResult.AllowStoringCreditCardNumber ? _encryptionService.EncryptText(processPaymentRequest.CreditCardCvv2) : string.Empty,
CardExpirationMonth = processPaymentResult.AllowStoringCreditCardNumber ? _encryptionService.EncryptText(processPaymentRequest.CreditCardExpireMonth.ToString()) : string.Empty,
CardExpirationYear = processPaymentResult.AllowStoringCreditCardNumber ? _encryptionService.EncryptText(processPaymentRequest.CreditCardExpireYear.ToString()) : string.Empty,
PaymentMethodSystemName = processPaymentRequest.PaymentMethodSystemName,
AuthorizationTransactionId = processPaymentResult.AuthorizationTransactionId,
AuthorizationTransactionCode = processPaymentResult.AuthorizationTransactionCode,
AuthorizationTransactionResult = processPaymentResult.AuthorizationTransactionResult,
CaptureTransactionId = processPaymentResult.CaptureTransactionId,
CaptureTransactionResult = processPaymentResult.CaptureTransactionResult,
SubscriptionTransactionId = processPaymentResult.SubscriptionTransactionId,
PaymentStatus = processPaymentResult.NewPaymentStatus,
PaidDateUtc = null,
BillingAddress = details.BillingAddress,
ShippingAddress = details.ShippingAddress,
ShippingStatus = details.ShippingStatus,
ShippingMethod = details.ShippingMethodName,
PickUpInStore = details.PickUpInStore,
PickupAddress = details.PickupAddress,
ShippingRateComputationMethodSystemName = details.ShippingRateComputationMethodSystemName,
CustomValuesXml = processPaymentRequest.SerializeCustomValues(),
VatNumber = details.VatNumber,
CreatedOnUtc = DateTime.UtcNow
};
_orderService.InsertOrder(order);
//reward points history
if (details.RedeemedRewardPointsAmount > decimal.Zero)
{
_rewardPointService.AddRewardPointsHistoryEntry(details.Customer, -details.RedeemedRewardPoints, order.StoreId,
string.Format(_localizationService.GetResource("RewardPoints.Message.RedeemedForOrder", order.CustomerLanguageId), order.Id),
order, details.RedeemedRewardPointsAmount);
_customerService.UpdateCustomer(details.Customer);
}
return order;
}
/// <summary>
/// Process a payment
/// </summary>
/// <param name="processPaymentRequest">Payment info required for an order processing</param>
/// <returns>Process payment result</returns>
public virtual ProcessPaymentResult ProcessPayment(ProcessPaymentRequest processPaymentRequest)
{
if (processPaymentRequest.OrderTotal == decimal.Zero)
{
var result = new ProcessPaymentResult()
{
NewPaymentStatus = PaymentStatus.Paid
};
return result;
}
else
{
//We should strip out any white space or dash in the CC number entered.
if (!String.IsNullOrWhiteSpace(processPaymentRequest.CreditCardNumber))
{
processPaymentRequest.CreditCardNumber = processPaymentRequest.CreditCardNumber.Replace(" ", "");
processPaymentRequest.CreditCardNumber = processPaymentRequest.CreditCardNumber.Replace("-", "");
}
var paymentMethod = LoadPaymentMethodBySystemName(processPaymentRequest.PaymentMethodSystemName);
if (paymentMethod == null)
throw new NopException("Payment method couldn't be loaded");
return paymentMethod.ProcessPayment(processPaymentRequest);
}
}
public ActionResult IPNHandler()
{
byte[] param = Request.BinaryRead(Request.ContentLength);
string strRequest = Encoding.ASCII.GetString(param);
Dictionary<string, string> values;
var processor = _paymentService.LoadPaymentMethodBySystemName("Payments.PayPalDirect") as PayPalDirectPaymentProcessor;
if (processor == null ||
!processor.IsPaymentMethodActive(_paymentSettings) || !processor.PluginDescriptor.Installed)
throw new NopException("PayPal Direct module cannot be loaded");
if (processor.VerifyIpn(strRequest, out values))
{
#region values
decimal mc_gross = decimal.Zero;
try
{
mc_gross = decimal.Parse(values["mc_gross"], new CultureInfo("en-US"));
}
catch { }
string payer_status = string.Empty;
values.TryGetValue("payer_status", out payer_status);
string payment_status = string.Empty;
values.TryGetValue("payment_status", out payment_status);
string pending_reason = string.Empty;
values.TryGetValue("pending_reason", out pending_reason);
string mc_currency = string.Empty;
values.TryGetValue("mc_currency", out mc_currency);
string txn_id = string.Empty;
values.TryGetValue("txn_id", out txn_id);
string txn_type = string.Empty;
values.TryGetValue("txn_type", out txn_type);
string rp_invoice_id = string.Empty;
values.TryGetValue("rp_invoice_id", out rp_invoice_id);
string payment_type = string.Empty;
values.TryGetValue("payment_type", out payment_type);
string payer_id = string.Empty;
values.TryGetValue("payer_id", out payer_id);
string receiver_id = string.Empty;
values.TryGetValue("receiver_id", out receiver_id);
string invoice = string.Empty;
values.TryGetValue("invoice", out invoice);
string payment_fee = string.Empty;
values.TryGetValue("payment_fee", out payment_fee);
#endregion
var sb = new StringBuilder();
sb.AppendLine("Paypal IPN:");
foreach (KeyValuePair<string, string> kvp in values)
{
sb.AppendLine(kvp.Key + ": " + kvp.Value);
}
var newPaymentStatus = PaypalHelper.GetPaymentStatus(payment_status, pending_reason);
sb.AppendLine("New payment status: " + newPaymentStatus);
switch (txn_type)
{
case "recurring_payment_profile_created":
//do nothing here
break;
case "recurring_payment":
#region Recurring payment
{
Guid orderNumberGuid = Guid.Empty;
try
{
orderNumberGuid = new Guid(rp_invoice_id);
}
catch
{
}
var initialOrder = _orderService.GetOrderByGuid(orderNumberGuid);
if (initialOrder != null)
{
var recurringPayments = _orderService.SearchRecurringPayments(0, 0, initialOrder.Id, null, 0 , int.MaxValue);
foreach (var rp in recurringPayments)
{
switch (newPaymentStatus)
{
case PaymentStatus.Authorized:
case PaymentStatus.Paid:
{
var recurringPaymentHistory = rp.RecurringPaymentHistory;
if (!recurringPaymentHistory.Any())
{
//first payment
var rph = new RecurringPaymentHistory
{
RecurringPaymentId = rp.Id,
OrderId = initialOrder.Id,
CreatedOnUtc = DateTime.UtcNow
};
rp.RecurringPaymentHistory.Add(rph);
_orderService.UpdateRecurringPayment(rp);
}
else
{
//next payments
var processPaymentResult = new ProcessPaymentResult();
processPaymentResult.NewPaymentStatus = newPaymentStatus;
if (newPaymentStatus == PaymentStatus.Authorized)
processPaymentResult.AuthorizationTransactionId = txn_id;
else
processPaymentResult.CaptureTransactionId = txn_id;
_orderProcessingService.ProcessNextRecurringPayment(rp, processPaymentResult);
}
}
break;
}
}
//this.OrderService.InsertOrderNote(newOrder.OrderId, sb.ToString(), DateTime.UtcNow);
_logger.Information("PayPal IPN. Recurring info", new NopException(sb.ToString()));
}
else
{
_logger.Error("PayPal IPN. Order is not found", new NopException(sb.ToString()));
}
}
#endregion
break;
default:
#region Standard payment
{
string orderNumber = string.Empty;
values.TryGetValue("custom", out orderNumber);
Guid orderNumberGuid = Guid.Empty;
try
{
orderNumberGuid = new Guid(orderNumber);
}
catch
{
}
var order = _orderService.GetOrderByGuid(orderNumberGuid);
if (order != null)
{
//order note
order.OrderNotes.Add(new OrderNote
{
Note = sb.ToString(),
DisplayToCustomer = false,
CreatedOnUtc = DateTime.UtcNow
});
_orderService.UpdateOrder(order);
switch (newPaymentStatus)
{
case PaymentStatus.Pending:
{
}
break;
case PaymentStatus.Authorized:
{
//validate order total
if (Math.Round(mc_gross, 2).Equals(Math.Round(order.OrderTotal, 2)))
{
//valid
if (_orderProcessingService.CanMarkOrderAsAuthorized(order))
{
_orderProcessingService.MarkAsAuthorized(order);
}
}
else
{
//not valid
string errorStr = string.Format("PayPal IPN. Returned order total {0} doesn't equal order total {1}. Order# {2}.", mc_gross, order.OrderTotal, order.Id);
//log
_logger.Error(errorStr);
//order note
order.OrderNotes.Add(new OrderNote
{
Note = errorStr,
DisplayToCustomer = false,
CreatedOnUtc = DateTime.UtcNow
});
_orderService.UpdateOrder(order);
}
}
break;
case PaymentStatus.Paid:
{
//validate order total
if (Math.Round(mc_gross, 2).Equals(Math.Round(order.OrderTotal, 2)))
{
//valid
if (_orderProcessingService.CanMarkOrderAsPaid(order))
{
order.AuthorizationTransactionId = txn_id;
_orderService.UpdateOrder(order);
_orderProcessingService.MarkOrderAsPaid(order);
}
}
else
{
//not valid
string errorStr = string.Format("PayPal IPN. Returned order total {0} doesn't equal order total {1}. Order# {2}.", mc_gross, order.OrderTotal, order.Id);
//log
_logger.Error(errorStr);
//order note
order.OrderNotes.Add(new OrderNote
{
Note = errorStr,
DisplayToCustomer = false,
CreatedOnUtc = DateTime.UtcNow
});
_orderService.UpdateOrder(order);
}
}
break;
case PaymentStatus.Refunded:
{
//compare last refund transaction id with IPN transaction id
if (order.GetAttribute<string>("RefundTransactionId") != txn_id)
{
//refund was initiated not in the nopCommerce
var totalToRefund = Math.Abs(mc_gross);
if (totalToRefund > 0 && Math.Round(totalToRefund, 2).Equals(Math.Round(order.OrderTotal, 2)))
{
//refund
if (_orderProcessingService.CanRefundOffline(order))
_orderProcessingService.RefundOffline(order);
}
else
{
//partial refund
if (_orderProcessingService.CanPartiallyRefundOffline(order, totalToRefund))
_orderProcessingService.PartiallyRefundOffline(order, totalToRefund);
}
}
}
break;
case PaymentStatus.Voided:
{
if (_orderProcessingService.CanVoidOffline(order))
{
_orderProcessingService.VoidOffline(order);
}
}
break;
default:
break;
}
}
else
{
_logger.Error("PayPal IPN. Order is not found", new NopException(sb.ToString()));
}
}
#endregion
break;
}
}
else
{
_logger.Error("PayPal IPN failed.", new NopException(strRequest));
}
//nothing should be rendered to visitor
return Content("");
}
/// <summary>
/// Places an order
/// </summary>
/// <param name="processPaymentRequest">Process payment request</param>
/// <returns>Place order result</returns>
public virtual PlaceOrderResult PlaceOrder(ProcessPaymentRequest processPaymentRequest)
{
//think about moving functionality of processing recurring orders (after the initial order was placed) to ProcessNextRecurringPayment() method
if (processPaymentRequest == null)
throw new ArgumentNullException("processPaymentRequest");
if (processPaymentRequest.OrderGuid == Guid.Empty)
processPaymentRequest.OrderGuid = Guid.NewGuid();
var result = new PlaceOrderResult();
try
{
#region Order details (customer, addresses, totals)
//Recurring orders. Load initial order
Order initialOrder = _orderService.GetOrderById(processPaymentRequest.InitialOrderId);
if (processPaymentRequest.IsRecurringPayment)
{
if (initialOrder == null)
throw new ArgumentException("Initial order is not set for recurring payment");
processPaymentRequest.PaymentMethodSystemName = initialOrder.PaymentMethodSystemName;
}
//customer
var customer = _customerService.GetCustomerById(processPaymentRequest.CustomerId);
if (customer == null)
throw new ArgumentException("Customer is not set");
//affilites
int affiliateId = 0;
var affiliate = _affiliateService.GetAffiliateById(customer.AffiliateId);
if (affiliate != null && affiliate.Active && !affiliate.Deleted)
affiliateId = affiliate.Id;
//customer currency
string customerCurrencyCode = "";
decimal customerCurrencyRate;
if (!processPaymentRequest.IsRecurringPayment)
{
var currencyTmp = _currencyService.GetCurrencyById(customer.GetAttribute<int>(SystemCustomerAttributeNames.CurrencyId, processPaymentRequest.StoreId));
var customerCurrency = (currencyTmp != null && currencyTmp.Published) ? currencyTmp : _workContext.WorkingCurrency;
customerCurrencyCode = customerCurrency.CurrencyCode;
var primaryStoreCurrency = _currencyService.GetCurrencyById(_currencySettings.PrimaryStoreCurrencyId);
customerCurrencyRate = customerCurrency.Rate / primaryStoreCurrency.Rate;
}
else
{
customerCurrencyCode = initialOrder.CustomerCurrencyCode;
customerCurrencyRate = initialOrder.CurrencyRate;
}
//customer language
Language customerLanguage;
if (!processPaymentRequest.IsRecurringPayment)
{
customerLanguage = _languageService.GetLanguageById(customer.GetAttribute<int>(
SystemCustomerAttributeNames.LanguageId, processPaymentRequest.StoreId));
}
else
{
customerLanguage = _languageService.GetLanguageById(initialOrder.CustomerLanguageId);
}
if (customerLanguage == null || !customerLanguage.Published)
customerLanguage = _workContext.WorkingLanguage;
//check whether customer is guest
if (customer.IsGuest() && !_orderSettings.AnonymousCheckoutAllowed)
throw new NopException("Anonymous checkout is not allowed");
//billing address
Address billingAddress;
if (!processPaymentRequest.IsRecurringPayment)
{
if (customer.BillingAddress == null)
throw new NopException("Billing address is not provided");
if (!CommonHelper.IsValidEmail(customer.BillingAddress.Email))
throw new NopException("Email is not valid");
//clone billing address
billingAddress = (Address)customer.BillingAddress.Clone();
if (billingAddress.Country != null && !billingAddress.Country.AllowsBilling)
throw new NopException(string.Format("Country '{0}' is not allowed for billing", billingAddress.Country.Name));
}
else
{
if (initialOrder.BillingAddress == null)
throw new NopException("Billing address is not available");
//clone billing address
billingAddress = (Address)initialOrder.BillingAddress.Clone();
if (billingAddress.Country != null && !billingAddress.Country.AllowsBilling)
throw new NopException(string.Format("Country '{0}' is not allowed for billing", billingAddress.Country.Name));
}
//checkout attributes
string checkoutAttributeDescription, checkoutAttributesXml;
if (!processPaymentRequest.IsRecurringPayment)
{
checkoutAttributesXml = customer.GetAttribute<string>(SystemCustomerAttributeNames.CheckoutAttributes, processPaymentRequest.StoreId);
checkoutAttributeDescription = _checkoutAttributeFormatter.FormatAttributes(checkoutAttributesXml, customer);
}
else
{
checkoutAttributesXml = initialOrder.CheckoutAttributesXml;
checkoutAttributeDescription = initialOrder.CheckoutAttributeDescription;
}
//load and validate customer shopping cart
IList<ShoppingCartItem> cart = null;
if (!processPaymentRequest.IsRecurringPayment)
{
//load shopping cart
cart = customer.ShoppingCartItems
.Where(sci => sci.ShoppingCartType == ShoppingCartType.ShoppingCart)
.LimitPerStore(processPaymentRequest.StoreId)
.ToList();
if (cart.Count == 0)
throw new NopException("Cart is empty");
//validate the entire shopping cart
var warnings = _shoppingCartService.GetShoppingCartWarnings(cart,
checkoutAttributesXml,
true);
if (warnings.Count > 0)
{
var warningsSb = new StringBuilder();
foreach (string warning in warnings)
{
warningsSb.Append(warning);
warningsSb.Append(";");
}
throw new NopException(warningsSb.ToString());
}
//validate individual cart items
foreach (var sci in cart)
{
var sciWarnings = _shoppingCartService.GetShoppingCartItemWarnings(customer, sci.ShoppingCartType,
sci.Product, processPaymentRequest.StoreId, sci.AttributesXml,
sci.CustomerEnteredPrice, sci.RentalStartDateUtc, sci.RentalEndDateUtc,
sci.Quantity, false);
if (sciWarnings.Count > 0)
{
var warningsSb = new StringBuilder();
foreach (string warning in sciWarnings)
{
warningsSb.Append(warning);
warningsSb.Append(";");
}
throw new NopException(warningsSb.ToString());
}
}
}
//min totals validation
if (!processPaymentRequest.IsRecurringPayment)
{
bool minOrderSubtotalAmountOk = ValidateMinOrderSubtotalAmount(cart);
if (!minOrderSubtotalAmountOk)
{
decimal minOrderSubtotalAmount = _currencyService.ConvertFromPrimaryStoreCurrency(_orderSettings.MinOrderSubtotalAmount, _workContext.WorkingCurrency);
throw new NopException(string.Format(_localizationService.GetResource("Checkout.MinOrderSubtotalAmount"), _priceFormatter.FormatPrice(minOrderSubtotalAmount, true, false)));
}
bool minOrderTotalAmountOk = ValidateMinOrderTotalAmount(cart);
if (!minOrderTotalAmountOk)
{
decimal minOrderTotalAmount = _currencyService.ConvertFromPrimaryStoreCurrency(_orderSettings.MinOrderTotalAmount, _workContext.WorkingCurrency);
throw new NopException(string.Format(_localizationService.GetResource("Checkout.MinOrderTotalAmount"), _priceFormatter.FormatPrice(minOrderTotalAmount, true, false)));
}
}
//tax display type
var customerTaxDisplayType = TaxDisplayType.IncludingTax;
if (!processPaymentRequest.IsRecurringPayment)
{
if (_taxSettings.AllowCustomersToSelectTaxDisplayType)
customerTaxDisplayType = (TaxDisplayType)customer.GetAttribute<int>(SystemCustomerAttributeNames.TaxDisplayTypeId, processPaymentRequest.StoreId);
else
customerTaxDisplayType = _taxSettings.TaxDisplayType;
}
else
{
customerTaxDisplayType = initialOrder.CustomerTaxDisplayType;
}
//applied discount (used to store discount usage history)
var appliedDiscounts = new List<Discount>();
//sub total
decimal orderSubTotalInclTax, orderSubTotalExclTax;
decimal orderSubTotalDiscountInclTax = 0, orderSubTotalDiscountExclTax = 0;
if (!processPaymentRequest.IsRecurringPayment)
{
//sub total (incl tax)
decimal orderSubTotalDiscountAmount1;
Discount orderSubTotalAppliedDiscount1;
decimal subTotalWithoutDiscountBase1;
decimal subTotalWithDiscountBase1;
_orderTotalCalculationService.GetShoppingCartSubTotal(cart,
true, out orderSubTotalDiscountAmount1, out orderSubTotalAppliedDiscount1,
out subTotalWithoutDiscountBase1, out subTotalWithDiscountBase1);
orderSubTotalInclTax = subTotalWithoutDiscountBase1;
orderSubTotalDiscountInclTax = orderSubTotalDiscountAmount1;
//discount history
if (orderSubTotalAppliedDiscount1 != null && !appliedDiscounts.ContainsDiscount(orderSubTotalAppliedDiscount1))
appliedDiscounts.Add(orderSubTotalAppliedDiscount1);
//sub total (excl tax)
decimal orderSubTotalDiscountAmount2;
Discount orderSubTotalAppliedDiscount2;
decimal subTotalWithoutDiscountBase2;
decimal subTotalWithDiscountBase2;
_orderTotalCalculationService.GetShoppingCartSubTotal(cart,
false, out orderSubTotalDiscountAmount2, out orderSubTotalAppliedDiscount2,
out subTotalWithoutDiscountBase2, out subTotalWithDiscountBase2);
orderSubTotalExclTax = subTotalWithoutDiscountBase2;
orderSubTotalDiscountExclTax = orderSubTotalDiscountAmount2;
}
else
{
orderSubTotalInclTax = initialOrder.OrderSubtotalInclTax;
orderSubTotalExclTax = initialOrder.OrderSubtotalExclTax;
}
//shipping info
bool shoppingCartRequiresShipping = false;
if (!processPaymentRequest.IsRecurringPayment)
{
shoppingCartRequiresShipping = cart.RequiresShipping();
}
else
{
shoppingCartRequiresShipping = initialOrder.ShippingStatus != ShippingStatus.ShippingNotRequired;
}
Address shippingAddress = null;
string shippingMethodName = "", shippingRateComputationMethodSystemName = "";
bool pickUpInStore = false;
if (shoppingCartRequiresShipping)
{
if (!processPaymentRequest.IsRecurringPayment)
{
pickUpInStore = _shippingSettings.AllowPickUpInStore &&
customer.GetAttribute<bool>(SystemCustomerAttributeNames.SelectedPickUpInStore, processPaymentRequest.StoreId);
if (!pickUpInStore)
{
if (customer.ShippingAddress == null)
throw new NopException("Shipping address is not provided");
if (!CommonHelper.IsValidEmail(customer.ShippingAddress.Email))
throw new NopException("Email is not valid");
//clone shipping address
shippingAddress = (Address) customer.ShippingAddress.Clone();
if (shippingAddress.Country != null && !shippingAddress.Country.AllowsShipping)
{
throw new NopException(string.Format("Country '{0}' is not allowed for shipping", shippingAddress.Country.Name));
}
}
var shippingOption = customer.GetAttribute<ShippingOption>(SystemCustomerAttributeNames.SelectedShippingOption, processPaymentRequest.StoreId);
if (shippingOption != null)
{
shippingMethodName = shippingOption.Name;
shippingRateComputationMethodSystemName = shippingOption.ShippingRateComputationMethodSystemName;
}
}
else
{
pickUpInStore = initialOrder.PickUpInStore;
if (!pickUpInStore)
{
if (initialOrder.ShippingAddress == null)
throw new NopException("Shipping address is not available");
//clone shipping address
shippingAddress = (Address) initialOrder.ShippingAddress.Clone();
if (shippingAddress.Country != null && !shippingAddress.Country.AllowsShipping)
{
throw new NopException(string.Format("Country '{0}' is not allowed for shipping", shippingAddress.Country.Name));
}
}
shippingMethodName = initialOrder.ShippingMethod;
shippingRateComputationMethodSystemName = initialOrder.ShippingRateComputationMethodSystemName;
}
}
//shipping total
decimal? orderShippingTotalInclTax, orderShippingTotalExclTax = null;
if (!processPaymentRequest.IsRecurringPayment)
{
decimal taxRate;
Discount shippingTotalDiscount;
orderShippingTotalInclTax = _orderTotalCalculationService.GetShoppingCartShippingTotal(cart, true, out taxRate, out shippingTotalDiscount);
orderShippingTotalExclTax = _orderTotalCalculationService.GetShoppingCartShippingTotal(cart, false);
if (!orderShippingTotalInclTax.HasValue || !orderShippingTotalExclTax.HasValue)
throw new NopException("Shipping total couldn't be calculated");
if (shippingTotalDiscount != null && !appliedDiscounts.ContainsDiscount(shippingTotalDiscount))
appliedDiscounts.Add(shippingTotalDiscount);
}
else
{
orderShippingTotalInclTax = initialOrder.OrderShippingInclTax;
orderShippingTotalExclTax = initialOrder.OrderShippingExclTax;
}
//payment total
decimal paymentAdditionalFeeInclTax, paymentAdditionalFeeExclTax;
if (!processPaymentRequest.IsRecurringPayment)
{
decimal paymentAdditionalFee = _paymentService.GetAdditionalHandlingFee(cart, processPaymentRequest.PaymentMethodSystemName);
paymentAdditionalFeeInclTax = _taxService.GetPaymentMethodAdditionalFee(paymentAdditionalFee, true, customer);
paymentAdditionalFeeExclTax = _taxService.GetPaymentMethodAdditionalFee(paymentAdditionalFee, false, customer);
}
else
{
paymentAdditionalFeeInclTax = initialOrder.PaymentMethodAdditionalFeeInclTax;
paymentAdditionalFeeExclTax = initialOrder.PaymentMethodAdditionalFeeExclTax;
}
//tax total
decimal orderTaxTotal = decimal.Zero;
string vatNumber = "", taxRates = "";
if (!processPaymentRequest.IsRecurringPayment)
{
//tax amount
SortedDictionary<decimal, decimal> taxRatesDictionary;
orderTaxTotal = _orderTotalCalculationService.GetTaxTotal(cart, out taxRatesDictionary);
//VAT number
var customerVatStatus = (VatNumberStatus)customer.GetAttribute<int>(SystemCustomerAttributeNames.VatNumberStatusId);
if (_taxSettings.EuVatEnabled && customerVatStatus == VatNumberStatus.Valid)
vatNumber = customer.GetAttribute<string>(SystemCustomerAttributeNames.VatNumber);
//tax rates
foreach (var kvp in taxRatesDictionary)
{
var taxRate = kvp.Key;
var taxValue = kvp.Value;
taxRates += string.Format("{0}:{1}; ", taxRate.ToString(CultureInfo.InvariantCulture), taxValue.ToString(CultureInfo.InvariantCulture));
}
}
else
{
orderTaxTotal = initialOrder.OrderTax;
//VAT number
vatNumber = initialOrder.VatNumber;
}
//order total (and applied discounts, gift cards, reward points)
decimal? orderTotal = null;
decimal orderDiscountAmount = decimal.Zero;
List<AppliedGiftCard> appliedGiftCards = null;
int redeemedRewardPoints = 0;
decimal redeemedRewardPointsAmount = decimal.Zero;
if (!processPaymentRequest.IsRecurringPayment)
{
Discount orderAppliedDiscount;
orderTotal = _orderTotalCalculationService.GetShoppingCartTotal(cart,
out orderDiscountAmount, out orderAppliedDiscount, out appliedGiftCards,
out redeemedRewardPoints, out redeemedRewardPointsAmount);
if (!orderTotal.HasValue)
throw new NopException("Order total couldn't be calculated");
//discount history
if (orderAppliedDiscount != null && !appliedDiscounts.ContainsDiscount(orderAppliedDiscount))
appliedDiscounts.Add(orderAppliedDiscount);
}
else
{
orderDiscountAmount = initialOrder.OrderDiscount;
orderTotal = initialOrder.OrderTotal;
}
processPaymentRequest.OrderTotal = orderTotal.Value;
#endregion
#region Payment workflow
//skip payment workflow if order total equals zero
bool skipPaymentWorkflow = orderTotal.Value == decimal.Zero;
//payment workflow
if (!skipPaymentWorkflow)
{
var paymentMethod = _paymentService.LoadPaymentMethodBySystemName(processPaymentRequest.PaymentMethodSystemName);
if (paymentMethod == null)
throw new NopException("Payment method couldn't be loaded");
//ensure that payment method is active
if (!paymentMethod.IsPaymentMethodActive(_paymentSettings))
throw new NopException("Payment method is not active");
}
else
processPaymentRequest.PaymentMethodSystemName = "";
//recurring or standard shopping cart?
bool isRecurringShoppingCart = false;
if (!processPaymentRequest.IsRecurringPayment)
{
isRecurringShoppingCart = cart.IsRecurring();
if (isRecurringShoppingCart)
{
int recurringCycleLength;
RecurringProductCyclePeriod recurringCyclePeriod;
int recurringTotalCycles;
string recurringCyclesError = cart.GetRecurringCycleInfo(_localizationService,
out recurringCycleLength, out recurringCyclePeriod, out recurringTotalCycles);
if (!string.IsNullOrEmpty(recurringCyclesError))
throw new NopException(recurringCyclesError);
processPaymentRequest.RecurringCycleLength = recurringCycleLength;
processPaymentRequest.RecurringCyclePeriod = recurringCyclePeriod;
processPaymentRequest.RecurringTotalCycles = recurringTotalCycles;
}
}
else
isRecurringShoppingCart = true;
//process payment
ProcessPaymentResult processPaymentResult = null;
if (!skipPaymentWorkflow)
{
if (!processPaymentRequest.IsRecurringPayment)
{
if (isRecurringShoppingCart)
{
//recurring cart
var recurringPaymentType = _paymentService.GetRecurringPaymentType(processPaymentRequest.PaymentMethodSystemName);
switch (recurringPaymentType)
{
case RecurringPaymentType.NotSupported:
throw new NopException("Recurring payments are not supported by selected payment method");
case RecurringPaymentType.Manual:
case RecurringPaymentType.Automatic:
processPaymentResult = _paymentService.ProcessRecurringPayment(processPaymentRequest);
break;
default:
throw new NopException("Not supported recurring payment type");
}
}
else
{
//standard cart
processPaymentResult = _paymentService.ProcessPayment(processPaymentRequest);
}
}
else
{
if (isRecurringShoppingCart)
{
//Old credit card info
processPaymentRequest.CreditCardType = initialOrder.AllowStoringCreditCardNumber ? _encryptionService.DecryptText(initialOrder.CardType) : "";
processPaymentRequest.CreditCardName = initialOrder.AllowStoringCreditCardNumber ? _encryptionService.DecryptText(initialOrder.CardName) : "";
processPaymentRequest.CreditCardNumber = initialOrder.AllowStoringCreditCardNumber ? _encryptionService.DecryptText(initialOrder.CardNumber) : "";
//MaskedCreditCardNumber
processPaymentRequest.CreditCardCvv2 = initialOrder.AllowStoringCreditCardNumber ? _encryptionService.DecryptText(initialOrder.CardCvv2) : "";
try
{
processPaymentRequest.CreditCardExpireMonth = initialOrder.AllowStoringCreditCardNumber ? Convert.ToInt32(_encryptionService.DecryptText(initialOrder.CardExpirationMonth)) : 0;
processPaymentRequest.CreditCardExpireYear = initialOrder.AllowStoringCreditCardNumber ? Convert.ToInt32(_encryptionService.DecryptText(initialOrder.CardExpirationYear)) : 0;
}
catch {}
var recurringPaymentType = _paymentService.GetRecurringPaymentType(processPaymentRequest.PaymentMethodSystemName);
switch (recurringPaymentType)
{
case RecurringPaymentType.NotSupported:
throw new NopException("Recurring payments are not supported by selected payment method");
case RecurringPaymentType.Manual:
processPaymentResult = _paymentService.ProcessRecurringPayment(processPaymentRequest);
break;
case RecurringPaymentType.Automatic:
//payment is processed on payment gateway site
processPaymentResult = new ProcessPaymentResult();
break;
default:
throw new NopException("Not supported recurring payment type");
}
}
else
{
throw new NopException("No recurring products");
}
}
}
else
{
//payment is not required
if (processPaymentResult == null)
processPaymentResult = new ProcessPaymentResult();
processPaymentResult.NewPaymentStatus = PaymentStatus.Paid;
}
if (processPaymentResult == null)
throw new NopException("processPaymentResult is not available");
#endregion
if (processPaymentResult.Success)
{
//save order in data storage
//uncomment this line to support transactions
//using (var scope = new System.Transactions.TransactionScope())
{
#region Save order details
var shippingStatus = ShippingStatus.NotYetShipped;
if (!shoppingCartRequiresShipping)
shippingStatus = ShippingStatus.ShippingNotRequired;
var order = new Order
{
StoreId = processPaymentRequest.StoreId,
OrderGuid = processPaymentRequest.OrderGuid,
CustomerId = customer.Id,
CustomerLanguageId = customerLanguage.Id,
CustomerTaxDisplayType = customerTaxDisplayType,
CustomerIp = _webHelper.GetCurrentIpAddress(),
OrderSubtotalInclTax = orderSubTotalInclTax,
OrderSubtotalExclTax = orderSubTotalExclTax,
OrderSubTotalDiscountInclTax = orderSubTotalDiscountInclTax,
OrderSubTotalDiscountExclTax = orderSubTotalDiscountExclTax,
OrderShippingInclTax = orderShippingTotalInclTax.Value,
OrderShippingExclTax = orderShippingTotalExclTax.Value,
PaymentMethodAdditionalFeeInclTax = paymentAdditionalFeeInclTax,
PaymentMethodAdditionalFeeExclTax = paymentAdditionalFeeExclTax,
TaxRates = taxRates,
OrderTax = orderTaxTotal,
OrderTotal = orderTotal.Value,
RefundedAmount = decimal.Zero,
OrderDiscount = orderDiscountAmount,
CheckoutAttributeDescription = checkoutAttributeDescription,
CheckoutAttributesXml = checkoutAttributesXml,
CustomerCurrencyCode = customerCurrencyCode,
CurrencyRate = customerCurrencyRate,
AffiliateId = affiliateId,
OrderStatus = OrderStatus.Pending,
AllowStoringCreditCardNumber = processPaymentResult.AllowStoringCreditCardNumber,
CardType = processPaymentResult.AllowStoringCreditCardNumber ? _encryptionService.EncryptText(processPaymentRequest.CreditCardType) : string.Empty,
CardName = processPaymentResult.AllowStoringCreditCardNumber ? _encryptionService.EncryptText(processPaymentRequest.CreditCardName) : string.Empty,
CardNumber = processPaymentResult.AllowStoringCreditCardNumber ? _encryptionService.EncryptText(processPaymentRequest.CreditCardNumber) : string.Empty,
MaskedCreditCardNumber = _encryptionService.EncryptText(_paymentService.GetMaskedCreditCardNumber(processPaymentRequest.CreditCardNumber)),
CardCvv2 = processPaymentResult.AllowStoringCreditCardNumber ? _encryptionService.EncryptText(processPaymentRequest.CreditCardCvv2) : string.Empty,
CardExpirationMonth = processPaymentResult.AllowStoringCreditCardNumber ? _encryptionService.EncryptText(processPaymentRequest.CreditCardExpireMonth.ToString()) : string.Empty,
CardExpirationYear = processPaymentResult.AllowStoringCreditCardNumber ? _encryptionService.EncryptText(processPaymentRequest.CreditCardExpireYear.ToString()) : string.Empty,
PaymentMethodSystemName = processPaymentRequest.PaymentMethodSystemName,
AuthorizationTransactionId = processPaymentResult.AuthorizationTransactionId,
AuthorizationTransactionCode = processPaymentResult.AuthorizationTransactionCode,
AuthorizationTransactionResult = processPaymentResult.AuthorizationTransactionResult,
CaptureTransactionId = processPaymentResult.CaptureTransactionId,
CaptureTransactionResult = processPaymentResult.CaptureTransactionResult,
SubscriptionTransactionId = processPaymentResult.SubscriptionTransactionId,
PaymentStatus = processPaymentResult.NewPaymentStatus,
PaidDateUtc = null,
BillingAddress = billingAddress,
ShippingAddress = shippingAddress,
ShippingStatus = shippingStatus,
ShippingMethod = shippingMethodName,
PickUpInStore = pickUpInStore,
ShippingRateComputationMethodSystemName = shippingRateComputationMethodSystemName,
CustomValuesXml = processPaymentRequest.SerializeCustomValues(),
VatNumber = vatNumber,
CreatedOnUtc = DateTime.UtcNow
};
_orderService.InsertOrder(order);
result.PlacedOrder = order;
if (!processPaymentRequest.IsRecurringPayment)
{
//move shopping cart items to order items
foreach (var sc in cart)
{
//prices
decimal taxRate;
Discount scDiscount;
decimal discountAmount;
decimal scUnitPrice = _priceCalculationService.GetUnitPrice(sc);
decimal scSubTotal = _priceCalculationService.GetSubTotal(sc, true, out discountAmount, out scDiscount);
decimal scUnitPriceInclTax = _taxService.GetProductPrice(sc.Product, scUnitPrice, true, customer, out taxRate);
decimal scUnitPriceExclTax = _taxService.GetProductPrice(sc.Product, scUnitPrice, false, customer, out taxRate);
decimal scSubTotalInclTax = _taxService.GetProductPrice(sc.Product, scSubTotal, true, customer, out taxRate);
decimal scSubTotalExclTax = _taxService.GetProductPrice(sc.Product, scSubTotal, false, customer, out taxRate);
decimal discountAmountInclTax = _taxService.GetProductPrice(sc.Product, discountAmount, true, customer, out taxRate);
decimal discountAmountExclTax = _taxService.GetProductPrice(sc.Product, discountAmount, false, customer, out taxRate);
if (scDiscount != null && !appliedDiscounts.ContainsDiscount(scDiscount))
appliedDiscounts.Add(scDiscount);
//attributes
string attributeDescription = _productAttributeFormatter.FormatAttributes(sc.Product, sc.AttributesXml, customer);
var itemWeight = _shippingService.GetShoppingCartItemWeight(sc);
//save order item
var orderItem = new OrderItem
{
OrderItemGuid = Guid.NewGuid(),
Order = order,
ProductId = sc.ProductId,
UnitPriceInclTax = scUnitPriceInclTax,
UnitPriceExclTax = scUnitPriceExclTax,
PriceInclTax = scSubTotalInclTax,
PriceExclTax = scSubTotalExclTax,
OriginalProductCost = _priceCalculationService.GetProductCost(sc.Product, sc.AttributesXml),
AttributeDescription = attributeDescription,
AttributesXml = sc.AttributesXml,
Quantity = sc.Quantity,
DiscountAmountInclTax = discountAmountInclTax,
DiscountAmountExclTax = discountAmountExclTax,
DownloadCount = 0,
IsDownloadActivated = false,
LicenseDownloadId = 0,
ItemWeight = itemWeight,
RentalStartDateUtc = sc.RentalStartDateUtc,
RentalEndDateUtc = sc.RentalEndDateUtc
};
order.OrderItems.Add(orderItem);
_orderService.UpdateOrder(order);
//gift cards
if (sc.Product.IsGiftCard)
{
string giftCardRecipientName, giftCardRecipientEmail,
giftCardSenderName, giftCardSenderEmail, giftCardMessage;
_productAttributeParser.GetGiftCardAttribute(sc.AttributesXml,
out giftCardRecipientName, out giftCardRecipientEmail,
out giftCardSenderName, out giftCardSenderEmail, out giftCardMessage);
for (int i = 0; i < sc.Quantity; i++)
{
var gc = new GiftCard
{
GiftCardType = sc.Product.GiftCardType,
PurchasedWithOrderItem = orderItem,
Amount = scUnitPriceExclTax,
IsGiftCardActivated = false,
GiftCardCouponCode = _giftCardService.GenerateGiftCardCode(),
RecipientName = giftCardRecipientName,
RecipientEmail = giftCardRecipientEmail,
SenderName = giftCardSenderName,
SenderEmail = giftCardSenderEmail,
Message = giftCardMessage,
IsRecipientNotified = false,
CreatedOnUtc = DateTime.UtcNow
};
_giftCardService.InsertGiftCard(gc);
}
}
//inventory
_productService.AdjustInventory(sc.Product, -sc.Quantity, sc.AttributesXml);
}
//clear shopping cart
cart.ToList().ForEach(sci => _shoppingCartService.DeleteShoppingCartItem(sci, false));
}
else
{
//recurring payment
var initialOrderItems = initialOrder.OrderItems;
foreach (var orderItem in initialOrderItems)
{
//save item
var newOrderItem = new OrderItem
{
OrderItemGuid = Guid.NewGuid(),
Order = order,
ProductId = orderItem.ProductId,
UnitPriceInclTax = orderItem.UnitPriceInclTax,
UnitPriceExclTax = orderItem.UnitPriceExclTax,
PriceInclTax = orderItem.PriceInclTax,
PriceExclTax = orderItem.PriceExclTax,
OriginalProductCost = orderItem.OriginalProductCost,
AttributeDescription = orderItem.AttributeDescription,
AttributesXml = orderItem.AttributesXml,
Quantity = orderItem.Quantity,
DiscountAmountInclTax = orderItem.DiscountAmountInclTax,
DiscountAmountExclTax = orderItem.DiscountAmountExclTax,
DownloadCount = 0,
IsDownloadActivated = false,
LicenseDownloadId = 0,
ItemWeight = orderItem.ItemWeight,
RentalStartDateUtc = orderItem.RentalStartDateUtc,
RentalEndDateUtc = orderItem.RentalEndDateUtc
};
order.OrderItems.Add(newOrderItem);
_orderService.UpdateOrder(order);
//gift cards
if (orderItem.Product.IsGiftCard)
{
string giftCardRecipientName, giftCardRecipientEmail,
giftCardSenderName, giftCardSenderEmail, giftCardMessage;
_productAttributeParser.GetGiftCardAttribute(orderItem.AttributesXml,
out giftCardRecipientName, out giftCardRecipientEmail,
out giftCardSenderName, out giftCardSenderEmail, out giftCardMessage);
for (int i = 0; i < orderItem.Quantity; i++)
{
var gc = new GiftCard
{
GiftCardType = orderItem.Product.GiftCardType,
PurchasedWithOrderItem = newOrderItem,
Amount = orderItem.UnitPriceExclTax,
IsGiftCardActivated = false,
GiftCardCouponCode = _giftCardService.GenerateGiftCardCode(),
RecipientName = giftCardRecipientName,
RecipientEmail = giftCardRecipientEmail,
SenderName = giftCardSenderName,
SenderEmail = giftCardSenderEmail,
Message = giftCardMessage,
IsRecipientNotified = false,
CreatedOnUtc = DateTime.UtcNow
};
_giftCardService.InsertGiftCard(gc);
}
}
//inventory
_productService.AdjustInventory(orderItem.Product, -orderItem.Quantity, orderItem.AttributesXml);
}
}
//discount usage history
if (!processPaymentRequest.IsRecurringPayment)
foreach (var discount in appliedDiscounts)
{
var duh = new DiscountUsageHistory
{
Discount = discount,
Order = order,
CreatedOnUtc = DateTime.UtcNow
};
_discountService.InsertDiscountUsageHistory(duh);
}
//gift card usage history
if (!processPaymentRequest.IsRecurringPayment)
if (appliedGiftCards != null)
foreach (var agc in appliedGiftCards)
{
decimal amountUsed = agc.AmountCanBeUsed;
var gcuh = new GiftCardUsageHistory
{
GiftCard = agc.GiftCard,
UsedWithOrder = order,
UsedValue = amountUsed,
CreatedOnUtc = DateTime.UtcNow
};
agc.GiftCard.GiftCardUsageHistory.Add(gcuh);
_giftCardService.UpdateGiftCard(agc.GiftCard);
}
//reward points history
if (redeemedRewardPointsAmount > decimal.Zero)
{
customer.AddRewardPointsHistoryEntry(-redeemedRewardPoints,
string.Format(_localizationService.GetResource("RewardPoints.Message.RedeemedForOrder", order.CustomerLanguageId), order.Id),
order,
redeemedRewardPointsAmount);
_customerService.UpdateCustomer(customer);
}
//recurring orders
if (!processPaymentRequest.IsRecurringPayment && isRecurringShoppingCart)
{
//create recurring payment (the first payment)
var rp = new RecurringPayment
{
CycleLength = processPaymentRequest.RecurringCycleLength,
CyclePeriod = processPaymentRequest.RecurringCyclePeriod,
TotalCycles = processPaymentRequest.RecurringTotalCycles,
StartDateUtc = DateTime.UtcNow,
IsActive = true,
CreatedOnUtc = DateTime.UtcNow,
InitialOrder = order,
};
_orderService.InsertRecurringPayment(rp);
var recurringPaymentType = _paymentService.GetRecurringPaymentType(processPaymentRequest.PaymentMethodSystemName);
switch (recurringPaymentType)
{
case RecurringPaymentType.NotSupported:
{
//not supported
}
break;
case RecurringPaymentType.Manual:
{
//first payment
var rph = new RecurringPaymentHistory
{
RecurringPayment = rp,
CreatedOnUtc = DateTime.UtcNow,
OrderId = order.Id,
};
rp.RecurringPaymentHistory.Add(rph);
_orderService.UpdateRecurringPayment(rp);
}
break;
case RecurringPaymentType.Automatic:
{
//will be created later (process is automated)
}
break;
default:
break;
}
}
#endregion
#region Notifications & notes
//notes, messages
if (_workContext.OriginalCustomerIfImpersonated != null)
{
//this order is placed by a store administrator impersonating a customer
order.OrderNotes.Add(new OrderNote
{
Note = string.Format( "Order placed by a store owner ('{0}'. ID = {1}) impersonating the customer.",
_workContext.OriginalCustomerIfImpersonated.Email, _workContext.OriginalCustomerIfImpersonated.Id),
DisplayToCustomer = false,
CreatedOnUtc = DateTime.UtcNow
});
_orderService.UpdateOrder(order);
}
else
{
order.OrderNotes.Add(new OrderNote
{
Note = "Order placed",
DisplayToCustomer = false,
CreatedOnUtc = DateTime.UtcNow
});
_orderService.UpdateOrder(order);
}
//send email notifications
int orderPlacedStoreOwnerNotificationQueuedEmailId = _workflowMessageService.SendOrderPlacedStoreOwnerNotification(order, _localizationSettings.DefaultAdminLanguageId);
if (orderPlacedStoreOwnerNotificationQueuedEmailId > 0)
{
order.OrderNotes.Add(new OrderNote
{
Note = string.Format("\"Order placed\" email (to store owner) has been queued. Queued email identifier: {0}.", orderPlacedStoreOwnerNotificationQueuedEmailId),
DisplayToCustomer = false,
CreatedOnUtc = DateTime.UtcNow
});
_orderService.UpdateOrder(order);
}
var orderPlacedAttachmentFilePath = _orderSettings.AttachPdfInvoiceToOrderPlacedEmail ?
_pdfService.PrintOrderToPdf(order, 0) : null;
var orderPlacedAttachmentFileName = _orderSettings.AttachPdfInvoiceToOrderPlacedEmail ?
"order.pdf" : null;
int orderPlacedCustomerNotificationQueuedEmailId = _workflowMessageService
.SendOrderPlacedCustomerNotification(order, order.CustomerLanguageId, orderPlacedAttachmentFilePath, orderPlacedAttachmentFileName);
if (orderPlacedCustomerNotificationQueuedEmailId > 0)
{
order.OrderNotes.Add(new OrderNote
{
Note = string.Format("\"Order placed\" email (to customer) has been queued. Queued email identifier: {0}.", orderPlacedCustomerNotificationQueuedEmailId),
DisplayToCustomer = false,
CreatedOnUtc = DateTime.UtcNow
});
_orderService.UpdateOrder(order);
}
var vendors = GetVendorsInOrder(order);
foreach (var vendor in vendors)
{
int orderPlacedVendorNotificationQueuedEmailId = _workflowMessageService.SendOrderPlacedVendorNotification(order, vendor, order.CustomerLanguageId);
if (orderPlacedVendorNotificationQueuedEmailId > 0)
{
order.OrderNotes.Add(new OrderNote
{
Note = string.Format("\"Order placed\" email (to vendor) has been queued. Queued email identifier: {0}.", orderPlacedVendorNotificationQueuedEmailId),
DisplayToCustomer = false,
CreatedOnUtc = DateTime.UtcNow
});
_orderService.UpdateOrder(order);
}
}
//check order status
CheckOrderStatus(order);
//reset checkout data
if (!processPaymentRequest.IsRecurringPayment)
_customerService.ResetCheckoutData(customer, processPaymentRequest.StoreId, clearCouponCodes: true, clearCheckoutAttributes: true);
if (!processPaymentRequest.IsRecurringPayment)
{
_customerActivityService.InsertActivity(
"PublicStore.PlaceOrder",
_localizationService.GetResource("ActivityLog.PublicStore.PlaceOrder"),
order.Id);
}
//uncomment this line to support transactions
//scope.Complete();
//raise event
_eventPublisher.Publish(new OrderPlacedEvent(order));
if (order.PaymentStatus == PaymentStatus.Paid)
{
ProcessOrderPaid(order);
}
#endregion
}
}
else
{
foreach (var paymentError in processPaymentResult.Errors)
result.AddError(string.Format("Payment error: {0}", paymentError));
}
}
catch (Exception exc)
{
_logger.Error(exc.Message, exc);
result.AddError(exc.Message);
}
#region Process errors
string error = "";
for (int i = 0; i < result.Errors.Count; i++)
{
error += string.Format("Error {0}: {1}", i + 1, result.Errors[i]);
if (i != result.Errors.Count - 1)
error += ". ";
}
if (!String.IsNullOrEmpty(error))
{
//log it
string logError = string.Format("Error while placing order. {0}", error);
_logger.Error(logError);
}
#endregion
return result;
}
/// <summary>
/// Process a payment
/// </summary>
/// <param name="processPaymentRequest">Payment info required for an order processing</param>
/// <returns>Process payment result</returns>
public ProcessPaymentResult ProcessPayment(ProcessPaymentRequest processPaymentRequest)
{
var result = new ProcessPaymentResult();
result.NewPaymentStatus = PaymentStatus.Authorized;
return result;
}
/// <summary>
/// Process recurring payment
/// </summary>
/// <param name="processPaymentRequest">Payment info required for an order processing</param>
/// <returns>Process payment result</returns>
public ProcessPaymentResult ProcessRecurringPayment(ProcessPaymentRequest processPaymentRequest)
{
var result = new ProcessPaymentResult();
var customer = _customerService.GetCustomerById(processPaymentRequest.CustomerId);
var req = new CreateRecurringPaymentsProfileReq();
req.CreateRecurringPaymentsProfileRequest = new CreateRecurringPaymentsProfileRequestType();
req.CreateRecurringPaymentsProfileRequest.Version = GetApiVersion();
var details = new CreateRecurringPaymentsProfileRequestDetailsType();
req.CreateRecurringPaymentsProfileRequest.CreateRecurringPaymentsProfileRequestDetails = details;
details.CreditCard = new CreditCardDetailsType();
details.CreditCard.CreditCardNumber = processPaymentRequest.CreditCardNumber;
details.CreditCard.CreditCardType = GetPaypalCreditCardType(processPaymentRequest.CreditCardType);
details.CreditCard.ExpMonthSpecified = true;
details.CreditCard.ExpMonth = processPaymentRequest.CreditCardExpireMonth;
details.CreditCard.ExpYearSpecified = true;
details.CreditCard.ExpYear = processPaymentRequest.CreditCardExpireYear;
details.CreditCard.CVV2 = processPaymentRequest.CreditCardCvv2;
details.CreditCard.CardOwner = new PayerInfoType();
details.CreditCard.CardOwner.PayerCountry = GetPaypalCountryCodeType(customer.BillingAddress.Country);
details.CreditCard.CreditCardTypeSpecified = true;
details.CreditCard.CardOwner.Address = new AddressType();
details.CreditCard.CardOwner.Address.CountrySpecified = true;
details.CreditCard.CardOwner.Address.Street1 = customer.BillingAddress.Address1;
details.CreditCard.CardOwner.Address.Street2 = customer.BillingAddress.Address2;
details.CreditCard.CardOwner.Address.CityName = customer.BillingAddress.City;
if (customer.BillingAddress.StateProvince != null)
details.CreditCard.CardOwner.Address.StateOrProvince = customer.BillingAddress.StateProvince.Abbreviation;
else
details.CreditCard.CardOwner.Address.StateOrProvince = "CA";
details.CreditCard.CardOwner.Address.Country = GetPaypalCountryCodeType(customer.BillingAddress.Country);
details.CreditCard.CardOwner.Address.PostalCode = customer.BillingAddress.ZipPostalCode;
details.CreditCard.CardOwner.Payer = customer.BillingAddress.Email;
details.CreditCard.CardOwner.PayerName = new PersonNameType();
details.CreditCard.CardOwner.PayerName.FirstName = customer.BillingAddress.FirstName;
details.CreditCard.CardOwner.PayerName.LastName = customer.BillingAddress.LastName;
//start date
details.RecurringPaymentsProfileDetails = new RecurringPaymentsProfileDetailsType();
details.RecurringPaymentsProfileDetails.BillingStartDate = DateTime.UtcNow;
details.RecurringPaymentsProfileDetails.ProfileReference = processPaymentRequest.OrderGuid.ToString();
//schedule
details.ScheduleDetails = new ScheduleDetailsType();
details.ScheduleDetails.Description = "Recurring payment";
details.ScheduleDetails.PaymentPeriod = new BillingPeriodDetailsType();
details.ScheduleDetails.PaymentPeriod.Amount = new BasicAmountType();
details.ScheduleDetails.PaymentPeriod.Amount.Value = Math.Round(processPaymentRequest.OrderTotal, 2).ToString("N", new CultureInfo("en-us"));
details.ScheduleDetails.PaymentPeriod.Amount.currencyID = PaypalHelper.GetPaypalCurrency(_currencyService.GetCurrencyById(_currencySettings.PrimaryStoreCurrencyId));
details.ScheduleDetails.PaymentPeriod.BillingFrequency = processPaymentRequest.RecurringCycleLength;
switch (processPaymentRequest.RecurringCyclePeriod)
{
case RecurringProductCyclePeriod.Days:
details.ScheduleDetails.PaymentPeriod.BillingPeriod = BillingPeriodType.Day;
break;
case RecurringProductCyclePeriod.Weeks:
details.ScheduleDetails.PaymentPeriod.BillingPeriod = BillingPeriodType.Week;
break;
case RecurringProductCyclePeriod.Months:
details.ScheduleDetails.PaymentPeriod.BillingPeriod = BillingPeriodType.Month;
break;
case RecurringProductCyclePeriod.Years:
details.ScheduleDetails.PaymentPeriod.BillingPeriod = BillingPeriodType.Year;
break;
default:
throw new NopException("Not supported cycle period");
}
details.ScheduleDetails.PaymentPeriod.TotalBillingCycles = processPaymentRequest.RecurringTotalCycles;
details.ScheduleDetails.PaymentPeriod.TotalBillingCyclesSpecified = true;
using (var service2 = new PayPalAPIAASoapBinding())
{
if (!_paypalDirectPaymentSettings.UseSandbox)
service2.Url = "https://api-3t.paypal.com/2.0/";
else
service2.Url = "https://api-3t.sandbox.paypal.com/2.0/";
service2.RequesterCredentials = new CustomSecurityHeaderType();
service2.RequesterCredentials.Credentials = new UserIdPasswordType();
service2.RequesterCredentials.Credentials.Username = _paypalDirectPaymentSettings.ApiAccountName;
service2.RequesterCredentials.Credentials.Password = _paypalDirectPaymentSettings.ApiAccountPassword;
service2.RequesterCredentials.Credentials.Signature = _paypalDirectPaymentSettings.Signature;
service2.RequesterCredentials.Credentials.Subject = "";
CreateRecurringPaymentsProfileResponseType response = service2.CreateRecurringPaymentsProfile(req);
string error = "";
bool success = PaypalHelper.CheckSuccess(response, out error);
if (success)
{
result.NewPaymentStatus = PaymentStatus.Pending;
if (response.CreateRecurringPaymentsProfileResponseDetails != null)
{
result.SubscriptionTransactionId = response.CreateRecurringPaymentsProfileResponseDetails.ProfileID;
}
}
else
{
result.AddError(error);
}
}
return result;
}
public ProcessPaymentResult ProcessPayment(ProcessPaymentRequest processPaymentRequest)
{
TransactionResponse TransactionResponse = null;
var authorizeNetPaymentSettings = _settingService.LoadSetting<BridgePaySettings>();
var twoDigitMonth = processPaymentRequest.CreditCardExpireMonth.ToString("00");
var twoDigitYear = processPaymentRequest.CreditCardExpireYear.ToString().Substring(2, 2);
string serviceUrl = string.Format(authorizeNetPaymentSettings.GatewayUrl + "?" +
"UserName="******"&" +
"Password="******"&" +
"TransType=Sale&"+
"CardNum=" + processPaymentRequest.CreditCardNumber + "&"+
"ExpDate=" + twoDigitMonth + twoDigitYear + "&"+
"MagData=data&" +
"NameOnCard=" + processPaymentRequest.CreditCardName + "&" +
"Amount=" + processPaymentRequest.OrderTotal + "&" +
"InvNum=1&" +
"PNRef=1&" +
"Zip=43600&" +
"Street=Kamra&" +
"CVNum=" + processPaymentRequest.CreditCardCvv2 + "&" +
"ExtData=ext-data");
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(serviceUrl);
try
{
var httpResponse = (HttpWebResponse)request.GetResponse();
//Receipt Receipt = null;
using (var streamReader = new StreamReader(httpResponse.GetResponseStream()))
{
var responstText = streamReader.ReadToEnd();
XmlDocument doc = new XmlDocument();
doc.LoadXml(responstText);
if (doc.ChildNodes[1].Name == "Response")
{
var responseNode = doc.ChildNodes[1];
var responseNodes = responseNode.Cast<XmlNode>().ToArray();
var res = responseNodes.SingleOrDefault(n => n.Name == "Result");
string jsonText = JsonConvert.SerializeXmlNode(node: responseNode, formatting: Newtonsoft.Json.Formatting.None, omitRootObject: true);
// parse json to anonymous object
var Response = new
{
Result = 0,
RespMSG = string.Empty,
ExtData = string.Empty
};
Response = Newtonsoft.Json.JsonConvert.DeserializeAnonymousType(jsonText, Response);
// parse json to class object
TransactionResponse = Newtonsoft.Json.JsonConvert.DeserializeObject<TransactionResponse>(jsonText);
}
}
}
catch (Exception)
{ }
var result = new ProcessPaymentResult();
var customer = _customerService.GetCustomerById(processPaymentRequest.CustomerId);
if (TransactionResponse != null)
{
switch (TransactionResponse.Result)
{
case 0:
result.AuthorizationTransactionCode = string.Format("{0}", TransactionResponse.AuthCode);
result.AuthorizationTransactionResult = string.Format("Approved {0})", TransactionResponse.Message1);
result.AvsResult = TransactionResponse.GetAVSResult;
//responseFields[38];
//if (_authorizeNetPaymentSettings.TransactMode == TransactMode.Authorize)
//{
// result.NewPaymentStatus = PaymentStatus.Authorized;
//}
//else
//{
// result.NewPaymentStatus = PaymentStatus.Paid;
//}
break;
case 24:
result.AddError(string.Format("Error: {0}", TransactionResponse.Message));
break;
case 110:
result.AddError(string.Format("Error: {0}", TransactionResponse.RespMSG));
break;
}
}
else
{
result.AddError("BridgePay unknown error");
}
/////////////////////////////////////////////////////////////////////////////////////////////////
//var webClient = new WebClient();
//var form = new NameValueCollection();
//form.Add("x_login", _authorizeNetPaymentSettings.LoginId);
//form.Add("x_tran_key", _authorizeNetPaymentSettings.TransactionKey);
////we should not send "x_test_request" parameter. otherwise, the transaction won't be logged in the sandbox
////if (_authorizeNetPaymentSettings.UseSandbox)
//// form.Add("x_test_request", "TRUE");
////else
//// form.Add("x_test_request", "FALSE");
//form.Add("x_delim_data", "TRUE");
//form.Add("x_delim_char", "|");
//form.Add("x_encap_char", "");
//form.Add("x_version", GetApiVersion());
//form.Add("x_relay_response", "FALSE");
//form.Add("x_method", "CC");
//form.Add("x_currency_code", _currencyService.GetCurrencyById(_currencySettings.PrimaryStoreCurrencyId).CurrencyCode);
//if (_authorizeNetPaymentSettings.TransactMode == TransactMode.Authorize)
// form.Add("x_type", "AUTH_ONLY");
//else if (_authorizeNetPaymentSettings.TransactMode == TransactMode.AuthorizeAndCapture)
// form.Add("x_type", "AUTH_CAPTURE");
//else
// throw new NopException("Not supported transaction mode");
//var orderTotal = Math.Round(processPaymentRequest.OrderTotal, 2);
//form.Add("x_amount", orderTotal.ToString("0.00", CultureInfo.InvariantCulture));
//form.Add("x_card_num", processPaymentRequest.CreditCardNumber);
//form.Add("x_exp_date", processPaymentRequest.CreditCardExpireMonth.ToString("D2") + processPaymentRequest.CreditCardExpireYear.ToString());
//form.Add("x_card_code", processPaymentRequest.CreditCardCvv2);
//form.Add("x_first_name", customer.BillingAddress.FirstName);
//form.Add("x_last_name", customer.BillingAddress.LastName);
//form.Add("x_email", customer.BillingAddress.Email);
//if (!string.IsNullOrEmpty(customer.BillingAddress.Company))
// form.Add("x_company", customer.BillingAddress.Company);
//form.Add("x_address", customer.BillingAddress.Address1);
//form.Add("x_city", customer.BillingAddress.City);
//if (customer.BillingAddress.StateProvince != null)
// form.Add("x_state", customer.BillingAddress.StateProvince.Abbreviation);
//form.Add("x_zip", customer.BillingAddress.ZipPostalCode);
//if (customer.BillingAddress.Country != null)
// form.Add("x_country", customer.BillingAddress.Country.TwoLetterIsoCode);
////x_invoice_num is 20 chars maximum. hece we also pass x_description
//form.Add("x_invoice_num", processPaymentRequest.OrderGuid.ToString().Substring(0, 20));
//form.Add("x_description", string.Format("Full order #{0}", processPaymentRequest.OrderGuid));
//form.Add("x_customer_ip", _webHelper.GetCurrentIpAddress());
//var responseData = webClient.UploadValues(GetAuthorizeNetUrl(), form);
//var reply = Encoding.ASCII.GetString(responseData);
//if (!String.IsNullOrEmpty(reply))
//{
// string[] responseFields = reply.Split('|');
// switch (responseFields[0])
// {
// case "1":
// result.AuthorizationTransactionCode = string.Format("{0},{1}", responseFields[6], responseFields[4]);
// result.AuthorizationTransactionResult = string.Format("Approved ({0}: {1})", responseFields[2], responseFields[3]);
// result.AvsResult = responseFields[5];
// //responseFields[38];
// if (_authorizeNetPaymentSettings.TransactMode == TransactMode.Authorize)
// {
// result.NewPaymentStatus = PaymentStatus.Authorized;
// }
// else
// {
// result.NewPaymentStatus = PaymentStatus.Paid;
// }
// break;
// case "2":
// result.AddError(string.Format("Declined ({0}: {1})", responseFields[2], responseFields[3]));
// break;
// case "3":
// result.AddError(string.Format("Error: {0}", reply));
// break;
// }
//}
//else
//{
// result.AddError("Authorize.NET unknown error");
//}
return result;
}
protected ProcessPaymentResult AuthorizeOrSale(ProcessPaymentRequest processPaymentRequest, bool authorizeOnly)
{
var result = new ProcessPaymentResult();
var customer = _customerService.GetCustomerById(processPaymentRequest.CustomerId);
if (customer == null)
throw new Exception("Customer cannot be loaded");
var req = new DoDirectPaymentReq();
req.DoDirectPaymentRequest = new DoDirectPaymentRequestType();
req.DoDirectPaymentRequest.Version = GetApiVersion();
var details = new DoDirectPaymentRequestDetailsType();
req.DoDirectPaymentRequest.DoDirectPaymentRequestDetails = details;
details.IPAddress = _webHelper.GetCurrentIpAddress() ?? "";
if (authorizeOnly)
details.PaymentAction = PaymentActionCodeType.AUTHORIZATION;
else
details.PaymentAction = PaymentActionCodeType.SALE;
//credit card
details.CreditCard = new CreditCardDetailsType();
details.CreditCard.CreditCardNumber = processPaymentRequest.CreditCardNumber;
details.CreditCard.CreditCardType = GetPaypalCreditCardType(processPaymentRequest.CreditCardType);
details.CreditCard.ExpMonth = processPaymentRequest.CreditCardExpireMonth;
details.CreditCard.ExpYear = processPaymentRequest.CreditCardExpireYear;
details.CreditCard.CVV2 = processPaymentRequest.CreditCardCvv2;
details.CreditCard.CardOwner = new PayerInfoType();
var country = EngineContext.Current.Resolve<ICountryService>().GetCountryById(customer.BillingAddress.CountryId);
details.CreditCard.CardOwner.PayerCountry = GetPaypalCountryCodeType(country);
//billing address
details.CreditCard.CardOwner.Address = new AddressType();
details.CreditCard.CardOwner.Address.Street1 = customer.BillingAddress.Address1;
details.CreditCard.CardOwner.Address.Street2 = customer.BillingAddress.Address2;
details.CreditCard.CardOwner.Address.CityName = customer.BillingAddress.City;
if (customer.BillingAddress.StateProvinceId != 0)
{
var state = EngineContext.Current.Resolve<IStateProvinceService>().GetStateProvinceById(customer.BillingAddress.StateProvinceId);
details.CreditCard.CardOwner.Address.StateOrProvince = state.Abbreviation;
}
else
details.CreditCard.CardOwner.Address.StateOrProvince = "CA";
details.CreditCard.CardOwner.Address.Country = GetPaypalCountryCodeType(country);
details.CreditCard.CardOwner.Address.PostalCode = customer.BillingAddress.ZipPostalCode;
details.CreditCard.CardOwner.Payer = customer.BillingAddress.Email;
details.CreditCard.CardOwner.PayerName = new PersonNameType();
details.CreditCard.CardOwner.PayerName.FirstName = customer.BillingAddress.FirstName;
details.CreditCard.CardOwner.PayerName.LastName = customer.BillingAddress.LastName;
//order totals
var payPalCurrency = PaypalHelper.GetPaypalCurrency(_currencyService.GetCurrencyById(_currencySettings.PrimaryStoreCurrencyId));
details.PaymentDetails = new PaymentDetailsType();
details.PaymentDetails.OrderTotal = new BasicAmountType();
details.PaymentDetails.OrderTotal.value = Math.Round(processPaymentRequest.OrderTotal, 2).ToString("N", new CultureInfo("en-us"));
details.PaymentDetails.OrderTotal.currencyID = payPalCurrency;
details.PaymentDetails.Custom = processPaymentRequest.OrderGuid.ToString();
details.PaymentDetails.ButtonSource = "nopCommerceCart";
//shipping
if (customer.ShippingAddress != null)
{
if (customer.ShippingAddress.StateProvinceId != 0 && customer.ShippingAddress.CountryId != 0)
{
var state = EngineContext.Current.Resolve<IStateProvinceService>().GetStateProvinceById(customer.ShippingAddress.StateProvinceId);
var countryshipping = EngineContext.Current.Resolve<ICountryService>().GetCountryById(customer.ShippingAddress.CountryId);
var shippingAddress = new AddressType();
shippingAddress.Name = customer.ShippingAddress.FirstName + " " + customer.ShippingAddress.LastName;
shippingAddress.Street1 = customer.ShippingAddress.Address1;
shippingAddress.Street2 = customer.ShippingAddress.Address2;
shippingAddress.CityName = customer.ShippingAddress.City;
shippingAddress.StateOrProvince = state.Abbreviation;
shippingAddress.PostalCode = customer.ShippingAddress.ZipPostalCode;
shippingAddress.Country = (CountryCodeType)Enum.Parse(typeof(CountryCodeType), countryshipping.TwoLetterIsoCode, true);
details.PaymentDetails.ShipToAddress = shippingAddress;
}
}
//send request
var service = GetService();
DoDirectPaymentResponseType response = service.DoDirectPayment(req);
string error;
bool success = PaypalHelper.CheckSuccess(response, out error);
if (success)
{
result.AvsResult = response.AVSCode;
result.AuthorizationTransactionCode = response.CVV2Code;
if (authorizeOnly)
{
result.AuthorizationTransactionId = response.TransactionID;
result.AuthorizationTransactionResult = response.Ack.ToString();
result.NewPaymentStatus = PaymentStatus.Authorized;
}
else
{
result.CaptureTransactionId = response.TransactionID;
result.CaptureTransactionResult = response.Ack.ToString();
result.NewPaymentStatus = PaymentStatus.Paid;
}
}
else
{
result.AddError(error);
}
return result;
}
/// <summary>
/// Process a payment
/// </summary>
/// <param name="processPaymentRequest">Payment info required for an order processing</param>
/// <returns>Process payment result</returns>
public ProcessPaymentResult ProcessPayment(ProcessPaymentRequest processPaymentRequest)
{
var result = new ProcessPaymentResult();
var token = (string)processPaymentRequest.CustomValues["token_value"];
var config = new HpsServicesConfig();
config.SecretApiKey = _secureSubmitPaymentSettings.SecretApiKey;
config.DeveloperId = "002914";
config.VersionNumber = "1513";
var creditService = new HpsCreditService(config);
var customer = _customerService.GetCustomerById(processPaymentRequest.CustomerId);
var cardHolder = new HpsCardHolder();
cardHolder.Address = new HpsAddress();
cardHolder.Address.Address = customer.BillingAddress.Address1;
cardHolder.Address.City = customer.BillingAddress.City;
cardHolder.Address.State = customer.BillingAddress.StateProvince.Abbreviation;
cardHolder.Address.Zip = customer.BillingAddress.ZipPostalCode.Replace("-", "");
cardHolder.Address.Country = customer.BillingAddress.Country.ThreeLetterIsoCode;
HpsAuthorization response = null;
try
{
if (_secureSubmitPaymentSettings.TransactMode == TransactMode.Authorize)
{
// auth
response = creditService.Authorize(
processPaymentRequest.OrderTotal,
_currencyService.GetCurrencyById(_currencySettings.PrimaryStoreCurrencyId).CurrencyCode,
token,
cardHolder,
false);
result.NewPaymentStatus = PaymentStatus.Authorized;
result.AuthorizationTransactionCode = response.AuthorizationCode;
result.AuthorizationTransactionId = response.TransactionId.ToString();
}
else
{
//capture
response = creditService.Charge(
processPaymentRequest.OrderTotal,
_currencyService.GetCurrencyById(_currencySettings.PrimaryStoreCurrencyId).CurrencyCode,
token,
cardHolder,
false);
result.NewPaymentStatus = PaymentStatus.Paid;
result.CaptureTransactionId = response.TransactionId.ToString();
result.CaptureTransactionResult = response.ResponseText;
}
}
catch (HpsException ex)
{
result.AddError(ex.Message);
}
return result;
}
/// <summary>
/// Process a payment
/// </summary>
/// <param name="processPaymentRequest">Payment info required for an order processing</param>
/// <returns>Process payment result</returns>
public ProcessPaymentResult ProcessPayment(ProcessPaymentRequest processPaymentRequest)
{
var result = new ProcessPaymentResult();
result.NewPaymentStatus = PaymentStatus.Pending;
return result;
}
/// <summary>
/// Process a payment
/// </summary>
/// <param name="processPaymentRequest">Payment info required for an order processing</param>
/// <returns>Process payment result</returns>
public ProcessPaymentResult ProcessPayment(ProcessPaymentRequest processPaymentRequest)
{
var result = new ProcessPaymentResult();
try
{
result.AllowStoringCreditCardNumber = false;
var customer = _customerService.GetCustomerById(processPaymentRequest.CustomerId);
var order = _orderService.GetOrderByGuid(processPaymentRequest.OrderGuid);
string currency = _currencyService.GetCurrencyById(_currencySettings.PrimaryStoreCurrencyId).CurrencyCode;
PaymentModel pm = new PaymentModel();
pm = getPayment("?token=" + processPaymentRequest.CustomValues["paymenttoken"]);
string paymentid = pm.id;
string amount = processPaymentRequest.OrderTotal.ToString();
amount = Regex.Replace(amount, @"[^\d]", "");
//string urlappend = "?payment=" + payment + "&amount=" + amount + "¤cy=" + currency + "&description=" + description;
string urlbuilder = "?payment=" + paymentid + "&amount=" + amount + "¤cy=" + currency + "&description=Order from Store ID: " + processPaymentRequest.StoreId.ToString() + " PaymentID: " + pm.id;
TransactionModel trans = new TransactionModel();
//_logger.InsertLog(Core.Domain.Logging.LogLevel.Information, "url for transaction", urlbuilder);
trans = getTransaction(urlbuilder, pm);
string responsecode = trans.response_code;
string transactionid = trans.id;
//set the transaction variables
if (responsecode == "20000")
{
//successful response
result.AuthorizationTransactionCode = transactionid;
result.AuthorizationTransactionResult = responsecode;
result.NewPaymentStatus = PaymentStatus.Paid;
//_logger.InsertLog(Core.Domain.Logging.LogLevel.Information, "success at paymill proceessorder" + responsecode + urlbuilder + paymentid, trans.status + urlbuilder + paymentid, null);
}
else
{
//failed transaction
_logger.InsertLog(Core.Domain.Logging.LogLevel.Information, "failure at paymill proceessorder" + responsecode, trans.status, null);
result.AddError(getErrorcodes(responsecode, trans.status));
}
}
catch (Exception ex)
{
_logger.InsertLog(Core.Domain.Logging.LogLevel.Error, ex.Message, ex.ToString());
result.AddError(ex.ToString());
}
return result;
}
