protected void AddLimitPolicy(int policyId)
        {
            Limit       limits         = null;
            Limit       limits2        = null;
            PolicyLimit objPolicyLimit = null;

            DataTable tbllimitGet          = HttpContext.Current.Session["Limit"] as DataTable;
            DataTable tblPolicylimitGet    = HttpContext.Current.Session["PolicyLimit"] as DataTable;
            DataTable tblAllPolicylimitGet = HttpContext.Current.Session["tblAllPolicylimit"] as DataTable;

            string type = string.Empty;

            for (int count = 0; count < tbllimitGet.Rows.Count; count++)
            {
                limits                  = new Limit();
                limits.LimitLetter      = tbllimitGet.Rows[count]["LimitLetter"].ToString();
                limits.LimitType        = Convert.ToInt32(tbllimitGet.Rows[count]["LimitType"].ToString());
                limits.LimitDescription = tbllimitGet.Rows[count]["LimitDescription"].ToString();
                limits.IsStatic         = Convert.ToBoolean(tbllimitGet.Rows[count]["IsStatic"].ToString());
                limits2                 = LimitManager.Save(limits);


                objPolicyLimit                        = new PolicyLimit();
                objPolicyLimit.PolicyID               = policyId;
                objPolicyLimit.LimitID                = limits2.LimitID;
                objPolicyLimit.LimitAmount            = Convert.ToDecimal(tblAllPolicylimitGet.Rows[count]["LimitAmount"].ToString());
                objPolicyLimit.LimitDeductible        = Convert.ToDecimal(tblAllPolicylimitGet.Rows[count]["LimitDeductible"].ToString());
                objPolicyLimit.ITV                    = Convert.ToDecimal(tblAllPolicylimitGet.Rows[count]["ITV"].ToString());
                objPolicyLimit.Reserve                = Convert.ToDecimal(tblAllPolicylimitGet.Rows[count]["Reserve"].ToString());
                objPolicyLimit.IsDeleted              = Convert.ToBoolean(tblAllPolicylimitGet.Rows[count]["IsDeleted"].ToString());
                objPolicyLimit.ApplyAcrossAllCoverage = Convert.ToBoolean(tblAllPolicylimitGet.Rows[count]["ApplyAcrossAllCoverage"].ToString());
                objPolicyLimit.ApplyTo                = tblAllPolicylimitGet.Rows[count]["ApplyTo"].ToString();
                PolicyLimitManager.Save(objPolicyLimit);
            }
        }
        protected void btnShowLossTemplate_Click(object sender, EventArgs e)
        {
            //int policyId = 0;

            ClaimManager objClaimManager = new ClaimManager();
            int          policyId        = Convert.ToInt32(hdnPolicyIdDetuctible.Value);

            List <Claim> lstClaim = objClaimManager.GetPolicyClaim(policyId);


            using (TransactionScope scope = new TransactionScope())
            {
                //delete all claim from claim limit
                foreach (var claim in lstClaim)
                {
                    int claimId = claim.ClaimID;
                    ClaimLimitManager.IsDeleted(claimId);
                }


                // delete limit,claimlimit,policylimit data which enter as loss details
                LimitManager.DeletePolicyLimit(policyId);

                //first get all limit
                List <Limit> objLimit = LimitManager.GetAllLimit(true);


                foreach (var limit in objLimit)
                {
                    //enter in
                    PolicyLimit objPolicyLimit = new PolicyLimit();
                    objPolicyLimit.PolicyID = policyId;
                    objPolicyLimit.LimitID  = limit.LimitID;
                    PolicyLimitManager.Save(objPolicyLimit);
                }

                //code for enter in all claim in claim limit
                foreach (var claim in lstClaim)
                {
                    foreach (var limit in objLimit)
                    {
                        ClaimLimit objClaimLimit = new ClaimLimit();
                        objClaimLimit.ClaimID = claim.ClaimID;
                        objClaimLimit.LimitID = limit.LimitID;
                        ClaimLimitManager.Save(objClaimLimit);
                    }
                }

                scope.Complete();
            }

            acrossAllCoverages.Enabled = true;
            coverageSpecific.Enabled   = true;
            txtDeductible.Enabled      = true;


            propertyLimits.bindData(policyId);
            //casualtyLimits.bindData(policyId);
        }
        protected void SetAddCoverage(int policyId)
        {
            List <PolicyLimit> limits = null;

            limits = PolicyLimitManager.GetAll(policyID);
            if (limits != null && limits.Count > 0)
            {
                bool applyAcrossAll = limits[0].ApplyAcrossAllCoverage ?? false;
                if (applyAcrossAll)
                {
                    txtDeductible.Enabled      = false;
                    acrossAllCoverages.Checked = true;

                    acrossAllCoverages.Enabled = false;
                    coverageSpecific.Enabled   = false;

                    coverageSpecific.Checked = false;
                    hdnApplyDeductible.Value = "1";
                }
                else
                {
                    acrossAllCoverages.Enabled = false;
                    coverageSpecific.Enabled   = false;

                    txtDeductible.Enabled      = true;
                    acrossAllCoverages.Checked = false;
                    coverageSpecific.Checked   = true;
                    hdnApplyDeductible.Value   = "0";
                }
                if (limits[0].ApplyAcrossAllCoverage == null)
                {
                    acrossAllCoverages.Enabled = true;
                    coverageSpecific.Enabled   = true;
                    txtDeductible.Enabled      = true;
                    acrossAllCoverages.Checked = false;
                    coverageSpecific.Checked   = true;
                    hdnApplyDeductible.Value   = "0";
                }

                //if (limits[0].ApplyAcrossAllCoverage==null)
                //{

                //}
            }
            else
            {
                acrossAllCoverages.Enabled = true;
                coverageSpecific.Enabled   = true;
                txtDeductible.Enabled      = true;
                acrossAllCoverages.Checked = true;
                coverageSpecific.Checked   = false;
                hdnApplyDeductible.Value   = "1";
            }
        }
        public void saveLimits(int policyID)
        {
            int         policyLimitID = 0;
            int         limitID       = 0;
            PolicyLimit limit         = null;

            foreach (GridViewRow row in gvLimits.Rows)
            {
                if (row.RowType == DataControlRowType.DataRow)
                {
                    WebNumericEditor txtLimit = row.FindControl("txtLimit") as WebNumericEditor;


                    policyLimitID = (int)gvLimits.DataKeys[row.RowIndex].Values[0];
                    limitID       = (int)gvLimits.DataKeys[row.RowIndex].Values[1];

                    if (policyLimitID == 0)
                    {
                        limit = new PolicyLimit();
                    }
                    else
                    {
                        limit = PolicyLimitManager.Get(policyLimitID);
                    }

                    limit.PolicyLimitID = policyLimitID;
                    limit.LimitID       = limitID;

                    limit.PolicyID    = policyID;
                    limit.LimitAmount = txtLimit.Value == null ? 0 : Convert.ToDecimal(txtLimit.Value);

                    try {
                        PolicyLimitManager.Save(limit);
                    }
                    catch (Exception ex) {
                        Core.EmailHelper.emailError(ex);
                    }
                }
            }
        }
        protected void gvLimits2_RowCommand(object sender, GridViewCommandEventArgs e)
        {
            int          limitID         = Convert.ToInt32(e.CommandArgument);
            int          policyId        = Convert.ToInt32(Session["policyID"].ToString());
            ClaimManager objClaimManager = new ClaimManager();


            using (TransactionScope scope = new TransactionScope())
            {
                List <Claim> lstClaim = objClaimManager.GetPolicyClaim(policyId);
                foreach (var claim in lstClaim)
                {
                    int claimId = claim.ClaimID;
                    ClaimLimitManager.EditModeDeleteClaimLimit(limitID, claimId);
                }
                PolicyLimitManager.EditModeDeletePolicyLimit(limitID);
                LimitManager.EditModeDeleteLimit(limitID);
                scope.Complete();
            }
            Response.Redirect(Request.RawUrl);
            bindData(policyId);
        }
        private ClaimReportView getClaimListingReport(List <ClaimReport> reportData, DateTime txtFromDateTime, DateTime txtToDateTime, int[] ddlCarrierList, string[] gvLocationList)
        {
            List <ClaimReport> ClaimReportArr               = new List <ClaimReport>();
            int                       clientID              = SessionHelper.getClientId();
            ClaimReportView           ClaimReportViewObj    = new ClaimReportView();
            List <ClaimReportAverage> ClaimReportAverageArr = new List <ClaimReportAverage>();
            ClaimReportAverage        ClaimReportAverageObj = new ClaimReportAverage();

            decimal totalCoverageA     = 0;
            decimal totalCoverageB     = 0;
            decimal totalCoverageC     = 0;
            decimal totalCoverageD     = 0;
            decimal totalCoverageE     = 0;
            decimal totalOtherCoverage = 0;
            decimal totalOurInvoice    = 0;
            decimal totalQty           = 0;

            for (var i = 0; i < reportData.Count; i++)
            {
                string insureBranch = getInsureBranch(reportData[i].claimId);
                string insuredName  = getInsuredName(reportData[i].claimId);
                string examinerName = "";
                if (reportData[i].ExaminerId != null)
                {
                    int examinerId = Convert.ToInt32(reportData[i].ExaminerId);

                    examinerName = getExaminerName(examinerId);
                }


                if (((reportData[i].DateReceived >= txtFromDateTime && reportData[i].DateClosed <= txtToDateTime) || txtToDateTime == DateTime.MinValue) && gvLocationList.Contains(insureBranch) && ddlCarrierList.Contains(Convert.ToInt32(reportData[i].CarrierId)))
                {
                    ClaimReport ClaimReportObj = new ClaimReport();
                    ClaimReportObj.AdjusterClaimNumber = reportData[i].AdjusterClaimNumber;
                    ClaimReportObj.InsurerClaim        = reportData[i].InsurerClaim;
                    ClaimReportObj.InsuredName         = insuredName;
                    TimeSpan span = Convert.ToDateTime(reportData[i].DateClosed) - Convert.ToDateTime(reportData[i].DateReceived);
                    ClaimReportObj.DaystoClose = span.Days;

                    ClaimReportObj.DateReceived    = reportData[i].DateReceived;
                    ClaimReportObj.DateClosed      = reportData[i].DateClosed;
                    ClaimReportObj.InsureBranch    = reportData[i].InsureBranch;
                    ClaimReportObj.OurAdjuster     = reportData[i].OurAdjuster;
                    ClaimReportObj.claimId         = reportData[i].claimId;
                    ClaimReportObj.CarrierExaminer = examinerName;


                    int policyId = reportData[i].policyId;

                    ClaimReportObj.CoverageA     = 0;
                    ClaimReportObj.CoverageB     = 0;
                    ClaimReportObj.CoverageC     = 0;
                    ClaimReportObj.CoverageD     = 0;
                    ClaimReportObj.CoverageE     = 0;
                    ClaimReportObj.OtherCoverage = 0;
                    ClaimReportObj.CoverageA     = PolicyLimitManager.getPolicyLimitAmount("A", policyId);
                    ClaimReportObj.CoverageB     = PolicyLimitManager.getPolicyLimitAmount("B", policyId);
                    ClaimReportObj.CoverageC     = PolicyLimitManager.getPolicyLimitAmount("C", policyId);
                    ClaimReportObj.CoverageD     = PolicyLimitManager.getPolicyLimitAmount("D", policyId);
                    ClaimReportObj.CoverageE     = PolicyLimitManager.getPolicyLimitAmount("E", policyId);
                    ClaimReportObj.OtherCoverage = PolicyLimitManager.getPolicyLimitAmountOther(policyId);
                    ClaimReportObj.OurInvoice    = InvoiceDetailManager.getTotalInvoice(reportData[i].claimId);
                    ClaimReportObj.Miles         = InvoiceDetailManager.getTotalMiles(reportData[i].claimId, clientID);



                    ClaimReportObj.CoverageA     = Decimal.Round(Convert.ToDecimal(ClaimReportObj.CoverageA), 2);
                    ClaimReportObj.CoverageB     = Decimal.Round(Convert.ToDecimal(ClaimReportObj.CoverageB), 2);
                    ClaimReportObj.CoverageC     = Decimal.Round(Convert.ToDecimal(ClaimReportObj.CoverageC), 2);
                    ClaimReportObj.CoverageD     = Decimal.Round(Convert.ToDecimal(ClaimReportObj.CoverageD), 2);
                    ClaimReportObj.CoverageE     = Decimal.Round(Convert.ToDecimal(ClaimReportObj.CoverageE), 2);
                    ClaimReportObj.OtherCoverage = Decimal.Round(Convert.ToDecimal(ClaimReportObj.OtherCoverage), 2);
                    ClaimReportObj.OurInvoice    = Decimal.Round(Convert.ToDecimal(ClaimReportObj.OurInvoice), 2);
                    ClaimReportObj.Miles         = Decimal.Round(Convert.ToDecimal(ClaimReportObj.Miles), 2);


                    if (ClaimReportObj.CoverageA != null)
                    {
                        totalCoverageA = Decimal.Round(totalCoverageA + Convert.ToDecimal(ClaimReportObj.CoverageA), 2);
                    }
                    if (ClaimReportObj.CoverageB != null)
                    {
                        totalCoverageB = Decimal.Round(totalCoverageB + Convert.ToDecimal(ClaimReportObj.CoverageB), 2);
                    }
                    if (ClaimReportObj.CoverageC != null)
                    {
                        totalCoverageC = Decimal.Round(totalCoverageC + Convert.ToDecimal(ClaimReportObj.CoverageC), 2);
                    }
                    if (ClaimReportObj.CoverageD != null)
                    {
                        totalCoverageD = Decimal.Round(totalCoverageD + Convert.ToDecimal(ClaimReportObj.CoverageD), 2);
                    }
                    if (ClaimReportObj.CoverageE != null)
                    {
                        totalCoverageE = Decimal.Round(totalCoverageE + Convert.ToDecimal(ClaimReportObj.CoverageE), 2);
                    }
                    if (ClaimReportObj.OtherCoverage != null)
                    {
                        totalOtherCoverage = Decimal.Round(totalOtherCoverage + Convert.ToDecimal(ClaimReportObj.OtherCoverage), 2);
                    }
                    if (ClaimReportObj.OurInvoice != null)
                    {
                        totalOurInvoice = Decimal.Round(totalOurInvoice + Convert.ToDecimal(ClaimReportObj.OurInvoice), 2);
                    }
                    if (ClaimReportObj.Miles != null)
                    {
                        totalQty = Decimal.Round(totalQty + Convert.ToDecimal(ClaimReportObj.Miles), 2);
                    }

                    ClaimReportArr.Add(ClaimReportObj);
                }
            }
            if (reportData != null && reportData.Count != 0)
            {
                ClaimReportViewObj.claimReportArr        = ClaimReportArr;
                ClaimReportAverageObj.totalCoverageA     = totalCoverageA;
                ClaimReportAverageObj.totalCoverageB     = totalCoverageB;
                ClaimReportAverageObj.totalCoverageC     = totalCoverageC;
                ClaimReportAverageObj.totalCoverageD     = totalCoverageD;
                ClaimReportAverageObj.totalCoverageE     = totalCoverageE;
                ClaimReportAverageObj.totalOtherCoverage = totalOtherCoverage;
                ClaimReportAverageObj.totalOurInvoice    = totalOurInvoice;
                ClaimReportAverageObj.totalMiles         = totalQty;
            }


            if (reportData != null && reportData.Count != 0)
            {
                ClaimReportAverageObj.avgCoverageA     = Decimal.Round(totalCoverageA / reportData.Count, 2);
                ClaimReportAverageObj.avgCoverageB     = Decimal.Round(totalCoverageB / reportData.Count, 2);
                ClaimReportAverageObj.avgCoverageC     = Decimal.Round(totalCoverageC / reportData.Count, 2);
                ClaimReportAverageObj.avgCoverageD     = Decimal.Round(totalCoverageD / reportData.Count, 2);
                ClaimReportAverageObj.avgCoverageE     = Decimal.Round(totalCoverageE / reportData.Count, 2);
                ClaimReportAverageObj.avgOtherCoverage = Decimal.Round(totalOtherCoverage / reportData.Count, 2);
                ClaimReportAverageObj.avgOurInvoice    = Decimal.Round(totalOurInvoice / reportData.Count, 2);
                ClaimReportAverageObj.avgMiles         = Decimal.Round(totalQty / reportData.Count, 2);
            }
            ClaimReportAverageArr.Add(ClaimReportAverageObj);
            ClaimReportViewObj.ClaimReportAverageObj = ClaimReportAverageArr;
            return(ClaimReportViewObj);
        }
        public void bindData(int policyID)
        {
            List <PolicyLimit> limits = null;


            if (HttpContext.Current.Session["Limit"] != null && HttpContext.Current.Session["PolicyLimit"] != null && HttpContext.Current.Session["tblCasulityPolicylimit"] != null && HttpContext.Current.Session["tblAllPolicylimit"] != null)
            {
                DataTable Limit       = HttpContext.Current.Session["Limit"] as DataTable;
                DataTable PolicyLimit = HttpContext.Current.Session["tblCasulityPolicylimit"] as DataTable;

                var results = from limit in Limit.AsEnumerable()
                              join policylimit in PolicyLimit.AsEnumerable() on(int) limit["LimitID"] equals(int) policylimit["LimitID"]
                              select new
                {
                    LimitLetter      = (string)limit["LimitLetter"],
                    LimitDescription = (string)limit["LimitDescription"],
                    LimitAmount      = (decimal)policylimit["LimitAmount"],
                    LimitID          = (int)limit["LimitID"],
                    //LimitDeductible = (decimal)policylimit["LimitDeductible"],
                    //ApplyTo = (string)policylimit["ApplyTo"],
                    //ITV = (decimal)policylimit["ITV"],
                    //Reserve = (decimal)policylimit["Reserve"],
                };


                gvLimits3.DataSource = results;
                gvLimits3.DataBind();

                if (!results.Any())
                {
                    lblNoRecordFound.Visible = true;
                }
                else
                {
                    lblNoRecordFound.Visible = false;
                }
            }
            else
            {
                limits = PolicyLimitManager.GetAll(policyID, LimitType.LIMIT_TYPE_CASUALTY);
                bool isStatic = PolicyLimitManager.LimitIsStatic(policyID);


                //gvLimits.DataSource = limits;
                //gvLimits.DataBind();

                lblNoRecordFound.Visible = false;
                if (limits.Count > 0)
                {
                    if (isStatic)
                    {
                        gvLimits.DataSource = limits;
                        gvLimits.DataBind();

                        gvLimits2.DataSource = null;
                        gvLimits2.DataBind();
                    }
                    else
                    {
                        gvLimits.DataSource = null;
                        gvLimits.DataBind();
                        gvLimits2.DataSource = limits;
                        gvLimits2.DataBind();
                    }
                }
                else
                {
                    lblNoRecordFound.Visible = true;
                }

                if (isStatic == true || policyID == 0)
                {
                    if (limits != null && limits.Count == 0)
                    {
                        limits = primeCasualtyLimits();
                        gvLimits.DataSource = limits;
                        gvLimits.DataBind();

                        gvLimits2.DataSource = null;
                        gvLimits2.DataBind();
                        lblNoRecordFound.Visible = false;
                    }
                }

                gvLimits3.DataSource = null;
                gvLimits3.DataBind();
            }
        }
Beispiel #8
0
        public void saveLimits(int policyID)
        {
            int policyLimitID = 0;
            int limitID       = 0;
            //int claimLimitID = 0;
            int myClaimID      = 0;
            int myClaimLimitID = 0;
            int myLimitId      = 0;                 //anything prefaced with "my" is new; OC

            myClaimID = SessionHelper.getClaimID(); //Convert.ToInt32(Session["ClaimID"]);
            PolicyLimit limit         = null;
            PolicyLimit myPolicyLimit = null;
            Limit       myLimit       = null;
            // ClaimLimit myClaimLimit = null;
            //added new; OC 9/11/2014: put in place to add new row to the policy limits grid. took the old 3 column one out.
            //crete the footer controls available for use here :OC 9/12/14
            WebTextEditor    txtMyCoverage         = (WebTextEditor)gvLimits.FooterRow.FindControl("txtMyCoverage");
            WebTextEditor    txtMyDescription      = (WebTextEditor)gvLimits.FooterRow.FindControl("txtMyDescription");
            WebNumericEditor txtMyLimit            = (WebNumericEditor)gvLimits.FooterRow.FindControl("txtMyLimit");
            WebNumericEditor txtMyDeductible       = (WebNumericEditor)gvLimits.FooterRow.FindControl("txtMyDeductible");
            WebTextEditor    txtMyCATDeductible    = (WebTextEditor)gvLimits.FooterRow.FindControl("txtMyCATDeductible");
            WebDropDown      ddlMySettlementType   = (WebDropDown)gvLimits.FooterRow.FindControl("ddlMySettlementType");
            WebPercentEditor txtMyCoInsuranceLimit = (WebPercentEditor)gvLimits.FooterRow.FindControl("txtMyCoInsuranceLimit");
            WebPercentEditor txtMyITV           = (WebPercentEditor)gvLimits.FooterRow.FindControl("txtMyITV");
            WebNumericEditor txtMyReserve       = (WebNumericEditor)gvLimits.FooterRow.FindControl("txtMyReserve");
            WebTextEditor    txtMyWHDeductible  = (WebTextEditor)gvLimits.FooterRow.FindControl("txtMyWHDeductible");
            WebNumericEditor txtMyLossAmountACV = (WebNumericEditor)gvLimits.FooterRow.FindControl("txtMyLossAmountACV");
            WebNumericEditor txtMyLossAmountRCV = (WebNumericEditor)gvLimits.FooterRow.FindControl("txtMyLossAmountRCV");
            WebNumericEditor txtMyOverage       = (WebNumericEditor)gvLimits.FooterRow.FindControl("txtMyOverage");

            if (txtMyCoverage.Text != "")//TODO: change this condition to something more stable (checkbox or something)
            {
                //LIMIT TABLE STUFF
                myLimit                  = new Limit();
                myLimit.LimitLetter      = txtMyCoverage.Text;
                myLimit.LimitType        = 1;//need to change to user input and create text boxes
                myLimit.LimitDescription = txtMyDescription.Text;
                myLimit.IsStatic         = false;
                try
                {
                    LimitManager.Save(myLimit);
                }
                catch (Exception ex)
                {
                    Core.EmailHelper.emailError(ex);
                }

                var a = LimitManager.GetLatest(); //need to get the lastly created limit id from the insert we just did above
                myLimitId = Convert.ToInt32(a.LimitID);

                //CLAIM LIMIT STUFF
                //myClaimLimit = new ClaimLimit();
                //myClaimLimit.LimitID = myLimitId;
                //myClaimLimit.ClaimID = myClaimID;
                //myClaimLimit.PolicyID = policyID;
                //myClaimLimit.LossAmountACV = txtMyLossAmountACV.Value == null ? 0 : Convert.ToDecimal(txtMyLossAmountACV.Text);
                //myClaimLimit.LossAmountRCV = txtMyLossAmountRCV.Value == null ? 0 : Convert.ToDecimal(txtMyLossAmountRCV.Text);
                //myClaimLimit.OverageAmount = txtMyOverage.Value == null ? 0 : Convert.ToDecimal(txtMyOverage.Text);
                //try
                //{
                //    ClaimLimitManager.Save(myClaimLimit);
                //}
                //catch (Exception ex)
                //{

                //}
                //var b = ClaimLimitManager.GetLatest();
                //myClaimLimitID = Convert.ToInt32(b.ClaimLimitID);

                //POLICY LIMIT STUFF
                myPolicyLimit                 = new PolicyLimit();
                myPolicyLimit.PolicyID        = policyID;
                myPolicyLimit.LimitID         = myLimitId;
                myPolicyLimit.ClaimLimitID    = myClaimLimitID;
                myPolicyLimit.LimitAmount     = txtMyLimit.Value == null ? 0 : Convert.ToDecimal(txtMyLimit.Text); //= Convert.ToDecimal(txtMyLimit.Text);
                myPolicyLimit.LimitDeductible = txtMyDeductible.Value == null ? 0 : Convert.ToDecimal(txtMyDeductible.Text);
                myPolicyLimit.CATDeductible   = txtMyCATDeductible.Text;
                if (ddlMySettlementType.SelectedItemIndex > 0)
                {
                    myPolicyLimit.ApplyTo = ddlMySettlementType.SelectedItem.Text;
                }
                else
                {
                    myPolicyLimit.ApplyTo = null;
                }

                myPolicyLimit.ConInsuranceLimit = Convert.ToDecimal(txtMyCoInsuranceLimit.Value);
                myPolicyLimit.ITV                = Convert.ToDecimal(txtMyITV.Value);
                myPolicyLimit.Reserve            = Convert.ToDecimal(txtMyReserve.Value);
                myPolicyLimit.WindHailDeductible = txtMyWHDeductible.Text;
                myPolicyLimit.LossAmountACV      = txtMyLossAmountACV.Value == null ? 0 : Convert.ToDecimal(txtMyLossAmountACV.Text);
                myPolicyLimit.LossAmountRCV      = txtMyLossAmountRCV.Value == null ? 0 : Convert.ToDecimal(txtMyLossAmountRCV.Text);
                myPolicyLimit.OverageAmount      = txtMyOverage.Value == null ? 0 : Convert.ToDecimal(txtMyOverage.Text);

                try
                {
                    PolicyLimitManager.Save(myPolicyLimit);
                }
                catch (Exception ex)
                {
                }
            }

            else //run the regular stuff it was doing before
            {
                //original code
                foreach (GridViewRow row in gvLimits.Rows)
                {
                    if (row.RowType == DataControlRowType.DataRow)
                    {
                        //Label txtLimitLetter = row.FindControl("txtLimitLetter") as Label;
                        //Label txtDescription = row.FindControl("txtDescription") as Label;
                        WebNumericEditor txtLimit            = row.FindControl("txtLimit") as WebNumericEditor;
                        WebNumericEditor txtDeductible       = row.FindControl("txtDeductible") as WebNumericEditor;
                        WebTextEditor    txtWHDeductible     = row.FindControl("txtWHDeductible") as WebTextEditor;//new
                        WebTextEditor    txtCATDeductible    = row.FindControl("txtCATDeductible") as WebTextEditor;
                        WebTextEditor    txtSettlementType   = row.FindControl("txtSettlementType") as WebTextEditor;
                        WebNumericEditor txtCoInsuranceLimit = row.FindControl("txtCoInsuranceLimit") as WebNumericEditor;
                        WebDropDown      ddlSettlementType   = row.FindControl("ddlSettlementType") as WebDropDown;
                        WebPercentEditor txtITV           = row.FindControl("txtITV") as WebPercentEditor;           //new
                        WebNumericEditor txtReserve       = row.FindControl("txtReserve") as WebNumericEditor;       //new
                        WebNumericEditor txtLossAmountACV = row.FindControl("txtLossAmountACV") as WebNumericEditor; //new
                        WebNumericEditor txtLossAmountRCV = row.FindControl("txtLossAmountRCV") as WebNumericEditor; //new
                        WebNumericEditor txtOverage       = row.FindControl("txtOverage") as WebNumericEditor;       //new
                        policyLimitID = (int)gvLimits.DataKeys[row.RowIndex].Values[0];
                        limitID       = (int)gvLimits.DataKeys[row.RowIndex].Values[1];

                        //claimLimitID = (int)gvLimits.DataKeys[row.RowIndex].Values[2];
                        //claimLimitID = (int)gvLimits.DataKeys[row.RowIndex].Values[2];
                        //if ((txtLossAmountACV.Text != "" ||
                        //    txtLossAmountRCV.Text != "" ||
                        //    txtOverage.Text != "" )&&
                        //   ( txtOverage.Text != "0.00" ||
                        //    txtLossAmountRCV.Text != "0.00" ||
                        //    txtLossAmountACV.Text != "0.00"))
                        //{
                        //CLAIM LIMIT STUFF
                        //myClaimLimit = new ClaimLimit();
                        //myClaimLimit.ClaimLimitID = claimLimitID;
                        //myClaimLimit.LimitID = limitID;
                        //myClaimLimit.ClaimID = myClaimID;
                        //myClaimLimit.PolicyID = policyID;
                        //myClaimLimit.PolicyLimitID = policyLimitID;
                        //myClaimLimit.LossAmountACV = txtLossAmountACV.Value == null ? 0 : Convert.ToDecimal(txtLossAmountACV.Text);
                        //myClaimLimit.LossAmountRCV = txtLossAmountRCV.Value == null ? 0 : Convert.ToDecimal(txtLossAmountRCV.Text);
                        //myClaimLimit.OverageAmount = txtOverage.Value == null ? 0 : Convert.ToDecimal(txtOverage.Text);
                        //try
                        //{
                        //    ClaimLimitManager.Save(myClaimLimit);
                        //}
                        //catch (Exception ex)
                        //{

                        //}
                        ////    var b = ClaimLimitManager.GetLatest2(policyLimitID);
                        ////    myClaimLimitID = Convert.ToInt32(b.ClaimLimitID);
                        ////}
                        if (policyLimitID == 0)
                        {
                            limit = new PolicyLimit();
                        }
                        else
                        {
                            limit = PolicyLimitManager.Get(policyLimitID);
                        }

                        limit.PolicyLimitID = policyLimitID;
                        limit.LimitID       = limitID;
                        //limit.ClaimLimitID = claimLimitID;
                        limit.PolicyID           = policyID;
                        limit.LimitAmount        = txtLimit.Value == null ? 0 : Convert.ToDecimal(txtLimit.Value);
                        limit.LimitDeductible    = txtDeductible.Value == null ? 0 : Convert.ToDecimal(txtDeductible.Value);
                        limit.CATDeductible      = txtCATDeductible.Text;
                        limit.WindHailDeductible = txtWHDeductible.Text;
                        limit.ConInsuranceLimit  = txtCoInsuranceLimit.Value == null ? 0 : Convert.ToDecimal(txtCoInsuranceLimit.Value);
                        limit.ITV           = Convert.ToDecimal(txtITV.Value);
                        limit.Reserve       = Convert.ToDecimal(txtReserve.Value);
                        limit.LossAmountACV = txtLossAmountACV.Value == null ? 0 : Convert.ToDecimal(txtLossAmountACV.Text);
                        limit.LossAmountRCV = txtLossAmountRCV.Value == null ? 0 : Convert.ToDecimal(txtLossAmountRCV.Text);
                        limit.OverageAmount = txtOverage.Value == null ? 0 : Convert.ToDecimal(txtOverage.Text);
                        if (ddlSettlementType.SelectedItemIndex > 0)
                        {
                            //limit.SettlementType = ddlSettlementType.SelectedValue;
                            limit.ApplyTo = ddlSettlementType.SelectedValue;
                        }
                        else
                        {
                            limit.ApplyTo = null;
                        }

                        try
                        {
                            PolicyLimitManager.Save(limit);
                        }
                        catch (Exception ex)
                        {
                            Core.EmailHelper.emailError(ex);
                        }
                    }
                }
            }
            cbAddNewPolicy.Checked = false;
            disableNewRow();
        }