static CardDTO[] Cards(AccountDTO[] accounts)
        {
            var countRnd = new RndBuilder <int>()
                           .DistributionValues(new[] { 0, 1, 2 })
                           .DistributionProbabilities(new[] { 50, 40, 10 })
                           .Build();

            return(ValuesGenerator.CreateCards(accounts, countRnd).ToArray());
        }
示例#2
0
        public static SetupAll Generate(int usersCount, DateTime minDate, DateTime maxDate)
        {
            var users        = ValuesGenerator.CreateUsers(usersCount).ToArray();
            var accounts     = Accounts(users);
            var recipientRnd = new RndBuilder <string>().DistributionValues(accounts.Select(a => a.Id)).Build();
            var timestampRnd = new RndBuilder <DateTime>().Min(minDate).Max(maxDate).Build();

            var activePayments   = ActivePayments(accounts, recipientRnd, timestampRnd);
            var loansAndPayments = ActiveLoans(accounts, recipientRnd);

            var totalPaymentsCount = activePayments.Count() + loansAndPayments.Count();
            var interval           = (maxDate - minDate) / totalPaymentsCount;
            var date = minDate;

            foreach (var payment in activePayments)
            {
                payment.LatestProcessingTimestamp = date - payment.Interval;
                payment.StartTimestamp            = date - 2 * payment.Interval;
                date += interval;
            }

            foreach (var pair in loansAndPayments)
            {
                pair.payment.LatestProcessingTimestamp = date - pair.payment.Interval;
                pair.payment.StartTimestamp            = date - ((pair.loan.PaidAmount / pair.loan.TotalAmount) * pair.loan.Instalments) * pair.payment.Interval - pair.payment.Interval;
                date += interval;
            }

            var setupall = new SetupAll
            {
                AccountsSetup = new AccountsSetup {
                    Accounts = accounts
                },
                LoansSetup = new LoansSetup {
                    Loans = loansAndPayments.Select(x => x.loan).ToArray()
                },
                PaymentsSetup = new PaymentsSetup {
                    Payments = loansAndPayments.Select(x => x.payment).Concat(activePayments).ToArray()
                },
                UsersSetup = new UsersSetup {
                    Users = users
                },

                CardsSetup = new CardsSetup {
                    Cards = new CardDTO[0]
                },
                TransactionsSetup = new TransactionsSetup {
                    Transactions = new TransactionDTO[0]
                },
            };

            return(setupall);
        }
        static AccountDTO[] Accounts(UserDTO[] users)
        {
            var countRnd = new RndBuilder <int>()
                           .DistributionValues(new[] { 1, 2 })
                           .DistributionProbabilities(new[] { 80, 20 })
                           .Build();

            var amountRnd = new RndBuilder <float>(new CurrencyRnd())
                            .Min(500)
                            .Max(50000)
                            .DistributionValues(new float[] { 3000, 5000, 10000, 15000, 20000, 35000 })
                            .DistributionProbabilities(new int[] { 20, 25, 20, 15, 10, 5, 5 })
                            .Build();

            return(ValuesGenerator.CreateAccounts(users, countRnd, amountRnd).ToArray());
        }
        //cards loans payments transactions
        public static SetupAll GenerateOverallReportData(int usersCount, int cardsTC, int loansTC, int paymentsTC, int accountsTC, DateTime minDate, DateTime maxDate)
        {
            var users        = ValuesGenerator.CreateUsers(usersCount).ToArray();
            var accounts     = Accounts(users);
            var recipientRnd = new RndBuilder <string>().DistributionValues(accounts.Select(a => a.Id)).Build();
            var timestampRnd = new RndBuilder <DateTime>().Min(minDate).Max(maxDate).Build();

            var cards            = Cards(accounts);
            var activePayments   = ActivePayments(accounts, recipientRnd, timestampRnd);
            var loansAndPayments = ActiveLoans(accounts, recipientRnd);

            var accountsTransactions = AccountsTransactions(accountsTC, accounts, recipientRnd, timestampRnd);
            var loansTransactions    = LoansTransactions(loansTC, loansAndPayments.Select(lp => lp.loan).ToArray(), loansAndPayments.Select(lp => lp.payment).ToArray(), timestampRnd);
            var cardsTransactions    = CardsTransactions(cardsTC, cards, recipientRnd, timestampRnd);
            var paymentsTransactions = PaymentsTransactions(paymentsTC, activePayments, timestampRnd);

            var allTransactions = accountsTransactions
                                  .Concat(loansTransactions)
                                  .Concat(cardsTransactions)
                                  .Concat(paymentsTransactions)
                                  .ToArray();

            var setupall = new SetupAll
            {
                AccountsSetup = new AccountsSetup {
                    Accounts = accounts
                },
                CardsSetup = new CardsSetup {
                    Cards = cards
                },
                LoansSetup = new LoansSetup {
                    Loans = loansAndPayments.Select(x => x.loan).ToArray()
                },
                PaymentsSetup = new PaymentsSetup {
                    Payments = loansAndPayments.Select(x => x.payment).Concat(activePayments).ToArray()
                },
                UsersSetup = new UsersSetup {
                    Users = users
                },
                TransactionsSetup = new TransactionsSetup {
                    Transactions = allTransactions
                },
            };

            return(setupall);
        }
        static PaymentDTO[] ActivePayments(AccountDTO[] accounts, IRnd <string> recipientRnd, IRnd <DateTime> timestampRnd)
        {
            var titleRnd = (TitleRnd) new RndBuilder <string>(new TitleRnd()).Build();
            var countRnd = new RndBuilder <int>()
                           .DistributionValues(new[] { 0, 1, 2 })
                           .DistributionProbabilities(new[] { 50, 40, 10 })
                           .Build();

            var amountRnd = new RndBuilder <float>(new CurrencyRnd()).Min(20).Max(20000)
                            .DistributionValues(new float[] { 500, 1000, 3000, 8000, 15000 })
                            .DistributionProbabilities(new[] { 30, 20, 30, 10, 7, 3 })
                            .Build(); //dystrybuanta
            var startDateRnd = timestampRnd;

            var intervalRnd = new RndBuilder <TimeSpan>()
                              .DistributionValues(new[] { TimeSpan.FromDays(30), TimeSpan.FromDays(90), TimeSpan.FromDays(180), TimeSpan.FromDays(365), })
                              .DistributionProbabilities(new[] { 75, 10, 10, 5 })
                              .Build();

            return(ValuesGenerator.CreatePayments(accounts, PaymentStatus.ACTIVE, recipientRnd, countRnd, amountRnd, startDateRnd, () => DateTime.UtcNow, intervalRnd, titleRnd).ToArray());
        }