public async Task <IActionResult> Run(
            [HttpTrigger(AuthorizationLevel.Function, "get", Route = "GetSubmission/{Id}")] HttpRequest req, string Id, ILogger log)
        {
            log.LogInformation("GET - Get Submission requested");
            try
            {
                if (!RIPAAuthorization.ValidateAdministratorRole(req, log).ConfigureAwait(false).GetAwaiter().GetResult())
                {
                    return(new UnauthorizedResult());
                }
            }
            catch (Exception ex)
            {
                log.LogError(ex.Message);
                return(new UnauthorizedResult());
            }

            //limit
            var queryLimit  = !string.IsNullOrWhiteSpace(req.Query["limit"]) ? Convert.ToInt32(req.Query["limit"]) : default;
            var queryOffset = !string.IsNullOrWhiteSpace(req.Query["offset"]) ? Convert.ToInt32(req.Query["offset"]) : default;
            var limit       = string.Empty;

            if (queryLimit != 0)
            {
                limit = Environment.NewLine + $"OFFSET {queryOffset} LIMIT {queryLimit}";
            }

            var queryOrderBy = !string.IsNullOrWhiteSpace(req.Query["OrderBy"]) ? req.Query["OrderBy"] : default;
            var queryOrder   = !string.IsNullOrWhiteSpace(req.Query["Order"]) ? req.Query["Order"] : default;

            var order = Environment.NewLine + "ORDER BY c.StopDateTime DESC";

            if (!string.IsNullOrWhiteSpace(queryOrderBy))
            {
                order = Environment.NewLine + $"ORDER BY c.{queryOrderBy} ";
                if (!string.IsNullOrWhiteSpace(queryOrder))
                {
                    if (queryOrder.ToString().ToUpperInvariant() == "DESC" || queryOrder.ToString().ToUpperInvariant() == "ASC")
                    {
                        order += queryOrder;
                    }
                }
            }

            List <string> whereStatements = new List <string>();
            string        join            = string.Empty;

            join += Environment.NewLine + "JOIN ListSubmission IN c.ListSubmission";
            whereStatements.Add(Environment.NewLine + $"ListSubmission.Id = '{Id}'");

            if (!string.IsNullOrWhiteSpace(req.Query["ErrorCode"]))
            {
                join += Environment.NewLine + "JOIN ListSubmissionError IN ListSubmission.ListSubmissionError";
                whereStatements.Add(Environment.NewLine + $"ListSubmissionError.Code = '{req.Query["ErrorCode"]}'");
            }

            string where = string.Empty;
            if (whereStatements.Count > 0)
            {
                where = " WHERE ";
                foreach (var whereStatement in whereStatements)
                {
                    where += Environment.NewLine + whereStatement;
                    where += Environment.NewLine + "AND";
                }
                where = where.Remove(where.Length - 3);
            }

            if (!string.IsNullOrEmpty(Id))
            {
                var submissionResponse = await _submissionCosmosDbService.GetSubmissionAsync(Id);

                if (submissionResponse != null)
                {
                    string query = $"SELECT VALUE c FROM c {join} {where} {order} {limit}";

                    var stopResponse = await _stopCosmosDbService.GetStopsAsync(query);

                    var getSubmissionErrorSummariesResponse = await _stopCosmosDbService.GetSubmissionErrorSummaries(Id);

                    var response = new
                    {
                        submission = new {
                            submissionResponse.Id,
                            submissionResponse.DateSubmitted,
                            submissionResponse.RecordCount,
                            submissionResponse.OfficerId,
                            submissionResponse.OfficerName,
                            submissionResponse.MaxStopDate,
                            submissionResponse.MinStopDate,
                            ErrorCount = getSubmissionErrorSummariesResponse.Sum(x => x.Count)
                        },
                        stops   = stopResponse,
                        summary = getSubmissionErrorSummariesResponse
                    };

                    return(new OkObjectResult(response));
                }
            }
            return(new BadRequestObjectResult("Submission Id not found"));
        }