zszq-trs/YLErpDAL/Modules/TradeModule/OrderModule/TradeInvalidService.cs

using YLErp.BLL;

namespace YLErp.Modules.TradeModule.OrderModule
{
    /// <summary>
    /// 交易删除
    /// </summary>
    public class TradeInvalidService : TradeServiceBase
    {
        public TradeInvalidService(OptUserInfo userInfo) : base(userInfo)
        {
        }

        public TradeInvalidService(YLBaseService baseService) : base(baseService)
        {
        }

        /// <summary>
        /// 无效某条交易
        /// </summary>
        public void InvalidTrade(int id, bool needCheckStatus)
        {
            var dbTrade = DbContext.trade.Find(id);

            InvalidTrade(dbTrade, needCheckStatus);
        }

        /// <summary>
        /// 无效某条交易
        /// </summary>
        public void InvalidTrade(string tradeNumber, bool needCheckStatus)
        {
            if (string.IsNullOrWhiteSpace(tradeNumber))
            {
                throw new ArgumentException($"“{nameof(tradeNumber)}”不能为 null 或空白。", nameof(tradeNumber));
            }

            var dbTrade = DbContext.trade.FirstOrDefault(n => n.TradeNumber == tradeNumber);

            InvalidTrade(dbTrade, needCheckStatus);
        }

        /// <summary>
        /// 无效某条交易
        /// </summary>
        private void InvalidTrade(trade dbTrade, bool needCheckStatus)
        {
            if (dbTrade == null)
            {
                throw new ServiceException("找不到交易信息");
            }

            if (needCheckStatus && dbTrade.TradeStatus != ConsTrade.新增待确认 && dbTrade.TradeStatus != ConsTrade.修改待确认 && dbTrade.TradeStatus != ConsTrade.已拒绝 && (!PS.Config.IsGuoJun ? dbTrade.TradeStatus != ConsTrade.确认成交 : true))
            {
                throw new ServiceException($"交易状态为{dbTrade.TradeStatus}，不能被删除。");
            }

            //结构化交易删除子交易，则主交易相关所有记录均会被删除
            if (dbTrade.ParentTradeId > 0 && dbTrade.TradeType != "收益互换")
            {
                dbTrade = DbContext.trade.Find(dbTrade.ParentTradeId);

                if (dbTrade == null)
                {
                    throw new ServiceException("找不到结构化交易信息");
                }
            }

            var ids = new HashSet<int> { dbTrade.id };

            if (dbTrade.TradeType == "结构化交易" || dbTrade.IsGroup == 1)
            {
                var subTrades = DbContext.trade.Where(t => t.ParentTradeId == dbTrade.id).ToList();

                InnerInvalidTrade(dbTrade);

                foreach (var subTrade in subTrades)
                {
                    ids.Add(subTrade.id);

                    InnerInvalidTrade(subTrade);
                }
            }
            else
            {
                InnerInvalidTrade(dbTrade);

                //组合收益互换
                if (dbTrade.ParentTradeId > 0)
                {
                    var parentTrade = DbContext.trade.Find(dbTrade.ParentTradeId);
                    if (parentTrade != null)
                    {
                        parentTrade.OriginalStockEqvNotional -= dbTrade.OriginalStockEqvNotional;
                        parentTrade.StockEqvNotional -= dbTrade.StockEqvNotional;
                        parentTrade.StockEqvNotionalReal -= dbTrade.StockEqvNotionalReal;
                        var tradePrice = (parentTrade.TradePrice ?? 0) * (parentTrade.BuySell == "买入" ? -1 : 1) - (dbTrade.TradePrice ?? 0) * (dbTrade.BuySell == "买入" ? -1 : 1);
                        parentTrade.TradePrice = Math.Abs(tradePrice);
                        parentTrade.BuySell = tradePrice >= 0 ? "卖出" : "买入";
                        if (parentTrade.StockEqvNotional <= 0)
                        {
                            parentTrade.TradeStatus = "已平仓";
                        }
                    }

                    var swapDetail = DbContext.trade_swap_detail.FirstOrDefault(x => x.ChildTradeId == dbTrade.id);
                    if (swapDetail != null)
                    {
                        swapDetail.ValidState = "InValid";
                    }
                }

                if (dbTrade.TradeType == "收益互换" && PS.Config.IsGuoJun)
                {
                    var flowid = DbContext.trade_swap.Where(x => x.TradeId == dbTrade.id).Select(x => x.FlowId).ToList();
                    var swapflowmore = DbContext.trade_swap_flow_more.Where(x => flowid.Contains(x.id)).ToList();
                    swapflowmore.ForEach(x =>
                    {
                        x.IsDelete = true;
                    });
                }
            }

            //设置相关提成失效
            SetCommissionInVaild(ids);

            DbContext.SaveChanges();
        }

        public void InnerInvalidTrade(trade dbTrade)
        {
            dbTrade.OptId = UserId;
            dbTrade.OptName = UserName;
            dbTrade.OptDate = OptDate;
            dbTrade.ValidState = ConsGlobal.InValid;

            if (!string.IsNullOrWhiteSpace(dbTrade.TradeNumber))
            {
                var contractBll = new TradeContractBLL(UserId, UserName);
                contractBll.DeleteConfirmBook(dbTrade.id);
                if (dbTrade.TradeNumber.StartsWith("CW"))
                {
                    dbTrade.TradeNumber = dbTrade.TradeNumber.Replace("CW", "XX");
                }
                else //if (PS.Config.Is光大光子)
                {
                    dbTrade.TradeNumber = dbTrade.TradeNumber.Insert(0, "XX");
                }
            }

            var tradeMarginTemplates = DbContext.trade_margin_template.Where(x => x.TradeId == dbTrade.id);
            if(tradeMarginTemplates.Any())
            {
                DbContext.trade_margin_template.RemoveRange(tradeMarginTemplates);
            }

            RemoveEodTradeAndFutureInfo(true, dbTrade.id, DateTime.MinValue);
            new DealModule.TradeConfirmService(this).EditReportStatus(dbTrade.id);
            AddTradeOperationHistoryAndSetParentTradeInfo(true, dbTrade, "删除交易");
        }

        //设置相关提成失效
        public void SetCommissionInVaild(HashSet<int> tradeIds)
        {
            var commissions = DbContext.SalesCommissionInfo.Where(o => tradeIds.Contains(o.TradeID)).ToArray();

            foreach (var item in commissions)
            {
                item.IsValid = false;
                item.OptDate = DateTime.Now;
            }
        }

        /// <summary>
        /// 批量删除当日交易‘新增待确认’状态的交易
        /// </summary>
        public int InvalidTodayUnconfirmedTrades(HashSet<int> ids)
        {
            if (ids is null || !ids.Any())
            {
                return 0;
            }

            var valueDate = valuedateBLL.ValueDate;
            var tradeList = DbContext.trade.Where(t => t.TradeDate == valueDate && ids.Contains(t.id) && t.ValidState != ConsGlobal.InValid && t.TradeStatus == ConsTrade.新增待确认).ToList();
            if (!tradeList.Any())
            {
                return 0;
            }

            var pids = tradeList.Select(n => n.ParentTradeId).ToHashSet();
            pids.Remove(0);
            if (pids.Any())
            {
                var pTrades = DbContext.trade.Where(t => t.TradeDate == valueDate && !ids.Contains(t.id) && (pids.Contains(t.id) || pids.Contains(t.ParentTradeId))).ToArray();

                tradeList.AddRange(pTrades);
            }

            var childrenTrades = DbContext.trade.Where(t => t.TradeDate == valueDate && !ids.Contains(t.id) && ids.Contains(t.ParentTradeId)).ToArray();
            if (childrenTrades.Any())
            {
                tradeList.AddRange(childrenTrades);
            }

            foreach (var t in tradeList)
            {
                ids.Add(t.id);
                InnerInvalidTrade(t);
            }

            SetCommissionInVaild(ids);

            DbContext.SaveChanges();

            return tradeList.Count;
        }
    }
}