コード例 #1
0
ファイル: FilterService.cs プロジェクト: yinboxie/CSum.Abp
        /// <summary>
        /// 将模型<see cref="IFilterModel"/>的属性集解析成<see cref="IReqGroup"/>
        /// </summary>
        /// <param name="model"></param>
        /// <param name="reqFields"></param>
        /// <returns></returns>
        protected virtual IReqGroup TryGetReqGroupWithProperties(IFilterModel model, IEnumerable <PropertyInfo> reqFields)
        {
            ReqGroup group = new ReqGroup();

            foreach (var field in reqFields)
            {
                var val = field.GetValue(model);
                if (val == null)
                {
                    continue;
                }

                IReqFieldAttribute attr = (IReqFieldAttribute)field.GetCustomAttributes().FirstOrDefault(a => typeof(IReqFieldAttribute).IsAssignableFrom(a.GetType()));


                var rule = attr.ParseRule(field.Name, val);
                if (field.PropertyType.IsNullableEnum() && rule is ReqRule reqRule)
                {
                    //枚举字段需要转换成int
                    reqRule.SetConversionType(typeof(int), "int");
                }
                group.AddRule(rule);
            }
            return(group);
        }
コード例 #2
0
        private Expression <Func <Game, bool> > FindByPublishTime(IFilterModel model, Expression <Func <Game, bool> > exp) // todo: domain model edit
        {
            if (model.WhenPublished == null || model.WhenPublished == String.Empty)
            {
                return(exp);
            }

            if (model.WhenPublished == WhenPublishedOprionsEnum.LastWeek.ToString())
            {
                return(null);
            }

            if (model.WhenPublished == WhenPublishedOprionsEnum.LastMonth.ToString())
            {
                return(null);
            }

            if (model.WhenPublished == WhenPublishedOprionsEnum.LastYear.ToString())
            {
                return(null);
            }

            if (model.WhenPublished == WhenPublishedOprionsEnum.TwoYears.ToString())
            {
                return(null);
            }

            if (model.WhenPublished == WhenPublishedOprionsEnum.ThreeYearsAndMore.ToString())
            {
                return(null);
            }

            return(null);
        }
コード例 #3
0
        public Expression <Func <Game, bool> > Start(IFilterModel model)
        {
            var predicate = PredicateBuilder.True <Game>();



            return(FindByName(model, predicate));
        }
コード例 #4
0
 public void LoadFilter(IFilterModel filter)
 {
     if (filter is FilterDateModel)
     {
         var filterToLoad = filter as FilterDateModel;
         DateFilterType = filterToLoad.DateFilterType;
     }
 }
コード例 #5
0
        private Expression <Func <Game, bool> > FindByName(IFilterModel model, Expression <Func <Game, bool> > exp)
        {
            if (model.FilterByName != null && model.FilterByName != String.Empty)
            {
                exp = exp.And(g => g.Name.Contains(model.FilterByName));
            }

            return(SortByPriceRange(model, exp));
        }
コード例 #6
0
        public void LoadFilter(IFilterModel filter)
        {
            if (filter is FilterQuickModel)
            {
                var filterToLoad = filter as FilterQuickModel;

                ResetQuickFilterCollectionTo(filterToLoad.QuickFilterCollection);
            }
        }
コード例 #7
0
        public void LoadFilter(IFilterModel filter)
        {
            if (filter is FilterOmahaHandGridModel)
            {
                var filterToLoad = filter as FilterOmahaHandGridModel;

                ResetHandGridCollectionTo(filterToLoad.HandGridCollection);
            }
        }
コード例 #8
0
        public void LoadFilter(IFilterModel filter)
        {
            if (filter is FilterHoleCardsModel)
            {
                var filterToLoad = filter as FilterHoleCardsModel;

                ResetFilterHoleCardsTo(filterToLoad.HoleCardsCollection.ToList());
            }
        }
コード例 #9
0
        /// <summary>
        /// 获取<typeparamref name="TEntity"/>查询(不跟踪改变的)数据源,并可附加过滤条件模型
        /// </summary>
        /// <param name="model">数据过滤模型</param>
        /// <param name="includeDetails">是否包含明细,默认true</param>
        /// <returns>符合条件的数据集</returns>
        public static IQueryable <TEntity> CreateFilteredQuery <TEntity>(this IReadOnlyBasicRepository <TEntity> repository,
                                                                         IFilterModel model = null,
                                                                         Func <IQueryable <TEntity>, IFilterModel, IQueryable <TEntity> > func = null,
                                                                         bool includeDetails = true)
            where TEntity : class, IEntity
        {
            var repo = ProxyHelper.UnProxy(repository) as ISupportsPredicateQuery <TEntity>;

            return(repo != null?repo.CreateFilteredQuery(model, func, includeDetails) : null);
        }
コード例 #10
0
        public FilterViewModel(IDirectoryManager directoryManager, IEventAggregator eventAggregator, IFilterModel filterModel)
        {
            DirectoryManager = directoryManager;

            CurrentFilter = filterModel;

            InitializeEvents(eventAggregator);

            InitializeCommands();
        }
コード例 #11
0
 /// <summary>
 /// Set current filter
 /// </summary>
 private void SetFilter(bool IsFilterEmpty, IFilterModel CurrentFilter)
 {
     if (IsFilterEmpty)
     {
         _currentFilter.Reset();
     }
     else
     {
         _currentFilter = CurrentFilter;
     }
 }
コード例 #12
0
        private void FilterTriggered(FilterEvent obj)
        {
            if (!obj.IsFilterEmpty)
            {
                IsFilterSet = true;
            }

            _currentFilter = obj.CurrentFilter;

            OnHideFilter();
        }
コード例 #13
0
        public void UpdateFromModel(IFilterModel model)
        {
            Color notFoundColor = Color.FromArgb(255, 102, 102); // firefox color
            var   filterCount   = model.FilterCount;

            if (model.HasBackItem)
            {
                filterCount--;
            }
            eFilter.BackColor = string.IsNullOrEmpty(model.FilterText) || filterCount > 0 ? Color.White : notFoundColor;
        }
コード例 #14
0
ファイル: FilterPresenter.cs プロジェクト: 00mjk/LanExchange
 public void SetModel(IFilterModel value)
 {
     m_Model = null;
     if (value != null)
     {
         View.SetFilterText(value.FilterText);
         m_Model = value;
         m_Model.ApplyFilter();
         View.UpdateFromModel(m_Model);
         View.DoFilterCountChanged();
     }
 }
コード例 #15
0
        public PagedResult(IEnumerable <TModel> data, int totalCount, IFilterModel filterModel)
        {
            Data       = data;
            TotalCount = totalCount;

            if (filterModel == null)
            {
                throw new Exception("FilterModel is NULL, it is required");
            }
            Limit  = filterModel.Limit;
            Offset = filterModel.Offset;
        }
コード例 #16
0
        public void LoadFilter(IFilterModel filter)
        {
            if (filter is FilterHandActionModel)
            {
                var loadedFilter = filter as FilterHandActionModel;

                ResetPreflopFilterTo(loadedFilter.PreflopButtons, loadedFilter.PreflopItems);
                ResetFlopFilterTo(loadedFilter.FlopButtons, loadedFilter.FlopItems);
                ResetTurnFilterTo(loadedFilter.TurnButtons, loadedFilter.TurnItems);
                ResetRiverFilterTo(loadedFilter.RiverButtons, loadedFilter.RiverItems);
            }
        }
コード例 #17
0
ファイル: QueryBuilder.cs プロジェクト: flaschracket/dscribe
        public static IQueryable <TEntity> CreateSelectQuery <TEntity>(IFilterModel <TEntity> request, DbContext context)
            where TEntity : class
        {
            IQueryable <TEntity> query = context.Set <TEntity>();

            if (request?.Filters != null)
            {
                foreach (var filter in request.Filters)
                {
                    query = query.Where(filter);
                }
            }
            return(query);
        }
コード例 #18
0
        public static void Produces(this IFilterModel model, params string[] contentTypes)
        {
            if (contentTypes.Length == 0)
            {
                return;
            }
            if (model.Filters.Any(x => x is ProducesAttribute a && a.ContentTypes.Contains(contentTypes, StringComparison.OrdinalIgnoreCase)))
            {
                return;
            }

            var produces = contentTypes.Length == 1
                ? new ProducesAttribute(contentTypes[0])
                : new ProducesAttribute(contentTypes[0], contentTypes[1..]);
コード例 #19
0
        public IEnumerable <Game> GetFilteredResult(IFilterModel filter)
        {
            //pipeline call
            PipeLineStarter pipeLine = new PipeLineStarter();

            var expression = pipeLine.Start(filter);

            var filtered = _unitOfWork.Games.Find(expression).ToList();

            Sorter sorter = new Sorter();
            var    result = sorter.OrderByOptions(filter, filtered);

            return(result);
        }
コード例 #20
0
ファイル: FilterService.cs プロジェクト: yinboxie/CSum.Abp
        /// <summary>
        /// 解析成<see cref="ReqGroupList"/>
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        protected virtual ReqGroupList TryParseReqGroupList(IFilterModel model)
        {
            ReqGroupList reqGroups  = new ReqGroupList();
            var          properties = model.GetType().GetProperties();

            //获取标记了IFilterFieldAttribute特性的字段
            var filterFields = properties.Where(p => p.CustomAttributes.Any(a => typeof(IReqFieldAttribute).IsAssignableFrom(a.AttributeType)));

            //获取标记了ReqGroupAttribute特性的字段
            var groupFields = filterFields.Where(p => p.CustomAttributes.Any(a => typeof(IReqGroupAttribute).IsAssignableFrom(a.AttributeType)));
            Dictionary <int, ConditionLink>        dLinkPairs     = new Dictionary <int, ConditionLink>();
            Dictionary <int, List <PropertyInfo> > dPropertyPairs = new Dictionary <int, List <PropertyInfo> >();

            foreach (var gField in groupFields)
            {
                //将相同分组序号的放置一个ReqGroup, 并且必须得有相同的Link
                IReqGroupAttribute attr = (IReqGroupAttribute)gField.GetCustomAttributes().FirstOrDefault(a => typeof(IReqGroupAttribute).IsAssignableFrom(a.GetType()));
                if (!dLinkPairs.ContainsKey(attr.SortCode))
                {
                    dLinkPairs.Add(attr.SortCode, attr.Link);
                    var ls = new List <PropertyInfo>();
                    ls.Add(gField);
                    dPropertyPairs.Add(attr.SortCode, ls);
                }
                else
                {
                    if (dLinkPairs[attr.SortCode] != attr.Link)
                    {
                        throw new Exception($"解析过滤规则分组失败,相同组序号({attr.SortCode})必须有相同的Link连接符");
                    }
                    dPropertyPairs[attr.SortCode].Add(gField);
                }
            }
            foreach (var fields in dPropertyPairs.Values)
            {
                var onegroup = TryGetReqGroupWithProperties(model, fields);
                reqGroups.AddGroup(onegroup);
            }


            //将没有标记ReqGroupAttribute特性放置在一组
            var noGroupFields = filterFields.Where(p => !p.CustomAttributes.Any(a => typeof(IReqGroupAttribute).IsAssignableFrom(a.AttributeType)));
            var group         = TryGetReqGroupWithProperties(model, noGroupFields);

            if (group.Rules.Count > 0)
            {
                reqGroups.AddGroup(group);
            }
            return(reqGroups);
        }
コード例 #21
0
        public void AddFilter(IFilterModel mdl, bool allowRemove, IEnumerable <Property> sourceProperties)
        {
            InitializeFilter();
            _filter.Add(mdl);
            if (mdl is IUIFilterModel)
            {
                var uimdl = (IUIFilterModel)mdl;

                var vmdl = FilterViewModel.Fetch(ViewModelFactory, DataContext, this, uimdl);
                vmdl.RequestedKind         = uimdl.RequestedKind;
                vmdl.RespectRequiredFilter = RespectRequiredFilter;

                var levmdl = FilterListEntryViewModel.Fetch(ViewModelFactory, DataContext, this, vmdl);
                levmdl.IsUserFilter     = allowRemove;
                levmdl.SourceProperties = sourceProperties;

                // attach change events
                uimdl.FilterChanged += new EventHandler(delegate(object s, EventArgs a)
                {
                    var f = s as FilterModel;
                    if (f == null || !f.RefreshOnFilterChanged)
                    {
                        return;
                    }

                    if (f.IsServerSideFilter)
                    {
                        OnExecuteFilter();
                    }
                    else
                    {
                        OnExecutePostFilter();
                    }
                });

                _FilterViewModels.Add(vmdl);
                _FilterListEntryViewModels.Add(levmdl);
            }
            if (allowRemove)
            {
                UpdateRespectRequieredFilter();
            }

            OnPropertyChanged("RespectRequiredFilter");
            OnPropertyChanged("HasUserFilter");
            OnPropertyChanged("Filter");
            OnPropertyChanged("FilterViewModels");
            OnPropertyChanged("FilterListEntryViewModels");
        }
コード例 #22
0
        public void LoadFilter(IFilterModel filter)
        {
            if (filter is FilterBoardTextureModel)
            {
                var filterToLoad = filter as FilterBoardTextureModel;

                ResetFlopCardsTo(filterToLoad.FlopCardItemsCollection);
                ResetTurnCardsTo(filterToLoad.TurnCardItemsCollection);
                ResetRiverCardsTo(filterToLoad.RiverCardItemsCollection);

                ResetFlopBoardTextureTo(filterToLoad.FlopBoardTextureCollection);
                ResetTurnBoardTextureTo(filterToLoad.TurnBoardTextureCollection);
                ResetRiverBoardTextureTo(filterToLoad.RiverBoardTextureCollection);
            }
        }
コード例 #23
0
ファイル: FilterService.cs プロジェクト: yinboxie/CSum.Abp
        /// <summary>
        /// 解析未标注<see cref="IReqFieldAttribute"/>的字段
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        protected virtual Dictionary <string, object> TryParseExtraProperties(IFilterModel model)
        {
            var properties      = model.GetType().GetProperties();
            var fields          = properties.Where(p => !p.CustomAttributes.Any(a => typeof(IReqFieldAttribute).IsAssignableFrom(a.AttributeType)));
            var extraProperties = new Dictionary <string, object>();

            foreach (var field in fields)
            {
                var val = field.GetValue(model);
                if (val != null && !val.ToString().IsNullOrEmpty())
                {
                    extraProperties.Add(field.Name, field.GetValue(model));
                }
            }
            return(extraProperties);
        }
コード例 #24
0
        /// <summary>
        /// 获取<typeparamref name="TEntity"/>查询(不跟踪改变的)数据源,并可附加过滤条件模型
        /// </summary>
        /// <param name="model">数据过滤模型</param>
        /// <param name="includeDetails">是否包含明细,默认true</param>
        /// <returns>符合条件的数据集</returns>
        public virtual IQueryable <TEntity> CreateFilteredQuery(IFilterModel model = null, Func <IQueryable <TEntity>, IFilterModel, IQueryable <TEntity> > func = null, bool includeDetails = true)
        {
            var query = includeDetails?  WithDetails():  DbSet;

            if (func != null)
            {
                query = func(query, model);
            }
            if (model != null)
            {
                var condition = FilterService.Translate(model);
                if (!condition.ConditionalText.IsNullOrWhiteSpace())
                {
                    query = query.WhereDynamic(condition.ConditionalText);
                }
            }
            return(query.AsNoTracking());
        }
コード例 #25
0
        private Expression <Func <Game, bool> > FindByRelations(IFilterModel model, Expression <Func <Game, bool> > exp)
        {
            if (model.SelectedGenres.Count() != 0)
            {
                exp = exp.And(g => g.Genres.Any(gen => model.SelectedGenres.Contains(gen.Id)));
            }
            if (model.SelectedPlatforms.Count() != 0)
            {
                exp = exp.And(g => g.Platforms.Any(plat => model.SelectedPlatforms.Contains(plat.Id)));
            }
            if (model.SelectedPublishers.Count() != 0)
            {
                exp = exp.And(g => g.Publishers.Any(pub => model.SelectedPublishers.Contains(pub.Id)));
            }


            return(PipeEnd(exp));
        }
コード例 #26
0
        public IEnumerable <Game> OrderByOptions(IFilterModel model, IEnumerable <Game> games)
        {
            if (model.OrderByOptions == null || model.OrderByOptions == String.Empty)
            {
                return(games);
            }

            if (model.OrderByOptions == FilterByOptionsEnum.MostCommented.ToString())
            {
                var result = games.OrderByDescending(g => g.Comments.Count);

                return(result);
            }

            if (model.OrderByOptions == FilterByOptionsEnum.MostPopular.ToString())
            {
                var result = games.OrderBy(g => g.CountOfViews);

                return(result);
            }

            if (model.OrderByOptions == FilterByOptionsEnum.New.ToString())
            {
                var result = games.OrderBy(g => g.AddingDate);

                return(result);
            }

            if (model.OrderByOptions == FilterByOptionsEnum.PriceASC.ToString())
            {
                var result = games.OrderBy(g => g.Price);

                return(result);
            }

            if (model.OrderByOptions == FilterByOptionsEnum.PriceDESC.ToString())
            {
                var result = games.OrderByDescending(g => g.Price);

                return(result);
            }

            return(games);
        }
コード例 #27
0
ファイル: FilterService.cs プロジェクト: yinboxie/CSum.Abp
        public virtual FilteringCondition Translate(IFilterModel model, ITranslator translator)
        {
            Condition = new FilteringCondition(model);
            //设置额外属性
            SetConditionExtraProperties(TryParseExtraProperties(model));


            //解析成ReqGroupList
            var reqGroups = TryParseReqGroupList(model);

            //翻译
            var result = translator.Translate(new TranslateContext {
                DbParameterPrefix = Options.DbParameterPrefix, FilterGroup = reqGroups
            });

            SetConditionConditionalText(result.ConditionalText);
            SetConditionFilteringParams(result.FilteringParams);
            return(Condition);
        }
コード例 #28
0
        /// <summary>
        /// Load active data from DB converting to List of IWorkOrderModel
        /// Out errorMessage if data not loaded
        /// </summary>
        public IEnumerable <IOrderModel> GetHistoryOrders(int page, IFilterModel filter, string accessToken, out string errorMessage)
        {
            errorMessage = null;

            var laborDetailFilter = filter.ConvertFromModel <LaborDetail.Filter>();

            laborDetailFilter.IsActive = false;
            laborDetailFilter.Page     = page;

            List <IOrderModel> result = new List <IOrderModel>();

            var orders = WebApiWorker.GetResult <List <LaborDetail.ListItem> >(apiLaborDetail + "/LaborDetail/Get", accessToken, out errorMessage, laborDetailFilter);

            if (string.IsNullOrEmpty(errorMessage))
            {
                result = ConvertToWorkModel(orders);
            }

            return(result);
        }
コード例 #29
0
        public OrderListViewModel(IDirectoryManager directoryManager, IOrderRepository orderRepository,
                                  IEventAggregator eventAggregator, IFilterModel filterModel, ISignalRWorker signalRWorker)
        {
            _eventAggregator = eventAggregator;

            _directoryManager = directoryManager;

            _orderRepository = orderRepository;

            _currentFilter = filterModel;

            _signalRWorker = signalRWorker;

            InitializeEvents(_eventAggregator);

            InitializeCommands();

            InitializeCollections();

            InitializeHub();
        }
コード例 #30
0
        private void Consumes(IFilterModel model)
        {
            switch (_options.Value.ApiFormats)
            {
            case ApiSupportedMediaTypes.None:
                throw new NotSupportedException(_localizer.GetString("API must support at least one content format"));

            case ApiSupportedMediaTypes.ApplicationJson | ApiSupportedMediaTypes.ApplicationXml:
                model.Consumes(ApiMediaTypeNames.Application.Json, ApiMediaTypeNames.Application.Xml);
                break;

            case ApiSupportedMediaTypes.ApplicationJson:
                model.Consumes(ApiMediaTypeNames.Application.Json);
                break;

            case ApiSupportedMediaTypes.ApplicationXml:
                model.Consumes(ApiMediaTypeNames.Application.Xml);
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
コード例 #31
0
 public void RemoveFilter(IFilterModel mdl)
 {
     FilterList.RemoveFilter(mdl);
 }
コード例 #32
0
        public bool RemoveFilter(IFilterModel mdl)
        {
            if (!_filter.Remove(mdl)) return false;
            if (mdl is IUIFilterModel)
            {
                var uimdl = (IUIFilterModel)mdl;
                var vmdl = FilterViewModel.Fetch(ViewModelFactory, DataContext, this, uimdl);
                var levmdl = FilterListEntryViewModel.Fetch(ViewModelFactory, DataContext, this, vmdl);

                _FilterViewModels.Remove(vmdl);
                _FilterListEntryViewModels.Remove(levmdl);
            }
            UpdateRespectRequieredFilter();

            OnPropertyChanged("RespectRequiredFilter");
            OnPropertyChanged("HasUserFilter");
            OnPropertyChanged("Filter");
            OnPropertyChanged("FilterViewModels");
            OnPropertyChanged("FilterListEntryViewModels");
            return true;
        }
コード例 #33
0
ファイル: FilterListViewModel.cs プロジェクト: daszat/zetbox
        public void AddFilter(IFilterModel mdl, bool allowRemove, IEnumerable<Property> sourceProperties)
        {
            InitializeFilter();
            _filter.Add(mdl);
            if (mdl is IUIFilterModel)
            {
                var uimdl = (IUIFilterModel)mdl;

                var vmdl = FilterViewModel.Fetch(ViewModelFactory, DataContext, this, uimdl);
                vmdl.RequestedKind = uimdl.RequestedKind;
                vmdl.RespectRequiredFilter = RespectRequiredFilter;

                var levmdl = FilterListEntryViewModel.Fetch(ViewModelFactory, DataContext, this, vmdl);
                levmdl.IsUserFilter = allowRemove;
                levmdl.SourceProperties = sourceProperties;

                // attach change events
                uimdl.FilterChanged += OnUIFilterChanged;

                _FilterViewModels.Add(vmdl);
                _FilterListEntryViewModels.Add(levmdl);
            }
            if (allowRemove) UpdateRespectRequieredFilter();
            UpdateExclusiveFilter();

            OnPropertyChanged("IsExclusiveFilterActive");
            OnPropertyChanged("RespectRequiredFilter");
            OnPropertyChanged("HasUserFilter");
            OnPropertyChanged("Filter");
            OnPropertyChanged("ShowFilter");
            OnPropertyChanged("FilterViewModels");
            OnPropertyChanged("FilterListEntryViewModels");
        }
コード例 #34
0
 public void AddFilter(IFilterModel mdl)
 {
     AddFilter(mdl, false, null);
 }
コード例 #35
0
 public void AddFilter(IFilterModel mdl)
 {
     FilterList.AddFilter(mdl);
 }
コード例 #36
0
 public void AddFilter(IFilterModel mdl, bool allowRemove)
 {
     AddFilter(mdl, allowRemove, null);
 }
コード例 #37
0
        public void AddFilter(IFilterModel mdl, bool allowRemove, IEnumerable<Property> sourceProperties)
        {
            InitializeFilter();
            _filter.Add(mdl);
            if (mdl is IUIFilterModel)
            {
                var uimdl = (IUIFilterModel)mdl;

                var vmdl = FilterViewModel.Fetch(ViewModelFactory, DataContext, this, uimdl);
                vmdl.RequestedKind = uimdl.RequestedKind;
                vmdl.RespectRequiredFilter = RespectRequiredFilter;

                var levmdl = FilterListEntryViewModel.Fetch(ViewModelFactory, DataContext, this, vmdl);
                levmdl.IsUserFilter = allowRemove;
                levmdl.SourceProperties = sourceProperties;

                // attach change events
                uimdl.FilterChanged += new EventHandler(delegate(object s, EventArgs a)
                {
                    var f = s as FilterModel;
                    if (f == null || !f.RefreshOnFilterChanged) return;

                    if (f.IsServerSideFilter)
                    {
                        OnExecuteFilter();
                    }
                    else
                    {
                        OnExecutePostFilter();
                    }
                });

                _FilterViewModels.Add(vmdl);
                _FilterListEntryViewModels.Add(levmdl);
            }
            if(allowRemove) UpdateRespectRequieredFilter();

            OnPropertyChanged("RespectRequiredFilter");
            OnPropertyChanged("HasUserFilter");
            OnPropertyChanged("Filter");
            OnPropertyChanged("FilterViewModels");
            OnPropertyChanged("FilterListEntryViewModels");
        }