Added BackgroundService and Validation

Author: linkdotnet

src/LinkDotNet.Blog.Domain/BlogPost.cs

@@ -22,9 +22,11 @@ private BlogPost()
 
     public DateTime UpdatedDate { get; private set; }
 
+    public DateTime? ScheduledPublishDate { get; private set; }
+
     public virtual ICollection<Tag> Tags { get; private set; }
 
-    public bool IsPublished { get; set; }
+    public bool IsPublished { get; private set; }
 
     public int Likes { get; set; }
 
@@ -35,15 +37,22 @@ public static BlogPost Create(
         string previewImageUrl,
         bool isPublished,
         DateTime? updatedDate = null,
+        DateTime? scheduledPublishDate = null,
         IEnumerable<string> tags = null,
         string previewImageUrlFallback = null)
     {
+        if (scheduledPublishDate is not null && isPublished)
+        {
+            throw new InvalidOperationException("Can't schedule publish date if the blog post is already published.");
+        }
+
         var blogPost = new BlogPost
         {
             Title = title,
             ShortDescription = shortDescription,
             Content = content,
             UpdatedDate = updatedDate ?? DateTime.Now,
+            ScheduledPublishDate = scheduledPublishDate,
             PreviewImageUrl = previewImageUrl,
             PreviewImageUrlFallback = previewImageUrlFallback,
             IsPublished = isPublished,
@@ -53,6 +62,17 @@ public static BlogPost Create(
         return blogPost;
     }
 
+    public void Publish()
+    {
+        if (ScheduledPublishDate is not null)
+        {
+            UpdatedDate = ScheduledPublishDate.Value;
+            ScheduledPublishDate = null;
+        }
+
+        IsPublished = true;
+    }
+
     public void Update(BlogPost from)
     {
         if (from == this)
@@ -64,6 +84,7 @@ public void Update(BlogPost from)
         ShortDescription = from.ShortDescription;
         Content = from.Content;
         UpdatedDate = from.UpdatedDate;
+        ScheduledPublishDate = from.ScheduledPublishDate;
         PreviewImageUrl = from.PreviewImageUrl;
         PreviewImageUrlFallback = from.PreviewImageUrlFallback;
         IsPublished = from.IsPublished;
@@ -85,4 +106,4 @@ private void ReplaceTags(IEnumerable<Tag> tags)
             }
         }
     }
-}
+}

src/LinkDotNet.Blog.Web/Features/Admin/BlogPostEditor/Components/CreateNewModel.cs

@@ -17,6 +17,7 @@ public class CreateNewModel
     private bool shouldUpdateDate;
     private string tags;
     private string previewImageUrlFallback;
+    private DateTime? scheduledPublishDate;
 
     [Required]
     [MaxLength(256)]
@@ -65,6 +66,7 @@ public string PreviewImageUrl
     }
 
     [Required]
+    [PublishedWithScheduledDateValidation]
     public bool IsPublished
     {
         get => isPublished;
@@ -86,6 +88,16 @@ public bool ShouldUpdateDate
         }
     }
 
+    public DateTime? ScheduledPublishDate
+    {
+        get => scheduledPublishDate;
+        set
+        {
+            scheduledPublishDate = value;
+            IsDirty = true;
+        }
+    }
+
     public string Tags
     {
         get => tags;
@@ -123,6 +135,7 @@ public static CreateNewModel FromBlogPost(BlogPost blogPost)
             PreviewImageUrl = blogPost.PreviewImageUrl,
             originalUpdatedDate = blogPost.UpdatedDate,
             PreviewImageUrlFallback = blogPost.PreviewImageUrlFallback,
+            ScheduledPublishDate = blogPost.ScheduledPublishDate,
             IsDirty = false,
         };
     }
@@ -134,7 +147,16 @@ public BlogPost ToBlogPost()
             ? null
             : originalUpdatedDate;
 
-        var blogPost = BlogPost.Create(Title, ShortDescription, Content, PreviewImageUrl, IsPublished, updatedDate, tagList, PreviewImageUrlFallback);
+        var blogPost = BlogPost.Create(
+            Title,
+            ShortDescription,
+            Content,
+            PreviewImageUrl,
+            IsPublished,
+            updatedDate,
+            scheduledPublishDate,
+            tagList,
+            PreviewImageUrlFallback);
         blogPost.Id = id;
         return blogPost;
     }

src/LinkDotNet.Blog.Web/Features/Admin/BlogPostEditor/Components/PublishedWithScheduledDateValidationAttribute.cs

@@ -0,0 +1,18 @@
+using System;
+using System.ComponentModel.DataAnnotations;
+
+namespace LinkDotNet.Blog.Web.Features.Admin.BlogPostEditor.Components;
+
+[AttributeUsage(AttributeTargets.Property)]
+public sealed class PublishedWithScheduledDateValidationAttribute : ValidationAttribute
+{
+    protected override ValidationResult IsValid(object value, ValidationContext validationContext)
+    {
+        if (validationContext.ObjectInstance is CreateNewModel { IsPublished: true, ScheduledPublishDate: { } })
+        {
+            return new ValidationResult("Cannot have a scheduled publish date when the post is already published.");
+        }
+
+        return ValidationResult.Success;
+    }
+}

src/LinkDotNet.Blog.Web/Features/BlogPostPublisher.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using LinkDotNet.Blog.Domain;
+using LinkDotNet.Blog.Infrastructure.Persistence;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+
+namespace LinkDotNet.Blog.Web.Features;
+
+public class BlogPostPublisher : BackgroundService
+{
+    private readonly IServiceProvider serviceProvider;
+    private readonly ILogger<BlogPostPublisher> logger;
+
+    public BlogPostPublisher(IServiceProvider serviceProvider, ILogger<BlogPostPublisher> logger)
+    {
+        this.serviceProvider = serviceProvider;
+        this.logger = logger;
+    }
+
+    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+    {
+        // await Task.Yield();
+        logger.LogInformation("BlogPostPublisher is starting.");
+
+        using var timer = new PeriodicTimer(TimeSpan.FromHours(1));
+
+        while (!stoppingToken.IsCancellationRequested)
+        {
+            await PublishScheduledBlogPosts();
+
+            await timer.WaitForNextTickAsync(stoppingToken);
+        }
+
+        logger.LogInformation("BlogPostPublisher is stopping.");
+    }
+
+    private async Task PublishScheduledBlogPosts()
+    {
+        logger.LogInformation("Checking for scheduled blog posts.");
+
+        using var scope = serviceProvider.CreateScope();
+        var repository = scope.ServiceProvider.GetRequiredService<IRepository<BlogPost>>();
+
+        var now = DateTime.UtcNow;
+        var scheduledBlogPosts = await repository.GetAllAsync(
+            filter: b => b.ScheduledPublishDate != null && b.ScheduledPublishDate <= now);
+
+        foreach (var blogPost in scheduledBlogPosts)
+        {
+            blogPost.Publish();
+            await repository.StoreAsync(blogPost);
+            logger.LogInformation("Published blog post with ID {BlogPostId}", blogPost.Id);
+        }
+    }
+}

src/LinkDotNet.Blog.Web/Program.cs

@@ -1,6 +1,7 @@
 using Blazored.Toast;
 using LinkDotNet.Blog.Web.Authentication.Auth0;
 using LinkDotNet.Blog.Web.Authentication.Dummy;
+using LinkDotNet.Blog.Web.Features;
 using LinkDotNet.Blog.Web.RegistrationExtensions;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.Extensions.DependencyInjection;
@@ -34,6 +35,7 @@ private static void RegisterServices(WebApplicationBuilder builder)
         builder.Services.RegisterServices();
         builder.Services.AddStorageProvider(builder.Configuration);
         builder.Services.AddResponseCompression();
+        builder.Services.AddHostedService<BlogPostPublisher>();
 
         if (builder.Environment.IsDevelopment())
         {
@@ -73,4 +75,4 @@ private static void ConfigureApp(WebApplication app)
         app.MapFallbackToPage("/searchByTag/{tag}", "/_Host");
         app.MapFallbackToPage("/search/{searchTerm}", "/_Host");
     }
-}
+}

tests/LinkDotNet.Blog.IntegrationTests/Web/Features/BlogPostPublisherTests.cs

@@ -0,0 +1,45 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using LinkDotNet.Blog.Domain;
+using LinkDotNet.Blog.IntegrationTests;
+using LinkDotNet.Blog.TestUtilities;
+using LinkDotNet.Blog.Web.Features;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+
+namespace LinkDotNet.Blog.UnitTests.Web.Features;
+
+public sealed class BlogPostPublisherTests : SqlDatabaseTestBase<BlogPost>, IDisposable
+{
+    private readonly BlogPostPublisher sut;
+
+    public BlogPostPublisherTests()
+    {
+        var serviceProvider = new ServiceCollection()
+            .AddScoped(_ => Repository)
+            .BuildServiceProvider();
+
+        sut = new BlogPostPublisher(serviceProvider, Mock.Of<ILogger<BlogPostPublisher>>());
+    }
+
+    [Fact]
+    public async Task ShouldPublishScheduledBlogPosts()
+    {
+        var now = DateTime.UtcNow;
+        var bp1 = new BlogPostBuilder().WithScheduledPublishDate(now.AddHours(-2)).IsPublished(false).Build();
+        var bp2 = new BlogPostBuilder().WithScheduledPublishDate(now.AddHours(-1)).IsPublished(false).Build();
+        var bp3 = new BlogPostBuilder().WithScheduledPublishDate(now.AddHours(1)).IsPublished(false).Build();
+        await Repository.StoreAsync(bp1);
+        await Repository.StoreAsync(bp2);
+        await Repository.StoreAsync(bp3);
+
+        await sut.StartAsync(CancellationToken.None);
+
+        (await Repository.GetByIdAsync(bp1.Id)).IsPublished.Should().BeTrue();
+        (await Repository.GetByIdAsync(bp2.Id)).IsPublished.Should().BeTrue();
+        (await Repository.GetByIdAsync(bp3.Id)).IsPublished.Should().BeFalse();
+    }
+
+    public void Dispose() => sut?.Dispose();
+}

tests/LinkDotNet.Blog.TestUtilities/BlogPostBuilder.cs

@@ -14,6 +14,7 @@ public class BlogPostBuilder
     private string[] tags;
     private int likes;
     private DateTime? updateDate;
+    private DateTime? scheduledPublishDate;
 
     public BlogPostBuilder WithTitle(string title)
     {
@@ -69,9 +70,24 @@ public BlogPostBuilder WithUpdatedDate(DateTime updateDate)
         return this;
     }
 
+    public BlogPostBuilder WithScheduledPublishDate(DateTime scheduledPublishDate)
+    {
+        this.scheduledPublishDate = scheduledPublishDate;
+        return this;
+    }
+
     public BlogPost Build()
     {
-        var blogPost = BlogPost.Create(title, shortDescription, content, previewImageUrl, isPublished, updateDate, tags, previewImageUrlFallback);
+        var blogPost = BlogPost.Create(
+            title,
+            shortDescription,
+            content,
+            previewImageUrl,
+            isPublished,
+            updateDate,
+            scheduledPublishDate,
+            tags,
+            previewImageUrlFallback);
         blogPost.Likes = likes;
         return blogPost;
     }

tests/LinkDotNet.Blog.UnitTests/Domain/BlogPostTests.cs

@@ -69,4 +69,25 @@ public void ShouldNotDeleteTagsWhenSameReference()
         bp.Tags.Should().HaveCount(1);
         bp.Tags.Single().Content.Should().Be("tag 1");
     }
-}
+
+    [Fact]
+    public void ShouldPublishBlogPost()
+    {
+        var date = new DateTime(2023, 3, 24);
+        var bp = new BlogPostBuilder().IsPublished(false).WithScheduledPublishDate(date).Build();
+
+        bp.Publish();
+
+        bp.IsPublished.Should().BeTrue();
+        bp.ScheduledPublishDate.Should().BeNull();
+        bp.UpdatedDate.Should().Be(date);
+    }
+
+    [Fact]
+    public void ShouldThrowErrorWhenCreatingBlogPostThatIsPublishedAndHasScheduledPublishDate()
+    {
+        Action action = () => BlogPost.Create("1", "2", "3", "4", true, scheduledPublishDate: new DateTime(2023, 3, 24));
+
+        action.Should().Throw<InvalidOperationException>();
+    }
+}

tests/LinkDotNet.Blog.UnitTests/Web/Features/Admin/BlogPostEditor/Components/PublishedWithScheduledDateValidationAttributeTests.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using LinkDotNet.Blog.Web.Features.Admin.BlogPostEditor.Components;
+
+namespace LinkDotNet.Blog.UnitTests.Web.Features.Admin.BlogPostEditor.Components;
+
+public class PublishedWithScheduledDateValidationAttributeTests
+{
+    [Fact]
+    public void GivenBlogPostIsPublishedAndHasScheduledDate_WhenValidating_ThenError()
+    {
+        var model = new CreateNewModel
+        {
+            Title = "Title",
+            ShortDescription = "Desc",
+            Content = "Content",
+            IsPublished = true,
+            ScheduledPublishDate = DateTime.Now,
+            PreviewImageUrl = "https://steven-giesel.com",
+        };
+        var validationContext = new ValidationContext(model);
+        var results = new List<ValidationResult>();
+
+        var result = Validator.TryValidateObject(model, validationContext, results, true);
+
+        result.Should().BeFalse();
+        results.Count.Should().Be(1);
+    }
+}