private List <Error> SaveGrid(BenefitPlanVM grid1, IEnumerable <KeyValuePair <string, ModelState> > state, Benefit benefit)
        {
            List <Error> errors = new List <Error>();

            // Deleted
            if (grid1.deleted != null)
            {
                foreach (BenefitPlanViewModel model in grid1.deleted)
                {
                    var benefitplan = new BenefitPlan
                    {
                        Id = model.Id
                    };
                    AutoMapper(new Models.AutoMapperParm
                    {
                        Source     = benefitplan,
                        ObjectName = "Benefit",
                        Transtype  = TransType.Delete
                    });

                    _hrUnitOfWork.BenefitsRepository.Remove(benefitplan);
                }
            }

            // Exclude delete models from sever side validations
            if (ServerValidationEnabled)
            {
                var modified = Models.Utils.GetModifiedRows(state.Where(a => !a.Key.Contains("deleted")));
                if (modified.Count > 0)
                {
                    errors = _hrUnitOfWork.CompanyRepository.Check(new CheckParm
                    {
                        CompanyId  = CompanyId,
                        ObjectName = "BenefitPlans",
                        Columns    = Models.Utils.GetModifiedRows(state.Where(a => !a.Key.Contains("deleted"))),
                        Culture    = Language
                    });

                    if (errors.Count() > 0)
                    {
                        return(errors);
                    }
                }
            }

            // updated records
            if (grid1.updated != null)
            {
                foreach (BenefitPlanViewModel model in grid1.updated)
                {
                    var benefitplan = new BenefitPlan();
                    _hrUnitOfWork.BenefitsRepository.BenefitServs(model.BenefitServs, model.Id);
                    AutoMapper(new Models.AutoMapperParm {
                        Destination = benefitplan, Source = model, Transtype = TransType.Update
                    });
                    benefitplan.ModifiedTime = DateTime.Now;
                    benefitplan.ModifiedUser = UserName;
                    _hrUnitOfWork.BenefitsRepository.Attach(benefitplan);
                    _hrUnitOfWork.BenefitsRepository.Entry(benefitplan).State = EntityState.Modified;
                }
            }

            // inserted records
            if (grid1.inserted != null)
            {
                foreach (BenefitPlanViewModel model in grid1.inserted)
                {
                    var benefitplan = new BenefitPlan();
                    AutoMapper(new Models.AutoMapperParm {
                        Destination = benefitplan, Source = model, Transtype = TransType.Insert
                    });
                    benefitplan.Benefit     = benefit;
                    benefitplan.CreatedTime = DateTime.Now;
                    benefitplan.CreatedUser = UserName;
                    var ids             = _hrUnitOfWork.Repository <BenefitServ>().Where(a => model.BenefitServs.Contains(a.Name)).Select(a => a.Id).ToList();
                    var benfitServPlans = new List <BenefitServPlans>();
                    ids.ForEach(delegate(int id)
                    {
                        benfitServPlans.Add(new BenefitServPlans {
                            BenefitPlan = benefitplan, BenefitServId = id
                        });
                    });
                    _hrUnitOfWork.BenefitsRepository.AddRange(benfitServPlans);
                    _hrUnitOfWork.BenefitsRepository.Add(benefitplan);
                }
            }

            return(errors);
        }
        public ActionResult Details(BenefitFormViewModel model, OptionsViewModel moreInfo, BenefitPlanVM grid1)
        {
            List <Error> errors = new List <Error>();

            if (ModelState.IsValid)
            {
                if (ServerValidationEnabled)
                {
                    errors = _hrUnitOfWork.SiteRepository.CheckForm(new CheckParm
                    {
                        CompanyId    = CompanyId,
                        ObjectName   = "Benefit",
                        TableName    = "Benefits",
                        ParentColumn = "CompanyId",
                        Columns      = Models.Utils.GetColumnViews(ModelState.Where(a => !a.Key.Contains('.'))),
                        Culture      = Language
                    });

                    if (errors.Count() > 0)
                    {
                        foreach (var e in errors)
                        {
                            foreach (var errorMsg in e.errors)
                            {
                                ModelState.AddModelError(errorMsg.field, errorMsg.message);
                            }
                        }

                        return(Json(Models.Utils.ParseFormErrors(ModelState)));
                    }
                }
                var sequence = _hrUnitOfWork.Repository <Benefit>().Select(a => a.Code).DefaultIfEmpty(0).Max();
                // var MaxCode

                Benefit record;
                //insert
                if (model.Id == 0)
                {
                    record = new Benefit();

                    AutoMapper(new Models.AutoMapperParm
                    {
                        Destination = record,
                        Source      = model,
                        ObjectName  = "Benefit",
                        Options     = moreInfo,
                        Transtype   = TransType.Insert
                    });
                    MapBenefit(record, model, moreInfo);
                    record.CreatedUser = UserName;
                    record.CreatedTime = DateTime.Now;
                    if (model.EmpAccural != 3)
                    {
                        record.WaitMonth = null;
                    }
                    record.CompanyId = model.IsLocal ? CompanyId : (int?)null;
                    if (record.StartDate > record.EndDate)
                    {
                        ModelState.AddModelError("EndDate", MsgUtils.Instance.Trls("EndDateGthanStartDate"));
                        return(Json(Models.Utils.ParseFormErrors(ModelState)));
                    }
                    _hrUnitOfWork.BenefitsRepository.Add(record);
                }
                //update
                else
                {
                    record = _hrUnitOfWork.Repository <Benefit>().FirstOrDefault(a => a.Id == model.Id);
                    AutoMapper(new Models.AutoMapperParm
                    {
                        Destination = record,
                        Source      = model,
                        ObjectName  = "Benefit",
                        Options     = moreInfo,
                        Transtype   = TransType.Update
                    });
                    MapBenefit(record, model, moreInfo);
                    record.ModifiedTime = DateTime.Now;
                    record.ModifiedUser = UserName;
                    if (model.EmpAccural != 3)
                    {
                        record.WaitMonth = null;
                    }
                    record.CompanyId = model.IsLocal ? CompanyId : (int?)null;
                    if (record.StartDate > record.EndDate)
                    {
                        ModelState.AddModelError("EndDate", MsgUtils.Instance.Trls("EndDateGthanStartDate"));
                        return(Json(Models.Utils.ParseFormErrors(ModelState)));
                    }
                    _hrUnitOfWork.BenefitsRepository.Attach(record);
                    _hrUnitOfWork.BenefitsRepository.Entry(record).State = EntityState.Modified;
                }

                // Save grid1
                errors = SaveGrid(grid1, ModelState.Where(a => a.Key.Contains("grid")), record);

                if (errors.Count > 0)
                {
                    return(Json(errors.First().errors.First().message));
                }

                errors = SaveChanges(Language);

                var message = "OK";
                if (errors.Count > 0)
                {
                    message = errors.First().errors.First().message;
                }

                return(Json(message));
            }

            return(Json(Models.Utils.ParseFormErrors(ModelState)));
        }