Esempio n. 1
0
        /// <summary>
        /// Adds filters
        /// </summary>
        /// <param name="availableFilters">Available filters</param>
        /// <param name="enabledFilters">Enabled filters</param>
        private void AddFilters(List <string> availableFilters, List <string> enabledFilters)
        {
            var upmFilterArray = new List <UPMFilter>();

            foreach (string filterNameItem in availableFilters)
            {
                if (!string.IsNullOrEmpty(filterNameItem))
                {
                    var filter = UPMFilter.FilterForName(filterNameItem, this.PreparedSearch.FilterParameter);

                    if (filter != null)
                    {
                        if (enabledFilters != null && enabledFilters.Contains(filterNameItem))
                        {
                            if (filter.FilterType == UPMFilterType.NoParam || filter.RawValues?.Count > 0)
                            {
                                filter.DefaultEnabled = true;
                                filter.Active         = true;
                            }
                        }

                        upmFilterArray.Add(filter);
                    }
                }
            }

            this.SearchPage.AvailableFilters = upmFilterArray;
        }
Esempio n. 2
0
        /// <summary>
        /// Populates filters and Identifiers for filter != Config1Filter
        /// </summary>
        /// <param name="configStore">
        /// IConfigurationUnitStore
        /// </param>
        /// <param name="filters">
        /// List&lt;UPMFilter&gt;
        /// </param>
        /// <param name="identifiers">
        /// List&lt;IIdentifier&gt;
        /// </param>
        /// <param name="defaultRadiusMeter">
        /// defaultRadiusMeter
        /// </param>
        private void PopulatePageFiltersAndIdentifiersForNonConfig1Filter(
            IConfigurationUnitStore configStore,
            List <UPMFilter> filters,
            List <IIdentifier> identifiers,
            int defaultRadiusMeter)
        {
            var infoAreaId = string.Empty;

            for (int configNo = 2; configNo < 99; configNo++)
            {
                var configNameKey = $"Config{configNo}Name";
                var configName    = ViewReference.ContextValueForKey(configNameKey);
                if (!string.IsNullOrWhiteSpace(configName))
                {
                    var configFilterKey = $"Config{configNo}Filter";
                    var geoFilter       = ViewReference.ContextValueForKey(configFilterKey);
                    var filter          = UPMFilter.FilterForName(geoFilter) as UPMDistanceFilter;
                    if (filter == null)
                    {
                        continue;
                    }

                    var expand              = configStore.ExpandByName(configName);
                    var imageName           = expand.ImageName;
                    var searchConfiguration = configStore.SearchAndListByName(configName);
                    var colorKey            = configStore.InfoAreaConfigById(searchConfiguration.InfoAreaId).ColorKey;
                    if (string.IsNullOrWhiteSpace(imageName))
                    {
                        imageName = configStore.InfoAreaConfigById(searchConfiguration.InfoAreaId).ImageName;
                    }

                    filter.ImageName = imageName;
                    filter.ColorKey  = colorKey;
                    filter.Radius    = (int)defaultRadiusMeter;
                    filter.Active    = true;
                    usedFilters.SetObjectForKey(filter, configName);
                    infoAreaId = (searchConfiguration != null) ? searchConfiguration.InfoAreaId : configName;
                    identifiers.Add(new RecordIdentifier(infoAreaId, null));
                    filters.Add(filter);
                }
                else
                {
                    break;
                }
            }
        }
Esempio n. 3
0
        private void AddFilters(List <string> availableFilters)
        {
            List <UPMFilter> upmFilterArray = new List <UPMFilter>();

            foreach (string filterNameItem in availableFilters)
            {
                if (!string.IsNullOrEmpty(filterNameItem))
                {
                    UPMFilter filter = UPMFilter.FilterForName(filterNameItem);
                    if (filter != null)
                    {
                        upmFilterArray.Add(filter);
                    }
                }
            }

            ((UPMDocumentPage)this.Page).AvailableFilters = upmFilterArray;
        }
Esempio n. 4
0
        /// <summary>
        /// Creates and adds filters based on given filter name list
        /// </summary>
        /// <param name="availableFilters">List of available filter names</param>
        public void AddFilters(IEnumerable <string> availableFilters)
        {
            var upmFilterArray = new List <UPMFilter>();

            foreach (string filterNameItem in availableFilters)
            {
                if (!string.IsNullOrEmpty(filterNameItem))
                {
                    UPMFilter filter = UPMFilter.FilterForName(filterNameItem);
                    if (filter != null && filter.FilterType == UPMFilterType.NoParam)
                    {
                        upmFilterArray.Add(filter);
                    }
                }
            }

            this.SearchPage.AvailableFilters = upmFilterArray;
        }
Esempio n. 5
0
        /// <summary>
        /// Populates filters and Identifiers for filter = Config1Filter
        /// </summary>
        /// <param name="configStore">
        /// IConfigurationUnitStore
        /// </param>
        /// <param name="filters">
        /// List&lt;UPMFilter&gt;
        /// </param>
        /// <param name="identifiers">
        /// List&lt;IIdentifier&gt;
        /// </param>
        /// <param name="defaultRadiusMeter">
        /// defaultRadiusMeter
        /// </param>
        private void PopulatePageFiltersAndIdentifiersForConfig1Filter(
            IConfigurationUnitStore configStore,
            List <UPMFilter> filters,
            List <IIdentifier> identifiers,
            int defaultRadiusMeter)
        {
            var infoAreaId = string.Empty;
            var geoFilter1 = ViewReference.ContextValueForKey("Config1Filter");
            var filter     = UPMFilter.FilterForName(geoFilter1) as UPMDistanceFilter;

            if (filter != null)
            {
                var expand              = configStore.ExpandByName(ConfigName);
                var imageName           = expand.ImageName;
                var searchConfiguration = configStore.SearchAndListByName(ConfigName);
                infoAreaId = searchConfiguration != null ? searchConfiguration.InfoAreaId : ConfigName;
                if (string.IsNullOrWhiteSpace(imageName))
                {
                    imageName = configStore.InfoAreaConfigById(searchConfiguration.InfoAreaId).ImageName;
                }

                var colorKey = expand.ColorKey;
                if (string.IsNullOrWhiteSpace(colorKey))
                {
                    colorKey = configStore.InfoAreaConfigById(searchConfiguration.InfoAreaId).ColorKey;
                }

                filter.ImageName = imageName;
                filter.ColorKey  = colorKey;
                filter.Radius    = defaultRadiusMeter;
                filter.Active    = true;
                usedFilters.SetObjectForKey(filter, ConfigName);
                filters.Add(filter);
                identifiers.Add(new RecordIdentifier(infoAreaId, null));
            }
        }
        /// <summary>
        /// Creates the page instance.
        /// </summary>
        /// <returns></returns>
        public override UPMSearchPage CreatePageInstance()
        {
            this.InfoAreaId = this.ViewReference.ContextValueForKey("InfoArea");
            this.ConfigName = this.ViewReference.ContextValueForKey("Config1Name");
            IConfigurationUnitStore configStore = ConfigurationUnitStore.DefaultStore;
            string searchTypeString             = this.ViewReference.ContextValueForKey("InitialSearchType");
            SearchPageSearchType searchType     = Convert.ToInt32(searchTypeString) == 2 ? SearchPageSearchType.OnlineSearch : SearchPageSearchType.OfflineSearch;

            if (string.IsNullOrEmpty(this.InfoAreaId) && this.ViewReference.ContextValueForKey("Modus") == "MultiSearch")
            {
                if (string.IsNullOrEmpty(this.ConfigName))
                {
                    this.ConfigName = "default";
                }
            }

            List <IIdentifier> identifiers = new List <IIdentifier>();

            this.usedFilters = new Dictionary <string, UPMFilter>();
            List <UPMFilter> filters             = new List <UPMFilter>();
            string           geoFilter1          = this.ViewReference.ContextValueForKey("Config1Filter");
            UPMFilter        filter              = UPMFilter.FilterForName(geoFilter1);
            SearchAndList    searchConfiguration = configStore.SearchAndListByName(this.ConfigName);
            var infoAreaId = searchConfiguration != null ? searchConfiguration.InfoAreaId : this.ConfigName;

            if (filter != null)
            {
                filter.Active = true;
                this.usedFilters[this.ConfigName] = filter;
                filters.Add(filter);
            }

            identifiers.Add(new RecordIdentifier(infoAreaId, null));
            for (int i = 2; i < 99; i++)
            {
                string configNameKey = $"Config{i}Name";
                string configName2   = this.ViewReference.ContextValueForKey(configNameKey);
                if (!string.IsNullOrEmpty(configName2))
                {
                    string        configFilterKey      = $"Config{i}Filter";
                    string        geoFilter2           = this.ViewReference.ContextValueForKey(configFilterKey);
                    UPMFilter     filter2              = UPMFilter.FilterForName(geoFilter2);
                    SearchAndList searchConfiguration2 = configStore.SearchAndListByName(configName2);
                    if (filter2 != null)
                    {
                        filter2.Active = true;
                        this.usedFilters[configName2] = filter2;
                        filters.Add(filter2);
                    }

                    infoAreaId = (searchConfiguration2 != null) ? searchConfiguration2.InfoAreaId : configName2;
                    identifiers.Add(new RecordIdentifier(infoAreaId, null));
                }
                else
                {
                    break;
                }
            }

            MultipleIdentifier multipleIdentifier = new MultipleIdentifier(identifiers);
            UPMSearchPage      page = new UPMSearchPage(multipleIdentifier)
            {
                SearchType            = searchType,
                AvailableFilters      = filters,
                Style                 = UPMTableStyle.UPMStandardTableStyle,
                AvailableOnlineSearch = !this.ViewReference.ContextValueIsSet("hideOnlineOfflineButton"),
                InitiallyOnline       = searchType == SearchPageSearchType.OnlineSearch,
                HideSearchBar         = true,
                ViewType              = SearchPageViewType.List
            };

            return(page);
        }