public Task GetPart(MessageContext context, GetPartPaymentsEvent inputEvent)
        {
            var payments = paymentsRepository.Get(inputEvent.Part, inputEvent.TotalParts, inputEvent.Timestamp);

            publishingRouter.Publish(context.ReplyTo, new SelectedPaymentsEvent {
                Payments = payments
            }, context.FlowId);
            return(Task.CompletedTask);
        }
Exemplo n.º 2
0
        public async Task <BatchData> Get([FromQuery(Name = "part")] int part, [FromQuery(Name = "total")] int total, [FromQuery(Name = "timestamp")] DateTime timestamp)
        {
            var flowId = HttpContext.Items["flowId"].ToString();

            Payment[]        payments = null;
            Loan[]           loans    = null;
            AccountBalance[] balances = null;

            var paymentsFlowId = flowId + "_p";
            var paymentsEvent  = new GetPartPaymentsEvent {
                Part = part, TotalParts = total, Timestamp = timestamp
            };
            var paymentsResponse = await eventsAwaiter.AwaitResponse <SelectedPaymentsEvent>(paymentsFlowId, () => publishingRouter.Publish(Queues.Payments, paymentsEvent, paymentsFlowId, Queues.APIGateway));

            payments = paymentsResponse.Payments;

            var parallelTasks = new List <Task>();

            parallelTasks.Add(Task.Run(async() =>
            {
                var loansFlowId = flowId + "_l";
                var paymentsIds = payments.Select(p => p.Id).ToArray();
                var loansEvent  = new GetLoansByPaymentsEvent {
                    PaymentsIds = paymentsIds
                };
                var loansResponse = await eventsAwaiter.AwaitResponse <SelectedLoansEvent>(loansFlowId, () => publishingRouter.Publish(Queues.Loans, loansEvent, loansFlowId, Queues.APIGateway));
                loans             = loansResponse.Loans;
            }));
            parallelTasks.Add(Task.Run(async() =>
            {
                var balancesFlowId = flowId + "_b";
                var accountsIds    = payments.Select(p => p.AccountId).Distinct().ToArray();
                var balancesEvent  = new GetBalancesEvent {
                    Ids = accountsIds
                };
                var balancesRequest = await eventsAwaiter.AwaitResponse <SelectedBalancesEvent>(balancesFlowId, () => publishingRouter.Publish(Queues.Accounts, balancesEvent, balancesFlowId, Queues.APIGateway));
                balances            = balancesRequest.Balances;
            }));

            await Task.WhenAll(parallelTasks);

            return(new BatchData
            {
                Balances = balances.Select(b => mapper.Map <BalanceDTO>(b)).ToArray(),
                Loans = loans.Select(l => mapper.Map <LoanDTO>(l)).ToArray(),
                Payments = payments.Select(p => mapper.Map <PaymentDTO>(p)).ToArray()
            });
        }