private SOInfo CreateSubSO()
{
SOInfo subSOInfo = new SOInfo();
subSOInfo.BaseInfo = SerializationUtility.DeepClone <SOBaseInfo>(CurrentSO.BaseInfo);
subSOInfo.ClientInfo = SerializationUtility.DeepClone <SOClientInfo>(CurrentSO.ClientInfo);
subSOInfo.FPInfo = SerializationUtility.DeepClone <SOFPInfo>(CurrentSO.FPInfo);
//添加增值税发票信息到每个仓库
subSOInfo.InvoiceInfo = SerializationUtility.DeepClone <SOInvoiceInfo>(CurrentSO.InvoiceInfo);
subSOInfo.ReceiverInfo = SerializationUtility.DeepClone <SOReceiverInfo>(CurrentSO.ReceiverInfo);
subSOInfo.ShippingInfo = SerializationUtility.DeepClone <SOShippingInfo>(CurrentSO.ShippingInfo);
subSOInfo.CompanyCode = CurrentSO.BaseInfo.CompanyCode;
subSOInfo.Merchant = CurrentSO.Merchant;
subSOInfo.WebChannel = CurrentSO.WebChannel;
//提前生成子单号
int subSOSysNo = SODA.NewSOSysNo();
subSOInfo.SysNo = subSOSysNo;
subSOInfo.BaseInfo.SOID = subSOSysNo.ToString();
subSOInfo.BaseInfo.CreateTime = DateTime.Now;
subSOInfo.BaseInfo.SplitType = SOSplitType.SubSO;
subSOInfo.BaseInfo.SOSplitMaster = SOSysNo;
subSOInfo.ShippingInfo.IsCombine = null;
return(subSOInfo);
}
/// <summary>
/// 为SO提供计算当前订单能能享受的所有促销活动结果
/// </summary>
/// <param name="soInfo">订单信息</param>
/// <param name="isModifyCoupons"></param>
/// <returns></returns>
public virtual List <SOPromotionInfo> CalculateSOPromotion(SOInfo soInfo, bool isModifyCoupons)
{
/* TODO:
* （1）根据SOInfo中的Master和Items的信息，判断当前能够参加哪些促销活动并将相应的促销活动信息Load出来:团购、限时和赠品的活动不做处理
* （2）按照促销活动相互间的优先、排重关系，确定能够使用哪些促销活动:先做Combo，然后得到订单中商品实际总金额；再做优惠券
* （3）调用各促销活动中的计算方法，返回各促销活动的计算结果
* （4) 汇总所有促销活动的计算结果
* */
SOInfo soInfoClone = SerializationUtility.DeepClone <SOInfo>(soInfo);
List <SOPromotionInfo> promotionList = new List <SOPromotionInfo>();
List <SOPromotionInfo> comboPromotionList = ObjectFactory <ComboProcessor> .Instance.CalculateSOPromotion(soInfoClone, promotionList);
//得到Combo中所有的折扣
decimal allComboTotalDiscount = comboPromotionList.Sum(f => f.DiscountAmount.Value);
promotionList.AddRange(comboPromotionList);
//应用销售立减
soInfoClone = SerializationUtility.DeepClone <SOInfo>(soInfo);
var saleDiscountPromoInfoList = ObjectFactory <SaleDiscountRuleProcessor> .Instance.CalculateSOPromotion(soInfoClone, promotionList);
decimal totalSaleDiscountAmount = saleDiscountPromoInfoList.Sum(s => s.DiscountAmount.Value);
promotionList.AddRange(saleDiscountPromoInfoList);
//再次Clone,供Coupon计算使用
soInfoClone = SerializationUtility.DeepClone <SOInfo>(soInfo);
soInfoClone.BaseInfo.SOAmount = soInfoClone.BaseInfo.SOAmount.Value + allComboTotalDiscount + totalSaleDiscountAmount;
List <SOPromotionInfo> couponPromotionList = ObjectFactory <CouponsProcessor> .Instance.CalculateSOPromotion(soInfoClone, isModifyCoupons);
promotionList.AddRange(couponPromotionList);
return(promotionList);
}
/// <summary>
/// 获取促销结果
/// </summary>
/// <param name="origComboList"></param>
/// <param name="soInfo"></param>
/// <param name="soItemList"></param>
/// <param name="promotionInfoList"></param>
protected virtual void GetPromotionListForSO(List <ComboInfo> origComboList, SOInfo soInfo, ref List <SOItemInfo> soItemList, ref List <SOPromotionInfo> promotionInfoList)
{
//1.取当前订单商品有效的Combo
List <ComboInfo> validComboList = GetValidComboList(origComboList, soItemList);
if (validComboList.Count == 0)
{
return;
}
//2.按照这些可以参与活动的Combo列表，得到所有的折扣列表: 遵循最大Combo折扣优先原则，而不是客户最大折扣优先原则
List <ComboApplyInstance> comboApplyList = new List <ComboApplyInstance>();
foreach (ComboInfo combo in validComboList)
{
ComboApplyInstance comboApply = new ComboApplyInstance();
ComboInfo comboClone = SerializationUtility.DeepClone <ComboInfo>(combo);
comboApply.ComboSysNo = comboClone.SysNo.Value;
//获取当前Combo在订单中最多可以存在多少套: 取订单中满足该Combo商品中最小数量
int maxCount = int.MaxValue;
foreach (ComboItem comboItem in comboClone.Items)
{
SOItemInfo soItem = soItemList.Find(f => f.ProductSysNo == comboItem.ProductSysNo);
int curCount = soItem.Quantity.Value / comboItem.Quantity.Value;
if (curCount < maxCount)
{
maxCount = curCount;
}
}
comboApply.Qty = maxCount;
decimal totalDiscount = 0.00m;
foreach (ComboItem comboItem in comboClone.Items)
{
totalDiscount += Math.Round(comboItem.Discount.Value * comboItem.Quantity.Value * maxCount, 2);
}
//取Combo Total Discount的绝对值
comboApply.TotalDiscount = Math.Abs(totalDiscount);
comboApplyList.Add(comboApply);
}
//3.得到折扣从大到小排序的列表
var comboApplySortList = from p in comboApplyList
orderby p.TotalDiscount descending
select p;
//4.取最大折扣的Combo
ComboApplyInstance maxDiscountComboApply = comboApplySortList.First();
ComboInfo curCombo = validComboList.Find(f => f.SysNo.Value == maxDiscountComboApply.ComboSysNo);
SOPromotionInfo promotionInfo = GetPromotionInfoForCurrentCombo(curCombo, maxDiscountComboApply, ref soItemList,
promotionInfoList.Count + 1, soInfo.SysNo);
if (promotionInfo != null)
{
promotionInfoList.Add(promotionInfo);
}
//5.轮询调用剩下的订单商品
GetPromotionListForSO(validComboList, soInfo, ref soItemList, ref promotionInfoList);
}
void ContractPhoneSOSpliter_SubSOAssign(SOInfo subSOInfo)
{
if (CurrentSO.SIMCardAndContractPhoneInfo != null)
{
subSOInfo.SIMCardAndContractPhoneInfo = SerializationUtility.DeepClone(CurrentSO.SIMCardAndContractPhoneInfo);
subSOInfo.SIMCardAndContractPhoneInfo.SOSysNo = subSOInfo.SysNo;
}
}
public void Test_Invoice_NetPayEntityClone()
{
var now = DateTime.Now;
NetPayInfo netpayInfo = new NetPayInfo();
netpayInfo.ApproveTime = now;
netpayInfo.ApproveUserSysNo = 1;
netpayInfo.ChannelID = "channel";
netpayInfo.CompanyCode = "8601";
netpayInfo.ExternalKey = "externalkey";
netpayInfo.GiftCardPayAmt = 1000;
netpayInfo.MasterSoSysNo = 100000;
netpayInfo.Note = "note";
netpayInfo.OrderAmt = 1000;
netpayInfo.PayAmount = 1000;
netpayInfo.PayTypeSysNo = 1;
netpayInfo.PointPay = 1000;
netpayInfo.PrePayAmt = 1000;
netpayInfo.RelatedSoSysNo = 100000;
netpayInfo.ReviewedTime = now;
netpayInfo.ReviewedUserSysNo = 1;
netpayInfo.SOSysNo = 100000;
netpayInfo.Source = NetPaySource.Bank;
netpayInfo.Status = NetPayStatus.Abandon;
netpayInfo.SysNo = 1000;
var cloneNetPayInfo = SerializationUtility.DeepClone <NetPayInfo>(netpayInfo);
Assert.AreEqual(now, cloneNetPayInfo.ApproveTime);
Assert.AreEqual(1, cloneNetPayInfo.ApproveUserSysNo);
Assert.AreEqual("channel", cloneNetPayInfo.ChannelID);
Assert.AreEqual("8601", cloneNetPayInfo.CompanyCode);
Assert.AreEqual("externalkey", cloneNetPayInfo.ExternalKey);
Assert.AreEqual(1000, cloneNetPayInfo.GiftCardPayAmt);
Assert.AreEqual(100000, cloneNetPayInfo.MasterSoSysNo);
Assert.AreEqual("note", cloneNetPayInfo.Note);
Assert.AreEqual(1000, cloneNetPayInfo.OrderAmt);
Assert.AreEqual(1000, cloneNetPayInfo.PayAmount);
Assert.AreEqual(1, cloneNetPayInfo.PayTypeSysNo);
Assert.AreEqual(1000, cloneNetPayInfo.PointPay);
Assert.AreEqual(1000, cloneNetPayInfo.PrePayAmt);
Assert.AreEqual(100000, cloneNetPayInfo.RelatedSoSysNo);
Assert.AreEqual(now, cloneNetPayInfo.ReviewedTime);
Assert.AreEqual(1, cloneNetPayInfo.ReviewedUserSysNo);
Assert.AreEqual(100000, cloneNetPayInfo.SOSysNo);
Assert.AreEqual(NetPaySource.Bank, cloneNetPayInfo.Source);
Assert.AreEqual(NetPayStatus.Abandon, cloneNetPayInfo.Status);
Assert.AreEqual(1000, cloneNetPayInfo.SysNo);
}
public void DeepCloneTest()
{
var user1 = new User(0, "AAA");
var user2 = new User(1, "BBB");
var users = new List <User> {
user1, user2
};
var userCollection = new UserCollection(users);
var cloned = SerializationUtility.DeepClone(userCollection);
Assert.AreEqual(userCollection, cloned);
Assert.AreNotSame(userCollection, cloned);
Assert.AreNotSame(userCollection.Users, cloned.Users);
}
public static List <PayTypeInfo> GetAllPayTypeList()
{
string cacheKey = "Payment_GetAllPayTypeList";
if (HttpRuntime.Cache[cacheKey] != null)
{
return((List <PayTypeInfo>)HttpRuntime.Cache[cacheKey]);
}
List <PayTypeInfo> payTypeList = PaymentDA.GetAllPayTypeList();
var cachedPayTypeList = SerializationUtility.DeepClone(payTypeList);
HttpRuntime.Cache.Insert(cacheKey, cachedPayTypeList, null, DateTime.Now.AddSeconds(CacheTime.Longest), Cache.NoSlidingExpiration);
return(payTypeList);
}
public void Test_Invoice_PostPayEntityClone()
{
var now = DateTime.Now;
PostPayInfo postpayInfo = new PostPayInfo();
postpayInfo.ChannelID = "channel";
postpayInfo.CompanyCode = "8601";
postpayInfo.ConfirmedSOSysNo = 100000;
postpayInfo.GiftCardPay = 1000;
postpayInfo.MasterSoSysNo = 100000;
postpayInfo.Note = "note";
postpayInfo.OrderAmt = 1000;
postpayInfo.PayAmount = 1000;
postpayInfo.PayTypeSysNo = 1000;
postpayInfo.PointPay = 1000;
postpayInfo.PrepayAmt = 1000;
postpayInfo.RemainAmt = 1000;
postpayInfo.SOSysNo = 100000;
postpayInfo.Status = PostPayStatus.Yes;
postpayInfo.SysNo = 1000;
var clonePostPayInfo = SerializationUtility.DeepClone <PostPayInfo>(postpayInfo);
Assert.AreEqual("channel", clonePostPayInfo.ChannelID);
Assert.AreEqual("8601", clonePostPayInfo.CompanyCode);
Assert.AreEqual(100000, clonePostPayInfo.ConfirmedSOSysNo);
Assert.AreEqual(1000, clonePostPayInfo.GiftCardPay);
Assert.AreEqual(100000, clonePostPayInfo.MasterSoSysNo);
Assert.AreEqual("note", clonePostPayInfo.Note);
Assert.AreEqual(1000, clonePostPayInfo.OrderAmt);
Assert.AreEqual(1000, clonePostPayInfo.PayAmount);
Assert.AreEqual(1000, clonePostPayInfo.PayTypeSysNo);
Assert.AreEqual(1000, clonePostPayInfo.PointPay);
Assert.AreEqual(1000, clonePostPayInfo.PrepayAmt);
Assert.AreEqual(1000, clonePostPayInfo.RemainAmt);
Assert.AreEqual(100000, clonePostPayInfo.SOSysNo);
Assert.AreEqual(PostPayStatus.Yes, clonePostPayInfo.Status);
Assert.AreEqual(1000, clonePostPayInfo.SysNo);
}
/// <summary>
/// 保存单个子订单
/// </summary>
/// <param name="subSOInfo"></param>
protected virtual void SaveSubSO(SOInfo subSOInfo)
{
if (IsAutoSplit)
{
subSOInfo.StatusChangeInfoList = SerializationUtility.DeepClone(CurrentSO.StatusChangeInfoList);
}
//保存订单主信息
SODA.InsertSOMainInfo(subSOInfo);
//邮政自提
if (IsPostShip)
{
subSOInfo.ShippingInfo.PostInfo.SOSysNo = subSOInfo.SysNo;
SODA.InsertChinaPost(subSOInfo.ShippingInfo.PostInfo);
}
//添加增值税发票信息
if (subSOInfo.InvoiceInfo != null && subSOInfo.InvoiceInfo.IsVAT.Value && subSOInfo.InvoiceInfo.VATInvoiceInfo != null)
{
SODA.UpdateSOVATInvoice(subSOInfo.InvoiceInfo.VATInvoiceInfo);
}
SODA.InsertSOItemInfo(subSOInfo);
SODA.InsertSOCheckShippingInfo(subSOInfo);
//处理赠品信息 2011-8-29
foreach (SOPromotionInfo promotionInfo in subSOInfo.SOPromotions)
{
SODA.InsertSOPromotionInfo(promotionInfo, subSOInfo.CompanyCode);
}
//处理毛利分配信息
foreach (ItemGrossProfitInfo gross in subSOInfo.ItemGrossProfitList)
{
SODA.InsertSOItemGossProfit(gross);
}
}
/// <summary>
/// 子订单促销活动分摊
/// </summary>
/// <param name="masterSOInfo"></param>
/// <param name="subSOInfo"></param>
private void AssignSubSOPromotion(SOInfo subSOInfo)
{
#region 拆分订单的促销活动.
//拆分订单的促销活动.
if (CurrentSO.SOPromotions != null && CurrentSO.SOPromotions.Count > 0)
{
CurrentSO.SOPromotions.ForEach(promotion =>
{
SOPromotionInfo promotionInfo = SerializationUtility.DeepClone(promotion);
promotionInfo.SOSysNo = subSOInfo.SysNo;
switch (promotion.PromotionType)
{
case SOPromotionType.Combo:
break;
case SOPromotionType.Coupon:
if (promotionInfo.SOPromotionDetails != null && promotionInfo.SOPromotionDetails.Count > 0)
{
//移出主商品不在子订单中的促销明细
promotionInfo.SOPromotionDetails.RemoveAll(d =>
{
return(!subSOInfo.Items.Exists(subSOItem =>
{
return subSOItem.ProductSysNo == d.MasterProductSysNo;
}));
});
//计算子订单的总折扣
promotionInfo.DiscountAmount = promotionInfo.SOPromotionDetails.Sum <SOPromotionDetailInfo>(d => d.DiscountAmount);
}
if (promotionInfo.DiscountAmount == 0)
{
promotionInfo = null;
}
break;
case SOPromotionType.SelfGift:
//子订单中是否包含有赠品,没有就将促销设置为null.
if (!promotionInfo.GiftList.Exists(g =>
{
return(subSOInfo.Items.Exists(item =>
{
return item.ProductType == SOProductType.SelfGift && g.ProductSysNo == item.ProductSysNo;
}));
}))
{
promotionInfo = null;
}
break;
case SOPromotionType.VendorGift:
case SOPromotionType.Accessory:
//子订单是否包含附件或厂商赠品,如果没有就设置为null
if (promotionInfo.SOPromotionDetails != null && promotionInfo.GiftList.Count > 0)
{
//移出不在子订单中的附件
promotionInfo.GiftList.RemoveAll(g =>
{
return(!subSOInfo.Items.Exists(subSOItem =>
{
return promotion.PromotionType == SOPromotionType.Accessory ?
(subSOItem.ProductSysNo == g.ProductSysNo && subSOItem.ProductType == SOProductType.Accessory) :
(subSOItem.ProductSysNo == g.ProductSysNo && subSOItem.ProductType == SOProductType.Gift);
}));
});
////移出附件不在子订单中的附件明细
//if (promotionInfo.GiftList.Count < 1)
//{
// promotionInfo.SOPromotionDetails.RemoveAll(d =>
// {
// d.GiftList.RemoveAll(dg =>
// {
// return !promotionInfo.GiftList.Exists(g =>
// {
// return g.ProductSysNo == dg.ProductSysNo;
// });
// });
// return d.GiftList.Count == 0;
// });
//}
}
if (promotionInfo.GiftList.Count == 0)
{
promotionInfo = null;
}
break;
}
if (promotionInfo != null)
{
subSOInfo.SOPromotions.Add(promotionInfo);
}
});
}
#endregion
}
/// <summary>
/// 分摊子订单
/// </summary>
/// <param name="subSOList"></param>
private void CalculateSubSO(List <SOInfo> subSOList)
{
// 按金额升序排列，保证分摊的最后订单的金额最大，减少分摊误差。
subSOList.Sort((o1, o2) => { return(o1.BaseInfo.SOAmount.Value.CompareTo(o2.BaseInfo.SOAmount.Value)); });
decimal masterSOTotalPrice = CurrentSO.BaseInfo.PromotionAmount.Value; //计算金额基数
decimal masterSOTotalWeight = 0; //计算重量基数
CurrentSO.Items.ForEach(item =>
{
masterSOTotalPrice += item.Quantity.Value * item.OriginalPrice.Value;
masterSOTotalWeight += item.Quantity.Value * item.Weight.Value;
});
#region 分摊主的费用到子订单
int t_PointPay = CurrentSO.BaseInfo.PointPay.Value;
decimal t_ShipPrice = CurrentSO.BaseInfo.ShipPrice.Value;
decimal t_PayPrice = CurrentSO.BaseInfo.PayPrice.Value;
decimal t_PremiumAmt = CurrentSO.BaseInfo.PremiumAmount.Value;
decimal t_PrepayAmt = CurrentSO.BaseInfo.PrepayAmount.Value;
decimal t_PromotionValue = CurrentSO.BaseInfo.CouponAmount.Value;
decimal t_GiftCardPay = CurrentSO.BaseInfo.GiftCardPay.Value;
decimal?t_OriginShipPrice = CurrentSO.ShippingInfo.OriginShipPrice ?? 0;
decimal?t_PackageFee = CurrentSO.ShippingInfo.PackageFee ?? 0;
decimal?t_RegisteredFee = CurrentSO.ShippingInfo.RegisteredFee ?? 0;
decimal?t_ShippingFee = CurrentSO.ShippingInfo.ShippingFee ?? 0;
decimal?t_Weight3PL = CurrentSO.ShippingInfo.Weight3PL ?? 0;
decimal?t_WeightSO = CurrentSO.ShippingInfo.Weight ?? 0;
int subSOIndex = 0;
foreach (SOInfo soInfo in subSOList)
{
bool isLastSubSO = ++subSOIndex == subSOList.Count;
decimal subSOWeight = 0; //订单总重量
decimal subSOTotalPrice = 0; //订单去优惠券折扣后的总价
soInfo.BaseInfo.PromotionAmount = 0;
soInfo.BaseInfo.GainPoint = 0;
soInfo.BaseInfo.CouponAmount = 0;
soInfo.Items.ForEach(item =>
{
item.SOSysNo = soInfo.SysNo;
soInfo.BaseInfo.PromotionAmount += item.PromotionAmount.Value; //计算销售规则拆扣
soInfo.BaseInfo.GainPoint += item.GainPoint; //计算获得的积分
soInfo.BaseInfo.CouponAmount += item.CouponAmount; //计算优惠券折扣
subSOWeight += item.Weight.Value * item.Quantity.Value;
//价格引用Price，而不是OriginalPrice，因为总价中不包含优惠券折扣。
subSOTotalPrice += item.Quantity.Value * item.Price.Value + item.PromotionAmount.Value;
});
soInfo.ShippingInfo.Weight = subSOWeight;
#region 分摊订单费用
decimal weightRate = subSOWeight / (masterSOTotalWeight <= 0 ? 1 : masterSOTotalWeight); //重量分摊比例
decimal priceRate = subSOTotalPrice / (masterSOTotalPrice <= 0 ? 1 : masterSOTotalPrice); //金额分摊比例
if (!isLastSubSO) // 不是最后一个子订单
{
//根据重量来分摊运费
soInfo.BaseInfo.ShipPrice = UtilityHelper.ToMoney(CurrentSO.BaseInfo.ShipPrice.Value * weightRate);
t_ShipPrice -= soInfo.BaseInfo.ShipPrice.Value;
//根据价格来分摊积分支付
soInfo.BaseInfo.PointPay = (int)(Math.Round(CurrentSO.BaseInfo.PointPay.Value * priceRate));
t_PointPay -= soInfo.BaseInfo.PointPay.Value;
soInfo.BaseInfo.PointPayAmount = Convert.ToDecimal(soInfo.BaseInfo.PointPay) / ExternalDomainBroker.GetPointToMoneyRatio(); //计算积分支付
//根据价格来分摊手续费
soInfo.BaseInfo.PayPrice = UtilityHelper.ToMoney(CurrentSO.BaseInfo.PayPrice.Value * priceRate);
t_PayPrice -= soInfo.BaseInfo.PayPrice.Value;
//根据价格来分摊积保价费
soInfo.BaseInfo.PremiumAmount = UtilityHelper.ToMoney(CurrentSO.BaseInfo.PremiumAmount.Value * priceRate);
t_PremiumAmt -= soInfo.BaseInfo.PremiumAmount.Value;
//余额支付的分摊比例
decimal priceRate_Prepay = soInfo.BaseInfo.SOTotalAmount / (CurrentSO.BaseInfo.SOTotalAmount <= 0 ? 1 : CurrentSO.BaseInfo.SOTotalAmount);
//根据商品总价分摊余额支付
soInfo.BaseInfo.PrepayAmount = UtilityHelper.ToMoney(CurrentSO.BaseInfo.PrepayAmount.Value * priceRate_Prepay);//分摊余额支付
t_PrepayAmt -= soInfo.BaseInfo.PrepayAmount.Value;
//根据商品总价分摊礼品卡支付
soInfo.BaseInfo.GiftCardPay = UtilityHelper.ToMoney(CurrentSO.BaseInfo.GiftCardPay.Value * priceRate_Prepay);//分摊礼品支付
t_GiftCardPay -= soInfo.BaseInfo.GiftCardPay.Value;
}
else // 最后一个子订单
{
soInfo.BaseInfo.ShipPrice = UtilityHelper.ToMoney(t_ShipPrice);
soInfo.BaseInfo.PointPay = t_PointPay;
soInfo.BaseInfo.PointPayAmount = Convert.ToDecimal(soInfo.BaseInfo.PointPay) / ExternalDomainBroker.GetPointToMoneyRatio(); //计算积分支付
soInfo.BaseInfo.PayPrice = UtilityHelper.ToMoney(t_PayPrice);
soInfo.BaseInfo.PremiumAmount = UtilityHelper.ToMoney(t_PremiumAmt);
//余额支付的分摊比例
decimal priceRate_Prepay = soInfo.BaseInfo.SOTotalAmount / (CurrentSO.BaseInfo.SOTotalAmount <= 0 ? 1 : CurrentSO.BaseInfo.SOTotalAmount);
soInfo.BaseInfo.PrepayAmount = UtilityHelper.ToMoney(t_PrepayAmt);
soInfo.BaseInfo.GiftCardPay = UtilityHelper.ToMoney(t_GiftCardPay);
}
if (CurrentSO.SOGiftCardList.Count > 0)
{
decimal itemGiftCardPay = soInfo.BaseInfo.GiftCardPay.Value;
foreach (ECCentral.BizEntity.IM.GiftCardRedeemLog giftCard in CurrentSO.SOGiftCardList)
{
if (itemGiftCardPay <= 0)
{
break;
}
if (giftCard.Amount <= 0)
{
continue;
}
if (giftCard.Amount >= itemGiftCardPay)
{
giftCard.Amount -= itemGiftCardPay;
soInfo.SOGiftCardList.Add(new ECCentral.BizEntity.IM.GiftCardRedeemLog
{
Code = giftCard.Code,
Amount = itemGiftCardPay
});
itemGiftCardPay = 0;
break;
}
else
{
itemGiftCardPay -= giftCard.Amount.Value;
soInfo.SOGiftCardList.Add(new ECCentral.BizEntity.IM.GiftCardRedeemLog
{
Code = giftCard.Code,
Amount = giftCard.Amount
});
giftCard.Amount = 0;
}
if (itemGiftCardPay == 0M)
{
break;
}
}
}
if (IsAutoSplit)
{
soInfo.BaseInfo.Status = SOStatus.WaitingOutStock;//拆分后子单为待出库状态
}
else
{
soInfo.BaseInfo.Status = SOStatus.Origin;//拆分后子单为待审核状态
}
//拆单后需要重新计算每个子单是否是大件
soInfo.BaseInfo.IsLarge = SOCommon.ValidateIsLarge(soInfo.ShippingInfo.Weight.Value); // 是否大件商品
if (!isLastSubSO)
{
soInfo.ShippingInfo.OriginShipPrice = UtilityHelper.ToMoney((CurrentSO.ShippingInfo.OriginShipPrice ?? 0) * weightRate);
t_OriginShipPrice -= soInfo.ShippingInfo.OriginShipPrice;
soInfo.ShippingInfo.PackageFee = UtilityHelper.ToMoney((CurrentSO.ShippingInfo.PackageFee ?? 0) * weightRate);
t_PackageFee -= soInfo.ShippingInfo.PackageFee;
soInfo.ShippingInfo.RegisteredFee = UtilityHelper.ToMoney((CurrentSO.ShippingInfo.RegisteredFee ?? 0) * weightRate);
t_RegisteredFee -= soInfo.ShippingInfo.RegisteredFee;
soInfo.ShippingInfo.ShippingFee = UtilityHelper.ToMoney((CurrentSO.ShippingInfo.ShippingFee ?? 0) * weightRate);
t_ShippingFee -= soInfo.ShippingInfo.ShippingFee;
soInfo.ShippingInfo.Weight3PL = (int)((CurrentSO.ShippingInfo.Weight3PL ?? 0) * weightRate);
t_Weight3PL -= soInfo.ShippingInfo.Weight3PL;
soInfo.ShippingInfo.Weight = (int)((CurrentSO.ShippingInfo.Weight ?? 0) * weightRate);
t_WeightSO -= soInfo.ShippingInfo.Weight;
}
else
{
soInfo.ShippingInfo.OriginShipPrice = t_OriginShipPrice;
soInfo.ShippingInfo.PackageFee = t_PackageFee;
soInfo.ShippingInfo.RegisteredFee = t_RegisteredFee;
soInfo.ShippingInfo.ShippingFee = t_ShippingFee;
soInfo.ShippingInfo.Weight3PL = t_Weight3PL;
soInfo.ShippingInfo.Weight = t_WeightSO;
}
#endregion
AssignSubSOPromotion(soInfo);
AssignSubSOInvoice(soInfo);
if (SubSOAssign != null)
{
SubSOAssign(soInfo);
}
List <ItemGrossProfitInfo> gorsses = new List <ItemGrossProfitInfo>();
foreach (ItemGrossProfitInfo gross in CurrentSO.ItemGrossProfitList)
{
foreach (SOItemInfo item in soInfo.Items)
{
if (gross.ProductSysNo == item.ProductSysNo)
{
ItemGrossProfitInfo subgross = SerializationUtility.DeepClone(gross);
subgross.SOSysNo = soInfo.SysNo.Value;
soInfo.ItemGrossProfitList.Add(subgross);
}
}
}
}
#endregion
}
/// <summary>
/// 拆分当前订单
/// </summary>
private void SplitCurrentSO()
{
#region 拆分订单
List <SOItemInfo> couponList = new List <SOItemInfo>(); //订单使用的优惠券
List <SOItemInfo> extendWarrentyList = new List <SOItemInfo>(); //订单的所有延保
List <int> stockSysNoList = new List <int>();
CurrentSO.Items.ForEach(item =>
{
switch (item.ProductType.Value)
{
case SOProductType.Product:
case SOProductType.Gift:
case SOProductType.Award:
case SOProductType.Accessory:
case SOProductType.SelfGift:
{
if (!stockSysNoList.Exists(stockSysNo => { return(stockSysNo == item.StockSysNo && item.StockSysNo != null); }))
{
stockSysNoList.Add(item.StockSysNo.Value);
}
break;
}
case SOProductType.Coupon:
couponList.Add(item);
break;
case SOProductType.ExtendWarranty:
extendWarrentyList.Add(item);
break;
}
});
if (stockSysNoList.Count < 2)
{
BizExceptionHelper.Throw("SO_Split_NotSplit");
return;
}
foreach (int stockSysNo in stockSysNoList)
{
SOInfo soInfo = CreateSubSO();
//取得子订单的商品
soInfo.Items = SerializationUtility.DeepClone <List <SOItemInfo> >(CurrentSO.Items.FindAll(item => item.StockSysNo == stockSysNo));
//修改ItemsExtenstion
if (soInfo.Items != null && soInfo.Items.Count > 0)
{
foreach (var item in soInfo.Items)
{
if (item.ItemExtList != null && item.ItemExtList.Count > 0)
{
item.ItemExtList.ForEach(x => { x.SOSysNo = soInfo.SysNo.Value; });
}
}
}
//添加优惠券到每个仓库
if (couponList != null && couponList.Count > 0)
{
soInfo.Items.AddRange(SerializationUtility.DeepClone(couponList));
}
//延保跟随主商品
extendWarrentyList.ForEach(item =>
{
if (soInfo.Items.Exists(o => o.ProductSysNo == int.Parse(item.MasterProductSysNo)))
{
soInfo.Items.Add(SerializationUtility.DeepClone <SOItemInfo>(item));
}
});
//计算总金额
soInfo.BaseInfo.SOAmount = UtilityHelper.ToMoney(soInfo.Items.Sum <SOItemInfo>(item =>
{
if (item.ProductType == SOProductType.Product || item.ProductType == SOProductType.ExtendWarranty)
{
return(item.OriginalPrice.Value * item.Quantity.Value);
}
return(0);
}));
//soInfo.ShippingInfo.DeliveryFrequency = SetDeliveryType(soInfo);//设置订单的配置频率
SetSOCCheckShippingSettlementStatus(soInfo);
SubSOList.Add(soInfo);
}
#endregion
}
/// <summary>
/// 加载代销结算单详细
/// </summary>
/// <param name="settlementSysNo"></param>
/// <returns></returns>
public virtual CollectionPaymentInfo Create(CollectionPaymentInfo entity)
{
//去除已经删除的Item（SysNo=-1） 次方法已经在Portal加过了，此处只为以防万一了
entity.SettleItems = (from tItem in entity.SettleItems
where tItem.SettleSysNo != -1
select tItem).ToList();
string OperationIP = string.Empty;
string OperationUserUniqueName = string.Empty;
VerifyCreate(entity);
VerifySettleItems(entity, SettlementVerifyType.CREATE);
VerifyProductPMSysNo(entity);
//VerityOverConsignRuleQuantity(entity);
//entity.CreateUserSysNo = SystemUserHelper.GetUserSystemNumber(BusinessContext.Current.OperationUserFullName,
// BusinessContext.Current.OperationUserSourceDirectoryKey, BusinessContext.Current.OperationUserLoginName,
// BusinessContext.Current.CompanyCode);
entity.CreateUserSysNo = entity.CurrentUserSysNo;;
entity.CreateTime = DateTime.Now;
entity.Status = POCollectionPaymentSettleStatus.Origin;
//修改代销转财务记录的状态
foreach (var item in entity.SettleItems)
{
item.ConsignToAccLogInfo.ConsignToAccStatus = ConsignToAccountLogStatus.ManualCreated;
//item.
}
//用于收集操作过的结算单
List <CollectionPaymentInfo> settleEntityList = new List <CollectionPaymentInfo>();
//计算返点,返点总额将会平均分配到以下结算单，当返点总额大于单个结算单的返点额，那单个结算单返点将和计算单总额相等
//剩余返点额将在下个结算单中使用
decimal totalUsingReturnPoint = entity.UsingReturnPoint ?? 0;
using (TransactionScope scope = new TransactionScope())
{
//按照仓库的不同自动分结算单
var stockSysNoList = entity.SettleItems.Select(p => p.ConsignToAccLogInfo.StockSysNo).Distinct();
foreach (int?stockSysNo in stockSysNoList)
{
//需要深度赋值新的类
var newEntity = SerializationUtility.DeepClone <CollectionPaymentInfo>(entity);
newEntity.SourceStockInfo.SysNo = stockSysNo;
var tempSettleList = new List <CollectionPaymentItem>();
tempSettleList.AddRange(newEntity.SettleItems.Where(p => p.ConsignToAccLogInfo.StockSysNo == stockSysNo));
//计算总结算数
newEntity.TotalAmt = tempSettleList.Sum(p => p.Cost * p.ConsignToAccLogInfo.ProductQuantity.Value);
newEntity.SettleItems = tempSettleList;
//判断规则数量是否还有剩余
newEntity = CollectionPaymentDA.Create(newEntity);
entity.SysNo = newEntity.SysNo;
//将操作完成的收集在临时列表中
settleEntityList.Add(newEntity);
}
//更新代销转财务记录状态
settleEntityList.ForEach(x =>
{
UpdateConsignToAccLogStatus(x);
});
//发送ESB消息
EventPublisher.Publish <CollectionPaymentCreateMessage>(new CollectionPaymentCreateMessage()
{
CurrentUserSysNo = ServiceContext.Current.UserSysNo,
SysNo = entity.SysNo.Value
});
scope.Complete();
}
foreach (var newEntity in settleEntityList)
{
//执行其它操作
newEntity.OperationIP = OperationIP;
newEntity.OperationUserSysNumber = entity.CreateUserSysNo;
newEntity.OperationUserUniqueName = OperationUserUniqueName;
//CommonService.WriteLog<CollectionPaymentEntity>(newEntity, " Create VendorSettle ", newEntity.SysNo.Value.ToString(), (int)LogType.CollectionPayment_Create);
VendorInfo vendor = VendorDA.LoadVendorInfo(newEntity.VendorInfo.SysNo.Value);
if (vendor.VendorFinanceInfo.IsAutoAudit != null && vendor.VendorFinanceInfo.IsAutoAudit == true)
{
try
{
Audit(newEntity);
}
catch (Exception ex)
{
//MailService.SendMail(ConfigurationManager.AppSettings["VendorSettleFrom"], ConfigurationManager.AppSettings["VendorSettleTo"], "代销结算单自动审核", newEntity.SysNo.ToString() + ":" + ex.ErrorDescription);
}
//自动结算
entity = Settle(newEntity);
}
}
return(entity);
}
public void UpdateAdjustQuantityOfSTB(List <InventoryBatchDetailsInfo> model, int inputDocumentNumber, string inputType, string inputAction)
{
if (model == null || model.Count == 0)
{
AbandonSTBInfo(inputDocumentNumber, inputType, inputAction);
}
else
{
//获取数据库重更新前的数量
List <InventoryBatchDetailsInfo> originalInventoryBatchDetailsInfolist = ObjectFactory <IInventoryAdjustDA> .Instance.GetBatchDetailsInfoEntityListByNumber(Convert.ToInt32(inputDocumentNumber));
List <int> deleteItemSysNoList = new List <int>();
List <InventoryBatchDetailsInfo> deleteBatchInfoList = new List <InventoryBatchDetailsInfo>();
if (originalInventoryBatchDetailsInfolist != null)
{
originalInventoryBatchDetailsInfolist.ForEach(p =>
{
if (model != null)
{
var count = model.Where(k => k.ProductSysNo == p.ProductSysNo).Count();
if (count == 0)
{
deleteItemSysNoList.Add(p.ProductSysNo);
}
}
var c = model.Where(k => k.ProductSysNo == p.ProductSysNo && k.BatchNumber == p.BatchNumber && k.StockSysNo == p.StockSysNo).Count();
if (c == 0)
{
var clone = SerializationUtility.DeepClone <InventoryBatchDetailsInfo>(p);
clone.Quantity = 0;
deleteBatchInfoList.Add(clone);
}
});
}
//把需要删除的批次加入
model.AddRange(deleteBatchInfoList);
using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required, new TimeSpan(0, 5, 0)))
{
//损益单 调整需要 特殊处理
if (inputType.Equals("Adjust") && inputAction.Equals("Create"))//损益单创建 输入正值 不调占用库存
{
InnerAdjustMethod(model, inputDocumentNumber, deleteItemSysNoList, "AD", "Create", originalInventoryBatchDetailsInfolist);
}
else if (inputType.Equals("Lend") && inputAction.Equals("Create"))//借货单创建 更新
{
InnerLendMethod(model, inputDocumentNumber, deleteItemSysNoList, "LD", "Create", originalInventoryBatchDetailsInfolist);
}
else if (inputType.Equals("Lend") && inputAction.Equals("Return"))//借货单归还 更新实际库存
{
//更新 ST_Batch Quantity 和ReturnQty
ObjectFactory <IInventoryAdjustDA> .Instance.UpdateSTBInfo(model, inputDocumentNumber, "LD", "Return");
//拼XML 调用TankSP调整 实际库存
InnerReturndMethod(model, inputDocumentNumber, inputType, inputAction);
//发送SSB 到仓库
ObjectFactory <LendRequestProcessor> .Instance.ReturnSendSSBToWMS(inputDocumentNumber, model[0].StockSysNo.ToString(), model, null, "借货单归还向仓库发送SSB");
}
else if (inputType.Equals("Convert") && inputAction.Equals("Create"))//转换单创建 目标商品不调占用库存
{
List <InventoryBatchDetailsInfo> OriginalSourceInventoryBatchDetailsInfolist = new List <InventoryBatchDetailsInfo>();
if (originalInventoryBatchDetailsInfolist != null && originalInventoryBatchDetailsInfolist.Count > 0)
{
OriginalSourceInventoryBatchDetailsInfolist = originalInventoryBatchDetailsInfolist.FindAll(x => { return(x.ReturnQty == 0); });
}
//找到源商品中被删除的商品
deleteItemSysNoList.Clear();
deleteBatchInfoList.Clear();
if (originalInventoryBatchDetailsInfolist != null)
{
var originSourceBatchDetailsInfoList = originalInventoryBatchDetailsInfolist.Where(p => p.ReturnQty == 0).ToList();
originSourceBatchDetailsInfoList.ForEach(p =>
{
if (model != null)
{
var count = model.Where(k => k.ProductSysNo == p.ProductSysNo).Count();
if (count == 0)
{
deleteItemSysNoList.Add(p.ProductSysNo);
}
var c = model.Where(k => k.ProductSysNo == p.ProductSysNo && k.BatchNumber == p.BatchNumber && k.StockSysNo == p.StockSysNo).Count();
if (c == 0)
{
var clone = SerializationUtility.DeepClone <InventoryBatchDetailsInfo>(p);
clone.Quantity = 0;
deleteBatchInfoList.Add(p);
}
}
});
}
model.AddRange(deleteBatchInfoList);
InnerConvertMethod(model, inputDocumentNumber, deleteItemSysNoList, "TR", "Create", OriginalSourceInventoryBatchDetailsInfolist);
}
else if (inputType.Equals("Convert") && inputAction.Equals("Target"))//转换单创建 目标商品不调占用库存
{
//找到目标商品中被删除的商品
deleteItemSysNoList.Clear();
deleteBatchInfoList.Clear();
if (originalInventoryBatchDetailsInfolist != null)
{
var originTargetBatchDetailsInfoList = originalInventoryBatchDetailsInfolist.Where(p => p.ReturnQty != 0).ToList();
originTargetBatchDetailsInfoList.ForEach(p =>
{
if (model != null)
{
var count = model.Where(k => k.ProductSysNo == p.ProductSysNo).Count();
if (count == 0)
{
deleteItemSysNoList.Add(p.ProductSysNo);
}
var c = model.Where(k => k.ProductSysNo == p.ProductSysNo && k.BatchNumber == p.BatchNumber && k.StockSysNo == p.StockSysNo).Count();
if (c == 0)
{
var clone = SerializationUtility.DeepClone <InventoryBatchDetailsInfo>(p);
clone.Quantity = 0;
deleteBatchInfoList.Add(p);
}
}
});
}
model.AddRange(deleteBatchInfoList);
if (deleteItemSysNoList.Count > 0)
{
foreach (var item in deleteItemSysNoList)
{
ObjectFactory <IInventoryAdjustDA> .Instance.DeleteBatchItemOfSTB(item, inputDocumentNumber);
}
}
ObjectFactory <IInventoryAdjustDA> .Instance.TargetUpdateSTBInfo(model, inputDocumentNumber, "TR");
}
scope.Complete();
}
}
}
protected virtual void CalculateVendorGift(SOInfo soInfo)
{
//找出所有的GiftVendor的promotion
if (soInfo.SOPromotions.Count > 0)
{
var vendorPromotions = soInfo.SOPromotions.FindAll(x => (x.PromotionType == SOPromotionType.VendorGift));
if (vendorPromotions.Count > 0)
{
List <SOItemInfo> itemsInSO = SerializationUtility.DeepClone <List <SOItemInfo> >(soInfo.Items);
//删除没有主商品和赠品的Promotion
for (int i = vendorPromotions.Count - 1; i >= 0; i--)
{
if (!itemsInSO.Exists(item => item.ProductSysNo == vendorPromotions[i].MasterList[0].ProductSysNo) ||
!itemsInSO.Exists(x => vendorPromotions[i].GiftList.Exists(y => y.ProductSysNo == x.ProductSysNo)))
{
soInfo.SOPromotions.Remove(vendorPromotions[i]);
vendorPromotions.RemoveAt(i);
}
}
//计算每个Promotion的最大赠品数量
foreach (var promotion in vendorPromotions)
{
promotion.SOSysNo = soInfo.SysNo;
//主商品
var master = itemsInSO.First(item => item.ProductSysNo == promotion.MasterList[0].ProductSysNo);
//次数
int times = master.Quantity.Value;
foreach (var giftInPromotion in promotion.GiftList)
{
//赠品的最大数量
int Ratio = SOItemDA.GetRatioOfGift(master.ProductSysNo.Value, promotion.PromotionSysNo.Value, giftInPromotion.ProductSysNo);
int maxGiftQty = times * Ratio;
//找到SO里对应赠品
var giftInSO = itemsInSO.FirstOrDefault(x => x.ProductSysNo == giftInPromotion.ProductSysNo);
//跟新Promotional的实际赠品数量
int realQty = giftInSO == null ? 0 : giftInSO.Quantity >= maxGiftQty ? maxGiftQty : giftInSO.Quantity.Value;
giftInPromotion.Quantity = realQty;
//扣去被占用的数量
giftInSO.Quantity -= realQty;
}
}
//没有主商品的赠品
var noMasterGifts = itemsInSO.Where(item => item.Quantity > 0 && item.ProductType == SOProductType.Gift);
//移除这些赠品
foreach (var noMasterGift in noMasterGifts)
{
for (int i = soInfo.Items.Count - 1; i >= 0; i--)
{
if (soInfo.Items[i].ProductSysNo == noMasterGift.ProductSysNo)
{
int adjustQty = soInfo.Items[i].Quantity.Value - noMasterGift.Quantity.Value;
if (adjustQty > 0)
{
soInfo.Items[i].Quantity = adjustQty;
}
else
{
soInfo.Items.RemoveAt(i);
}
}
}
}
}
}
}
public virtual T DeepClone()
{
return(SerializationUtility.DeepClone(this as T));
}
