Example #1
0
        // GET: Premiums/Create
        public async Task <IActionResult> Create(Guid productId, Guid clientId, Guid policyId)
        {
            Receivable receivable = new Receivable
            {
                ReceivableDate = DateTime.Now
            };

            Premium premium = new Premium
            {
                PremiumDate = DateTime.Now
            };

            PremiumViewModel viewModel = new PremiumViewModel
            {
                ProductID       = productId,
                ClientID        = clientId,
                PolicyID        = policyId,
                Receivable      = receivable,
                Premium         = premium,
                PaymentTypeList = new SelectList(await _context.PaymentTypes.AsNoTracking().ToListAsync(),
                                                 "ID", "Name"),
                PremiumTypeList = new SelectList(await _context.PremiumTypes.AsNoTracking().ToListAsync(),
                                                 "ID", "Name")
            };

            return(View(viewModel));
        }
Example #2
0
        public IActionResult Index()
        {
            var model = new PremiumViewModel();

            model.ProductName = "Gold";
            model.PlanName    = "Essential";
            return(View(model));
        }
Example #3
0
        // GET: Premiums/Edit/5
        public async Task <IActionResult> Edit(Guid Id)
        {
            Premium premium = await _context.Premiums.SingleOrDefaultAsync(m => m.ID == Id);

            PremiumViewModel viewModel = new PremiumViewModel
            {
                Premium         = premium,
                PremiumTypeList = new SelectList(await _context.PremiumTypes.AsNoTracking().OrderBy(p => p.Name).ToListAsync(),
                                                 "ID", "Name", premium.PremiumTypeID)
            };

            return(View(viewModel));
        }
Example #4
0
        //Shows the premium view
        public ActionResult Premium()
        {
            checkCookie();
            CheckUserID();

            int  id   = Convert.ToInt32(Session["UserID"].ToString());
            User user = db.Users.Include("UserLevel").Where(x => x.ID == id).FirstOrDefault();
            //finds your user and checks if you are a premium member along with dates and payment method
            PremiumBilling   bill = db.PremiumBilling.Where(x => x.Member.ID == user.ID).FirstOrDefault();
            PremiumViewModel vm   = new PremiumViewModel
            {
                MyUser    = user,
                MyBilling = bill,
            };

            return(View(vm));
        }
Example #5
0
        private void getASinglePremium(BultTestViewModel btvm, PremiumCalculator pc)
        {
            PremiumViewModel pvm = new PremiumViewModel();

            pvm.ProductName     = btvm.ProductName;
            pvm.PlanName        = btvm.PlanName;
            pvm.PlanType        = btvm.PlanType;
            pvm.SumInsured      = btvm.SumInsured;
            pvm.Term            = btvm.Term;
            pvm.Age             = btvm.Age;
            pvm.Gender          = btvm.Gender;
            pvm.Diabetes        = btvm.Diabetes;
            pvm.Hyperlipidaemia = btvm.Hyperlipidaemia;
            pvm.Hypertension    = btvm.Hypertension;
            pvm.Asthma          = btvm.Asthma;
            pvm.Spouse          = btvm.Spouse;
            pvm.Father          = btvm.Father;
            pvm.Mother          = btvm.Mother;
            pvm.FatherInLaw     = btvm.FatherInLaw;
            pvm.MotherInLaw     = btvm.MotherInLaw;
            pvm.Kids            = btvm.Kids;
            pvm.RoomType        = btvm.RoomType;
            pvm.Zone            = btvm.Zone;
            pvm.Channel         = btvm.Channel;
            pvm.Staff           = btvm.Staff;
            pvm.Deductible      = btvm.Deductible;
            pvm.OPD             = btvm.OPD;
            pvm.HospitalCash    = btvm.HospitalCash;
            pvm.Maternity       = btvm.Maternity;
            pvm.PremiumWaiver   = btvm.PremiumWaiver;

            pc.calculatePremium(pvm);
            //PremiumCalc prem = null;
            foreach (PremiumCalc prem in pvm.Premiums)
            {
                if (prem.name == "Total")
                {
                    btvm.TotalPremium = prem;
                }
            }
            btvm.Premiums = pvm.Premiums;
            btvm.TestPass = System.Math.Round(btvm.TotalPremium.NetAmount, 2) == System.Math.Round(btvm.inputPremium, 2);
        }
Example #6
0
        private int getFamilyComposition(PremiumViewModel model)
        {
            int famComp = cSelf;

            if (model.Spouse)
            {
                famComp += cSpouse;
            }
            if (model.Father)
            {
                famComp += cFather;
            }
            if (model.Mother)
            {
                famComp += cMother;
            }
            if (model.FatherInLaw)
            {
                famComp += cFatherInLaw;
            }
            if (model.MotherInLaw)
            {
                famComp += cMotherInLaw;
            }
            int kids = model.Kids;

            if (kids > 3)
            {
                addMessage("Kids reduced to maximum 3");
                kids = 3;
            }
            if (kids < 0)
            {
                kids = 0;
            }
            famComp += (kids * cKids);
            addMessage("Family Comp = " + famComp);
            return(famComp);
        }
Example #7
0
        public async Task <IActionResult> Edit(PremiumViewModel viewModel)
        {
            if (ModelState.IsValid)
            {
                try
                {
                    Premium premium = new Premium();
                    premium = viewModel.Premium;

                    //  Calculate Policy Fee, Commission and Admin Fee using currentproductId
                    List <decimal> BrokerCharges = GetBrokerCharges(viewModel.ProductID, premium.RiskID, premium.Amount);
                    premium.PolicyFee  = BrokerCharges[0];
                    premium.Commission = BrokerCharges[1];
                    premium.AdminFee   = BrokerCharges[2];

                    _context.Update(premium);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateException ex)
                {
                    var errorMsg = ex.InnerException.Message.ToString();

                    viewModel.ErrMsg = errorMsg;
                    ModelState.AddModelError(string.Empty, viewModel.ErrMsg);
                }
                return(RedirectToAction("Index", new
                {
                    productId = viewModel.ProductID,
                    clientId = viewModel.ClientID,
                    policyId = viewModel.PolicyID
                }));
            }
            viewModel.PremiumTypeList = new SelectList(await _context.PremiumTypes.AsNoTracking().OrderBy(p => p.Name).ToListAsync(),
                                                       "ID", "Name", viewModel.Premium.PremiumTypeID);
            return(View(viewModel));
        }
Example #8
0
        public async Task <IActionResult> CreateConfirmed(PremiumViewModel viewModel)
        {
            try
            {
                if (ModelState.IsValid)
                {
                    var productId = viewModel.ProductID;

                    Receivable receivable = viewModel.Receivable;
                    receivable.ID        = Guid.NewGuid();
                    receivable.ProductID = productId;
                    _context.Add(receivable);
                    await _context.SaveChangesAsync();

                    var receivableId = receivable.ID;
                    var policyId     = viewModel.PolicyID;

                    //  Collect RiskItemID using PolicyID and RiskID
                    //  Split the premium if more than 1 RiskItemIDs
                    object[,] riskItemPremiums = GetRiskItems(policyId);

                    Premium premium          = viewModel.Premium;
                    var     availablePremium = premium.Amount;
                    var     riskId           = 0;

                    if (riskItemPremiums.Length > 0)
                    {
                        for (int i = 0; i < riskItemPremiums.GetUpperBound(0) + 1; i++)
                        {
                            if (riskId != int.Parse(riskItemPremiums[i, 0].ToString()))
                            {
                                riskId = int.Parse(riskItemPremiums[i, 0].ToString());
                            }

                            premium.ID           = Guid.NewGuid();
                            premium.ReceivableID = receivableId;
                            premium.PolicyID     = policyId;
                            premium.RiskID       = riskId;
                            premium.RiskItemID   = Guid.Parse(riskItemPremiums[i, 1].ToString());

                            //  Split the Premium Amount if more than one risk item
                            var riskitempremium = decimal.Parse(riskItemPremiums[i, 2].ToString());
                            var balancePremium  = availablePremium - riskitempremium;

                            if (balancePremium > -1)
                            {
                                premium.Amount   = riskitempremium;
                                availablePremium = balancePremium;
                            }
                            else
                            {
                                premium.Amount   = availablePremium;
                                availablePremium = 0;
                            }

                            //  Calculate Policy Fee, Commission and Admin Fee
                            //  using currentproductId and premium amount
                            List <decimal> BrokerCharges = GetBrokerCharges(productId, riskId, premium.Amount);
                            premium.PolicyFee  = BrokerCharges[0];
                            premium.Commission = BrokerCharges[1];
                            premium.AdminFee   = BrokerCharges[2];
                            _context.Add(premium);
                            await _context.SaveChangesAsync();
                        }
                    }

                    //  Update the policy table with next premium due date based on the policy
                    //  frequency
                    var premiumDate = premium.PremiumDate;
                    UpdatePremiumDueDate(policyId, premiumDate);

                    return(RedirectToAction("Index", new {
                        productId = viewModel.ProductID, clientId = viewModel.ClientID, policyId = viewModel.PolicyID
                    }));
                }
            }
            catch (DbUpdateException ex)
            {
                var errorMsg = ex.InnerException.Message.ToString();

                viewModel.ErrMsg = errorMsg;
                ModelState.AddModelError(string.Empty, viewModel.ErrMsg);
            }
            viewModel.PaymentTypeList = new SelectList(await _context.PaymentTypes.AsNoTracking().OrderBy(p => p.Name).ToListAsync(),
                                                       "ID", "Name", viewModel.Receivable.PaymentTypeID);
            viewModel.PremiumTypeList = new SelectList(await _context.PremiumTypes.AsNoTracking().OrderBy(p => p.Name).ToListAsync(),
                                                       "ID", "Name", viewModel.Premium.PremiumTypeID);
            return(View(viewModel));
        }
Example #9
0
 public async Task <IActionResult> Premium(PremiumViewModel model)
 {
     return(RedirectToAction("Index", "Home"));
 }
Example #10
0
        public PremiumViewModel calculatePremium(PremiumViewModel model)
        {
            PremiumItem prem;
            //Base Premium
            int famComp = 0;

            switch (model.PlanType)
            {
            case "Family Floater":
                famComp = getFamilyComposition(model);
                break;

            case "Individual":
                famComp = (model.Gender == "Male") ? cSelf : (cSelf * 2);
                break;
            }
            string chronic = "Non Chronic";

            if (model.ProductName == "Platinum" && model.PlanType != "Family Floater")
            {
                if (model.Diabetes)
                {
                    chronic = "Diabetic";
                }
                else if (model.Hypertension)
                {
                    chronic = "Hypertension";
                }
                else if (model.Hyperlipidaemia)
                {
                    chronic = "Hyperlipidaemia";
                }
                else if (model.Asthma)
                {
                    chronic = "Asthma";
                }
            }
            int deductible = model.Deductible;

            if (chronic != "Non Chronic")
            {
                deductible = 0;
            }
            int term      = model.Term;
            int thisterm  = term;
            int noOffBase = 0;
            //Base Premium Loop
            PremiumCalc pmc = new PremiumCalc {
                name = "Base Premium", LoadingFactor = 1m, DiscountFactor = 1m, RelativesFactor = 1m, TotalFactor = 1m
            };

            model.Premiums.Add(pmc);
            for (int age = model.Age; age < (term + model.Age); age++)
            {
                noOffBase++;
                prem = getPremiumRecord(model.ProductName, model.PlanName, model.PlanType, famComp, chronic,
                                        model.SumInsured, deductible, age, thisterm, "Base Premium " + thisterm);
                if (prem != null)
                {
                    pmc.BasePremium += prem.Amount;
                    pmc.premiumItems.Add(prem);
                }
                thisterm++;
            }
            pmc.NetAmount = pmc.BasePremium;

            //Premium Loading
            /*Co-Morbitity Load  */
            decimal coMorbitLoading = 0m;

            if (model.ProductName == "Platinum" && model.PlanType != "Family Floater")
            {
                if (model.Diabetes)
                {
                    coMorbitLoading = (model.Hypertension && model.Hyperlipidaemia && model.Asthma) ? 7050m : coMorbitLoading;
                    coMorbitLoading = (model.Hypertension && model.Hyperlipidaemia && !model.Asthma) ? 5150m : coMorbitLoading;
                    coMorbitLoading = (model.Hypertension && !model.Hyperlipidaemia && model.Asthma) ? 2780m : coMorbitLoading;
                    coMorbitLoading = (!model.Hypertension && model.Hyperlipidaemia && model.Asthma) ? 550m : coMorbitLoading;
                    coMorbitLoading = (model.Hypertension && !model.Hyperlipidaemia && !model.Asthma) ? 1050m : coMorbitLoading;
                    coMorbitLoading = (!model.Hypertension && !model.Hyperlipidaemia && model.Asthma) ? 1400m : coMorbitLoading;
                    coMorbitLoading = (!model.Hypertension && model.Hyperlipidaemia && !model.Asthma) ? 3600m : coMorbitLoading;
                }
                else if (model.Hypertension)
                {
                    coMorbitLoading = (model.Hyperlipidaemia && model.Asthma) ? 5250m : coMorbitLoading;
                    coMorbitLoading = (model.Hyperlipidaemia && !model.Asthma) ? 3350m : coMorbitLoading;
                    coMorbitLoading = (!model.Hyperlipidaemia && model.Asthma) ? 1150m : coMorbitLoading;
                }
                else if (model.Hyperlipidaemia)
                {
                    coMorbitLoading = (model.Asthma) ? 5650m : coMorbitLoading;
                }
            }
            if (coMorbitLoading > 0m)
            {
                //pmc.LoadingPerc += coMorbitLoading;
                //pmc.LoadingFactor *= (1m + coMorbitLoading);
                decimal loadAmount = coMorbitLoading * model.Term;
                pmc.NetAmount = pmc.BasePremium + (loadAmount);
                pmc.Info     += string.Format("\nCo-Morbitity Loading  " + loadAmount);
            }

            //Premium Waiver on co-pay for Essential
            if (model.PremiumWaiver && model.PlanName == "Essential")
            {
                pmc.LoadingFactor *= (1m + 0.25m);
                //pmc.LoadingPerc += 0.25m;
                pmc.Info += "\nPremium Waiver Loading 25%|";
            }
            //pmc.LoadingAmount = pmc.NetAmount * (1m - pmc.LoadingPerc);
            //pmc.NetAmount = pmc.NetAmount * pmc.LoadingAmount;

            //           pmc.NetAmount = pmc.BasePremium;
            /*Discounts*/
            //Term Discount
            if (noOffBase > 1)
            {
                pmc.Info += "\n" + noOffBase + " year term|";
                if (noOffBase == 2)
                {
                    pmc.DiscountFactor *= (1m - 0.075m);
                    pmc.Info           += "\nTerm discount 7.5%|";
                }
                if (noOffBase == 3)
                {
                    pmc.DiscountFactor *= (1m - 0.10m);
                    pmc.Info           += "\nTerm discount 10%|";
                }
            }
            //Staff Discount
            if (model.Staff)
            {
                pmc.DiscountFactor *= (1m - 0.10m);
                pmc.Info           += "\nStaff discount 10%|";
            }
            //pmc.DiscountAmount = pmc.NetAmount * (1m - pmc.DiscountPerc);
            //pmc.NetAmount = pmc.NetAmount * pmc.DiscountPerc;

            /* Relatives */
            //Zone
            if (model.Zone > 1)
            {
                if (model.Zone == 2)
                {
                    pmc.RelativesFactor *= (1m - 0.10m);
                    pmc.Info            += "\nZone Relative 10%|";
                }
                if (model.Zone == 3)
                {
                    pmc.RelativesFactor *= (1m - 0.25m);
                    pmc.Info            += "\nZone Relative 25%|";
                }
            }
            //Room Type
            if (model.RoomType != 1)
            {
                //Not Single
                if (model.PlanName == "Essential")
                {
                    if (model.RoomType == 2)//Shared
                    {
                        pmc.RelativesFactor *= (1m - 0.10m);
                        pmc.Info            += "\nRoomType Relative 10%|";
                    }
                    if (model.RoomType == 3)//General/Economy
                    {
                        pmc.RelativesFactor *= (1m - 0.20m);
                        pmc.Info            += "\nRoomType Relative 20%|";
                    }
                }
                if (model.PlanName == "Enhanced")
                {
                    if (model.RoomType == 2 || model.RoomType == 3)//Shared or General/Economy
                    {
                        pmc.RelativesFactor *= (1m - 0.10m);
                        pmc.Info            += "\nRoomType Relative 10%|";
                    }
                    if (model.RoomType == 4)//any room
                    {
                        pmc.RelativesFactor *= (1m + 0.25m);
                        pmc.Info            += "\nRoomType Loading Relative +25%|";
                    }
                }
            }

            pmc.TotalFactor = pmc.LoadingFactor * pmc.DiscountFactor * pmc.RelativesFactor;
            pmc.NetAmount   = pmc.NetAmount * pmc.TotalFactor;
            //pmc.RelativesAmount = pmc.NetAmount * (1m - pmc.RelativesPerc);
            //pmc.NetAmount = pmc.NetAmount * pmc.RelativesPerc;

            //Hospital Cash
            if (model.HospitalCash > 0)
            {
                pmc = new PremiumCalc {
                    name = "Hospital Daily Cash"
                };
                model.Premiums.Add(pmc);
                famComp = (model.Gender == "Male") ? cSelf : (cSelf * 2);
                for (int age = model.Age; age < (model.Term + model.Age); age++)
                {
                    prem = getPremiumRecord("Optional Benefit: Hospital Daily Cash Benefit", "HospCash",
                                            "Optional", famComp, "",
                                            model.HospitalCash, 0, age, model.Term, "Hospital Daily Cash");

                    if (prem != null)
                    {
                        pmc.BasePremium += prem.Amount;
                        pmc.premiumItems.Add(prem);
                    }
                }
                pmc.NetAmount = pmc.BasePremium;
            }

            //OPD
            if (model.OPD > 0)
            {
                pmc = new PremiumCalc {
                    name = "OPD Expenses"
                };
                model.Premiums.Add(pmc);
                prem = getPremiumRecord("Optional Benefit : OPD Expenses", "OPD",
                                        "Optional", cSelf, "",
                                        model.OPD, 0, 0, model.Term, "OPD Expenses");
                if (prem != null)
                {
                    pmc.NetAmount   = prem.Amount * model.Term; //Multiply by Term
                    pmc.BasePremium = prem.Amount;
                    pmc.premiumItems.Add(prem);
                }
            }
            //Maternity
            if (model.Maternity)
            {
                pmc = new PremiumCalc {
                    name = "Maternity Expenses"
                };
                model.Premiums.Add(pmc);

                for (int age = model.Age; age < (model.Term + model.Age); age++)
                {
                    prem = getPremiumRecord("Optional Benefit: Maternity Expenses", "Maternity",
                                            "Optional", (cSelf * 2), "",
                                            0, 0, age, model.Term, "Maternity Expenses");

                    if (prem != null)
                    {
                        pmc.BasePremium += (prem.Amount / 3);
                        pmc.NetAmount    = pmc.BasePremium;
                        pmc.premiumItems.Add(prem);
                    }
                }


                /*
                 *   if (prem != null)
                 *   {
                 *       pmc.BasePremium = prem.Amount;
                 *       //Maternity has a 3 Year Premium
                 *       pmc.NetAmount = (pmc.BasePremium / 3) * noOffBase;
                 *       pmc.premiumItems.Add(prem);
                 *   }
                 */
            }
            //Add a Total Row
            PremiumCalc totPrem = new PremiumCalc {
                name = "Total"
            };

            foreach (PremiumCalc pmc1 in model.Premiums)
            {
                totPrem.NetAmount   += pmc1.NetAmount;
                totPrem.BasePremium += pmc1.BasePremium;

                /*totPrem.DiscountPerc += pmc1.DiscountPerc;
                 * totPrem.DiscountAmount += pmc1.DiscountAmount;
                 * totPrem.RelativesPerc += pmc1.RelativesPerc;
                 * totPrem.RelativesAmount += pmc1.RelativesAmount;
                 * totPrem.LoadingPerc += pmc1.LoadingPerc;
                 * totPrem.LoadingAmount += pmc1.LoadingAmount;*/
                totPrem.LoadingFactor   = (pmc1.LoadingFactor > totPrem.LoadingFactor) ? pmc1.LoadingFactor : totPrem.LoadingFactor;
                totPrem.DiscountFactor  = (pmc1.DiscountFactor > totPrem.DiscountFactor) ? pmc1.DiscountFactor : totPrem.DiscountFactor;
                totPrem.RelativesFactor = (pmc1.RelativesFactor > totPrem.RelativesFactor) ? pmc1.RelativesFactor : totPrem.RelativesFactor;
                totPrem.TotalFactor     = (pmc1.TotalFactor > totPrem.TotalFactor) ? pmc1.TotalFactor : totPrem.TotalFactor;
                totPrem.Info           += pmc1.Info;
            }
            model.Premiums.Add(totPrem);

            return(model);
        }
Example #11
0
        // GET: Pricing
        public IActionResult Index(PremiumViewModel model)
        {
            PremiumCalculator pc = new PremiumCalculator(_context);

            return(View(pc.calculatePremium(model)));
        }