Merge pull request #137 from Geta/feature/filtering-improvements

Feature/filtering improvements & fixes

Author: kaspars-ozols

src/Geta.Optimizely.Sitemaps/Areas/GetaOptimizelySitemaps/Pages/Shared/_Layout.cshtml

@@ -38,11 +38,15 @@
                 </div>
                 <div>
                     <span class="fw-bold">Paths to include:</span>
-                    Sitemap will contain only pages from this virtual directory url. Separate multiple with ";".
+                    Include only pages whose URL starts with one of the given values.
+                    Separate multiple values with a semicolon (e.g., /en/blog;/en/guides).
+                    If left empty, no filtering will be applied.
                 </div>
                 <div>
                     <span class="fw-bold">Paths to avoid:</span>
-                    Sitemap will not contain pages from this virtual directory url (works only if "Directory to include" left blank). Separate multiple with ";".
+                    Exclude pages whose URL starts with one of the given values.
+                    Separate multiple values with a semicolon (e.g., /en/locations;/en/destinations).
+                    If left empty, no filtering will be applied.
                 </div>
                 <div>
                     <span class="fw-bold">Root page ID:</span>

src/Geta.Optimizely.Sitemaps/Utils/UrlFilter.cs

@@ -8,63 +8,54 @@
 namespace Geta.Optimizely.Sitemaps.Utils
 {
     /// <summary>
-    /// Administrators are able to specify specific paths to exclude (blacklist) or include (whitelist) in sitemaps.
+    /// Administrators are able to specify specific paths to include (whitelist) or exclude (blacklist) in sitemaps.
     /// This class is used to check this.
     /// </summary>
     public static class UrlFilter
     {
         public static bool IsUrlFiltered(string url, SitemapData sitemapConfig)
         {
-            var whiteList = sitemapConfig.PathsToInclude;
-            var blackList = sitemapConfig.PathsToAvoid;
-
-            return IsNotInWhiteList(url, whiteList) || IsInBlackList(url, blackList);
+            // URL is removed if it fails whitelist or fails blacklist checks
+            return !IsAllowedByWhitelist(url, sitemapConfig.PathsToInclude) ||
+                   !IsAllowedByBlacklist(url, sitemapConfig.PathsToAvoid);
         }
 
-        private static bool IsNotInWhiteList(string url, IList<string> paths)
+        private static bool IsAllowedByWhitelist(string url, IList<string> whitelist)
         {
-            return IsPathInUrl(url, paths, true);
-        }
+            if (whitelist == null || whitelist.Count == 0)
+            {
+                // if whitelist is empty, then everything is allowed
+                return true; 
+            }
 
-        private static bool IsInBlackList(string url, IList<string> paths)
-        {
-            return IsPathInUrl(url, paths, false);
+            // otherwise - url has to match at least one path
+            return whitelist.Any(path => IsMatch(url, path));
         }
 
-        private static bool IsPathInUrl(string url, ICollection<string> paths, bool mustContainPath)
+        private static bool IsAllowedByBlacklist(string url, IList<string> blacklist)
         {
-            if (paths == null || paths.Count <= 0)
+            if (blacklist == null || blacklist.Count == 0)
             {
-                return false;
+                // if blacklist is empty, then everything is allowed
+                return true; 
             }
 
-            var anyPathIsInUrl = paths.Any(x =>
-            {
-                var dir = AddStartSlash(AddTailingSlash(x.ToLower().Trim()));
-                return url.ToLower().StartsWith(dir);
-            });
-
-            return anyPathIsInUrl != mustContainPath;
+            // otherwise - url is not allowed if it matches any of the paths 
+            return !blacklist.Any(path => IsMatch(url, path));
         }
 
-        private static string AddTailingSlash(string url)
+        private static bool IsMatch(string url, string path)
         {
-            if (!url.EndsWith('/'))
-            {
-                url += "/";
-            }
-
-            return url;
+            var normalizedUrl = Normalize(url);
+            var normalizedPath = Normalize(path);
+            return normalizedUrl.StartsWith(normalizedPath);
         }
 
-        private static string AddStartSlash(string url)
+        private static string Normalize(string value)
         {
-            if (!url.StartsWith('/'))
-            {
-                url = "/" + url;
-            }
+            var transformedValue = value?.ToLower().Trim().TrimStart('/').TrimEnd('/');
 
-            return url;
+            return string.IsNullOrWhiteSpace(transformedValue) ? "/" : $"/{transformedValue}/";
         }
     }
 }