コード例 #1
0
        public async Task <IEnumerable <OrderModel> > Handle(GetRunOrdersQuery request,
                                                             CancellationToken cancellationToken)
        {
            var run = _runRepository.GetAsync(request.RunId);

            var orders = (await _orderRepository.GetOrdersAsync(request.RunId).ConfigureAwait(false)).ToList();

            if (orders.Count == 0)
            {
                return(new List <OrderModel>());
            }

            var users   = _userRepository.GetManyAsync(orders.Select(o => o.UserId)).ConfigureAwait(false);
            var options = _optionsRepository.GetManyAsync(orders.Select(o => o.OptionId)).ConfigureAwait(false);

            var userDict    = (await users).ToDictionary(k => k.Id);
            var optionsDict = (await options).ToDictionary(k => k.Id);

            var models = new List <OrderModel>();

            foreach (var order in orders)
            {
                models.Add(new OrderModel
                {
                    Id          = order.Id,
                    CreatedDate = order.CreatedDate,
                    Run         = await run.ConfigureAwait(false),
                    User        = userDict[order.UserId],
                    Option      = optionsDict[order.OptionId]
                });
            }

            return(models);
        }
コード例 #2
0
        //End run
        public async Task <Unit> Handle(EndRunCommand request, CancellationToken cancellationToken)
        {
            var run = await _runRepository.GetAsync(request.RunId).ConfigureAwait(false);

            var runnerUserId = await GetRunner(request).ConfigureAwait(false);

            //update run
            run.Ended = true;
            await _runRepository.UpdateAsync(run).ConfigureAwait(false);

            //store result
            var runResult = new RunResult
            {
                RunId        = request.RunId,
                RunnerUserId = runnerUserId,
                EndedTime    = _clock.UtcNow()
            };

            await _runRepository.CreateResultAsync(runResult).ConfigureAwait(false);

            //publish event
            var evt = new RunEndedEvent
            {
                Orders       = request.Orders,
                RoomId       = request.RoomId,
                RunnerUserId = runResult.RunnerUserId,
                RunId        = runResult.RunId,
                EndedTime    = runResult.EndedTime,
                State        = request.State
            };

            await _eventPublisher.Publish(evt).ConfigureAwait(false);

            return(Unit.Value);
        }
コード例 #3
0
        public async Task <PermisionCheckResult> CheckAsync(EndRunCommand request)
        {
            var run = await _runRepository.GetAsync(request.RunId).ConfigureAwait(false);

            if (run == null)
            {
                return(PermisionCheckResult.Ok());
            }

            //only allow person who started the run to end it
            if (run.UserId != request.UserId)
            {
                return(PermisionCheckResult.NotOk("Only the person who started the round can end it"));
            }

            return(PermisionCheckResult.Ok());
        }