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