示例#1
0
        public async Task <GetLimitsOperationResponse> Execute(GetLimitsOperationRequest request)
        {
            var employee = await _authorizationContext.CurrentEmployee();

            var limit = await _limitRepository.GetByEmployeeIdAsync(employee.Id);

            var getRemainingLimitsRequest = new GetRemainingLimitsForQuarterOperationRequest
            {
                Quarter = request.Date.GetQuarter()
            };

            var remainingLimit = await _getRemainingLimitsForQuarterOperation.Execute(getRemainingLimitsRequest);

            return(new GetLimitsOperationResponse
            {
                Id = limit.Id,
                AssignedLimit = new GetLimitsOperationResponse.Limit
                {
                    DaysPerQuarter = limit.DaysPerQuarter,
                    TopicsPerDay = limit.TopicsPerDay
                },
                RemainingLimit = new GetLimitsOperationResponse.Limit
                {
                    DaysPerQuarter = remainingLimit.DaysPerQuarter,
                    TopicsPerDay = limit.TopicsPerDay
                }
            });
        }
示例#2
0
        public async Task <GetRemainingLimitsForQuarterOperationResponse> Execute(GetRemainingLimitsForQuarterOperationRequest request)
        {
            var currentEmployee = await _authorizationContext.CurrentEmployee();

            var assignedLimit = await _limitRepository.QuerySingleOrDefaultAsync(limit =>
                                                                                 limit.Employees.Any(employee => employee.Id == currentEmployee.Id));

            var learningDaysInQuarter = (await _learningDayRepository.GetByEmployeeIdForQuarterAsync(currentEmployee.Id, request.Quarter)).Count;

            var remainingDaysPerQuarter = assignedLimit.DaysPerQuarter - learningDaysInQuarter;

            return(new GetRemainingLimitsForQuarterOperationResponse
            {
                DaysPerQuarter = remainingDaysPerQuarter
            });
        }
示例#3
0
        private async Task ThrowIfInvalidLearningDayAsync(Guid employeeId, DateTime date)
        {
            var getRemainingLimitsRequest = new GetRemainingLimitsForQuarterOperationRequest
            {
                Quarter = date.GetQuarter()
            };

            var remainingLimits = await _getRemainingLimitsForQuarterOperation.Execute(getRemainingLimitsRequest);

            if (remainingLimits.DaysPerQuarter <= 0)
            {
                throw new LimitExceededException(nameof(remainingLimits.DaysPerQuarter));
            }

            if ((await _learningDayRepository.QueryAsync(learningDay =>
                                                         learningDay.EmployeeId == employeeId && learningDay.Date == date)).Any())
            {
                throw new LearningDayAlreadyExistsException(date);
            }
        }