Remove query parameter when recording clicked url

Author: linkdotnet

LinkDotNet.Blog.IntegrationTests/Web/Pages/Admin/Dashboard/VisitCountPerPageTests.cs

@@ -0,0 +1,37 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Bunit;
+using FluentAssertions;
+using LinkDotNet.Blog.TestUtilities;
+using LinkDotNet.Blog.Web.Shared.Admin.Dashboard;
+using LinkDotNet.Domain;
+using LinkDotNet.Infrastructure.Persistence;
+using Microsoft.Extensions.DependencyInjection;
+using Xunit;
+
+namespace LinkDotNet.Blog.IntegrationTests.Web.Pages.Admin.Dashboard
+{
+    public class VisitCountPerPageTests : SqlDatabaseTestBase<BlogPost>
+    {
+        [Fact]
+        public async Task ShouldShowCounts()
+        {
+            var blogPost = new BlogPostBuilder().WithTitle("I was clicked").Build();
+            await Repository.StoreAsync(blogPost);
+            using var ctx = new TestContext();
+            ctx.Services.AddScoped<IRepository<BlogPost>>(_ => Repository);
+            var visits = new List<KeyValuePair<string, int>>();
+            visits.Add(new KeyValuePair<string, int>($"blogPost/{blogPost.Id}", 5));
+            var pageVisitCounts = visits.OrderByDescending(s => s.Value);
+
+            var cut = ctx.RenderComponent<VisitCountPerPage>(p => p.Add(
+                s => s.PageVisitCount, pageVisitCounts));
+
+            cut.WaitForState(() => cut.FindAll("td").Any());
+            var elements = cut.FindAll("td").Select(t => t.InnerHtml).ToList();
+            elements.Should().Contain("I was clicked");
+            elements.Should().Contain("5");
+        }
+    }
+}

LinkDotNet.Blog.UnitTests/Web/Shared/UserRecordServiceTests.cs

@@ -7,7 +7,6 @@
 using LinkDotNet.Blog.Web.Shared;
 using LinkDotNet.Domain;
 using LinkDotNet.Infrastructure.Persistence;
-using Microsoft.Extensions.Logging;
 using Moq;
 using Xunit;
 
@@ -31,15 +30,14 @@ public UserRecordServiceTests()
                 repositoryMock.Object,
                 fakeNavigationManager,
                 fakeAuthenticationStateProvider,
-                localStorageService.Object,
-                new Mock<ILogger>().Object);
+                localStorageService.Object);
         }
 
         [Fact]
         public async Task ShouldStoreInformation()
         {
-            const string Url = "http://localhost/subpart";
-            fakeNavigationManager.NavigateTo(Url);
+            const string url = "http://localhost/subpart";
+            fakeNavigationManager.NavigateTo(url);
             UserRecord recordToDb = null;
             repositoryMock.Setup(r => r.StoreAsync(It.IsAny<UserRecord>()))
                 .Callback<UserRecord>(u => recordToDb = u);
@@ -90,5 +88,21 @@ public async Task ShouldNotThrowExceptionToOutsideWorld()
 
             await act.Should().NotThrowAsync<Exception>();
         }
+
+        [InlineData("http://localhost/blogPost/12?q=3", "blogPost/12")]
+        [InlineData("http://localhost/?q=3", "")]
+        [Theory]
+        public async Task ShouldRemoveQueryStringIfPresent(string url, string expectedRecord)
+        {
+            fakeNavigationManager.NavigateTo(url);
+            UserRecord recordToDb = null;
+            repositoryMock.Setup(r => r.StoreAsync(It.IsAny<UserRecord>()))
+                .Callback<UserRecord>(u => recordToDb = u);
+
+            await sut.StoreUserRecordAsync();
+
+            recordToDb.Should().NotBeNull();
+            recordToDb.UrlClicked.Should().Be(expectedRecord);
+        }
     }
 }

LinkDotNet.Blog.Web/Shared/UserRecordService.cs

@@ -1,11 +1,11 @@
 using System;
+using System.Diagnostics;
 using System.Threading.Tasks;
 using Blazored.LocalStorage;
 using LinkDotNet.Domain;
 using LinkDotNet.Infrastructure.Persistence;
 using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.Components.Authorization;
-using Microsoft.Extensions.Logging;
 
 namespace LinkDotNet.Blog.Web.Shared
 {
@@ -20,35 +20,32 @@ public class UserRecordService : IUserRecordService
         private readonly NavigationManager navigationManager;
         private readonly AuthenticationStateProvider authenticationStateProvider;
         private readonly ILocalStorageService localStorageService;
-        private readonly ILogger logger;
 
         public UserRecordService(
             IRepository<UserRecord> userRecordRepository,
             NavigationManager navigationManager,
             AuthenticationStateProvider authenticationStateProvider,
-            ILocalStorageService localStorageService,
-            ILogger logger)
+            ILocalStorageService localStorageService)
         {
             this.userRecordRepository = userRecordRepository;
             this.navigationManager = navigationManager;
             this.authenticationStateProvider = authenticationStateProvider;
             this.localStorageService = localStorageService;
-            this.logger = logger;
         }
 
         public async Task StoreUserRecordAsync()
         {
             try
             {
-                await GetAndStoreUSerRecordAsync();
+                await GetAndStoreUserRecordAsync();
             }
             catch (Exception e)
             {
-                logger.Log(LogLevel.Error, e, "Couldn't write user record");
+                Trace.Write($"Exception: {e}");
             }
         }
 
-        private async Task GetAndStoreUSerRecordAsync()
+        private async Task GetAndStoreUserRecordAsync()
         {
             var userIdentity = (await authenticationStateProvider.GetAuthenticationStateAsync()).User.Identity;
             if (userIdentity == null || userIdentity.IsAuthenticated)
@@ -58,11 +55,13 @@ private async Task GetAndStoreUSerRecordAsync()
 
             var identifierHash = await GetIdentifierHashAsync();
 
+            var url = GetClickedUrl();
+
             var record = new UserRecord
             {
                 UserIdentifierHash = identifierHash,
                 DateTimeUtcClicked = DateTime.UtcNow,
-                UrlClicked = navigationManager.ToBaseRelativePath(navigationManager.Uri),
+                UrlClicked = url,
             };
 
             await userRecordRepository.StoreAsync(record);
@@ -81,5 +80,18 @@ private async Task<int> GetIdentifierHashAsync()
             await localStorageService.SetItemAsync("user", id);
             return id.GetHashCode();
         }
+
+        private string GetClickedUrl()
+        {
+            var basePath = navigationManager.ToBaseRelativePath(navigationManager.Uri);
+
+            if (string.IsNullOrEmpty(basePath))
+            {
+                return string.Empty;
+            }
+
+            var queryIndex = basePath.IndexOf('?');
+            return queryIndex <= 0 ? basePath[..(queryIndex - 1)] : basePath;
+        }
     }
 }