Beispiel #1
0
        public async Task <IActionResult> Excel(PlannedSearch search, int page = 1)
        {
            try
            {
                PlannedWhereBuilder plannedWhereBuilder = new PlannedWhereBuilder(search);

                string searchParams = search != default ? search.ToString() : default;

                List <PlannedPreviewViewModel> plannings = await GetPage(search, plannedWhereBuilder, searchParams, page);

                if (plannings == default)
                {
                    return(BadRequest());
                }

                return(await base.FormatModel <PlannedPreviewViewModel>(plannings, MedicDataLocalization.Plannings, FormattableFactory));
            }
            catch (Exception ex)
            {
                Task <int> _ = MedicLoggerService.SaveAsync(new Log()
                {
                    Message = ex.Message,
                    InnerExceptionMessage = ex?.InnerException?.Message ?? null,
                    Source     = ex.Source,
                    StackTrace = ex.StackTrace,
                    Date       = DateTime.Now
                });

                throw;
            }
        }
Beispiel #2
0
        public async Task <IActionResult> Index(PlannedSearch search, int page = 1)
        {
            try
            {
                PlannedWhereBuilder plannedWhereBuilder = new PlannedWhereBuilder(search);

                string searchParams = search != default ? search.ToString() : default;

                List <PlannedPreviewViewModel> plannings = await GetPage(search, plannedWhereBuilder, searchParams, page);

                string plannedCountKey = $"{MedicConstants.Planned} - {searchParams}";

                if (!base.MedicCache.TryGetValue(plannedCountKey, out int planningsCount))
                {
                    planningsCount = await PlannedService
                                     .GetPlanningsCountAsync(plannedWhereBuilder);

                    base.MedicCache.Set(plannedCountKey, planningsCount);
                }

                List <SexOption> sexOptions = base.GetDefaultSexes();
                sexOptions.AddRange(await base.GetSexesAsync());

                List <HealthRegionOption> healthRegions = base.GetDefaultHealthRegions();
                healthRegions.AddRange(await base.GetHealthRegionsAsync());

                return(View(new PlannedPageIndexModel()
                {
                    Plannings = plannings,
                    Title = MedicDataLocalization.Get(MedicDataLocalization.Plannings),
                    Description = MedicDataLocalization.Get(MedicDataLocalization.Plannings),
                    Keywords = MedicDataLocalization.Get(MedicDataLocalization.PlanningsSummary),
                    Search = search,
                    CurrentPage = page,
                    TotalPages = base.TotalPages((int)search.Length, planningsCount),
                    TotalResults = planningsCount,
                    Sexes = sexOptions,
                    HealthRegions = healthRegions
                }));
            }
            catch (Exception ex)
            {
                Task <int> _ = MedicLoggerService.SaveAsync(new Log()
                {
                    Message = ex.Message,
                    InnerExceptionMessage = ex?.InnerException?.Message ?? null,
                    Source     = ex.Source,
                    StackTrace = ex.StackTrace,
                    Date       = DateTime.Now
                });

                throw ex;
            }
        }
Beispiel #3
0
        private async Task <List <PlannedPreviewViewModel> > GetPage(PlannedSearch search, PlannedWhereBuilder plannedWhereBuilder, string searchParams, int page)
        {
            int pageLength = (int)search.Length;
            int startIndex = base.GetStartIndex(pageLength, page);

            string plannedKey = $"{nameof(PlannedPreviewViewModel)} - {startIndex} - {searchParams}";

            if (!base.MedicCache.TryGetValue(plannedKey, out List <PlannedPreviewViewModel> plannings))
            {
                PlannedHelperBuilder helperBuilder = new PlannedHelperBuilder(search);

                plannings = await PlannedService.GetPlanningsAsync(plannedWhereBuilder, helperBuilder, startIndex);

                base.MedicCache.Set(plannedKey, plannings);
            }

            return(plannings);
        }
 public PlannedHelperBuilder(PlannedSearch plannedProcedureSearch)
 {
     PlannedProcedureSearch = plannedProcedureSearch;
 }
 public PlannedWhereBuilder(PlannedSearch plannedProcedureSearch)
 {
     PlannedProcedureSearch = plannedProcedureSearch;
 }