Exemplo n.º 1
0
        //Policy Approval and posting to accounts
        public object InsuranceTransactionPosting(IEnumerable <INSURANCE_LEDGER> ledger)
        {
            var db = new SibaModel();

            using (var trans = db.Database.BeginTransaction())
            {
                try
                {
                    int polSysID;
                    var policy = db.INS_UWD_POLICY_HEAD.Find(ledger.FirstOrDefault().IGL_POL_SYS_ID);

                    //save policy header history
                    var historyPolicy = new INS_UWD_HPOLICY_HEAD();
                    historyPolicy.Map(policy);
                    historyPolicy.POLH_TXN_STATE = "P";
                    db.INS_UWD_HPOLICY_HEAD.Add(historyPolicy);

                    //insert policy fee history
                    policy.INS_UDW_POL_FEES.ForEach(f =>
                    {
                        var historyPolFee = new INS_UDW_HPOL_FEES();
                        historyPolFee.Map(f);
                        db.INS_UDW_HPOL_FEES.Add(historyPolFee);
                    });


                    policy.INS_UDW_BONDS.ForEach(b =>
                    {
                        var historyBonds = new INS_UDW_HBONDS();
                        historyBonds.Map(b);
                        db.INS_UDW_HBONDS.Add(historyBonds);

                        //save risk cover history
                        b.INS_UWD_RISK_COVERS.ForEach(c =>
                        {
                            var historyCovers = new INS_UWD_HRISK_COVERS();
                            historyCovers.Map(c);
                            db.INS_UWD_HRISK_COVERS.Add(historyCovers);
                        });
                    });

                    policy.INS_UDW_BOND_FEES.ForEach(f =>
                    {
                        var historyriskFee = new INS_UDW_HBOND_FEES();
                        historyriskFee.Map(f);
                        db.INS_UDW_HBOND_FEES.Add(historyriskFee);
                    });

                    policy.INS_RI_FAC_INWARD.ForEach(inw =>
                    {
                        var historyRIFacInward = new INS_HRI_FAC_INWARD();
                        historyRIFacInward.Map(inw);
                        db.INS_HRI_FAC_INWARD.Add(historyRIFacInward);

                        inw.INS_RI_FAC_INW_COMPANY.ForEach(c =>
                        {
                            var historyInFacCompany = new INS_HRI_FAC_INW_COMPANY();
                            historyInFacCompany.Map(c);
                            db.INS_HRI_FAC_INW_COMPANY.Add(historyInFacCompany);
                        });
                    });

                    policy.INS_RI_FAC_OUTWARD.ForEach(otw =>
                    {
                        var historyRIFacOutward = new INS_HRI_FAC_OUTWARD();
                        historyRIFacOutward.Map(otw);
                        db.INS_HRI_FAC_OUTWARD.Add(historyRIFacOutward);
                    });



                    //todo: insert other product risk history

                    ledger.ForEach(l =>
                    {
                        polSysID = (int)l.IGL_POL_SYS_ID;

                        if (l.IGL_STATUS.Equals("U"))
                        {
                            //insurance ledger head to general ledger head mapping
                            var glHeader = new ACCT_GL_HEAD
                            {
                                TH_ACCT_YEAR     = (short)l.IGL_ACCT_DATE.Value.Year,
                                TH_ANALYSIS_01   = null,
                                TH_BATCH_ID      = l.IGL_SYS_ID,
                                TH_COMP_CODE     = null,
                                TH_CRTE_BY       = "System",
                                TH_CRTE_DATE     = DateTime.Now,
                                TH_DEPT_CODE     = null,
                                TH_DOC_CAL_MONTH = (byte)l.IGL_ACCT_DATE.Value.Month,
                                TH_DOC_CAL_YEAR  = (short)l.IGL_ACCT_DATE.Value.Year,
                                TH_DOC_DATE      = l.IGL_ACCT_DATE,
                                TH_DOC_NO        = l.IGL_DOC_NUMBER,
                                TH_DOC_TYPE      = l.IGL_TXN_DOC_TYPE,
                                TH_MOD_BY        = "",
                                TH_MOD_DATE      = null,
                                TH_OFFICE_CODE   = null,
                                TH_STATUS        = "A",
                                TH_TXN_REF       = l.IG_REF_DOC,
                                TH_TXN_REF_DT    = l.IGL_ACCT_DATE,
                                TH_NARRATION     = l.IGL_NARRATION
                            };

                            db.ACCT_GL_HEAD.Add(glHeader);
                            db.SaveChanges();

                            //insurance sub ledger to general ledger detail mapping
                            l.INSURANCE_SUB_LEDGER.ForEach(s =>
                            {
                                db.ACCT_GL_DETAIL.Add(new ACCT_GL_DETAIL
                                {
                                    TD_AMT_BC         = s.ISL_AMOUNT_BC,
                                    TD_AMT_FC         = s.ISL_AMOUNT_FC,
                                    TD_ANNALYSIS_1    = s.ISL_SUB_LEDGER,
                                    TD_CRTE_BY        = "System",
                                    TD_CRTE_DATE      = DateTime.Now,
                                    TD_CURR_CODE      = s.ISL_CURRENCY,
                                    TD_CURR_RATE      = s.ISL_FX_RATE,
                                    TD_DEPT_CODE      = s.ISL_OFFICE,
                                    TD_DOC_DATE       = s.ISL_ACCT_DATE,
                                    TD_DOC_NO         = null,//glHeader.TH_DOC_NO,
                                    TD_DOC_REF        = null,
                                    TD_LINE_NARRATION = s.ISL_NARRATION,
                                    TD_DRCR_FLAG      = s.ISL_DR_CR,
                                    TD_OFFICE_CODE    = s.ISL_OFFICE,
                                    TD_SEQ_NO         = 0,
                                    TD_TH_SYS_ID      = glHeader.TH_SYS_ID,
                                    TD_STATUS         = "A",
                                    TD_SUB_ACCT_LV1   = s.ISL_SUB_LEDGER,
                                    TD_SUB_ACCT_LV2   = s.ISL_SUB_LEDGER,
                                    TD_MAIN_ACCT_CODE = s.ISL_ACCT_NUMBER
                                });
                            });


                            //insurance ledger header to open entry mapping
                            db.ACCT_TXN_OPEN_ENTRY.Add(new ACCT_TXN_OPEN_ENTRY
                            {
                                OE_TXN_REF_ID = l.IGL_SYS_ID.ToString(),
                                //OE_TXN_REF_ID = l.IGL_SYS_ID.ToString(),
                                OE_R_BATCH_ID        = null,
                                OE_DOC_TYPE          = l.IGL_TXN_DOC_TYPE,
                                OE_DOC_NO            = l.IGL_DOC_NUMBER,
                                OE_LINE_NO           = null,
                                OE_DOC_DATE          = l.IGL_ACCT_DATE,
                                OE_DUE_DATE          = l.IGL_ACCT_DATE,
                                OE_CUST_CODE         = l.IGL_CUST_CODE,
                                OE_MAIN_ACCT_CODE    = l.IGL_ACCOUNT_CODE,
                                OE_SUB_ACCT_CODE     = null,
                                OE_DR_CR             = l.IGL_DR_CR,
                                OE_OFFICE_CODE       = null,
                                OE_CURR_CODE         = l.IGL_CURRENCY,
                                OE_CURR_RATE         = l.IGL_FX_RATE,
                                OE_ORGNL_FC_AMT      = l.IGL_AMOUNT_FC,
                                OE_ORGNL_BC_AMT      = l.IGL_AMOUNT_BC,
                                OE_ADJ_FC_AMT        = null,
                                OE_ADJ_BC_AMT        = null,
                                OE_UNPOST_ADJ_FC_AMT = null,
                                OE_UNPOST_ADJ_BC_AMT = null,
                                OE_ACCT_YEAR         = (short)l.IGL_ACCT_DATE.Value.Year,
                                OE_DOC_CAL_MONTH     = (byte)l.IGL_ACCT_DATE.Value.Month,
                                OE_CRTE_BY           = "System",
                                OE_CRTE_DATE         = DateTime.Now,
                            });

                            //update  insurance ledger status to posted(P)
                            var dbLedger = db.INSURANCE_LEDGER.Find(l.IGL_SYS_ID);
                            db.INSURANCE_LEDGER.Attach(dbLedger);
                            dbLedger.IGL_STATUS = "P";


                            //update  Policy Transaction state after Approval (P)
                            var dbPolTxn = db.INS_UWD_POLICY_HEAD.Find(l.IGL_POL_SYS_ID);
                            db.INS_UWD_POLICY_HEAD.Attach(dbPolTxn);
                            dbPolTxn.POLH_TXN_STATE = "P";
                        }
                    });


                    db.SaveChanges();
                    trans.Commit();

                    //return policy status
                    var POLH_TXN_STATE = "P";
                    return(new { POLH_TXN_STATE });
                }
                catch (Exception e)
                {
                    trans.Rollback();
                    throw;
                }
            }
        }
Exemplo n.º 2
0
        public static bool PolicyHistoryInsert(INS_UWD_POLICY_HEAD policy)
        {
            var db = new SibaModel();

            using (db)
            {
                using (var trans = db.Database.BeginTransaction())
                {
                    try
                    {
                        //save policy header history
                        var historyPolicy = new INS_UWD_HPOLICY_HEAD();
                        historyPolicy.Map(policy);
                        db.INS_UWD_HPOLICY_HEAD.Add(historyPolicy);


                        //save policy vehicle risk hsitory
                        policy.INS_UWD_VEHICLE_RISK.ForEach(r =>
                        {
                            var historyRisk = new INS_UWD_HVEHICLE_RISK();
                            historyRisk.Map(r);
                            db.INS_UWD_HVEHICLE_RISK.Add(historyRisk);

                            //save risk cover history
                            r.INS_UWD_RISK_COVERS.ForEach(c =>
                            {
                                var historyCover = new INS_UWD_HRISK_COVERS();
                                historyCover.Map(c);
                                db.INS_UWD_HRISK_COVERS.Add(historyCover);

                                //save cover discount history
                                c.INS_UDW_COVER_DISCLOAD.ForEach(d =>
                                {
                                    var hisDiscLoad = new INS_UDW_HCOVER_DISCLOAD();
                                    hisDiscLoad.Map(d);
                                    db.INS_UDW_HCOVER_DISCLOAD.Add(hisDiscLoad);
                                });
                            });

                            //save risk fee history
                            r.INS_UDW_VEHICLE_FEES.ForEach(f =>
                            {
                                var historyFee = new INS_UDW_HVEHICLE_FEES();
                                historyFee.Map(f);
                                db.INS_UDW_HVEHICLE_FEES.Add(historyFee);
                            });


                            //save risk discount history
                            r.INS_UDW_RISK_DISCLOAD.ForEach(d =>
                            {
                                var historyDiscount = new INS_UDW_HRISK_DISCLOAD();
                                historyDiscount.Map(d);
                                db.INS_UDW_HRISK_DISCLOAD.Add(historyDiscount);
                            });

                            //save risk excess history
                            r.INS_UDW_RISK_EXCESS.ForEach(e =>
                            {
                                var historyExcess = new INS_UDW_HRISK_EXCESS();
                                historyExcess.Map(e);
                                db.INS_UDW_HRISK_EXCESS.Add(historyExcess);
                            });
                        });


                        //todo: save other product risk history
                        db.SaveChanges();
                        trans.Commit();
                        return(true);
                    }
                    catch (Exception)
                    {
                        trans.Rollback();
                        throw;
                    }
                }
            }
        }