public void Can_save_and_load_orderNote()
{
var on = new OrderNote()
{
Order = GetTestOrder(),
Note = "Note1",
DisplayToCustomer= true,
CreatedOnUtc = new DateTime(2010, 01, 01),
};
var fromDb = SaveAndLoadEntity(on);
fromDb.ShouldNotBeNull();
fromDb.Note.ShouldEqual("Note1");
fromDb.DisplayToCustomer.ShouldEqual(true);
fromDb.CreatedOnUtc.ShouldEqual(new DateTime(2010, 01, 01));
fromDb.Order.ShouldNotBeNull();
}
/// <summary>
/// Deletes an order note
/// </summary>
/// <param name="orderNote">The order note</param>
public virtual void DeleteOrderNote(OrderNote orderNote)
{
if (orderNote == null)
throw new ArgumentNullException("orderNote");
_orderNoteRepository.Delete(orderNote);
//event notification
_eventPublisher.EntityDeleted(orderNote);
}
private IList<Token> GenerateTokens(OrderNote orderNote, int languageId)
{
var tokens = new List<Token>();
_messageTokenProvider.AddStoreTokens(tokens);
_messageTokenProvider.AddOrderNoteTokens(tokens, orderNote);
_messageTokenProvider.AddOrderTokens(tokens, orderNote.Order, languageId);
_messageTokenProvider.AddCustomerTokens(tokens, orderNote.Order.Customer);
return tokens;
}
/// <summary>
/// Sends a new order note added notification to a customer
/// </summary>
/// <param name="orderNote">Order note</param>
/// <param name="languageId">Message language identifier</param>
/// <returns>Queued email identifier</returns>
public virtual int SendNewOrderNoteAddedCustomerNotification(OrderNote orderNote, int languageId)
{
if (orderNote == null)
throw new ArgumentNullException("orderNote");
var order = orderNote.Order;
languageId = EnsureLanguageIsActive(languageId);
var messageTemplate = GetLocalizedActiveMessageTemplate("Customer.NewOrderNote", languageId);
if (messageTemplate == null)
return 0;
var orderTokens = GenerateTokens(orderNote, languageId);
//event notification
_eventPublisher.MessageTokensAdded(messageTemplate, orderTokens);
var emailAccount = GetEmailAccountOfMessageTemplate(messageTemplate, languageId);
var toEmail = order.BillingAddress.Email;
var toName = string.Format("{0} {1}", order.BillingAddress.FirstName, order.BillingAddress.LastName);
return SendNotification(messageTemplate, emailAccount,
languageId, orderTokens,
toEmail, toName);
}
public ActionResult OrderNoteAdd(int orderId, bool displayToCustomer, string message)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageOrders))
return AccessDeniedView();
var order = _orderService.GetOrderById(orderId);
if (order == null)
return Json(new { Result = false }, JsonRequestBehavior.AllowGet);
var orderNote = new OrderNote()
{
DisplayToCustomer = displayToCustomer,
Note = message,
CreatedOnUtc = DateTime.UtcNow,
};
order.OrderNotes.Add(orderNote);
_orderService.UpdateOrder(order);
//new order notification
if (displayToCustomer)
{
//email
_workflowMessageService.SendNewOrderNoteAddedCustomerNotification(
orderNote, _workContext.WorkingLanguage.Id);
}
return Json(new { Result = true }, JsonRequestBehavior.AllowGet);
}
/// <summary>
/// Sends a new order note added notification to a customer
/// </summary>
/// <param name="orderNote">Order note</param>
/// <param name="languageId">Message language identifier</param>
/// <returns>Queued email identifier</returns>
public virtual int SendNewOrderNoteAddedCustomerNotification(OrderNote orderNote, int languageId)
{
if (orderNote == null)
throw new ArgumentNullException("orderNote");
var order = orderNote.Order;
var store = _storeService.GetStoreById(order.StoreId) ?? _storeContext.CurrentStore;
languageId = EnsureLanguageIsActive(languageId, store.Id);
var messageTemplate = GetActiveMessageTemplate("Customer.NewOrderNote", store.Id);
if (messageTemplate == null)
return 0;
//email account
var emailAccount = GetEmailAccountOfMessageTemplate(messageTemplate, languageId);
//tokens
var tokens = new List<Token>();
_messageTokenProvider.AddStoreTokens(tokens, store, emailAccount);
_messageTokenProvider.AddOrderNoteTokens(tokens, orderNote);
_messageTokenProvider.AddOrderTokens(tokens, orderNote.Order, languageId);
_messageTokenProvider.AddCustomerTokens(tokens, orderNote.Order.Customer);
//event notification
_eventPublisher.MessageTokensAdded(messageTemplate, tokens);
var toEmail = order.BillingAddress.Email;
var toName = string.Format("{0} {1}", order.BillingAddress.FirstName, order.BillingAddress.LastName);
return SendNotification(messageTemplate, emailAccount,
languageId, tokens,
toEmail, toName);
}
public virtual void AddOrderNoteTokens(IList<Token> tokens, OrderNote orderNote)
{
tokens.Add(new Token("Order.NewNoteText", orderNote.FormatOrderNoteText(), true));
tokens.Add(new Token("Order.OrderNoteAttachmentUrl", string.Format("{0}download/ordernotefile/{1}", GetStoreUrl(orderNote.Order.StoreId), orderNote.Id), true));
//event notification
_eventPublisher.EntityTokensAdded(orderNote, tokens);
}
public virtual void AddOrderNoteTokens(IList<Token> tokens, OrderNote orderNote)
{
tokens.Add(new Token("Order.NewNoteText", orderNote.FormatOrderNoteText(), true));
//event notification
_eventPublisher.EntityTokensAdded(orderNote, tokens);
}
public virtual void AddOrderNoteTokens(IList<Token> tokens, OrderNote orderNote)
{
tokens.Add(new Token("Order.NewNoteText", orderNote.FormatOrderNoteText(), true));
}
public virtual void AddOrderNoteTokens(IList<Token> tokens, OrderNote orderNote)
{
tokens.Add(new Token("Order.NewNoteText", orderNote.FormatOrderNoteText(), true));
var order = EngineContext.Current.Resolve<IOrderService>().GetOrderById(orderNote.OrderId);
tokens.Add(new Token("Order.OrderNoteAttachmentUrl", string.Format("{0}download/ordernotefile/{1}", GetStoreUrl(order.StoreId), orderNote.Id), true));
//event notification
_eventPublisher.EntityTokensAdded(orderNote, tokens);
}
/// <summary>
/// Deletes an order note
/// </summary>
/// <param name="orderNote">The order note</param>
public virtual void DeleteOrderNote(OrderNote orderNote)
{
if (orderNote == null)
throw new ArgumentNullException("orderNote");
var updatebuilder = Builders<Order>.Update;
var update = updatebuilder.Pull(p => p.OrderNotes, orderNote);
_orderRepository.Collection.UpdateOneAsync(new BsonDocument("Id", orderNote.OrderId), update);
//event notification
_eventPublisher.EntityDeleted(orderNote);
}
public virtual void AddOrderNoteTokens(IList<Token> tokens, OrderNote orderNote)
{
tokens.Add(new Token("Order.NewNoteText", orderNote.FormatOrderNoteText(), true));
//UNDONE: should we display a link to download an attached file (if exists)?
//event notification
_eventPublisher.EntityTokensAdded(orderNote, tokens);
}
public ActionResult OrderNoteAdd(int orderId, int downloadId, bool displayToCustomer, string message)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageOrders))
return AccessDeniedView();
var order = _orderService.GetOrderById(orderId);
if (order == null)
return Json(new { Result = false }, JsonRequestBehavior.AllowGet);
//a vendor does not have access to this functionality
if (_workContext.CurrentVendor != null)
return Json(new { Result = false }, JsonRequestBehavior.AllowGet);
var orderNote = new OrderNote
{
DisplayToCustomer = displayToCustomer,
Note = message,
DownloadId = downloadId,
OrderId = orderId,
CreatedOnUtc = DateTime.UtcNow,
Id = order.OrderNotes.Count > 0 ? order.OrderNotes.Max(x => x.Id) + 1 : 1,
_id = ObjectId.GenerateNewId().ToString(),
};
order.OrderNotes.Add(orderNote);
_orderService.UpdateOrder(order);
//new order notification
if (displayToCustomer)
{
//email
_workflowMessageService.SendNewOrderNoteAddedCustomerNotification(
orderNote, _workContext.WorkingLanguage.Id);
}
return Json(new { Result = true }, JsonRequestBehavior.AllowGet);
}
/// <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");
var result = new PlaceOrderResult();
try
{
if (processPaymentRequest.OrderGuid == Guid.Empty)
processPaymentRequest.OrderGuid = Guid.NewGuid();
//prepare order details
var details = PreparePlaceOrderDetails(processPaymentRequest);
if (details.ShippingMethodName == "Pick up from access point")
{
details.PickUpInStore = true;
}
#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,
EstimateDate = processPaymentRequest.EstimateDeliveryDate,
PickUpStore = "",
Note = "",
CustomerNote = processPaymentRequest.CustomerNote
};
_orderService.InsertOrder(order);
result.PlacedOrder = order;
var neworder = _orderService.GetOrderById(result.PlacedOrder.Id);
var orderNote = new OrderNote
{
DisplayToCustomer = true,
Note = processPaymentRequest.CustomerNote,
DownloadId = 0,
CreatedOnUtc = DateTime.UtcNow,
};
neworder.OrderNotes.Add(orderNote);
_orderService.UpdateOrder(order);
if (!processPaymentRequest.IsRecurringPayment)
{
var isGiftCard = false;
//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)
if (sc.Product.AdminComment == "Gift Card")
{
isGiftCard = true;
string giftCardRecipientName, giftCardRecipientEmail,
giftCardSenderName, giftCardSenderEmail, giftCardMessage;
_productAttributeParser.GetGiftCardAttribute(sc.AttributesXml,
out giftCardRecipientName, out giftCardRecipientEmail,
out giftCardSenderName, out giftCardSenderEmail, out giftCardMessage);
//var giftCardCode = _giftCardService.GetCustomerGiftCard(order.Customer);
var giftCardId = _giftCardService.GetCustomerGiftCardId(order.Customer);
var giftcardOBject = _giftCardService.GetGiftCardById(giftCardId);
//var gcBalance = 0;
var giftCardCode = "";
if (giftCardId != 0)
{
giftCardMessage = "Renewal";
giftCardCode = giftcardOBject.GiftCardCouponCode;
}
else
{
giftCardCode = _giftCardService.GenerateGiftCardCode();
}
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
GiftCardType = sc.Product.GiftCardType,
PurchasedWithOrderItem = orderItem,
Amount = scUnitPriceExclTax,
IsGiftCardActivated = false,
GiftCardCouponCode = giftCardCode,
//RecipientName = order.Customer.GetFullName(),
RecipientName = order.Customer.Email,
RecipientEmail = order.Customer.Email,
SenderName = order.Customer.GetFullName(),
SenderEmail = order.Customer.Email,
Message = giftCardMessage,
IsRecipientNotified = false,
CreatedOnUtc = DateTime.UtcNow
};
if (giftCardId == 0)
{
gc.IsGiftCardActivated = true;
}
_giftCardService.InsertGiftCard(gc);
_giftCardService.UpdateFreeShipping(order.Customer.Id, 1, scUnitPriceExclTax); //update free shipping for all gift card
}
if (giftCardId != 0)
{
var giftcard = new GiftCard
{
Amount = scUnitPriceExclTax + giftcardOBject.Amount,
Id = giftCardId
};
_giftCardService.UpdateGiftCard(giftCardId, scUnitPriceExclTax + giftcardOBject.Amount);
//_giftCardService.UpdateGiftCard(giftcard);
}
}
//inventory
_productService.AdjustInventory(sc.Product, -sc.Quantity, sc.AttributesXml);
}
if (!isGiftCard)
_giftCardService.UpdateFreeShipping(order.Customer.Id, 0, order.OrderSubtotalExclTax);
//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);
//var customeremail = orderItem.Order.Customer.Email;
//orderItem.Order.Customer.GetFullName();
//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)
{
details.Customer.AddRewardPointsHistoryEntry(-details.RedeemedRewardPoints,
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
{
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);
_logger.Error(logError);
}
#endregion
return result;
}
