public ActionResult ConfirmTimeSheet(string tid, string fid)
        {
            var loggedInUser     = HttpContext.User;
            var loggedInUserName = loggedInUser.Identity.Name;

            var upTimeSheet = (from t in context.TimeSheet
                               where t.TimeSheetNumber.Equals(tid) && t.FunctionId.Equals(fid)
                               select t).FirstOrDefault();


            ViewBag.userMenu = GetMenu();

            var uid    = (from u in context.UserSspm where u.Username.Equals(loggedInUserName) select u).FirstOrDefault();
            var update = (from x in context.TimeSheet
                          where x.FunctionId.Equals(fid) &&
                          x.UserId.Equals(uid.UserId) && x.TimeSheetNumber.Equals(tid)
                          select x).FirstOrDefault();

            var e = new TimeSheetInputModel()
            {
                TimeSheetNumber = tid,
                FunctionId      = fid,
                UserId          = uid.UserId,
                ActionId        = update.ActionId,
                TaskId          = update.TaskId,
                ProjectNumber   = update.ProjectNumber,
            };

            ViewData["Action"] = new SelectList(context.Action.Where(a => a.ActionId != "N"), "ActionId", "ActionName");

            return(PartialView("ConfirmTimeSheet", e));
        }
        public async Task <IActionResult> AddTimeSheet(String id)
        {
            ViewBag.userMenu = GetMenu();
            ViewBag.nothi    = Nothi();
            if (id == null)
            {
                return(NotFound());
            }


            var Func = await context.Function.SingleOrDefaultAsync(m => m.FunctionId == id);

            var Tasx = await context.Task.SingleOrDefaultAsync(m => m.TaskId == Func.TaskId);

            var Proj = await context.Project.SingleOrDefaultAsync(m => m.ProjectNumber == Tasx.ProjectNumber);

            var e = new TimeSheetInputModel()
            {
                ProjectNumber = Proj.ProjectNumber,
                ProjectName   = Proj.ProjectName,
                TaskId        = Tasx.TaskId,
                TaskName      = Tasx.TaskName,
                FunctionId    = Func.FunctionId,
                FunctionName  = Func.FunctionName,
            };

            ViewData["ProjectName"] = " " + Proj.ProjectName;
            if (e == null)
            {
                return(NotFound());
            }


            return(PartialView("AddTimeSheet", e));
        }
        public async Task <IActionResult> AddTimeSheet(TimeSheetInputModel inputModel)
        {
            ViewBag.userMenu = GetMenu();

            var loggedInUser     = HttpContext.User;
            var loggedInUserName = loggedInUser.Identity.Name;



            var tsFunc = (from x in context.TimeSheet where x.FunctionId.Equals(inputModel.FunctionId)
                          orderby x.TimeSheetNumber descending
                          select x

                          ).FirstOrDefault();

            Boolean X = Boolean.ReferenceEquals(tsFunc, null);

            int num;

            if (X)
            {
                num = 100000;
            }
            else
            {
                num = Convert.ToInt32(tsFunc.TimeSheetNumber);
                num = num + 1;
            }

            var uid = (from u in context.UserSspm where u.Username.Equals(loggedInUserName) select u).FirstOrDefault();

            TimeSheet ord = new TimeSheet
            {
                ProjectNumber   = inputModel.ProjectNumber,
                TaskId          = inputModel.TaskId,
                FunctionId      = inputModel.FunctionId,
                TimeSheetId     = DateTime.Now,
                TimeSheetStart  = inputModel.TimeSheetStart,
                TimeSheetEnd    = inputModel.TimeSheetEnd,
                UserId          = uid.UserId,
                TimeSheetNumber = num.ToString(),
                ActionId        = "N"
            };

            try
            {
                context.TimeSheet.Add(ord);
                await context.SaveChangesAsync();
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                // Provide for exceptions.
            }

            return(RedirectToAction("TimeSheet", "TimeSheet", new RouteValueDictionary(
                                        new { Controller = "TimeSheet", Action = "TimeSheet", id = inputModel.ProjectNumber })));
        }
        public async Task <ActionResult> ApproveFunction(TimeSheetInputModel inputModel)
        {
            var loggedInUser     = HttpContext.User;
            var loggedInUserName = loggedInUser.Identity.Name;

            var update = (from x in context.TimeSheet
                          where x.FunctionId.Equals(inputModel.FunctionId) &&
                          x.UserId.Equals(inputModel.UserId) && x.TimeSheetNumber.Equals(inputModel.TimeSheetNumber)
                          select x);
            var userApprove = (from x in context.UserSspm where x.Username.Equals(loggedInUserName) select x).SingleOrDefault();

            foreach (Models.TimeSheet TUpdate in update)
            {
                TUpdate.ActionId = "Z";
                TUpdate.Approve1 = userApprove.UserId;
            }
            await context.SaveChangesAsync();

            try
            {
                var addLog = (from x in context.TimeSheet
                              where x.FunctionId.Equals(inputModel.FunctionId) &&
                              x.UserId.Equals(inputModel.UserId) && x.TimeSheetNumber.Equals(inputModel.TimeSheetNumber)
                              select x).FirstOrDefault();
                var stat = "";
                var AP1  = "";
                if (addLog.ActionId.Equals("Z"))
                {
                    stat = "F";
                    AP1  = userApprove.UserId;
                }
                else
                {
                    stat = "P";
                }
                FunctionLog ord = new FunctionLog
                {
                    ProjectNumber  = addLog.ProjectNumber,
                    FunctionLogId  = addLog.TimeSheetId,
                    FunctionId     = addLog.FunctionId,
                    FunctionStart  = addLog.TimeSheetStart,
                    FunctionEnd    = addLog.TimeSheetEnd,
                    FunctionNumber = addLog.TimeSheetNumber,
                    StatusId       = stat,
                    TaskId         = addLog.TaskId,
                    Approve1       = AP1,
                };

                context.FunctionLog.Add(ord);
                await context.SaveChangesAsync();

                try
                {
                    var update2 = (from x in context.FunctionLog
                                   where x.FunctionId.Equals(inputModel.FunctionId) &&
                                   x.FunctionNumber.Equals(inputModel.TimeSheetNumber)
                                   select x);
                    var ip = (from x in context.TimeSheet
                              where x.FunctionId.Equals(inputModel.FunctionId) &&
                              x.TimeSheetNumber.Equals(inputModel.TimeSheetNumber)
                              select x).FirstOrDefault();
                    if (ip.ActionId.Equals("Z"))
                    {
                        var checkss = (from x in context.FunctionLog where x.FunctionNumber.Equals("100000") select x).FirstOrDefault();

                        DateTime alstat = (DateTime)checkss.ActualStart;
                        DateTime alend  = (DateTime)addLog.TimeSheetEnd;

                        foreach (Models.FunctionLog FUpdate in update2)
                        {
                            FUpdate.StatusId    = "F";
                            FUpdate.ActualStart = checkss.ActualStart;
                            FUpdate.ActualEnd   = addLog.TimeSheetEnd;
                            FUpdate.Variant     = (int)alend.Subtract(alstat).TotalDays;
                        }
                        await context.SaveChangesAsync();

                        try
                        {
                            var check1 = (from x in context.FunctionLog
                                          where x.FunctionId.Equals(addLog.FunctionId) && x.StatusId.Equals("F") &&
                                          x.ProjectNumber.Equals(inputModel.ProjectNumber) && x.TaskId.Equals(inputModel.TaskId)
                                          select x).FirstOrDefault();
                            var update3 = (from x in context.Function
                                           where x.FunctionId.Equals(inputModel.FunctionId) && x.TaskId.Equals(inputModel.TaskId) && x.ProjectNumber.Equals(inputModel.ProjectNumber)
                                           select x);
                            DateTime afstat = (DateTime)check1.ActualStart;
                            DateTime afend  = (DateTime)check1.ActualEnd;


                            foreach (Models.Function FUpdate in update3)
                            {
                                FUpdate.ActualStart = check1.ActualStart;
                                FUpdate.ActualEnd   = check1.ActualEnd;
                                FUpdate.Variant     = (int)afend.Subtract(afstat).TotalDays;
                            }
                            await context.SaveChangesAsync();



                            var AllTask   = (from x in context.Function where x.TaskId.Equals(check1.TaskId) select x).Count();
                            var CheckTask = (from x in context.FunctionLog where x.TaskId.Equals(check1.TaskId) && x.StatusId.Equals("F") select x).Count();



                            if (AllTask == CheckTask)
                            {
                                var update4 = (from x in context.Task
                                               where x.TaskId.Equals(addLog.TaskId)
                                               select x);
                                var at = (from x in context.Task
                                          where x.TaskId.Equals(addLog.TaskId)
                                          select x).FirstOrDefault();
                                DateTime atstat = (DateTime)at.ActualStart;
                                DateTime atend  = (DateTime)check1.ActualEnd;
                                foreach (Models.Task FUpdate in update4)
                                {
                                    FUpdate.ActualEnd = check1.ActualEnd;
                                    FUpdate.Variant   = (int)atend.Subtract(atstat).TotalDays;
                                }
                                await context.SaveChangesAsync();

                                var AllProject   = (from x in context.Task where x.TaskId.Equals(check1.TaskId) select x).Count();
                                var CheckProject = (from x in context.FunctionLog where x.TaskId.Equals(check1.TaskId) && x.StatusId.Equals("F") && x.ProjectNumber.Equals(check1.ProjectNumber) && x.TaskId.Equals(check1.TaskId) select x).Count();
                                if (AllProject == CheckProject)
                                {
                                    var update5 = (from x in context.Project
                                                   where x.ProjectNumber.Equals(inputModel.ProjectNumber)
                                                   select x);
                                    var ap = (from x in context.Project
                                              where x.ProjectNumber.Equals(inputModel.ProjectNumber)
                                              select x).FirstOrDefault();
                                    DateTime apstat = (DateTime)ap.ActualStart;
                                    DateTime apend  = (DateTime)check1.ActualEnd;
                                    foreach (Models.Project FUpdate in update5)
                                    {
                                        FUpdate.ActualEnd = check1.ActualEnd;
                                        FUpdate.Variant   = (int)apend.Subtract(apstat).TotalDays;
                                    }
                                    await context.SaveChangesAsync();
                                }
                            }
                        }
                        catch (Exception e)
                        {
                            Console.WriteLine(e);
                        }
                    }
                    else
                    {
                        var c = (from x in context.TimeSheet where x.FunctionId.Equals(inputModel.FunctionId) && x.TaskId.Equals(inputModel.TaskId) select x).Count();
                        if (c == 1)
                        {
                            foreach (Models.FunctionLog FUpdate in update2)
                            {
                                FUpdate.ActualStart = addLog.TimeSheetStart;
                            }
                            await context.SaveChangesAsync();

                            var c4 = (from x in context.Function where x.FunctionId.Equals(inputModel.FunctionId) && x.TaskId.Equals(inputModel.TaskId) select x).Count();
                            if (c == 1)
                            {
                                var update3 = (from x in context.Function
                                               where x.FunctionId.Equals(inputModel.FunctionId) && x.TaskId.Equals(inputModel.TaskId) && x.ProjectNumber.Equals(inputModel.ProjectNumber)
                                               select x);
                                foreach (Models.Function FUpdate in update3)
                                {
                                    FUpdate.ActualStart = addLog.TimeSheetStart;
                                }
                                await context.SaveChangesAsync();
                            }
                            var c2 = (from x in context.TimeSheet where x.TaskId.Equals(addLog.TaskId) select x).Count();
                            if (c2 == 1)
                            {
                                var update4 = (from x in context.Task
                                               where x.TaskId.Equals(addLog.TaskId) && x.ProjectNumber.Equals(inputModel.ProjectNumber)
                                               select x);
                                foreach (Models.Task FUpdate in update4)
                                {
                                    FUpdate.ActualStart = addLog.TimeSheetStart;
                                }
                                await context.SaveChangesAsync();

                                var c3 = (from x in context.TimeSheet where x.ProjectNumber.Equals(addLog.ProjectNumber) select x).Count();
                                if (c2 == 1)
                                {
                                    var update5 = (from x in context.Project
                                                   where x.ProjectNumber.Equals(addLog.ProjectNumber)
                                                   select x);
                                    foreach (Models.Project FUpdate in update5)
                                    {
                                        FUpdate.ActualStart = addLog.TimeSheetStart;
                                    }
                                    await context.SaveChangesAsync();
                                }
                            }
                        }
                        var checkss = (from x in context.FunctionLog where x.FunctionNumber.Equals("100000") && x.FunctionId.Equals(addLog.FunctionId) && x.ProjectNumber.Equals(inputModel.ProjectNumber) && x.TaskId.Equals(inputModel.TaskId) select x).FirstOrDefault();

                        foreach (Models.FunctionLog FUpdate in update2)
                        {
                            FUpdate.StatusId    = "P";
                            FUpdate.ActualStart = checkss.ActualStart;
                        }
                        await context.SaveChangesAsync();
                    }
                }
                catch (Exception e)
                {
                    Console.WriteLine(e);
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }

            return(RedirectToAction("TimeSheet", "TimeSheet", new RouteValueDictionary(
                                        new { Controller = "TimeSheet", Action = "TimeSheet", id = inputModel.ProjectNumber })));
        }