protected static (int Skip, int Take) GetSkipTake(PaginationRequestDto request)
{
int skip = request.PageNumber * request.PageSize - request.PageSize;
int take = request.PageSize;
return(skip, take);
}
public async Task GetAllClinics_IsSuccess_WhenSorting(bool IsAscending)
{
//Arrange
PaginationRequestDto pagingRequest = new PaginationRequestDto {
Column = "Name", IsAscending = IsAscending
};
var clinicRepository = new Mock <IClinicRepository>();
clinicRepository.Setup(c => c.GetAll()).ReturnsAsync(ClinicList);
var clinicAppService = new Mock <ClinicAppService>(clinicRepository.Object).Object;
//Act
var paginatedlist = await clinicAppService.GetAllClinics(pagingRequest);
//Assert
if (IsAscending)
{
Assert.Equal(paginatedlist.Items.ToList().First().Name, paginatedlist.Items.OrderBy(s => s.Name).First().Name);
}
else
{
Assert.Equal(paginatedlist.Items.ToList().First().Name, paginatedlist.Items.OrderByDescending(s => s.Name).First().Name);
}
Assert.IsType <Paginatedlist <ClinicItemDto> >(paginatedlist);
}
public IActionResult GetTab(
[FromRoute, Required] string device,
[FromRoute, Required] string tab,
[FromQuery] PaginationRequestDto paginationDto,
[FromQuery] SortRequestDto sortDto,
[FromQuery] AdvancedFilterRequestDto filterRequestDto)
{
try
{
var deviceId = new DeviceId(device);
var filter = AdvancedFilterRequestDto.ParseFilterRequest(filterRequestDto);
var pagination = PaginationRequestDto.MapPaginationRequest(paginationDto);
var sort = SortRequestDto.MapSortRequest(sortDto);
var tabEntries = _DataModel.GetTab(deviceId, tab, pagination, sort, filter);
return(Json(tabEntries));
}
catch (UnknownDeviceIdException e)
{
Logger.LogError("Exception while execution:", e);
return(FormattedNotFound($"Device id not found."));
}
catch (UnknownKeyException e)
{
Logger.LogError("Exception while execution:", e);
return(FormattedNotFound($"Key not found."));
}
catch (Exception e)
{
Logger.LogError("Exception while execution:", e);
return(FormattedInternalServerError($"{nameof(e)} {e.Message}"));
}
}
public async Task <(IEnumerable <UserDto> Users, int Total)> GetAllAsync(PaginationRequestDto request)
{
using var connection = ConnectionFactory.NewConnection;
(int skip, int take) = GetSkipTake(request);
var parameter = new DynamicParameters();
parameter.Add("skip", skip);
parameter.Add("take", take);
parameter.Add("total", dbType: DbType.Int32, direction: ParameterDirection.Output);
var result = await connection.QueryAsync <string>("spUsers_GetAll", param : parameter, commandType : CommandType.StoredProcedure);
int total = parameter.Get <int>("total");
if (!result.Any())
{
return(Enumerable.Empty <UserDto>(), total);
}
var dbUsers = JsonSerializer.Deserialize <IEnumerable <DbUser> >(string.Join("", result));
var users = dbUsers.Select(dbUser => new UserDto
{
Id = dbUser.Id,
Username = dbUser.Username,
TimeUntilDeletion = GetTimeUntilDeletion(dbUser.DeletionDate)
});
return(users, total);
}
public async Task <Paginatedlist <ClinicItemDto> > GetAllClinics(PaginationRequestDto dto)
{
var result = new Paginatedlist <ClinicItemDto>();
var query = await clinicRepository.GetAll();
var totalItem = query.Count();
var property = typeof(Clinic).GetProperties().Where(p => p.CanWrite && p.Name.ToLower() == dto.Column?.ToLower()).SingleOrDefault();
switch (dto.Type)
{
case PaginationType.Sorting:
query = dto.IsAscending ? query.OrderBy(c => property.GetValue(c)) : query.OrderByDescending(c => property.GetValue(c));
break;
case PaginationType.Searching:
query = query.Where(c => c.Name != null && c.Name.ToLower().Contains(dto.SearchText?.ToLower()));
break;
default:
break;
}
query = query.Skip(dto.Page * dto.PageItemCount).Take(dto.PageItemCount);
var clinics = query?.ToClinicItemDtoList();
return(new Paginatedlist <ClinicItemDto>(clinics, dto.Page, totalItem, dto.PageItemCount));
}
public IActionResult GetValues(
[FromRoute, Required] string device,
[FromQuery] PaginationRequestDto pagination,
[FromQuery] FilterRequest filter,
[FromQuery] SortRequestDto sort)
{
try
{
var deviceId = new DeviceId(device);
var dataDto = _DataModel.GetValueData(deviceId, pagination.PageNumber, pagination.PageSize,
filter.FilterBy, filter.FilterString, filter.FilterExcluding,
filter.FilterStateBy, filter.FilterStateExcluding,
sort.SortBy, sort.SortOrderAscending);
return(Json(dataDto));
}
catch (UnknownDeviceIdException e)
{
Logger.LogError("Exception while execution:", e);
return(FormattedNotFound($"Device id not found."));
}
catch (Exception e)
{
Logger.LogError("Exception while execution:", e);
return(FormattedInternalServerError($"{nameof(e)} {e.Message}"));
}
}
public async Task <IActionResult> GetClinics([FromBody] PaginationRequestDto dto)
{
return(await ActionHandle(async() =>
{
var clinics = await clinicService.GetAllClinics(dto);
return Ok(clinics);
}));
}
public ApiResponse <IEnumerable <Message> > GetDataMessage(DeviceId device, PaginationRequestDto pagination = null,
FilterRequest filter = null,
SortRequestDto sort = null)
{
var uri = $"/api/data/{device.FullId}/messages";
return(GetAll <Message>(uri));
}
public async Task <Paginatedlist <ClinicItemDto> > GetAllClinics(PaginationRequestDto dto)
{
var result = await client.GetClinicsAsync(new CommonRequestMessage { Content = JsonConvert.SerializeObject(dto) });
var clinics = JsonConvert.DeserializeObject <Paginatedlist <ClinicItemDto> >(result.Content);
return(clinics);
}
public void BuildQuery(NameValueCollection query, PaginationRequestDto paginationRequest)
{
if (paginationRequest == null)
{
return;
}
query["PageNumber"] = paginationRequest.PageNumber.ToString();
query["PageSize"] = paginationRequest.PageSize.ToString();
}
public async Task <PaginatedEmails> SearchEmailsAsync(PaginationRequestDto paginationRequest)
{
var totalEmails = _unitOfWork.EmailRepository.GetCountAsync();
var emails = await _unitOfWork.EmailRepository.GetAsync(paginationRequest.Skip, paginationRequest.Take);
var dtos = emails.Select(e => new EmailDto(e.Id, e.Sent, e.Subject, Enum.Parse <NotificationType>(e.GetType().Name), e.Recipient.Address, e.Attachments.Count()));
return(new PaginatedEmails(dtos, new Pagination(paginationRequest.Skip, paginationRequest.Take, await totalEmails)));
}
public async Task <IActionResult> GetAll([FromQuery] PaginationRequestDto request)
{
var(users, total) = await UserRepository.GetAllAsync(request);
return(Ok(new PagedResponseDto <UserDto>
{
Data = users,
Total = total
}));
}
public Task <IEnumerable <StoryDto> > GetAll(PaginationRequestDto request)
{
if (request == null)
{
return(null);
}
return(this.storyService
.GetAll(request.Page, request.PageSize)
.ContinueWith(x => Mapper.Map <IEnumerable <StoryDto> >(x.Result)));
}
/// <summary>
/// Gets the page asynchronous.
/// </summary>
/// <param name="pageIndex">Index of the page.</param>
/// <param name="pageSize">Size of the page.</param>
/// <returns></returns>
public async virtual Task <PaginationResultDto <TDto> > GetPaginatedAsync(PaginationRequestDto paginationRequest)
{
var paginationRequestEntity = Mapper.Map <PaginationRequest>(paginationRequest);
var repository = UnitOfWork.GetRepository <TRepository>();
var entities = await repository.GetPaginatedAsync(paginationRequestEntity);
var dto = Mapper.Map <PaginationResultDto <TDto> >(entities);
return(dto);
}
public async Task <ResultPagedList <ConcatResponseDto> > GetList(
[FromQuery] PaginationRequestDto dto)
{
var data = await _serviceProvider.GetRequiredService <EditorService>().GetConcatList(dto.PageNo, dto.PageSize);
if (!data.Success)
{
return(ResultPagedList <ConcatResponseDto> .ReFailure(data.Message, data.Status));
}
return(ResultPagedList <ConcatResponseDto> .ReSuccess(_mapper.Map <List <ConcatResponseDto> >(data.Data),
data.TotalCount));
}
public async Task GetAllClinics_IsSuccess(PaginationRequestDto dto, bool expectation)
{
try
{
var clinic = await clinicAppService.GetAllClinics(dto);
Assert.Equal(clinic.Items.Any(), expectation);
}
catch
{
Assert.True(false);
}
}
public async Task <ApiResponse <IEnumerable <TabEntryDto> > > GetDataTab(DeviceId device, string tab,
PaginationRequestDto paginationDto = null,
SortRequestDto sortDto = null,
AdvancedFilterRequestDto filterRequestDto = null)
{
var query = HttpUtility.ParseQueryString("");
BuildQuery(query, paginationDto);
BuildQuery(query, sortDto);
BuildQuery(query, filterRequestDto);
var uri = $"/api/data/tab/{device.FullId}/{tab}?{query.ToString()}";
return(await GetAllAsync <TabEntryDto>(uri));
}
public async Task GetAllClinics_IsSuccess_WhenPaging(PaginationRequestDto pagingRequest, int firstItemIndex_Should)
{
//Arrange
var clinicRepository = new Mock <IClinicRepository>();
clinicRepository.Setup(c => c.GetAll()).ReturnsAsync(ClinicList);
var clinicAppService = new Mock <ClinicAppService>(clinicRepository.Object).Object;
//Act
var paginatedlist = await clinicAppService.GetAllClinics(pagingRequest);
//Assert
Assert.IsType <Paginatedlist <ClinicItemDto> >(paginatedlist);
Assert.Equal(paginatedlist.Items.Count, pagingRequest.PageItemCount);
Assert.Equal(paginatedlist.Page, pagingRequest.Page);
Assert.Equal(paginatedlist.Items[0].Id, ClinicList.ToList().ElementAt(firstItemIndex_Should).Id);
}
public async Task GetAllClinics_IsSuccess(PaginationRequestDto dto, bool expectation)
{
try
{
var okResult = await clinicController.GetClinics(dto) as OkObjectResult;
//Asserts
var result = Assert.IsType <OkObjectResult>(okResult);
var clinics = result.Value;
var model = Assert.IsAssignableFrom <Paginatedlist <ClinicItemDto> >(
clinics);
Assert.Equal(model.Items.Any(), expectation);
}
catch
{
Assert.True(false);
}
}
public async Task GetAllClinics_IsSuccess_WhenSearching()
{
//Arrange
PaginationRequestDto pagingRequest = new PaginationRequestDto {
Column = "Name", SearchText = "Clinic2"
};
var clinicRepository = new Mock <IClinicRepository>();
clinicRepository.Setup(c => c.GetAll()).ReturnsAsync(ClinicList);
var clinicAppService = new Mock <ClinicAppService>(clinicRepository.Object).Object;
var result_Should = ClinicList.Where(s => s.Name.Contains(pagingRequest.SearchText)).ToList();
//Act
var paginatedlist = await clinicAppService.GetAllClinics(pagingRequest);
//Assert
Assert.Equal(result_Should.Count, paginatedlist.Items.Count);
Assert.True(paginatedlist.Items.Where(s => !s.Name.Contains(pagingRequest.SearchText)).Count() == 0);
Assert.IsType <Paginatedlist <ClinicItemDto> >(paginatedlist);
}
public IActionResult GetJobs(
[FromRoute, Required] string device,
[FromQuery, Optional] PaginationRequestDto paginationDto,
[FromQuery, Optional] SortRequestDto sortDto,
[FromQuery, Optional] AdvancedFilterRequestDto filterRequestDto)
{
try
{
var deviceId = new DeviceId(device);
var filter = AdvancedFilterRequestDto.ParseFilterRequest(filterRequestDto);
var pagination = PaginationRequestDto.MapPaginationRequest(paginationDto);
var sort = SortRequestDto.MapSortRequest(sortDto);
var jobEntries = _jobModel.GetJobs(deviceId, pagination, sort, filter);
return(Json(jobEntries));
}
catch (Exception e)
{
return(ResolveException(e));
}
}
private static string FormatUriForGetCities(CityFilterDto filter, PaginationRequestDto pagination, OrderDto order)
{
var sb = new StringBuilder(GetCitiesUri);
if (filter != null)
{
if (!string.IsNullOrEmpty(filter.CountryIso))
{
sb.Append("&filter[countryIso]=");
sb.Append(filter.CountryIso);
}
if (filter.Id > 0)
{
sb.Append("&filter[id]=");
sb.Append(filter.Id);
}
if (filter.Ids != null)
{
for (var i = 0; i < filter.Ids.Length; i++)
{
sb.Append("&filter[ids][");
sb.Append(i);
sb.Append("]=");
sb.Append(filter.Ids[i]);
}
}
if (!string.IsNullOrEmpty(filter.Name))
{
sb.Append("&filter[name]=");
sb.Append(filter.Name);
}
if (!string.IsNullOrEmpty(filter.NameStrictLanguage))
{
sb.Append("&filter[nameStrictLanguage]=");
sb.Append(filter.NameStrictLanguage);
}
if (filter.RegionId > 0)
{
sb.Append("&filter[regionId]=");
sb.Append(filter.RegionId);
}
if (filter.RegionCodes != null)
{
for (var i = 0; i < filter.RegionCodes.Length; i++)
{
sb.Append("&filter[regionCodes][");
sb.Append(i);
sb.Append("]=");
sb.Append(filter.RegionCodes[i]);
}
}
}
if (pagination != null)
{
sb.Append("&pagination[page]=");
sb.Append(pagination.Page);
sb.Append("&pagination[limit]=");
sb.Append(pagination.Limit);
}
if (order == null)
{
return(sb.ToString());
}
if (!string.IsNullOrEmpty(order.By))
{
sb.Append("&order[by]=");
sb.Append(order.By);
}
if (string.IsNullOrEmpty(order.Dir))
{
return(sb.ToString());
}
sb.Append("&order[dir]=");
sb.Append(order.Dir);
return(sb.ToString());
}
public async Task <List <City> > GetCities(LocaleDto locale, CityFilterDto filter = null, PaginationRequestDto pagination = null, OrderDto order = null)
{
var uri = string.Format(FormatUriForGetCities(filter, pagination, order), Secrets.GeoHelperApiKey, locale.Lang, locale.FallbackLang);
Debug.WriteLine(uri);
var res = await GetAsync <City>(uri);
return(res ?? new List <City>());
}
public async Task <ApiResponse <IEnumerable <Job> > > GetDataJobs(DeviceId device, PaginationRequestDto pagination = null,
FilterRequest filter = null,
SortRequestDto sort = null)
{
var uri = $"/api/data/{device.FullId}/jobs";
return(await GetAllAsync <Job>(uri));
}
public Task <PaginatedEmails> Search([FromQuery] PaginationRequestDto paginationRequest)
{
return(_searchEmailUseCase.SearchEmailsAsync(paginationRequest));
}
public Task <IActionResult> GetAll([FromQuery] PaginationRequestDto paginationRequestDto)
{
return(GetPaginatedAsyncInternal(paginationRequestDto));
}
