#36 Completed http and www rewrite functionality.

Author: Ray Fan

src/Fan.Web/Extensions/IApplicationBuilderExtensions.cs

@@ -1,4 +1,5 @@
 using Fan.Web.MetaWeblog;
+using Fan.Web.Middlewares;
 
 namespace Microsoft.AspNetCore.Builder
 {
@@ -13,5 +14,16 @@ public static IApplicationBuilder UseMetablog(this IApplicationBuilder builder)
         {
             return builder.UseMiddleware<MetaWeblogMiddleware>();
         }
+
+        /// <summary>
+        /// Adds <see cref="HttpWwwRewriteMiddleware"/> for redirect between http / https and 
+        /// preferred domain www / nonwww.
+        /// </summary>
+        /// <param name="builder"></param>
+        /// <returns></returns>
+        public static IApplicationBuilder UseHttpWwwRewrite(this IApplicationBuilder builder)
+        {
+            return builder.UseMiddleware<HttpWwwRewriteMiddleware>();
+        }
     }
 }

src/Fan.Web/Middlewares/HttpWwwRewriteMiddleware.cs

@@ -0,0 +1,45 @@
+using Fan.Models;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Http.Extensions;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using Microsoft.Net.Http.Headers;
+using System;
+using System.Threading.Tasks;
+
+namespace Fan.Web.Middlewares
+{
+    public class HttpWwwRewriteMiddleware
+    {
+        private readonly RequestDelegate _next;
+        private ILogger<HttpWwwRewriteMiddleware> _logger;
+
+        public HttpWwwRewriteMiddleware(RequestDelegate next, ILoggerFactory loggerFactory)
+        {
+            _next = next ?? throw new ArgumentNullException(nameof(next));
+            _logger = loggerFactory.CreateLogger<HttpWwwRewriteMiddleware>();
+        }
+
+        public Task Invoke(HttpContext context, IHttpWwwRewriter helper)
+        {
+            // has to locate service instead of inject in for appsettings update to be picked up in middleware automatically
+            var settings = context.RequestServices.GetService<IOptionsSnapshot<AppSettings>>().Value;
+
+            _logger.LogDebug("PreferredDomain {@PreferredDomain}", settings.PreferredDomain);
+            _logger.LogDebug("UseHttps {@UseHttps}", settings.UseHttps);
+
+            if (helper.ShouldRewrite(settings, context.Request.GetDisplayUrl(), out string url))
+            {
+                _logger.LogInformation("RewriteUrl: {@RewriteUrl}", url);
+
+                context.Response.Headers[HeaderNames.Location] = url;
+                context.Response.StatusCode = 301;
+                context.Response.Redirect(url);
+                return Task.CompletedTask;
+            }
+
+            return _next(context);
+        }
+    }
+}

src/Fan.Web/Middlewares/HttpWwwRewriter.cs

@@ -0,0 +1,67 @@
+using Fan.Enums;
+using Fan.Models;
+using Microsoft.Extensions.Logging;
+using System;
+using System.Linq;
+
+namespace Fan.Web.Middlewares
+{
+    public class HttpWwwRewriter : IHttpWwwRewriter
+    {
+        private ILogger<HttpWwwRewriter> _logger;
+        private bool _schemeRequireUpdate;
+        private bool _hostRequireWwwAddition;
+        private bool _hostRequireWwwRemoval;
+
+        public HttpWwwRewriter(ILogger<HttpWwwRewriter> logger)
+        {
+            _logger = logger;
+        }
+
+        /// <summary>
+        /// Returns true if request url requires a url rewrite based on appsettings, 
+        /// the out param url will be the new url to redirect to.
+        /// </summary>
+        /// <param name="appSettings"></param>
+        /// <param name="requestUrl"></param>
+        /// <param name="url"></param>
+        /// <returns></returns>
+        public bool ShouldRewrite(AppSettings appSettings, string requestUrl, out string url)
+        {
+            Uri uri = new Uri(requestUrl);
+            string host = uri.Authority; // host with port
+
+            // if useHttps is set to false, but the user is using https, that's ok
+            _schemeRequireUpdate = appSettings.UseHttps && uri.Scheme != "https";
+
+            // add www if domain does not start with www and domain has only 1 dot, 
+            // so yoursite.azurewebsites.net and localhost:1234 would disqualify it
+            _hostRequireWwwAddition = appSettings.PreferredDomain == EPreferredDomain.Www &&
+                                      !host.StartsWith("www.") &&
+                                      host.Count(s => s == '.') == 1;
+
+            // remove www if domain starts with www
+            _hostRequireWwwRemoval = appSettings.PreferredDomain == EPreferredDomain.NonWww && host.StartsWith("www.");
+
+            url = GetUrl(uri.Scheme, host, uri.PathAndQuery, uri.Fragment);
+            return _schemeRequireUpdate || _hostRequireWwwAddition || _hostRequireWwwRemoval;
+        }
+
+        private string GetUrl(string scheme, string host, string pathAndQuery, string fragment)
+        {
+            scheme = _schemeRequireUpdate ? "https" : scheme;
+
+            if (_hostRequireWwwAddition)
+            {
+                host = $"www.{host}";
+            }
+            else if (_hostRequireWwwRemoval)
+            {
+                int index = host.IndexOf("www.");
+                host = host.Remove(index, 4);
+            }
+
+            return $"{scheme}://{host}{pathAndQuery}{fragment}";
+        }
+    }
+}

src/Fan.Web/Middlewares/IHttpWwwRewriter.cs

@@ -0,0 +1,17 @@
+using Fan.Models;
+
+namespace Fan.Web.Middlewares
+{
+    public interface IHttpWwwRewriter
+    {
+        /// <summary>
+        /// Returns true if request url requires a url rewrite based on appsettings, 
+        /// the out param url will be the new url to redirect to.
+        /// </summary>
+        /// <param name="appSettings"></param>
+        /// <param name="requestUrl"></param>
+        /// <param name="url"></param>
+        /// <returns></returns>
+        bool ShouldRewrite(AppSettings appSettings, string requestUrl, out string url);
+    }
+}

src/Fan.Web/Startup.cs

@@ -1,9 +1,11 @@
 using AutoMapper;
 using Fan.Data;
+using Fan.Enums;
 using Fan.Helpers;
 using Fan.Models;
 using Fan.Services;
 using Fan.Web.MetaWeblog;
+using Fan.Web.Middlewares;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.Identity;
@@ -12,6 +14,7 @@
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
+using System;
 using System.IO;
 
 namespace Fan.Web
@@ -20,11 +23,11 @@ public class Startup
     {
         private ILogger<Startup> _logger;
 
-        public Startup(IConfiguration configuration, IHostingEnvironment env, ILoggerFactory loggerFactory)
+        public Startup(IConfiguration configuration, IHostingEnvironment env, ILogger<Startup> logger)
         {
             HostingEnvironment = env;
             Configuration = configuration;
-            _logger = loggerFactory.CreateLogger<Startup>();
+            _logger = logger;
         }
 
         public IConfiguration Configuration { get; }
@@ -35,8 +38,8 @@ public void ConfigureServices(IServiceCollection services)
             // Db
             services.AddDbContext<FanDbContext>(builder =>
             {
-                bool.TryParse(Configuration["Database:UseSqLite"], out bool useSqLite);
-                if (useSqLite)
+                Enum.TryParse(Configuration["AppSettings:Database"], ignoreCase: true, result: out ESupportedDatabase db);
+                if (db == ESupportedDatabase.Sqlite)
                 {
                     builder.UseSqlite("Data Source=" + Path.Combine(HostingEnvironment.ContentRootPath, "Fanray.sqlite"));
                     _logger.LogInformation("Using SQLite database.");
@@ -76,6 +79,7 @@ public void ConfigureServices(IServiceCollection services)
             services.AddScoped<IBlogService, BlogService>();
             services.AddScoped<IXmlRpcHelper, XmlRpcHelper>();
             services.AddScoped<IMetaWeblogService, MetaWeblogService>();
+            services.AddScoped<IHttpWwwRewriter, HttpWwwRewriter>();
             services.Configure<AppSettings>(Configuration.GetSection("AppSettings"));
 
             // Mvc
@@ -84,6 +88,9 @@ public void ConfigureServices(IServiceCollection services)
 
         public void Configure(IApplicationBuilder app, IHostingEnvironment env)
         {
+            // https and www rewrite
+            app.UseHttpWwwRewrite();
+
             // OLW
             app.MapWhen(context => context.Request.Path.ToString().Equals("/olw"), appBuilder => appBuilder.UseMetablog());
 

src/Fan.Web/appsettings.Production.json

@@ -1,6 +1,8 @@
 {
-  "Database": {
-    "UseSqLite": false
+  "AppSettings": {
+    "Database": "sqlserver",
+    "PreferredDomain": "www",
+    "UseHttps": true
   },
   "Serilog": {
     "Using": [ "Serilog.Sinks.RollingFile" ],

src/Fan.Web/appsettings.json

@@ -1,6 +1,9 @@
 {
-  "Database": {
-    "UseSqLite": true
+  "AppSettings": {
+    "Version": "1.0.0-alpha",
+    "Database": "sqlite",
+    "PreferredDomain": "auto",
+    "UseHttps": false
   },
   "ConnectionStrings": {
     "DefaultConnection": "Server=.\\sql2016;Database=Fanray;Trusted_Connection=True;MultipleActiveResultSets=true"

src/Fan/Models/AppSettings.cs

@@ -40,6 +40,8 @@ public class AppSettings
         /// 
         /// Note if user sets this value to false but is already using https, I don't downgrade 
         /// you to http as this is good for SEO, Google strongly recommend all website to use https.
+        /// Also if you are running locally with console, set this value to false as console may 
+        /// not support https.
         /// </remarks>
         public bool UseHttps { get; set; }
     }

test/Fan.Web.Tests/Middlewares/HttpWwwRewriterTest.cs

@@ -0,0 +1,145 @@
+using Fan.Enums;
+using Fan.Models;
+using Fan.Web.Middlewares;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using Xunit;
+
+namespace Fan.Web.Tests.UrlRewrite
+{
+    public class AppSettingsTestData : IEnumerable<object[]>
+    {
+        private readonly List<object[]> _data = new List<object[]>
+        {
+            new object[] {
+                new AppSettings { PreferredDomain = EPreferredDomain.Www, UseHttps = true },
+                "http://test.com/about?name=john&age=10",
+                true,
+                "https://www.test.com/about?name=john&age=10"
+            },
+            new object[] {
+                new AppSettings { PreferredDomain = EPreferredDomain.Www, UseHttps = true },
+                "https://www.test.com/about?name=john",
+                false, // when the url is already correct, I don't do redirect
+                "https://www.test.com/about?name=john"
+            },
+            new object[] {
+                new AppSettings { PreferredDomain = EPreferredDomain.Www, UseHttps = false },
+                "http://test.com/about?name=john",
+                true,
+                "http://www.test.com/about?name=john"
+            },
+            new object[] {
+                new AppSettings { PreferredDomain = EPreferredDomain.Www, UseHttps = false }, // when UseHttps is set to false
+                "https://www.test.com/about?name=john", // but user is using https, the recommended way
+                false, // I don't do redirect
+                "https://www.test.com/about?name=john"  // I don't downgrade you
+            },
+            // --------------------------------------------------- nonwww tests
+            new object[] {
+                new AppSettings { PreferredDomain = EPreferredDomain.NonWww, UseHttps = true },
+                "http://www.test.com/about?name=john",
+                true,
+                "https://test.com/about?name=john"
+            },
+            new object[] {
+                new AppSettings { PreferredDomain = EPreferredDomain.NonWww, UseHttps = true },
+                "https://test.com/about?name=john",
+                false, // when the url is already correct, we don't do redirect
+                "https://test.com/about?name=john"
+            },
+            new object[] {
+                new AppSettings { PreferredDomain = EPreferredDomain.NonWww, UseHttps = false },
+                "http://www.test.com/about?name=john",
+                true,
+                "http://test.com/about?name=john"
+            },
+            new object[] {
+                new AppSettings { PreferredDomain = EPreferredDomain.NonWww, UseHttps = false }, // when UseHttps is set to false
+                "https://test.com/about?name=john", // but user is using https, the recommended way
+                false, // I don't do redirect
+                "https://test.com/about?name=john"  // I don't downgrade you
+            },
+            // -------------------------------------------------- www / nonwww setting makes no effect if subdomain is other than www
+            new object[] {
+                new AppSettings { PreferredDomain = EPreferredDomain.Www, UseHttps = true },
+                "http://plus.google.com/+John/posts/BPn85MDmCSL",
+                true,
+                "https://plus.google.com/+John/posts/BPn85MDmCSL"
+            },
+            new object[] {
+                new AppSettings { PreferredDomain = EPreferredDomain.Www, UseHttps = true },
+                "https://plus.google.com/+John/posts/BPn85MDmCSL",
+                false,
+                "https://plus.google.com/+John/posts/BPn85MDmCSL"
+            },
+            new object[] {
+                new AppSettings { PreferredDomain = EPreferredDomain.NonWww, UseHttps = true },
+                "http://blog.test.com/#resource/sub/af-6f/res/ft.eb/site",
+                true,
+                "https://blog.test.com/#resource/sub/af-6f/res/ft.eb/site",
+            },
+            // --------------------------------------------------- auto
+             new object[] {
+                new AppSettings { PreferredDomain = EPreferredDomain.Auto, UseHttps = true },
+                "http://plus.google.com/+John/posts/BPn85MDmCSL",
+                true,
+                "https://plus.google.com/+John/posts/BPn85MDmCSL"
+            },
+             new object[] {
+                new AppSettings { PreferredDomain = EPreferredDomain.Auto, UseHttps = false },
+                "http://plus.google.com/+John/posts/BPn85MDmCSL",
+                false,
+                "http://plus.google.com/+John/posts/BPn85MDmCSL"
+            },
+        };
+
+        public IEnumerator<object[]> GetEnumerator() => _data.GetEnumerator();
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+    }
+
+    public class HttpWwwRewriterTest
+    {
+        private IHttpWwwRewriter _helper;
+        public HttpWwwRewriterTest()
+        {
+            var serviceProvider = new ServiceCollection().AddLogging().BuildServiceProvider();
+            var loggerFactory = serviceProvider.GetService<ILoggerFactory>();
+            _helper = new HttpWwwRewriter(loggerFactory.CreateLogger<HttpWwwRewriter>());
+        }
+
+        [Theory]
+        [ClassData(typeof(AppSettingsTestData))]
+        public void ShouldRewriteTest(AppSettings appSettings, string requestUrl, bool expectedShould, string expectedUrl)
+        {
+            bool should = _helper.ShouldRewrite(appSettings, requestUrl, out string url);
+            Assert.Equal(expectedShould, should);
+            Assert.Equal(expectedUrl, url);
+        }
+
+        /// <summary>
+        /// Test <see cref="Uri"/> class, I use this class as a parser and it's important to 
+        /// understand what it does.
+        /// </summary>
+        [Fact]
+        public void TestUri()
+        {
+            Uri uri = new Uri("http://test.com/about?name=john&age=10#abc");
+            Assert.Equal("/about", uri.AbsolutePath);
+            Assert.Equal("http://test.com/about?name=john&age=10#abc", uri.AbsoluteUri);
+            Assert.Equal("test.com", uri.Authority);
+            Assert.Equal("test.com", uri.DnsSafeHost);
+            Assert.Equal("#abc", uri.Fragment);
+            Assert.Equal("test.com", uri.Host);
+            Assert.Equal("http://test.com/about?name=john&age=10#abc", uri.OriginalString);
+            Assert.Equal("/about?name=john&age=10", uri.PathAndQuery);
+            Assert.Equal(80, uri.Port);
+            Assert.Equal("?name=john&age=10", uri.Query);
+            Assert.Equal("http", uri.Scheme);
+            Assert.Equal(2, uri.Segments.Length);
+        }
+    }
+}