zszq-trs/YLErpDAL/Modules/UnderlyingModule/VarietyBLL.cs

using BaseOUDAL;
using YLErp.Model;
using YLErp.Modules;

namespace YLErp.BLL
{
    public class VarietyBLL
    {
        private readonly YLContext db = new YLContext();

        public static IQueryable<Variety> GetAllvarietyModel()
        {
            return Modules.DataCacheModule.DataCacheManager.GetVarietyDataSource().AsQueryable();
        }

        /// <summary>
        /// 查询variety
        /// </summary>
        public SearchListResult<Variety> SearchList(VarietyReq req)
        {
            var query = from source in db.variety select source;
            if (!string.IsNullOrEmpty(req.VarietyCode))
            {
                query = query.Where(d => d.VarietyCode.Contains(req.VarietyCode));
            }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            if (string.IsNullOrEmpty(req.sidx))
            {
                req.sidx = "id";
                req.sord = "desc";
            }

            var sList = query.ToSearchList(req);

            var Market = DataCacheProvider.GetMarketDataSource().AsQueryable();
            foreach (var item in sList.rows)
            {
                var market = Market?.FirstOrDefault(o => o.MarketName == item.TradingMarket);
                item.TradingMarketNo = market?.ExchangeNo;
            }

            return sList;
        }
    }
}