Included file scoped namespace for webspa project

3 years ago · c89dc1c3de
--- a/src/Web/WebSPA/AppSettings.cs
+++ b/src/Web/WebSPA/AppSettings.cs
@ -1,20 +1,14 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 namespace eShopOnContainers.WebSPA;

 namespace eShopOnContainers.WebSPA
 public class AppSettings
 {
    public class AppSettings
    {
        public string IdentityUrl { get; set; }
        public string BasketUrl { get; set; }
        public string MarketingUrl { get; set; }
    public string IdentityUrl { get; set; }
    public string BasketUrl { get; set; }
    public string MarketingUrl { get; set; }

        public string PurchaseUrl { get; set; }
        public string SignalrHubUrl { get; set; }
    public string PurchaseUrl { get; set; }
    public string SignalrHubUrl { get; set; }

        public string ActivateCampaignDetailFunction { get; set; }
        public bool UseCustomizationData { get; set; }
    }
    public string ActivateCampaignDetailFunction { get; set; }
    public bool UseCustomizationData { get; set; }
 }
--- a/src/Web/WebSPA/Program.cs
+++ b/src/Web/WebSPA/Program.cs
@ -1,12 +1,4 @@
 using eShopConContainers.WebSPA;
 using Microsoft.AspNetCore;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
 using Serilog;
 using System.IO;

 BuildWebHost(args).Run();
 await BuildWebHost(args).RunAsync();

 IWebHost BuildWebHost(string[] args) =>
    WebHost.CreateDefaultBuilder(args)
--- a/src/Web/WebSPA/Server/Controllers/HomeController.cs
+++ b/src/Web/WebSPA/Server/Controllers/HomeController.cs
@ -1,25 +1,18 @@
 // For more information on enabling MVC for empty projects, visit http://go.microsoft.com/fwlink/?LinkID=397860
 namespace eShopConContainers.WebSPA.Server.Controllers;

 using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.Extensions.Options;
 using eShopOnContainers.WebSPA;

 namespace eShopConContainers.WebSPA.Server.Controllers
 public class HomeController : Controller
 {
    public class HomeController : Controller
    {
        private readonly IWebHostEnvironment _env;
        private readonly IOptionsSnapshot<AppSettings> _settings;
    private readonly IWebHostEnvironment _env;
    private readonly IOptionsSnapshot<AppSettings> _settings;

        public HomeController(IWebHostEnvironment env, IOptionsSnapshot<AppSettings> settings)
        {
            _env = env;
            _settings = settings;
        }
        public IActionResult Configuration()
        {
            return Json(_settings.Value);
        } 
    public HomeController(IWebHostEnvironment env, IOptionsSnapshot<AppSettings> settings)
    {
        _env = env;
        _settings = settings;
    }
    public IActionResult Configuration()
    {
        return Json(_settings.Value);
    } 
 }
--- a/src/Web/WebSPA/Server/Infrastructure/WebContextSeed.cs
+++ b/src/Web/WebSPA/Server/Infrastructure/WebContextSeed.cs
@ -1,77 +1,67 @@
 using eShopOnContainers.WebSPA;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.Extensions.DependencyInjection;
 namespace WebSPA.Infrastructure;

 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using System;
 using System.IO;
 using System.IO.Compression;
 using System.Linq;

 namespace WebSPA.Infrastructure
 public class WebContextSeed
 {
    public class WebContextSeed
    public static void Seed(IApplicationBuilder applicationBuilder, IWebHostEnvironment env, ILoggerFactory loggerFactory)
    {
        public static void Seed(IApplicationBuilder applicationBuilder, IWebHostEnvironment env, ILoggerFactory loggerFactory)
        {
            var log = loggerFactory.CreateLogger<WebContextSeed>();
        var log = loggerFactory.CreateLogger<WebContextSeed>();

            var settings = applicationBuilder
                .ApplicationServices.GetRequiredService<IOptions<AppSettings>>().Value;
        var settings = applicationBuilder
            .ApplicationServices.GetRequiredService<IOptions<AppSettings>>().Value;

            var useCustomizationData = settings.UseCustomizationData;
            var contentRootPath = env.ContentRootPath;
            var webroot = env.WebRootPath;
        var useCustomizationData = settings.UseCustomizationData;
        var contentRootPath = env.ContentRootPath;
        var webroot = env.WebRootPath;

            if (useCustomizationData)
            {
                GetPreconfiguredImages(contentRootPath, webroot, log);
            }
        if (useCustomizationData)
        {
            GetPreconfiguredImages(contentRootPath, webroot, log);
        }
    }

        static void GetPreconfiguredImages(string contentRootPath, string webroot, ILogger log)
    static void GetPreconfiguredImages(string contentRootPath, string webroot, ILogger log)
    {
        try
        {
            try
            string imagesZipFile = Path.Combine(contentRootPath, "Setup", "images.zip");
            if (!File.Exists(imagesZipFile))
            {
                string imagesZipFile = Path.Combine(contentRootPath, "Setup", "images.zip");
                if (!File.Exists(imagesZipFile))
                {
                    log.LogError("Zip file '{ZipFileName}' does not exists.", imagesZipFile);
                    return;
                }
                log.LogError("Zip file '{ZipFileName}' does not exists.", imagesZipFile);
                return;
            }

                string imagePath = Path.Combine(webroot, "assets", "images");
                if (!Directory.Exists(imagePath))
                {
                    Directory.CreateDirectory(imagePath);
                }
                string[] imageFiles = Directory.GetFiles(imagePath).Select(file => Path.GetFileName(file)).ToArray();
            string imagePath = Path.Combine(webroot, "assets", "images");
            if (!Directory.Exists(imagePath))
            {
                Directory.CreateDirectory(imagePath);
            }
            string[] imageFiles = Directory.GetFiles(imagePath).Select(file => Path.GetFileName(file)).ToArray();

                using (ZipArchive zip = ZipFile.Open(imagesZipFile, ZipArchiveMode.Read))
            using (ZipArchive zip = ZipFile.Open(imagesZipFile, ZipArchiveMode.Read))
            {
                foreach (ZipArchiveEntry entry in zip.Entries)
                {
                    foreach (ZipArchiveEntry entry in zip.Entries)
                    if (!imageFiles.Contains(entry.Name))
                    {
                        if (!imageFiles.Contains(entry.Name))
                        string destinationFilename = Path.Combine(imagePath, entry.Name);
                        if (File.Exists(destinationFilename))
                        {
                            string destinationFilename = Path.Combine(imagePath, entry.Name);
                            if (File.Exists(destinationFilename))
                            {
                                File.Delete(destinationFilename);
                            }
                            entry.ExtractToFile(destinationFilename);
                        }
                        else
                        {
                            log.LogWarning("Skipped file '{FileName}' in zipfile '{ZipFileName}'", entry.Name, imagesZipFile);
                            File.Delete(destinationFilename);
                        }
                        entry.ExtractToFile(destinationFilename);
                    }
                    else
                    {
                        log.LogWarning("Skipped file '{FileName}' in zipfile '{ZipFileName}'", entry.Name, imagesZipFile);
                    }
                }
            }
            catch (Exception ex)
            {
                log.LogError(ex, "ERROR in GetPreconfiguredImages: {Message}", ex.Message);
            }
        }
        catch (Exception ex)
        {
            log.LogError(ex, "ERROR in GetPreconfiguredImages: {Message}", ex.Message);
        }
    }
 }
--- a/src/Web/WebSPA/Startup.cs
+++ b/src/Web/WebSPA/Startup.cs
@ -1,164 +1,143 @@
 using eShopOnContainers.WebSPA;
 using HealthChecks.UI.Client;
 using Microsoft.AspNetCore.Antiforgery;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.DataProtection;
 using Microsoft.AspNetCore.Diagnostics.HealthChecks;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.SpaServices.AngularCli;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Diagnostics.HealthChecks;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 using StackExchange.Redis;
 using System;
 using System.IO;
 using WebSPA.Infrastructure;

 namespace eShopConContainers.WebSPA
 namespace eShopConContainers.WebSPA;

 public class Startup
 {
    public class Startup
    public Startup(IConfiguration configuration)
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }
        Configuration = configuration;
    }

        public IConfiguration Configuration { get; }
    public IConfiguration Configuration { get; }

        public Startup()
        {
            var localPath = new Uri(Configuration["ASPNETCORE_URLS"])?.LocalPath ?? "/";
            Configuration["BaseUrl"] = localPath;
        }
    public Startup()
    {
        var localPath = new Uri(Configuration["ASPNETCORE_URLS"])?.LocalPath ?? "/";
        Configuration["BaseUrl"] = localPath;
    }

        // This method gets called by the runtime. Use this method to add services to the container.
        // For more information on how to configure your application, visit http://go.microsoft.com/fwlink/?LinkID=398940
        public void ConfigureServices(IServiceCollection services)
        {
            RegisterAppInsights(services);
    // This method gets called by the runtime. Use this method to add services to the container.
    // For more information on how to configure your application, visit http://go.microsoft.com/fwlink/?LinkID=398940
    public void ConfigureServices(IServiceCollection services)
    {
        RegisterAppInsights(services);

            services.AddHealthChecks()
                .AddCheck("self", () => HealthCheckResult.Healthy())
                .AddUrlGroup(new Uri(Configuration["IdentityUrlHC"]), name: "identityapi-check", tags: new string[] { "identityapi" });
        services.AddHealthChecks()
            .AddCheck("self", () => HealthCheckResult.Healthy())
            .AddUrlGroup(new Uri(Configuration["IdentityUrlHC"]), name: "identityapi-check", tags: new string[] { "identityapi" });

            services.Configure<AppSettings>(Configuration);
        services.Configure<AppSettings>(Configuration);

            if (Configuration.GetValue<string>("IsClusterEnv") == bool.TrueString)
        if (Configuration.GetValue<string>("IsClusterEnv") == bool.TrueString)
        {
            services.AddDataProtection(opts =>
            {
                services.AddDataProtection(opts =>
                {
                    opts.ApplicationDiscriminator = "eshop.webspa";
                })
                .PersistKeysToStackExchangeRedis(ConnectionMultiplexer.Connect(Configuration["DPConnectionString"]), "DataProtection-Keys");
            }

            // Add Antiforgery services and configure the header name that angular will use by default.
            services.AddAntiforgery(options => options.HeaderName = "X-XSRF-TOKEN");
                opts.ApplicationDiscriminator = "eshop.webspa";
            })
            .PersistKeysToStackExchangeRedis(ConnectionMultiplexer.Connect(Configuration["DPConnectionString"]), "DataProtection-Keys");
        }

            // Add controllers support and add a global AutoValidateAntiforgeryTokenFilter that will make the application check for an Antiforgery token on all "mutating" requests (POST, PUT, DELETE).
            // The AutoValidateAntiforgeryTokenFilter is an internal class registered when we register views, so we need to register controllers and views also.
            services.AddControllersWithViews(options => options.Filters.Add(new AutoValidateAntiforgeryTokenAttribute()))
                .AddJsonOptions(options =>
                {
                    options.JsonSerializerOptions.PropertyNameCaseInsensitive = true;
                });
        // Add Antiforgery services and configure the header name that angular will use by default.
        services.AddAntiforgery(options => options.HeaderName = "X-XSRF-TOKEN");

            // Setup where the compiled version of our spa application will be, when in production. 
            services.AddSpaStaticFiles(configuration =>
        // Add controllers support and add a global AutoValidateAntiforgeryTokenFilter that will make the application check for an Antiforgery token on all "mutating" requests (POST, PUT, DELETE).
        // The AutoValidateAntiforgeryTokenFilter is an internal class registered when we register views, so we need to register controllers and views also.
        services.AddControllersWithViews(options => options.Filters.Add(new AutoValidateAntiforgeryTokenAttribute()))
            .AddJsonOptions(options =>
            {
                configuration.RootPath = "wwwroot";
                options.JsonSerializerOptions.PropertyNameCaseInsensitive = true;
            });

        // Setup where the compiled version of our spa application will be, when in production. 
        services.AddSpaStaticFiles(configuration =>
        {
            configuration.RootPath = "wwwroot";
        });
    }

    // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
    public void Configure(IApplicationBuilder app, IWebHostEnvironment env, ILoggerFactory loggerFactory, IAntiforgery antiforgery)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env, ILoggerFactory loggerFactory, IAntiforgery antiforgery)
        // Here we add Angular default Antiforgery cookie name on first load. https://angular.io/guide/http#security-xsrf-protection
        // This cookie will be read by Angular app and its value will be sent back to the application as the header configured in .AddAntiforgery()
        app.Use(next => context =>
        {
            if (env.IsDevelopment())
            string path = context.Request.Path.Value;

            if (
                string.Equals(path, "/", StringComparison.OrdinalIgnoreCase) ||
                string.Equals(path, "/index.html", StringComparison.OrdinalIgnoreCase))
            {
                app.UseDeveloperExceptionPage();
                // The request token has to be sent as a JavaScript-readable cookie, 
                // and Angular uses it by default.
                var tokens = antiforgery.GetAndStoreTokens(context);
                context.Response.Cookies.Append("XSRF-TOKEN", tokens.RequestToken,
                    new CookieOptions() { HttpOnly = false });
            }

            // Here we add Angular default Antiforgery cookie name on first load. https://angular.io/guide/http#security-xsrf-protection
            // This cookie will be read by Angular app and its value will be sent back to the application as the header configured in .AddAntiforgery()
            app.Use(next => context =>
            {
                string path = context.Request.Path.Value;

                if (
                    string.Equals(path, "/", StringComparison.OrdinalIgnoreCase) ||
                    string.Equals(path, "/index.html", StringComparison.OrdinalIgnoreCase))
                {
                    // The request token has to be sent as a JavaScript-readable cookie, 
                    // and Angular uses it by default.
                    var tokens = antiforgery.GetAndStoreTokens(context);
                    context.Response.Cookies.Append("XSRF-TOKEN", tokens.RequestToken,
                        new CookieOptions() { HttpOnly = false });
                }

                return next(context);
            });
            return next(context);
        });

            //Seed Data
            WebContextSeed.Seed(app, env, loggerFactory);
        //Seed Data
        WebContextSeed.Seed(app, env, loggerFactory);

            var pathBase = Configuration["PATH_BASE"];
        var pathBase = Configuration["PATH_BASE"];

            if (!string.IsNullOrEmpty(pathBase))
            {
                loggerFactory.CreateLogger<Startup>().LogDebug("Using PATH BASE '{pathBase}'", pathBase);
                app.UsePathBase(pathBase);
            }
        if (!string.IsNullOrEmpty(pathBase))
        {
            loggerFactory.CreateLogger<Startup>().LogDebug("Using PATH BASE '{pathBase}'", pathBase);
            app.UsePathBase(pathBase);
        }

            app.UseDefaultFiles();
            app.UseStaticFiles();
        app.UseDefaultFiles();
        app.UseStaticFiles();

            // this will make the application to respond with the index.html and the rest of the assets present on the configured folder (at AddSpaStaticFiles() (wwwroot))
            if (!env.IsDevelopment())
        // this will make the application to respond with the index.html and the rest of the assets present on the configured folder (at AddSpaStaticFiles() (wwwroot))
        if (!env.IsDevelopment())
        {
            app.UseSpaStaticFiles();
        }
        app.UseRouting();
        app.UseEndpoints(endpoints =>
        {
            endpoints.MapDefaultControllerRoute();
            endpoints.MapControllers();
            endpoints.MapHealthChecks("/liveness", new HealthCheckOptions
            {
                app.UseSpaStaticFiles();
            }
            app.UseRouting();
            app.UseEndpoints(endpoints =>
                Predicate = r => r.Name.Contains("self")
            });
            endpoints.MapHealthChecks("/hc", new HealthCheckOptions()
            {
                endpoints.MapDefaultControllerRoute();
                endpoints.MapControllers();
                endpoints.MapHealthChecks("/liveness", new HealthCheckOptions
                {
                    Predicate = r => r.Name.Contains("self")
                });
                endpoints.MapHealthChecks("/hc", new HealthCheckOptions()
                {
                    Predicate = _ => true,
                    ResponseWriter = UIResponseWriter.WriteHealthCheckUIResponse
                });
                Predicate = _ => true,
                ResponseWriter = UIResponseWriter.WriteHealthCheckUIResponse
            });
        });

            // Handles all still unnatended (by any other middleware) requests by returning the default page of the SPA (wwwroot/index.html).
            app.UseSpa(spa =>
            {
                // To learn more about options for serving an Angular SPA from ASP.NET Core,
                // see https://go.microsoft.com/fwlink/?linkid=864501
        // Handles all still unnatended (by any other middleware) requests by returning the default page of the SPA (wwwroot/index.html).
        app.UseSpa(spa =>
        {
            // To learn more about options for serving an Angular SPA from ASP.NET Core,
            // see https://go.microsoft.com/fwlink/?linkid=864501

                // the root of the angular app. (Where the package.json lives)
                spa.Options.SourcePath = "Client";
            // the root of the angular app. (Where the package.json lives)
            spa.Options.SourcePath = "Client";

                if (env.IsDevelopment())
                { 
            if (env.IsDevelopment())
            { 

                    // use the SpaServices extension method for angular, that will make the application to run "ng serve" for us, when in development.
                    spa.UseAngularCliServer(npmScript: "start");
                }
            });
        }
                // use the SpaServices extension method for angular, that will make the application to run "ng serve" for us, when in development.
                spa.UseAngularCliServer(npmScript: "start");
            }
        });
    }

        private void RegisterAppInsights(IServiceCollection services)
        {
            services.AddApplicationInsightsTelemetry(Configuration);
            services.AddApplicationInsightsKubernetesEnricher();
        }
    private void RegisterAppInsights(IServiceCollection services)
    {
        services.AddApplicationInsightsTelemetry(Configuration);
        services.AddApplicationInsightsKubernetesEnricher();
    }
 }