public ActionResult Category(string category)
{
PaginationDTO <PostCardDTO> postCardPaginationDTO = postService.GetPostCardPagination(pageNumber: 1, pageSize: Settings.POST_PAGE_SIZE, category);
PaginationModel <PostCardModel> postCardPaginationModel = dataMapper.MapPostCardPaginationDTOToModel(postCardPaginationDTO);
return(View(postCardPaginationModel));
}
public ActionResult PostGrid(string category, int pageNumber = 1, string searchQuery = null)
{
object jsonObject;
if (pageNumber <= 0)
{
jsonObject = new { status = 500 };
return(Json(jsonObject));
}
PaginationDTO <PostCardDTO> postCardPaginationDTO = postService.GetPostCardPagination(pageNumber, Settings.HOME_POST_PAGE_SIZE, category, searchQuery);
if (postCardPaginationDTO == null)
{
jsonObject = new { status = 500 };
}
else
{
PaginationModel <PostCardModel> postCardPaginationModel = dataMapper.MapPostCardPaginationDTOToModel(postCardPaginationDTO);
jsonObject = new
{
status = 200,
data = postCardPaginationModel
};
}
return(Json(jsonObject));
}
public async Task <ActionResult <List <Image> > > Get([FromQuery] PaginationDTO paginationDTO)
{
var queryable = _context.Images.AsQueryable();
await HttpContext.InsertPaginationParametersInResponse(queryable, paginationDTO.RecordsPerPage); //InsertPaginationParametersInResponse located in BlazorProject.Server/Helpers/HttpContextExtensions
return(await queryable.Paginate(paginationDTO).ToListAsync());
}
public async Task <ActionResult <List <ReviewDTO> > > Get(int movieId, [FromQuery] PaginationDTO pagination)
{
var queryable = context.Reviews.Include(x => x.User).AsQueryable();
queryable = queryable.Where(x => x.MovieId == movieId);
return(await Get <Review, ReviewDTO>(pagination, queryable));
}
public PaginationDTO <CommentDTO> GetCommentPagination(int pageNumber, int pageSize, string postId = null, string commentId = null, string searchQuery = null)
{
PaginationEntity <CommentEntity> commentPaginationEntity = commentRepository.GetCommentPagination(pageNumber, pageSize, postId, commentId, searchQuery);
PaginationDTO <CommentDTO> commentPaginationDTO = dataMapper.MapCommentPaginationEntityToDTO(commentPaginationEntity);
return(commentPaginationDTO);
}
public PaginationDTO <CommentDTO> GetCommentPaginationOfPostWithPreservedFetch(string postId, DateTime createdDate, int pageSize)
{
PaginationEntity <CommentEntity> commentPaginationEntity = commentRepository.GetCommentPaginationOfPostWithPreservedFetch(postId, createdDate, pageSize);
PaginationDTO <CommentDTO> commentPaginationDTO = dataMapper.MapCommentPaginationEntityToDTO(commentPaginationEntity);
return(commentPaginationDTO);
}
public async Task <Tuple <PaginationDTO, List <ChatMessage> > > GetAllChatsPagination(int id, int skip, int take)
{
var cleanTake = 200;
var cleanSkip = 0;
var ChatMessage = await _context.Chats.Where(c => c.FolderId == id).OrderByDescending(c => c.MessageTime).ToListAsync();
var result = ChatMessage.Skip(cleanSkip).Take(cleanTake).ToList();
var allowNext = false; //allow older messages
var allowBack = false; //allow newer messages
if (cleanSkip > 0)
{
allowBack = true;
}
if ((cleanSkip + cleanTake) < ChatMessage.Count())
{
allowNext = true;
}
var pagesCounter = ChatMessage.Count() / cleanTake; //totalmessages divided by current take
var currentPage = (cleanSkip + cleanTake) / cleanTake;
var paginationDto = new PaginationDTO(cleanSkip, cleanTake, allowNext, allowBack, pagesCounter, currentPage);
return(new Tuple <PaginationDTO, List <ChatMessage> >(paginationDto, result));
}
public async Task <List <NewsFullDTO> > GetNews(PaginationDTO pagination)
{
try
{
var res = await _context.News
.Take(pagination.Take)
.Skip(pagination.Skip)
.OrderByDescending(c => c.Date)
.ToListAsync();
foreach (var i in res)
{
i.ViewCount++;
}
_context.News.UpdateRange(res);
await _context.SaveChangesAsync();
return(_mapper.Map <List <NewsFullDTO> >(res));
}
catch (Exception ex)
{
throw new Exception("Не удалось достать новости");
}
}
public List <CompanyInfoDTO> GetCompanyInfos(PaginationDTO cmd, ref int pagesCount)
{
var query = from c in db.CompanyInfos
where c.IsDeleted == false
select new CompanyInfoDTO()
{
Accountant = c.Accountant,
Address = c.Address,
BankDetails = c.BankDetails,
City = c.City,
Director = c.Director,
INN = c.INN,
LegalName = c.LegalName,
Id = c.Id,
MFO = c.MFO,
PaymentAccount = c.PaymentAccount,
Phone = c.Phone,
OKONX = c.OKONX,
};
pagesCount = (int)Math.Ceiling((double)(from p in query select p).Count() / cmd.PageSize);
query = query.Page(cmd.PageSize, cmd.Page);
return(query.ToList());
}
public PaginationDTO <PostCardDTO> GetPostCardPagination(int pageNumber, int pageSize, string category = null, string searchQuery = null)
{
PaginationEntity <PostEntity> postPaginationEntity = postRepository.GetPostPagination(pageNumber, pageSize, category, searchQuery);
PaginationDTO <PostCardDTO> postCardPaginationDTO = dataMapper.MapPostCardPaginationEntityToDTO(postPaginationEntity);
return(postCardPaginationDTO);
}
public ActionResult Index(int?page)
{
var pagination = new PaginationDTO();
pagination.ActualPageNumber = (page ?? 1);
var model = new RelDepartamentos();
model.TopMaisAvaliados = new List <DepartamentosModel>();
model.TopMenosAvaliados = new List <DepartamentosModel>();
model = relRepo.RelDepartamentos(1, 1);
model.TopMaisAvaliados.ForEach(x =>
{
x.Departamento = string.IsNullOrEmpty(x.Departamento) ? "não informado na integração" : x.Departamento;
});
model.TopMenosAvaliados.ForEach(x =>
{
x.Departamento = string.IsNullOrEmpty(x.Departamento) ? "não informado na integração" : x.Departamento;
});
return(View(model));
}
public async Task <ActionResult <List <Person> > > Get([FromQuery] PaginationDTO paginationDTO)
{
var queryable = context.People.AsQueryable();
await HttpContext.InsertPaginationParameterInResponse(queryable, paginationDTO.RecordsPerPage);
return(await queryable.Paginate(paginationDTO).ToListAsync());
}
public static async Task <PaginatedResponse <T> > GetHelper <T>(this IHttpService httpService, string url,
PaginationDTO paginationDTO)
{
string newURL = "";
if (url.Contains("?"))
{
newURL = $"{url}&page={paginationDTO.Page}&recordsPerPage={paginationDTO.RecordsPerPage}";
}
else
{
newURL = $"{url}?page={paginationDTO.Page}&recordsPerPage={paginationDTO.RecordsPerPage}";
}
var httpResponse = await httpService.Get <T>(newURL);
var totalAmountPages = int.Parse(httpResponse.HttpResponseMessage.Headers.GetValues("totalAmountPages").FirstOrDefault());
var paginatedResponse = new PaginatedResponse <T>
{
Response = httpResponse.Response,
TotalAmountPages = totalAmountPages
};
return(paginatedResponse);
}
public static IQueryable <T> Paginate <T>(this IQueryable <T> queryable,
PaginationDTO pagination)
{
return(queryable
.Skip((pagination.Page - 1) * pagination.QuantityPerPage)
.Take(pagination.QuantityPerPage));
}
public void FromDto <V>(PaginationDTO <V, U> paginationDto)
{
SearchQuery = paginationDto.SearchQuery;
TotalCount = paginationDto.TotalCount;
ObjectList = paginationDto.ObjectList == null ? null
: paginationDto.ObjectList.Select(e => (T)Convert.ChangeType(e, typeof(T)));
}
public async Task <ActionResult <List <ContentCreatorDTO> > > Get([FromQuery] PaginationDTO paginationDTO,
[FromQuery] ContentCreatorFilters contentCreatorFilters)
{
var queryable = GetContentCreatorQueryable();
if (!string.IsNullOrEmpty(contentCreatorFilters.UserNameContains))
{
queryable = queryable.Where(u => u.RealName.Contains(contentCreatorFilters.UserNameContains) || u.UserName.Contains(contentCreatorFilters.UserNameContains));
}
if (contentCreatorFilters.TechnologyId != null && contentCreatorFilters.TechnologyId.Count > 0)
{
queryable = queryable.Where(u => u.ApplicationUserTechnology.Any(t => contentCreatorFilters.TechnologyId.Contains(t.TechnologyId)));
}
await HttpContext.InserPaginationHeader(queryable);
queryable = queryable.Paginate(paginationDTO);
var entities = await queryable.ToListAsync();
var dto = mapper.Map <List <ContentCreatorDTO> >(entities);
//Mapear tecnologias
var technologyIdUserGroup = entities.Select(x => new
{
x.Id,
TechnologyIds = x.ApplicationUserTechnology.Select(y => y.TechnologyId)
}).ToList();
var totalIds = technologyIdUserGroup.Aggregate(new List <int>(), (before, next) =>
{
before.AddRange(next.TechnologyIds);
return(before);
}).Distinct();
var technologies = await applicationDbContext.Technologies.Where(t => totalIds.Contains(t.Id)).ToListAsync();
technologyIdUserGroup.ForEach(g =>
{
var creator = dto.FirstOrDefault(c => g.Id == c.UserId);
var creatorTechnologies = g.TechnologyIds.Select(x => technologies.FirstOrDefault(t => t.Id == x));
creator.ApplicationUserTechnology = mapper.Map <List <UserTechnologyDTO> >(creatorTechnologies);
var currentUser = entities.FirstOrDefault(u => u.Id == g.Id);
int principalIndex = currentUser.ApplicationUserTechnology.FindIndex(x => x.IsPrincipal);
if (principalIndex != -1)
{
creator.ApplicationUserTechnology[principalIndex].IsPrincipal = true;
}
});
return(dto);
}
public async Task <ActionResult <List <UserInfoDTO> > > Get([FromQuery] PaginationDTO pagination)
{
var queryable = context.Users.AsQueryable();
queryable = queryable.OrderBy(x => x.Email);
return(await Get <ApplicationUser, UserInfoDTO>(pagination));
}
public static async Task <PaginatedResponse <T> > GetHelper <T>(this IHttpService httpService, string url,
PaginationDTO paginationDTO, bool includeToken = true)
{
string newURL = "";
if (url.Contains("?")) //if url has "?" it means it already has queryStrings
{
newURL = $"{url}&page={paginationDTO.Page}&recordsPerPage={paginationDTO.RecordsPerPage}";
}
else
{
newURL = $"{url}?page={paginationDTO.Page}&recordsPerPage={paginationDTO.RecordsPerPage}";
}
var httpResponse = await httpService.Get <T>(newURL, includeToken);
var totalAmountOfPages = int.Parse(httpResponse.HttpResponseMessage.Headers.GetValues("totalAmountOfPages").FirstOrDefault());
var paginatedResponse = new PaginatedResponse <T>
{
Response = httpResponse.Response,
TotalAmountOfPages = totalAmountOfPages
};
return(paginatedResponse);
}
public ActionResult Index(int?page)
{
var pagination = new PaginationDTO();
pagination.ActualPageNumber = (page ?? 1);
var model = new RelatoriosDeProdutosModel();
model.Produtos = new List <ProdutoModel>();
model.TopMaisAvaliado = new List <ProdutoModel>();
model.TopMenosAvaliado = new List <ProdutoModel>();
model = produtoRepo.RelTopProdutos(1, pagination.ActualPageNumber);
if (model != null && model.Produtos.Any())
{
pagination.RowsPerPage = model.Produtos.FirstOrDefault().RowsPerPage;
pagination.TotalRows = model.Produtos.FirstOrDefault().TotalRows;
ViewBag.Produtos = new StaticPagedList <ProdutoModel>(model.Produtos.ToList(), pagination.ActualPageNumber, pagination.RowsPerPage, pagination.TotalRows);
}
else
{
model.Produtos = new List <ProdutoModel>();
ViewBag.Produtos = new StaticPagedList <ProdutoModel>(model.Produtos.ToList(), 1, 1, pagination.TotalRows);
}
return(View(model));
}
protected async Task <ActionResult <List <TDTO> > > Get <TEntity, TDTO>(PaginationDTO paginationDTO, IQueryable <TEntity> queryable) where TEntity : class
{
await HttpContext.InsertParametersPagination(queryable, paginationDTO.RecordsPage);
var entities = await queryable.Paginate(paginationDTO).ToListAsync();
return(_mapper.Map <List <TDTO> >(entities));
}
protected async Task <List <TDTO> > Get <TEntity, TDTO>(PaginationDTO paginationDTO, IQueryable <TEntity> queryable) where TEntity : class
{
await HttpContext.InsertPaginationParams(queryable, paginationDTO.RowsPerPage);
var entities = await queryable.Paginate(paginationDTO).ToListAsync();
return(mapper.Map <List <TDTO> >(entities));
}
public List <ExpenseDTO> GetExpenses(PaginationDTO cmd, int userId, ref int pagesCount)
{
var userData = new UserBL().GetAccountUser(userId);
var workplaceId = userData.WorkPlace.Id;
var isSuperUser = userData.PositionRole == 1 || userData.isSunnat;
return(new ExpenseDalFacade().GetExpenses(cmd, workplaceId.Value, isSuperUser, ref pagesCount));
}
public async Task <ActionResult <List <BlogDTO> > > GetByUserId(int id, [FromQuery] PaginationDTO paginationDTO)
{
var blogDTOs = await _blogService.GetAllByUserIdAsync(id);
await HttpContext.InsertPaginationParametersInResponseAsync(blogDTOs, paginationDTO.RecordsPerPage);
return(blogDTOs.Paginate(paginationDTO).ToList());
}
public static IQueryable <T> Paginate <T>(this IQueryable <T> queryable, PaginationDTO pagination, int totalAmountPages)
{
var currentPage = pagination.Page > totalAmountPages ? totalAmountPages : pagination.Page;
return(queryable
.Skip((currentPage - 1) * pagination.RecordsPerPage)
.Take(pagination.RecordsPerPage));
}
public async Task <ActionResult <List <Person> > > Get([FromQuery] PaginationDTO paginationDTO)
{
var paginatedResponse = await personRepository.GetPeople(paginationDTO);
HttpContext.InsertPaginationParametersInResponse(paginatedResponse.TotalAmountPages);
return(paginatedResponse.Response);
}
public async Task <ActionResult <List <UserDTO> > > GetListUsers([FromQuery] PaginationDTO paginationDTO)
{
var queryable = context.Users.AsQueryable();
await HttpContext.InsertParametersPaginationInHeader(queryable);
var users = await queryable.OrderBy(x => x.Email).Paginate(paginationDTO).ToListAsync();
return(mapper.Map <List <UserDTO> >(users));
}
public async Task <ActionResult <List <CustomerDTO> > > Get([FromQuery] PaginationDTO pagination)
{
var queryable = context.Customers.AsQueryable();
await HttpContext.InsertPaginationParametersInResponse(queryable, pagination.RecordsPerPage);
var customer = await queryable.Paginate(pagination).ToListAsync();
return(mapper.Map <List <CustomerDTO> >(customer));
}
protected async Task <List <TDTO> > Get <TEntity, TDTO>(PaginationDTO pagination) where TEntity : class
{
var queryable = context.Set <TEntity>().AsNoTracking().AsQueryable();
await HttpContext.InsertPaginationParametersInResponse(queryable, pagination.RecordsPerPage);
var entities = await queryable.Paginate(pagination).ToListAsync();
return(mapper.Map <List <TDTO> >(entities));
}
public void Paginate_WhenCalled_ReturnsPaginatedIenumerable()
{
var enumerable = Enumerable.Range(0, 10);
var paginationDTO = new PaginationDTO(2, 5);
var result = enumerable.Paginate(paginationDTO);
Assert.That(result, Is.EquivalentTo(new[] { 5, 6, 7, 8, 9 }));
}
public async Task <ActionResult <List <PersonDTO> > > Get([FromQuery] PaginationDTO pagination)
{
var querable = _context.People.AsQueryable();
await HttpContext.InsertPaginationParametersInResponse(querable, pagination.RecordsPerPage);
var people = await querable.Paginate(pagination).ToListAsync();
return(_mapper.Map <List <PersonDTO> >(people));
}