public WebAPI.DTO.IPagedResponse <FavoriteDTO> GetFavorites(int page, SortState sortOrder)
{
int pageSize = 8;
var favorites = favoriteRepository.GetAllFavorites();
var count = favorites.Count();
var pageNumber = (int)Math.Ceiling(count / (double)pageSize);
var favoriteSerial = mapper.Map <IEnumerable <FavoriteDTO> >(favorites.Where(s => s.ContentType == ContentType.Serial).Select(i => (_serialRepository.GetSerialById(i.ContentId))));
var favoriteMovie = mapper.Map <IEnumerable <FavoriteDTO> >(favorites.Where(s => s.ContentType == ContentType.Movie).Select(i => (_movieRepository.GetMovieById(i.ContentId))));
IEnumerable <FavoriteDTO> union = favoriteSerial.Union(favoriteMovie);
union = sortOrder switch
{
SortState.NameDesc => union.OrderByDescending(s => s.Name),
SortState.RatingAsc => union.OrderBy(s => s.Rating),
SortState.RatingDesc => union.OrderByDescending(s => s.Rating),
SortState.YearAsc => union.OrderBy(s => s.Year),
SortState.YearDesc => union.OrderByDescending(s => s.Year),
_ => union.OrderBy(s => s.Name),
};
var items = union.Skip((page - 1) * pageSize).Take(pageSize).ToList();
WebAPI.DTO.IPagedResponse <FavoriteDTO> pagedResponse = new WebAPI.DTO.IPagedResponse <FavoriteDTO>
{
PageNumber = pageNumber,
PageSize = pageSize,
TotalCount = count,
Data = items
};
return(pagedResponse);
}
public async Task <IActionResult> Index(int?type, string name, int page = 1,
SortState sortOrder = SortState.NameAsc)
{
const int pageSize = 5;
//фильтрация
IQueryable <Toy> toys = db.Toys.Include(x => x.Type);
if (type != null && type != 0)
{
toys = toys.Where(p => p.TypeId == type);
}
if (!string.IsNullOrEmpty(name))
{
toys = toys.Where(p => p.Name.Contains(name));
}
// сортировка
toys = sortOrder switch
{
SortState.NameDesc => toys.OrderByDescending(s => s.Name),
SortState.PriceAsc => toys.OrderBy(s => s.Price),
SortState.PriceDesc => toys.OrderByDescending(s => s.Price),
SortState.TypeAsc => toys.OrderBy(s => s.Type.Name),
SortState.TypeDesc => toys.OrderByDescending(s => s.Type.Name),
_ => toys.OrderBy(s => s.Name)
};
// пагинация
var count = await toys.CountAsync();
var items = await toys.Skip((page - 1) *pageSize).Take(pageSize).ToListAsync();
// формируем модель представления
var viewModel = new IndexViewModel
{
PageViewModel = new PageViewModel(count, page, pageSize),
SortViewModel = new SortViewModel(sortOrder),
FilterViewModel = new FilterViewModel(db.ToyTypes.ToList(), type, name),
Toys = items
};
return(View(viewModel));
}
public async Task <IActionResult> Index(int?selectID, int?selectNumber, int?selectValue, SortState sortOrder = SortState.IDAsc, int page = 1)
{
var data = _baseService.GetCounters();
int pageSize = 5;
if (selectID != null)
{
data = data.Where(k => k.ID + 8 == selectID).Select(k => k);
}
if (selectNumber != null)
{
data = data.Where(k => k.Number == selectNumber).Select(k => k);
}
if (selectValue != null)
{
data = data.Where(k => k.Value == selectValue).Select(k => k);
}
data = sortOrder switch
{
SortState.IDDesc => data.OrderByDescending(x => x.ID),
SortState.NumberAsc => data.OrderBy(x => x.Number),
SortState.NumberDesc => data.OrderByDescending(x => x.Number),
SortState.ValueAsc => data.OrderBy(x => x.Value),
SortState.ValueDesc => data.OrderByDescending(x => x.Value),
_ => data.OrderBy(x => x.ID),
};
var count = await data.CountAsync();
var items = await data.Skip((page - 1) *pageSize).Take(pageSize).ToListAsync();
IndexViewModel viewModel = new IndexViewModel
{
Counters = items,
SortViewModel = new SortViewModel(sortOrder),
PageViewModel = new PageViewModel(count, page, pageSize),
FilterViewModel = new FilterViewModel(selectID, selectNumber, selectValue)
};
return(View(viewModel));
}
public async Task <IActionResult> Index(string name, int?manufacturer, SortState sortOrder = SortState.NameAsc, int page = 1)
{
int pageSize = 4;
IQueryable <Mobile> songs = db.Mobiles.Include(x => x.Manufacturer);
if (manufacturer != null && manufacturer != 0)//brand filter
{
songs = songs.Where(p => p.ManufacturerId == manufacturer);
}
if (!String.IsNullOrEmpty(name))//song name filter
{
songs = songs.Where(p => p.Name.Contains(name));
}
songs = sortOrder switch
{
SortState.NameDes => songs.OrderByDescending(s => s.Name),
SortState.YearAsc => songs.OrderBy(s => s.Yaer),
SortState.ManufacturerAsc => songs.OrderBy(s => s.Manufacturer.Name),
SortState.ManufacturerDes => songs.OrderByDescending(s => s.Manufacturer.Name),
SortState.DiagonalAsc => songs.OrderBy(s => s.Diagonal),
SortState.DiagonalDes => songs.OrderByDescending(s => s.Diagonal),
_ => songs.OrderBy(s => s.Name),
};
var count = await songs.CountAsync();
var items = await songs.Skip((page - 1) *pageSize).Take(pageSize).ToListAsync();
IndexViewModel viewModel = new IndexViewModel
{
PageViewModel = new PageViewModel(count, page, pageSize),
SortViewModel = new SortViewModel(sortOrder),
FilterViewModel = new FilterViewModel(db.Manufacturers.ToList(), manufacturer, name),
Mobile = items
};
SetClearance();
return(View(viewModel));
}
public async Task <IActionResult> Index(List <int> selectedCategories,
List <int> selectedSuspensions,
List <int> selectedSexes,
List <int> selectedAges,
List <int> selectedYears,
List <double> selectedWheels,
int lowPriceBorder, int highPriceBorder,
string searchString, int page = 1, SortState sortOrder = SortState.NameAsc)
{
List <Model> models = await _context.Models
.Include(m => m.AgeGroup)
.Include(m => m.Category)
.Include(m => m.ModelName)
.Include(m => m.ModelPrefix)
.Include(m => m.Sex)
.Include(m => m.Suspension)
.ToListAsync();
var modelColours = await _context.ModelColours.Include(mc => mc.Colour).ToListAsync();
await _context.Bikes.Include(b => b.FrameSize).Include(b => b.Status).Include(b => b.StoringPlace).ToListAsync();
// Get models which are on stock
var modelColoursId = modelColours.Where(mc => mc.Bike != null && mc.Bike.Where(b => b.Status.Id != 2).Count() != 0).Select(mc => mc.Id).ToList();
models = models.Where(m => m.ModelColoursId.Intersect(modelColoursId).Count() > 0).ToList();
#region Filter
// Filter
if (selectedCategories.Count != 0)
{
models = models.Where(m => selectedCategories.Any(id => m.CategoryId == id)).ToList();
}
if (selectedSuspensions.Count != 0)
{
models = models.Where(m => selectedSuspensions.Any(id => m.SuspensionId == id)).ToList();
}
if (selectedSexes.Count != 0)
{
models = models.Where(m => selectedSexes.Any(id => m.SexId == id)).ToList();
}
if (selectedAges.Count != 0)
{
models = models.Where(m => selectedAges.Any(id => m.AgeGroupId == id)).ToList();
}
if (selectedYears.Count != 0)
{
models = models.Where(m => selectedYears.Any(y => m.Year == y)).ToList();
}
if (selectedWheels.Count != 0)
{
models = models.Where(m => selectedWheels.Any(ws => m.WheelSize == ws)).ToList();
}
highPriceBorder = models.Max(m => (int)m.Price);
models = models.Where(m => (int)m.Price >= lowPriceBorder && (int)m.Price <= highPriceBorder).ToList();
#endregion
// Search by name
if (!String.IsNullOrEmpty(searchString))
{
models = models.Where(m => m.FullName.ToLower().Contains(searchString.ToLower())).ToList();
}
#region Sort
// Sort
models = sortOrder switch
{
SortState.NameDesc => models.OrderByDescending(m => m.Name).ThenByDescending(m => m.Prefix).ToList(),
SortState.YearAsc => models.OrderBy(m => m.Year).ToList(),
SortState.YearDesc => models.OrderByDescending(m => m.Year).ToList(),
SortState.ColourAsc => models.OrderBy(m => m.ModelColour.ToList()[0].Colour.ColourValue).ToList(),
SortState.ColourDesc => models.OrderByDescending(m => m.ModelColour.ToList()[0].Colour.ColourValue).ToList(),
SortState.PriceAsc => models.OrderBy(m => m.Price).ToList(),
SortState.PriceDesc => models.OrderByDescending(m => m.Price).ToList(),
_ => models.OrderBy(m => m.Name).ThenBy(m => m.Prefix).ToList(),
};
ViewData["SortItems"] = new List <SelectListItem>
{
new SelectListItem {
Text = "Назва (за зростанням)", Value = "0", Selected = (int)sortOrder == 0
},
new SelectListItem {
Text = "Назва (за спаданням)", Value = "1", Selected = (int)sortOrder == 1
},
new SelectListItem {
Text = "Рік (за зростанням)", Value = "2", Selected = (int)sortOrder == 2
},
new SelectListItem {
Text = "Рік (за спаданням)", Value = "3", Selected = (int)sortOrder == 3
},
new SelectListItem {
Text = "Колір (за зростанням)", Value = "4", Selected = (int)sortOrder == 4
},
new SelectListItem {
Text = "Колір (за спаданням)", Value = "5", Selected = (int)sortOrder == 5
},
new SelectListItem {
Text = "Ціна (за зростанням)", Value = "6", Selected = (int)sortOrder == 6
},
new SelectListItem {
Text = "Ціна (за спаданням)", Value = "7", Selected = (int)sortOrder == 7
},
};
#endregion
// Pagination
int modelsCount = models.Count;
models = models.Skip((page - 1) * _itemsPerPage).Take(_itemsPerPage).ToList();
ViewData["PageViewModel"] = new PageViewModel(modelsCount, page, _itemsPerPage);
ViewData["FilterViewModel"] = new FilterViewModel(await _context.Categories.ToListAsync(), selectedCategories,
await _context.Suspensions.ToListAsync(), selectedSuspensions,
await _context.Sexes.ToListAsync(), selectedSexes,
await _context.AgeGroups.ToListAsync(), selectedAges,
await _context.Models.Select(m => m.Year).Distinct().ToListAsync(), selectedYears,
await _context.Models.Select(m => m.WheelSize).Distinct().ToListAsync(), selectedWheels,
lowPriceBorder,
(models.Count != 0) ? models.Max(m => (int)m.Price) : highPriceBorder,
searchString);
return(View(models));
}
