zszq-trs/YLErpDAL/Modules/TradeModule/QueryModule/TradeDetailQueryApiService.cs

using System.Data;
using System.Linq.Expressions;
using YLErp.Modules.TradeModule.BaseModels;

namespace YLErp.Modules.TradeModule.QueryModule
{
    /// <summary>
    /// OTC-13931 交易明细API业务代码
    /// </summary>
    public class TradeDetailQueryApiService : YLBaseService
    {
        public TradeDetailQueryApiService(OptUserInfo userInfo) : base(userInfo)
        {

        }

        public TradeDetailQueryApiService(YLBaseService baseService) : base(baseService)
        {

        }

        /// <summary>
        /// 
        /// </summary>
        public IPagedList<TradeDetailQueryApiResult> TradeDetailPageList(TradeDetailQueryApiModel queryModel)
        {
            var predicate = CreateTradePredicate(queryModel);
            var pagedList = DbContext.trade.Where(predicate).ToPagedList(queryModel);
            var tradeIds = pagedList.Select(x => x.id).ToList();
            var trade_cashlist = DbContext.trade_cash.Where(x => x.ValidState != ConsGlobal.InValid && tradeIds.Contains(x.TradeId) && !x.IsDeleted).ToList();
            var tradeList = pagedList.Select(n =>
            {
                var otcTrade = new TradeDetailQueryApiResult();
                YLAutoMapper.Map<OtcTradeBase, OtcTradeBase>(n, otcTrade);
                otcTrade.RealizedPnl = trade_cashlist?.Where(x => x.TradeId == n.id).Sum(x => x.Amount);
                otcTrade.ClientNumber = ClientModule.ClientDataQueryService.GetClient(otcTrade.ClientId)?.Number;
                return otcTrade;
            }).ToArray();

            var pagedList2 = new PagedList<TradeDetailQueryApiResult>
            {
                PageSize = pagedList.PageSize,
                PageIndex = pagedList.PageIndex,
                Items = tradeList,
                TotalCount = pagedList.TotalCount
            };

            new TradeExtendService(this).SetTradeExtend(pagedList2, true);

            return pagedList2;
        }

        /// <summary>
        /// 根据查询参数拼接查询条件
        /// </summary>
        protected Expression<Func<trade, bool>> CreateTradePredicate(TradeDetailQueryApiModel queryModel)
        {
            var predicate = PredicateBuilder.Create<trade>(t => t.ValidState != ConsGlobal.InValid);

            if (queryModel.IncludeGroupMain)
            {
                predicate = predicate.And(n => n.TradeType != "结构化交易" || n.IsGroup == 1);
            }
            else
            {
                predicate = predicate.And(n => n.TradeType != "结构化交易");
            }

            // 交易类型
            if (queryModel.TradeTypes.HasNonEmptyItem())
            {
                predicate = predicate.And(d => queryModel.TradeTypes.Contains(d.TradeType));
            }

            // 簿记账户名称
            var assetIds = GetAssetIds(queryModel.AssetBookNames);
            if (assetIds != null)
            {
                predicate = predicate.And(d => assetIds.Contains(d.AssetId));
            }

            //交易员名称（ 使用参数），不使用登录名进行匹配
            var traderIds = GetTraderId(queryModel.TraderNames);
            if (traderIds != null)
            {
                predicate = predicate.And(d => traderIds.Contains(d.TraderId));
            }

            //客户 优先使用客户编号
            var clientIds = GetClientIdsByNumber(queryModel.ClientNumbers)
                ?? GetClientIdsByName(queryModel.ClientNames);
            if (clientIds != null)
            {
                predicate = predicate.And(d => clientIds.Contains(d.ClientId));
            }

            //交易编号 
            if (!string.IsNullOrEmpty(queryModel.TradeNumber))
            {
                //第2个条件的适用场景为传入了结构化交易主交易的交易编号则匹配出来子交易
                predicate = predicate.And(d => d.TradeNumber.Equals(queryModel.TradeNumber) ||
                    DbContext.trade.Any(n => n.TradeNumber.Equals(queryModel.TradeNumber) && n.id == d.ParentTradeId));
            }

            //交易标的代码
            if (queryModel.UnderlyingCodes.HasNonEmptyItem())
            {
                predicate = predicate.And(d => queryModel.UnderlyingCodes.Contains(d.UnderlyingCode));
            }

            //交易方向: 买入|卖出 
            if (!string.IsNullOrEmpty(queryModel.BuySell))
            {
                predicate = predicate.And(d => d.BuySell == queryModel.BuySell);
            }

            //看涨看跌: Call|Put
            if (!string.IsNullOrEmpty(queryModel.OptionType))
            {
                var optionType = ConsGlobal.CallPut.ConvertToCN(queryModel.OptionType);
                predicate = predicate.And(d => d.OptionType == optionType);
            }

            //行权方式:American|European 
            if (!string.IsNullOrEmpty(queryModel.ExerciseMode))
            {
                predicate = predicate.And(d => d.ExerciseMode == queryModel.ExerciseMode);
            }

            //成交日期
            if (queryModel.TradeDate.HasValue)
            {
                predicate = predicate.And(d => d.TradeDate == queryModel.TradeDate);
            }

            //到期日期
            if (queryModel.ExerciseDate.HasValue)
            {
                predicate = predicate.And(d => d.ExerciseDate == queryModel.ExerciseDate);
            }

            //结算日期
            if (queryModel.SettlementDate.HasValue)
            {
                predicate = predicate.And(d => d.SettlementDate == queryModel.SettlementDate);
            }

            //交易状态：确认成交、新增待确认、已平仓、已到期。。。等等 
            if (queryModel.TradeStatus != null && queryModel.TradeStatus.Any())
            {
                predicate = predicate.And(d => queryModel.TradeStatus.Contains(d.TradeStatus));
            }

            return predicate;
        }

        #region  先转换成id再构建查询条件

        /// <summary>
        /// 获取簿记账户id
        /// </summary>
        private List<int> GetAssetIds(IEnumerable<string> AssetBookName)
        {
            if (!AssetBookName.HasNonEmptyItem())
            {
                return null;
            }
            return DbContext.assetunit.Where(x => AssetBookName.Contains(x.Name)).Select(x => x.id).ToList();
        }

        /// <summary>
        ///  返回交易员ID
        /// </summary>
        private IEnumerable<int> GetTraderId(IEnumerable<string> traderNames)
        {
            if (!traderNames.HasNonEmptyItem())
            {
                return null;
            }

            using (var sysdb = DbContextFactory.GetErpBaseContext())
            {
                return sysdb.SystemUsers.Where(su => traderNames.Contains(su.LoginName)).Select(n => n.Id).ToArray();
            }
        }

        /// <summary>
        /// 根据交易对手方编号返回交易对手方ID
        /// </summary>
        /// <param name="clientNumbers">交易对手方编号</param>
        private List<int> GetClientIdsByNumber(IEnumerable<string> clientNumbers)
        {
            if (!clientNumbers.HasNonEmptyItem())
            {
                return null;
            }

            using (var clientDbContext = DbContextFactory.GetClientDbContext(OptUser))
            {
                return clientDbContext.client.Where(x => clientNumbers.Contains(x.Number)).Select(x => x.id).ToList();
            }
        }

        /// <summary>
        /// 根据客户名称返回客户ID
        /// </summary>
        private List<int> GetClientIdsByName(IEnumerable<string> clientNames)
        {
            if (!clientNames.HasNonEmptyItem())
            {
                return null;
            }

            using (var clientDbContext = DbContextFactory.GetClientDbContext(OptUser))
            {
                return clientDbContext.client.Where(x => clientNames.Contains(x.Name)).Select(x => x.id).ToList();
            }
        }

        #endregion
    }

    /// <summary>
    /// 交易明细API
    /// </summary>
    public class TradeDetailQueryApiResult : OtcOptionTradeFull
    {
        /// <summary>
        /// 实现盈亏
        /// </summary>
        public double? RealizedPnl { get; set; }
    }
}