public async Task When_CancellingSubscribedTutoringSession_Expect_NewSessionCreated()
        {
            var cancelDto = new TutoringSessionCancelDto {
                Reason = "Test reason"
            };
            await _tutoringSessionsService.CancelTutoringSession(7, cancelDto);

            var session = await _context.TutoringSessions.FirstAsync(ts => ts.Id == 8);

            Assert.Equal(TutoringSessionStatusEnum.Upcoming, session.Status);
            Assert.Equal(DateTimeOffset.Now.AddDays(14).Date, session.SessionDate.Date);
        }
        public async Task <IActionResult> CancelTutoringSession(int id, [FromBody] TutoringSessionCancelDto tutoringSessionCancel)
        {
            try
            {
                await _tutoringSessionsService.CancelTutoringSession(id, tutoringSessionCancel);

                return(Ok());
            }
            catch (Exception ex)
            {
                return(BadRequest(ex.Message));
            }
        }
        public async Task When_CancellingTutoringSession_Expect_SessionCancelled()
        {
            var cancelDto = new TutoringSessionCancelDto {
                Reason = "Test reason"
            };
            await _tutoringSessionsService.CancelTutoringSession(4, cancelDto);

            var session = await _context.TutoringSessions.FirstAsync(ts => ts.Id == 4);

            Assert.Equal(TutoringSessionStatusEnum.Cancelled, session.Status);
            Assert.Equal(DateTimeOffset.Now.Date, session.StatusChangeDate.GetValueOrDefault().Date);
            Assert.Equal("Test reason", session.CancellationReason);
        }
        public async Task CancelTutoringSession(int id, TutoringSessionCancelDto tutoringSessionCancel)
        {
            var session = await _tutoringSessionsRepository.GetById(id);

            var currentUserId = _currentUserService.GetUserId();

            if (session.TutorId != currentUserId && session.StudentId != currentUserId)
            {
                throw new InvalidOperationException("You can not cancel this session");
            }

            if (session.Status != TutoringSessionStatusEnum.Upcoming)
            {
                throw new InvalidOperationException("You can not cancel this session");
            }

            session.Status             = TutoringSessionStatusEnum.Cancelled;
            session.StatusChangeDate   = _timeService.GetCurrentTime();
            session.CancellationReason = tutoringSessionCancel.Reason;

            await _tutoringSessionsRepository.Update(session);

            if (session.IsSubscribed)
            {
                var newSession = new TutoringSession
                {
                    CreationDate = _timeService.GetCurrentTime(),
                    IsSubscribed = true,
                    ModuleId     = session.ModuleId,
                    SessionDate  = session.SessionDate.AddDays(7),
                    Status       = TutoringSessionStatusEnum.Upcoming,
                    StudentId    = session.StudentId,
                    TutorId      = session.TutorId
                };

                await _tutoringSessionsRepository.Create(newSession);
            }
        }