private void AddExpressions(QueryParameters qParams, List <FilterItem> filterItems, BaseFilterParameter <TTable> filter, List <Expression> expressions)
{
expressions.AddRange(
filterItems.Where(f => f.FilterType == "NotEquals")
.Select(f => filter.CreateFilterExpression(f, qParams))
.Where(f => f != null));
var items = filterItems
.Where(f => f.FilterType != "NotEquals" && f.FilterType != "Non")
.Select(f => filter.CreateFilterExpression(f, qParams))
.Where(f => f != null)
.ToList();
if (items.Count == 1)
{
expressions.Add(items[0]);
AppliedFilters.Add(filter);
}
else if (items.Count > 1)
{
var param = Expression.Parameter(typeof(TTable), "orRow");
var orExpressions =
items.Select(e => (Expression)Expression.Invoke(e, param)).Aggregate(Expression.Or);
expressions.Add(Expression.Lambda(orExpressions, param));
AppliedFilters.Add(filter);
}
}
/// <summary>
/// Apply filter to image. Notice that FilterModel may consist of many IFilter components.
/// </summary>
/// <param name="filter">Filter to apply</param>
public void ApplyFilter(FilterModel filter, bool shouldCrop)
{
AppliedFilters.Add(filter);
// cropping photo
if (shouldCrop)
{
int minSide = (int)Math.Min(Width, Height);
Windows.Foundation.Rect rect = new Windows.Foundation.Rect()
{
Width = minSide,
Height = minSide,
X = (Width - minSide) / 2,
Y = (Height - minSide) / 2,
};
_session.AddFilter(FilterFactory.CreateCropFilter(rect));
}
foreach (IFilter f in filter.Components)
{
_session.AddFilter(f);
}
Width = _session.Dimensions.Width;
Height = _session.Dimensions.Height;
}
/// <summary>
/// Applies filters
/// </summary>
/// <param name="filters">Filters</param>
public void ApplyFilters(List <Filter> filters)
{
try
{
// Saving original image
if (AppliedFilters.Count == 0)
{
OriginalFileName = GenerateOriginalFileName(ImageFileName);
File.Copy(ImageFilePath, OriginalFilePath, true);
}
// Creating temp image
if (TempFilePath.IsNullOrEmpty())
{
TempFilePath = Path.Combine(ImageFolderPath, GenerateTempFileName(ImageFileName));
File.Copy(ImageFilePath, TempFilePath, true);
}
foreach (Filter filter in filters)
{
try
{
// Applying filter
Bitmap original = new Bitmap(TempFilePath);
Bitmap bitmap = new Bitmap(original);
original.Dispose();
File.Delete(TempFilePath);
ApplyFilter(bitmap, filter).Save(TempFilePath, ImageFormat.Jpeg);
bitmap.Dispose();
GarbageCollector.Collect();
AppliedFilters.Add(filter);
}
catch (Exception e)
{
LogHelper.Logger.Error(e, $"Unable to apply filter to image. Filter name: {filter.FilterType}");
}
}
// Create thumbnail for filtered image
if (TempThumbnailFilePath.IsNullOrEmpty())
{
TempThumbnailFilePath = Path.Combine(ImageFolderPath, GenerateTempThumbnailFileName(ImageFileName));
}
else
if (File.Exists(TempThumbnailFilePath))
{
File.Delete(TempThumbnailFilePath);
}
new ImagesConverter(TempFilePath).CreateThumbnail(TempThumbnailFilePath, CommonSettings.ThumbnailWidth, CommonSettings.ThumbnailHeight);
}
catch (Exception e)
{
LogHelper.Logger.Error(e, "Unable to apply filters to image.");
}
GarbageCollector.Collect();
}
public void UndoAllFilters()
{
if (CanUndoFilter)
{
AppliedFilters.Clear();
_components.Clear();
}
}
/// <summary>
/// Apply filter to image. Notice that FilterModel may consist of many IFilter components.
/// </summary>
/// <param name="filter">Filter to apply</param>
public void ApplyFilter(FilterModel filter)
{
AppliedFilters.Add(filter);
foreach (IFilter f in filter.Components)
{
_components.Add(f);
}
}
/// <summary>
/// Undo last applied filter (if any).
/// </summary>
public void UndoFilter()
{
if (CanUndoFilter)
{
AppliedFilters.RemoveAt(AppliedFilters.Count - 1);
_session.Undo();
Width = _session.Dimensions.Width;
Height = _session.Dimensions.Height;
}
}
/// <summary>
/// Apply filter to image. Notice that FilterModel may consist of many IFilter components.
/// </summary>
/// <param name="filter">Filter to apply</param>
public void ApplyFilter(FilterModel filter)
{
AppliedFilters.Add(filter);
foreach (IFilter f in filter.Components)
{
_session.AddFilter(f);
}
Width = _session.Dimensions.Width;
Height = _session.Dimensions.Height;
}
/// <summary>
/// Undo last applied filter (if any).
/// </summary>
public void UndoFilter()
{
if (CanUndoFilter)
{
FilterModel filter = AppliedFilters[AppliedFilters.Count - 1];
for (int i = 0; i < filter.Components.Count; i++)
{
_components.RemoveAt(_components.Count - 1);
}
AppliedFilters.RemoveAt(AppliedFilters.Count - 1);
}
}
/// <summary>
/// Compute the format string which represents the relative U
/// </summary>
/// <param name="enableSorting"></param>
/// <param name="control"></param>
/// <returns></returns>
public override bool Initialize(bool enableSorting, Control control)
{
string[] fields = this.DataNavigateUrlFormatString.Split('?');
SiteMapNode node;
// If the containing page is not part of the sitemap, do not attempt to resolve the Url.
if (SiteMap.Enabled && SiteMap.CurrentNode != null)
{
node = SiteMap.Provider.FindSiteMapNodeFromKey(fields[0]);
}
else
{
node = null;
}
if (node == null)
{
_reportId = fields[0];
if (SiteMap.CurrentNode == null)
{
_navigateUrlFormatString = this.DataNavigateUrlFormatString;
if (!string.IsNullOrEmpty(this.AppliedFiltersControlID))
{
AppliedFilters af = (AppliedFilters)control.NamingContainer.FindControl(this.AppliedFiltersControlID);
_navigateUrlFormatString = af.AddQueryString(_navigateUrlFormatString);
}
}
else
{
_navigateUrlFormatString = string.Empty;
}
}
else
{
_navigateUrlFormatString = this.DataNavigateUrlFormatString.Replace(fields[0], node.Url);
if (!string.IsNullOrEmpty(this.AppliedFiltersControlID))
{
AppliedFilters af = (AppliedFilters)control.NamingContainer.FindControl(this.AppliedFiltersControlID);
_navigateUrlFormatString = af.AddQueryString(_navigateUrlFormatString);
}
}
return(base.Initialize(enableSorting, control));
}
/// <summary>
/// Rolls image filters one step back.
/// </summary>
public void RollBackFiltersOneStepBack()
{
try
{
if (AppliedFilters.Count > 1)
{
AppliedFilters.RemoveAt(AppliedFilters.Count - 1);
ClearServiceImages(false);
ApplyFilters(AppliedFilters);
}
else if (AppliedFilters.Count == 1)
{
RollBackToOriginal();
}
}
catch (Exception e)
{
LogHelper.Logger.Error(e, "Unable to roll image filters one step back.");
}
}
internal SearchCommandArgs(BaseSearchCommand command, ParseResult parseResult) : base(command, parseResult)
{
string?nameCriteria = parseResult.GetValueForArgument(BaseSearchCommand.NameArgument);
if (!string.IsNullOrWhiteSpace(nameCriteria))
{
SearchNameCriteria = nameCriteria;
}
// for legacy case new command argument is also accepted
else if (command is LegacySearchCommand legacySearchCommand)
{
string?newCommandArgument = parseResult.GetValueForArgument(NewCommand.ShortNameArgument);
if (!string.IsNullOrWhiteSpace(newCommandArgument))
{
SearchNameCriteria = newCommandArgument;
}
}
(DisplayAllColumns, ColumnsToDisplay) = ParseTabularOutputSettings(command, parseResult);
if (AppliedFilters.Contains(FilterOptionDefinition.LanguageFilter))
{
Language = GetFilterValue(FilterOptionDefinition.LanguageFilter);
}
}
public override void ClearState()
{
base.ClearState();
AppliedFilters.Clear();
}
