public CobieLiteUkExport()
{
InitializeComponent();
// prepare templates list
AvailableTemplates = new ObservableCollection <string>();
foreach (var avail in Templates.GetAvalilableTemplateTypes())
{
AvailableTemplates.Add(avail);
}
SelectedTemplate = AvailableTemplates.FirstOrDefault();
// prepare export
ExportTypes = new ObservableCollection <string>()
{
"XLS", "XLSX", "JSON", "XML", "IFC"
};
SelectedExportType = "XLSX";
// prepare system modes
AvailableSystemModes = new ObservableCollection <SystemModeItem>();
foreach (var valid in Enum.GetValues(typeof(SystemExtractionMode)).OfType <SystemExtractionMode>().Where(r => r != SystemExtractionMode.System))
{
AvailableSystemModes.Add(new SystemModeItem(valid));
}
// define filters and set defaults
UserFilters = new FilterValues();
SetDefaultFilters();
DataContext = this;
}
public ClassFilter(FilterValues userFilters)
{
InitializeComponent();
DefaultFilters = new FilterValues(); //gives us the initial list of types
UserFilters = userFilters; //hold the amendments, as required by the user
}
public FilterControllerTests()
{
var profiles = new MapProfiles();
var configuration = new MapperConfiguration(cfg => cfg.AddProfile(profiles));
var mapper = new Mapper(configuration);
var values = new FilterValues
{
Id = "1",
Field = "2",
Values = new[] { new LabelValuePair {
Label = "3", Value = "3"
}, new LabelValuePair {
Label = "4", Value = "4"
} },
Libraries = new [] { "5", "6" }
};
var filterServiceMock = new Mock <IFilterService>();
filterServiceMock
.Setup(x => x.GetFilterValues(It.IsAny <LibraryType>(), It.IsAny <string>(), It.IsAny <string[]>()))
.Returns(values);
_controller = new FilterController(filterServiceMock.Object, mapper);
}
public ClassFilter(FilterValues userFilters)
{
InitializeComponent();
DefaultFilters = new FilterValues(); //gives us the initial list of types
UserFilters = userFilters; //hold the amendments, as required by the user
}
/// <summary>
/// Добавить значение в параметр FilterValues.
/// </summary>
/// <param name="filterValue"></param>
public void AddFilterValue(string filterValue)
{
if (FilterValues == null)
{
FilterValues = new List <string>();
}
FilterValues.Add(filterValue);
}
public COBieXLSSerialiser(string fileName, string templateFileName)
{
FileName = fileName;
TemplateFileName = templateFileName;
HasErrorLevel = typeof(COBieError).GetProperties().Any(prop => prop.Name == "ErrorLevel");
_commentCount = 0;
Excludes = new FilterValues();//get the rules for excludes for generating COBie
}
private FilterValues GetFilterValues()
{
var filterValuesDto = new FilterValues
{
Rooms = _roomService.GetAllRoomCompanyNames().ToList()
};
return(filterValuesDto);
}
public COBieGenerator()
{
InitializeComponent();
MergeItemsList = new List <string>();
UserFilters = new FilterValues(); //class filters
// Configure the app to use Esent when appropriate
IfcStore.ModelProviderFactory.UseHeuristicModelProvider();
}
public void Insert(FilterValues values)
{
ExecuteQuery(() =>
{
using var database = Context.CreateDatabaseContext();
var collection = database.GetCollection <FilterValues>("Filters");
collection.Insert(values);
});
}
private FilterValues GetFilterValues()
{
var filterValuesDto = new FilterValues
{
Genres = _genreService.GetAllGenreNames().ToList(),
Platforms = _platformService.GetAllPlatformNames().ToList(),
Publishers = _publisherService.GetAllPublisherCompanyNames().ToList()
};
return(filterValuesDto);
}
protected override void SetupRepository()
{
var context = CreateDbContext();
using (var database = context.LiteDatabase)
{
var collection = database.GetCollection <FilterValues>("Filters");
var filterValuesOne = new FilterValues
{
Field = "subtitle",
Id = "10",
Libraries = new[] { "1", "2" },
Values = new[] { new LabelValuePair {
Label = "1", Value = "1"
}, new LabelValuePair {
Label = "2", Value = "2"
} }
};
var filterValuesTwo = new FilterValues
{
Field = "subtitle",
Id = "11",
Libraries = new[] { "1" },
Values = new[] { new LabelValuePair {
Label = "3", Value = "3"
}, new LabelValuePair {
Label = "4", Value = "4"
} }
};
var filterValuesThree = new FilterValues
{
Field = "container",
Id = "12",
Libraries = new [] { "1" },
Values = new[] { new LabelValuePair {
Label = "a", Value = "a"
}, new LabelValuePair {
Label = "b", Value = "b"
} }
};
collection.InsertBulk(new[] { filterValuesOne, filterValuesTwo, filterValuesThree });
}
_filterRepository = new FilterRepository(context);
}
public IEnumerable <T> GetFilteredRows <T>(IEnumerable <T> resultRows) where T : IResultRow
{
int cutoffIrating;
try
{
cutoffIrating = FilterValues.OfType <IntFilterValueEntity>().FirstOrDefault().IntValue;
}
catch (Exception e)
{
throw new InvalidFilterValueException("Filter is null or has invalid type", innerException: e);
}
// Return rows with irating >= cutoff or exclude them
return(resultRows.Where(x => (x.SeasonStartIRating >= cutoffIrating) != Exclude));
}
public COBieExport()
{
InitializeComponent();
ConfigureFolder();
// prepare templates list
Templates = new ObservableCollection <string>()
{
UkTemplate, UsTemplate
};
SelectedTemplate = UkTemplate;
// define filters and set defaults
UserFilters = new FilterValues();
SetDefaultFilters();
DataContext = this;
}
public COBieClassFilter(FilterValues userFilters)
{
InitializeComponent();
UserFilters = userFilters; //hold the amendments, as required by the user
DefaultFilters = new FilterValues(); //gives us the initial list of types
//initialize the collection classes for the list box's
ClassFilterComponent = new ObservableCollection <CheckedListItem <Type> >();
ClassFilterType = new ObservableCollection <CheckedListItem <Type> >();
ClassFilterAssembly = new ObservableCollection <CheckedListItem <Type> >();
//fill in the collections to display the check box's in the list box's
InitExcludes(ClassFilterComponent, DefaultFilters.ObjectType.Component, UserFilters.ObjectType.Component);
InitExcludes(ClassFilterType, DefaultFilters.ObjectType.Types, UserFilters.ObjectType.Types);
InitExcludes(ClassFilterAssembly, DefaultFilters.ObjectType.Assembly, UserFilters.ObjectType.Assembly);
DataContext = this;
}
public XplorerMainWindow()
{
InitializeComponent();
this.Closed += new EventHandler(XplorerMainWindow_Closed);
this.Loaded += XplorerMainWindow_Loaded;
this.Closing += new CancelEventHandler(XplorerMainWindow_Closing);
this.DrawingControl.UserModeledDimensionChangedEvent += DrawingControl_MeasureChangedEvent;
InitFromSettings();
RefreshRecentFiles();
UserFilters = new FilterValues();//COBie Class filters, set to initial defaults
COBieTemplate = _UKTemplate;
if (Settings.Default.PluginStartupLoad)
{
RefreshPlugins();
}
}
private FilterValues CalculateMovieFilterValues(string field, string[] libraryIds)
{
var values = new FilterValues
{
Id = Guid.NewGuid().ToString(),
Field = field,
Libraries = libraryIds
};
switch (field.ToLowerInvariant())
{
case "subtitle":
values.Values = _movieRepository.CalculateSubtitleFilterValues(libraryIds).ToArray();
break;
case "genre":
values.Values = _movieRepository.CalculateGenreFilterValues(libraryIds).ToArray();
break;
case "container":
values.Values = _movieRepository.CalculateContainerFilterValues(libraryIds).ToArray();
break;
case "collection":
values.Values = _movieRepository.CalculateCollectionFilterValues().ToArray();
break;
case "codec":
values.Values = _movieRepository.CalculateCodecFilterValues(libraryIds).ToArray();
break;
case "videorange":
values.Values = _movieRepository.CalculateVideoRangeFilterValues(libraryIds).ToArray();
break;
default: return(null);
}
_filterRepository.Insert(values);
return(values);
}
private void MetroWindow_Loaded(object sender, System.Windows.RoutedEventArgs e)
{
MainWindow mainWindow = Application.Current.MainWindow as MainWindow;
List <EnvironmentState> environmentstate = mainWindow.GetEnvironmentStatesList();
List <ReleaseInformation> releaseinfo = mainWindow.GetReleaseInformation();
List <PlatformReleaseInformation> platformrelease = mainWindow.GetPlatformReleaseInformation();
Status.ItemsSource = environmentstate;
Release.ItemsSource = releaseinfo;
PlatformRelease.ItemsSource = platformrelease;
FilterValues filterValues = mainWindow.GetFilter();
if (filterValues.Active == true)
{
Status.SelectedItem = environmentstate.FirstOrDefault(x => x.StateDescription.Equals(filterValues.environmentState));
Release.SelectedItem = releaseinfo.FirstOrDefault(x => x.Release.Equals(filterValues.releaseInformation));
PlatformRelease.SelectedItem = platformrelease.FirstOrDefault(x => x.PlatformRelease.Equals(filterValues.platformReleaseInformation));
}
}
public async Task <IEnumerable <CosmosSensorData> > GetFilteredSensorData(string minDateTime = null, string maxDateTime = null)
{
string message = $"GetFilteredSensorData() called at {DateTime.UtcNow.ToLongTimeString()}";
_logger.LogInformation(message);
FilterValues filter = new FilterValues();
if (minDateTime != null)
{
filter.MinDateTime = minDateTime;
}
if (maxDateTime != null)
{
filter.MaxDateTime = maxDateTime;
}
var result = await _queries.GetAllItems(filter);
return(result);
}
private FilterService CreateFilterService(LibraryType type, string field, string[] libraryIds)
{
_filterValues = new FilterValues
{
Id = "1",
Field = field,
Values = new[] { new LabelValuePair {
Label = "2", Value = "2"
}, new LabelValuePair {
Label = "3", Value = "3"
} },
Libraries = libraryIds
};
_filterRepositoryMock
.Setup(x => x.Get(field, libraryIds))
.Returns(_filterValues);
_filterRepositoryMock
.Setup(x => x.Insert(It.IsAny <FilterValues>()));
return(new FilterService(_filterRepositoryMock.Object, _movieRepositoryMock.Object));
}
private void SetDefaultFilters()
{
var defaultFilters = new FilterValues(); //gives us the initial list of types
//initialize the collection classes for the list box's
if (ClassFilterComponent == null)
{
ClassFilterComponent = new ObservableCollection <CheckedListItem <Type> >();
}
if (ClassFilterType == null)
{
ClassFilterType = new ObservableCollection <CheckedListItem <Type> >();
}
if (ClassFilterAssembly == null)
{
ClassFilterAssembly = new ObservableCollection <CheckedListItem <Type> >();
}
//fill in the collections to display the check box's in the list box's
InitExcludes(ClassFilterComponent, defaultFilters.ObjectType.Component, UserFilters.ObjectType.Component);
InitExcludes(ClassFilterType, defaultFilters.ObjectType.Types, UserFilters.ObjectType.Types);
InitExcludes(ClassFilterAssembly, defaultFilters.ObjectType.Assembly, UserFilters.ObjectType.Assembly);
}
public JsonResult GetFiltersValue(string _reportID)
{
Guid ReportID = new Guid(_reportID);
var data = db.reportFilters.Where(x => x.ReportID == ReportID).Where(x => x.IsEditable == 1).GroupBy(x => x.FilterType);
List <FilterValues> model = new List <FilterValues>();
foreach (var group in data)
{
FilterValues record = new FilterValues();
record.key = group.Key.ToString();
record.gid = string.Empty;
record.val = string.Empty;
foreach (var entry in group)
{
record.gid = record.gid == string.Empty ? record.gid : record.gid + ",";
record.val = record.val == string.Empty ? record.val : record.val + ",";
record.gid += string.IsNullOrEmpty(entry.FilterGUID.ToString()) ? "-" : entry.FilterGUID.ToString();
record.val += string.IsNullOrEmpty(entry.FilterValue.ToString()) ? "-" : entry.FilterValue.ToString();
}
model.Add(record);
}
return(Json(model, JsonRequestBehavior.AllowGet));
}
public COBieXLSXSerialiser(string fileName, string templateFileName)
{
IsXlsx = false;
FileName = fileName;
TemplateFileName = templateFileName;
hasErrorLevel = typeof(COBieError).GetProperties().Where(prop => prop.Name == "ErrorLevel").Any();
_commentCount = 0;
Excludes = new FilterValues();//get the rules for excludes for generating COBie
}
public static FilterResult Filter(FilterValues filters, string path)
{
var results = new List <Histogram>();
var filterCount = 9;
var destImages = new Image <Rgba32> [filterCount];
var srcImage = Image.Load <Rgba32>(path);
IImageInfo info;
using (var file = new FileStream(path, FileMode.Open))
{
info = Image.Identify(file);
}
// Reserve image memory
for (int i = 0; i < filterCount; i++)
{
destImages[i] = new Image <Rgba32>(info.Width, info.Height);
}
// Create threads
var threads = Environment.ProcessorCount;
double chunks = (double)info.Height / threads;
Parallel.For(0, threads, i =>
{
// Leave a image edge of 1px for kernel
var rect = new FilterRect
{
x = 1,
y = (int)(i * chunks) + 1,
endx = info.Width - 1,
endy = (int)((i + 1) * chunks) + (i == (threads - 1) ? -1 : +1)
};
results.Add(ApplyFilters(filters, srcImage, destImages, rect));
});
LongestVerticalLineCount(
srcImage: srcImage,
srcFilter: destImages[ImageIdx.Passfilter],
hinterpolateImage: destImages[ImageIdx.HInterpolte],
destImage: destImages[ImageIdx.LongestEdgeOverlay],
avgWindow: filters.ScanlineInterpolationWidth);
// Processing now completed
// Copy all filtered images into one
var stages = new Image <Rgba32>[]
{
destImages[ImageIdx.EdgeFilter],
destImages[ImageIdx.Blur],
destImages[ImageIdx.Passfilter],
destImages[ImageIdx.HInterpolte],
destImages[ImageIdx.LongestEdgeOverlay]
};
var pipelineImage = new Image <Rgba32>(stages.Length * info.Width, info.Height);
for (int y = 0; y < info.Height; y++)
{
var targetRow = pipelineImage.GetPixelRowSpan(y);
// Copy all stages rows into one giant column side by side
for (int i = 0; i < stages.Length; i++)
{
var srcRow = stages[i].GetPixelRowSpan(y);
for (int x = 0; x < info.Width; x++)
{
targetRow[x + i * info.Width] = srcRow[x];
}
}
}
return(new FilterResult
{
Histogram = results.Aggregate(new Histogram(), (a, b) => a.Add(b)),
RedImage = destImages[ImageIdx.Red],
GreenImage = destImages[ImageIdx.Green],
LeafImage = destImages[ImageIdx.Leaf],
EarthImage = destImages[ImageIdx.Earth],
EdgeImage = destImages[ImageIdx.EdgeFilter],
PassImage = destImages[ImageIdx.Passfilter],
BlurImage = destImages[ImageIdx.Blur],
HInterpolateImage = destImages[ImageIdx.HInterpolte],
PlantTipImage = destImages[ImageIdx.LongestEdgeOverlay],
WholePipeline = pipelineImage
});
}
public IEnumerable <string> GetFilterValues()
{
return(FilterValues.Select(x => x.ToString()));
}
public COBieGenerator()
{
InitializeComponent();
MergeItemsList = new List <string>();
UserFilters = new FilterValues(); //class filters
}
bool _FilterOperatorSingleRow; // false for Top/Bottom N and Percent; otherwise true
internal Filter(ReportDefn r, ReportLink p, XmlNode xNode) : base(r, p)
{
_FilterExpression = null;
_FilterOperator = FilterOperatorEnum.Unknown;
_FilterValues = null;
// Loop thru all the child nodes
foreach (XmlNode xNodeLoop in xNode.ChildNodes)
{
if (xNodeLoop.NodeType != XmlNodeType.Element)
{
continue;
}
switch (xNodeLoop.Name)
{
case "FilterExpression":
_FilterExpression = new Expression(r, this, xNodeLoop, ExpressionType.Variant);
break;
case "Operator":
_FilterOperator = Engine.FilterOperator.GetStyle(xNodeLoop.InnerText);
if (_FilterOperator == FilterOperatorEnum.Unknown)
{
OwnerReport.rl.LogError(8, "Unknown Filter operator '" + xNodeLoop.InnerText + "'.");
}
break;
case "FilterValues":
_FilterValues = new FilterValues(r, this, xNodeLoop);
break;
default:
// don't know this element - log it
OwnerReport.rl.LogError(4, "Unknown Filter element '" + xNodeLoop.Name + "' ignored.");
break;
}
}
if (_FilterExpression == null)
{
OwnerReport.rl.LogError(8, "Filter requires the FilterExpression element.");
}
if (_FilterValues == null)
{
OwnerReport.rl.LogError(8, "Filter requires the FilterValues element.");
return; // some of the filter operator checks require values
}
_FilterOperatorSingleRow = true;
switch (_FilterOperator)
{
case FilterOperatorEnum.Like:
case FilterOperatorEnum.Equal:
case FilterOperatorEnum.NotEqual:
case FilterOperatorEnum.GreaterThan:
case FilterOperatorEnum.GreaterThanOrEqual:
case FilterOperatorEnum.LessThan:
case FilterOperatorEnum.LessThanOrEqual:
if (_FilterValues.Items.Count != 1)
{
OwnerReport.rl.LogError(8, "Filter Operator requires exactly 1 FilterValue.");
}
break;
case FilterOperatorEnum.TopN:
case FilterOperatorEnum.BottomN:
case FilterOperatorEnum.TopPercent:
case FilterOperatorEnum.BottomPercent:
_FilterOperatorSingleRow = false;
if (_FilterValues.Items.Count != 1)
{
OwnerReport.rl.LogError(8, "Filter Operator requires exactly 1 FilterValue.");
}
break;
case FilterOperatorEnum.In:
break;
case FilterOperatorEnum.Between:
if (_FilterValues.Items.Count != 2)
{
OwnerReport.rl.LogError(8, "Filter Operator Between requires exactly 2 FilterValues.");
}
break;
default:
OwnerReport.rl.LogError(8, "Valid Filter operator must be specified.");
break;
}
}
public CloudHostedViewModel()
{
RDPTerminals = new System.Collections.ObjectModel.ObservableCollection <Model.RDPTerminal>();
MainWindow mainWindow = Application.Current.MainWindow as MainWindow;
List <CloudHostedInstance> cloudHostedTerminals = mainWindow.CloudHosted;
List <InstanceAttribute> instanceAttributes = mainWindow.InstanceAttributes;
mainWindow.EnableCloudHosted(false);
FilterValues filterValues = mainWindow.GetFilter();
NumberOfMachines = cloudHostedTerminals.Count;
if (cloudHostedTerminals != null)
{
foreach (CloudHostedInstance instance in cloudHostedTerminals)
{
InstanceAttribute instanceAttribute = instanceAttributes.Find(x => x.EnvironmentId == instance.EnvironmentId);
string imageSource = "/Resources/DefaultVM.png";
if (instanceAttribute != null)
{
imageSource = instanceAttribute.ImageSource;
}
EnvironmentState envState = new EnvironmentState()
{
StateDescription = instance.DeploymentStatus,
StateNum = instance.DeploymentState
};
mainWindow.AddEnvironmentState(envState);
PlatformReleaseInformation platformReleaseInformation = new PlatformReleaseInformation()
{
PlatformRelease = instance.CurrentPlatformReleaseName
};
ReleaseInformation releaseinformation = new ReleaseInformation()
{
Release = instance.CurrentApplicationReleaseName
};
if (platformReleaseInformation.PlatformRelease != null && releaseinformation.Release != null)
{
mainWindow.AddReleaseInformation(releaseinformation, platformReleaseInformation);
}
bool okToAdd = false;
if (filterValues.Active == true)
{
if (instance.DeploymentStatus == filterValues.environmentState.StateDescription &&
instance.CurrentApplicationReleaseName == filterValues.releaseInformation.Release &&
instance.CurrentPlatformReleaseName == filterValues.platformReleaseInformation.PlatformRelease)
{
okToAdd = true;
}
}
else
{
okToAdd = true;
}
if (okToAdd == true)
{
RDPTerminals.Add(new Model.RDPTerminal()
{
InstanceId = instance.InstanceId,
DeploymentStatus = instance.DeploymentStatus,
ApplicationRelease = instance.CurrentApplicationReleaseName,
CurrentPlatformReleaseName = instance.CurrentPlatformReleaseName,
TopologyType = instance.TopologyType,
DisplayName = instance.DisplayName,
EnvironmentId = instance.EnvironmentId,
Instances = instance.Instances,
SqlAzureCredentials = instance.SqlAzureCredentials,
NavigationLinks = instance.NavigationLinks,
ImageSource = imageSource
});
}
}
if (RDPTerminals.Count > 0)
{
RDPTerminals.BubbleSort();
SelectedRDPTerminal = RDPTerminals[0];
mainWindow.EnableCloudHosted(true);
}
}
}
public COBieGenerator()
{
InitializeComponent();
MergeItemsList = new List<string>();
UserFilters = new FilterValues(); //class filters
}
/// <summary>
/// This method does three things:
/// 1. Create a histogram or the original image color distribution
/// 2. Creates a new image with filtered green colors
/// 2. Creates a new image with filtered red colors
/// </summary>
/// <returns></returns>
public ImageProcessResult Start(FilterValues thresholds)
{
var filterResult = Filter(thresholds, _imageFile.Original.Path);
filterResult.RedImage.Save(_imageFile.FilteredRed.Path);
filterResult.GreenImage.Save(_imageFile.FilteredGreen.Path);
filterResult.LeafImage.Save(_imageFile.Leaf.Path);
filterResult.EarthImage.Save(_imageFile.Earth.Path);
filterResult.EdgeImage.Save(_imageFile.Edge.Path);
filterResult.PlantTipImage.Save(_imageFile.PlantTip.Path);
filterResult.BlurImage.Save(_imageFile.Blur.Path);
filterResult.PassImage.Save(_imageFile.Pass.Path);
filterResult.HInterpolateImage.Save(_imageFile.HInterpolate.Path);
filterResult.Histogram.Draw(filterResult, false, 256, 200);
filterResult.Histogram.HistogramR.Save(_imageFile.HistR.Path);
filterResult.Histogram.HistogramG.Save(_imageFile.HistG.Path);
filterResult.Histogram.HistogramB.Save(_imageFile.HistB.Path);
filterResult.WholePipeline.Save(_imageFile.WholePipeline.Path);
return(new ImageProcessResult
{
FilterValues = thresholds,
Files = new List <FilterFileInfo>()
{
new FilterFileInfo {
Path = _imageFile.WholePipeline.RelativePath, Element = "pipeline"
},
new FilterFileInfo {
Path = _imageFile.Original.RelativePath, Element = "original"
},
new FilterFileInfo {
Path = _imageFile.Blur.RelativePath, Element = "blur"
},
new FilterFileInfo {
Path = _imageFile.Earth.RelativePath, Element = "earth"
},
new FilterFileInfo {
Path = _imageFile.Edge.RelativePath, Element = "edge"
},
new FilterFileInfo {
Path = _imageFile.FilteredGreen.RelativePath, Element = "green"
},
new FilterFileInfo {
Path = _imageFile.FilteredRed.RelativePath, Element = "red"
},
new FilterFileInfo {
Path = _imageFile.PlantTip.RelativePath, Element = "tip"
},
new FilterFileInfo {
Path = _imageFile.Leaf.RelativePath, Element = "leaf"
},
new FilterFileInfo {
Path = _imageFile.HInterpolate.RelativePath, Element = "hinterpolate"
},
new FilterFileInfo {
Path = _imageFile.HistR.RelativePath, Element = "hist-red"
},
new FilterFileInfo {
Path = _imageFile.HistG.RelativePath, Element = "hist-green"
},
new FilterFileInfo {
Path = _imageFile.HistB.RelativePath, Element = "hist-blue"
},
new FilterFileInfo {
Path = _imageFile.Pass.RelativePath, Element = "pass"
}
}
});
}
public IEnumerable <T> GetFilteredRows <T>(IEnumerable <T> resultRows) where T : IResultRow
{
// get property by columnPropertyName
var nestedColumnProperty = typeof(IResultRow).GetNestedPropertyInfo(ColumnPropertyName);
if (nestedColumnProperty == null)
{
throw new InvalidFilterValueException($"Column property witht the name {ColumnPropertyName} not found");
}
Type propertyType = nestedColumnProperty.PropertyType;
if (typeof(IComparable).IsAssignableFrom(propertyType) == false)
{
throw new InvalidFilterValueException($"Column {ColumnPropertyName} does not have a comparable type");
}
// Convert string to column property type
IEnumerable <IComparable> comparableFilterValues;
if (propertyType.Equals(typeof(TimeSpan)))
{
comparableFilterValues = FilterValues.Select(x => TimeSpan.Parse(x)).Cast <IComparable>();
}
else
{
comparableFilterValues = FilterValues.Select(x => Convert.ChangeType(x, propertyType, CultureInfo.InvariantCulture)).Cast <IComparable>();
}
Func <IComparable, IEnumerable <IComparable>, bool> compare;
switch (Comparator)
{
case ComparatorTypeEnum.IsBigger:
compare = (x, y) => { var c = x.CompareTo(y.FirstOrDefault()); return(c == 1); };
break;
case ComparatorTypeEnum.IsBiggerOrEqual:
compare = (x, y) => { var c = x.CompareTo(y.FirstOrDefault()); return(c == 1 || c == 0); };
break;
case ComparatorTypeEnum.IsEqual:
compare = (x, y) => { var c = x.CompareTo(y.FirstOrDefault()); return(c == 0); };
break;
case ComparatorTypeEnum.IsSmallerOrEqual:
compare = (x, y) => { var c = x.CompareTo(y.FirstOrDefault()); return(c == -1 || c == 0); };
break;
case ComparatorTypeEnum.IsSmaller:
compare = (x, y) => { var c = x.CompareTo(y.FirstOrDefault()); return(c == -1); };
break;
case ComparatorTypeEnum.NotEqual:
compare = (x, y) => { var c = x.CompareTo(y.FirstOrDefault()); return(c == 1 || c == -1); };
break;
case ComparatorTypeEnum.InList:
compare = (x, y) => { var c = y.Any(z => x.CompareTo(z) == 0); return(c); };
break;
default:
compare = (x, y) => true;
break;
}
return(resultRows.Where(x => { var value = (IComparable)nestedColumnProperty.GetValue(x); return (value != null && compare(value, comparableFilterValues)) != Exclude; }));
}
/// <summary>
/// Page load.
/// </summary>
protected void Page_Load(object sender, EventArgs e)
{
if (StopProcessing)
{
// Do nothing
}
else
{
if (!RequestHelper.IsPostBack() && (FilterMode != SearchFilterModeEnum.TextBox))
{
// If query name filled - execute it
if (!string.IsNullOrEmpty(FilterQueryName))
{
// Execute query
DataSet ds = ConnectionHelper.ExecuteQuery(FilterQueryName, null, FilterWhere, FilterOrderBy);
if (!DataHelper.DataSourceIsEmpty(ds))
{
// Check that dataset has at least 3 columns
if (ds.Tables[0].Columns.Count < 3)
{
lblError.ResourceString = "srch.filter.fewcolumns";
lblError.Visible = true;
return;
}
// Loop thru all rows
foreach (DataRow dr in ds.Tables[0].Rows)
{
AddItem(dr[0].ToString(), dr[1].ToString(), ResHelper.LocalizeString(dr[2].ToString()));
}
}
}
// Else if values are filled - parse them
else if (!string.IsNullOrEmpty(FilterValues))
{
// Split values into rows
string[] rows = FilterValues.Split(new string[] { "\n" }, StringSplitOptions.RemoveEmptyEntries);
// Loop thru each row
foreach (string row in rows)
{
string trimmedRow = row.Trim().TrimEnd('\r');
if (!string.IsNullOrEmpty(trimmedRow))
{
string[] values = trimmedRow.Split(';');
if (values.Length == 3)
{
AddItem(values[0], values[1], values[2]);
}
else
{
lblError.ResourceString = "srch.filter.badformat";
lblError.Visible = true;
return;
}
}
}
}
}
// Get webpart ID
string webpartID = ValidationHelper.GetString(GetValue("WebpartControlID"), ClientID);
// Try to get selected values from querystring - but only if is not postback
if (!RequestHelper.IsPostBack())
{
string selectedItems = QueryHelper.GetString(webpartID, "");
// If none of items are selected - try to get default values
if (string.IsNullOrEmpty(selectedItems))
{
selectedItems = DefaultSelectedIndex;
}
if (!string.IsNullOrEmpty(selectedItems))
{
string[] splittedItems = selectedItems.Split(';');
foreach (string item in splittedItems)
{
switch (FilterMode)
{
case SearchFilterModeEnum.Checkbox:
SelectItem(item, chklstFilter);
break;
case SearchFilterModeEnum.RadioButton:
SelectItem(item, radlstFilter);
break;
case SearchFilterModeEnum.DropdownList:
SelectItem(item, drpFilter);
break;
default:
txtFilter.Text = item;
break;
}
}
}
}
string applyFilter = "";
string ids = "";
// Set up controls
switch (FilterMode)
{
// Set text box
case SearchFilterModeEnum.TextBox:
txtFilter.Visible = true;
txtFilter.WatermarkCssClass = WatermarkCssClass;
txtFilter.WatermarkText = WatermarkText;
txtFilter.AutoPostBack = FilterAutoPostback;
if (!String.IsNullOrEmpty(DefaultSelectedIndex) && String.IsNullOrEmpty(txtFilter.Text) && !URLHelper.IsPostback())
{
txtFilter.Text = DefaultSelectedIndex;
}
// Apply filter only of textbox contains something
if (!String.IsNullOrEmpty(txtFilter.Text))
{
// Prepare right condition when filter values aren't empty
if (!String.IsNullOrEmpty(FilterValues))
{
string[] rows = FilterValues.Split(new string[] { "\n" }, StringSplitOptions.RemoveEmptyEntries);
// Loop thru each row
foreach (string row in rows)
{
string trimmedRow = row.Trim();
if (!string.IsNullOrEmpty(trimmedRow))
{
applyFilter += trimmedRow + ":(" + SearchHelper.ProcessSearchKeywords(txtFilter.Text, SearchOptionsEnum.NoneSearch) + ") ";
}
}
}
else
{
applyFilter = txtFilter.Text;
}
}
ids = HttpUtility.UrlEncode(txtFilter.Text);
break;
// Set checkbox list
case SearchFilterModeEnum.Checkbox:
// Set visibility and layout
chklstFilter.Visible = true;
chklstFilter.RepeatDirection = RepeatDirection.Vertical;
if (FilterLayout == ControlLayoutEnum.Horizontal)
{
chklstFilter.RepeatDirection = RepeatDirection.Horizontal;
}
chklstFilter.RepeatLayout = GetLayoutEnumFromString(RepeatLayout);
chklstFilter.RepeatColumns = this.RepeatColumns;
// Get selected items
applyFilter = GetSelectedItems(chklstFilter, out ids);
// Set autopostback
if (FilterAutoPostback)
{
chklstFilter.AutoPostBack = true;
}
break;
// Set radio list
case SearchFilterModeEnum.RadioButton:
// Set visibility and layout
radlstFilter.Visible = true;
radlstFilter.RepeatDirection = RepeatDirection.Vertical;
if (FilterLayout == ControlLayoutEnum.Horizontal)
{
radlstFilter.RepeatDirection = RepeatDirection.Horizontal;
}
radlstFilter.RepeatLayout = GetLayoutEnumFromString(RepeatLayout);
radlstFilter.RepeatColumns = this.RepeatColumns;
// Get selected items
applyFilter = GetSelectedItems(radlstFilter, out ids);
// Set autopostback
if (FilterAutoPostback)
{
radlstFilter.AutoPostBack = true;
}
break;
// Set dropdown list
default:
// Set visibility
drpFilter.Visible = true;
// Get selected items
applyFilter = GetSelectedItems(drpFilter, out ids);
// Set autopostback
if (FilterAutoPostback)
{
drpFilter.AutoPostBack = true;
}
lblFilter.AssociatedControlID = drpFilter.ID;
break;
}
// Apply filter and add selected values to querystring
ISearchFilterable searchWebpart = (ISearchFilterable)CMSControlsHelper.GetFilter(SearchWebpartID);
if (searchWebpart != null)
{
if (FilterIsConditional)
{
// If filter fieldname or value is filled
if (!string.IsNullOrEmpty(applyFilter) && (applyFilter.Trim() != ":"))
{
// Handle filter clause
if (!string.IsNullOrEmpty(FilterClause))
{
applyFilter = FilterClause + "( " + applyFilter + " )";
}
searchWebpart.ApplyFilter(applyFilter, null);
}
searchWebpart.AddFilterOptionsToUrl(webpartID, ids);
}
else
{
searchWebpart.ApplyFilter(null, applyFilter);
searchWebpart.AddFilterOptionsToUrl(webpartID, ids);
}
}
}
}
private static Histogram ApplyFilters(FilterValues filterValues, in Image <Rgba32> srcImage, Image <Rgba32>[] images,
