zszq-trs/YLErpDAL/Modules/SwapModule/SwapEndConfirmService.cs

using BaseOUDAL;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using YLErp.Model.Enum;
using YLErp.Model;
using YLErp.DBModels.Consts;
using System.Linq.Expressions;
using YLErp.QdpModule;
using static YLErp.ConsGlobal;

namespace YLErp.Modules.SwapModule
{
    public class SwapEndConfirmService : YLBaseService
    {
        public SwapEndConfirmService(OptUserInfo optUser) : base(optUser)
        {

        }
        /// <summary>
        /// 查询 到期结算报告和提前终止报告
        /// </summary>
        public SearchListResult<SwapTradeContractGroup> SearchEitherTradeWithCashList(SwapEndConfirmReq req)
        {
            var db = DbContext;
            var actionList = new List<int>() { (int)SwapEventTypeEnum.平仓,(int)SwapEventTypeEnum.合成持仓 };
            var types = new List<string>() { ContractTypeEnum.Clearing, ContractTypeEnum.UnWind };
            var flowQuery= PredicateBuilder.Create<swap_flow_event>(n => actionList.Contains(n.EventType) && n.PayDirection > 0);
            var eventQuery = PredicateBuilder.Create<swap_event>(n => actionList.Contains(n.EventType) && !n.Invalid);
            var tradeQuery = buildTradeQuery(req);
            if (!string.IsNullOrEmpty(req.UnderlyingCodes))
            {
                flowQuery = flowQuery.And(d => req.UnderlyingCodeList.Contains(d.UnderlyingCode));
            }
            if (req.UnWindDateEnd == null)
            {
                req.UnWindDateEnd = DateTime.MaxValue;
            }
            if (req.UnWindDateStart == null)
            {
                req.UnWindDateStart = DateTime.MinValue;
            }
            eventQuery = eventQuery.And(d => d.ValueDate >= req.UnWindDateStart && d.ValueDate <= req.UnWindDateEnd);
            var query = from trade in db.trade.Where(tradeQuery)
                        join swapEvent in db.swap_event.Where(eventQuery) on trade.id equals swapEvent.SwapTradeId
                        join flowEvent in db.swap_flow_event.Where(flowQuery) on swapEvent.id equals flowEvent.EventId
                        join position in db.swap_position on flowEvent.PositionId equals position.PositionId
                        join tcrConfirm in db.trade_contract_r.Where(O => O.Type == ContractTypeEnum.Trade && O.IsValid) on trade.id equals tcrConfirm.TradeId into tcrConfirms
                        from tcrConfirm in tcrConfirms.DefaultIfEmpty()
                        select new SwapTradeContractGroup
                        {
                            id = flowEvent.id,
                            trade = trade,
                            swap_flow_event= flowEvent,
                            swap_event= swapEvent,
                            swap_position = position,
                            ConfirmContractR= tcrConfirm,
                        };
            query = query.OrderByDescending(s => s.swap_flow_event.id);
            var retListResult = query.ToSearchList(req, isWithOrder: false);

            var tradeIds = retListResult.rows.Select(s=>s.swap_flow_event.SwapTradeId).Distinct().ToList();
            var underlyingCodes = retListResult.rows.Select(r => r.swap_flow_event.UnderlyingCode).ToList();
            var underlyings = DbContext.underlying_manager.Where(x => underlyingCodes.Contains(x.UnderlyingCode)).AsNoTracking().ToList();
            List<trade_extend> extendList = DbContext.trade_extend.AsNoTracking().Where(p => tradeIds.Contains(p.TradeId)).ToList();
            if (extendList == null)
            {
                extendList = new List<trade_extend>();
            }
            foreach (var x in retListResult.rows)
            {
                x.trade_contract_r = db.trade_contract_r.Where(O => types.Contains(O.Type) && O.IsValid&&O.TradeId==x.trade.id&&O.SwapFlowEventId==x.swap_flow_event.id).FirstOrDefault();
                var swapEventFlow = x.swap_flow_event;
                var um = underlyings.FirstOrDefault(x => x.UnderlyingCode == swapEventFlow.UnderlyingCode);
                if (um != null && um.IsBond())
                {
                    x.swap_flow_event.TradingAmountAvg *= ConsGlobal.bondShowPriceMultiple;
                    x.swap_flow_event.TradingAmountFeeAvg *= ConsGlobal.bondShowPriceMultiple;
                    x.swap_flow_event.TradingAmountNetAvg *= ConsGlobal.bondShowPriceMultiple;
                    x.swap_flow_event.TradingAmountNetFeeAvg *= ConsGlobal.bondShowPriceMultiple;
                }
                if (x.trade_contract_r != null)
                {
                    GetTradeDocumentResults(req, x);
                }
                if (x.swap_event!=null)
                {
                    x.swap_event.unwindData = JsonHelper.Deserialize<UnwindData>(x.swap_event.EventData);
                    if (x.trade.StructureType=="多空组合")
                    {
                        UnwindData unwindData = new UnwindData();
                        unwindData.SwapCloseAmount = x.swap_flow_event.MarkClosePnl;
                        x.swap_event.unwindData= unwindData;
                    }
                }
                var extend = extendList.FirstOrDefault(p => p.TradeId == x.swap_flow_event.SwapTradeId);
                if (x.swap_flow_event.PayDate == null || x.swap_flow_event.EventType != (int)SwapEventTypeEnum.平仓)
                {
                    if (extend != null)
                    {
                        x.swap_flow_event.PayDate = x.swap_flow_event.EventDate.AddDays(extend.ExtendObj.SettlementRules);
                    }
                }
            }
            return retListResult;
        }

        private Expression<Func<trade,bool>> buildTradeQuery(SwapEndConfirmReq req)
        {
            var tradeQuery = PredicateBuilder.Create<trade>(n => n.TradeType == "收益互换" && n.ValidState != ConsGlobal.InValid);
            if (req.UserAssets != null && req.UserClients != null)
            {
                tradeQuery = tradeQuery.And(x => req.UserAssets.Contains(x.AssetId) || req.UserClients.Contains(x.ClientId));
            }
            if (!string.IsNullOrEmpty(req.TradeNumber))
            {
                tradeQuery = tradeQuery.And(d => d.TradeNumber.Contains(req.TradeNumber));
            }
            if (req.StartDateStart != DateTime.MinValue)
            {
                tradeQuery = tradeQuery.And(d => d.StartDate >= req.StartDateStart);
            }
            if (req.StartDateEnd != DateTime.MinValue)
            {
                var StartDateTemp = req.StartDateEnd.AddDays(1);
                tradeQuery = tradeQuery.And(d => d.StartDate < StartDateTemp);
            }
            if (!string.IsNullOrEmpty(req.ClientIds))
            {
                tradeQuery = tradeQuery.And(d => req.ClientIdsInt.Contains(d.ClientId));
            }
            if (req.AssetIdList.Any())
            {
                tradeQuery = tradeQuery.And(d => req.AssetIdList.Contains(d.AssetId));
            }
            if (!string.IsNullOrEmpty(req.TraderNames))
            {
                tradeQuery = tradeQuery.And(d => req.TraderNamesList.Contains(d.TraderId));
            }
            if (req.ExerciseDateStart != null || req.ExerciseDateEnd != null)
            {
                if (req.ExerciseDateEnd == null)
                {
                    req.ExerciseDateEnd = DateTime.MaxValue;
                }
                if (req.ExerciseDateStart == null)
                {
                    req.ExerciseDateStart = DateTime.MinValue;
                }
                tradeQuery = tradeQuery.And(d => d.ExerciseDate >= req.ExerciseDateStart && d.ExerciseDate <= req.ExerciseDateEnd);
            }
            return tradeQuery;
        }
        private void GetTradeDocumentResults(SwapEndConfirmReq req, SwapTradeContractGroup x)
        {
            var documentQuery = (from trade in DbContext.trade_contract_document where trade.Code == x.trade_contract_r.ContractCode && trade.Type == x.trade_contract_r.Type select trade);

            x.trade_contract_document = documentQuery.FirstOrDefault();
            x.ContractDocUrl = x.trade_contract_document?.RelativePath;
            x.ContractCode = x.trade_contract_r.ContractCode;
        }
    }
}