Beispiel #1
0
        public static int CalculateAverageLessonPrice <TEntity>(this MonthlyIndicator item, ModelSource <TEntity> models, int?coachID)
            where TEntity : class, new()
        {
            AchievementQueryViewModel queryModel = new AchievementQueryViewModel
            {
                AchievementDateFrom = item.StartDate.AddMonths(-1),
                BypassCondition     = true,
            };

            IQueryable <V_Tuition> lessonItems = queryModel.InquireAchievement(models);

            if (item.StartDate == DateTime.Today.FirstDayOfMonth())
            {
                lessonItems = lessonItems.Where(l => l.ClassTime < DateTime.Today);
            }
            else
            {
                lessonItems = lessonItems.Where(l => l.SettlementID.HasValue);
            }

            IQueryable <V_Tuition> tuitionItems = lessonItems;
            int lessonAchievement;
            var coachTuitionItems = tuitionItems.Where(t => t.AttendingCoach == coachID);

            lessonAchievement  = coachTuitionItems.Where(t => SessionScopeForAchievement.Contains(t.PriceStatus)).Sum(t => t.ListPrice * t.GroupingMemberCount * t.PercentageOfDiscount / 100) ?? 0;
            lessonAchievement += (coachTuitionItems.Where(t => SessionScopeForAchievement.Contains(t.ELStatus)).Sum(l => l.EnterpriseListPrice * l.GroupingMemberCount * l.PercentageOfDiscount / 100) ?? 0);

            var completeLessonCount = Math.Max(coachTuitionItems.Where(t => SessionScopeForAchievement.Contains(t.PriceStatus)).Count()
                                               + coachTuitionItems.Where(t => SessionScopeForAchievement.Contains(t.ELStatus)).Count(), 1);

            return((lessonAchievement + completeLessonCount - 1) / completeLessonCount);
        }
        public ActionResult ShowCoachBonusList(AchievementQueryViewModel viewModel)
        {
            ViewResult result = (ViewResult)SelectCoachBonus(viewModel);
            IQueryable <CoachMonthlySalary> items = (IQueryable <CoachMonthlySalary>)result.Model;

            return(View("~/Views/BonusCredit/Module/MonthlyBonusList.cshtml", items));
        }
Beispiel #3
0
        public static IQueryable <V_Tuition> InquireAchievementTuition <TEntity>(this AchievementQueryViewModel viewModel, ModelSource <TEntity> models)
            where TEntity : class, new()
        {
            if (!viewModel.AchievementDateFrom.HasValue)
            {
                if (!String.IsNullOrEmpty(viewModel.AchievementYearMonthFrom))
                {
                    viewModel.AchievementDateFrom = DateTime.ParseExact(viewModel.AchievementYearMonthFrom, "yyyy/MM", System.Globalization.CultureInfo.CurrentCulture);
                }
                else
                {
                    viewModel.AchievementDateFrom = DateTime.Today.FirstDayOfMonth();
                }
            }

            if (!viewModel.AchievementDateTo.HasValue)
            {
                if (!String.IsNullOrEmpty(viewModel.AchievementYearMonthTo))
                {
                    viewModel.AchievementDateTo = DateTime.ParseExact(viewModel.AchievementYearMonthTo, "yyyy/MM", System.Globalization.CultureInfo.CurrentCulture).AddMonths(1);
                }
                else
                {
                    viewModel.AchievementDateTo = viewModel.AchievementDateFrom.Value.AddMonths(1);
                }
            }

            IQueryable <V_Tuition> items = models.GetTable <V_Tuition>();

            if (viewModel.CoachID.HasValue)
            {
                items = items.Where(c => c.AttendingCoach == viewModel.CoachID);
            }

            if (viewModel.ByCoachID != null && viewModel.ByCoachID.Length > 0)
            {
                items = items.Where(c => viewModel.ByCoachID.Contains(c.AttendingCoach));
            }

            if (viewModel.BranchID.HasValue)
            {
                items = items.Where(c => c.BranchID == viewModel.BranchID);
            }

            if (viewModel.AchievementDateFrom.HasValue)
            {
                items = items.Where(c => c.ClassTime >= viewModel.AchievementDateFrom);
            }

            if (viewModel.AchievementDateTo.HasValue)
            {
                items = items.Where(c => c.ClassTime < viewModel.AchievementDateTo);
            }

            return(items);
        }
Beispiel #4
0
        public static IQueryable <CoachMonthlySalary> InquireMonthlySalary <TEntity>(this AchievementQueryViewModel viewModel, ModelSource <TEntity> models)
            where TEntity : class, new()
        {
            IQueryable <CoachMonthlySalary> items = models.GetTable <Settlement>()
                                                    .Where(s => s.SettlementDate >= viewModel.AchievementDateFrom.Value.AddMonths(1) &&
                                                           s.SettlementDate < viewModel.AchievementDateTo.Value.AddMonths(1))
                                                    .Join(models.GetTable <CoachMonthlySalary>(),
                                                          s => s.SettlementID, c => c.SettlementID, (s, c) => c);

            return(items);
        }
Beispiel #5
0
        public ActionResult PrepareAchievementDetails(AchievementQueryViewModel viewModel)
        {
            //IQueryable<LessonTime> items = viewModel.InquireAchievement(this, out string alertMessage);

            //items = items.Join(models.GetTable<LessonTimeSettlement>().Where(l => l.SettlementID.HasValue),
            //                l => l.LessonID, t => t.LessonID, (l, t) => l);

            //IQueryable<V_Tuition> tuitionItems = items.Join(models.GetTable<V_Tuition>(), l => l.LessonID, t => t.LessonID, (l, t) => t);
            //return View("~/Views/ReportConsole/Module/PrepareAchievementDetails.cshtml", items);
            ViewResult result = (ViewResult)PrepareMonthlyBonus(viewModel);

            result.ViewName = "~/Views/ReportConsole/Module/PrepareAchievementDetails.cshtml";
            return(result);
        }
Beispiel #6
0
        public ActionResult PrepareMonthlyBonus(AchievementQueryViewModel viewModel)
        {
            ViewBag.ViewModel = viewModel;

            if (!viewModel.AchievementDateFrom.HasValue)
            {
                viewModel.AchievementDateFrom = DateTime.Today.FirstDayOfMonth();
            }
            viewModel.AchievementDateTo = viewModel.AchievementDateFrom.Value.AddMonths(1);

            IQueryable <CoachMonthlySalary> items = viewModel.InquireMonthlySalary(models);

            return(View("~/Views/ReportConsole/Module/PrepareMonthlyBonus.cshtml", items));
        }
        // GET: BonusCredit
        public ActionResult SelectCoachBonus(AchievementQueryViewModel viewModel)
        {
            ViewBag.ViewModel = viewModel;

            if (!viewModel.AchievementDateFrom.HasValue)
            {
                viewModel.AchievementDateFrom = DateTime.Today.FirstDayOfMonth();
            }
            viewModel.AchievementDateTo = viewModel.AchievementDateFrom.Value.AddMonths(1);

            IQueryable <CoachMonthlySalary> items = viewModel.InquireMonthlySalary(models);

            return(View("~/Views/BonusCredit/BonusModal/GiveBonusToCoach.cshtml", items));
        }
Beispiel #8
0
        public static IQueryable <V_Tuition> InquireAchievement <TEntity>(this AchievementQueryViewModel viewModel, SampleController <TEntity> controller, out String alertMessage)
            where TEntity : class, new()
        {
            alertMessage = null;
            var ModelState  = controller.ModelState;
            var ViewBag     = controller.ViewBag;
            var HttpContext = controller.HttpContext;
            var models      = controller.DataSource;

            ViewBag.ViewModel = viewModel;
            var profile = HttpContext.GetUser();

            if (!viewModel.AchievementDateFrom.HasValue)
            {
                if (!String.IsNullOrEmpty(viewModel.AchievementYearMonthFrom))
                {
                    viewModel.AchievementDateFrom = DateTime.ParseExact(viewModel.AchievementYearMonthFrom, "yyyy/MM", System.Globalization.CultureInfo.CurrentCulture);
                }
                else
                {
                    //ModelState.AddModelError("AchievementYearMonthFrom", "請選擇查詢月份");
                    viewModel.AchievementDateFrom = DateTime.Today.FirstDayOfMonth().AddMonths(1);
                }
            }

            if (!viewModel.AchievementDateTo.HasValue)
            {
                if (!String.IsNullOrEmpty(viewModel.AchievementYearMonthTo))
                {
                    viewModel.AchievementDateTo = DateTime.ParseExact(viewModel.AchievementYearMonthTo, "yyyy/MM", System.Globalization.CultureInfo.CurrentCulture);
                }
            }

            IQueryable <V_Tuition> items = viewModel.InquireAchievement(models, profile);

            return(items);
        }
Beispiel #9
0
        public static async Task <IQueryable <V_Tuition> > InquireAchievementAsync(this AchievementQueryViewModel viewModel, SampleController <UserProfile> controller)

        {
            var ModelState  = controller.ModelState;
            var ViewBag     = controller.ViewBag;
            var HttpContext = controller.HttpContext;
            var models      = controller.DataSource;

            ViewBag.ViewModel = viewModel;
            var profile = await HttpContext.GetUserAsync();

            if (!viewModel.AchievementDateFrom.HasValue)
            {
                if (!String.IsNullOrEmpty(viewModel.AchievementYearMonthFrom))
                {
                    viewModel.AchievementDateFrom = DateTime.ParseExact(viewModel.AchievementYearMonthFrom, "yyyy/MM", System.Globalization.CultureInfo.CurrentCulture);
                }
                else
                {
                    //ModelState.AddModelError("AchievementYearMonthFrom", "請選擇查詢月份");
                    viewModel.AchievementDateFrom = DateTime.Today.FirstDayOfMonth().AddMonths(1);
                }
            }

            if (!viewModel.AchievementDateTo.HasValue)
            {
                if (!String.IsNullOrEmpty(viewModel.AchievementYearMonthTo))
                {
                    viewModel.AchievementDateTo = DateTime.ParseExact(viewModel.AchievementYearMonthTo, "yyyy/MM", System.Globalization.CultureInfo.CurrentCulture);
                }
            }

            IQueryable <V_Tuition> items = viewModel.InquireAchievement(models, profile);

            return(items);
        }
Beispiel #10
0
        public static IQueryable <V_Tuition> InquireAchievement(this AchievementQueryViewModel viewModel, GenericManager <BFDataContext> models, UserProfile profile = null)

        {
            IQueryable <V_Tuition> items = models.GetTable <V_Tuition>()
                                           .Where(v => v.PriceStatus != (int)Naming.DocumentLevelDefinition.教練PI);

            if (viewModel.IgnoreAttendance == true)
            {
            }
            else
            {
                items = items.FilterByCompleteLesson();
            }

            bool hasConditon = false;

            if (viewModel.BypassCondition == true)
            {
                hasConditon = true;
            }

            if (viewModel.CoachID.HasValue)
            {
                hasConditon = true;
                items       = items.Where(c => c.AttendingCoach == viewModel.CoachID);
            }

            if (viewModel.ByCoachID != null && viewModel.ByCoachID.Length > 0)
            {
                items = items.Where(c => viewModel.ByCoachID.Contains(c.AttendingCoach));
            }

            //if (!hasConditon)
            //{
            if (viewModel.BranchID.HasValue)
            {
                hasConditon = true;
                items       = items.Where(c => c.BranchID == viewModel.BranchID);
            }
            //}


            if (!hasConditon)
            {
                if (profile == null)
                {
                    items = items.Where(l => false);
                }
                else if (profile.IsAssistant() || profile.IsAccounting() || profile.IsOfficer())
                {
                }
                else if (profile.IsManager() || profile.IsViceManager())
                {
                    var coaches = profile.GetServingCoachInSameStore(models);
                    items = items.Join(coaches, c => c.AttendingCoach, h => h.CoachID, (c, h) => c);
                }
                else if (profile.IsCoach())
                {
                    items = items.Where(c => c.AttendingCoach == profile.UID);
                }
            }

            if (viewModel.AchievementDateFrom.HasValue)
            {
                items = items.Where(c => c.ClassTime >= viewModel.AchievementDateFrom);

                if (!viewModel.AchievementDateTo.HasValue)
                {
                    viewModel.AchievementDateTo = viewModel.AchievementDateFrom;
                }
            }

            if (viewModel.AchievementDateTo.HasValue)
            {
                items = items.Where(c => c.ClassTime < viewModel.AchievementDateTo.Value.AddMonths(1));
            }

            return(items);
        }
        public ActionResult RestoreCoachRevenueIndicator(MonthlyCoachRevenueIndicatorQueryViewModel viewModel, int[] exclusiveCoach = null)
        {
            ViewBag.ViewModel = viewModel;

            IQueryable <MonthlyIndicator> indicatorItems = models.GetTable <MonthlyIndicator>();

            if (viewModel.DateFrom.HasValue)
            {
                viewModel.DateFrom = viewModel.DateFrom.Value.FirstDayOfMonth();
                indicatorItems.Where(i => i.StartDate >= viewModel.DateFrom);
            }
            if (viewModel.DateTo.HasValue)
            {
                viewModel.DateTo = viewModel.DateTo.Value.FirstDayOfMonth().AddMonths(1);
                indicatorItems.Where(i => i.StartDate < viewModel.DateTo);
            }

            IQueryable <ServingCoach> coachItems = models.GetTable <ServingCoach>();

            if (viewModel.CoachID.HasValue)
            {
                coachItems = coachItems.Where(c => c.CoachID == viewModel.CoachID);
            }

            if (exclusiveCoach != null && exclusiveCoach.Length > 0)
            {
                coachItems = coachItems
                             .Where(c => !exclusiveCoach.Contains(c.CoachID))
                             .Where(c => c.CoachWorkplace.Any());
            }

            var forCoaches = coachItems.ToArray();

            foreach (MonthlyIndicator indicator in indicatorItems)
            {
                AchievementQueryViewModel queryModel = new AchievementQueryViewModel
                {
                    AchievementDateFrom = indicator.StartDate,
                    BypassCondition     = true,
                };

                IQueryable <V_Tuition> lessonItems = queryModel.InquireAchievement(models);
                lessonItems = lessonItems.Where(l => l.SettlementID.HasValue);
                IQueryable <V_Tuition> tuitionItems = lessonItems;

                PaymentQueryViewModel paymentQuery = new PaymentQueryViewModel
                {
                    PayoffDateFrom  = indicator.StartDate,
                    PayoffDateTo    = indicator.EndExclusiveDate.AddDays(-1),
                    BypassCondition = true,
                };

                IQueryable <Payment>            paymentItems     = paymentQuery.InquirePayment(models);
                IQueryable <TuitionAchievement> achievementItems = paymentItems.GetPaymentAchievement(models);

                CourseContractQueryViewModel contractQuery = new CourseContractQueryViewModel
                {
                    ContractQueryMode = Naming.ContractServiceMode.ContractOnly,
                    Status            = (int)Naming.CourseContractStatus.已生效,
                    EffectiveDateFrom = indicator.StartDate,
                    EffectiveDateTo   = indicator.EndExclusiveDate,
                };
                IQueryable <CourseContract> contractItems = contractQuery.InquireContract(models);

                void calcCoachAchievement(MonthlyCoachRevenueIndicator coachIndicator)
                {
                    int lessonAchievement, tuitionAchievement;

                    var coachTuitionItems     = tuitionItems.Where(t => t.AttendingCoach == coachIndicator.CoachID);
                    var coachAchievementItems = achievementItems.Where(t => t.CoachID == coachIndicator.CoachID);
                    var coachContractItems    = contractItems.Where(c => c.FitnessConsultant == coachIndicator.CoachID);

                    lessonAchievement  = coachTuitionItems.Where(t => BusinessConsoleExtensions.SessionScopeForAchievement.Contains(t.PriceStatus)).Sum(t => t.ListPrice * t.GroupingMemberCount * t.PercentageOfDiscount / 100) ?? 0;
                    lessonAchievement += (coachTuitionItems.Where(t => BusinessConsoleExtensions.SessionScopeForAchievement.Contains(t.ELStatus)).Sum(l => l.EnterpriseListPrice * l.GroupingMemberCount * l.PercentageOfDiscount / 100) ?? 0);
                    tuitionAchievement = coachAchievementItems.Sum(a => a.ShareAmount) ?? 0;

                    coachIndicator.ActualCompleteLessonCount = coachTuitionItems.Where(t => BusinessConsoleExtensions.SessionScopeForComleteLessonCount.Contains(t.PriceStatus)).Count()
                                                               + coachTuitionItems.Where(t => BusinessConsoleExtensions.SessionScopeForComleteLessonCount.Contains(t.ELStatus)).Count();
                    coachIndicator.ActualLessonAchievement        = lessonAchievement;
                    coachIndicator.ActualRenewContractAchievement = coachContractItems.Where(c => c.Renewal == true).Count();
                    coachIndicator.ActualNewContractAchievement   = coachContractItems.Count() - coachIndicator.ActualRenewContractAchievement;
                    coachIndicator.ActualCompleteTSCount          = coachTuitionItems.Where(t => t.PriceStatus == (int)Naming.LessonPriceStatus.體驗課程).Count()
                                                                    + coachTuitionItems.Where(t => t.ELStatus == (int)Naming.LessonPriceStatus.體驗課程).Count();
                    coachIndicator.ActualCompletePICount = coachTuitionItems.Where(t => t.PriceStatus == (int)Naming.LessonPriceStatus.自主訓練).Count()
                                                           + coachTuitionItems.Where(t => t.ELStatus == (int)Naming.LessonPriceStatus.自主訓練).Count();
                    coachIndicator.ATCount       = coachTuitionItems.Where(t => t.PriceStatus == (int)Naming.LessonPriceStatus.運動防護課程).Count();
                    coachIndicator.ATAchievement = coachTuitionItems.Where(t => t.PriceStatus == (int)Naming.LessonPriceStatus.運動防護課程).Sum(t => t.ListPrice) ?? 0;
                    coachIndicator.SRCount       = coachTuitionItems.Where(t => t.PriceStatus == (int)Naming.LessonPriceStatus.運動恢復課程).Count();
                    coachIndicator.SRAchievement = coachTuitionItems.Where(t => t.PriceStatus == (int)Naming.LessonPriceStatus.運動恢復課程).Sum(t => t.ListPrice) ?? 0;
                    coachIndicator.SDCount       = coachTuitionItems.Where(t => t.PriceStatus == (int)Naming.LessonPriceStatus.營養課程).Count();
                    coachIndicator.SDAchievement = coachTuitionItems.Where(t => t.PriceStatus == (int)Naming.LessonPriceStatus.營養課程).Sum(t => t.ListPrice) ?? 0;

                    models.SubmitChanges();
                }

                foreach (var coach in forCoaches)
                {
                    var item = models.GetTable <MonthlyCoachRevenueIndicator>()
                               .Where(c => c.PeriodID == indicator.PeriodID && c.CoachID == coach.CoachID).FirstOrDefault();

                    if (item == null)
                    {
                        var attendingLessons = models.GetTable <LessonTime>()
                                               .Where(l => l.AttendingCoach == coach.CoachID)
                                               .Where(l => l.ClassTime >= indicator.StartDate)
                                               .Where(l => l.ClassTime < indicator.EndExclusiveDate);

                        if (attendingLessons.Any())
                        {
                            item = new MonthlyCoachRevenueIndicator
                            {
                                PeriodID = indicator.PeriodID,
                                CoachID  = coach.CoachID,
                                BranchID = coach.CoachWorkplace.First().BranchID,
                                LevelID  = coach.LevelID,
                            };
                            models.GetTable <MonthlyCoachRevenueIndicator>().InsertOnSubmit(item);

                            item.AchievementGoal     = 0;
                            item.CompleteLessonsGoal = 0;
                            item.AverageLessonPrice  = indicator.CalculateAverageLessonPrice(models, coach.CoachID);
                            item.BRCount             = 0;
                            item.LessonTuitionGoal   = 0;

                            models.SubmitChanges();

                            calcCoachAchievement(item);
                        }
                    }
                }
            }

            return(Json(new { result = true }));
        }
Beispiel #12
0
        public static void UpdateMonthlyAchievement <TEntity>(this MonthlyIndicator item, ModelSource <TEntity> models, bool?forcedUpdate = null, bool?calcAverage = null)
            where TEntity : class, new()
        {
            AchievementQueryViewModel queryModel = new AchievementQueryViewModel
            {
                AchievementDateFrom = item.StartDate,
                BypassCondition     = true,
            };

            IQueryable <Payment> voidPayment = UpdateVoidShare(models, item.StartDate, item.EndExclusiveDate);

            IQueryable <V_Tuition>  lessonItems = queryModel.InquireAchievement(models);
            IQueryable <LessonTime> STItems     = models.GetTable <LessonTime>()
                                                  .Where(c => c.ClassTime >= item.StartDate)
                                                  .Where(c => c.ClassTime < item.StartDate.AddMonths(1))
                                                  .Where(t => t.TrainingBySelf == 2);

            if (forcedUpdate == true)
            {
                lessonItems = lessonItems.Where(l => l.SettlementID.HasValue);
            }
            else if (item.StartDate == DateTime.Today.FirstDayOfMonth())
            {
                lessonItems = lessonItems.Where(l => l.ClassTime < DateTime.Today);
            }
            else
            {
                lessonItems = lessonItems.Where(l => l.SettlementID.HasValue);
            }

            IQueryable <V_Tuition> tuitionItems = lessonItems;

            PaymentQueryViewModel paymentQuery = new PaymentQueryViewModel
            {
                PayoffDateFrom  = item.StartDate,
                PayoffDateTo    = item.EndExclusiveDate.AddDays(-1),
                BypassCondition = true,
            };

            IQueryable <Payment>            paymentItems     = paymentQuery.InquirePayment(models);
            IQueryable <TuitionAchievement> achievementItems = paymentItems.GetPaymentAchievement(models);

            CourseContractQueryViewModel contractQuery = new CourseContractQueryViewModel
            {
                ContractQueryMode = Naming.ContractServiceMode.ContractOnly,
                Status            = (int)Naming.CourseContractStatus.已生效,
                EffectiveDateFrom = item.StartDate,
                EffectiveDateTo   = item.EndExclusiveDate,
            };
            IQueryable <CourseContract> contractItems       = contractQuery.InquireContract(models);
            IQueryable <CourseContract> installmentItems    = contractItems.Where(c => c.Installment.HasValue);
            IQueryable <CourseContract> nonInstallmentItems = contractItems.Where(c => !c.Installment.HasValue);

            int lessonAchievement, tuitionAchievement;

            void calcHeadquarterAchievement()
            {
                var voidTuition = voidPayment
                                  .Join(models.GetTable <TuitionAchievement>(), p => p.PaymentID, t => t.InstallmentID, (p, t) => t);

                lessonAchievement  = tuitionItems.Where(t => SessionScopeForAchievement.Contains(t.PriceStatus)).Sum(t => t.ListPrice * t.GroupingMemberCount * t.PercentageOfDiscount / 100) ?? 0;
                lessonAchievement += (tuitionItems.Where(t => SessionScopeForAchievement.Contains(t.ELStatus)).Sum(l => l.EnterpriseListPrice * l.GroupingMemberCount * l.PercentageOfDiscount / 100) ?? 0);
                tuitionAchievement = achievementItems.Sum(a => a.ShareAmount) ?? 0;

                IQueryable <TuitionAchievement> newContractAchievementItems = paymentItems
                                                                              .Join(models.GetTable <ContractPayment>()
                                                                                    .Join(models.GetTable <CourseContract>()
                                                                                          .Where(t => !t.Installment.HasValue)
                                                                                          .Where(t => !t.Renewal.HasValue || t.Renewal != true),
                                                                                          c => c.ContractID, t => t.ContractID, (c, t) => c),
                                                                                    p => p.PaymentID, c => c.PaymentID, (p, c) => p)
                                                                              .GetPaymentAchievement(models);

                IQueryable <TuitionAchievement> renewContractAchievementItems = paymentItems
                                                                                .Join(models.GetTable <ContractPayment>()
                                                                                      .Join(models.GetTable <CourseContract>()
                                                                                            .Where(t => !t.Installment.HasValue)
                                                                                            .Where(t => t.Renewal == true),
                                                                                            c => c.ContractID, t => t.ContractID, (c, t) => c),
                                                                                      p => p.PaymentID, c => c.PaymentID, (p, c) => p)
                                                                                .GetPaymentAchievement(models);

                IQueryable <TuitionAchievement> installmentContractAchievementItems = paymentItems
                                                                                      .Join(models.GetTable <ContractPayment>()
                                                                                            .Join(models.GetTable <CourseContract>()
                                                                                                  .Where(t => t.Installment.HasValue),
                                                                                                  c => c.ContractID, t => t.ContractID, (c, t) => c),
                                                                                            p => p.PaymentID, c => c.PaymentID, (p, c) => p)
                                                                                      .GetPaymentAchievement(models);

                var revenueItem = item.MonthlyRevenueIndicator.Where(r => r.MonthlyRevenueGoal != null)
                                  .Select(r => r.MonthlyRevenueGoal)
                                  .FirstOrDefault();

                if (revenueItem != null)
                {
                    revenueItem.ActualCompleteLessonCount = tuitionItems.Where(t => SessionScopeForComleteLessonCount.Contains(t.PriceStatus)).Count()
                                                            + tuitionItems.Where(t => SessionScopeForComleteLessonCount.Contains(t.ELStatus)).Count();
                    revenueItem.ActualLessonAchievement = lessonAchievement;
                    revenueItem.ActualSharedAchievement = tuitionAchievement;
                    revenueItem.RenewContractCount      = nonInstallmentItems.Where(c => c.Renewal == true).Count();
                    revenueItem.NewContractCount        = nonInstallmentItems.Count() - revenueItem.RenewContractCount;
                    revenueItem.RenewContractSubtotal   = nonInstallmentItems.Where(c => c.Renewal == true).Sum(c => c.TotalCost) ?? 0;
                    revenueItem.NewContractSubtotal     = nonInstallmentItems.Sum(c => c.TotalCost) - revenueItem.RenewContractSubtotal;
                    revenueItem.InstallmentCount        = installmentItems.Count();
                    revenueItem.InstallmentSubtotal     = installmentItems.Sum(c => c.TotalCost) ?? 0;

                    revenueItem.ActualCompleteTSCount = tuitionItems.Where(t => t.PriceStatus == (int)Naming.LessonPriceStatus.體驗課程).Count()
                                                        + tuitionItems.Where(t => t.ELStatus == (int)Naming.LessonPriceStatus.體驗課程).Count();
                    revenueItem.ActualCompletePICount = tuitionItems.Where(t => t.PriceStatus == (int)Naming.LessonPriceStatus.自主訓練).Count()
                                                        + tuitionItems.Where(t => t.ELStatus == (int)Naming.LessonPriceStatus.自主訓練).Count();

                    revenueItem.NewContractAchievement   = newContractAchievementItems.Sum(t => t.ShareAmount) ?? 0;
                    revenueItem.RenewContractAchievement = renewContractAchievementItems.Sum(t => t.ShareAmount) ?? 0;
                    revenueItem.InstallmentAchievement   = installmentContractAchievementItems.Sum(t => t.ShareAmount) ?? 0;
                    revenueItem.VoidShare = voidTuition.Sum(t => t.VoidShare) ?? 0;

                    models.SubmitChanges();
                }
            }

            void calcBranchAchievement()
            {
                foreach (var branchIndicator in item.MonthlyBranchIndicator)
                {
                    var voidTuition = voidPayment
                                      .Join(models.GetTable <PaymentTransaction>().Where(t => t.BranchID == branchIndicator.BranchID), p => p.PaymentID, t => t.PaymentID, (p, t) => p)
                                      .Join(models.GetTable <TuitionAchievement>(), p => p.PaymentID, t => t.InstallmentID, (p, t) => t);

                    var branchTuitionItems        = tuitionItems.Where(t => t.CoachWorkPlace == branchIndicator.BranchID);
                    var branchAchievementItems    = achievementItems.Where(t => t.CoachWorkPlace == branchIndicator.BranchID);
                    var branchContractItems       = contractItems.Where(c => c.CourseContractExtension.BranchID == branchIndicator.BranchID);
                    var branchInstallmentItems    = installmentItems.Where(c => c.CourseContractExtension.BranchID == branchIndicator.BranchID);
                    var branchNonInstallmentItems = nonInstallmentItems.Where(c => c.CourseContractExtension.BranchID == branchIndicator.BranchID);

                    IQueryable <TuitionAchievement> branchNewContractAchievementItems = paymentItems
                                                                                        .Join(models.GetTable <ContractPayment>()
                                                                                              .Join(models.GetTable <CourseContract>()
                                                                                                    .Where(t => !t.Installment.HasValue)
                                                                                                    .Where(t => !t.Renewal.HasValue || t.Renewal != true),
                                                                                                    c => c.ContractID, t => t.ContractID, (c, t) => c),
                                                                                              p => p.PaymentID, c => c.PaymentID, (p, c) => p)
                                                                                        .GetPaymentAchievement(models)
                                                                                        .Where(t => t.CoachWorkPlace == branchIndicator.BranchID);

                    IQueryable <TuitionAchievement> branchRenewContractAchievementItems = paymentItems
                                                                                          .Join(models.GetTable <ContractPayment>()
                                                                                                .Join(models.GetTable <CourseContract>()
                                                                                                      .Where(t => !t.Installment.HasValue)
                                                                                                      .Where(t => t.Renewal == true),
                                                                                                      c => c.ContractID, t => t.ContractID, (c, t) => c),
                                                                                                p => p.PaymentID, c => c.PaymentID, (p, c) => p)
                                                                                          .GetPaymentAchievement(models)
                                                                                          .Where(t => t.CoachWorkPlace == branchIndicator.BranchID);

                    IQueryable <TuitionAchievement> branchInstallmentContractAchievementItems = paymentItems
                                                                                                .Join(models.GetTable <ContractPayment>()
                                                                                                      .Join(models.GetTable <CourseContract>()
                                                                                                            .Where(t => t.Installment.HasValue),
                                                                                                            c => c.ContractID, t => t.ContractID, (c, t) => c),
                                                                                                      p => p.PaymentID, c => c.PaymentID, (p, c) => p)
                                                                                                .GetPaymentAchievement(models)
                                                                                                .Where(t => t.CoachWorkPlace == branchIndicator.BranchID);

                    var revenueItem = branchIndicator.MonthlyBranchRevenueIndicator
                                      .Where(v => v.MonthlyBranchRevenueGoal != null)
                                      .FirstOrDefault()?.MonthlyBranchRevenueGoal;
                    if (revenueItem != null)
                    {
                        lessonAchievement  = branchTuitionItems.Where(t => SessionScopeForAchievement.Contains(t.PriceStatus)).Sum(t => t.ListPrice * t.GroupingMemberCount * t.PercentageOfDiscount / 100) ?? 0;
                        lessonAchievement += (branchTuitionItems.Where(t => SessionScopeForAchievement.Contains(t.ELStatus)).Sum(l => l.EnterpriseListPrice * l.GroupingMemberCount * l.PercentageOfDiscount / 100) ?? 0);
                        tuitionAchievement = branchAchievementItems.Sum(a => a.ShareAmount) ?? 0;

                        revenueItem.ActualCompleteLessonCount = branchTuitionItems.Where(t => SessionScopeForComleteLessonCount.Contains(t.PriceStatus)).Count()
                                                                + branchTuitionItems.Where(t => SessionScopeForComleteLessonCount.Contains(t.ELStatus)).Count();
                        revenueItem.ActualLessonAchievement = lessonAchievement;
                        revenueItem.ActualSharedAchievement = tuitionAchievement;
                        revenueItem.RenewContractCount      = branchNonInstallmentItems.Where(c => c.Renewal == true).Count();
                        revenueItem.NewContractCount        = branchNonInstallmentItems.Count() - revenueItem.RenewContractCount;
                        revenueItem.RenewContractSubtotal   = branchNonInstallmentItems.Where(c => c.Renewal == true).Sum(c => c.TotalCost) ?? 0;
                        revenueItem.NewContractSubtotal     = branchNonInstallmentItems.Sum(c => c.TotalCost) - revenueItem.RenewContractSubtotal;
                        revenueItem.InstallmentCount        = branchInstallmentItems.Count();
                        revenueItem.InstallmentSubtotal     = branchInstallmentItems.Sum(c => c.TotalCost) ?? 0;

                        revenueItem.ActualCompleteTSCount = branchTuitionItems.Where(t => t.PriceStatus == (int)Naming.LessonPriceStatus.體驗課程).Count()
                                                            + branchTuitionItems.Where(t => t.ELStatus == (int)Naming.LessonPriceStatus.體驗課程).Count();
                        revenueItem.ActualCompletePICount = branchTuitionItems.Where(t => t.PriceStatus == (int)Naming.LessonPriceStatus.自主訓練).Count()
                                                            + branchTuitionItems.Where(t => t.ELStatus == (int)Naming.LessonPriceStatus.自主訓練).Count();

                        revenueItem.NewContractAchievement   = branchNewContractAchievementItems.Sum(t => t.ShareAmount) ?? 0;
                        revenueItem.RenewContractAchievement = branchRenewContractAchievementItems.Sum(t => t.ShareAmount) ?? 0;
                        revenueItem.InstallmentAchievement   = branchInstallmentContractAchievementItems.Sum(t => t.ShareAmount) ?? 0;
                        revenueItem.VoidShare = voidTuition.Sum(t => t.VoidShare) ?? 0;

                        models.SubmitChanges();
                    }
                }
            }

            void calcCoachAchievement()
            {
                foreach (var coachIndicator in item.MonthlyCoachRevenueIndicator)
                {
                    var voidTuition = voidPayment
                                      .Join(models.GetTable <TuitionAchievement>()
                                            .Where(t => t.CoachID == coachIndicator.CoachID),
                                            p => p.PaymentID, t => t.InstallmentID, (p, t) => t);

                    var coachTuitionItems     = tuitionItems.Where(t => t.AttendingCoach == coachIndicator.CoachID);
                    var coachAchievementItems = achievementItems.Where(t => t.CoachID == coachIndicator.CoachID);
                    var coachContractItems    = contractItems.Where(c => c.FitnessConsultant == coachIndicator.CoachID);
                    IQueryable <CourseContract> coachInstallmentItems    = coachContractItems.Where(c => c.Installment.HasValue);
                    IQueryable <CourseContract> coachNonInstallmentItems = coachContractItems.Where(c => !c.Installment.HasValue);

                    var coachSTItems = STItems.Where(t => t.AttendingCoach == coachIndicator.CoachID);

                    IQueryable <TuitionAchievement> coachNewContractAchievementItems = paymentItems
                                                                                       .Join(models.GetTable <ContractPayment>()
                                                                                             .Join(models.GetTable <CourseContract>()
                                                                                                   .Where(t => !t.Installment.HasValue)
                                                                                                   .Where(t => !t.Renewal.HasValue || t.Renewal != true),
                                                                                                   c => c.ContractID, t => t.ContractID, (c, t) => c),
                                                                                             p => p.PaymentID, c => c.PaymentID, (p, c) => p)
                                                                                       .GetPaymentAchievement(models)
                                                                                       .Where(t => t.CoachID == coachIndicator.CoachID);

                    IQueryable <TuitionAchievement> coachRenewContractAchievementItems = paymentItems
                                                                                         .Join(models.GetTable <ContractPayment>()
                                                                                               .Join(models.GetTable <CourseContract>()
                                                                                                     .Where(t => !t.Installment.HasValue)
                                                                                                     .Where(t => t.Renewal == true),
                                                                                                     c => c.ContractID, t => t.ContractID, (c, t) => c),
                                                                                               p => p.PaymentID, c => c.PaymentID, (p, c) => p)
                                                                                         .GetPaymentAchievement(models)
                                                                                         .Where(t => t.CoachID == coachIndicator.CoachID);

                    IQueryable <TuitionAchievement> coachInstallmentContractAchievementItems = paymentItems
                                                                                               .Join(models.GetTable <ContractPayment>()
                                                                                                     .Join(models.GetTable <CourseContract>()
                                                                                                           .Where(t => t.Installment.HasValue),
                                                                                                           c => c.ContractID, t => t.ContractID, (c, t) => c),
                                                                                                     p => p.PaymentID, c => c.PaymentID, (p, c) => p)
                                                                                               .GetPaymentAchievement(models)
                                                                                               .Where(t => t.CoachID == coachIndicator.CoachID);


                    lessonAchievement  = coachTuitionItems.Where(t => SessionScopeForAchievement.Contains(t.PriceStatus)).Sum(t => t.ListPrice * t.GroupingMemberCount * t.PercentageOfDiscount / 100) ?? 0;
                    lessonAchievement += (coachTuitionItems.Where(t => SessionScopeForAchievement.Contains(t.ELStatus)).Sum(l => l.EnterpriseListPrice * l.GroupingMemberCount * l.PercentageOfDiscount / 100) ?? 0);
                    tuitionAchievement = coachAchievementItems.Sum(a => a.ShareAmount) ?? 0;

                    coachIndicator.ActualCompleteLessonCount = coachTuitionItems.Where(t => SessionScopeForComleteLessonCount.Contains(t.PriceStatus)).Count()
                                                               + coachTuitionItems.Where(t => SessionScopeForComleteLessonCount.Contains(t.ELStatus)).Count();
                    coachIndicator.ActualLessonAchievement        = lessonAchievement;
                    coachIndicator.ActualRenewContractAchievement = coachRenewContractAchievementItems.Sum(t => t.ShareAmount) ?? 0;
                    coachIndicator.ActualNewContractAchievement   = coachNewContractAchievementItems.Sum(t => t.ShareAmount) ?? 0;
                    coachIndicator.ActualCompleteTSCount          = coachTuitionItems.Where(t => t.PriceStatus == (int)Naming.LessonPriceStatus.體驗課程).Count()
                                                                    + coachTuitionItems.Where(t => t.ELStatus == (int)Naming.LessonPriceStatus.體驗課程).Count();
                    coachIndicator.ActualCompletePICount = coachTuitionItems.Where(t => t.PriceStatus == (int)Naming.LessonPriceStatus.自主訓練).Count()
                                                           + coachTuitionItems.Where(t => t.ELStatus == (int)Naming.LessonPriceStatus.自主訓練).Count();

                    coachIndicator.InstallmentAchievement = coachInstallmentContractAchievementItems.Sum(t => t.ShareAmount) ?? 0;
                    coachIndicator.RenewContractCount     = coachNonInstallmentItems.Where(t => t.Renewal == true).Count();
                    coachIndicator.NewContractCount       = coachNonInstallmentItems.Count() - coachIndicator.RenewContractCount;
                    coachIndicator.RenewContractSubtotal  = coachNonInstallmentItems.Where(c => c.Renewal == true).Sum(c => c.TotalCost) ?? 0;
                    coachIndicator.NewContractSubtotal    = coachNonInstallmentItems.Sum(c => c.TotalCost) - coachIndicator.RenewContractSubtotal;
                    coachIndicator.InstallmentCount       = coachInstallmentItems.Count();
                    coachIndicator.InstallmentSubtotal    = coachInstallmentItems.Sum(c => c.TotalCost) ?? 0;


                    if (calcAverage == true)
                    {
                        coachIndicator.AverageLessonPrice = item.CalculateAverageLessonPrice(models, coachIndicator.CoachID);
                        coachIndicator.LessonTuitionGoal  = coachIndicator.CompleteLessonsGoal * coachIndicator.AverageLessonPrice;
                    }

                    coachIndicator.STCount   = coachSTItems.Count();
                    coachIndicator.VoidShare = voidTuition.Sum(t => t.VoidShare) ?? 0;

                    models.SubmitChanges();
                }
            }

            calcHeadquarterAchievement();
            calcBranchAchievement();
            calcCoachAchievement();
        }