private async Task LoadMetrics()
        {
            var authState = await AuthenticationStateProvider.GetAuthenticationStateAsync();

            var user = authState.User;

            filterOptions.Moderator = user.Identity.Name;


            displayStyle = "d-none";
            messageStyle = "";
            message      = "Loading metrics...";

            metrics = await Service.GetModeratorMetricsAsync(filterOptions);

            if (!metrics.HasContent)
            {
                message      = "No metrics found for the selected filter options. Please select a different set of filter options...";
                displayStyle = "d-none";
            }
            else
            {
                messageStyle = "d-none";
                displayStyle = "";
            }

            StateHasChanged();

            await JSRuntime.InvokeVoidAsync("DrawDetectionsChart", metrics.DetectionsArray);

            await JSRuntime.InvokeVoidAsync("DrawDetectionResultsChart", metrics.DetectionResultsArray);
        }
        public async Task <IActionResult> GetModeratorMetrics([FromQuery] ModeratorMetricsFilterDTO queryParameters)
        {
            try
            {
                if (string.IsNullOrWhiteSpace(queryParameters.Timeframe))
                {
                    throw new ArgumentNullException("Timeframe");
                }

                if (string.IsNullOrWhiteSpace(queryParameters.Moderator))
                {
                    throw new ArgumentNullException("Moderator");
                }

                var metrics = new ModeratorMetrics();

                metrics.Timeframe = queryParameters.Timeframe;
                metrics.Moderator = queryParameters.Moderator;

                // Build base queryable
                var queryable = await BuildQueryableAsync(queryParameters.Timeframe, queryParameters.Moderator);

                // If not metrics to return
                if (queryable == null || queryable.Count() == 0)
                {
                    return(NoContent());
                }

                // Pull reviewed/unreviewed metrics from querable
                var reviewed = MetadataProcessors.GetReviewed(queryable);

                metrics.Reviewed   = reviewed.ReviewedCount;
                metrics.Unreviewed = reviewed.UnreviewedCount;

                // Pull results metrics from queryable
                var results = MetadataProcessors.GetResults(queryable);

                metrics.ConfirmedDetection = results.ConfirmedCount;
                metrics.FalseDetection     = results.FalseCount;
                metrics.UnknownDetection   = results.UnknownCount;

                // Pull comments from queryable
                metrics.ConfirmedComments   = MetadataProcessors.GetComments(queryable, "yes");
                metrics.UnconfirmedComments = MetadataProcessors.GetComments(queryable, "no");
                metrics.UnconfirmedComments.AddRange(MetadataProcessors.GetComments(queryable, "don't know"));

                // Pull tags from queryable
                metrics.Tags = MetadataProcessors.GetTags(queryable);

                return(Ok(metrics));
            }
            catch (ArgumentNullException ex)
            {
                var details = new ProblemDetails()
                {
                    Detail = ex.Message
                };
                return(BadRequest(details));
            }
            catch (Exception ex)
            {
                var details = new ProblemDetails()
                {
                    Title  = ex.GetType().ToString(),
                    Detail = ex.Message
                };

                return(StatusCode(StatusCodes.Status500InternalServerError, details));
            }
        }