public async Task <PagedList <UserDto> > GetOnlineFriends(Guid userId, PaginationParams paginationParams)
{
List <Guid> onlineUsersIds = GetOnlineUsers();
List <Guid> userFriendsIds = _friendsRelationService.GetUserFriendsId(userId);
List <Guid> onlineFriendsIds = onlineUsersIds.Intersect(userFriendsIds).ToList();
PagedList <Guid> onlineFriendsPages = PagedList <Guid> .Create(onlineFriendsIds,
paginationParams.PageNumber,
paginationParams.PageSize,
(paginationParams.PageNumber - 1) *paginationParams.PageSize + paginationParams.Skip);
List <UserDto> onlineFriendsFromApi = await _userService.GetUsersAsync(onlineFriendsPages);
return(PagedList <UserDto> .CreateNewWithSameParams(onlineFriendsPages, onlineFriendsFromApi));
}
public ListaPaginada <UsuariosModel> Get([FromQuery] PaginationParams model)
{
var usuarios = RestornaUsuariosList();
if (!string.IsNullOrEmpty(model.buscaTermo))
{
usuarios = usuarios.Where(x => x.Nome.Contains(model.buscaTermo) ||
x.Cpf.Contains(model.buscaTermo) ||
x.Email.Contains(model.buscaTermo)
).ToList();
}
var listaPaginada = new ListaPaginada <UsuariosModel>(model.PageNumber, model.PageSize);
return(listaPaginada.Carregar(usuarios));
}
public async Task <PagedList <AuditTypeDto> > Search(PaginationParams param, object text)
{
var lists = _repoAuditType.FindAll().ProjectTo <AuditTypeDto>(_configMapper)
.Where(
x => x.Audit_Type_ID.Contains(text.ToString()) ||
x.Brand.Contains(text.ToString()) ||
x.Audit_Type1.Contains(text.ToString()) ||
x.Audit_Type2.Contains(text.ToString()) ||
x.Audit_Type2_Name.Contains(text.ToString()) ||
x.Updated_By.Contains(text.ToString())
)
.OrderByDescending(x => x.Updated_Time);
return(await PagedList <AuditTypeDto> .CreateAsync(lists, param.PageNumber, param.PageSize));
}
public async Task <IEnumerable <DistrictDto> > GetDistrictsAsync(
string countryTag,
string provinceName,
PaginationParams paginationParams)
{
var query = from country in _locationDbContext.Countries
join province in _locationDbContext.Province on country.Id equals province.CountryId
join district in _locationDbContext.Districts on province.ProvinceId equals district.ProvinceId
where country.CountryTag == countryTag && province.ProvinceName == provinceName
select new DistrictDto {
DistrictId = district.DistrictId, DistrictName = district.DistrictName
};
return(await query.ToListAsync());
}
public async Task <IEnumerable <ProvinceDto> > GetProvincesAsync(
string countyTag,
PaginationParams paginationParams)
{
var query = from country in _locationDbContext.Countries
join province in _locationDbContext.Province on country.Id equals province.CountryId
where country.CountryTag == countyTag
select new ProvinceDto()
{
ProvinceId = province.ProvinceId,
ProvinceName = province.ProvinceName
};
return(await query.ToListAsync());
}
public async Task<PagedList<Transaction_Main_Dto>> FilterMissingPrint(PaginationParams param, FilterMissingParam filterParam)
{
var lists = _repoTransactionMain.GetAll()
.ProjectTo<Transaction_Main_Dto>(_configMapper)
.Where(x => x.Missing_No != null && x.Transac_Type.Trim() == "I");
if (filterParam.MO_No != null && filterParam.MO_No != "")
{
lists = lists.Where(x => x.MO_No.Trim() == filterParam.MO_No.Trim());
}
if (filterParam.Material_ID != null && filterParam.Material_ID != "")
{
lists = lists.Where(x => x.Material_ID.Trim() == filterParam.Material_ID.Trim());
}
lists = lists.Distinct().OrderByDescending(x => x.Updated_Time);
return await PagedList<Transaction_Main_Dto>.CreateAsync(lists, param.PageNumber, param.PageSize);
}
public async Task <PagedList <Product_Dto> > GetProducts(PaginationParams param)
{
var products = _repoProduct.FindAll();
var categorys = _repoCategory.FindAll();
var data = (from a in products join b in categorys
on a.CatID equals b.ID select new Product_Dto()
{
ID = a.ID,
Name = a.Name,
category = b,
Update_By = a.Updated_By,
Update_Time = a.Update_Time
}).OrderByDescending(x => x.Update_Time);
return(await PagedList <Product_Dto> .CreateAsync(data, param.PageNumber, param.PageSize));;
}
public async Task <PageListUtility <Article_Dto> > GetArticleWithPaginations(PaginationParams param, string text)
{
var data = _articleRepository.FindAll().ProjectTo <Article_Dto>(_configuration).OrderByDescending(x => x.Article_Cate_ID).ThenBy(x => x.Article_ID);
if (!string.IsNullOrEmpty(text))
{
data = data.Where(x => x.Article_ID.ToString().ToLower().Contains(text.ToLower()) ||
x.Article_Name.ToLower().Contains(text.ToLower()) ||
x.Update_By.ToLower().Contains(text.ToLower()) ||
x.Content.ToLower().Contains(text.ToLower()) ||
x.Alias.ToLower().Contains(text.ToLower()) ||
x.Article_Cate_ID.ToLower().Contains(text.ToLower())
).OrderByDescending(x => x.Article_Cate_ID).ThenBy(x => x.Article_ID);
}
return(await PageListUtility <Article_Dto> .PageListAsync(data, param.PageNumber, param.PageSize));
}
private static bool ValidateOrderBy(this PaginationParams paginationParams)
{
if (paginationParams.OrderBy == null)
{
return(false);
}
//if does not contain any order by, return
if (!paginationParams.OrderBy.Any())
{
return(false);
}
//check for null elements
return(paginationParams.OrderBy.Any(c => !string.IsNullOrWhiteSpace(c.ColumnName.Trim())));
}
public static StringBuilder AddOrderByToSqlString(this StringBuilder sql, PaginationParams paginationParams)
{
//Return if no orderby present
if (!paginationParams.ValidateOrderBy())
{
return(sql);
}
//Get the order by list
var notNullElements = paginationParams.OrderBy.Where(c => !string.IsNullOrWhiteSpace(c.ColumnName.Trim())).Select(d => d.ToString());
//Append new line with oder
sql.AppendLine($"order by {string.Join(", ", notNullElements)}");
return(sql);
}
public async Task <PagedList <UserDto> > GetUsersPagination(PaginationParams paginationParams)
{
var query = _context.Users
.Include(p => p.PhotoUsers)
.Include(p => p.Downloads)
.AsQueryable();
if (!string.IsNullOrEmpty(paginationParams.Search))
{
query = query.Where(e => e.FullName.ToLower().Contains(paginationParams.Search));
}
return(await PagedList <UserDto> .CreateAsync(query.ProjectTo <UserDto>(_mapper
.ConfigurationProvider).AsNoTracking(),
paginationParams.PageNumber, paginationParams.PageSize));
}
public PagedList <NotificationDto> GetUserNotifications(Guid userId, PaginationParams paginationParams, string fromWhoId = null, int notificationType = 0, string eventId = null)
{
_logger.LogDebug("Trying to get user notifications: {userid}", userId);
if (userId == Guid.Empty)
{
throw new ArgumentNullException(nameof(Guid));
}
try
{
var predicate = PredicateBuilder.New <Notification>();
predicate = predicate.And(x => x.ToWhoId == userId);
if (fromWhoId != null)
{
Guid.TryParse(fromWhoId, out Guid gFromWhoId);
predicate = predicate.And(x => x.FromWho == gFromWhoId);
}
if (notificationType != 0)
{
predicate = predicate.And(x => x.NotificationType == (NotificationType)notificationType);
}
if (eventId != null)
{
Guid.TryParse(eventId, out Guid gEventId);
predicate = predicate.And(x => x.EventId == gEventId);
}
List <Notification> notificationsFromRepo = _notificationRepository
.Get(predicate)
.OrderByDescending(x => x.WhenAdded)
.ToList();
List <NotificationDto> notificationsToReturn = _mapper.Map <List <NotificationDto> >(notificationsFromRepo);
return(PagedList <NotificationDto> .Create(notificationsToReturn,
paginationParams.PageNumber,
paginationParams.PageSize,
(paginationParams.PageNumber - 1) *paginationParams.PageSize + paginationParams.Skip));
}
catch (Exception ex)
{
_logger.LogError(ex, "Error occured during getting the user notifications.");
throw;
}
}
public async Task <IActionResult> GetMessagesForUser(int userId, [FromQuery] PaginationParams paginationParams)
{
if (userId != Convert.ToInt32(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
paginationParams.UserId = userId;
var messagesFromRepo = await _repo.GetMessagesForUser(paginationParams);
var messages = _mapper.Map <List <MessageToReturnDTO> >(messagesFromRepo);
Response.AddPagination(messagesFromRepo.CurrentPage, messagesFromRepo.PageSize, messagesFromRepo.TotalCount, messagesFromRepo.TotalPages);
return(Ok(messages));
}
public async Task <PagedList <AuditType_D_Dto> > SearchByAuditType(PaginationParams param, string audit_Type_ID, string audit_Item_ID)
{
var lists = _repoauditTypeD.FindAll().ProjectTo <AuditType_D_Dto>(_configMapper);
if (audit_Type_ID != "all")
{
if (audit_Item_ID != null)
{
lists = lists.Where(x => x.Audit_Type_ID.Trim() == audit_Type_ID && x.Audit_Item_ID == audit_Item_ID);
}
else
{
lists = lists.Where(x => x.Audit_Type_ID.Trim() == audit_Type_ID);
}
}
return(await PagedList <AuditType_D_Dto> .CreateAsync(lists, param.PageNumber, param.PageSize));
}
/// <summary>
/// List users
/// </summary>
/// <param name="pagination"></param>
/// <returns>Paginated list with all users</returns>
public async Task <PagedList <User> > ListAsync(PaginationParams pagination)
{
try
{
//Get paginated users from db
List <User> paginatedUsers = await _userRepository.List(pagination);
//Get total count of users in db
int totalCount = await _userRepository.Table.CountAsync();
return(new PagedList <User>(paginatedUsers, totalCount, pagination.CurrentPage, pagination.PageSize));
}
catch
{
throw;
}
}
public async Task <PagedList <User> > GetUsers(PaginationParams paginationParams)
{
var users = _context.Users.OrderByDescending(b => b.LastActive).AsQueryable();
users = users.Where(a => a.Id != paginationParams.UserId && a.Gender == paginationParams.Gender);
if (paginationParams.minAge != 18 || paginationParams.maxAge != 99)
{
var minDob = DateTime.Today.AddYears(-paginationParams.maxAge - 1);
var maxDob = DateTime.Today.AddYears(-paginationParams.minAge);
users = users.Where(a => a.DateOfBirth >= minDob && a.DateOfBirth <= maxDob);
}
if (paginationParams.Likers)
{
var userLikers = await GetUserLikes(paginationParams.UserId, paginationParams.Likers);
users = users.Where(a => userLikers.Contains(a.Id));
}
if (paginationParams.Likees)
{
var userLikees = await GetUserLikes(paginationParams.UserId, paginationParams.Likers);
users = users.Where(a => userLikees.Contains(a.Id));
}
if (!string.IsNullOrEmpty(paginationParams.OrderBy))
{
switch (paginationParams.OrderBy)
{
case "created":
users = users.OrderByDescending(a => a.Created);
break;
default:
users = users.OrderByDescending(a => a.LastActive);
break;
}
}
return(await PagedList <User> .CreateAsync(users, paginationParams.PageNumber, paginationParams.PageSize));
}
public async Task <PagedList <SMEScoreRecordDto> > GetLisSMEScoreRecord(PaginationParams paginationParams, ScoreRecordParam sixsScoreRecordParam, bool isPaging = true)
{
var queryAuditRateM = _auditRateMRepository.FindAll().Where(x => x.Audit_Type1.Trim() == "SME2.0");
var queryAuditRateD = _auditRateDRepository.FindAll();
if (sixsScoreRecordParam.PDC != "")
{
queryAuditRateM = queryAuditRateM.Where(x => x.PDC.Trim() == sixsScoreRecordParam.PDC);
}
if (sixsScoreRecordParam.Building != "")
{
queryAuditRateM = queryAuditRateM.Where(x => x.Building.Trim() == sixsScoreRecordParam.Building);
}
if (sixsScoreRecordParam.Line != "")
{
queryAuditRateM = queryAuditRateM.Where(x => x.Line.Trim() == sixsScoreRecordParam.Line);
}
if (sixsScoreRecordParam.AuditType2 != "")
{
queryAuditRateM = queryAuditRateM.Where(x => x.Audit_Type2.Trim() == sixsScoreRecordParam.AuditType2);
}
if (sixsScoreRecordParam.FromDate != "" && sixsScoreRecordParam.ToDate != "")
{
DateTime d1 = Convert.ToDateTime(sixsScoreRecordParam.FromDate + " 00:00:00");
DateTime d2 = Convert.ToDateTime(sixsScoreRecordParam.ToDate + " 23:59:59");
queryAuditRateM = queryAuditRateM.Where(x => x.Record_Date >= d1 && x.Record_Date <= d2);
}
var data = queryAuditRateM.OrderByDescending(x => x.Updated_Time).Select(x => new SMEScoreRecordDto
{
RecordId = x.Record_ID,
AuditDate = x.Record_Date,
AuditType = x.Audit_Type1,
AuditType2 = x.Audit_Type2,
LineId = x.PDC + " + " + x.Building + " + " + x.Line,
UpdateBy = x.Updated_By,
UpdateTime = x.Updated_Time,
Rating0 = queryAuditRateD.Where(y => y.Record_ID == x.Record_ID).Sum(z => z.Rating_0),
Rating1 = queryAuditRateD.Where(y => y.Record_ID == x.Record_ID).Sum(z => z.Rating_1),
Rating2 = queryAuditRateD.Where(y => y.Record_ID == x.Record_ID).Sum(z => z.Rating_2),
RatingNa = queryAuditRateD.Where(y => y.Record_ID == x.Record_ID).Sum(z => z.Rate_NA) == null ? 0 : queryAuditRateD.Where(y => y.Record_ID == x.Record_ID).Sum(z => z.Rate_NA),
});
return(await PagedList <SMEScoreRecordDto> .CreateAsync(data, paginationParams.PageNumber, paginationParams.PageSize, isPaging));
}
public async Task <PagedList <AuditRecDto> > GetAllAuditRecViewModel(PaginationParams param)
{
var listAuditRecM = _repoM.FindAll();
var listAuditRecD = _repoD.FindAll();
var listAuditMes = _repoMes.FindAll(x => x.Status == 1);
var listAuditRecDto = listAuditRecD.Join(listAuditRecM, x => x.Record_ID, y => y.Record_ID, (x, y) => new { x, y })
.Join(listAuditMes, z => z.y.Line, t => t.Line_ID_2, (z, t)
=> new AuditRecDto
{
Record_ID = z.x.Record_ID,
Record_Time = z.y.Record_Time,
After_Picture = z.x.After_Picture,
Audit_Item = z.x.Audit_Item,
Audit_Type_ID = z.x.Audit_Type_ID,
Audit_Type = (z.x == null || z.x.Audit_Type_ID == "") ? "" : _repoAuditTypeM.FindById(z.x.Audit_Type_ID).Audit_Type1 + "-" + _repoAuditTypeM.FindById(z.x.Audit_Type_ID).Audit_Type2,
Before_Picture = z.x.Before_Picture,
Finished_Date = z.x.Finished_Date,
ERCS = z.x.ERCS,
Implement_Time = z.x.Implement_Time,
Implement_User = z.x.Implement_User,
Issue_EN = z.x.Issue_EN,
Issue_LL = z.x.Issue_LL,
Issue_ZW = z.x.Issue_ZW,
Building = z.y.Building,
PDC = z.y.PDC,
Line = z.y.Line,
Line_Name = t.Line_ID_2_Name,
ME_PIC = z.x.ME_PIC,
Model_Name = z.y.Model_Name,
Model_No = z.y.Model_No,
Chief = z.y.Chief,
Recorder = z.y.Recorder,
Attendees = z.y.Attendees,
PD_PIC = z.x.PD_PIC,
PD_Department = z.x.PD_Department,
PD_Building = z.x.PD_Building,
Remark = z.x.Remark,
Status = z.x.Status,
Item_no = z.x.Item_no,
Updated_By = z.x.Updated_By,
Updated_Time = z.x.Updated_Time,
}).OrderBy(x => x.Audit_Type_ID);
return(await PagedList <AuditRecDto> .CreateAsync(listAuditRecDto, param.PageNumber, param.PageSize));
}
public async Task <PagedList <WMSB_Packing_List> > SearchViewModel(PaginationParams param, FilterPackingListParam filterParam)
{
var packingSearch = _repoPackingList.GetAll();
if (filterParam.From_Date != null && filterParam.To_Date != null)
{
packingSearch = packingSearch.
Where(x => x.Receive_Date >= DateTime.Parse(filterParam.From_Date + " 00:00:00.000") &&
x.Generated_QRCode.Trim() == "N" &&
x.Receive_Date <= DateTime.Parse(filterParam.To_Date + " 23:59:59.000")
);
}
if (filterParam.MO_No != null && filterParam.MO_No != string.Empty)
{
packingSearch = packingSearch.Where(x => x.MO_No.Trim() == filterParam.MO_No.Trim());
}
return(await PagedList <WMSB_Packing_List> .CreateAsync(packingSearch, param.PageNumber, param.PageSize));
}
public async Task <PagedList <Product_Dto> > Search(PaginationParams param, string filterParam)
{
var products = _repoProduct.FindAll(x => x.ID.Trim().Contains(filterParam.Trim()));
var categorys = _repoCategory.FindAll();
var data = (from a in products join b in categorys
on a.CatID equals b.ID select new Product_Dto()
{
ID = a.ID,
Name = a.Name,
CatID = a.CatID,
CatName = b.Name_LL,
CatName_ZW = b.Name_ZW,
Update_By = a.Updated_By,
Update_Time = a.Update_Time
}).OrderByDescending(x => x.Update_Time);
return(await PagedList <Product_Dto> .CreateAsync(data, param.PageNumber, param.PageSize));
}
public async Task <PagedList <Product_Dto> > Search(PaginationParams param, string filterParam)
{
var products = _repoProduct.FindAll(x => x.ID.Trim().Contains(filterParam.Trim()));
var categorys = _repoCategory.FindAll();
var data = products.Join(categorys, x => x.CatID, y => y.ID, (x, y) => new Product_Dto()
{
ID = x.ID,
Name = x.Name,
CatID = x.CatID,
CatName = y.Name_LL,
CatName_ZW = y.Name_ZW,
category = y,
Update_By = x.Updated_By,
Update_Time = x.Update_Time
}).OrderByDescending(x => x.Update_Time);
return(await PagedList <Product_Dto> .CreateAsync(data, param.PageNumber, param.PageSize));
}
public async Task <IActionResult> ExportExcelSMERecord([FromQuery] PaginationParams paginationParams, ScoreRecordParam scoreRecordParam)
{
var data = await _waterSpiderRecordService.GetLisWaterSpiderScoreRecord(paginationParams, scoreRecordParam);
var path = Path.Combine(_webHostEnvironment.ContentRootPath, "Resource\\Template\\WaterSpider_Score_Record_Template.xlsx");
WorkbookDesigner designer = new WorkbookDesigner();
designer.Workbook = new Workbook(path);
Worksheet ws = designer.Workbook.Worksheets[0];
designer.SetDataSource("result", data);
designer.Process();
MemoryStream stream = new MemoryStream();
designer.Workbook.Save(stream, SaveFormat.Xlsx);
byte[] result = stream.ToArray();
return(File(result, "application/xlsx", "WaterSpider_Score_Record" + DateTime.Now.ToString("dd_MM_yyyy_HH_mm_ss") + ".xlsx"));
}
public async Task <IActionResult> GetUsers([FromQuery] PaginationParams userParams)
{
var currentUserId = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value);
var userFromRepo = await _repo.GetUser(currentUserId, true);
userParams.UserId = currentUserId;
if (string.IsNullOrEmpty(userParams.Gender))
{
userParams.Gender = userFromRepo.Gender == "male" ? "female" : "male";
}
var users = await _repo.GetUsers(userParams);
var usersToReturn = _mapper.Map <IEnumerable <UserForListDTO> >(users);
Response.AddPagination(users.CurrentPage, users.PageSize, users.TotalPages, users.TotalCount);
return(Ok(usersToReturn));
}
public async Task <ActionResult> GetUsersWithRoles([FromQuery] PaginationParams paginationParams)
{
var users = _userManager.Users
.Include(r => r.UserRoles)
.ThenInclude(r => r.Role)
.OrderBy(u => u.UserName)
.Select(u => new UserRolesDto
{
Id = u.Id,
Username = u.UserName,
Roles = u.UserRoles.Select(r => r.Role.Name).ToList()
});
var usersRoles = await PagedList <UserRolesDto> .CreateAsync(users, paginationParams.PageNumber,
paginationParams.PageSize);
Response.AddPaginationHeader(usersRoles.CurrentPage, usersRoles.PageSize, usersRoles.TotalCount, usersRoles.TotalPages);
return(Ok(usersRoles));
}
public async Task <IActionResult> GetFilteredCars([FromQuery] PaginationParams carsParam)
{
//if (!User.Identity.IsAuthenticated)
// return Unauthorized();
//if (!User.IsInRole("Admin"))
// return Unauthorized();
var model = new List <CarForListDto>();
var carsAsync = await _carService.GetFilteredCarsAsync(carsParam);
var cars = carsAsync.ToList();
if (cars == null || cars.Count() <= 0)
{
return(BadRequest());
}
for (int i = 0; i < cars.Count(); i++)
{
var carUpload = await _carUploadService.GetCarUploadByCarIdAsync(cars[i].Id);
model.Add(new CarForListDto
{
Id = cars[i].Id,
CarNumber = cars[i].CarNumber,
BrandName = await _brandService.GetBrandNameAsync((int)cars[i].BrandId),
ModelYear = cars[i].ModelYear,
NumberOfDoors = cars[i].NumberOfDoors,
CarCapacity = cars[i].CarCapacity,
CarColor = cars[i].CarColor,
PriceForDay = cars[i].PriceForDay,
Description = cars[i].Description,
ModelName = await _modelService.GetModelNameAsync((int)cars[i].ModelId),
FuelType = await _fuelTypeService.GetFuelTypeNameAsync((int)cars[i].FuelTypeId),
TransmisionType = cars[i].TransmisionType.Name,
CarLocation = await _locationService.GetLocationAsync((int)cars[i].CarLocationId),
Path = carUpload != null ? Url.Content(carUpload.Path) : ""
});
}
Response.AddPagination(carsAsync.CurrentPage, carsAsync.PageSize, carsAsync.TotalCount, carsAsync.TotalPages);
return(Ok(model));
}
public async Task <IActionResult> GetFilteredBookings([FromQuery] PaginationParams paginationParams)
{
var model = new List <BookingForListDto>();
var bookingsAsync = await _bookingService.GetFilteredBookingsAsync(paginationParams);
var bookings = bookingsAsync.ToList();
if (bookings == null || bookings.Count <= 0)
{
return(BadRequest("Booking not found"));
}
for (int i = 0; i < bookings.Count(); i++)
{
model.Add(new BookingForListDto
{
Id = bookings[i].Id,
PickUpLocation = await _locationService.GetLocationAsync((int)bookings[i].PreBooking.PickLocationId),
ReturnLocation = await _locationService.GetLocationAsync((int)bookings[i].PreBooking.ReturnLocationId),
PickUpDate = (DateTime)bookings[i].PreBooking.PickDate,
ReturnDate = (DateTime)bookings[i].PreBooking.ReturnDate,
Car = new CarForListDto
{
Id = bookings[i].Car.Id,
CarNumber = bookings[i].Car.CarNumber
},
User = new UserDto
{
Id = bookings[i].User.Id,
FirstName = bookings[i].User.FirstName,
LastName = bookings[i].User.LastName,
Email = bookings[i].User.Email,
PhoneNumber = bookings[i].User.PhoneNumber
}
});
}
Response.AddPagination(bookingsAsync.CurrentPage, bookingsAsync.PageSize, bookingsAsync.TotalCount, bookingsAsync.TotalPages);
return(Ok(model));
}
public async Task <PagedList <Circle> > GetCircles(PaginationParams paginationParams, CircleSearchParameter searchOptions)
{
var query = _context.Circles.Include(c => c.Category)
.Include(c => c.City)
.Include(c => c.MainPhoto)
// .Include(c => c.CircleMemberList)
.AsQueryable();
if (searchOptions.CityId != null && searchOptions.CityId > 0)
{
query = query.Where(c => c.CityId == null || c.CityId == searchOptions.CityId);
}
if (searchOptions.CategoryId != null && searchOptions.CategoryId > 0)
{
query = query.Where(c => c.Category.Id == searchOptions.CategoryId);
}
return(await PagedList <Circle> .CreateAsync(query, paginationParams.PageNumber, paginationParams.PageSize));
}
public async Task <IEnumerable <MessageDto> > GetMessages(int chatId, PaginationParams parameters)
{
var messages = await _unitOfWork.Repository <Message>().GetAll()
.Include(m => m.Chat)
.Include(m => m.Poster)
.ThenInclude(u => u.Details)
.Where(m => m.ChatId == chatId)
.OrderByDescending(m => m.Timestamp)
.Skip(parameters.Skip)
.Take(parameters.Take)
.ToListAsync();
var mapper = new MapperConfiguration(cfg => cfg.CreateMap <Message, MessageDto>()
.ForMember(m => m.PosterName, opt => opt.MapFrom(m => m.Poster.Details.FirstName))).CreateMapper();
var messagesDto = mapper.Map <IEnumerable <Message>, IEnumerable <MessageDto> >(messages);
return(messagesDto);
}
public async Task <IActionResult> PagedHomePosts([FromQuery] PaginationParams input)
{
var token = GetToken();
if (!String.IsNullOrEmpty(token))
{
var userId = LoginHelper.GetClaim(token, "UserId");
input.EntityId = Guid.Parse(userId);
}
if (input.EntityId == null)
{
return(Unauthorized());
}
var post = await _postAppService.PagedHomePosts(input);
return(Ok(post));
}
public async Task <PagedResultDto <GetAllPostDto> > DailyTrends(PaginationParams input)
{
var result = await _postRepository.GetAll().Where(x => x.IsDeleted == false)
.Include(x => x.User)
.Include(x => x.Community).Select(
x => new GetAllPostDto
{
Id = x.Id,
Slug = x.Slug,
Content = x.Content,
LinkUrl = x.LinkUrl,
UserPostVote = x.Votes.FirstOrDefault(l => l.UserId == input.EntityId && l.IsDeleted == false && l.PostId == x.Id),
VoteCount = x.Votes.Count(v => v.IsDeleted == false && v.Value == 1) - x.Votes.Count(v => v.IsDeleted == false && v.Value == -1),
MediaContentPath = x.MediaContentPath == null ? null : BlobService.BlobService.GetImageUrl(x.MediaContentPath),
ContentType = x.ContentType,
CreatedDateTime = x.CreatedDate,
PageNumber = input.PageNumber,
Comments = x.Comments.Where(f => f.IsDeleted == false).Select(f => new Comment
{
ReplyCount = f.Replies.Count(v => v.IsDeleted == false)
}).ToList(),
Community = new PostCommunityDto
{
Slug = x.Community.Slug,
Name = x.Community.Name,
LogoPath = x.Community.LogoPath == null ? null : BlobService.BlobService.GetImageUrl(x.Community.LogoPath)
},
User = new PostUserDto
{
UserName = x.User.Username,
ProfileImagePath = BlobService.BlobService.GetImageUrl(x.User.ProfileImagePath)
}
}).OrderByDescending(x => x.CreatedDateTime).ThenByDescending(x => x.VoteCount).
Skip((input.PageNumber - 1) * input.PageSize).Take(input.PageSize).ToListAsync();
var hasNext = await _postRepository.GetAll().Where(x => x.IsDeleted == false).Skip((input.PageNumber) * input.PageSize).AnyAsync();
var bb = new PagedResultDto <GetAllPostDto> {
Results = result, HasNext = hasNext
};
return(bb);
}
