Example #1
0
 public IActionResult IndexDataTable(IDataTablesRequest request)
 {
     try
     {
         DataTablesJsonResult model = _repository.GetAllPetani(request);
         return(model);
     }
     catch (Exception ex)
     {
         return(Json(new { error = ex.Message }));
     }
 }
Example #2
0
 public IActionResult DataTableAjaxHandler(IDataTablesRequest request)
 {
     try
     {
         DataTablesJsonResult model = _repo.GetAllBerat(request);
         return(model);
     }
     catch (Exception ex)
     {
         return(Json(new { error = ex.Message }));
     }
 }
Example #3
0
        public JsonResult GetValidationRulesReportData(IDataTablesRequest request)
        {
            var result        = _cacheManager.GetRulesetDefinitions();
            var sortedResults = result.SelectMany(
                x =>
                x.RuleDefinitions.Select(
                    y =>
                    new RulesetReportDetail
            {
                Ruleset        = x.Name,
                Id             = y.Id,
                ValidationType = y.ValidationType,
                Message        = y.Message
            }));

            var count = sortedResults.Count();

            var sortColumn = request.Columns.FirstOrDefault(x => x.Sort != null);

            if (sortColumn != null)
            {
                Func <RulesetReportDetail, string> orderingFunctionString = null;

                switch (sortColumn.Field)
                {
                case "name":
                {
                    orderingFunctionString = x => x.Ruleset;
                    sortedResults          = sortColumn.Sort.Direction == SortDirection.Ascending
                                                ? sortedResults.OrderBy(orderingFunctionString)
                                                : sortedResults.OrderByDescending(orderingFunctionString);
                    break;
                }

                case "id":
                {
                    orderingFunctionString = x => x.Id;
                    sortedResults          = sortColumn.Sort.Direction == SortDirection.Ascending
                                                ? sortedResults.OrderBy(orderingFunctionString)
                                                : sortedResults.OrderByDescending(orderingFunctionString);
                    break;
                }

                case "validationType":
                {
                    orderingFunctionString = x => x.ValidationType;
                    sortedResults          = sortColumn.Sort.Direction == SortDirection.Ascending
                                                ? sortedResults.OrderBy(orderingFunctionString)
                                                : sortedResults.OrderByDescending(orderingFunctionString);
                    break;
                }

                case "message":
                {
                    orderingFunctionString = x => x.Message;
                    sortedResults          = sortColumn.Sort.Direction == SortDirection.Ascending
                                                ? sortedResults.OrderBy(orderingFunctionString)
                                                : sortedResults.OrderByDescending(orderingFunctionString);
                    break;
                }

                default:
                    break;
                }
            }

            if (request.Search != null)
            {
                sortedResults = sortedResults.Where(x =>
                                                    x.Ruleset.IndexOf(request.Search.Value, StringComparison.OrdinalIgnoreCase) >= 0 ||
                                                    x.Id.IndexOf(request.Search.Value, StringComparison.OrdinalIgnoreCase) >= 0 ||
                                                    x.Message.IndexOf(request.Search.Value, StringComparison.OrdinalIgnoreCase) >= 0);
            }

            var pagedResults = sortedResults.Skip(request.Start).Take(request.Length);
            var response     = DataTablesResponse.Create(request, count, sortedResults.Count(), pagedResults);
            var jsonResult   = new DataTablesJsonResult(response, JsonRequestBehavior.AllowGet);

            return(jsonResult);
        }
Example #4
0
        public JsonResult ReportSummaries(int edOrgId, IDataTablesRequest request)
        {
            var results = _validationResultsService.GetValidationReportSummaries(edOrgId).OrderByDescending(rs => rs.CompletedWhen).ToList();

            IEnumerable <ValidationReportSummary> sortedResults = results;

            var sortColumn = request.Columns.FirstOrDefault(x => x.Sort != null);

            if (sortColumn != null)
            {
                Func <ValidationReportSummary, string>    orderingFunctionString;
                Func <ValidationReportSummary, int?>      orderingFunctionNullableInt;
                Func <ValidationReportSummary, DateTime>  orderingFunctionDateTime;
                Func <ValidationReportSummary, DateTime?> orderingFunctionNullableDateTime;

                switch (sortColumn.Field)
                {
                case "requestedWhen":
                {
                    orderingFunctionDateTime = x => x.RequestedWhen;
                    sortedResults            = sortColumn.Sort.Direction == SortDirection.Ascending
                                                ? results.OrderBy(orderingFunctionDateTime)
                                                : results.OrderByDescending(orderingFunctionDateTime);
                    break;
                }

                case "collection":
                {
                    orderingFunctionString = x => $"{x.SchoolYear.StartYear}-{x.SchoolYear.EndYear} / {x.Collection}";
                    sortedResults          = sortColumn.Sort.Direction == SortDirection.Ascending
                                                ? results.OrderBy(orderingFunctionString)
                                                : results.OrderByDescending(orderingFunctionString);
                    break;
                }

                case "initiatedBy":
                {
                    orderingFunctionString = x => x.InitiatedBy;
                    sortedResults          = sortColumn.Sort.Direction == SortDirection.Ascending
                                                ? results.OrderBy(orderingFunctionString)
                                                : results.OrderByDescending(orderingFunctionString);
                    break;
                }

                case "status":
                {
                    orderingFunctionString = x => x.Status;
                    sortedResults          = sortColumn.Sort.Direction == SortDirection.Ascending
                                                ? results.OrderBy(orderingFunctionString)
                                                : results.OrderByDescending(orderingFunctionString);
                    break;
                }

                case "completedWhen":
                {
                    orderingFunctionNullableDateTime = x => x.CompletedWhen;
                    sortedResults = sortColumn.Sort.Direction == SortDirection.Ascending
                                                ? results.OrderBy(orderingFunctionNullableDateTime)
                                                : results.OrderByDescending(orderingFunctionNullableDateTime);
                    break;
                }

                case "errorCount":
                {
                    orderingFunctionNullableInt = x => x.ErrorCount;
                    sortedResults = sortColumn.Sort.Direction == SortDirection.Ascending
                                                ? results.OrderBy(orderingFunctionNullableInt)
                                                : results.OrderByDescending(orderingFunctionNullableInt);
                    break;
                }

                case "warningCount":
                {
                    orderingFunctionNullableInt = x => x.WarningCount;
                    sortedResults = sortColumn.Sort.Direction == SortDirection.Ascending
                                                ? results.OrderBy(orderingFunctionNullableInt)
                                                : results.OrderByDescending(orderingFunctionNullableInt);
                    break;
                }

                default:
                {
                    sortedResults = results;
                    break;
                }
                }
            }

            var pagedResults = sortedResults.Skip(request.Start).Take(request.Length);
            var response     = DataTablesResponse.Create(request, results.Count, results.Count, pagedResults);
            var jsonResult   = new DataTablesJsonResult(response, JsonRequestBehavior.AllowGet);

            return(jsonResult);
        }