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 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 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 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 <UserDto> Login(LoginDto loginDto)
{
var password = _stringEncryptionService.Encrypt(loginDto.Password);
var user = await AsyncExecuter.FirstOrDefaultAsync(_userRepository.GetAll().Where(t => t.UserName == loginDto.UserName && t.Password == password));
return(ObjectMapper.Map <User, UserDto>(user));
}
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 <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 <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 <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 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 <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 <CategoryItemDto> GetAsync(Guid id)
{
var categoryItems = await Repository.GetQueryableAsync();
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
where categoryItem.Id == id
select new { categoryItem, category, item });
var queryResult = await AsyncExecuter.FirstOrDefaultAsync(query);
if (!CurrentTenant.Id.HasValue)
{
using (_dataFilter.Disable <IMultiTenant>())
{
queryResult = await AsyncExecuter.FirstOrDefaultAsync(query);
}
}
if (queryResult == null)
{
throw new EntityNotFoundException(typeof(CategoryItem), id);
}
var categoryItDto = ObjectMapper.Map <CategoryItem, CategoryItemDto>(queryResult.categoryItem);
categoryItDto.CategoryName = queryResult.category.Name;
categoryItDto.ItemName = queryResult.item.Name;
return(categoryItDto);
}
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 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));
}
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 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 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 virtual async Task <bool> ExistsAsync(Guid blogId, CancellationToken cancellationToken = default)
{
return(await AsyncExecuter.AnyAsync(
await GetQueryableAsync(),
x => x.Id == blogId,
cancellationToken));
}
public async Task <int> GetCountAsync(Guid blogId, CancellationToken cancellationToken = default)
{
return(await AsyncExecuter.CountAsync(
await WithDetailsAsync(),
x => x.BlogId == blogId,
GetCancellationToken(cancellationToken)));
}
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 <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 void TryCreatePlayer(UInt16 lnk, ulong accountId, string planeName, string plyName, Byte pro, Byte sex, Iocp.NetConnection connect, RPC.RPCForwardInfo fwd)
{
//planesName = ServerFrame.DB.DBConnect.SqlSafeString(planesName);
plyName = ServerFrame.DB.DBConnect.SqlSafeString(plyName);
ulong roleId = ServerFrame.Util.GenerateObjID(ServerFrame.GameObjectType.Player);
AsyncExecuter exe = AsyncExecuteThreadManager.Instance.AsyncExe(false);
UInt16 returnSerialId = fwd.ReturnSerialId;
exe.Exec = delegate()
{
RPC.PackageWriter retPkg = new RPC.PackageWriter();
CSCommon.Data.PlayerData result = mPlayerManager.TryCreatePlayer(Thread.PlayerEnterThread.Instance.DBConnect, mPlanesMgr, accountId, roleId, planeName, plyName, pro, sex);
//告诉GateServer，创建是否成功
if (result != null)
{
retPkg.Write((sbyte)1);
retPkg.Write(result.RoleDetail);
retPkg.DoReturnCommand2(connect, returnSerialId);
}
else
{
retPkg.Write((sbyte)-1);
retPkg.DoReturnCommand2(connect, returnSerialId);
}
};
//这里要放到一个专门的队列创建
Thread.PlayerEnterThread.Instance.PushRoleCreator(exe);
}
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()
));
}
/// <summary>
/// (数据库内容本地化demo) 更新指定语言版本
/// </summary>
/// <param name="id"></param>
/// <param name="input"></param>
/// <returns></returns>
public async Task UpdateAsync(Guid id, ProductDto input)
{
using (CultureHelper.Use(input.CultureName))
{
var entity = await AsyncExecuter.FirstOrDefaultAsync(_ProductRepository.WithDetails(s => s.Entries).Where(s => s.Id == id));
entity.ProductCode = input.ProductCode;
if (!entity.Entries.Any())
{
entity.Entries.Add(new DemoProductLocalizableEntry
{
CultureName = input.CultureName,
Title = input.Title,
Description = input.Description,
Name = input.Name
});
}
else
{
entity.Entries.First().Title = input.Title;
entity.Entries.First().Description = input.Description;
entity.Entries.First().Name = input.Name;
}
}
}
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 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 <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 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
));
}
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
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
));
}
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());
}
}
