Added Order models

Labeled all service to enable assembly scanning

.drone.yml

@@ -17,29 +17,12 @@ steps:
       NEXUS_URL: https://nexus.khongisa.co.za/repository/nuget-hosted/
       VERSION: 1.${DRONE_BUILD_NUMBER}.0
     commands:      
-      # Abstractions
-      - dotnet pack LiteCharms.Abstractions/LiteCharms.Abstractions.csproj -c Release -p:PackageVersion=$VERSION -o dist/
-      - dotnet nuget push dist/LiteCharms.Abstractions.$VERSION.nupkg --api-key $NEXUS_KEY --source $NEXUS_URL
-
-      # Models
-      - dotnet pack LiteCharms.Models/LiteCharms.Models.csproj -c Release -p:PackageVersion=$VERSION -o dist/
-      - dotnet nuget push dist/LiteCharms.Models.$VERSION.nupkg --api-key $NEXUS_KEY --source $NEXUS_URL
-
-      # Infrastructure
-      - dotnet pack LiteCharms.Infrastructure/LiteCharms.Infrastructure.csproj -c Release -p:PackageVersion=$VERSION -o dist/
-      - dotnet nuget push dist/LiteCharms.Infrastructure.$VERSION.nupkg --api-key $NEXUS_KEY --source $NEXUS_URL
-
-      # Features
       - dotnet pack LiteCharms.Features/LiteCharms.Features.csproj -c Release -p:PackageVersion=$VERSION -o dist/
       - dotnet nuget push dist/LiteCharms.Features.$VERSION.nupkg --api-key $NEXUS_KEY --source $NEXUS_URL
-
+      - dotnet pack LiteCharms.Features.TechShop/LiteCharms.Features.TechShop.csproj -c Release -p:PackageVersion=$VERSION -o dist/
-      # Extensions
+      - dotnet nuget push dist/LiteCharms.Features.TechShop.$VERSION.nupkg --api-key $NEXUS_KEY --source $NEXUS_URL
-      - dotnet pack LiteCharms.Extensions/LiteCharms.Extensions.csproj -c Release -p:PackageVersion=$VERSION -o dist/
+      - dotnet pack LiteCharms.Features.MidrandBooks/LiteCharms.Features.MidrandBooks.csproj -c Release -p:PackageVersion=$VERSION -o dist/
-      - dotnet nuget push dist/LiteCharms.Extensions.$VERSION.nupkg --api-key $NEXUS_KEY --source $NEXUS_URL
+      - dotnet nuget push dist/LiteCharms.Features.MidrandBooks.$VERSION.nupkg --api-key $NEXUS_KEY --source $NEXUS_URL
-
-      # Entities
-      - dotnet pack LiteCharms.Entities/LiteCharms.Entities.csproj -c Release -p:PackageVersion=$VERSION -o dist/
-      - dotnet nuget push dist/LiteCharms.Entities.$VERSION.nupkg --api-key $NEXUS_KEY --source $NEXUS_URL
 
   - name: gitea-tag-release
     image: alpine/git
@@ -49,6 +32,7 @@ steps:
       GITEA_PASS: { from_secret: git_password }
       VERSION: 1.${DRONE_BUILD_NUMBER}.0
     commands:
+      - echo "169.255.58.144 gitea.khongisa.co.za" >> /etc/hosts
       - apk add --no-cache curl
       - git remote set-url origin https://$${GITEA_USER}:$${GITEA_PASS}@gitea.khongisa.co.za/litecharms/components.git
       - git tag $VERSION
@@ -61,7 +45,7 @@ steps:
                \"tag_name\": \"$VERSION\",
                \"target_commitish\": \"${DRONE_COMMIT_SHA}\",
                \"name\": \"Library Suite $VERSION\",
-               \"body\": \"### Published NuGet Packages\nAll packages versioned as **$VERSION**:\n* LiteCharms.Abstractions\n* LiteCharms.Models\n* LiteCharms.Infrastructure\n* LiteCharms.Features\n* LiteCharms.Extensions\n* LiteCharms.Entities\n\n[View in Nexus](https://nexus.khongisa.co.za/repository/nuget-group/)\",
+               \"body\": \"### Published NuGet Packages\nAll packages versioned as **$VERSION**:\n* LiteCharms.Features\n* LiteCharms.Features.TechShop\n* LiteCharms.Features.MidrandBooks\n\n[View in Nexus](https://nexus.khongisa.co.za/repository/nuget-group/)\",
                \"draft\": false,
                \"prerelease\": false
              }"

LiteCharms.Abstractions/LiteCharms.Abstractions.csproj

@@ -1,40 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFramework>net10.0</TargetFramework>
-    <ImplicitUsings>enable</ImplicitUsings>
-    <Nullable>enable</Nullable>
-    <SignAssembly>True</SignAssembly>
-    <AssemblyOriginatorKeyFile>..\LiteCharms.snk</AssemblyOriginatorKeyFile>
-  </PropertyGroup>
-
-  <!-- Nuget Package Details -->
-  <PropertyGroup>
-    <PackageId>LiteCharms.Abstractions</PackageId>
-    <Version>1.0.20</Version>
-    <Authors>Khwezi Mngoma</Authors>
-    <Company>Lite Charms (PTY) Ltd</Company>
-    <Description>Shared abstractions for Lite Charms applications.</Description>
-    <PackageProjectUrl>https://gitea.khongisa.co.za/litecharms/components</PackageProjectUrl>
-    <RepositoryUrl>https://gitea.khongisa.co.za/litecharms/components.git</RepositoryUrl>
-    <RepositoryType>git</RepositoryType>
-    <PackageLicenseFile>LICENSE</PackageLicenseFile>
-    <PackageTags>utility;dotnet</PackageTags>
-    <PackageIcon>icon.png</PackageIcon>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <None Include="..\LICENSE" Pack="true" PackagePath="\" />
-    <None Include="..\icon.png" Pack="true" PackagePath="\" />
-  </ItemGroup>
-  
-  <ItemGroup>
-    <PackageReference Include="FluentResults" Version="4.0.0" />
-    <PackageReference Include="Mediator.Abstractions" Version="3.0.2" />
-
-    <Using Include="Mediator" />
-    <Using Include="FluentResults" />
-    <Using Include="System.Threading.Channels" />
-  </ItemGroup>
-
-</Project>

LiteCharms.Entities/Configuration/OrderConfiguration.cs

@@ -1,32 +0,0 @@
-namespace LiteCharms.Entities.Configuration;
-
-public class OrderConfiguration : IEntityTypeConfiguration<Order>
-{
-    public void Configure(EntityTypeBuilder<Order> builder)
-    {
-        builder.ToTable(nameof(Order));
-
-        builder.HasKey(f => f.Id);
-        builder.Property(f => f.CreatedAt).ValueGeneratedOnAdd();
-        builder.Property(f => f.UpdatedAt).IsRequired(false).ValueGeneratedOnUpdate();
-        builder.Property(f => f.CustomerId).IsRequired();
-        builder.Property(f => f.QuoteId).IsRequired(false);
-        builder.Property(f => f.RefundId).IsRequired(false);
-        builder.Property(f => f.ShoppingCartId).IsRequired();
-        builder.Property(f => f.Status).HasConversion<int>().IsRequired();
-        builder.Property(f => f.Requirements).HasColumnType("jsonb").IsRequired(false);
-        builder.Property(f => f.Notes).HasColumnType("jsonb").IsRequired(false);
-        builder.Property(f => f.Terms).HasColumnType("jsonb").IsRequired(false);
-        builder.Property(f => f.DepositRequired);
-
-        builder.HasOne(f => f.Quote)
-            .WithOne(f => f.Order)
-            .HasForeignKey<Order>(f => f.QuoteId)
-            .OnDelete(DeleteBehavior.Restrict);
-
-        builder.HasOne(f => f.Customer)
-            .WithMany(f => f.Orders)
-            .HasForeignKey(f => f.CustomerId)
-            .OnDelete(DeleteBehavior.Restrict);
-    }
-}

LiteCharms.Entities/Configuration/PackageConfirguration.cs

@@ -1,16 +0,0 @@
-namespace LiteCharms.Entities.Configuration;
-
-public class PackageConfirguration : IEntityTypeConfiguration<Package>
-{
-    public void Configure(EntityTypeBuilder<Package> builder)
-    {
-        builder.ToTable(nameof(Package));
-
-        builder.HasKey(f => f.Id);
-        builder.Property(f => f.CreatedAt).IsRequired().ValueGeneratedOnAdd();
-        builder.Property(f => f.UpdatedAt).IsRequired(false).ValueGeneratedOnUpdate();
-        builder.Property(f => f.Name).IsRequired();
-        builder.Property(f => f.Description).IsRequired();
-        builder.Property(f => f.Active);
-    }
-}

LiteCharms.Entities/Configuration/ProductConfiguration.cs

@@ -1,14 +0,0 @@
-namespace LiteCharms.Entities.Configuration;
-
-public class ProductConfiguration : IEntityTypeConfiguration<Product>
-{
-    public void Configure(EntityTypeBuilder<Product> builder)
-    {
-        builder.ToTable(nameof(Product));
-
-        builder.HasKey(f => f.Id);
-        builder.Property(f => f.Name).IsRequired();
-        builder.Property(f => f.Description).IsRequired();
-        builder.Property(f => f.Active).HasDefaultValue(true);
-    }
-}

LiteCharms.Entities/Configuration/QuoteConfiguration.cs

@@ -1,23 +0,0 @@
-namespace LiteCharms.Entities.Configuration;
-
-public class QuoteConfiguration : IEntityTypeConfiguration<Quote>
-{
-    public void Configure(EntityTypeBuilder<Quote> builder)
-    {
-        builder.ToTable(nameof(Quote));
-
-        builder.HasKey(f => f.Id);
-        builder.Property(f => f.CreatedAt).IsRequired().ValueGeneratedOnAdd();
-        builder.Property(f => f.UpdatedAt).IsRequired(false).ValueGeneratedOnUpdate();
-        builder.Property(f => f.ExpiredAt).IsRequired(false);
-        builder.Property(f => f.CustomerId).IsRequired();
-        builder.Property(f => f.Status).IsRequired().HasConversion<int>();
-        builder.Property(f => f.ShoppingCartId).IsRequired();
-        builder.Property(f => f.Reason).IsRequired(false);
-
-        builder.HasOne(f => f.Customer)
-            .WithMany()
-            .HasForeignKey(f => f.CustomerId)
-            .OnDelete(DeleteBehavior.Cascade);
-    }
-}

LiteCharms.Entities/Configuration/ShoppingCartConfiguration.cs

@@ -1,31 +0,0 @@
-namespace LiteCharms.Entities.Configuration;
-
-public class ShoppingCartConfiguration : IEntityTypeConfiguration<ShoppingCart>
-{
-    public void Configure(EntityTypeBuilder<ShoppingCart> builder)
-    {
-        builder.ToTable(nameof(ShoppingCart));
-
-        builder.HasKey(f =>  f.Id);
-        builder.Property(f => f.CreatedAt).IsRequired().ValueGeneratedOnAdd();
-        builder.Property(f => f.UpdatedAt).IsRequired(false).ValueGeneratedOnUpdate();
-        builder.Property(f => f.CustomerId).IsRequired(false);
-        builder.Property(f => f.OrderId).IsRequired(false);
-        builder.Property(f => f.QuoteId).IsRequired(false);        
-
-        builder.HasOne(f => f.Customer)
-            .WithMany(c => c.ShoppingCarts)
-            .HasForeignKey(f => f.CustomerId)
-            .OnDelete(DeleteBehavior.NoAction);
-
-        builder.HasOne(f => f.Order)
-            .WithOne(o => o.ShoppingCart)
-            .HasForeignKey<Order>(o => o.ShoppingCartId)
-            .OnDelete(DeleteBehavior.NoAction);
-
-        builder.HasOne(f => f.Quote)
-            .WithOne(o => o.ShoppingCart)
-            .HasForeignKey<Quote>(o => o.ShoppingCartId)
-            .OnDelete(DeleteBehavior.NoAction);
-    }
-}

LiteCharms.Entities/Configuration/ShoppingCartItemConfiguration.cs

@@ -1,25 +0,0 @@
-namespace LiteCharms.Entities.Configuration;
-
-public class ShoppingCartItemConfiguration : IEntityTypeConfiguration<ShoppingCartItem>
-{
-    public void Configure(EntityTypeBuilder<ShoppingCartItem> builder)
-    {
-        builder.ToTable(nameof(ShoppingCartItem));
-
-        builder.HasKey(f => f.Id);
-        builder.Property(f => f.CreatedAt).IsRequired().ValueGeneratedOnAdd();
-        builder.Property(f => f.UpdatedAt).IsRequired(false).ValueGeneratedOnUpdate();
-        builder.Property(f => f.Quantity).IsRequired().HasDefaultValue(1);
-        builder.Property(f => f.ProductPriceId).IsRequired();
-
-        builder.HasOne(f => f.ProductPrice)
-            .WithMany()
-            .HasForeignKey(f => f.ProductPriceId)
-            .OnDelete(DeleteBehavior.NoAction);
-
-        builder.HasOne(f => f.ShoppingCart)
-            .WithMany(f => f.ShoppingCartItems)
-            .HasForeignKey(f => f.ShoppingCartId)
-            .OnDelete(DeleteBehavior.NoAction);
-    }
-}

LiteCharms.Entities/Configuration/ShoppingCartPackageConfiguration.cs

@@ -1,24 +0,0 @@
-namespace LiteCharms.Entities.Configuration;
-
-public class ShoppingCartPackageConfiguration : IEntityTypeConfiguration<ShoppingCartPackage>
-{
-    public void Configure(EntityTypeBuilder<ShoppingCartPackage> builder)
-    {
-        builder.ToTable(nameof(ShoppingCartPackage));
-
-        builder.HasKey(f => f.Id);
-        builder.Property(f => f.CreatedAt).IsRequired().ValueGeneratedOnAdd();
-        builder.Property(f => f.ShoppingCartId).IsRequired();
-        builder.Property(f => f.PackageId).IsRequired();
-
-        builder.HasOne(f => f.Package)
-            .WithMany()
-            .HasForeignKey(f => f.PackageId)
-            .OnDelete(DeleteBehavior.NoAction);
-
-        builder.HasOne(f => f.ShoppingCart)
-            .WithMany()
-            .HasForeignKey(f => f.ShoppingCartId)
-            .OnDelete(DeleteBehavior.NoAction);
-    }
-}

LiteCharms.Entities/LiteCharms.Entities.csproj

@@ -1,45 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFramework>net10.0</TargetFramework>
-    <ImplicitUsings>enable</ImplicitUsings>
-    <Nullable>enable</Nullable>
-    <SignAssembly>True</SignAssembly>
-    <AssemblyOriginatorKeyFile>..\LiteCharms.snk</AssemblyOriginatorKeyFile>
-  </PropertyGroup>
-
-  <!-- Nuget Package Details -->
-  <PropertyGroup>
-    <PackageId>LiteCharms.Entities</PackageId>
-    <Version>1.0.20</Version>
-    <Authors>Khwezi Mngoma</Authors>
-    <Company>Lite Charms (PTY) Ltd</Company>
-    <Description>Shared entities for Lite Charms applications.</Description>
-    <PackageProjectUrl>https://gitea.khongisa.co.za/litecharms/components</PackageProjectUrl>
-    <RepositoryUrl>https://gitea.khongisa.co.za/litecharms/components.git</RepositoryUrl>
-    <RepositoryType>git</RepositoryType>
-    <PackageLicenseFile>LICENSE</PackageLicenseFile>
-    <PackageTags>utility;dotnet</PackageTags>
-    <PackageIcon>icon.png</PackageIcon>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <None Include="..\LICENSE" Pack="true" PackagePath="\"/>
-    <None Include="..\icon.png" Pack="true" PackagePath="\" />
-  </ItemGroup>
-
-  <!-- Database -->
-  <ItemGroup>
-    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="10.0.7" />    
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Relational" Version="10.0.7" />    
-
-    <!-- Global Usings -->    
-    <Using Include="Microsoft.EntityFrameworkCore" />
-    <Using Include="Microsoft.EntityFrameworkCore.Metadata.Builders" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\LiteCharms.Models\LiteCharms.Models.csproj" />
-  </ItemGroup>
-
-</Project>

LiteCharms.Entities/Order.cs

@@ -1,15 +0,0 @@
-using LiteCharms.Entities.Configuration;
-
-namespace LiteCharms.Entities;
-
-[EntityTypeConfiguration<OrderConfiguration, Order>]
-public class Order : Models.Order
-{
-    public virtual OrderRefund? Refund { get; set; }
-
-    public virtual Customer? Customer { get; set; }
-
-    public virtual Quote? Quote { get; set; }
-
-    public virtual ShoppingCart? ShoppingCart { get; set; }
-}

LiteCharms.Entities/PackageItem.cs

@@ -1,9 +0,0 @@
-using LiteCharms.Entities.Configuration;
-
-namespace LiteCharms.Entities;
-
-[EntityTypeConfiguration<PackageItemConfiguration, PackageItem>]
-public class PackageItem : Models.PackageItem
-{
-    public virtual Package? Package { get; set; }
-}

LiteCharms.Entities/ShoppingCartItem.cs

@@ -1,8 +0,0 @@
-namespace LiteCharms.Entities;
-
-public class ShoppingCartItem : Models.ShoppingCartItem
-{
-    public virtual ShoppingCart? ShoppingCart { get; set; }
-
-    public virtual ProductPrice? ProductPrice { get; set; }
-}

LiteCharms.Extensions/Email.cs

@@ -1,13 +0,0 @@
-using LiteCharms.Models.Configuraton.Email;
-
-namespace LiteCharms.Extensions;
-
-public static class Email
-{
-    public static IServiceCollection AddEmailServices(this IServiceCollection services, IConfiguration configuration)
-    {
-        services.Configure<SmtpSettings>(configuration.GetSection("Email"));
-
-        return services;
-    }
-}

LiteCharms.Extensions/HealthChecks.cs

@@ -1,34 +0,0 @@
-using LiteCharms.Infrastructure.HealthChecks;
-
-namespace LiteCharms.Extensions;
-
-public static class HealthChecks
-{
-    public static IServiceCollection AddQuartzHealtchCheck(this IServiceCollection services)
-    {
-        services.AddHealthChecks().AddCheck<QuartzHealthCheck>("Quartz");
-
-        return services;
-    }
-
-    public static IServiceCollection AddPostgresHealtchCheck(this IServiceCollection services)
-    {
-        services.AddHealthChecks().AddCheck<PostgresHealthCheck>("PostgreSQL");
-
-        return services;
-    }
-
-    public static IServiceCollection AddHealthChecksSupport(this IServiceCollection services, IConfiguration configuration)
-    {
-        services.AddHealthChecks()
-            .AddCheck("Self", () => HealthCheckResult.Healthy());
-
-        //services.AddHealthChecksUI(setup =>
-        //{
-        //    setup.AddHealthCheckEndpoint("Lead Generator", $"{configuration["ASPNETCORE_URLS"]}/health");
-        //    setup.SetEvaluationTimeInSeconds(15);
-        //}).AddInMemoryStorage(databaseName: "healthuidb");
-
-        return services;
-    }
-}

LiteCharms.Extensions/Postgres.cs

@@ -1,14 +0,0 @@
-using LiteCharms.Infrastructure.Database;
-
-namespace LiteCharms.Extensions;
-
-public static class Postgres
-{
-    public static IServiceCollection AddShopDatabase(this IServiceCollection services, IConfiguration configuration)
-    {
-        services.AddPooledDbContextFactory<ShopDbContext>(options =>
-            options.UseNpgsql(configuration.GetConnectionString("PostgresShop")));
-
-        return services;
-    }
-}

LiteCharms.Features.MidrandBooks.Tests/Fixture.cs

@@ -0,0 +1,38 @@
+using LiteCharms.Features.Extensions;
+using LiteCharms.Features.MidrandBooks.Extensions;
+
+namespace LiteCharms.Features.MidrandBooks.Tests;
+
+public class Fixture : IDisposable
+{
+    public IConfiguration Configuration { get; set; }
+
+    public IServiceProvider Services { get; set; }
+
+    public IMediator Mediator { get; set; }
+
+    public Fixture()
+    {
+        Configuration = new ConfigurationBuilder()
+            .SetBasePath(Directory.GetCurrentDirectory())
+            .AddUserSecrets<Fixture>()
+            .AddJsonFile(Path.Combine(Directory.GetCurrentDirectory(), "appsettings.json"), optional: true, reloadOnChange: true)
+            .AddEnvironmentVariables()
+            .Build();
+
+        Services = new ServiceCollection()            
+            .AddMediator()
+            .AddLogging()
+            //.AddMidrandShopServices()
+            .AddEmailServiceBus()
+            .AddGarageS3(Configuration)
+            .AddMidrandShopDatabase(Configuration)
+            .AddEmailServices(Configuration)
+            .AddSingleton(Configuration)
+            .BuildServiceProvider();
+
+        Mediator = Services.GetRequiredService<IMediator>();
+    }
+
+    public void Dispose() { }
+}

LiteCharms.Features.MidrandBooks.Tests/LiteCharms.Features.MidrandBooks.Tests.csproj

@@ -0,0 +1,51 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <IsPackable>false</IsPackable>
+    <UserSecretsId>b205af96-ceef-44e1-851c-458c9fd1c437</UserSecretsId>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="coverlet.collector" Version="10.0.1">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Mediator.SourceGenerator" Version="3.0.2">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.5.1" />
+    <PackageReference Include="xunit" Version="2.9.3" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="3.1.5">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <!-- Global Usings -->
+  <ItemGroup>
+    <Using Include="Mediator" />
+    <Using Include="Xunit.Abstractions" />
+    <Using Include="Microsoft.Extensions.DependencyInjection" />
+    <Using Include="Microsoft.Extensions.Configuration" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\LiteCharms.Features.MidrandBooks\LiteCharms.Features.MidrandBooks.csproj" />
+    <ProjectReference Include="..\LiteCharms.Features\LiteCharms.Features.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="Xunit" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Update="appsettings.json">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
+
+</Project>

LiteCharms.Features.MidrandBooks.Tests/appsettings.json

@@ -0,0 +1,34 @@
+{
+  "BookshopS3Settings": {
+    "ServiceUrl": "http://192.168.1.177:30900",
+    "Region": "garage",
+    "BucketName": "bookshop",
+    "CdnBaseUrl": "https://bookshop.cdn.khongisa.co.za"
+  },
+  "BookshopQuotesS3Settings": {
+    "ServiceUrl": "http://192.168.1.177:30900",
+    "Region": "garage",
+    "BucketName": "bookshop.quotes",
+    "CdnBaseUrl": "https://bookshop.quotes.cdn.khongisa.co.za"
+  },
+  "Email": {
+    "Credentials": {
+      "Username": "shop@litecharms.co.za"
+    },
+    "Port": 465,
+    "Host": "mail.litecharms.co.za",
+    "UseSsl": true
+  },
+  "Monitoring": {
+    "ApiKey": "",
+    "Address": "http://aspire-dashboard-service.aspire.svc.cluster.local:18889",
+    "ServiceName": "LiteCharms.LeadGenerator"
+  },
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  },
+  "AllowedHosts": "*"
+}

LiteCharms.Features.MidrandBooks/Abstractions/IService.cs

@@ -0,0 +1,3 @@
+namespace LiteCharms.Features.MidrandBooks.Abstractions;
+
+public interface IService;

LiteCharms.Features.MidrandBooks/AuthorBooks/BooksService.cs

@@ -0,0 +1,141 @@
+using LiteCharms.Features.MidrandBooks.Abstractions;
+using LiteCharms.Features.MidrandBooks.AuthorBooks.Models;
+using LiteCharms.Features.MidrandBooks.Extensions;
+using LiteCharms.Features.MidrandBooks.Postgres;
+
+namespace LiteCharms.Features.MidrandBooks.AuthorBooks;
+
+public class BooksService(IDbContextFactory<MidrandBooksDbContext> contextFactory) : IService
+{
+    public async ValueTask<Result> UpdateBookStatusAsync(long bookId, bool isEnabled, CancellationToken cancellationToken)
+    {
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var book = await context.Books.FirstOrDefaultAsync(b => b.Id == bookId, cancellationToken);
+
+            if (book is null)
+                return Result.Fail(new Error($"Book with ID {bookId} not found"));
+
+            book.UpdatedAt = DateTime.UtcNow;
+            book.Enabled = isEnabled;
+
+            return await context.SaveChangesAsync(cancellationToken) > 0
+                ? Result.Ok()
+                : Result.Fail(new Error($"Failed to change status of book with ID {bookId}"));
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result<long>> CreateBookAsync(long authorId, long productId, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            if(!await context.Authors.AnyAsync(a => a.Id == authorId, cancellationToken))
+                return Result.Fail<long>("Author not found.");
+
+            if (!await context.Products.AnyAsync(p => p.Id == productId, cancellationToken))
+                return Result.Fail<long>("Product not found.");
+
+            var book = context.Books.Add(new Entities.AuthorBook
+            {
+                AuthorId = authorId,
+                ProductId = productId,
+            });
+
+            return await context.SaveChangesAsync(cancellationToken) > 0
+                ? Result.Ok(book.Entity.Id)
+                : Result.Fail<long>("Failed to create book.");
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail<long>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result<AuthorBook>> GetBookAsync(long bookId, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var book = await context.Books
+                .AsNoTracking()
+                .Include(b => b.Author)
+                .Include(b => b.Product!.Price)
+                .Include(b => b.Pages)
+                .FirstOrDefaultAsync(b => b.Id == bookId, cancellationToken);
+
+            return book is null 
+                ? Result.Fail<AuthorBook>(new Error($"Book with ID {bookId} not found")) 
+                : Result.Ok(book.ToModel());
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail<AuthorBook>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result<AuthorBook[]>> GetBooksByAuthorAsync(long authorId, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            if(!await context.Authors.AnyAsync(a => a.Id == authorId, cancellationToken))
+                return Result.Fail<AuthorBook[]>(new Error($"Author with ID {authorId} not found"));
+
+            var books = await context.Books
+                .AsNoTracking()
+                .Include(b => b.Author)
+                .Include(b => b.Product!.Price)
+                .OrderByDescending(b => b.CreatedAt)
+                .Where(b => b.AuthorId == authorId)
+                .ToListAsync(cancellationToken);
+
+            return books?.Count > 0
+                ? Result.Ok(books.Select(b => b.ToModel()).ToArray())
+                : Result.Fail<AuthorBook[]>(new Error($"No books found for author with ID {authorId}"));
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail<AuthorBook[]>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result<AuthorBook[]>> GetPublishedBooksAsync(int offset, int limit, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var books = await context.Books
+                .AsNoTracking()
+                .Include(b => b.Author)
+                .Include(b => b.Product!.Price)
+                .Include(b => b.Pages)
+                .Where(b => b.Enabled && b.Product!.Enabled && b.Author.Enabled)
+                .OrderByDescending(b => b.Ranking)
+                    .ThenByDescending(b => b.Ranking)
+                    .ThenByDescending(b => b.CreatedAt)
+                    .ThenByDescending(b => b.UpdatedAt)
+                .Skip(offset).Take(limit)
+                .AsSplitQuery()
+                .ToArrayAsync(cancellationToken);
+
+            return books?.Length > 0
+                ? Result.Ok(books.Select(b => b.ToModel()).ToArray())
+                : Result.Fail<AuthorBook[]>(new Error("No published books found."));
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail<AuthorBook[]>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+}

LiteCharms.Features.MidrandBooks/AuthorBooks/Entities/AuthorBook.cs

@@ -0,0 +1,14 @@
+using LiteCharms.Features.MidrandBooks.Authors.Entities;
+using LiteCharms.Features.MidrandBooks.Pages.Entities;
+using LiteCharms.Features.MidrandBooks.Products.Entities;
+
+namespace LiteCharms.Features.MidrandBooks.AuthorBooks.Entities;
+
+public class AuthorBook : Models.AuthorBook
+{
+    public virtual Author Author { get; set; } = new();
+
+    public new virtual Product? Product { get; set; }
+
+    public virtual ICollection<BookPage> Pages { get; set; } = [];
+}

LiteCharms.Features.MidrandBooks/AuthorBooks/Entities/AuthorBookConfiguration.cs

@@ -0,0 +1,28 @@
+namespace LiteCharms.Features.MidrandBooks.AuthorBooks.Entities;
+
+public class AuthorBookConfiguration : IEntityTypeConfiguration<AuthorBook>
+{
+    public void Configure(EntityTypeBuilder<AuthorBook> builder)
+    {
+        builder.ToTable("Books");
+
+        builder.HasKey(f => f.AuthorId);
+        builder.Property(f => f.CreatedAt).IsRequired().ValueGeneratedOnAdd().HasDefaultValueSql("now()");
+        builder.Property(f => f.UpdatedAt).HasDefaultValueSql("now()");
+        builder.Property(f => f.AuthorId).IsRequired();
+        builder.Property(f => f.ProductId).IsRequired();
+        builder.Property(f => f.Rating).IsRequired(false);
+        builder.Property(f => f.Ranking).IsRequired(false);
+        builder.Property(f => f.Enabled).HasDefaultValue(true);
+
+        builder.HasOne(f => f.Author)
+            .WithMany(a => a.Books)
+            .HasForeignKey(f => f.AuthorId)
+            .OnDelete(DeleteBehavior.Restrict);
+
+        builder.HasOne(f => f.Product)
+            .WithMany()
+            .HasForeignKey(f => f.ProductId)
+            .OnDelete(DeleteBehavior.Restrict);
+    }
+}

LiteCharms.Features.MidrandBooks/AuthorBooks/Models/AuthorBook.cs

@@ -0,0 +1,24 @@
+using LiteCharms.Features.MidrandBooks.Products.Models;
+
+namespace LiteCharms.Features.MidrandBooks.AuthorBooks.Models;
+
+public class AuthorBook
+{
+    public long Id { get; set; }
+
+    public DateTime CreatedAt { get; set; }
+
+    public DateTime? UpdatedAt { get; set; }
+
+    public long AuthorId { get; set; }
+
+    public long ProductId { get; set; }
+
+    public int Rating { get; set; }
+
+    public int Ranking { get; set; }
+
+    public Product? Product { get; set; }
+
+    public bool Enabled { get; set; }
+}

LiteCharms.Features.MidrandBooks/Authors/AuthorService.cs

@@ -0,0 +1,186 @@
+using LiteCharms.Features.MidrandBooks.Abstractions;
+using LiteCharms.Features.MidrandBooks.AuthorBooks.Models;
+using LiteCharms.Features.MidrandBooks.Authors.Models;
+using LiteCharms.Features.MidrandBooks.Extensions;
+using LiteCharms.Features.MidrandBooks.Postgres;
+using LiteCharms.Features.Models;
+
+namespace LiteCharms.Features.MidrandBooks.Authors;
+
+public class AuthorService(IDbContextFactory<MidrandBooksDbContext> contextFactory) : IService
+{
+    public async ValueTask<Result<AuthorBook[]>> GetAuthorBooksAsync(long authorId, CancellationToken cancellationToken)
+    {
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var author = await context.Authors.FirstOrDefaultAsync(a => a.Id == authorId, cancellationToken);
+
+            if (author is null)
+                return Result.Fail<AuthorBook[]>(new Error($"Author with ID {authorId} not found"));
+
+            var books = await context.Books
+                .AsNoTracking()
+                .Include(b => b.Author)
+                .Include(b => b.Product!.Price)
+                .OrderByDescending(b => b.CreatedAt)
+                .Where(p => p.AuthorId == authorId)
+                .AsSplitQuery()                
+                .ToArrayAsync(cancellationToken);
+
+            return books?.Length > 0
+                ? Result.Ok(books.Select(b => b.ToModel()).ToArray())
+                : Result.Fail<AuthorBook[]>(new Error($"No books found for author with ID {authorId}"));
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail<AuthorBook[]>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result> UpdateAuthorStatusAsync(long authorId, bool isEnabled, CancellationToken cancellationToken)
+    {
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var author = await context.Authors.FirstOrDefaultAsync(a => a.Id == authorId, cancellationToken);
+
+            if (author is null)
+                return Result.Fail(new Error($"Author with ID {authorId} not found"));
+
+            author.UpdatedAt = DateTime.UtcNow;
+            author.Enabled = isEnabled;
+
+            return await context.SaveChangesAsync(cancellationToken) > 0
+                ? Result.Ok()
+                : Result.Fail(new Error($"Failed to change status of author with ID {authorId}"));
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result<Author>> GetAuthorAsync(long authorId, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var author = await context.Authors.FirstOrDefaultAsync(a => a.Id == authorId, cancellationToken);
+
+            return author is not null
+                ? Result.Ok(author.ToModel())
+                : Result.Fail<Author>(new Error($"Author with ID {authorId} not found"));
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail<Author>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result<Author[]>> GetAuthors(DateRange range, CancellationToken cancellationToken)
+    {
+        try
+        {
+            var fromDate = range.From.ToDateTime(TimeOnly.MinValue);
+            var toDate = range.To.ToDateTime(TimeOnly.MaxValue);
+
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var authors = await context.Authors.AsNoTracking()
+               .OrderByDescending(o => o.CreatedAt)
+                .ThenByDescending(o => o.UpdatedAt)
+               .Where(a => a.CreatedAt >= fromDate && a.CreatedAt <= toDate)
+               .Take(range.MaxRecords)
+               .ToArrayAsync(cancellationToken);
+
+            return authors?.Length > 0
+                ? Result.Ok(authors.Select(a => a.ToModel()).ToArray())
+                : Result.Fail<Author[]>(new Error("No authors found in the specified date range."));
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail<Author[]>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result> UpdateAuthorAsync(long authorId, UpdateAuthor request, CancellationToken cancellationToken)
+    {
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            if (await context.Authors.AnyAsync(a => a.Name == request.Name && a.LastName == request.LastName, cancellationToken))
+                return Result.Fail(new Error($"An author with the name {request.Name} {request.LastName} already exists"));
+
+            if (await context.Authors.AnyAsync(a => a.Email == request.Email, cancellationToken))
+                return Result.Fail(new Error($"An author with the email {request.Email} already exists"));
+
+            var author = await context.Authors.FirstOrDefaultAsync(a => a.Id == authorId, cancellationToken);
+
+            if (author is null)
+                return Result.Fail(new Error($"Author with ID {authorId} not found"));
+
+            author.UpdatedAt = DateTime.UtcNow;
+            author.PublisherType = request.PublisherType;
+            author.Company = request.Company;
+            author.VatNumber = request.VatNumber;
+            author.Name = request.Name;
+            author.LastName = request.LastName;
+            author.Biography = request.Biography;
+            author.Email = request.Email;
+            author.Website = request.Website;
+            author.ImageUrl = request.ImageUrl;
+            author.ThumbnailImageUrl = request.ThumbnailImageUrl;
+            author.SocialMedia = request.SocialMedia;
+
+            return await context.SaveChangesAsync(cancellationToken) > 0
+                ? Result.Ok()
+                : Result.Fail(new Error($"Failed to update author with ID {authorId}"));
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result<long>> CreateAuthorAsync(CreateAuthor request, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            if(await context.Authors.AnyAsync(a => a.Name == request.Name && a.LastName == request.LastName, cancellationToken))
+                return Result.Fail<long>(new Error($"An author with the name {request.Name} {request.LastName} already exists"));
+
+            if(await context.Authors.AnyAsync(a => a.Email == request.Email, cancellationToken))
+                return Result.Fail<long>(new Error($"An author with the email {request.Email} already exists"));
+
+            var newAuthor = context.Authors.Add(new Entities.Author
+            {
+                Company = request.Company,
+                VatNumber = request.VatNumber,
+                PublisherType = request.PublisherType,
+                Name = request.Name,
+                LastName = request.LastName,
+                Biography = request.Biography,
+                Email = request.Email,
+                Website = request.Website,
+                ImageUrl = request.ImageUrl,
+                ThumbnailImageUrl = request.ThumbnailImageUrl,
+                SocialMedia = request.SocialMedia
+            });
+
+            return await context.SaveChangesAsync(cancellationToken) > 0
+                ? Result.Ok(newAuthor.Entity.Id)
+                : Result.Fail<long>(new Error($"Failed to create author {request.Name} {request.LastName}"));
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail<long>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+}

LiteCharms.Features.MidrandBooks/Authors/Entities/Author.cs

@@ -0,0 +1,9 @@
+using LiteCharms.Features.MidrandBooks.AuthorBooks.Entities;
+
+namespace LiteCharms.Features.MidrandBooks.Authors.Entities;
+
+[EntityTypeConfiguration<AuthorConfiguration, Author>]
+public class Author : Models.Author
+{
+    public ICollection<AuthorBook> Books { get; set; } = [];
+}

LiteCharms.Features.MidrandBooks/Authors/Entities/AuthorConfiguration.cs

@@ -0,0 +1,24 @@
+namespace LiteCharms.Features.MidrandBooks.Authors.Entities;
+
+public class AuthorConfiguration : IEntityTypeConfiguration<Author>
+{
+    public void Configure(EntityTypeBuilder<Author> builder)
+    {
+        builder.ToTable("Authors");
+
+        builder.HasKey(f => f.Id);
+        builder.Property(f => f.CreatedAt).IsRequired().ValueGeneratedOnAdd().HasDefaultValueSql("now()");
+        builder.Property(f => f.UpdatedAt).HasDefaultValueSql("now()");
+        builder.Property(f => f.PublisherType).IsRequired();
+        builder.Property(f => f.VatNumber).IsRequired(false).HasMaxLength(255);
+        builder.Property(f => f.Name).IsRequired().HasMaxLength(255);
+        builder.Property(f => f.LastName).IsRequired().HasMaxLength(255);
+        builder.Property(f => f.Biography).IsRequired(false).HasMaxLength(2048);
+        builder.Property(f => f.Email).IsRequired().HasMaxLength(512);
+        builder.Property(f => f.Website).IsRequired(false).HasMaxLength(1024);
+        builder.Property(f => f.ImageUrl).IsRequired().HasMaxLength(2048);
+        builder.Property(f => f.ThumbnailImageUrl).IsRequired(false).HasMaxLength(2048);
+        builder.Property(f => f.SocialMedia).IsRequired(false).HasColumnType("jsonb");
+        builder.Property(f => f.Enabled).HasDefaultValue(true);
+    }
+}

LiteCharms.Features.MidrandBooks/Authors/Models/Author.cs

@@ -0,0 +1,36 @@
+using LiteCharms.Features.Models;
+
+namespace LiteCharms.Features.MidrandBooks.Authors.Models;
+
+public class Author
+{
+    public long Id { get; set; }
+
+    public DateTime CreatedAt { get; set; }
+
+    public DateTime? UpdatedAt { get; set; }
+
+    public PublisherTypes PublisherType { get; set; }
+
+    public string? Company { get; set; }
+
+    public string? VatNumber { get; set; }
+
+    public string? Name { get; set; }
+
+    public string? LastName { get; set; }
+
+    public string? Biography { get; set; }
+
+    public string? Email { get; set; }
+
+    public string? Website { get; set; }
+
+    public string? ImageUrl { get; set; }
+
+    public string? ThumbnailImageUrl { get; set; }
+
+    public SocialMedia[]? SocialMedia { get; set; }
+
+    public bool Enabled { get; set; }
+}

LiteCharms.Features.MidrandBooks/Authors/Models/Records.cs

@@ -0,0 +1,30 @@
+using LiteCharms.Features.Models;
+
+namespace LiteCharms.Features.MidrandBooks.Authors.Models;
+
+public record UpdateAuthor : CreateAuthor;
+
+public record CreateAuthor
+{
+    public required PublisherTypes PublisherType { get; set; }
+
+    public string? Company { get; set; }
+
+    public string? VatNumber { get; set; }
+
+    public required string Name { get; set; }
+
+    public required string LastName { get; set; }
+
+    public string? Biography { get; set; }
+
+    public required string Email { get; set; }
+
+    public string? Website { get; set; }
+
+    public required string ImageUrl { get; set; }
+
+    public string? ThumbnailImageUrl { get; set; }
+
+    public SocialMedia[]? SocialMedia { get; set; }
+}

LiteCharms.Features.MidrandBooks/Customers/CustomerService.cs

@@ -0,0 +1,408 @@
+using LiteCharms.Features.MidrandBooks.Abstractions;
+using LiteCharms.Features.MidrandBooks.Customers.Models;
+using LiteCharms.Features.MidrandBooks.Extensions;
+using LiteCharms.Features.MidrandBooks.Postgres;
+
+namespace LiteCharms.Features.MidrandBooks.Customers;
+
+public class CustomerService(IDbContextFactory<MidrandBooksDbContext> contextFactory) : IService
+{
+    public async ValueTask<Result<long>> CreateCustomerAsync(CreateCustomer request, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            if (await context.Customers.AnyAsync(c => c.Email!.Equals(request.Email, StringComparison.OrdinalIgnoreCase), cancellationToken))
+                return Result.Fail<long>(new Error($"Customer with email '{request.Email}' already exists."));
+
+            var customer = context.Customers.Add(new Entities.Customer
+            {
+                Company = request.Company,
+                VatNumber = request.VatNumber,
+                Email = request.Email,
+                Website = request.Website,
+                Phone = request.Phone,
+                SocialMedia = request.SocialMedia,
+                Enabled = true
+            });
+
+            return await context.SaveChangesAsync(cancellationToken) > 0
+                ? Result.Ok(customer.Entity.Id)
+                : Result.Fail<long>(new Error("Failed to create customer."));
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail<long>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result<long>> CreateCustomerContactAsync(long customerId, CreateCustomerContact request, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            if (!await context.Customers.AnyAsync(c => c.Id == customerId, cancellationToken))
+                return Result.Fail<long>(new Error($"Customer with ID '{customerId}' does not exist."));
+
+            if (await context.Contacts.AnyAsync(cc => cc.CustomerId == customerId && cc.Email!.Equals(request.Email, StringComparison.OrdinalIgnoreCase), cancellationToken))
+                return Result.Fail<long>(new Error($"Contact with email '{request.Email}' already exists for this customer."));
+
+            var contact = context.Contacts.Add(new Entities.Contact
+            {
+                CustomerId = customerId,
+                Name = request.Name,
+                Email = request.Email,
+                Phone = request.Phone,
+                LastName = request.LastName,
+                Type = request.Type,
+                Enabled = true
+            });
+
+            return await context.SaveChangesAsync(cancellationToken) > 0
+                ? Result.Ok(contact.Entity.Id)
+                : Result.Fail<long>(new Error("Failed to create customer contact."));
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail<long>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result<long>> CreateCustomerAddressAsync(long customerId, CreateCustomerAddress request, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            if (!await context.Customers.AnyAsync(c => c.Id == customerId, cancellationToken))
+                return Result.Fail<long>(new Error($"Customer with ID '{customerId}' does not exist."));
+
+            var address = context.Addresses.Add(new Entities.Address
+            {
+                CustomerId = customerId,
+                Street = request.Street,
+                City = request.City,
+                State = request.State,
+                PostalCode = request.PostalCode,
+                Country = request.Country,
+                Type = request.Type,
+                Enabled = true,
+                BuildingType = request.BuildingType,
+                IsPrimary = request.IsPrimary,
+                Name = request.Name
+            });
+
+            return await context.SaveChangesAsync(cancellationToken) > 0
+                ? Result.Ok(address.Entity.Id)
+                : Result.Fail<long>(new Error("Failed to create customer address."));
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail<long>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result> UpdateCustomerAsync(long customerId, UpdateCustomer request, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var customer = await context.Customers.FirstOrDefaultAsync(c => c.Id == customerId, cancellationToken);
+
+            if (customer is null)
+                return Result.Fail(new Error($"Customer with ID '{customerId}' does not exist."));
+
+            customer.UpdatedAt = DateTime.UtcNow;
+            customer.Company = request.Company;
+            customer.VatNumber = request.VatNumber;
+            customer.Email = request.Email;
+            customer.Website = request.Website;
+            customer.Phone = request.Phone;
+            customer.SocialMedia = request.SocialMedia;
+
+            return await context.SaveChangesAsync(cancellationToken) > 0
+                ? Result.Ok()
+                : Result.Fail(new Error("Failed to update customer."));
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result> UpdateCustomerContactAsync(long contactId, UpdateCustomerContact request, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var contact = await context.Contacts.FirstOrDefaultAsync(cc => cc.Id == contactId, cancellationToken);
+
+            if (contact is null)
+                return Result.Fail(new Error($"Contact with ID '{contactId}' does not exist."));
+
+            contact.UpdatedAt = DateTime.UtcNow;
+            contact.Name = request.Name;
+            contact.LastName = request.LastName;
+            contact.Email = request.Email;
+            contact.Phone = request.Phone;
+            contact.Type = request.Type;
+
+            return await context.SaveChangesAsync(cancellationToken) > 0
+                ? Result.Ok()
+                : Result.Fail(new Error("Failed to update customer contact."));
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result> UpdateCustomerAddressAsync(long addressId, UpdateCustomerAddress request, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var address = await context.Addresses.FirstOrDefaultAsync(a => a.Id == addressId, cancellationToken);
+
+            if (address is null)
+                return Result.Fail(new Error($"Address with ID '{addressId}' does not exist."));
+
+            address.UpdatedAt = DateTime.UtcNow;
+            address.Street = request.Street;
+            address.City = request.City;
+            address.State = request.State;
+            address.PostalCode = request.PostalCode;
+            address.Country = request.Country;
+            address.Type = request.Type;
+            address.BuildingType = request.BuildingType;
+            address.IsPrimary = request.IsPrimary;
+            address.Name = request.Name;
+
+            return await context.SaveChangesAsync(cancellationToken) > 0
+                ? Result.Ok()
+                : Result.Fail(new Error("Failed to update customer address."));
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result> UpdateCustomerStatusAsync(long customerId, bool enabled, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var customer = await context.Customers.FirstOrDefaultAsync(c => c.Id == customerId, cancellationToken);
+
+            if (customer is null)
+                return Result.Fail(new Error($"Customer with ID '{customerId}' does not exist."));
+
+            customer.Enabled = enabled;
+            customer.UpdatedAt = DateTime.UtcNow;
+
+            return await context.SaveChangesAsync(cancellationToken) > 0
+                ? Result.Ok()
+                : Result.Fail(new Error("Failed to update customer status."));
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result> UpdateCustomerContactStatusAsync(long contactId, bool enabled, bool isPrimary, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var contact = await context.Contacts.FirstOrDefaultAsync(cc => cc.Id == contactId, cancellationToken);
+
+            if (contact is null)
+                return Result.Fail(new Error($"Contact with ID '{contactId}' does not exist."));
+
+            contact.Enabled = enabled;
+            contact.IsPrimary = isPrimary;
+            contact.UpdatedAt = DateTime.UtcNow;
+
+            return await context.SaveChangesAsync(cancellationToken) > 0
+                ? Result.Ok()
+                : Result.Fail(new Error("Failed to update customer contact status."));
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result> UpdateCustomerAddressStatusAsync(long addressId, bool enabled, bool isPrimary, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var address = await context.Addresses.FirstOrDefaultAsync(a => a.Id == addressId, cancellationToken);
+
+            if (address is null)
+                return Result.Fail(new Error($"Address with ID '{addressId}' does not exist."));
+
+            address.Enabled = enabled;
+            address.IsPrimary = isPrimary;
+            address.UpdatedAt = DateTime.UtcNow;
+
+            return await context.SaveChangesAsync(cancellationToken) > 0
+                ? Result.Ok()
+                : Result.Fail(new Error("Failed to update customer address status."));
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result<Customer[]>> GetCustomersAsync(CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var customers = await context.Customers
+                .AsNoTracking()
+                .Include(c => c.Contacts)
+                .Include(c => c.Addresses)
+                .OrderByDescending(c => c.CreatedAt)
+                    .ThenByDescending(c => c.UpdatedAt)
+                .AsSplitQuery()
+                .ToListAsync(cancellationToken);
+
+            return customers?.Count > 0
+                ? Result.Ok(customers.Select(c => c.ToModel()).ToArray())
+                : Result.Fail<Customer[]>(new Error("No customers found."));
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail<Customer[]>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result<Contact[]>> GetCustomerContactsAsync(long customerId, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            if (!await context.Customers.AnyAsync(c => c.Id == customerId, cancellationToken))
+                return Result.Fail<Contact[]>(new Error($"Customer with ID '{customerId}' does not exist."));
+
+            var contacts = await context.Contacts
+                .AsNoTracking()
+                .Where(cc => cc.CustomerId == customerId)
+                .OrderByDescending(cc => cc.CreatedAt)
+                    .ThenByDescending(cc => cc.UpdatedAt)
+                .ToListAsync(cancellationToken);
+
+            return contacts?.Count > 0
+                ? Result.Ok(contacts.Select(cc => cc.ToModel()).ToArray())
+                : Result.Fail<Contact[]>(new Error("No contacts found for the specified customer."));
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail<Contact[]>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result<Address[]>> GetCustomerAddressesAsync(long customerId, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            if (!await context.Customers.AnyAsync(c => c.Id == customerId, cancellationToken))
+                return Result.Fail<Address[]>(new Error($"Customer with ID '{customerId}' does not exist."));
+
+            var addresses = await context.Addresses
+                .AsNoTracking()
+                .Where(a => a.CustomerId == customerId)
+                .OrderByDescending(a => a.CreatedAt)
+                    .ThenByDescending(a => a.UpdatedAt)
+                .ToListAsync(cancellationToken);
+
+            return addresses?.Count > 0
+                ? Result.Ok(addresses.Select(a => a.ToModel()).ToArray())
+                : Result.Fail<Address[]>(new Error($"No addresses found for customer with ID '{customerId}'."));
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail<Address[]>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result<Customer>> GetCustomerAsync(long customerId, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var customer = await context.Customers
+                .AsNoTracking()
+                .Include(c => c.Contacts)
+                .Include(c => c.Addresses)
+                .FirstOrDefaultAsync(c => c.Id == customerId, cancellationToken);
+
+            return customer is not null
+                ? Result.Ok(customer.ToModel())
+                : Result.Fail<Customer>(new Error($"Customer with ID '{customerId}' does not exist."));
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail<Customer>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result<Contact>> GetCustomerContactAsync(long contactId, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var contact = await context.Contacts
+                .AsNoTracking()
+                .FirstOrDefaultAsync(cc => cc.Id == contactId, cancellationToken);
+
+            return contact is not null
+                ? Result.Ok(contact.ToModel())
+                : Result.Fail<Contact>(new Error($"Contact with ID '{contactId}' does not exist."));
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail<Contact>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result<Address>> GetCustomerAddressAsync(long addressId, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var address = await context.Addresses
+                .AsNoTracking()
+                .FirstOrDefaultAsync(a => a.Id == addressId, cancellationToken);
+
+            return address is not null
+                ? Result.Ok(address.ToModel())
+                : Result.Fail<Address>(new Error($"Address with ID '{addressId}' does not exist."));
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail<Address>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+}

LiteCharms.Features.MidrandBooks/Customers/Entities/Address.cs

@@ -0,0 +1,7 @@
+namespace LiteCharms.Features.MidrandBooks.Customers.Entities;
+
+[EntityTypeConfiguration<AddressConfiguration, Address>]
+public class Address : Models.Address
+{
+    public virtual Customer? Customer { get; set; }
+}

LiteCharms.Features.MidrandBooks/Customers/Entities/AddressConfiguration.cs

@@ -0,0 +1,29 @@
+namespace LiteCharms.Features.MidrandBooks.Customers.Entities;
+
+public class AddressConfiguration : IEntityTypeConfiguration<Address>
+{
+    public void Configure(EntityTypeBuilder<Address> builder)
+    {
+        builder.ToTable("Addresses");
+
+        builder.HasKey(a => a.Id);
+        builder.Property(a => a.CustomerId).IsRequired();
+        builder.Property(a => a.CreatedAt).IsRequired().ValueGeneratedOnAdd().HasDefaultValueSql("now()");
+        builder.Property(a => a.UpdatedAt).HasDefaultValueSql("now()");
+        builder.Property(a => a.Name).IsRequired();
+        builder.Property(a => a.Type).IsRequired();
+        builder.Property(a => a.BuildingType).IsRequired();
+        builder.Property(a => a.Street).IsRequired();
+        builder.Property(a => a.City).IsRequired();
+        builder.Property(a => a.State).IsRequired();
+        builder.Property(a => a.PostalCode).IsRequired();
+        builder.Property(a => a.Country).IsRequired();
+        builder.Property(a => a.IsPrimary).HasDefaultValue(false);
+        builder.Property(a => a.Enabled).HasDefaultValue(true);
+
+        builder.HasOne(a => a.Customer)
+            .WithMany(c => c.Addresses)
+            .HasForeignKey(a => a.CustomerId)
+            .OnDelete(DeleteBehavior.Cascade);
+    }
+}

LiteCharms.Features.MidrandBooks/Customers/Entities/Contact.cs

@@ -0,0 +1,7 @@
+namespace LiteCharms.Features.MidrandBooks.Customers.Entities;
+
+[EntityTypeConfiguration<ContactConfiguration, Contact>]
+public class Contact : Models.Contact
+{
+    public virtual Customer? Customer { get; set; }
+}

LiteCharms.Features.MidrandBooks/Customers/Entities/ContactConfiguration.cs

@@ -0,0 +1,26 @@
+namespace LiteCharms.Features.MidrandBooks.Customers.Entities;
+
+public class ContactConfiguration : IEntityTypeConfiguration<Contact>
+{
+    public void Configure(EntityTypeBuilder<Contact> builder)
+    {
+        builder.ToTable("Contacts");
+
+        builder.HasKey(c => c.Id);
+        builder.Property(c => c.CustomerId).IsRequired();
+        builder.Property(c => c.CreatedAt).IsRequired().ValueGeneratedOnAdd().HasDefaultValueSql("now()");
+        builder.Property(c => c.UpdatedAt).HasDefaultValueSql("now()");
+        builder.Property(c => c.Name).IsRequired();
+        builder.Property(c => c.LastName).IsRequired();
+        builder.Property(c => c.Type).IsRequired();
+        builder.Property(c => c.Phone).IsRequired();
+        builder.Property(c => c.Email).IsRequired();
+        builder.Property(c => c.IsPrimary).HasDefaultValue(false);
+        builder.Property(c => c.Enabled).HasDefaultValue(true);
+
+        builder.HasOne(c => c.Customer)
+            .WithMany(c => c.Contacts)
+            .HasForeignKey(c => c.CustomerId)
+            .OnDelete(DeleteBehavior.Cascade);
+    }
+}

LiteCharms.Features.MidrandBooks/Customers/Entities/Customer.cs

@@ -0,0 +1,9 @@
+namespace LiteCharms.Features.MidrandBooks.Customers.Entities;
+
+[EntityTypeConfiguration<CustomerConfiguration, Customer>]
+public class Customer : Models.Customer
+{
+    public virtual ICollection<Contact> Contacts { get; set; } = [];
+
+    public virtual ICollection<Address> Addresses { get; set; } = [];
+}

LiteCharms.Features.MidrandBooks/Customers/Entities/CustomerConfiguration.cs

@@ -0,0 +1,20 @@
+namespace LiteCharms.Features.MidrandBooks.Customers.Entities;
+
+public class CustomerConfiguration : IEntityTypeConfiguration<Customer>
+{
+    public void Configure(EntityTypeBuilder<Customer> builder)
+    {
+        builder.ToTable("Customers");
+
+        builder.HasKey(c => c.Id);        
+        builder.Property(c => c.CreatedAt).IsRequired().ValueGeneratedOnAdd().HasDefaultValueSql("now()");
+        builder.Property(c => c.UpdatedAt).HasDefaultValueSql("now()");     
+        builder.Property(c => c.Company).IsRequired(false);
+        builder.Property(c => c.VatNumber).IsRequired(false);
+        builder.Property(c => c.Email).IsRequired();
+        builder.Property(c => c.Phone).IsRequired();
+        builder.Property(c => c.Website).IsRequired();
+        builder.Property(c => c.SocialMedia).IsRequired(false).HasColumnType("jsonb");
+        builder.Property(c => c.Enabled).HasDefaultValue(true);
+    }
+}

LiteCharms.Features.MidrandBooks/Customers/Models/Address.cs

@@ -0,0 +1,32 @@
+namespace LiteCharms.Features.MidrandBooks.Customers.Models;
+
+public class Address
+{
+    public long Id { get; set; }
+
+    public long CustomerId { get; set; }
+
+    public string? Name { get; set; }
+
+    public DateTime CreatedAt { get; set; }
+
+    public DateTime? UpdatedAt { get; set; }
+
+    public AddressType Type { get; set; }
+
+    public AddressBuildingTypes BuildingType { get; set; }
+
+    public string? Street { get; set; }
+
+    public string? City { get; set; }
+
+    public string? State { get; set; }
+
+    public string? PostalCode { get; set; }
+
+    public string? Country { get; set; }
+
+    public bool IsPrimary { get; set; }
+
+    public bool Enabled { get; set; }
+}

LiteCharms.Features.MidrandBooks/Customers/Models/Contact.cs

@@ -0,0 +1,26 @@
+namespace LiteCharms.Features.MidrandBooks.Customers.Models;
+
+public class Contact
+{
+    public long Id { get; set; }
+
+    public long CustomerId { get; set; }
+
+    public DateTime CreatedAt { get; set; }
+
+    public DateTime? UpdatedAt { get; set; }
+
+    public ContactTypes Type { get; set; }
+
+    public string? Name { get; set; }
+
+    public string? LastName { get; set; }
+
+    public string? Email { get; set; }
+
+    public string? Phone { get; set; }
+
+    public bool IsPrimary { get; set; }
+
+    public bool Enabled { get; set; }
+}

LiteCharms.Features.MidrandBooks/Customers/Models/Customer.cs

@@ -0,0 +1,26 @@
+using LiteCharms.Features.Models;
+
+namespace LiteCharms.Features.MidrandBooks.Customers.Models;
+
+public class Customer
+{
+    public long Id { get; set; }
+
+    public DateTime CreatedAt { get; set; }
+
+    public DateTime? UpdatedAt { get; set; }
+
+    public string? Company { get; set; }    
+
+    public string? VatNumber { get; set; }
+
+    public string? Email { get; set; }
+
+    public string? Website { get; set; }
+
+    public string? Phone { get; set; }
+
+    public SocialMedia[]? SocialMedia { get; set; }
+
+    public bool Enabled { get; set; }
+}

LiteCharms.Features.MidrandBooks/Customers/Models/Records.cs

@@ -0,0 +1,60 @@
+using LiteCharms.Features.Models;
+
+namespace LiteCharms.Features.MidrandBooks.Customers.Models;
+
+public record CreateCustomer
+{
+    public string? Company { get; set; }
+
+    public string? VatNumber { get; set; }
+
+    public string? Email { get; set; }
+
+    public string? Website { get; set; }
+
+    public string? Phone { get; set; }
+
+    public SocialMedia[]? SocialMedia { get; set; }
+}
+
+public record UpdateCustomer : CreateCustomer;
+
+public record CreateCustomerContact
+{
+    public ContactTypes Type { get; set; }
+
+    public string? Name { get; set; }
+
+    public string? LastName { get; set; }
+
+    public string? Email { get; set; }
+
+    public string? Phone { get; set; }
+}
+
+public record UpdateCustomerContact : CreateCustomerContact;
+
+public record CreateCustomerAddress
+{
+    public string? Name { get; set; }
+
+    public AddressType Type { get; set; }
+
+    public AddressBuildingTypes BuildingType { get; set; }
+
+    public string? Street { get; set; }
+
+    public string? City { get; set; }
+
+    public string? State { get; set; }
+
+    public string? PostalCode { get; set; }
+
+    public string? Country { get; set; }
+
+    public bool IsPrimary { get; set; }
+
+    public bool Enabled { get; set; }
+}
+
+public record UpdateCustomerAddress : CreateCustomerAddress;

LiteCharms.Features.MidrandBooks/Enums.cs

@@ -0,0 +1,62 @@
+namespace LiteCharms.Features.MidrandBooks;
+
+public enum PublisherTypes : int
+{
+    Individual = 0,
+    Company = 1,
+    Organization = 2,
+    SelfPublished = 3,
+    UniversityPress = 4,
+    GovernmentAgency = 5,
+    NonProfit = 6,
+    Independent = 7
+}
+
+public enum BookTypes : int
+{
+    Fiction = 0,
+    NonFiction = 1,
+    Academic = 2,
+    SelfHelp = 3,
+    Biography = 4,
+    Poetry = 5,
+    Children = 6,
+    YoungAdult = 7,
+    ScienceFiction = 8,
+    Fantasy = 9
+}
+
+public enum BookContentTypes : int
+{
+    Text = 0,
+    Image = 1,
+    Video = 2,
+    Audio = 3,
+    Interactive = 4,
+    Markdown = 5,
+    Html = 6,
+    Json = 7,
+    Yaml = 8
+}
+
+public enum BookPageTypes : int
+{
+    Cover = 0,
+    Preface = 1,
+    Introduction = 2,
+    Content = 3,
+    Closing = 4,
+    Referencer = 5,
+    Credits = 6,
+    BackCover = 7
+}
+
+public enum ProductTypes : int
+{
+    Book = 1,
+    Journal = 2,
+    Magazine = 3,
+    EBook = 4,
+    Audiobook = 5,
+    Accessory = 6
+}

LiteCharms.Features.MidrandBooks/Extensions/HealthChecks.cs

@@ -0,0 +1,30 @@
+using LiteCharms.Features.MidrandBooks.HealthChecks;
+using static LiteCharms.Features.Extensions.Postgres;
+using static LiteCharms.Features.MidrandBooks.Extensions.Postgres;
+
+namespace LiteCharms.Features.MidrandBooks.Extensions;
+
+public static class HealthChecks
+{
+    public static IServiceCollection AddMidrandShopQuartzHealthCheck(this IServiceCollection services)
+    {
+        services.AddHealthChecks().AddCheck<MidrandShopQuartzHealthCheck>(SchedulerDbConfigName);
+
+        return services;
+    }
+
+    public static IServiceCollection AddMidrandShopPostgresHealthCheck(this IServiceCollection services)
+    {
+        services.AddHealthChecks().AddCheck<PostgresMidrandShopHealthCheck>(MidrandBooksDbConfigName);
+
+        return services;
+    }
+
+    public static IServiceCollection AddHealthChecksSupport(this IServiceCollection services, IConfiguration configuration)
+    {
+        services.AddHealthChecks()
+            .AddCheck("Self", () => HealthCheckResult.Healthy());
+
+        return services;
+    }
+}

LiteCharms.Features.MidrandBooks/Extensions/Mappers.cs

@@ -0,0 +1,133 @@
+using LiteCharms.Features.MidrandBooks.AuthorBooks.Models;
+using LiteCharms.Features.MidrandBooks.Authors.Models;
+using LiteCharms.Features.MidrandBooks.Customers.Models;
+using LiteCharms.Features.MidrandBooks.Pages.Models;
+using LiteCharms.Features.MidrandBooks.Products.Models;
+
+namespace LiteCharms.Features.MidrandBooks.Extensions;
+
+public static class Mappers
+{
+    public static Customer ToModel(this Customers.Entities.Customer entiry) => new()
+    {
+        Id = entiry.Id,
+        Company = entiry.Company,
+        CreatedAt = entiry.CreatedAt,
+        Email = entiry.Email,
+        Enabled = entiry.Enabled,
+        Phone = entiry.Phone,
+        SocialMedia = entiry.SocialMedia,
+        UpdatedAt = entiry.UpdatedAt,
+        VatNumber = entiry.VatNumber,
+        Website = entiry.Website        
+    };
+
+    public static Address ToModel(this Customers.Entities.Address entity) => new()
+    {
+        Id = entity.Id,
+        BuildingType = entity.BuildingType,
+        CreatedAt = entity.CreatedAt,
+        CustomerId = entity.CustomerId,
+        Enabled = entity.Enabled,
+        IsPrimary = entity.IsPrimary,
+        Name = entity.Name,
+        PostalCode = entity.PostalCode,
+        Type = entity.Type,
+        UpdatedAt = entity.UpdatedAt,
+        Street = entity.Street,
+        City = entity.City,
+        State = entity.State,
+        Country = entity.Country        
+    };
+
+    public static Contact ToModel(this Customers.Entities.Contact entity) => new()
+    {
+        Id = entity.Id,
+        Type = entity.Type,
+        CreatedAt = entity.CreatedAt,
+        UpdatedAt = entity.UpdatedAt,
+        CustomerId = entity.CustomerId,
+        Email = entity.Email,
+        Enabled = entity.Enabled,
+        LastName = entity.LastName,
+        Name = entity.Name,
+        Phone = entity.Phone
+    };
+
+    public static BookPage ToModel(this Pages.Entities.BookPage entity) => new()
+    {
+        Id = entity.Id,
+        CreatedAt = entity.CreatedAt,
+        UpdatedAt = entity.UpdatedAt,
+        AuthorBookId = entity.AuthorBookId,
+        Content = entity.Content,
+        ContentType = entity.ContentType,
+        Number = entity.Number,
+        Enabled = entity.Enabled,
+        Notes = entity.Notes,
+        References = entity.References,
+        Type = entity.Type        
+    };
+
+    public static AuthorBook ToModel(this AuthorBooks.Entities.AuthorBook entity) => new()
+    {
+        Id = entity.Id,
+        ProductId = entity.ProductId,
+        CreatedAt = entity.CreatedAt,
+        AuthorId = entity.AuthorId,
+        Ranking = entity.Ranking,
+        Rating = entity.Rating,
+        Enabled = entity.Enabled,
+        Product = entity.Product?.ToModel(),
+    };
+
+    public static ProductPrice ToModel(this Products.Entities.ProductPrice entity) => new()
+    {
+        Id = entity.Id,
+        CreatedAt = entity.CreatedAt,
+        UpdatedAt = entity.UpdatedAt,
+        ProductId = entity.ProductId,
+        Amount = entity.Amount,
+        Discount = entity.Discount,
+        Enabled = entity.Enabled
+    };
+
+    public static Product ToModel(this Products.Entities.Product entity)
+    {
+        return new Product
+        {
+            Id = entity.Id,
+            CreatedAt = entity.CreatedAt,
+            UpdatedAt = entity.UpdatedAt,
+            Name = entity.Name,
+            Summary = entity.Summary,
+            Description = entity.Description,
+            Type = entity.Type,
+            ImageUrl = entity.ImageUrl,
+            ThumbnailUrls = entity.ThumbnailUrls,
+            Metadata = entity.Metadata,
+            Categories = entity.Categories,
+            Enabled = entity.Enabled,
+            Price = entity.Prices?.FirstOrDefault(p => p.Enabled)?.ToModel() ?? null,
+        };
+    }
+
+    public static Author ToModel(this Authors.Entities.Author entity) => new()
+    {
+        Id = entity.Id,
+        CreatedAt = entity.CreatedAt,
+        UpdatedAt = entity.UpdatedAt,
+        Name = entity.Name,
+        LastName = entity.LastName,
+        Biography = entity.Biography,
+        Email = entity.Email,
+        Website = entity.Website,
+        ImageUrl = entity.ImageUrl,
+        ThumbnailImageUrl = entity.ThumbnailImageUrl,
+        SocialMedia = entity.SocialMedia,
+        Enabled = entity.Enabled,
+        Company = entity.Company,
+        PublisherType = entity.PublisherType,
+        VatNumber = entity.VatNumber
+    };
+}

LiteCharms.Features.MidrandBooks/Extensions/Postgres.cs

@@ -0,0 +1,16 @@
+using LiteCharms.Features.MidrandBooks.Postgres;
+
+namespace LiteCharms.Features.MidrandBooks.Extensions;
+
+public static class Postgres
+{
+    public const string MidrandBooksDbConfigName = "PostgresMidrandBooks";
+
+    public static IServiceCollection AddMidrandShopDatabase(this IServiceCollection services, IConfiguration configuration)
+    {
+        services.AddPooledDbContextFactory<MidrandBooksDbContext>(options =>
+            options.UseNpgsql(configuration.GetConnectionString(MidrandBooksDbConfigName)));
+
+        return services;
+    }
+}

LiteCharms.Features.MidrandBooks/HealthChecks/MidrandShopQuartzHealthCheck.cs

@@ -0,0 +1,28 @@
+using static LiteCharms.Features.Extensions.Quartz;
+
+namespace LiteCharms.Features.MidrandBooks.HealthChecks;
+
+public class MidrandShopQuartzHealthCheck(ISchedulerFactory schedulerFactory) : IHealthCheck
+{
+    public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            var scheduler = await schedulerFactory.GetScheduler(MidrandShopSchedulerName, cancellationToken);
+
+            if(scheduler == null) 
+                return HealthCheckResult.Unhealthy($"Scheduler with name '{MidrandShopSchedulerName}' not found.");
+
+            if (!scheduler.IsStarted)
+                return HealthCheckResult.Unhealthy($"{MidrandShopSchedulerName} Quartz scheduler is not running");
+
+            await scheduler.CheckExists(new JobKey(Guid.NewGuid().ToString()), cancellationToken);
+
+            return HealthCheckResult.Healthy($"{MidrandShopSchedulerName} Quartz scheduler is ready");
+        }
+        catch (SchedulerException)
+        {
+            return HealthCheckResult.Unhealthy($"{MidrandShopSchedulerName} Quartz scheduler cannot connect to the store");
+        }
+    }
+}

LiteCharms.Features.MidrandBooks/HealthChecks/PostgresMidrandShopHealthCheck.cs

@@ -0,0 +1,28 @@
+using static LiteCharms.Features.MidrandBooks.Extensions.Postgres;
+
+namespace LiteCharms.Features.MidrandBooks.HealthChecks;
+
+public class PostgresMidrandShopHealthCheck(IConfiguration configuration) : IHealthCheck
+{
+    private readonly string connectionString = configuration.GetConnectionString(MidrandBooksDbConfigName)!;
+
+    public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await using var dataSource = NpgsqlDataSource.Create(connectionString);
+            await using var connection = await dataSource.OpenConnectionAsync(cancellationToken);
+
+            await using var command = connection.CreateCommand();
+            command.CommandText = "SELECT 1";
+
+            await command.ExecuteScalarAsync(cancellationToken);
+
+            return HealthCheckResult.Healthy($"{MidrandBooksDbConfigName} is responsive.");
+        }
+        catch (Exception ex)
+        {
+            return HealthCheckResult.Unhealthy($"{MidrandBooksDbConfigName} is unreachable.", ex);
+        }
+    }
+}

LiteCharms.Features.MidrandBooks/LiteCharms.Features.MidrandBooks.csproj

@@ -6,26 +6,16 @@
     <Nullable>enable</Nullable>
     <SignAssembly>True</SignAssembly>
     <AssemblyOriginatorKeyFile>..\LiteCharms.snk</AssemblyOriginatorKeyFile>
-    <JsonSerializerIsReflectionEnabledByDefault>true</JsonSerializerIsReflectionEnabledByDefault>
+    <UserSecretsId>5be62f49-3ed0-4468-884e-1b04e048b45a</UserSecretsId>
-  </PropertyGroup>
-
-  <!-- Warnings And Exclusions -->
-  <PropertyGroup>
-    <NoWarn>$(NoWarn);MA0004</NoWarn>
-    <!-- https://github.com/dotnet/aspnetcore/issues/50836 -->
-    <NoWarn>$(NoWarn);AD0001</NoWarn>
-    <PublishTrimmed>true</PublishTrimmed>
-    <NoWarn>$(NoWarn);IL2080;IL2065;IL2075;IL2087;IL2057;IL2060;IL2070;IL2067;IL2072;IL2026;IL2104</NoWarn>
-    <NoWarn>$(NoWarn);IL2110;IL2111</NoWarn>
   </PropertyGroup>
 
   <!-- Nuget Package Details -->
   <PropertyGroup>
-    <PackageId>LiteCharms.Extensions</PackageId>
+    <PackageId>LiteCharms.Features.MidrandBooks</PackageId>
     <Version>1.0.20</Version>
     <Authors>Khwezi Mngoma</Authors>
     <Company>Lite Charms (PTY) Ltd</Company>
-    <Description>Extension components for Lite Charms applications.</Description>
+    <Description>MidrandBooks feature components for Lite Charms applications.</Description>
     <PackageProjectUrl>https://gitea.khongisa.co.za/litecharms/components</PackageProjectUrl>
     <RepositoryUrl>https://gitea.khongisa.co.za/litecharms/components.git</RepositoryUrl>
     <RepositoryType>git</RepositoryType>
@@ -39,6 +29,32 @@
     <None Include="..\icon.png" Pack="true" PackagePath="\" />
   </ItemGroup>
 
+  <!-- Quartz Scheduler-->
+  <ItemGroup>
+    <PackageReference Include="OpenTelemetry" Version="1.15.3" />
+    <PackageReference Include="Quartz" Version="3.18.1" />
+    <PackageReference Include="Quartz.Plugins" Version="3.18.1" />
+    <PackageReference Include="Quartz.Plugins.TimeZoneConverter" Version="3.18.1" />
+    <PackageReference Include="Quartz.Serialization.SystemTextJson" Version="3.18.1" />
+    <PackageReference Include="Quartz.AspNetCore" Version="3.18.1" />
+    <PackageReference Include="Quartz.Extensions.DependencyInjection" Version="3.18.1" />
+
+    <!-- Global Usings -->
+    <Using Include="Quartz" />
+  </ItemGroup>
+
+  <!-- Configuration -->
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Configuration" Version="10.0.8" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Abstractions" Version="10.0.8" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.EnvironmentVariables" Version="10.0.8" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="10.0.8" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.UserSecrets" Version="10.0.8" />
+
+    <!-- Global Usings -->
+    <Using Include="Microsoft.Extensions.Configuration" />
+  </ItemGroup>
+
   <!-- Health Checks -->
   <ItemGroup>
     <PackageReference Include="AspNetCore.HealthChecks.UI.Client" Version="9.0.0" />
@@ -46,10 +62,9 @@
     <PackageReference Include="AspNetCore.HealthChecks.UI.Core" Version="9.0.0" />
     <PackageReference Include="AspNetCore.HealthChecks.UI.Data" Version="9.0.0" />
     <PackageReference Include="AspNetCore.HealthChecks.UI.InMemory.Storage" Version="9.0.0" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="10.0.7" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="10.0.8" />
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="10.0.7" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="10.0.8" />
-    <PackageReference Include="Quartz.AspNetCore" Version="3.18.1" />
+    <PackageReference Include="Microsoft.Extensions.Diagnostics.HealthChecks" Version="10.0.8" />
-    <PackageReference Include="Quartz.Extensions.DependencyInjection" Version="3.18.1" />
 
     <!-- Global Usings -->
     <Using Include="Microsoft.Extensions.Diagnostics.HealthChecks" />
@@ -75,13 +90,13 @@
 
   <!-- Database -->
   <ItemGroup>
-    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="10.0.7" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="10.0.8" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="10.0.7">
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="10.0.8">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Relational" Version="10.0.7" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Relational" Version="10.0.8" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="10.0.7">
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="10.0.8">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
@@ -94,20 +109,62 @@
     <Using Include="Microsoft.EntityFrameworkCore.Metadata.Builders" />
   </ItemGroup>
 
+  <!-- Email -->
+  <ItemGroup>
+    <PackageReference Include="MailKit" Version="4.16.0" />
+    <PackageReference Include="MimeKit" Version="4.16.0" />
+
+    <!-- Global Usings-->
+    <Using Include="MimeKit" />
+    <Using Include="MailKit.Net.Smtp" />
+  </ItemGroup>
+
+  <!-- CQRS -->
+  <ItemGroup>
+    <PackageReference Include="FluentResults" Version="4.0.0" />
+    <PackageReference Include="Mediator.Abstractions" Version="3.0.2" />
+
+    <!-- Global Usings -->
+    <Using Include="FluentResults" />
+    <Using Include="Mediator" />
+  </ItemGroup>
+
+  <!-- Amazon S3 SDK -->
+  <ItemGroup>
+    <PackageReference Include="AWSSDK.Extensions.NetCore.Setup" Version="4.0.4.1" />
+    <PackageReference Include="AWSSDK.S3" Version="4.0.23.4" />
+    <ProjectReference Include="..\LiteCharms.Features\LiteCharms.Features.csproj" />
+
+    <!-- global Usings -->
+    <Using Include="Amazon.S3" />
+    <Using Include="Amazon.S3.Model" />
+    <Using Include="Amazon.Runtime" />
+  </ItemGroup>
+
   <!-- Shared Usings -->
   <ItemGroup>
-    <Using Include="Quartz" />
     <Using Include="Microsoft.AspNetCore.Builder" />
-    <Using Include="Microsoft.Extensions.Configuration" />
+    <Using Include="Microsoft.Extensions.Hosting" />
+    <Using Include="System.Text" />
+    <Using Include="System.Text.Json" />
+    <Using Include="System.Threading.Channels" />
+    <Using Include="System.Collections.ObjectModel" />
+    <Using Include="System.Diagnostics" />
+    <Using Include="System.Diagnostics.Metrics" />
     <Using Include="Microsoft.Extensions.DependencyInjection" />
+    <Using Include="System.Security.Cryptography" />
+    <Using Include="Microsoft.Extensions.Options" />
     <Using Include="Microsoft.Extensions.Logging" />
   </ItemGroup>
 
-  <!-- Project References -->
   <ItemGroup>
-    <ProjectReference Include="..\LiteCharms.Entities\LiteCharms.Entities.csproj" />
+    <None Update="appsettings.json">
-    <ProjectReference Include="..\LiteCharms.Infrastructure\LiteCharms.Infrastructure.csproj" />
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    <ProjectReference Include="..\LiteCharms.Models\LiteCharms.Models.csproj" />
+    </None>
+  </ItemGroup>
+
+  <ItemGroup>
+    <Folder Include="Order\Entities\" />
   </ItemGroup>
 
 </Project>

LiteCharms.Features.MidrandBooks/Order/Models/Order.cs

@@ -0,0 +1,22 @@
+namespace LiteCharms.Features.MidrandBooks.Order.Models;
+
+public class Order
+{
+    public long Id { get; set; }
+
+    public DateTime CreatedAt { get; set; }
+
+    public DateTime? UpdatedAt { get; set; }
+
+    public long CustomerId { get; set; }
+
+    public OrderStatus Status { get; set; }
+
+    public decimal Total { get; set; }
+
+    public string[]? Notes { get; set; }
+
+    public string[]? Terms { get; set; }
+
+    public string? InvoiceUrl { get; set; }
+}

LiteCharms.Features.MidrandBooks/Order/Models/Refund.cs

@@ -0,0 +1,20 @@
+namespace LiteCharms.Features.MidrandBooks.Order.Models;
+
+public class Refund
+{
+    public Guid Id { get; set; }
+
+    public DateTime CreatedAt { get; set; }
+
+    public DateTime? UpdatedAt { get; set; }
+
+    public Guid OrderId { get; set; }
+
+    public RefundTypes Type { get; set; }
+
+    public RefundStatus Status { get; set; }
+
+    public string? Reason { get; set; }
+
+    public decimal Amount { get; set; }
+}

LiteCharms.Features.MidrandBooks/Order/Models/Shipping.cs

@@ -0,0 +1,14 @@
+namespace LiteCharms.Features.MidrandBooks.Order.Models;
+
+public class Shipping
+{
+    public long Id { get; set; }
+
+    public DateTime CreatedAt { get; set; }
+
+    public DateTime? UpdatedAt { get; set; }
+
+    public long OrderId { get; set; }
+
+    public ShippingStatuses Status { get; set; }
+}

LiteCharms.Features.MidrandBooks/Order/Models/ShippingProvider.cs

@@ -0,0 +1,18 @@
+namespace LiteCharms.Features.MidrandBooks.Order.Models;
+
+public class ShippingProvider
+{
+    public long Id { get; set; }
+
+    public DateTime CreatedAt { get; set; }
+
+    public DateTime? UpdatedAt { get; set; }
+
+    public ShippingProviderTypes Type { get; set; }
+
+    public string? Name { get; set; }
+
+    public decimal? Price { get; set; }
+
+    public bool Enabled { get; set; }
+}

LiteCharms.Features.MidrandBooks/Pages/Entities/BookPage.cs

@@ -0,0 +1,9 @@
+using LiteCharms.Features.MidrandBooks.AuthorBooks.Entities;
+
+namespace LiteCharms.Features.MidrandBooks.Pages.Entities;
+
+[EntityTypeConfiguration<BookPageConfiguration, BookPage>]
+public class BookPage : Models.BookPage
+{
+    public virtual AuthorBook Book { get; set; } = new();
+}

LiteCharms.Features.MidrandBooks/Pages/Entities/BookPageConfiguration.cs

@@ -0,0 +1,26 @@
+namespace LiteCharms.Features.MidrandBooks.Pages.Entities;
+
+public class BookPageConfiguration : IEntityTypeConfiguration<BookPage>
+{
+    public void Configure(EntityTypeBuilder<BookPage> builder)
+    {
+        builder.ToTable("BookPages");
+
+        builder.HasKey(bp => bp.Id);
+        builder.Property(bp => bp.CreatedAt).IsRequired().ValueGeneratedOnAdd().HasDefaultValueSql("now()");
+        builder.Property(bp => bp.UpdatedAt).HasDefaultValueSql("now()");
+        builder.Property(bp => bp.Number).IsRequired().HasDefaultValue(0);
+        builder.Property(bp => bp.AuthorBookId).IsRequired();
+        builder.Property(bp => bp.Content).IsRequired();
+        builder.Property(bp => bp.Type).IsRequired();
+        builder.Property(bp => bp.ContentType).IsRequired();
+        builder.Property(bp => bp.Notes).IsRequired(false).HasColumnType("jsonb");
+        builder.Property(bp => bp.References).IsRequired(false).HasColumnType("jsonb");
+        builder.Property(bp => bp.Enabled).HasDefaultValue(true);
+
+        builder.HasOne(f =>f.Book)
+            .WithMany(b => b.Pages)
+            .HasForeignKey(f => f.AuthorBookId)
+            .OnDelete(DeleteBehavior.NoAction);
+    }
+}

LiteCharms.Features.MidrandBooks/Pages/Models/BookPage.cs

@@ -0,0 +1,28 @@
+using LiteCharms.Features.Models;
+
+namespace LiteCharms.Features.MidrandBooks.Pages.Models;
+
+public class BookPage
+{
+    public long Id { get; set; }
+
+    public long AuthorBookId { get; set; }
+
+    public DateTime CreatedAt { get; set; }
+
+    public DateTime? UpdatedAt { get; set; }
+
+    public BookPageTypes Type { get; set; }
+
+    public BookContentTypes ContentType { get; set; }
+
+    public int Number { get; set; }
+
+    public byte[]? Content { get; set; }
+
+    public string[]? Notes { get; set; }
+
+    public PageReference[]? References { get; set; }
+
+    public bool Enabled { get; set; }
+}

LiteCharms.Features.MidrandBooks/Pages/Models/CreateBookPage.cs

@@ -0,0 +1,18 @@
+using LiteCharms.Features.Models;
+
+namespace LiteCharms.Features.MidrandBooks.Pages.Models;
+
+public class CreateBookPage
+{
+    public BookPageTypes Type { get; set; }
+
+    public BookContentTypes ContentType { get; set; }
+
+    public int Number { get; set; }
+
+    public byte[]? Content { get; set; }
+
+    public string[]? Notes { get; set; }
+
+    public PageReference[]? References { get; set; }
+}

LiteCharms.Features.MidrandBooks/Pages/Models/UpdateBookPage.cs

@@ -0,0 +1,3 @@
+namespace LiteCharms.Features.MidrandBooks.Pages.Models;
+
+public class UpdateBookPage : CreateBookPage;

LiteCharms.Features.MidrandBooks/Pages/PageService.cs

@@ -0,0 +1,226 @@
+using LiteCharms.Features.MidrandBooks.Abstractions;
+using LiteCharms.Features.MidrandBooks.Extensions;
+using LiteCharms.Features.MidrandBooks.Pages.Models;
+using LiteCharms.Features.MidrandBooks.Postgres;
+
+namespace LiteCharms.Features.MidrandBooks.Pages;
+
+public class PageService(IDbContextFactory<MidrandBooksDbContext> contextFactory) : IService
+{
+    public async ValueTask<Result> DeleteAllAsync(long authorBookId, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            if (!await context.Books.AnyAsync(b => b.Id == authorBookId, cancellationToken))
+                return Result.Fail("Book not found");
+
+            var pages = await context.Pages.Where(p => p.AuthorBookId == authorBookId).ToListAsync(cancellationToken);
+
+            if (pages.Count == 0)
+                return Result.Fail("No pages found for the specified book");
+
+            context.Pages.RemoveRange(pages);
+
+            await context.SaveChangesAsync(cancellationToken);
+
+            return Result.Ok();
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result> DeleteByPageTypeAsync(long authorBookId, int pageNumber, BookPageTypes pageType, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var page = await context.Pages.FirstOrDefaultAsync(p => p.AuthorBookId == authorBookId && p.Number == pageNumber && p.Type == pageType, cancellationToken);
+
+            if (page is null)
+                return Result.Fail("Page not found");
+
+            context.Pages.Remove(page);
+
+            return await context.SaveChangesAsync(cancellationToken) > 0
+                ? Result.Ok()
+                : Result.Fail("Failed to delete page");
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result> UpdatePageStatusAsync(long bookPageId, bool enabled, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var page = await context.Pages.FirstOrDefaultAsync(p => p.Id == bookPageId, cancellationToken);
+
+            if (page is null)
+                return Result.Fail("Page not found");
+
+            page.UpdatedAt = DateTime.UtcNow;
+            page.Enabled = enabled;
+
+            return await context.SaveChangesAsync(cancellationToken) > 0
+                ? Result.Ok()
+                : Result.Fail("Failed to update page status");
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result> DeletePageAsync(long bookPageId, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var page = await context.Pages.FirstOrDefaultAsync(p => p.Id == bookPageId, cancellationToken);
+
+            if (page is null)
+                return Result.Fail("Page not found");
+
+            context.Pages.Remove(page);
+
+            return await context.SaveChangesAsync(cancellationToken) > 0
+                ? Result.Ok()
+                : Result.Fail("Failed to delete page");
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result> UpdatePageAsync(long bookPageId, UpdateBookPage request, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var page = await context.Pages.FirstOrDefaultAsync(p => p.Id == bookPageId, cancellationToken);
+
+            if (page is null)
+                return Result.Fail("Page not found");
+            
+            page.UpdatedAt = DateTime.UtcNow;
+            page.Type = request.Type;
+            page.ContentType = request.ContentType;
+            page.Number = request.Number;
+            page.Content = request.Content;
+            page.Notes = request.Notes;
+            page.References = request.References;
+
+            return await context.SaveChangesAsync(cancellationToken) > 0
+                ? Result.Ok()
+                : Result.Fail("Failed to update page");
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result<long>> CreatePageAsync(long authorBookId, CreateBookPage request, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            if (!await context.Books.AnyAsync(b => b.Id == authorBookId, cancellationToken))
+                return Result.Fail<long>("Book not found");
+
+            if (await context.Pages.AnyAsync(p => p.AuthorBookId == authorBookId && p.Number == request.Number && p.Type == request.Type, cancellationToken))
+                return Result.Fail<long>("A page with the same number already exists for this book");
+
+            var page = context.Pages.Add(new Entities.BookPage
+            {
+                AuthorBookId = authorBookId,
+                Type = request.Type,
+                ContentType = request.ContentType,
+                Number = request.Number,
+                Content = request.Content,
+                Notes = request.Notes,
+                References = request.References,
+                Enabled = true
+            });
+
+            return await context.SaveChangesAsync(cancellationToken) > 0
+                ? Result.Ok(page.Entity.Id)
+                : Result.Fail<long>("Failed to create page");
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail<long>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result<BookPage[]>> GetPagesAsync(long authorBookId, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            if (!await context.Books.AnyAsync(b => b.Id == authorBookId, cancellationToken))
+                return Result.Fail<BookPage[]>("Book not found");
+
+            var pages = await context.Pages.AsNoTracking()
+                .Where(p => p.AuthorBookId == authorBookId).ToArrayAsync(cancellationToken);
+
+            return pages?.Length > 0
+                ? Result.Ok(pages.Select(p => p.ToModel()).ToArray())
+                : Result.Fail<BookPage[]>("No pages found for the specified book");
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail<BookPage[]>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result<BookPage>> GetPageByNumberAsync(long pageId, int number, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var page = await context.Pages.FirstOrDefaultAsync(p => p.Id == pageId && p.Number == number, cancellationToken);
+
+            return page is not null
+                ? page.ToModel()
+                : Result.Fail<BookPage>("Page not found");
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail<BookPage>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result<BookPage>> GetPageAsync(long pageId, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var page = await context.Pages.FirstOrDefaultAsync(p => p.Id == pageId, cancellationToken);
+
+            return page is not null
+                ? page.ToModel()
+                : Result.Fail<BookPage>("Page not found");
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail<BookPage>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+}

LiteCharms.Features.MidrandBooks/Postgres/MidrandBooksDbContext.cs

@@ -0,0 +1,26 @@
+using LiteCharms.Features.MidrandBooks.AuthorBooks.Entities;
+using LiteCharms.Features.MidrandBooks.Authors.Entities;
+using LiteCharms.Features.MidrandBooks.Customers.Entities;
+using LiteCharms.Features.MidrandBooks.Pages.Entities;
+using LiteCharms.Features.MidrandBooks.Products.Entities;
+
+namespace LiteCharms.Features.MidrandBooks.Postgres;
+
+public class MidrandBooksDbContext(DbContextOptions<MidrandBooksDbContext> options) : DbContext(options)
+{
+    public DbSet<Author> Authors => Set<Author>();
+
+    public DbSet<Product> Products => Set<Product>();
+
+    public DbSet<ProductPrice> Prices => Set<ProductPrice>();
+
+    public DbSet<AuthorBook> Books => Set<AuthorBook>();
+
+    public DbSet<BookPage> Pages => Set<BookPage>();
+
+    public DbSet<Contact> Contacts => Set<Contact>();
+
+    public DbSet<Address> Addresses => Set<Address>();
+
+    public DbSet<Customer> Customers => Set<Customer>();
+}

LiteCharms.Features.MidrandBooks/Postgres/MidrandBooksDbContextFactory.cs

@@ -0,0 +1,21 @@
+using static LiteCharms.Features.MidrandBooks.Extensions.Postgres;
+
+namespace LiteCharms.Features.MidrandBooks.Postgres;
+
+public class MidrandBooksDbContextFactory : IDesignTimeDbContextFactory<MidrandBooksDbContext>
+{
+    public MidrandBooksDbContext CreateDbContext(string[] args)
+    {
+        var configuration = new ConfigurationBuilder()
+            .SetBasePath(Directory.GetCurrentDirectory())
+            .AddUserSecrets(typeof(MidrandBooksDbContext).Assembly)
+            .AddJsonFile("appsettings.json")
+            .AddEnvironmentVariables()
+            .Build();
+
+        var optionsBuilder = new DbContextOptionsBuilder<MidrandBooksDbContext>();
+        optionsBuilder.UseNpgsql(configuration.GetConnectionString(MidrandBooksDbConfigName));
+
+        return new MidrandBooksDbContext(optionsBuilder.Options);
+    }
+}

LiteCharms.Features.MidrandBooks/Products/Entities/Product.cs

@@ -0,0 +1,7 @@
+namespace LiteCharms.Features.MidrandBooks.Products.Entities;
+
+[EntityTypeConfiguration<ProductConfiguration, Product>]
+public class Product : Models.Product
+{
+    public virtual ICollection<ProductPrice> Prices { get; set; } = [];
+}

LiteCharms.Features.MidrandBooks/Products/Entities/ProductConfiguration.cs

@@ -0,0 +1,22 @@
+namespace LiteCharms.Features.MidrandBooks.Products.Entities;
+
+public class ProductConfiguration : IEntityTypeConfiguration<Product>
+{
+    public void Configure(EntityTypeBuilder<Product> builder)
+    {
+        builder.ToTable("Products");
+
+        builder.HasKey(f => f.Id);
+        builder.Property(f => f.CreatedAt).IsRequired().ValueGeneratedOnAdd().HasDefaultValueSql("now()");
+        builder.Property(f => f.UpdatedAt).HasDefaultValueSql("now()");
+        builder.Property(f => f.Type).IsRequired();
+        builder.Property(f => f.Name).IsRequired().HasMaxLength(255);
+        builder.Property(f => f.Summary).IsRequired().HasMaxLength(512);
+        builder.Property(f => f.Description).HasMaxLength(1024);
+        builder.Property(f => f.ImageUrl).HasMaxLength(1024);
+        builder.Property(f => f.ThumbnailUrls).IsRequired(false).HasColumnType("jsonb");
+        builder.Property(f => f.Metadata).IsRequired(false).HasColumnType("jsonb");
+        builder.Property(f => f.Categories).IsRequired(false).HasColumnType("jsonb");
+        builder.Property(f => f.Enabled).HasDefaultValue(false);
+    }
+}

LiteCharms.Features.MidrandBooks/Products/Entities/ProductPrice.cs

@@ -0,0 +1,7 @@
+namespace LiteCharms.Features.MidrandBooks.Products.Entities;
+
+[EntityTypeConfiguration<ProductPriceConfiguration, ProductPrice>]
+public class ProductPrice : Models.ProductPrice
+{
+    public virtual Product Product { get; set; } = new();
+}

LiteCharms.Features.MidrandBooks/Products/Entities/ProductPriceConfiguration.cs

@@ -0,0 +1,22 @@
+namespace LiteCharms.Features.MidrandBooks.Products.Entities;
+
+public class ProductPriceConfiguration : IEntityTypeConfiguration<ProductPrice>
+{
+    public void Configure(EntityTypeBuilder<ProductPrice> builder)
+    {
+        builder.ToTable("Prices");
+
+        builder.HasKey(f => f.Id);
+        builder.Property(f => f.CreatedAt).IsRequired().ValueGeneratedOnAdd().HasDefaultValueSql("now()");
+        builder.Property(f => f.UpdatedAt).HasDefaultValueSql("now()");
+        builder.Property(f => f.ProductId).IsRequired();
+        builder.Property(f => f.Amount).IsRequired().HasPrecision(18, 2);
+        builder.Property(f => f.Discount).IsRequired().HasPrecision(18, 2);
+        builder.Property(f => f.Enabled).HasDefaultValue(false);
+
+        builder.HasOne(f => f.Product)
+            .WithMany(p => p.Prices)
+            .HasForeignKey(f => f.ProductId)
+            .OnDelete(DeleteBehavior.Restrict);
+    }
+}

LiteCharms.Features.MidrandBooks/Products/Models/CreateProductPrice.cs

@@ -0,0 +1,10 @@
+namespace LiteCharms.Features.MidrandBooks.Products.Models;
+
+public class CreateProductPrice
+{
+    public long ProductId { get; set; }
+
+    public decimal Amount { get; set; }
+
+    public decimal Discount { get; set; }
+}

LiteCharms.Features.MidrandBooks/Products/Models/Product.cs

@@ -0,0 +1,32 @@
+using LiteCharms.Features.Models;
+
+namespace LiteCharms.Features.MidrandBooks.Products.Models;
+
+public class Product
+{
+    public long Id { get; set; }
+
+    public DateTime CreatedAt { get; set; }
+
+    public DateTime? UpdatedAt { get; set; }
+
+    public ProductTypes Type { get; set; }
+
+    public string? Name { get; set; }
+
+    public string? Summary { get; set; }
+
+    public string? Description { get; set; }
+
+    public string? ImageUrl { get; set; }
+
+    public string[]? ThumbnailUrls { get; set; }
+
+    public string[]? Categories { get; set; }
+
+    public ProductMetadata? Metadata { get; set; }
+
+    public ProductPrice? Price { get; set; }
+
+    public bool Enabled { get; set; }
+}

LiteCharms.Features.MidrandBooks/Products/Models/ProductPrice.cs

@@ -0,0 +1,18 @@
+namespace LiteCharms.Features.MidrandBooks.Products.Models;
+
+public class ProductPrice
+{
+    public long Id { get; set; }
+
+    public DateTime CreatedAt { get; set; }
+
+    public DateTime? UpdatedAt { get; set; }
+
+    public long ProductId { get; set; }
+
+    public decimal Amount { get; set; }
+
+    public decimal Discount { get; set; }
+
+    public bool Enabled { get; set; }
+}

LiteCharms.Features.MidrandBooks/Products/Models/Records.cs

@@ -0,0 +1,22 @@
+using LiteCharms.Features.Models;
+
+namespace LiteCharms.Features.MidrandBooks.Products.Models;
+
+public record CreateProduct
+{
+    public required ProductTypes Type { get; set; }
+
+    public required string Name { get; set; }
+
+    public required string Summary { get; set; }
+
+    public required string Description { get; set; }
+
+    public required string ImageUrl { get; set; }
+
+    public string[]? ThumbnailUrls { get; set; }
+
+    public string[]? Categories { get; set; }
+
+    public ProductMetadata? Metadata { get; set; }
+}

LiteCharms.Features.MidrandBooks/Products/ProductService.cs

@@ -0,0 +1,256 @@
+using LiteCharms.Features.MidrandBooks.Abstractions;
+using LiteCharms.Features.MidrandBooks.Extensions;
+using LiteCharms.Features.MidrandBooks.Postgres;
+using LiteCharms.Features.MidrandBooks.Products.Models;
+using LiteCharms.Features.Models;
+
+namespace LiteCharms.Features.MidrandBooks.Products;
+
+public class ProductService(IDbContextFactory<MidrandBooksDbContext> contextFactory) : IService
+{
+    public async ValueTask<Result> UpdateProductPriceStatusAsync(long productPriceId, bool isEnabled, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var productPrice = await context.Prices.FirstOrDefaultAsync(p => p.Id == productPriceId, cancellationToken);
+
+            if (productPrice is null)
+                return Result.Fail(new Error($"Product price with ID {productPriceId} not found"));
+
+            productPrice.UpdatedAt = DateTime.UtcNow;
+            productPrice.Enabled = isEnabled;
+
+            return await context.SaveChangesAsync(cancellationToken) > 0
+                ? Result.Ok()
+                : Result.Fail(new Error($"Failed to change status of product price with ID {productPriceId}"));
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result> UpdateProductStatusAsync(long productId, bool isEnabled, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var product = await context.Products.FirstOrDefaultAsync(p => p.Id == productId, cancellationToken);
+
+            if (product is null)
+                return Result.Fail(new Error($"Product with ID {productId} not found"));
+
+            product.UpdatedAt = DateTime.UtcNow;
+            product.Enabled = isEnabled;
+
+            return await context.SaveChangesAsync(cancellationToken) > 0
+                ? Result.Ok()
+                : Result.Fail(new Error($"Failed to change status of product with ID {productId}"));
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result<Product[]>> SearchProductsAsync(ProductFilter filter, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var query = context.Products.AsQueryable();
+
+            if (!string.IsNullOrWhiteSpace(filter.Title))
+                query = query.Where(p => p.Name!.Contains(filter.Title));
+
+            if (!string.IsNullOrWhiteSpace(filter.Category))
+                query = query.Where(p => p.Categories!.Any(c => c == filter.Category));
+
+            if (!string.IsNullOrWhiteSpace(filter.Manufacturer))
+                query = query.Where(p => p.Metadata!.Manufacturer == filter.Manufacturer);
+
+            if (!string.IsNullOrWhiteSpace(filter.SerialNumber))
+                query = query.Where(p => p.Metadata!.SerialNumber == filter.SerialNumber);
+
+            if (filter.MinPrice > 0)
+                query = query.Where(p => p.Prices!.Any(pr => pr.Amount >= filter.MinPrice && pr.Amount <= filter.MaxPrice));
+
+            var products = await query.AsNoTracking().Where(p => p.Enabled).ToListAsync(cancellationToken);
+
+            return products?.Count > 0
+                ? Result.Ok(products.Select(p => p.ToModel()).ToArray())
+                : Result.Fail<Product[]>("No products found.");
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail<Product[]>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result<long>> CreateProductPriceAsync(long productId, CreateProductPrice request, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            if (!await context.Products.AnyAsync(p => p.Id == productId, cancellationToken))
+                return Result.Fail<long>($"Product with ID {productId} does not exist.");
+
+            var existingPrices = await context.Prices.Where(p => p.ProductId == productId).ToListAsync(cancellationToken);
+
+            if (existingPrices.Count > 0)
+                foreach (var existingPrice in existingPrices)
+                {
+                    existingPrice.Enabled = false;
+                    existingPrice.UpdatedAt = DateTime.UtcNow;
+                    context.Prices.Update(existingPrice);
+                }
+
+            var price = context.Prices.Add(new Entities.ProductPrice
+            {
+                ProductId = productId,
+                Amount = request.Amount,
+                Discount = request.Discount,
+                Enabled = true,
+            });
+
+            return await context.SaveChangesAsync(cancellationToken) > 0
+                ? Result.Ok(price.Entity.Id)
+                : Result.Fail<long>("Failed to create product price.");
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail<long>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result<long>> CreateProductAsync(CreateProduct request, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            if (await context.Products.AnyAsync(p => p.Name == request.Name, cancellationToken))
+                return Result.Fail<long>("A product with the same name already exists.");
+
+            if (request.Metadata is not null)
+                if (await context.Products.AnyAsync(p => p.Metadata!.SerialNumber == request.Metadata.SerialNumber, cancellationToken))
+                    return Result.Fail<long>("A product with the same metadata already exists.");
+
+            var product = context.Products.Add(new Entities.Product
+            {
+                UpdatedAt = DateTime.UtcNow,
+                Type = request.Type,
+                Name = request.Name,
+                Summary = request.Summary,
+                Description = request.Description,
+                ImageUrl = request.ImageUrl,
+                ThumbnailUrls = request.ThumbnailUrls,
+                Metadata = request.Metadata,
+                Categories = request.Categories,
+                Enabled = true
+            });
+
+            return await context.SaveChangesAsync(cancellationToken) > 0
+                ? Result.Ok(product.Entity.Id)
+                : Result.Fail<long>("Failed to create product.");
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail<long>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result<ProductPrice[]>> GetProductPriceAsync(long productId, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var product = await context.Prices
+                .AsNoTracking()
+                .OrderByDescending(p => p.CreatedAt)
+                    .ThenBy(p => p.UpdatedAt)
+                .FirstOrDefaultAsync(p => p.ProductId == productId, cancellationToken);
+
+            return product is not null
+                ? Result.Ok(new[] { product.ToModel() })
+                : Result.Fail<ProductPrice[]>(new Error($"No price found for product with ID {productId}"));
+
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail<ProductPrice[]>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result<ProductPrice[]>> GetProductPricesAsync(long productId, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var prices = await context.Prices.Where(p => p.ProductId == productId).ToListAsync(cancellationToken);
+
+            return prices?.Count > 0
+                ? prices.Select(p => p.ToModel()).ToArray()
+                : Result.Fail<ProductPrice[]>(new Error($"No prices found for product with ID {productId}"));
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail<ProductPrice[]>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result<Product>> GetProductAsync(long productId, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var product = await context.Products.AsNoTracking().FirstOrDefaultAsync(p => p.Id == productId, cancellationToken);
+
+            return product is null
+                ? Result.Fail<Product>(new Error($"Product with ID {productId} not found."))
+                : Result.Ok(product.ToModel());
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail<Product>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result<Product[]>> GetProductsAsync(int offset, DateRange range, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            var fromDate = range.From.ToDateTime(TimeOnly.MinValue);
+            var toDate = range.To.ToDateTime(TimeOnly.MaxValue);
+
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var products = await context.Products
+                .AsNoTracking()
+                .Include(p => p.Prices)
+                .OrderByDescending(p => p.CreatedAt)
+                    .ThenByDescending(p => p.UpdatedAt)
+                .Where(p => p.CreatedAt >= fromDate && p.CreatedAt <= toDate)
+                .Skip(offset)
+                .Take(range.MaxRecords)
+                .AsSplitQuery()
+                .ToArrayAsync(cancellationToken);
+
+            return await context.SaveChangesAsync(cancellationToken) > 0
+                ? Result.Ok(products.Select(p => p.ToModel()).ToArray())
+                : Result.Fail<Product[]>(new Error("Failed to retrieve products."));
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail<Product[]>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+}

LiteCharms.Features.MidrandBooks/appsettings.json

@@ -0,0 +1,22 @@
+{
+  "Email": {
+    "Credentials": {
+      "Username": "shop@litecharms.co.za"
+    },
+    "Port": 465,
+    "Host": "mail.litecharms.co.za",
+    "UseSsl": true
+  },
+  "Monitoring": {
+    "ApiKey": "",
+    "Address": "http://aspire-dashboard-service.aspire.svc.cluster.local:18889",
+    "ServiceName": "MidrandBooks"
+  },
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  },
+  "AllowedHosts": "*"
+}

LiteCharms.Features.TechShop.Tests/Fixture.cs

@@ -0,0 +1,38 @@
+using LiteCharms.Features.Extensions;
+using LiteCharms.Features.TechShop.Extensions;
+
+namespace LiteCharms.Features.TechShop.Tests;
+
+public class Fixture : IDisposable
+{
+    public IConfiguration Configuration { get; set; }
+
+    public IServiceProvider Services { get; set; }
+
+    public IMediator Mediator { get; set; }
+
+    public Fixture()
+    {
+        Configuration = new ConfigurationBuilder()
+            .SetBasePath(Directory.GetCurrentDirectory())
+            .AddUserSecrets<Fixture>()
+            .AddJsonFile(Path.Combine(Directory.GetCurrentDirectory(), "appsettings.json"), optional: true, reloadOnChange: true)
+            .AddEnvironmentVariables()
+            .Build();
+
+        Services = new ServiceCollection()            
+            .AddMediator()
+            .AddLogging()
+            .AddTechShopServices()
+            .AddEmailServiceBus()
+            .AddGarageS3(Configuration)
+            .AddTechShopDatabase(Configuration)
+            .AddEmailServices(Configuration)
+            .AddSingleton(Configuration)
+            .BuildServiceProvider();
+
+        Mediator = Services.GetRequiredService<IMediator>();
+    }
+
+    public void Dispose() { }
+}

LiteCharms.Features.TechShop.Tests/LiteCharms.Features.TechShop.Tests.csproj

@@ -0,0 +1,51 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <IsPackable>false</IsPackable>
+    <UserSecretsId>fa06c1a6-2ba8-4c47-b19b-11e0f78e7b92</UserSecretsId>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="coverlet.collector" Version="10.0.1">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Mediator.SourceGenerator" Version="3.0.2">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.5.1" />
+    <PackageReference Include="xunit" Version="2.9.3" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="3.1.5">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <!-- Global Usings -->
+  <ItemGroup>
+    <Using Include="Mediator" />
+    <Using Include="Xunit.Abstractions" />
+    <Using Include="Microsoft.Extensions.DependencyInjection" />
+    <Using Include="Microsoft.Extensions.Configuration" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\LiteCharms.Features.TechShop\LiteCharms.Features.TechShop.csproj" />
+    <ProjectReference Include="..\LiteCharms.Features\LiteCharms.Features.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="Xunit" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Update="appsettings.json">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
+
+</Project>

LiteCharms.Features.TechShop.Tests/NotificationsFeatureTests.cs

@@ -0,0 +1,65 @@
+using LiteCharms.Features.Models;
+using LiteCharms.Features.TechShop.Notifications;
+using LiteCharms.Features.TechShop.Notifications.Events;
+using static LiteCharms.Features.Extensions.Email;
+
+namespace LiteCharms.Features.TechShop.Tests;
+
+public class NotificationsFeatureTests(Fixture fixture, ITestOutputHelper output) : IClassFixture<Fixture>
+{
+    private readonly NotificationService notificationService = fixture.Services.GetRequiredService<NotificationService>();
+
+    [Fact]
+    public async Task CreateNotificationCommand_ShouldSucceed()
+    {
+        Notifications.Models.CreateNotification request = new()
+        {
+            CorrelationId = Guid.CreateVersion7().ToString(),
+            CorrelationIdType = CorrelationIdTypes.None,
+            Direction = NotificationDirection.Outgoing,
+            Platform = NotificationPlatforms.Email,
+            Priority = Priorities.Medium,
+            Sender = "xUnit Test",
+            SenderAddress = "khwezi@mngoma.africa",
+            Recipient = $"{ShopEmailFromName} [Test]",
+            RecipientAddress = ShopEmailFromAddress,
+            Subject = "Test Message",
+            Message = "This is an automation test",
+            IsHtml = false,
+            IsInternal = true,
+        };
+
+        var createResult = await notificationService.CreateNotificationAsync(request);
+
+        Assert.True(createResult.IsSuccess);
+
+        foreach (var error in createResult.Errors) output.WriteLine(error.Message);
+    }
+
+    [Fact]
+    public async Task GetNotifications_ShouldReturn_AllNotifications()
+    {
+        DateRange range = new()
+        {
+            From = DateOnly.FromDateTime(new DateTime(2026, 04, 01, 0, 0, 0, DateTimeKind.Utc)),
+            To = DateOnly.FromDateTime(DateTime.UtcNow),
+            MaxRecords = 10
+        };
+
+        var getResult = await notificationService.GetNotificationsAsync(range);
+
+        Assert.True(getResult.IsSuccess);
+
+        foreach (var error in getResult.Errors) output.WriteLine(error.Message);
+    }
+
+    [Fact]
+    public async Task ProcessEmailNotificationsEvent_ShouldSucceed()
+    {
+        var notification = ProcessEmailNotificationsEvent.Create();
+
+        await fixture.Mediator.Publish(notification);
+
+        Assert.True(true);
+    }
+}

LiteCharms.Features.TechShop.Tests/ProductsFeatureTests.cs

@@ -0,0 +1,19 @@
+using LiteCharms.Features.TechShop.Products;
+
+namespace LiteCharms.Features.TechShop.Tests;
+
+public class ProductsFeatureTests(Fixture fixture, ITestOutputHelper output) : IClassFixture<Fixture>
+{
+    [Fact]
+    public async Task GetProductsAsync_ReturnsProducts()
+    {
+        var productService = fixture.Services.GetRequiredService<ProductService>();
+
+        var result = await productService.GetProductsAsync();
+
+        Assert.True(result.IsSuccess);
+        Assert.NotNull(result.Value);
+
+        output.WriteLine($"Retrieved {result.Value.Length} products.");
+    }
+}

LiteCharms.Features.TechShop.Tests/appsettings.json

@@ -0,0 +1,34 @@
+{
+  "BookshopS3Settings": {
+    "ServiceUrl": "http://192.168.1.177:30900",
+    "Region": "garage",
+    "BucketName": "bookshop",
+    "CdnBaseUrl": "https://bookshop.cdn.khongisa.co.za"
+  },
+  "BookshopQuotesS3Settings": {
+    "ServiceUrl": "http://192.168.1.177:30900",
+    "Region": "garage",
+    "BucketName": "bookshop.quotes",
+    "CdnBaseUrl": "https://bookshop.quotes.cdn.khongisa.co.za"
+  },
+  "Email": {
+    "Credentials": {
+      "Username": "shop@litecharms.co.za"
+    },
+    "Port": 465,
+    "Host": "mail.litecharms.co.za",
+    "UseSsl": true
+  },
+  "Monitoring": {
+    "ApiKey": "",
+    "Address": "http://aspire-dashboard-service.aspire.svc.cluster.local:18889",
+    "ServiceName": "LiteCharms.LeadGenerator"
+  },
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  },
+  "AllowedHosts": "*"
+}

LiteCharms.Features.TechShop/CartPackages/Entities/Package.cs

@@ -1,6 +1,4 @@
-using LiteCharms.Entities.Configuration;
+namespace LiteCharms.Features.TechShop.CartPackages.Entities;
-
-namespace LiteCharms.Entities;
 
 [EntityTypeConfiguration<PackageConfirguration, Package>]
 public class Package : Models.Package

LiteCharms.Features.TechShop/CartPackages/Entities/PackageConfirguration.cs

@@ -0,0 +1,18 @@
+namespace LiteCharms.Features.TechShop.CartPackages.Entities;
+
+public class PackageConfirguration : IEntityTypeConfiguration<Package>
+{
+    public void Configure(EntityTypeBuilder<Package> builder)
+    {
+        builder.ToTable(nameof(Package));
+
+        builder.HasKey(f => f.Id);
+        builder.Property(f => f.CreatedAt).IsRequired().ValueGeneratedOnAdd().HasDefaultValueSql("now()");
+        builder.Property(f => f.UpdatedAt).IsRequired(false).HasDefaultValueSql(null);
+        builder.Property(f => f.Name).IsRequired();
+        builder.Property(f => f.Summary).IsRequired().HasMaxLength(512);
+        builder.Property(f => f.Description).IsRequired().HasMaxLength(2048);
+        builder.Property(f => f.ImageUrl).IsRequired(false).HasMaxLength(2048);
+        builder.Property(f => f.Active);
+    }
+}

LiteCharms.Features.TechShop/CartPackages/Entities/PackageItem.cs

@@ -0,0 +1,11 @@
+using LiteCharms.Features.TechShop.Products.Entities;
+
+namespace LiteCharms.Features.TechShop.CartPackages.Entities;
+
+[EntityTypeConfiguration<PackageItemConfiguration, PackageItem>]
+public class PackageItem : Models.PackageItem
+{
+    public virtual Package? Package { get; set; }
+
+    public virtual ProductPrice? ProductPrice { get; set; }
+}

LiteCharms.Features.TechShop/CartPackages/Entities/PackageItemConfiguration.cs

@@ -1,4 +1,4 @@
-namespace LiteCharms.Entities.Configuration;
+namespace LiteCharms.Features.TechShop.CartPackages.Entities;
 
 public class PackageItemConfiguration : IEntityTypeConfiguration<PackageItem>
 {
@@ -7,14 +7,21 @@ public class PackageItemConfiguration : IEntityTypeConfiguration<PackageItem>
         builder.ToTable(nameof(PackageItem));
 
         builder.HasKey(f => f.Id);
-        builder.Property(f => f.CreatedAt).IsRequired().ValueGeneratedOnAdd();
+        builder.Property(f => f.CreatedAt).IsRequired().ValueGeneratedOnAdd().HasDefaultValueSql("now()");
         builder.Property(f => f.PackageId).IsRequired();
         builder.Property(f => f.ProductPriceId).IsRequired();
         builder.Property(f => f.Active);
 
         builder.HasOne(f => f.Package)
-            .WithMany()
+            .WithMany(f => f.PackageItems)
-            .HasForeignKey(f => f.PackageId)
+            .HasForeignKey(pi => pi.PackageId)
-            .OnDelete(DeleteBehavior.NoAction);
+            .IsRequired()
+            .OnDelete(DeleteBehavior.Cascade);
+
+        builder.HasOne(f => f.ProductPrice)
+               .WithMany()
+               .HasForeignKey(pi => pi.ProductPriceId)
+               .IsRequired()
+               .OnDelete(DeleteBehavior.Restrict);
     }
 }

LiteCharms.Features.TechShop/CartPackages/Models/Package.cs

@@ -0,0 +1,20 @@
+namespace LiteCharms.Features.TechShop.CartPackages.Models;
+
+public class Package
+{
+    public Guid Id { get; set; }
+
+    public DateTime CreatedAt { get; set; }
+
+    public DateTime? UpdatedAt { get; set; }
+
+    public string? Name { get; set; }
+
+    public string? Summary { get; set; }
+
+    public string? Description { get; set; }
+
+    public string? ImageUrl { get; set; }
+
+    public bool Active { get; set; }
+}

LiteCharms.Features.TechShop/CartPackages/Models/PackageItem.cs

@@ -1,4 +1,4 @@
-namespace LiteCharms.Models;
+namespace LiteCharms.Features.TechShop.CartPackages.Models;
 
 public class PackageItem
 {

LiteCharms.Features.TechShop/CartPackages/PackageService.cs

@@ -0,0 +1,242 @@
+using LiteCharms.Features.Extensions;
+using LiteCharms.Features.Models;
+using LiteCharms.Features.TechShop.CartPackages.Models;
+using LiteCharms.Features.TechShop.Extensions;
+using LiteCharms.Features.TechShop.Postgres;
+
+namespace LiteCharms.Features.TechShop.CartPackages;
+
+public class PackageService(IDbContextFactory<ShopDbContext> contextFactory)
+{
+    public async ValueTask<Result<Guid>> AddPackageItemAsync(Guid packageId, Guid productPriceId, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            if (!await context.Packages.AnyAsync(p => p.Id == packageId, cancellationToken))
+                return Result.Fail($"Could not find package by ID {packageId}");
+
+            if (!await context.ProductPrices.AnyAsync(p => p.Id == productPriceId && p.Active == true, cancellationToken))
+                return Result.Fail($"Could not find an active product price by ID {productPriceId}");
+
+            if (await context.PackageItems.AnyAsync(p => p.ProductPriceId == productPriceId && p.PackageId == packageId, cancellationToken))
+                return Result.Fail<Guid>($"Product price {productPriceId} is already added to this package {packageId}");
+
+            var newPackageItem = context.PackageItems.Add(new Entities.PackageItem
+            {
+                PackageId = packageId,
+                ProductPriceId = productPriceId,
+                Active = true
+            });
+
+            return await context.SaveChangesAsync(cancellationToken) > 0
+                ? Result.Ok(newPackageItem.Entity.Id)
+                : Result.Fail<Guid>($"Failed to add new package item by ID {productPriceId}");
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail<Guid>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result<Guid>> CreatePackageAsync(string? name, string? summary, string? description, string? ImageUrl, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            if (await context.Packages.AnyAsync(p => p.Name == name, cancellationToken))
+                return Result.Fail($"A package by the same name already exists: {name}");
+
+            var newPackage = context.Packages.Add(new Entities.Package
+            {
+                Name = name,
+                Summary = summary,
+                Description = description,
+                ImageUrl = ImageUrl,
+                Active = true
+            });
+
+            return await context.SaveChangesAsync(cancellationToken) > 0
+                ? Result.Ok(newPackage.Entity.Id)
+                : Result.Fail($"Failed to create a new package by the name: {name}");
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail<Guid>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result> DeletePackageItemAsync(Guid packageId, Guid packageItemId, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            if (!await context.Packages.AnyAsync(p => p.Id == packageId, cancellationToken))
+                return Result.Fail($"Could not find package by ID {packageId}");
+
+            var item = await context.PackageItems.FirstOrDefaultAsync(p => p.Id == packageItemId && p.PackageId == packageId, cancellationToken);
+
+            if (item is null)
+                return Result.Fail($"Product item {packageItemId} is already added to this package {packageId}");
+
+            context.PackageItems.Remove(item);
+
+            return await context.SaveChangesAsync(cancellationToken) > 0
+                ? Result.Ok()
+                : Result.Fail($"Failed to delete package item by id {packageItemId}");
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result> DeletePackageItemsAsync(Guid packageId, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            if (!await context.Packages.AnyAsync(p => p.Id == packageId, cancellationToken))
+                return Result.Fail($"Could not find package by ID {packageId}");
+
+            var items = await context.PackageItems.Where(i => i.PackageId == packageId).ToArrayAsync(cancellationToken);
+
+            context.PackageItems.RemoveRange(items);
+
+            return await context.SaveChangesAsync(cancellationToken) > 0
+                ? Result.Ok()
+                : Result.Fail($"Failed to delete package {packageId} items");
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result<Package>> GetPackageAsync(Guid packageId, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var package = await context.Packages.FirstOrDefaultAsync(p => p.Id == packageId, cancellationToken);
+
+            return package is not null
+                ? Result.Ok(package.ToModel())
+                : Result.Fail($"Failed to find package by ID {packageId}");
+
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail<Package>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result<PackageItem[]>> GetPackageItemsAsync(Guid packageId, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            if (!await context.Packages.AnyAsync(p => p.Id == packageId, cancellationToken))
+                return Result.Fail<PackageItem[]>($"Package could not be found with ID {packageId}");
+
+            var items = await context.PackageItems.AsNoTracking()
+                .OrderByDescending(o => o.CreatedAt)
+                .Where(p => p.PackageId == packageId)
+                .ToArrayAsync(cancellationToken);
+
+            return items?.Length > 0
+                ? Result.Ok(items.Select(i => i.ToModel()).ToArray())
+                : Result.Fail<PackageItem[]>($"Could not find package items by package ID {packageId}");
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail<PackageItem[]>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result<Package[]>> GetPackagesAsync(Guid packageId, DateRange range, bool active, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            var fromDate = range.From.ToDateTime(TimeOnly.MinValue);
+            var toDate = range.To.ToDateTime(TimeOnly.MaxValue);
+
+            using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var packages = await context.Packages
+                .AsNoTracking()
+                .OrderByDescending(o => o.CreatedAt)
+                .Where(p => p.CreatedAt >= fromDate && p.CreatedAt <= toDate)
+                .Where(p => p.Active == active)
+                .Take(range.MaxRecords)
+                .ToArrayAsync(cancellationToken);
+
+            return packages?.Length > 0
+                ? Result.Ok(packages.Select(o => o.ToModel()).ToArray())
+                : Result.Fail<Package[]>(new Error($"No packages found for the specified date range {range.From} - {range.To}."));
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail<Package[]>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result<Guid>> UpdatePackageAsync(Guid packageId, string? name, string? summary, string? description, string? ImageUrl, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            if (await context.Packages.AnyAsync(p => p.Name == name, cancellationToken))
+                return Result.Fail($"A package by the same name already exists: {name}");
+
+            var package = await context.Packages.FirstOrDefaultAsync(p => p.Id == packageId, cancellationToken);
+
+            if (package is null)
+                return Result.Fail($"Could not find package by id {packageId}");
+
+            package.Name = name;
+            package.Summary = summary;
+            package.Description = description;
+            package.ImageUrl = ImageUrl;
+            package.UpdatedAt = DateTime.UtcNow;
+
+            return await context.SaveChangesAsync(cancellationToken) > 0
+                ? Result.Ok()
+                : Result.Fail($"Failed to update package with id {packageId}");
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result<Guid>> UpdatePackageStatusAsync(Guid packageId, bool active, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var package = await context.Packages.FirstOrDefaultAsync(p => p.Id == packageId, cancellationToken);
+
+            if (package is null)
+                return Result.Fail($"Could not find package by id {packageId}");
+
+            package.Active = active;
+
+            return await context.SaveChangesAsync(cancellationToken) > 0
+                ? Result.Ok()
+                : Result.Fail($"Failed to update package with id {packageId}");
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+}

LiteCharms.Features.TechShop/Customers/CustomerService.cs

@@ -0,0 +1,132 @@
+using LiteCharms.Features.Models;
+using LiteCharms.Features.TechShop.Customers.Models;
+using LiteCharms.Features.TechShop.Extensions;
+using LiteCharms.Features.TechShop.Postgres;
+
+namespace LiteCharms.Features.TechShop.Customers;
+
+public class CustomerService(IDbContextFactory<ShopDbContext> contextFactory)
+{
+    public async ValueTask<Result<Guid>> CreateCustomerAsync(CreateCustomer request, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var customerEmail = request.Email.ToLower().Trim();
+
+            if (await context.Customers.AnyAsync(c => c.Email == customerEmail, cancellationToken))
+                return Result.Fail<Guid>(new Error($"A customer with the email {customerEmail} already exists"));
+
+            var newCustomer = context.Customers.Add(new Entities.Customer
+            {
+                Company = request.Company,
+                Name = request.Name,
+                LastName = request.LastName,
+                Tax = request.Tax,
+                Email = customerEmail,
+                Discord = request.Discord,
+                Slack = request.Slack,
+                LinkedIn = request.LinkedIn,
+                Whatsapp = request.Whatsapp,
+                Website = request.Website,
+                Phone = request.Phone,
+                Address = request.Address,
+                City = request.City,
+                Region = request.Region,
+                Country = request.Country,
+                PostalCode = request.PostalCode,
+                Active = true,
+            });
+
+            return await context.SaveChangesAsync(cancellationToken) > 0
+                ? Result.Ok(newCustomer.Entity.Id)
+                : Result.Fail<Guid>(new Error($"Failed to create customer {customerEmail}"));
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail<Guid>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result<Customer>> GetCustomerAsync(Guid customerId, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var customer = await context.Customers.FirstOrDefaultAsync(c => c.Id == customerId, cancellationToken);
+
+            return customer is not null
+                ? Result.Ok(customer.ToModel())
+                : Result.Fail<Customer>($"Customer not found with id {customerId}");
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail<Customer>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result<Customer[]>> GetCustomersAsync(DateRange range, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            var fromDate = range.From.ToDateTime(TimeOnly.MinValue);
+            var toDate = range.To.ToDateTime(TimeOnly.MaxValue);
+
+            using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var customers = await context.Customers.AsNoTracking()
+                .OrderByDescending(o => o.CreatedAt)
+                .Where(c => c.CreatedAt >= fromDate && c.CreatedAt <= toDate)
+                .Take(range.MaxRecords)
+                .ToArrayAsync(cancellationToken);
+
+            return customers?.Length > 0
+                ? Result.Ok(customers.Select(c => c.ToModel()).ToArray())
+                : Result.Fail<Customer[]>(new Error("No customers found in the specified date range."));
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail<Customer[]>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result> UpdateCustomerAsync(UpdateCustomer request, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var customer = await context.Customers.FirstOrDefaultAsync(c => c.Id == request.CustomerId, cancellationToken);
+
+            if (customer is null)
+                return Result.Fail(new Error($"Customer with ID {request.CustomerId} not found."));
+
+            customer.Name = request.Name;
+            customer.LastName = request.LastName;
+            customer.Email = request.Email;
+            customer.Company = request.Company;
+            customer.Address = request.Address;
+            customer.City = request.City;
+            customer.Region = request.Region;
+            customer.Country = request.Country;
+            customer.PostalCode = request.PostalCode;
+            customer.Phone = request.Phone;
+            customer.Tax = request.Tax;
+            customer.City = request.City;
+            customer.Discord = request.Discord;
+            customer.Slack = request.Slack;
+            customer.LinkedIn = request.LinkedIn;
+            customer.Whatsapp = request.Whatsapp;
+
+            return await context.SaveChangesAsync(cancellationToken) > 0
+                ? Result.Ok()
+                : Result.Fail(new Error($"Failed to update the customer {request.CustomerId}."));
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+}

LiteCharms.Features.TechShop/Customers/Entities/Customer.cs

@@ -1,6 +1,9 @@
-using LiteCharms.Entities.Configuration;
+using LiteCharms.Features.TechShop.Leads.Entities;
+using LiteCharms.Features.TechShop.Orders.Entities;
+using LiteCharms.Features.TechShop.Quotes.Entities;
+using LiteCharms.Features.TechShop.ShoppingCarts.Entities;
 
-namespace LiteCharms.Entities;
+namespace LiteCharms.Features.TechShop.Customers.Entities;
 
 [EntityTypeConfiguration<CustomerConfiguration, Customer>]
 public class Customer : Models.Customer

LiteCharms.Features.TechShop/Customers/Entities/CustomerConfiguration.cs

@@ -1,14 +1,14 @@
-namespace LiteCharms.Entities.Configuration;
+namespace LiteCharms.Features.TechShop.Customers.Entities;
 
 public class CustomerConfiguration : IEntityTypeConfiguration<Customer>
 {
     public void Configure(EntityTypeBuilder<Customer> builder)
     {
-        builder.ToTable(nameof(Customer));
+        builder.ToTable("Customers");
 
         builder.HasKey(f => f.Id);
-        builder.Property(f => f.CreatedAt).ValueGeneratedOnAdd();
+        builder.Property(f => f.CreatedAt).ValueGeneratedOnAdd().HasDefaultValueSql("now()");
-        builder.Property(f => f.UpdatedAt).IsRequired(false).ValueGeneratedOnUpdate();
+        builder.Property(f => f.UpdatedAt).IsRequired(false).HasDefaultValueSql(null);
         builder.Property(f => f.Company);
         builder.Property(f => f.Name).IsRequired();
         builder.Property(f => f.LastName).IsRequired();
@@ -26,10 +26,5 @@ public class CustomerConfiguration : IEntityTypeConfiguration<Customer>
         builder.Property(f => f.Country);
         builder.Property(f => f.PostalCode);
         builder.Property(f => f.Active).HasDefaultValue(true);
-
-        builder.HasMany(f => f.Leads)
-            .WithOne(f => f.Customer)
-            .HasForeignKey(f => f.CustomerId)
-            .OnDelete(DeleteBehavior.NoAction);
     }
 }

LiteCharms.Features.TechShop/Customers/Models/Customer.cs

@@ -1,12 +1,12 @@
-namespace LiteCharms.Models;
+namespace LiteCharms.Features.TechShop.Customers.Models;
 
 public class Customer
 {
     public Guid Id { get; set; }
 
-    public DateTimeOffset CreatedAt { get; set; }
+    public DateTime CreatedAt { get; set; }
 
-    public DateTimeOffset? UpdatedAt { get; set; }
+    public DateTime? UpdatedAt { get; set; }
 
     public string? Company { get; set; }
 

LiteCharms.Features.TechShop/Customers/Models/Records.cs

@@ -0,0 +1,73 @@
+namespace LiteCharms.Features.TechShop.Customers.Models;
+
+public record CreateCustomer
+{
+    public string? Company { get; set; }
+
+    public required string Name { get; set; }
+
+    public required string LastName { get; set; }
+
+    public string? Tax { get; set; }
+
+    public required string Email { get; set; }
+
+    public string? Discord { get; set; }
+
+    public string? Slack { get; set; }
+
+    public string? LinkedIn { get; set; }
+
+    public string? Whatsapp { get; set; }
+
+    public string? Website { get; set; }
+
+    public string? Phone { get; set; }
+
+    public string? Address { get; set; }
+
+    public string? City { get; set; }
+
+    public string? Region { get; set; }
+
+    public string? Country { get; set; }
+
+    public string? PostalCode { get; set; }
+}
+
+public record UpdateCustomer
+{
+    public required Guid CustomerId { get; set; }
+
+    public string? Company { get; set; }
+
+    public string? Name { get; set; }
+
+    public string? LastName { get; set; }
+
+    public string? Tax { get; set; }
+
+    public string? Email { get; set; }
+
+    public string? Discord { get; set; }
+
+    public string? Slack { get; set; }
+
+    public string? LinkedIn { get; set; }
+
+    public string? Whatsapp { get; set; }
+
+    public string? Website { get; set; }
+
+    public string? Phone { get; set; }
+
+    public string? Address { get; set; }
+
+    public string? City { get; set; }
+
+    public string? Region { get; set; }
+
+    public string? Country { get; set; }
+
+    public string? PostalCode { get; set; }
+}

LiteCharms.Features.TechShop/Enums.cs

@@ -1,4 +1,4 @@
-namespace LiteCharms.Models;
+namespace LiteCharms.Features.TechShop;
 
 public enum CorrelationIdTypes : int
 {
@@ -15,13 +15,6 @@ public enum CorrelationIdTypes : int
     LinkedIn = 10
 }
 
-public enum Priorities : int
-{
-    Low = 0, 
-    Medium = 1,
-    High = 2,
-}
-
 public enum NotificationPlatforms : int
 {
     Email = 1,
@@ -66,3 +59,4 @@ public enum NotificationDirection : int
     Outgoing = 1,
     Neutral = 2
 }
+

LiteCharms.Features.TechShop/Extensions/HealthChecks.cs

@@ -0,0 +1,22 @@
+using LiteCharms.Features.TechShop.HealthChecks;
+using static LiteCharms.Features.TechShop.Extensions.Postgres;
+
+namespace LiteCharms.Features.TechShop.Extensions;
+
+public static class HealthChecks
+{
+    public static IServiceCollection AddShopQuartzHealthCheck(this IServiceCollection services)
+    {
+        services.AddHealthChecks().AddCheck<ShopQuartzHealthCheck>("ShopQuartz");
+
+        return services;
+    }
+
+    
+    public static IServiceCollection AddShopPostgresHealthCheck(this IServiceCollection services)
+    {
+        services.AddHealthChecks().AddCheck<PostgresShopHealthCheck>(TechShopDbConfigName);
+
+        return services;
+    }    
+}

LiteCharms.Features.TechShop/Extensions/Mappers.cs

@@ -1,10 +1,18 @@
-using LiteCharms.Models;
+using LiteCharms.Features.TechShop.CartPackages.Models;
+using LiteCharms.Features.TechShop.Customers.Models;
+using LiteCharms.Features.TechShop.Leads.Models;
+using LiteCharms.Features.TechShop.Notifications.Models;
+using LiteCharms.Features.TechShop.Orders.Models;
+using LiteCharms.Features.TechShop.Products.Entities;
+using LiteCharms.Features.TechShop.Products.Models;
+using LiteCharms.Features.TechShop.Quotes.Models;
+using LiteCharms.Features.TechShop.ShoppingCarts.Models;
 
-namespace LiteCharms.Extensions;
+namespace LiteCharms.Features.TechShop.Extensions;
 
-public static class EntityModeMappers
+public static class Mappers
 {
-    public static ShoppingCartPackage ToModel(this Entities.ShoppingCartPackage entity) =>
+    public static ShoppingCartPackage ToModel(this ShoppingCarts.Entities.ShoppingCartPackage entity) =>
         new()
         {
             Id = entity.Id,
@@ -13,7 +21,7 @@ public static class EntityModeMappers
             ShoppingCartId = entity.ShoppingCartId            
         };
 
-    public static PackageItem ToModel(this Entities.PackageItem entity) =>
+    public static PackageItem ToModel(this CartPackages.Entities.PackageItem entity) =>
         new()
         {
             Id = entity.Id,
@@ -23,7 +31,7 @@ public static class EntityModeMappers
             ProductPriceId = entity.ProductPriceId
         };
 
-    public static Package ToModel(this Entities.Package entity) =>
+    public static Package ToModel(this CartPackages.Entities.Package entity) =>
         new()
         {
             Id = entity.Id,
@@ -31,10 +39,12 @@ public static class EntityModeMappers
             Active = entity.Active,
             Description = entity.Description,
             Name = entity.Name,
-            UpdatedAt = entity.UpdatedAt
+            UpdatedAt = entity.UpdatedAt,
+            ImageUrl = entity.ImageUrl,
+            Summary = entity.Summary
         };
 
-    public static ShoppingCartItem ToModel(this Entities.ShoppingCartItem entity) =>
+    public static ShoppingCartItem ToModel(this ShoppingCarts.Entities.ShoppingCartItem entity) =>
         new()
         {
             Id = entity.Id,
@@ -45,18 +55,17 @@ public static class EntityModeMappers
             ShoppingCartId = entity.ShoppingCartId
         };
 
-    public static ShoppingCart ToModel(this Entities.ShoppingCart entity) =>
+    public static ShoppingCart ToModel(this ShoppingCarts.Entities.ShoppingCart entity) =>
         new()
         {
             Id = entity.Id,
             CreatedAt = entity.CreatedAt,
             UpdatedAt = entity.UpdatedAt,
             CustomerId = entity.CustomerId,
-            OrderId = entity.OrderId,
+            OrderId = entity.OrderId
-            QuoteId = entity.QuoteId            
         };
 
-    public static Quote ToModel(this Entities.Quote entity) =>
+    public static Quote ToModel(this Quotes.Entities.Quote entity) =>
         new()
         {
             Id = entity.Id,
@@ -66,10 +75,12 @@ public static class EntityModeMappers
             ExpiredAt = entity.ExpiredAt,
             Reason = entity.Reason,
             ShoppingCartId = entity.ShoppingCartId,
-            Status = entity.Status
+            Status = entity.Status,
+            InvoiceUrl = entity.InvoiceUrl,
+            OrderId = entity.OrderId
         };
 
-    public static Notification ToModel(this Entities.Notification entity) =>
+    public static Notification ToModel(this Notifications.Entities.Notification entity) =>
         new()
         {
             Id = entity.Id,
@@ -79,9 +90,9 @@ public static class EntityModeMappers
             CorrelationId = entity.CorrelationId,
             CorrelationIdType = entity.CorrelationIdType,
             IsInternal = entity.IsInternal,
-            Sender = entity.Sender,
+            SenderAddress = entity.SenderAddress,
             Platform = entity.Platform,
-            Recipient = entity.Recipient,
+            RecipientName = entity.RecipientName,
             Subject = entity.Subject,
             Processed = entity.Processed,
             SenderName = entity.SenderName,
@@ -93,7 +104,7 @@ public static class EntityModeMappers
             Errors = entity.Errors
         };
 
-    public static Customer ToModel(this Entities.Customer entity) =>
+    public static Customer ToModel(this Customers.Entities.Customer entity) =>
         new()
         {
             Id = entity.Id,
@@ -118,7 +129,7 @@ public static class EntityModeMappers
             Whatsapp = entity.Whatsapp
         };
 
-    public static Lead ToModel(this Entities.Lead entity) =>
+    public static Lead ToModel(this Leads.Entities.Lead entity) =>
         new()
         {
             Id = entity.Id,
@@ -139,7 +150,7 @@ public static class EntityModeMappers
             Status = entity.Status
         };
 
-    public static Order ToModel(this Entities.Order entity) =>
+    public static Order ToModel(this Orders.Entities.Order entity) =>
         new()
         {
             Id = entity.Id,
@@ -147,16 +158,13 @@ public static class EntityModeMappers
             UpdatedAt = entity.UpdatedAt,
             CustomerId = entity.CustomerId,            
             Notes = entity.Notes,
-            RefundId = entity.RefundId,
-            QuoteId = entity.QuoteId,
             Status = entity.Status,
-            ShoppingCartId = entity.ShoppingCartId,
-            DepositRequired = entity.DepositRequired,
             Requirements = entity.Requirements,
-            Terms = entity.Terms
+            Terms = entity.Terms,
+            InvoiceUrl = entity.InvoiceUrl            
         };
 
-    public static OrderRefund ToModel(this Entities.OrderRefund entity) =>
+    public static OrderRefund ToModel(this Orders.Entities.OrderRefund entity) =>
         new()
         {
             Id = entity.Id,
@@ -166,16 +174,21 @@ public static class EntityModeMappers
             Amount = entity.Amount
         };
 
-    public static Product ToModel(this Entities.Product entity) =>
+    public static Products.Models.Product ToModel(this Products.Entities.Product entity) =>
         new()
         {
             Id = entity.Id,    
+            CreatedAt = entity.CreatedAt,
             Name = entity.Name,
             Description = entity.Description,
-            Active = entity.Active            
+            Active = entity.Active,
+            Summary = entity.Summary,
+            ImageUrl = entity.ImageUrl,
+            Thumbnails = entity.Thumbnails,
+            Metadata = entity.Metadata,
         };
 
-    public static ProductPrice ToModel(this Entities.ProductPrice entity) =>
+    public static Products.Models.ProductPrice ToModel(this Products.Entities.ProductPrice entity) =>
         new()
         {
             Id = entity.Id,

LiteCharms.Features.TechShop/Extensions/Postgres.cs

@@ -0,0 +1,16 @@
+using LiteCharms.Features.TechShop.Postgres;
+
+namespace LiteCharms.Features.TechShop.Extensions;
+
+public static class Postgres
+{
+    public const string TechShopDbConfigName = "PostgresShop";
+
+    public static IServiceCollection AddTechShopDatabase(this IServiceCollection services, IConfiguration configuration)
+    {
+        services.AddPooledDbContextFactory<ShopDbContext>(options =>
+            options.UseNpgsql(configuration.GetConnectionString(TechShopDbConfigName)));
+
+        return services;
+    }
+}

LiteCharms.Features.TechShop/Extensions/Shop.cs

@@ -0,0 +1,27 @@
+using LiteCharms.Features.TechShop.CartPackages;
+using LiteCharms.Features.TechShop.Customers;
+using LiteCharms.Features.TechShop.Leads;
+using LiteCharms.Features.TechShop.Notifications;
+using LiteCharms.Features.TechShop.Orders;
+using LiteCharms.Features.TechShop.Products;
+using LiteCharms.Features.TechShop.Quotes;
+using LiteCharms.Features.TechShop.ShoppingCarts;
+
+namespace LiteCharms.Features.TechShop.Extensions;
+
+public static class Shop
+{
+    public static IServiceCollection AddTechShopServices(this IServiceCollection services)
+    {
+        services.AddSingleton<PackageService>()
+            .AddSingleton<LeadService>()
+            .AddSingleton<NotificationService>()
+            .AddSingleton<OrderService>()
+            .AddSingleton<ProductService>()
+            .AddSingleton<QuoteService>()
+            .AddSingleton<ShoppingCartService>()
+            .AddSingleton<CustomerService>();
+
+        return services;
+    }
+}

LiteCharms.Features.TechShop/HealthChecks/PostgresShopHealthCheck.cs

@@ -1,8 +1,10 @@
-namespace LiteCharms.Infrastructure.HealthChecks;
+using static LiteCharms.Features.TechShop.Extensions.Postgres;
 
-public class PostgresHealthCheck(IConfiguration configuration) : IHealthCheck
+namespace LiteCharms.Features.TechShop.HealthChecks;
+
+public class PostgresShopHealthCheck(IConfiguration configuration) : IHealthCheck
 {
-    private readonly string connectionString = configuration.GetConnectionString("PostgresShop")!;
+    private readonly string connectionString = configuration.GetConnectionString(TechShopDbConfigName)!;
 
     public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
     {
@@ -16,11 +18,11 @@ public class PostgresHealthCheck(IConfiguration configuration) : IHealthCheck
 
             await command.ExecuteScalarAsync(cancellationToken);
 
-            return HealthCheckResult.Healthy("PostgreSQL is responsive.");
+            return HealthCheckResult.Healthy($"{TechShopDbConfigName} is responsive.");
         }
         catch (Exception ex)
         {
-            return HealthCheckResult.Unhealthy("PostgreSQL is unreachable.", ex);
+            return HealthCheckResult.Unhealthy($"{TechShopDbConfigName} is unreachable.", ex);
         }
     }
 }

LiteCharms.Features.TechShop/HealthChecks/ShopQuartzHealthCheck.cs

@@ -0,0 +1,28 @@
+using static LiteCharms.Features.Extensions.Quartz;
+
+namespace LiteCharms.Features.TechShop.HealthChecks;
+
+public class ShopQuartzHealthCheck(ISchedulerFactory schedulerFactory) : IHealthCheck
+{
+    public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            var scheduler = await schedulerFactory.GetScheduler(TechShopSchedulerName, cancellationToken);
+
+            if(scheduler == null) 
+                return HealthCheckResult.Unhealthy($"Scheduler with name '{TechShopSchedulerName}' not found.");
+
+            if (!scheduler.IsStarted)
+                return HealthCheckResult.Unhealthy($"{TechShopSchedulerName} Quartz scheduler is not running");
+
+            await scheduler.CheckExists(new JobKey(Guid.NewGuid().ToString()), cancellationToken);
+
+            return HealthCheckResult.Healthy($"{TechShopSchedulerName} Quartz scheduler is ready");
+        }
+        catch (SchedulerException)
+        {
+            return HealthCheckResult.Unhealthy($"{TechShopSchedulerName} Quartz scheduler cannot connect to the store");
+        }
+    }
+}

LiteCharms.Features.TechShop/Leads/Entities/Lead.cs

@@ -1,6 +1,6 @@
-using LiteCharms.Entities.Configuration;
+using LiteCharms.Features.TechShop.Customers.Entities;
 
-namespace LiteCharms.Entities;
+namespace LiteCharms.Features.TechShop.Leads.Entities;
 
 [EntityTypeConfiguration<LeadConfiguration, Lead>]
 public class Lead : Models.Lead

LiteCharms.Features.TechShop/Leads/Entities/LeadConfiguration.cs

@@ -1,15 +1,15 @@
-namespace LiteCharms.Entities.Configuration;
+namespace LiteCharms.Features.TechShop.Leads.Entities;
 
 public class LeadConfiguration : IEntityTypeConfiguration<Lead>
 {
     public void Configure(EntityTypeBuilder<Lead> builder)
     {
-        builder.ToTable(nameof(Lead));
+        builder.ToTable("Leads");
 
         builder.HasKey(f => f.Id);
-        builder.Property(f => f.CreatedAt).ValueGeneratedOnAdd();
+        builder.Property(f => f.CreatedAt).ValueGeneratedOnAdd().HasDefaultValueSql("now()");
-        builder.Property(f => f.UpdatedAt).IsRequired(false).ValueGeneratedOnUpdate();
+        builder.Property(f => f.UpdatedAt).IsRequired(false).HasDefaultValueSql(null);
-        builder.Property(f => f.CustomerId).IsRequired(false);
+        builder.Property(f => f.CustomerId);
         builder.Property(f => f.Source);
         builder.Property(f => f.ClickId);
         builder.Property(f => f.WebClickId);
@@ -22,5 +22,10 @@ public class LeadConfiguration : IEntityTypeConfiguration<Lead>
         builder.Property(f => f.ClickLocation);
         builder.Property(f => f.Status).IsRequired();
         builder.Property(f => f.AttributionHash).IsRequired(true);
+
+        builder.HasOne(f => f.Customer)
+            .WithMany(f => f.Leads)
+            .HasForeignKey(f => f.CustomerId)
+            .OnDelete(DeleteBehavior.Restrict);
     }
 }

LiteCharms.Features.TechShop/Leads/LeadService.cs

@@ -0,0 +1,118 @@
+using LiteCharms.Features.Extensions;
+using LiteCharms.Features.Models;
+using LiteCharms.Features.TechShop.Extensions;
+using LiteCharms.Features.TechShop.Leads.Models;
+using LiteCharms.Features.TechShop.Postgres;
+using static LiteCharms.Features.Extensions.Hash;
+
+namespace LiteCharms.Features.TechShop.Leads;
+
+public class LeadService(IDbContextFactory<ShopDbContext> contextFactory)
+{
+    public async ValueTask<Result<Guid>> CreateLeadAsync(CreateLead request, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var newLead = context.Leads.Add(new Entities.Lead
+            {
+                WebClickId = request.WebClickId,
+                AppClickId = request.AppClickId,
+                Source = request.Source,
+                ClickId = request.ClickId,
+                AdGroupId = request.AdGroupId,
+                AdName = request.AdName,
+                CampaignId = request.CampaignId,
+                ClickLocation = request.ClickLocation,
+                CustomerId = request.CustomerId,
+                FeedItemId = request.FeedItemId,
+                Status = LeadStatus.New,
+                TargetId = request.TargetId,
+                AttributionHash = StringToSha256Hash.Invoke($"{request.ClickId}{request.AppClickId}{request.WebClickId}")
+            });
+
+            return await context.SaveChangesAsync(cancellationToken) > 0
+                ? Result.Ok(newLead.Entity.Id)
+                : Result.Fail<Guid>(new Error($"Failed to create lead -> Google ClickId: {request.ClickId}, App ClickId: {request.AppClickId}, Web ClickId: {request.WebClickId}"));
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail<Guid>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result<Lead[]>> GetCustomerLeadsAsync(Guid customerId, DateRange range, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            var fromDate = range.From.ToDateTime(TimeOnly.MinValue);
+            var toDate = range.To.ToDateTime(TimeOnly.MaxValue);
+
+            using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var leads = await context.Leads.AsNoTracking()
+                .OrderByDescending(o => o.CreatedAt)
+                .Where(lead => lead.CustomerId == customerId)
+                .Where(lead => lead.CreatedAt.Date >= fromDate && lead.CreatedAt.Date <= toDate)
+                .ToArrayAsync(cancellationToken);
+
+            return leads?.Length > 0
+                ? Result.Ok(leads.Select(l => l.ToModel()).ToArray())
+                : Result.Fail(new Error($"No customer {customerId} leads found for the specified date range {range.From} to {range.To}."));
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail<Lead[]>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result<Lead[]>> GetLeadsAsync(DateRange range, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            var fromDate = range.From.ToDateTime(TimeOnly.MinValue);
+            var toDate = range.To.ToDateTime(TimeOnly.MaxValue);
+
+            using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var leads = await context.Leads.AsNoTracking()
+                .OrderByDescending(o => o.CreatedAt)
+                .Where(l => l.CreatedAt.Date >= fromDate && l.CreatedAt.Date <= toDate)
+                .Take(range.MaxRecords)
+                .ToArrayAsync(cancellationToken);
+
+            return leads?.Length > 0
+                ? Result.Ok(leads.Select(l => l.ToModel()).ToArray())
+                : Result.Fail(new Error($"No leads found for the specified date range {range.From} to {range.To}."));
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result> UpdateLeadAsync(Guid leadId, LeadStatus status, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var lead = await context.Leads.FirstOrDefaultAsync(l => l.Id == leadId, cancellationToken);
+
+            if (lead is null)
+                return Result.Fail(new Error($"Lead with ID {leadId} not found."));
+
+            lead.Status = status;
+            lead.UpdatedAt = DateTime.UtcNow;
+
+            return await context.SaveChangesAsync(cancellationToken) > 0
+                ? Result.Ok()
+                : Result.Fail(new Error($"Failed to update the lead {leadId}."));
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+}

LiteCharms.Features.TechShop/Leads/Models/Lead.cs

@@ -1,12 +1,12 @@
-namespace LiteCharms.Models;
+namespace LiteCharms.Features.TechShop.Leads.Models;
 
 public class Lead
 {
     public Guid Id { get; set; }
 
-    public DateTimeOffset CreatedAt { get; set; }
+    public DateTime CreatedAt { get; set; }
 
-    public DateTimeOffset? UpdatedAt { get; set; }
+    public DateTime? UpdatedAt { get; set; }
 
     public Guid? CustomerId { get; set; }
 

LiteCharms.Features.TechShop/Leads/Models/Records.cs

@@ -0,0 +1,28 @@
+namespace LiteCharms.Features.TechShop.Leads.Models;
+
+public record CreateLead
+{
+    public Guid? CustomerId { get; set; }
+
+    public required string Source { get; set; }
+
+    public required string ClickId { get; set; }
+
+    public required string WebClickId { get; set; }
+
+    public required string AppClickId { get; set; }
+
+    public long? CampaignId { get; set; }
+
+    public long? AdGroupId { get; set; }
+
+    public long? AdName { get; set; }
+
+    public long? TargetId { get; set; }
+
+    public long? FeedItemId { get; set; }
+
+    public string? ClickLocation { get; set; }
+
+    public string? AttribusionHash { get; set; }
+}

LiteCharms.Features.TechShop/LiteCharms.Features.TechShop.csproj

@@ -0,0 +1,171 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <SignAssembly>True</SignAssembly>
+    <AssemblyOriginatorKeyFile>..\LiteCharms.snk</AssemblyOriginatorKeyFile>
+    <UserSecretsId>fbd8f4a2-0420-44e2-baff-4678d9e7eee1</UserSecretsId>
+  </PropertyGroup>
+
+  <!-- Nuget Package Details -->
+  <PropertyGroup>
+    <PackageId>LiteCharms.Features.TechShop</PackageId>
+    <Version>1.0.20</Version>
+    <Authors>Khwezi Mngoma</Authors>
+    <Company>Lite Charms (PTY) Ltd</Company>
+    <Description>TechShop feature components for Lite Charms applications.</Description>
+    <PackageProjectUrl>https://gitea.khongisa.co.za/litecharms/components</PackageProjectUrl>
+    <RepositoryUrl>https://gitea.khongisa.co.za/litecharms/components.git</RepositoryUrl>
+    <RepositoryType>git</RepositoryType>
+    <PackageLicenseFile>LICENSE</PackageLicenseFile>
+    <PackageTags>utility;dotnet</PackageTags>
+    <PackageIcon>icon.png</PackageIcon>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Remove="Addresses\**" />
+    <EmbeddedResource Remove="Addresses\**" />
+    <None Remove="Addresses\**" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Include="..\LICENSE" Pack="true" PackagePath="\" />
+    <None Include="..\icon.png" Pack="true" PackagePath="\" />
+  </ItemGroup>
+
+  <!-- Quartz Scheduler-->
+  <ItemGroup>
+    <PackageReference Include="OpenTelemetry" Version="1.15.3" />
+    <PackageReference Include="Quartz" Version="3.18.1" />
+    <PackageReference Include="Quartz.Plugins" Version="3.18.1" />
+    <PackageReference Include="Quartz.Plugins.TimeZoneConverter" Version="3.18.1" />
+    <PackageReference Include="Quartz.Serialization.SystemTextJson" Version="3.18.1" />
+    <PackageReference Include="Quartz.AspNetCore" Version="3.18.1" />
+    <PackageReference Include="Quartz.Extensions.DependencyInjection" Version="3.18.1" />
+
+    <!-- Global Usings -->
+    <Using Include="Quartz" />
+  </ItemGroup>
+
+  <!-- Configuration -->
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Configuration" Version="10.0.8" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Abstractions" Version="10.0.8" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.EnvironmentVariables" Version="10.0.8" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="10.0.8" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.UserSecrets" Version="10.0.8" />
+
+    <!-- Global Usings -->
+    <Using Include="Microsoft.Extensions.Configuration" />
+  </ItemGroup>
+
+  <!-- Health Checks -->
+  <ItemGroup>
+    <PackageReference Include="AspNetCore.HealthChecks.UI.Client" Version="9.0.0" />
+    <PackageReference Include="AspNetCore.HealthChecks.UI" Version="9.0.0" />
+    <PackageReference Include="AspNetCore.HealthChecks.UI.Core" Version="9.0.0" />
+    <PackageReference Include="AspNetCore.HealthChecks.UI.Data" Version="9.0.0" />
+    <PackageReference Include="AspNetCore.HealthChecks.UI.InMemory.Storage" Version="9.0.0" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="10.0.8" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="10.0.8" />
+    <PackageReference Include="Microsoft.Extensions.Diagnostics.HealthChecks" Version="10.0.8" />
+
+    <!-- Global Usings -->
+    <Using Include="Microsoft.Extensions.Diagnostics.HealthChecks" />
+    <Using Include="Microsoft.AspNetCore.Diagnostics.HealthChecks" />
+  </ItemGroup>
+
+  <!-- Open Telemetry -->
+  <ItemGroup>
+    <PackageReference Include="OpenTelemetry.Exporter.OpenTelemetryProtocol" Version="1.15.3" />
+    <PackageReference Include="OpenTelemetry.Extensions.Hosting" Version="1.15.3" />
+    <PackageReference Include="OpenTelemetry.Instrumentation.AspNetCore" Version="1.15.2" />
+    <PackageReference Include="OpenTelemetry.Instrumentation.Http" Version="1.15.1" />
+    <PackageReference Include="OpenTelemetry.Instrumentation.Runtime" Version="1.15.1" />
+    <PackageReference Include="OpenTelemetry.Exporter.Console" Version="1.15.3" />
+
+    <!-- Global Usings -->
+    <Using Include="OpenTelemetry.Resources" />
+    <Using Include="OpenTelemetry.Exporter" />
+    <Using Include="OpenTelemetry.Logs" />
+    <Using Include="OpenTelemetry.Metrics" />
+    <Using Include="OpenTelemetry.Trace" />
+  </ItemGroup>
+
+  <!-- Database -->
+  <ItemGroup>
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="10.0.8" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="10.0.8">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Relational" Version="10.0.8" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="10.0.8">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="10.0.1" />
+
+    <!-- Global Usings -->
+    <Using Include="Npgsql" />
+    <Using Include="Microsoft.EntityFrameworkCore" />
+    <Using Include="Microsoft.EntityFrameworkCore.Design" />
+    <Using Include="Microsoft.EntityFrameworkCore.Metadata.Builders" />
+  </ItemGroup>
+
+  <!-- Email -->
+  <ItemGroup>
+    <PackageReference Include="MailKit" Version="4.16.0" />
+    <PackageReference Include="MimeKit" Version="4.16.0" />
+
+    <!-- Global Usings-->
+    <Using Include="MimeKit" />
+    <Using Include="MailKit.Net.Smtp" />
+  </ItemGroup>
+
+  <!-- CQRS -->
+  <ItemGroup>
+    <PackageReference Include="FluentResults" Version="4.0.0" />
+    <PackageReference Include="Mediator.Abstractions" Version="3.0.2" />
+
+    <!-- Global Usings -->
+    <Using Include="FluentResults" />
+    <Using Include="Mediator" />
+  </ItemGroup>
+
+  <!-- Amazon S3 SDK -->
+  <ItemGroup>
+    <PackageReference Include="AWSSDK.Extensions.NetCore.Setup" Version="4.0.4.1" />
+    <PackageReference Include="AWSSDK.S3" Version="4.0.23.4" />
+    <ProjectReference Include="..\LiteCharms.Features\LiteCharms.Features.csproj" />
+
+    <!-- global Usings -->
+    <Using Include="Amazon.S3" />
+    <Using Include="Amazon.S3.Model" />
+    <Using Include="Amazon.Runtime" />
+  </ItemGroup>
+
+  <!-- Shared Usings -->
+  <ItemGroup>
+    <Using Include="Microsoft.AspNetCore.Builder" />
+    <Using Include="Microsoft.Extensions.Hosting" />
+    <Using Include="System.Text" />
+    <Using Include="System.Text.Json" />
+    <Using Include="System.Threading.Channels" />
+    <Using Include="System.Collections.ObjectModel" />
+    <Using Include="System.Diagnostics" />
+    <Using Include="System.Diagnostics.Metrics" />
+    <Using Include="Microsoft.Extensions.DependencyInjection" />
+    <Using Include="System.Security.Cryptography" />
+    <Using Include="Microsoft.Extensions.Options" />
+    <Using Include="Microsoft.Extensions.Logging" />
+  </ItemGroup>
+  
+  <ItemGroup>
+    <None Update="appsettings.json">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
+  
+</Project>

LiteCharms.Features.TechShop/Notifications/Entities/Notification.cs

@@ -1,6 +1,4 @@
-using LiteCharms.Entities.Configuration;
+namespace LiteCharms.Features.TechShop.Notifications.Entities;
-
-namespace LiteCharms.Entities;
 
 [EntityTypeConfiguration<NotificationConfiguration, Notification>]
 public class Notification : Models.Notification;