zszq-trs/YLErpDAL/Modules/ExcelAddinModule/Service/TradeQueryService.cs

using System.ComponentModel.DataAnnotations.Schema;
using YLErp.BLL;
using YLErp.DBModels.Enums;
using YLErp.Modules.ExcelAddinModule.Model;

namespace YLErp.Modules.ExcelAddinModule.Service
{
    public class TradeQueryService : YLBaseService
    {
        /// <summary>
        /// 分隔符
        /// </summary>
        private readonly char[] separator = ",".ToArray();
        /// <summary>
        /// 无效日期
        /// </summary>
        private readonly DateTime InValidDate = DateTime.Now.AddYears(-10);

        public TradeQueryService(OptUserInfo userInfo) : base(userInfo)
        {
        }

        private bool SplitParame(string str, out string[] arr)
        {
            bool result = false;
            arr = null;
            if (!string.IsNullOrWhiteSpace(str))
            {
                arr = str.Split(separator, StringSplitOptions.RemoveEmptyEntries);
                result = arr.Length > 0;
            }
            return result;
        }

        public List<trade> SearchTradeList(TradeQueryReq req)
        {
            List<trade> results = null;
            try
            {
                var query = from source in DbContext.trade where source.ValidState != "InValid" select source;
                string[] payoffTypeArr = null, strikeTypeArr = null;
                if (req.AveragingPeriodStartDateStart > InValidDate ||
                    req.AveragingPeriodStartDateEnd > InValidDate ||
                    SplitParame(req.PayoffTypeStr, out payoffTypeArr) ||
                    SplitParame(req.StrikeTypeStr, out strikeTypeArr))
                {
                    var queryEx = from source in query join ex in DbContext.trade_asian_option on source.id equals ex.TradeId select new { source, ex };
                    if (req.AveragingPeriodStartDateStart > InValidDate)
                    {
                        queryEx = queryEx.Where(O => O.ex.AveragingPeriodStartDate >= req.AveragingPeriodStartDateStart);
                    }
                    if (req.AveragingPeriodStartDateEnd > InValidDate)
                    {
                        queryEx = queryEx.Where(O => O.ex.AveragingPeriodStartDate <= req.AveragingPeriodStartDateEnd);
                    }
                    if (payoffTypeArr?.Length > 0)
                    {
                        queryEx = queryEx.Where(O => payoffTypeArr.Contains(O.ex.PayoffType));
                    }
                    if (strikeTypeArr?.Length > 0)
                    {
                        queryEx = queryEx.Where(O => strikeTypeArr.Contains(O.ex.StrikeType));
                    }
                    query = queryEx.Select(O => O.source);
                }
                if (req.TradeDateStart > InValidDate)
                {
                    query = query.Where(O => O.TradeDate >= req.TradeDateStart);
                }
                if (req.TradeDateEnd > InValidDate)
                {
                    query = query.Where(O => O.TradeDate <= req.TradeDateEnd);
                }
                if (SplitParame(req.TradeTypes, out var tradeTypeArr))
                {
                    query = query.Where(O => tradeTypeArr.Contains(O.TradeType));
                }
                if (req.ExerciseDateStart > InValidDate)
                {
                    query = query.Where(O => O.ExerciseDate >= req.ExerciseDateStart);
                }
                if (req.ExerciseDateEnd > InValidDate)
                {
                    query = query.Where(O => O.ExerciseDate <= req.ExerciseDateEnd);
                }
                if (SplitParame(req.TradeStatusStr, out var tradeStatusArr))
                {
                    query = query.Where(O => tradeStatusArr.Contains(O.TradeStatus));
                }
                if (SplitParame(req.AssetBookNameStr, out var assetBookNameArr))
                {
                    query = query.Where(O => assetBookNameArr.Contains(O.AssetBookName));
                }
                if (SplitParame(req.TradeNumberStr, out var tradeNumberArr))
                {
                    query = query.Where(O => tradeNumberArr.Contains(O.TradeNumber));
                }
                if (SplitParame(req.UnderlyingCodeStr, out var underlyingCodeArr))
                {
                    query = query.Where(O => underlyingCodeArr.Contains(O.UnderlyingCode));
                }
                if (SplitParame(req.BuySellStr, out var buySellArr))
                {
                    query = query.Where(O => buySellArr.Contains(O.BuySell));
                }
                if (SplitParame(req.OptionTypeStr, out var optionTypeArr))
                {
                    query = query.Where(O => optionTypeArr.Contains(O.OptionType));
                }
                if (SplitParame(req.ExerciseModeStr, out var exerciseModeArr))
                {
                    query = query.Where(O => exerciseModeArr.Contains(O.ExerciseMode));
                }
                if (SplitParame(req.ClientNameStr, out var clientNameArr))
                {
                    query = query.Where(O => clientNameArr.Contains(O.ClientName));
                }
                if (SplitParame(req.TraderNameStr, out var traderNameArr))
                {
                    query = query.Where(O => traderNameArr.Contains(O.TraderName));
                }
                if (req.StartDateStart > InValidDate)
                {
                    query = query.Where(O => O.StartDate >= req.StartDateStart);
                }
                if (req.StartDateEnd > InValidDate)
                {
                    query = query.Where(O => O.StartDate <= req.StartDateEnd);
                }
                results = query.ToList();
                tradeBLL.SetFieldsByTradeType(results);
            }
            catch (Exception ex)
            {
                LogFactory.GetLogger<TradeQueryService>().Error(ex);
                throw;
            }
            return results ?? new List<trade>();
        }

        public List<trade> SearchExchangeTradeList(TradeQueryReq req)
        {
            try
            {
                var query = from source in DbContext.ExchangeTrade
                            join book in DbContext.assetunit on source.AssetBookId equals book.id
                            join underlying in DbContext.underlying_manager on source.UnderlyingId equals underlying.id
                            where source.IsValid
                            select new InnerExchangeTradeDto
                            {
                                id = source.id,
                                AssetBookName = book.Name,
                                AssetId = source.AssetBookId,
                                BuySell = source.TradeSide,
                                OptionType = source.OptionType,
                                Comments = source.Comments,
                                Commission = source.Commission,
                                CommissionType = source.CommissionType,
                                CreateDate = source.CreateTime,
                                ExchangeAccountCode = source.ExchangeAccountCode,
                                ExchangeAccountId = source.ExchangeAccountId,
                                ExchangeOptionCode = source.OptionCode,
                                ExerciseMode = source.ExerciseMode,
                                ExerciseDate = source.MaturityDate,
                                Lots = source.TradeLots,
                                Notional = source.Notional,
                                OptDate = source.OptDate,
                                OptId = source.OptId ?? 0,
                                OptName = source.OptName,
                                OriginalNotional = source.Notional,
                                SpotPrice = source.TradeSinglePrice,
                                TradeSinglePrice = source.TradeSinglePrice,
                                StartDate = source.TradeDate,
                                TradeNumber = source.TradeNumber,
                                TradeDate = source.TradeDate,
                                Strike = source.OptionStrike,
                                TradeAmount = source.TradeAmount,
                                TradePrice = source.TradeSinglePrice * source.Notional,
                                TradeType = source.TradeType,
                                UnderlyingAssetClass = underlying.UnderlyingType,
                                UnderlyingAssetName = underlying.UnderlyingName,
                                UnderlyingCode = source.UnderlyingCode,
                                UnderlyingId = source.UnderlyingId,
                            };
                if (req.TradeDateStart > InValidDate)
                {
                    query = query.Where(O => O.TradeDate >= req.TradeDateStart);
                }
                if (req.TradeDateEnd > InValidDate)
                {
                    query = query.Where(O => O.TradeDate <= req.TradeDateEnd);
                }
                if (SplitParame(req.TradeTypes, out var tradeTypeArr))
                {
                    query = query.Where(O => tradeTypeArr.Contains(O.TradeType));
                }
                if (req.ExerciseDateStart > InValidDate)
                {
                    query = query.Where(O => O.ExerciseDate >= req.ExerciseDateStart);
                }
                if (req.ExerciseDateEnd > InValidDate)
                {
                    query = query.Where(O => O.ExerciseDate <= req.ExerciseDateEnd);
                }
                if (SplitParame(req.AssetBookNameStr, out var assetBookNameArr))
                {
                    query = query.Where(O => assetBookNameArr.Contains(O.AssetBookName));
                }
                if (SplitParame(req.TradeNumberStr, out var tradeNumberArr))
                {
                    query = query.Where(O => tradeNumberArr.Contains(O.TradeNumber));
                }
                if (SplitParame(req.UnderlyingCodeStr, out var underlyingCodeArr))
                {
                    query = query.Where(O => underlyingCodeArr.Contains(O.UnderlyingCode));
                }
                if (SplitParame(req.BuySellStr, out var buySellArr))
                {
                    query = query.Where(O => buySellArr.Contains(O.BuySell));
                }
                if (SplitParame(req.OptionTypeStr, out var optionTypeArr))
                {
                    query = query.Where(O => optionTypeArr.Contains(O.OptionType));
                }
                if (SplitParame(req.ExerciseModeStr, out var exerciseModeArr))
                {
                    query = query.Where(O => exerciseModeArr.Contains(O.ExerciseMode));
                }
                if (req.StartDateStart > InValidDate)
                {
                    query = query.Where(O => O.StartDate >= req.StartDateStart);
                }
                if (req.StartDateEnd > InValidDate)
                {
                    query = query.Where(O => O.StartDate <= req.StartDateEnd);
                }
                if (SplitParame(req.ExchangeOptionCodeStr, out var exchangeOptionCodeArr))
                {
                    query = query.Where(O => exchangeOptionCodeArr.Contains(O.ExchangeOptionCode));
                }

                return query.ToList().Select(O =>
                {
                    var td = new InnerTradeDto();
                    YLAutoMapper.Map<OtcTradeBase, OtcTradeBase>(O, td);
                    td.ExchangeAccountId = O.ExchangeAccountId;
                    td.ExchangeAccountCode = O.ExchangeAccountCode;
                    td.Commission = O.Commission;
                    td.CommissionType = O.CommissionType;
                    return (trade)td;
                }).ToList();
            }
            catch (Exception ex)
            {
                LogFactory.GetLogger<TradeQueryService>().Error(ex);
                throw;
            }
        }

        class InnerExchangeTradeDto : OtcTradeBase
        {
            private string exchangeAccountCode;

            /// <summary>
            /// 对冲账户
            /// </summary>
            public int? ExchangeAccountId { get; set; }

            /// <summary>
            /// 对冲账户
            /// </summary>
            public string ExchangeAccountCode
            {
                get => exchangeAccountCode;
                set => exchangeAccountCode = value ?? "";
            }

            /// <summary>
            /// 手续费
            /// </summary>
            public double? Commission { get; set; }

            /// <summary>
            /// 手续费计算方式
            /// </summary>
            public CommissionType? CommissionType { get; set; }
        }

        [NotMapped]
        class InnerTradeDto : trade
        {
            /// <summary>
            /// 对冲账户
            /// </summary>
            public int? ExchangeAccountId { get; set; }

            /// <summary>
            /// 对冲账户
            /// </summary>
            public string ExchangeAccountCode { get; set; }

            /// <summary>
            /// 手续费
            /// </summary>
            public double? Commission { get; set; }

            /// <summary>
            /// 手续费计算方式
            /// </summary>
            public CommissionType? CommissionType { get; set; }
        }
    }
}