public async Task <PostResponseModel> PostContent(string url, string path, RegionModel regionModel, IEnumerable <KeyValuePair <string, string> > formParameters, string requestBaseUrl)
        {
            _ = regionModel ?? throw new ArgumentNullException(nameof(regionModel));

            var results = new PostResponseModel();

            try
            {
                if (regionModel.IsHealthy)
                {
                    logger.LogInformation($"{nameof(PostContent)}: Posting child response from: {url}");

                    var request = new HttpRequestMessage(HttpMethod.Post, url)
                    {
                        Content = formParameters != null ? new FormUrlEncodedContent(formParameters) : null,
                    };

                    var httpClient = httpClientFactory.GetClientForRegionEndpoint(regionModel.RegionEndpoint);
                    var response   = await httpClient.SendAsync(request);

                    if (response.IsRedirectionStatus())
                    {
                        responseHandler.Process(response);

                        var redirectUrl = requestBaseUrl;

                        redirectUrl += response.Headers.Location.IsAbsoluteUri
                            ? response.Headers.Location.PathAndQuery.ToString(CultureInfo.InvariantCulture)
                            : response.Headers.Location.ToString();

                        throw new RedirectException(new Uri(url), new Uri(redirectUrl),
                                                    response.StatusCode == HttpStatusCode.PermanentRedirect);
                    }

                    if (!response.IsSuccessStatusCode)
                    {
                        throw new EnhancedHttpException(response.StatusCode, response.ReasonPhrase, url);
                    }

                    var mediaType = response.Content.Headers.ContentType.MediaType;
                    if (FileDownloadContentTypes.TryGetValue(mediaType, out var fileExtension))
                    {
                        results.FileDownloadModel = new FileDownloadModel
                        {
                            FileBytes       = await response.Content.ReadAsByteArrayAsync(),
                            FileContentType = mediaType,
                            FileName        = !string.IsNullOrWhiteSpace(response.Content.Headers.ContentDisposition.FileNameStar) ? response.Content.Headers.ContentDisposition.FileNameStar : $"NCS file download.{fileExtension}",
                        };
                    }
                    else
                    {
                        results.Html = await response.Content.ReadAsStringAsync();
                    }

                    logger.LogInformation($"{nameof(PostContent)}: Received child response from: {url}");
                }
                else
                {
                    results.Html = !string.IsNullOrWhiteSpace(regionModel.OfflineHtml)
                        ? regionModel.OfflineHtml
                        : markupMessages.GetRegionOfflineHtml(regionModel.PageRegion);
                }
            }
            catch (BrokenCircuitException ex)
            {
                logger.LogError(ex, $"{nameof(ContentRetriever)}: BrokenCircuit: {url} - {ex.Message}");

                if (regionModel.HealthCheckRequired)
                {
                    await appRegistryDataService.SetRegionHealthState(path, regionModel.PageRegion, false);
                }

                results.Html = !string.IsNullOrWhiteSpace(regionModel.OfflineHtml)
                    ? regionModel.OfflineHtml
                    : markupMessages.GetRegionOfflineHtml(regionModel.PageRegion);
            }
            catch (Exception ex)
            {
                logger.LogInformation($"{nameof(PostContent)}: Received error response from: {url}. {ex.Message}");
                throw;
            }

            return(results);
        }
Exemple #2
0
        public ContentRetrieverTests()
        {
            httpResponse = new HttpResponseMessage
            {
                StatusCode = HttpStatusCode.OK,
                Content    = new StringContent(DummyChildAppContent),
            };

            fakeHttpRequestSender = A.Fake <IFakeHttpRequestSender>();
            A.CallTo(() => fakeHttpRequestSender.Send(A <HttpRequestMessage> .Ignored)).Returns(httpResponse);

            fakeHttpMessageHandler = new FakeHttpMessageHandler(fakeHttpRequestSender);

            httpClientFactory = A.Fake <IUriSpecifcHttpClientFactory>();
            httpClient        = new HttpClient(fakeHttpMessageHandler)
            {
                BaseAddress = new Uri("http://SomeRegionBaseAddress"),
            };

            A.CallTo(() => httpClientFactory.GetClientForRegionEndpoint(A <string> .Ignored)).Returns(httpClient);

            defaultFormPostParams = new List <KeyValuePair <string, string> > {
                new KeyValuePair <string, string>("formParam1", "test value")
            };

            logger = A.Fake <ILogger <ContentRetriever> >();
            appRegistryDataService     = A.Fake <IAppRegistryDataService>();
            httpResponseMessageHandler = A.Fake <IHttpResponseMessageHandler>();
            markupMessages             = new MarkupMessages
            {
                AppOfflineHtml    = "<h3>App offline</h3>",
                RegionOfflineHtml = new Dictionary <PageRegion, string>
                {
                    {
                        PageRegion.Head, "<h3>Head Region is offline</h3>"
                    },
                    {
                        PageRegion.Breadcrumb, "<h3>Breadcrumb Region is offline</h3>"
                    },
                    {
                        PageRegion.BodyTop, "<h3>BodyTop Region is offline</h3>"
                    },
                    {
                        PageRegion.Body, "<h3>Body Region is offline</h3>"
                    },
                    {
                        PageRegion.SidebarRight, "<h3>SidebarRight Region is offline</h3>"
                    },
                    {
                        PageRegion.SidebarLeft, "<h3>SidebarLeft Region is offline</h3>"
                    },
                    {
                        PageRegion.BodyFooter, "<h3>BodyFooter Region is offline</h3>"
                    },
                    {
                        PageRegion.HeroBanner, "<h3>HeroBanner Region is offline</h3>"
                    },
                },
            };

            memoryCache    = new MemoryCache(Options.Create(new MemoryCacheOptions()));
            defaultService = new ContentRetriever(httpClientFactory, logger, appRegistryDataService, httpResponseMessageHandler, markupMessages, memoryCache, passOnHeaderSettings);
        }