Exemple #1
0
        public Task Setup(SetupAll setup)
        {
            var usersEvent = mapper.Map <SetupUsersEvent>(setup.UsersSetup);

            this.publishingRouter.Publish(Queues.Users, usersEvent, null);

            var accountsEvent = mapper.Map <SetupAccountsEvent>(setup.AccountsSetup);

            this.publishingRouter.Publish(Queues.Accounts, accountsEvent, null);

            var cardsEvent = mapper.Map <SetupCardsEvent>(setup.CardsSetup);

            this.publishingRouter.Publish(Queues.Cards, cardsEvent, null);

            for (int i = 0; i < setup.LoansSetup.loans.Length; i += 10000)
            {
                var portion    = setup.LoansSetup.loans.Skip(i).Take(10000).ToArray();
                var loansEvent = new SetupAppendLoansEvent {
                    Loans = portion.Select(l => mapper.Map <Loan>(l)).ToArray()
                };
                this.publishingRouter.Publish(Queues.Loans, loansEvent, null);
            }

            for (int i = 0; i < setup.PaymentsSetup.payments.Length; i += 10000)
            {
                var portion       = setup.PaymentsSetup.payments.Skip(i).Take(10000).ToArray();
                var paymentsEvent = new SetupAppendPaymentsEvent {
                    Payments = portion.Select(p => mapper.Map <Payment>(p)).ToArray()
                };
                this.publishingRouter.Publish(Queues.Payments, paymentsEvent, null);
            }

            for (int i = 0; i < setup.TransactionsSetup.transactions.Length; i += 10000)
            {
                var portion           = setup.TransactionsSetup.transactions.Skip(i).Take(10000).ToArray();
                var transactionsEvent = new SetupAppendTransactionsEvent {
                    Transactions = portion.Select(t => mapper.Map <Transaction>(t)).ToArray()
                };
                this.publishingRouter.Publish(Queues.Transactions, transactionsEvent, null);
            }

            return(Task.CompletedTask);
        }
Exemple #2
0
        public async Task Setup(SetupAll setup)
        {
            var usersRequest = mapper.Map <UsersMicroservice.SetupRequest>(setup.UsersSetup);
            await usersClient.SetupAsync(usersRequest);

            var accountsRequest = mapper.Map <AccountsMicroservice.SetupRequest>(setup.AccountsSetup);
            await accountsClient.SetupAsync(accountsRequest);

            var cardsRequest = mapper.Map <CardsMicroservice.SetupRequest>(setup.CardsSetup);
            await cardsClient.SetupAsync(cardsRequest);

            for (int i = 0; i < setup.LoansSetup.loans.Length; i += 10000)
            {
                var portion = setup.LoansSetup.loans.Skip(i).Take(10000).ToArray();
                var request = mapper.Map <LoansMicroservice.SetupRequest>(new LoansSetup {
                    loans = portion
                });
                await loansClient.SetupAppendAsync(request);
            }

            for (int i = 0; i < setup.PaymentsSetup.payments.Length; i += 10000)
            {
                var portion = setup.PaymentsSetup.payments.Skip(i).Take(10000).ToArray();
                var request = mapper.Map <PaymentsMicroservice.SetupRequest>(new PaymentsSetup {
                    payments = portion
                });
                await paymentsClient.SetupAppendAsync(request);
            }

            for (int i = 0; i < setup.TransactionsSetup.transactions.Length; i += 10000)
            {
                var portion = setup.TransactionsSetup.transactions.Skip(i).Take(10000).ToArray();
                var request = mapper.Map <TransactionsMicroservice.SetupRequest>(new TransactionsSetup {
                    transactions = portion
                });
                await transactionsClient.SetupAppendAsync(request);
            }
        }
        public static string[] BusinessUserScenario(SetupAll setup, int clients, int actionsPerGroup, int minTransactions, int maxTransacitons, int requesters)
        {
            var users = setup.UsersSetup.Users.Where(u => u.Business)
                        .Select((u, i) => new { index = i, user = u })
                        .ToArray();
            var usersDict = users.ToDictionary(k => k.user.Id, v => v.user);
            var groups    = users.GroupBy(u => u.index % clients);
            var accounts  = setup.AccountsSetup.Accounts
                            .GroupBy(a => a.UserId)
                            .ToDictionary(k => k.Key, v => v.ToArray());

            var minAmount = 50;
            var amountRnd = new RndBuilder <float>(new CurrencyRnd()).Min(minAmount).Max(10000)
                            .DistributionValues(new float[] { 300, 500, 1500, 2500, 5000, 8000 })
                            .DistributionProbabilities(new[] { 2, 15, 20, 30, 25, 5, 3 })
                            .Build();
            var titelRnd             = new TitleRnd();
            var transactionsCountRnd = new RndBuilder <int>().Min(minTransactions).Max(maxTransacitons).Build();

            var allActions = new List <BusinessUserScenarioElement>();
            var no         = 0;

            foreach (var group in groups)
            {
                var groupCount    = group.Count();
                var groupAccounts = group.Where(g => accounts.ContainsKey(g.user.Id)).SelectMany(g => accounts[g.user.Id]).ToArray();
                var usersAccounts = groupAccounts.GroupBy(a => a.UserId).ToDictionary(k => k.Key, v => v.ToArray());

                for (int actions = 0; actions < actionsPerGroup; actions++)
                {
                    var user              = group.ElementAt(rand.Next(0, groupCount)).user;
                    var userAccounts      = usersAccounts[user.Id];
                    var transactionsCount = transactionsCountRnd.Next();
                    var userActions       = new List <BusinessUserTransaction>();

                    for (int i = 0; i < transactionsCount; i++)
                    {
                        if (userAccounts.All(a => a.Balance < minAmount))
                        {
                            continue;
                        }
                        var amount    = GetAmount(userAccounts, amountRnd);
                        var sender    = GetSender(amount, userAccounts);
                        var recipient = groupAccounts.ElementAt(rand.Next(0, groupAccounts.Length));

                        userActions.Add(new BusinessUserTransaction {
                            Amount = amount, AccountId = sender.Id, Recipient = recipient.Id, Title = titelRnd.Next()
                        });

                        sender.Balance    -= amount;
                        recipient.Balance += amount;
                    }

                    allActions.Add(new BusinessUserScenarioElement {
                        No = (no++).ToString(), Group = group.Key, UserId = user.Id, User = user.Login, Transactions = userActions.ToArray()
                    });
                }
            }

            return(allActions.GroupBy(a => a.Group % requesters).Select(g => JsonConvert.SerializeObject(g)).ToArray());
        }