Пример #1
0
        public async Task <ServiceResult> CreateScheduleRequest(Guid originTeamId, DTO.MatchSeries.CreateScheduleRequest payload)
        {
            var result     = new ServiceResult();
            var originTeam = await this.alexandriaContext.Teams.Include(t => t.OriginatingScheduleRequests).FirstOrDefaultAsync(t => t.Id == originTeamId);

            if (originTeam == null)
            {
                result.Error = Shared.ErrorKey.Team.TeamNotFound;
                return(result);
            }

            var targetTeamExists = await this.alexandriaContext.Teams.AnyAsync(t => t.Id == payload.TargetTeamId);

            if (!targetTeamExists)
            {
                result.Error = Shared.ErrorKey.Team.TeamNotFound;
                return(result);
            }

            var timeSlotTaken = originTeam.OriginatingScheduleRequests.Any(osr => osr.State == Shared.Enums.ScheduleRequestState.Pending && osr.MatchSeriesId == payload.MatchSeriesId);

            if (timeSlotTaken)
            {
                result.Error = Shared.ErrorKey.ScheduleRequest.ScheduleRequestWithTimeslotAlreadyExists;
                return(result);
            }

            if (payload.MatchSeriesId.HasValue && payload.MatchSeriesId.Value != Guid.Empty)
            {
                var match = await this.alexandriaContext.MatchSeries.FirstOrDefaultAsync(ms => ms.Id == payload.MatchSeriesId.Value);

                if (match == null)
                {
                    result.Error = Shared.ErrorKey.MatchSeries.NotFound;
                    return(result);
                }

                if (match.Type != payload.MatchType)
                {
                    result.Error = Shared.ErrorKey.ScheduleRequest.UnmatchingMatchTypes;
                    return(result);
                }
            }

            var scheduleRequest = this.DangerouslyCreateScheduleRequest(originTeamId, payload);

            if (scheduleRequest != null)
            {
                result.Succeed();
            }

            return(result);
        }
        public async Task <OperationResult> CreateScheduleRequest(DTO.MatchSeries.CreateScheduleRequest payload)
        {
            if (this.resourceId == Guid.Empty)
            {
                return(new OperationResult <IList <DTO.MatchSeries.ScheduleRequest> >(404));
            }

            var result = await this.matchService.CreateScheduleRequest(this.resourceId, payload);

            if (result.Success)
            {
                return(new OperationResult(201));
            }

            return(new OperationResult(result.Error));
        }
Пример #3
0
        private EF.Models.MatchSeriesScheduleRequest DangerouslyCreateScheduleRequest(Guid originTeamId, DTO.MatchSeries.CreateScheduleRequest payload)
        {
            var scheduleRequest = new EF.Models.MatchSeriesScheduleRequest(originTeamId, payload.TargetTeamId, payload.MatchType, payload.ProposedTimeSlot, payload.MatchSeriesId);

            this.alexandriaContext.MatchSeriesScheduleRequests.Add(scheduleRequest);

            return(scheduleRequest);
        }