public override PagedResultDto <SysObjectDto> GetAll(PagedAndSortedResultRequestDto input) { var list = base.GetAll(input); foreach (var x in list.Items) { x.RefPermissions = _repoPermission.GetAllList(t => t.TenantId == null && t.ObjectKey == x.ObjectKey) .MapTo <List <ObjectPermissionDto> >(); } return(list); }
public virtual async Task <PagedResultDto <IdentityRoleDto> > GetListAsync(PagedAndSortedResultRequestDto input) { var list = await RoleRepository.GetListAsync(input.Sorting, input.MaxResultCount, input.SkipCount); var totalCount = await RoleRepository.GetCountAsync(); return(new PagedResultDto <IdentityRoleDto>( totalCount, ObjectMapper.Map <List <IdentityRole>, List <IdentityRoleDto> >(list) )); }
public async Task <PagedResultDto <CurrencyViewDto> > GetListAsync(PagedAndSortedResultRequestDto input) { var totalCount = await _repository.GetCountAsync(true); var list = await _repository.GetListAsync(input.Sorting, input.MaxResultCount, input.SkipCount, true); return(new PagedResultDto <CurrencyViewDto>( totalCount, ObjectMapper.Map <List <Currency>, List <CurrencyViewDto> >(list) )); }
public async Task <PagedResultDto <OrganizationUnitDto> > GetListAsync(PagedAndSortedResultRequestDto input) { var count = (long)await OrganizationUnitRepository.GetCountAsync(); var list = await OrganizationUnitRepository.GetListAsync(input.Sorting, input.MaxResultCount, input.SkipCount); return(new PagedResultDto <OrganizationUnitDto>( count, ObjectMapper.Map <List <OrganizationUnit>, List <OrganizationUnitDto> >(list) )); }
/// <summary> /// /// </summary> public async Task <PagedResultDto <DIME2Barcode.Entities.VM_ICMOInspectBillED> > GetAll( PagedAndSortedResultRequestDto input) { var query = JIT_VM_ICMOInspectBillED.GetAll().Where(A => A.FStatus >= PublicEnum.ICMODispBillState.已检验.EnumToInt() && A.FYSQty > 0); var data = await query.PageBy(input).ToListAsync(); var list = data.MapTo <List <DIME2Barcode.Entities.VM_ICMOInspectBillED> >(); return(new PagedResultDto <DIME2Barcode.Entities.VM_ICMOInspectBillED>(query.Count(), list)); }
private static IQueryable <TEntity> ApplySorting(IQueryable <TEntity> query, PagedAndSortedResultRequestDto input) { if (!input.Sorting.IsNullOrEmpty()) { return(query.OrderBy(input.Sorting)); } if (input.MaxResultCount > 0) { return(query.OrderByDescending(e => e.Id)); } return(query); }
public async Task <PagedResultDto <AuthorDto> > GetListAsync(PagedAndSortedResultRequestDto input) { var count = await _authorRepository.CountAsync(); var list = await _authorRepository.OrderBy(input.Sorting).PageBy(input).ToListAsync(); return(new PagedResultDto <AuthorDto> { TotalCount = count, Items = ObjectMapper.Map <List <Author>, List <AuthorDto> >(list) }); }
public async Task <PagedResultDto <ProductDto> > GetListPagedAsync(PagedAndSortedResultRequestDto input) { await NormalizeMaxResultCountAsync(input); var products = await _productRepository.GetListAsync(input.Sorting, input.MaxResultCount, input.SkipCount); var totalCount = await _productRepository.GetCountAsync(); var dtos = ObjectMapper.Map <List <Product>, List <ProductDto> >(products); return(new PagedResultDto <ProductDto>(totalCount, dtos)); }
public EditModalModel(IBookmarkAppService bookAppService, ICategoryAppService categoryAppService) { _bookAppService = bookAppService; _categoryAppService = categoryAppService; PagedAndSortedResultRequestDto input = new PagedAndSortedResultRequestDto(); PagedResultDto <CategoryDto> categoryDtoPaged = _categoryAppService.GetListAsync(input).Result; foreach (CategoryDto item in categoryDtoPaged.Items) { CategorysItem.Add(new SelectListItem(item.Name, item.Id.ToString())); } }
public async Task <PagedResultDto <TaskDto> > GetListAsync(PagedAndSortedResultRequestDto input) { var query = _taskRepository.GetAll().WhereIf(true, q => q.IsDeleted == false); var tasks = query.PageBy(input).ToList(); var totalCount = await _taskRepository.GetCountAsync(); IReadOnlyList <TaskDto> list = new List <TaskDto>( ObjectMapper.Map <List <Task>, List <TaskDto> >(tasks)); return(new PagedResultDto <TaskDto>(totalCount, list)); }
public async Task <PagedResultDto <CityDto> > GetListAsync(PagedAndSortedResultRequestDto input) { List <City> items = await _cityRepository.GetListAsync(includeDetails : true); List <CityDto> result = ObjectMapper.Map <List <City>, List <CityDto> >(items); long totalCount = await _cityRepository.GetCountAsync(); return(new PagedResultDto <CityDto>( totalCount, result )); }
public ListResultDto <DriverListDto> GetAll(PagedAndSortedResultRequestDto request) { var query = this.driverRepository.GetAll(); query = !string.IsNullOrWhiteSpace(request.Sorting) ? query.OrderBy(request.Sorting) : query.OrderBy(r => r.Name); var count = query.Count(); var list = query.AsQueryable().PageBy(request).ToList(); var dtos = list.MapTo <List <DriverListDto> >(); return(new PagedResultDto <DriverListDto>(count, dtos)); }
public virtual async Task <PagedResultDto <ApiResourceDto> > GetListAsync( PagedAndSortedResultRequestDto input) { var list = await _resourceRepository.GetListAsync(input.Sorting, input.SkipCount, input.MaxResultCount, includeDetails : true); var totalCount = await _resourceRepository.GetCountAsync(); return(new PagedResultDto <ApiResourceDto>( totalCount, ObjectMapper.Map <List <ApiResource>, List <ApiResourceDto> >(list) )); }
public PagedResultDto <AlarmStatusDto> GetAlarmInfoStatus(PagedAndSortedResultRequestDto input01) { PagedAndSortedResultRequestDto input = new PagedAndSortedResultRequestDto() { MaxResultCount = 1000, SkipCount = 0, Sorting = "id" }; var AlarmData = _alarmHostAppService.GetListAsync(input).Result.Items; var AlarmStatusData = _alarmStatusAppService.GetListAsync(input).Result.Items; List <AlarmStatusDto> listalarmStatus = new List <AlarmStatusDto>(); foreach (var item in AlarmData) { string url = $"{dvrurl}/api/AlarmInfo/GetAlarmInfo?DVR_IP={item.AlarmHostIP}&DVR_Name={item.User}&DVR_PassWord={item.Password}"; var handler = new HttpClientHandler(); var response = _httpClient.GetAsync(url).Result; var refStatus = response.Content.ReadAsStringAsync().Result; var refStatusData = Newtonsoft.Json.JsonConvert.DeserializeObject <List <AlarmStatusDto> >(refStatus); var HostAlarmStatusData = AlarmStatusData.Where(u => u.AlarmHostIP == item.AlarmHostIP); for (int i = 0; i < item.AlarmChannelCount; i++) { AlarmStatusDto refalarmStatusDto = refStatusData.Where(u => u.Channel_ID == i).FirstOrDefault(); var alarmdata3 = HostAlarmStatusData.Where(u => u.Channel_ID == i).FirstOrDefault(); AlarmStatusDto alarmStatusDto = new AlarmStatusDto(); alarmStatusDto.Channel_ID = i; alarmStatusDto.Alarm_ID = item.AlarmHostIP; alarmStatusDto.Alarm_ID = refalarmStatusDto.Alarm_ID; alarmStatusDto.IsAlarm = refalarmStatusDto.IsAlarm; alarmStatusDto.IsAnomaly = refalarmStatusDto.IsAnomaly; alarmStatusDto.IsDefence = refalarmStatusDto.IsDefence; alarmStatusDto.LastModificationTime = refalarmStatusDto.LastModificationTime; if (alarmdata3 != null) { alarmStatusDto.IsOpenDoor = alarmdata3.IsOpenDoor; } listalarmStatus.Add(alarmStatusDto); } } // var listrequst = listalarmStatus.PageBy(input01.SkipCount, input01.MaxResultCount).ToList(); return(new PagedResultDto <AlarmStatusDto>() { Items = listalarmStatus, TotalCount = listalarmStatus.Count }); }
public virtual async Task <PagedResultDto <WechatUserinfo> > GetListAsync(PagedAndSortedResultRequestDto input) { var query = _wechatUserRepository.AsQueryable(); var totalCount = await query.CountAsync(); query = query.OrderBy("CreationTime desc"); query = query.PageBy(input); var result = await query.ToListAsync(); return(new PagedResultDto <WechatUserinfo>(totalCount, result)); }
public async Task <PagedResultDto <BookmarkDto> > GetListAsync(PagedAndSortedResultRequestDto input) { _logger.LogInformation("==============GetListAsync===============试测试测试测试测试测试测试测试测试测试测试"); var query = _bookmarkRepository.GetAll(); var bookmarks = query.PageBy(input).ToList(); var totalCount = await _bookmarkRepository.GetCountAsync(); IReadOnlyList <BookmarkDto> list = new List <BookmarkDto>( ObjectMapper.Map <List <Bookmark>, List <BookmarkDto> >(bookmarks)); return(new PagedResultDto <BookmarkDto>(totalCount, list)); }
public virtual async Task <PagedResultDto <BlogPostDto> > GetListAsync(PagedAndSortedResultRequestDto input) { if (input.Sorting.IsNullOrEmpty()) { input.Sorting = nameof(BlogPost.CreationTime) + " desc"; } var blogPosts = await BlogPostRepository.GetPagedListAsync(input.SkipCount, input.MaxResultCount, input.Sorting, includeDetails : true); var count = await BlogPostRepository.GetCountAsync(); return(new PagedResultDto <BlogPostDto>( count, ObjectMapper.Map <List <BlogPost>, List <BlogPostDto> >(blogPosts))); }
public static PagedResultDto <TEntityDto> PagingAndSorting(PagedAndSortedResultRequestDto input, IQueryable <TEntity> query) { var totalCount = query.Count(); query = ApplySorting(query, input); query = ApplyPaging(query, input); var entities = query.ToList(); return(new PagedResultDto <TEntityDto>( totalCount, entities.Select(MapToEntityDto).ToList() )); }
/// <summary> /// Queries a Watson Discovery collection of coops and entry-level jobs based on features learned /// from analysing the user's resume via NLU. /// </summary> /// <returns>Stringified JSON result from Watson Discovery</returns> public async Task <string> GetCoopsForUserAsync(PagedAndSortedResultRequestDto input) { //Load user's profile UserProfile profile = await _userProfileRepository.FirstOrDefaultAsync(p => p.UserId == AbpSession.UserId); if (profile != null && !String.IsNullOrEmpty(profile.CoopsQuery)) { //CoopsQuery includes the "filter" which we use for location. //extract "filter" (query is like '...__location__location:Riyadh') and we'll extract 'location:Riyadh' string[] queryParts = profile.CoopsQuery.Split("__location__"); return(GetDocsFromWatson(queryParts[0], queryParts[1], input.MaxResultCount, input.SkipCount)); } return(""); }
public async Task <PagedResultDto <ProductInputOutputDto> > GetAll(PagedAndSortedResultRequestDto input) { var query = _productRepository.GetAll(); var totalCount = await query.CountAsync(); query = ApplySorting(query, input); query = ApplyPaging(query, input); var entities = await query.ToListAsync(); return(new PagedResultDto <ProductInputOutputDto>( totalCount, entities.Select(x => ObjectMapper.Map <ProductInputOutputDto>(x)).ToList() )); }
public PagedResultDto <TEntityDto> ApplyPagination(IQueryable <IEntidadeBase> set, PagedAndSortedResultRequestDto input) { var result = set.PageBy(input).ToList(); var secondResult = result.AsQueryable().Select(x => ObjectMapper .Map(x, Activator.CreateInstance <TEntityDto>())) .ToList(); return(new PagedResultDto <TEntityDto> { TotalCount = DynamicQueryableExtensions.Count(set), Items = secondResult }); }
public async Task <RiderDto[]> GetAll( [FromQuery] int cityId = -1, [FromQuery] int skipCount = 0, [FromQuery] int maxResultCount = 10) { var input = new PagedAndSortedResultRequestDto { SkipCount = skipCount, MaxResultCount = maxResultCount }; if (cityId > -1) { return(await RiderAppService.GetListAsync(cityId, input, true)); } return(await RiderAppService.GetListAsync(input, true)); }
public async Task <ListResultDto <CourseDto> > GetListssss(PagedAndSortedResultRequestDto input, String?text) { if (text == null) { List <Course> course = await _repository.GetListAsync(); List <CourseDto> courdto = ObjectMapper.Map <List <Course>, List <CourseDto> >(course); return(new ListResultDto <CourseDto>(courdto)); } else { var course = _repository.Where(p => p.Name.Contains(text)).ToList(); List <CourseDto> courdto = ObjectMapper.Map <List <Course>, List <CourseDto> >(course); return(new ListResultDto <CourseDto>(courdto)); } }
public async Task OnGetAsync() { var materialNameDTO = await _materialNameService.GetAsync(2); PagedAndSortedResultRequestDto input = new PagedAndSortedResultRequestDto() { MaxResultCount = 200, SkipCount = 0, Sorting = "id" }; var data = await _materialNameService.GetListAsync(input); materialNames = data.Items.ToList(); // materialName = materialNameDTO; }
public IActionResult GetOutExcel() { PagedAndSortedResultRequestDto resultRequestDto = new PagedAndSortedResultRequestDto() { MaxResultCount = 200000, SkipCount = 0, Sorting = "Id" }; var data = _dVRAppService.GetListAsync(resultRequestDto); var list = data.Result.Items.ToList(); DataTable dataTable = ListToDataTable.toDataTable<DVRDto>(list); var pathname = $"{System.AppDomain.CurrentDomain.BaseDirectory}Basics\\OutExcel.xlsx"; var requst = ExcelHelper.DataTableToExcel(dataTable, pathname, "Sheet1", true); var stream = System.IO.File.OpenRead(pathname); string fileExt = Path.GetExtension(pathname); var provider = new FileExtensionContentTypeProvider(); var meni = provider.Mappings[fileExt]; var returnFile = File(stream, meni, Path.GetFileName(pathname)); return returnFile; }
public async Task Should_Get_PagedAndSorted_Of_Authors() { var result = await WithUnitOfWorkAsync(async() => { var input = new PagedAndSortedResultRequestDto { SkipCount = 0, MaxResultCount = 10, Sorting = "Name" }; return(await _authorAppService.GetListAsync(input)); }); result.TotalCount.ShouldBe(1); result.Items.Count.ShouldBe(1); }
public override async Task <PagedResultDto <EventDto> > GetListAsync(PagedAndSortedResultRequestDto input) { try { var queryable = await Repository.GetQueryableAsync(); //Prepare a query to join books and authors var query = from book in queryable join author in _organizerRepository on book.OrganizerId equals author.Id select new { book, author }; //Paging query = query .Skip(input.SkipCount) .Take(input.MaxResultCount); //Execute the query and get a list var queryResult = await AsyncExecuter.ToListAsync(query); var bookDtos = queryResult.Select(x => { var bookDto = ObjectMapper.Map <Event, EventDto>(x.book); bookDto.OrganizerName = x.author.Name; return(bookDto); }).ToList(); var totalCount = await Repository.GetCountAsync(); return(new PagedResultDto <EventDto>( totalCount, bookDtos )); } catch (Exception ex) { throw; } //Get the IQueryable<Book> from the repository //Convert the query result to a list of BookDto objects //Get the total count with another query }
public async Task <PagedResultDto <BoxRecordDto> > GetBoxesAsync(PagedAndSortedResultRequestDto input) { var query = _boxRepository.GetAllIncluding(x => x.BoxRecord); var totalCount = await AsyncQueryableExecuter.CountAsync(query); if (!string.IsNullOrWhiteSpace(input.Sorting)) { query = query.OrderBy(input.Sorting); // Applying Sorting } query = query.Skip(input.SkipCount).Take(input.MaxResultCount); // Applying Paging var entities = await AsyncQueryableExecuter.ToListAsync(query); return(new PagedResultDto <BoxRecordDto>( totalCount, entities.Select(MapToBoxRecordDto).ToList() )); }
public async Task <Dictionary <string, int> > GetCameraByBuildAsync() { PagedAndSortedResultRequestDto resultRequestDto = new PagedAndSortedResultRequestDto() { MaxResultCount = 20000, SkipCount = 0, Sorting = null }; Dictionary <string, int> keyValues = new Dictionary <string, int>(); var data = _cameraAppService.GetListAsync(resultRequestDto).Result.Items.ToList(); var databuild = data.Select(i => new { Build = i.Build }).Distinct(); foreach (var item in databuild) { var data2 = data.Where(u => u.Build == item.Build); keyValues.Add(item.Build, data2.Count()); } return(keyValues);//Newtonsoft.Json.JsonConvert.SerializeObject(keyValues); }
public async Task <PagedResultDto <CompanyDto> > GetAll(PagedAndSortedResultRequestDto input) { var query = _companyRepository.GetAll(); int totalCount = query.Count(); if (input.Sorting.IsNullOrEmpty()) { input.Sorting = "Id"; } query = query.OrderBy(input.Sorting); query = query.PageBy(input); var entities = await query.ToListAsync(); var list = ObjectMapper.Map <List <CompanyDto> >(entities); return(new PagedResultDto <CompanyDto>(totalCount, list)); }