Exemple #1
0
        public void CreateTest()
        {
            var r = GetRandom.Object <InsuranceData>();
            var o = new Insurance(r);
            var v = InsuranceViewFactory.Create(o);

            Assert.AreEqual(v.Payment, o.Data.Payment);
            Assert.AreEqual(v.Status, o.Data.Status);
            Assert.AreEqual(v.Type, o.Data.Type);
            Assert.AreEqual(v.AccountId, o.Data.AccountId);
            Assert.AreEqual(v.ValidFrom, o.Data.ValidFrom);
        }
        public async Task <IActionResult> Create(string accountId)
        {
            var loggedInUser = await userManager.GetUserAsync(HttpContext.User);

            var accIds = new List <string>();
            var accs   = await accounts.LoadAccountsForUser(loggedInUser.Id);

            foreach (var acc in accs)
            {
                accIds.Add(acc.Data.ID);
            }
            ViewBag.Accounts       = accIds;
            ViewBag.InsuranceTypes = Enum.GetValues(typeof(InsuranceType)).Cast <InsuranceType>();
            if (accountId == null)
            {
                accountId = accIds.FirstOrDefault() ?? "Unspecified";
            }
            return(View(InsuranceViewFactory.Create(
                            InsuranceFactory.CreateInsurance(null, null, "", "", accountId))));
        }
        public async Task <IActionResult> Create([Bind(properties)] InsuranceView model)
        {
            //if (!ModelState.IsValid) return View(model);
            var accountObject = await accounts.GetObject(model.AccountId);

            bool isAccountOk       = checkIfHasEnoughPaymentMoney(accountObject, model.Payment);
            bool isInsuranceDataOk = checkIfIsntInPast(model.ValidFrom, model.ValidTo);

            if (isAccountOk && isInsuranceDataOk)
            {
                model.ID = Guid.NewGuid().ToString();
                var insurance = InsuranceViewFactory.Create(model);
                insurance.Data.Payment   = model.Payment;
                insurance.Data.Type      = model.Type;
                insurance.Data.ValidFrom = model.ValidFrom ?? DateTime.MinValue;
                insurance.Data.ValidTo   = model.ValidTo ?? DateTime.MaxValue;
                insurance.Data.AccountId = model.AccountId;
                insurance.Data.Status    = Status.Active.ToString();

                accountObject.Data.Balance = accountObject.Data.Balance - model.Payment;

                var transaction = TransactionFactory.CreateTransaction(model.ID, model.Payment,
                                                                       model.Type + " insurance", "systemAccount", model.AccountId,
                                                                       model.ValidFrom, model.ValidTo);

                await insurances.AddObject(insurance);

                await accounts.UpdateObject(accountObject);
                await generateInsuranceNotification(insurance);

                await transactions.AddObject(transaction);

                TempData["Status"] =
                    insurance.Data.Type + " insurance is now valid from " + insurance.Data.ValidFrom.ToString("dd/M/yyyy", CultureInfo.InvariantCulture) + " to "
                    + insurance.Data.ValidTo.ToString("dd/M/yyyy", CultureInfo.InvariantCulture) + " in payment of " + insurance.Data.Payment;
            }

            return(RedirectToAction("Index"));
        }