public ActionResult Browse(FilterViewModel model)
{
if (Request.Form["save"] != null)
{
model.LastViewed = DateTime.Now;
SaveFilter(model);
}
return View(model);
}
public async Task <IEnumerable <MovieRequests> > Filter(FilterViewModel vm)
{
var shouldHide = await HideFromOtherUsers();
var requests = shouldHide.Hide ? MovieRepository.GetWithUser(shouldHide.UserId) : MovieRepository.GetWithUser();
switch (vm.AvailabilityFilter)
{
case FilterType.None:
break;
case FilterType.Available:
requests = requests.Where(x => x.Available);
break;
case FilterType.NotAvailable:
requests = requests.Where(x => !x.Available);
break;
default:
throw new ArgumentOutOfRangeException();
}
switch (vm.StatusFilter)
{
case FilterType.None:
break;
case FilterType.Approved:
requests = requests.Where(x => x.Approved);
break;
case FilterType.Processing:
requests = requests.Where(x => x.Approved && !x.Available);
break;
case FilterType.PendingApproval:
requests = requests.Where(x => !x.Approved && !x.Available && !(x.Denied ?? false));
break;
default:
throw new ArgumentOutOfRangeException();
}
return(requests);
}
private void UpdateRegionFilter(FilterViewModel regions)
{
if (this.RegionMap == null || this.RegionMap.Series.Count == 0)
{
return;
}
var series = this.RegionMap.Series.OfType <GeographicShapeSeries>().Last();
series.ItemsSource = null;
foreach (var shape in this.RegionsViewModel.SelectableShapeElements)
{
var region = regions.First(reg => reg.Name == shape.ShapeName);
shape.IsSelected = region.IsSelected;
}
series.ItemsSource = this.RegionsViewModel.SelectableShapeElements;
}
public async Task <HttpResponseMessage> Get([FromUri] FilterViewModel filter)
{
PageViewModel result = new PageViewModel();
var filterModel = _mapper.Map <FilterModel>(filter);
result.Items =
_mapper.Map <List <PhoneSummaryViewModel> >(_phonesService.GetPhones(filterModel, filter.ItemsOnPage,
filter.Page));
result.TotalItems = _phonesService.TotalItems;
result.TotalPages = _phonesService.TotalPages;
var response = Request.CreateResponse(HttpStatusCode.OK, result);
return(response);
}
public ActionResult Index()
{
var filter = new FilterViewModel
{
Positions = new List <PositionViewModel>
{
new PositionViewModel
{
Name = "Quarterback",
Key = "QB"
},
new PositionViewModel
{
Name = "Running back",
Key = "RB"
},
new PositionViewModel
{
Name = "Wide receiver",
Key = "WR"
},
new PositionViewModel
{
Name = "Tight end",
Key = "TE"
},
new PositionViewModel
{
Name = "Kicker",
Key = "K"
},
new PositionViewModel
{
Name = "Defense",
Key = "DST"
}
},
Years = new List <string>
{
"2001", "2002", "2003", "2004", "2005", "2006", "2007", "2008", "2009", "2010", "2011", "2012", "2013"
}
};
return(View(filter));
}
public void TestBrowseCubeMapDataset()
{
// Arrange
var dataset =
BusinessLayerTestHelper.CreateDataset(BusinessLayerTestHelper.DatasetName);
dataset.Dimensions = BusinessLayerTestHelper.CreateDimensions(dataset);
dataset.Measures = BusinessLayerTestHelper.CreateMeasures(dataset);
var filter = new FilterViewModel();
// Act
var model = _bcvmm.Map(dataset, filter);
// Assert
model.Dataset.Dimensions.Count.ShouldBeEquivalentTo(4);
model.Dataset.Measures.Count.ShouldBeEquivalentTo(1);
model.GroupedChart.ShouldBeEquivalentTo(null);
model.DrilldownChart.ShouldBeEquivalentTo(null);
}
public async Task GetMenuItems_ReturnsViewModels()
{
var SUT = Setup();
var expectedResult = MenuItemDtos.Select(x => new ShowMenuItemViewModel
{
Id = x.Id,
Name = x.Name,
Price = $"£{x.Price:F}",
MealType = x.MealType.ToString(),
Allergens = x.Allergens.Select(y => y.AllergenType.DisplayName()),
});
var filterViewModel = new FilterViewModel();
var result = await SUT.GetMenuItems(filterViewModel);
result.Should().BeEquivalentTo(expectedResult);
}
public async Task <ActionResult> GetFilter(FilterViewModel model)
{
try
{
if (DateTime.Compare(model.LeaveFilters.Fromdate, Convert.ToDateTime("01-01-0001")) == 0 || DateTime.Compare(model.LeaveFilters.Todate, Convert.ToDateTime("01-01-2001")) == 0)
{
return(RedirectToAction("GetPendingLeave"));
}
var data = await APIHelpers.GetAsync <List <LeaveViewModel> >("api/Leave/Filter?name=" + model.LeaveFilters.Name + "&fromdate=" + model.LeaveFilters.Fromdate + "&todate=" + model.LeaveFilters.Todate + "&LeaveType=" + Convert.ToInt32(model.LeaveFilters.leavetype) + "&LeaveStatus=" + Convert.ToInt32(model.LeaveFilters.leavestatus));
model.Leaves = data;
return(View("GetPendingLeave", model));
}
catch (Exception ex)
{
throw;
}
}
public IActionResult GetAllAlternatives(FilterViewModel filter)
{
var filterDto = _mapper.Map <FilterViewModel, FilterDto>(filter);
filterDto.UserId = Guid.Parse(User.FindFirstValue(ClaimTypes.NameIdentifier));
var alternatives = _mapper.Map <IEnumerable <Model.Entities.Alternative>, IEnumerable <AlternativeViewModel> >(_alternativeService
.GetAlternativesByFilter(filterDto));
var alternativeFilterViewModel = new AlternativeFilterViewModel
{
Alternatives = alternatives,
SelectedSpecialty = filter.SelectedSpecialty,
Semestr = filter.Semestr,
SelectedCourses = filter.SelectedCourses
};
return(View(alternativeFilterViewModel));
}
public FilterViewModel Map(DimensionTree tree)
{
var viewModel = new FilterViewModel { Dimensions = new List<FilterDimensionViewModel>() };
var dimensionDtos = tree.GetDimensionDtos().ToList();
foreach (var dimensionDto in dimensionDtos)
{
var dimensionViewModel = new FilterDimensionViewModel
{
DimensionId = dimensionDto.Id,
DimensionName = dimensionDto.Name,
Values = new List<DimensionValueViewModel>()
};
dimensionViewModel.Values.AddRange(dimensionDto.DimensionValues
.Select(v => new DimensionValueViewModel {Id = v.Id, Value = v.Value, Checked = true}));
viewModel.Dimensions.Add(dimensionViewModel);
}
return viewModel;
}
public void ShowWindow(FilterViewModel viewModel)
{
_filterWindow = new FilterWindow
{
Owner = Application.Current.MainWindow,
DataContext = viewModel
};
Messenger.Default.Register <NotificationMessage>(this, message =>
{
if (message.Notification == "CloseFilterWindow")
{
CloseWindow();
}
});
_filterWindow.ShowDialog();
}
public async Task <IViewComponentResult> InvokeAsync(FilterViewModel model)
{
FilterViewModel filterViewModel = new FilterViewModel()
{
BrandName = model.BrandName,
Brand = model.Brand,
ProductBrandId = model.ProductBrandId,
SubCategoryName = model.SubCategoryName,
SubCategory = model.SubCategory,
SubCategoryId = model.SubCategoryId,
Category = model.Category,
CategoryName = model.CategoryName,
CategoryId = model.CategoryId
};
var productList = await _productService.GetByFilter(filterViewModel);
return(View(productList.Result));
}
// GET: Direction
public async Task <ActionResult> Index(FilterViewModel filter)
{
if (filter.Direction == null || filter.Date == null)
{
return(View(await db.Directions.ToListAsync()));
}
var query = from n in db.Directions
where n.Description.Contains(filter.Direction)
select n;
if (filter.Date.HasValue)
{
query = query.Where(r => r.Created == filter.Date.Value);
}
return(View(await query.ToListAsync()));
}
void Awake()
{
model = gameObject.GetComponent <FilterViewModel>();
if (null == model)
{
this.enabled = false;
throw new MissingComponentException();
}
else
{
ResetFilter();
}
if (null == filterResultsController)
{
Debug.LogError("FilterViewController: missing results controller reference");
}
}
public ActionResult DisplayStats(FilterViewModel filterModel)
{
if (filterModel.selectedRaceIds == null)
{
return(new HttpNotFoundResult());
}
var simpleModel = SimpleFilterViewModel.Create(filterModel);
if (filterModel.selectedRaceIds.Count() > 1)
{
return(RedirectToAction("ViewResults", "CompareRaces", simpleModel));
}
else
{
return(RedirectToAction("ViewResults", "TriStatsSummary", simpleModel));
}
}
public Movie()
{
// Initialize ViewModels
filterViewModel = new FilterViewModel();
settingViewModel = new SettingViewModel();
movieViewModels = new ObservableCollection <MovieViewModel>();
// Initialize services
settingService = new SettingService(Constants.LocalDBPath);
movieService = new MovieService(Constants.LocalDBPath);
filterService = new FilterService(Constants.LocalDBPath);
fileSizeService = new FileSizeService(Constants.LocalDBPath);
fileTypeService = new FileTypeService(Constants.LocalDBPath);
socketServer = new SocketServerService();
InitializeComponent();
// Set MovieViewModel and Show Loading
startTaskSetMovieViewModel();
}
public async Task <IEnumerable <RegistrationViewModel> > GetByFilter(FilterViewModel filter)
{
var query = _applicationContext.Registrations.OrderBy(x => x.FirstName).ThenBy(x => x.LastName)
.ThenBy(x => x.DateOfBirth).ThenBy(x => x.Id).Select(x => x);
if (filter.ColorIds != null && filter.ColorIds.Any())
{
var idsByColor = _applicationContext.RegistrationColors.Where(x =>
filter.ColorIds.Contains(x.ColorId)).Select(x => x.RegistrationId);
query = query.Where(x => idsByColor.Contains(x.Id));
}
if (filter.DrinkIds != null && filter.DrinkIds.Any())
{
var idsByDrink = _applicationContext.RegistrationDrinks.Where(x =>
filter.DrinkIds.Contains(x.DrinkId)).Select(x => x.RegistrationId);
query = query.Where(x => idsByDrink.Contains(x.Id));
}
var result = await query.Skip(filter.Skip).Take(filter.Take).Select(x => new RegistrationViewModel
{
Id = x.Id,
LastName = x.LastName,
Name = x.FirstName,
Phone = x.Phone,
DrinkNames = (from d in _applicationContext.Drinks
join rd in _applicationContext.RegistrationDrinks on d.DrinkId equals rd.DrinkId
where rd.RegistrationId == x.Id
select d.Name).ToList(),
ColorNames = (from c in _applicationContext.Colors
join rc in _applicationContext.RegistrationColors on c.ColorId equals rc.ColorId
where rc.RegistrationId == x.Id
select c.Name).ToList(),
DateOfBirthAsDate = x.DateOfBirth
}).ToListAsync();
DecorateModel(result);
return(result);
}
void Awake()
{
model = gameObject.GetComponent<FilterViewModel>();
if (null == model)
{
this.enabled = false;
throw new MissingComponentException();
}
else
{
ResetFilter();
}
if (null == filterResultsController)
{
Debug.LogError("FilterViewController: missing results controller reference");
}
}
public async Task <PartialViewResult> List(FilterViewModel filterModel, int page = 1)
{
ApplicationUser user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
IEnumerable <UserTask> tasks = user.Tasks;
if (!string.IsNullOrEmpty(filterModel.Place))
{
tasks = tasks.Where(m => (m.Place == filterModel.Place));
}
if (filterModel.TaskState != null)
{
tasks = tasks.Where(m => m.TaskState == filterModel.TaskState);
}
if (filterModel.MinTime != default(DateTime) && filterModel.MaxTime != default(DateTime))
{
tasks = tasks.Where(m => (m.Time >= filterModel.MinTime && m.Time <= filterModel.MaxTime));
}
else if (filterModel.MinTime != default(DateTime))
{
tasks = tasks.Where(m => (m.Time >= filterModel.MinTime));
}
else if (filterModel.MaxTime != default(DateTime))
{
tasks = tasks.Where(m => (m.Time <= filterModel.MaxTime));
}
tasks = tasks.Skip(_itemPerPage * (page - 1)).Take(_itemPerPage);
TaskListViewModel model = new TaskListViewModel
{
Tasks = tasks.Skip(_itemPerPage * (page - 1)).Take(_itemPerPage),
PagingInfo = new PagingInfo
{
CurrentPage = page,
ItemsPerPage = _itemPerPage,
TotalItems = tasks.Count()
}
};
return(PartialView(model));
}
public IHttpActionResult GetUserProducts(FilterViewModel filterViewModel)
{
try
{
var products = db.Products.Select(s => new ProductModel()
{
Brand = s.Brand,
ProductDescription = s.ProductDescription,
ProductCode = s.ProductCode,
ProductName = s.ProductName,
CreatedDate = s.CreatedDate,
Quantity = s.Quantity,
ProductID = s.ProductID,
ProductPrice = s.ProductPrice,
CategoryName = s.Category.CategoryName,
ModifiedBy = s.ModifiedBy,
CategoryID = s.CategoryID,
ModifiedDate = s.ModifiedDate,
InStock = s.InStock,
Image = s.Images.Where(w => w.ProductID == s.ProductID).Select(t => t.ProductImage).FirstOrDefault()
}).AsQueryable();
if (filterViewModel.Search != "")
{
products = products.Where(w => w.ProductName.Contains(filterViewModel.Search) || w.ProductDescription.Contains(filterViewModel.Search)).AsQueryable();
}
if (filterViewModel.MinPrice != 0 && filterViewModel.MaxPrice != 0)
{
products = products.Where(w => w.ProductPrice > filterViewModel.MinPrice && w.ProductPrice <= filterViewModel.MaxPrice).AsQueryable();
}
if (filterViewModel.SortBy == "asc" || filterViewModel.SortBy == "")
{
return(Ok(products.OrderBy(o => o.ProductName).ToList()));
}
else
{
return(Ok(products.OrderByDescending(o => o.ProductName).ToList()));
}
}
catch (Exception e)
{
return(Ok(e));
}
}
public ActionResult ProductListPost(FilterViewModel filter)
{
if (filter.CategoryId == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
List <Data.Entities.Attribute> att = Repository.GetAttributes((int)filter.CategoryId);
if (att == null || att.Count == 0)
{
return(HttpNotFound());
}
filter.Attributes = att;
List <Product> list = Repository.GetProducts((FilterModel)filter);
filter.Products = list;
filter.FilterAttributes = Repository.Temp(att);
return(View(filter));
}
/// <summary>
/// Creator: Robert Holmes
/// Created: 04/29/2020
/// Approver:
///
/// Creates a list of the distinct entries for each filter criteria.
/// </summary>
/// <remarks>
/// Updater:
/// Updated:
/// Update:
/// </remarks>
public PartialViewResult FilterDropDowns()
{
var filterList = new FilterViewModel();
var products = _productManager.RetrieveAllProducts();
filterList.Categories = products
.Select(x => x.Category)
.Distinct()
.OrderBy(x => x);
filterList.Types = products
.Select(x => x.Type)
.Distinct()
.OrderBy(x => x);
filterList.Brands = products
.Select(x => x.Brand)
.Distinct()
.OrderBy(x => x);
return(PartialView(filterList));
}
public static ViewModelSection GetNewSection(ViewModels viewType, IServiceProvider _service)
{
ViewModelSection retView = null;
switch (viewType)
{
case ViewModels.PlaneMeeting:
retView = new PlaneMeetingViewModel(_service);
retView.Name = "Інформація про засідання";
break;
case ViewModels.Issues:
retView = new IssuesViewModel(_service);
retView.Name = "Огляд протоколів";
break;
case ViewModels.ReqistryOfDecisions:
retView = new RegistryViewModel(_service);
retView.Name = "Реєстр рішень";
break;
case ViewModels.Protocols:
retView = new ProtocolsViewModel(_service);
retView.Name = "Перелік протоколів";
break;
case ViewModels.Filter:
retView = new FilterViewModel(_service);
retView.Name = "Фільтр";
break;
case ViewModels.CreateMeeting:
retView = new CreateMeetingViewModel(_service);
retView.Name = "Планування нового засідання";
break;
default:
break;
}
return(retView);
}
public IEnumerable <User> FilterMusicians(FilterViewModel filter)
{
IEnumerable <User> users = _context.Users
.Where(x => x.Role == "Musician")
.Include(x => x.Instruments);
if (filter.location != null)
{
users = users.Where(x => x.Location.Contains(filter.location));
}
;
if (filter.name != null)
{
users = users.Where(x => x.Name.Contains(filter.name) || x.MusicianName.Contains(filter.name));
}
;
List <User> myUsers = users.ToList();
List <User> usersToRemove = new List <User>();
foreach (User user in myUsers)
{
bool check = false;
foreach (Instrument inst in user.Instruments)
{
if (inst.YearsExperience < filter.years || (filter.instruments.Length != 0 && !filter.instruments.Contains(inst.Name)))
{
check = true;
}
}
if (check)
{
usersToRemove.Add(user);
}
}
foreach (User user in usersToRemove)
{
myUsers.Remove(user);
}
return(myUsers);
}
public ActionResult Products(string Category)
{
Category c = context.Categories.FirstOrDefault(x => x.Name == Category);
if (c == null)
{
return(HttpNotFound());
}
FilterViewModel model = new FilterViewModel()
{
CategoryName = Category,
Products = context.Products.Where(x => x.CategoryId == c.Id).ToList(),
Properties = context.Properties.Where(x => x.CategoryId == c.Id).ToList(),
PropertiesValue = context.PropertiesValue.ToList(),
};
return(View(model));
}
public async void LogSortApplied(FilterViewModel filterVM)
{
LogEntry entry = new LogEntry();
entry.Function = Function.View.ToString();
entry.Operation = Operation.ClipDataColumn.ToString();
entry.Error = null;
entry.Method = "Sort";
entry.ErrorLevel = ErrorLevel.Info.ToString();
entry.AttributesDictionary = new Dictionary <string, object>();
entry.AttributesDictionary.Add("Method", "Sort");
entry.AttributesDictionary.Add("Sort", filterVM.sortType.ToString());
entry.AttributesDictionary.Add("Column", filterVM.ColumnHeaderName);
entry.Attributes = JsonConvert.SerializeObject(entry.AttributesDictionary);
entry.AttributesDictionary = null;
ServiceAccessor.MakeApiCallLog(ServiceAccessor.URL_SERVICE_LOG, JsonConvert.SerializeObject(entry));
}
public void TestNotebookViewModel()
{
FilterViewModel filter = new FilterViewModel();
filter.NotebookName = "Dell";
filter.MinRamMemory = 16;
filter.MaxRamMemory = 16;
filter.MaxBatteryTime = 1000;
filter.MinBatteryTime = 901;
filter.OS = OS.windows;
filter.MaxPrice = 1000;
filter.MinPrice = 500;
foreach (Notebook nb in filter.GetNotebooks())
{
Assert.That(nb.Name.Contains("Dell"));
Assert.That(nb.RamInGB == 16);
Assert.That(nb.Price.Amount > 500 && nb.Price.Amount < 1000);
Assert.That(nb.Os == OS.windows);
}
}
public ActionResult FilterResult(int?page)
{
FilterViewModel filterViewData = null;
if (Session["filterViewData"] != null)
{
filterViewData = (FilterViewModel)Session["filterViewData"];
}
else
{
return(RedirectToAction("Complaints"));
}
IEnumerable <DisplayComplaintViewModel> list = this.cr.FilterComplaints(filterViewData);
Int32 pageSize = 10, pageIndex = 1;
pageIndex = page.HasValue ? Convert.ToInt32(page) : 1;
ViewBag.PagingAction = "FilterResult";
return(View("~/Views/Complaint/Complaints.cshtml", list.ToPagedList(pageIndex, pageSize)));
}
public static FilterViewModel GetValidFilterViewModel(string deviceType = "", string fieldgroup = "anschluesse", string field = "vga", string metaValue = "1", string order = "ASC", int limit = 10, string orderBy = "Name")
{
var vmdl = new FilterViewModel
{
DeviceType = deviceType,
Limit = limit,
Offset = 0,
MetaQuery = new List <DeviceMetaViewModel>
{
new DeviceMetaViewModel {
FieldGroupSlug = fieldgroup, FieldSlug = field, Value = metaValue
}
},
OrderBy = orderBy,
Order = order
};
return(vmdl);
}
public ActionResult Filter(FilterViewModel filterViewData)
{
IEnumerable <DisplayComplaintViewModel> list = this.cr.FilterComplaints(filterViewData);
if (filterViewData.display == "P")
{
(new ComplaintPDFReport()).createReport(list, filterViewData);
var fileStream = new FileStream(Server.MapPath("~/Content/PDF/complaints.pdf"),
FileMode.Open,
FileAccess.Read
);
var fsResult = new FileStreamResult(fileStream, "application/pdf");
return(fsResult);
}
else
{
Session["filterViewData"] = filterViewData;
}
return(RedirectToAction("FilterResult"));
}
// GET: Filter
public ActionResult Index()
{
var beaches = _dataRepository.GetBeaches(true).ToList();
var photos = _dataRepository.GetPhotos();
var features = JsonConvert.SerializeObject(beaches.ToArray());
var filters = _dataRepository.GetBeachFilters().ToList();
var viewModel = new FilterViewModel()
{
Beaches = beaches,
Photos = photos,
BeachFilters = filters,
BeachFeatures = features
.Replace("'", "\\'")
.Replace("\\n", string.Empty)
.Replace("\\\"", "\"")
};
return(View(viewModel));
}
public ActionResult Index(FilterViewModel gameFilterViewModel)
{
var page = (gameFilterViewModel.Page >= 1) ? gameFilterViewModel.Page : 1;
var filterDto = Mapper.Map <FilterDTO>(gameFilterViewModel);
var isWithDeleted = false;
if (User.Identity.IsAuthenticated)
{
isWithDeleted = User.IsInRole("Administrator") ||
User.IsInRole("Manager") ||
User.IsInRole("Moderator");
}
gameFilterViewModel.Page = page;
gameFilterViewModel.PageSize = PageEnum.Ten;
var filterResult = _gameService.GetAllByFilter(filterDto, isWithDeleted, gameFilterViewModel.Page,
gameFilterViewModel.PageSize);
gameFilterViewModel.TotalItemsCount = filterResult.Count;
return(View(gameFilterViewModel));
}
public ShellViewModel(TodoListViewModel todoList, FilterViewModel filter)
{
this.TodoList = todoList;
this.Filter = filter;
}
/// <summary>
/// Setups the filters.
/// </summary>
/// <param name="metric">The metric.</param>
private void SetupFilters(IMetric metric)
{
if (metric.FilterGuid != Guid.Empty)
{
var metricFilter = Filters.FirstOrDefault(f => f.FilterGuid == metric.FilterGuid);
if (metricFilter != null)
{
SelectedFilter = metricFilter;
PopulateUdp(metric.FilterDefinition);
}
}
if (SelectedFilter != null && SelectedFilter != NullFilter)
{
var task = LoadFilterInfo(SelectedFilter.FilterGuid);
task.GetAwaiter().OnCompleted(() =>
{
if (task.Exception == null)
{
var filterInfo = task.Result;
if (filterInfo != null)
{
var filterType = filterInfo.IsAdminFilter == true ? FilterType.ProcessFilter : FilterType.UserFilter;
ChosenFilter = new FilterViewModel(filterInfo, filterType);
}
}
});
}
}
private static bool CanExecuteApplyFilterCommand(FilterViewModel arg)
{
return true;
}
private void ExecuteApplyFilterCommand(FilterViewModel parameter)
{
if (parameter == null)
return;
ApplyFilter(parameter);
}
/// <summary>
/// The apply filter.
/// </summary>
/// <param name="filterViewModel"> The filter view model. </param>
public void ApplyFilter(FilterViewModel filterViewModel)
{
if (filterViewModel == null)
{
if (SelectedFilter != null && !string.IsNullOrEmpty(SelectedFilter.Layout))
SearchViewModel.ApplyDefaultLayout(true);
SelectedFilter = null;
SearchViewModel.AppliedFilter = null;
QuickFilterToolbarVM.Value.FilterLabel = LanguageService.Translate("Constants_NoFilter");
SearchViewModel.RefreshSearchList();
return;
}
if (filterViewModel.DefaultLayoutId.HasValue)
{
SearchViewModel.ApplyLayout(SearchViewModel.LayoutList.First(l => l.Id == filterViewModel.DefaultLayoutId.Value), true, true);
}
/*else
SearchViewModel.ApplyDefaultLayout();*/
//VRN-5462
var filter = (FilterDescriptor)FilterDescriptor.FromJSON(filterViewModel.OriginalFilterDefinitions);
if (filter == null)
SearchViewModel.RefreshSearchList();
else
{
FilterPreprocessor.Value.PreprocessFilterDescriptor(
filter,
Guid.Empty,
SearchViewModel.ProcessSystemName,
f =>
{
if (f == null)
{
//ELMTSUP-1535
//if (SearchViewModel.AppliedFilter != null)
// SearchViewModel.RefreshSearchList(SearchViewModel.AppliedFilter);
//else
// SearchViewModel.RefreshSearchList();
//ELMTDEV-2283
if (SearchViewModel.IsItemsLoaded)
SearchViewModel.SetIsBusy(false);
else
SearchViewModel.RefreshSearchList();
return;
}
SelectedFilter = filterViewModel;
filter.ReplacePredefinedValues(null);
SelectedFilter.TempFilterDefinitions = filter.ToJSON();
SearchViewModel.SetPageIndex(0);
SearchViewModel.RefreshSearchList(SelectedFilter);
SearchViewModel.AppliedFilter = filterViewModel;
QuickFilterToolbarVM.Value.FilterLabel = filterViewModel.Name;
});
}
}
private void PopulateFilters(IEnumerable<IFilterInfo> filterList)
{
FilterList.Clear();
foreach (var f in filterList)
{
var type = f.FilterTypeUsed == (int)FilterType.ProcessFilter ? FilterType.ProcessFilter : FilterType.UserFilter;
var filterVm = new FilterViewModel(f, type);
EditFilterDescriptor(filterVm);
FilterList.Add(filterVm);
RaisePropertyChanged(() => filterVm.IsDefault);
}
QuickFilterToolbarVM.Value.Init(this);
RaisePropertyChanged(() => FilterList);
FilterListView.View.Refresh();
}
private FilterViewModel ExtractSkills(BllFilter filter)
{
int id = filter != null ? filter.Id : 0;
var allSkills = skillService.GetAll().Select(x => x.ToMvc()).ToList();
if (filter != null && filter.Skills != null)
{
foreach (var skill in filter.Skills)
{
UserSkillViewModel fsvm = allSkills.First(x => x.Skill.Id == skill.Key.Id);
fsvm.Level = skill.Value;
}
}
FilterViewModel filterViewModel = new FilterViewModel
{
Id = id,
Skills = allSkills
};
return filterViewModel;
}
/// <summary>
/// Populates the filters.
/// </summary>
/// <param name="filterList">The filter list.</param>
private void PopulateFilters(IEnumerable<IFilterInfo> filterList)
{
FilterList.Clear();
AdminFilterList = new List<IFilterViewModel>();
UserFilterList = new List<IFilterViewModel>();
foreach (var f in filterList.ToList())
{
var type = f.IsAdminFilter == true ? FilterType.ProcessFilter : FilterType.UserFilter;
var filterVM = new FilterViewModel(f, type);
if (filterVM.FilterType == FilterType.ProcessFilter)
AdminFilterList.Add(filterVM);
else
UserFilterList.Add(filterVM);
FilterList.Add(FilterDescriptor.FromJSON(f.FilterDefinition));
}
RaisePropertyChanged(() => FilterList);
}
public ActionResult Filter(FilterViewModel model)
{
SaveFilter(model);
return RedirectToAction("Index");
}
private void EditFilterDescriptor(FilterViewModel filter)
{
var descriptor = FilterDescriptor.FromJSON(filter.OriginalFilterDefinitions);
if (descriptor.ColumnName == Constants.CurrentStateGuidColumnName)
{
var filterValue = descriptor.Value as FilterValue;
if (filterValue != null)
{
Guid guid;
if (Guid.TryParse(filterValue.DefaultValue as string, out guid))
{
var state = SearchViewModel.CurrentStates.StateManager.States.FirstOrDefault(x => x.Guid == guid);
if (state != null)
{
descriptor.ReplaceDefaultValueFilterGuidWithId(state.Id);
}
}
}
filter.OriginalFilterDefinitions = descriptor.ToJSON();
}
}
private void SaveFilter(FilterViewModel model)
{
BllManager user = (BllManager)userService.Find(User.Identity.Name);
BllFilter filter = model.ToBal();
BllFilter userfilter = user.Filters.FirstOrDefault(x => x.Id == filter.Id);
if (userfilter == null)
user.Filters.Add(filter);
else
{
userfilter.Skills = filter.Skills;
userfilter.LastViewed = filter.LastViewed;
}
userService.Update(user);
}
