예제 #1
0
        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
                       ));
        }
예제 #2
0
        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
                       ));
        }
예제 #3
0
        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)
                       ));
        }
예제 #4
0
        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
                       ));;
        }
예제 #5
0
        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)
                    );
            }));
        }
예제 #7
0
        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)
                       ));
        }
예제 #8
0
        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()
                       ));
        }
예제 #9
0
 public async Task <int> GetCountAsync(Guid blogId, CancellationToken cancellationToken = default)
 {
     return(await AsyncExecuter.CountAsync(
                await WithDetailsAsync(),
                x => x.BlogId == blogId,
                cancellationToken));
 }
예제 #10
0
        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)
                       ));
        }
예제 #12
0
        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)
                       ));
        }
예제 #13
0
        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()
                       ));
        }
예제 #15
0
        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)));
        }
예제 #18
0
        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;
        }
예제 #19
0
        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);
        }
예제 #20
0
        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
                       ));
        }
예제 #21
0
        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()));
        }
예제 #22
0
        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);
        }
예제 #23
0
        /// <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));
        }
예제 #24
0
        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);
        }
예제 #25
0
        /// <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));
        }
예제 #26
0
        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()
                       ));
        }
예제 #28
0
        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));
        }
예제 #29
0
        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);
        }
예제 #30
0
        /// <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));
        }