/// <summary>
/// Gets paged list of all VehicleModels.
/// </summary>
/// <param name="makeId"></param>
/// <param name="filter"></param>
/// <param name="paging"></param>
/// <param name="sorting"></param>
/// <returns> Paged list of all VehicleModels. </returns>
public IPagedList<IVehicleModel> GetModels(Guid makeId, IFiltering filter, IPaging paging, ISorting sorting)
{
// Gets the search input.
var searchString = filter.SearchString;
// Gets the number and size of a page.
int pageNumber = paging.PageNumber;
int pageSize = paging.PageSize;
// Gets the specific models of the make, conditioned by search string.
var vehicleModels = genericRepository.GetSet<VehicleModel>().Where(m => m.MakeId == makeId);
if (!String.IsNullOrEmpty(searchString))
{
vehicleModels = vehicleModels.Where(m => m.Name == searchString
|| m.Abrev == searchString);
}
// Sorts the filtered list of models.
var sortedModel = vehicleModels.OrderBy(sorting.Sorters.FirstOrDefault().GetSortExpression());
// Gets the paged list by parameters and maps it to corresponding type.
var pagedList = genericRepository.GetPagedList(sortedModel, pageSize, pageNumber);
IEnumerable<VehicleModelPoco> sourceList = Mapper.Map<IEnumerable<VehicleModel>, IEnumerable<VehicleModelPoco>>(pagedList);
return new StaticPagedList<VehicleModelPoco>(sourceList, pagedList.GetMetaData());
}
/// <summary>
/// Подсчитать время. затраченное на кол-во операций.
/// </summary>
/// <param name="sorting">Алгоритм сортировки.</param>
/// <param name="data">Данные для сортировки.</param>
/// <param name="operationCount">Кол-во операций для измерения времени.</param>
/// <returns></returns>
private static long getRunMilliseconds(ISorting sorting, int []data, int operationCount)
{
SortCore sortCore = new SortCore(sorting, null);
System.Diagnostics.Stopwatch swatch = new System.Diagnostics.Stopwatch();
swatch.Start();
for (int i = 0; i <= operationCount; i++)
{
sortCore.process(data);
}
swatch.Stop();
return swatch.ElapsedMilliseconds;
}
public IPagedList <IRental> GetAll(ISorting sorting, IFiltering filtering, IPaging paging, IOptions options)
{
IQueryable <IRental> rentals = _unitOfWork.GetAll <Rental>();
if (options.IncludeBooks)
{
rentals = rentals.Include(r => r.Book);
}
if (options.IncludeCustomers)
{
rentals = rentals.Include(r => r.Customer);
}
// filter records based on the DateReturned beeing null or not
switch (filtering.RecordsFilter)
{
case "Rented":
rentals = rentals.Where(r => r.DateReturned == null);
break;
case "Returned":
rentals = rentals.Where(r => r.DateReturned != null);
break;
}
if (!string.IsNullOrEmpty(filtering.SearchString))
{
switch (filtering.SearchBy)
{
case "Book Title":
rentals = rentals.Where(r => r.Book.Title.ToLower().Contains(filtering.SearchString.ToLower()));
break;
case "Customer Name":
rentals = rentals.Where(r => r.Customer.LastName.ToLower().Contains(filtering.SearchString.ToLower()) ||
r.Customer.FirstName.ToLower().Contains(filtering.SearchString.ToLower()));
break;
case "Rental Id":
rentals = rentals.Where(r => r.Id.ToString().Contains(filtering.SearchString));
break;
}
}
switch (sorting.SortingParam)
{
case "dRented":
rentals = rentals.OrderBy(c => c.DateRented);
break;
case "dReturned":
rentals = rentals.OrderBy(c => c.DateRented);
break;
case "dReturned_desc":
rentals = rentals.OrderByDescending(c => c.DateRented);
break;
case "bookTitle":
rentals = rentals.OrderBy(c => c.Book.Title);
break;
case "bookTitle_desc":
rentals = rentals.OrderByDescending(c => c.Book.Title);
break;
case "customerName":
rentals = rentals.OrderBy(c => c.Customer.LastName);
break;
case "customerName_desc":
rentals = rentals.OrderByDescending(c => c.Customer.LastName);
break;
default:
rentals = rentals.OrderByDescending(c => c.DateRented);
break;
}
var pagedList = rentals.ToPagedList(paging.PageNumber, paging.PageSize);
if (pagedList.PageCount < pagedList.PageNumber)
{
return(rentals.ToPagedList(1, paging.PageSize));
}
return(pagedList);
}
/// <summary>
/// Sorts input in ascending order using Cocktail sort technique
/// </summary>
/// <param name="sort">ISort</param>
/// <param name="sortingAlgorithmFactory">Sorting algorithm factory</param>
/// <param name="input">input data</param>
/// <param name="comparer">Comparer must returns '1' if the first element is greater than next</param>
/// <returns>The ascending ordered content</returns>
public static string UseCocktail(this ISorting sort, ISortingAlgorithmFactory sortingAlgorithmFactory, string input, IComparer <char> comparer = null)
{
return(sort.Sort(sortingAlgorithmFactory, SortingTypes.Cocktail, input, comparer));
}
public async Task <IEnumerable <UserIdentityDTO> > GetAllAsync(ISorting sorting, IFiltering filtering, IPaging paging)
{
var models = await userIdentityRepository.GetAllAsync(sorting, filtering, paging);
return(models);
}
public PlayerAction(ISorting sorting, IDrawing drawing)
{
this.sorting = sorting;
this.drawing = drawing;
}
/// <summary>
/// Sorts input in ascending order using Cocktail sort technique
/// </summary>
/// <typeparam name="T">Type of data</typeparam>
/// <param name="sort">ISort</param>
/// <param name="sortingAlgorithmFactory">Sorting algorithm factory</param>
/// <param name="input">input data</param>
/// <param name="comparer">Comparer must returns '1' if the first element is greater than next</param>
public static void UseCocktail <T>(this ISorting sort, ISortingAlgorithmFactory sortingAlgorithmFactory, T[] input, IComparer <T> comparer)
{
sort.Sort <T>(sortingAlgorithmFactory, SortingTypes.Cocktail, input, comparer);
}
public PressureAnalyzer(ISorting <PressureNode> sorting)
{
this.Sorting = sorting;
}
public async Task <IEnumerable <RegistrationDTO> > GetAllAsync(ISorting sorting, IFiltering filtering, IPaging paging)
{
var models = await registrationRepository.GetAllAsync(sorting, filtering, paging);
return(models);
}
/// <summary>
/// Sorts input in ascending order using Selection sort technique
/// </summary>
/// <typeparam name="T">Type of data</typeparam>
/// <param name="sort">ISort</param>
/// <param name="sortingAlgorithmFactory">Sorting algorithm factory</param>
/// <param name="input">input data</param>
/// <param name="comparer">Comparer must returns '1' if the first element is greater than next</param>
public static void UseSelection <T>(this ISorting sort, ISortingAlgorithmFactory sortingAlgorithmFactory, T[] input, IComparer <T> comparer)
{
sort.Sort <T>(sortingAlgorithmFactory, SortingTypes.Selection, input, comparer);
}
/// <summary>
/// Sorts input in ascending order using Selection sort technique
/// </summary>
/// <param name="sort">ISort</param>
/// <param name="input">input data</param>
/// <param name="comparer">Comparer must returns '1' if the first element is greater than next</param>
/// <returns>The ascending ordered content</returns>
public static string UseSelection(this ISorting sort, string input, IComparer <char> comparer = null)
{
return(sort.Sort(SortingTypes.Selection, input, comparer));
}
private static bool SortingFieldSpecified(SortingHeader sortingHeader, ISorting sorting)
{
return(sortingHeader.ShouldSort &&
sorting.SortableFields.Contains(sortingHeader.SortBy, StringComparer.OrdinalIgnoreCase));
}
public static SortedQueryable <T> WithSorting <T>(this IQueryable <T> source, SortingHeader sortingHeader, ISorting sorting)
{
var validatedSortingHeader = DetermineSortingHeader <T>(sortingHeader, sorting);
var orderedQueryable = validatedSortingHeader.SortOrder == SortOrder.Ascending
? source.OrderBy(validatedSortingHeader.SortBy)
: source.OrderByDescending(validatedSortingHeader.SortBy);
return(new SortedQueryable <T>(orderedQueryable, validatedSortingHeader));
}
private static SortingHeader DetermineSortingHeader <T>(SortingHeader sortingHeader, ISorting sorting)
{
return(SortingFieldSpecified(sortingHeader, sorting)
? sortingHeader
: sorting.DefaultSortingHeader);
}
public static IQueryable <T> Sort <T>(this IQueryable <T> query, ISorting sorting) => Sort(query, sorting, null);
public async Task <IEnumerable <IVehicleMakeDTO> > GetAllMakesAsync(IFilter filter, IPaging paging, ISorting sorting)
{
return(await vehicleMakeRepository.GetAllMakesAsync(filter, paging, sorting));
}
/// <summary>
/// Sorts input in ascending order using Radix sort technique
/// This techique currently supports only positive integer sorting
/// </summary>
/// <param name="sort">ISort</param>
/// <param name="input">input data</param>
/// <param name="comparer">Comparer must returns '1' if the first element is greater than next</param>
public static void UseRadix(this ISorting sort, int[] input, IComparer <int> comparer)
{
var radix = new RadixSort(comparer);
radix.Sort(input);
}
/// <summary>
/// Sorts input in ascending order using Radix sort technique
/// This techique currently supports only positive integer sorting
/// </summary>
/// <param name="sort">ISort</param>
/// <param name="input">input data</param>
/// <param name="comparer">Comparer must returns '1' if the first element is greater than next</param>
public static void UseRadix(this ISorting sort, int[] input)
{
var radix = new RadixSort(new IntegerComparer());
radix.Sort(input);
}
/// <summary>
/// Sorts input in ascending order using Selection sort technique
/// </summary>
/// <typeparam name="T">Type of data</typeparam>
/// <param name="sort">ISort</param>
/// <param name="input">input data</param>
/// <param name="comparer">Comparer must returns '1' if the first element is greater than next</param>
public static void UseSelection <T>(this ISorting sort, T[] input, IComparer <T> comparer)
{
sort.Sort <T>(SortingTypes.Selection, input, comparer);
}
/// <summary>
/// Gets paged list of all VehicleModels.
/// </summary>
/// <param name="makeId"></param>
/// <param name="filter"></param>
/// <param name="paging"></param>
/// <param name="sorting"></param>
/// <returns> Paged list of all VehicleModels. </returns>
public IPagedList<IVehicleModel> GetModels(Guid makeId, IFiltering filter, IPaging paging, ISorting sorting)
{
return vehicleModelRepository.GetModels(makeId, filter, paging, sorting);
}
/// <summary>
/// Sorts input in ascending order using Selection sort technique
/// </summary>
/// <param name="sort">ISort</param>
/// <param name="sortingAlgorithmFactory">Sorting algorithm factory</param>
/// <param name="input">input data</param>
/// <param name="comparer">Comparer must returns '1' if the first element is greater than next</param>
/// <returns>The ascending ordered content</returns>
public static string UseSelection(this ISorting sort, ISortingAlgorithmFactory sortingAlgorithmFactory, string input, IComparer <char> comparer = null)
{
return(sort.Sort(sortingAlgorithmFactory, SortingTypes.Selection, input, comparer));
}
/// <summary>
/// Sorts input in ascending order using Bitonic sort technique.
/// This will work only if the input size is power of 2
/// </summary>
/// <typeparam name="T">Type of data</typeparam>
/// <param name="sort">ISort</param>
/// <param name="input">input data</param>
/// <param name="comparer">Comparer must returns '1' if the first element is greater than next</param>
public static void UseBitonic <T>(this ISorting sort, T[] input, IComparer <T> comparer)
{
sort.Sort <T>(SortingTypes.Bitonic, input, comparer);
}
public void Sorting(ISorting sortStrategy)
{
this._sortStrategy = sortStrategy;
}
/// <summary>
/// Sorts input in ascending order using Bitonic sort technique
/// This will work only if the input size is power of 2
/// </summary>
/// <typeparam name="T">Type of data</typeparam>
/// <param name="sort">ISort</param>
/// <param name="sortingAlgorithmFactory">Sorting algorithm factory</param>
/// <param name="input">input data</param>
/// <param name="comparer">Comparer must returns '1' if the first element is greater than next</param>
public static void UseBitonic <T>(this ISorting sort, ISortingAlgorithmFactory sortingAlgorithmFactory, T[] input, IComparer <T> comparer)
{
sort.Sort <T>(sortingAlgorithmFactory, SortingTypes.Bitonic, input, comparer);
}
public async Task <IEnumerable <SeminarDTO> > GetAllAsync(ISorting sorting, IFiltering filtering, IPaging paging)
{
var models = await seminarRepository.GetAllAsync(sorting, filtering, paging);
return(models);
}
/// <summary>
/// Sorts input in ascending order using Pancake sort technique
/// </summary>
/// <typeparam name="T">Type of data</typeparam>
/// <param name="sort">ISort</param>
/// <param name="input">input data</param>
/// <param name="comparer">Comparer must returns '1' if the first element is greater than next</param>
public static void UsePancake <T>(this ISorting sort, T[] input, IComparer <T> comparer)
{
sort.Sort <T>(SortingTypes.Pancake, input, comparer);
}
/// <summary>
/// Sorts input in ascending order using Cocktail sort technique
/// </summary>
/// <typeparam name="T">Type of data</typeparam>
/// <param name="sort">ISort</param>
/// <param name="input">input data</param>
/// <param name="comparer">Comparer must returns '1' if the first element is greater than next</param>
public static void UseCocktail <T>(this ISorting sort, T[] input, IComparer <T> comparer)
{
sort.Sort <T>(SortingTypes.Cocktail, input, comparer);
}
/// <summary>
/// Sorts input in ascending order using Pancake sort technique
/// </summary>
/// <typeparam name="T">Type of data</typeparam>
/// <param name="sort">ISort</param>
/// <param name="sortingAlgorithmFactory">Sorting algorithm factory</param>
/// <param name="input">input data</param>
/// <param name="comparer">Comparer must returns '1' if the first element is greater than next</param>
public static void UsePancake <T>(this ISorting sort, ISortingAlgorithmFactory sortingAlgorithmFactory, T[] input, IComparer <T> comparer)
{
sort.Sort <T>(sortingAlgorithmFactory, SortingTypes.Pancake, input, comparer);
}
/// <summary>
/// Sorts input in ascending order using Cocktail sort technique
/// </summary>
/// <param name="sort">ISort</param>
/// <param name="input">input data</param>
/// <param name="comparer">Comparer must returns '1' if the first element is greater than next</param>
/// <returns>The ascending ordered content</returns>
public static string UseCocktail(this ISorting sort, string input, IComparer <char> comparer = null)
{
return(sort.Sort(SortingTypes.Cocktail, input, comparer));
}
/// <summary>
/// Sorts input in ascending order using Heap sort technique
/// </summary>
/// <typeparam name="T">Type of data</typeparam>
/// <param name="sort">ISort</param>
/// <param name="input">input data</param>
/// <param name="comparer">Comparer must returns '1' if the first element is greater than next</param>
public static void UseHeap <T>(this ISorting sort, T[] input, IComparer <T> comparer)
{
sort.Sort <T>(SortingTypes.Heap, input, comparer);
}
public ProjectController(AppDbContext context, ISorting sorter)
{
_context = context;
_sorter = sorter;
}
/// <summary>
/// Sorts input in ascending order using Heap sort technique
/// </summary>
/// <param name="sort">ISort</param>
/// <param name="input">input data</param>
/// <param name="comparer">Comparer must returns '1' if the first element is greater than next</param>
/// <returns>The ascending ordered content</returns>
public static string UseHeap(this ISorting sort, string input, IComparer <char> comparer = null)
{
return(sort.Sort(SortingTypes.Heap, input, comparer));
}
/// <summary>
/// Gets all songs filtered, ordered, using pages
/// </summary>
/// <param name="filter">The filter.</param>
/// <param name="options">The options.</param>
/// <param name="orderBy">The string represeting how to order songs.</param>
/// <param name="ascending">Whether to order ascending or descending.</param>
/// <param name="pageNumber">The current page number.</param>
/// <param name="pageSize">The page size.</param>
/// <returns></returns>
public async Task <IPagedList <ISong> > GetAsync(IFilter filter, string[] options, ISorting sortingOptions, IPaging pageOptions)
{
IQueryable <SongEntity> query = Repository.Get(options);
IOrderedEnumerable <SongEntity> orderedQuery;
Func <SongEntity, string> order;
// filtering
if (filter.Title != null)
{
query = query.Where(s => s.Title.Contains(filter.Title));
}
// sorting
switch (sortingOptions.SortBy)
{
case "title":
order = s => s.Title;
break;
case "composer":
order = s => s.Composer.Surname;
break;
case "arranger":
order = s => s.Arranger.Surname;
break;
default:
order = s => s.Title;
break;
}
if (sortingOptions.SortAscending)
{
orderedQuery = query.OrderBy(order);
}
else
{
orderedQuery = query.OrderByDescending(order);
}
// paging
IPagedList <SongEntity> songEntities = await orderedQuery.ToPagedListAsync(pageOptions.PageNumber, pageOptions.PageSize);
IPagedList <ISong> result = new StaticPagedList <ISong>(Mapper.Map <IEnumerable <ISong> >(songEntities), songEntities.GetMetaData());
return(result);
}
/// <summary>
/// Gets paged list of all VehicleMakes.
/// </summary>
/// <param name="filter"></param>
/// <param name="paging"></param>
/// <param name="sorting"></param>
/// <returns> A paged list of makes. </returns>
public IPagedList<IVehicleMake> GetMakes(IFiltering filter, IPaging paging, ISorting sorting)
{
return vehicleMakeRepository.GetMakes(filter, paging, sorting);
}
