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));
}
