public Task <PagedResult <int> > Handle(ToursByPlayerIdQuery request, CancellationToken cancellationToken)
{
var teamPlayerLinksRepo = _uow.GetReadOnlyRepository <TeamPlayerLink>();
IPaginate <TeamPlayerLink> teamPlayerLinks = teamPlayerLinksRepo
.GetList(
tpl => tpl.PlayerId == request.PlayerId,
size: request.Size,
index: request.Page);
if (teamPlayerLinks.Count == 0)
{
return(null);
}
var teamIds = teamPlayerLinks.Items.Select(x => x.TeamId).ToList();
var teamRepo = _uow.GetReadOnlyRepository <Team>();
var result = PagedResult <int> .Create(
teamRepo.GetList(x => teamIds.Contains(x.Id), size : teamIds.Count).Items.Select(x => x.TourId),
teamPlayerLinks.Index,
teamPlayerLinks.Size,
teamPlayerLinks.Pages,
teamPlayerLinks.Count);
return(Task.FromResult(result));
}
private List <UserEntity> ConvertPaginateToList(IPaginate <UserEntity> users)
{
int count = users.Count;
UserEntity[] temp = new UserEntity[count];
users.Items.CopyTo(temp, 0);
return(ConvertArrayToList(temp));
}
public async Task <PagedResult <LeagueDto> > Handle(LeaguesQuery request, CancellationToken cancellationToken)
{
var leagueRepo = _uow.GetRepositoryAsync <League>();
Expression <Func <League, bool> > lPredicate = null;
if (!(request.LeagueId is null) && request.LeagueId.Length != 0)
{
lPredicate = league => request.LeagueId.Contains(league.Id);
}
IPaginate <League> leagues =
await leagueRepo.GetListAsync(
lPredicate,
size : request.Size,
index : request.Page,
include : q => q.Include(league => league.LeaguePlayerLinks),
cancellationToken : cancellationToken);
List <LeagueDto> resultLeagues = leagues.Items
.Select(x => _mapper.Map <LeagueDto>(x))
.ToList();
Func <LeaguePlayerLink, bool> lplPredicate;
if (request.PlayerExternalId is null)
{
if (request.Pid is null || request.Pid.Length == 0)
{
return(GetPagedResult(resultLeagues, leagues));
}
lplPredicate = l => request.Pid.Contains(l.PlayerId);
}
else
{
var playerInternalIdDto = await _playersService.GetInternalIdAsync(request.PlayerExternalId);
if (playerInternalIdDto is null)
{
return(null);
}
lplPredicate = l => l.PlayerId == playerInternalIdDto.InternalId;
}
foreach (var league in leagues.Items)
{
var distinctLinks = league.LeaguePlayerLinks
.Where(lplPredicate)
.OrderBy(p => p.CreationTime)
.GroupBy(p => p.PlayerId)
.Select(g => g.Last())
.ToList();
resultLeagues.First(x => x.Id == league.Id).PlayersLeagueStatuses = EnrichByPlayerInformation(distinctLinks);
}
return(GetPagedResult(resultLeagues, leagues));
}
/// <summary>
/// 教育组可用对象
/// </summary>
/// <param name="shared"></param>
/// <returns></returns>
private async Task <IList <TeacherVO> > EnableComunity(IPaginate <CollabratorEntity> shared)
{
var rev = await this._uproxy.ComunityMemberByUser(this._user.Session);
if (rev == null || rev.Count == 0)
{
return(null);
}
IList <TeacherVO> tv = new List <TeacherVO>();
foreach (var item in rev)
{
//教研组
var comunity = new TeacherVO
{
Id = item.Idx,
Name = item.Name
};
//角色
foreach (var role in item.ChildList)
{
var roleAry = new TeacherVO
{
Id = role.Idx,
Name = role.Name
};
// 教师
foreach (var tc in role.ChildList)
{
if (shared.Count > 0 && shared.Items.Any(t => t.ObjId == tc.Idx))
{
continue;
}
if (tc.Idx == this._user.UserId)
{
continue;
}
roleAry.Children.Add(new TeacherVO
{
Id = tc.Idx,
Name = tc.Name
});
}
comunity.Children.Add(roleAry);
}
tv.Add(comunity);
}
return(tv);
}
public static async Task <string> ResolveResourceId <TResource>(this IPaginate <TResource> repository, ElementReference reference) where TResource : Resource, INamedResource
{
var resource = await repository.FindOne(r => string.Equals(Trim(r.Name), Trim(reference.Name), StringComparison.OrdinalIgnoreCase));
if (resource == null)
{
throw new KeyNotFoundException($"{typeof(TResource).Name} with name '{reference.Name}' not found.");
}
return(resource.Id);
}
private static PagedResult <LeagueDto> GetPagedResult(
List <LeagueDto> resultLeagues,
IPaginate <League> leagues)
{
return(PagedResult <LeagueDto> .Create(
resultLeagues,
leagues.Index,
leagues.Size,
leagues.Pages,
leagues.Count));
}
public Task <PlayersInfoDto> Handle(PlayersInfoQuery request, CancellationToken cancellationToken)
{
var repo = _uow.GetReadOnlyRepository <Player>();
IPaginate <Player> players = repo.GetList();
var playersInfoDto = new PlayersInfoDto()
{
Count = players.Count
};
return(Task.FromResult(playersInfoDto));
}
public Task <LeaguesShortInfoDto> Handle(LeaguesShortInfoQuery request, CancellationToken cancellationToken)
{
var repo = _uow.GetReadOnlyRepository <League>();
IPaginate <League> leagues = repo.GetList();
var leaguesInfoDto = new LeaguesShortInfoDto
{
Count = leagues.Count
};
return(Task.FromResult(leaguesInfoDto));
}
public async Task <IActionResult> Get(string name)
{
IPaginate <ProductsView> result = null;
try
{
result = await _unitOfWork.GetRepositoryAsync <ProductsView>().GetListAsync(p => p.Name.ToLowerInvariant().Contains(name.ToLowerInvariant()));
}
catch (Exception ex)
{
throw ex;
}
return(Ok(result));
}
public async Task <IActionResult> Get()
{
IPaginate <ProductsView> result = null;
try
{
result = await _unitOfWork.GetRepositoryAsync <ProductsView>().GetListAsync();
}
catch (Exception ex)
{
throw ex;
}
return(Ok(result));
}
public async Task <IActionResult> Get()
{
IPaginate <AppMessageLog> result = null;
try
{
result = await _unitOfWork.GetRepositoryAsync <AppMessageLog>().GetListAsync(orderBy: o => o.OrderByDescending(t => t.Id));
}
catch (Exception ex)
{
throw ex;
}
return(Ok(result));
}
public async Task HandleAsync(PlayerRegistered @event, ICorrelationContext context)
{
var playersRepo = _uow.GetRepositoryAsync <Player>();
IPaginate <Player> players = await playersRepo.GetListAsync(p =>
p.FirstName == @event.FirstName &&
p.LastName == @event.LastName); //todo:: case comparison
if (players.Count != 0)
{
var player = players.Items[0]; //todo:: handle all players
var updatedPlayer = Player.GetUpdated(player.Id, player.FirstName, player.LastName, @event.ExternalId);
playersRepo.UpdateAsync(updatedPlayer);
}
else
{
await playersRepo.AddAsync(Player.Create(@event.FirstName, @event.LastName, @event.ExternalId));
}
_uow.SaveChanges();
}
private async Task <IList <TeacherVO> > SchooleEnabled(IPaginate <CollabratorEntity> shared)
{
var school = await this._user.GetSchool();
var t = await this._uproxy.TeacherGroupClass(this._user.Session, school.Code); //this._uproxy.TeacherByClass(session); //await this._uproxy.SchoolTeacherByUser(session);
IList <TeacherVO> ts = new List <TeacherVO>();
var section = t.First().ChildList;
//学段
foreach (var cl in section)
{
//年级
foreach (var grade in cl.ChildList)
{
// 年级节点
var tv = new TeacherVO
{
Id = grade.Idx,
Name = grade.Name,
Children = new List <TeacherVO>()
};
//年级下的班级
foreach (var tc in grade.ChildList)
{
//班级节点
var gradeNode = new TeacherVO
{
Id = tc.Idx,
Name = tc.Name
};
if (tc.ChildList == null || tc.ChildList.Count == 0)
{
continue;
}
//班级下的教师
foreach (var teacherItem in tc.ChildList)
{
if (shared != null && shared.Items.Count > 0 && shared.Items.Any(s => s.ObjId == teacherItem.Idx))
{
continue;
}
if (teacherItem.Idx == this._user.UserId)
{
continue;
}
var teacherNode = new TeacherVO
{
Id = teacherItem.Idx,
Name = teacherItem.Name
};
gradeNode.Children.Add(teacherNode);
}
tv.Children.Add(gradeNode);
}
ts.Add(tv);
}
}
return(ts);
}
public static int Skip(this IPaginate paginate, int defaultPageSize = 100)
{
return((paginate.PageNumber.GetValueOrDefault() - 1) * paginate.PageSize ?? defaultPageSize);
}
public static IQueryable <T> GetPaginate <T>(this IQueryable <T> query, IPaginate paginate)
{
return(query
.Skip(paginate.Page * paginate.Size)
.Take(paginate.Size));
}
public void ResetComments()
{
this.Comments = null;
}
public TakeSkip(IPaginate paginate)
{
Take = paginate.PageSize;
Skip = (paginate.Page - 1) * paginate.PageSize;
}
public IEnumerable <TViewModel> GetPaginated(IPaginate paginate)
{
var result = domainService.GetAll().AsQueryable().GetPaginate(paginate);
return(iMapper.Map <IEnumerable <TEntity>, IEnumerable <TViewModel> >(result));
}
public static int Take(this IPaginate paginate, int defaultPageSize = 100)
{
return(paginate.PageSize ?? defaultPageSize);
}
public async Task <IEnumerable <PlayerWithRate> > Handle(PlayersQuery request, CancellationToken cancellationToken)
{
var repo = _uow.GetReadOnlyRepository <Player>();
Expression <Func <Player, bool> > predicate = null;
if (request.PlayerId != null &&
request.PlayerId.Length != 0)
{
predicate = player => request.PlayerId.Contains(player.Id);
}
IPaginate <Player> players = repo.GetList(
predicate,
include: p => p.Include(a => a.Rates),
index: request.Page,
size: request.Size);
if (players.Count == 0)
{
return(null);
}
var playersWithRates = new List <PlayerWithRate>();
foreach (var player in players.Items)
{
var list = new List <PlayerLeagueRate>();
var rates = request.QueryType == PlayersQueryType.Actual ?
player.Rates
.OrderBy(p => p.Date)
.GroupBy(p => p.LeagueId)
.Select(g => g.Last()) :
player.Rates;
foreach (var rate in rates)
{
if (request.LeagueId != null &&
request.LeagueId.Length != 0 &&
!request.LeagueId.Contains(rate.LeagueId))
{
continue;
}
list.Add(_mapper.Map <PlayerLeagueRate>(rate));
}
if (list.Count != 0)
{
playersWithRates.Add(
new PlayerWithRate
{
Id = player.Id,
FirstName = player.FirstName,
LastName = player.LastName,
PlayerLeagueRates = list
});
}
}
return(playersWithRates);
}
