Exemple #1
0
        public async Task <Player[]> List(PlayerDataFilter model, bool sudo = false)
        {
            if (!sudo && !model.WantsGame && !model.WantsTeam)
            {
                return new Player[] {}
            }
            ;

            var q = _List(model);

            return(await Mapper.ProjectTo <Player>(q).ToArrayAsync());
        }
Exemple #2
0
        public async Task <Standing[]> Standings(PlayerDataFilter model)
        {
            if (model.gid.IsEmpty())
            {
                return new Standing[] {}
            }
            ;

            model.Filter = model.Filter
                           .Append(PlayerDataFilter.FilterScoredOnly)
                           .ToArray()
            ;

            var q = _List(model);

            return(await Mapper.ProjectTo <Standing>(q).ToArrayAsync());
        }
 private async Task _validate(PlayerDataFilter model)
 {
     await Task.CompletedTask;
 }
Exemple #4
0
        private IQueryable <Data.Player> _List(PlayerDataFilter model)
        {
            var ts = DateTimeOffset.UtcNow;

            var q = Store.List()
                    .Include(p => p.User)
                    .AsNoTracking();

            if (model.WantsGame)
            {
                q = q.Where(p => p.GameId == model.gid);

                if (model.WantsUser)
                {
                    q = q.Where(p => p.UserId == model.uid);
                }

                if (model.WantsOrg)
                {
                    q = q.Where(p => p.Sponsor == model.org);
                }
            }

            if (model.WantsTeam)
            {
                q = q.Where(p => p.TeamId == model.tid);
            }

            if (model.WantsCollapsed || model.WantsActive || model.WantsScored)
            {
                q = q.Where(p => p.Role == PlayerRole.Manager);
            }

            if (model.WantsActive)
            {
                q = q.Where(p => p.SessionBegin < ts && p.SessionEnd > ts);
            }

            if (model.WantsComplete)
            {
                q = q.Where(p => p.SessionEnd > DateTimeOffset.MinValue);
            }

            if (model.WantsAdvanced)
            {
                q = q.Where(p => p.Advanced);
            }

            if (model.WantsDismissed)
            {
                q = q.Where(p => !p.Advanced);
            }

            if (model.WantsPending)
            {
                q = q.Where(u => string.IsNullOrEmpty(u.NameStatus) && u.Name != u.ApprovedName);
            }

            if (model.WantsDisallowed)
            {
                q = q.Where(u => !string.IsNullOrEmpty(u.NameStatus));
            }

            if (model.WantsScored)
            {
                q = q.Where(p => p.Score > 0);
            }

            if (model.Term.NotEmpty())
            {
                string term = model.Term.ToLower();

                q = q.Where(p =>
                            p.ApprovedName.ToLower().Contains(term) ||
                            p.Name.ToLower().Contains(term) ||
                            p.Id.StartsWith(term) ||
                            p.TeamId.StartsWith(term) ||
                            p.UserId.StartsWith(term) ||
                            p.Sponsor.StartsWith(term) ||
                            p.User.Name.ToLower().Contains(term) ||
                            p.User.ApprovedName.ToLower().Contains(term)
                            );
            }

            // TODO: maybe just sort on rank here
            if (model.WantsSortByRank)
            {
                q = q.OrderByDescending(p => p.Score)
                    .ThenBy(p => p.Time)
                    .ThenByDescending(p => p.CorrectCount)
                    .ThenByDescending(p => p.PartialCount)
                    .ThenBy(p => p.Rank)
                    .ThenBy(p => p.ApprovedName);
            }

            if (model.WantsSortByTime)
            {
                q = q.OrderByDescending(p => p.SessionBegin);
            }

            if (model.WantsSortByName)
            {
                q = q.OrderBy(p => p.ApprovedName)
                    .ThenBy(p => p.User.ApprovedName);
            }

            q = q.Skip(model.Skip);

            if (model.Take > 0)
            {
                q = q.Take(model.Take);
            }

            return(q);
        }
 public async Task <Standing[]> Scores([FromQuery] PlayerDataFilter model)
 {
     return(await PlayerService.Standings(model));
 }
 public async Task <Player[]> List([FromQuery] PlayerDataFilter model)
 {
     return(await PlayerService.List(model, Actor.IsRegistrar));
 }