Merge pull request #23 from patrickdemooij9/feature/ImageRedirects

Allow for media redirects

source/SimpleRedirects.Core/Components/DatabaseUpgradeComponent.cs

@@ -1,5 +1,6 @@
 using Microsoft.Extensions.Logging;
 using SimpleRedirects.Core.Migrations;
+using Umbraco.Cms.Core;
 using Umbraco.Cms.Core.Composing;
 using Umbraco.Cms.Core.Migrations;
 using Umbraco.Cms.Core.Scoping;
@@ -13,17 +14,21 @@ public class DatabaseUpgradeComponent : IComponent
     {
         private readonly IScopeProvider _scopeProvider;
         private readonly IKeyValueService _keyValueService;
+        private readonly IRuntimeState _runtimeState;
         private readonly IMigrationPlanExecutor _migrationPlanExecutor;
 
-        public DatabaseUpgradeComponent(IMigrationPlanExecutor migrationPlanExecutor, IScopeProvider scopeProvider, IKeyValueService keyValueService)
+        public DatabaseUpgradeComponent(IMigrationPlanExecutor migrationPlanExecutor, IScopeProvider scopeProvider, IKeyValueService keyValueService, IRuntimeState runtimeState)
         {
             _migrationPlanExecutor = migrationPlanExecutor;
             _scopeProvider = scopeProvider;
             _keyValueService = keyValueService;
+            _runtimeState = runtimeState;
         }
 
         public void Initialize()
         {
+            if (_runtimeState.Level != RuntimeLevel.Run) return;
+
             var plan = new MigrationPlan("SimpleRedirectsMigration");
             plan.From(string.Empty)
                 .To<InitialMigration>("state-1")

source/SimpleRedirects.Core/Middleware/SimpleRedirectsMiddleware.cs

@@ -0,0 +1,91 @@
+using System;
+using System.Net;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Http.Extensions;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using SimpleRedirects.Core.Options;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Web;
+
+namespace SimpleRedirects.Core.Middleware
+{
+    public class SimpleRedirectsMiddleware
+    {
+        private readonly RequestDelegate _next;
+        private readonly RedirectRepository _redirectRepository;
+        private readonly IRuntimeState _runtimeState;
+        private readonly IUmbracoContextAccessor _umbracoContextAccessor;
+
+        private SimpleRedirectsOptions _config;
+
+        public SimpleRedirectsMiddleware(RequestDelegate next,
+            RedirectRepository redirectRepository,
+            IRuntimeState runtimeState,
+            IUmbracoContextAccessor umbracoContextAccessor,
+            IOptionsMonitor<SimpleRedirectsOptions> options)
+        {
+            _next = next;
+            _redirectRepository = redirectRepository;
+            _runtimeState = runtimeState;
+            _umbracoContextAccessor = umbracoContextAccessor;
+            _config = options.CurrentValue;
+            options.OnChange((newValue) => _config = newValue);
+        }
+
+        public async Task Invoke(HttpContext context)
+        {
+            if (_runtimeState.Level != RuntimeLevel.Run)
+            {
+                await _next.Invoke(context);
+                return;
+            }
+
+            var pathAndQuery = context.Request.GetEncodedPathAndQuery();
+
+            if (pathAndQuery.IndexOf("/umbraco", StringComparison.InvariantCultureIgnoreCase) == 0)
+            {
+                await _next(context);
+                return;
+            }
+
+            if (_config.OnlyRedirectOn404)
+            {
+                context.Response.OnStarting(() =>
+                {
+                    if (context.Response.StatusCode != (int)HttpStatusCode.NotFound)
+                    {
+                        return Task.CompletedTask;
+                    }
+
+                    HandleRedirect(context);
+                    return Task.CompletedTask;
+                });
+                await _next(context);
+            }
+            else
+            {
+                if (!HandleRedirect(context))
+                {
+                    await _next(context);
+                }
+            }
+        }
+
+        private bool HandleRedirect(HttpContext context)
+        {
+            var url = new Uri(context.Request.GetEncodedUrl());
+            var matchedRedirect = _redirectRepository.FindRedirect(url);
+            if (matchedRedirect == null)
+            {
+                return false;
+            };
+
+            var isPerm = matchedRedirect.RedirectCode == (int)HttpStatusCode.MovedPermanently;
+            context.Response.Redirect(matchedRedirect.GetNewUrl(url), isPerm);
+            return true;
+        }
+    }
+}

source/SimpleRedirects.Core/Options/SimpleRedirectsOptions.cs

@@ -6,5 +6,6 @@ public class SimpleRedirectsOptions
 
         public bool CacheEnabled {get; set;} = true;
         public int CacheDuration {get; set;} = 86400;
+        public bool OnlyRedirectOn404 { get; set; } = false;
     }
 }

source/SimpleRedirects.Core/RedirectUserComposer.cs

@@ -1,28 +1,48 @@
 using System.Configuration;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using SimpleRedirects.Core.Components;
+using SimpleRedirects.Core.Middleware;
 using SimpleRedirects.Core.Options;
 using SimpleRedirects.Core.Utilities.Caching;
 using Umbraco.Cms.Core.Composing;
 using Umbraco.Cms.Core.DependencyInjection;
 using Umbraco.Cms.Core.Routing;
+using Umbraco.Cms.Web.Common.ApplicationBuilder;
 using Umbraco.Extensions;
 
 namespace SimpleRedirects.Core
 {
-    public class RedirectUserComposer : IUserComposer
+    public class RedirectUserComposer : IComposer
     {
         public void Compose(IUmbracoBuilder builder)
         {
             builder.Dashboards().Add<RedirectDashboard>();
             builder.Components().Append<DatabaseUpgradeComponent>();
-            builder.ContentFinders().InsertBefore<ContentFinderByUrl, RedirectContentFinder>();
 
             builder.Services.AddUnique<RedirectRepository>();
             builder.Services.AddUnique<ICacheManager, CacheManager>();
 
             builder.Services.Configure<SimpleRedirectsOptions>(builder.Config.GetSection(
-                                        SimpleRedirectsOptions.Position));
+                SimpleRedirectsOptions.Position));
+            var onlyRedirectOn404 = builder.Config.GetSection(SimpleRedirectsOptions.Position)?.Get<SimpleRedirectsOptions>()?.OnlyRedirectOn404 ?? false;
+
+            builder.Services.Configure<UmbracoPipelineOptions>(options => {
+                options.AddFilter(new UmbracoPipelineFilter(
+                    "SimpleRedirects",
+                    applicationBuilder =>
+                    {
+                        if (!onlyRedirectOn404)
+                            applicationBuilder.UseMiddleware<SimpleRedirectsMiddleware>();
+                    },
+                    applicationBuilder => {
+                        if (onlyRedirectOn404)
+                            applicationBuilder.UseMiddleware<SimpleRedirectsMiddleware>();
+                    },
+                    applicationBuilder => { }
+                ));
+            });
         }
     }
 }

source/SimpleRedirects.Site/appsettings.json

@@ -10,7 +10,7 @@
     }
   },
   "ConnectionStrings": {
-    "umbracoDbDSN": "Data Source=|DataDirectory|\\Umbraco.sdf;Flush Interval=1;"
+    "umbracoDbDSN": "Data Source=(localdb)\\MSSQLLocalDB;AttachDbFilename=|DataDirectory|\\Umbraco.mdf;Integrated Security=True"
   },
   "Umbraco": {
     "CMS": {
@@ -21,5 +21,10 @@
         "Id": "4d3183bb-a9d5-4f96-b2eb-8d875dcaa0c1"
       }
     }
-  }
+  },
+  "SimpleRedirects": {
+    "CacheEnabled": true,
+    "CacheDuration": 86400, 
+    "OnlyRedirectOn404": false
+  } 
 }