/// <summary>
///
/// </summary>
/// <param name="pageDetails"></param>
/// <param name="subscriptionId"></param>
/// <returns></returns>
public async Task <PagedResultSet <DomainModel.Contact> > MyContacts(Models.Common.PageDetails pageDetails, Guid?subscriptionId)
{
Expression <Func <DomainModel.Contact, bool> > expression = contact => true;
if (subscriptionId != null && subscriptionId != Guid.Empty)
{
expression = contact => contact.SubscriptionId == subscriptionId;
}
if (!string.IsNullOrWhiteSpace(pageDetails?.SearchText))
{
expression = expression.And(contact => (contact.FirstName.Contains(pageDetails.SearchText) ||
contact.LastName.Contains(pageDetails.SearchText) ||
contact.Email.Contains(pageDetails.SearchText) ||
contact.PhoneNumber.Contains(pageDetails.SearchText) ||
contact.GroupContactAssociations.Any(asso => asso.Group.Name.Contains(pageDetails.SearchText))));
}
var contacts = await Repository.GetAsync(expression);
var skip = pageDetails?.PageSize != null && pageDetails?.PageNo != null ?
pageDetails.PageSize.Value * (pageDetails.PageNo.Value - 1) :
pageDetails?.PageSize;
return(PagedResultSet <DomainModel.Contact> .Construct(contacts, skip, pageDetails?.PageSize));
}
public async Task <PagedResultSet <MovieResponseModel> > GetMoviesByPagination(int pageSize = 20, int page = 0, string title = "")
{
// check if title parameter is null or empty, if not then construct a Expression with Contains method
// contains method will transalate to SQL like
Expression <Func <Movie, bool> > filterExpression = null;
if (!string.IsNullOrEmpty(title))
{
filterExpression = movie => title != null && movie.Title.Contains(title);
}
// // we are gonna call GetPagedData method from repository;
// pass the order by column, here we are ordering our result by movie title
// pass the above filter expression
var pagedMovies = await _movieRepository.GetPagedData(page, pageSize, movies => movies.OrderBy(m => m.Title), filterExpression);
// once you get movies from repository , convert them in to MovieResponseModel List
var pagedMovieResponseModel = new List <MovieResponseModel>();
foreach (var movie in pagedMovies)
{
pagedMovieResponseModel.Add(new MovieResponseModel
{
Id = movie.Id,
Title = movie.Title,
PosterUrl = movie.PosterUrl,
ReleaseDate = movie.ReleaseDate.Value
});
}
// Pass the List of MovieResponseModel to our PagedResultSet class so that it can display the data along with page numbers
var movies = new PagedResultSet <MovieResponseModel>(pagedMovieResponseModel, page, pageSize, pagedMovies.TotalCount);
return(movies);
}
public async Task <PagedResultSet <InitiativeInfo> > GetInitiativesByStakeholderPersonIdAsync(int personId, string filter, int pageNumber, int pageSize)
{
return(await ExecuteAsync(async client =>
{
var response = await client.GetAsync($"?View=Mine");
if (response.IsSuccessStatusCode)
{
var ideaString = await response.Content.ReadAsStringAsync();
string totalCountString = response.Headers.GetValues("X-Total-Count").FirstOrDefault();
int totalCount = 0;
if (!string.IsNullOrWhiteSpace(totalCountString))
{
int.TryParse(totalCountString, out totalCount);
}
var contractResolver = new InitiativeContractResolver();
var settings = new JsonSerializerSettings()
{
ContractResolver = contractResolver
};
var returnValues = JsonConvert.DeserializeObject <IEnumerable <InitiativeInfo> >(ideaString, settings).ToList();
return PagedResultSet.Create(returnValues, pageNumber, pageSize, totalCount);
}
else
{
var ex = new InvalidOperationException($"Response from remote webservice did not indicate success ({response.StatusCode})");
ex.Data["HttpResponse"] = response;
throw ex;
}
}));
}
/// <summary>
///
/// </summary>
/// <param name="subscriptionId"></param>
/// <param name="pageDetails"></param>
/// <returns></returns>
public async Task <PagedResultSet <Models.Campaign.CampaignSummary> > GetMyCampaigns(Guid?subscriptionId, PageDetails pageDetails)
{
Expression <Func <DomainModel.Campaign, bool> > expression = campaign => true;
if (subscriptionId.HasValue && subscriptionId.Value != Guid.Empty)
{
expression = campaign => campaign.SubscriptionId == subscriptionId;
}
var campaigns = await Repository.GetAsync(expression);
if (!campaigns.Any())
{
return(PagedResultSet <Models.Campaign.CampaignSummary> .Construct(new List <Models.Campaign.CampaignSummary>(), null, null));
}
var campaignsSummary = _mapper.Map <IEnumerable <Models.Campaign.CampaignSummary> >(campaigns);
var IdentifierFilter = campaignsSummary.Select(campaignSummary => new Models.Subscription.Input.IdentifierFilter {
SubscriptionId = campaignSummary.SubscriptionId,
GroupId = campaignSummary.GroupId
}).ToList();
var subscriptionsAndGroupSummary = await _subscriptionServiceClient.GetSubscriptionsAndGroupSummaryByIdAsync(IdentifierFilter);
campaignsSummary.ToList().ForEach(summary =>
{
var subscriptionSummary = subscriptionsAndGroupSummary.First(subscriptionAndGroupSummary => subscriptionAndGroupSummary.Id == summary.SubscriptionId);
summary.Subscription = _mapper.Map <SubscriptionWithGroupSummary, Subscription>(subscriptionSummary);
summary.GroupSummary = summary.GroupId != null ? subscriptionSummary.GroupSummary.First(group => group.Id == summary.GroupId) : null;
});
var skip = pageDetails.PageSize.HasValue ? pageDetails.PageSize.Value * (pageDetails.PageNo.Value - 1) : pageDetails.PageSize.GetValueOrDefault();
return(PagedResultSet <Models.Campaign.CampaignSummary> .Construct(campaignsSummary, skip, pageDetails.PageSize.GetValueOrDefault()));
}
public IActionResult GetMovieByPagination(int index, string title = "")
{
var movies = _movieService.GetMoviesByPagination(index, 20, title).ToList();
var totalMovies = _movieService.GetMovieByTitle(title).Count();
var PageResultmovie = new PagedResultSet <Movie>(index, 20, totalMovies, movies);
return(Ok(PageResultmovie));
}
public Task <PagedResultSet <TEntity> > Search(PagedRequest pagedRequest, Func <IQueryable <TEntity>, IQueryable <TEntity> > query)
{
return(PagedResultSet <TEntity> .CreateAsync(
query(Context.Set <TEntity>().AsQueryable()),
pagedRequest.PageNumber,
pagedRequest.PageSize,
x => x.ToListAsync()));
}
public Task <PagedResultSet <PrimaryItem> > GetAllWithSecondaryItemBySecondaryItemIdAsync(long secondaryItemId, PagedRequest pagedRequest)
{
var query = ServiceContext.PrimaryItems
.Include(e => e.SecondaryItem)
.Where(e => e.SecondaryItemId == secondaryItemId);
return(PagedResultSet <PrimaryItem> .CreateAsync(query, pagedRequest.PageNumber, pagedRequest.PageSize, x => x.ToListAsync()));
}
public Task <PagedResultSet <PrimaryItem> > GetAllWithSecondaryItemPagedAsync(PrimaryItemPagedRequest pagedRequest)
{
var query = ServiceContext.PrimaryItems
.Include(x => x.SecondaryItem)
.Where(x => string.IsNullOrWhiteSpace(pagedRequest.Query) || x.Name.Contains(pagedRequest.Query))
.OrderBy(pagedRequest.OrderBy + $" {pagedRequest.SortOrder}");
return(PagedResultSet <PrimaryItem> .CreateAsync(query, pagedRequest.PageNumber, pagedRequest.PageSize, x => x.ToListAsync()));
}
public IActionResult MyFavoritedMovies(int index, int pageSize = 20, string filter = "")
{
var users = _userService.GetUserPagination(index, pageSize, filter);
var userDto = _mapper.Map <IEnumerable <User>, IEnumerable <UserDTO> >(users);
var totalUsers = _userService.GetAllUsers(filter);
var pageSet = new PagedResultSet <UserDTO>(page: index, pageSize: pageSize, totalRecords: totalUsers, data: userDto);
return(Ok(pageSet));
}
public async Task <PagedResultSet <InitiativeInfo> > GetInitiativesByStakeholderPersonIdAsync(int personId,
string filter, int pageNumber, int pageSize)
{
var query = _initiativeContext.Initiatives
.Where(x => x.Stakeholders.Any(y => y.PersonId == personId));
var initiatives = CreateInitiativeInfoQuery(query, filter);
return(await PagedResultSet.Create(initiatives, pageNumber, pageSize));
}
protected override async Task <PagedResultSet <SpaceView> > HandleInput(FindParams input)
{
using (var connection = database.GetConnection()) {
ISpaceRepo spaceRepo = database.GetRepo <ISpaceRepo>(connection);
PagedResultSet <Space> spaces = await spaceRepo.Find(input.Pagination?.PageNumber ?? 0, input.Pagination?.PageSize ?? Post.PageSize);
return(new PagedResultSet <SpaceView>(spaces.Select(s => mapper.Map(s)), spaces.Pagination));
}
}
public Task <PagedResultSet <TEntity> > Search(PagedRequest pagedRequest, Expression <Func <TEntity, bool> > predicate)
{
var query = Context.Set <TEntity>().Where(predicate);
return(PagedResultSet <TEntity> .CreateAsync(
query,
pagedRequest.PageNumber,
pagedRequest.PageSize,
x => x.ToListAsync()));
}
public Task <PagedResultSet <TEntity> > GetAllAsync(PagedRequest pagedRequest)
{
var query = Context.Set <TEntity>();
return(PagedResultSet <TEntity> .CreateAsync(
query,
pagedRequest.PageNumber,
pagedRequest.PageSize,
x => x.ToListAsync()));
}
public IActionResult GetMovieByPage(int index = 1, int pageSize = 20, string filter = "")
{
IList <MovieDTO> movieDtos = new List <MovieDTO>();
var movies = _movieService.GetMoviesByPagination(index, pageSize, filter).ToList();
var movieDto = _mapper.Map <IList <Movie>, IList <MovieDTO> >(movies, movieDtos);
var totalMovies = _movieService.GetMovieByTitle(filter).Count();
var PageResultmovie = new PagedResultSet <MovieDTO>(index, 20, totalMovies, movieDto);
return(Ok(PageResultmovie));
}
public async Task <PagedResultSet <MovieResponseModel> > GetAllMoviePurchasesByPagination(int pageSize = 50, int page = 0)
{
var totalPurchases = await _purchaseRepository.GetCountAsync();
var purchases = await _purchaseRepository.GetAllPurchases(pageSize, page);
var data = _mapper.Map <List <MovieResponseModel> >(purchases);
var purchasedMovies = new PagedResultSet <MovieResponseModel>(data, page, pageSize, totalPurchases);
return(purchasedMovies);
}
public async Task PagedResultSet_PageNumber_ReturnsCorrectValue(int pageNumber, int expectedResult)
{
IQueryable <string> values = new List <string>
{
"a", "b", "c", "d", "e", "f"
}.AsQueryable();
var result = await PagedResultSet <string> .CreateAsync(values, pageNumber, 1, async x => x.ToList());
result.PageNumber.Should().Be(expectedResult);
}
public async Task PagedResultSet_ItemCount_ReturnsCorrectValue(int pageNumber, int pageSize, int itemCount)
{
IQueryable <string> values = new List <string>
{
"a", "b", "c", "d", "e", "f"
}.AsQueryable();
var result = await PagedResultSet <string> .CreateAsync(values, pageNumber, pageSize, async x => x.ToList());
result.Items.Count().Should().Be(itemCount);
}
public IActionResult ShowAllMovies([FromQuery] PageDTO page)
{
if (!ModelState.IsValid)
{
return(BadRequest("failed"));
}
var totalRecords = _adminService.TotalMovieRecords(page.Filter);
var movies = _adminService.ShowAllMovies(page);
var movieDto = _mapper.Map <IEnumerable <Movie>, IEnumerable <MovieDTO> >(movies);
var pageData = new PagedResultSet <MovieDTO>(page: page.Index, pageSize: page.PageSize, totalRecords: totalRecords, data: movieDto);
return(Ok(pageData));
}
public PagedResultSet <T> GetPagedData(int currentPage, int pageSize)
{
IQueryable <T> query = _dbContext.Set <T>();
var totalRowCount = query.Count();
var currentPageIndex = currentPage;
var skip = (currentPageIndex - 1) * pageSize;
var data = query.Skip(skip).Take(pageSize).ToList();
var pagedResult = new PagedResultSet <T>(currentPageIndex, pageSize, totalRowCount, data);
return(pagedResult);
}
public IActionResult GetAllUserInfo([FromQuery] PageDTO page)
{
if (!ModelState.IsValid)
{
return(BadRequest(""));
}
var totalRecords = _adminService.TotalUserRecords(page.Filter);
var users = _adminService.GetAllUserInfo(page);
var userDto = _mapper.Map <IEnumerable <User>, IEnumerable <UserDTO> >(users);
var pageData = new PagedResultSet <UserDTO>(page: page.Index, pageSize: page.PageSize, totalRecords: totalRecords, data: userDto);
return(Ok(pageData));
}
public IActionResult GetAllPurchasesForMovie([FromQuery] PageDTO page)
{
if (!ModelState.IsValid)
{
return(BadRequest(""));
}
var totalRecords = _adminService.TotalPurchaseMovieRecords(page.Filter);
var purchases = _adminService.GetAllPuchasesForMovie(page);
var purchasesDto = _mapper.Map <IEnumerable <Purchase>, IEnumerable <PurchaseDTO> >(purchases);
var pageData = new PagedResultSet <PurchaseDTO>(page: page.Index, pageSize: page.PageSize, totalRecords: totalRecords, data: purchasesDto);
return(Ok(pageData));
}
public async Task <PagedResultSet <IssueInfo> > GetIssuesAsync(string filter, int pageNumber, int pageSize)
{
return(await ExecuteAsync(async client =>
{
var queryBuilder = new StringBuilder();
if (!string.IsNullOrWhiteSpace(filter))
{
queryBuilder.Append(queryBuilder.Length == 0 ? "?" : "&");
queryBuilder.Append("contains=");
queryBuilder.Append(filter);
}
if (pageNumber > 0)
{
queryBuilder.Append(queryBuilder.Length == 0 ? "?" : "&");
queryBuilder.Append("page=");
queryBuilder.Append(pageNumber);
}
if (pageSize > 0)
{
queryBuilder.Append(queryBuilder.Length == 0 ? "?" : "&");
queryBuilder.Append("pageSize=");
queryBuilder.Append(pageSize);
}
var response = await client.GetAsync(queryBuilder.ToString());
if (response.IsSuccessStatusCode)
{
string totalCountString = response.Headers.GetValues("X-Total-Count").FirstOrDefault();
int totalCount = 0;
if (!string.IsNullOrWhiteSpace(totalCountString))
{
int.TryParse(totalCountString, out totalCount);
}
var ideaString = await response.Content.ReadAsStringAsync();
var contractResolver = new IssueContractResolver();
var settings = new JsonSerializerSettings()
{
ContractResolver = contractResolver
};
var returnValues = JsonConvert.DeserializeObject <IEnumerable <IssueInfo> >(ideaString, settings).ToList();
return PagedResultSet.Create(returnValues, pageNumber, pageSize, totalCount);
}
else
{
var ex = new InvalidOperationException($"Response from remote webservice did not indicate success ({response.StatusCode})");
ex.Data["HttpResponse"] = response;
throw ex;
}
}));
}
public async Task <PagedResultSet <User> > GetAllUsersByPagination(int pageSize = 20, int page = 0, string lastName = "")
{
Expression <Func <User, bool> > filter = null;
if (!string.IsNullOrEmpty(lastName))
{
filter = user => lastName != null && user.LastName == lastName;
}
var pagedUsers = await _userRepository.GetPagedData(page, pageSize, user => user.OrderBy(u => u.LastName), filter);
var pagedResults = new PagedResultSet <User>(pagedUsers, page, pageSize, pagedUsers.TotalCount);
return(pagedResults);
}
public IHttpActionResult GetDepartments([FromUri] int pageSize = 8, [FromUri] int page = 1,
[FromUri] string name = "")
{
var totalDepartmentsCount = _departmentService.GetTotalDepartments(name);
var departments = _departmentService.GetDepartmentsPagination(pageSize, page, name);
var pagedDepartments = new PagedResultSet <DepartmentDTO>(page, pageSize, totalDepartmentsCount,
Mapper
.Map <IList <Department>, IList <DepartmentDTO>
>(departments.ToList()));
var response = pagedDepartments.Data.Any()
? Request.CreateResponse(HttpStatusCode.OK, pagedDepartments)
: Request.CreateResponse(HttpStatusCode.NotFound, "No Departments for your query");
return(ResponseMessage(response));
}
/// <summary>
/// Adds the paging headers.
/// </summary>
/// <typeparam name="TResult">The type of the result.</typeparam>
/// <param name="model">The model.</param>
private void AddPagingHeaders <TResult>(PagedResultSet <TResult> model)
{
var response = Response;
response.Headers.Add(Constants.SharedHttpHeaders.PagingTotal, model.Total.ToString());
if (model.First.HasValue)
{
response.Headers.Add(Constants.SharedHttpHeaders.PagingFirst, model.First.ToString());
}
if (model.Last.HasValue)
{
response.Headers.Add(Constants.SharedHttpHeaders.PagingLast, model.Last.ToString());
}
}
public async Task <IActionResult> Index()
{
var racingCategory = Server.Instance.Categories.Categories.SingleOrDefault(c => c.Name.Equals("racing", StringComparison.CurrentCultureIgnoreCase));
if (racingCategory != null)
{
ViewData["FeaturedGalleries"] = await Server.Instance.Galleries.GetGalleriesAsync(racingCategory, 1, 3, 3);
}
else
{
ViewData["FeaturedGalleries"] = new PagedResultSet <Gallery>();
}
ViewData["LatestGalleries"] = await Server.Instance.Galleries.GetLatestActiveGalleriesAsync(12);
return(View());
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public async Task <PagedResultSet <DomainModel.Subscription> > MySubscriptions(Models.Common.PageDetails pageDetails)
{
Expression <Func <DomainModel.Subscription, bool> > expression = subscription => true;
if (!string.IsNullOrWhiteSpace(pageDetails?.SearchText))
{
expression = expression.And(subscription => subscription.Name.Contains(pageDetails.SearchText));
}
var subscriptions = await Repository.GetAsync(expression);
var skip = pageDetails?.PageSize != null && pageDetails?.PageNo != null ?
pageDetails.PageSize.Value * (pageDetails.PageNo.Value - 1) :
pageDetails?.PageSize;
return(PagedResultSet <DomainModel.Subscription> .Construct(subscriptions, skip, pageDetails?.PageSize));
}
public async Task <PagedResultSet <MovieResponseModel> > GetMoviesByPagination(int pageSize = 20, int page = 0, string title = "")
{
Expression <Func <Movie, bool> > filterExpression = null;
//contains translate translated to sql like
if (!string.IsNullOrEmpty(title))
{
filterExpression = movie => title != null && movie.Title.Contains(title);
}
var pagedMovies = await _movieRepository.GetPagedData(page, pageSize, movies => movies.OrderBy(m => m.Title), filterExpression);
var pagedMovieResponseModel = _mapper.Map <List <MovieResponseModel> >(pagedMovies);
var movies = new PagedResultSet <MovieResponseModel>(pagedMovieResponseModel, page, pageSize, pagedMovies.TotalCount);
return(movies);
}
protected override async Task <PagedResultSet <PostView> > HandleInput(FindByValueParams <string> input)
{
using (var connection = database.GetConnection()) {
IPostRepo postRepo = database.GetRepo <IPostRepo>(connection);
IVoteRepo voteRepo = database.GetRepo <IVoteRepo>(connection);
PagedResultSet <Post> posts = await postRepo.FindByUser(input.Value, input.Pagination?.PageNumber ?? 0, input.Pagination?.PageSize ?? Post.PageSize);
if (input.User != null)
{
foreach (Post p in posts)
{
p.Vote = await voteRepo.FindByUserAndPost(input.User.Username, p.Id);
}
}
return(new PagedResultSet <PostView>(posts.Items.Select(p => postMapper.Map(p)), posts.Pagination));
}
}
public async Task <PagedResultSet <MovieResponseModel> > GetMoviesByPagination(int page = 20, int pageSize = 25, string title = "")
{
var movies = await _movieRepository.GetPagedData(page, pageSize);
var responseMovies = new List <MovieResponseModel>();
foreach (var item in movies)
{
responseMovies.Add(new MovieResponseModel
{
Id = item.Id,
PosterUrl = item.PosterUrl,
ReleaseDate = item.ReleaseDate.Value,
Title = item.Title
});
}
var set = new PagedResultSet <MovieResponseModel>(responseMovies, page, pageSize, movies.Count);
return(set);
}