Esempio n. 1
0
        private async Task ValidateCriterionAsync(DrawingCriterion criterion)
        {
            if (criterion.SystemId.HasValue)
            {
                if (!(await _systemRepository.ValidateAsync(
                          criterion.SystemId.Value, criterion.SiteId)))
                {
                    throw new GraException("Invalid System selection.");
                }
                if (criterion.BranchId.HasValue && !(await _branchRepository.ValidateAsync(
                                                         criterion.BranchId.Value, criterion.SystemId.Value)))
                {
                    throw new GraException("Invalid Branch selection.");
                }
            }
            else if (criterion.BranchId.HasValue && !(await _branchRepository.ValidateBySiteAsync(
                                                          criterion.BranchId.Value, criterion.SiteId)))
            {
                throw new GraException("Invalid Branch selection.");
            }

            if (criterion.ProgramId.HasValue && !(await _programRepository.ValidateAsync(
                                                      criterion.ProgramId.Value, criterion.SiteId)))
            {
                throw new GraException("Invalid Program selection.");
            }
        }
Esempio n. 2
0
        public async Task <DrawingCriterion> EditCriterionAsync(DrawingCriterion criterion)
        {
            int authUserId = GetClaimId(ClaimType.UserId);

            if (HasPermission(Permission.PerformDrawing))
            {
                var currentCriterion = await _drawingCriterionRepository.GetByIdAsync(criterion.Id);

                criterion.SiteId          = currentCriterion.SiteId;
                criterion.RelatedBranchId = currentCriterion.RelatedBranchId;
                criterion.RelatedSystemId = currentCriterion.RelatedSystemId;

                if (criterion.ProgramIds != null)
                {
                    var programs = await _programRepository.GetAllAsync(GetCurrentSiteId());

                    if (!programs.Select(_ => _.Id).Except(criterion.ProgramIds).Any())
                    {
                        criterion.ProgramIds = new List <int>();
                    }
                }
                else
                {
                    criterion.ProgramIds = new List <int>();
                }

                return(await _drawingCriterionRepository.UpdateSaveAsync(authUserId, criterion));
            }
            else
            {
                _logger.LogError($"User {authUserId} doesn't have permission to edit criterion {criterion.Id}.");
                throw new GraException("Permission denied.");
            }
        }
        public override async Task <DrawingCriterion> UpdateSaveAsync(int userId,
                                                                      DrawingCriterion criterion)
        {
            var updatedCriterion = await base.UpdateSaveAsync(userId, criterion);

            var thisCriterionPrograms = _context.DrawingCriterionPrograms.AsNoTracking()
                                        .Where(_ => _.DrawingCriterionId == updatedCriterion.Id);

            if (criterion.ProgramIds != null)
            {
                var programsToAdd = criterion.ProgramIds
                                    .Except(thisCriterionPrograms.Select(_ => _.ProgramId))
                                    .Select(_ => new Model.DrawingCriterionProgram()
                {
                    DrawingCriterionId = updatedCriterion.Id,
                    ProgramId          = _
                });
                await _context.DrawingCriterionPrograms.AddRangeAsync(programsToAdd);
            }

            var programsToRemove = thisCriterionPrograms
                                   .Where(_ => !criterion.ProgramIds.Contains(_.ProgramId));

            _context.DrawingCriterionPrograms.RemoveRange(programsToRemove);

            await _context.SaveChangesAsync();

            return(updatedCriterion);
        }
Esempio n. 4
0
        public async Task <DrawingCriterion> AddCriterionAsync(DrawingCriterion criterion)
        {
            int authUserId = GetClaimId(ClaimType.UserId);

            if (HasPermission(Permission.PerformDrawing))
            {
                criterion.SiteId = GetCurrentSiteId();
                return(await _drawingCriterionRepository.AddSaveAsync(authUserId, criterion));
            }
            else
            {
                _logger.LogError($"User {authUserId} doesn't have permission to add a criterion.");
                throw new GraException("Permission denied.");
            }
        }
Esempio n. 5
0
        public async Task <DrawingCriterion> EditCriterionAsync(DrawingCriterion criterion)
        {
            int authUserId = GetClaimId(ClaimType.UserId);

            if (HasPermission(Permission.PerformDrawing))
            {
                var currentCriterion = await _drawingCriterionRepository.GetByIdAsync(criterion.Id);

                criterion.SiteId = currentCriterion.SiteId;
                return(await _drawingCriterionRepository.UpdateSaveAsync(authUserId, criterion));
            }
            else
            {
                _logger.LogError($"User {authUserId} doesn't have permission to edit criterion {criterion.Id}.");
                throw new GraException("Permission denied.");
            }
        }
        public override async Task <DrawingCriterion> AddSaveAsync(int userId,
                                                                   DrawingCriterion criterion)
        {
            var newCriterion = await base.AddSaveAsync(userId, criterion);

            if (criterion.ProgramIds != null)
            {
                var criterionProgramList = new List <Model.DrawingCriterionProgram>();
                foreach (var programId in criterion.ProgramIds)
                {
                    criterionProgramList.Add(new Model.DrawingCriterionProgram()
                    {
                        DrawingCriterionId = newCriterion.Id,
                        ProgramId          = programId
                    });
                }
                await _context.DrawingCriterionPrograms.AddRangeAsync(criterionProgramList);

                await _context.SaveChangesAsync();
            }

            return(newCriterion);
        }
        private IQueryable <int> ApplyCriterion(DrawingCriterion criterion)
        {
            var users = _context.Users
                        .AsNoTracking()
                        .Where(_ => _.IsDeleted == false && _.SiteId == criterion.SiteId);

            if (criterion.ProgramId != null)
            {
                users = users.Where(_ => _.ProgramId == criterion.ProgramId);
            }

            if (criterion.SystemId != null)
            {
                users = users.Where(_ => _.SystemId == criterion.SystemId);
            }

            if (criterion.BranchId != null)
            {
                users = users.Where(_ => _.BranchId == criterion.BranchId);
            }

            if (!criterion.IncludeAdmin)
            {
                users = users.Where(_ => _.IsAdmin == false);
            }

            var userIds = users.Select(_ => _.Id);
            IQueryable <int> activityUsers = null;
            IQueryable <int> pointUsers    = null;

            if (criterion.ActivityAmount != null && criterion.PointTranslationId != null)
            {
                var userLog = _context.UserLogs
                              .AsNoTracking()
                              .Where(_ => _.IsDeleted == false &&
                                     _.ActivityEarned >= criterion.ActivityAmount &&
                                     _.PointTranslationId == criterion.PointTranslationId &&
                                     userIds.Contains(_.UserId));

                if (criterion.StartOfPeriod != null)
                {
                    userLog = userLog.Where(_ => _.CreatedAt >= criterion.StartOfPeriod);
                }
                if (criterion.EndOfPeriod != null)
                {
                    userLog = userLog.Where(_ => _.CreatedAt <= criterion.EndOfPeriod);
                }

                activityUsers = userLog.Select(_ => _.UserId);
            }

            if (criterion.PointsMinimum != null || criterion.PointsMinimum != null)
            {
                IQueryable <int> pointUserStart = activityUsers != null
                    ? activityUsers
                    : userIds;

                var userLog = _context.UserLogs
                              .AsNoTracking()
                              .Where(_ => _.IsDeleted == false &&
                                     pointUserStart.Contains(_.UserId));

                if (criterion.StartOfPeriod != null)
                {
                    userLog = userLog.Where(_ => _.CreatedAt >= criterion.StartOfPeriod);
                }

                if (criterion.EndOfPeriod != null)
                {
                    userLog = userLog.Where(_ => _.CreatedAt <= criterion.EndOfPeriod);
                }

                var pointSum = userLog.GroupBy(_ => _.UserId)
                               .Select(sum => new
                {
                    UserId = sum.Key,
                    Total  = sum.Sum(_ => _.PointsEarned)
                });

                if (criterion.PointsMinimum != null)
                {
                    pointUsers = pointSum
                                 .Where(_ => _.Total >= criterion.PointsMinimum)
                                 .Select(_ => _.UserId);
                }
                if (criterion.PointsMaximum != null)
                {
                    var maxUsers = pointSum
                                   .Where(_ => _.Total <= criterion.PointsMaximum)
                                   .Select(_ => _.UserId);
                    if (pointUsers == null)
                    {
                        pointUsers = maxUsers;
                    }
                    else
                    {
                        pointUsers = pointUsers.Where(_ => maxUsers.Contains(_));
                    }
                }
            }

            if (pointUsers != null)
            {
                return(pointUsers);
            }
            if (activityUsers != null)
            {
                return(activityUsers);
            }
            return(userIds);
        }
        private IQueryable <int> ApplyCriterion(DrawingCriterion criterion)
        {
            var users = _context.Users
                        .AsNoTracking()
                        .Where(_ => _.IsDeleted == false && _.SiteId == criterion.SiteId);

            if (criterion.ProgramId != null)
            {
                users = users.Where(_ => _.ProgramId == criterion.ProgramId);
            }
            else if (criterion.ProgramIds?.Count() > 0)
            {
                users = users.Where(_ => criterion.ProgramIds.Contains(_.ProgramId));
            }

            if (criterion.SystemId != null)
            {
                users = users.Where(_ => _.SystemId == criterion.SystemId);
            }

            if (criterion.BranchId != null)
            {
                users = users.Where(_ => _.BranchId == criterion.BranchId);
            }

            if (!criterion.IncludeAdmin)
            {
                users = users.Where(_ => _.IsAdmin == false);
            }

            if (criterion.ExcludePreviousWinners)
            {
                var previousWinners = _context.PrizeWinners.AsNoTracking()
                                      .Where(_ => _.DrawingId.HasValue)
                                      .Distinct()
                                      .Select(_ => _.UserId);

                users = users.Where(_ => !previousWinners.Contains(_.Id));
            }

            var userIds = users.Select(_ => _.Id);
            IQueryable <int> activityUsers = null;
            IQueryable <int> pointUsers    = null;

            if (criterion.ReadABook)
            {
                var userLog = _context.UserLogs
                              .AsNoTracking()
                              .Where(_ => _.IsDeleted == false &&
                                     _.ActivityEarned > 0 &&
                                     _.PointTranslationId.HasValue &&
                                     userIds.Contains(_.UserId));

                if (criterion.StartOfPeriod != null)
                {
                    userLog = userLog.Where(_ => _.CreatedAt >= criterion.StartOfPeriod);
                }
                if (criterion.EndOfPeriod != null)
                {
                    userLog = userLog.Where(_ => _.CreatedAt <= criterion.EndOfPeriod);
                }

                activityUsers = userLog.Select(_ => _.UserId).Distinct();
            }

            if (criterion.PointsMinimum != null || criterion.PointsMinimum != null)
            {
                IQueryable <int> pointUserStart = activityUsers != null
                    ? activityUsers
                    : userIds;

                var userLog = _context.UserLogs
                              .AsNoTracking()
                              .Where(_ => _.IsDeleted == false &&
                                     pointUserStart.Contains(_.UserId));

                if (criterion.StartOfPeriod != null)
                {
                    userLog = userLog.Where(_ => _.CreatedAt >= criterion.StartOfPeriod);
                }

                if (criterion.EndOfPeriod != null)
                {
                    userLog = userLog.Where(_ => _.CreatedAt <= criterion.EndOfPeriod);
                }

                var pointSum = userLog.GroupBy(_ => _.UserId)
                               .Select(sum => new
                {
                    UserId = sum.Key,
                    Total  = sum.Sum(_ => _.PointsEarned)
                });

                if (criterion.PointsMinimum != null)
                {
                    pointSum = pointSum.Where(_ => _.Total >= criterion.PointsMinimum);
                }
                if (criterion.PointsMaximum != null)
                {
                    pointSum = pointSum.Where(_ => _.Total <= criterion.PointsMaximum);
                }

                pointUsers = pointSum.Select(_ => _.UserId);
            }

            if (pointUsers != null)
            {
                return(pointUsers);
            }
            if (activityUsers != null)
            {
                return(activityUsers);
            }
            return(userIds);
        }