public async Task <PagedResultDto <PatientDto> > GetListAsync(GetPatientListDto input) { if (input.Sorting.IsNullOrWhiteSpace()) { input.Sorting = nameof(Patient.Name); } var patients = await _patientRepository.GetListAsync( input.SkipCount, input.MaxResultCount, input.Sorting, input.Filter ); var patientsDtos = ObjectMapper.Map <List <Patient>, List <PatientDto> >(patients); var doctorDictionary = await GetDoctorDictionaryAsync(patients); patientsDtos.ForEach(patientDto => patientDto.DoctorName = doctorDictionary[patientDto.DoctorId].Name); var countQuery = _patientRepository.WhereIf( !input.Filter.IsNullOrWhiteSpace(), p => p.Name.Contains(input.Filter)); var totalCount = await AsyncExecuter.CountAsync(countQuery); return(new PagedResultDto <PatientDto>( totalCount, patientsDtos )); }
public override async Task <PagedResultDto <ProductViewDto> > GetListAsync(GetProductListInput input) { await CheckGetListPolicyAsync(); if (input.ShowHidden || input.ShowUnpublished) { await CheckMultiStorePolicyAsync(input.StoreId, ProductsPermissions.Products.Manage); } if (await _cache.GetAsync(await GetCacheKeyAsync(input.StoreId), true) == null) { await BuildStoreProductViewsAsync(input.StoreId); } var query = await CreateFilteredQueryAsync(input); var totalCount = await AsyncExecuter.CountAsync(query); query = ApplySorting(query, input); query = ApplyPaging(query, input); var productViews = await AsyncExecuter.ToListAsync(query); var entityDtos = await MapToGetListOutputDtosAsync(productViews); return(new PagedResultDto <ProductViewDto>( totalCount, entityDtos )); }
public async Task <PagedResultDto <AuthorDto> > GetListAsync(GetAuthorListDto input) { if (input.Sorting.IsNullOrWhiteSpace()) { input.Sorting = nameof(Author.Name); } var authors = await _authorRepository.GetListAsync( input.SkipCount, input.MaxResultCount, input.Sorting, input.Filter ); var totalCount = await AsyncExecuter.CountAsync( _authorRepository.WhereIf( !input.Filter.IsNullOrWhiteSpace(), author => author.Name.Contains(input.Filter) ) ); return(new PagedResultDto <AuthorDto>( totalCount, ObjectMapper.Map <List <Author>, List <AuthorDto> >(authors) )); }
public override async Task <PagedResultDto <FileDto> > GetListAsync(FileResultRequestDto input) { var query = from file in Repository join bot in botRepository on file.BotId equals bot.Id orderby input.Sorting select new { bot, file }; if (input.BotId.HasValue) { query = query.Where(q => q.file.BotId.Equals(input.BotId)); } query = query.Skip(input.SkipCount).Take(input.MaxResultCount); var queryResult = await AsyncExecuter.ToListAsync(query); var fileList = queryResult.Select(f => { var fileDto = ObjectMapper.Map <File, FileDto>(f.file); fileDto.BotName = f.bot.Name; return(fileDto); }).ToList(); var totalCount = await AsyncExecuter.CountAsync(Repository.WhereIf(input.BotId.HasValue, q => q.BotId.Equals(input.BotId))); return(new PagedResultDto <FileDto>( totalCount, fileList ));; }
public async Task <PagedResultDto <OrganizationDto> > GetListAsync(GetOrganizationListDto input) { if (input.Sorting.IsNullOrWhiteSpace()) { input.Sorting = nameof(Organization.Name); } var organizations = await _orgRepository.GetListAsync( input.SkipCount, input.MaxResultCount, input.Sorting, input.Filter ); var totalCount = await AsyncExecuter.CountAsync( _orgRepository.WhereIf( !input.Filter.IsNullOrWhiteSpace(), organization => organization.Name.Contains(input.Filter) ) ); return(new PagedResultDto <OrganizationDto>( totalCount, ObjectMapper.Map <List <Organization>, List <OrganizationDto> >(organizations) )); }
public async Task <PagedResultDto <AuthorDto> > GetListAsync(GetAuthorListDto input) { return(await _cacheService.GetListAsync(AuthorCacheConsts.CacheKey.Key_GetList.FormatWith(input.SkipCount, input.MaxResultCount), async() => { if (string.IsNullOrWhiteSpace(input.Sorting)) { input.Sorting = nameof(Author.Name); } var authors = await _authorRepository.GetListAsync( input.SkipCount, input.MaxResultCount, input.Sorting, input.Filter ); var totalCount = await AsyncExecuter.CountAsync( _authorRepository.WhereIf( !string.IsNullOrWhiteSpace(input.Filter), author => author.Name.Contains(input.Filter) ) ); return new PagedResultDto <AuthorDto>( totalCount, ObjectMapper.Map <List <Author>, List <AuthorDto> >(authors) ); })); }
public async Task <PagedResultDto <RetailCustomerDto> > GetListAsync(GetRetailCustomerListDto input) { if (input.Sorting.IsNullOrWhiteSpace()) { input.Sorting = nameof(RetailCustomer.Name); } var retailCustomers = await _retailCustomerRepository.GetListAsync( input.SkipCount, input.MaxResultCount, input.Sorting, input.Filter ); var countQuery = _retailCustomerRepository.WhereIf( !input.Filter.IsNullOrWhiteSpace(), retailCustomer => retailCustomer.Name.Contains(input.Filter) ); var totalCount = await AsyncExecuter.CountAsync( countQuery.AsQueryable()); return(new PagedResultDto <RetailCustomerDto>( totalCount, ObjectMapper.Map <List <RetailCustomer>, List <RetailCustomerDto> >(retailCustomers) )); }
public override async Task <PagedResultDto <ResourceDto> > GetListAsync(GetResourceListDto input) { var query = _repository.GetQueryableWithAuthorizationStatus(CurrentUser.GetId(), input.AuthorizedOnly) .Where(x => x.Resource.CategoryId == input.CategoryId); if (!await _categoryDataPermissionProvider.IsCurrentUserAllowedToManageAsync(input.CategoryId)) { query = query.Where(x => x.Resource.IsPublished); } var totalCount = await AsyncExecuter.CountAsync(query); query = query.PageBy(input); var resources = await AsyncExecuter.ToListAsync(query); return(new PagedResultDto <ResourceDto>( totalCount, resources.Select(x => { var dto = ObjectMapper.Map <Resource, ResourceDto>(x.Resource); dto.IsAuthorized = x.IsAuthorized; return dto; }).ToList() )); }
public async Task <int> GetCountAsync(Guid blogId, CancellationToken cancellationToken = default) { return(await AsyncExecuter.CountAsync( await WithDetailsAsync(), x => x.BlogId == blogId, cancellationToken)); }
public async Task <PopularResult <PagedResultDto <ViolationDto> > > GetListAsync(ViolationQueryDto dto) { var result = new PopularResult <PagedResultDto <ViolationDto> >(); var countQuery = _violationRepository.Where(x => x.IsDelete == dto.IsDelete) .WhereIf(!dto.License.IsNullOrWhiteSpace(), violation => violation.Vehicle.License.Contains(dto.License)); var query = from m in countQuery.OrderBy(x => x.CreateTime).PageBy(dto.ToSkipCount(), dto.ToMaxResultCount()) join v in _vehicleRepository on m.VehicleId equals v.Id into cls from c in cls.DefaultIfEmpty() select new ViolationEntity(m.Id) { Fine = m.Fine, Indemnity = m.Indemnity, IsOutDanger = m.IsOutDanger, TookDate = m.TookDate, MaintenanceCost = m.MaintenanceCost, Vehicle = c, VehicleId = m.VehicleId, //IsDelete = m.IsDelete, CreateTime = m.CreateTime, Creator = m.Creator, Remark = m.Remark, }; var violations = await AsyncExecuter.ToListAsync(query); var totalCount = await AsyncExecuter.CountAsync(countQuery); var dtos = ObjectMapper.Map <List <ViolationEntity>, List <ViolationDto> >(violations); result.Success(new PagedResultDto <ViolationDto>(totalCount, dtos)); return(result); }
public async Task <PagedResultDto <MeterAccountReadingDto> > GetListAsync(GetMeterAccountListDto input) { //throw new NotImplementedException(); if (input.Sorting.IsNullOrWhiteSpace()) { input.Sorting = nameof(MeterAccount.RouteNO1); //默认按线路1排序 } //input.Filter = UserName ? input.Filter = CurrentUser.UserName; //调用仓储层...从数据库得到列表 var meterAccounts = await _meterAccountRepository.GetListAsync( input.SkipCount, input.MaxResultCount, input.Sorting, input.Filter ); var totalCount = await AsyncExecuter.CountAsync( _meterAccountRepository.WhereIf( !input.Filter.IsNullOrWhiteSpace(), meterAccount => meterAccount.UserName.Equals(input.Filter) ) ); return(new PagedResultDto <MeterAccountReadingDto>( totalCount, ObjectMapper.Map <List <MeterAccount>, List <MeterAccountReadingDto> >(meterAccounts) )); }
public override async Task <PagedResultDto <ResourceItemDto> > GetListAsync(GetResourceItemListDto input) { var resource = await _resourceRepository.GetAsync(input.ResourceId); var currentUserAllowedToManage = await _categoryDataPermissionProvider.IsCurrentUserAllowedToManageAsync(resource.CategoryId); if (!resource.IsPublished && !currentUserAllowedToManage) { throw new EntityNotFoundException(typeof(Resource), input.ResourceId); } var query = CreateFilteredQuery(input); if (!currentUserAllowedToManage) { query = query.Where(x => x.IsPublished); } var totalCount = await AsyncExecuter.CountAsync(query); query = ApplySorting(query, input); query = ApplyPaging(query, input); var resourceItems = await AsyncExecuter.ToListAsync(query); return(new PagedResultDto <ResourceItemDto>( totalCount, await MapToGetOutputDtoAsync(resourceItems) )); }
public override async Task <PagedResultDto <ProductDto> > GetListAsync(GetProductListInput input) { await CheckGetListPolicyAsync(); if (input.ShowHidden || input.ShowUnpublished) { await CheckMultiStorePolicyAsync(input.StoreId, ProductsPermissions.Products.Manage); } // Todo: Products cache. var query = await CreateFilteredQueryAsync(input); var totalCount = await AsyncExecuter.CountAsync(query); query = ApplySorting(query, input); query = ApplyPaging(query, input); var products = await AsyncExecuter.ToListAsync(query); var items = new List <ProductDto>(); foreach (var product in products) { var productDto = await MapToGetListOutputDtoAsync(product); await LoadDtoExtraDataAsync(product, productDto); items.Add(productDto); } await LoadDtosProductGroupDisplayNameAsync(items); return(new PagedResultDto <ProductDto>(totalCount, items)); }
public override async Task <PagedResultDto <DynamicEntityDto> > GetListAsync(GetDynamicEntityListInput input) { var modelDefinition = input.ModelDefinitionId.HasValue ? await GetModelDefinitionAsync(input.ModelDefinitionId.Value) : await _modelDefinitionRepository.GetAsync(x => x.Name == input.ModelName); await AuthorizationService.CheckAsync( new DynamicEntityOperationInfoModel(modelDefinition, null, input.FilterGroup), new DynamicEntityOperationAuthorizationRequirement(DynamicEntityOperationAuthorizationRequirement .GetListName)); input.ModelDefinitionId = modelDefinition.Id; var query = await CreateFilteredQueryAsync(input); var totalCount = await AsyncExecuter.CountAsync(query); query = ApplySorting(query, input); query = ApplyPaging(query, input); var entities = await AsyncExecuter.ToListAsync(query); return(new PagedResultDto <DynamicEntityDto>( totalCount, entities.Select(MapToGetListOutputDto).ToList() )); }
public override async Task <PagedResultDto <BasketItemDto> > GetListAsync(GetBasketItemListDto input) { await CheckGetListPolicyAsync(); if (input.UserId != CurrentUser.GetId()) { await AuthorizationService.CheckAsync(BasketsPermissions.BasketItem.Manage); } var query = CreateFilteredQuery(input); var totalCount = await AsyncExecuter.CountAsync(query); query = ApplySorting(query, input); query = ApplyPaging(query, input); var items = await AsyncExecuter.ToListAsync(query); var productSkuIds = items.Select(item => item.ProductSkuId).ToList(); var skuIdUpdateTimeDict = (await _productUpdateRepository.GetListByProductSkuIdsAsync(productSkuIds)).ToDictionary( x => x.ProductSkuId, x => x.LastModificationTime ?? x.CreationTime); var productDtoDict = new Dictionary <Guid, ProductDto>(); foreach (var item in items) { if (!skuIdUpdateTimeDict.ContainsKey(item.ProductSkuId)) { continue; } var itemUpdateTime = item.LastModificationTime ?? item.CreationTime; var productUpdateTime = skuIdUpdateTimeDict[item.ProductSkuId]; if (itemUpdateTime >= productUpdateTime) { continue; } if (!productDtoDict.ContainsKey(item.ProductId)) { // Todo: deleted product cause errors productDtoDict[item.ProductId] = await _productAppService.GetAsync(item.ProductId, item.StoreId); } await UpdateProductDataAsync(item.Quantity, item, productDtoDict[item.ProductId]); await _repository.UpdateAsync(item); } return(new PagedResultDto <BasketItemDto>( totalCount, await MapToGetListOutputDtosAsync(items) )); }
public async Task <PagedResultDto <IssueDto> > GetListAsync(GetIssueListDto input) { if (input.Sorting.IsNullOrWhiteSpace()) { input.Sorting = nameof(Issue.Title); } var issues = await _issueRepository.GetPagedListAsync(input.SkipCount, input.MaxResultCount, input.Sorting); var totalCount = await AsyncExecuter.CountAsync(_issueRepository.WhereIf(!input.Filter.IsNullOrWhiteSpace(), issue => issue.Title.Contains(input.Filter))); return(new PagedResultDto <IssueDto>(totalCount, ObjectMapper.Map <List <Issue>, List <IssueDto> >(issues))); }
public async Task <PagedResultDto <AuthorDto> > GetDeletedListAsync() { var query = _authorRepository.AsQueryable(); var totalCount = await AsyncExecuter.CountAsync(query.Where(x => x.IsDeleted)); var deletedAuthors = await AsyncExecuter.ToListAsync(query.Where(x => x.IsDeleted)); return(new PagedResultDto <AuthorDto>( totalCount, ObjectMapper.Map <List <Author>, List <AuthorDto> >(deletedAuthors))); }
public virtual async Task Disable(string id) { var habilitadas = await AsyncExecuter.CountAsync(_monedaStore.Where(x => x.IsEnabled)); if (habilitadas < 2) { throw new UserFriendlyException("Debe haber al menos una moneda habilitada"); } var moneda = await GetEntityByIdAsync(id); moneda.IsEnabled = false; }
public async Task <PopularResult <PagedResultDto <DriverDto> > > GetListAsync(DriverQueryDto dto) { var result = new PopularResult <PagedResultDto <DriverDto> >(); var queryable = _driverRepository.Where(x => x.IsDelete == dto.IsDelete) .WhereIf(!dto.Name.IsNullOrWhiteSpace(), driver => driver.Name.Contains(dto.Name)) .WhereIf(!dto.Name.IsNullOrWhiteSpace(), driver => driver.Name.Contains(dto.Name)) .WhereIf(dto.UnitId.HasValue, driver => driver.UnitId.Equals(dto.UnitId)); var query = from v in queryable.PageBy(dto.SkipCount, dto.MaxResultCount) join u in _unitRepository.WhereIf(dto.UnitId.HasValue, unit => unit.Id == dto.UnitId) on v.UnitId equals u.Id into cls from c in cls.DefaultIfEmpty() join d in _dictRepository.Where(x => true) on v.ClassId equals d.Id into f from e in f.DefaultIfEmpty() join cc in _dictRepository.Where(x => true) on v.StatusId equals cc.Id into ee from ff in ee.DefaultIfEmpty() select new DriverEntity(v.Id) { Address = v.Address, ClassId = v.ClassId, FirstIssueDate = v.FirstIssueDate, Hiredate = v.Hiredate, IdNo = v.IdNo, Name = v.Name, Sex = v.Sex, StatusId = v.StatusId, //IsDelete = v.IsDelete, CreateTime = v.CreateTime, Creator = v.Creator, Remark = v.Remark, UnitId = v.UnitId, Unit = c, Class = e, Status = ff }; var drivers = await AsyncExecuter.ToListAsync(query.PageBy(dto.SkipCount, dto.MaxResultCount)); var totalCount = await AsyncExecuter.CountAsync(queryable); var dtos = ObjectMapper.Map <List <DriverEntity>, List <DriverDto> >(drivers); result.Success(new PagedResultDto <DriverDto>(totalCount, dtos)); return(result); }
public virtual async Task <PagedResultDto <TGetListOutputDto> > GetPageListAsync(PagedAndSortedResultRequestDto pagedRequestDto, IFilterModel model = null) { await CheckGetListPolicyAsync(); var query = CreateFilteredQuery(model); var totalCount = await AsyncExecuter.CountAsync(query); query = ApplySorting(query, pagedRequestDto); //如果有分页条件 if (pagedRequestDto is IHasPagedRequestDto hasPaged) { if (hasPaged.IsPaged) { //进行分页查询 query = ApplyPaging(query, pagedRequestDto); } else { //不分页查询时,只查询有效数据 if (typeof(TEntity).IsAssignableTo <IPassivable>()) { query = query.Where(e => ((IPassivable)e).IsActive == true); } } } else { query = ApplyPaging(query, pagedRequestDto); } List <TGetListOutputDto> listOutputDtos; var func = CreateGetListOutputFunc(); // 输出的委托 if (func != null) { listOutputDtos = func(query); } else { var entities = await AsyncExecuter.ToListAsync(query); listOutputDtos = entities.Select(MapToGetListOutputDto).ToList(); } return(new PagedResultDto <TGetListOutputDto>( totalCount, listOutputDtos )); }
public virtual async Task <PagedResultDto <TViewOutput> > GetListPaged(TGetAllInput input) { await CheckGetListPolicyAsync(); var query = CreateFilteredQuery(input); var totalCount = await AsyncExecuter.CountAsync(query); query = ApplySorting(query, input); query = ApplyPaging(query, input); var result = await AsyncExecuter.ToListAsync(query); return(new PagedResultDto <TViewOutput>(totalCount, result.Select(MapToViewOutputDto).ToList())); }
public async Task <PopularResult <PagedResultDto <DictTypeDto> > > GetListAsync(DictTypeQueryDto dto) { var result = new PopularResult <PagedResultDto <DictTypeDto> >(); var queryable = _dictTypeRepository .WhereIf(!dto.Name.IsNullOrWhiteSpace(), dictType => dictType.Name.Contains(dto.Name)); var dictTypes = await _dictTypeRepository.GetPagedAsync(dto.Name, dto.SkipCount, dto.MaxResultCount); var totalCount = await AsyncExecuter.CountAsync(queryable); var dtos = ObjectMapper.Map <List <DictTypeEntity>, List <DictTypeDto> >(dictTypes); result.Success(new PagedResultDto <DictTypeDto>(totalCount, dtos)); return(result); }
/// <summary> /// 列表 /// </summary> /// <param name="employeeId">员工Id</param> /// <param name="input">查询条件</param> /// <returns>结果</returns> public virtual async Task <PagedResultDto <EducationExperienceListDto> > GetListAsync(Guid employeeId, GetEducationExperiencesInput input) { await NormalizeMaxResultCountAsync(input); var queryable = await _educationExperienceRepository.GetQueryableAsync(); long totalCount = await AsyncExecuter.CountAsync(queryable); var entities = await AsyncExecuter.ToListAsync(queryable .OrderBy(input.Sorting ?? "Id DESC") .Skip(input.SkipCount) .Take(input.MaxResultCount)); var dtos = ObjectMapper.Map <List <EducationExperience>, List <EducationExperienceListDto> >(entities); return(new PagedResultDto <EducationExperienceListDto>(totalCount, dtos)); }
public async Task <PopularResult <PagedResultDto <UnitDto> > > GetListAsync(UnitQueryDto dto) { var result = new PopularResult <PagedResultDto <UnitDto> >(); var queryAble = _unitRepository.Where(x => x.IsDelete == 0) .WhereIf(!dto.Name.IsNullOrWhiteSpace(), unit => unit.Name.Contains(dto.Name)) .WhereIf(!dto.InteriorCode.IsNullOrWhiteSpace(), unit => unit.InteriorCode.Contains(dto.InteriorCode)); var units = await AsyncExecuter.ToListAsync(queryAble.PageBy(dto.SkipCount, dto.MaxResultCount)); var totalCount = await AsyncExecuter.CountAsync(queryAble); var dtos = ObjectMapper.Map <List <UnitEntity>, List <UnitDto> >(units); result.Success(new PagedResultDto <UnitDto>(totalCount, dtos)); return(result); }
/// <summary> /// 列表 /// </summary> /// <param name="input">查询条件</param> /// <returns>结果</returns> public virtual async Task <PagedResultDto <SalaryListDto> > GetListAsync(GetSalarysInput input) { await NormalizeMaxResultCountAsync(input); var queryable = await _salaryRepository.GetQueryableAsync(); long totalCount = await AsyncExecuter.CountAsync(queryable); var entities = await AsyncExecuter.ToListAsync(queryable .OrderBy(input.Sorting ?? "Id DESC") .Skip(input.SkipCount) .Take(input.MaxResultCount)); var dtos = ObjectMapper.Map <List <Salary>, List <SalaryListDto> >(entities); return(new PagedResultDto <SalaryListDto>(totalCount, dtos)); }
public async Task <PopularResult <PagedResultDto <VehicleDto> > > GetListAsync(VehicleQueryDto dto) { var result = new PopularResult <PagedResultDto <VehicleDto> >(); var queryable = _vehicleRepository.Where(x => x.IsDelete == dto.IsDelete) .WhereIf(!dto.License.IsNullOrWhiteSpace(), vehicle => vehicle.License.Contains(dto.License)) .WhereIf(!dto.Vin.IsNullOrWhiteSpace(), vehicle => vehicle.Vin.Contains(dto.Vin)) .WhereIf(dto.UnitId.HasValue, vehicle => vehicle.UnitId == dto.UnitId); var query = from v in queryable.PageBy(dto.SkipCount, dto.MaxResultCount) join u in _unitRepository.WhereIf(dto.UnitId.HasValue, unit => unit.Id == dto.UnitId) on v.UnitId equals u.Id into cls from c in cls.DefaultIfEmpty() select new VehicleEntity(v.Id) { License = v.License, //IsDelete = v.IsDelete, InteriorCode = v.InteriorCode, EngineNo = v.EngineNo, ActivationTime = v.ActivationTime, Color = v.Color, CreateTime = v.CreateTime, Creator = v.Creator, Displacement = v.Displacement, Price = v.Price, PurchaseDate = v.PurchaseDate, Purpose = v.Purpose, Remark = v.Remark, UnitId = v.UnitId, VehicleType = v.VehicleType, Vin = v.Vin, Unit = c }; var vehicles = query.ToList(); var totalCount = await AsyncExecuter.CountAsync(queryable); var dtos = ObjectMapper.Map <List <VehicleEntity>, List <VehicleDto> >(vehicles); result.Success(new PagedResultDto <VehicleDto>(totalCount, dtos)); return(result); }
public override async Task <PagedResultDto <EnterpriseAreaDto> > GetListAsync(PagedAndSortedResultRequestDto input) { await CheckGetListPolicyAsync(); var query = CreateFilteredQuery(input); var totalCount = await AsyncExecuter.CountAsync(query); query = ApplySorting(query, input); query = ApplyPaging(query, input); query = query.Include(a => a.EnterpriseSite); var entities = await AsyncExecuter.ToListAsync(query); return(new PagedResultDto <EnterpriseAreaDto>( totalCount, entities.Select(MapToGetListOutputDto).ToList() )); }
public override async Task <PagedResultDto <ProductDto> > GetListAsync(GetProductListDto input) { await CheckGetListPolicyAsync(); var isCurrentUserStoreAdmin = await AuthorizationService.IsMultiStoreGrantedAsync(input.StoreId, ProductsPermissions.Products.Default, ProductsPermissions.Products.CrossStore); if (input.ShowHidden && !isCurrentUserStoreAdmin) { throw new NotAllowedToGetProductListWithShowHiddenException(); } // Todo: Products cache. var query = CreateFilteredQuery(input); if (!isCurrentUserStoreAdmin) { query = query.Where(x => x.IsPublished); } var totalCount = await AsyncExecuter.CountAsync(query); query = ApplySorting(query, input); query = ApplyPaging(query, input); var products = await AsyncExecuter.ToListAsync(query); var items = new List <ProductDto>(); foreach (var product in products) { var productDto = await MapToGetListOutputDtoAsync(product); await LoadDtoExtraDataAsync(product, productDto, input.StoreId); items.Add(productDto); } await LoadDtosProductGroupDisplayNameAsync(items); return(new PagedResultDto <ProductDto>(totalCount, items)); }
public async Task <PopularResult <PagedResultDto <OilCostDto> > > GetListAsync(OilCostQueryDto dto) { var result = new PopularResult <PagedResultDto <OilCostDto> >(); var queryable = _oilCostRepository.Where(x => x.IsDelete == dto.IsDelete) .WhereIf(!dto.CardNo.IsNullOrWhiteSpace(), oilCost => oilCost.CardNo.Contains(dto.CardNo)) .WhereIf(dto.VehicleId.HasValue, oilCost => oilCost.VehicleId == dto.VehicleId); var query = from v in queryable.PageBy(dto.SkipCount, dto.MaxResultCount) join u in _vehicleRepository.WhereIf(dto.VehicleId.HasValue, vehicle => vehicle.Id == dto.VehicleId) on v.VehicleId equals u.Id into cls from c in cls.DefaultIfEmpty() join d in _dictRepository.Where(x => true) on v.OilTypeId equals d.Id into f from e in f.DefaultIfEmpty() select new OilCostEntity(v.Id) { Balance = v.Balance, CardNo = v.CardNo, Expend = v.Expend, OilType = e, OilTypeId = v.OilTypeId, RefuelingTime = v.RefuelingTime, Vehicle = c, VehicleId = v.VehicleId, //IsDelete = v.IsDelete, CreateTime = v.CreateTime, Creator = v.Creator, Remark = v.Remark, }; var oilCosts = await AsyncExecuter.ToListAsync(query.PageBy(dto.SkipCount, dto.MaxResultCount)); var totalCount = await AsyncExecuter.CountAsync(queryable); var dtos = ObjectMapper.Map <List <OilCostEntity>, List <OilCostDto> >(oilCosts); result.Success(new PagedResultDto <OilCostDto>(totalCount, dtos)); return(result); }
/// <summary> /// 列表 /// </summary> /// <param name="employeeId">员工Id</param> /// <param name="input">查询条件</param> /// <returns>结果</returns> public virtual async Task <PagedResultDto <EmergencyContactListDto> > GetListAsync(Guid employeeId, GetEmergencyContactsInput input) { await NormalizeMaxResultCountAsync(input); var queryable = await _emergencyContactRepository.GetQueryableAsync(); queryable = queryable.Where(q => q.EmployeeId == input.EmployeeId); long totalCount = await AsyncExecuter.CountAsync(queryable); var entities = await AsyncExecuter.ToListAsync(queryable .OrderBy(input.Sorting ?? "Id DESC") .Skip(input.SkipCount) .Take(input.MaxResultCount)); var dtos = ObjectMapper.Map <List <EmergencyContact>, List <EmergencyContactListDto> >(entities); return(new PagedResultDto <EmergencyContactListDto>(totalCount, dtos)); }