public void loan_517()
        {
            var calculator = new LoanScheduleCalculator()
            {
                Interest = 0.06M, Term = 3
            };

            calculator.Calculate(1000, _loan, Parse("2012-10-26 00:00:00.000"));
            _loan.Status = LoanStatus.Live;

            var rollover = new PaymentRollover()
            {
                Created      = Parse("2012-12-26 18:02:54.000"),
                ExpiryDate   = Parse("2012-12-29 00:00:00.000"),
                Status       = RolloverStatus.New,
                LoanSchedule = _loan.Schedule[0],
                Payment      = 50
            };

            _loan.Schedule[0].Rollovers.Add(rollover);

            Console.WriteLine(_loan);

            MakePayment(170m, Parse("2012-12-26 16:03:42.000"));

            var payEarlyCalc = new LoanRepaymentScheduleCalculator(_loan, Parse("2012-12-26 16:03:42.000"), 0);
            var state        = payEarlyCalc.GetState();

            Assert.That(rollover.PaidPaymentAmount, Is.EqualTo(50m));
            Assert.That(_loan.TransactionsWithPaypoint[0].Rollover, Is.EqualTo(50m));
            Assert.That(_loan.TransactionsWithPaypoint[0].Interest, Is.EqualTo(120m));
            Assert.That(_loan.TransactionsWithPaypoint[0].LoanRepayment, Is.EqualTo(0m));
        }
        public void loan_582_Taras()
        {
            var calculator = new LoanScheduleCalculator()
            {
                Interest = 0.06M, Term = 3
            };

            calculator.Calculate(1000, _loan, Parse("2012-10-30 00:00:00.000"));
            _loan.Status = LoanStatus.Live;

            var rollover = new PaymentRollover()
            {
                Created      = Parse("2012-12-28 16:00:31.000"),
                ExpiryDate   = Parse("2012-12-31 00:00:00.000"),
                Status       = RolloverStatus.New,
                LoanSchedule = _loan.Schedule[1],
                Payment      = 50
            };

            _loan.Schedule[1].Rollovers.Add(rollover);

            Console.WriteLine(_loan);

            var payEarlyCalc = new LoanRepaymentScheduleCalculator(_loan, Parse("2012-12-28 14:00:53.000"), 0);
            var state        = payEarlyCalc.GetState();

            Assert.That(state.Fees + state.Interest, Is.EqualTo(116m + 50m));
        }
        //https://trello.com/c/IhYey6dp
        public void trello_card_162()
        {
            var calculator = new LoanScheduleCalculator()
            {
                Interest = 0.06M, Term = 3
            };

            calculator.Calculate(1000, _loan, Parse("2012-11-25 00:00:00.000"));
            _loan.Status = LoanStatus.Live;

            var rollover = new PaymentRollover()
            {
                Created      = Parse("2012-12-22 16:59:04.000"),
                ExpiryDate   = Parse("2012-12-25 00:00:00.000"),
                Status       = RolloverStatus.New,
                LoanSchedule = _loan.Schedule[1],
                Payment      = 50
            };

            _loan.Schedule[1].Rollovers.Add(rollover);

            Console.WriteLine(_loan);

            MakePayment(54.00m, Parse("2012-12-22 15:00:15.000"));
            MakePayment(36.00m, Parse("2012-12-22 15:01:21.000"));

            Assert.That(_loan.TransactionsWithPaypoint[0].Interest, Is.EqualTo(54m));

            Assert.That(rollover.PaidPaymentAmount, Is.EqualTo(36m));
            Assert.That(_loan.TransactionsWithPaypoint[1].Rollover, Is.EqualTo(36m));
        }
        //https://trello.com/c/IhYey6dp
        public void trello_card_191()
        {
            var calculator = new LoanScheduleCalculator()
            {
                Interest = 0.06M, Term = 3
            };

            calculator.Calculate(1000, _loan, Parse("2012-11-20 00:00:00.000"));
            _loan.Status = LoanStatus.Live;

            var rollover = new PaymentRollover()
            {
                Created      = Parse("2012-12-24 17:25:49.000"),
                ExpiryDate   = Parse("2012-12-27 00:00:00.000"),
                Status       = RolloverStatus.New,
                LoanSchedule = _loan.Schedule[1],
                Payment      = 50
            };

            _loan.Schedule[1].Rollovers.Add(rollover);

            Console.WriteLine(_loan);

            MakePayment(54.00m, Parse("2012-12-24 15:26:17.000"));
            MakePayment(36.00m, Parse("2012-12-24 15:26:53.000"));
            MakePayment(30.00m, Parse("2012-12-24 15:27:41.000"));

            Assert.That(rollover.PaidPaymentAmount, Is.EqualTo(50m));
            Assert.That(_loan.TransactionsWithPaypoint[2].Rollover, Is.EqualTo(27.74m));
        }
        public void loan_121()
        {
            var calculator = new LoanScheduleCalculator()
            {
                Interest = 0.07M, Term = 6
            };

            calculator.Calculate(6300, _loan, Parse("2012-11-18 11:56:41.000"));

            Console.WriteLine(_loan);

            MakePayment(670, Parse("2012-11-23 14:23:14.000"));
            MakePayment(521, Parse("2012-11-23 22:31:21.000"));
            MakePayment(500, Parse("2012-11-24 10:21:15.000"));
            MakePayment(238, Parse("2012-11-25 12:16:00.000"));

            Assert.That(_loan.Schedule[0].Status, Is.EqualTo(LoanScheduleStatus.PaidEarly));
            Assert.That(_loan.Schedule[1].Status, Is.EqualTo(LoanScheduleStatus.StillToPay));
            Assert.That(_loan.Schedule[2].Status, Is.EqualTo(LoanScheduleStatus.StillToPay));
            Assert.That(_loan.Schedule[3].Status, Is.EqualTo(LoanScheduleStatus.StillToPay));
            Assert.That(_loan.Schedule[4].Status, Is.EqualTo(LoanScheduleStatus.StillToPay));
            Assert.That(_loan.Schedule[5].Status, Is.EqualTo(LoanScheduleStatus.StillToPay));

            Assert.That(_loan.DateClosed, Is.Null);

            Assert.That(_loan.Schedule[0].AmountDue, Is.EqualTo(0m));
            Assert.That(_loan.Schedule[1].AmountDue, Is.EqualTo(820.03m));
            Assert.That(_loan.Schedule[2].AmountDue, Is.EqualTo(1344.0m));
            Assert.That(_loan.Schedule[3].AmountDue, Is.EqualTo(1270.5m));
            Assert.That(_loan.Schedule[4].AmountDue, Is.EqualTo(1197.0m));
            Assert.That(_loan.Schedule[5].AmountDue, Is.EqualTo(1123.5m));
        }
        //https://trello.com/c/MeFaqtiZ
        public void trello_card_122_totalearlypayment()
        {
            var calculator = new LoanScheduleCalculator()
            {
                Interest = 0.06M
            };

            calculator.Calculate(1110, _loan, Parse("2012-12-14 11:11:38.000"));
            _loan.Status = LoanStatus.Live;

            MakePayment(378.59m, Parse("2012-12-18 14:47:08.000"));
            MakePayment(731.41m, Parse("2012-12-18 15:01:07.000"));

            Console.WriteLine(_loan);

            var calc = new LoanRepaymentScheduleCalculator(_loan, Parse("2012-12-21 11:11:38.000"), 0);

            var payment = calc.TotalEarlyPayment();
            var next    = calc.NextEarlyPayment();

            Console.WriteLine(_loan);

            Assert.That(payment, Is.EqualTo(8.64m));
            Assert.That(next, Is.EqualTo(8.64m));
        }
        public void loan_67()
        {
            var calculator = new LoanScheduleCalculator()
            {
                Interest = 0.06M
            };

            calculator.Calculate(2000, _loan, Parse("2012-10-15 19:18:25.000"));

            Console.WriteLine(_loan);

            MakePayment(240, Parse("2012-11-09 13:04:40.000"));
            MakePayment(550, Parse("2012-11-13 22:23:49.000"));
            MakePayment(100, Parse("2012-11-14 19:33:30.000"));
            MakePayment(142, Parse("2012-11-14 19:35:05.000"));

            Assert.That(_loan.Schedule[0].Status, Is.EqualTo(LoanScheduleStatus.PaidEarly));
            Assert.That(_loan.Schedule[1].Status, Is.EqualTo(LoanScheduleStatus.StillToPay));
            Assert.That(_loan.Schedule[2].Status, Is.EqualTo(LoanScheduleStatus.StillToPay));

            Assert.That(_loan.DateClosed, Is.Null);

            Assert.That(_loan.Schedule[0].AmountDue, Is.EqualTo(0m));
            Assert.That(_loan.Schedule[1].AmountDue, Is.EqualTo(482.7m));
            Assert.That(_loan.Schedule[2].AmountDue, Is.EqualTo(705.96m));
        }
        public void loan_147()
        {
            var calculator = new LoanScheduleCalculator()
            {
                Interest = 0.07M
            };

            calculator.Calculate(400, _loan, new DateTime(2012, 11, 24, 19, 57, 02));

            Console.WriteLine(_loan);

            MakePayment(100, new DateTime(2012, 12, 02, 10, 0, 0));
            MakePayment(100, new DateTime(2012, 12, 02, 11, 0, 0));

            Assert.That(_loan.Schedule[1].Interest, Is.EqualTo(25.17m));
            Assert.That(_loan.Schedule[1].LoanRepayment, Is.EqualTo(74.47m));

            MakePayment(100, new DateTime(2012, 12, 02, 12, 0, 0));
            MakePayment(55, new DateTime(2012, 12, 02, 13, 0, 0));

            Assert.That(_loan.TransactionsWithPaypointSuccesefull[0].Interest, Is.EqualTo(7.47m));

            Assert.That(_loan.Schedule[0].Status, Is.EqualTo(LoanScheduleStatus.PaidEarly));
            Assert.That(_loan.Schedule[1].Status, Is.EqualTo(LoanScheduleStatus.PaidEarly));
            Assert.That(_loan.Schedule[2].Status, Is.EqualTo(LoanScheduleStatus.StillToPay));

            Assert.That(_loan.DateClosed, Is.Null);
        }
        public void loan_41()
        {
            var calculator = new LoanScheduleCalculator()
            {
                Interest = 0.05M
            };

            calculator.Calculate(18000, _loan, new DateTime(2012, 09, 20, 11, 00, 10));

            Console.WriteLine(_loan);

            MakePayment(6780, new DateTime(2012, 10, 16, 11, 09, 35));

            Assert.That(_loan.Schedule[0].Status, Is.EqualTo(LoanScheduleStatus.PaidEarly));
            Assert.That(_loan.Schedule[1].Status, Is.EqualTo(LoanScheduleStatus.StillToPay));
            Assert.That(_loan.Schedule[2].Status, Is.EqualTo(LoanScheduleStatus.StillToPay));

            Assert.That(_loan.DateClosed, Is.Null);

            MakePayment(12665, new DateTime(2012, 11, 19, 09, 04, 18));

            Assert.That(_loan.Schedule[0].Status, Is.EqualTo(LoanScheduleStatus.PaidEarly));
            Assert.That(_loan.Schedule[1].Status, Is.EqualTo(LoanScheduleStatus.PaidEarly));
            Assert.That(_loan.Schedule[2].Status, Is.EqualTo(LoanScheduleStatus.PaidEarly));

            Assert.That(_loan.DateClosed, Is.Not.Null);
        }
Exemple #10
0
        public void double_principal_bug()
        {
            var calculator = new LoanScheduleCalculator()
            {
                Interest = 0.06M, Term = 3
            };

            calculator.Calculate(1000, _loan, Parse("2012-10-27 18:43:59.000"));
            _loan.Status = LoanStatus.Live;

            var rollover = new PaymentRollover()
            {
                Created      = Parse("2012-12-27 20:46:25.000"),
                ExpiryDate   = Parse("2012-12-28 00:00:00.000"),
                Status       = RolloverStatus.New,
                LoanSchedule = _loan.Schedule[0],
                Payment      = 50
            };

            _loan.Schedule[0].Rollovers.Add(rollover);

            Console.WriteLine(_loan);

            MakePayment(170m, Parse("2012-12-27 08:58:02.000"));

            //var payEarlyCalc = new LoanRepaymentScheduleCalculator(_loan, Parse("2012-12-27 08:58:02.000"));
            //var state = payEarlyCalc.GetState();

            Assert.That(_loan.Schedule[0].Status, Is.EqualTo(LoanScheduleStatus.StillToPay));
            Assert.That(_loan.Schedule[1].Status, Is.EqualTo(LoanScheduleStatus.StillToPay));
            Assert.That(_loan.Schedule[2].Status, Is.EqualTo(LoanScheduleStatus.StillToPay));

            Console.WriteLine(_loan);
        }
Exemple #11
0
        public void state_at_begining_of_the_loan_with_late_charge()
        {
            var calculator = new LoanScheduleCalculator()
            {
                Interest = 0.06M
            };

            calculator.Calculate(5000, _loan, Parse("2012-09-23 23:29:35.000"));

            Console.WriteLine(_loan);

            var charge = new LoanCharge()
            {
                Amount = 60, Loan = _loan, Date = new DateTime(2012, 10, 25)
            };

            _loan.Charges.Add(charge);

            var state = _facade.GetStateAt(_loan, new DateTime(2012, 9, 23));

            Console.WriteLine(_loan);

            Assert.That(state.AmountDue, Is.EqualTo(0));
            Assert.That(state.LoanRepayment, Is.EqualTo(0));
            Assert.That(state.Interest, Is.EqualTo(0));
        }
Exemple #12
0
        public void charge_can_be_added()
        {
            var loan       = new Loan();
            var calculator = new LoanScheduleCalculator()
            {
                Interest = 0.06M
            };

            calculator.Calculate(1000, loan, new DateTime(2012, 10, 10));

            var charge = new LoanCharge
            {
                Amount      = 100,
                ChargesType = new ConfigurationVariable()
                {
                    Id = 1, Name = "Charge1", Value = "100"
                },
                Date = new DateTime(2012, 10, 11),
                Loan = loan
            };

            loan.TryAddCharge(charge);

            Assert.That(loan.Charges.Count, Is.EqualTo(1));
        }
Exemple #13
0
        public void check_fees_on_experied_rollover2()
        {
            const int rolloverAmount = 50;

            var calculator = new LoanScheduleCalculator {
                Interest = 0.06M
            };

            calculator.Calculate(1000, _loan, Parse("2012-12-05 00:00:00.000"));

            var rollover = new PaymentRollover
            {
                LoanSchedule = _loan.Schedule[0],
                Created      = Parse("2013-01-08 13:35:59.000"),
                ExpiryDate   = Parse("2013-01-09 00:00:00.000"),
                Payment      = rolloverAmount
            };

            _loan.Schedule[0].Rollovers.Add(rollover);

            var payEarlyCalc = new LoanRepaymentScheduleCalculator(_loan, Parse("2013-01-11 10:10:10.000"), 0);             //state for expired rollover
            var state1       = payEarlyCalc.GetState();
            var state        = payEarlyCalc.GetState();

            var model = LoanModel.FromLoan(_loan, payEarlyCalc, payEarlyCalc);

            Assert.That(state.Fees, Is.EqualTo(0));
            Assert.That(state.AmountDue, Is.EqualTo(405.61m));
            Assert.That(state.LateCharges, Is.EqualTo(0));
            Assert.That(state.Interest, Is.EqualTo(405.61m - 334m));

            Assert.That(model.Late, Is.EqualTo(405.61m));
        }
Exemple #14
0
        public void loan_732_prod()
        {
            var calculator = new LoanScheduleCalculator();

            calculator.Term     = 6;
            calculator.Interest = 0.06m;
            calculator.Calculate(5000, _loan, Parse("2013-04-18 09:26:54.000"));

            var rollover = new PaymentRollover
            {
                LoanSchedule = _loan.Schedule[0],
                Created      = Parse("2013-05-18 15:46:54.000"),
                ExpiryDate   = Parse("2013-05-21 00:00:00.000"),
                Payment      = 50,
                Status       = RolloverStatus.New
            };

            _loan.Schedule[0].Rollovers.Add(rollover);

            MakePayment(1262.42m, Parse("2013-05-30 00:00:00.000"));
            MakePayment(1088.77m, Parse("2013-06-26 07:04:11.000"));

            var state = GetStateAt(_loan, Parse("2013-06-26 07:04:11.000"));

            Assert.That(state.LoanRepayment, Is.EqualTo(0));

            Console.WriteLine(_loan);
        }
Exemple #15
0
        public void check_fees_on_experied_rollover()
        {
            const int rolloverAmount = 50;

            var calculator = new LoanScheduleCalculator {
                Interest = 0.06M
            };

            calculator.Calculate(1000, _loan, Parse("2013-01-15 10:10:10.000"));

            var rollover = new PaymentRollover
            {
                LoanSchedule = _loan.Schedule[1],
                Created      = Parse("2013-01-15 10:10:10.000"),
                ExpiryDate   = Parse("2013-01-25 10:10:10.000"),
                Payment      = rolloverAmount
            };

            _loan.Schedule[1].Rollovers.Add(rollover);

            var payEarlyCalc = new LoanRepaymentScheduleCalculator(_loan, Parse("2013-01-26 10:10:10.000"), 0);             //state for expired rollover
            var state        = payEarlyCalc.GetState();

            Assert.That(state.Fees, Is.EqualTo(0));
        }
Exemple #16
0
        public void pay_after_expired_rollover()
        {
            var calculator = new LoanScheduleCalculator()
            {
                Interest = 0.06M
            };

            calculator.Calculate(1000, _loan, Parse("2012-01-01 23:29:35.000"));

            var rollover = new PaymentRollover()
            {
                LoanSchedule = _loan.Schedule[1],
                Created      = Parse("2012-01-25 20:15:43.000"),
                ExpiryDate   = Parse("2012-02-10 20:15:43.000"),
                Payment      = 100
            };

            _loan.Schedule[1].Rollovers.Add(rollover);

            Console.WriteLine(_loan);

            var state = _facade.GetStateAt(_loan, Parse("2012-02-11 20:15:43.000"));

            Assert.That(state.Fees, Is.EqualTo(0));

            //pay installment, and rollover
            MakePayment(666, Parse("2012-02-11 20:15:43.000"));

            Console.WriteLine(_loan);

            Assert.That(_loan.TransactionsWithPaypoint[0].Rollover, Is.EqualTo(0));
        }
Exemple #17
0
        public void rollover_is_added_to_total_balance()
        {
            var startDate = DateTime.Now;

            var rolloverCreateDate = startDate.AddDays(35);
            var rolloverExpiryDate = rolloverCreateDate.AddDays(5);
            var payentDate         = rolloverCreateDate.AddDays(4);

            var calculator = new LoanScheduleCalculator {
                Interest = 0.06M
            };

            calculator.Calculate(1000, _loan, startDate);

            var rollover = new PaymentRollover
            {
                LoanSchedule = _loan.Schedule[0],
                Created      = rolloverCreateDate,
                ExpiryDate   = rolloverExpiryDate,
                Payment      = 50,
                Status       = RolloverStatus.New
            };

            _loan.Schedule[0].Rollovers.Add(rollover);

            Console.WriteLine(_loan);

            var payment = _loan.TotalEarlyPayment(_loan.Date);

            Assert.That(payment, Is.EqualTo(1050));
        }
Exemple #18
0
        public void rollover_adds_to_amount_to_pay_on_installment_date()
        {
            var calculator = new LoanScheduleCalculator()
            {
                Interest = 0.06M
            };

            calculator.Calculate(1000, _loan, Parse("2012-01-01 23:29:35.000"));

            var rollover = new PaymentRollover()
            {
                LoanSchedule = _loan.Schedule[1],
                Created      = Parse("2012-01-25 20:15:43.000"),
                ExpiryDate   = Parse("2012-02-10 20:15:43.000"),
                Payment      = 100
            };

            _loan.Schedule[1].Rollovers.Add(rollover);

            Console.WriteLine(_loan);

            var state = _facade.GetStateAt(_loan, Parse("2012-02-01 12:29:35.000"));

            Assert.That(state.AmountDue, Is.EqualTo(394 + 100));

            Assert.That(rollover.Status, Is.EqualTo(RolloverStatus.New));

            Console.WriteLine(_loan);
        }
Exemple #19
0
        public void pay_rollover_with_two_shuffle_mouth()
        {
            var calculator = new LoanScheduleCalculator()
            {
                Interest = 0.06M
            };

            calculator.Calculate(1000, _loan, new DateTime(2012, 1, 1));

            var rollover = new PaymentRollover()
            {
                LoanSchedule = _loan.Schedule[1],
                Created      = new DateTime(2012, 2, 10),
                ExpiryDate   = new DateTime(2012, 2, 15),
                Payment      = 100,
                MounthCount  = 2
            };

            _loan.Schedule[1].Rollovers.Add(rollover);

            Console.WriteLine(_loan);

            //pay installment, and rollover
            MakePayment(394 + 100, new DateTime(2012, 2, 12));

            Console.WriteLine(_loan);

            Assert.That(_loan.Schedule[1].Date.Date, Is.EqualTo(new DateTime(2012, 5, 1)));
        }
Exemple #20
0
        public void pay_rollover_ontime()
        {
            var calculator = new LoanScheduleCalculator()
            {
                Interest = 0.06M
            };

            calculator.Calculate(1000, _loan, Parse("2012-01-01 23:29:35.000"));

            var rollover = new PaymentRollover()
            {
                LoanSchedule = _loan.Schedule[1],
                Created      = Parse("2012-01-25 20:15:43.000"),
                ExpiryDate   = Parse("2012-02-10 20:15:43.000"),
                Payment      = 100,
                MounthCount  = 1
            };

            _loan.Schedule[1].Rollovers.Add(rollover);

            Console.WriteLine(_loan);

            //pay installment, and rollover
            MakePayment(394 + 100, Parse("2012-02-01 10:00:04.000"));

            Console.WriteLine(_loan);

            Assert.That(_loan.Schedule[1].Date.Date, Is.EqualTo(new DateTime(2012, 4, 1)));

            //interest is calculated for 2 moths
            Assert.That(_loan.Schedule[1].Interest, Is.EqualTo(82.68M));
        }
Exemple #21
0
        public void state_after_missed_payment_is_correct()
        {
            var calculator = new LoanScheduleCalculator()
            {
                Interest = 0.06M
            };

            calculator.Calculate(5000, _loan, Parse("2012-09-23 23:29:35.000"));

            Console.WriteLine(_loan);

            var fee    = 60m;
            var charge = new LoanCharge()
            {
                Amount = fee, Loan = _loan, Date = new DateTime(2012, 10, 25)
            };

            _loan.Charges.Add(charge);

            var state = _facade.GetStateAt(_loan, new DateTime(2012, 10, 26));

            Console.WriteLine(_loan);

            var percents = 29.03m; // проценты, которые набежали с момента последнего instllment
            var oldInstallmentAmountDue = 1968m;

            Assert.That(state.AmountDue, Is.EqualTo(oldInstallmentAmountDue + fee + percents));
            //Assert.That(state.LoanRepayment, Is.EqualTo(0));
            //Assert.That(state.Interest, Is.EqualTo(0));
        }
Exemple #22
0
        public void loan_34()
        {
            var calculator = new LoanScheduleCalculator()
            {
                Interest = 0.06M, Term = 3
            };

            calculator.Calculate(400, _loan, Parse("2012-09-12 15:05:27.000"));
            _loan.Status = LoanStatus.Live;

            Console.WriteLine(_loan);

            MakePayment(158.0m, Parse("2012-10-12 10:50:44.000"));
            MakePayment(146.0m, Parse("2012-11-07 12:23:19.000"));
            MakePayment(136.0m, Parse("2012-11-21 16:33:08.000"));
            MakePayment(0.13m, Parse("2013-01-22 20:00:11.000"));

            var payEarlyCalc = new LoanRepaymentScheduleCalculator(_loan, Parse("2013-01-23 20:00:11.000"), 0);
            var state        = payEarlyCalc.GetState();

            Assert.That(state.AmountDue, Is.EqualTo(1.08m));

            //Assert.That(state.AmountDue, Is.EqualTo(0.04m));
            //Assert.That(_loan.Status, Is.EqualTo(LoanStatus.PaidOff));
            //Assert.That(_loan.Schedule.All(s => s.Status == LoanScheduleStatus.PaidEarly), Is.True);
        }
Exemple #23
0
        public void simple_late_charge()
        {
            var calculator = new LoanScheduleCalculator()
            {
                Interest = 0.06M
            };

            calculator.Calculate(5000, _loan, Parse("2012-09-23 23:29:35.000"));

            var charge = new LoanCharge()
            {
                Amount = 60, Loan = _loan, Date = new DateTime(2012, 10, 25)
            };

            _loan.Charges.Add(charge);

            Console.WriteLine(_loan);

            MakePayment(1968, Parse("2012-10-28 10:03:01.000"));
            MakePayment(1865.92m, Parse("2012-11-23 10:44:22.000"));
            MakePayment(1765.96m, Parse("2012-12-23 13:30:18.000"));

            Assert.That(_loan.TransactionsWithPaypointSuccesefull[0].Fees, Is.EqualTo(60));
            Assert.That(charge.AmountPaid, Is.EqualTo(60));
        }
        public void loan_276()
        {
            var calculator = new LoanScheduleCalculator()
            {
                Interest = 0.06M
            };

            calculator.Calculate(1475, _loan, Parse("2012-12-11 17:07:51.000"));

            Console.WriteLine(_loan);

            MakePayment(123, Parse("2012-12-19 00:00:00.000"));

            var rollover = new PaymentRollover()
            {
                LoanSchedule = _loan.Schedule[0],
                Created      = Parse("2012-12-19 16:20:35.000"),
                ExpiryDate   = Parse("2012-12-22 00:00:00.000"),
                Payment      = 57
            };

            _loan.Schedule[0].Rollovers.Add(rollover);

            _facade.GetStateAt(_loan, Parse("2012-12-19 16:20:35.000"));

            Console.WriteLine(_loan);

            Assert.That(rollover.Payment, Is.EqualTo(57m));
        }
Exemple #25
0
        public void rollover_expires()
        {
            var calculator = new LoanScheduleCalculator()
            {
                Interest = 0.06M
            };

            calculator.Calculate(1000, _loan, Parse("2012-01-01 23:29:35.000"));

            var rollover = new PaymentRollover()
            {
                LoanSchedule = _loan.Schedule[1],
                Created      = Parse("2012-01-25 20:15:43.000"),
                ExpiryDate   = Parse("2012-02-10 20:15:43.000"),
                Payment      = 100
            };

            _loan.Schedule[1].Rollovers.Add(rollover);

            Console.WriteLine(_loan);

            var state = _facade.GetStateAt(_loan, Parse("2012-02-11 12:29:35.000"));

            Assert.That(rollover.Status, Is.EqualTo(RolloverStatus.Expired));

            Console.WriteLine(_loan);
        }
 public void SetUp()
 {
     _facade     = new LoanPaymentFacade();
     _calculator = new LoanScheduleCalculator();
     _loan       = new Loan();
     _startDate  = new DateTime(2012, 10, 10);
     _schedule   = _calculator.Calculate(3000m, _loan, _startDate);
 }
Exemple #27
0
        protected override void SetUp()
        {
            var calculator = new LoanScheduleCalculator();

            _startDate = new DateTime(2012, 1, 1);
            calculator.Calculate(_takenMoney, _loan, _startDate);
            base.SetUp();
        }
Exemple #28
0
        public void loan_478_roman()
        {
            var calculator = new LoanScheduleCalculator()
            {
                Interest = 0.06M, Term = 3
            };

            calculator.Calculate(1000, _loan, Parse("2012-05-26 00:00:00.000"));
            _loan.Status = LoanStatus.Live;

            var rollover1 = new PaymentRollover()
            {
                Created      = Parse("2012-12-26 12:35:42.000"),
                ExpiryDate   = Parse("2012-12-29 00:00:00.000"),
                Status       = RolloverStatus.New,
                LoanSchedule = _loan.Schedule[0],
                Payment      = 50
            };

            var rollover2 = new PaymentRollover()
            {
                Created      = Parse("2012-12-26 12:39:12.000"),
                ExpiryDate   = Parse("2012-12-29 00:00:00.000"),
                Status       = RolloverStatus.New,
                LoanSchedule = _loan.Schedule[0],
                Payment      = 50
            };

            _loan.Schedule[0].Rollovers.Add(rollover1);
            _loan.Schedule[0].Rollovers.Add(rollover2);

            Console.WriteLine(_loan);

            var state = _facade.GetStateAt(_loan, Parse("2012-12-26 10:36:26.000"));

            var interest = 420m;

            Assert.That(state.Interest, Is.EqualTo(interest));

            MakePayment(interest + 50m, Parse("2012-12-26 10:36:26.000"));
            Assert.That(_loan.TransactionsWithPaypoint[0].Interest, Is.EqualTo(interest));
            Assert.That(_loan.TransactionsWithPaypoint[0].Rollover, Is.EqualTo(50));
            Assert.That(rollover1.PaidPaymentAmount, Is.EqualTo(50));

            MakePayment(50m, Parse("2012-12-26 10:54:48.000"));

            Assert.That(rollover2.PaidPaymentAmount, Is.EqualTo(50));
            Assert.That(_loan.TransactionsWithPaypoint[1].Rollover, Is.EqualTo(50));
            MakePayment(1000.00m, Parse("2012-12-26 10:57:31.000"));

            Assert.That(_loan.Status, Is.EqualTo(LoanStatus.PaidOff));

            Assert.That(rollover1.PaidPaymentAmount, Is.EqualTo(50));
            Assert.That(rollover2.PaidPaymentAmount, Is.EqualTo(50));

            Console.WriteLine(_loan);
        }
Exemple #29
0
        public void state_at_installment_dates()
        {
            var calculator = new LoanScheduleCalculator()
            {
                Interest = 0.06M
            };

            calculator.Calculate(5000, _loan, Parse("2012-09-23 23:29:35.000"));

            var charge = new LoanCharge()
            {
                Amount = 60, Loan = _loan, Date = new DateTime(2012, 10, 25)
            };

            _loan.Charges.Add(charge);

            Console.WriteLine(_loan);

            LoanScheduleItem state;

            //loan start
            state = _facade.GetStateAt(_loan, new DateTime(2012, 9, 23));
            Console.WriteLine(_loan);
            Assert.That(state.AmountDue, Is.EqualTo(0));
            Assert.That(state.LoanRepayment, Is.EqualTo(0));
            Assert.That(state.Interest, Is.EqualTo(0));
            Assert.That(state.Fees, Is.EqualTo(0));

            Console.WriteLine(_loan);

            // installment #1
            state = _facade.GetStateAt(_loan, new DateTime(2012, 10, 23));
            Console.WriteLine(_loan);
            Assert.That(state.AmountDue, Is.EqualTo(1968.00m));
            Assert.That(state.LoanRepayment, Is.EqualTo(1668));
            Assert.That(state.Interest, Is.EqualTo(300.00m));
            Assert.That(state.Fees, Is.EqualTo(0));

            // installment #2
            state = _facade.GetStateAt(_loan, new DateTime(2012, 11, 23));
            Console.WriteLine(_loan);
            //Assert.That(state.AmountDue, Is.EqualTo(1865.92m));
            Assert.That(state.LoanRepayment, Is.EqualTo(1666 + 1668));
            Assert.That(state.Fees, Is.EqualTo(60));
            //Assert.That(state.Interest, Is.EqualTo(199.92m));

            // installment #3
            state = _facade.GetStateAt(_loan, new DateTime(2012, 12, 23));
            Console.WriteLine(_loan);
            //Assert.That(state.AmountDue, Is.EqualTo(1765.96m));
            Assert.That(state.LoanRepayment, Is.EqualTo(1666 + 1666 + 1668));
            Assert.That(state.Fees, Is.EqualTo(60));
            //Assert.That(state.Interest, Is.EqualTo(99.96m));
        }
        public void SetUp()
        {
            _loanOriginal = new Loan();
            _cashRequest  = new CashRequest()
            {
                InterestRate = 0.06m, LoanType = new StandardLoanType()
            };
            _calculator = new LoanScheduleCalculator();
            _calculator.Calculate(1000, _loanOriginal, new DateTime(2012, 10, 21));

            _builder = new ChangeLoanDetailsModelBuilder();
        }