public bool UpdateOrderStatus(OrderStatusUpdateModel orderStatusUpdate)
{
var order = _unitOfWork.OrderRepository.Find(x => x.Id == orderStatusUpdate.orderId, y => y.OrderProductItem).FirstOrDefault();
OrderProductItem subOrder = order.OrderProductItem.Where(x => x.Id == orderStatusUpdate.subOrderId).FirstOrDefault();
bool flagChangeOrderStatus = true;
if (subOrder != null)
{
subOrder.OrderItemStatus = orderStatusUpdate.statusId;
foreach (var item in order.OrderProductItem)
{
if (subOrder.Id != item.Id)
{
if (item.OrderItemStatus < orderStatusUpdate.statusId)
{
flagChangeOrderStatus = false;
break;
}
}
}
if (flagChangeOrderStatus)
{
order.OrderStatusId = orderStatusUpdate.statusId;
}
_unitOfWork.UpdateAndSave(order);
_unitOfWork.Commit();
}
return(true);
}
/// <summary>
/// 获取packageNo
/// </summary>
/// <param name="packageNo"></param>
/// <param name="item"></param>
/// <returns></returns>
private static int GetPackageNo(int packageNo, OrderProductItem item)
{
if (packageNo == 0)
{
return(item["PackageNo"] != null ? (int)item["PackageNo"] : 0);
}
return(packageNo);
}
/// <summary>
/// 取得满足优惠券条件的商品总金额
/// </summary>
/// <param name="orderList"></param>
/// <param name="coupon"></param>
/// <returns></returns>
private decimal GetCanCalculateAmount(List <OrderInfo> orderList, CouponInfo coupon)
{
List <int> productSysNoList = new List <int>();
foreach (var order in orderList)
{
foreach (OrderItemGroup itemGroup in order.OrderItemGroupList)
{
foreach (OrderProductItem item in itemGroup.ProductItemList)
{
productSysNoList.Add(item.ProductSysNo);
}
}
}
List <SimpleItemEntity> productList = PromotionDA.GetSimpleItemListBySysNumbers(productSysNoList);
//couponProductList:满足条件的商品列表，使用OrderProductItem这个对象来记录，UnitSalePrice是这个商品的价格，UnitQuantity会作为这个商品的总数量
List <OrderProductItem> couponProductList = new List <OrderProductItem>();
foreach (var order in orderList)
{
foreach (OrderItemGroup itemGroup in order.OrderItemGroupList)
{
foreach (OrderProductItem item in itemGroup.ProductItemList)
{
SimpleItemEntity product = productList.Find(f => f.ProductSysNo == item.ProductSysNo);
if (CheckIsCouponProduct(product, coupon))
{
OrderProductItem couponProduct = couponProductList.Find(f => f.ProductSysNo == product.ProductSysNo);
if (couponProduct == null)
{
couponProduct = new OrderProductItem();
couponProduct.ProductSysNo = item.ProductSysNo;
couponProduct.UnitSalePrice = item.UnitSalePrice;
couponProduct.UnitQuantity = item.UnitQuantity * itemGroup.Quantity;
couponProductList.Add(couponProduct);
}
else
{
couponProduct.UnitQuantity += item.UnitQuantity * itemGroup.Quantity;
}
}
}
}
}
decimal totalAmount = 0.00m;
foreach (OrderProductItem couponProduct in couponProductList)
{
totalAmount += couponProduct.UnitSalePrice * couponProduct.UnitQuantity;
}
return(totalAmount);
}
public JsonResult SetOrderToSession(int id)
{
var obj = orderService.GetByID(id);
var list = orderProductService.GetListOrderProductByOrderID(id);
bool?stt = obj.Status.HasValue ? obj.Status : false;
CurrentContext.SetAllItem().AddInfoOrder(obj.ID, obj.TableID, stt);
foreach (var p in list)
{
var item = new OrderProductItem
{
ID = p.ID,
quantity = p.Quantity,
price = decimal.Parse(p.Price.ToString()),
};
CurrentContext.SetAllItem().AddItem(item);
}
return(Json(true, JsonRequestBehavior.AllowGet));
}
private async Task CreateOrderProductItems(string orderId, string userId)
{
var productItems = this.shoppingCartItemsService.GetAllShoppingCartItems <OrderProductItemViewModel>(userId);
if (productItems == null)
{
return;
}
foreach (var productItem in productItems)
{
var orderProductItem = new OrderProductItem()
{
ProductItemId = productItem.ProductItemId,
OrderId = orderId,
Quantity = productItem.Quantity,
};
await this.orderProductItemRepository.AddAsync(orderProductItem);
await this.orderProductItemRepository.SaveChangesAsync();
}
}
public IActionResult OnGet(int?id)
{
if (id == null)
{
Order = new Order();
Order.CreatedOn = DateTime.Now;
Order.UpdatedOn = Order.CreatedOn;
Order.CreatedBy = Helpers.User.GetUPN(HttpContext);
Order.UpdatedBy = Helpers.User.GetUPN(HttpContext);
RecipeChoices = new RecipeChoicesViewModel();
OrderProductItems = new List <OrderProductItem>();
RecipeTypes = new Dictionary <string, string>(LanguageResources.RecipeTypeTranslations);
ProductDeliveryPerDay = new Dictionary <ProductDeliveryDay, Dictionary <Product, int> >();
return(Page());
}
Order = orderData.GetById(id.Value);
if (Order == null)
{
return(RedirectToPage("./List"));
}
RecipeTypes = new Dictionary <string, string>(LanguageResources.RecipeTypeTranslations);
var Recipes = recipeData.GetByName(null).ToList();
RecipeChoices = new RecipeChoicesViewModel();
// RecipeChoicesViewModel only contains a list of ChoiceViewModel items. They are the rows of the recipe quantity table.
int i = 1;
foreach (Recipe r in Recipes)
{
RecipeChoices.Choices.Add(new ChoiceViewModel()
{
Id = i++, Name = r.Name, RecipeResultingQuantity = String.Format("{0:n0}", r.ResultingQuantityInGrams),
RecipeId = r.Id, IsActive = r.IsActive, RecipeTypeId = (int)(r.RecipeType ?? RecipeType.Unknown)
});
}
// Get only recipe quantity data related to this order only - Even new orders must have been saved first so an OrderId will exist.
var orderRecipes = orderRecipeItemData.GetByName(null).Where(o => o.OrderId == Order.Id).ToList();
foreach (var c in RecipeChoices.Choices)
{
// Scan each recipe to see if a quantity for a particular days is set. For a new order this will not find anything!
foreach (var orderRecipe in orderRecipes.Where(o => o.RecipeId == c.RecipeId))
{
switch (orderRecipe.Day)
{
case OrderDay.Monday:
c.OrderQuantity_Monday = orderRecipe.Quantity;
break;
case OrderDay.Tuesday:
c.OrderQuantity_Tuesday = orderRecipe.Quantity;
break;
case OrderDay.Wednesday:
c.OrderQuantity_Wednesday = orderRecipe.Quantity;
break;
case OrderDay.Thursday:
c.OrderQuantity_Thursday = orderRecipe.Quantity;
break;
case OrderDay.Friday:
c.OrderQuantity_Friday = orderRecipe.Quantity;
break;
case OrderDay.Saturday:
c.OrderQuantity_Saturday = orderRecipe.Quantity;
break;
case OrderDay.Sunday:
c.OrderQuantity_Sunday = orderRecipe.Quantity;
break;
}
}
}
// Now that we know the quantities for each recipe we can remove those that are inactive and have 0 total quantity.
// If they have more than 0 quantity we still need to show them as they were previously chosen!
RecipeChoices.Choices.RemoveAll(c => !c.IsActive && c.TotalWeekOrderQuantity == 0);
OrderProductItems = new List <OrderProductItem>();
foreach (Recipe recipe in Recipes)
{
// SingleOrDefault is used because some inactive recipes have been excluded!
var choice = RecipeChoices.Choices.SingleOrDefault(r => r.RecipeId == recipe.Id);
if (choice == null)
{
continue;
}
// If the recipe does not have any quantities selected for any day continue...
if (choice.TotalWeekOrderQuantity == 0)
{
continue;
}
// For this recipe that we know that at least 1 quantity order for some day exists add its incredients * quantity
// to the total ingredient quantity list "OrderProductItems"
foreach (Ingredient ingredient in recipe.Ingredients)
{
OrderProductItem item = OrderProductItems.SingleOrDefault(o => o.Product.Id == ingredient.Product.Id);
if (item == null)
{
item = new OrderProductItem()
{
Product = ingredient.Product, Supplier = ingredient.Product.Supplier
};
OrderProductItems.Add(item);
}
// At this point it does not matter which day the order for this recipe is place. We only care about the weekly total!
item.Quantity += choice.TotalWeekOrderQuantity * ingredient.Quantity;
}
}
OrderProductItems = OrderProductItems.OrderBy(o => o.Product.ProductType).ThenBy(o => o.Product.Name).ToList();
// *** At this point the first sub table for the total item order is completed *** OrderProductItems is not used anymore!
// *** The more complex part of computing the order per day and supplier starts here ***
// This is the end result: A map that for each day (key) has another map as value which has productId as key and quantity as value!
Dictionary <OrderDay, Dictionary <int, int> > productQuantityOrderedPerDay = new Dictionary <OrderDay, Dictionary <int, int> >();
foreach (OrderDay day in Enum.GetValues(typeof(OrderDay)))
{
productQuantityOrderedPerDay[day] = new Dictionary <int, int>();
List <OrderRecipeItem> dayOrderRecipeItems = orderRecipes.Where(o => o.Day == day).ToList();
foreach (var orderRecipeItem in dayOrderRecipeItems)
{
foreach (var recipeIngredient in orderRecipeItem.Recipe.Ingredients)
{
productQuantityOrderedPerDay[day].TryGetValue(recipeIngredient.ProductId, out int currentIngredientQuantity);
productQuantityOrderedPerDay[day][recipeIngredient.ProductId] = currentIngredientQuantity + recipeIngredient.Quantity * orderRecipeItem.Quantity;
}
}
}
//*** We now have an object that contains per day per product the quantities needed for this order ***
// However we need a product delivery schedule per day depending on when the product is needed!
ProductDeliveryPerDay = new Dictionary <ProductDeliveryDay, Dictionary <Product, int> >();
var products = productData.GetByName(null).ToList();
foreach (OrderDay day in Enum.GetValues(typeof(OrderDay)))
{
foreach (int productId in productQuantityOrderedPerDay[day].Keys)
{
var product = products.Single(p => p.Id == productId);
//ProductDeliveryDay deliveryDay = ProductDeliveryDay.PreviousFriday;
// THIS IS NOW REMOVED!!! THIS IS REALLY CRUCIAL HERE!!! - MUST REVIEW THIS AGAIN!!!!
//if (product.OrderWindow > 0)
// deliveryDay = (ProductDeliveryDay)Math.Max((int)day - product.OrderWindow, (int)ProductDeliveryDay.PreviousFriday);
// New logic is based on delivery day as define per product:
// We search for the previous available delivery day.
ProductDeliveryDay deliveryDay = product.GetProductDeliveryDay(day);
if (!ProductDeliveryPerDay.ContainsKey(deliveryDay))
{
ProductDeliveryPerDay[deliveryDay] = new Dictionary <Product, int>();
}
ProductDeliveryPerDay[deliveryDay].TryGetValue(product, out int currentProductOrder);
ProductDeliveryPerDay[deliveryDay][product] =
currentProductOrder + productQuantityOrderedPerDay[day][productId];
}
}
return(Page());
}
public void Persist(OrderInfo order)
{
//更新平台优惠券使用次数
if (order.CouponCodeSysNo.HasValue && order.CouponCodeSysNo > 0)
{
PipelineDA.UpdateCouponCodeQuantity(order.CouponCodeSysNo.Value);
PipelineDA.UpdateSaleRulesExQuantity(order.CouponCodeSysNo.Value);
}
//更新店铺优惠券使用次数
if (order.SubOrderList != null && order.SubOrderList.Count > 0)
{
List <int> merchantCouponCodeSysNoList = new List <int>();
foreach (var subOrder in order.SubOrderList.Values)
{
if (subOrder.MerchantCouponCodeSysNo.HasValue && subOrder.MerchantCouponCodeSysNo > 0 &&
!merchantCouponCodeSysNoList.Exists(m => m == subOrder.MerchantCouponCodeSysNo.Value))
{
merchantCouponCodeSysNoList.Add(subOrder.MerchantCouponCodeSysNo.Value);
}
}
foreach (int couponCodeSysNo in merchantCouponCodeSysNoList)
{
PipelineDA.UpdateCouponCodeQuantity(couponCodeSysNo);
PipelineDA.UpdateSaleRulesExQuantity(couponCodeSysNo);
}
}
//生成购物车编号
order.ShoppingCartID = PipelineDA.GenerateSOSysNo().ToString();
foreach (var subOrder in order.SubOrderList.Values)
{
subOrder.ID = PipelineDA.GenerateSOSysNo();
subOrder.ShoppingCartID = order.ShoppingCartID;
subOrder.InDate = DateTime.Now;
subOrder["Note"] = string.Empty;//订单日志
subOrder["IsUsePrepay"] = (subOrder.BalancePayAmount > 0m) ? 1 : 0;
PipelineDA.CreateShoppingCart(subOrder); //Create SO ShoppingCart
PipelineDA.CreateSOMaster(subOrder); //Create SOMaster
#region SO Item
List <OrderItem> subOrderItemList = new List <OrderItem>();
subOrder.OrderItemGroupList.ForEach(orderGroup =>
{
orderGroup.ProductItemList.ForEach(proItem =>
{
proItem["SpecialActivityType"] = proItem.SpecialActivityType;
proItem["SOSysNo"] = subOrder.ID;
proItem["GiftSysNo"] = null;
proItem["ProductType"] = (int)SOItemType.ForSale;
proItem["MasterProductCode"] = null;
proItem["Quantity"] = proItem.UnitQuantity;
proItem["Point"] = proItem.UnitRewardedPoint;
proItem["DiscountAmt"] = (decimal)proItem["UnitDiscountAmt"];
//总优惠券均摊金额，正数
proItem["PromotionDiscount"] = (decimal)proItem["UnitCouponAmt"];
//平台优惠券均摊金额，正数
proItem["PlatPromotionDiscount"] = (decimal)proItem["UnitCouponAmt"] - (proItem["MerchantUnitCouponAmt"] == null ? 0m : (decimal)proItem["MerchantUnitCouponAmt"]);
proItem["Price"] = proItem.UnitSalePrice - (decimal)proItem["UnitCouponAmt"]; //-(decimal)proItem["UnitDiscountAmt"];
subOrderItemList.Add(proItem);
});
});
subOrder.AttachmentItemList.ForEach(proItem =>
{
proItem["SpecialActivityType"] = 0;
proItem["SOSysNo"] = subOrder.ID;
proItem["GiftSysNo"] = null;
proItem["ProductType"] = (int)SOItemType.HiddenGift;
proItem["MasterProductCode"] = null;
proItem["Quantity"] = proItem.UnitQuantity;
proItem["Price"] = 0;
proItem["Point"] = proItem.UnitRewardedPoint;
proItem["DiscountAmt"] = decimal.Zero;
proItem["PromotionDiscount"] = 0;
subOrderItemList.Add(proItem);
});
subOrder.GiftItemList.ForEach(proItem =>
{
proItem["SpecialActivityType"] = 0;
proItem["SOSysNo"] = subOrder.ID;
proItem["GiftSysNo"] = proItem.ActivityNo;
proItem["ProductType"] = (int)SOItemType.Gift;
proItem["MasterProductCode"] = null;
proItem["Quantity"] = proItem.UnitQuantity;
proItem["Price"] = 0;
proItem["Point"] = proItem.UnitRewardedPoint;
proItem["DiscountAmt"] = decimal.Zero;
proItem["PromotionDiscount"] = 0;
if (proItem.SaleGiftType == SaleGiftType.Vendor)
{
proItem["ProductType"] = (int)SOItemType.Gift;
}
else
{
proItem["ProductType"] = SOItemType.ActivityGift; //新蛋赠品(除厂商赠品外以前统一为新的赠品)
}
subOrderItemList.Add(proItem);
});
//平台
if (subOrder.CouponCodeSysNo.HasValue && subOrder.CouponCodeSysNo > 0)
{
OrderProductItem item = new OrderProductItem();
item["SOSysNo"] = subOrder.ID;
item.ProductSysNo = subOrder.CouponCodeSysNo.Value;
item.ProductName = string.Format("【平台优惠券】{0}({1})", subOrder.CouponName, subOrder.CouponCode);
item["GiftSysNo"] = null;
item["ProductType"] = (int)SOItemType.Promotion; //优惠券
item["MasterProductCode"] = null;
item.Weight = 0;
item["Quantity"] = 1;
item["ProductType"] = SOItemType.Promotion;
item["Price"] = decimal.Zero;
item.UnitCostPrice = decimal.Zero;
item["Point"] = 0;
item["DiscountAmt"] = decimal.Zero;
item["UnitDiscountAmt"] = 0m;
item["PromotionDiscount"] = 0;
item.UnitSalePrice = (-1) * (subOrder.CouponAmount - subOrder.MerchantCouponAmount);
item.WarehouseNumber = 0;
item.WarehouseName = string.Empty;
//item["TariffCode"] = null;//关税代码
// item["TariffRate"] = null;//单个关税
// item["EntryRecord"] = null;//报关编号
item["ProductStoreType"] = null; //储存运输方式
subOrderItemList.Add(item);
}
//商家
if (subOrder.MerchantCouponCodeSysNo.HasValue && subOrder.MerchantCouponCodeSysNo > 0)
{
OrderProductItem item = new OrderProductItem();
item["SOSysNo"] = subOrder.ID;
item.ProductSysNo = subOrder.MerchantCouponCodeSysNo.Value;
item.ProductName = string.Format("【商家优惠券】{0}({1})", subOrder.MerchantCouponName, subOrder.MerchantCouponCode);
item["GiftSysNo"] = null;
item["ProductType"] = (int)SOItemType.Promotion; //优惠券
item["MasterProductCode"] = null;
item.Weight = 0;
item["Quantity"] = 1;
item["ProductType"] = SOItemType.Promotion;
item["Price"] = decimal.Zero;
item.UnitCostPrice = decimal.Zero;
item["Point"] = 0;
item["DiscountAmt"] = decimal.Zero;
item["UnitDiscountAmt"] = 0m;
item["PromotionDiscount"] = 0;
item.UnitSalePrice = (-1) * subOrder.MerchantCouponAmount;
item.WarehouseNumber = 0;
item.WarehouseName = string.Empty;
//item["TariffCode"] = null;//关税代码
//item["TariffRate"] = null;//单个关税
//item["EntryRecord"] = null;//报关编号
item["ProductStoreType"] = null; //储存运输方式
subOrderItemList.Add(item);
}
#endregion
subOrderItemList.ForEach(item =>
{
//货币、当时汇率
item["CurrencySysNo"] = order["CurrencySysNo"];
item["ExchangeRate"] = order["ExchangeRate"];
var productType = (int)item["ProductType"];
if (productType == 0 || productType == 1 || productType == 2 || productType == 5 || productType == 6)
{
var GiftSysNo = item["GiftSysNo"]; //赠品
var SpecialActivityType = (int)item["SpecialActivityType"]; // 1=团购商品；2=抢购商品；3-虚拟团购商品
var DiscountAmt = (decimal)item["DiscountAmt"]; //捆绑的折扣
if (ConstValue.PaymentInventory)
{
#region
////赠品
//if (GiftSysNo != null)
//{
// //create soitem
// PipelineDA.CreateSOItem(item);
// //so item log
// subOrder["Note"] += string.Format("SysNo:{0}, Qty:{1}, Price:{2};", item.ProductSysNo, item["Quantity"], item["Price"]);
//}
////团购
//else if (SpecialActivityType != 0 && SpecialActivityType == 1)
//{
// //create soitem
// PipelineDA.CreateSOItem(item);
// //so item log
// subOrder["Note"] += string.Format("SysNo:{0}, Qty:{1}, Price:{2};", item.ProductSysNo, item["Quantity"], item["Price"]);
//}
#endregion
//限时促销
if (SpecialActivityType != 0 && SpecialActivityType == 2 && PipelineDA.CheckCountDownByProductSysNo(item.ProductSysNo))
{
//create soitem
PipelineDA.CreateSOItem(item);
//so item log
subOrder["Note"] += string.Format("SysNo:{0}, Qty:{1}, Price:{2};", item.ProductSysNo, item["Quantity"], item["Price"]);
}
else
{
//扣减订单商品库存
int inventoryType = PipelineDA.GetInventoryType(item);
var rowCount = PipelineDA.UpdateInventory(item);
if (rowCount != 1 && inventoryType != 1 && inventoryType != 3 && inventoryType != 5)
{
ECommerce.Utility.Logger.WriteLog("inventory: qty is not enough", "SOPipeline.CreateSOBasicPersister");
throw new BusinessException(string.Format("商品【{0}】库存不足", item.ProductName));
}
rowCount = PipelineDA.UpdateInventoryStock(item);
if (rowCount != 1 && inventoryType != 1 && inventoryType != 3 && inventoryType != 5)
{
ECommerce.Utility.Logger.WriteLog("inventory_stock: qty is not enough", "SOPipeline.CreateSOBasicPersister");
throw new BusinessException(string.Format("商品【{0}】库存不足", item.ProductName));
}
//create soitem
PipelineDA.CreateSOItem(item);
//so item log
subOrder["Note"] += string.Format("SysNo:{0}, Qty:{1}, Price:{2};", item.ProductSysNo, item["Quantity"], item["Price"]);
}
#region 所有促销活动都开启支付完成后扣减库存
////正常品
//if (GiftSysNo == null && SpecialActivityType == 0 && !PipelineDA.CheckGiftSaleListByProductSysNo(item.ProductSysNo) && DiscountAmt == 0)
//{
// //扣减订单商品库存
// int inventoryType = PipelineDA.GetInventoryType(item);
// var rowCount = PipelineDA.UpdateInventory(item);
// if (rowCount != 1 && inventoryType != 1 && inventoryType != 3 && inventoryType != 5)
// {
// ECommerce.Utility.Logger.WriteLog("inventory: qty is not enough", "SOPipeline.CreateSOBasicPersister");
// throw new BusinessException(string.Format("商品【{0}】库存不足", item.ProductName));
// }
// rowCount = PipelineDA.UpdateInventoryStock(item);
// if (rowCount != 1 && inventoryType != 1 && inventoryType != 3 && inventoryType != 5)
// {
// ECommerce.Utility.Logger.WriteLog("inventory_stock: qty is not enough", "SOPipeline.CreateSOBasicPersister");
// throw new BusinessException(string.Format("商品【{0}】库存不足", item.ProductName));
// }
// //create soitem
// PipelineDA.CreateSOItem(item);
// //so item log
// subOrder["Note"] += string.Format("SysNo:{0}, Qty:{1}, Price:{2};", item.ProductSysNo, item["Quantity"], item["Price"]);
//}
////赠品，团购，限时促销，捆绑商品
//else
//{
// //create soitem
// PipelineDA.CreateSOItem(item);
// //so item log
// subOrder["Note"] += string.Format("SysNo:{0}, Qty:{1}, Price:{2};", item.ProductSysNo, item["Quantity"], item["Price"]);
//}
#endregion
}
else
{
//扣减订单商品库存
int inventoryType = PipelineDA.GetInventoryType(item);
var rowCount = PipelineDA.UpdateInventory(item);
if (rowCount != 1 && inventoryType != 1 && inventoryType != 3 && inventoryType != 5)
{
ECommerce.Utility.Logger.WriteLog("inventory: qty is not enough", "SOPipeline.CreateSOBasicPersister");
throw new BusinessException(string.Format("商品【{0}】库存不足", item.ProductName));
}
rowCount = PipelineDA.UpdateInventoryStock(item);
if (rowCount != 1 && inventoryType != 1 && inventoryType != 3 && inventoryType != 5)
{
ECommerce.Utility.Logger.WriteLog("inventory_stock: qty is not enough", "SOPipeline.CreateSOBasicPersister");
throw new BusinessException(string.Format("商品【{0}】库存不足", item.ProductName));
}
//create soitem
PipelineDA.CreateSOItem(item);
//so item log
subOrder["Note"] += string.Format("SysNo:{0}, Qty:{1}, Price:{2};", item.ProductSysNo, item["Quantity"], item["Price"]);
}
}
else if (productType == 3)
{
//create soitem
PipelineDA.CreateSOItem(item);
subOrder["Note"] += string.Format("PromotionSysNo:{0}, Qty:{1}, Price:{2};", item.ProductSysNo, item["Quantity"], item["Price"]);
}
});
}
}
public void Calculate(ref OrderInfo order)
{
CalculateDiscountAmount(order);
Dictionary <int, List <OrderInfo> > merchantOrderList = new Dictionary <int, List <OrderInfo> >();
#region 1、分拆商家订单
if (order.SubOrderList != null)
{
foreach (var subOrder in order.SubOrderList)
{
int merchantSysNo = Convert.ToInt32(subOrder.Key.Split('|')[0]);
if (!merchantOrderList.ContainsKey(merchantSysNo))
{
merchantOrderList[merchantSysNo] = new List <OrderInfo>();
}
merchantOrderList[merchantSysNo].Add(subOrder.Value);
}
}
#endregion
#region 2、计算商家优惠券
List <CustomerCouponInfo> merchantCouponList = PromotionDA.GetMerchantCouponCodeList(order.Customer.SysNo);
if (merchantCouponList != null)
{
foreach (var merchantOrder in merchantOrderList)
{
List <CustomerCouponInfo> currMerchantCouponList = merchantCouponList.FindAll(m => m.MerchantSysNo == merchantOrder.Key);
if (currMerchantCouponList == null || currMerchantCouponList.Count == 0)
{
continue;
}
foreach (var coupon in currMerchantCouponList)
{
bool canUse = false;
#region 检查商品限制，是否可用
List <int> productSysNoList = new List <int>();
foreach (var itemOrder in merchantOrder.Value)
{
foreach (var itemGroup in itemOrder.OrderItemGroupList)
{
itemGroup.ProductItemList.ForEach(product =>
{
productSysNoList.Add(product.ProductSysNo);
});
}
}
List <CouponSaleRules> couponSaleRulesList = PromotionDA.GetCouponSaleRulesList(coupon.CouponCode);
if (couponSaleRulesList == null || couponSaleRulesList.Count == 0)
{
//不存在排除或指定商品，全网通用
canUse = true;
}
else
{
foreach (int productSysNo in productSysNoList)
{
if (couponSaleRulesList.Exists(m => m.ProductSysNo == productSysNo))
{
if (couponSaleRulesList[0].RelationType == "N")
{
//存在排除的商品，不可用
canUse = false;
break;
}
else
{
//存在指定的商品，可用
canUse = true;
break;
}
}
}
}
#endregion
if (canUse)
{
if (CheckCouponCodeCanUse(coupon.CouponCode, order.Customer))
{
foreach (var itemOrder in merchantOrder.Value)
{
if (itemOrder.MerchantCouponList == null)
{
itemOrder.MerchantCouponList = new List <CustomerCouponInfo>();
}
itemOrder.MerchantCouponList.Add(coupon);
}
}
}
}
}
}
#endregion
#region 3、商家订单使用优惠券
foreach (var merchantOrder in merchantOrderList)
{
MerchantCoupon merchantCoupon = null;
if (order.MerchantCouponCodeList != null)
{
merchantCoupon = order.MerchantCouponCodeList.Find(m => m.MerchantSysNo == merchantOrder.Key);
}
if (merchantCoupon == null)
{
continue;
}
string couponCode = merchantCoupon.CouponCode.ToUpper().Trim();
#region 1、初次筛选该优惠券号码对于前用户是否能用
CustomerCouponInfo customerCoupon = PromotionDA.GetCouponSaleRules(order.Customer.SysNo, couponCode);
if (customerCoupon == null)
{
SetCouponError(ref order, LanguageHelper.GetText("您没有此优惠券{0}", order.LanguageCode), merchantCoupon.CouponName);
continue;
}
if (customerCoupon.IsExpired)
{
SetCouponError(ref order, LanguageHelper.GetText("此优惠券{0}已过期", order.LanguageCode), merchantCoupon.CouponName);
continue;
}
if (customerCoupon.CustomerMaxFrequency.HasValue && customerCoupon.UsedCount >= customerCoupon.CustomerMaxFrequency.Value)
{
SetCouponError(ref order, LanguageHelper.GetText("您已达到使用优惠券{0}的次数上限", order.LanguageCode), merchantCoupon.CouponName);
continue;
}
int totalUsedCount = 0;
if (customerCoupon.CodeType.Trim().ToUpper() == "C")
{
totalUsedCount = PromotionDA.GetCouponCodeTotalUsedCount(couponCode);
}
else
{
totalUsedCount = PromotionDA.GetCouponTotalUsedCount(customerCoupon.CouponSysNo);
}
if (customerCoupon.WebsiteMaxFrequency.HasValue && totalUsedCount >= customerCoupon.WebsiteMaxFrequency)
{
SetCouponError(ref order, LanguageHelper.GetText("此优惠券{0}的已达到全网使用次数上限", order.LanguageCode), merchantCoupon.CouponName);
continue;
}
#endregion
#region 2、获取该优惠券号码对应的优惠券活动所有信息
CouponInfo coupon = PromotionDA.GetComboInfoByCouponCode(couponCode);
if (coupon.SaleRulesEx.CustomerMaxFrequency.HasValue && customerCoupon.UsedCount >= coupon.SaleRulesEx.CustomerMaxFrequency.Value)
{
SetCouponError(ref order, LanguageHelper.GetText("您已达到使用此优惠券活动的次数上限", order.LanguageCode));
continue;
}
if (coupon.SaleRulesEx.MaxFrequency.HasValue && totalUsedCount >= coupon.SaleRulesEx.MaxFrequency.Value)
{
SetCouponError(ref order, LanguageHelper.GetText("此优惠券活动已达到全网使用次数上限", order.LanguageCode));
continue;
}
if (coupon == null)
{
SetCouponError(ref order, LanguageHelper.GetText("此优惠券{0}不存在", order.LanguageCode), merchantCoupon.CouponName);
continue;
}
#endregion
#region 3、详细检查该优惠券号码是否可用
if (!string.IsNullOrWhiteSpace(coupon.SaleRulesEx.NeedEmailVerification) && coupon.SaleRulesEx.NeedEmailVerification.ToUpper().Trim() == "Y")
{
if (order.Customer.IsEmailConfirmed != 1)
{
SetCouponError(ref order, LanguageHelper.GetText("此优惠券要求客户验证了电子邮箱才可使用！", order.LanguageCode));
continue;
}
}
if (!string.IsNullOrWhiteSpace(coupon.SaleRulesEx.NeedMobileVerification) && coupon.SaleRulesEx.NeedMobileVerification.ToUpper().Trim() == "Y")
{
if (order.Customer.IsPhoneValided != 1)
{
SetCouponError(ref order, LanguageHelper.GetText("此优惠券要求客户验证了手机才可使用！", order.LanguageCode));
continue;
}
}
if (coupon.SaleRulesList.Count > 0 && coupon.SaleRulesList.Exists(f => f.SaleRuleType == CouponSaleRuleType.RelCustomerRank))
{
//-1表示不限制
if (!coupon.SaleRulesList.Exists(f => f.CustomerRank == -1))
{
int customerRank = order.Customer.CustomerRank;
if (!coupon.SaleRulesList.Exists(f => f.CustomerRank == customerRank))
{
SetCouponError(ref order, LanguageHelper.GetText("当前客户不满足此优惠券要求的客户等级！", order.LanguageCode));
continue;
}
}
}
if (coupon.SaleRulesList.Count > 0 && coupon.SaleRulesList.Exists(f => f.SaleRuleType == CouponSaleRuleType.RelArea))
{
int areaID = order.Contact.AddressAreaID;
Area area = PromotionDA.GetAreaBySysNo(areaID);
int provinceId = area.ProvinceSysNo.Value;
if (!coupon.SaleRulesList.Exists(f => f.SaleRuleType == CouponSaleRuleType.RelArea && f.AreaSysNo == provinceId))
{
SetCouponError(ref order, LanguageHelper.GetText("当前客户不满足此优惠券要求的客户地区！", order.LanguageCode));
continue;
}
}
#endregion
#region 4、计算该优惠券可以抵扣多少，填充到OrderInfo中
if (coupon.DiscountRuleList != null && coupon.DiscountRuleList.Count > 0)
{
//取得满足优惠券条件的商品总金额
decimal canCalculateAmount = GetCanCalculateAmount(merchantOrder.Value, coupon);
if (canCalculateAmount == 0)
{
SetCouponError(ref order, LanguageHelper.GetText("没有满足该优惠券的商品，无法抵扣", order.LanguageCode));
continue;
}
canCalculateAmount = canCalculateAmount - Math.Abs(order.TotalDiscountAmount);
if (canCalculateAmount < coupon.SaleRulesEx.OrderAmountLimit)
{
SetCouponError(ref order, LanguageHelper.GetText("没有满足该优惠券要求的商品总金额下限{0}，无法抵扣", order.LanguageCode), coupon.SaleRulesEx.OrderAmountLimit);
continue;
}
decimal totalPriceAmount = (merchantOrder.Value.Sum(m => m.TotalProductAmount) - merchantOrder.Value.Sum(m => m.TotalDiscountAmount));
#region 处理订单 折扣金额模式 和 百分比模式
if (coupon.DiscountRuleList[0].DiscountType == CouponDiscountType.OrderAmountDiscount || coupon.DiscountRuleList[0].DiscountType == CouponDiscountType.OrderAmountPercentage)
{
//获取适合的折扣规则
Coupon_DiscountRules curDiscountRule = GetMatchDiscountRule(coupon, canCalculateAmount);
if (curDiscountRule == null)
{
SetCouponError(ref order, LanguageHelper.GetText("订单总金额未达到优惠券要求的最小购买金额，无法抵扣", order.LanguageCode));
return;
}
decimal discount = 0m;
if (curDiscountRule.DiscountType == CouponDiscountType.OrderAmountDiscount)
{
discount = Math.Abs(Math.Round(curDiscountRule.Value, 2));
}
else
{
discount = Math.Abs(Math.Round(canCalculateAmount * curDiscountRule.Value, 2));
}
if (coupon.SaleRulesEx.OrderMaxDiscount.HasValue && coupon.SaleRulesEx.OrderMaxDiscount.Value > 0m)
{
if (discount > coupon.SaleRulesEx.OrderMaxDiscount.Value)
{
discount = coupon.SaleRulesEx.OrderMaxDiscount.Value;
}
}
foreach (var subOrder in merchantOrder.Value)
{
subOrder.MerchantCouponCodeSysNo = customerCoupon.CouponCodeSysNo;
subOrder.MerchantCouponCode = customerCoupon.CouponCode;
subOrder.MerchantCouponSysNo = customerCoupon.CouponSysNo;
subOrder.MerchantCouponName = customerCoupon.CouponName;
subOrder.MerchantCouponAmount = discount * ((subOrder.TotalProductAmount - subOrder.TotalDiscountAmount) / totalPriceAmount);
subOrder.MerchantCouponErrorDesc = string.Empty;
foreach (var itemGroup in subOrder.OrderItemGroupList)
{
foreach (var item in itemGroup.ProductItemList)
{
item["UnitCouponAmt"] = (discount * (item.UnitSalePrice - (item["UnitDiscountAmt"] == null ? 0m :(decimal)item["UnitDiscountAmt"])))
/ totalPriceAmount;
item["MerchantUnitCouponAmt"] = (discount * (item.UnitSalePrice - (item["UnitDiscountAmt"] == null ? 0m : (decimal)item["UnitDiscountAmt"])))
/ totalPriceAmount;
}
}
}
}
#endregion
#region 处理 一个商品直减模式
if (coupon.DiscountRuleList[0].DiscountType == CouponDiscountType.ProductPriceDiscount)
{
if (coupon.SaleRulesList == null || coupon.SaleRulesList.Count == 0)
{
SetCouponError(ref order, LanguageHelper.GetText("没有满足该优惠券的指定商品，无法抵扣", order.LanguageCode));
return;
}
Coupon_SaleRules productSaleRule = coupon.SaleRulesList.Find(f => f.SaleRuleType == CouponSaleRuleType.RelProduct);
int discountProductSysNo = productSaleRule.ProductSysNo;
int discountProductCount = 0;
decimal productReduce = 0m;
decimal productPrice = 0.00m;
foreach (OrderItemGroup itemGroup in order.OrderItemGroupList)
{
OrderProductItem item = itemGroup.ProductItemList.Find(f => f.ProductSysNo == discountProductSysNo);
if (item != null)
{
discountProductCount += item.UnitQuantity * itemGroup.Quantity;
productPrice = item.UnitSalePrice;
}
}
if (discountProductCount == 0)
{
SetCouponError(ref order, LanguageHelper.GetText("没有满足该优惠券的指定商品，无法抵扣", order.LanguageCode));
return;
}
if (discountProductCount > coupon.DiscountRuleList[0].Quantity)
{
discountProductCount = coupon.DiscountRuleList[0].Quantity;
}
productReduce = coupon.DiscountRuleList[0].Value;
if (coupon.DiscountRuleList[0].Value > productPrice)
{
productReduce = productPrice;
}
decimal discount = Math.Abs(Math.Round(productReduce * discountProductCount, 2));
if (coupon.SaleRulesEx.OrderMaxDiscount.HasValue && coupon.SaleRulesEx.OrderMaxDiscount.Value > 0m)
{
if (discount > coupon.SaleRulesEx.OrderMaxDiscount.Value)
{
discount = coupon.SaleRulesEx.OrderMaxDiscount.Value;
}
}
foreach (var subOrder in merchantOrder.Value)
{
subOrder.MerchantCouponCodeSysNo = customerCoupon.CouponCodeSysNo;
subOrder.MerchantCouponCode = customerCoupon.CouponCode;
subOrder.MerchantCouponSysNo = customerCoupon.CouponSysNo;
subOrder.MerchantCouponName = customerCoupon.CouponName;
subOrder.MerchantCouponAmount = discount * ((subOrder.TotalProductAmount - subOrder.TotalDiscountAmount) / totalPriceAmount);
subOrder.MerchantCouponErrorDesc = string.Empty;
subOrder["MerchantCoupon_DiscountProductSysNo"] = discountProductSysNo;
subOrder["MerchantCoupon_DiscountProductCount"] = discountProductCount;
foreach (var itemGroup in subOrder.OrderItemGroupList)
{
foreach (var item in itemGroup.ProductItemList)
{
item["UnitCouponAmt"] = (discount * (item.UnitSalePrice - (item["UnitDiscountAmt"] == null ? 0m : (decimal)item["UnitDiscountAmt"])))
/ totalPriceAmount;
item["MerchantUnitCouponAmt"] = (discount * (item.UnitSalePrice - (item["UnitDiscountAmt"] == null ? 0m : (decimal)item["UnitDiscountAmt"])))
/ totalPriceAmount;
}
}
}
}
#endregion
#region 处理 一个商品最终售价模式
if (coupon.DiscountRuleList[0].DiscountType == CouponDiscountType.ProductPriceFinal)
{
if (coupon.SaleRulesList == null || coupon.SaleRulesList.Count == 0)
{
SetCouponError(ref order, LanguageHelper.GetText("没有满足该优惠券的指定商品，无法抵扣", order.LanguageCode));
return;
}
Coupon_SaleRules productSaleRule = coupon.SaleRulesList.Find(f => f.SaleRuleType == CouponSaleRuleType.RelProduct);
int discountProductSysNo = productSaleRule.ProductSysNo;
decimal discountProductPrice = 0.00m;
int discountProductCount = 0;
foreach (var currOrder in merchantOrder.Value)
{
foreach (OrderItemGroup itemGroup in currOrder.OrderItemGroupList)
{
OrderProductItem item = itemGroup.ProductItemList.Find(f => f.ProductSysNo == discountProductSysNo);
if (item != null)
{
discountProductCount += item.UnitQuantity * itemGroup.Quantity;
discountProductPrice = item.UnitSalePrice;
}
}
}
if (discountProductCount == 0)
{
SetCouponError(ref order, LanguageHelper.GetText("没有满足该优惠券的指定商品,无法抵扣", order.LanguageCode));
return;
}
if (discountProductCount > coupon.DiscountRuleList[0].Quantity)
{
discountProductCount = coupon.DiscountRuleList[0].Quantity;
}
decimal discount = 0m;
if (discountProductPrice > coupon.DiscountRuleList[0].Value)
{
discount = Math.Abs(Math.Round((discountProductPrice - coupon.DiscountRuleList[0].Value) * discountProductCount, 2));
}
else
{
SetCouponError(ref order, LanguageHelper.GetText("该优惠券的指定商品已经是优惠券设定的最低价格,无法抵扣", order.LanguageCode));
return;
}
if (coupon.SaleRulesEx.OrderMaxDiscount.HasValue && coupon.SaleRulesEx.OrderMaxDiscount.Value > 0m)
{
if (discount > coupon.SaleRulesEx.OrderMaxDiscount.Value)
{
discount = coupon.SaleRulesEx.OrderMaxDiscount.Value;
}
}
foreach (var subOrder in merchantOrder.Value)
{
subOrder.MerchantCouponCodeSysNo = customerCoupon.CouponCodeSysNo;
subOrder.MerchantCouponCode = customerCoupon.CouponCode;
subOrder.MerchantCouponSysNo = customerCoupon.CouponSysNo;
subOrder.MerchantCouponName = customerCoupon.CouponName;
subOrder.MerchantCouponAmount = discount * ((subOrder.TotalProductAmount - subOrder.TotalDiscountAmount) / totalPriceAmount);
subOrder.MerchantCouponErrorDesc = string.Empty;
subOrder["MerchantCoupon_DiscountProductSysNo"] = discountProductSysNo;
subOrder["MerchantCoupon_DiscountProductCount"] = discountProductCount;
foreach (var itemGroup in subOrder.OrderItemGroupList)
{
foreach (var item in itemGroup.ProductItemList)
{
item["UnitCouponAmt"] = (discount * (item.UnitSalePrice - (item["UnitDiscountAmt"] == null ? 0m : (decimal)item["UnitDiscountAmt"])))
/ totalPriceAmount;
item["MerchantUnitCouponAmt"] = (discount * (item.UnitSalePrice - (item["UnitDiscountAmt"] == null ? 0m : (decimal)item["UnitDiscountAmt"])))
/ totalPriceAmount;
}
}
}
}
#endregion
foreach (var subOrder in merchantOrder.Value)
{
subOrder["MerchantCoupon_DiscountType"] = coupon.DiscountRuleList[0].DiscountType;
}
}
#endregion
}
#endregion
}
/// <summary>
/// 加够商品转换为主商品
/// </summary>
/// <param name="productSysNo">商品编号</param>
/// <param name="customerSysNo">用户编号</param>
/// <returns></returns>
private OrderItemGroup PlusPriceConvertToProduct(OrderGiftItem plusPrice, int customerSysNo)
{
OrderItemGroup result = new OrderItemGroup();
OrderProductItem productItem = new OrderProductItem();
productItem.ProductSysNo = plusPrice.ProductSysNo;
//商品基础信息
ProductBasicInfo basicInfo = PipelineDA.GetProductBasicInfoBySysNo(productItem.ProductSysNo);
//商品备案信息
ProductEntryInfo entryInfo = PipelineDA.GetProductEntryInfoBySysNo(productItem.ProductSysNo);
basicInfo.ProductEntryInfo = entryInfo;
productItem["ProductStoreType"] = (int)entryInfo.ProductStoreType;
//商品备货时间
productItem["LeadTimeDays"] = basicInfo.ProductEntryInfo.LeadTimeDays;
//商品销售信息
ProductSalesInfo salesInfo = PipelineDA.GetProductSalesInfoBySysNo(productItem.ProductSysNo);
productItem.ProductID = basicInfo.Code;
productItem.ProductName = basicInfo.ProductName;
productItem.Weight = basicInfo.Weight;
productItem["ProductTitle"] = basicInfo.ProductTitle;
productItem.DefaultImage = basicInfo.DefaultImage;
productItem.UnitMarketPrice = salesInfo.MarketPrice;
productItem.UnitCostPrice = salesInfo.UnitCostPrice;
productItem.UnitSalePrice = plusPrice.UnitSalePrice;
productItem.UnitRewardedPoint = 0;
//productItem["TariffRate"] = basicInfo.ProductEntryInfo.TariffRate;
productItem.TotalInventory = salesInfo.OnlineQty;
productItem.MerchantSysNo = basicInfo.VendorSysno;
productItem.MerchantName = basicInfo.VendorInfo.VendorName;
result.MerchantSysNo = basicInfo.VendorSysno;
result.MerchantName = basicInfo.VendorInfo.VendorName;
productItem["ProductStatus"] = (int)basicInfo.ProductStatus;
productItem["Warranty"] = basicInfo.Warranty;
productItem.WarehouseNumber = plusPrice.WarehouseNumber;
productItem.WarehouseName = plusPrice.WarehouseName;
productItem.WarehouseCountryCode = plusPrice.WarehouseCountryCode;
salesInfo.MinCountPerOrder = salesInfo.OnlineQty < productItem.UnitQuantity ? salesInfo.OnlineQty : productItem.UnitQuantity;
salesInfo.MaxCountPerOrder = salesInfo.OnlineQty < productItem.UnitQuantity ? salesInfo.OnlineQty : productItem.UnitQuantity;
productItem["MinCountPerOrder"] = productItem.UnitQuantity;
productItem["MaxCountPerOrder"] = productItem.UnitQuantity;
result.MinCountPerSO = productItem.UnitQuantity;
result.MaxCountPerSO = productItem.UnitQuantity;
result.MerchantSysNo = productItem.MerchantSysNo;
result.MerchantName = productItem.MerchantName;
result.PackageNo = 0;
result.PackageType = 0;
result.Quantity = 1;
//商品分组属性
List <ProductSplitGroupProperty> splitGroupProperty = PipelineDA.GetProductSplitGroupPropertyList(productItem.ProductSysNo);
if (splitGroupProperty != null && splitGroupProperty.Count > 0)
{
productItem.SplitGroupPropertyDescList = new List <KeyValuePair <string, string> >();
foreach (ProductSplitGroupProperty property in splitGroupProperty)
{
productItem.SplitGroupPropertyDescList.Add(new KeyValuePair <string, string>(property.PropertyDescription, property.ValueDescription));
}
}
result.ProductItemList = new List <OrderProductItem>();
result.ProductItemList.Add(productItem);
return(result);
}
public void Calculate(ref OrderInfo orderInfo)
{
Dictionary <string, OrderInfo> subOrderInfoList = new Dictionary <string, OrderInfo>();
#region 【 将加够商品合并至主商品 】
foreach (var plusPriceItem in orderInfo.PlusPriceItemList)
{
if (plusPriceItem.IsSelect)
{
orderInfo.OrderItemGroupList.Add(PlusPriceConvertToProduct(plusPriceItem, orderInfo.Customer.SysNo));
}
}
#endregion
#region 【 先处理主商品 】
List <OrderProductItem> masterItemList = new List <OrderProductItem>();
if (orderInfo.OrderItemGroupList != null)
{
foreach (var itemGroup in orderInfo.OrderItemGroupList)
{
if (itemGroup.ProductItemList != null)
{
itemGroup.ProductItemList.ForEach(masterItem =>
{
//将主商品拆分到最细粒度，即一个商品一个OrderProductItem
for (int i = 0; i < masterItem.UnitQuantity * itemGroup.Quantity; i++)
{
OrderProductItem cloneItem = (OrderProductItem)masterItem.Clone();
cloneItem.UnitQuantity = 1;
//设置商品上的套餐号和套餐类型，很别扭,先这样吧，下个项目再修改 at 【2014-08-08 13:25:43】
cloneItem["PackageNo"] = itemGroup.PackageNo;
cloneItem["PackageType"] = itemGroup.PackageType;
masterItemList.Add(cloneItem);
}
});
}
}
}
//先初步按照 供应商+仓库+存储运输方式 拆分
Dictionary <string, List <OrderProductItem> > dicMasterItemPreSplitResult = GetMainItemSplitResult(masterItemList);
Dictionary <string, List <OrderProductItem> > dicSubOrderMasterItemResult = new Dictionary <string, List <OrderProductItem> >();
//取得每单最大限制金额
Dictionary <string, decimal> maxPerOrderAmountConfig = GetMaxPerOrderAmountConfig();
foreach (var kvs in dicMasterItemPreSplitResult)
{
kvs.Value.Sort((item1, item2) =>
{
return((item1.TotalSalePrice).CompareTo(item2.TotalSalePrice));
});
//单个订单金额拆分规则
string warehouseCountryCode = string.IsNullOrEmpty(kvs.Value[0].WarehouseCountryCode) ? string.Empty :
kvs.Value[0].WarehouseCountryCode;
decimal maxPerOrderAmount = decimal.MaxValue;
if (maxPerOrderAmountConfig.ContainsKey(warehouseCountryCode.ToUpper().Trim()))
{
maxPerOrderAmount = maxPerOrderAmountConfig[warehouseCountryCode.ToUpper().Trim()];
}
decimal shoppingItemPriceSum = 0;
string thisKey = string.Empty;
List <OrderProductItem> thisGroupMasterItemList = new List <OrderProductItem>();
//根据每单最大购买金额进行一次拆单
foreach (OrderProductItem masterItem in kvs.Value)
{
decimal currentItemAmtSum = masterItem.TotalSalePrice;
//判断当前订单金额是否大于出库地区每单最大金额
if (shoppingItemPriceSum + currentItemAmtSum > maxPerOrderAmount)
{
//如果大于出库地区每单最大金额，并且主商品分组为空的话，那么当前单商品金额就已经超出
//最大购买金额，单商品自成一单
if (thisGroupMasterItemList.Count <= 0)
{
shoppingItemPriceSum = masterItem.TotalSalePrice;
thisGroupMasterItemList.Add(masterItem);
//根据订单金额重新计算一次key值
thisKey = GetSubOrderKey(kvs.Key, shoppingItemPriceSum, dicSubOrderMasterItemResult);
dicSubOrderMasterItemResult[thisKey] = thisGroupMasterItemList;
shoppingItemPriceSum = currentItemAmtSum;
thisGroupMasterItemList = new List <OrderProductItem>();
}
else
{
//主商品分组合并组成一个子单，清空之前的主商品分组，并且将当前主商品加入到分组中
//根据订单金额重新计算一次key值
thisKey = GetSubOrderKey(kvs.Key, shoppingItemPriceSum, dicSubOrderMasterItemResult);
dicSubOrderMasterItemResult[thisKey] = thisGroupMasterItemList;
shoppingItemPriceSum = currentItemAmtSum;
thisGroupMasterItemList = new List <OrderProductItem>()
{
masterItem
};
}
}
else
{
//金额没有超过最大购买金额，将当前主商品加入到分组中
shoppingItemPriceSum += masterItem.TotalSalePrice;
thisGroupMasterItemList.Add(masterItem);
}
}
//处理剩下的主商品分组，这些主商品组成一个子单
if (thisGroupMasterItemList.Count > 0)
{
thisKey = GetSubOrderKey(kvs.Key, shoppingItemPriceSum, dicSubOrderMasterItemResult);
dicSubOrderMasterItemResult[thisKey] = thisGroupMasterItemList;
}
}
foreach (var kvs in dicSubOrderMasterItemResult)
{
OrderInfo subOrderInfo = (OrderInfo)orderInfo.Clone();
//设置订单的默认出库仓
subOrderInfo["WarehouseNumber"] = kvs.Value.FirstOrDefault().WarehouseNumber;
subOrderInfo["WarehouseName"] = kvs.Value.FirstOrDefault().WarehouseName;
subOrderInfo["WarehouseCountryCode"] = kvs.Value.FirstOrDefault().WarehouseCountryCode;
subOrderInfo["MerchantSysNo"] = kvs.Value.FirstOrDefault().MerchantSysNo;
subOrderInfo["StoreType"] = kvs.Value.FirstOrDefault()["ProductStoreType"];
subOrderInfo.OrderItemGroupList = new List <OrderItemGroup>();
subOrderInfo.GiftItemList = new List <OrderGiftItem>();
subOrderInfo.AttachmentItemList = new List <OrderAttachment>();
OrderItemGroup itemGroup = new OrderItemGroup();
//商品在拆单后，购买行为上的分组失去意义，设置组上的购买数量为1，商品的上UnitQuantity及时真实的商品购买数量
itemGroup.Quantity = 1;
itemGroup.ProductItemList = new List <OrderProductItem>();
kvs.Value.ForEach(masterItem =>
{
//itemGroup.ProductItemList.Add(masterItem);
//由于前面将主商品拆分到最细，这里需要将主商品合并
if (!itemGroup.ProductItemList.Exists(x =>
{
if (x.ProductSysNo == masterItem.ProductSysNo)
{
x.UnitQuantity += masterItem.UnitQuantity;
return(true);
}
return(false);
}))
{
itemGroup.ProductItemList.Add(masterItem);
}
});
subOrderInfo.OrderItemGroupList.Add(itemGroup);
subOrderInfoList.Add(kvs.Key, subOrderInfo);
}
#endregion
#region 【 处理赠品和附件 】
List <OrderItem> giftAndAccessoryList = new List <OrderItem>();
if (orderInfo.GiftItemList != null)
{
orderInfo.GiftItemList.ForEach(gift =>
{
if (!giftAndAccessoryList.Exists(g =>
{
OrderGiftItem giftItem = (OrderGiftItem)g;
//赠品合并增加一个赠品活动编号维度,客户端考虑对相同商品编号的赠品合并
if (giftItem.ProductSysNo == gift.ProductSysNo &&
giftItem.ActivityNo == gift.ActivityNo)
{
g.UnitQuantity += gift.UnitQuantity * gift.ParentCount;
return(true);
}
return(false);
}))
{
OrderGiftItem cloneGift = (OrderGiftItem)gift.Clone();
cloneGift.UnitQuantity = gift.UnitQuantity * gift.ParentCount;
//合并后赠品的组数量失去意义，设置赠品的组购买数量为1
cloneGift.ParentCount = 1;
giftAndAccessoryList.Add(cloneGift);
}
});
}
if (orderInfo.AttachmentItemList != null)
{
orderInfo.AttachmentItemList.ForEach(attachment =>
{
if (!giftAndAccessoryList.Exists(a =>
{
if (a.ProductSysNo == attachment.ProductSysNo)
{
a.UnitQuantity += attachment.UnitQuantity * attachment.ParentCount;
return(true);
}
return(false);
}))
{
OrderAttachment cloneAttachment = (OrderAttachment)attachment.Clone();
cloneAttachment.UnitQuantity = attachment.UnitQuantity * attachment.ParentCount;
//合并后附件的组数量失去意义，设置附件的组购买数量为1
cloneAttachment.ParentCount = 1;
giftAndAccessoryList.Add(cloneAttachment);
}
});
}
Dictionary <string, List <OrderItem> > dicGiftAndAccessorySplitResult = GetItemSplitResult(giftAndAccessoryList);
//赠品和附件不会影响订单金额，将按照商家+仓库+存储运输方式拆好的单和前面主商品拆好的单进行合并
foreach (var kvs in dicGiftAndAccessorySplitResult)
{
OrderInfo theSubOrderInfo = null;
//赠品（附件）在新的子单中
bool giftOrAccessoryInNewSubOrder = false;
foreach (string thisKey in subOrderInfoList.Keys)
{
//thisKey:vendorSysno|warehouseNumber|storeType|amt-1....n
string prefixKey = thisKey.Substring(0, thisKey.LastIndexOf('|'));
prefixKey = prefixKey.Substring(0, prefixKey.LastIndexOf('|'));
//kvs.Key: vendorSysno|warehouseNumber|storeType
string newKey = kvs.Key.Substring(0, kvs.Key.LastIndexOf('|'));
if (newKey.ToUpper().Trim() == prefixKey.ToUpper().Trim())
{
theSubOrderInfo = subOrderInfoList[thisKey];
break;
}
}
if (theSubOrderInfo == null)
{
giftOrAccessoryInNewSubOrder = true;
theSubOrderInfo = (OrderInfo)orderInfo.Clone();
//设置订单的默认出库仓
theSubOrderInfo["WarehouseNumber"] = kvs.Value.FirstOrDefault().WarehouseNumber;
theSubOrderInfo["WarehouseName"] = kvs.Value.FirstOrDefault().WarehouseName;
theSubOrderInfo["WarehouseCountryCode"] = kvs.Value.FirstOrDefault().WarehouseCountryCode;
theSubOrderInfo["MerchantSysNo"] = kvs.Value.FirstOrDefault().MerchantSysNo;
theSubOrderInfo["StoreType"] = kvs.Value.FirstOrDefault()["ProductStoreType"];
theSubOrderInfo.OrderItemGroupList = new List <OrderItemGroup>();
theSubOrderInfo.GiftItemList = new List <OrderGiftItem>();
theSubOrderInfo.AttachmentItemList = new List <OrderAttachment>();
subOrderInfoList.Add(kvs.Key, theSubOrderInfo);
}
foreach (var orderItem in kvs.Value)
{
if (orderItem is OrderGiftItem)
{
OrderGiftItem giftItem = orderItem as OrderGiftItem;
//Modified by PoseidonTong at [2014-08-11 12:33:01]
//赠品在和主商品同仓的前提下，优先和关联的主商品拆在同一个订单
if (!giftOrAccessoryInNewSubOrder && giftItem.ParentProductSysNo > 0)
{
var giftMasterProductSubOrderInfos = subOrderInfoList.Select(_ => _.Value)
.Where(x => x.OrderItemGroupList != null &&
x.OrderItemGroupList.Exists(y =>
y.ProductItemList != null &&
y.ProductItemList.Exists(p => p.ProductSysNo == giftItem.ParentProductSysNo)
));
if (giftMasterProductSubOrderInfos.Count() > 0)
{
//取满足条件的第一个子单，考虑同一个主商品由于金额
//限制拆分成了多个子单的情况，这里将赠品放到第一个主单中
giftMasterProductSubOrderInfos.First().GiftItemList.Add(giftItem);
continue;
}
}
theSubOrderInfo.GiftItemList.Add(giftItem);
}
else if (orderItem is OrderAttachment)
{
OrderAttachment attrItem = orderItem as OrderAttachment;
//Modified by PoseidonTong at [2014-08-11 12:33:01]
//附件在和主商品同仓的前提下，优先和关联的主商品拆在同一个订单
if (!giftOrAccessoryInNewSubOrder && attrItem.ParentProductSysNo > 0)
{
var attMasterProductSubOrderInfos = subOrderInfoList.Select(_ => _.Value)
.Where(x => x.OrderItemGroupList != null &&
x.OrderItemGroupList.Exists(y =>
y.ProductItemList != null &&
y.ProductItemList.Exists(p => p.ProductSysNo == attrItem.ParentProductSysNo)
));
if (attMasterProductSubOrderInfos.Count() > 0)
{
//取满足条件的第一个子单，考虑同一个主商品由于金额
//限制拆分成了多个子单的情况，这里将附件放到第一个主单中
attMasterProductSubOrderInfos.First().AttachmentItemList.Add(attrItem);
continue;
}
}
theSubOrderInfo.AttachmentItemList.Add(attrItem);
}
}
}
#endregion
#region 【 设置子单类型和商家模式 】
foreach (var kvs in subOrderInfoList)
{
OrderInfo subOrderInfo = kvs.Value;
#region 设置商家模式
ECommerce.Entity.Product.VendorInfo vendorInfo = PipelineDA.GetVendorInfo((int)subOrderInfo["MerchantSysNo"]);
subOrderInfo["ShippingType"] = vendorInfo.ShippingType;
subOrderInfo["StockType"] = vendorInfo.StockType;
subOrderInfo["InvoiceType"] = vendorInfo.InvoiceType;
subOrderInfo["SellerType"] = vendorInfo.SellerType;
subOrderInfo["VendorName"] = vendorInfo.VendorName;
#endregion
#region 设置子单类型
subOrderInfo.SOType = (int)SOType.Normal;
////团购商品不能和普通商品混合下单，所以只要订单中有团购商品，那么订单一定就是团购订单
//if (subOrderInfo.OrderItemGroupList != null)
//{
// if (subOrderInfo.OrderItemGroupList.Exists(itemGroup =>
// {
// if (itemGroup.ProductItemList != null)
// {
// return itemGroup.ProductItemList.Exists(product =>
// {
// if (product.SpecialActivityType == 1 || product.SpecialActivityType == 3)
// {
// //记录下团购编号
// subOrderInfo["ReferenceSysNo"] = product.SpecialActivitySysNo;
// return true;
// }
// return false;
// });
// }
// return false;
// }))
// {
// subOrderInfo.SOType = (int)SOType.GroupBuy;
// }
// else
// {
// subOrderInfo.SOType = (int)SOType.Normal;
// }
//}
//else
//{
// subOrderInfo.SOType = (int)SOType.Normal;
//}
#endregion
}
#endregion
orderInfo.SubOrderList = subOrderInfoList;
}
/// <summary>
/// 支付后台回调
/// </summary>
/// <param name="payTypeSysNo">支付方式系统编号</param>
/// <param name="collection">POST数据集合</param>
/// <returns></returns>
public string PaymentCallback(int payTypeSysNo, NameValueCollection collection, out CallbackContext context)
{
context = new CallbackContext();
try
{
#region [ 写系统Log ]
ApplicationEventLog log = new ApplicationEventLog()
{
Source = "B2C site pay",
EventType = 8,
HostName = "B2C",
EventTitle = "Pay callback",
EventMessage = Charges.BuildStringFromNameValueCollection(collection),
LanguageCode = ConstValue.LanguageCode,
CompanyCode = ConstValue.CompanyCode,
StoreCompanyCode = ConstValue.StoreCompanyCode
};
CommonDA.CreateApplicationEventLog(log);
#endregion
context.PaymentModeId = payTypeSysNo;
context.ResponseForm = collection;
Charges charge = Charges.GetInstance(context);
context.SOSysNo = charge.GetSOSysNo(context);
context.SOInfo = ShoppingOrderDA.PayGetOrderInfoBySOSysNo(context.SOSysNo);
charge.UpdateCallbackPayment(context);
//如果为泰隆网关支付，写入积分消费记录
//if (payTypeSysNo == 201)
//{
// CreateUserBankPointRecord(context);
//}
if (charge.VerifySign(context))
{
#region [ 检查返回的订单实际支付金额与订单需要支付的金额是否相等，否则不予处理 ]
if (context.SOInfo == null)
{
return(BuildPaymentCallbackReturnResult(payTypeSysNo, false));
}
if (!charge.GetPayAmount(context).ToString("F2").Equals(context.SOInfo.RealPayAmt.ToString("F2")))
{
ECommerce.Utility.Logger.WriteLog("订单实际支付金额与订单需要支付的金额不相等！", "PayCallback", "CheckPayAmount");
return(BuildPaymentCallbackReturnResult(payTypeSysNo, false));
}
#endregion
#region [ 检查NetPay是否存在并且状态为>=0，是则已支付过 ]
NetpayInfo netPayInfo = ShoppingOrderDA.GetCenterDBNetpayBySOSysNo(context.SOSysNo);
if (netPayInfo != null && netPayInfo.Status > (int)NetPayStatusType.Origin)
{
ECommerce.Utility.Logger.WriteLog("订单已经支付！", "PayCallback", "CheckNetPay");
return(BuildPaymentCallbackReturnResult(payTypeSysNo, true));
}
#endregion
if (charge.GetPayResult(context))
{
//支付成功
using (ITransaction scope = TransactionManager.Create())
{
#region 1.写Netpay
netPayInfo = new NetpayInfo()
{
SOSysNo = context.SOSysNo,
PayTypeSysNo = payTypeSysNo,
PayAmount = context.SOInfo.RealPayAmt,
Source = 0,
Status = NetPayStatusType.Verified,
CompanyCode = context.SOInfo.CompanyCode,
LanguageCode = context.SOInfo.LanguageCode,
CurrencySysNo = context.SOInfo.CurrencySysNo,
StoreCompanyCode = context.SOInfo.StoreCompanyCode,
OrderAmt = (context.SOInfo.SoAmt
- Math.Abs((context.SOInfo.Amount.PointPay * 1.00m) / decimal.Parse(ConstValue.PointExhangeRate))
- Math.Abs(context.SOInfo.PromotionAmt)
+ Math.Abs(context.SOInfo.Amount.PayPrice)
+ Math.Abs(context.SOInfo.Amount.ShipPrice)
+ Math.Abs(context.SOInfo.Amount.PremiumAmt)
- Math.Abs(context.SOInfo.Amount.DiscountAmt)
+ Math.Abs(context.SOInfo.TariffAmt)
),
PrePayAmt = context.SOInfo.Amount.PrepayAmt,
PointPayAmt = context.SOInfo.PointPay * 1.00m / decimal.Parse(ConstValue.PointExhangeRate),
GiftCardPayAmt = context.SOInfo.Amount.GiftCardPay,
SerialNumber = charge.GetSerialNumber(context),
PayProcessTime = charge.GetPayProcessTime(context)
};
bool isTrue = ShoppingOrderDA.CreateNetpay(netPayInfo);
#endregion
if (!isTrue)
{
//解决前后台多次并发处理重复数据
ECommerce.Utility.Logger.WriteLog("订单已经支付！", "PayCallback", "CreateNetPay");
return(BuildPaymentCallbackReturnResult(payTypeSysNo, false));
}
if (ConstValue.PaymentInventory)
{
List <OrderItem> subOrderItemList = new List <OrderItem>();
context.SOInfo.SOItemList.ForEach(Item =>
{
OrderProductItem opitem = new OrderProductItem();
opitem["Quantity"] = Item.Quantity;
opitem.ProductSysNo = int.Parse(Item.ProductID);
opitem.ProductName = Item.ProductName;
opitem.WarehouseNumber = int.Parse(Item.WarehouseNumber);
subOrderItemList.Add(opitem);
});
subOrderItemList.ForEach(Item =>
{
//限时促销
if (PipelineDA.CheckCountDownByProductSysNo(Item.ProductSysNo))
{
//扣减订单商品库存
int inventoryType = PipelineDA.GetInventoryType(Item);
var rowCount = PipelineDA.UpdateInventory(Item);
if (rowCount != 1 && inventoryType != 1 && inventoryType != 3 && inventoryType != 5)
{
ECommerce.Utility.Logger.WriteLog("inventory: qty is not enough", "SOPipeline.CreateSOBasicPersister");
throw new BusinessException(string.Format("商品【{0}】库存不足", Item.ProductName));
}
rowCount = PipelineDA.UpdateInventoryStock(Item);
if (rowCount != 1 && inventoryType != 1 && inventoryType != 3 && inventoryType != 5)
{
ECommerce.Utility.Logger.WriteLog("inventory_stock: qty is not enough", "SOPipeline.CreateSOBasicPersister");
throw new BusinessException(string.Format("商品【{0}】库存不足", Item.ProductName));
}
}
});
}
#region 2.发送支付成功邮件
//确认不需要发邮件
//CustomerInfo customer = CustomerDA.GetCustomerInfo(context.SOInfo.CustomerSysNo);
//if (!string.IsNullOrWhiteSpace(customer.Email))
//{
// AsyncEmail email = new AsyncEmail();
// email.MailAddress = customer.Email;
// email.CustomerID = customer.CustomerID;
// email.Status = (int)EmailStatus.NotSend;
// string token = Guid.NewGuid().ToString("N");
// email.ImgBaseUrl = ConfigurationManager.AppSettings["CDNWebDomain"].ToString();
// email.SetNewTokenUrl = "/EmailVerifySucceed?token=" + token + "&sysno=" + customer.SysNo.ToString() + "&email=" + System.Web.HttpUtility.HtmlEncode(customer.Email);
// string subject = string.Empty;
// email.MailBody = MailHelper.GetMailTemplateBody("SalesOrderPaySuccessful", out subject);
// email.MailSubject = subject.Replace("[SOSysNo]", context.SOInfo.SoSysNo.ToString());
// //订单内容
// email.MailBody = email.MailBody.Replace("[CustomerName]", customer.CustomerName);
// email.MailBody = email.MailBody.Replace("[SOSysNo]", context.SOInfo.SoSysNo.ToString());
// email.MailBody = email.MailBody.Replace("[PayAmount]", context.SOInfo.RealPayAmt.ToString("F2"));
// email.MailBody = email.MailBody.Replace("[PayTypeName]", context.SOInfo.Payment.PayTypeName);
// email.MailBody = email.MailBody.Replace("[OrderDate]", context.SOInfo.OrderDate.ToString());
// email.MailBody = email.MailBody.Replace("[ReceiveName]", context.SOInfo.ReceiveName);
// email.MailBody = email.MailBody.Replace("[SOMemo]", context.SOInfo.Memo);
// email.MailBody = email.MailBody.Replace("[NowDate]", DateTime.Now.ToShortDateString());
// EmailDA.SendEmail(email);
//}
#endregion
scope.Complete();
}
return(BuildPaymentCallbackReturnResult(payTypeSysNo, true));
}
else
{
ECommerce.Utility.Logger.WriteLog("返回支付失败", "PayCallback", "CheckPayResult");
return(BuildPaymentCallbackReturnResult(payTypeSysNo, false));
}
}
else
{
//验签失败
return(BuildPaymentCallbackReturnResult(payTypeSysNo, false));
}
}
catch (Exception ex)
{
//系统异常，写日志
ECommerce.Utility.Logger.WriteLog(string.Format("系统异常，异常信息：{0}！", ex.ToString()), "PayCallback", "OnlinePayBgCallbackFailure");
return(BuildPaymentCallbackReturnResult(payTypeSysNo, false));
}
}
public int CreateOrder(int userId, List <ShoppingCartResultSet> shoppingCartItemList, OrderDTO orderDTO, Utilities.Enums.PaymentOption paymentOption,
Utilities.Enums.DeliveryOption deliveryOption, string couponCode)
{
var orderid = 0;
decimal ordersubTotalInclTax = 0M;
OrderProduct orderProduct = new OrderProduct();
orderProduct.OrderGuid = Guid.NewGuid();
orderProduct.BillingAddressId = orderDTO.BillingAddressId;
orderProduct.ShippingAddressId = orderDTO.ShippingAddressId;
orderProduct.CustomerIp = orderDTO.CustomerIp;
orderProduct.CustomerId = orderDTO.CustomerId;
orderProduct.OrderStatusId = orderDTO.OrderStatusId;
orderProduct.PaymentStatusId = orderDTO.PaymentStatusId;
orderProduct.PaymentMethod = (int)paymentOption;
orderProduct.DeliveryMethod = (int)deliveryOption;
orderProduct.OrderShippingCharges = 0;
orderProduct.OrderDateUtc = DateTime.UtcNow;
orderProduct.UpdatedOnUtc = DateTime.UtcNow;
foreach (ShoppingCartResultSet shoppingCartItem in shoppingCartItemList)
{
OrderProductItem item = new OrderProductItem();
item.BranchId = shoppingCartItem.BranchId;
item.ProductId = shoppingCartItem.ProductId;
item.OrderItemGuid = Guid.NewGuid();
item.Quantity = shoppingCartItem.Quantity;
//Get pricing details.
// ProductRepository.getPr
// item.
item.UnitPriceInclTax = shoppingCartItem.UnitPrice;
item.PriceInclTax = item.UnitPriceInclTax * item.Quantity;
item.ShippingCharges = shoppingCartItem.AdditionalShippingCharge * item.Quantity;
item.OrderItemStatus = orderProduct.OrderStatusId;//when creating we will have same status.
item.SelectedSize = shoppingCartItem.SelectedSize;
var currentShoppingCartItem = this.context.ShoppingCartItems.Where(x => x.BranchId == shoppingCartItem.BranchId && x.CustomerId == orderProduct.CustomerId &&
x.ProductId == item.ProductId && x.Quantity == item.Quantity).FirstOrDefault();
orderProduct.OrderSubtotalInclTax += item.PriceInclTax;
orderProduct.OrderShippingCharges += item.ShippingCharges ?? 0;
orderProduct.OrderProductItem.Add(item);
context.Entry(currentShoppingCartItem).State = EntityState.Deleted;
}
//
orderProduct.OrderDiscount = 0M;
if (!string.IsNullOrEmpty(couponCode))
{
var discountObject = context.Discounts.Where(x => x.CouponCode.ToUpper() == couponCode.ToUpper() &&
x.StartDateUtc <= DateTime.UtcNow && x.EndDateUtc >= DateTime.UtcNow).FirstOrDefault();
if (discountObject != null && discountObject.UsePercentage && discountObject.MinOrderValue < orderProduct.OrderSubtotalInclTax)
{
orderProduct.OrderDiscount = (orderProduct.OrderSubtotalInclTax * (discountObject.DiscountPercentage / 100));
}
else if (discountObject != null && discountObject.DiscountAmount > 0 && discountObject.MinOrderValue < orderProduct.OrderSubtotalInclTax)
{
orderProduct.OrderDiscount = orderProduct.OrderSubtotalInclTax - discountObject.DiscountAmount;
}
if (orderProduct.OrderDiscount > discountObject.MaxDiscountAmount)
{
orderProduct.OrderDiscount = discountObject.MaxDiscountAmount;
}
//We should return that the order value is less etc.. Validation to be done seperately.
}
//To Change later.
orderProduct.PaymentMethodAdditionalFee = 0.0M;
orderProduct.OrderTotal = (orderProduct.OrderSubtotalInclTax + orderProduct.OrderShippingCharges +
orderProduct.PaymentMethodAdditionalFee) - orderProduct.OrderDiscount;
this.context.Entry(orderProduct).State = EntityState.Added;
this.context.SaveChanges();
return(orderProduct.Id);
}
/// <summary>
/// 取得满足优惠券条件的商品总金额
/// </summary>
/// <param name="order"></param>
/// <param name="coupon"></param>
/// <returns></returns>
private decimal GetCanCalculateAmount(ref OrderInfo order, CouponInfo coupon)
{
List <SOItemInfo> soItemList = InternalHelper.ConvertToSOItemList(order, false, true);
List <int> productSysNoList = new List <int>();
soItemList.ForEach(f => productSysNoList.Add(f.ProductSysNo));
//couponProductList:满足条件的商品列表，使用OrderProductItem这个对象来记录，UnitSalePrice是这个商品的价格，UnitQuantity会作为这个商品的总数量
List <OrderProductItem> couponProductList = new List <OrderProductItem>();
List <SimpleItemEntity> productList = PromotionDA.GetSimpleItemListBySysNumbers(productSysNoList);
//主商品
foreach (OrderItemGroup itemGroup in order.OrderItemGroupList)
{
foreach (OrderProductItem item in itemGroup.ProductItemList)
{
SimpleItemEntity product = productList.Find(f => f.ProductSysNo == item.ProductSysNo);
if (CheckIsCouponProduct(product, coupon))
{
OrderProductItem couponProduct = couponProductList.Find(f => f.ProductSysNo == product.ProductSysNo);
if (couponProduct == null)
{
couponProduct = new OrderProductItem();
couponProduct.ProductSysNo = item.ProductSysNo;
couponProduct.UnitSalePrice = item.UnitSalePrice;
couponProduct.UnitQuantity = item.UnitQuantity * itemGroup.Quantity;
couponProductList.Add(couponProduct);
}
else
{
couponProduct.UnitQuantity += item.UnitQuantity * itemGroup.Quantity;
}
}
}
}
//加购商品
if (order.PlusPriceItemList != null)
{
foreach (OrderGiftItem item in order.PlusPriceItemList)
{
SimpleItemEntity product = productList.Find(f => f.ProductSysNo == item.ProductSysNo);
if (CheckIsCouponProduct(product, coupon))
{
OrderProductItem couponProduct = couponProductList.Find(f => f.ProductSysNo == product.ProductSysNo);
if (couponProduct == null)
{
couponProduct = new OrderProductItem();
couponProduct.ProductSysNo = item.ProductSysNo;
couponProduct.UnitSalePrice = item.UnitSalePrice;
couponProduct.UnitQuantity = item.UnitQuantity;
couponProductList.Add(couponProduct);
}
else
{
couponProduct.UnitQuantity += item.UnitQuantity;
}
}
}
}
decimal totalAmount = 0.00m;
foreach (OrderProductItem couponProduct in couponProductList)
{
totalAmount += couponProduct.UnitSalePrice * couponProduct.UnitQuantity;
}
order.CouponProductList = couponProductList;
return(totalAmount);
}
public void Calculate(ref OrderInfo order)
{
order.CouponErrorDesc = string.Empty;
if (string.IsNullOrWhiteSpace(order.CouponCode))
{
return;
}
string couponCode = order.CouponCode.ToUpper().Trim();
#region 1、初次筛选该优惠券号码对于前用户是否能用
List <CustomerCouponInfo> customerCouponList = PromotionDA.GetCanUsingCouponCodeList(order.Customer.SysNo, order.Customer.CustomerRank);
CustomerCouponInfo customerCoupon = customerCouponList.Find(f => f.CouponCode.ToUpper().Trim() == couponCode);
if (customerCoupon == null)
{
SetCouponError(ref order, LanguageHelper.GetText("您没有此优惠券号码{0}", order.LanguageCode), couponCode);
return;
}
if (customerCoupon.IsExpired)
{
SetCouponError(ref order, LanguageHelper.GetText("此优惠券号码{0}已过期", order.LanguageCode), couponCode);
return;
}
if (customerCoupon.CustomerMaxFrequency.HasValue && customerCoupon.UsedCount >= customerCoupon.CustomerMaxFrequency.Value)
{
SetCouponError(ref order, LanguageHelper.GetText("您已达到使用优惠券号码{0}的次数上限", order.LanguageCode), couponCode);
return;
}
int totalUsedCount = 0;
int CodeTotalUsedCount = 0;
//用户参与活动的次数
int CustomerUsedCount = 0;
//if (customerCoupon.CodeType.Trim().ToUpper() == "C")
//{
CodeTotalUsedCount = PromotionDA.GetCouponCodeTotalUsedCount(couponCode);
//}
//else
//{
//这个是活动的已使用次数
totalUsedCount = PromotionDA.GetCouponTotalUsedCount(customerCoupon.CouponSysNo);
CustomerUsedCount = PromotionDA.GetCustomerCouponNumber(customerCoupon.CouponSysNo, order.Customer.SysNo);
//}
if (customerCoupon.WebsiteMaxFrequency.HasValue && CodeTotalUsedCount >= customerCoupon.WebsiteMaxFrequency)
{
SetCouponError(ref order, LanguageHelper.GetText("此优惠券号码{0}在全网使用次数已用尽，请使用其他优惠券号码。", order.LanguageCode), couponCode);
return;
}
//if (customerCoupon.WebsiteMaxFrequency.HasValue && totalUsedCount >= customerCoupon.WebsiteMaxFrequency)
//{
// SetCouponError(ref order, LanguageHelper.GetText("此优惠券号码{0}的已达到全网使用次数上限", order.LanguageCode), couponCode);
// return;
//}
#endregion
#region 2、获取该优惠券号码对应的优惠券活动所有信息
CouponInfo coupon = PromotionDA.GetComboInfoByCouponCode(order.CouponCode);
var orderItem = order.OrderItemGroupList.FirstOrDefault();
int merchantSysNo = orderItem == null ? 1 : orderItem.MerchantSysNo;
string merchantName = orderItem == null ? "泰隆" : orderItem.MerchantName;
if (coupon.MerchantSysNo != merchantSysNo && coupon.MerchantSysNo != 1)
{
SetCouponError(ref order, LanguageHelper.GetText(string.Format("该优惠券不是{0}优惠券", merchantName), order.LanguageCode));
return;
}
if (coupon.SaleRulesEx.CustomerMaxFrequency.HasValue && CustomerUsedCount >= coupon.SaleRulesEx.CustomerMaxFrequency.Value)
//if (coupon.SaleRulesEx.CustomerMaxFrequency.HasValue && customerCoupon.UsedCount >= coupon.SaleRulesEx.CustomerMaxFrequency.Value)
{
SetCouponError(ref order, LanguageHelper.GetText("您已达到使用此优惠券活动的次数上限", order.LanguageCode));
return;
}
if (coupon.SaleRulesEx.MaxFrequency.HasValue && totalUsedCount >= coupon.SaleRulesEx.MaxFrequency.Value)
{
SetCouponError(ref order, LanguageHelper.GetText("此优惠券活动已达到全网使用次数上限", order.LanguageCode));
return;
}
if (coupon == null)
{
SetCouponError(ref order, LanguageHelper.GetText("此优惠券{0}不存在", order.LanguageCode), couponCode);
return;
}
#endregion
#region 3、详细检查该优惠券号码是否可用
if (!string.IsNullOrWhiteSpace(coupon.SaleRulesEx.NeedEmailVerification) && coupon.SaleRulesEx.NeedEmailVerification.ToUpper().Trim() == "Y")
{
if (order.Customer.IsEmailConfirmed != 1)
{
SetCouponError(ref order, LanguageHelper.GetText("此优惠券要求客户验证了电子邮箱才可使用！", order.LanguageCode));
return;
}
}
if (!string.IsNullOrWhiteSpace(coupon.SaleRulesEx.NeedMobileVerification) && coupon.SaleRulesEx.NeedMobileVerification.ToUpper().Trim() == "Y")
{
if (order.Customer.IsPhoneValided != 1)
{
SetCouponError(ref order, LanguageHelper.GetText("此优惠券要求客户验证了手机才可使用！", order.LanguageCode));
return;
}
}
if (coupon.SaleRulesList.Count > 0 && coupon.SaleRulesList.Exists(f => f.SaleRuleType == CouponSaleRuleType.RelCustomerRank))
{
//-1表示不限制
if (!coupon.SaleRulesList.Exists(f => f.CustomerRank == -1))
{
int customerRank = order.Customer.CustomerRank;
if (!coupon.SaleRulesList.Exists(f => f.CustomerRank == customerRank))
{
SetCouponError(ref order, LanguageHelper.GetText("当前客户不满足此优惠券要求的客户等级！", order.LanguageCode));
return;
}
}
}
if (coupon.SaleRulesList.Count > 0 && coupon.SaleRulesList.Exists(f => f.SaleRuleType == CouponSaleRuleType.RelArea))
{
int areaID = order.Contact.AddressAreaID;
Area area = PromotionDA.GetAreaBySysNo(areaID);
int provinceId = area.ProvinceSysNo.Value;
if (!coupon.SaleRulesList.Exists(f => f.SaleRuleType == CouponSaleRuleType.RelArea && f.AreaSysNo == provinceId))
{
SetCouponError(ref order, LanguageHelper.GetText("当前客户不满足此优惠券要求的客户地区！", order.LanguageCode));
return;
}
}
#endregion
#region 4、计算该优惠券可以抵扣多少，填充到OrderInfo中
if (coupon.DiscountRuleList != null && coupon.DiscountRuleList.Count > 0)
{
//取得满足优惠券条件的商品总金额
decimal canCalculateAmount = GetCanCalculateAmount(ref order, coupon);
if (canCalculateAmount == 0)
{
SetCouponError(ref order, LanguageHelper.GetText("没有满足该优惠券的商品，无法抵扣", order.LanguageCode));
return;
}
canCalculateAmount = canCalculateAmount - Math.Abs(order.TotalDiscountAmount);
if (canCalculateAmount < coupon.SaleRulesEx.OrderAmountLimit)
{
SetCouponError(ref order, LanguageHelper.GetText("没有满足该优惠券要求的商品总金额下限{0}，无法抵扣", order.LanguageCode), coupon.SaleRulesEx.OrderAmountLimit);
return;
}
#region 处理订单 折扣金额模式 和 百分比模式
if (coupon.DiscountRuleList[0].DiscountType == CouponDiscountType.OrderAmountDiscount || coupon.DiscountRuleList[0].DiscountType == CouponDiscountType.OrderAmountPercentage)
{
//获取适合的折扣规则
Coupon_DiscountRules curDiscountRule = GetMatchDiscountRule(coupon, canCalculateAmount);
if (curDiscountRule == null)
{
SetCouponError(ref order, LanguageHelper.GetText("订单总金额未达到优惠券要求的最小购买金额，无法抵扣", order.LanguageCode));
return;
}
decimal discount = 0m;
if (curDiscountRule.DiscountType == CouponDiscountType.OrderAmountDiscount)
{
discount = Math.Abs(Math.Round(curDiscountRule.Value, 2));
}
else
{
discount = Math.Abs(Math.Round(canCalculateAmount * curDiscountRule.Value, 2));
}
if (coupon.SaleRulesEx.OrderMaxDiscount.HasValue && coupon.SaleRulesEx.OrderMaxDiscount.Value > 0m)
{
if (discount > coupon.SaleRulesEx.OrderMaxDiscount.Value)
{
discount = coupon.SaleRulesEx.OrderMaxDiscount.Value;
}
}
order.CouponCodeSysNo = customerCoupon.CouponCodeSysNo;
order.CouponSysNo = customerCoupon.CouponSysNo;
order.CouponName = customerCoupon.CouponName;
order.CouponAmount = discount;
order.CouponErrorDesc = string.Empty;
}
#endregion
#region 处理 一个商品直减模式
if (coupon.DiscountRuleList[0].DiscountType == CouponDiscountType.ProductPriceDiscount)
{
if (coupon.SaleRulesList == null || coupon.SaleRulesList.Count == 0)
{
SetCouponError(ref order, LanguageHelper.GetText("没有满足该优惠券的指定商品，无法抵扣", order.LanguageCode));
return;
}
Coupon_SaleRules productSaleRule = coupon.SaleRulesList.Find(f => f.SaleRuleType == CouponSaleRuleType.RelProduct);
int discountProductSysNo = productSaleRule.ProductSysNo;
int discountProductCount = 0;
decimal productReduce = 0m;
decimal productPrice = 0.00m;
foreach (OrderItemGroup itemGroup in order.OrderItemGroupList)
{
OrderProductItem item = itemGroup.ProductItemList.Find(f => f.ProductSysNo == discountProductSysNo);
if (item != null)
{
discountProductCount += item.UnitQuantity * itemGroup.Quantity;
productPrice = item.UnitSalePrice;
}
}
if (discountProductCount == 0)
{
SetCouponError(ref order, LanguageHelper.GetText("没有满足该优惠券的指定商品，无法抵扣", order.LanguageCode));
return;
}
if (discountProductCount > coupon.DiscountRuleList[0].Quantity)
{
discountProductCount = coupon.DiscountRuleList[0].Quantity;
}
productReduce = coupon.DiscountRuleList[0].Value;
if (coupon.DiscountRuleList[0].Value > productPrice)
{
productReduce = productPrice;
}
decimal discount = Math.Abs(Math.Round(productReduce * discountProductCount, 2));
if (coupon.SaleRulesEx.OrderMaxDiscount.HasValue && coupon.SaleRulesEx.OrderMaxDiscount.Value > 0m)
{
if (discount > coupon.SaleRulesEx.OrderMaxDiscount.Value)
{
discount = coupon.SaleRulesEx.OrderMaxDiscount.Value;
}
}
order.CouponCodeSysNo = customerCoupon.CouponCodeSysNo;
order.CouponSysNo = customerCoupon.CouponSysNo;
order.CouponName = customerCoupon.CouponName;
order.CouponAmount = discount;
order.CouponErrorDesc = string.Empty;
order["Coupon_DiscountProductSysNo"] = discountProductSysNo;
order["Coupon_DiscountProductCount"] = discountProductCount;
}
#endregion
#region 处理 一个商品最终售价模式
if (coupon.DiscountRuleList[0].DiscountType == CouponDiscountType.ProductPriceFinal)
{
if (coupon.SaleRulesList == null || coupon.SaleRulesList.Count == 0)
{
SetCouponError(ref order, LanguageHelper.GetText("没有满足该优惠券的指定商品，无法抵扣", order.LanguageCode));
return;
}
Coupon_SaleRules productSaleRule = coupon.SaleRulesList.Find(f => f.SaleRuleType == CouponSaleRuleType.RelProduct);
int discountProductSysNo = productSaleRule.ProductSysNo;
decimal discountProductPrice = 0.00m;
int discountProductCount = 0;
foreach (OrderItemGroup itemGroup in order.OrderItemGroupList)
{
OrderProductItem item = itemGroup.ProductItemList.Find(f => f.ProductSysNo == discountProductSysNo);
if (item != null)
{
discountProductCount += item.UnitQuantity * itemGroup.Quantity;
discountProductPrice = item.UnitSalePrice;
}
}
if (discountProductCount == 0)
{
SetCouponError(ref order, LanguageHelper.GetText("没有满足该优惠券的指定商品,无法抵扣", order.LanguageCode));
return;
}
if (discountProductCount > coupon.DiscountRuleList[0].Quantity)
{
discountProductCount = coupon.DiscountRuleList[0].Quantity;
}
decimal discount = 0m;
if (discountProductPrice > coupon.DiscountRuleList[0].Value)
{
discount = Math.Abs(Math.Round((discountProductPrice - coupon.DiscountRuleList[0].Value) * discountProductCount, 2));
}
else
{
SetCouponError(ref order, LanguageHelper.GetText("该优惠券的指定商品已经是优惠券设定的最低价格,无法抵扣", order.LanguageCode));
return;
}
if (coupon.SaleRulesEx.OrderMaxDiscount.HasValue && coupon.SaleRulesEx.OrderMaxDiscount.Value > 0m)
{
if (discount > coupon.SaleRulesEx.OrderMaxDiscount.Value)
{
discount = coupon.SaleRulesEx.OrderMaxDiscount.Value;
}
}
order.CouponCodeSysNo = customerCoupon.CouponCodeSysNo;
order.CouponSysNo = customerCoupon.CouponSysNo;
order.CouponName = customerCoupon.CouponName;
order.CouponAmount = discount;
order.CouponErrorDesc = string.Empty;
order["Coupon_DiscountProductSysNo"] = discountProductSysNo;
order["Coupon_DiscountProductCount"] = discountProductCount;
}
#endregion
order["Coupon_DiscountType"] = coupon.DiscountRuleList[0].DiscountType;
}
#endregion
}
