/// <summary> /// refreshes and sets required values for search to work (for example when to change the sorting) /// </summary> private void SetSearchValues(SortAndFilterData sortAndfilter) { var sortOrder = sortAndfilter.SortOrder; var sortField = sortAndfilter.SortField; var searchString = sortAndfilter.SearchString; var page = sortAndfilter.Page; sortAndfilter.SortField = string.IsNullOrEmpty(sortField) ? defaultSortingField : sortField; sortAndfilter.SortOrder = string.IsNullOrEmpty(sortOrder) ? AscendingOrder : sortOrder; sortAndfilter.PageSize = !sortAndfilter.PageSize.HasValue ? 10 : sortAndfilter.PageSize; if (sortAndfilter.SortOrder.ToLower() == DescendingOrder && !string.IsNullOrEmpty(sortOrder)) { sortAndfilter.SortOrder = DescendingOrder; } else { sortAndfilter.SortOrder = AscendingOrder; } if ((searchString != null && page == null) || page == null) { page = 1; sortAndfilter.Page = page; } }
public void LoadAllItems(SortAndFilterData searchData = null) { if (!worker.IsBusy) { var loading = LoadingItems; if (loading != null) { loading(this, null); } if (ListControl != null) { ListControl.Enabled = false; } if (paginator != null) { paginator.Enabled = false; } searchData = PrepareSearchData(searchData); worker.RunWorkerAsync(searchData); } }
/// <summary> /// initiates the search, and refreshes the values to the parameter sortAndFilter /// </summary> private ReturnType VerifySearchDataAssembleSearchQuery(SortAndFilterData sortAndfilter) { SetSearchValues(sortAndfilter); var elements = SortAndFilterEntities(sortAndfilter); return(elements); }
/// <summary> /// Returns the <see cref="SearchParams"/> object that contains basic sort and filtering data /// </summary> /// <param name="sortAndFilter">determines the sort and filtering criteria for the search</param> /// <param name="unitOfWork">the unit of work required to perform the search</param> /// <returns></returns> protected virtual SearchParams GetSearchParams(SortAndFilterData sortAndFilter, TIUnitOfWork unitOfWork) { var param = new SearchParams { UnitOfWork = unitOfWork, DefaultSortingField = DefaultSortField, SortAndFilter = sortAndFilter }; return(param); }
/// <summary> /// viejo executesortandfilter /// </summary> /// <param name="sortAndFilter"></param> /// <returns></returns> private ReturnType SortAndFilterEntities(SortAndFilterData sortAndFilter) { var searchString = sortAndFilter.SearchString; var pageNumber = parameters.SortAndFilter.Page.Value; var pageSize = parameters.SortAndFilter.PageSize.Value; var skip = pageSize * (pageNumber - 1); var take = pageSize; return(InternalSortAndFilterEntities(searchString, skip, take)); }
public SearchResults <Model> LoadAllItems(SortAndFilterData searchData = null) { ItemsCount = 0; var evt = NotifyLoadItems; if (evt != null) { var result = evt(searchData); ItemsCount = result.Results.Count(); return(result); } return(null); }
/// <summary> /// Executes a search on the database, based on criteria set on <seealso cref="SortAndFilterData"/> entity returning a list of elements that matches that criteria /// </summary> /// <param name="sortAndFilter">the entity containing sort and search criteria</param> /// <param name="getCount">determines whether we should return the amount of elements returned</param> /// <returns>a <seealso cref="SearchResults{T}"/> object containing the view models that matched the criteria and a count property if <paramref name="getCount"/> is true</returns> protected SearchResults <TViewModel> GetList(SortAndFilterData sortAndFilter) { currentAction = LogicAction.Get; SearchResults <TViewModel> result = null; ExecuteCrudMethod(() => { using (var unitOfWork = factory.CreateUoW()) { unitOfWork.Execute(() => { result = ExecuteGetList(sortAndFilter, unitOfWork); }); } }, result); return(result); }
private void OnSearchControlNotifySearchRequest(string search) { int searchInt; bool isNumeric = int.TryParse(search, out searchInt); if (!worker.IsBusy && (search.Length >= 3 || search.Length == 0 || isNumeric)) { CurrentPage = 1; var searchData = new SortAndFilterData { SearchString = search, SortOrder = CurrentSortDirection, Page = CurrentPage, PageSize = CurrentPageSize, SortField = CurrentSortField }; LoadAllItems(searchData); } }
protected virtual SearchResults <TIViewModel> GetAllItems(SortAndFilterData data) { SearchResults <TIViewModel> elements = null; try { SetViewBusyState(); elements = GetElementsList(data); SetViewNormalState(); } catch (Exception ex) { HandleError(ex); } return(elements); }
protected override SearchResults <TViewModel> ExecuteGetList(SortAndFilterData sortAndFilter, IBaseUnitOfWorkEf unitOfWork) { var param = GetSearchParams(sortAndFilter, unitOfWork); var search = GetSearchEngine(param); var searchQuery = search.GetSearchQuery(); var totalCount = 0; var repo = unitOfWork.GetGenericRepo <TModel>(); if (sortAndFilter.GetCount) { totalCount = repo.Get().Count(); } var models = ToViewModel(searchQuery).ToList(); return(new SearchResults <TViewModel> { Results = models, Count = totalCount }); }
/// <summary> /// updates or creates a <see cref="SortAndFilterData"/> object that contains the filtering and searching patterns /// for the items being loaded into the grid /// <para>override to alter sort and filter behaviour</para> /// </summary> /// <param name="searchData">the previously existing filter that may be passed into this method (default is null)</param> /// <returns>the <see cref="SortAndFilterData"/> object</returns> protected virtual SortAndFilterData PrepareSearchData(SortAndFilterData searchData = null) { if (searchData == null) { searchData = new SortAndFilterData { Page = CurrentPage, PageSize = CurrentPageSize, SortOrder = CurrentSortDirection, SortField = CurrentSortField } } ; var filter = searchData.SearchString; filter = string.IsNullOrEmpty(filter) && SearchControl != null && !string.IsNullOrEmpty(SearchControl.InputText) ? SearchControl.InputText : filter; searchData.SearchString = filter; BindingSource.DataSource = null; return(searchData); }
protected void OnGridColumnClick(string columnName) { if (!worker.IsBusy) { if (columnName == CurrentSortField) { if (CurrentSortDirection == "desc") { CurrentSortDirection = "asc"; } else { CurrentSortDirection = "desc"; } } CurrentSortField = columnName; var searchData = new SortAndFilterData { SortField = columnName, SortOrder = CurrentSortDirection, Page = CurrentPage, PageSize = CurrentPageSize }; LoadAllItems(searchData); } }
protected override SearchResults <TViewModel> ExecuteGetList(SortAndFilterData sortAndFilter, IBaseUnitOfWorkAdo unitOfWork) { var param = GetSearchParams(sortAndFilter, unitOfWork); var engine = GetSearchEngine(param); var repo = unitOfWork.GetGenericRepo <TModel>(); var searchresults = engine.GetSearchQuery(); var totalCount = 0; if (sortAndFilter.GetCount) { totalCount = repo.Get().Count(); } var entities = repo.Get(searchresults.Filter, searchresults.OrderBy, searchresults.Sort, searchresults.Page, searchresults.PageSize); var models = ToViewModel(entities).ToList(); return(new SearchResults <TViewModel> { Results = models, Count = totalCount }); }
/// <summary> /// Performs the actual search query onto the database /// </summary> /// <param name="getCount">indicates whether we get the count of elements returned by the search query. /// <para> /// NOTE: be aware that setting this parameter as true may incurr into some overhead /// </para> /// </param> /// <param name="unitOfWork">the <seealso cref="IBaseUnitOfWork"/> that performs the actual query against the db</param> /// <param name="searchQuery">the query that will be executed against the database</param> /// <param name="totalCount">when <paramref name="getCount"/> is true then this parameter returns the obtained count for the records that matched searching criteria</param> /// <returns></returns> protected abstract SearchResults <TViewModel> ExecuteGetList(SortAndFilterData sortAndFilter, TIUnitOfWork unitOfWork);
protected abstract SearchResults <TIViewModel> GetElementsList(SortAndFilterData data);
protected SearchResults <TIViewModel> OnViewNotifyLoadItems(SortAndFilterData searchData) { return(GetAllItems(searchData)); }
public SearchEngine(BaseSearchParams parameters) { this.parameters = parameters; sortAndFilter = parameters.SortAndFilter; defaultSortingField = parameters.DefaultSortingField; }