public async Task <List <SongDto> > SongListByPlaylist(int limitfrom, Guid idplaylist)
{
await CheckGetListPolicyAsync();
var query = from playlist in _playlist
join include in _inclus on playlist.Id equals include.playlist_id
join song in _repository on include.song_id equals song.Id
where playlist.user_id == _currentUser.Id && playlist.Id == idplaylist
select song;
query = query.Skip(limitfrom).Take(10);
var queryResult = await AsyncExecuter.ToListAsync(query);
var DTos = queryResult.Select(x =>
{
var dto = ObjectMapper.Map <Song, SongDto>(x);
return(dto);
}).ToList();
return(new List <SongDto>(DTos));
}
public override async Task <PagedResultDto <BookDto> > GetListAsync(PagedAndSortedResultRequestDto input)
{
//Get the IQueryable<Book> from the repository
var queryable = await Repository.GetQueryableAsync();
//Prepare a query to join books and authors
var query = from book in queryable
join author in await _authorRepository.GetQueryableAsync() on book.AuthorId equals author.Id
select new { book, author };
//Paging
query = query
.OrderBy(NormalizeSorting(input.Sorting))
.Skip(input.SkipCount)
.Take(input.MaxResultCount);
//Execute the query and get a list
var queryResult = await AsyncExecuter.ToListAsync(query);
//Convert the query result to a list of BookDto objects
var bookDtos = queryResult.Select(x =>
{
var bookDto = ObjectMapper.Map <Book, BookDto>(x.book);
bookDto.AuthorName = x.author.Name;
return(bookDto);
}).ToList();
//Get the total count with another query
var totalCount = await Repository.GetCountAsync();
return(new PagedResultDto <BookDto>(
totalCount,
bookDtos
));
}
public async Task <List <SongDto> > SonglistByAuthor(string authot, int limitfrom)
{
await CheckGetListPolicyAsync();
var query = from song in _repository
join author in _author on song.author_id equals author.Id
join singerr in _singer on song.singer_id equals singerr.Id
where author.name.StartsWith(authot)
select new { song, author, singerr };
query = query.Skip(limitfrom).Take(10);
var queryResult = await AsyncExecuter.ToListAsync(query);
var DTos = queryResult.Select(x =>
{
var dto = ObjectMapper.Map <Song, SongDto>(x.song);
dto.singername = x.singerr.name;
dto.authorname = x.author.name;
dto.views = x.song.views;
return(dto);
}).ToList();
return(new List <SongDto>(DTos));
}
public async Task <List <SongDto> > ListSong(int limitfrom)
{
await CheckGetListPolicyAsync();
/*
* var query = from song in _repository
* join songsinger in _songsinger on song.Id equals songsinger.song_id
* join singer in _singer on songsinger.singer_id equals singer.Id
* where singer.name.StartsWith(singerr)
* select new { song, singer };
*/
var query = from singer in _singer
join song in _repository on singer.Id equals song.singer_id
join author in _author on song.author_id equals author.Id
select new { song, singer, author };
query = query.Skip(limitfrom).Take(10);
var queryResult = await AsyncExecuter.ToListAsync(query);
var DTos = queryResult.Select(x =>
{
var dto = ObjectMapper.Map <Song, SongDto>(x.song);
dto.authorname = x.author.name;
dto.singername = x.singer.name;
dto.views = x.song.views;
return(dto);
}).ToList();
return(new List <SongDto>(DTos));
}
protected virtual async Task <List <TGetListOutputDto> > GetListAsync(bool IgnoreDisabled, IFilterModel model = null)
{
await CheckGetListPolicyAsync();
var query = CreateFilteredQuery(model);
if (IgnoreDisabled)
{
if (typeof(TEntity).IsAssignableTo <IPassivable>())
{
query = query.Where(e => ((IPassivable)e).IsActive == true);
}
}
query = ApplySorting(query);
var func = CreateGetListOutputFunc(); // 输出的委托
if (func != null)
{
return(func(query));
}
else
{
var entities = await AsyncExecuter.ToListAsync(query);
return(entities.Select(MapToGetListOutputDto).ToList());
}
}
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 <BookDto> > GetListAsync(PagedAndSortedResultRequestDto input)
{
//Prepare a query to join books and authors
var query = from book in Repository
join author in _authorRepository on book.AuthorId equals author.Id
orderby input.Sorting //TODO: Can not sort like that!
select new { book, author };
query = query
.Skip(input.SkipCount)
.Take(input.MaxResultCount);
//异步执行查询并获取列表
var queryResult = await AsyncExecuter.ToListAsync(query);
//将查询结果转换为BookDto对象列表
var bookDtos = queryResult.Select(x =>
{
var bookDto = ObjectMapper.Map <Book, BookDto>(x.book);
bookDto.AuthorName = x.author.Name;
return(bookDto);
}).ToList();
//使用另一个查询获取总数
var totalCount = await Repository.GetCountAsync();
return(new PagedResultDto <BookDto>(
totalCount,
bookDtos
));
}
public async Task <LockupsDto> GetLockupsAsync(int countryId = 0, int stateId = 0)
{
var stateList = new List <State>();
var cityList = new List <City>();
var countryList = await _countryRepository.GetListAsync();
if (countryId > 0)
{
var stateQuery = _stateRepository.Where(s => s.Country.Id == countryId);
stateList = await _asyncExecuter.ToListAsync(stateQuery);
var cityQuery = _cityRepository.Where(c => c.State.Id == stateId);
cityList = await AsyncExecuter.ToListAsync(cityQuery);
}
var doctorSpecialestList = await _doctorSpecialestRepository.GetListAsync();
var doctorTitleList = await _doctorTitleRepository.GetListAsync();
var result = new LockupsDto
{
Country = ObjectMapper.Map <List <Country>, List <CountryDto> >(countryList),
State = ObjectMapper.Map <List <State>, List <StateDto> >(stateList),
City = ObjectMapper.Map <List <City>, List <CityDto> >(cityList),
DoctorSpecialty = ObjectMapper.Map <List <DoctorSpecialty>, List <DoctorSpecialtyDto> >(doctorSpecialestList),
DoctorTitle = ObjectMapper.Map <List <DoctorTitle>, List <DoctorTitleDto> >(doctorTitleList),
};
return(result);
}
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 override async Task <PagedResultDto <BookDto> > GetListAsync(PagedAndSortedResultRequestDto input)
{
//Set a default sorting, if not provided
if (input.Sorting.IsNullOrWhiteSpace())
{
input.Sorting = nameof(Book.Name);
}
//Get the books
var books = await AsyncExecuter.ToListAsync(
Repository
.OrderBy(input.Sorting)
.Skip(input.SkipCount)
.Take(input.MaxResultCount)
);
//Convert to DTOs
var bookDtos = ObjectMapper.Map <List <Book>, List <BookDto> >(books);
//Get a lookup dictionary for the related authors
var authorDictionary = await GetAuthorDictionaryAsync(books);
//Set AuthorName for the DTOs
bookDtos.ForEach(bookDto => bookDto.AuthorName = authorDictionary[bookDto.AuthorId].Name);
//Get the total count with another query (required for the paging)
var totalCount = await Repository.GetCountAsync();
return(new PagedResultDto <BookDto>(
totalCount,
bookDtos
));
}
public virtual async Task <List <Product> > GetProductsInOuIncludingChildrenOptimizedAsync(OrganizationUnit organizationUnit)
{
var ouIds = (await _organizationUnitRepository.GetListAsync())
.Where(ou => ou.Code.StartsWith(organizationUnit.Code)).Select(ou => ou.Id).ToList();
return(await AsyncExecuter.ToListAsync((await _productRepository.GetQueryableAsync()).Where(p => ouIds.Contains(p.OrganizationUnitId))));
}
public override async Task <PagedResultDto <BookDto> > GetListAsync(PagedAndSortedResultRequestDto input)
{
//Prepare a query to join books and authors
var query = from book in Repository
join author in _authorRepository on book.AuthorId equals author.Id
orderby input.Sorting //TODO: Can not sort like that!
select new { book, author };
query = query
.Skip(input.SkipCount)
.Take(input.MaxResultCount);
//Execute the query and get a list
var queryResult = await AsyncExecuter.ToListAsync(query);
//Convert the query result to a list of BookDto objects
var bookDtos = queryResult.Select(x =>
{
var bookDto = ObjectMapper.Map <Book, BookDto>(x.book);
bookDto.AuthorName = x.author.Name;
return(bookDto);
}).ToList();
//Get the total count with another query
var totalCount = await Repository.GetCountAsync();
return(new PagedResultDto <BookDto>(
totalCount,
bookDtos
));
}
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 updateLearnAfterAddWord(Guid idlesson)
{
var query = (from l in _lessonuserrepository
select new { l.UserId }).Distinct();
var queryResult = await AsyncExecuter.ToListAsync(query);
var list = queryResult.Select(x =>
{
var dto = x.UserId;
return(dto);
}).ToList();
var countOfRows = _repository.Count();
var w = _repository.Skip(countOfRows - 1).FirstOrDefault();
//return w;
foreach (Guid l in list)
{
await _learnrepository.InsertAsync(
new Learn
{
UserId = l,
WordId = w.Id,
LessonId = idlesson,
Level = 0,
DateReview = DateTime.Now.AddHours(400),
DateofLearn = DateTime.Now,
Note = ""
}, autoSave : true);
}
}
public async Task <List <BlogPost> > GetPagedListAsync(Guid blogId, int skipCount, int maxResultCount,
string sorting, bool includeDetails = false, CancellationToken cancellationToken = default)
{
var token = GetCancellationToken(cancellationToken);
var dbContext = await GetDbContextAsync(token);
var blogPostQueryable = dbContext.Collection <BlogPost>().AsQueryable();
var usersQueryable = dbContext.Collection <CmsUser>().AsQueryable();
IQueryable <BlogPost> queryable = blogPostQueryable
.Where(x => x.BlogId == blogId);
if (!sorting.IsNullOrWhiteSpace())
{
queryable = queryable.OrderBy(sorting);
}
var combinedQueryable = queryable
.Join(
usersQueryable,
o => o.AuthorId,
i => i.Id,
(blogPost, user) => new { blogPost, user })
.Skip(skipCount)
.Take(maxResultCount);
var combinedResult = await AsyncExecuter.ToListAsync(combinedQueryable, GetCancellationToken(cancellationToken));
return(combinedResult.Select(s =>
{
s.blogPost.Author = s.user;
return s.blogPost;
}).ToList());
}
public async Task <PopularResult <List <VeComStaDto> > > GetVeComStaAsync(VeComStaQueryDto dto)
{
var result = new PopularResult <List <VeComStaDto> >();
var oilCostQuery = _oilCostRepoitory.Where(x => x.RefuelingTime >= dto.StartTime && x.RefuelingTime <= dto.EndTime).GroupBy(x => x.VehicleId).Select(x => new { VeId = x.Key, OilCost = x.Sum(i => i.Expend) });
var mileageQuery = _vehicleMileageRepository.Where(x => x.RecordDate >= dto.StartTime && x.RecordDate <= dto.EndTime).GroupBy(x => x.VehicleId).Select(x => new { VeId = x.Key, Mileage = (x.Max(i => i.Mileage) - x.Min(i => i.Mileage)) });
var maintenanceExpendQuery = _maintenanceRepository.Where(x => x.RecordTime >= dto.StartTime && x.RecordTime <= dto.EndTime).GroupBy(x => x.VehicleId).Select(x => new { VeId = x.Key, maintenanceExpend = x.Sum(i => i.Expend) });
var all = from v in _vehicleRepository.Where(x => x.IsDelete == 0).WhereIf(dto.UnitId.HasValue, x => x.UnitId == dto.UnitId.Value)
join oil in oilCostQuery on v.Id equals oil.VeId into voil
from newvoil in voil.DefaultIfEmpty()
join mil in mileageQuery on v.Id equals mil.VeId into vmil
from newvmil in vmil.DefaultIfEmpty()
join mai in maintenanceExpendQuery on v.Id equals mai.VeId into vmai
from newvmai in vmai.DefaultIfEmpty()
select new VeComStaDto()
{
License = v.License,
OilCost = newvoil.OilCost,
Mileage = newvmil.Mileage,
Maintenance = newvmai.maintenanceExpend
};
var list = await AsyncExecuter.ToListAsync(all);
result.Success(list);
return(result);
}
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 <BoardMessageListDto> GetBoardMessageListByProjectId(Guid projectId)
{
var project = await _projectRepository.GetAsync(x => x.Id == projectId);
var query = from message in Repository.Where(x => x.ProjectId == projectId)
join user in _userRepository on message.CreatorId equals user.Id
select new BoardMessageWithUserDto
{
Id = message.Id,
Title = message.Title,
Content = message.Content,
CreationTime = message.CreationTime,
UserName = user.UserName,
Name = user.Name,
Surname = user.Surname,
CommentCount = _boardMessageCommentRepository.Count(x => x.ParentId == message.Id)
};
var queryResult = await AsyncExecuter.ToListAsync(query);
return(new BoardMessageListDto
{
ProjectId = projectId,
ProjectTitle = project.Title,
ProjectDescription = project.Description,
BoardMessageList = queryResult.OrderByDescending(x => x.CreationTime).ToList()
});
}
public async Task <IList <TariffDto> > AllTariff()
{
var query = TariffRepository.WithDetails();
var entities = await AsyncExecuter.ToListAsync(query);
return(ObjectMapper.Map <IList <Tariff>, IList <TariffDto> >(entities));
}
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 <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 override async Task <PagedResultDto <PedidoDto> > GetListAsync(PagedAndSortedResultRequestDto input)
{
await CheckGetListPolicyAsync();
var query = from pedido in Repository
join cliente in _clienteRepository on pedido.ClienteId equals cliente.Id
join vendedor in _vendedorRepository on pedido.VendedorId equals vendedor.Id
orderby input.Sorting
select new { pedido, cliente, vendedor };
query = query
.Skip(input.SkipCount)
.Take(input.MaxResultCount);
var queryResult = await AsyncExecuter.ToListAsync(query);
var pedidoDtos = queryResult.Select(x =>
{
var pedidoDto = ObjectMapper.Map <Pedido, PedidoDto>(x.pedido);
pedidoDto.ClienteNombre = x.cliente.nombre;
pedidoDto.VendedorNombre = x.vendedor.nombre;
return(pedidoDto);
}).ToList();
//Get the total count with another query
var totalCount = await Repository.GetCountAsync();
return(new PagedResultDto <PedidoDto>(
totalCount,
pedidoDtos
));
}
public async override Task <PagedResultDto <BlogListDto> > GetListAsync(BlogListInput input)
{
await CheckGetListPolicyAsync();
using (input.IgnoreSoftDelete ? DataFilter.Disable <ISoftDelete>() : DataFilter.Enable <ISoftDelete>())
using (input.IgnoreSoftDeleteForPosts ? DataFilter.Disable <ISoftDelete <Posts.Post> >() : DataFilter.Enable <ISoftDelete <Posts.Post> >())
//using (input.IgnoreSoftDelete ? DataFilter.Disable<ISoftDelete<Blog>>() : DataFilter.Enable<ISoftDelete<Blog>>())
{
var query = await CreateFilteredQueryAsync(input);
//if (AbpQueryFilterDemoConsts.UseCustomFiltering && input.IgnoreSoftDelete && input.IgnoreSoftDeleteForPosts)
//{
// query = query.IgnoreAbpQueryFilters();
//}
var totalCount = AbpQueryFilterDemoConsts.ExecuteCountQuery ? await AsyncExecuter.CountAsync(query) : 2;
query = ApplySorting(query, input);
query = ApplyPaging(query, input);
var entities = await AsyncExecuter.ToListAsync(query);
var entityDtos = await MapToGetListOutputDtosAsync(entities);
return(new PagedResultDto <BlogListDto>(totalCount, entityDtos));
}
}
public async Task <StoreOpenDayDto[]> UpdateOpenDayAsync(int branchId, StoreOpenDayDto[] dtoArr)
{
var storeBranchE = await Repository.GetAsync(branchId) ?? throw new EntityNotFoundException();
var openDayEs = await AsyncExecuter.ToListAsync(StoreOpenDayRepository.Where(e => e.StoreBranchID == branchId));
foreach (var entity in openDayEs)
{
var dto = dtoArr.SingleOrDefault(e => e.DayOfWeek == entity.DayOfWeek);
if (dto == null)
{
await StoreOpenDayRepository.DeleteAsync(entity, autoSave : true);
}
else
{
entity.OpeningTime = dto.OpeningTime;
entity.ClosingTime = dto.ClosingTime;
await StoreOpenDayRepository.UpdateAsync(entity, autoSave : true);
}
}
foreach (var dto in dtoArr)
{
var entity = openDayEs.SingleOrDefault(e => e.DayOfWeek == dto.DayOfWeek);
if (entity == null)
{
var cEntity = ObjectMapper.Map <StoreOpenDayDto, StoreOpenDayEntity>(dto);
await StoreOpenDayRepository.InsertAsync(cEntity, autoSave : true);
}
}
openDayEs = await AsyncExecuter.ToListAsync(StoreOpenDayRepository.Where(e => e.StoreBranchID == branchId));
return(ObjectMapper.Map <StoreOpenDayEntity[], StoreOpenDayDto[]>(openDayEs.ToArray()));
}
public async Task <StoreClosingDateDto[]> GetAllClosingDateAsync(int branchId)
{
var eList = await AsyncExecuter.ToListAsync(StoreClosingDateRepository.Where(e => e.StoreBranchID == branchId));
return(ObjectMapper.Map <StoreClosingDateEntity[], StoreClosingDateDto[]>(eList.ToArray())
.OrderBy(dto => dto.ClosingDate)
.ToArray());
}
public async Task <IEnumerable <Student> > Example2()
{
var spec = new AgeSpecification().And(new BalanceSpecification());
var query = _repository.Where(spec.ToExpression());
return(await AsyncExecuter.ToListAsync(query));
}
public virtual async Task <List <Product> > GetProductsInOuIncludingChildrenOptimizedMoreAsync(OrganizationUnit organizationUnit)
{
var ouIds = (await _organizationUnitRepository.GetAllChildrenWithParentCodeAsync(
code: organizationUnit.Code,
parentId: organizationUnit.ParentId)).Select(ou => ou.Id).ToList();
return(await AsyncExecuter.ToListAsync(_productRepository.Where(p => ouIds.Contains(p.OrganizationUnitId))));
}
public override async Task <PagedResultDto <CategoryItemDto> > GetListAsync(PagedAndSortedResultRequestDto input)
{
var categoryItems = await Repository.GetQueryableAsync();
//var query = null;
var query = (from categoryItem in categoryItems
join category in _categoryRepository on categoryItem.CategoryId equals category.Id
join item in _itemRepository on categoryItem.ItemId equals item.Id
select new
{
categoryItem,
category,
item
});
query = query
//.OrderBy(NormalizeSorting(input.Sorting))
.Skip(input.SkipCount)
.Take(input.MaxResultCount);
var queryResult = await AsyncExecuter.ToListAsync(query);
if (!CurrentTenant.Id.HasValue)
{
using (_dataFilter.Disable <IMultiTenant>())
{
queryResult = await AsyncExecuter.ToListAsync(query);
}
}
//_itemRepository = _itemRepository.GetQueryableAsync();
/*
* query = query
* //.OrderBy(NormalizeSorting(input.Sorting))
* .Skip(input.SkipCount)
* .Take(input.MaxResultCount);
* var queryResult = await AsyncExecuter.ToListAsync(query);
*
*
*/
var categoryItemDtos = queryResult.Select(x =>
{
var categoryItemDto = ObjectMapper.Map <CategoryItem, CategoryItemDto>(x.categoryItem);
categoryItemDto.CategoryName = x.category.Name;
categoryItemDto.ItemName = x.item.Name;
return(categoryItemDto);
}).ToList();
var totalCount = await Repository.GetCountAsync();
return(new PagedResultDto <CategoryItemDto>(
totalCount,
categoryItemDtos
));
}
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)
));
}
