// GET: SalaryStructures/Edit/5
        public async Task <ActionResult> Edit(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            SalaryStructure salaryStructure = await db.SalaryStructures.FindAsync(id);

            if (salaryStructure == null)
            {
                return(HttpNotFound());
            }
            List <SelectListItem> list = new List <SelectListItem>();

            foreach (var rolee in RoleManager.Roles)
            {
                list.Add(new SelectListItem()
                {
                    Value = rolee.Name, Text = rolee.Name
                });
            }
            list.RemoveRange(4, 2);
            ViewBag.Roles = list;
            return(View(salaryStructure));
        }
Ejemplo n.º 2
0
        private void bandedGridView1_FocusedRowChanged(object sender, FocusedRowChangedEventArgs e)
        {
            SalaryStructure row = bandedGridView1.GetRow(e.PrevFocusedRowHandle) as SalaryStructure;

            if (row != null)
            {
            }
        }
Ejemplo n.º 3
0
        private void bandedGridView1_CellValueChanging(object sender, CellValueChangedEventArgs e)
        {
            SalaryStructure row = bandedGridView1.GetRow(e.RowHandle) as SalaryStructure;

            if (row != null)
            {
            }
        }
        public async Task <ActionResult> DeleteConfirmed(int id)
        {
            SalaryStructure salaryStructure = await db.SalaryStructures.FindAsync(id);

            db.SalaryStructures.Remove(salaryStructure);
            await db.SaveChangesAsync();

            return(RedirectToAction("Index"));
        }
Ejemplo n.º 5
0
        public IActionResult Create(vmSalaryStructureDetails salaryStructure)
        {
            bool flag = false;

            if (ModelState.IsValid)
            {
                try
                {
                    var structure = new SalaryStructure
                    {
                        Name = salaryStructure.Name,
                    };
                    db.SalaryStructure.Add(structure);
                    db.Save();

                    SalaryStructureDetails details = new SalaryStructureDetails()
                    {
                        SalaryStructureId = structure.Id,

                        SalaryBreakupId = salaryStructure.SalaryBreakupId,
                        Amount          = salaryStructure.Amount,
                        Percentage      = salaryStructure.Percentage,
                    };
                    db.SalaryStructureDetails.Add(details);
                    db.Save();
                    flag = true;
                    //employee salary
                    foreach (var item in salaryStructure.SalaryStructureList)
                    {
                        if (salaryStructure.SalaryGrade != null)
                        {
                            var salary = new EmployeeSalaryBase()
                            {
                                SalaryStructureId = salaryStructure.SalaryGrade.Value,
                                SalaryBreakupId   = item.SalaryBreakupId,
                                Amount            = item.Amount,
                                EffectiveFrom     = DateTime.Now,
                                Remarks           = item.Remarks,
                            };
                            db.EmployeeSalaryBase.Add(salary);
                            db.Save();
                        }
                    }
                }

                catch (Exception ex)
                {
                }
            }
            return(Json(flag));
        }
        // GET: SalaryStructures/Details/5
        public async Task <ActionResult> Details(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            SalaryStructure salaryStructure = await db.SalaryStructures.FindAsync(id);

            if (salaryStructure == null)
            {
                return(HttpNotFound());
            }
            return(View(salaryStructure));
        }
Ejemplo n.º 7
0
        private void btn添加_Click(object sender, EventArgs e)
        {
            List <EmployeeInfo>    list   = new List <EmployeeInfo>();
            List <SalaryStructure> ssList = SalaryStructure.GetHasPerformanceSalaryEmployees();

            foreach (SalaryStructure ss in ssList)
            {
                EmployeeInfo emp = ss.员工信息;
                if (list.Find(a => a.员工编号 == emp.员工编号) == null)
                {
                    list.Add(emp);
                }
            }
            EmployeePickerForm form = new EmployeePickerForm(list);

            form.OnSelected += OnEmployeeSelectd;
            form.ShowDialog();
        }
        public object GetSalaryStructureById(int id)
        {
            object result = null;

            SalaryStructure objSalaryStructure = new SalaryStructure();
            List <int?>     DepartmentIds      = new List <int?>();
            List <int?>     PayrollCategoryIds = new List <int?>();

            try
            {
                using (_context)
                {
                    objSalaryStructure = _context.SalaryStructure.FirstOrDefault(x => x.Id == id);
                    DepartmentIds      = _context.SalaryStructureDepartmentMapping.Where(y => y.SalaryStructureId == id).Select(z => z.DepartmentId).ToList();
                    PayrollCategoryIds = _context.SalaryStructurePayrollCategoryMapping.Where(y => y.SalaryStructureId == id).Select(z => z.PayrollCategoryId).ToList();
                    result             = new
                    {
                        objSalaryStructure,
                        DepartmentIds,
                        PayrollCategoryIds,
                        error = "0",
                        msg   = "Success"
                    };
                }
            }
            catch (Exception ex)
            {
                ex.ToString();
                result = new
                {
                    objSalaryStructure,
                    DepartmentIds,
                    PayrollCategoryIds,
                    error = "1",
                    msg   = "Error"
                };
            }
            return(result);
        }
        public async Task <ActionResult> Edit([Bind(Include = "Id,Role,BaseSalary,PayWidth,MinPay,MaxPay,Allowance,Housing,Medicals,Tax,Pension,NetSalary")] SalaryStructure salaryStructure)
        {
            if (ModelState.IsValid)
            {
                db.Entry(salaryStructure).State = EntityState.Modified;
                await db.SaveChangesAsync();

                return(RedirectToAction("Index"));
            }
            List <SelectListItem> list = new List <SelectListItem>();

            foreach (var rolee in RoleManager.Roles)
            {
                list.Add(new SelectListItem()
                {
                    Value = rolee.Name, Text = rolee.Name
                });
            }
            list.RemoveRange(4, 2);
            ViewBag.Roles = list;
            return(View(salaryStructure));
        }
Ejemplo n.º 10
0
        public async Task <ActionResult> RegisterFaculty(RegisterFacultyViewModel model)
        {
            if (ModelState.IsValid)
            {
                var user = new ApplicationUser
                {
                    UserName      = model.Email,
                    Email         = model.Email,
                    Firstname     = model.Firstname,
                    Lastname      = model.Lastname,
                    DateOfBirth   = model.DateOfBirth,
                    Address1      = model.Address1,
                    Address2      = model.Address2,
                    City          = model.City,
                    Country       = model.Country,
                    Institution   = model.Institution,
                    Program       = model.Program,
                    YearOfJoining = model.YearOfJoining,
                    PhoneNumber   = model.Mobile,
                };
                var result = await UserManager.CreateAsync(user, model.Password);

                if (result.Succeeded)
                {
                    result = await UserManager.AddToRoleAsync(user.Id, model.RoleeName);

                    ViewBag.FacultySuccess = "Successfully Created " + user.Firstname + "as a faculty member.";

                    SalaryStructure structure = (SalaryStructure)db.SalaryStructures.First(m => m.Id == model.StructId);

                    var salary = new Salary
                    {
                        Username   = model.Email,
                        Role       = model.RoleeName,
                        BaseSalary = structure.BaseSalary,
                        PayWidth   = structure.PayWidth,
                        MinPay     = structure.MinPay,
                        MaxPay     = structure.MaxPay,
                        Allowance  = structure.Allowance,
                        Housing    = structure.Housing,
                        Medicals   = structure.Medicals,
                        Tax        = structure.Tax,
                        Pension    = structure.Pension,
                        NetSalary  = structure.NetSalary,
                        StructId   = structure.Id
                    };

                    db.Salaries.Add(salary);
                    db.SaveChanges();

                    return(RedirectToAction("Index", "ViewUser"));
                }
                AddErrors(result);
            }
            List <SelectListItem> list = new List <SelectListItem>();

            foreach (var rolee in RoleManager.Roles)
            {
                list.Add(new SelectListItem()
                {
                    Value = rolee.Name, Text = rolee.Name
                });
            }
            list.RemoveRange(4, 2);
            ViewBag.Roles    = list;
            ViewBag.StructId = new SelectList(db.SalaryStructures, "Id", "Role", model.StructId);
            //ViewBag.Ranks = new SelectList(db.FacultyRanks, "Id", "Rank");

            return(View(model));
        }
Ejemplo n.º 11
0
 private void EditSalaryStructureForm_Load(object sender, EventArgs e)
 {
     this.Text = "员工薪酬结构查询";
     all_rows  = SalaryStructure.GetEffectiveSalaryStructures();
     LoadData(null);
 }
Ejemplo n.º 12
0
        public bool Calculate()
        {
            计算完成 = false;

            try
            {
                bool 工资系数 = false;

                #region 获取月薪酬标准

                //获取交通餐饮补助标准
                交通餐饮补助标准 = PsHelper.GetTrafficSubsidies(员工编号, 期间开始);
                //获取满勤奖标准
                满勤奖标准 = PsHelper.GetFullAttendancePayFromCache(this.表工资表.薪酬体系编号, this.表工资表.薪等编号, 期间开始);
                //工资借款标准
                WageLoan wl = WageLoan.GetEffective(员工编号, 期间开始);
                if (wl != null)
                {
                    工资借款标准 = wl.月借款额度;
                }
                //报账工资标准
                RembursementSalary rs = RembursementSalary.GetEffective(员工编号, 期间开始);
                if (rs != null)
                {
                    报账工资标准 = rs.月度可报账标准_税前;
                }
                //2018-7-9 契约津贴
                ContractAllowance ca = ContractAllowance.GetEffective(员工编号, 期间开始);
                if (ca != null)
                {
                    契约津贴标准 = ca.月津贴额度;
                }

                #endregion

                //获取月薪资料
                if (!ReadMonthlySalaryData())
                {
                    计算错误描述 = "没有找到 " + 姓名 + "【" + 员工编号 + "】" + 年 + "年 " + 月 + "月的职级工资(即执行月薪)";
                    return(false);
                }
                if (执行职级月薪 == 0)
                {
                    计算错误描述 = 姓名 + "【" + 员工编号 + "】" + 年 + "年 " + 月 + "月的职级工资是 0";
                    return(false);
                }
                职级工资_标准 = 执行职级月薪;

                //2018年5月18日 如果录入了员工的薪酬结构,以薪酬结构的工资为准
                SalaryStructure 薪酬结构 = SalaryStructure.GetEffective(员工编号, 期间开始);
                if (薪酬结构 == null)
                {
                    职级工资_实际 = 执行职级月薪;
                }
                else
                {
                    职级工资_实际   = 薪酬结构.月薪项目_小计;
                    本月执行绩效工资额 = 薪酬结构.月薪项目_减项_绩效工资;
                    薪资奖励_月摊   = 薪酬结构.年薪_奖励 / 12;
                    年绩效工资_月摊  = 薪酬结构.年薪_绩效工资 / 12;
                }

                月应发工资 = 职级工资_标准 - 薪资奖励_月摊 - 年绩效工资_月摊 - 工资借款标准 - 报账工资标准 - 福利借款标准 - 契约津贴标准 - 本月执行绩效工资额;

                #region 计算其它奖扣项

                //计算其它奖项
                List <OtherMoney> myOtherMoneyItems = 工资计算器.其它奖扣项.FindAll(a => a.员工编号 == this.员工编号 && a.类型 == "其它奖项");
                其它奖项 = myOtherMoneyItems.Sum(a => a.金额);

                //计算其它扣项
                myOtherMoneyItems = 工资计算器.其它奖扣项.FindAll(a => a.员工编号 == this.员工编号 && a.类型 == "其它扣项");
                其它扣项 = myOtherMoneyItems.Sum(a => a.金额);

                //计算工资降级
                myOtherMoneyItems = 工资计算器.其它奖扣项.FindAll(a => a.员工编号 == this.员工编号 && a.类型 == "工资降级");
                工资降级  = myOtherMoneyItems.Sum(a => a.金额);
                工资降级 += 表工资表.工资降级;

                //计算代垫费用
                myOtherMoneyItems = 工资计算器.其它奖扣项.FindAll(a => a.员工编号 == this.员工编号 && a.类型 == "代垫费用");
                其它代垫费用            = myOtherMoneyItems.Sum(a => a.金额);
                代垫费用 = 表工资表.代垫费用 + 其它代垫费用;
                #endregion

                #region 获取工资系数

                //获取工资系数
                EmpPayRate epRate = 工资计算器.工资系数表.Find(a => a.员工编号 == this.员工编号);
                if (epRate != null)
                {
                    工资系数 = epRate.系数;
                    工资系数 = true;
                }

                #endregion

                //有封闭工资的人才需要计算
                if (职级工资_实际 > 0 || 其它奖项 != 0 || 其它扣项 != 0 || 工资降级 != 0 || 其它代垫费用 != 0)
                {
                    //2017.10.22 如果封闭工资没有设置职级工资,职级工资就是上表工资的工资标准
                    //主要针对没有封闭职级工资,但是有比较大的奖项在封闭工资系统发放的情况
                    if (职级工资_实际 == 0)
                    {
                        职级工资_实际 = 表工资表.表工资 + 工资降级;
                    }

                    #region 计算封闭出勤工资

                    //年休假工资
                    年休假工资 = 表工资表.未休年休假工资;

                    //清除老的还款记录
                    PersonRepayment.Clear(this.员工编号, this.年, this.月);

                    #region 自动创建还款记录

                    //自动创建还款记录
                    List <PersonBorrow> personBorrowList = PersonBorrow.GetMyBorrows(this.员工编号, this.年, this.月);
                    foreach (PersonBorrow borrowItem in personBorrowList)
                    {
                        //如果还有未还清的款
                        if (borrowItem.余额 > 0)
                        {
                            PersonRepayment pRepayment = PersonRepayment.AddPersonRepayment(borrowItem, this.年, this.月);
                            pRepayment.还款金额 = borrowItem.余额 > borrowItem.每月扣还 ? borrowItem.每月扣还 : borrowItem.余额;
                            pRepayment.员工编号 = this.员工编号;
                            pRepayment.创建人  = AccessController.CurrentUser.姓名;
                            pRepayment.创建时间 = DateTime.Now;
                            pRepayment.Save();
                        }
                    }
                    #endregion

                    #region 获取还款记录

                    List <PersonRepayment> prList = PersonRepayment.GetPersonRepayments(this.员工编号, this.年, this.月);
                    if (prList.Count > 0)
                    {
                        PersonRepayment 还款_提前借工资 = prList.Find(a => a.项目 == "提前借工资");
                        if (还款_提前借工资 != null)
                        {
                            提前借工资本月还款额 = 还款_提前借工资.还款金额;
                        }

                        PersonRepayment 还款_个人专用车费用 = prList.Find(a => a.项目 == "个人专用车费用");
                        if (还款_个人专用车费用 != null)
                        {
                            个人专用车费用本月还款额 = 还款_个人专用车费用.还款金额;
                        }
                    }

                    #endregion

                    #region 获取报销记录

                    List <PersonReimbursement> rbList = PersonReimbursement.GetPersonReimbursements(this.员工编号, this.年, this.月);
                    if (rbList.Count > 0)
                    {
                        PersonReimbursement 报销_月租房报销 = rbList.Find(a => a.项目 == "月租房报销");
                        if (报销_月租房报销 != null)
                        {
                            月租房报销费用本月实际报销额 = 报销_月租房报销.报销金额;
                        }

                        PersonReimbursement 报销_探亲飞机票 = rbList.Find(a => a.项目 == "探亲飞机票");
                        if (报销_探亲飞机票 != null)
                        {
                            探亲飞机票本月实际报销额 = 报销_探亲飞机票.报销金额;
                        }
                    }

                    #endregion

                    #region 获取绩效工资

                    EffectivePerformanceSalary 绩效考核 = EffectivePerformanceSalary.GetEffective(this.员工编号, this.年, this.月);
                    if (绩效考核 != null)
                    {
                        //本月执行绩效工资额 = 绩效考核.绩效工资;
                        本月实得绩效工资额 = 绩效考核.实得工资;
                    }

                    #endregion

                    if (工资系数)
                    {
                        本月剩余月薪额 = 职级工资_实际 * 工资系数 - 工资借款标准 - 报账工资标准 - 福利借款标准 - 契约津贴标准;
                    }

                    else
                    {
                        本月剩余月薪额 = 职级工资_实际 - 工资借款标准 - 报账工资标准 - 福利借款标准 - 契约津贴标准;
                    }

                    //2016.6.6 调整,将减掉的部分移到后面
                    //本月剩余月薪额 = 本月剩余月薪额 - 提前借工资本月还款额 - 个人专用车费用本月还款额 - 月租房报销费用本月实际报销额 - 探亲飞机票本月实际报销额 - 本月执行绩效工资额;

                    //计算挂考勤的工资
                    挂考勤的工资 = 本月剩余月薪额 - 表工资表.未休年休假工资;

                    //排班天数
                    排班天数 = 表工资表.企业排班天数;

                    //出勤天数
                    实际出勤天数 = 表工资表.实际出勤天数;

                    #region 计算放弃年休假补助

                    //2018-4-4 计算放弃年休假补助
                    List <WaiveAnnualVacation> wavList = this.工资计算器.放弃年休假记录表.FindAll(a => a.员工编号 == this.员工编号);
                    放弃年休假天数 = wavList.Sum(a => a.放弃天数);
                    放弃年休假补助 = ((职级工资_实际 - 满勤奖标准) / (decimal)21.75) * 放弃年休假天数 * (decimal)0.8;

                    #endregion

                    //封闭出勤工资基准
                    封闭出勤工资计算标准 = 挂考勤的工资 - 工资降级 - 表工资表.表工资 - 满勤奖标准 - 交通餐饮补助标准;
                    //剔除考核工资个人部分
                    封闭出勤工资计算标准 -= 本月执行绩效工资额;
                    //本次发放标准
                    本次发放标准 = 封闭出勤工资计算标准;

                    //出勤天数
                    班别 = 表工资表.班别.Trim();

                    decimal attDays = 实际出勤天数;
                    //封闭出勤工资中, 行政班出勤天数不能大于排班天数
                    if (班别 == "6") //行政班
                    {
                        attDays = 实际出勤天数 > 排班天数 ? 排班天数 : 实际出勤天数;
                    }

                    if (班别 == "6") //行政班
                    {
                        if (实际出勤天数 > 10)
                        {
                            封闭出勤工资 = 封闭出勤工资计算标准 - 封闭出勤工资计算标准 / (decimal)21.75 * (排班天数 - attDays);
                        }
                        else
                        {
                            封闭出勤工资 = (封闭出勤工资计算标准 / (decimal)21.75) * attDays;
                        }
                    }
                    else
                    {
                        if (班别 == "8") //特殊+业务代表+司机
                        {
                            封闭出勤工资 = (封闭出勤工资计算标准 / 排班天数) * attDays;
                        }
                        else
                        {
                            封闭出勤工资 = (封闭出勤工资计算标准 / 26) * attDays;
                        }
                    }

                    #endregion

                    //封闭奖扣合计
                    封闭奖扣合计 = 其它奖项 - 其它扣项;
                    //工资合计
                    //2016.6.6 调整 与上面对应
                    //原来  封闭工资合计 = 封闭出勤工资 + 封闭奖扣合计 + 津贴补助 + 本月实得绩效工资额;
                    封闭工资合计 = 封闭出勤工资 + 封闭奖扣合计 + 津贴补助 + 本月实得绩效工资额 - 提前借工资本月还款额 - 个人专用车费用本月还款额 - 月租房报销费用本月实际报销额 - 探亲飞机票本月实际报销额 + 放弃年休假补助;
                    封闭工资合计 = Math.Round(封闭工资合计, 2, MidpointRounding.AwayFromZero);

                    //总应税工资
                    总应税工资 = 表工资表.合计应税工资额 + 封闭工资合计;  //上表税前应税工资(含年休假工资)加上封闭部分的工资

                    //工资发放总额
                    工资发放总额 = 表工资表.表工资总额 + 表工资表.未休年休假工资 + 封闭工资合计;    //上表工资总额不含年休假

                    //个税(总个税)
                    个人所得税 = GetTax(总应税工资);

                    //实发(含封闭和上表)
                    实发工资 = 总应税工资 - 个人所得税 - 代垫费用;
                    实发工资 = Math.Round(实发工资, 2, MidpointRounding.AwayFromZero);

                    计算完成 = true;
                }
                return(true);
            }
            catch (Exception e)
            {
                计算错误描述 = 姓名 + "【" + 员工编号 + "】计算失败" + e.ToString();
            }
            return(false);
        }
        public object CreateUpdateSalaryStructure(int id, [FromBody] SalaryStructureVM model)
        {
            object result    = null;
            string message   = "";
            string errorcode = "";
            string excp      = "";

            if (model == null)
            {
                return(BadRequest());
            }
            using (_context)
            {
                using (var _ctxTransaction = _context.Database.BeginTransaction())
                {
                    try
                    {
                        if (id != 0)
                        {
                            var entityUpdate = _context.SalaryStructure.FirstOrDefault(x => x.Id == id);

                            if (entityUpdate != null)
                            {
                                entityUpdate.Name        = model.Name;
                                entityUpdate.Description = model.Description;
                                entityUpdate.IsActive    = model.IsActive;

                                _context.SaveChanges();
                            }

                            List <SalaryStructureDepartmentMapping> RemoveDepartmentList = _context.SalaryStructureDepartmentMapping.Where(y => y.SalaryStructureId == id).ToList();
                            if (RemoveDepartmentList.Count > 0)
                            {
                                _context.SalaryStructureDepartmentMapping.RemoveRange(RemoveDepartmentList);
                            }
                            if (model.DepartmentIds.Count > 0)
                            {
                                foreach (int DepartmentId in model.DepartmentIds)
                                {
                                    SalaryStructureDepartmentMapping objMapping = null;
                                    objMapping = new SalaryStructureDepartmentMapping {
                                        SalaryStructureId = id, DepartmentId = DepartmentId
                                    };
                                    _context.Add(objMapping);
                                }
                                _context.SaveChanges();
                            }
                            List <SalaryStructurePayrollCategoryMapping> RemovePayrollCategoryList = _context.SalaryStructurePayrollCategoryMapping.Where(y => y.SalaryStructureId == id).ToList();
                            if (RemovePayrollCategoryList.Count > 0)
                            {
                                _context.SalaryStructurePayrollCategoryMapping.RemoveRange(RemovePayrollCategoryList);
                            }
                            if (model.PayrollCategoryIds.Count > 0)
                            {
                                foreach (int PayrollCategoryId in model.PayrollCategoryIds)
                                {
                                    SalaryStructurePayrollCategoryMapping objMapping = null;
                                    objMapping = new SalaryStructurePayrollCategoryMapping {
                                        SalaryStructureId = id, PayrollCategoryId = PayrollCategoryId
                                    };
                                    _context.Add(objMapping);
                                }
                                _context.SaveChanges();
                            }

                            _ctxTransaction.Commit();
                            message   = "Entry Updated";
                            errorcode = "0";
                        }
                        else
                        {
                            SalaryStructure objSalaryStructure = new SalaryStructure();
                            objSalaryStructure.Name        = model.Name;
                            objSalaryStructure.Description = model.Description;
                            objSalaryStructure.IsActive    = model.IsActive;
                            _context.SalaryStructure.Add(objSalaryStructure);
                            //await _ctx.SaveChangesAsync();
                            _context.SaveChanges();

                            if (model.DepartmentIds.Count > 0)
                            {
                                foreach (int DepartmentId in model.DepartmentIds)
                                {
                                    SalaryStructureDepartmentMapping objMapping = null;
                                    objMapping = new SalaryStructureDepartmentMapping {
                                        SalaryStructureId = objSalaryStructure.Id, DepartmentId = DepartmentId
                                    };
                                    _context.Add(objMapping);
                                }
                                _context.SaveChanges();
                            }

                            if (model.PayrollCategoryIds.Count > 0)
                            {
                                foreach (int PayrollCategoryId in model.PayrollCategoryIds)
                                {
                                    SalaryStructurePayrollCategoryMapping objMapping = null;
                                    objMapping = new SalaryStructurePayrollCategoryMapping {
                                        SalaryStructureId = objSalaryStructure.Id, PayrollCategoryId = PayrollCategoryId
                                    };
                                    _context.Add(objMapping);
                                }
                                _context.SaveChanges();
                            }

                            _ctxTransaction.Commit();
                            message   = "Saved Successfully";
                            errorcode = "0";
                        }
                    }
                    catch (Exception e)
                    {
                        _ctxTransaction.Rollback();
                        e.ToString();
                        message   = "Saved Error";
                        errorcode = "1";
                        excp      = e.ToString();
                    }

                    result = new
                    {
                        error = errorcode,
                        msg   = message,
                        excp  = excp
                    };
                }
            }
            return(result);
        }
        public object CreateSalaryStructure([FromBody] SalaryStructureVM model)
        {
            object result    = null;
            string message   = "";
            string errorcode = "";
            string excp      = "";

            if (model == null)
            {
                return(BadRequest());
            }
            using (_context)
            {
                using (var _ctxTransaction = _context.Database.BeginTransaction())
                {
                    try
                    {
                        SalaryStructure objSalaryStructure = new SalaryStructure();
                        objSalaryStructure.Name        = model.Name;
                        objSalaryStructure.Description = model.Description;
                        objSalaryStructure.IsActive    = model.IsActive;
                        _context.SalaryStructure.Add(objSalaryStructure);
                        //await _ctx.SaveChangesAsync();
                        _context.SaveChanges();

                        if (model.DepartmentIds.Count > 0)
                        {
                            foreach (int DepartmentId in model.DepartmentIds)
                            {
                                SalaryStructureDepartmentMapping objMapping = null;
                                objMapping = new SalaryStructureDepartmentMapping {
                                    SalaryStructureId = objSalaryStructure.Id, DepartmentId = DepartmentId
                                };
                                _context.Add(objMapping);
                            }
                            _context.SaveChanges();
                        }

                        if (model.PayrollCategoryIds.Count > 0)
                        {
                            foreach (int PayrollCategoryId in model.PayrollCategoryIds)
                            {
                                SalaryStructurePayrollCategoryMapping objMapping = null;
                                objMapping = new SalaryStructurePayrollCategoryMapping {
                                    SalaryStructureId = objSalaryStructure.Id, PayrollCategoryId = PayrollCategoryId
                                };
                                _context.Add(objMapping);
                            }
                            _context.SaveChanges();
                        }

                        _ctxTransaction.Commit();
                        message   = "Saved Successfully";
                        errorcode = "0";
                    }
                    catch (Exception e)
                    {
                        _ctxTransaction.Rollback();
                        e.ToString();
                        message   = "Saved Error";
                        errorcode = "1";
                        excp      = e.ToString();
                    }

                    result = new
                    {
                        error = errorcode,
                        msg   = message,
                        excp  = excp
                    };
                }
            }
            return(result);
        }