예제 #1
0
        public async Task <CreateSessionResponse> Handle(CreateSessionCommand message)
        {
            var cinema = await _cinemaRepository.GetCinemaById(message.CinemaId);

            if (cinema == null)
            {
                throw new InvalidOperationException($"The cinema with id [{message.CinemaId}] can not be found");
            }

            var film = await _filmRepository.GetFilmById(message.FilmId);

            if (film == null)
            {
                throw new InvalidOperationException($"The film with id [{message.FilmId}] can not be found");
            }

            var screen = cinema.Screens.SingleOrDefault(s => s.Id == message.ScreenId);

            if (screen == null)
            {
                throw new InvalidOperationException($"The screen with id [{message.ScreenId}] can not be found in the cinema [{message.CinemaId}]");
            }

            var session = Session.Create(
                screen,
                film,
                message.Start);

            await _sessionRepository.AddAsync(session);

            await _unitOfWork.CommitAsync();

            return(new CreateSessionResponse(SessionViewModel.FromSession(session)));
        }
        public async Task AddAsync(CreateSessionDTO newSession)
        {
            var session = _mapper.Map <Session>(newSession);

            await SessionValidAsync(session);

            await _sessionRepository.AddAsync(session);
        }
예제 #3
0
        public async Task SaveSessionAsync(Session session)
        {
            using (var transaction = Database.BeginTransaction())
            {
                var sessionDao = Mapper.Map <SessionDao>(session);
                await SessionRepo.AddAsync(sessionDao);

                await TimeEntryRepo.AddAsync(FinalizeTimeEntries(session));

                transaction.Complete();
            }
        }
예제 #4
0
        public async Task <Session> CreateSession(string mobileNumber, Wallet wallet)
        {
            var session = new Session
            {
                ExpireAt  = DateTime.UtcNow.AddMinutes(_sessionSettings.ExpiresInMinutes),
                CreatedAt = DateTime.UtcNow,
                Wallet    = wallet
            };
            await _sessionRepository.AddAsync(session);

            await _sessionRepository.SaveAsync();

            return(session);
        }
        public async Task <SessionResponse> SaveAsync(Session session)
        {
            try
            {
                await _sessionRepository.AddAsync(session);

                await _unitOfWork.CompleteAsync();

                return(new SessionResponse(session));
            }
            catch (Exception ex)
            {
                return(new SessionResponse($"An error ocurred while saving session: {ex.Message}"));
            }
        }
예제 #6
0
        public async Task <IActionResult> Index(SessionViewModel viewModel)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            await _sessionRepository.AddAsync(new SessionModel()
            {
                DateCreated = DateTime.Now,
                Name        = viewModel.Name
            });

            return(RedirectToAction(actionName: nameof(Index)));
        }
예제 #7
0
        public async Task <(ICommandResult result, IReadOnlyList <IDomainEvent> events)> ExecuteAsync(RequestSession command, CancellationToken cancellationToken = default)
        {
            Schedule?schedule;

            try
            {
                schedule = Schedule.Create(command.StartTime, command.EndTime);
            }
            catch (ArgumentException e)
            {
                var result = new ValidationFailureCommandResult($"Schedule is invalid: {e.Message}.");
                result.AddValidationError(e.ParamName, e.Message);
                return(result, DomainEvent.None);
            }

            if (command.Speakers.Any())
            {
                var peopleExists = await Task.WhenAll(command.Speakers.Select(async s =>
                {
                    var name = await _personProjectionStore.GetNameAsync(s);
                    return(id: s, exists: name != null);
                }));

                ValidationFailureCommandResult?vfcr = null;
                foreach (var p in peopleExists.Where(p => !p.exists))
                {
                    vfcr ??= new ValidationFailureCommandResult("Speakers are invalid: unknown speakers");
                    vfcr.AddValidationError(nameof(RequestSession.Speakers), $"{p.id} is unknown");
                }

                if (vfcr != null)
                {
                    return(vfcr, DomainEvent.None);
                }
            }

            var session = new Session(SessionId.New(), command.Speakers, command.Title, command.Description, command.Tags, schedule, SessionStatus.Requested);

            await _sessionRepository.AddAsync(session).ConfigureAwait(false);

            return(new SuccessCommandResult(), new[] { new SessionRequested(session.Id) });
        }
예제 #8
0
        public async Task <SessionResponse> SaveAsync(int tutorId, Session session)
        {
            var existingTutor = await _tutorRepository.FindById(tutorId);

            if (existingTutor == null)
            {
                return(new SessionResponse("Id de tutor no encontrado"));
            }

            try
            {
                session.TutorId = tutorId;
                await _sessionRepository.AddAsync(session);

                await _unitOfWork.CompleteAsync();

                return(new SessionResponse(session));
            }
            catch (Exception e)
            {
                return(new SessionResponse("Has ocurred an error saving the session " + e.Message));
            }
        }
예제 #9
0
 public async Task RegisterAsync(Category category, DateTime startTime, DateTime finishTime, IEnumerable <IPoint> gpsPoints, string note)
 {
     var session = new Session(category, startTime, finishTime, gpsPoints);
     await _sessionRepository.AddAsync(session);
 }