public void Calculate(ref OrderInfo order)
{
GetAllSaleGift(ref order);
#region 给赠品赋税率，运输方式等
List <int> giftSysNoList = order.GiftItemList.Select(x => x.ProductSysNo).Distinct().ToList <int>();
List <ProductEntryInfo> allProductEntryInfoList = PipelineDA.GetProductEntryInfo(giftSysNoList);
foreach (OrderGiftItem giftItem in order.GiftItemList)
{
ProductEntryInfo entryInfo = allProductEntryInfoList.Find(f => f.ProductSysNo == giftItem.ProductSysNo);
if (entryInfo != null)
{
giftItem["ProductStoreType"] = (int)entryInfo.ProductStoreType;
//giftItem["TariffRate"] = entryInfo.TariffRate;
}
else
{
giftItem["ProductStoreType"] = (int)ProductStoreType.Narmal;
// giftItem["TariffRate"] = 0;
}
}
#endregion
//加价购和赠品都属于赠品，都按赠品获取，之后按销售价格区分拆开
order.PlusPriceItemList = order.GiftItemList.FindAll(m => m.UnitSalePrice > 0m);
order.GiftItemList = order.GiftItemList.FindAll(m => m.UnitSalePrice == 0m);
PrcessorCustomerSelectGift(ref order);
PrcessorCustomerSelectPlusPrice(ref order);
}
public bool Validate(OrderInfo order, out string errorMsg)
{
if (order.CouponCodeSysNo.HasValue && order.CouponCodeSysNo > 0)
{
if (order.SubOrderList == null || order.SubOrderList.Count <= 0)
{
if (order.SOType == (int)SOType.GroupBuy)
{
errorMsg = LanguageHelper.GetText("团购订单不能使用优惠券", order.LanguageCode);
return(false);
}
}
else if (order.SubOrderList.Any(x => x.Value.SOType == (int)SOType.GroupBuy))
{
errorMsg = LanguageHelper.GetText("团购订单不能使用优惠券", order.LanguageCode);
return(false);
}
int quantity = PipelineDA.GetCouponCodeUseQuantity(order.CouponCodeSysNo.Value);
if (quantity == 0)
{
errorMsg = LanguageHelper.GetText("优惠券数量不足", order.LanguageCode);
return(false);
}
quantity = PipelineDA.CouponSaleRulesExUserQuantity(order.CouponCodeSysNo.Value);
if (quantity == 0)
{
errorMsg = LanguageHelper.GetText("优惠券数量不足", order.LanguageCode);
return(false);
}
}
errorMsg = null;
return(true);
}
private bool InnerValidate(OrderInfo order, out string errorMsg)
{
bool checkCustomerPass = true;
if (order.Customer == null)
{
checkCustomerPass = false;
}
else
{
bool customerExist = PipelineDA.IsExistCustomer(order.Customer.SysNo);
if (!customerExist)
{
checkCustomerPass = false;
}
}
if (!checkCustomerPass)
{
errorMsg = "您尚未登录或当前用户不存在，请您重新登录后再试";
}
else
{
errorMsg = null;
}
return(checkCustomerPass);
}
public void Persist(OrderInfo order)
{
foreach (var subOrder in order.SubOrderList.Values)
{
PipelineDA.CreateSOItemGrossProfit(subOrder);
}
}
public void Persist(OrderInfo order)
{
if (order.GiftCardList == null || order.GiftCardList.Count <= 0)
{
return;
}
foreach (GiftCardInfo giftCardInfo in order.GiftCardList)
{
//更新礼品卡信息
PipelineDA.UpdateGiftCardInfo(giftCardInfo);
}
foreach (var kvs in order.SubOrderList)
{
OrderInfo subPreOrderInfo = kvs.Value;
XDocument xDoc = new XDocument(
new XElement("Message",
new XElement("Header"
, new XElement("Action", "SOConsume")
, new XElement("Version", "V1")
, new XElement("NameSpace", "http://soa.ECommerce.com/CustomerProfile")
, new XElement("From", "EC")
, new XElement("CurrencySysNo", order["CurrencySysNo"])
, new XElement("Language", "zh-CN")
, new XElement("CompanyCode", "8601")
, new XElement("StoreCompanyCode", "8601")
),
new XElement("Body"
, new XElement("Memo", "")
, new XElement("EditUser", "WebSite")
)
));
int priority = 1;
foreach (GiftCardInfo giftCardInfo in subPreOrderInfo.GiftCardList)
{
giftCardInfo["SOSysNo"] = subPreOrderInfo.ID;
giftCardInfo["CustomerSysNo"] = subPreOrderInfo.Customer.SysNo;
giftCardInfo["CurrencySysNo"] = subPreOrderInfo["CurrencySysNo"];
//创建礼品卡使用日志
PipelineDA.CreateGiftCardRedeemLog(giftCardInfo);
XElement giftCardElement = new XElement("GiftCard");
giftCardElement.Add(new XElement("Code", giftCardInfo.Code.Trim()));
giftCardElement.Add(new XElement("Priority", priority++));
giftCardElement.Add(new XElement("UseAmount", giftCardInfo.UseAmount));
giftCardElement.Add(new XElement("CustomerSysno", subPreOrderInfo.Customer.SysNo));
giftCardElement.Add(new XElement("ReferenceSOSysNo", subPreOrderInfo.ID));
xDoc.Root.Element("Body").Add(giftCardElement);
}
//创建礼品卡操作记录
string xDocMsg = xDoc.ToString();
PipelineDA.CreateGiftCardOperateLog(xDocMsg);
}
}
public static FreeShippingConfig GetConfig()
{
var config = new FreeShippingConfig();
config.Rules = PipelineDA.GetFreeShippingConfig();
return(config);
}
public void Persist(OrderInfo order)
{
foreach (var subOrder in order.SubOrderList.Values)
{
//订单创建实名认证信息
PipelineDA.CreateSOAuthentication(subOrder);
}
}
public bool Validate(OrderInfo order, out string errorMsg)
{
bool checkResult = PipelineDA.CheckCustomerOrderFrequency(order.Customer.SysNo, TimeSpan.FromMinutes(1));
if (!checkResult)
{
errorMsg = "请不要在1分钟之内重复下单，请到帐户中心查看您的订单。";
return(checkResult);
}
errorMsg = "";
return(checkResult);
}
/// <summary>
/// 检查总库存
/// </summary>
/// <param name="allOrderItemList"></param>
/// <param name="errorMsg"></param>
/// <returns></returns>
private bool ValidateInventory(List <OrderItem> allOrderItemList, out string errorMsg)
{
List <OrderItem> shortageOfStockItemList = new List <OrderItem>();
if (allOrderItemList != null && allOrderItemList.Count > 0)
{
List <int> allOrderItemSysNoList = allOrderItemList.Select(x => x.ProductSysNo).ToList();
List <ProductSalesInfo> allOrderItemSalesInfoList = PipelineDA.GetProductSalesInfoBySysNoList(allOrderItemSysNoList);
if (allOrderItemSalesInfoList != null)
{
foreach (var orderItem in allOrderItemList)
{
var salesInfo = allOrderItemSalesInfoList.Find(x => x.ProductSysNo == orderItem.ProductSysNo);
if (salesInfo == null)
{
shortageOfStockItemList.Add(orderItem);
}
else
{
if (salesInfo.OnlineQty < orderItem.UnitQuantity)
{
shortageOfStockItemList.Add(orderItem);
}
}
}
}
else
{
shortageOfStockItemList.AddRange(allOrderItemList);
}
}
StringBuilder msgBuilder = new StringBuilder();
shortageOfStockItemList.Select(x => string.Format("商品【{0}】库存不足！", x.ProductName))
.ToList()
.ForEach(msg =>
{
msgBuilder.AppendLine(msg);
});
errorMsg = msgBuilder.ToString();
if (!string.IsNullOrEmpty(errorMsg))
{
return(false);
}
errorMsg = null;
return(true);
}
/// <summary>
/// 计算关税
/// </summary>
/// <param name="order"></param>
private void CalculateTrariffAmount(OrderInfo order, Dictionary <string, List <OrderItem> > dicSubOrderItem)
{
OrderInfo subOrderInfo;
List <ProductEntryInfo> allProductEntryInfoList = null;
List <int> allItemSysNoList = dicSubOrderItem.SelectMany(kvs => kvs.Value.Select(item => item.ProductSysNo))
.Distinct()
.ToList();
if (allItemSysNoList.Count > 0)
{
allProductEntryInfoList = PipelineDA.GetProductEntryInfo(allItemSysNoList);
}
decimal totalTrariffAmountSum = 0m;
decimal subOrderTrariffAmountSum = 0m;
if (allProductEntryInfoList != null && allProductEntryInfoList.Count > 0)
{
foreach (var kvs in order.SubOrderList)
{
subOrderInfo = kvs.Value;
subOrderTrariffAmountSum = 0m;
//循环计算子单中每个item的关税
foreach (var item in dicSubOrderItem[kvs.Key])
{
CalculateOrderItemTrariffAmount(item, order, subOrderInfo, allProductEntryInfoList);
subOrderTrariffAmountSum += item.UnitTaxFee * item.UnitQuantity;
}
//单笔订单关税金额小于50元的免征关税
if (subOrderTrariffAmountSum <= 50m)
{
subOrderTrariffAmountSum = 0m;
dicSubOrderItem[kvs.Key].ForEach(item =>
{
//满足关税免征条件，给出免征提示，并记录下原始关税计算金额
item["Tariff-Free-Flag"] = "1";
item.UnitTaxFee = 0m;
});
}
kvs.Value.TaxAmount = subOrderTrariffAmountSum;
totalTrariffAmountSum += subOrderTrariffAmountSum;
}
}
order.TaxAmount = totalTrariffAmountSum;
}
/// <summary>
/// 计算手续费
/// </summary>
/// <param name="order"></param>
private void CalculateCommissionAmount(OrderInfo order)
{
//先计算子单的手续费
PayTypeInfo payTypeInfo = PipelineDA.GetPayTypeBySysNo(order.PayTypeID);
order.PayTypeName = payTypeInfo.PayTypeName;
foreach (KeyValuePair <string, OrderInfo> sub in order.SubOrderList)
{
sub.Value.CommissionAmount = decimal.Round(payTypeInfo.PayRate * sub.Value.CashPayAmount, 2, MidpointRounding.AwayFromZero);
sub.Value.PayTypeName = payTypeInfo.PayTypeName;
}
order.CommissionAmount = order.SubOrderList.Sum(subOrder => subOrder.Value.CommissionAmount);
}
public bool Validate(OrderInfo order, out string errorMsg)
{
bool pass = true;
//先检查订单上的配送地址
if (order.Contact.AddressAreaID <= 0)
{
errorMsg = "请先保存收货人信息！";
return(false);
}
List <ShipTypeInfo> allShipTypeList = PipelineDA.GetAllShippingTypeList();
//先检查主单
pass = InnerValidate(order, allShipTypeList, true, out errorMsg);
if (!pass)
{
return(pass);
}
//检查拆分后的子单
if (order.SubOrderList != null && order.SubOrderList.Count > 0)
{
OrderInfo subOrder = null;
foreach (var kvs in order.SubOrderList)
{
subOrder = kvs.Value;
pass = InnerValidate(subOrder, allShipTypeList, false, out errorMsg);
if (!pass)
{
return(pass);
}
}
}
//因配送区域删除，所以去掉对商品配送区域的判断
//errorMsg = CheckShippingType(order);
if (!string.IsNullOrWhiteSpace(errorMsg))
{
return(false);
}
errorMsg = null;
return(true);
}
public void Persist(OrderInfo order)
{
// 检查是否来自CMP
if (!IsFromCMP())
{
return;
}
// 解析CMP代码
AnalyseCMPCode();
// 保存广告跟踪数据
foreach (var subOrder in order.SubOrderList.Values)
{
BuildAdvEffectMonitorInfo(subOrder);
PipelineDA.CreateAdvEffectMonitor(advEffectMonitor);
}
}
public void Persist(OrderInfo order)
{
foreach (var subOrder in order.SubOrderList.Values)
{
//创建订单捆绑销售规则
var dicountDetailGroups = subOrder.DiscountDetailList.Where(x => x.DiscountType == 1 && x.DiscountActivityNo > 0)
.GroupBy(
k => new { SaleRuleSysNo = k.DiscountActivityNo, SaleRuleName = k.DiscountActivityName },
v => v
);
DTOInfo dtoInfo = null;
StringBuilder note = new StringBuilder();
decimal discount = 0m;
foreach (var theGroup in dicountDetailGroups)
{
dtoInfo = new DTOInfo();
discount = 0m;
note.Clear();
foreach (var item in theGroup)
{
discount += item.UnitDiscount * item.Quantity;
note.AppendFormat("{0},{1},{2};", item.Quantity, item.ProductSysNo, (-1) * item.UnitDiscount);
}
dtoInfo["SOSysNo"] = subOrder.ID;
dtoInfo["SaleRuleSysNo"] = theGroup.Key.SaleRuleSysNo;
dtoInfo["SaleRuleName"] = theGroup.Key.SaleRuleName;
dtoInfo["Discount"] = (-1m) * discount;
dtoInfo["Times"] = 1; //拆单的时候，套餐的折扣信息已经合并，Discount字段记录的即是总折扣
dtoInfo["Note"] = note.ToString();
PipelineDA.CreateSalesRuleInfo(dtoInfo);
}
//更新优惠券信息
if (subOrder.CouponCodeSysNo.HasValue && subOrder.CouponCodeSysNo > 0)
{
PipelineDA.CreateSONewPromotionLog(subOrder);
}
if (subOrder.MerchantCouponCodeSysNo.HasValue && subOrder.MerchantCouponCodeSysNo > 0)
{
PipelineDA.CreateSONewMerchantPromotionLog(subOrder);
}
}
}
public void Persist(OrderInfo order)
{
int soSysNo = PipelineDA.GenerateSOSysNo();
foreach (var subOrder in order.SubOrderList.Values)
{
if (subOrder.OrderItemGroupList.Count > 0 &&
subOrder.OrderItemGroupList[0].ProductItemList.Count > 0)
{
int quantity = subOrder.OrderItemGroupList[0].Quantity * subOrder.OrderItemGroupList[0].ProductItemList[0].UnitQuantity;
while (quantity > 0)
{
subOrder.ID = soSysNo;
PipelineDA.CreateGroupBuyingTicket(subOrder);
quantity--;
}
}
}
}
/// <summary>
/// 检查是否有不支持的配送区域
/// </summary>
/// <param name="order"></param>
/// <returns></returns>
private string CheckShippingType(OrderInfo order)
{
string shippingErrorMsg = "";
foreach (var kvs in order.SubOrderList)
{
OrderInfo subOrderInfo = kvs.Value;
List <ProductShippingPrice> ProductSysNoList = PipelineDA.Pipeline_GetAllProductRestrictedAreaByAreaSysNo(subOrderInfo.Contact.AddressAreaID);
if (ProductSysNoList == null || ProductSysNoList.Count <= 0)
{
shippingErrorMsg = "订单无法配送到您选择的送货区域，请重新选择！";
break;
}
else
{
List <int> ProductSysNo = new List <int>();
foreach (OrderItemGroup ItemGroup in subOrderInfo.OrderItemGroupList)
{
foreach (OrderProductItem ProductItem in ItemGroup.ProductItemList)
{
if (!ProductSysNoList.Exists(p => p.ProductSysNo == ProductItem.ProductSysNo))
{
shippingErrorMsg = "商品（" + ProductItem.ProductName + "）无法配送到您选择的送货区域，请重新选择！";
break;
}
}
}
}
if (!PipelineDA.Pipeline_ExistsShipTypeAreaPrice(int.Parse(subOrderInfo.ShipTypeID), subOrderInfo.Contact.AddressAreaID))
{
shippingErrorMsg += "该收货地区配置有误，请重新选择！";
break;
}
}
if (!string.IsNullOrWhiteSpace(shippingErrorMsg))
{
return(shippingErrorMsg);
}
return("");
}
private bool InnerValidate(OrderInfo order, out string errorMsg)
{
if (string.IsNullOrEmpty(order.PayTypeID))
{
errorMsg = "请选择一种支付方式";
return(false);
}
PayTypeInfo payTypeInfo = PipelineDA.GetPayTypeBySysNo(order.PayTypeID);
if (payTypeInfo == null)
{
errorMsg = "不支持您选择的支付方式，请重新选择";
return(false);
}
errorMsg = null;
return(true);
}
private WarehouseAllocateResponse GetWarehouseAllocateResponse(WarehouseAllocateRequest request)
{
WarehouseAllocateResponse response = PipelineDA.AllocateWarehouse(request);
if (response.AllocateItemInventoryInfoList != null)
{
List <AllocatedItemInventoryInfo> allocatedItemInventoryInfoResult = new List <AllocatedItemInventoryInfo>();
foreach (AllocateItemInfo productInfo in request.ProductList)
{
List <AllocatedItemInventoryInfo> thisItemAllocateInventoryList = response.AllocateItemInventoryInfoList.FindAll(item =>
{
return(productInfo.ProductID == item.ProductID);
});
if (thisItemAllocateInventoryList != null && thisItemAllocateInventoryList.Count > 0)
{
//删除库存不足的仓库，不做并单发货，不存在前台自动移仓单
thisItemAllocateInventoryList.RemoveAll(item =>
{
return((item.StockAvailableQty + item.StockConsignQty + item.StockVirtualQty) < productInfo.Quantity);
});
//筛选出最佳出库仓库
if (thisItemAllocateInventoryList.Count > 0)
{
FilterAllocatedItemInventoryInfo(productInfo, thisItemAllocateInventoryList);
allocatedItemInventoryInfoResult.AddRange(thisItemAllocateInventoryList);
}
}
}
response.AllocateItemInventoryInfoList = allocatedItemInventoryInfoResult;
if (response.AllocateItemInventoryInfoList.Count == 0)
{
response.AllocateResult = -1;
}
}
return(response);
}
public void Initialize(ref OrderInfo order)
{
order.BindingGiftCardList = PipelineDA.GetCustomerBindingGiftCardInfoList(order.Customer.SysNo);
if (order.BindingGiftCardList != null)
{
//礼品卡按到期时间从近到远排列，引导用户优先使用快到期的礼品卡
order.BindingGiftCardList.Sort((giftCard1, giftCard2) =>
{
var diffDate1 = giftCard1.ValidEndDate.Subtract(DateTime.Today);
var diffDate2 = giftCard2.ValidEndDate.Subtract(DateTime.Today);
return(diffDate1.CompareTo(diffDate2));
});
foreach (var giftCardInfo in order.BindingGiftCardList)
{
giftCardInfo["ActAvailableAmount"] = giftCardInfo.AvailableAmount;
}
}
}
/// <summary>
/// 取得每单最大限制金额，默认指定HK的最大限制金额为800，JP的最大限制金额为1000
/// 可以通过web.config的配置项“MaxPerOrderAmount”进行改写
/// </summary>
/// <returns></returns>
private Dictionary <string, decimal> GetMaxPerOrderAmountConfig()
{
List <string> allStockCountryCode = PipelineDA.GetAllStockCountryCode();
Dictionary <string, decimal> config = allStockCountryCode.ToDictionary(k => k, v => decimal.MaxValue);
string maxPerOrderAmountConfig = ConstValue.MaxPerOrderAmount;
if (!string.IsNullOrWhiteSpace(maxPerOrderAmountConfig))
{
string[] parts = maxPerOrderAmountConfig.Split(new char[] { '|', ';' }, StringSplitOptions.RemoveEmptyEntries);
for (int i = 0; i < parts.Length; i = i + 2)
{
string key = parts[i];
decimal maxPerOrderAmt;
if (config.ContainsKey(key) && decimal.TryParse(parts[i + 1], out maxPerOrderAmt))
{
config[key] = maxPerOrderAmt;
}
}
}
return(config);
}
public void Persist(OrderInfo order)
{
foreach (var kvs in order.SubOrderList)
{
var subOrder = kvs.Value;
//记录订单支付日志
PipelineDA.UpdateFinanceNetPayForPrepay(subOrder);
//记录订单创建日志 OrderKey:查找拆单在某步发生的日志
subOrder.IPAddress = HttpContext.Current.Request.UserHostAddress;
subOrder["Note"] = string.Format("OrderKey:{0}, Customer#:{1}, RecvSysNo:{2}, Items:({3}), RecvAddress:{4}, ShipType:{5}, PayType:{6}", kvs.Key, subOrder.Customer.SysNo, subOrder.Contact.AddressAreaID, subOrder["Note"], subOrder.Contact.AddressDetail, subOrder.ShipTypeID, subOrder.PayTypeID);
//免运费日志
if (subOrder.HasProperty("FreeShippingChargeLog"))
{
subOrder["Note"] = string.Format("{0}, {1}", subOrder["Note"], subOrder["FreeShippingChargeLog"]);
}
PipelineDA.UpdateSalesOrderLog(subOrder, 0);
subOrder["Note"] = "订单已提交";
PipelineDA.UpdateSalesOrderLog(subOrder, 200);
}
}
private void InnerCalculate(KeyValuePair <string, OrderInfo> preSubOrderKVS, List <FreeShippingItemConfig> rules)
{
bool isMatchFreeShippingCharge = false;
ECommerce.Entity.Area contactAddressInfo = null;
OrderInfo preSubOrderInfo = preSubOrderKVS.Value;
OrderInfo clonedPreSubOrderInfo = (OrderInfo)preSubOrderInfo.Clone();
//原运费
decimal ShippingPrice = preSubOrderInfo.ShippingAmount;
//有效的免运费规则
string matchedRule = null;
foreach (var rule in rules)
{
// 1. 检查是否满足金额条件限制
isMatchFreeShippingCharge = OrderAmtMatchedContext.GetContext(rule).IsMatched(preSubOrderInfo, rule);
#region 2. 检查是否满足支付类型条件限制(旧逻辑现在不用)
/*
* if (isMatchFreeShippingCharge && !string.IsNullOrWhiteSpace(rule.PayTypeSettingValue))
* {
* isMatchFreeShippingCharge = false;
*
* string[] setValues = rule.PayTypeSettingValue.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
* for (int i = 0; i < setValues.Length; i++)
* {
* if (setValues[i].Trim() == preSubOrderInfo.PayTypeID)
* {
* isMatchFreeShippingCharge = true;
* break;
* }
* }
* }*/
#endregion
// 3. 检查是否满足配送区域条件限制
if (isMatchFreeShippingCharge && !string.IsNullOrWhiteSpace(rule.ShipAreaSettingValue))
{
isMatchFreeShippingCharge = false;
contactAddressInfo = ECommerce.DataAccess.Common.CommonDA.GetAreaBySysNo(preSubOrderInfo.Contact.AddressAreaID);
if (contactAddressInfo != null && contactAddressInfo.ProvinceSysNo != null)
{
string[] setValues = rule.ShipAreaSettingValue.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
for (int i = 0; i < setValues.Length; i++)
{
if (setValues[i].Trim() == contactAddressInfo.ProvinceSysNo.ToString())
{
isMatchFreeShippingCharge = true;
break;
}
}
}
}
//商品免运费数量
int ProductFreeNumber = 0;
#region 排除免运费的商品
if (isMatchFreeShippingCharge && rule.ProductSettingValue != null && rule.ProductSettingValue.Count > 0)
{
isMatchFreeShippingCharge = false;
if (clonedPreSubOrderInfo.OrderItemGroupList != null)
{
foreach (var itemGroup in clonedPreSubOrderInfo.OrderItemGroupList)
{
if (itemGroup.ProductItemList != null)
{
for (int i = itemGroup.ProductItemList.Count - 1; i >= 0; i--)
{
if (rule.ProductSettingValue.Exists(productSysNo => itemGroup.ProductItemList[i].ProductSysNo == productSysNo))
{
isMatchFreeShippingCharge = true;
itemGroup.ProductItemList.RemoveAt(i);
ProductFreeNumber++;
}
}
}
}
}
if (clonedPreSubOrderInfo.GiftItemList != null)
{
for (int i = clonedPreSubOrderInfo.GiftItemList.Count - 1; i >= 0; i--)
{
if (rule.ProductSettingValue.Exists(productSysNo => clonedPreSubOrderInfo.GiftItemList[i].ProductSysNo == productSysNo))
{
clonedPreSubOrderInfo.GiftItemList.RemoveAt(i);
ProductFreeNumber++;
}
}
}
if (clonedPreSubOrderInfo.AttachmentItemList != null)
{
for (int i = clonedPreSubOrderInfo.AttachmentItemList.Count - 1; i >= 0; i--)
{
if (rule.ProductSettingValue.Exists(productSysNo => clonedPreSubOrderInfo.AttachmentItemList[i].ProductSysNo == productSysNo))
{
clonedPreSubOrderInfo.AttachmentItemList.RemoveAt(i);
ProductFreeNumber++;
}
}
}
}
#endregion
if (ProductFreeNumber > 0)
{
matchedRule += rule.ToXmlString() + ";";
}
/*
* //对同时满足门槛金额限制、支付类型限制、配送区域限制的子单重新计算运费(旧逻辑现在不用)
* if (isMatchFreeShippingCharge)
* {
* CalcShippingAmount(preSubOrderKVS, rule);
* //break; //旧逻辑
* }
*/
}
//排除免运费商品后，子单中还剩下部分商品，计算这部分商品的运费作为本单运费
//fixbug: 在没有收货地址的情况下，如果订单满足免运费条件，此时ShippingFeeQueryInfo对象的AreaId=0，计算运费的sp进入某个特定分支后会报错
if (clonedPreSubOrderInfo.TotalItemCount > 0 && preSubOrderInfo.Contact.AddressAreaID > 0)
//if (ProductFreeNumber <= 0 && preSubOrderInfo.Contact.AddressAreaID > 0 && clonedPreSubOrderInfo.TotalItemCount > 0)
{
List <ShippingFeeQueryInfo> qryList = new List <ShippingFeeQueryInfo>();
ShippingFeeQueryInfo qry = new ShippingFeeQueryInfo();
qry.TransID = preSubOrderKVS.Key;
qry.SoAmount = clonedPreSubOrderInfo.TotalProductAmount;
qry.SoTotalWeight = clonedPreSubOrderInfo.TotalWeight;
qry.SOSingleMaxWeight = clonedPreSubOrderInfo.MaxWeight;
qry.AreaId = preSubOrderInfo.Contact.AddressAreaID;
qry.CustomerSysNo = preSubOrderInfo.Customer.SysNo;
qry.IsUseDiscount = 0;
qry.SubShipTypeList = preSubOrderInfo.ShipTypeID.ToString();
qry.SellType = Convert.ToInt32(preSubOrderInfo["SellerType"]);
qry.MerchantSysNo = Convert.ToInt32(preSubOrderKVS.Key.Split('|')[0]);
qry.ShipTypeId = 0;
qryList.Add(qry);
List <ShippingInfo> shipFeeList = PipelineDA.GetAllShippingFee(qryList);
ShippingInfo curShippingInfo = shipFeeList.Find(x => x.TransID == preSubOrderKVS.Key && x.ShippingTypeID.ToString() == preSubOrderInfo.ShipTypeID);
if (curShippingInfo != null)
{
preSubOrderInfo.ShippingAmount = curShippingInfo.ShippingPrice; //+curShippingInfo.ShippingPackageFee;
}
}
else
{
//排除免运费商品后，子单中商品数量为0，免本单运费
preSubOrderInfo.ShippingAmount = 0m;
}
if (!string.IsNullOrWhiteSpace(matchedRule))
{
preSubOrderInfo["FreeShippingChargeLog"] = string.Format("符合免运费规则：{0}\r\n，原运费为:{1:F2}元，减免后运费为:{2:F2}元",
matchedRule.ToXmlString(), ShippingPrice, preSubOrderInfo.ShippingAmount);
}
}
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 Persist(OrderInfo order)
{
//更新当前收货地址为用户的默认收货地址
PipelineDA.SetCustomerShippingAddressAsDefault(order.Contact.ID, order.Customer.SysNo);
foreach (var subOrder in order.SubOrderList.Values)
{
//更新用户积分信息
if (subOrder.PointPayAmount > 0m)
{
subOrder["Memo"] = "创建订单扣减积分";
var msgResult = PipelineDA.UpdatePointForCustomer(subOrder);
if (String.IsNullOrWhiteSpace(msgResult) || !msgResult.Trim().Equals("1000099"))
{
ECommerce.Utility.Logger.WriteLog("Update point of customer failed,ErrorCode:" + msgResult, "SOPipeline.NeweggSpecialPersister");
throw new BusinessException("用户积分不足");
}
}
//更新用户余额
if (subOrder.BalancePayAmount > 0m)
{
PipelineDA.UpdateCustomerPrepayBasic(subOrder);
}
//更新用户扩展信息
PipelineDA.UpdateCustomerExtend(subOrder);
//订单发货仓库
//subOrder["LocalWHSysNo"] = subOrder.OrderItemGroupList.FirstOrDefault().ProductItemList.FirstOrDefault().WarehouseNumber;
subOrder["LocalWHSysNo"] = subOrder["WarehouseNumber"];
//订单运费检查
PipelineDA.UpdateSOCheckShipping(subOrder);
//创建订单扩展信息
PipelineDA.CreateSOMasterExtension(subOrder);
//创建订单商品扩展信息
if (subOrder.OrderItemGroupList != null)
{
//只记录团购商品信息，用于job后台结算
subOrder.OrderItemGroupList.ForEach(g =>
{
if (g.ProductItemList != null)
{
g.ProductItemList.Where(x => x.SpecialActivityType == 1)
.ToList()
.ForEach(item =>
{
item["SOSysNo"] = subOrder.ID;
item["ItemExtensionType"] = "G";
PipelineDA.CreateSOItemExtension(item);
});
}
});
}
//新赠品规则
subOrder.AttachmentItemList.ForEach(item =>
{
item["SOSysNo"] = subOrder.ID;
PipelineDA.CreateSOItemAttachmentAccessory(item); //创建订单所有附件
});
List <DTOInfo> orderGiftMasterList = new List <DTOInfo>();
subOrder.GiftItemList.ForEach(item =>
{
DTOInfo dtoInfo = orderGiftMasterList.Find(f => (int)f["ActivityNo"] == item.ActivityNo);
if (dtoInfo == null)
{
dtoInfo = new DTOInfo();
dtoInfo["SOSysNo"] = subOrder.ID;
dtoInfo["ActivityNo"] = item.ActivityNo;
dtoInfo["SaleGiftType"] = item.SaleGiftType;
dtoInfo["Count"] = item.UnitQuantity;
dtoInfo["Order"] = 0;
orderGiftMasterList.Add(dtoInfo);
}
else
{
dtoInfo["Count"] = (int)dtoInfo["Count"] + item.UnitQuantity;
dtoInfo["Order"] = (int)dtoInfo["Order"] + 1;
}
PipelineDA.CreateSOItemGiftAccessory(item); //创建订单所有赠品
PipelineDA.CreateSOGiftItem(item); //促销活动订单赠品列表
});
foreach (DTOInfo dtoInfo in orderGiftMasterList)
{
PipelineDA.CreateSOGiftMaster(dtoInfo);//促销活动订单赠送
}
}
}
/// <summary>
/// 获取商家仓库的所有配送方式
/// </summary>
/// <param name="sellerSysNo">商家编号</param>
/// <returns></returns>
public static List <ShipTypeInfo> Checkout_GetStockShippingType(int sellerSysNo)
{
return(PipelineDA.Checkout_GetStockShippingType(sellerSysNo));
}
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;
}
public bool Validate(OrderInfo order, out string errorMsg)
{
errorMsg = string.Empty;
List <string> errorMsgList = new List <string>();
#region [ 商品库存检查 ]
if (!ValidateQuantity(order, out errorMsgList))
{
foreach (var item in errorMsgList)
{
errorMsg += item + "<br />";
}
return(false);
}
#endregion
foreach (OrderItemGroup itemGroup in order.OrderItemGroupList)
{
if (itemGroup.PackageChecked)
{
if (itemGroup.PackageType == 1)
{
foreach (OrderProductItem item in itemGroup.ProductItemList)
{
#region 1.商品状态检查
if (!item["ProductStatus"].ToString().Equals(((int)ECommerce.Enums.ProductStatus.Show).ToString()))
{
errorMsg = LanguageHelper.GetText("商品【{0}】未上架！", order.LanguageCode);
errorMsg = string.Format(errorMsg, item["ProductTitle"]);
return(false);
}
#endregion
#region 2.商品库存检查
//if (itemGroup.Quantity * item.UnitQuantity > item.TotalInventory)
//{
// errorMsg = LanguageHelper.GetText("商品【{0}】库存不足！", order.LanguageCode);
// errorMsg = string.Format(errorMsg, item["ProductTitle"]);
// return false;
//}
#endregion
#region 3.每单限购最小数量检查
int minCountPerOrder = 0;
int.TryParse(item["MinCountPerOrder"].ToString(), out minCountPerOrder);
if (itemGroup.Quantity * item.UnitQuantity < minCountPerOrder)
{
errorMsg = LanguageHelper.GetText("商品【{0}】每单限购数量{1}-{2}！", order.LanguageCode);
errorMsg = string.Format(errorMsg, item["ProductTitle"], item["MinCountPerOrder"], item["MaxCountPerOrder"]);
return(false);
}
#endregion
#region 4.每单限购最大数量检查
int maxCountPerOrder = 0;
int.TryParse(item["MaxCountPerOrder"].ToString(), out maxCountPerOrder);
if (itemGroup.Quantity * item.UnitQuantity > maxCountPerOrder)
{
errorMsg = LanguageHelper.GetText("商品【{0}】每单限购数量{1}-{2}！", order.LanguageCode);
errorMsg = string.Format(errorMsg, item["ProductTitle"], item["MinCountPerOrder"], item["MaxCountPerOrder"]);
return(false);
}
#endregion
List <OrderGiftItem> giftList = null;
if (order.GiftItemList != null && order.GiftItemList.Count > 0)
{
giftList = order.GiftItemList.FindAll(m
=> m.ParentPackageNo == itemGroup.PackageNo &&
m.MerchantSysNo == item.MerchantSysNo &&
m.ParentProductSysNo == item.ProductSysNo);
}
if (giftList == null)
{
giftList = new List <OrderGiftItem>();
}
//非赠品池赠品
var normalGiftList = giftList.FindAll(m => !m.IsGiftPool);
foreach (var gift in normalGiftList)
{
ProductSalesInfo giftSalesInfo = PipelineDA.GetProductSalesInfoBySysNo(gift.ProductSysNo);
gift.TotalInventory = giftSalesInfo.OnlineQty;
if (gift.UnitQuantity * gift.ParentCount > gift.TotalInventory)
{
errorMsg = LanguageHelper.GetText("赠品【{0}】库存不足！", order.LanguageCode);
errorMsg = string.Format(errorMsg, gift.ProductName);
return(false);
}
}
//订单级别用户选择的赠品（包含非赠品池删除后保留的赠品和赠品池选择的赠品）
List <OrderGiftItem> orderGiftList = new List <OrderGiftItem>();
if (order.GiftItemList != null)
{
orderGiftList = order.GiftItemList.FindAll(m => m.ParentPackageNo.Equals(0) &&
m.ParentProductSysNo.Equals(0) &&
((m.IsGiftPool && m.IsSelect) || !m.IsGiftPool));
}
var productList = order.OrderItemGroupList.FindAll(m => m.MerchantSysNo == item.MerchantSysNo);
var merchantOrderGiftList = orderGiftList.FindAll(m => m.MerchantSysNo == item.MerchantSysNo);
if (merchantOrderGiftList != null && merchantOrderGiftList.Count > 0)
{
for (int index = 0; index < merchantOrderGiftList.Count; index++)
{
var Gift = merchantOrderGiftList[index];
var itemGroupList = productList.FindAll(m => m.MerchantSysNo == merchantOrderGiftList[index].MerchantSysNo && m.PackageChecked);
if (itemGroupList.Count > 0 && itemGroupList != null)
{
ProductSalesInfo giftSalesInfo = PipelineDA.GetProductSalesInfoBySysNo(merchantOrderGiftList[index].ProductSysNo);
merchantOrderGiftList[index].TotalInventory = giftSalesInfo.OnlineQty;
if (merchantOrderGiftList[index].UnitQuantity * merchantOrderGiftList[index].ParentCount > merchantOrderGiftList[index].TotalInventory)
{
errorMsg = LanguageHelper.GetText("赠品【{0}】库存不足！", order.LanguageCode);
errorMsg = string.Format(errorMsg, merchantOrderGiftList[index].ProductName);
return(false);
}
}
}
}
}
}
else if (itemGroup.PackageType == 0)
{
foreach (OrderProductItem item in itemGroup.ProductItemList)
{
if (item.ProductChecked)
{
#region 1.商品状态检查
if (!item["ProductStatus"].ToString().Equals(((int)ECommerce.Enums.ProductStatus.Show).ToString()))
{
errorMsg = LanguageHelper.GetText("商品【{0}】未上架！", order.LanguageCode);
errorMsg = string.Format(errorMsg, item["ProductTitle"]);
return(false);
}
#endregion
#region 2.商品库存检查
//if (itemGroup.Quantity * item.UnitQuantity > item.TotalInventory)
//{
// errorMsg = LanguageHelper.GetText("商品【{0}】库存不足！", order.LanguageCode);
// errorMsg = string.Format(errorMsg, item["ProductTitle"]);
// return false;
//}
#endregion
#region 3.每单限购最小数量检查
int minCountPerOrder = 0;
int.TryParse(item["MinCountPerOrder"].ToString(), out minCountPerOrder);
if (itemGroup.Quantity * item.UnitQuantity < minCountPerOrder)
{
errorMsg = LanguageHelper.GetText("商品【{0}】每单限购数量{1}-{2}！", order.LanguageCode);
errorMsg = string.Format(errorMsg, item["ProductTitle"], item["MinCountPerOrder"], item["MaxCountPerOrder"]);
return(false);
}
#endregion
#region 4.每单限购最大数量检查
int maxCountPerOrder = 0;
int.TryParse(item["MaxCountPerOrder"].ToString(), out maxCountPerOrder);
if (itemGroup.Quantity * item.UnitQuantity > maxCountPerOrder)
{
errorMsg = LanguageHelper.GetText("商品【{0}】每单限购数量{1}-{2}！", order.LanguageCode);
errorMsg = string.Format(errorMsg, item["ProductTitle"], item["MinCountPerOrder"], item["MaxCountPerOrder"]);
return(false);
}
#endregion
//赠品
List <OrderGiftItem> giftList = null;
if (order.GiftItemList != null && order.GiftItemList.Count > 0)
{
giftList = order.GiftItemList.FindAll(m
=> m.ParentPackageNo == itemGroup.PackageNo &&
m.MerchantSysNo == item.MerchantSysNo &&
m.ParentProductSysNo == item.ProductSysNo);
}
if (giftList == null)
{
giftList = new List <OrderGiftItem>();
}
//非赠品池赠品
var normalGiftList = giftList.FindAll(m => !m.IsGiftPool);
foreach (var gift in normalGiftList)
{
ProductSalesInfo giftSalesInfo = PipelineDA.GetProductSalesInfoBySysNo(gift.ProductSysNo);
gift.TotalInventory = giftSalesInfo.OnlineQty;
if (gift.UnitQuantity * gift.ParentCount > gift.TotalInventory)
{
errorMsg = LanguageHelper.GetText("赠品【{0}】库存不足！", order.LanguageCode);
errorMsg = string.Format(errorMsg, gift.ProductName);
return(false);
}
}
//订单级别用户选择的赠品（包含非赠品池删除后保留的赠品和赠品池选择的赠品）
List <OrderGiftItem> orderGiftList = new List <OrderGiftItem>();
if (order.GiftItemList != null)
{
orderGiftList = order.GiftItemList.FindAll(m => m.ParentPackageNo.Equals(0) &&
m.ParentProductSysNo.Equals(0) &&
((m.IsGiftPool && m.IsSelect) || !m.IsGiftPool));
}
var productList = order.OrderItemGroupList.FindAll(m => m.MerchantSysNo == item.MerchantSysNo);
var merchantOrderGiftList = orderGiftList.FindAll(m => m.MerchantSysNo == item.MerchantSysNo);
if (merchantOrderGiftList != null && merchantOrderGiftList.Count > 0)
{
for (int index = 0; index < merchantOrderGiftList.Count; index++)
{
var Gift = merchantOrderGiftList[index];
var itemGroupList = productList.FindAll(m => m.MerchantSysNo == merchantOrderGiftList[index].MerchantSysNo && m.PackageChecked);
if (itemGroupList.Count > 0 && itemGroupList != null)
{
ProductSalesInfo giftSalesInfo = PipelineDA.GetProductSalesInfoBySysNo(merchantOrderGiftList[index].ProductSysNo);
merchantOrderGiftList[index].TotalInventory = giftSalesInfo.OnlineQty;
if (merchantOrderGiftList[index].UnitQuantity * merchantOrderGiftList[index].ParentCount > merchantOrderGiftList[index].TotalInventory)
{
errorMsg = LanguageHelper.GetText("赠品【{0}】库存不足！", order.LanguageCode);
errorMsg = string.Format(errorMsg, merchantOrderGiftList[index].ProductName);
return(false);
}
}
}
}
}
}
}
}
}
#region 优惠促销库存检查
if (order.AttachmentItemList != null)
{
foreach (OrderAttachment attachment in order.AttachmentItemList)
{
ProductSalesInfo attachmentSalesInfo = PipelineDA.GetProductSalesInfoBySysNo(attachment.ProductSysNo);
attachment.TotalInventory = attachmentSalesInfo.OnlineQty;
if (attachment.UnitQuantity * attachment.ParentCount > attachment.TotalInventory)
{
errorMsg = LanguageHelper.GetText("附件【{0}】库存不足！", order.LanguageCode);
errorMsg = string.Format(errorMsg, attachment.ProductName);
return(false);
}
}
}
if (order.GiftItemList != null)
{
foreach (OrderGiftItem gift in order.GiftItemList)
{
if (gift.IsSelect)
{
ProductSalesInfo giftSalesInfo = PipelineDA.GetProductSalesInfoBySysNo(gift.ProductSysNo);
gift.TotalInventory = giftSalesInfo.OnlineQty;
if (gift.UnitQuantity * gift.ParentCount > gift.TotalInventory)
{
errorMsg = LanguageHelper.GetText("赠品【{0}】库存不足！", order.LanguageCode);
errorMsg = string.Format(errorMsg, gift.ProductName);
return(false);
}
}
}
}
if (order.PlusPriceItemList != null)
{
foreach (OrderGiftItem gift in order.PlusPriceItemList)
{
if (gift.IsSelect)
{
ProductSalesInfo giftSalesInfo = PipelineDA.GetProductSalesInfoBySysNo(gift.ProductSysNo);
gift.TotalInventory = giftSalesInfo.OnlineQty;
if (gift.UnitQuantity > gift.TotalInventory)
{
errorMsg = LanguageHelper.GetText("加购商品【{0}】库存不足！", order.LanguageCode);
errorMsg = string.Format(errorMsg, gift.ProductName);
return(false);
}
}
}
}
#endregion
errorMsg = null;
return(true);
}
/// <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);
}
/// <summary>
/// 根据配送地区编号和支付方式编号取得所有支持的配送方式列表
/// </summary>
/// <param name="addressAreaID">配送地区编号</param>
/// <param name="paymentCategory">支付类别</param>
/// <returns></returns>
public static List <ShipTypeInfo> GetSupportedShipTypeList(int addressAreaID, PaymentCategory?paymentCategory)
{
return(PipelineDA.GetSupportedShipTypeList(addressAreaID, paymentCategory));
}
/// <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));
}
}
