public async Task <PagedResultDto <AggregateReRouteDto> > GetPagedListAsync(PagedResultRequestDto requestDto)
{
var reroutesTuple = await _aggregateReRouteRepository.GetPagedListAsync(requestDto.SkipCount, requestDto.MaxResultCount);
return(new PagedResultDto <AggregateReRouteDto>(reroutesTuple.total,
ObjectMapper.Map <List <AggregateReRoute>, List <AggregateReRouteDto> >(reroutesTuple.routes)));
}
public virtual async Task <PagedResultDto <FJOutput> > GetFinishedList(PagedResultRequestDto input)
{
var user = await _userRepository.GetAsync((int)AbpSession.UserId.Value);
var data = _fjRepository.GetAll().Where(
x =>
x.State == State.UnProtocoled ||
x.State == State.UnDig ||
x.State == State.Diged
);
//if (user.Department == Department.KanTanYeWu)
//{
// data = data.Where(x => x.RegionCode == user.RegionCode);
//}
var count = await data.CountAsync();
var list = await data.OrderByDescending(x => x.CreationTime).Skip(input.SkipCount).Take(input.MaxResultCount).ToListAsync();
var output = ObjectMapper.Map <List <FJOutput> >(list);
return(new PagedResultDto <FJOutput>
{
Items = output,
TotalCount = count
});
}
public async Task GetAllOrgUnit_Test()
{
int orgUnitCount = 50;
for (int i = 0; i < orgUnitCount; i++)
{
CreateOrgUnitDto createOrgUnitDto = new CreateOrgUnitDto()
{
ParentId = null,
DisplayName = $"Ou Test{i,2}"
};
var orgUnitDto = await _orgUnitAppService.CreateAsync(createOrgUnitDto);
}
PagedResultRequestDto pagedRoleDto = new PagedResultRequestDto()
{
SkipCount = 17,
MaxResultCount = 8
};
var orgUnits = await _orgUnitAppService.GetAllAsync(pagedRoleDto);
orgUnits.Items.Count.ShouldBe(8);
orgUnits.Items[0].DisplayName.ShouldBe("Ou Test17");
}
public async Task <PagedResultDto <DatasetReportOutput> > DataSets(PagedResultRequestDto input)
{
if (input.MaxResultCount == 0)
{
input.MaxResultCount = 10;
}
var totalCount = datasetRepo.Count();
var query = await datasetRepo.GetAll().Select(ff => new DatasetReportOutput
{
Id = ff.Id,
Description = ff.Description,
Name = ff.Name,
TotalBudget = ff.TotalBudget,
CreationTime = ff.CreationTime,
LabelingStatus = ff.LabelingStatus,
AnswerBudgetCountPerUser = ff.AnswerBudgetCountPerUser
}).OrderByDescending(ff => ff.CreationTime).Take(input.MaxResultCount).ToListAsync();
foreach (var item in query)
{
item.ItemsCount = datasetItemRepo.Count(ff => ff.DatasetID == item.Id);
item.RandomItemId = datasetItemRepo.GetAll()
.Where(ff => ff.DatasetID == item.Id)
.OrderBy(ff => Guid.NewGuid()).FirstOrDefault()?.Id;
}
return(new PagedResultDto <DatasetReportOutput>(totalCount, query));
}
public async Task <IPagedResultDto <UserDto> > FilterUsersAsync(PagedResultRequestDto pagedResultRequest, FilterUsersDto filter)
{
return(await _userRepository
.GetAll()
.SearchByFields(filter.SearchTerm, x => x.UserName)
.OrderBy(x => x.CreateDate)
.GetPagedResultAsync(pagedResultRequest.Page, pagedResultRequest.PageSize, x => _mapper.Map <UserDto>(x)));
}
public List <User> GetUsersNotInOrganizationUnitWithPage(PagedResultRequestDto paged, long organizationUnitId)
{
var users = GetUsersNotInOrganizationUnit(organizationUnitId)
.Skip(paged.SkipCount)
.Take(paged.MaxResultCount);
return(users.ToList());
}
public PagedResultDto <DeviceDataDto> GetAll(PagedResultRequestDto input)
{
var data = _dataManager.GetAll(input);
var total = data.Count;
return(new PagedResultDto <DeviceDataDto>(total, ObjectMapper.Map <List <DeviceDataDto> >(data)));
}
public List <DeviceData> GetAll(PagedResultRequestDto input)
{
var query = _deviceDatas.AsQueryable();
int total = query.Count();
var result = query.OrderBy(dd => dd.Timestamp).Skip(input.SkipCount).Take(input.MaxResultCount).ToList();
return(result);
}
public async Task <PagedResultDto <DataDictionaryDto> > GetListAsync(PagedResultRequestDto input)
{
var totalCount = await _dataDictionaryRepository.GetCountAsync();
var resultList = await _dataDictionaryRepository.GetListAsync(input.SkipCount, input.MaxResultCount);
return(new PagedResultDto <DataDictionaryDto>(totalCount, ObjectMapper.Map <List <DataDictionary>, List <DataDictionaryDto> >(resultList)));
}
public virtual async Task <PagedResultDto <PrivateMessageDto> > GetListAsync(PagedResultRequestDto input)
{
var list = await _privateMessageReceiverSideManager.GetListAsync(CurrentUser.GetId(), input.SkipCount,
input.MaxResultCount);
var count = await _privateMessageReceiverSideManager.CountAsync(CurrentUser.GetId());
return(new PagedResultDto <PrivateMessageDto>(count, await MapToDtoAndLoadMoreInfosAsync(list)));
}
public PagedResultDto <PlanCompleteDto> GetManyPlanComplete(PagedResultRequestDto input)
{
var lines = _planCompleteRepository.GetAll()
.Skip(input.SkipCount).Take(input.MaxResultCount);
var result = Mapper.Map <List <PlanCompleteDto> >(lines);
return(new PagedResultDto <PlanCompleteDto>(0, result));
}
// GET: /<controller>/
public async Task <ActionResult> Index(PagedResultRequestDto input)
{
IReadOnlyList <OfficeReadDto> officeList = (await _officeAppService.GetAll(new PagedResultRequestDto {
})).Items;
var model = new Index(officeList)
{
};
return(View(model));
}
// GET: /<controller>/
public async Task <ActionResult> Index(PagedResultRequestDto input)
{
IReadOnlyList <InstructorReadDto> instructorList = (await _instructorAppService.GetAll(new PagedResultRequestDto {
})).Items;
var model = new Index(instructorList)
{
};
return(View(model));
}
// GET: /<controller>/
public async Task <ActionResult> Index(PagedResultRequestDto input)
{
IReadOnlyList <DepartmentReadDto> departmentList = (await _departmentAppService.GetAll(new PagedResultRequestDto {
})).Items;
var model = new Index(departmentList)
{
};
return(View(model));
}
public PagedResultDto <PoemDto> GetPagedPoems(PagedResultRequestDto dto)
{
var count = _poemRepository.Count();
var lst = _poemRepository.OrderBy(o => o.Id).PageBy(dto).ToList();
return(new PagedResultDto <PoemDto>
{
TotalCount = count,
Items = ObjectMapper.Map <List <Core.Poems.Poem>, List <PoemDto> >(lst) //lst.MapTo<List<PoemDto>>()
});
}
// 综合类查询
public PagedResultDto <AttendanceDto> GetAttendancesInfo(PagedResultRequestDto pageQueryDto, string orgCode, int?tplId, string specId, int flag, DateTime?beginTime, DateTime?endTime, string selfCode)
{
if (string.IsNullOrEmpty(selfCode))
{
return(GetAttendances(pageQueryDto, orgCode, tplId, specId, flag, (DateTime)beginTime, (DateTime)endTime));
}
else
{
return(GetAttendancesBySelfCode(pageQueryDto, beginTime, endTime, selfCode, flag));
}
}
public async Task <PagedResultDto <ShopDto> > GetListAsync(PagedResultRequestDto input)
{
var query = _repository;
var total = await query.CountAsync();
var shops = await query.PageBy(input).ToListAsync();
return(new PagedResultDto <ShopDto>(total,
ObjectMapper.Map <List <Shop>, List <ShopDto> >(shops)));
}
public async Task <PagedResultDto <MediaList_News_Item> > GetMediaNews(PagedResultRequestDto input)
{
string accessToken = await GetAccessToken();
MediaList_NewsResult mediaList_NewsResult = Senparc.Weixin.MP.AdvancedAPIs.MediaApi.GetNewsMediaList(accessToken, input.SkipCount, input.PageSize);
GetMediaCountResultJson getMediaCountResultJson = await Senparc.Weixin.MP.AdvancedAPIs.MediaApi.GetMediaCountAsync(accessToken);
int totalCount = getMediaCountResultJson.news_count;
int pageCount = totalCount / input.PageSize;
return(new PagedResultDto <MediaList_News_Item>(totalCount, input.PageIndex, input.PageSize, mediaList_NewsResult.item));
}
public PagedResultDto <PoetDto> GetPagedPoets(PagedResultRequestDto dto)
{
var count = _poetRepository.Count();
var lst = _poetRepository.OrderBy(o => o.Id).PageBy(dto).ToList();
var items = new List <PoetDto>();
return(new PagedResultDto <PoetDto>
{
TotalCount = count,
Items = ObjectMapper.Map <List <Poet>, List <PoetDto> >(lst)
});
}
public async Task <ListResultDto <AxisDto> > GetAxes(PagedResultRequestDto input)
{
var user = await GetCurrentUserAsync();
int take = input.MaxResultCount > 50 || input.MaxResultCount <= 0 ? 10 : input.MaxResultCount,
skip = input.SkipCount > 0 ? input.SkipCount : 0;
var lines = _axisRepository.GetAll(user, skip, take);
var result = lines.Select(x => Mapper.Map <AxisDto>(x)).ToList();
return(new ListResultDto <AxisDto>(result));
}
// Getting all tags on the Home Page
public async Task <PagedResultDto <TagDto> > GetTags(PagedResultRequestDto input)
{
var tagCount = await _tagRepository.CountAsync();
var tags = await _tagRepository
.GetAll()
.ToListAsync();
return(new PagedResultDto <TagDto>
{
TotalCount = tagCount,
Items = tags.MapTo <List <TagDto> >()
});
}
public async Task <PagedResultDto <ImageListDto> > GetAll(PagedResultRequestDto input)
{
IQueryable <Image> images = await ImageManager.GetSystemImages();
IQueryable <ImageListDto> imageResult = images.Select(s => new ImageListDto
{
Id = s.Id,
CreationTime = s.CreationTime,
Identified = s.Identified,
Url = s.Url
});
return(await GetPagedResult(imageResult, input));
}
// GET: /<controller>/
public async Task <ActionResult> Index(PagedResultRequestDto input)
{
IReadOnlyList <StudentCourseReadDto> studentCourseList = (await _studentCourseAppService.GetAll(new PagedResultRequestDto {
})).Items;
IReadOnlyList <StudentReadDto> studentList = (await _studentAppService.GetAll(new PagedResultRequestDto {
})).Items;
IReadOnlyList <CourseReadDto> courseList = (await _courseAppService.GetAll(new PagedResultRequestDto {
})).Items;
var model = new Index(studentCourseList, studentList, courseList)
{
};
return(View(model));
}
protected virtual IQueryable <T> ApplySorting(IQueryable <T> query, PagedResultRequestDto input)
{
//Try to sort query if available
var sortInput = (ISortedResultRequest)input;
if (sortInput != null)
{
if (!sortInput.Sorting.IsNullOrWhiteSpace())
{
return(query.OrderBy(sortInput.Sorting));
}
}
//No sorting
return(query);
}
public async Task <PagedResultDto <ImageListDto> > GetAllSeller(PagedResultRequestDto input)
{
Seller.Seller seller = await GetCurrentSeller();
IQueryable <Image> images = await ImageManager.GetImagesForSeller(seller.Id);
IQueryable <ImageListDto> imageResult = images.Select(s => new ImageListDto
{
Id = s.Id,
CreationTime = s.CreationTime,
Identified = s.Identified,
Url = s.Url
});
return(await GetPagedResult(imageResult, input));
}
public async Task <PagedResultDto <UnitDto> > GetPages(PagedResultRequestDto pageQueryDto)
{
var query = _repository.GetAll().Where(x => !x.IsDeleted);
var count = await query.CountAsync();
var items = query.OrderByDescending(x => x.Id)
.Skip(pageQueryDto.SkipCount)
.Take(pageQueryDto.MaxResultCount)
.ToList();
var itemListDtos = items.MapTo <List <UnitDto> >();
return(new PagedResultDto <UnitDto>(
count,
itemListDtos
));
}
public async Task <PagedResultDto <AuctionListDto> > GetAll(PagedResultRequestDto input)
{
IQueryable <Domain.Auction.Auction> auctions = await _auctionManager
.GetAll();
IQueryable <AuctionListDto> results = auctions.Select(s => new AuctionListDto
{
Id = s.Id,
ProductName = s.Product.Name,
EndTime = s.EndDate,
ProductImage = s.Product.CoverImage.Image.Url,
CurrentPrice = s.CurrentPrice,
NumberOfBid = s.NumberOfBid
});
return(await GetPagedResult <AuctionListDto>(results, input));
}
public async Task <PagedResultDto <CreditHistory> > GetAll(PagedResultRequestDto input)
{
var data = _payInRepository
.GetAllIncluding(s => s.Target)
.Select(s => new CreditHistory
{
Credit = s.Credit,
Date = s.CreationTime,
Id = s.Id,
Money = s.Money,
SellerName = s.Target.Name
}
)
;
return(await GetPagedResult(data, input));
}
public Task <PagedResultDto <SettingModelDto> > GetSetingModelsAsync(PagedResultRequestDto input)
{
var totalCount = _settingModelTypeManager.EditableModels.Count;
var settingModels = _settingModelTypeManager.EditableModels.Skip(input.SkipCount).Take(input.MaxResultCount);
var dtos = settingModels.Select(s => ObjectMapper.Map <SettingModelBasicInfo, SettingModelDto>(s.ToModelBasicInfo())).ToList();
foreach (var dto in dtos)
{
dto.DisplayNameText = dto.DisplayName.Localize(StringLocalizerFactory).Value;
dto.DescriptionText = dto.Description?.Localize(StringLocalizerFactory).Value;
}
return(Task.FromResult(new PagedResultDto <SettingModelDto>(
totalCount,
dtos
)));
}
public async Task Should_Return_A_DataDictionary_List()
{
// Arrange
var requestDto = new PagedResultRequestDto
{
SkipCount = 0,
MaxResultCount = 10
};
// Act
var response = await _dataDictionaryAppService.GetListAsync(requestDto);
// Assert
response.ShouldNotBeNull();
response.TotalCount.ShouldBe(2);
response.Items.Any(x => x.Code == "MZ").ShouldBe(true);
}
