private IQueryable<JobDTO> ApplySort(IQueryable<JobDTO> source, string sortCriteria)
{
if (string.IsNullOrWhiteSpace(sortCriteria))
{
return source.OrderBy(x => x.ID);
}
string[] sortValues = sortCriteria.Split(' ');
var desceding = false;
if (sortValues.Length > 1)
{
if (sortValues[1].ToUpper() == "DESC")
{
desceding = true;
}
}
if (desceding)
{
return source.OrderBy(sortValues[0] + " descending");
}
else
{
return source.OrderBy(sortValues[0]);
}
}
private IQueryable<ProductsListViewModel> GetSorted(IQueryable<ProductsListViewModel> allProducts, string sortOrder)
{
ViewBag.CurrentSort = sortOrder;
ViewBag.DateSortParm = String.IsNullOrEmpty(sortOrder) ? "Date" : "";
ViewBag.PriceSortParm = sortOrder == "Price" ? "price_desc" : "Price";
ViewBag.RatingSortParm = sortOrder == "Rating" ? "rating_desc" : "Rating";
switch (sortOrder)
{
case "Rating":
allProducts = allProducts.OrderBy(p => p.Rating);
break;
case "rating_desc":
allProducts = allProducts.OrderByDescending(p => p.Rating);
break;
case "Price":
allProducts = allProducts.OrderBy(p => p.Price);
break;
case "price_desc":
allProducts = allProducts.OrderByDescending(p => p.Price);
break;
case "Date":
allProducts = allProducts.OrderByDescending(p => p.ReleaseDate);
break;
default:
allProducts = allProducts.OrderBy(p => p.ReleaseDate);
break;
}
return allProducts;
}
private static IQueryable<Product> OrderProducts(IQueryable<Product> products, string sortOrder)
{
switch (sortOrder)
{
case "desc":
return products.OrderByDescending(p => p.Price).ThenBy(p => p.Name).AsQueryable();
case "asc":
return products.OrderBy(p => p.Price).ThenBy(p => p.Name).AsQueryable();
default: // "abc"
return products.OrderBy(p => p.Name).AsQueryable();
}
}
public IQueryable<CmsWeb.Models.MailingController.MailingInfo> ApplySort(IQueryable<CmsWeb.Models.MailingController.MailingInfo> query, string sortExpression)
{
switch (sortExpression)
{
case "Name":
return query.OrderBy(mi => mi.LastName);
case "Zip":
return query.OrderBy(mi => mi.Zip);
//break;
default:
break;
}
return query;
}
public IQueryable<Person> ApplySort(IQueryable<Person> query, string sortExpression)
{
switch (sortExpression)
{
case "Name":
return query.OrderBy(mi => mi.Name2);
case "Zip":
return query.OrderBy(mi => mi.PrimaryZip);
//break;
default:
break;
}
return query;
}
public IQueryable<MailingInfo> ApplySort(IQueryable<MailingInfo> query, string sortExpression)
{
switch (sortExpression)
{
case "Name":
return query.OrderBy(mi => mi.Name2);
case "Zip":
return query.OrderBy(mi => mi.Zip);
//break;
default:
break;
}
return query;
}
public IQueryable<SMSList> ApplySort(IQueryable<SMSList> l)
{
if (Pager.Direction == "asc")
{
switch (Pager.Sort)
{
case "Sent/Scheduled":
l = l.OrderBy(e => e.Created);
break;
case "From":
l = l.OrderBy(e => e.Person.Name);
break;
case "Title":
l = l.OrderBy(e => e.Title);
break;
case "Include":
l = l.OrderBy(e => e.SentSMS);
break;
case "Exclude":
l = l.OrderBy(e => e.SentNone);
break;
}
}
else
{
switch (Pager.Sort)
{
case "Sent/Scheduled":
l = l.OrderByDescending(e => e.Created);
break;
case "From":
l = l.OrderByDescending(e => e.Person.Name);
break;
case "Title":
l = l.OrderByDescending(e => e.Title);
break;
case "Include":
l = l.OrderByDescending(e => e.SentSMS);
break;
case "Exclude":
l = l.OrderByDescending(e => e.SentNone);
break;
default:
l = l.OrderByDescending(e => e.Created);
break;
}
}
return l;
}
public static Station GetClosestStation(this Station station, IQueryable<Station> stations)
{
if (stations.Count () == 0) {
return Station.NotFoundStation ();
}
return stations.OrderBy (currentStation => SortableApproximateDistance (station, currentStation)).First ();
}
public IQueryable<MediaContent> Translate(IExpression expression, IQueryable<MediaContent> contentQueryable)
{
this.Visite(expression);
contentQueryable = contentQueryable.Where(this.LinqExpression);
if (this.OrderExprssion != null)
{
if (!this.OrderDesc)
{
contentQueryable = contentQueryable.OrderBy(this.OrderExprssion);
}
else
{
contentQueryable = contentQueryable.OrderByDescending(this.OrderExprssion);
}
}
if (Skip.HasValue)
{
contentQueryable = contentQueryable.Skip(Skip.Value);
}
if (Take.HasValue)
{
contentQueryable = contentQueryable.Take(Take.Value);
}
return contentQueryable;
}
public IQueryable<MarketOrder> ApplyFilter(IQueryable<MarketOrder> query)
{
query = query.Where(pos =>
(filterMagic == null || filterMagic.Value == pos.Magic) &&
(filterSide == null || filterSide.Value == pos.Side) &&
(string.IsNullOrEmpty(filterComment) ||
pos.Comment.Contains(filterComment)) &&
(string.IsNullOrEmpty(filterExpertComment) ||
pos.ExpertComment.Contains(filterExpertComment)) &&
(string.IsNullOrEmpty(filterTicker) ||
pos.Symbol.Contains(filterTicker)) &&
(filterTimeEnterStartsWith == null ||
pos.TimeEnter >= filterTimeEnterStartsWith.Value) &&
(filterTimeEnterEndsWith == null ||
pos.TimeEnter <= filterTimeEnterEndsWith.Value) &&
(filterTimeExitStartsWith == null ||
pos.TimeExit >= filterTimeExitStartsWith) &&
(filterTimeExitEndsWith == null ||
pos.TimeExit <= filterTimeExitEndsWith));
query = (sortAscending ? query.OrderBy(p => sortByTimeEnter ? p.TimeEnter : p.TimeExit)
: query.OrderByDescending(p => sortByTimeEnter ? p.TimeEnter : p.TimeExit))
.Take(takeCount);
return query;
}
private IQueryable<Customer> orderCustomers(IQueryable<Customer> customers, string sortColumn, string sortOrder)
{
if (sortColumn == "CustomerId")
return (sortOrder == "desc") ? customers.OrderByDescending(c => c.CustomerID) : customers.OrderBy(c => c.CustomerID);
if (sortColumn == "Name")
return (sortOrder == "desc") ? customers.OrderByDescending(c=>c.FirstName) : customers.OrderBy(c=>c.FirstName);
if (sortColumn == "Company")
return (sortOrder == "desc")? customers.OrderByDescending(c=>c.CompanyName) : customers.OrderBy(c=>c.CompanyName);
if (sortColumn == "EmailAddress")
return (sortOrder == "desc") ? customers.OrderByDescending(c => c.EmailAddress) : customers.OrderBy(c => c.EmailAddress);
if (sortColumn == "Last Modified")
return (sortOrder == "desc") ? customers.OrderByDescending(c => c.ModifiedDate) : customers.OrderBy(c => c.ModifiedDate);
if (sortColumn == "Telephone")
return (sortOrder == "desc") ? customers.OrderByDescending(c => c.Phone) : customers.OrderBy(c => c.Phone);
return customers;
}
/// <summary>
/// Returns a <see cref="PageViewModel{T}" /> containing a page of the data given according to the search
/// criteria.
///
/// Performs Ordering & Paging if applicable. When there is no order parameter, it sorts by the Id.
/// </summary>
/// <param name="data"></param>
/// <param name="criteria"></param>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public static PageViewModel <T> GetPage <T>(this IQueryable <T> data, BaseSearchCriteria criteria) where T : class
{
if (criteria == null)
{
return(new PageViewModel <T>
{
Data = data?.ToList()
});
}
criteria.PageSize = criteria.PageSize != 0 ? criteria.PageSize : int.MaxValue;
criteria.PageSize = criteria.PageSize > 10 ? criteria.PageSize : 10;
criteria.Page = criteria.Page > 1 ? criteria.Page : 1;
// if the model is of type base model, default OrderBy is Last Update Date. If not, default is the I
criteria.OrderBy = !string.IsNullOrWhiteSpace(criteria.OrderBy)
? criteria.OrderBy : "Id";
var page = new PageViewModel <T>
{
PageSize = criteria.PageSize,
Page = criteria.Page,
TotalRecords = data?.Count() ?? 0
};
string orderProperty = criteria.OrderBy.Split(' ')[0] ?? string.Empty;
bool descending = (!string.IsNullOrWhiteSpace(criteria?.OrderBy) && criteria.OrderBy.EndsWith(" desc", System.StringComparison.InvariantCultureIgnoreCase))? true:false;
page.Data = data?.OrderBy(criteria.OrderBy)
.Skip(criteria.PageSize * (criteria.Page - 1))
.Take(criteria.PageSize)
.ToList();
return(page);
}
IQueryable<Product> ApplyOrdering(IQueryable<Product> products, string direction)
{
if (products == null)
return null;
return direction == "desc" ? products.OrderByDescending(p => p.Id) : products.OrderBy(p => p.Id);
}
private IQueryable<ChinookModel.Track> SelectAllSortTracks(IQueryable<ChinookModel.Track> query, string sortExpr)
{
if (!String.IsNullOrEmpty(sortExpr))
{
query = query.OrderBy(sortExpr);
}
return query;
}
protected IQueryable<ProductViewModel> Sort(IQueryable<ProductViewModel> products, string sortBy, string sortOrder)
{
if (sortBy == SortByDefault)
{
if (sortOrder == SortOrderDefault)
return products.OrderByDescending(p => p.Likes.Count);
else
return products.OrderBy(p => p.Likes.Count);
}
if (sortBy == "Price")
{
if (sortOrder == SortOrderDefault)
return products.OrderByDescending(p => p.Price);
}
return products.OrderBy(p => p.Price);
}
public IQueryable<Country> ReportBuildQuery(IQueryable<Country> query)
{
query = query.Where(q => q.IsActive && !q.IsDeleted);
if (!string.IsNullOrWhiteSpace(Name)) query = query.Where(q => q.Name.Contains(Name));
if (!string.IsNullOrWhiteSpace(ShortCode)) query = query.Where(q => q.ShortCode.Contains(ShortCode));
if (Pager.Size > 0) query = query.OrderBy(x => x.Updated).Skip(Pager.Skip()).Take(Pager.Size);
return query;
}
protected IQueryable<EduProgramProfileInfo> OrderBy (IQueryable<EduProgramProfileInfo> source)
{
return source.OrderBy (epp => epp.EduProgram.EduLevel.SortIndex)
.ThenBy (epp => epp.EduProgram.Code)
.ThenBy (epp => epp.EduProgram.Title)
.ThenBy (epp => epp.ProfileCode)
.ThenBy (epp => epp.ProfileTitle)
.ThenBy (epp => epp.EduLevel.SortIndex);
}
// GET: GetListUserList
public PartialViewResult GetListUsers(string SortOrder, string CurrentFilter, string SearchString, int? Page = 1)
{
int pageSize = 10;
ViewBag.CurrentSort = SortOrder;
ViewBag.NameSortParm = String.IsNullOrEmpty(SortOrder) ? "Name_desc" : "";
ViewBag.UsernameSortParm = SortOrder == "Username" ? "Username_desc" : "Username";
ViewBag.EmailSortParm = SortOrder == "Email" ? "Email_desc" : "Email";
if (SearchString != null)
{
Page = 1;
}
else
{
SearchString = CurrentFilter;
}
ViewBag.CurrentFilter = SearchString;
UserList = UOW.UserRepository.Get();
if (!String.IsNullOrEmpty(SearchString))
{
UserList = UserList.Where(s => s.Name.Contains(SearchString)
|| s.Username.Contains(SearchString)
|| s.EmailAdress.Contains(SearchString));
}
ViewBag.Count = UserList.Count();
switch (SortOrder)
{
case "Name_desc":
UserList = UserList.OrderByDescending(s => s.Name);
break;
case "Username":
UserList = UserList.OrderBy(s => s.Username);
break;
case "Username_desc":
UserList = UserList.OrderByDescending(s => s.Username);
break;
case "Email":
UserList = UserList.OrderBy(s => s.EmailAdress);
break;
case "Email_desc":
UserList = UserList.OrderByDescending(s => s.EmailAdress);
break;
default:
UserList = UserList.OrderBy(s => s.Name);
break;
}
int pageNumber = (Page ?? 1);
return PartialView("GetListUsers",UserList.ToList().ToPagedList(pageNumber, pageSize));
}
/// <summary>
/// Private helper method set and return the sorted workouts
/// </summary>
/// <param name="workouts">The base workout query result</param>
/// <param name="sortBy">Indicates the sort order</param>
/// <param name="session">The Session object to get or set variables from/to</param>
/// <param name="viewBag">The viewBag object to pass the set variables back to the view with</param>
/// <returns>The sorted workouts</returns>
public static IQueryable<workout> doSort(IQueryable<workout> workouts, string sortBy, HttpSessionStateBase session, dynamic viewBag)
{
if (!String.IsNullOrEmpty(sortBy))
{
SessionVariableManager.setSessionFromSort(session, sortBy);
}
else
{
sortBy = SessionVariableManager.setSortFromSession(session, sortBy);
}
viewBag.NameSortParam = (sortBy == "name") ? "name_desc" : "name";
viewBag.DateSortParam = (sortBy == "date") ? "date_desc" : "date";
viewBag.CategorySortParam = (sortBy == "category") ? "category_desc" : "category";
viewBag.UserSortParam = (sortBy == "user") ? "user_desc" : "user";
viewBag.DescriptionSortParam = (sortBy == "description") ? "description_desc" : "description";
switch (sortBy)
{
case "name":
workouts = workouts.OrderBy(w => w.name);
break;
case "name_desc":
workouts = workouts.OrderByDescending(w => w.name);
break;
case "date":
workouts = workouts.OrderBy(w => w.created_at);
break;
case "date_desc":
workouts = workouts.OrderByDescending(w => w.created_at);
break;
case "category":
workouts = workouts.OrderBy(w => w.category.name);
break;
case "category_desc":
workouts = workouts.OrderByDescending(w => w.category.name);
break;
case "user":
workouts = workouts.OrderBy(w => w.user.username);
break;
case "user_desc":
workouts = workouts.OrderByDescending(w => w.user.username);
break;
case "description":
workouts = workouts.OrderBy(w => w.description);
break;
case "description_desc":
workouts = workouts.OrderByDescending(w => w.description);
break;
default:
workouts = workouts.OrderByDescending(w => w.name);
break;
}
return workouts;
}
public ASListVM(IQueryable<ASystem_Type> allTypesList,Heat_Station HS)
{
HS_No = HS.HS_ID;
HS_Adress = HS.HS_adress;
ASTypesList = new List<HSASType>();
foreach (var Type in allTypesList.OrderBy(x=>x.AST_sortOrder))
{
ASTypesList.Add(new HSASType { shortName = Type.AST_Name, longName = Type.AST_Description,HShasType = HS.ASystems.Count(x=>string.Compare(x.AS_type,Type.AST_Name)==0)>0 });
}
}
//public long CountryId;
public IQueryable<MyUser> BuildQuery(IQueryable<MyUser> query)
{
if (!string.IsNullOrWhiteSpace(UserId)) query = query.Where(q => q.Id == UserId);
if (!string.IsNullOrWhiteSpace(Email)) query = query.Where(q => q.Email.Contains(Email));
//if (CountryId > 0) query = query.Where(q => q.CountryId == CountryId);
//query = query.Where(q => q.IsActive);
if (Pager.Size > 0) query = query.OrderBy(x => x.Updated).Skip(Pager.Skip()).Take(Pager.Size);
return query;
}
public IQueryable<City> BuildQuery(IQueryable<City> query)
{
if (Id > 0) query = query.Where(q => q.Id == Id);
if (!string.IsNullOrWhiteSpace(Name)) query = query.Where(q => q.Name.Contains(Name));
if (CountryId > 0) query = query.Where(q => q.CountryId == CountryId);
query = query.Where(q => q.IsActive && !q.IsDeleted);
if (Pager.Size > 0) query = query.OrderBy(x => x.Updated).Skip(Pager.Skip()).Take(Pager.Size);
return query;
}
private IList ExportUsers(IQueryable<User> users)
{
return users.OrderBy(u => u.UserName)
.ToList()
.Select(u => new
{
u.UserName,
LastActivityDate = u.LastActivityDate.ToString("o")
}).ToList();
}
private void GetTowns(IQueryable<TOWN> towns)
{
towns
.OrderBy(t => t.ID)
.ToList()
.ForEach(t => this.Towns.Add(new Town
{
Id = t.ID,
Name = t.NAME
}));
}
public PagerModel GetPageList(PagerDataRequest dataPager, IQueryable queryPaging)
{
PagerModel pagerModel = new PagerModel();
pagerModel.TotalRows = queryPaging.Count();
#region " Filtering "
if (dataPager.Filter != null && (dataPager.Filter.Filters != null && dataPager.Filter.Filters.Count > 0))
{
//string whereCond = null;
//var param = new List<object>();
//var filters = dataPager.Filter.Filters;
//for (int i = 0; i < filters.Count; i++)
//{
// if (i == 0)
// {
// whereCond += string.Format(" {0}",)
// }
// else
// {
// }
//}
}
#endregion
#region " Sorting "
var sort = dataPager.Sort;
string sortBy = null;
for (int i = 0; i < sort.Count; i++)
{
if (i == sort.Count - 1)
{
sortBy += sortBy + string.Format("{0} {1}", sort[i].Field, sort[i].Dir);
}
else
{
sortBy += sortBy + string.Format("{0} {1}, ", sort[i].Field, sort[i].Dir);
}
}
queryPaging = queryPaging.OrderBy(sortBy);
#endregion
pagerModel.Data = queryPaging.Skip(dataPager.Skip).Take(dataPager.Take);
return pagerModel;
}
private void GetMeasures(IQueryable<MEASURE> measures)
{
measures
.OrderBy(m => m.ID)
.ToList()
.ForEach(m => this.Measures.Add(new Measure
{
Id = m.ID,
Name = m.NAME
}));
}
private void GetProductsTypes(IQueryable<PRODUCTSTYPE> productsTypes)
{
productsTypes
.OrderBy(pt => pt.ID)
.ToList()
.ForEach(pt => this.ProductsTypes.Add(new ProductType
{
Id = pt.ID,
Name = pt.NAME
}));
}
private IEnumerable <AssemblyFail> GetFails(IEnumerable <Expression <Func <AssemblyFail, bool> > > expressions)
{
IQueryable <AssemblyFail> assemblyFails = null;
foreach (var func in expressions)
{
assemblyFails = assemblyFails?.Where(func) ?? this.assemblyFailsRepository.FilterBy(func);
}
return(assemblyFails?.OrderBy(a => a.Id).ToList() ?? new List <AssemblyFail>());
}
public IEnumerable <KeyValuePair <string, string> > GetDisplayList(ServiceArgs args = null)
{
if (args != null && args.ContainsKey("RepairId") && int.TryParse(args["RepairId"].ToString(), out var repairId) && args.ContainsKey("ShopGuid") && Guid.TryParse(args["ShopGuid"].ToString(), out var shopGuid))
{
var users = Conn.Query <UserEntityModel>("Access.usp_GetUsersByRepairId", new { RepairId = repairId == 0 ? null : new int?(repairId), ShopGuid = shopGuid == Guid.Empty ? null : new Guid?(shopGuid) }, null, true, null, CommandType.StoredProcedure);
return(users.Select(x => new KeyValuePair <string, string>(x.Id.ToString(), x.GetDisplayName)));
}
return(AllowedUsers?.OrderBy(u => u.LastName).ThenBy(u => u.FirstName).AsEnumerable()
.Select(u => new KeyValuePair <string, string>(u.Id.ToString(), u.GetDisplayName)));
}
private IQueryable<Product> Sort(IQueryable<Product> products, SortField sortField, SortDirection sortDirection)
{
if (sortField == SortField.Name)
{
if (sortDirection == SortDirection.Up)
{
return products.OrderBy(o => o.Category.Name);
}
else
{
return products.OrderByDescending(o => o.Category.Name);
}
}
if (sortField == SortField.Price)
{
if (sortDirection == SortDirection.Up)
{
return products.OrderBy(o => o.Price);
}
else
{
return products.OrderByDescending(o => o.Price);
}
}
if (sortField == SortField.Title)
{
if (sortDirection == SortDirection.Up)
{
return products.OrderBy(o => o.Title);
}
else
{
return products.OrderByDescending(o => o.Title);
}
}
// Should not reach here, but return products for compiler
return products;
}
private static IQueryable<User> AddSortExpression(IQueryable<User> data, ListSortDirection
sortDirection, string memberName)
{
if (sortDirection == ListSortDirection.Ascending)
{
switch (memberName)
{
case "FirstName":
data = data.OrderBy(order => order.FirstName);
break;
case "LastName":
data = data.OrderBy(order => order.LastName);
break;
case "CountryCode":
data = data.OrderBy(order => order.CountryCode);
break;
case "Location":
data = data.OrderBy(order => order.Location);
break;
case "PositionTitle":
data = data.OrderBy(order => order.PositionTitle);
break;
case "Function":
data = data.OrderBy(order => order.FunctionalArea);
break;
}
}
else
{
switch (memberName)
{
case "FirstName":
data = data.OrderByDescending(order => order.FirstName);
break;
case "LastName":
data = data.OrderByDescending(order => order.LastName);
break;
case "CountryCode":
data = data.OrderByDescending(order => order.CountryCode);
break;
case "Location":
data = data.OrderByDescending(order => order.Location);
break;
case "PositionTitle":
data = data.OrderByDescending(order => order.PositionTitle);
break;
case "Function":
data = data.OrderByDescending(order => order.FunctionalArea);
break;
}
}
return data;
}
private void GetSupermarkets(IQueryable<SUPERMARKET> supermarkets)
{
supermarkets
.OrderBy(s => s.ID)
.ToList()
.ForEach(s => this.Supermarkets.Add(new Supermarket
{
Id = s.ID,
Name = s.NAME,
TownId = s.TOWNID
}));
}
private static IQueryable<UserModel> AddSortExpression(IQueryable<UserModel> data, ListSortDirection sortDirection, string memberName)
{
if (sortDirection == ListSortDirection.Ascending)
{
switch (memberName)
{
case "DisplayName":
data = data.OrderBy(x => x.DisplayName);
break;
case "PhoneMobile":
data = data.OrderBy(x => x.PhoneMobile);
break;
case "LastLoginDate":
data = data.OrderBy(x => x.LastLoginDate);
break;
case "Active":
data = data.OrderBy(x => x.Active);
break;
}
}
else
{
switch (memberName)
{
case "DisplayName":
data = data.OrderByDescending(x => x.DisplayName);
break;
case "PhoneMobile":
data = data.OrderByDescending(x => x.PhoneMobile);
break;
case "LastLoginDate":
data = data.OrderByDescending(x => x.LastLoginDate);
break;
case "Active":
data = data.OrderByDescending(x => x.Active);
break;
}
}
return data;
}
public IPaged <TEntity> Find(Expression <Func <TEntity, bool> > predicate, int?page, int?count)
{
var paged = new Paged <TEntity>
{
TotalItemsCount = Collection.Count(),
Page = page ?? 0,
PageCount = count ?? int.MaxValue
};
paged.Items = Collection
?.OrderBy(p => p.Id)
?.Where(predicate.Compile())
?.Skip(paged.Page * paged.PageCount)
?.Take(paged.PageCount);
return(paged);
}
private IQueryable <PlayersOfMatches> SortedPlayersOfMatchList(IQueryable <PlayersOfMatches> playersOfMatchList)
{
return(playersOfMatchList?
.OrderBy(x => x.PlayingStatus == 3)
.ThenBy(x => x.PlayingStatus == 0)
.ThenBy(x => x.PlayingStatus == 2)
.ThenBy(x => x.PlayingStatus == 1)
.ThenByDescending(x => x.Position == "GK")
.ThenBy(x => x.Number == null)
.ThenBy(x => x.Number)
.ThenBy(x => x.Position == null)
.ThenBy(x => x.Position == "ATT")
.ThenBy(x => x.Position == "MID")
.ThenBy(x => x.Position == "DEF")
.ThenBy(x => x.Position == "GK")
.ThenBy(x => x.FirstName)
.ThenBy(x => x.Lastname));
}
public ActionResult Grid()
{
var skip = 0;
var pageSize = 0;
var total = 0;
// get IQueryable instance
var query = _repo.Users.Fetch();
total = query.Count();
// apply Grid Orders and Filters
IQueryable <User> users = KendoGrid <User> .GridQueryable(query, Request, out skip, out pageSize);
// apply additional conditions if any
// ordery by if request has no sortby
if (string.IsNullOrEmpty(KendoGrid <object> .OrderByExistInRequest(Request)))
{
users = users?.OrderBy(o => o.Name);
}
// pagination conditions
users = users?.Skip(skip).Take(pageSize);
// format data according to grid frontend
var data = users?.ToList().Select(d => new
{
Id = d.Id,
Name = d.Name,
Email = d.Email,
ActionLink = KendoGrid <object> .GenerateButtons("Users", d.Id, true, true, false)
});
//return Json(data, JsonRequestBehavior.AllowGet);
return(Json(new { total, data }, JsonRequestBehavior.AllowGet));
}
private IQueryable <WarehouseDAO> DynamicOrder(IQueryable <WarehouseDAO> query, WarehouseFilter filter)
{
switch (filter.OrderType)
{
case OrderType.ASC:
switch (filter.OrderBy)
{
case WarehouseOrder.Id:
query = query.OrderBy(q => q.Id);
break;
case WarehouseOrder.Code:
query = query.OrderBy(q => q.Code);
break;
case WarehouseOrder.Name:
query = query.OrderBy(q => q.Name);
break;
case WarehouseOrder.Address:
query = query.OrderBy(q => q.Address);
break;
case WarehouseOrder.Organization:
query = query.OrderBy(q => q.OrganizationId);
break;
case WarehouseOrder.Province:
query = query.OrderBy(q => q.ProvinceId);
break;
case WarehouseOrder.District:
query = query.OrderBy(q => q.DistrictId);
break;
case WarehouseOrder.Ward:
query = query.OrderBy(q => q.WardId);
break;
case WarehouseOrder.Status:
query = query.OrderBy(q => q.StatusId);
break;
}
break;
case OrderType.DESC:
switch (filter.OrderBy)
{
case WarehouseOrder.Id:
query = query.OrderByDescending(q => q.Id);
break;
case WarehouseOrder.Code:
query = query.OrderByDescending(q => q.Code);
break;
case WarehouseOrder.Name:
query = query.OrderByDescending(q => q.Name);
break;
case WarehouseOrder.Address:
query = query.OrderByDescending(q => q.Address);
break;
case WarehouseOrder.Organization:
query = query.OrderByDescending(q => q.OrganizationId);
break;
case WarehouseOrder.Province:
query = query.OrderByDescending(q => q.ProvinceId);
break;
case WarehouseOrder.District:
query = query.OrderByDescending(q => q.DistrictId);
break;
case WarehouseOrder.Ward:
query = query.OrderByDescending(q => q.WardId);
break;
case WarehouseOrder.Status:
query = query.OrderByDescending(q => q.StatusId);
break;
}
break;
}
query = query.Skip(filter.Skip).Take(filter.Take);
return(query);
}
private void BindGrid()
{
string type = PageParameter("SearchType");
string term = PageParameter("SearchTerm");
if (!String.IsNullOrWhiteSpace(type) && !String.IsNullOrWhiteSpace(term))
{
using (var rockContext = new RockContext())
{
var personService = new PersonService(rockContext);
IQueryable <Person> people = null;
switch (type.ToLower())
{
case ("name"):
{
bool allowFirstNameOnly = false;
if (!bool.TryParse(PageParameter("allowFirstNameOnly"), out allowFirstNameOnly))
{
allowFirstNameOnly = false;
}
people = personService.GetByFullName(term, allowFirstNameOnly, true);
break;
}
case ("phone"):
{
var phoneService = new PhoneNumberService(rockContext);
var personIds = phoneService.GetPersonIdsByNumber(term);
people = personService.Queryable().Where(p => personIds.Contains(p.Id));
break;
}
case ("address"):
{
var groupMemberService = new GroupMemberService(rockContext);
var personIds2 = groupMemberService.GetPersonIdsByHomeAddress(term);
people = personService.Queryable().Where(p => personIds2.Contains(p.Id));
break;
}
case ("email"):
{
people = personService.Queryable().Where(p => p.Email.Contains(term));
break;
}
}
SortProperty sortProperty = gPeople.SortProperty;
if (sortProperty != null)
{
people = people.Sort(sortProperty);
}
else
{
people = people.OrderBy(p => p.LastName).ThenBy(p => p.FirstName);
}
var personList = people.ToList();
if (personList.Count == 1)
{
Response.Redirect(string.Format("~/Person/{0}", personList[0].Id), false);
Context.ApplicationInstance.CompleteRequest();
}
else
{
if (type.ToLower() == "name")
{
var similiarNames = personService.GetSimiliarNames(term,
personList.Select(p => p.Id).ToList(), true);
if (similiarNames.Any())
{
var hyperlinks = new List <string>();
foreach (string name in similiarNames.Distinct())
{
var pageRef = CurrentPageReference;
pageRef.Parameters["SearchTerm"] = name;
hyperlinks.Add(string.Format("<a href='{0}'>{1}</a>", pageRef.BuildUrl(), name));
}
string altNames = string.Join(", ", hyperlinks);
nbNotice.Text = string.Format("Other Possible Matches: {0}", altNames);
nbNotice.Visible = true;
}
}
_inactiveStatus = DefinedValueCache.Read(Rock.SystemGuid.DefinedValue.PERSON_RECORD_STATUS_INACTIVE);
gPeople.DataSource = personList;
gPeople.DataBind();
}
}
}
}
// GET: Home
public ActionResult Index(string restaurantName, string sortColumn, string direction, int pageIndex = 1, int categoryID = 0)
{
RestaurantsS1Entities dbContext = new RestaurantsS1Entities();
List <Category> allCategories = dbContext.Categories.ToList();
ViewBag.AllCategories = new SelectList(allCategories, "ID", "Name", categoryID);
IQueryable <Restaurant> records = dbContext.Restaurants.AsQueryable();
//first filter the results
if (string.IsNullOrEmpty(restaurantName) == false)
{
records = records.Where(r => r.Name.Contains(restaurantName));
}
if (categoryID != 0)
{
records = records.Where(r => r.CategoryID == categoryID);
}
//then sort by the specified column
string sortColDirection = sortColumn + direction;
switch (sortColDirection)
{
case "Category":
records = records.OrderBy(r => r.Category.Name);
break;
case "CategoryDesc":
records = records.OrderByDescending(r => r.Category.Name);
break;
case "City":
records = records.OrderBy(r => r.City.Name);
break;
case "CityDesc":
records = records.OrderByDescending(r => r.City.Name);
break;
case "NameDesc":
records = records.OrderByDescending(r => r.Name);
break;
default:
records = records.OrderBy(r => r.Name);
break;
}
//convert the IQueryable list to list (i.e. retrieve the data from the database)
//List<Restaurant> list = records.ToList(); //old
List <Restaurant> list = records
.Skip((pageIndex - 1) * SearchViewModel.PageSize)
.Take(SearchViewModel.PageSize)
.ToList();
int allRecordsCount = records.Count(); //
//create the view model
//SearchViewModel viewModel = new SearchViewModel(list); //old
SearchViewModel viewModel = new SearchViewModel(list, pageIndex, allRecordsCount);
viewModel.LastSortColumn = sortColumn;
viewModel.LastSortDirection = direction;
return(View(viewModel));
}
// GET: InventoryItems
public ActionResult Index(string sort, string search, int?page)
{
ViewBag.CategorySort = String.IsNullOrEmpty(sort) ? "category_desc" : String.Empty;
ViewBag.ItemCodeSort = sort == "itemcode" ? "itemcode_desc" : "itemcode";
ViewBag.NameSort = sort == "name" ? "name_desc" : "name";
ViewBag.UnitPriceSort = sort == "unitprice" ? "unitprice_desc" : "unitprice";
ViewBag.CurrentSort = sort;
ViewBag.CurrentSearch = search;
IQueryable <InventoryItem> inventoryItems = _applicationDbContext.InventoryItems.Include(i => i.Category);
if (!string.IsNullOrEmpty(search))
{
inventoryItems = inventoryItems
.Where(ii => ii.InventoryItemCode.StartsWith(search) ||
ii.InventoryItemName.StartsWith(search));
}
switch (sort)
{
case "category_desc":
inventoryItems = inventoryItems
.OrderByDescending(ii => ii.Category.CategoryName)
.ThenBy(ii => ii.InventoryItemName);
break;
case "itemcode":
inventoryItems = inventoryItems
.OrderBy(ii => ii.InventoryItemCode);
break;
case "itemcode_desc":
inventoryItems = inventoryItems
.OrderByDescending(ii => ii.InventoryItemCode);
break;
case "name":
inventoryItems = inventoryItems
.OrderBy(ii => ii.InventoryItemName);
break;
case "name_desc":
inventoryItems = inventoryItems
.OrderByDescending(ii => ii.InventoryItemName);
break;
case "unitprice":
inventoryItems = inventoryItems
.OrderBy(ii => ii.UnitPrice);
break;
case "unitprice_desc":
inventoryItems = inventoryItems
.OrderByDescending(ii => ii.UnitPrice);
break;
default:
inventoryItems = inventoryItems
.OrderBy(ii => ii.Category.CategoryName)
.ThenBy(ii => ii.InventoryItemName);
break;
}
int pageSIze = 3;
int pageNumber = page ?? 1;
return(View(inventoryItems.ToPagedList(pageNumber, pageSIze)));
}
public async Task <ListViewModel <CourseViewModel> > GetCoursesAsync(CourseListInputModel model)
{
IQueryable <Course> baseQuery = dbContext.Courses;
switch (model.OrderBy)
{
case "Title":
if (model.Ascending)
{
baseQuery = baseQuery.OrderBy(course => course.Title);
}
else
{
baseQuery = baseQuery.OrderByDescending(course => course.Title);
}
break;
case "Rating":
if (model.Ascending)
{
baseQuery = baseQuery.OrderBy(course => course.Rating);
}
else
{
baseQuery = baseQuery.OrderByDescending(course => course.Rating);
}
break;
case "CurrentPrice":
if (model.Ascending)
{
baseQuery = baseQuery.OrderBy(course => course.CurrentPrice.Amount);
}
else
{
baseQuery = baseQuery.OrderByDescending(course => course.CurrentPrice.Amount);
}
break;
}
IQueryable <CourseViewModel> queryLinq = baseQuery
//.Where(course => course.Title.Contains(model.Search))
.Where(course => EF.Functions.Like(course.Title, $"%{model.Search}%"))
.AsNoTracking()
.Select(course =>
new CourseViewModel
{
Id = course.Id,
Title = course.Title,
ImagePath = course.ImagePath,
Author = course.Author,
Rating = course.Rating,
CurrentPrice = course.CurrentPrice,
FullPrice = course.FullPrice
});
List <CourseViewModel> courses = await queryLinq
.Skip(model.Offset)
.Take(model.Limit)
.ToListAsync();
int totalCount = await queryLinq.CountAsync();
ListViewModel <CourseViewModel> results = new ListViewModel <CourseViewModel>
{
Results = courses,
TotalCount = totalCount
};
return(results);
}
protected override IQueryable <User> ApplySorting(IQueryable <User> query, PagedResultRequestDto input)
{
return(query.OrderBy(r => r.UserName));
}
protected override IQueryable <Role> ApplySorting(IQueryable <Role> query, PagedRoleResultRequestDto input)
{
return(query.OrderBy(r => r.DisplayName));
}
public static IQueryable <T> ApplySort <T>(this IQueryable <T> source, string orderBy,
Dictionary <string, PropertyMappingValue> mappingDictionary)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (mappingDictionary == null)
{
throw new ArgumentNullException(nameof(mappingDictionary));
}
if (string.IsNullOrWhiteSpace(orderBy))
{
return(source);
}
// the orderBy string is separated by ",", so we split it.
string[] orderByAfterSplit = orderBy.Split(',');
// apply each orderby clause in reverse order - otherwise, the IQueryable will be ordered in the wrong order
foreach (string orderByClause in orderByAfterSplit.Reverse())
{
// trim the orderByClause, as it might contain leading or trailing spaces. Can't trim the var in foreach,
// so use another var.
string trimmedOrderByClause = orderByClause.Trim();
// if the sort option ends with with " desc", we order descending, otherwise ascending
bool orderDescending = trimmedOrderByClause.EndsWith(" desc");
// remove " asc" or " desc" from the orderByClause, so we get the property name to look for in the
// mapping dictionary
int indexOfFirstSpace = trimmedOrderByClause.IndexOf(" ", StringComparison.Ordinal);
string propertyName = indexOfFirstSpace == -1 ?
trimmedOrderByClause : trimmedOrderByClause.Remove(indexOfFirstSpace);
// find the matching property
if (!mappingDictionary.ContainsKey(propertyName))
{
throw new ArgumentException($"Key mapping for {propertyName} is missing");
}
// get the PropertyMappingValue
PropertyMappingValue propertyMappingValue = mappingDictionary[propertyName];
if (propertyMappingValue == null)
{
throw new ArgumentNullException(nameof(propertyMappingValue));
}
// Run through the property names in reverse so the orderby clauses are applied in the correct order
foreach (string destinationProperty in propertyMappingValue.DestinationProperties.Reverse())
{
// revert sort order if necessary
if (propertyMappingValue.Revert)
{
orderDescending = !orderDescending;
}
source = source.OrderBy(destinationProperty + (orderDescending ? " descending" : " ascending"));
}
}
return(source);
}
public List <OrderSnapshot> FindByCriteriaPaged(OrderSearchCriteria criteria, int pageNumber, int pageSize, ref int rowCount)
{
List <OrderSnapshot> result = new List <OrderSnapshot>();
if (pageNumber < 1)
{
pageNumber = 1;
}
int take = pageSize;
int skip = (pageNumber - 1) * pageSize;
IQueryable <Data.EF.bvc_Order> items = repository.Find()
.Where(y => y.StoreId == context.CurrentStore.Id)
.Where(y => y.TimeOfOrder >= criteria.StartDateUtc &&
y.TimeOfOrder <= criteria.EndDateUtc);
// Order Number
if (criteria.OrderNumber != string.Empty)
{
items = items.Where(y => y.OrderNumber == criteria.OrderNumber);
}
// Is Placed
items = items.Where(y => y.IsPlaced == (criteria.IsPlaced ? 1 : 0));
// Status Code
if (criteria.StatusCode != string.Empty)
{
items = items.Where(y => y.StatusCode == criteria.StatusCode);
}
// Affiliate Id
if (criteria.AffiliateId != string.Empty)
{
items = items.Where(y => y.AffiliateId == criteria.AffiliateId);
}
// Payment Status
if (criteria.PaymentStatus != OrderPaymentStatus.Unknown)
{
int tempPay = (int)criteria.PaymentStatus;
items = items.Where(y => y.PaymentStatus == tempPay);
}
// Shipping Status
if (criteria.ShippingStatus != OrderShippingStatus.Unknown)
{
int tempShip = (int)criteria.ShippingStatus;
items = items.Where(y => y.ShippingStatus == tempShip);
}
// Keyword (most expensive operation)
if (criteria.Keyword != string.Empty)
{
items = items.Where(y => y.OrderNumber.Contains(criteria.Keyword) ||
y.UserEmail.Contains(criteria.Keyword) ||
y.BillingAddress.Contains(criteria.Keyword) ||
y.ShippingAddress.Contains(criteria.Keyword));
}
// return total item count;
var counter = items.Count();
rowCount = counter;
if (criteria.SortDescending)
{
var paged = items.OrderByDescending(y => y.Id).Skip(skip).Take(take);
return(ListPocoSnapshot(paged));
}
else
{
var paged2 = items.OrderBy(y => y.Id).Skip(skip).Take(take);
return(ListPocoSnapshot(paged2));
}
}
public async Task OnGetAsync(string sortOrder, string searchString, int?companyFilter, string datePeriodFilter
, bool filtersVisible, bool rowSelectorsVisible, int?pageIndex, int?pageSize)
{
LoadFilters();
FiltersVisible = filtersVisible;
RowSelectorsVisible = rowSelectorsVisible;
PageSize = (int)((pageSize == null || pageSize == 0) ? 20 : pageSize);
CurrentPageSize = PageSize;
CompanyFilter = (int)(companyFilter ?? 0);
CurrentSort = sortOrder;
NameSort = sortOrder == "Name" ? "name_desc" : "Name";
DateSort = sortOrder == "Date" ? "date_desc" : "Date";
if (searchString != null)
{
pageIndex = 1;
}
else
{
searchString = CurrentFilter;
}
CurrentFilter = searchString;
CurrentDatePeriod = datePeriodFilter;
IQueryable <WarehouseTransaction> fullListIq = from s in _context.WarehouseTransactions
select s;
if (companyFilter > 0)
{
fullListIq = fullListIq.Where(p => p.CompanyId == companyFilter);
}
DateTime fromDate = new DateTime(DateTime.Now.Year, DateTime.Now.Month, 1);
DateTime toDate = DateTime.Now;
switch (datePeriodFilter)
{
case "CURMONTH":
fromDate = new DateTime(DateTime.Now.Year, DateTime.Now.Month, 1);
toDate = DateTime.Now;
break;
case "30DAYS":
toDate = DateTime.Now;
fromDate = toDate.AddDays(-30);
break;
case "60DAYS":
toDate = DateTime.Now;
fromDate = toDate.AddDays(-60);
break;
case "360DAYS":
toDate = DateTime.Now;
fromDate = toDate.AddDays(-360);
break;
case "CURYEAR":
break;
default:
fromDate = new DateTime(DateTime.Now.Year, DateTime.Now.Month, 1);
toDate = DateTime.Now;
CurrentDatePeriod = "CURMONTH";
break;
}
fullListIq = fullListIq.Where(p => p.TransDate >= fromDate && p.TransDate <= toDate);
if (!String.IsNullOrEmpty(searchString))
{
fullListIq = fullListIq.Where(s => s.WarehouseItem.Name.Contains(searchString));
}
switch (sortOrder)
{
case "Date":
fullListIq = fullListIq.OrderBy(p => p.TransDate);
DateSortIcon = "fas fa-sort-numeric-up ";
NameSortIcon = "invisible";
break;
case "date_desc":
fullListIq = fullListIq.OrderByDescending(p => p.TransDate);
DateSortIcon = "fas fa-sort-numeric-down ";
NameSortIcon = "invisible";
break;
case "Name":
fullListIq = fullListIq.OrderBy(p => p.WarehouseItem.Name);
NameSortIcon = "fas fa-sort-alpha-up ";
DateSortIcon = "invisible";
break;
case "name_desc":
fullListIq = fullListIq.OrderByDescending(p => p.WarehouseItem.Name);
NameSortIcon = "fas fa-sort-alpha-down ";
DateSortIcon = "invisible";
break;
default:
fullListIq = fullListIq.OrderBy(p => p.Id);
break;
}
var t = fullListIq.ProjectTo <WarehouseTransListDto>(_mapper.ConfigurationProvider);
ListItems = await PagedList <WarehouseTransListDto> .CreateAsync(
t, pageIndex ?? 1, PageSize);
SumImportVolume = ListItems.Sum(p => p.InvoicedImportUnits);
SumImportValue = ListItems.Sum(p => p.InvoicedImportAmount);
SumExportVolume = ListItems.Sum(p => p.InvoicedExportUnits);
SumExportValue = ListItems.Sum(p => p.InvoicedExportAmount);
}
public IQueryable <Company> GetAll()
{
IQueryable <Company> Result = base.All();
return(Result.OrderBy(o => o.SN));
}
protected override IQueryable <Country> ApplySorting(IQueryable <Country> query, CountryInputDto input)
{
return(query.OrderBy(x => x.Name));
}
protected override IOrderedQueryable <FAT_PARAMETRO_NFS> Ordenar(IQueryable <FAT_PARAMETRO_NFS> query)
{
return(query.OrderBy(e => e.id));
}
public static IOrderedQueryable <T> MyOrderBy <T, TKey>(this IQueryable <T> qry, Expression <Func <T, TKey> > expr)
{
return(qry.OrderBy(expr));
}
public async Task OnGetAsync(string sortOrder, string currentFilter, string searchString, int?pageIndex)
{
CurrentSort = sortOrder;
BookSort = String.IsNullOrEmpty(sortOrder) ? "book_desc" : "Book";
DateSort = sortOrder == "Date" ? "date_desc" : "Date";
if (searchString != null)
{
pageIndex = 1;
}
else
{
searchString = currentFilter;
}
IQueryable <Scripture> scriptures = from s in _context.Scripture
select s;
IQueryable <string> bookQuery = from sc in _context.Scripture
orderby sc.Book
select sc.Book;
switch (sortOrder)
{
case "Book":
scriptures = scriptures.OrderBy(s => s.Book);
break;
case "book_desc":
scriptures = scriptures.OrderByDescending(s => s.Book);
break;
case "Date":
scriptures = scriptures.OrderBy(s => s.Date);
break;
case "date_desc":
scriptures = scriptures.OrderByDescending(s => s.Date);
break;
default:
scriptures = scriptures.OrderBy(s => s.Book);
break;
}
if (!string.IsNullOrEmpty(SearchString))
{
scriptures = scriptures.Where(s => s.Note.Contains(SearchString));
}
if (!string.IsNullOrEmpty(ScriptureNote))
{
scriptures = scriptures.Where(x => x.Book == ScriptureNote);
}
int pageSize = 5;
Scripture = await PaginatedList <Scripture> .CreateAsync(
scriptures.AsNoTracking(), pageIndex ?? 1, pageSize);
Book = new SelectList(await bookQuery.Distinct().ToListAsync());
/* Scripture = await scriptures.ToListAsync(); */
}
public override Tuple <List <Vat>, int, Dictionary <string, string>, List <string> > ReadModel(int Page = 1, int Size = 25, string Order = "{}", List <string> Select = null, string Keyword = null, string Filter = "{}")
{
IQueryable <Vat> Query = this.DbContext.Vat;
Dictionary <string, object> FilterDictionary = JsonConvert.DeserializeObject <Dictionary <string, object> >(Filter);
Query = ConfigureFilter(Query, FilterDictionary);
Dictionary <string, string> OrderDictionary = JsonConvert.DeserializeObject <Dictionary <string, string> >(Order);
/* Search With Keyword */
if (Keyword != null)
{
List <string> SearchAttributes = new List <string>()
{
"Name", "COACodeCredit"
};
Query = Query.Where(General.BuildSearch(SearchAttributes), Keyword);
}
/* Const Select */
List <string> SelectedFields = new List <string>()
{
"Id", "Name", "Rate", "COACodeCredit", "Date"
};
Query = Query
.Select(b => new Vat
{
Id = b.Id,
Name = b.Name,
Rate = b.Rate,
COACodeCredit = b.COACodeCredit,
Date = b.Date
});
/* Order */
if (OrderDictionary.Count.Equals(0))
{
OrderDictionary.Add("_updatedDate", General.DESCENDING);
Query = Query.OrderByDescending(b => b._LastModifiedUtc); /* Default Order */
}
else
{
string Key = OrderDictionary.Keys.First();
string OrderType = OrderDictionary[Key];
string TransformKey = General.TransformOrderBy(Key);
BindingFlags IgnoreCase = BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance;
Query = OrderType.Equals(General.ASCENDING) ?
Query.OrderBy(b => b.GetType().GetProperty(TransformKey, IgnoreCase).GetValue(b)) :
Query.OrderByDescending(b => b.GetType().GetProperty(TransformKey, IgnoreCase).GetValue(b));
}
/* Pagination */
Pageable <Vat> pageable = new Pageable <Vat>(Query, Page - 1, Size);
List <Vat> Data = pageable.Data.ToList <Vat>();
int TotalData = pageable.TotalCount;
SetCache();
return(Tuple.Create(Data, TotalData, OrderDictionary, SelectedFields));
}
public static IQueryable <TEntity> Sort <TEntity>(
this IQueryable <TEntity> queryable,
SortOrder <TEntity> sortOrder)
=> sortOrder.Order == SortOrder <TEntity> .Descending
? queryable.OrderByDescending(sortOrder.ToExpression())
: queryable.OrderBy(sortOrder.ToExpression());
public IEnumerable <T> GetPagedList(out int totalCount, int?page = null, int?pageSize = null,
Expression <Func <T, bool> > filter = null, string[] includePaths = null,
params SortExpression <T>[] sortExpressions)
{
IQueryable <T> query = _dbContext.Set <T>();
if (filter != null)
{
query = _dbContext.Set <T>().Where(filter);
}
totalCount = query.Count();
if (includePaths != null)
{
for (var i = 0; i < includePaths.Count(); i++)
{
query = query.Include(includePaths[i]);
}
}
if (sortExpressions != null)
{
IOrderedQueryable <T> orderedQuery = null;
for (var i = 0; i < sortExpressions.Count(); i++)
{
if (i == 0)
{
if (sortExpressions[i].SortDirection == ListSortDirection.Ascending)
{
orderedQuery = query.OrderBy(sortExpressions[i].SortBy);
}
else
{
orderedQuery = query.OrderByDescending(sortExpressions[i].SortBy);
}
}
else
{
if (sortExpressions[i].SortDirection == ListSortDirection.Ascending)
{
orderedQuery = orderedQuery.ThenBy(sortExpressions[i].SortBy);
}
else
{
orderedQuery = orderedQuery.ThenByDescending(sortExpressions[i].SortBy);
}
}
}
if (page != null)
{
query = orderedQuery.Skip(((int)page - 1) * (int)pageSize);
}
}
if (pageSize != null)
{
query = query.Take((int)pageSize);
}
return(query.ToList());
}
// GET: Devices
public async Task <ActionResult> Index(string sortOrder, string currentFilter, string searchString, int?page)
{
ViewBag.NameSortParm = String.IsNullOrEmpty(sortOrder) ? "Name_desc" : "";
ViewBag.IMEISortParm = sortOrder == "IMEI" ? "IMEI_desc" : "IMEI";
ViewBag.SerialNoSortParm = sortOrder == "SerialNo" ? "SerialNo_desc" : "SerialNo";
ViewBag.StatusSortParm = sortOrder == "Status" ? "Status_desc" : "Status";
IQueryable <DeviceViewModel> devicesData = from devices in db.Devices.Include(d => d.DeviceStatus)
select new DeviceViewModel()
{
DeviceID = devices.DeviceID,
Name = devices.Name,
IMEI = devices.IMEI,
SerialNo = devices.SerialNo,
Status = devices.DeviceStatus.Status
};
//Paging
if (searchString != null)
{
page = 1;
}
else
{
searchString = currentFilter;
}
ViewBag.CurrentFilter = searchString;
//Filtering
if (!String.IsNullOrEmpty(searchString))
{
devicesData = devicesData.Where
(s => s.IMEI.ToString().ToUpper().Contains(searchString.ToUpper()) ||
s.SerialNo.ToString().ToUpper().Contains(searchString.ToUpper())
);
}
switch (sortOrder)
{
case "Name_desc":
devicesData = devicesData.OrderByDescending(s => s.Name);
break;
case "IMEI":
devicesData = devicesData.OrderBy(s => s.IMEI);
break;
case "IMEI_desc":
devicesData = devicesData.OrderByDescending(s => s.IMEI);
break;
case "SerialNo":
devicesData = devicesData.OrderBy(s => s.SerialNo);
break;
case "SerialNo_desc":
devicesData = devicesData.OrderByDescending(s => s.SerialNo);
break;
case "Status":
devicesData = devicesData.OrderBy(s => s.Status);
break;
case "Status_desc":
devicesData = devicesData.OrderByDescending(s => s.Status);
break;
default:
devicesData = devicesData.OrderBy(s => s.Name);
break;
}
int pageSize = 15;
int pageNumber = (page ?? 1);
return(View(await devicesData.ToPagedListAsync(pageNumber, pageSize)));
}
public static Page <User> Search(long pageSize = 3, long pageIndex = 1, UserSortOrder orderBy = UserSortOrder.UserName, SortOrder sortOrder = SortOrder.Ascending, Role?role = null, string keyword = "")
{
Page <User> result = new Page <User>();
if (pageSize < 1)
{
pageSize = 1;
}
IQueryable <User> userQuery = (IQueryable <User>)db.Users;
if (role != null)
{
userQuery = userQuery.Where(u => u.Role == role.Value);
}
if (string.IsNullOrEmpty(keyword) == false)
{
userQuery = userQuery.Where(u => u.FirstName.Contains(keyword) ||
u.LastName.Contains(keyword) ||
u.UserName.Contains(keyword));
}
long queryCount = userQuery.Count();
int pageCount = (int)Math.Ceiling((decimal)(queryCount / pageSize));
long mod = (queryCount % pageSize);
if (mod > 0)
{
pageCount = pageCount + 1;
}
int skip = (int)(pageSize * (pageIndex - 1));
List <User> users = new List <User>();
if (sortOrder == SortOrder.Ascending && orderBy == UserSortOrder.UserName)
{
users = userQuery.OrderBy(u => u.UserName).ToList();
}
else if (sortOrder == SortOrder.Descending && orderBy == UserSortOrder.UserName)
{
users = userQuery.OrderByDescending(u => u.UserName).ToList();
}
else if (sortOrder == SortOrder.Ascending && orderBy == UserSortOrder.FirstName)
{
users = userQuery.OrderBy(u => u.FirstName).ToList();
}
else if (sortOrder == SortOrder.Descending && orderBy == UserSortOrder.FirstName)
{
users = userQuery.OrderByDescending(u => u.FirstName).ToList();
}
else if (sortOrder == SortOrder.Ascending && orderBy == UserSortOrder.LastName)
{
users = userQuery.OrderBy(u => u.LastName).ToList();
}
else if (sortOrder == SortOrder.Descending && orderBy == UserSortOrder.LastName)
{
users = userQuery.OrderByDescending(u => u.LastName).ToList();
}
result.Items = users.Skip(skip).Take((int)pageSize).ToList();
result.PageCount = pageCount;
result.PageSize = pageSize;
result.QueryCount = queryCount;
return(result);
}
/// <summary>
/// It's do sorting, paging and filtering
/// </summary>
public static IQueryable <T> SPF <T>(this IQueryable <T> query,
SPFInputDto model, out long totalRecord)
{
// اعمال فیلتر
if (!string.IsNullOrWhiteSpace(model.SearchTerm))
{
var searchTerm = model.SearchTerm.Trim().ToLower();
var searchQ = string.Empty;
var objectProperties = typeof(T).GetProperties();
var objPropertiesLength = objectProperties.Length;
var objPropertiesName = new string[objPropertiesLength];
// بیرون کشیدن نام پراپرتی ها
for (var i = 0; i < objPropertiesLength; i++)
{
objPropertiesName[i] = objectProperties[i].Name;
}
for (var i = 0; i < objPropertiesLength; i++)
{
// بررسی نوع داده
if (objectProperties[i].IsStringType())
{
searchQ +=
$"({objPropertiesName[i]} != null && " +
$"{objPropertiesName[i]}.ToLower().Contains" +
$"(\"{searchTerm}\")) || ";
}
else
{
// اگر نوع عددی نبود برو به ابتدای حلقه
if (!objectProperties[i].IsNumericType())
{
continue;
}
// آیا نوع اعشاری هست؟
if (objectProperties[i].IsDecimalType())
{
// اگر سرچ قابل تبدیل به اعشاری بود، آن را تبدیل کن
if (decimal.TryParse(searchTerm,
out decimal parsedSearchTerm))
{
searchQ +=
$"{objPropertiesName[i]} == " +
$"{parsedSearchTerm} || ";
}
}
else
{
// اگر سرچ قابل تبدیل به عددی بود، آن را تبدیل کن
if (long.TryParse(searchTerm,
out var parsedSearchTerm))
{
searchQ +=
$"{objPropertiesName[i]} == " +
$"{parsedSearchTerm} || ";
}
}
}
}
// حذف 4 کاراکتر اضافی انتهای سرچ تولید شده
searchQ = searchQ.Remove(searchQ.Length - 4);
// اعمال سرچ
query = query.Where(searchQ);
}
// اعمال سورت روی اطلاعات
if (!string.IsNullOrWhiteSpace(model.SortColumnName))
{
var sortTypeStr =
model.SortType == SortType.Asc ? "ASC" : "DESC";
query = query?.OrderBy($"{model.SortColumnName} {sortTypeStr}");
}
totalRecord = query.LongCount();
// صفحه بندی
query = query.ToList()
.Skip((model.PageNumber - 1) * model.PageSize)
.Take(model.PageSize)
.AsQueryable();
return(query);
}
private int?ResolvePersonId(Payer payer)
{
// take a pushpay payer and find or create a touchpoint person
bool hasKey = payer.Key.HasValue();
bool hasEmail = payer.emailAddress.HasValue();
bool hasMobileNumber = payer.mobileNumber.HasValue();
bool hasFirstAndLastName = payer.firstName.HasValue() && payer.lastName.HasValue();
if (!hasKey &&
!hasEmail &&
!hasMobileNumber &&
!hasFirstAndLastName)
{
// can't resolve - typically due to an anonymous donation
return(null);
}
IQueryable <Person> people = db.People.AsQueryable();
// first look for an already established person link
int?PersonId = null;
if (hasKey)
{
PersonId = db.PeopleExtras.Where(p => p.Field == PushPayKey && p.Data == payer.Key).Select(p => p.PeopleId).SingleOrDefault();
if (PersonId.HasValue && PersonId != 0)
{
return(PersonId);
}
}
IQueryable <Person> result = null;
Func <bool> hasResults = delegate() { return(result != null && result.Any()); };
if (hasEmail && hasFirstAndLastName)
{
result = people.Where(p => p.EmailAddress == payer.emailAddress &&
p.FirstName == payer.firstName && p.LastName == payer.lastName);
}
if (hasEmail && !hasResults())
{
result = people.Where(p => p.EmailAddress == payer.emailAddress);
}
var cellPhone = payer.mobileNumber.GetDigits();
if (hasMobileNumber && hasFirstAndLastName && !hasResults())
{
result = people.Where(p => p.CellPhone == cellPhone &&
p.FirstName == payer.firstName && p.LastName == payer.lastName);
}
if (hasMobileNumber && !hasResults())
{
result = people.Where(p => p.CellPhone == cellPhone);
}
if (hasFirstAndLastName && !hasResults())
{
result = people.Where(p => p.FirstName == payer.firstName && p.LastName == payer.lastName);
}
if (hasResults())
{
PersonId = result.OrderBy(p => p.CreatedDate).Select(p => p.PeopleId).First();
}
else
{
Person person = Person.Add(db, null, payer.firstName, null, payer.lastName, null);
person.EmailAddress = payer.emailAddress;
person.CellPhone = payer.mobileNumber;
person.Comments = "Added in context of PushPayImport because record was not found";
db.SubmitChanges();
PersonId = person.PeopleId;
}
// add extra value
if (payer.Key.HasValue())
{
db.AddExtraValueDataIfNotExist(PersonId, PushPayKey, null, null, payer.Key, null, null);
}
return(PersonId);
}
public static IQueryable <TSource> OrderBy <TSource, TKey>(this IQueryable <TSource> source, Func <TSource, TKey> keySelector, SortingDirection direction)
{
return(direction == SortingDirection.Ascending ? source.OrderBy(keySelector).AsQueryable() : source.OrderByDescending(keySelector).AsQueryable());
}
public IActionResult Index(int id, int page = 1, SortState sortOrder = SortState.OrderIdAsc)
{
int pageSize = 10;
IQueryable <Order> source = db.Orders.Include(p => p.Product);
if (id != 0)
{
source = source.Where(p => p.Id == id);
}
switch (sortOrder)
{
case SortState.OrderIdDec:
source = source.OrderByDescending(s => s.Id);
break;
case SortState.OrderProductNameDec:
source = source.OrderByDescending(s => s.Product.Name);
break;
case SortState.OrderQuantityDec:
source = source.OrderByDescending(s => s.Quantity);
break;
case SortState.OrderPriceDec:
source = source.OrderByDescending(s => s.Price);
break;
case SortState.OrderDateOfOrderDec:
source = source.OrderByDescending(s => s.Date_of_order);
break;
case SortState.OrderDateOfSaleDec:
source = source.OrderByDescending(s => s.Date_of_sale);
break;
case SortState.OrderProductNameAsc:
source = source.OrderBy(s => s.Product.Name);
break;
case SortState.OrderQuantityAsc:
source = source.OrderBy(s => s.Quantity);
break;
case SortState.OrderPriceAsc:
source = source.OrderBy(s => s.Price);
break;
case SortState.OrderDateOfOrderAsc:
source = source.OrderBy(s => s.Date_of_order);
break;
case SortState.OrderDateOfSaleAsc:
source = source.OrderBy(s => s.Date_of_sale);
break;
}
var count = source.Count();
var items = source.Skip((page - 1) * pageSize).Take(pageSize).ToList();
PageViewModel pageViewModel = new PageViewModel(count, page, pageSize);
OrdersViewModel viewModel = new OrdersViewModel
{
Orders = items,
OrderViewModel = orderViewModel,
SortViewModel = new OrderSortViewModel(sortOrder),
PageViewModel = pageViewModel,
FilterViewModel = new FilterViewModel(id)
};
return(View(viewModel));
}
