/// <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;
}
