Beispiel #1
0
        public ActionResult DeleteConfirmed(string id)
        {
            LvConsumed lvconsumed = db.LvConsumeds.Find(id);

            db.LvConsumeds.Remove(lvconsumed);
            db.SaveChanges();
            return(RedirectToAction("Index"));
        }
Beispiel #2
0
 public ActionResult Edit([Bind(Include = "EmpLvType,EmpID,LeaveType,CompanyID,JanConsumed,FebConsumed,MarchConsumed,AprConsumed,MayConsumed,JuneConsumed,JulyConsumed,AugustConsumed,SepConsumed,OctConsumed,NovConsumed,DecConsumed,TotalForYear,YearRemaining,GrandTotal,GrandTotalRemaining")] LvConsumed lvconsumed)
 {
     if (ModelState.IsValid)
     {
         db.Entry(lvconsumed).State = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     ViewBag.EmpID = new SelectList(db.Emps, "EmpID", "EmpNo", lvconsumed.EmpID);
     return(View(lvconsumed));
 }
Beispiel #3
0
        // GET: /LvConsumed/Details/5
        public ActionResult Details(string id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            LvConsumed lvconsumed = db.LvConsumeds.Find(id);

            if (lvconsumed == null)
            {
                return(HttpNotFound());
            }
            return(View(lvconsumed));
        }
Beispiel #4
0
        // GET: /LvConsumed/Edit/5
        public ActionResult Edit(string id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            LvConsumed lvconsumed = db.LvConsumeds.Find(id);

            if (lvconsumed == null)
            {
                return(HttpNotFound());
            }
            ViewBag.EmpID = new SelectList(db.Emps, "EmpID", "EmpNo", lvconsumed.EmpID);
            return(View(lvconsumed));
        }
        private LvConsumed CheckMonthAndAddOneLeave(LvConsumed consume)
        {
            DateTime today = DateTime.Now;

            switch (today.Month)
            {
            case 1: consume.JanConsumed = consume.JanConsumed + 1;
                break;

            case 2: consume.FebConsumed = consume.FebConsumed + 1;
                break;

            case 3: consume.MarchConsumed = consume.MarchConsumed + 1;
                break;

            case 4: consume.AprConsumed = consume.AprConsumed + 1;
                break;

            case 5: consume.MayConsumed = consume.MayConsumed + 1;
                break;

            case 6: consume.JuneConsumed = consume.JuneConsumed + 1;
                break;

            case 7: consume.JulyConsumed = consume.JulyConsumed + 1;
                break;

            case 8: consume.AugustConsumed = consume.AugustConsumed + 1;
                break;

            case 9: consume.AugustConsumed = consume.AugustConsumed + 1;
                break;

            case 10: consume.SepConsumed = consume.SepConsumed + 1;
                break;

            case 11: consume.OctConsumed = consume.OctConsumed + 1;
                break;

            case 12: consume.DecConsumed = consume.DecConsumed + 1;
                break;
            }
            return(consume);
        }
Beispiel #6
0
        public void GenerateLeaveQuotaAttributes(List <Emp> _emp, List <LvType> _lvType, int AL, int CL, int SL)
        {
            using (var ctx = new TAS2013Entities())
            {
                foreach (var emp in _emp)
                {
                    List <LvConsumed> lvcon = ctx.LvConsumeds.Where(aa => aa.EmpID == emp.EmpID).ToList();
                    foreach (var lvType in _lvType)
                    {
                        string            empLvType        = emp.EmpID.ToString() + lvType.LvType1;
                        List <LvConsumed> lvConsumedlvType = new List <LvConsumed>();
                        if (lvcon.Where(aa => aa.EmpLvType == empLvType).Count() == 0)
                        {
                            string     empType    = emp.EmpID.ToString() + lvType.LvType1;
                            LvConsumed lvConsumed = new LvConsumed();
                            lvConsumed.EmpLvType      = empType;
                            lvConsumed.EmpID          = emp.EmpID;
                            lvConsumed.LeaveType      = lvType.LvType1;
                            lvConsumed.JanConsumed    = 0;
                            lvConsumed.FebConsumed    = 0;
                            lvConsumed.MarchConsumed  = 0;
                            lvConsumed.AprConsumed    = 0;
                            lvConsumed.MayConsumed    = 0;
                            lvConsumed.JuneConsumed   = 0;
                            lvConsumed.JulyConsumed   = 0;
                            lvConsumed.AugustConsumed = 0;
                            lvConsumed.SepConsumed    = 0;
                            lvConsumed.OctConsumed    = 0;
                            lvConsumed.NovConsumed    = 0;
                            lvConsumed.DecConsumed    = 0;
                            switch (lvType.LvType1)
                            {
                            case "A":    //CL
                                lvConsumed.TotalForYear        = CL;
                                lvConsumed.YearRemaining       = CL;
                                lvConsumed.GrandTotal          = CL;
                                lvConsumed.GrandTotalRemaining = CL;
                                break;

                            case "B":    //AL
                                lvConsumed.TotalForYear        = AL;
                                lvConsumed.YearRemaining       = AL;
                                lvConsumed.GrandTotal          = AL;
                                lvConsumed.GrandTotalRemaining = AL;
                                break;

                            case "C":    //SL
                                lvConsumed.TotalForYear        = SL;
                                lvConsumed.YearRemaining       = SL;
                                lvConsumed.GrandTotal          = SL;
                                lvConsumed.GrandTotalRemaining = SL;
                                break;
                            }
                            ctx.LvConsumeds.Add(lvConsumed);
                            ctx.SaveChanges();
                        }
                    }
                }

                ctx.Dispose();
            }
        }
        private DataTable GetLV(List <EmpView> _Emp, int month)
        {
            using (var ctx = new TAS2013Entities())
            {
                List <LvConsumed> _lvConsumed = new List <LvConsumed>();
                LvConsumed        _lvTemp     = new LvConsumed();
                _lvConsumed = ctx.LvConsumeds.ToList();
                List <LvType> _lvTypes = ctx.LvTypes.ToList();
                foreach (var emp in _Emp)
                {
                    float             BeforeCL = 0, UsedCL = 0, BalCL = 0;
                    float             BeforeSL = 0, UsedSL = 0, BalSL = 0;
                    float             BeforeAL = 0, UsedAL = 0, BalAL = 0;
                    string            _month  = "";
                    List <LvConsumed> entries = ctx.LvConsumeds.Where(aa => aa.EmpID == emp.EmpID).ToList();
                    LvConsumed        eCL     = entries.FirstOrDefault(lv => lv.LeaveType == "A");
                    LvConsumed        eSL     = entries.FirstOrDefault(lv => lv.LeaveType == "C");
                    LvConsumed        eAL     = entries.FirstOrDefault(lv => lv.LeaveType == "B");
                    if (entries.Count > 0)
                    {
                        switch (month)
                        {
                        case 1:
                            // casual
                            BeforeCL = (float)eCL.TotalForYear;
                            UsedCL   = (float)eCL.JanConsumed;
                            //Sick
                            BeforeSL = (float)eSL.TotalForYear;
                            UsedSL   = (float)eSL.JanConsumed;
                            //Anual
                            BeforeAL = (float)eAL.TotalForYear;
                            UsedAL   = (float)eAL.JanConsumed;
                            _month   = "January";
                            break;

                        case 2:
                            // casual
                            BeforeCL = (float)eCL.TotalForYear - (float)eCL.JanConsumed;
                            UsedCL   = (float)eCL.FebConsumed;
                            //Sick
                            BeforeSL = (float)eSL.TotalForYear - (float)eSL.JanConsumed;
                            UsedSL   = (float)eSL.FebConsumed;
                            //Anual
                            BeforeAL = (float)eAL.TotalForYear - (float)eAL.JanConsumed;
                            UsedAL   = (float)eAL.FebConsumed;
                            break;
                            _month = "Febu";

                        case 3:
                            // casual
                            BeforeCL = (float)eCL.TotalForYear - ((float)eCL.JanConsumed + (float)eCL.FebConsumed);
                            UsedCL   = (float)eCL.MarchConsumed;
                            //Sick
                            BeforeSL = (float)eSL.TotalForYear - ((float)eSL.JanConsumed + (float)eSL.FebConsumed);
                            UsedSL   = (float)eSL.MarchConsumed;
                            //Anual
                            BeforeAL = (float)eAL.TotalForYear - ((float)eAL.JanConsumed + (float)eAL.FebConsumed);
                            UsedAL   = (float)eAL.MarchConsumed;
                            break;

                        case 4:
                            // casual
                            BeforeCL = (float)eCL.TotalForYear - ((float)eCL.JanConsumed + (float)eCL.FebConsumed + (float)eCL.MarchConsumed);
                            UsedCL   = (float)eCL.AprConsumed;
                            //Sick
                            BeforeSL = (float)eSL.TotalForYear - ((float)eSL.JanConsumed + (float)eSL.FebConsumed + (float)eSL.MarchConsumed);
                            UsedSL   = (float)eSL.AprConsumed;
                            //Anual
                            BeforeAL = (float)eAL.TotalForYear - ((float)eAL.JanConsumed + (float)eAL.FebConsumed + (float)eAL.MarchConsumed);
                            UsedAL   = (float)eAL.AprConsumed;
                            break;

                        case 5:
                            // casual
                            BeforeCL = (float)eCL.TotalForYear - ((float)eCL.JanConsumed + (float)eCL.FebConsumed + (float)eCL.MarchConsumed + (float)eCL.AprConsumed);
                            UsedCL   = (float)eCL.MayConsumed;
                            //Sick
                            BeforeSL = (float)eSL.TotalForYear - ((float)eSL.JanConsumed + (float)eSL.FebConsumed + (float)eSL.MarchConsumed + (float)eSL.AprConsumed);
                            UsedSL   = (float)eSL.MayConsumed;
                            //Anual
                            BeforeAL = (float)eAL.TotalForYear - ((float)eAL.JanConsumed + (float)eAL.FebConsumed + (float)eAL.MarchConsumed + (float)eAL.AprConsumed);
                            UsedAL   = (float)eAL.MayConsumed;
                            break;

                        case 6:
                            // casual
                            BeforeCL = (float)eCL.TotalForYear - ((float)eCL.JanConsumed + (float)eCL.FebConsumed + (float)eCL.MarchConsumed + (float)eCL.AprConsumed + (float)eCL.MayConsumed);
                            UsedCL   = (float)eCL.JuneConsumed;
                            //Sick
                            BeforeSL = (float)eSL.TotalForYear - ((float)eSL.JanConsumed + (float)eSL.FebConsumed + (float)eSL.MarchConsumed + (float)eSL.AprConsumed + (float)eSL.MayConsumed);
                            UsedSL   = (float)eSL.JuneConsumed;
                            //Anual
                            BeforeAL = (float)eAL.TotalForYear - ((float)eAL.JanConsumed + (float)eAL.FebConsumed + (float)eAL.MarchConsumed + (float)eAL.AprConsumed + (float)eAL.MayConsumed);
                            UsedAL   = (float)eAL.JuneConsumed;
                            break;

                        case 7:
                            // casual
                            BeforeCL = (float)eCL.TotalForYear - ((float)eCL.JanConsumed + (float)eCL.FebConsumed + (float)eCL.MarchConsumed + (float)eCL.AprConsumed + (float)eCL.MayConsumed + (float)eCL.JuneConsumed);
                            UsedCL   = (float)eCL.JulyConsumed;
                            //Sick
                            BeforeSL = (float)eSL.TotalForYear - ((float)eSL.JanConsumed + (float)eSL.FebConsumed + (float)eSL.MarchConsumed + (float)eSL.AprConsumed + (float)eSL.MayConsumed + (float)eSL.JuneConsumed);
                            UsedSL   = (float)eSL.JulyConsumed;
                            //Anual
                            BeforeAL = (float)eAL.TotalForYear - ((float)eAL.JanConsumed + (float)eAL.FebConsumed + (float)eAL.MarchConsumed + (float)eAL.AprConsumed + (float)eAL.MayConsumed + (float)eAL.JuneConsumed);
                            UsedAL   = (float)eAL.JulyConsumed;
                            break;

                        case 8:
                            // casual
                            BeforeCL = (float)eCL.TotalForYear - ((float)eCL.JanConsumed + (float)eCL.FebConsumed + (float)eCL.MarchConsumed + (float)eCL.AprConsumed + (float)eCL.MayConsumed + (float)eCL.JuneConsumed + (float)eCL.JulyConsumed);
                            UsedCL   = (float)eCL.AugustConsumed;
                            //Sick
                            BeforeSL = (float)eSL.TotalForYear - ((float)eSL.JanConsumed + (float)eSL.FebConsumed + (float)eSL.MarchConsumed + (float)eSL.AprConsumed + (float)eSL.MayConsumed + (float)eSL.JuneConsumed + (float)eSL.JulyConsumed);
                            UsedSL   = (float)eSL.AugustConsumed;
                            //Anual
                            BeforeAL = (float)eAL.TotalForYear - ((float)eAL.JanConsumed + (float)eAL.FebConsumed + (float)eAL.MarchConsumed + (float)eAL.AprConsumed + (float)eAL.MayConsumed + (float)eAL.JuneConsumed + (float)eAL.JulyConsumed);
                            UsedAL   = (float)eAL.AugustConsumed;
                            break;

                        case 9:
                            // casual
                            BeforeCL = (float)eCL.TotalForYear - ((float)eCL.JanConsumed + (float)eCL.FebConsumed + (float)eCL.MarchConsumed + (float)eCL.AprConsumed + (float)eCL.MayConsumed + (float)eCL.JuneConsumed + (float)eCL.JulyConsumed + (float)eCL.AugustConsumed);
                            UsedCL   = (float)eCL.SepConsumed;
                            //Sick
                            BeforeSL = (float)eSL.TotalForYear - ((float)eSL.JanConsumed + (float)eSL.FebConsumed + (float)eSL.MarchConsumed + (float)eSL.AprConsumed + (float)eSL.MayConsumed + (float)eSL.JuneConsumed + (float)eSL.JulyConsumed + (float)eSL.AugustConsumed);
                            UsedSL   = (float)eSL.SepConsumed;
                            //Anual
                            BeforeAL = (float)eAL.TotalForYear - ((float)eAL.JanConsumed + (float)eAL.FebConsumed + (float)eAL.MarchConsumed + (float)eAL.AprConsumed + (float)eAL.MayConsumed + (float)eAL.JuneConsumed + (float)eAL.JulyConsumed + (float)eAL.AugustConsumed);
                            UsedAL   = (float)eAL.SepConsumed;
                            break;

                        case 10:
                            // casual
                            BeforeCL = (float)eCL.TotalForYear - ((float)eCL.JanConsumed + (float)eCL.FebConsumed + (float)eCL.MarchConsumed + (float)eCL.AprConsumed + (float)eCL.MayConsumed + (float)eCL.JuneConsumed + (float)eCL.JulyConsumed + (float)eCL.AugustConsumed + (float)eCL.SepConsumed);
                            UsedCL   = (float)eCL.OctConsumed;
                            //Sick
                            BeforeSL = (float)eSL.TotalForYear - ((float)eSL.JanConsumed + (float)eSL.FebConsumed + (float)eSL.MarchConsumed + (float)eSL.AprConsumed + (float)eSL.MayConsumed + (float)eSL.JuneConsumed + (float)eSL.JulyConsumed + (float)eSL.AugustConsumed + (float)eSL.SepConsumed);
                            UsedSL   = (float)eSL.OctConsumed;
                            //Anual
                            BeforeAL = (float)eAL.TotalForYear - ((float)eAL.JanConsumed + (float)eAL.FebConsumed + (float)eAL.MarchConsumed + (float)eAL.AprConsumed + (float)eAL.MayConsumed + (float)eAL.JuneConsumed + (float)eAL.JulyConsumed + (float)eAL.AugustConsumed + (float)eAL.AugustConsumed);
                            UsedAL   = (float)eAL.SepConsumed;
                            break;

                        case 11:
                            // casual
                            BeforeCL = (float)eCL.TotalForYear - ((float)eCL.JanConsumed + (float)eCL.FebConsumed + (float)eCL.MarchConsumed + (float)eCL.AprConsumed + (float)eCL.MayConsumed + (float)eCL.JuneConsumed + (float)eCL.JulyConsumed + (float)eCL.AugustConsumed + (float)eCL.SepConsumed + (float)eCL.OctConsumed);
                            UsedCL   = (float)eCL.NovConsumed;
                            //Sick
                            BeforeSL = (float)eSL.TotalForYear - ((float)eSL.JanConsumed + (float)eSL.FebConsumed + (float)eSL.MarchConsumed + (float)eSL.AprConsumed + (float)eSL.MayConsumed + (float)eSL.JuneConsumed + (float)eSL.JulyConsumed + (float)eSL.AugustConsumed + (float)eSL.SepConsumed + (float)eSL.OctConsumed);
                            UsedSL   = (float)eSL.NovConsumed;
                            //Anual
                            BeforeAL = (float)eAL.TotalForYear - ((float)eAL.JanConsumed + (float)eAL.FebConsumed + (float)eAL.MarchConsumed + (float)eAL.AprConsumed + (float)eAL.MayConsumed + (float)eAL.JuneConsumed + (float)eAL.JulyConsumed + (float)eAL.AugustConsumed + (float)eAL.AugustConsumed + (float)eAL.OctConsumed);
                            UsedAL   = (float)eAL.NovConsumed;
                            break;

                        case 12:
                            // casual
                            BeforeCL = (float)eCL.TotalForYear - ((float)eCL.JanConsumed + (float)eCL.FebConsumed + (float)eCL.MarchConsumed + (float)eCL.AprConsumed + (float)eCL.MayConsumed + (float)eCL.JuneConsumed + (float)eCL.JulyConsumed + (float)eCL.AugustConsumed + (float)eCL.SepConsumed + (float)eCL.OctConsumed + (float)eCL.NovConsumed);
                            UsedCL   = (float)eCL.DecConsumed;
                            //Sick
                            BeforeSL = (float)eSL.TotalForYear - ((float)eSL.JanConsumed + (float)eSL.FebConsumed + (float)eSL.MarchConsumed + (float)eSL.AprConsumed + (float)eSL.MayConsumed + (float)eSL.JuneConsumed + (float)eSL.JulyConsumed + (float)eSL.AugustConsumed + (float)eSL.SepConsumed + (float)eSL.OctConsumed + (float)eSL.NovConsumed);
                            UsedSL   = (float)eSL.DecConsumed;
                            //Anual
                            BeforeAL = (float)eAL.TotalForYear - ((float)eAL.JanConsumed + (float)eAL.FebConsumed + (float)eAL.MarchConsumed + (float)eAL.AprConsumed + (float)eAL.MayConsumed + (float)eAL.JuneConsumed + (float)eAL.JulyConsumed + (float)eAL.AugustConsumed + (float)eAL.AugustConsumed + (float)eAL.OctConsumed + (float)eAL.NovConsumed);
                            UsedAL   = (float)eAL.DecConsumed;
                            break;
                        }
                        BalCL = (float)(BeforeCL - UsedCL);
                        BalSL = (float)(BeforeSL - UsedSL);
                        BalAL = (float)(BeforeAL - UsedAL);
                        AddDataToDT(emp.EmpNo, emp.EmpName, emp.DesignationName, emp.SectionName, emp.DeptName, emp.TypeName, emp.CatName, emp.LocName, BeforeCL, BeforeSL, BeforeAL, UsedCL, UsedSL, UsedAL, BalCL, BalSL, BalAL, _month);
                    }
                }
            }
            return(LvSummaryMonth);
        }
        private int AddCausalLeave(LvShort lvshort)
        {
            //find that bastard through the causal leave field in EmpLvType
            string EmpLvType = lvshort.EmpID + "A";
            //if there is some freak accident and now he has two or more records
            //cater for that by going through a list
            List <LvConsumed> consumed = db.LvConsumeds.Where(aa => aa.EmpLvType == EmpLvType).ToList();

            if (consumed.Count() > 0)
            {
                foreach (LvConsumed consume in consumed)
                {
                    consume.GrandTotalRemaining = consume.GrandTotalRemaining - 1;
                    consume.YearRemaining       = consume.YearRemaining - 1;
                    LvConsumed refresh = new LvConsumed();
                    refresh = CheckMonthAndAddOneLeave(consume);
                    if (db.LvApplications.Where(aa => aa.LvDate == lvshort.DutyDate && aa.EmpID == lvshort.EmpID && aa.LvType == "A").Count() > 0)
                    {
                        return(1);
                    }
                    else
                    {
                        LvApplication lvapplication = new LvApplication();
                        lvapplication.EmpID      = (int)lvshort.EmpID;
                        lvapplication.LvDate     = (DateTime)lvshort.DutyDate;
                        lvapplication.LvType     = "A";
                        lvapplication.FromDate   = (DateTime)lvshort.DutyDate;
                        lvapplication.ToDate     = (DateTime)lvshort.DutyDate;
                        lvapplication.NoOfDays   = 1;
                        lvapplication.IsHalf     = false;
                        lvapplication.HalfAbsent = false;
                        lvapplication.LvReason   = lvshort.Remarks;
                        lvapplication.CreatedBy  = lvshort.CreatedBy;
                        lvapplication.LvStatus   = "P";
                        lvapplication.CompanyID  = lvshort.CompanyID;
                        lvapplication.Active     = true;
                        LeaveController LvProcessController = new LeaveController();
                        if (LvProcessController.HasLeaveQuota(lvapplication.EmpID, lvapplication.LvType))
                        {
                            if (lvapplication.IsHalf != true)
                            {
                                if (LvProcessController.CheckDuplicateLeave(lvapplication))
                                {
                                    //Check leave Balance
                                    if (LvProcessController.CheckLeaveBalance(lvapplication))
                                    {
                                        lvapplication.LvDate = DateTime.Today;
                                        int _userID = Convert.ToInt32(Session["LogedUserID"].ToString());
                                        lvapplication.CreatedBy = _userID;
                                        db.LvApplications.Add(lvapplication);
                                        if (db.SaveChanges() > 0)
                                        {
                                            HelperClass.MyHelper.SaveAuditLog(_userID, (byte)MyEnums.FormName.Leave, (byte)MyEnums.Operation.Add, DateTime.Now);
                                            LvProcessController.AddLeaveToLeaveData(lvapplication);
                                            LvProcessController.AddLeaveToLeaveAttData(lvapplication);
                                            return(2);
                                        }
                                        else
                                        {
                                            ModelState.AddModelError("Remarks", "There is an error while creating leave.");
                                        }
                                    }
                                    else
                                    {
                                        ModelState.AddModelError("Remarks", "Leave Balance Exceeds, Please check the balance");
                                    }
                                }
                                else
                                {
                                    ModelState.AddModelError("Remarks", "This Employee already has leave of this date ");
                                }
                            }
                        }
                        else
                        {
                            ModelState.AddModelError("Remarks", "Leave Quota does not exist");
                        }
                    }
                }
                return(2);
            }
            else
            {
                return(3);
            }
        }
Beispiel #9
0
        public void GenerateLeaveQuotaAttributes(List <Emp> _emp, List <LvType> _lvType, float AL, float CL, float SL)
        {
            using (var ctx = new TAS2013Entities())
            {
                DateTime dt = DateTime.Today;
                if (dt.Month == 1 && dt.Day < 3)
                {
                    dt = new DateTime(dt.Year - 1, 12, 31);
                }
                foreach (var emp in _emp)
                {
                    List <LvConsumed> lvcon = ctx.LvConsumeds.Where(aa => aa.EmpID == emp.EmpID).ToList();
                    foreach (var lvType in _lvType)
                    {
                        string            empLvType        = emp.EmpID.ToString() + lvType.LvType1 + dt.Year.ToString();
                        List <LvConsumed> lvConsumedlvType = new List <LvConsumed>();
                        if (lvcon.Where(aa => aa.EmpLvTypeYear == empLvType).Count() == 0)
                        {
                            string     empType    = emp.EmpID.ToString() + lvType.LvType1;
                            LvConsumed lvConsumed = new LvConsumed();
                            lvConsumed.EmpLvType      = empType;
                            lvConsumed.EmpLvTypeYear  = empType + dt.Year.ToString();
                            lvConsumed.Year           = dt.Year.ToString();
                            lvConsumed.EmpID          = emp.EmpID;
                            lvConsumed.LeaveType      = lvType.LvType1;
                            lvConsumed.JanConsumed    = 0;
                            lvConsumed.FebConsumed    = 0;
                            lvConsumed.MarchConsumed  = 0;
                            lvConsumed.AprConsumed    = 0;
                            lvConsumed.MayConsumed    = 0;
                            lvConsumed.JuneConsumed   = 0;
                            lvConsumed.JulyConsumed   = 0;
                            lvConsumed.AugustConsumed = 0;
                            lvConsumed.SepConsumed    = 0;
                            lvConsumed.OctConsumed    = 0;
                            lvConsumed.NovConsumed    = 0;
                            lvConsumed.DecConsumed    = 0;
                            lvConsumed.CompanyID      = emp.CompanyID;
                            switch (lvType.LvType1)
                            {
                            case "A":    //CL
                                lvConsumed.TotalForYear        = CL;
                                lvConsumed.YearRemaining       = CL;
                                lvConsumed.GrandTotal          = CL;
                                lvConsumed.GrandTotalRemaining = CL;
                                break;

                            case "B":    //AL
                                lvConsumed.TotalForYear        = AL;
                                lvConsumed.YearRemaining       = AL;
                                lvConsumed.GrandTotal          = AL;
                                lvConsumed.GrandTotalRemaining = AL;
                                break;

                            case "C":    //SL
                                lvConsumed.TotalForYear        = SL;
                                lvConsumed.YearRemaining       = SL;
                                lvConsumed.GrandTotal          = SL;
                                lvConsumed.GrandTotalRemaining = SL;
                                break;
                                //case "E"://CPL
                                //    lvConsumed.TotalForYear = CPL;
                                //    lvConsumed.YearRemaining = CPL;
                                //    lvConsumed.GrandTotal = CPL;
                                //    lvConsumed.GrandTotalRemaining = CPL;
                                //    break;
                            }
                            ctx.LvConsumeds.Add(lvConsumed);
                            ctx.SaveChanges();
                        }
                    }
                }

                ctx.Dispose();
            }
        }
Beispiel #10
0
        public ActionResult AdjustLeaves(FormCollection collection)
        {
            float AL  = float.Parse(Request.Form["ALeaves"].ToString(), CultureInfo.InvariantCulture.NumberFormat);
            float CL  = float.Parse(Request.Form["CLeaves"].ToString(), CultureInfo.InvariantCulture.NumberFormat);
            float SL  = float.Parse(Request.Form["SLeaves"].ToString(), CultureInfo.InvariantCulture.NumberFormat);
            float CPL = float.Parse(Request.Form["CPLLeaves"].ToString(), CultureInfo.InvariantCulture.NumberFormat);

            int    EmpID = Convert.ToInt32(Request.Form["EmpID"].ToString());
            string year  = Request.Form["LvYear"].ToString();

            string EmpLvTypeYearCL  = EmpID.ToString() + "A" + year;
            string EmpLvTypeYearAL  = EmpID.ToString() + "B" + year;
            string EmpLvTypeYearSL  = EmpID.ToString() + "C" + year;
            string EmpLvTypeYearCPL = EmpID.ToString() + "E" + year;

            var lvTypeAL  = db.LvConsumeds.Where(aa => aa.EmpLvTypeYear == EmpLvTypeYearAL).ToList();
            var lvTypeCL  = db.LvConsumeds.Where(aa => aa.EmpLvTypeYear == EmpLvTypeYearCL).ToList();
            var lvTypeSL  = db.LvConsumeds.Where(aa => aa.EmpLvTypeYear == EmpLvTypeYearSL).ToList();
            var lvTypeCPL = db.LvConsumeds.Where(aa => aa.EmpLvTypeYear == EmpLvTypeYearCPL).ToList();

            //Anual
            if (lvTypeAL.Count > 0)
            {
                foreach (var item in lvTypeAL)
                {
                    item.YearRemaining       = (float)AL;
                    item.GrandTotalRemaining = (float)AL;
                    db.SaveChanges();
                }
            }
            else
            {
                LvConsumed lvConsumed = new LvConsumed();
                lvConsumed.Year                = DateTime.Today.Year.ToString();
                lvConsumed.EmpID               = EmpID;
                lvConsumed.JanConsumed         = 0;
                lvConsumed.FebConsumed         = 0;
                lvConsumed.MarchConsumed       = 0;
                lvConsumed.AprConsumed         = 0;
                lvConsumed.MayConsumed         = 0;
                lvConsumed.JuneConsumed        = 0;
                lvConsumed.JulyConsumed        = 0;
                lvConsumed.AugustConsumed      = 0;
                lvConsumed.SepConsumed         = 0;
                lvConsumed.OctConsumed         = 0;
                lvConsumed.NovConsumed         = 0;
                lvConsumed.DecConsumed         = 0;
                lvConsumed.TotalForYear        = AL;
                lvConsumed.YearRemaining       = AL;
                lvConsumed.GrandTotal          = AL;
                lvConsumed.GrandTotalRemaining = AL;
                lvConsumed.EmpLvType           = EmpID.ToString() + "B";
                lvConsumed.EmpLvTypeYear       = EmpLvTypeYearAL;
                lvConsumed.LeaveType           = "B";
                db.LvConsumeds.Add(lvConsumed);
                db.SaveChanges();
            }
            //Casual
            if (lvTypeCL.Count > 0)
            {
                foreach (var item in lvTypeCL)
                {
                    item.YearRemaining       = (float)CL;
                    item.GrandTotalRemaining = (float)CL;
                    db.SaveChanges();
                }
            }
            else
            {
                LvConsumed lvConsumed = new LvConsumed();
                lvConsumed.Year                = DateTime.Today.Year.ToString();
                lvConsumed.EmpID               = EmpID;
                lvConsumed.JanConsumed         = 0;
                lvConsumed.FebConsumed         = 0;
                lvConsumed.MarchConsumed       = 0;
                lvConsumed.AprConsumed         = 0;
                lvConsumed.MayConsumed         = 0;
                lvConsumed.JuneConsumed        = 0;
                lvConsumed.JulyConsumed        = 0;
                lvConsumed.AugustConsumed      = 0;
                lvConsumed.SepConsumed         = 0;
                lvConsumed.OctConsumed         = 0;
                lvConsumed.NovConsumed         = 0;
                lvConsumed.DecConsumed         = 0;
                lvConsumed.TotalForYear        = CL;
                lvConsumed.YearRemaining       = CL;
                lvConsumed.GrandTotal          = CL;
                lvConsumed.GrandTotalRemaining = CL;
                lvConsumed.EmpLvType           = EmpID.ToString() + "A";
                lvConsumed.EmpLvTypeYear       = EmpLvTypeYearCL;
                lvConsumed.LeaveType           = "A";
                db.LvConsumeds.Add(lvConsumed);
                db.SaveChanges();
            }
            //Sick
            if (lvTypeSL.Count > 0)
            {
                foreach (var item in lvTypeSL)
                {
                    item.YearRemaining       = (float)SL;
                    item.GrandTotalRemaining = (float)SL;
                    db.SaveChanges();
                }
            }
            else
            {
                LvConsumed lvConsumed = new LvConsumed();
                lvConsumed.Year                = DateTime.Today.Year.ToString();
                lvConsumed.EmpID               = EmpID;
                lvConsumed.JanConsumed         = 0;
                lvConsumed.FebConsumed         = 0;
                lvConsumed.MarchConsumed       = 0;
                lvConsumed.AprConsumed         = 0;
                lvConsumed.MayConsumed         = 0;
                lvConsumed.JuneConsumed        = 0;
                lvConsumed.JulyConsumed        = 0;
                lvConsumed.AugustConsumed      = 0;
                lvConsumed.SepConsumed         = 0;
                lvConsumed.OctConsumed         = 0;
                lvConsumed.NovConsumed         = 0;
                lvConsumed.DecConsumed         = 0;
                lvConsumed.TotalForYear        = SL;
                lvConsumed.YearRemaining       = SL;
                lvConsumed.GrandTotal          = SL;
                lvConsumed.GrandTotalRemaining = SL;
                lvConsumed.EmpLvType           = EmpID.ToString() + "C";
                lvConsumed.EmpLvTypeYear       = EmpLvTypeYearSL;
                lvConsumed.LeaveType           = "C";
                db.LvConsumeds.Add(lvConsumed);
                db.SaveChanges();
            }
            //CPL
            if (lvTypeCPL.Count > 0)
            {
                foreach (var item in lvTypeCPL)
                {
                    item.YearRemaining       = (float)CPL;
                    item.GrandTotalRemaining = (float)CPL;
                    db.SaveChanges();
                }
            }
            else
            {
                LvConsumed lvConsumed = new LvConsumed();
                lvConsumed.Year                = DateTime.Today.Year.ToString();
                lvConsumed.EmpID               = EmpID;
                lvConsumed.JanConsumed         = 0;
                lvConsumed.FebConsumed         = 0;
                lvConsumed.MarchConsumed       = 0;
                lvConsumed.AprConsumed         = 0;
                lvConsumed.MayConsumed         = 0;
                lvConsumed.JuneConsumed        = 0;
                lvConsumed.JulyConsumed        = 0;
                lvConsumed.AugustConsumed      = 0;
                lvConsumed.SepConsumed         = 0;
                lvConsumed.OctConsumed         = 0;
                lvConsumed.NovConsumed         = 0;
                lvConsumed.DecConsumed         = 0;
                lvConsumed.TotalForYear        = CPL;
                lvConsumed.YearRemaining       = CPL;
                lvConsumed.GrandTotal          = CPL;
                lvConsumed.GrandTotalRemaining = CPL;
                lvConsumed.EmpLvType           = EmpID.ToString() + "E";
                lvConsumed.EmpLvTypeYear       = EmpLvTypeYearCPL;
                lvConsumed.LeaveType           = "E";
                db.LvConsumeds.Add(lvConsumed);
                db.SaveChanges();
            }
            User LoggedInUser = Session["LoggedUser"] as User;

            ViewBag.CompanyID    = new SelectList(CustomFunction.GetCompanies(db.Companies.ToList(), LoggedInUser), "CompID", "CompName", LoggedInUser.CompanyID);
            ViewBag.CompanyIDEmp = new SelectList(CustomFunction.GetCompanies(db.Companies.ToList(), LoggedInUser), "CompID", "CompName", LoggedInUser.CompanyID);
            ViewBag.LocationID   = new SelectList(db.Locations.OrderBy(s => s.LocName), "LocID", "LocName");
            ViewBag.CatID        = new SelectList(db.Categories.OrderBy(s => s.CatName), "CatID", "CatName");
            return(View("Index"));
        }