zszq-trs/YLErpDAL/Modules/ReportModule/TradeBarrierReportService.cs

using BaseOUDAL;
using YLErp.Model;

namespace YLErp.Modules.ReportModule
{
    /// <summary>
    /// 障碍期权报告
    /// </summary>
    public class TradeBarrierReportService : YLBaseService
    {
        public TradeBarrierReportService(OptUserInfo userInfo) : base(userInfo)
        {
        }

        /// <summary>
        /// 查找包含关联表的trade信息
        /// </summary>
        public SearchListResult<TradeBarrierReportResult> SearchTrades(TradeReq req, List<int> userAssetUnit = null, bool isExerciseDateReport = false, bool isWithStructTrade = false)
        {
            //簿记账户
            var query = from source in DbContext.trade
                        join au in DbContext.assetunit on source.AssetId equals au.id
                        join barrier in DbContext.trade_barrier_option on source.id equals barrier.TradeId into tempbar
                        from barrier in tempbar.DefaultIfEmpty()
                        select new TradeBarrierReportResult
                        {
                            trade = source,
                            trade_barrier_option = barrier
                        };
            if (userAssetUnit != null)
            {
                query = query.Where(q => userAssetUnit.Contains(q.trade.AssetId));
            }
            else
            {
                //未除权 的 交易 
            }
            if (!isWithStructTrade)
            {
                query = query.Where(q => q.trade.ParentTradeId == 0);
            }
            if (!string.IsNullOrEmpty(req.ExerciseMode))
            {
                query = query.Where(d => d.trade.ExerciseMode.Contains(req.ExerciseMode));
            }
            if (!string.IsNullOrEmpty(req.UnderlyingAssetClass))
            {
                query = query.Where(d => d.trade.UnderlyingAssetClass.Contains(req.UnderlyingAssetClass));
            }
            if (!string.IsNullOrEmpty(req.ClientIds))
            {
                query = query.Where(d => req.ClientIdsInt.Contains(d.trade.ClientId));
            }
            if (!string.IsNullOrEmpty(req.OptionType))
            {
                query = query.Where(d => req.OptionType == d.trade.OptionType);
            }
            if (!string.IsNullOrEmpty(req.TradeTypes))
            {
                query = query.Where(d => req.TradeTypesList.Contains(d.trade.TradeType) || req.TradeTypesList.Contains(d.trade.StructureType));
            }
            if (!string.IsNullOrEmpty(req.UnderlyingInstrumentTypes))
            {
                query = query.Where(d => req.UnderlyingInstrumentTypesList.Contains(d.trade.UnderlyingAssetClass));
            }
            if (!string.IsNullOrEmpty(req.OptIds))
            {
                query = query.Where(d => req.OptIdsList.Contains(d.trade.OptId + ""));
            }
            if (!string.IsNullOrEmpty(req.Comments))
            {
                query = query.Where(d => d.trade.Comments.Contains(req.Comments));
            }

            if (!string.IsNullOrEmpty(req.UnderlyingIds))
            {
                query = query.Where(d => req.UnderlyingIdsInt.Contains(d.trade.UnderlyingId));
            }

            if (req.AssetIdList.Any())
            {
                query = query.Where(d => req.AssetIdList.Contains(d.trade.AssetId));
            }

            if (req.KnockInOutStatus == "观察中")
            {
                query = query.Where(d => d.trade_barrier_option != null && string.IsNullOrEmpty(d.trade_barrier_option.KnockInOutStatus));
            }
            else
            {
                query = query.Where(d => d.trade_barrier_option != null && d.trade_barrier_option.KnockInOutStatus == req.KnockInOutStatus);
            }

            if (!string.IsNullOrEmpty(req.TradeNumber))
            {
                query = query.Where(d => d.trade.TradeNumber.Contains(req.TradeNumber));
            }

            if (req.ClientId != null)
            {
                query = query.Where(d => d.trade.ClientId == req.ClientId);
            }

            if (!string.IsNullOrEmpty(req.ClientName))
            {
                query = query.Where(d => d.trade.ClientName.Contains(req.ClientName));
            }

            if (!string.IsNullOrEmpty(req.UnderlyingCode))
            {
                query = query.Where(d => d.trade.UnderlyingCode.Contains(req.UnderlyingCode));
            }

            if (req.UnderlyingId != null)
            {
                query = query.Where(d => d.trade.UnderlyingId == req.UnderlyingId);
            }

            if (!string.IsNullOrEmpty(req.TradeType))
            {
                query = query.Where(d => d.trade.TradeType.Contains(req.TradeType));
            }

            if (req.TradeDateStart != DateTime.MinValue)
            {
                query = query.Where(d => d.trade.TradeDate >= req.TradeDateStart);
            }

            if (req.TradeDateEnd != DateTime.MinValue)
            {
                var TradeDateTemp = req.TradeDateEnd.AddDays(1);
                query = query.Where(d => d.trade.TradeDate < TradeDateTemp);
            }
            if (!string.IsNullOrEmpty(req.BuySell))
            {
                query = query.Where(d => d.trade.BuySell.Contains(req.BuySell));
            }

            if (req.StartDateStart != DateTime.MinValue)
            {
                query = query.Where(d => d.trade.StartDate >= req.StartDateStart);
            }

            if (req.StartDateEnd != DateTime.MinValue)
            {
                var StartDateTemp = req.StartDateEnd.AddDays(1);
                query = query.Where(d => d.trade.StartDate < StartDateTemp);
            }

            if (isExerciseDateReport)
            {
                if (req.ExerciseDateStart != null || req.ExerciseDateEnd != null)
                {
                    if (req.ExerciseDateEnd == null)
                    {
                        req.ExerciseDateEnd = DateTime.MaxValue;
                    }
                    if (req.ExerciseDateStart == null)
                    {
                        req.ExerciseDateStart = DateTime.MinValue;
                    }
                    query = query.Where(d => d.trade.ExerciseDate >= req.ExerciseDateStart && d.trade.ExerciseDate <= req.ExerciseDateEnd);
                }
            }
            else
            {
                if (req.ExerciseDateStart != null || req.ExerciseDateEnd != null)
                {
                    if (req.ExerciseDateEnd == null)
                    {
                        req.ExerciseDateEnd = DateTime.MaxValue;
                    }
                    if (req.ExerciseDateStart == null)
                    {
                        req.ExerciseDateStart = DateTime.MinValue;
                    }
                    query = query.Where(d => d.trade.ExerciseMode == null || ((d.trade.ExerciseMode == "European" && d.trade.ExerciseDate >= req.ExerciseDateStart && d.trade.ExerciseDate <= req.ExerciseDateEnd) || (d.trade.ExerciseMode == "American" && ((d.trade.ExerciseDate >= req.ExerciseDateStart && d.trade.ExerciseDate <= req.ExerciseDateEnd) || (d.trade.StartDate >= req.ExerciseDateStart && d.trade.StartDate <= req.ExerciseDateEnd) || (d.trade.StartDate <= req.ExerciseDateStart && d.trade.ExerciseDate >= req.ExerciseDateEnd)))));
                }
            }

            if (!string.IsNullOrEmpty(req.TradeStatus))
            {
                var statuses = req.TradeStatus.Split(',').ToList();
                query = query.Where(d => statuses.Contains(d.trade.TradeStatus));
            }
            if (req.TradeStatusList != null)
            {
                query = query.Where(d => req.TradeStatusList.Contains(d.trade.TradeStatus));
            }
            if (req.OptId != null)
            {
                query = query.Where(d => d.trade.OptId == req.OptId);
            }

            if (!string.IsNullOrEmpty(req.OptName))
            {
                query = query.Where(d => d.trade.OptName.Contains(req.OptName));
            }

            if (req.OptDateStart != DateTime.MinValue)
            {
                query = query.Where(d => d.trade.OptDate >= req.OptDateStart);
            }

            if (req.OptDateEnd != DateTime.MinValue)
            {
                var OptDateTemp = req.OptDateEnd.AddDays(1);
                query = query.Where(d => d.trade.OptDate < OptDateTemp);
            }

            query = query.Where(d => d.trade.ValidState != "InValid");
            query = query.OrderByDescending(s => s.trade.OptDate);
            return query.ToSearchList(req, false);
        }
    }

    public class TradeBarrierReportResult
    {
        public trade trade { get; set; }

        public trade_barrier_option trade_barrier_option { get; set; }
    }
}