public Settings(SerializationInfo info, StreamingContext context)
{
_directories = (List<Directory>) info.GetValue("_directories", typeof(List<Directory>));
_searchState = (SearchState) info.GetValue("_searchState", typeof (SearchState));
_sortState = (SortState) info.GetValue("_sortState", typeof(SortState));
_sortReversed = info.GetBoolean("_sortReversed");
}
/// <summary>
/// Creates a new search on the item list supplied, with the specified options.
/// Results on the IEnumberable.
/// </summary>
/// <param name="allItems">The list of items to search</param>
/// <param name="searchTerms">The string to search on</param>
/// <param name="state">Search options</param>
public Search(List<Item> allItems, string searchTerms, SearchState state, SortState sort = SortState.Filename, bool sortAscending = true)
{
_allItems = allItems;
_search = searchTerms;
_state = state;
_results = new List<Item>();
_sort = sort;
_sortAscending = sortAscending;
doSearch();
}
internal void FromSortState(SortState ss)
{
this.SetAllNull();
if (ss.ColumnSort != null && ss.ColumnSort.Value) this.ColumnSort = ss.ColumnSort.Value;
if (ss.CaseSensitive != null && ss.CaseSensitive.Value) this.CaseSensitive = ss.CaseSensitive.Value;
if (ss.SortMethod != null) this.SortMethod = ss.SortMethod.Value;
int iStartRowIndex = 1;
int iStartColumnIndex = 1;
int iEndRowIndex = 1;
int iEndColumnIndex = 1;
string sRef = ss.Reference.Value;
if (sRef.IndexOf(":") > 0)
{
if (SLTool.FormatCellReferenceRangeToRowColumnIndex(sRef, out iStartRowIndex, out iStartColumnIndex, out iEndRowIndex, out iEndColumnIndex))
{
this.StartRowIndex = iStartRowIndex;
this.StartColumnIndex = iStartColumnIndex;
this.EndRowIndex = iEndRowIndex;
this.EndColumnIndex = iEndColumnIndex;
}
}
else
{
if (SLTool.FormatCellReferenceToRowColumnIndex(sRef, out iStartRowIndex, out iStartColumnIndex))
{
this.StartRowIndex = iStartRowIndex;
this.StartColumnIndex = iStartColumnIndex;
this.EndRowIndex = iStartRowIndex;
this.EndColumnIndex = iStartColumnIndex;
}
}
if (ss.HasChildren)
{
SLSortCondition sc;
using (OpenXmlReader oxr = OpenXmlReader.Create(ss))
{
while (oxr.Read())
{
if (oxr.ElementType == typeof(SortCondition))
{
sc = new SLSortCondition();
sc.FromSortCondition((SortCondition)oxr.LoadCurrentElement());
// limit of 64 from Open XML specs
if (this.SortConditions.Count < 64) this.SortConditions.Add(sc);
}
}
}
}
}
public async Task <IActionResult> EntityFSP(int?company, string name, int page = 1,
SortState sortOrder = SortState.NameAsc)
{
int pageSize = 3;
//фильтрация
IQueryable <UserSort> users = _dbContext.UsersSort.Include(x => x.Company);
if (company != null && company != 0)
{
users = users.Where(p => p.CompanyId == company);
}
if (!String.IsNullOrEmpty(name))
{
users = users.Where(p => p.Name.Contains(name));
}
// сортировка
switch (sortOrder)
{
case SortState.NameDesc:
users = users.OrderByDescending(s => s.Name);
break;
case SortState.AgeAsc:
users = users.OrderBy(s => s.Age);
break;
case SortState.AgeDesc:
users = users.OrderByDescending(s => s.Age);
break;
case SortState.CompanyAsc:
users = users.OrderBy(s => s.Company.Name);
break;
case SortState.CompanyDesc:
users = users.OrderByDescending(s => s.Company.Name);
break;
default:
users = users.OrderBy(s => s.Name);
break;
}
// пагинация
var count = await users.CountAsync();
var items = await users.Skip((page - 1) *pageSize).Take(pageSize).ToListAsync();
// формируем модель представления
EntityFSPViewModel viewModel = new EntityFSPViewModel
{
PageViewModel = new PageViewModel(count, page, pageSize),
SortUserViewModel = new SortUserViewModel(sortOrder),
FilterViewModel = new FilterViewModel(_dbContext.CompaniesSort.ToList(), company, name),
Users = items,
UserName = CurrentUserName,
AvatarPath = CurrentAvatarPath
};
return(View("EntityFSP", viewModel));
}
private static void Fork <T>(T[] collection, int maxDegreeOfParallelism, IComparer <T> comparer, SortState state)
{
ThreadPool.Instance.QueueWorkItem(() => Sort(collection, maxDegreeOfParallelism - 1, comparer, state));
}
public IActionResult Index(string RiskName, string RiskDescription, int page = 1, SortState sortOrder = SortState.RiskNameAsc)
{
int pageSize = 10;
IQueryable <Risks> source = _context.Risks.Include(r => r.Type);
ViewData["RiskNameSort"] = sortOrder == SortState.RiskNameAsc ? SortState.RiskNameDesc : SortState.RiskNameAsc;
ViewData["RiskDescriptionSort"] = sortOrder == SortState.RiskDescriptionAsc ? SortState.RiskDescriptionDesc : SortState.RiskDescriptionAsc;
if (RiskName != null)
{
source = source.Where(x => x.RiskName == RiskName);
}
if (RiskDescription != null)
{
source = source.Where(x => x.RiskDescription == RiskDescription);
}
switch (sortOrder)
{
case SortState.RiskNameAsc:
source = source.OrderBy(x => x.RiskName);
break;
case SortState.RiskNameDesc:
source = source.OrderByDescending(x => x.RiskName);
break;
case SortState.RiskDescriptionAsc:
source = source.OrderBy(x => x.RiskDescription);
break;
case SortState.RiskDescriptionDesc:
source = source.OrderByDescending(x => x.RiskDescription);
break;
}
var count = source.Count();
var items = source.Skip((page - 1) * pageSize).Take(pageSize);
PageViewModel pageView = new PageViewModel(count, page, pageSize);
IndexViewModel ivm = new IndexViewModel
{
PageViewModel = pageView,
FilterRisksViewModel = new FilterRisksViewModel(RiskName, RiskDescription),
Risks = items
};
return(View(ivm));
}
public IActionResult Index(string Name, int?Experiance, int Age, string Machanic, int RegistrationNumber, int BodyNumber, int PhoneNumber, string DstinationNumber, int page = 1, SortState sortOrder = SortState.AgeAcs)
{
int pageSize = 10;
IQueryable <Cars> source = _context.Cars.Include(c => c.Driver).Include(c => c.Mark);
ViewData["RegistrationNumberSort"] = sortOrder == SortState.RegistrationNumberAcs ? SortState.RegistrationNumberDesc : SortState.RegistrationNumberAcs;
ViewData["BodyNumberSort"] = sortOrder == SortState.BodyNumberAcs ? SortState.BodyNumberDesc : SortState.BodyNumberAcs;
ViewData["MachanicSort"] = sortOrder == SortState.MachanicAcs ? SortState.MachanicDesc : SortState.MachanicAcs;
if (RegistrationNumber != null)
{
source = source.Where(x => x.RegistrationNumber == RegistrationNumber);
}
if (BodyNumber != null)
{
source = source.Where(x => x.BodyNumber == BodyNumber);
}
if (Machanic != null)
{
source = source.Where(x => x.Machanic == Machanic);
}
switch (sortOrder)
{
case SortState.RegistrationNumberAcs:
source = source.OrderBy(x => x.RegistrationNumber);
break;
case SortState.RegistrationNumberDesc:
source = source.OrderByDescending(x => x.RegistrationNumber);
break;
case SortState.BodyNumberAcs:
source = source.OrderBy(x => x.BodyNumber);
break;
case SortState.BodyNumberDesc:
source = source.OrderByDescending(x => x.BodyNumber);
break;
case SortState.MachanicAcs:
source = source.OrderBy(x => x.Machanic);
break;
case SortState.MachanicDesc:
source = source.OrderByDescending(x => x.Machanic);
break;
}
var count = source.Count();
var items = source.Skip((page - 1) * pageSize).Take(pageSize);
PageViewModel pageView = new PageViewModel(count, page, pageSize);
IndexViewModel ivm = new IndexViewModel
{
PageViewModel = pageView,
FilterView = new FilterView(Name, Experiance, Age, Machanic, RegistrationNumber, BodyNumber, PhoneNumber, DstinationNumber),
Cars = items
};
return(View(ivm));
}
public async Task <IActionResult> ItemView(string userId, string discriminator, string name, string description, SortState sortOrder = SortState.NameAsc)
{
if (String.IsNullOrEmpty(discriminator))
{
discriminator = "Book";
}
_discriminator = discriminator;
IQueryable <Collection> collections;
if (!String.IsNullOrEmpty(userId))
{
collections = db.Collections.Where(p => p.UserId == userId && p.Discriminator == _discriminator);
}
else
{
_currentUser = await GetCurrentUser();
userId = _currentUser.Id;
collections = db.Collections.Where(p => p.UserId == userId && p.Discriminator == _discriminator);
}
if (!String.IsNullOrEmpty(name))
{
collections = collections.Where(p => p.Name.Contains(name));
}
switch (sortOrder)
{
case SortState.NameDesc:
collections = collections.OrderByDescending(s => s.Name);
break;
case SortState.DescrAsc:
collections = collections.OrderBy(s => s.Discription);
break;
case SortState.DescrDesc:
collections = collections.OrderByDescending(s => s.Discription);
break;
case SortState.DateCreateAsc:
collections = collections.OrderBy(s => s.DateCreate);
break;
case SortState.DateCreateDesc:
collections = collections.OrderByDescending(s => s.DateCreate);
break;
default:
collections = collections.OrderBy(s => s.Name);
break;
}
PersonalCollectionViewModel viewModel = new PersonalCollectionViewModel
{
SortViewModel = new SortViewModel(sortOrder),
FilterViewModel = new FilterViewModel(db.Collections.ToList(), name, description, _discriminator, userId),
Collections = await collections.AsNoTracking().ToListAsync()
};
return(View(viewModel));
}
public static JobHandle CopySortedData <T>(NativeList <T> result, NativeList <T>[] buffers, SortState state, JobHandle inputDeps)
where T : struct, IComparable <T>
{
if (state.SortLength == 0)
{
return(inputDeps);
}
// The last buffer will always contain the sorted data
inputDeps = buffers[buffers.Length - 1].CopyTo(result.AsDeferredJobArray(), 0, 0, state.SortLength, inputDeps);
return(inputDeps);
}
public void RemoveUnselectedRows()
{
int[] x = GetSelectedRows();
model = new SubTableModel(model, x);
modelRowSel = new bool[model.RowCount];
order = ArrayUtils.ConsecutiveInts(model.RowCount);
inverseOrder = ArrayUtils.ConsecutiveInts(model.RowCount);
sortCol = -1;
sortState = SortState.Unsorted;
VisibleY = 0;
Invalidate(true);
if (SelectionChanged != null){
SelectionChanged(this, new EventArgs());
}
}
// Generates content of tableDefinitionPart6.
private void GenerateTableDefinitionPart6Content(TableDefinitionPart tableDefinitionPart6)
{
Table table6 = new Table(){ Id = (UInt32Value)1U, Name = "DataTable1", DisplayName = "DataTable1", Reference = "A1:F5", TotalsRowShown = false };
AutoFilter autoFilter6 = new AutoFilter(){ Reference = "A1:F5" };
SortState sortState2 = new SortState(){ Reference = "A2:F2001" };
SortCondition sortCondition2 = new SortCondition(){ Reference = "A2:A2001" };
sortState2.Append(sortCondition2);
TableColumns tableColumns6 = new TableColumns(){ Count = (UInt32Value)6U };
TableColumn tableColumn13 = new TableColumn(){ Id = (UInt32Value)1U, Name = "Date", DataFormatId = (UInt32Value)13U };
TableColumn tableColumn14 = new TableColumn(){ Id = (UInt32Value)2U, Name = "Product" };
TableColumn tableColumn15 = new TableColumn(){ Id = (UInt32Value)3U, Name = "Quantity" };
TableColumn tableColumn16 = new TableColumn(){ Id = (UInt32Value)4U, Name = "Price" };
TableColumn tableColumn17 = new TableColumn(){ Id = (UInt32Value)5U, Name = "DeliveryDate", DataFormatId = (UInt32Value)12U };
TableColumn tableColumn18 = new TableColumn(){ Id = (UInt32Value)6U, Name = "Employee" };
tableColumns6.Append(tableColumn13);
tableColumns6.Append(tableColumn14);
tableColumns6.Append(tableColumn15);
tableColumns6.Append(tableColumn16);
tableColumns6.Append(tableColumn17);
tableColumns6.Append(tableColumn18);
TableStyleInfo tableStyleInfo6 = new TableStyleInfo(){ Name = "TableStyleMedium2", ShowFirstColumn = false, ShowLastColumn = false, ShowRowStripes = true, ShowColumnStripes = false };
table6.Append(autoFilter6);
table6.Append(sortState2);
table6.Append(tableColumns6);
table6.Append(tableStyleInfo6);
tableDefinitionPart6.Table = table6;
}
private void InvertOrder()
{
sortState = SortState.Decreasing;
ArrayUtils.Revert(order);
ArrayUtils.Revert(inverseOrder);
}
private void Sort()
{
sortState = SortState.Increasing;
ColumnType type = model.GetColumnType(sortCol);
switch (type){
case ColumnType.Integer:
order = SortInt();
break;
case ColumnType.NumericLog:
case ColumnType.Numeric:
case ColumnType.Expression:
order = SortDouble();
break;
default:
order = SortString();
break;
}
inverseOrder = new int[order.Length];
for (int i = 0; i < order.Length; i++){
inverseOrder[order[i]] = i;
}
}
// Generates content of tableDefinitionPart3.
private void GenerateTableDefinitionPart3Content(TableDefinitionPart tableDefinitionPart3)
{
Table table3 = new Table(){ Id = (UInt32Value)4U, Name = "DataTable2", DisplayName = "DataTable2", Reference = "A1:F6", TotalsRowShown = false };
AutoFilter autoFilter3 = new AutoFilter(){ Reference = "A1:F6" };
SortState sortState1 = new SortState(){ Reference = "A2:F2001" };
SortCondition sortCondition1 = new SortCondition(){ Reference = "A2" };
sortState1.Append(sortCondition1);
TableColumns tableColumns3 = new TableColumns(){ Count = (UInt32Value)6U };
TableColumn tableColumn4 = new TableColumn(){ Id = (UInt32Value)1U, Name = "Date", DataFormatId = (UInt32Value)8U };
TableColumn tableColumn5 = new TableColumn(){ Id = (UInt32Value)2U, Name = "Product", DataFormatId = (UInt32Value)7U };
TableColumn tableColumn6 = new TableColumn(){ Id = (UInt32Value)3U, Name = "Quantity", DataFormatId = (UInt32Value)6U };
TableColumn tableColumn7 = new TableColumn(){ Id = (UInt32Value)4U, Name = "Price", DataFormatId = (UInt32Value)5U };
TableColumn tableColumn8 = new TableColumn(){ Id = (UInt32Value)5U, Name = "DeliveryDate", DataFormatId = (UInt32Value)4U };
TableColumn tableColumn9 = new TableColumn(){ Id = (UInt32Value)6U, Name = "Employee", DataFormatId = (UInt32Value)3U };
tableColumns3.Append(tableColumn4);
tableColumns3.Append(tableColumn5);
tableColumns3.Append(tableColumn6);
tableColumns3.Append(tableColumn7);
tableColumns3.Append(tableColumn8);
tableColumns3.Append(tableColumn9);
TableStyleInfo tableStyleInfo3 = new TableStyleInfo(){ Name = "TableStyleMedium2", ShowFirstColumn = false, ShowLastColumn = false, ShowRowStripes = true, ShowColumnStripes = false };
table3.Append(autoFilter3);
table3.Append(sortState1);
table3.Append(tableColumns3);
table3.Append(tableStyleInfo3);
tableDefinitionPart3.Table = table3;
}
public Settings()
{
_directories = new List<Directory>();
_searchState = SearchState.Tagged | SearchState.Untagged | SearchState.Tags | SearchState.Filenames;
_sortState = SortState.Filename;
}
public void ShowAllRows()
{
model = origModel;
modelRowSel = new bool[model.RowCount];
order = ArrayUtils.ConsecutiveInts(model.RowCount);
inverseOrder = ArrayUtils.ConsecutiveInts(model.RowCount);
sortCol = -1;
sortState = SortState.Unsorted;
Invalidate(true);
if (SelectionChanged != null){
SelectionChanged(this, new EventArgs());
}
}
public void SetVisibleRows(IList<int> rows)
{
model = new SubTableModel(origModel, rows.ToArray());
modelRowSel = new bool[model.RowCount];
order = ArrayUtils.ConsecutiveInts(model.RowCount);
inverseOrder = ArrayUtils.ConsecutiveInts(model.RowCount);
sortCol = -1;
sortState = SortState.Unsorted;
Invalidate(true);
if (SelectionChanged != null){
SelectionChanged(this, new EventArgs());
}
}
public async Task <IActionResult> Index(int?id, string name, int page = 0,
SortState sortOrder = SortState.IdAsc)
{
var sessionOrganizations = HttpContext.Session.Get("Invoices");
if (sessionOrganizations != null && id == null && name == null && page == 0 && sortOrder == SortState.IdAsc)
{
if (sessionOrganizations.Keys.Contains("id"))
{
id = Convert.ToInt32(sessionOrganizations["id"]);
}
if (sessionOrganizations.Keys.Contains("name"))
{
name = sessionOrganizations["name"];
}
if (sessionOrganizations.Keys.Contains("page"))
{
page = Convert.ToInt32(sessionOrganizations["page"]);
}
if (sessionOrganizations.Keys.Contains("sortOrder"))
{
sortOrder = (SortState)Enum.Parse(typeof(SortState), sessionOrganizations["sortOrder"]);
}
}
if (page == 0)
{
page = 1;
}
int pageSize = 10; // количество элементов на странице
IQueryable <Invoice> source = db.Invoices;
await source.ForEachAsync(d => d.Rent = db.Rents.Where(p => p.Id == d.RentId).First());
if (id != null && id != 0)
{
source = source.Where(p => p.Id == id);
}
if (!String.IsNullOrEmpty(name))
{
source = source.Where(p => p.Bailee.Contains(name));
}
switch (sortOrder)
{
case SortState.DateOfPaymentDesc:
source = source.OrderByDescending(s => s.DateOfPayment);
break;
case SortState.DateOfPaymentAsc:
source = source.OrderBy(s => s.DateOfPayment);
break;
case SortState.IdDesc:
source = source.OrderByDescending(s => s.Id);
break;
case SortState.RentIdAsc:
source = source.OrderBy(s => s.RentId);
break;
case SortState.RentIdDesc:
source = source.OrderByDescending(s => s.RentId);
break;
case SortState.MounthAsc:
source = source.OrderBy(s => s.Mounth);
break;
case SortState.MounthDesc:
source = source.OrderByDescending(s => s.Mounth);
break;
case SortState.TotalAsc:
source = source.OrderBy(s => s.Total);
break;
case SortState.TotalDesc:
source = source.OrderByDescending(s => s.Total);
break;
default:
source = source.OrderBy(s => s.Id);
break;
}
var count = await source.CountAsync();
var items = await source.Skip((page - 1) *pageSize).Take(pageSize).ToListAsync();
PageViewModel pageViewModel = new PageViewModel(count, page, pageSize);
IndexViewModel viewModel = new IndexViewModel
{
PageViewModel = pageViewModel,
Invoices = items,
Rents = db.Rents,
SortViewModel = new SortViewModel(sortOrder),
FilterViewModel = new FilterViewModel(db.Invoices.ToList(), id, name)
};
return(View(viewModel));
}
public IActionResult Index(string NameS, int?GroupId, string Name, string Description, int page = 1, SortState sortOrder = SortState.GroupIdAcs)
{
int pageSize = 10;
IQueryable <Artists> source = _context.Artists.Include(a => a.Group);
ViewData["NameSSort"] = sortOrder == SortState.NameSAcs ? SortState.NameSDesc : SortState.NameSAcs;
ViewData["GroupIdSort"] = sortOrder == SortState.GroupIdAcs ? SortState.GroupIdDesc : SortState.GroupIdAcs;
if (NameS != null)
{
source = source.Where(x => x.NameS == NameS);
}
if (GroupId != null)
{
source = source.Where(x => x.GroupId == GroupId);
}
switch (sortOrder)
{
case SortState.NameSAcs:
source = source.OrderBy(x => x.NameS);
break;
case SortState.NameSDesc:
source = source.OrderByDescending(x => x.NameS);
break;
case SortState.GroupIdAcs:
source = source.OrderBy(x => x.GroupId);
break;
case SortState.GroupIdDesc:
source = source.OrderByDescending(x => x.GroupId);
break;
}
var count = source.Count();
var items = source.Skip((page - 1) * pageSize).Take(pageSize);
PageViewModel pageView = new PageViewModel(count, page, pageSize);
IndexViewModels ivm = new IndexViewModels
{
PageViewModel = pageView,
FilterView = new FilterView(NameS, GroupId, Name, Description),
Artists = items
};
return(View(ivm));
}
private static void SortOnThread <T>(T[] collection, IComparer <T> comparer, [NotNull] SortState state)
{
const int sequentialThreshold = 2048;
var hasChild = false;
try
{
var sw = new SpinWait();
while (Volatile.Read(ref state.OpLeft) != 0)
{
if (state.Partitions.TryDequeue(out var range) == false)
{
sw.SpinOnce();
continue;
}
if (range.Right - range.Left < sequentialThreshold)
{
// Sort small collections sequentially
Array.Sort(collection, range.Left, range.Right - range.Left + 1, comparer);
Interlocked.Decrement(ref state.OpLeft);
}
else
{
var pivot = Partition(collection, range.Left, range.Right, comparer);
int delta = -1;
// Add work items
if (pivot - 1 > range.Left)
{
delta++;
}
if (range.Right > pivot + 1)
{
delta++;
}
Interlocked.Add(ref state.OpLeft, delta);
if (pivot - 1 > range.Left)
{
state.Partitions.Enqueue(new SortRange(range.Left, pivot - 1));
}
if (range.Right > pivot + 1)
{
state.Partitions.Enqueue(new SortRange(pivot + 1, range.Right));
}
// Add a new worker if necessary
if (!hasChild)
{
var w = Interlocked.Decrement(ref state.MaxWorkerCount);
if (w >= 0)
{
state.AddReference();
ThreadPool.Instance.QueueWorkItem(() => SortOnThread(collection, comparer, state));
}
hasChild = true;
}
}
}
}
finally
{
if (Volatile.Read(ref state.OpLeft) == 0)
{
state.Finished.Set();
}
state.Release();
}
}
private IQueryable <Teacher> GetSortedTeachers(SortState sortState, string name, string position, string education)
{
IQueryable <Teacher> teachers = _context.Teachers.AsQueryable();
switch (sortState)
{
case SortState.TeachersNameAsc:
teachers = teachers.OrderBy(x => x.Name);
break;
case SortState.TeachersNameDesc:
teachers = teachers.OrderByDescending(x => x.Name);
break;
case SortState.TeachersSurNameAsc:
teachers = teachers.OrderBy(x => x.SurName);
break;
case SortState.TeachersSurNameDesc:
teachers = teachers.OrderByDescending(x => x.SurName);
break;
case SortState.TeachersMiddleNameAsc:
teachers = teachers.OrderBy(x => x.MiddleName);
break;
case SortState.TeachersMiddleNameDesc:
teachers = teachers.OrderByDescending(x => x.MiddleName);
break;
}
if (!string.IsNullOrEmpty(name) && !string.IsNullOrEmpty(position) && !string.IsNullOrEmpty(education))
{
teachers = teachers.Where(x => x.SurName.Contains(name) && x.Position.Contains(position) && x.Education.Contains(education)).AsQueryable();
}
else if (!string.IsNullOrEmpty(name) && !string.IsNullOrEmpty(position))
{
teachers = teachers.Where(x => x.SurName.Contains(name) && x.Position.Contains(position)).AsQueryable();
}
else if (!string.IsNullOrEmpty(name) && !string.IsNullOrEmpty(education))
{
teachers = teachers.Where(x => x.SurName.Contains(name) && x.Education.Contains(education)).AsQueryable();
}
else if (!string.IsNullOrEmpty(position) && !string.IsNullOrEmpty(education))
{
teachers = teachers.Where(x => x.Position.Contains(position) && x.Education.Contains(education)).AsQueryable();
}
else if (!string.IsNullOrEmpty(name))
{
teachers = teachers.Where(x => x.SurName.Contains(name)).AsQueryable();
}
else if (!string.IsNullOrEmpty(position))
{
teachers = teachers.Where(x => x.Position.Contains(position)).AsQueryable();
}
else if (!string.IsNullOrEmpty(education))
{
teachers = teachers.Where(x => x.Education.Contains(education)).AsQueryable();
}
return(teachers);
}
private static void PopulateAutoFilter(XLAutoFilter xlAutoFilter, AutoFilter autoFilter)
{
var filterRange = xlAutoFilter.Range;
autoFilter.Reference = filterRange.RangeAddress.ToString();
foreach (var kp in xlAutoFilter.Filters)
{
var filterColumn = new FilterColumn {ColumnId = (UInt32)kp.Key - 1};
var xlFilterColumn = xlAutoFilter.Column(kp.Key);
var filterType = xlFilterColumn.FilterType;
if (filterType == XLFilterType.Custom)
{
var customFilters = new CustomFilters();
foreach (var filter in kp.Value)
{
var customFilter = new CustomFilter {Val = filter.Value.ToString()};
if (filter.Operator != XLFilterOperator.Equal)
customFilter.Operator = filter.Operator.ToOpenXml();
if (filter.Connector == XLConnector.And)
customFilters.And = true;
customFilters.Append(customFilter);
}
filterColumn.Append(customFilters);
}
else if (filterType == XLFilterType.TopBottom)
{
var top101 = new Top10 {Val = (double)xlFilterColumn.TopBottomValue};
if (xlFilterColumn.TopBottomType == XLTopBottomType.Percent)
top101.Percent = true;
if (xlFilterColumn.TopBottomPart == XLTopBottomPart.Bottom)
top101.Top = false;
filterColumn.Append(top101);
}
else if (filterType == XLFilterType.Dynamic)
{
var dynamicFilter = new DynamicFilter
{Type = xlFilterColumn.DynamicType.ToOpenXml(), Val = xlFilterColumn.DynamicValue};
filterColumn.Append(dynamicFilter);
}
else
{
var filters = new Filters();
foreach (var filter in kp.Value)
{
filters.Append(new Filter {Val = filter.Value.ToString()});
}
filterColumn.Append(filters);
}
autoFilter.Append(filterColumn);
}
if (xlAutoFilter.Sorted)
{
var sortState = new SortState
{
Reference =
filterRange.Range(filterRange.FirstCell().CellBelow(), filterRange.LastCell()).RangeAddress.
ToString()
};
var sortCondition = new SortCondition
{
Reference =
filterRange.Range(1, xlAutoFilter.SortColumn, filterRange.RowCount(),
xlAutoFilter.SortColumn).RangeAddress.ToString()
};
if (xlAutoFilter.SortOrder == XLSortOrder.Descending)
sortCondition.Descending = true;
sortState.Append(sortCondition);
autoFilter.Append(sortState);
}
}
private void Unsort()
{
sortState = SortState.Unsorted;
for (int i = 0; i < order.Length; i++){
order[i] = i;
inverseOrder[i] = i;
}
}
internal void FromSortState(SortState ss)
{
this.SetAllNull();
if (ss.ColumnSort != null && ss.ColumnSort.Value)
{
this.ColumnSort = ss.ColumnSort.Value;
}
if (ss.CaseSensitive != null && ss.CaseSensitive.Value)
{
this.CaseSensitive = ss.CaseSensitive.Value;
}
if (ss.SortMethod != null)
{
this.SortMethod = ss.SortMethod.Value;
}
int iStartRowIndex = 1;
int iStartColumnIndex = 1;
int iEndRowIndex = 1;
int iEndColumnIndex = 1;
string sRef = ss.Reference.Value;
if (sRef.IndexOf(":") > 0)
{
if (SLTool.FormatCellReferenceRangeToRowColumnIndex(sRef, out iStartRowIndex, out iStartColumnIndex, out iEndRowIndex, out iEndColumnIndex))
{
this.StartRowIndex = iStartRowIndex;
this.StartColumnIndex = iStartColumnIndex;
this.EndRowIndex = iEndRowIndex;
this.EndColumnIndex = iEndColumnIndex;
}
}
else
{
if (SLTool.FormatCellReferenceToRowColumnIndex(sRef, out iStartRowIndex, out iStartColumnIndex))
{
this.StartRowIndex = iStartRowIndex;
this.StartColumnIndex = iStartColumnIndex;
this.EndRowIndex = iStartRowIndex;
this.EndColumnIndex = iStartColumnIndex;
}
}
if (ss.HasChildren)
{
SLSortCondition sc;
using (OpenXmlReader oxr = OpenXmlReader.Create(ss))
{
while (oxr.Read())
{
if (oxr.ElementType == typeof(SortCondition))
{
sc = new SLSortCondition();
sc.FromSortCondition((SortCondition)oxr.LoadCurrentElement());
// limit of 64 from Open XML specs
if (this.SortConditions.Count < 64)
{
this.SortConditions.Add(sc);
}
}
}
}
}
}
// -----------------------------------------------------------------
/// <summary>
/// Listen for inworld commands and configuration
/// </summary>
// -----------------------------------------------------------------
protected string QuickSortState(UUID hostID, UUID scriptID, string command)
{
command = command.ToLower();
m_scriptID = scriptID;
m_reqID = UUID.Random();
m_log.DebugFormat("[QuickSort] set state to {0} in script {1}",command,m_scriptID);
try
{
switch (command)
{
case "abort":
if (m_state == SortState.Sort)
{
m_log.DebugFormat("[QuickSort] abort");
m_abort = true;
return m_reqID.ToString();
}
break;
case "create":
if (m_state == SortState.PreCreate)
{
m_log.DebugFormat("[QuickSort] create");
m_state = SortState.Create;
m_probeTimer.Start();
return m_reqID.ToString();
}
break;
case "destroy":
if ((m_state == SortState.PreSort) || (m_state == SortState.PreDestroy))
{
m_log.DebugFormat("[QuickSort] destroy");
m_state = SortState.Destroy;
m_probeTimer.Start();
return m_reqID.ToString();
}
break;
case "sort":
if (m_state == SortState.PreSort)
{
m_log.DebugFormat("[QuickSort] sort");
m_state = SortState.Sort;
m_probeTimer.Start();
return m_reqID.ToString();
}
break;
default:
m_log.WarnFormat("[QuickSort] unknown command {0}",command);
break;
}
}
catch (Exception e)
{
m_log.WarnFormat("[QuickSort] error processing command channel input: {0}",e.ToString());
}
return UUID.Zero.ToString();
}
//Отображение очереди
public async Task <IActionResult> Index(SortState sortOrder = SortState.PositionAsc)
{
IQueryable <Queue> queues = db.Queues;
if (User.Identity.IsAuthenticated)
{
var user = await _userManager.GetUserAsync(User);
if (user.Position == 0 || user == null)
{
ViewBag.Error = _localizer["YouAreNotInQueue"];
}
else
{
ViewBag.Error = _localizer["YouAreInQueue"];
}
}
//Сортировка
#region
ViewData["RoomSort"] = sortOrder == SortState.RelaxRoomNameAsc ? SortState.RelaxRoomNameDesc : SortState.RelaxRoomNameAsc;
ViewData["MicrowaveSort"] = sortOrder == SortState.MicrowaveNameAsc ? SortState.MicrowaveNameDesc : SortState.MicrowaveNameAsc;
ViewData["PositionSort"] = sortOrder == SortState.PositionAsc ? SortState.PositionDesc : SortState.PositionAsc;
ViewData["UserNameSort"] = sortOrder == SortState.UserNameAsc ? SortState.UserNameDesc : SortState.UserNameAsc;
ViewData["UserEmailSort"] = sortOrder == SortState.UserEmailAsc ? SortState.UserEmailDesc : SortState.UserEmailAsc;
switch (sortOrder)
{
case SortState.RelaxRoomNameAsc:
queues = queues.OrderBy(s => s.RelaxRoomName);
break;
case SortState.RelaxRoomNameDesc:
queues = queues.OrderByDescending(s => s.RelaxRoomName);
break;
case SortState.MicrowaveNameAsc:
queues = queues.OrderBy(s => s.MicrowaveName);
break;
case SortState.MicrowaveNameDesc:
queues = queues.OrderByDescending(s => s.MicrowaveName);
break;
case SortState.PositionAsc:
queues = queues.OrderByDescending(s => s.NumberPosition);
break;
case SortState.UserNameAsc:
queues = queues.OrderBy(s => s.UserName);
break;
case SortState.UserEmailAsc:
queues = queues.OrderBy(s => s.UserEmail);
break;
case SortState.UserEmailDesc:
queues = queues.OrderByDescending(s => s.UserEmail);
break;
default:
queues = queues.OrderByDescending(s => s.UserName);
break;
}
#endregion
return(View(await queues.AsNoTracking().ToListAsync()));
}
// -----------------------------------------------------------------
/// <summary>
/// Thread timer handler
/// </summary>
/// <param name="sender"></param>
/// <param name="ea"></param>
// -----------------------------------------------------------------
private void UpdateSortObjects(object sender, EventArgs ea)
{
m_log.DebugFormat("[QuickSort] timer event fired");
switch (m_state)
{
case SortState.Create:
CreateSortableObjects();
m_comms.DispatchReply(m_scriptID,1,"create",UUID.Zero.ToString());
m_state = SortState.PreSort;
break;
case SortState.Destroy:
DestroySortableObjects();
m_comms.DispatchReply(m_scriptID,1,"destroy",UUID.Zero.ToString());
m_state = SortState.PreCreate;
break;
case SortState.Sort:
SortSortableObjects();
m_comms.DispatchReply(m_scriptID,1,"sort",UUID.Zero.ToString());
m_state = SortState.PreDestroy;
break;
}
}
} // текущее значение сортировки
public SortViewModel(SortState sortOrder)
{
StatusSort = sortOrder == SortState.StatusAsc ? SortState.StatusAsc : SortState.StatusAsc;
DateSort = sortOrder == SortState.DateAsc ? SortState.DateDesc : SortState.DateAsc;
Current = sortOrder;
}
} // текущее значение сортировки
public SortViewModel(SortState sortOrder)
{
IndicatorCodeSort = sortOrder == SortState.IndicatorCodeAsc ? SortState.IndicatorCodeDesc : SortState.IndicatorCodeAsc;
UniversityNameSort = sortOrder == SortState.UniversityNameAsc ? SortState.UniversityNameDesc : SortState.UniversityNameAsc;
Current = sortOrder;
}
} // текущее значение сортировки
public SortViewModel(SortState sortOrder)
{
NameSort = sortOrder == SortState.NameAsc ? SortState.NameDesc : SortState.NameAsc;
PriceSort = sortOrder == SortState.PriceAsc ? SortState.PriceDesc : SortState.PriceAsc;
Current = sortOrder;
}
private void SortActions(SortState state)
{
_currentSortState = state;
RefreshData();
}
private static void Sort <T>(T[] collection, int maxDegreeOfParallelism, IComparer <T> comparer, [NotNull] SortState state)
{
const int sequentialThreshold = 2048;
// Other threads already processed all work before this one started. ActiveWorkerCount is already 0
if (state.Partitions.IsEmpty)
{
state.Release();
return;
}
// This thread is now actively processing work items, meaning there might be work in progress
Interlocked.Increment(ref state.ActiveWorkerCount);
var hasChild = false;
try
{
SortRange range;
while (state.Partitions.TryDequeue(out range))
{
if (range.Right - range.Left < sequentialThreshold)
{
// Sort small collections sequentially
Array.Sort(collection, range.Left, range.Right - range.Left + 1, comparer);
}
else
{
var pivot = Partition(collection, range.Left, range.Right, comparer);
// Add work items
if (pivot - 1 > range.Left)
{
state.Partitions.Enqueue(new SortRange(range.Left, pivot - 1));
}
if (range.Right > pivot + 1)
{
state.Partitions.Enqueue(new SortRange(pivot + 1, range.Right));
}
// Add a new worker if necessary
if (maxDegreeOfParallelism > 1 && !hasChild)
{
state.AddReference();
Fork(collection, maxDegreeOfParallelism, comparer, state);
hasChild = true;
}
}
}
}
finally
{
state.Release();
if (Interlocked.Decrement(ref state.ActiveWorkerCount) == 0)
{
state.Finished.Set();
}
}
}
} // Сортировка по возрастанию или убыванию
public SortViewModel(SortState sortOrder)
{
// значения по умолчанию
IdSort = SortState.IdAsc;
CountrySort = SortState.CountryAsc;
CitySort = SortState.CityAsc;
StereetSort = SortState.StereetAsc;
BuildingNumberSort = SortState.BuildingNumberAsc;
PostIDSort = SortState.PostIDAsc;
DateTimeSort = SortState.DateTimeAsc;
Up = true;
if (sortOrder == SortState.IdDesc ||
sortOrder == SortState.CountryDesc ||
sortOrder == SortState.CityDesc ||
sortOrder == SortState.StereetDesc ||
sortOrder == SortState.BuildingNumberDesc ||
sortOrder == SortState.PostIDDesc ||
sortOrder == SortState.DateTimeDesc)
{
Up = false;
}
switch (sortOrder)
{
case SortState.CountryAsc:
Current = CountrySort = SortState.CountryDesc;
break;
case SortState.CountryDesc:
Current = CountrySort = SortState.CountryAsc;
break;
case SortState.CityAsc:
Current = CitySort = SortState.CityDesc;
break;
case SortState.CityDesc:
Current = CitySort = SortState.CityAsc;
break;
case SortState.StereetAsc:
Current = StereetSort = SortState.StereetDesc;
break;
case SortState.StereetDesc:
Current = StereetSort = SortState.StereetAsc;
break;
case SortState.BuildingNumberAsc:
Current = BuildingNumberSort = SortState.BuildingNumberDesc;
break;
case SortState.BuildingNumberDesc:
Current = BuildingNumberSort = SortState.BuildingNumberAsc;
break;
case SortState.PostIDAsc:
Current = PostIDSort = SortState.PostIDDesc;
break;
case SortState.PostIDDesc:
Current = PostIDSort = SortState.PostIDAsc;
break;
case SortState.DateTimeAsc:
Current = DateTimeSort = SortState.DateTimeDesc;
break;
case SortState.DateTimeDesc:
Current = DateTimeSort = SortState.DateTimeAsc;
break;
case SortState.IdDesc:
Current = IdSort = SortState.IdAsc;
break;
case SortState.IdAsc:
Current = IdSort = SortState.IdDesc;
break;
default:
Current = IdSort = SortState.IdAsc;
break;
}
}
public async Task <IActionResult> Index(int?id, string name, int page = 0, SortState sortOrder = SortState.IdAsc)
{
var sessionService = HttpContext.Session.Get("Services");
if (sessionService != null && id == null && name == null && page == 0 && sortOrder == SortState.IdAsc)
{
try
{
if (sessionService.Keys.Contains("id"))
{
id = Convert.ToInt32(sessionService["id"]);
}
if (sessionService.Keys.Contains("name"))
{
name = sessionService["name"];
}
}
catch { }
if (sessionService.Keys.Contains("page"))
{
page = Convert.ToInt32(sessionService["page"]);
}
if (sessionService.Keys.Contains("sortOrder"))
{
sortOrder = (SortState)Enum.Parse(typeof(SortState), sessionService["sortOrder"]);
}
}
if (page == 0)
{
page = 1;
}
int pageSize = 10;
IQueryable <Service> source = context._Services;
if (id != null && id != 0)
{
source = source.Where(p => p.ListID == id);
}
if (!String.IsNullOrEmpty(name))
{
source = source.Where(p => p.Name.Contains(name));
}
switch (sortOrder)
{
case SortState.IdDesc:
source = source.OrderByDescending(s => s.ListID);
break;
case SortState.NameDesc:
source = source.OrderByDescending(s => s.Name);
break;
case SortState.NameAsc:
source = source.OrderBy(s => s.Name);
break;
case SortState.PriceDesc:
source = source.OrderByDescending(s => s.Price);
break;
case SortState.PriceAsc:
source = source.OrderBy(s => s.Price);
break;
default:
source = source.OrderBy(s => s.ListID);
break;
}
var count = await source.CountAsync();
var items = await source.Skip((page - 1) *pageSize).Take(pageSize).ToListAsync();
PageViewModel pageViewModel = new PageViewModel(count, page, pageSize);
IndexViewModel viewModel = new IndexViewModel
{
PageViewModel = pageViewModel,
Services = items,
SortViewModel = new SortViewModel(sortOrder),
FilterViewModel = new FilterViewModel(context._Services.ToList(), id, name)
};
return(View(viewModel));
}
public ActionResult <IPagedResponse <FavoriteDTO> > GetListFavorites(int userId, int page = 1, SortState sortOrder = SortState.NameAsc, bool isPageRequestNeeded = true)
{
IPagedResponse <FavoriteDTO> objectList = favoriteService.GetFavorites(userId, page, sortOrder, isPageRequestNeeded);
return(Ok(objectList));
}
public virtual void OnSortingStatusChanged(SortState pSortState)
{
this.mSortState = pSortState;
}
public override void OnColumnSortStatusChanged(int column, SortState sortState)
{
this._enclosing.PaginateOnColumnSort(column, sortState);
}
public async Task <IActionResult> Index(int?category, string name, string priceRange, int page = 1, SortState sortOrder = SortState.NameAsc)
{
IQueryable <Cap> caps = db.Caps
.Include(x => x.Category)
.Include(x => x.Supplier)
.AsNoTracking();
decimal maxPrice = caps.Max(p => p.Price);
decimal minPrice = caps.Min(p => p.Price);
caps = caps.Where(p => (p.Visible == true));
ViewData["CurrentRange"] = priceRange;
ViewData["CurrentName"] = name;
ViewData["CurrentCategory"] = category;
ViewData["CurrentSort"] = sortOrder;
if (!String.IsNullOrEmpty(priceRange))
{
//Get ints from string priceRange
string[] s = priceRange.Split(',');
int minRange = Convert.ToInt32(s[0]);
int maxRange = Convert.ToInt32(s[1]);
caps = caps.Where(p => (p.Price >= minRange && p.Price <= maxRange));
}
if (category != null && category != 0)
{
caps = caps.Where(p => p.CategoryId == category);
}
if (!String.IsNullOrEmpty(name))
{
caps = caps.Where(p => p.Name.Contains(name));
}
List <Category> categories = db.Categories.ToList();
// set the first element which allow to select all
categories.Insert(0, new Category {
Name = "All", Id = 0
});
ViewData["NameSort"] = sortOrder == SortState.NameAsc ? SortState.NameDesc : SortState.NameAsc;
ViewData["PriceSort"] = sortOrder == SortState.PriceAsc ? SortState.PriceDesc : SortState.PriceAsc;
ViewData["CatSort"] = sortOrder == SortState.CategoryAsc ? SortState.CategoryDesc : SortState.CategoryAsc;
switch (sortOrder)
{
case SortState.NameDesc:
caps = caps.OrderByDescending(s => s.Name);
break;
case SortState.PriceAsc:
caps = caps.OrderBy(s => s.Price);
break;
case SortState.PriceDesc:
caps = caps.OrderByDescending(s => s.Price);
break;
case SortState.SupplierAsc:
caps = caps.OrderBy(s => s.Supplier.Name);
break;
case SortState.SupplierDesc:
caps = caps.OrderByDescending(s => s.Supplier.Name);
break;
case SortState.CategoryAsc:
caps = caps.OrderBy(s => s.Category.Name);
break;
case SortState.CategoryDesc:
caps = caps.OrderByDescending(s => s.Category.Name);
break;
default:
caps = caps.OrderBy(s => s.Name);
break;
}
int pageSize = 9; // elements per page
var count = await caps.CountAsync();
var items = await caps.Skip((page - 1) *pageSize).Take(pageSize).ToListAsync();
PageViewModel pageViewModel = new PageViewModel(count, page, pageSize);
CapsListViewModel viewModel = new CapsListViewModel
{
Caps = items.ToList(),
Categories = new SelectList(categories, "Id", "Name"),
PageViewModel = pageViewModel,
Name = name,
MaxPrice = maxPrice,
MinPrice = minPrice
};
return(View(viewModel));
}
public override void OnRowHeaderSortStatusChanged(SortState sortState)
{
this._enclosing.PaginateOnColumnSort(-1, sortState);
}
public async Task <IActionResult> Main(string searchedValue, string searchInColumn, SortState sortOrder = SortState.NameAsc)
{
IQueryable <Apartment> apartments = null;
if (searchedValue != null && searchInColumn != null)
{
switch (searchInColumn)
{
case ("Apartment №"):
apartments = _dbContext.Apartments.Where(x => x.Name.ToString() == searchedValue);
break;
case ("NumberOfRooms"):
apartments = _dbContext.Apartments.Where(x => x.NumberOfRooms.ToString() == searchedValue);
break;
case ("MaxTenants"):
apartments = _dbContext.Apartments.Where(x => x.MaxTenants.ToString() == searchedValue);
break;
case ("PricePerHour"):
apartments = _dbContext.Apartments.Where(x => x.PricePerHour.ToString() == searchedValue);
break;
}
}
else
{
apartments = _dbContext.Apartments.Select(x => x);
}
switch (sortOrder)
{
case SortState.NameDesc:
apartments = apartments.OrderByDescending(x => x.Name);
break;
case SortState.ApartmentTypeAsc:
apartments = apartments.OrderBy(x => x.ApartmentType);
break;
case SortState.ApartmentTypeDesc:
apartments = apartments.OrderByDescending(x => x.ApartmentType);
break;
case SortState.FreeAsc:
apartments = apartments.OrderBy(x => x.Free);
break;
case SortState.FreeDesc:
apartments = apartments.OrderByDescending(x => x.Free);
break;
case SortState.NumberOfRoomsAsc:
apartments = apartments.OrderBy(x => x.NumberOfRooms);
break;
case SortState.NumberOfRoomsDesc:
apartments = apartments.OrderByDescending(x => x.NumberOfRooms);
break;
case SortState.PricePerHourAsc:
apartments = apartments.OrderBy(x => x.PricePerHour);
break;
case SortState.PricePerHourDesc:
apartments = apartments.OrderByDescending(x => x.PricePerHour);
break;
case SortState.MaxTenantsAsc:
apartments = apartments.OrderBy(x => x.MaxTenants);
break;
case SortState.MaxTenantsDesc:
apartments = apartments.OrderByDescending(x => x.MaxTenants);
break;
default:
apartments = apartments.OrderBy(x => x.Name);
break;
}
AdminViewModel sysViewModel = new AdminViewModel()
{
//Определяем не кэшированные данные для вывода в модели представление
Apartments = await apartments.AsNoTracking().ToListAsync(),
SortViewModel = new SortViewModel(sortOrder),
FilterViewModel = new FilterViewModel(searchedValue, searchInColumn)
};
return(View(sysViewModel));
}
public async Task <RecipeViewModel> Index(int?category, int?country, string name, int page = 1,
SortState sortOrder = SortState.TopicAsc)
{
return(await _recipeService.GetRecipe(category, country, name, page, sortOrder));
}
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));
}
public SortViewModel(SortState sortOrder)
{
NameSort = sortOrder == SortState.NameAsc ? SortState.NameDesc : SortState.NameAsc;
RatingSort = sortOrder == SortState.RatingAsc ? SortState.RatingDesc : SortState.RatingAsc;
Current = sortOrder;
}
public SortViewModel(SortState sortOrder)
{
DateOfTakingSort = sortOrder == SortState.dateOfTakingAsc ? SortState.dateofTakingDesc : SortState.dateOfTakingAsc;
Current = sortOrder;
}
public IActionResult Index(int?currency, int?typedeposit, int page = 1, SortState sortOrder = SortState.DespositIDAsc)
{
int pageSize = 10;
IQueryable <Deposit> source = db.Deposits.Include(d => d.Currency)
.Include(d => d.Depositor)
.Include(d => d.Typedeposit)
.Include(d => d.Employee);
if (currency != null && currency != 0)
{
source = source.Where(p => p.CurrencyID == currency);
}
if (typedeposit != null && typedeposit != 0)
{
source = source.Where(p => p.TypedepositID == typedeposit);
}
switch (sortOrder)
{
case SortState.DespositIDDesc:
source = source.OrderByDescending(s => s.DespositID);
break;
case SortState.TypeOfCurrencyAsc:
source = source.OrderBy(s => s.Currency.NameCurrency);
break;
case SortState.TypeOfCurrencyDesc:
source = source.OrderByDescending(s => s.Currency.NameCurrency);
break;
case SortState.TypeOfDepositorAsc:
source = source.OrderBy(s => s.Depositor.NameDep);
break;
case SortState.TypeOfDepositorDesc:
source = source.OrderByDescending(s => s.Depositor.NameDep);
break;
case SortState.TypeOfTypedepositAsc:
source = source.OrderBy(s => s.Typedeposit.NameType);
break;
case SortState.TypeOfTypedepositDesc:
source = source.OrderByDescending(s => s.Typedeposit.NameType);
break;
case SortState.TypeOfEmployeeAsc:
source = source.OrderBy(s => s.Employee.NameEmpl);
break;
case SortState.TypeOfEmployeeDesc:
source = source.OrderByDescending(s => s.Employee.NameEmpl);
break;
case SortState.DepositsumAsc:
source = source.OrderBy(s => s.Depositsum);
break;
case SortState.DepositsumDesc:
source = source.OrderByDescending(s => s.Depositsum);
break;
case SortState.DatedepositAsc:
source = source.OrderBy(s => s.Datedeposit);
break;
case SortState.DatedepositDesc:
source = source.OrderByDescending(s => s.Datedeposit);
break;
case SortState.RefundamountAsc:
source = source.OrderBy(s => s.Refundamount);
break;
case SortState.RefundamountDesc:
source = source.OrderByDescending(s => s.Refundamount);
break;
case SortState.DatereturnAsc:
source = source.OrderBy(s => s.Datereturn);
break;
case SortState.DatereturnDesc:
source = source.OrderByDescending(s => s.Datereturn);
break;
default:
source = source.OrderBy(s => s.DespositID);
break;
}
var count = source.Count();
var items = source.Skip((page - 1) * pageSize).Take(pageSize).ToList();
PageViewModel pageViewModel = new PageViewModel(count, page, pageSize);
DepositsFilterViewModel depositsFilterViewModel = new DepositsFilterViewModel(db.Currencies.ToList(), db.Typesdeposits.ToList(), currency, typedeposit);
DepositsViewModel deposits = new DepositsViewModel
{
Deposits = items,
DepositViewModel = _deposit,
PageViewModel = pageViewModel,
SortViewModel = new DepositsSortViewModel(sortOrder),
FilterViewModel = depositsFilterViewModel
};
return(View(deposits));
}
internal SortState ToSortState()
{
SortState ss = new SortState();
if (this.ColumnSort != null && this.ColumnSort.Value) ss.ColumnSort = this.ColumnSort.Value;
if (this.CaseSensitive != null && this.CaseSensitive.Value) ss.CaseSensitive = this.CaseSensitive.Value;
if (HasSortMethod) ss.SortMethod = this.SortMethod;
if (this.StartRowIndex == this.EndRowIndex && this.StartColumnIndex == this.EndColumnIndex)
{
ss.Reference = SLTool.ToCellReference(this.StartRowIndex, this.StartColumnIndex);
}
else
{
ss.Reference = string.Format("{0}:{1}",
SLTool.ToCellReference(this.StartRowIndex, this.StartColumnIndex),
SLTool.ToCellReference(this.EndRowIndex, this.EndColumnIndex));
}
if (this.SortConditions.Count > 0)
{
for (int i = 0; i < this.SortConditions.Count; ++i)
{
ss.Append(this.SortConditions[i].ToSortCondition());
}
}
return ss;
}
private void CheckSizes()
{
if (model == null){
return;
}
if (order == null || order.Length != model.RowCount){
order = ArrayUtils.ConsecutiveInts(model.RowCount);
inverseOrder = ArrayUtils.ConsecutiveInts(model.RowCount);
sortState = SortState.Unsorted;
sortCol = -1;
}
if (modelRowSel == null || modelRowSel.Length != model.RowCount){
modelRowSel = new bool[model.RowCount];
}
}
