public ActionResult UpdatePartial(int id, string periodeType)
        {
            int         pmsSummaryId = id;
            PeriodeType pType        = (PeriodeType)Enum.Parse(typeof(PeriodeType), periodeType);

            var request = new GetKpiAchievementsRequest {
                PeriodeType = pType, PmsSummaryId = pmsSummaryId
            };
            var    response = _kpiAchievementService.GetKpiAchievements(request);
            string view     = pType == PeriodeType.Yearly ? "_yearly" : "_monthly";

            if (response.IsSuccess)
            {
                var viewModel = response.MapTo <UpdateKpiAchievementsViewModel>();
                viewModel.PeriodeType  = pType.ToString();
                viewModel.PmsSummaryId = pmsSummaryId;
                return(PartialView(view, viewModel));
            }

            return(Content(response.Message));
        }
        public ActionResult Update(int id, string periodeType)
        {
            int         pmsSummaryId = id;
            PeriodeType pType        = string.IsNullOrEmpty(periodeType)
                            ? PeriodeType.Yearly
                            : (PeriodeType)Enum.Parse(typeof(PeriodeType), periodeType);
            var request = new GetKpiAchievementsRequest {
                PeriodeType = pType, PmsSummaryId = pmsSummaryId
            };
            var response = _kpiAchievementService.GetKpiAchievements(request);

            if (response.IsSuccess)
            {
                var viewModel = response.MapTo <UpdateKpiAchievementsViewModel>();
                viewModel.PmsSummaryId = pmsSummaryId;
                viewModel.PeriodeType  = pType.ToString();
                viewModel.PeriodeTypes = _dropdownService.GetPeriodeTypesForKpiTargetAndAchievement().MapTo <SelectListItem>();
                return(View("Update", viewModel));
            }
            return(base.ErrorPage(response.Message));
        }
Example #3
0
        public GetKpiAchievementsResponse GetKpiAchievements(GetKpiAchievementsRequest request)
        {
            var response = new GetKpiAchievementsResponse();

            try
            {
                var pmsSummary = DataContext.PmsSummaries.Single(x => x.Id == request.PmsSummaryId);

                var pillarsAndKpis = DataContext.PmsConfigDetails
                                     .Include(x => x.Kpi)
                                     .Include(x => x.Kpi.KpiAchievements)
                                     .Include(x => x.Kpi.Measurement)
                                     .Include(x => x.PmsConfig)
                                     .Include(x => x.PmsConfig.PmsSummary)
                                     .Include(x => x.PmsConfig.Pillar)
                                     .Where(x => x.PmsConfig.PmsSummary.Id == request.PmsSummaryId)
                                     .ToList()
                                     .GroupBy(x => x.PmsConfig.Pillar)
                                     .ToDictionary(x => x.Key);


                foreach (var item in pillarsAndKpis)
                {
                    var pillar = new GetKpiAchievementsResponse.Pillar();
                    pillar.Id   = item.Key.Id;
                    pillar.Name = item.Key.Name;

                    foreach (var val in item.Value)
                    {
                        var achievements = new List <GetKpiAchievementsResponse.KpiAchievement>();
                        switch (request.PeriodeType)
                        {
                        case PeriodeType.Monthly:
                            for (int i = 1; i <= 12; i++)
                            {
                                var kpiAchievementsMonthly = val.Kpi.KpiAchievements.FirstOrDefault(x => x.PeriodeType == PeriodeType.Monthly &&
                                                                                                    x.Periode.Month == i && x.Periode.Year == pmsSummary.Year);
                                var kpiAchievementMonthly = new GetKpiAchievementsResponse.KpiAchievement();
                                if (kpiAchievementsMonthly == null)
                                {
                                    kpiAchievementMonthly.Id      = 0;
                                    kpiAchievementMonthly.Periode = new DateTime(pmsSummary.Year, i, 1);
                                    kpiAchievementMonthly.Value   = null;
                                    kpiAchievementMonthly.Remark  = null;
                                }
                                else
                                {
                                    kpiAchievementMonthly.Id      = kpiAchievementsMonthly.Id;
                                    kpiAchievementMonthly.Periode = kpiAchievementsMonthly.Periode;
                                    kpiAchievementMonthly.Value   = kpiAchievementsMonthly.Value;
                                    kpiAchievementMonthly.Remark  = kpiAchievementsMonthly.Remark;
                                }

                                achievements.Add(kpiAchievementMonthly);
                            }
                            break;

                        case PeriodeType.Yearly:
                            var kpiAchievementsYearly =
                                val.Kpi.KpiAchievements.FirstOrDefault(x => x.PeriodeType == PeriodeType.Yearly &&
                                                                       x.Periode.Year == pmsSummary.Year);
                            var kpiAchievementYearly = new GetKpiAchievementsResponse.KpiAchievement();
                            if (kpiAchievementsYearly == null)
                            {
                                kpiAchievementYearly.Id      = 0;
                                kpiAchievementYearly.Periode = new DateTime(pmsSummary.Year, 1, 1);
                                kpiAchievementYearly.Value   = null;
                                kpiAchievementYearly.Remark  = null;
                            }
                            else
                            {
                                kpiAchievementYearly.Id      = kpiAchievementsYearly.Id;
                                kpiAchievementYearly.Periode = kpiAchievementsYearly.Periode;
                                kpiAchievementYearly.Value   = kpiAchievementsYearly.Value;
                                kpiAchievementYearly.Remark  = kpiAchievementsYearly.Remark;
                            }
                            achievements.Add(kpiAchievementYearly);

                            break;
                        }

                        var kpi = new GetKpiAchievementsResponse.Kpi
                        {
                            Id              = val.Kpi.Id,
                            Measurement     = val.Kpi.Measurement.Name,
                            Name            = val.Kpi.Name,
                            KpiAchievements = achievements
                        };

                        pillar.Kpis.Add(kpi);
                    }

                    response.Pillars.Add(pillar);
                }
                response.IsSuccess = true;
            }
            catch (ArgumentNullException argumentNullException)
            {
                response.Message = argumentNullException.Message;
            }
            catch (InvalidOperationException invalidOperationException)
            {
                response.Message = invalidOperationException.Message;
            }

            return(response);
        }