Merge commit '3656223b5f596095383a95825e553b776a50145a'

Added dates to product model
Migrated database changes

LiteCharms.Features.Tests/S3ServiceFeatureTests.cs

@@ -7,7 +7,7 @@ public class S3ServiceFeatureTests(CommonFixture fixture, ITestOutputHelper outp
     [Fact]
     public async Task BookshopS3Service_MustReturnUrl()
     {
-        var service = fixture.Services.GetKeyedService<IS3Service>(S3.Constants.BookshopQuotesBucketName);
+        var service = fixture.Services.GetKeyedService<IS3Service>(S3.Constants.BookshopBucketName);
 
         var fileName = "appsettings.json";
 
@@ -25,4 +25,30 @@ public class S3ServiceFeatureTests(CommonFixture fixture, ITestOutputHelper outp
 
         output.WriteLine(result.Value);        
     }
+
+    [Fact]
+    public async Task BookshopS3Service_MustDeleteFile()
+    {
+        var service = fixture.Services.GetKeyedService<IS3Service>(S3.Constants.BookshopBucketName);
+
+        var fileName = "appsettings.json";
+
+        string path = Path.Combine(Directory.GetCurrentDirectory(), fileName);
+
+        Assert.True(File.Exists(path));
+
+        var stream = File.OpenRead(path);
+
+        var uploadResult = await service!.UploadFileAsync(fileName, stream, MimeKit.MimeTypes.GetMimeType(fileName));
+
+        Assert.True(uploadResult.IsSuccess);
+        Assert.NotNull(uploadResult.Value);
+        Assert.NotEmpty(uploadResult.Value);
+
+        var fileKey = uploadResult.Value.Split('/').Last();
+
+        var deleteResult = await service!.DeleteFileAsync(fileKey);
+
+        Assert.True(deleteResult.IsSuccess);
+    }
 }

LiteCharms.Features/Email/Models/EmailEnquiryModel.cs

@@ -2,7 +2,7 @@
 
 namespace LiteCharms.Features.Email.Models;
 
-public sealed class EmailEnquiry
+public sealed class EmailEnquiryModel
 {
     [Required]
     [MinLength(2)]

LiteCharms.Features/Extensions/EntityModeMappers.cs

@@ -177,12 +177,14 @@ public static class EntityModeMappers
         new()
         {
             Id = entity.Id,    
+            CreatedAt = entity.CreatedAt,
             Name = entity.Name,
             Description = entity.Description,
             Active = entity.Active,
             Summary = entity.Summary,
             ImageUrl = entity.ImageUrl,
-            Thumbnails = entity.Thumbnails
+            Thumbnails = entity.Thumbnails,
+            Metadata = entity.Metadata,
         };
 
     public static ProductPrice ToModel(this Features.Shop.Products.Entities.ProductPrice entity) =>

LiteCharms.Features/Extensions/Hash.cs

@@ -2,6 +2,12 @@
 
 public static class Hash
 {
-    public static Func<string?, string?> GenerateSha256HashString = (input) => 
+    public static Func<string?, string?> StringToSha256Hash = (input) => 
         Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(input!)));
+
+    public static Func<Stream, string?> StreamToSha256Hash = (stream) =>
+        Convert.ToHexString(SHA256.HashData(stream));
+
+    public static Func<byte[], string?> BytesToSha256Hash = (bytes) =>
+        Convert.ToHexString(SHA256.HashData(bytes));
 }

LiteCharms.Features/S3/Abstractions/IS3Service.cs

@@ -3,4 +3,5 @@
 public interface IS3Service
 {
     Task<Result<string>> UploadFileAsync(string fileName, Stream fileStream, string contentType, CancellationToken cancellationToken = default);
+    Task<Result> DeleteFileAsync(string fileKey, CancellationToken cancellationToken = default);
 }

LiteCharms.Features/S3/Abstractions/S3ServiceBase.cs

@@ -1,4 +1,6 @@
-namespace LiteCharms.Features.S3.Abstractions;
+using static LiteCharms.Features.Extensions.Hash;
+
+namespace LiteCharms.Features.S3.Abstractions;
 
 public abstract class S3ServiceBase(IAmazonS3 amazonS3)
 {
@@ -17,17 +19,31 @@ public abstract class S3ServiceBase(IAmazonS3 amazonS3)
             if (string.IsNullOrWhiteSpace(CdnBaseUrl))
                 return Result.Fail<string>("CDN base URL is not configured.");
 
-            var fileKey = $"{Guid.NewGuid():N}{Path.GetExtension(fileName)}";
+            using var stream = new MemoryStream();
+
+            await fileStream.CopyToAsync(stream, cancellationToken);
+            await fileStream.DisposeAsync();
+
+            stream.Seek(0, SeekOrigin.Begin);
+
+            var fileHash = StreamToSha256Hash(stream);
+
+            if(string.IsNullOrWhiteSpace(fileHash))
+                return Result.Fail<string>("Failed to compute file hash.");
+
+            var fileKey = $"{fileHash.ToLower()}{Path.GetExtension(fileName)}";
 
             var putRequest = new PutObjectRequest
             {
                 BucketName = BucketName,
                 Key = fileKey,
-                InputStream = fileStream,
+                InputStream = stream,
                 ContentType = contentType,
                 UseChunkEncoding = false
             };
 
+            stream.Seek(0, SeekOrigin.Begin);
+
             var response = await Client.PutObjectAsync(putRequest, cancellationToken);
 
             return response.HttpStatusCode != System.Net.HttpStatusCode.OK
@@ -39,4 +55,29 @@ public abstract class S3ServiceBase(IAmazonS3 amazonS3)
             return Result.Fail<string>(new Error($"Error uploading {fileName} to S3: {ex.Message}").CausedBy(ex));
         }
     }
+
+    public virtual async Task<Result> DeleteFileAsync(string fileKey, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            if (string.IsNullOrWhiteSpace(BucketName))
+                return Result.Fail("Bucket name is not configured.");
+
+            var deleteRequest = new DeleteObjectRequest
+            {
+                BucketName = BucketName,
+                Key = fileKey
+            };
+
+            var response = await Client.DeleteObjectAsync(deleteRequest, cancellationToken);
+
+            return response.HttpStatusCode != System.Net.HttpStatusCode.NoContent
+                ? Result.Fail($"Failed to delete {fileKey} from S3.")
+                : Result.Ok();
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail(new Error($"Error deleting {fileKey} from S3: {ex.Message}").CausedBy(ex));
+        }
+    }
 }

LiteCharms.Features/Shop/CartPackages/PackageService.cs

@@ -2,7 +2,6 @@
 using LiteCharms.Features.Models;
 using LiteCharms.Features.Shop.CartPackages.Models;
 using LiteCharms.Features.Shop.Postgres;
-using static LiteCharms.Features.Extensions.Timezones;
 
 namespace LiteCharms.Features.Shop.CartPackages;
 

LiteCharms.Features/Shop/Leads/LeadService.cs

@@ -28,7 +28,7 @@ public class LeadService(IDbContextFactory<ShopDbContext> contextFactory)
                 FeedItemId = request.FeedItemId,
                 Status = LeadStatus.New,
                 TargetId = request.TargetId,
-                AttributionHash = GenerateSha256HashString.Invoke($"{request.ClickId}{request.AppClickId}{request.WebClickId}")
+                AttributionHash = StringToSha256Hash.Invoke($"{request.ClickId}{request.AppClickId}{request.WebClickId}")
             });
 
             return await context.SaveChangesAsync(cancellationToken) > 0

LiteCharms.Features/Shop/Postgres/Migrations/20260520191059_AddedProductMetadata.Designer.cs

@@ -0,0 +1,788 @@
+// <auto-generated />
+using System;
+using LiteCharms.Features.Shop.Postgres;
+using LiteCharms.Features.Shop.Products.Models;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace LiteCharms.Features.Shop.Postgres.Migrations
+{
+    [DbContext(typeof(ShopDbContext))]
+    [Migration("20260520191059_AddedProductMetadata")]
+    partial class AddedProductMetadata
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "10.0.8")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("LiteCharms.Features.Shop.CartPackages.Entities.Package", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("Active")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<string>("ImageUrl")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Summary")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Package", (string)null);
+                });
+
+            modelBuilder.Entity("LiteCharms.Features.Shop.CartPackages.Entities.PackageItem", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("Active")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<Guid>("PackageId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ProductPriceId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PackageId");
+
+                    b.HasIndex("ProductPriceId");
+
+                    b.ToTable("PackageItem", (string)null);
+                });
+
+            modelBuilder.Entity("LiteCharms.Features.Shop.Customers.Entities.Customer", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("Active")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(true);
+
+                    b.Property<string>("Address")
+                        .HasColumnType("text");
+
+                    b.Property<string>("City")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Company")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Country")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<string>("Discord")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LastName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LinkedIn")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Phone")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PostalCode")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Region")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Slack")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Tax")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Website")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Whatsapp")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Customers", (string)null);
+                });
+
+            modelBuilder.Entity("LiteCharms.Features.Shop.Leads.Entities.Lead", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<long?>("AdGroupId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long?>("AdName")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("AppClickId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("AttributionHash")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<long?>("CampaignId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("ClickId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClickLocation")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<Guid?>("CustomerId")
+                        .HasColumnType("uuid");
+
+                    b.Property<long?>("FeedItemId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("Source")
+                        .HasColumnType("text");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("integer");
+
+                    b.Property<long?>("TargetId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("WebClickId")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CustomerId");
+
+                    b.ToTable("Leads", (string)null);
+                });
+
+            modelBuilder.Entity("LiteCharms.Features.Shop.Notifications.Entities.Notification", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CorrelationId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("CorrelationIdType")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<int>("Direction")
+                        .HasColumnType("integer");
+
+                    b.PrimitiveCollection<string>("Errors")
+                        .HasColumnType("jsonb");
+
+                    b.Property<bool>("HasError")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("IsHtml")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("IsInternal")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(true);
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("Platform")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Priority")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("Processed")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false);
+
+                    b.Property<string>("RecipientAddress")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RecipientName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("SenderAddress")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("SenderName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Subject")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Notification", (string)null);
+                });
+
+            modelBuilder.Entity("LiteCharms.Features.Shop.Orders.Entities.Order", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<Guid>("CustomerId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("InvoiceUrl")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.PrimitiveCollection<string>("Notes")
+                        .HasColumnType("jsonb");
+
+                    b.PrimitiveCollection<string>("Requirements")
+                        .HasColumnType("jsonb");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("integer");
+
+                    b.PrimitiveCollection<string>("Terms")
+                        .HasColumnType("jsonb");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CustomerId");
+
+                    b.ToTable("Orders", (string)null);
+                });
+
+            modelBuilder.Entity("LiteCharms.Features.Shop.Orders.Entities.OrderRefund", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("numeric(18,2)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<Guid>("OrderId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Reason")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OrderId");
+
+                    b.ToTable("OrderRefunds", (string)null);
+                });
+
+            modelBuilder.Entity("LiteCharms.Features.Shop.Products.Entities.Product", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("Active")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false);
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<string>("ImageUrl")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<ProductMetadata>("Metadata")
+                        .HasColumnType("jsonb");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Summary")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.PrimitiveCollection<string>("Thumbnails")
+                        .HasColumnType("jsonb");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Products", (string)null);
+                });
+
+            modelBuilder.Entity("LiteCharms.Features.Shop.Products.Entities.ProductPrice", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("Active")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<decimal>("Discount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("numeric(18,2)");
+
+                    b.Property<decimal>("Price")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("numeric(18,2)");
+
+                    b.Property<Guid>("ProductId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProductId");
+
+                    b.ToTable("ProductPrices", (string)null);
+                });
+
+            modelBuilder.Entity("LiteCharms.Features.Shop.Quotes.Entities.Quote", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<Guid>("CustomerId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("ExpiredAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("InvoiceUrl")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<Guid?>("OrderId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Reason")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("ShoppingCartId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("OrderId")
+                        .IsUnique();
+
+                    b.HasIndex("ShoppingCartId")
+                        .IsUnique();
+
+                    b.ToTable("Quotes", (string)null);
+                });
+
+            modelBuilder.Entity("LiteCharms.Features.Shop.ShoppingCarts.Entities.ShoppingCart", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<Guid>("CustomerId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("OrderId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("OrderId")
+                        .IsUnique();
+
+                    b.ToTable("ShoppingCarts", (string)null);
+                });
+
+            modelBuilder.Entity("LiteCharms.Features.Shop.ShoppingCarts.Entities.ShoppingCartItem", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<Guid>("ProductPriceId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Quantity")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValue(1);
+
+                    b.Property<Guid>("ShoppingCartId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProductPriceId");
+
+                    b.HasIndex("ShoppingCartId");
+
+                    b.ToTable("ShoppingCartItems", (string)null);
+                });
+
+            modelBuilder.Entity("LiteCharms.Features.Shop.ShoppingCarts.Entities.ShoppingCartPackage", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<Guid>("PackageId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ShoppingCartId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PackageId");
+
+                    b.HasIndex("ShoppingCartId");
+
+                    b.ToTable("ShoppingCartPackages", (string)null);
+                });
+
+            modelBuilder.Entity("LiteCharms.Features.Shop.CartPackages.Entities.PackageItem", b =>
+                {
+                    b.HasOne("LiteCharms.Features.Shop.CartPackages.Entities.Package", "Package")
+                        .WithMany("PackageItems")
+                        .HasForeignKey("PackageId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("LiteCharms.Features.Shop.Products.Entities.ProductPrice", "ProductPrice")
+                        .WithMany()
+                        .HasForeignKey("ProductPriceId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Package");
+
+                    b.Navigation("ProductPrice");
+                });
+
+            modelBuilder.Entity("LiteCharms.Features.Shop.Leads.Entities.Lead", b =>
+                {
+                    b.HasOne("LiteCharms.Features.Shop.Customers.Entities.Customer", "Customer")
+                        .WithMany("Leads")
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Customer");
+                });
+
+            modelBuilder.Entity("LiteCharms.Features.Shop.Orders.Entities.Order", b =>
+                {
+                    b.HasOne("LiteCharms.Features.Shop.Customers.Entities.Customer", "Customer")
+                        .WithMany("Orders")
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Customer");
+                });
+
+            modelBuilder.Entity("LiteCharms.Features.Shop.Orders.Entities.OrderRefund", b =>
+                {
+                    b.HasOne("LiteCharms.Features.Shop.Orders.Entities.Order", "Order")
+                        .WithMany("Refunds")
+                        .HasForeignKey("OrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Order");
+                });
+
+            modelBuilder.Entity("LiteCharms.Features.Shop.Products.Entities.ProductPrice", b =>
+                {
+                    b.HasOne("LiteCharms.Features.Shop.Products.Entities.Product", "Product")
+                        .WithMany("ProductPrices")
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("LiteCharms.Features.Shop.Quotes.Entities.Quote", b =>
+                {
+                    b.HasOne("LiteCharms.Features.Shop.Customers.Entities.Customer", "Customer")
+                        .WithMany("Quotes")
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("LiteCharms.Features.Shop.Orders.Entities.Order", "Order")
+                        .WithOne("Quote")
+                        .HasForeignKey("LiteCharms.Features.Shop.Quotes.Entities.Quote", "OrderId");
+
+                    b.HasOne("LiteCharms.Features.Shop.ShoppingCarts.Entities.ShoppingCart", "ShoppingCart")
+                        .WithOne("Quote")
+                        .HasForeignKey("LiteCharms.Features.Shop.Quotes.Entities.Quote", "ShoppingCartId");
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("Order");
+
+                    b.Navigation("ShoppingCart");
+                });
+
+            modelBuilder.Entity("LiteCharms.Features.Shop.ShoppingCarts.Entities.ShoppingCart", b =>
+                {
+                    b.HasOne("LiteCharms.Features.Shop.Customers.Entities.Customer", "Customer")
+                        .WithMany("ShoppingCarts")
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("LiteCharms.Features.Shop.Orders.Entities.Order", "Order")
+                        .WithOne("ShoppingCart")
+                        .HasForeignKey("LiteCharms.Features.Shop.ShoppingCarts.Entities.ShoppingCart", "OrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("Order");
+                });
+
+            modelBuilder.Entity("LiteCharms.Features.Shop.ShoppingCarts.Entities.ShoppingCartItem", b =>
+                {
+                    b.HasOne("LiteCharms.Features.Shop.Products.Entities.ProductPrice", "ProductPrice")
+                        .WithMany()
+                        .HasForeignKey("ProductPriceId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("LiteCharms.Features.Shop.ShoppingCarts.Entities.ShoppingCart", "ShoppingCart")
+                        .WithMany("ShoppingCartItems")
+                        .HasForeignKey("ShoppingCartId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ProductPrice");
+
+                    b.Navigation("ShoppingCart");
+                });
+
+            modelBuilder.Entity("LiteCharms.Features.Shop.ShoppingCarts.Entities.ShoppingCartPackage", b =>
+                {
+                    b.HasOne("LiteCharms.Features.Shop.CartPackages.Entities.Package", "Package")
+                        .WithMany()
+                        .HasForeignKey("PackageId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("LiteCharms.Features.Shop.ShoppingCarts.Entities.ShoppingCart", "ShoppingCart")
+                        .WithMany("ShoppingCartPackages")
+                        .HasForeignKey("ShoppingCartId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Package");
+
+                    b.Navigation("ShoppingCart");
+                });
+
+            modelBuilder.Entity("LiteCharms.Features.Shop.CartPackages.Entities.Package", b =>
+                {
+                    b.Navigation("PackageItems");
+                });
+
+            modelBuilder.Entity("LiteCharms.Features.Shop.Customers.Entities.Customer", b =>
+                {
+                    b.Navigation("Leads");
+
+                    b.Navigation("Orders");
+
+                    b.Navigation("Quotes");
+
+                    b.Navigation("ShoppingCarts");
+                });
+
+            modelBuilder.Entity("LiteCharms.Features.Shop.Orders.Entities.Order", b =>
+                {
+                    b.Navigation("Quote");
+
+                    b.Navigation("Refunds");
+
+                    b.Navigation("ShoppingCart");
+                });
+
+            modelBuilder.Entity("LiteCharms.Features.Shop.Products.Entities.Product", b =>
+                {
+                    b.Navigation("ProductPrices");
+                });
+
+            modelBuilder.Entity("LiteCharms.Features.Shop.ShoppingCarts.Entities.ShoppingCart", b =>
+                {
+                    b.Navigation("Quote");
+
+                    b.Navigation("ShoppingCartItems");
+
+                    b.Navigation("ShoppingCartPackages");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

LiteCharms.Features/Shop/Postgres/Migrations/20260520191059_AddedProductMetadata.cs

@@ -0,0 +1,71 @@
+using System;
+using LiteCharms.Features.Shop.Products.Models;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace LiteCharms.Features.Shop.Postgres.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddedProductMetadata : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AlterColumn<bool>(
+                name: "Active",
+                table: "Products",
+                type: "boolean",
+                nullable: false,
+                defaultValue: false,
+                oldClrType: typeof(bool),
+                oldType: "boolean",
+                oldDefaultValue: true);
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "CreatedAt",
+                table: "Products",
+                type: "timestamp with time zone",
+                nullable: false,
+                defaultValueSql: "now()");
+
+            migrationBuilder.AddColumn<ProductMetadata>(
+                name: "Metadata",
+                table: "Products",
+                type: "jsonb",
+                nullable: true);
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "UpdatedAt",
+                table: "Products",
+                type: "timestamp with time zone",
+                nullable: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "CreatedAt",
+                table: "Products");
+
+            migrationBuilder.DropColumn(
+                name: "Metadata",
+                table: "Products");
+
+            migrationBuilder.DropColumn(
+                name: "UpdatedAt",
+                table: "Products");
+
+            migrationBuilder.AlterColumn<bool>(
+                name: "Active",
+                table: "Products",
+                type: "boolean",
+                nullable: false,
+                defaultValue: true,
+                oldClrType: typeof(bool),
+                oldType: "boolean",
+                oldDefaultValue: false);
+        }
+    }
+}

LiteCharms.Features/Shop/Postgres/Migrations/ShopDbContextModelSnapshot.cs

@@ -1,6 +1,7 @@
 // <auto-generated />
 using System;
 using LiteCharms.Features.Shop.Postgres;
+using LiteCharms.Features.Shop.Products.Models;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Infrastructure;
 using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
@@ -386,7 +387,12 @@ namespace LiteCharms.Features.Shop.Postgres.Migrations
                     b.Property<bool>("Active")
                         .ValueGeneratedOnAdd()
                         .HasColumnType("boolean")
-                        .HasDefaultValue(true);
+                        .HasDefaultValue(false);
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
 
                     b.Property<string>("Description")
                         .IsRequired()
@@ -397,6 +403,9 @@ namespace LiteCharms.Features.Shop.Postgres.Migrations
                         .HasMaxLength(2048)
                         .HasColumnType("character varying(2048)");
 
+                    b.Property<ProductMetadata>("Metadata")
+                        .HasColumnType("jsonb");
+
                     b.Property<string>("Name")
                         .IsRequired()
                         .HasColumnType("text");
@@ -409,6 +418,9 @@ namespace LiteCharms.Features.Shop.Postgres.Migrations
                     b.PrimitiveCollection<string>("Thumbnails")
                         .HasColumnType("jsonb");
 
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
                     b.HasKey("Id");
 
                     b.ToTable("Products", (string)null);

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

@@ -8,10 +8,13 @@ public class ProductConfiguration : IEntityTypeConfiguration<Product>
 
         builder.HasKey(f => f.Id);
         builder.Property(f => f.Name).IsRequired();
+        builder.Property(f => f.CreatedAt).IsRequired().ValueGeneratedOnAdd().HasDefaultValueSql("now()");
+        builder.Property(f => f.UpdatedAt).IsRequired(false);
         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.Thumbnails).HasColumnType("jsonb").IsRequired(false);
-        builder.Property(f => f.Active).HasDefaultValue(true);
+        builder.Property(f => f.Active).HasDefaultValue(false);
+        builder.Property(f => f.Metadata).HasColumnType("jsonb").IsRequired(false);        
     }
 }

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

@@ -7,7 +7,7 @@ public class ProductPriceConfiguration : IEntityTypeConfiguration<ProductPrice>
         builder.ToTable("ProductPrices");
 
         builder.HasKey(f => f.Id);
-        builder.Property(f => f.CreatedAt).ValueGeneratedOnAdd().HasDefaultValueSql("now()");
+        builder.Property(f => f.CreatedAt).IsRequired().ValueGeneratedOnAdd().HasDefaultValueSql("now()");
         builder.Property(f => f.UpdatedAt).IsRequired(false);
         builder.Property(f => f.ProductId).IsRequired();
         builder.Property(f => f.Price).IsRequired().HasPrecision(18, 2);

LiteCharms.Features/Shop/Products/Models/CreateProductModel.cs

@@ -0,0 +1,42 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace LiteCharms.Features.Shop.Products.Models;
+
+public class CreateProductModel
+{
+    [MaxLength(128)]
+    [Required(ErrorMessage = "Product name is required.")]
+    public string? Name { get; set; }
+
+    [MaxLength(512)]
+    [Required(ErrorMessage = "Summary is required.")]
+    public string? Summary { get; set; }
+
+    [MaxLength(2048)]
+    [Required(ErrorMessage = "Description is required.")]
+    public string? Description { get; set; }
+
+    [Range(0.01, double.MaxValue, ErrorMessage = "Price must be greater than zero.")]
+    public decimal Price { get; set; }
+
+    [MaxLength(128)]
+    [Required(ErrorMessage = "Author metadata is required.")]
+    public string? Author { get; set; }
+
+    [Required(ErrorMessage = "Publication Date is required.")]
+    public DateTime PublishDate { get; set; } = DateTime.Today;
+
+    [MaxLength(255)]
+    [Required(ErrorMessage = "Copyright Information field is required.")]
+    public string? CopyrightInfo { get; set; }
+
+    [MaxLength(128)]
+    [Required(ErrorMessage = "ISBN code is required.")]
+    [RegularExpression(@"^(?=(?:\D*\d){10}(?:(?:\D*\d){3})?$)[\d-]+$", ErrorMessage = "Please enter a valid ISBN-10 or ISBN-13 string.")]
+    public string? Isbn { get; set; }
+
+    [Required(ErrorMessage = "Primary image is required.")]
+    public string? ImageUrl { get; set; }
+
+    public List<string> Thumbnails { get; set; } = [];
+}

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

@@ -4,6 +4,10 @@ public class Product
 {
     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; }
@@ -15,4 +19,6 @@ public class Product
     public string[]? Thumbnails { get; set; }
 
     public bool Active { get; set; }
+
+    public ProductMetadata? Metadata { get; set; }
 }

LiteCharms.Features/Shop/Products/Models/ProductMetadata.cs

@@ -0,0 +1,12 @@
+namespace LiteCharms.Features.Shop.Products.Models;
+
+public class ProductMetadata
+{
+    public string? Manufacturer { get; set; }
+
+    public string? ManufactureDate { get; set; }
+
+    public string? CopyrightInfo { get; set; }
+
+    public string? SerialNumber { get; set; }
+}

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

@@ -11,4 +11,6 @@ public record CreateProduct
     public required string ImageUrl { get; set; }
 
     public string[]? Thumbnails { get; set; }
+
+    public ProductMetadata? Metadata { get; set; }
 }

LiteCharms.Features/Shop/Products/ProductService.cs

@@ -70,7 +70,8 @@ public class ProductService(IDbContextFactory<ShopDbContext> contextFactory)
                 Summary = request.Summary,
                 Description = request.Description,
                 ImageUrl = request.ImageUrl,
-                Thumbnails = request.Thumbnails
+                Thumbnails = request.Thumbnails,
+                Metadata = request.Metadata
             });
 
             return await context.SaveChangesAsync(cancellationToken) > 0
@@ -206,7 +207,7 @@ public class ProductService(IDbContextFactory<ShopDbContext> contextFactory)
 
             var result = await CreateProductPriceAsync(existingPrice.ProductId, price, discount, cancellationToken);
 
-            if(result.IsFailed)
+            if (result.IsFailed)
             {
                 var deactivatedPrice = await context.ProductPrices.FirstOrDefaultAsync(p => p.Id == productPriceId, cancellationToken);
 
@@ -225,4 +226,52 @@ public class ProductService(IDbContextFactory<ShopDbContext> contextFactory)
             return Result.Fail(new Error(ex.Message).CausedBy(ex));
         }
     }
+
+    public async ValueTask<Result> SetProductPriceStatusAsync(Guid productPriceId, bool active, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var productPrice = await context.ProductPrices.FirstOrDefaultAsync(p => p.Id == productPriceId, cancellationToken);
+
+            if (productPrice is null)
+                return Result.Fail($"Could not find product price with ID {productPriceId}");
+
+            productPrice.Active = active;
+            productPrice.UpdatedAt = DateTime.UtcNow;
+
+            return await context.SaveChangesAsync(cancellationToken) > 0
+                ? Result.Ok()
+                : Result.Fail($"Failed to change product price status by ID {productPriceId}");
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    public async ValueTask<Result> UpdateProductMetadataAsync(Guid productId, ProductMetadata metadata, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            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($"Could not find product with ID {productId}");
+            
+            product.Metadata = metadata;
+            product.UpdatedAt = DateTime.UtcNow;
+
+            return await context.SaveChangesAsync(cancellationToken) > 0
+                ? Result.Ok()
+                : Result.Fail($"Failed to update product metadata by ID {productId}");
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail(new Error(ex.Message).CausedBy(ex));
+        }
+    }
 }