Added more examples.

Author: PawelGerr

Directory.Packages.props

@@ -14,6 +14,7 @@
     <PackageVersion Include="Microsoft.EntityFrameworkCore.Sqlite" Version="9.0.3" />
     <PackageVersion Include="Microsoft.EntityFrameworkCore.SqlServer" Version="9.0.3" />
     <PackageVersion Include="Microsoft.EntityFrameworkCore.Relational" Version="9.0.3" />
+    <PackageVersion Include="Microsoft.Extensions.Logging.Abstractions" Version="9.0.3" />
     <PackageVersion Include="Microsoft.Extensions.Logging.Console" Version="9.0.3" />
     <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
     <PackageVersion Include="Microsoft.SourceLink.GitHub" Version="8.0.0" />

docs

@@ -1,4 +1,6 @@
 using System;
+using System.Linq;
+using System.Threading.Tasks;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.Extensions.Logging;
 using Thinktecture.SmartEnums;
@@ -150,4 +152,24 @@ private IActionResult RoundTripInternal<T>(T value)
 
       return Json(value);
    }
+
+   [HttpGet("notification/channels")]
+   public IActionResult GetAvailableChannels()
+   {
+      // Return all available notification channels
+      var channels = NotificationChannelTypeDto.Items.Select(c => c.Name);
+      return Ok(channels);
+   }
+
+   [HttpPost("notification/channels/{type}")]
+   public async Task<IActionResult> SendNotificationAsync(
+      NotificationChannelTypeDto type,
+      [FromBody] string message,
+      [FromServices] IServiceProvider serviceProvider)
+   {
+      var notificationSender = type.GetNotificationSender(serviceProvider);
+      await notificationSender.SendAsync(message);
+
+      return Ok();
+   }
 }

samples/Thinktecture.Runtime.Extensions.AspNetCore.Samples/Controllers/DemoController.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Linq;
 using System.Net.Http;
 using System.Net.Http.Json;
 using System.Text;
@@ -13,6 +14,7 @@
 using Serilog;
 using Serilog.Events;
 using Thinktecture.AspNetCore.ModelBinding;
+using Thinktecture.Helpers;
 using Thinktecture.SmartEnums;
 using Thinktecture.Text.Json.Serialization;
 using Thinktecture.Validation;
@@ -79,6 +81,9 @@ private static async Task DoHttpRequestsAsync(ILogger logger, bool forMinimalWeb
 
       await DoRequestAsync(logger, client, $"enddate/{DateOnly.FromDateTime(DateTime.Now):O}");
       await DoRequestAsync(logger, client, "enddate", DateOnly.FromDateTime(DateTime.Now));
+
+      await DoRequestAsync(logger, client, "notification/channels");
+      await DoRequestAsync(logger, client, "notification/channels/email", "Test email");
    }
 
    private static async Task DoRequestAsync(ILogger logger, HttpClient client, string url, object? body = null, string? jsonBody = null)
@@ -121,7 +126,9 @@ private static Task StartServerAsync(ILoggerFactory loggerFactory)
                     })
                     .ConfigureServices(collection =>
                     {
-                       collection.AddSingleton(loggerFactory);
+                       collection.AddSingleton(loggerFactory)
+                                 .AddSingleton<EmailNotificationSender>()
+                                 .AddSingleton<SmsNotificationSender>();
                        collection.AddControllers(options => options.ModelBinderProviders.Insert(0, new ValueObjectModelBinderProvider()))
                                  .AddJsonOptions(options => options.JsonSerializerOptions.Converters.Add(new ValueObjectJsonConverterFactory()));
                     })
@@ -135,6 +142,8 @@ private static Task StartMinimalWebApiAsync(ILoggerFactory loggerFactory)
       var builder = WebApplication.CreateBuilder();
       builder.Services
              .AddSingleton(loggerFactory)
+             .AddSingleton<EmailNotificationSender>()
+             .AddSingleton<SmsNotificationSender>()
              .ConfigureHttpJsonOptions(options =>
              {
                 options.SerializerOptions.Converters.Add(new ValueObjectJsonConverterFactory());
@@ -170,6 +179,21 @@ private static Task StartMinimalWebApiAsync(ILoggerFactory loggerFactory)
       routeGroup.MapGet("enddate/{date}", (OpenEndDate date) => date);
       routeGroup.MapPost("enddate", ([FromBody] OpenEndDate date) => date);
 
+      routeGroup.MapGet("notification/channels", () =>
+      {
+         var channels = NotificationChannelTypeDto.Items.Select(c => c.Name);
+         return Results.Ok(channels);
+      });
+      routeGroup.MapPost("notification/channels/{type}",
+                         async (
+                            NotificationChannelTypeDto type,
+                            [FromBody] string message,
+                            [FromServices] IServiceProvider serviceProvider) =>
+                         {
+                            var notificationSender = type.GetNotificationSender(serviceProvider);
+                            await notificationSender.SendAsync(message);
+                         });
+
       return app.StartAsync();
    }
 

samples/Thinktecture.Runtime.Extensions.AspNetCore.Samples/Program.cs

@@ -0,0 +1,18 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace Thinktecture.EntityConfigurations;
+
+public class MessageEntityTypeConfiguration : IEntityTypeConfiguration<Message>
+{
+   public void Configure(EntityTypeBuilder<Message> builder)
+   {
+      builder.ToTable("Messages");
+
+      builder.HasMany(m => m.States)
+             .WithOne()
+             .HasForeignKey("MessageId");
+
+      builder.Navigation(m => m.States).AutoInclude();
+   }
+}

samples/Thinktecture.Runtime.Extensions.EntityFrameworkCore.Samples/EntityConfigurations/MessageEntityTypeConfiguration.cs

@@ -0,0 +1,38 @@
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace Thinktecture.EntityConfigurations;
+
+public class MessageStateEntityTypeConfiguration
+   : IEntityTypeConfiguration<MessageState>,
+     IEntityTypeConfiguration<MessageState.Parsed>,
+     IEntityTypeConfiguration<MessageState.Processed>
+{
+   public void Configure(EntityTypeBuilder<MessageState> builder)
+   {
+      builder.ToTable("MessageStates");
+
+      builder.HasKey(s => s.Order);
+
+      builder.Property(s => s.Order).ValueGeneratedOnAdd(); // auto-increment
+      builder.Property<Guid>("MessageId"); // FK to the message table (as a shadow property)
+
+      builder
+         .HasDiscriminator<string>("Type")
+         .HasValue<MessageState.Initial>("Initial")
+         .HasValue<MessageState.Parsed>("Parsed")
+         .HasValue<MessageState.Processed>("Processed")
+         .HasValue<MessageState.Error>("Error");
+   }
+
+   public void Configure(EntityTypeBuilder<MessageState.Parsed> builder)
+   {
+      builder.Property(s => s.CreatedAt).HasColumnName("CreatedAt");
+   }
+
+   public void Configure(EntityTypeBuilder<MessageState.Processed> builder)
+   {
+      builder.Property(s => s.CreatedAt).HasColumnName("CreatedAt");
+   }
+}

samples/Thinktecture.Runtime.Extensions.EntityFrameworkCore.Samples/EntityConfigurations/MessageStateEntityTypeConfiguration.cs

@@ -0,0 +1,10 @@
+using System;
+using System.Collections.Generic;
+
+namespace Thinktecture;
+
+public class Message
+{
+   public required Guid Id { get; init; }
+   public required List<MessageState> States { get; set; }
+}

samples/Thinktecture.Runtime.Extensions.EntityFrameworkCore.Samples/Message.cs

@@ -0,0 +1,17 @@
+using System;
+
+namespace Thinktecture;
+
+[Union]
+public abstract partial record MessageState
+{
+   public int Order { get; }
+
+   public record Initial : MessageState;
+
+   public record Parsed(DateTime CreatedAt) : MessageState;
+
+   public record Processed(DateTime CreatedAt) : MessageState;
+
+   public record Error(string Message) : MessageState;
+}

samples/Thinktecture.Runtime.Extensions.EntityFrameworkCore.Samples/MessageState.cs

@@ -11,27 +11,36 @@ public class Product
    public ProductCategory Category { get; private set; }
    public ProductType ProductType { get; private set; }
    public OpenEndDate EndDate { get; set; }
+   public DayMonth ScheduledDeliveryDate { get; set; }
 
    private Boundary? _boundary;
    public Boundary Boundary => _boundary ?? throw new InvalidOperationException("Boundary is not loaded.");
 
-   private Product(Guid id, ProductName name, ProductCategory category, ProductType productType, OpenEndDate endDate)
+   private Product(
+      Guid id,
+      ProductName name,
+      ProductCategory category,
+      ProductType productType,
+      OpenEndDate endDate,
+      DayMonth scheduledDeliveryDate)
    {
       Id = id;
       Name = name;
       Category = category;
       ProductType = productType;
       EndDate = endDate;
+      ScheduledDeliveryDate = scheduledDeliveryDate;
    }
 
    public Product(
       Guid id,
       ProductName name,
       ProductCategory category,
       ProductType productType,
+      DayMonth scheduledDeliveryDate,
       Boundary boundary,
       OpenEndDate endDate = default)
-      : this(id, name, category, productType, endDate)
+      : this(id, name, category, productType, endDate, scheduledDeliveryDate)
    {
       _boundary = boundary;
    }

samples/Thinktecture.Runtime.Extensions.EntityFrameworkCore.Samples/Product.cs

@@ -5,6 +5,7 @@ namespace Thinktecture;
 public class ProductsDbContext : DbContext
 {
    public DbSet<Product> Products => Set<Product>();
+   public DbSet<Message> Messages => Set<Message>();
 
    public ProductsDbContext(DbContextOptions<ProductsDbContext> options)
       : base(options)
@@ -34,5 +35,7 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
       //                                                                              if (property.ClrType == typeof(ProductType))
       //                                                                                 property.SetMaxLength(20);
       //                                                                           });
+
+      modelBuilder.ApplyConfigurationsFromAssembly(typeof(ProductsDbContext).Assembly);
    }
 }