public IPage <PeanutParticipation> FindParticipationsOfUser(IPageable pageRequest, User forUser, DateTime from, DateTime to,
IList <PeanutParticipationState> participationStates = null)
{
HibernateDelegate <IPage <PeanutParticipation> > finder = delegate(ISession session) {
IQueryOver <PeanutParticipation, PeanutParticipation> queryOver = session.QueryOver <PeanutParticipation>();
IQueryOver <PeanutParticipation, UserGroupMembership> joinUserGroupMembership =
queryOver.JoinQueryOver(participation => participation.UserGroupMembership);
/*Nur für den Nutzer*/
joinUserGroupMembership.Where(userGroupMembership => userGroupMembership.User == forUser);
IQueryOver <PeanutParticipation, Peanut> joinPeanut = queryOver.JoinQueryOver(participation => participation.Peanut);
joinPeanut
/*Am oder nach dem ab Datum*/
.And(peanut => peanut.Day >= from)
.And(peanut => peanut.PeanutState != PeanutState.Canceled)
/*Nicht nach dem To Datum*/
.AndNot(peanut => peanut.Day > to);
if (participationStates != null && participationStates.Any())
{
/*Nur wenn die Teilnahme einen bestimmten Status hat.*/
queryOver.AndRestrictionOn(part => part.ParticipationState).IsIn(participationStates.ToArray());
}
return(FindPage(queryOver, pageRequest));
};
return(HibernateTemplate.Execute(finder));
}
public Page(List <T> content, IPageable <T> pageable = null, long?total = null)
{
Content = content ?? new List <T>();
if (total == null)
{
TotalElements = Content.Count;
}
else
{
TotalElements = total.Value < (long)Content.Count ? Content.Count : total.Value;
}
HasContent = Content.Count > 0;
if (HasContent)
{
NumberOfElements = Content.Count;
}
if (pageable == null)
{
return;
}
Number = pageable.PageNumber;
HasPrevious = pageable.PageNumber > 0;
HasNext = TotalElements > NumberOfElements + Number * pageable.PageSize;
if (TotalElements <= 0)
{
return;
}
var mod = (int)TotalElements % pageable.PageSize;
var quo = ((int)TotalElements) - mod;
TotalPages = (quo / pageable.PageSize) + (mod > 0 ? 1 : 0);
}
public IPage <Peanut> FindPeanutsInGroups(IPageable pageRequest, IList <UserGroup> userGroups, DateTime?from, DateTime?to)
{
Require.NotNull(userGroups, "userGroups");
Require.NotNull(pageRequest, "pageRequest");
HibernateDelegate <IPage <Peanut> > finder = delegate(ISession session) {
IQueryOver <Peanut, Peanut> queryOver = session.QueryOver <Peanut>();
queryOver.WhereRestrictionOn(p => p.UserGroup).IsIn(userGroups.ToList());
if (from != null)
{
/*Am oder nach dem ab Datum*/
queryOver.And(peanut => peanut.Day >= from);
}
if (to != null)
{
/*Nicht nach dem To Datum*/
queryOver.AndNot(peanut => peanut.Day > to);
}
return(FindPage(queryOver, pageRequest));
};
return(HibernateTemplate.Execute(finder));
}
/// <summary>
/// Versuch über ein Detached Criteria die Where-Klauseln zu verarbeiten, damit es mit dem Order nicht zu
/// komplikationen kommt.
/// </summary>
protected virtual IPage <T> Find(IPageable pageable, Action <DetachedCriteria> criteriaBuilder, Action <ICriteria> ordersBuilder = null)
{
Require.NotNull(pageable, "pageable");
Require.NotNull(criteriaBuilder, "criteriaBuilder");
HibernateDelegate <IPage <T> > finder = delegate(ISession session) {
DetachedCriteria whereCriteria = DetachedCriteria.For(typeof(T));
criteriaBuilder(whereCriteria);
whereCriteria.SetProjection(Projections.Property("Id"));
ICriteria elementsCriteria = session.CreateCriteria(typeof(T));
elementsCriteria.Add(Subqueries.PropertyIn("Id", whereCriteria));
if (ordersBuilder != null)
{
ordersBuilder(elementsCriteria);
}
ApplyPaging(pageable, elementsCriteria);
ICriteria countCriteria = session.CreateCriteria(typeof(T));
countCriteria.Add(Subqueries.PropertyIn("Id", whereCriteria));
countCriteria.SetProjection(Projections.RowCountInt64());
IFutureValue <long> futureTotalCount = countCriteria.FutureValue <long>();
IEnumerable <T> futureElements = elementsCriteria.Future <T>();
Page <T> page = new Page <T>(futureElements.ToList(), pageable, futureTotalCount.Value);
return(page);
};
return(HibernateTemplate.Execute(finder));
}
public async Task PrepareModelAsync(OrderItemListModel model, IPageable <OrderItem> orderItems)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
if (orderItems == null)
{
throw new ArgumentNullException(nameof(orderItems));
}
foreach (var orderItem in orderItems)
{
var orderItemModel = new OrderItemModel();
await PrepareModelAsync(orderItemModel, orderItem);
model.Items.Add(orderItemModel);
}
model.Page = orderItems.Page;
model.PageSize = orderItems.PageSize;
model.PageFrom = orderItems.PageFrom;
model.PageTo = orderItems.PageTo;
model.TotalPages = orderItems.TotalPages;
model.TotalItems = orderItems.TotalItems;
}
public Task PrepareModelAsync(TransactionListModel model, IPageable <Transaction> transactions)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
if (transactions == null)
{
throw new ArgumentNullException(nameof(transactions));
}
foreach (var transaction in transactions)
{
var transactionModel = new TransactionModel
{
Transaction = transaction
};
model.Items.Add(transactionModel);
}
model.ModeOptions.AddRange(SelectListHelper.GetEnumSelectList(selectedEnum: model.Filter.Mode, defaultText: "All"));
model.StatusOptions.AddRange(SelectListHelper.GetEnumSelectList(selectedEnum: model.Filter.Status, defaultText: "All"));
model.ProcessorOptions.AddRange(SelectListHelper.GetEnumSelectList(selectedEnum: model.Filter.Processor, defaultText: "All"));
model.TypeOptions.AddRange(SelectListHelper.GetEnumSelectList(selectedEnum: model.Filter.Type, defaultText: "All"));
model.Page = transactions.Page;
model.PageSize = transactions.PageSize;
model.PageFrom = transactions.PageFrom;
model.PageTo = transactions.PageTo;
model.TotalPages = transactions.TotalPages;
model.TotalItems = transactions.TotalItems;
return(Task.CompletedTask);
}
public Task PrepareModelAsync(AddressListModel model, IPageable <Address> addresses)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
if (addresses == null)
{
throw new ArgumentNullException(nameof(addresses));
}
foreach (var address in addresses)
{
var addressModel = new AddressModel
{
Address = address,
AddressType = model.AddressType
};
model.Items.Add(addressModel);
}
model.Page = addresses.Page;
model.PageSize = addresses.PageSize;
model.PageFrom = addresses.PageFrom;
model.PageTo = addresses.PageTo;
model.TotalPages = addresses.TotalPages;
model.TotalItems = addresses.TotalItems;
return(Task.CompletedTask);
}
public Task PrepareModelAsync(ReviewListModel model, IPageable <Review> reviews)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
if (reviews == null)
{
throw new ArgumentNullException(nameof(reviews));
}
foreach (var review in reviews)
{
var reviewModel = new ReviewModel
{
Review = review
};
model.Items.Add(reviewModel);
}
model.ApprovedOptions.AddRange(SelectListHelper.GetBoolSelectList("Approved", "Rejected", selectedBool: model.Filter.Approved, defaultText: "All"));
model.RatingOptions.AddRange(SelectListHelper.GetSelectList(Enumerable.Range(1, 5).Reverse(),
(x) => new SelectListItem <int>(text: $"{"star".ToQuantity(x)}", value: x.ToString(), selected: x == model.Filter.Rating), defaultText: "All"));
model.Page = reviews.Page;
model.PageSize = reviews.PageSize;
model.PageFrom = reviews.PageFrom;
model.PageTo = reviews.PageTo;
model.TotalPages = reviews.TotalPages;
model.TotalItems = reviews.TotalItems;
return(Task.CompletedTask);
}
public Task PrepareModelAsync(CategoryListModel model, IPageable <Category> categories)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
if (categories == null)
{
throw new ArgumentNullException(nameof(categories));
}
foreach (var category in categories)
{
var categoryModel = new CategoryModel
{
Category = category
};
model.Items.Add(categoryModel);
}
model.Page = categories.Page;
model.PageSize = categories.PageSize;
model.PageFrom = categories.PageFrom;
model.PageTo = categories.PageTo;
model.TotalPages = categories.TotalPages;
model.TotalItems = categories.TotalItems;
return(Task.CompletedTask);
}
/// <summary>
/// Versuch über ein Detached Criteria die Where-Klauseln zu verarbeiten, damit es mit dem Order nicht zu
/// komplikationen kommt.
/// </summary>
protected virtual IPage <T> Find(IPageable pageable, Action <IQueryOver <T, T> > criteriaBuilder, Action <IQueryOver <T, T> > ordersBuilder = null)
{
Require.NotNull(pageable, "pageable");
Require.NotNull(criteriaBuilder, "criteriaBuilder");
HibernateDelegate <IPage <T> > finder = delegate(ISession session) {
IQueryOver <T, T> query = session.QueryOver <T>();
criteriaBuilder(query);
if (ordersBuilder != null)
{
ordersBuilder(query);
}
IQueryOver <T, T> countQuery = session.QueryOver <T>();
criteriaBuilder(countQuery);
query.Skip(pageable.FirstItem);
query.Take(pageable.PageSize);
long futureTotalCount = countQuery.RowCountInt64();
IEnumerable <T> futureElements = query.Future <T>();
Page <T> page = new Page <T>(futureElements.ToList(), pageable, futureTotalCount);
return(page);
};
return(HibernateTemplate.Execute(finder));
}
public static Pager Pager(this IPageable pageable, int maxPagesToDisplay)
{
var firstPageToDisplay = 1;
var lastPageToDisplay = pageable.Pages;
if (maxPagesToDisplay > 0 && pageable.Pages > maxPagesToDisplay)
{
firstPageToDisplay = pageable.Page - maxPagesToDisplay / 2;
if (firstPageToDisplay < 1)
{
firstPageToDisplay = 1;
}
var pageNumbersToDisplay = maxPagesToDisplay;
lastPageToDisplay = firstPageToDisplay + pageNumbersToDisplay - 1;
if (lastPageToDisplay > pageable.Pages)
{
lastPageToDisplay = pageable.Pages;
}
}
return(new Pager
{
Pages = Enumerable.Range(firstPageToDisplay, lastPageToDisplay - firstPageToDisplay + 1)
});
}
public IPage <Bill> FindDebitorBillsForUser(IPageable pageRequest, User user, bool?isSettled)
{
HibernateDelegate <IPage <Bill> > finder = delegate(ISession session) {
Require.NotNull(pageRequest, "pageRequest");
Require.NotNull(user, "user");
/*Mitgliedschaften des Nutzers laden, da die Rechnungen gegen die Mitgliedschaft gehen*/
QueryOver <UserGroupMembership, UserGroupMembership> userGroupMembershipSubQuery =
QueryOver.Of <UserGroupMembership>().Where(mem => mem.User == user).Select(mem => mem.Id);
/*Subquery für die Rechnungen, bei denen der Nutzer Schuldner ist*/
IQueryOver <Bill, Bill> queryOver = session.QueryOver <Bill>();
queryOver.Right.JoinQueryOver <BillUserGroupDebitor>(bill => bill.UserGroupDebitors)
.WithSubquery.WhereProperty(deb => deb.UserGroupMembership)
.In(userGroupMembershipSubQuery);
if (isSettled.HasValue)
{
queryOver.And(bill => bill.IsSettled == isSettled.Value);
}
queryOver = queryOver.OrderBy(bill => bill.CreatedAt).Desc;
return(FindPage(queryOver, pageRequest));
};
return(HibernateTemplate.Execute(finder));
}
public override void Execute(UIElement target)
{
if (target is IPageable)
{
if (target.HasReceivedSwipe)
{
IPageable pageController = target as IPageable;
switch (target.MostRecetSwipeDirection)
{
case Direction.East:
if (pageController.CanPageBackward)
{
pageController.PageBackward();
}
break;
case Direction.West:
if (pageController.CanPageForward)
{
pageController.PageForward();
}
break;
}
}
}
else
{
Debug.LogErrorFormat("Target {0} does not implement IPageable. Cannot switch pages", target);
}
}
public IPage <UserGroupMembership> FindOtherMembershipsInUsersGroups(IPageable pageRequest, User user, IList <UserGroupMembershipType> membershipTypes = null)
{
Require.NotNull(pageRequest, "pageRequest");
Require.NotNull(user, "user");
HibernateDelegate <IPage <UserGroupMembership> > finder = delegate(ISession session) {
IQueryOver <UserGroupMembership, UserGroupMembership> queryOver = session.QueryOver <UserGroupMembership>();
/*Die Mitgliedschaften des Nutzers nicht!*/
queryOver.Where(membership => membership.User != user);
/*Nur die der Gruppen des Nutzers*/
var userGroupQueryOver = QueryOver.Of <UserGroupMembership>().Where(mem => mem.User == user).And(mem => mem.MembershipType == UserGroupMembershipType.Administrator || mem.MembershipType == UserGroupMembershipType.Member).Select(mem => mem.UserGroup.Id);
queryOver.WithSubquery.WhereProperty(membership => membership.UserGroup).In(userGroupQueryOver);
if (membershipTypes != null && membershipTypes.Any())
{
/*Einschränkung der Mitgliedschaften*/
queryOver.WhereRestrictionOn(memberShip => memberShip.MembershipType).IsIn(membershipTypes.ToArray());
}
return(FindPage(queryOver, pageRequest));
};
return(HibernateTemplate.Execute(finder));
}
/// <summary>
/// Ruft Seitenweise die beantragten Nutzer der Plattform ab.
/// </summary>
/// <param name="pageable">Informationen über aufzurufende Seite und Seitengröße</param>
/// <param name="searchTerm"></param>
/// <returns></returns>
public IPage <ProposedUser> FindProposedUser(IPageable pageable, string searchTerm)
{
Require.NotNull(pageable, "pageable");
Action <ICriteria> criterionsDelegate = delegate(ICriteria criteria) {
if (!string.IsNullOrEmpty(searchTerm))
{
/*Die Prüfung ob die Properties die Suchzeichenfolge enthalten per Oder verknüpfen*/
Disjunction orCriterias = new Disjunction();
orCriterias.Add(Restrictions.Like(Objects.GetPropertyName <ProposedUser>(user => user.UserName),
searchTerm,
MatchMode.Anywhere));
orCriterias.Add(Restrictions.Like(Objects.GetPropertyName <ProposedUser>(user => user.Email),
searchTerm,
MatchMode.Anywhere));
orCriterias.Add(Restrictions.Like(Objects.GetPropertyName <ProposedUser>(user => user.FirstName),
searchTerm,
MatchMode.Anywhere));
orCriterias.Add(Restrictions.Like(Objects.GetPropertyName <ProposedUser>(user => user.LastName),
searchTerm,
MatchMode.Anywhere));
criteria.Add(orCriterias);
}
};
/*Sortierung hinzufügen*/
Action <ICriteria> ordersDelegate = delegate(ICriteria criteria) {
criteria.AddOrder(Order.Asc("LastName"));
criteria.AddOrder(Order.Asc("FirstName"));
};
return(Find(pageable, criterionsDelegate, ordersDelegate));
}
public async Task PrepareModelAsync(OrderListModel model, IPageable <Order> orders)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
if (orders == null)
{
throw new ArgumentNullException(nameof(orders));
}
foreach (var order in orders)
{
var orderModel = new OrderModel();
await PrepareModelAsync(orderModel, order);
model.Items.Add(orderModel);
}
model.StatusOptions.AddRange(SelectListHelper.GetEnumSelectList(selectedEnum: model.Filter.Status, defaultText: "All"));
model.Page = orders.Page;
model.PageSize = orders.PageSize;
model.PageFrom = orders.PageFrom;
model.PageTo = orders.PageTo;
model.TotalPages = orders.TotalPages;
model.TotalItems = orders.TotalItems;
}
/// <summary>
/// Generates the pages for the specified ResultPage.
/// </summary>
/// <param name="self">The self.</param>
/// <param name="pageable">The pageable.</param>
/// <param name="pageFunc">The page func.</param>
/// <param name="maximumNumberOfPagesToShow">The maximum number of pages to show.</param>
/// <returns></returns>
public static MvcHtmlString GeneratePages(this HtmlHelper self, IPageable pageable, Func <PageData, MvcHtmlString> pageFunc, int maximumNumberOfPagesToShow)
{
Validate.Is.Not.Null(pageable, "pageable");
Validate.Is.Not.Null(pageFunc, "pageFunc");
return(new PageGenerator(pageable, pageFunc, maximumNumberOfPagesToShow).ToHtmlString());
}
public IPage <Peanut> FindBilledPeanutsInGroup(IPageable pageRequest, UserGroup userGroup, DateTime?from = null, DateTime?to = null)
{
Require.NotNull(userGroup, "userGroup");
Require.NotNull(pageRequest, "pageRequest");
HibernateDelegate <IPage <Peanut> > finder = delegate(ISession session) {
IQueryOver <Peanut, Peanut> queryOver = session.QueryOver <Peanut>();
queryOver.JoinQueryOver <Bill>(peanut => peanut.Bills).Where(peanutBill => peanutBill.IsSettled && peanutBill.UserGroup == userGroup);
queryOver.Where(peanut => peanut.UserGroup == userGroup);
if (from.HasValue)
{
queryOver.And(p => p.Day > from.Value);
}
if (to.HasValue)
{
queryOver.And(p => p.Day <= to.Value);
}
return(FindPage(queryOver, pageRequest));
};
return(HibernateTemplate.Execute(finder));
}
public async Task <ActionResult <IEnumerable <Region> > > GetAllRegions(IPageable pageable)
{
_log.LogDebug("REST request to get a page of Regions");
var result = await _regionService.FindAll(pageable);
return(Ok(result.Content).WithHeaders(result.GeneratePaginationHttpHeaders()));
}
protected override async Task <IPage <TEntity> > OnFindAsync(Expression <Func <TEntity, bool> > filter,
IPageable <TEntity> autumnPageable)
{
var count = await CountAsync(filter);
if (count == 0)
{
return(new Page <TEntity>(new List <TEntity>(), autumnPageable));
}
var find = _dbContext.Set <TEntity>()
.AsNoTracking()
.Where(filter);
var offset = autumnPageable.PageNumber * autumnPageable.PageSize;
var limit = autumnPageable.PageSize;
find = find.Skip(offset)
.Take(limit);
if (autumnPageable.Sort?.OrderBy?.Count() > 0)
{
find = autumnPageable.Sort.OrderBy.Aggregate(find, (current, order) => current.OrderBy(order));
}
if (autumnPageable.Sort?.OrderDescendingBy?.Count() > 0)
{
find = autumnPageable.Sort.OrderDescendingBy.Aggregate(find,
(current, order) => current.OrderByDescending(order));
}
var content = await find.ToListAsync();
return(new Page <TEntity>(content, autumnPageable, count));
}
private static IPageable <MediaFileInfo> ConvertPageable(IPageable <MediaFile> pageable, Func <MediaFile, MediaFileInfo> converter)
{
Guard.NotNull(pageable, nameof(pageable));
Guard.NotNull(converter, nameof(converter));
return(pageable.Select(converter).AsQueryable().ToPagedList(pageable.PageIndex, pageable.PageSize, pageable.TotalCount));
}
public static PagedList <T> ToPagedList <T>(this IQueryable <T> query, IPageable command,
int?defaultResults = null, int?maxResults = null)
{
return(query
.Paged(command, defaultResults, maxResults)
.ToPagedList(command.PageNumber ?? 1, command.PageSize ?? 100));
}
public virtual async Task <IPage <Sazeman> > FindAll(IPageable pageable)
{
var page = await _sazemanRepository.QueryHelper()
.GetPageAsync(pageable);
return(page);
}
public virtual async Task <IPage <PieceOfWork> > FindAll(IPageable pageable)
{
var page = await _pieceOfWorkRepository.QueryHelper()
.GetPageAsync(pageable);
return(page);
}
public virtual string JsonDataForjQgrid(int pageindex, int pagesize)
{
IPageable <T> page = this.GetPageable(pageindex, pagesize);
int recordcount = this.Count();
return(JSONhelper.FormatJSONForJQgrid(page.PageCount, pageindex, recordcount, page.Rows));
}
public void Delete(IPageable page)
{
if (pages.Any())
{
pages.Remove(page);
}
}
public PageableHttpResponse(
IPageable pageable,
Func <Uri, Task <HttpResponse <TV> > > resolvableRequest
)
{
_pageable = pageable;
_resolvableRequest = resolvableRequest;
}
public virtual void Init(IPageable pageable)
{
Guard.ArgumentNotNull(pageable, "pageable");
this.PageIndex = pageable.PageIndex;
this.PageSize = pageable.PageSize;
this.TotalCount = pageable.TotalCount;
}
public ActionResult <IEnumerable <Operation> > GetAllOperations(IPageable pageable)
{
_log.LogDebug("REST request to get a page of Operations");
var page = _applicationDatabaseContext.Operations.UsePageable(pageable);
var headers = PaginationUtil.GeneratePaginationHttpHeaders(page, HttpContext.Request);
return(Ok(page.Content).WithHeaders(headers));
}
protected void Init(IPageable pageable)
{
Guard.NotNull(pageable, "pageable");
this.PageIndex = pageable.PageIndex;
this.PageSize = pageable.PageSize;
this.TotalCount = pageable.TotalCount;
}
public PaginationBuilder(HtmlHelper htmlHelper, IPageable pageable)
{
Contract.ArgumentNotNull(htmlHelper, "htmlHelper");
Contract.ArgumentNotNull(pageable, "pageable");
_htmlHelper = htmlHelper;
_pageable = pageable;
_action = _htmlHelper.ViewContext.RouteData.Values["action"].ToString();
}
public CustomerBackInStockSubscriptionsModel(IPageable pageable) : base(pageable)
{
this.Subscriptions = new List<BackInStockSubscriptionModel>();
}
public virtual PagerBuilder Pager(IPageable model)
{
Guard.ArgumentNotNull(model, "model");
return new PagerBuilder(new Pager(), this.HtmlHelper).Model(model);
}
public PrivateMessageListModel(IPageable pageable) : base(pageable)
{
}
public CustomerForumSubscriptionsModel(IPageable pageable) : base(pageable)
{
this.ForumSubscriptions = new List<ForumSubscriptionModel>();
}
public void pageTitleBind(tbl_page pageItem, IPageable item, int langId)
{
if (pageItem != null)
{
pageTitleBind(pageItem.name, pageItem.title, pageItem.metaDescription, pageItem.metaDescription, pageItem.pageId, item, langId);
}
}
public void pageTitleBind(string name, string browserTitle, string metaDescription, string metaKeyword, int pageId, IPageable item, int langId)
{
var settingItem = db.tbl_settings.Where(a => a.langId == langId).FirstOrDefault();
if (settingItem != null)
{
item.setTitle(name);
item.setBrowserTitle(name + settingItem.allPageTitle);
if (!string.IsNullOrWhiteSpace(browserTitle))
{
item.setBrowserTitle(browserTitle + settingItem.allPageTitle);
}
if (!string.IsNullOrWhiteSpace(metaDescription))
{
item.setDescription(metaDescription);
}
if (!string.IsNullOrWhiteSpace(metaKeyword))
{
item.setKeywords(metaKeyword);
}
item.setPageId(pageId);
}
}
public ProfilePostsModel(IPageable pageable) : base(pageable)
{
}
public static MvcHtmlString PagingFor(this HtmlHelper helper, IPageable pageable)
{
return new MvcHtmlString(new PaginationBuilder(helper, pageable).Build());
}
