From 1b997013bbe38b8bdc2b5e3db4f846b013cb1fc5 Mon Sep 17 00:00:00 2001 From: Khwezi Mngoma Date: Sun, 3 May 2026 16:10:27 +0200 Subject: [PATCH] Added shared projects --- LICENSE | 18 + .../Configuration/CustomerConfiguration.cs | 35 ++ .../Configuration/LeadConfiguration.cs | 25 ++ .../Configuration/OrderConfiguration.cs | 28 ++ .../Configuration/OrderRefundConfiguration.cs | 19 + .../Configuration/ProductConfiguration.cs | 14 + .../ProductPriceConfiguration.cs | 22 ++ LiteCharms.Entities/Customer.cs | 11 + LiteCharms.Entities/Lead.cs | 9 + .../LiteCharms.Entities.csproj | 45 +++ LiteCharms.Entities/Order.cs | 13 + LiteCharms.Entities/OrderRefund.cs | 9 + LiteCharms.Entities/Product.cs | 9 + LiteCharms.Entities/ProductPrice.cs | 9 + LiteCharms.Extensions/EntityModeMappers.cs | 94 +++++ .../LiteCharms.Extensions.csproj | 95 +++++ LiteCharms.Extensions/Services.cs | 78 ++++ .../Commands/CreateCustomerCommand.cs | 64 ++++ .../Handlers/CreateCustomerCommandHandler.cs | 48 +++ .../Handlers/RefundCustomerCommandHandler.cs | 38 ++ .../Handlers/UpdateCustomerCommandHandler.cs | 44 +++ .../Commands/RefundCustomerCommand.cs | 38 ++ .../Commands/UpdateCustomerCommand.cs | 70 ++++ .../Queries/GetCustomerOrdersQuery.cs | 18 + .../Queries/GetCustomerRefundsQuery.cs | 18 + .../Customers/Queries/GetCustomersQuery.cs | 24 ++ .../Handlers/GetCustomerOrdersQueryHandler.cs | 29 ++ .../GetCustomerRefundsQueryHandler.cs | 31 ++ .../Handlers/GetCustomersQueryHandler.cs | 32 ++ .../Leads/Commands/CreateLeadCommand.cs | 49 +++ .../Handlers/CreateLeadCommandHandler.cs | 46 +++ .../Handlers/UpdateLeadCommandHandler.cs | 29 ++ .../Leads/Commands/UpdateLeadCommand.cs | 27 ++ .../Leads/Queries/GetCustomerLeadsQuery.cs | 30 ++ .../Leads/Queries/GetLeadsQuery.cs | 24 ++ .../Handlers/GetCustomerLeadsQueryHandler.cs | 33 ++ .../Queries/Handlers/GetLeadsQueryHandler.cs | 32 ++ .../LiteCharms.Features.csproj | 53 +++ .../Orders/Commands/CreateOrderCommand.cs | 25 ++ .../Handlers/CreateOrderCommandHandler.cs | 29 ++ .../Handlers/UpdateOrderCommandHandler.cs | 29 ++ .../Orders/Commands/UpdateOrderCommand.cs | 30 ++ .../Orders/Queries/GetOrderRefundQuery.cs | 27 ++ .../Orders/Queries/GetOrdersQuery.cs | 24 ++ .../Handlers/GetOrderRefundQueryHandler.cs | 27 ++ .../Queries/Handlers/GetOrdersQueryHandler.cs | 32 ++ .../Products/Queries/GetProductPriceQuery.cs | 18 + .../Products/Queries/GetProductQuery.cs | 18 + .../Products/Queries/GetProductsQuery.cs | 8 + .../Handlers/GetProductPriceQueryHandler.cs | 29 ++ .../Handlers/GetProductQueryHandler.cs | 26 ++ .../Handlers/GetProductsQueryHandler.cs | 26 ++ .../Utilities/Commands/ComputeHashCommand.cs | 16 + .../Handlers/ComputeHashCommandHandler.cs | 18 + .../Database/LeadGeneratorDbContext.cs | 18 + .../Database/LeadGeneratorDbContextFactory.cs | 19 + .../20260502231708_Init.Designer.cs | 272 +++++++++++++ .../Migrations/20260502231708_Init.cs | 154 ++++++++ ...123_DefinedEntityRelationships.Designer.cs | 357 ++++++++++++++++++ ...260503002123_DefinedEntityRelationships.cs | 175 +++++++++ ...03003624_RemovedLeadIdFromLead.Designer.cs | 354 +++++++++++++++++ .../20260503003624_RemovedLeadIdFromLead.cs | 29 ++ ...260503012708_AddedStatusToLead.Designer.cs | 357 ++++++++++++++++++ .../20260503012708_AddedStatusToLead.cs | 29 ++ ...tedAttributionHashColumnOnLead.Designer.cs | 357 ++++++++++++++++++ ...55_CorrectedAttributionHashColumnOnLead.cs | 28 ++ .../LeadGeneratorDbContextModelSnapshot.cs | 354 +++++++++++++++++ .../HealthChecks/PostgresHealthCheck.cs | 26 ++ .../LiteCharms.Infrastructure.csproj | 83 ++++ LiteCharms.Infrastructure/appsettings.json | 3 + LiteCharms.Models/Customer.cs | 44 +++ LiteCharms.Models/Enums.cs | 21 ++ LiteCharms.Models/Lead.cs | 34 ++ LiteCharms.Models/LiteCharms.Models.csproj | 30 ++ LiteCharms.Models/Order.cs | 20 + LiteCharms.Models/OrderRefund.cs | 14 + LiteCharms.Models/Product.cs | 12 + LiteCharms.Models/ProductPrice.cs | 18 + LiteCharms.snk | Bin 0 -> 596 bytes LiteCharmsShared.slnx | 8 +- icon.png | Bin 0 -> 287591 bytes 81 files changed, 4507 insertions(+), 1 deletion(-) create mode 100644 LICENSE create mode 100644 LiteCharms.Entities/Configuration/CustomerConfiguration.cs create mode 100644 LiteCharms.Entities/Configuration/LeadConfiguration.cs create mode 100644 LiteCharms.Entities/Configuration/OrderConfiguration.cs create mode 100644 LiteCharms.Entities/Configuration/OrderRefundConfiguration.cs create mode 100644 LiteCharms.Entities/Configuration/ProductConfiguration.cs create mode 100644 LiteCharms.Entities/Configuration/ProductPriceConfiguration.cs create mode 100644 LiteCharms.Entities/Customer.cs create mode 100644 LiteCharms.Entities/Lead.cs create mode 100644 LiteCharms.Entities/LiteCharms.Entities.csproj create mode 100644 LiteCharms.Entities/Order.cs create mode 100644 LiteCharms.Entities/OrderRefund.cs create mode 100644 LiteCharms.Entities/Product.cs create mode 100644 LiteCharms.Entities/ProductPrice.cs create mode 100644 LiteCharms.Extensions/EntityModeMappers.cs create mode 100644 LiteCharms.Extensions/LiteCharms.Extensions.csproj create mode 100644 LiteCharms.Extensions/Services.cs create mode 100644 LiteCharms.Features/Customers/Commands/CreateCustomerCommand.cs create mode 100644 LiteCharms.Features/Customers/Commands/Handlers/CreateCustomerCommandHandler.cs create mode 100644 LiteCharms.Features/Customers/Commands/Handlers/RefundCustomerCommandHandler.cs create mode 100644 LiteCharms.Features/Customers/Commands/Handlers/UpdateCustomerCommandHandler.cs create mode 100644 LiteCharms.Features/Customers/Commands/RefundCustomerCommand.cs create mode 100644 LiteCharms.Features/Customers/Commands/UpdateCustomerCommand.cs create mode 100644 LiteCharms.Features/Customers/Queries/GetCustomerOrdersQuery.cs create mode 100644 LiteCharms.Features/Customers/Queries/GetCustomerRefundsQuery.cs create mode 100644 LiteCharms.Features/Customers/Queries/GetCustomersQuery.cs create mode 100644 LiteCharms.Features/Customers/Queries/Handlers/GetCustomerOrdersQueryHandler.cs create mode 100644 LiteCharms.Features/Customers/Queries/Handlers/GetCustomerRefundsQueryHandler.cs create mode 100644 LiteCharms.Features/Customers/Queries/Handlers/GetCustomersQueryHandler.cs create mode 100644 LiteCharms.Features/Leads/Commands/CreateLeadCommand.cs create mode 100644 LiteCharms.Features/Leads/Commands/Handlers/CreateLeadCommandHandler.cs create mode 100644 LiteCharms.Features/Leads/Commands/Handlers/UpdateLeadCommandHandler.cs create mode 100644 LiteCharms.Features/Leads/Commands/UpdateLeadCommand.cs create mode 100644 LiteCharms.Features/Leads/Queries/GetCustomerLeadsQuery.cs create mode 100644 LiteCharms.Features/Leads/Queries/GetLeadsQuery.cs create mode 100644 LiteCharms.Features/Leads/Queries/Handlers/GetCustomerLeadsQueryHandler.cs create mode 100644 LiteCharms.Features/Leads/Queries/Handlers/GetLeadsQueryHandler.cs create mode 100644 LiteCharms.Features/LiteCharms.Features.csproj create mode 100644 LiteCharms.Features/Orders/Commands/CreateOrderCommand.cs create mode 100644 LiteCharms.Features/Orders/Commands/Handlers/CreateOrderCommandHandler.cs create mode 100644 LiteCharms.Features/Orders/Commands/Handlers/UpdateOrderCommandHandler.cs create mode 100644 LiteCharms.Features/Orders/Commands/UpdateOrderCommand.cs create mode 100644 LiteCharms.Features/Orders/Queries/GetOrderRefundQuery.cs create mode 100644 LiteCharms.Features/Orders/Queries/GetOrdersQuery.cs create mode 100644 LiteCharms.Features/Orders/Queries/Handlers/GetOrderRefundQueryHandler.cs create mode 100644 LiteCharms.Features/Orders/Queries/Handlers/GetOrdersQueryHandler.cs create mode 100644 LiteCharms.Features/Products/Queries/GetProductPriceQuery.cs create mode 100644 LiteCharms.Features/Products/Queries/GetProductQuery.cs create mode 100644 LiteCharms.Features/Products/Queries/GetProductsQuery.cs create mode 100644 LiteCharms.Features/Products/Queries/Handlers/GetProductPriceQueryHandler.cs create mode 100644 LiteCharms.Features/Products/Queries/Handlers/GetProductQueryHandler.cs create mode 100644 LiteCharms.Features/Products/Queries/Handlers/GetProductsQueryHandler.cs create mode 100644 LiteCharms.Features/Utilities/Commands/ComputeHashCommand.cs create mode 100644 LiteCharms.Features/Utilities/Commands/Handlers/ComputeHashCommandHandler.cs create mode 100644 LiteCharms.Infrastructure/Database/LeadGeneratorDbContext.cs create mode 100644 LiteCharms.Infrastructure/Database/LeadGeneratorDbContextFactory.cs create mode 100644 LiteCharms.Infrastructure/Database/Migrations/20260502231708_Init.Designer.cs create mode 100644 LiteCharms.Infrastructure/Database/Migrations/20260502231708_Init.cs create mode 100644 LiteCharms.Infrastructure/Database/Migrations/20260503002123_DefinedEntityRelationships.Designer.cs create mode 100644 LiteCharms.Infrastructure/Database/Migrations/20260503002123_DefinedEntityRelationships.cs create mode 100644 LiteCharms.Infrastructure/Database/Migrations/20260503003624_RemovedLeadIdFromLead.Designer.cs create mode 100644 LiteCharms.Infrastructure/Database/Migrations/20260503003624_RemovedLeadIdFromLead.cs create mode 100644 LiteCharms.Infrastructure/Database/Migrations/20260503012708_AddedStatusToLead.Designer.cs create mode 100644 LiteCharms.Infrastructure/Database/Migrations/20260503012708_AddedStatusToLead.cs create mode 100644 LiteCharms.Infrastructure/Database/Migrations/20260503133855_CorrectedAttributionHashColumnOnLead.Designer.cs create mode 100644 LiteCharms.Infrastructure/Database/Migrations/20260503133855_CorrectedAttributionHashColumnOnLead.cs create mode 100644 LiteCharms.Infrastructure/Database/Migrations/LeadGeneratorDbContextModelSnapshot.cs create mode 100644 LiteCharms.Infrastructure/HealthChecks/PostgresHealthCheck.cs create mode 100644 LiteCharms.Infrastructure/LiteCharms.Infrastructure.csproj create mode 100644 LiteCharms.Infrastructure/appsettings.json create mode 100644 LiteCharms.Models/Customer.cs create mode 100644 LiteCharms.Models/Enums.cs create mode 100644 LiteCharms.Models/Lead.cs create mode 100644 LiteCharms.Models/LiteCharms.Models.csproj create mode 100644 LiteCharms.Models/Order.cs create mode 100644 LiteCharms.Models/OrderRefund.cs create mode 100644 LiteCharms.Models/Product.cs create mode 100644 LiteCharms.Models/ProductPrice.cs create mode 100644 LiteCharms.snk create mode 100644 icon.png diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..d3f8705 --- /dev/null +++ b/LICENSE @@ -0,0 +1,18 @@ +PROPRIETARY LICENSE + +Copyright (c) 2026 Lite Charms (PTY) Ltd. All rights reserved. + +This software and its associated documentation (the "Software") are the +proprietary property of Lite Charms (PTY) Ltd. + +The Software is provided for internal use only. Unauthorized copying, +distribution, modification, or use of this file via any medium is +strictly prohibited. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. diff --git a/LiteCharms.Entities/Configuration/CustomerConfiguration.cs b/LiteCharms.Entities/Configuration/CustomerConfiguration.cs new file mode 100644 index 0000000..9792251 --- /dev/null +++ b/LiteCharms.Entities/Configuration/CustomerConfiguration.cs @@ -0,0 +1,35 @@ +namespace LiteCharms.Entities.Configuration; + +public class CustomerConfiguration : IEntityTypeConfiguration +{ + public void Configure(EntityTypeBuilder builder) + { + builder.ToTable(nameof(Customer)); + + builder.HasKey(f => f.Id); + builder.Property(f => f.CreatedAt).ValueGeneratedOnAdd(); + builder.Property(f => f.UpdatedAt).IsRequired(false).ValueGeneratedOnUpdate(); + builder.Property(f => f.Company); + builder.Property(f => f.Name).IsRequired(); + builder.Property(f => f.LastName).IsRequired(); + builder.Property(f => f.Email).IsRequired(); + builder.Property(f => f.Tax); + builder.Property(f => f.Discord); + builder.Property(f => f.Slack); + builder.Property(f => f.LinkedIn); + builder.Property(f => f.Whatsapp); + builder.Property(f => f.Website); + builder.Property(f => f.Phone); + builder.Property(f => f.Address); + builder.Property(f => f.City); + builder.Property(f => f.Region); + 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); + } +} \ No newline at end of file diff --git a/LiteCharms.Entities/Configuration/LeadConfiguration.cs b/LiteCharms.Entities/Configuration/LeadConfiguration.cs new file mode 100644 index 0000000..c2ec1b6 --- /dev/null +++ b/LiteCharms.Entities/Configuration/LeadConfiguration.cs @@ -0,0 +1,25 @@ +namespace LiteCharms.Entities.Configuration; + +public class LeadConfiguration : IEntityTypeConfiguration +{ + public void Configure(EntityTypeBuilder builder) + { + builder.ToTable(nameof(Lead)); + + 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(false); + builder.Property(f => f.GoogleClickId); + builder.Property(f => f.WebClickId); + builder.Property(f => f.AppClickId); + builder.Property(f => f.CampaignId); + builder.Property(f => f.AdGroupId); + builder.Property(f => f.AdName); + builder.Property(f => f.TargetId); + builder.Property(f => f.FeedItemId); + builder.Property(f => f.ClickLocation); + builder.Property(f => f.Status).IsRequired(); + builder.Property(f => f.AttributionHash).IsRequired(true); + } +} diff --git a/LiteCharms.Entities/Configuration/OrderConfiguration.cs b/LiteCharms.Entities/Configuration/OrderConfiguration.cs new file mode 100644 index 0000000..5e51f70 --- /dev/null +++ b/LiteCharms.Entities/Configuration/OrderConfiguration.cs @@ -0,0 +1,28 @@ +namespace LiteCharms.Entities.Configuration; + +public class OrderConfiguration : IEntityTypeConfiguration +{ + public void Configure(EntityTypeBuilder 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.RefundId).IsRequired(false); + builder.Property(f => f.ProductPriceId).IsRequired(); + builder.Property(f => f.Status).HasConversion().IsRequired(); + builder.Property(f => f.Notes).HasColumnType("jsonb").IsRequired(false); + + builder.HasOne(f => f.ProductPrice) + .WithMany() + .HasForeignKey(f => f.ProductPriceId) + .OnDelete(DeleteBehavior.Restrict); + + builder.HasOne(f => f.Customer) + .WithMany(f => f.Orders) + .HasForeignKey(f => f.CustomerId) + .OnDelete(DeleteBehavior.Restrict); + } +} diff --git a/LiteCharms.Entities/Configuration/OrderRefundConfiguration.cs b/LiteCharms.Entities/Configuration/OrderRefundConfiguration.cs new file mode 100644 index 0000000..5550805 --- /dev/null +++ b/LiteCharms.Entities/Configuration/OrderRefundConfiguration.cs @@ -0,0 +1,19 @@ +namespace LiteCharms.Entities.Configuration; + +public class OrderRefundConfiguration : IEntityTypeConfiguration +{ + public void Configure(EntityTypeBuilder builder) + { + builder.ToTable(nameof(OrderRefund)); + + builder.HasKey(f => f.Id); + builder.Property(f => f.CreatedAt).ValueGeneratedOnAdd(); + builder.Property(f => f.OrderId).IsRequired(); + builder.Property(f => f.Reason).IsRequired(); + builder.Property(f => f.Amount).IsRequired().HasPrecision(18, 2); + + builder.HasOne(f => f.Order) + .WithOne(o => o.Refund) + .HasForeignKey(o => o.OrderId); + } +} diff --git a/LiteCharms.Entities/Configuration/ProductConfiguration.cs b/LiteCharms.Entities/Configuration/ProductConfiguration.cs new file mode 100644 index 0000000..3b5ca6d --- /dev/null +++ b/LiteCharms.Entities/Configuration/ProductConfiguration.cs @@ -0,0 +1,14 @@ +namespace LiteCharms.Entities.Configuration; + +public class ProductConfiguration : IEntityTypeConfiguration +{ + public void Configure(EntityTypeBuilder 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); + } +} diff --git a/LiteCharms.Entities/Configuration/ProductPriceConfiguration.cs b/LiteCharms.Entities/Configuration/ProductPriceConfiguration.cs new file mode 100644 index 0000000..5e7cfc9 --- /dev/null +++ b/LiteCharms.Entities/Configuration/ProductPriceConfiguration.cs @@ -0,0 +1,22 @@ +namespace LiteCharms.Entities.Configuration; + +public class ProductPriceConfiguration : IEntityTypeConfiguration +{ + public void Configure(EntityTypeBuilder builder) + { + builder.ToTable(nameof(ProductPrice)); + + builder.HasKey(f => f.Id); + builder.Property(f => f.CreatedAt).ValueGeneratedOnAdd(); + builder.Property(f => f.UpdatedAt).IsRequired(false).ValueGeneratedOnUpdate(); + builder.Property(f => f.ProductId).IsRequired(); + builder.Property(f => f.Price).IsRequired().HasPrecision(18, 2); + builder.Property(f => f.Discount).HasPrecision(18, 2); + builder.Property(f => f.Active); + + builder.HasOne(f => f.Product) + .WithMany(p => p.ProductPrices) + .HasForeignKey(f => f.ProductId) + .OnDelete(DeleteBehavior.Restrict); + } +} diff --git a/LiteCharms.Entities/Customer.cs b/LiteCharms.Entities/Customer.cs new file mode 100644 index 0000000..d41be70 --- /dev/null +++ b/LiteCharms.Entities/Customer.cs @@ -0,0 +1,11 @@ +using LiteCharms.Entities.Configuration; + +namespace LiteCharms.Entities; + +[EntityTypeConfiguration] +public class Customer : Models.Customer +{ + public virtual ICollection? Leads { get; set; } + + public virtual ICollection? Orders { get; set; } +} diff --git a/LiteCharms.Entities/Lead.cs b/LiteCharms.Entities/Lead.cs new file mode 100644 index 0000000..b1bdf62 --- /dev/null +++ b/LiteCharms.Entities/Lead.cs @@ -0,0 +1,9 @@ +using LiteCharms.Entities.Configuration; + +namespace LiteCharms.Entities; + +[EntityTypeConfiguration] +public class Lead : Models.Lead +{ + public virtual Customer? Customer { get; set; } +} diff --git a/LiteCharms.Entities/LiteCharms.Entities.csproj b/LiteCharms.Entities/LiteCharms.Entities.csproj new file mode 100644 index 0000000..26c5b6a --- /dev/null +++ b/LiteCharms.Entities/LiteCharms.Entities.csproj @@ -0,0 +1,45 @@ + + + + net10.0 + enable + enable + True + ..\LiteCharms.snk + + + + + LiteCharms.Entities + 1.0.1 + Khwezi Mngoma + Lite Charms (PTY) Ltd + Shared entities for Lite Charms applications. + https://gitea.khongisa.co.za/litecharms/leadgenerator + https://gitea.khongisa.co.za/litecharms/leadgenerator.git + git + LICENSE + utility;dotnet + icon.png + + + + + + + + + + + + + + + + + + + + + + diff --git a/LiteCharms.Entities/Order.cs b/LiteCharms.Entities/Order.cs new file mode 100644 index 0000000..7d4d8c2 --- /dev/null +++ b/LiteCharms.Entities/Order.cs @@ -0,0 +1,13 @@ +using LiteCharms.Entities.Configuration; + +namespace LiteCharms.Entities; + +[EntityTypeConfiguration] +public class Order : Models.Order +{ + public virtual OrderRefund? Refund { get; set; } + + public virtual Customer? Customer { get; set; } + + public virtual ProductPrice? ProductPrice { get; set; } +} diff --git a/LiteCharms.Entities/OrderRefund.cs b/LiteCharms.Entities/OrderRefund.cs new file mode 100644 index 0000000..e5a285d --- /dev/null +++ b/LiteCharms.Entities/OrderRefund.cs @@ -0,0 +1,9 @@ +using LiteCharms.Entities.Configuration; + +namespace LiteCharms.Entities; + +[EntityTypeConfiguration] +public class OrderRefund : Models.OrderRefund +{ + public virtual Order? Order { get; set; } +} diff --git a/LiteCharms.Entities/Product.cs b/LiteCharms.Entities/Product.cs new file mode 100644 index 0000000..6b46ff7 --- /dev/null +++ b/LiteCharms.Entities/Product.cs @@ -0,0 +1,9 @@ +using LiteCharms.Entities.Configuration; + +namespace LiteCharms.Entities; + +[EntityTypeConfiguration] +public class Product : Models.Product +{ + public virtual ICollection? ProductPrices { get; set; } +} diff --git a/LiteCharms.Entities/ProductPrice.cs b/LiteCharms.Entities/ProductPrice.cs new file mode 100644 index 0000000..db492ed --- /dev/null +++ b/LiteCharms.Entities/ProductPrice.cs @@ -0,0 +1,9 @@ +using LiteCharms.Entities.Configuration; + +namespace LiteCharms.Entities; + +[EntityTypeConfiguration] +public class ProductPrice : Models.ProductPrice +{ + public virtual Product? Product { get; set; } +} diff --git a/LiteCharms.Extensions/EntityModeMappers.cs b/LiteCharms.Extensions/EntityModeMappers.cs new file mode 100644 index 0000000..2632526 --- /dev/null +++ b/LiteCharms.Extensions/EntityModeMappers.cs @@ -0,0 +1,94 @@ +using LiteCharms.Models; + +namespace LiteCharms.Extensions; + +public static class EntityModeMappers +{ + public static Customer ToModel(this Entities.Customer entity) => + new() + { + Id = entity.Id, + CreatedAt = entity.CreatedAt, + UpdatedAt = entity.UpdatedAt, + Active = entity.Active, + Address = entity.Address, + City = entity.City, + Company = entity.Company, + Country = entity.Country, + Discord = entity.Discord, + Email = entity.Email, + LastName = entity.LastName, + LinkedIn = entity.LinkedIn, + Name = entity.Name, + Phone = entity.Phone, + PostalCode = entity.PostalCode, + Region = entity.Region, + Slack = entity.Slack, + Tax = entity.Tax, + Website = entity.Website, + Whatsapp = entity.Whatsapp + }; + + public static Lead ToModel(this Entities.Lead entity) => + new() + { + Id = entity.Id, + CreatedAt = entity.CreatedAt, + UpdatedAt = entity.UpdatedAt, + AdGroupId = entity.AdGroupId, + AdName = entity.AdName, + AppClickId = entity.AppClickId, + AttributionHash = entity.AttributionHash, + CampaignId = entity.CampaignId, + ClickLocation = entity.ClickLocation, + CustomerId = entity.CustomerId, + FeedItemId = entity.FeedItemId, + GoogleClickId = entity.GoogleClickId, + TargetId = entity.TargetId, + WebClickId = entity.WebClickId, + Status = entity.Status + }; + + public static Order ToModel(this Entities.Order entity) => + new() + { + Id = entity.Id, + CreatedAt = entity.CreatedAt, + UpdatedAt = entity.UpdatedAt, + CustomerId = entity.CustomerId, + ProductPriceId = entity.ProductPriceId, + Notes = entity.Notes, + RefundId = entity.RefundId + }; + + public static OrderRefund ToModel(this Entities.OrderRefund entity) => + new() + { + Id = entity.Id, + CreatedAt = entity.CreatedAt, + OrderId = entity.OrderId, + Reason = entity.Reason, + Amount = entity.Amount + }; + + public static Product ToModel(this Entities.Product entity) => + new() + { + Id = entity.Id, + Name = entity.Name, + Description = entity.Description, + Active = entity.Active + }; + + public static ProductPrice ToModel(this Entities.ProductPrice entity) => + new() + { + Id = entity.Id, + ProductId = entity.ProductId, + Price = entity.Price, + Active = entity.Active, + CreatedAt = entity.CreatedAt, + Discount = entity.Discount, + UpdatedAt = entity.UpdatedAt + }; +} diff --git a/LiteCharms.Extensions/LiteCharms.Extensions.csproj b/LiteCharms.Extensions/LiteCharms.Extensions.csproj new file mode 100644 index 0000000..83fd24a --- /dev/null +++ b/LiteCharms.Extensions/LiteCharms.Extensions.csproj @@ -0,0 +1,95 @@ + + + + net10.0 + enable + enable + True + ..\LiteCharms.snk + + + + + LiteCharms.Extensions + 1.0.1 + Khwezi Mngoma + Lite Charms (PTY) Ltd + Extension components for Lite Charms applications. + https://gitea.khongisa.co.za/litecharms/leadgenerator + https://gitea.khongisa.co.za/litecharms/leadgenerator.git + git + LICENSE + utility;dotnet + icon.png + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + all + runtime; build; native; contentfiles; analyzers; buildtransitive + + + + all + runtime; build; native; contentfiles; analyzers; buildtransitive + + + + + + + + + + + + + + + + + diff --git a/LiteCharms.Extensions/Services.cs b/LiteCharms.Extensions/Services.cs new file mode 100644 index 0000000..6d00d21 --- /dev/null +++ b/LiteCharms.Extensions/Services.cs @@ -0,0 +1,78 @@ +using LiteCharms.Infrastructure.Database; +using LiteCharms.Infrastructure.HealthChecks; + +namespace LiteCharms.Extensions; + +public static class Services +{ + public static IServiceCollection AddHealthChecksSupport(this IServiceCollection services, IConfiguration configuration) + { + services.AddHealthChecks() + .AddCheck("Self", () => HealthCheckResult.Healthy()) + .AddCheck("PostgreSQL"); + + //services.AddHealthChecksUI(setup => + //{ + // setup.AddHealthCheckEndpoint("Lead Generator", $"{configuration["ASPNETCORE_URLS"]}/healthui"); + // setup.SetEvaluationTimeInSeconds(15); + //}).AddSqliteStorage($"Data Source=health_history.db"); + + return services; + } + + public static IServiceCollection AddLeadGeneratorDatabase(this IServiceCollection services, IConfiguration configuration) + { + services.AddPooledDbContextFactory(options => + options.UseNpgsql(configuration.GetConnectionString("PostgresLeadGenerator"))); + + return services; + } + + public static WebApplicationBuilder AddMonitoring(this WebApplicationBuilder builder) + { + var serviceName = builder.Configuration.GetValue("Monitoring:ServiceName") ?? "LiteCharms.Capture"; + var endpoint = builder.Configuration.GetValue("Monitoring:Address")!; + var apiKey = builder.Configuration.GetValue("Monitoring:ApiKey"); + + var resourceBuilder = ResourceBuilder.CreateDefault() + .AddService(serviceName); + + var otlpHeaders = !string.IsNullOrEmpty(apiKey) ? $"x-otlp-api-key={apiKey}" : null; + + builder.Logging.AddOpenTelemetry(logging => + { + logging.SetResourceBuilder(resourceBuilder); + logging.AddOtlpExporter(opt => + { + opt.Endpoint = new Uri(endpoint); + opt.Protocol = OtlpExportProtocol.Grpc; + opt.Headers = otlpHeaders; + }); + }); + + builder.Services.AddOpenTelemetry() + .WithTracing(tracing => tracing + .SetResourceBuilder(resourceBuilder) + .AddAspNetCoreInstrumentation() + .AddHttpClientInstrumentation() + .AddOtlpExporter(opt => + { + opt.Endpoint = new Uri(endpoint); + opt.Protocol = OtlpExportProtocol.Grpc; + opt.Headers = otlpHeaders; + })) + .WithMetrics(metrics => metrics + .SetResourceBuilder(resourceBuilder) + .AddMeter(serviceName) + .AddAspNetCoreInstrumentation() + .AddRuntimeInstrumentation() + .AddOtlpExporter(opt => + { + opt.Endpoint = new Uri(endpoint); + opt.Protocol = OtlpExportProtocol.Grpc; + opt.Headers = otlpHeaders; + })); + + return builder; + } +} \ No newline at end of file diff --git a/LiteCharms.Features/Customers/Commands/CreateCustomerCommand.cs b/LiteCharms.Features/Customers/Commands/CreateCustomerCommand.cs new file mode 100644 index 0000000..f0b3560 --- /dev/null +++ b/LiteCharms.Features/Customers/Commands/CreateCustomerCommand.cs @@ -0,0 +1,64 @@ +namespace LiteCharms.Features.Customers.Commands; + +public class CreateCustomerCommand : IRequest> +{ + 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; } + + private CreateCustomerCommand(string name, string lastName, string? company, string? tax, string email, string? discord, string? slack, string? linkedIn, string? whatsapp, string? website, string? phone, string? address, string? city, string? region, string? country, string? postalCode) + { + Name = name; + LastName = lastName; + Company = company; + Tax = tax; + Email = email; + Discord = discord; + Slack = slack; + LinkedIn = linkedIn; + Whatsapp = whatsapp; + Website = website; + Phone = phone; + Address = address; + City = city; + Region = region; + Country = country; + PostalCode = postalCode; + } + + public static CreateCustomerCommand Create(string name, string lastName, string? company, string? tax, string email, string? discord, string? slack, string? linkedIn, string? whatsapp, string? website, string? phone, string? address, string? city, string? region, string? country, string? postalCode) + { + if (string.IsNullOrWhiteSpace(name) && string.IsNullOrWhiteSpace(lastName) && string.IsNullOrWhiteSpace(email)) + throw new ArgumentException("At the following fields must be provided: Name, LastName, Email"); + + return new(name, lastName, company, tax, email, discord, slack, linkedIn, whatsapp, website, phone, address, city, region, country, postalCode); + } +} diff --git a/LiteCharms.Features/Customers/Commands/Handlers/CreateCustomerCommandHandler.cs b/LiteCharms.Features/Customers/Commands/Handlers/CreateCustomerCommandHandler.cs new file mode 100644 index 0000000..d49e7c1 --- /dev/null +++ b/LiteCharms.Features/Customers/Commands/Handlers/CreateCustomerCommandHandler.cs @@ -0,0 +1,48 @@ +using LiteCharms.Infrastructure.Database; + +namespace LiteCharms.Features.Customers.Commands.Handlers; + +public class CreateCustomerCommandHandler(IDbContextFactory contextFactory) : IRequestHandler> +{ + public async ValueTask> Handle(CreateCustomerCommand request, CancellationToken cancellationToken) + { + 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(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(new Error($"Failed to create customer {customerEmail}")); + } + catch (Exception ex) + { + return Result.Fail(new Error(ex.Message).CausedBy(ex)); + } + } +} diff --git a/LiteCharms.Features/Customers/Commands/Handlers/RefundCustomerCommandHandler.cs b/LiteCharms.Features/Customers/Commands/Handlers/RefundCustomerCommandHandler.cs new file mode 100644 index 0000000..1d3af5e --- /dev/null +++ b/LiteCharms.Features/Customers/Commands/Handlers/RefundCustomerCommandHandler.cs @@ -0,0 +1,38 @@ +using LiteCharms.Infrastructure.Database; + +namespace LiteCharms.Features.Customers.Commands.Handlers; + +public class RefundCustomerCommandHandler(IDbContextFactory contextFactory) : IRequestHandler> +{ + public async ValueTask> Handle(RefundCustomerCommand request, CancellationToken cancellationToken) + { + try + { + using var context = await contextFactory.CreateDbContextAsync(cancellationToken); + + if(!await context.Orders.AnyAsync(o => o.Id == request.OrderId, cancellationToken)) + return Result.Fail(new Error($"Order with Id: {request.OrderId} does not exist")); + + if (!await context.Customers.AnyAsync(c => c.Id == request.CustomerId, cancellationToken)) + return Result.Fail(new Error($"Customer with Id: {request.CustomerId} does not exist")); + + if(!await context.Orders.AnyAsync(o => o.Id == request.OrderId && o.CustomerId == request.CustomerId, cancellationToken)) + return Result.Fail(new Error($"Order with Id: {request.OrderId} does not belong to Customer with Id: {request.CustomerId}")); + + var refund = context.OrderRefunds.Add(new Entities.OrderRefund + { + OrderId = request.OrderId, + Reason = request.Reason, + Amount = request.Amount + }); + + return await context.SaveChangesAsync(cancellationToken) > 0 + ? Result.Ok(refund.Entity.Id) + : Result.Fail(new Error($"Failed to create refund for OrderId: {request.OrderId}")); + } + catch (Exception ex) + { + return Result.Fail(new Error(ex.Message).CausedBy(ex)); + } + } +} diff --git a/LiteCharms.Features/Customers/Commands/Handlers/UpdateCustomerCommandHandler.cs b/LiteCharms.Features/Customers/Commands/Handlers/UpdateCustomerCommandHandler.cs new file mode 100644 index 0000000..e16469a --- /dev/null +++ b/LiteCharms.Features/Customers/Commands/Handlers/UpdateCustomerCommandHandler.cs @@ -0,0 +1,44 @@ +using LiteCharms.Infrastructure.Database; + +namespace LiteCharms.Features.Customers.Commands.Handlers; + +public class UpdateCustomerCommandHandler(IDbContextFactory contextFactory) : IRequestHandler +{ + public async ValueTask Handle(UpdateCustomerCommand request, CancellationToken cancellationToken) + { + 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)); + } + } +} \ No newline at end of file diff --git a/LiteCharms.Features/Customers/Commands/RefundCustomerCommand.cs b/LiteCharms.Features/Customers/Commands/RefundCustomerCommand.cs new file mode 100644 index 0000000..6b22a2a --- /dev/null +++ b/LiteCharms.Features/Customers/Commands/RefundCustomerCommand.cs @@ -0,0 +1,38 @@ +namespace LiteCharms.Features.Customers.Commands; + +public class RefundCustomerCommand : IRequest> +{ + public Guid OrderId { get; set; } + + public Guid CustomerId { get; set; } + + public string? Reason { get; set; } + + public decimal Amount { get; set; } + + private RefundCustomerCommand(Guid orderId, Guid customerId, string? reason, decimal amount) + { + OrderId = orderId; + CustomerId = customerId; + Reason = reason; + Amount = amount; + CustomerId = customerId; + } + + public static RefundCustomerCommand Create(Guid orderId, Guid customerId, string? reason, decimal amount) + { + if (orderId == Guid.Empty) + throw new ArgumentException("OrderId is required", nameof(orderId)); + + if (customerId == Guid.Empty) + throw new ArgumentException("CustomerId is required", nameof(customerId)); + + if (amount <= 0) + throw new ArgumentException("Amount must be greater than zero", nameof(amount)); + + if (string.IsNullOrWhiteSpace(reason)) + throw new ArgumentException("Reason is required", nameof(reason)); + + return new(orderId, customerId, reason, amount); + } +} diff --git a/LiteCharms.Features/Customers/Commands/UpdateCustomerCommand.cs b/LiteCharms.Features/Customers/Commands/UpdateCustomerCommand.cs new file mode 100644 index 0000000..ac4f0cd --- /dev/null +++ b/LiteCharms.Features/Customers/Commands/UpdateCustomerCommand.cs @@ -0,0 +1,70 @@ +namespace LiteCharms.Features.Customers.Commands; + +public class UpdateCustomerCommand : IRequest +{ + public 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; } + + private UpdateCustomerCommand(Guid customerId, string name, string lastName, string? company, string? tax, string email, string? discord, string? slack, string? linkedIn, string? whatsapp, string? website, string? phone, string? address, string? city, string? region, string? country, string? postalCode) + { + CustomerId = customerId; + Name = name; + LastName = lastName; + Company = company; + Tax = tax; + Email = email; + Discord = discord; + Slack = slack; + LinkedIn = linkedIn; + Whatsapp = whatsapp; + Website = website; + Phone = phone; + Address = address; + City = city; + Region = region; + Country = country; + PostalCode = postalCode; + } + + public static UpdateCustomerCommand Create(Guid customerId, string name, string lastName, string? company, string? tax, string email, string? discord, string? slack, string? linkedIn, string? whatsapp, string? website, string? phone, string? address, string? city, string? region, string? country, string? postalCode) + { + if (customerId == Guid.Empty) + throw new ArgumentException("Customer ID is required.", nameof(customerId)); + + if (string.IsNullOrWhiteSpace(name) && string.IsNullOrWhiteSpace(lastName) && string.IsNullOrWhiteSpace(email)) + throw new ArgumentException("At the following fields must be provided: Name, LastName, Email"); + + return new(customerId, name, lastName, company, tax, email, discord, slack, linkedIn, whatsapp, website, phone, address, city, region, country, postalCode); + } +} diff --git a/LiteCharms.Features/Customers/Queries/GetCustomerOrdersQuery.cs b/LiteCharms.Features/Customers/Queries/GetCustomerOrdersQuery.cs new file mode 100644 index 0000000..26b7c0e --- /dev/null +++ b/LiteCharms.Features/Customers/Queries/GetCustomerOrdersQuery.cs @@ -0,0 +1,18 @@ +using LiteCharms.Models; + +namespace LiteCharms.Features.Customers.Queries; + +public class GetCustomerOrdersQuery : IRequest> +{ + public Guid CustomerId { get; } + + private GetCustomerOrdersQuery(Guid customerId) => CustomerId = customerId; + + public static GetCustomerOrdersQuery Create(Guid customerId) + { + if (customerId == Guid.Empty) + throw new ArgumentException("CustomerId is required.", nameof(customerId)); + + return new(customerId); + } +} diff --git a/LiteCharms.Features/Customers/Queries/GetCustomerRefundsQuery.cs b/LiteCharms.Features/Customers/Queries/GetCustomerRefundsQuery.cs new file mode 100644 index 0000000..eb4b7a2 --- /dev/null +++ b/LiteCharms.Features/Customers/Queries/GetCustomerRefundsQuery.cs @@ -0,0 +1,18 @@ +using LiteCharms.Models; + +namespace LiteCharms.Features.Customers.Queries; + +public class GetCustomerRefundsQuery : IRequest> +{ + public Guid CustomerId { get; set; } + + private GetCustomerRefundsQuery(Guid customerId) => CustomerId = customerId; + + public static GetCustomerRefundsQuery Create(Guid customerId) + { + if (customerId == Guid.Empty) + throw new ArgumentException("CustomerId is required.", nameof(customerId)); + + return new(customerId); + } +} diff --git a/LiteCharms.Features/Customers/Queries/GetCustomersQuery.cs b/LiteCharms.Features/Customers/Queries/GetCustomersQuery.cs new file mode 100644 index 0000000..76bab43 --- /dev/null +++ b/LiteCharms.Features/Customers/Queries/GetCustomersQuery.cs @@ -0,0 +1,24 @@ +using LiteCharms.Models; + +namespace LiteCharms.Features.Customers.Queries; + +public class GetCustomersQuery : IRequest> +{ + public DateOnly From { get; set; } + + public DateOnly To { get; set; } + + private GetCustomersQuery(DateOnly from, DateOnly to) + { + From = from; + To = to; + } + + public static GetCustomersQuery Create(DateOnly from, DateOnly to) + { + if (from > to) + throw new ArgumentException("From date cannot be greater than To date."); + + return new(from, to); + } +} diff --git a/LiteCharms.Features/Customers/Queries/Handlers/GetCustomerOrdersQueryHandler.cs b/LiteCharms.Features/Customers/Queries/Handlers/GetCustomerOrdersQueryHandler.cs new file mode 100644 index 0000000..66f1140 --- /dev/null +++ b/LiteCharms.Features/Customers/Queries/Handlers/GetCustomerOrdersQueryHandler.cs @@ -0,0 +1,29 @@ +using LiteCharms.Extensions; +using LiteCharms.Infrastructure.Database; +using LiteCharms.Models; + +namespace LiteCharms.Features.Customers.Queries.Handlers; + +public class GetCustomerOrdersQueryHandler(IDbContextFactory contextFactory) : IRequestHandler> +{ + public async ValueTask> Handle(GetCustomerOrdersQuery request, CancellationToken cancellationToken) + { + try + { + using var context = await contextFactory.CreateDbContextAsync(cancellationToken); + + var orders = await context.Orders.AsNoTracking() + .OrderByDescending(o => o.CreatedAt) + .Where(o => o.CustomerId == request.CustomerId) + .ToArrayAsync(cancellationToken); + + return orders?.Length > 0 + ? Result.Ok(orders.Select(o => o.ToModel()).ToArray()) + : Result.Fail(new Error($"No orders found for customer with Id {request.CustomerId}.")); + } + catch (Exception ex) + { + return Result.Fail(new Error(ex.Message).CausedBy(ex)); + } + } +} diff --git a/LiteCharms.Features/Customers/Queries/Handlers/GetCustomerRefundsQueryHandler.cs b/LiteCharms.Features/Customers/Queries/Handlers/GetCustomerRefundsQueryHandler.cs new file mode 100644 index 0000000..26188af --- /dev/null +++ b/LiteCharms.Features/Customers/Queries/Handlers/GetCustomerRefundsQueryHandler.cs @@ -0,0 +1,31 @@ +using LiteCharms.Extensions; +using LiteCharms.Infrastructure.Database; +using LiteCharms.Models; + +namespace LiteCharms.Features.Customers.Queries.Handlers; + +public class GetCustomerRefundsQueryHandler(IDbContextFactory contextFactory) : IRequestHandler> +{ + public async ValueTask> Handle(GetCustomerRefundsQuery request, CancellationToken cancellationToken) + { + try + { + using var context = await contextFactory.CreateDbContextAsync(cancellationToken); + + if(!await context.Customers.AnyAsync(c => c.Id == request.CustomerId, cancellationToken)) + return Result.Fail(new Error($"Customer with Id {request.CustomerId} does not exist.")); + + var refunds = await context.OrderRefunds.AsNoTracking().AsSplitQuery() + .OrderByDescending(o => o.CreatedAt) + .Where(r => r.Order!.CustomerId == request.CustomerId).ToArrayAsync(cancellationToken); + + return refunds?.Length > 0 + ? Result.Ok(refunds.Select(r => r.ToModel()).ToArray()) + : Result.Fail(new Error($"No refunds found for customer with Id {request.CustomerId}.")); + } + catch (Exception ex) + { + return Result.Fail(new Error(ex.Message).CausedBy(ex)); + } + } +} diff --git a/LiteCharms.Features/Customers/Queries/Handlers/GetCustomersQueryHandler.cs b/LiteCharms.Features/Customers/Queries/Handlers/GetCustomersQueryHandler.cs new file mode 100644 index 0000000..dd5d753 --- /dev/null +++ b/LiteCharms.Features/Customers/Queries/Handlers/GetCustomersQueryHandler.cs @@ -0,0 +1,32 @@ +using LiteCharms.Extensions; +using LiteCharms.Infrastructure.Database; +using LiteCharms.Models; + +namespace LiteCharms.Features.Customers.Queries.Handlers; + +public class GetCustomersQueryHandler(IDbContextFactory contextFactory) : IRequestHandler> +{ + public async ValueTask> Handle(GetCustomersQuery request, CancellationToken cancellationToken) + { + try + { + var fromDate = request.From.ToDateTime(TimeOnly.MinValue); + var toDate = request.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) + .ToArrayAsync(cancellationToken); + + return customers?.Length > 0 + ? Result.Ok(customers.Select(c => c.ToModel()).ToArray()) + : Result.Fail(new Error("No customers found in the specified date range.")); + } + catch (Exception ex) + { + return Result.Fail(new Error(ex.Message).CausedBy(ex)); + } + } +} diff --git a/LiteCharms.Features/Leads/Commands/CreateLeadCommand.cs b/LiteCharms.Features/Leads/Commands/CreateLeadCommand.cs new file mode 100644 index 0000000..e9f3ecb --- /dev/null +++ b/LiteCharms.Features/Leads/Commands/CreateLeadCommand.cs @@ -0,0 +1,49 @@ +namespace LiteCharms.Features.Leads.Commands; + +public class CreateLeadCommand : IRequest> +{ + public Guid? CustomerId { get; set; } + + public string? GoogleClickId { get; set; } + + public string? WebClickId { get; set; } + + public 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; } + + private CreateLeadCommand(Guid? customerId, string googleClickId, string webClickId, string appClickId, long? campaignId, long? adGroupId, long? adName, long? targetId, long? feedItemId, string? clickLocation, string? attribusionHash) + { + CustomerId = customerId; + GoogleClickId = googleClickId; + WebClickId = webClickId; + AppClickId = appClickId; + CampaignId = campaignId; + AdGroupId = adGroupId; + AdName = adName; + TargetId = targetId; + FeedItemId = feedItemId; + ClickLocation = clickLocation; + AttribusionHash = attribusionHash; + } + + public static CreateLeadCommand Create(Guid? customerId, string googleClickId, string webClickId, string appClickId, long? campaignId, long? adGroupId, long? adName, long? targetId, long? feedItemId, string? clickLocation, string? attribusionHash) + { + if (string.IsNullOrWhiteSpace(googleClickId) || string.IsNullOrWhiteSpace(appClickId) || string.IsNullOrWhiteSpace(webClickId)) + throw new ArgumentException("Google ClickId, App ClickId and Web ClickId are required to create a lead."); + + return new(customerId, googleClickId, webClickId, appClickId, campaignId, adGroupId, adName, targetId, feedItemId, clickLocation, attribusionHash); + } +} diff --git a/LiteCharms.Features/Leads/Commands/Handlers/CreateLeadCommandHandler.cs b/LiteCharms.Features/Leads/Commands/Handlers/CreateLeadCommandHandler.cs new file mode 100644 index 0000000..0d93755 --- /dev/null +++ b/LiteCharms.Features/Leads/Commands/Handlers/CreateLeadCommandHandler.cs @@ -0,0 +1,46 @@ +using LiteCharms.Features.Utilities.Commands; +using LiteCharms.Infrastructure.Database; + +namespace LiteCharms.Features.Leads.Commands.Handlers; + +public class CreateLeadCommandHandler(IDbContextFactory contextFactory, ISender mediator) : IRequestHandler> +{ + public async ValueTask> Handle(CreateLeadCommand request, CancellationToken cancellationToken) + { + try + { + var hashCommand = ComputeHashCommand.Create($"{request.GoogleClickId}{request.AppClickId}{request.WebClickId}"); + var hashResult = await mediator.Send(hashCommand, cancellationToken); + + if(hashResult.IsFailed) + return Result.Fail(new Error($"Failed to compute hash for lead -> Google ClickId: {request.GoogleClickId}, App ClickId: {request.AppClickId}, Web ClickId: {request.WebClickId}") + .CausedBy(hashResult.Errors)); + + using var context = await contextFactory.CreateDbContextAsync(cancellationToken); + + var newLead = context.Leads.Add(new Entities.Lead + { + WebClickId = request.WebClickId, + AppClickId = request.AppClickId, + GoogleClickId = request.GoogleClickId, + AdGroupId = request.AdGroupId, + AdName = request.AdName, + CampaignId = request.CampaignId, + ClickLocation = request.ClickLocation, + CustomerId = request.CustomerId, + FeedItemId = request.FeedItemId, + Status = Models.LeadStatus.New, + TargetId = request.TargetId, + AttributionHash = hashResult.Value + }); + + return await context.SaveChangesAsync(cancellationToken) > 0 + ? Result.Ok(newLead.Entity.Id) + : Result.Fail(new Error($"Failed to create lead -> Google ClickId: {request.GoogleClickId}, App ClickId: {request.AppClickId}, Web ClickId: {request.WebClickId}")); + } + catch (Exception ex) + { + return Result.Fail(new Error(ex.Message).CausedBy(ex)); + } + } +} diff --git a/LiteCharms.Features/Leads/Commands/Handlers/UpdateLeadCommandHandler.cs b/LiteCharms.Features/Leads/Commands/Handlers/UpdateLeadCommandHandler.cs new file mode 100644 index 0000000..7187005 --- /dev/null +++ b/LiteCharms.Features/Leads/Commands/Handlers/UpdateLeadCommandHandler.cs @@ -0,0 +1,29 @@ +using LiteCharms.Infrastructure.Database; + +namespace LiteCharms.Features.Leads.Commands.Handlers; + +public class UpdateLeadCommandHandler(IDbContextFactory contextFactory) : IRequestHandler +{ + public async ValueTask Handle(UpdateLeadCommand request, CancellationToken cancellationToken) + { + try + { + using var context = await contextFactory.CreateDbContextAsync(cancellationToken); + + var lead = await context.Leads.FirstOrDefaultAsync(l => l.Id == request.LeadId, cancellationToken); + + if (lead is null) + return Result.Fail(new Error($"Lead with ID {request.LeadId} not found.")); + + lead.Status = request.Status; + + return await context.SaveChangesAsync(cancellationToken) > 0 + ? Result.Ok() + : Result.Fail(new Error($"Failed to update the lead {request.LeadId}.")); + } + catch (Exception ex) + { + return Result.Fail(new Error(ex.Message).CausedBy(ex)); + } + } +} diff --git a/LiteCharms.Features/Leads/Commands/UpdateLeadCommand.cs b/LiteCharms.Features/Leads/Commands/UpdateLeadCommand.cs new file mode 100644 index 0000000..a201b70 --- /dev/null +++ b/LiteCharms.Features/Leads/Commands/UpdateLeadCommand.cs @@ -0,0 +1,27 @@ +using LiteCharms.Models; + +namespace LiteCharms.Features.Leads.Commands; + +public class UpdateLeadCommand : IRequest +{ + public Guid LeadId { get; set; } + + public LeadStatus Status { get; set; } + + private UpdateLeadCommand(Guid leadId, LeadStatus status) + { + LeadId = leadId; + Status = status; + } + + public static UpdateLeadCommand Create(Guid leadId, LeadStatus status) + { + if (leadId == Guid.Empty) + throw new ArgumentException("Lead ID cannot be empty.", nameof(leadId)); + + if (!Enum.IsDefined(typeof(LeadStatus), status)) + throw new ArgumentException("Invalid lead status.", nameof(status)); + + return new(leadId, status); + } +} diff --git a/LiteCharms.Features/Leads/Queries/GetCustomerLeadsQuery.cs b/LiteCharms.Features/Leads/Queries/GetCustomerLeadsQuery.cs new file mode 100644 index 0000000..ddede3c --- /dev/null +++ b/LiteCharms.Features/Leads/Queries/GetCustomerLeadsQuery.cs @@ -0,0 +1,30 @@ +using LiteCharms.Models; + +namespace LiteCharms.Features.Leads.Queries; + +public class GetCustomerLeadsQuery : IRequest> +{ + public Guid CustomerId { get; } + + public DateOnly From { get; set; } + + public DateOnly To { get; set; } + + private GetCustomerLeadsQuery(Guid customerId, DateOnly from, DateOnly to) + { + CustomerId = customerId; + From = from; + To = to; + } + + public static GetCustomerLeadsQuery Create(Guid customerId, DateOnly from, DateOnly to) + { + if(customerId == Guid.Empty) + throw new ArgumentException("Customer ID cannot be empty.", nameof(customerId)); + + if(from > to) + throw new ArgumentException("The 'From' date cannot be later than the 'To' date."); + + return new(customerId, from, to); + } +} diff --git a/LiteCharms.Features/Leads/Queries/GetLeadsQuery.cs b/LiteCharms.Features/Leads/Queries/GetLeadsQuery.cs new file mode 100644 index 0000000..d0c0714 --- /dev/null +++ b/LiteCharms.Features/Leads/Queries/GetLeadsQuery.cs @@ -0,0 +1,24 @@ +using LiteCharms.Models; + +namespace LiteCharms.Features.Leads.Queries; + +public class GetLeadsQuery : IRequest> +{ + public DateOnly From { get; set; } + + public DateOnly To { get; set; } + + private GetLeadsQuery(DateOnly from, DateOnly to) + { + From = from; + To = to; + } + + public static GetLeadsQuery Create(DateOnly from, DateOnly to) + { + if (from > to) + throw new ArgumentException("From date cannot be greater than To date."); + + return new(from, to); + } +} diff --git a/LiteCharms.Features/Leads/Queries/Handlers/GetCustomerLeadsQueryHandler.cs b/LiteCharms.Features/Leads/Queries/Handlers/GetCustomerLeadsQueryHandler.cs new file mode 100644 index 0000000..630b9c5 --- /dev/null +++ b/LiteCharms.Features/Leads/Queries/Handlers/GetCustomerLeadsQueryHandler.cs @@ -0,0 +1,33 @@ +using LiteCharms.Extensions; +using LiteCharms.Infrastructure.Database; +using LiteCharms.Models; + +namespace LiteCharms.Features.Leads.Queries.Handlers; + +public class GetCustomerLeadsQueryHandler(IDbContextFactory contextFactory) : IRequestHandler> +{ + public async ValueTask> Handle(GetCustomerLeadsQuery request, CancellationToken cancellationToken) + { + try + { + var fromDate = request.From.ToDateTime(TimeOnly.MinValue); + var toDate = request.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 == request.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 {request.CustomerId} leads found for the specified date range {request.From} to {request.To}.")); + } + catch (Exception ex) + { + return Result.Fail(new Error(ex.Message).CausedBy(ex)); + } + } +} diff --git a/LiteCharms.Features/Leads/Queries/Handlers/GetLeadsQueryHandler.cs b/LiteCharms.Features/Leads/Queries/Handlers/GetLeadsQueryHandler.cs new file mode 100644 index 0000000..497a292 --- /dev/null +++ b/LiteCharms.Features/Leads/Queries/Handlers/GetLeadsQueryHandler.cs @@ -0,0 +1,32 @@ +using LiteCharms.Extensions; +using LiteCharms.Infrastructure.Database; +using LiteCharms.Models; + +namespace LiteCharms.Features.Leads.Queries.Handlers; + +public class GetLeadsQueryHandler(IDbContextFactory contextFactory) : IRequestHandler> +{ + public async ValueTask> Handle(GetLeadsQuery request, CancellationToken cancellationToken) + { + try + { + var fromDate = request.From.ToDateTime(TimeOnly.MinValue); + var toDate = request.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) + .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 {request.From} to {request.To}.")); + } + catch (Exception ex) + { + return Result.Fail(new Error(ex.Message).CausedBy(ex)); + } + } +} diff --git a/LiteCharms.Features/LiteCharms.Features.csproj b/LiteCharms.Features/LiteCharms.Features.csproj new file mode 100644 index 0000000..1262027 --- /dev/null +++ b/LiteCharms.Features/LiteCharms.Features.csproj @@ -0,0 +1,53 @@ + + + + net10.0 + enable + enable + True + ..\LiteCharms.snk + + + + + LiteCharms.Features + 1.0.2 + Khwezi Mngoma + Lite Charms (PTY) Ltd + Feature components for Lite Charms applications. + https://gitea.khongisa.co.za/litecharms/leadgenerator + https://gitea.khongisa.co.za/litecharms/leadgenerator.git + git + LICENSE + utility;dotnet + icon.png + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/LiteCharms.Features/Orders/Commands/CreateOrderCommand.cs b/LiteCharms.Features/Orders/Commands/CreateOrderCommand.cs new file mode 100644 index 0000000..39a7a27 --- /dev/null +++ b/LiteCharms.Features/Orders/Commands/CreateOrderCommand.cs @@ -0,0 +1,25 @@ +namespace LiteCharms.Features.Orders.Commands; + +public class CreateOrderCommand : IRequest> +{ + public Guid CustomerId { get; set; } + + public Guid ProductPriceId { get; set; } + + private CreateOrderCommand(Guid customerId, Guid productPriceId) + { + CustomerId = customerId; + ProductPriceId = productPriceId; + } + + public static CreateOrderCommand Create(Guid customerId, Guid productPriceId) + { + if (customerId == Guid.Empty) + throw new ArgumentException("CustomerId is required.", nameof(customerId)); + + if (productPriceId == Guid.Empty) + throw new ArgumentException("ProductPriceId is required.", nameof(productPriceId)); + + return new(customerId, productPriceId); + } +} diff --git a/LiteCharms.Features/Orders/Commands/Handlers/CreateOrderCommandHandler.cs b/LiteCharms.Features/Orders/Commands/Handlers/CreateOrderCommandHandler.cs new file mode 100644 index 0000000..f744f89 --- /dev/null +++ b/LiteCharms.Features/Orders/Commands/Handlers/CreateOrderCommandHandler.cs @@ -0,0 +1,29 @@ +using LiteCharms.Infrastructure.Database; + +namespace LiteCharms.Features.Orders.Commands.Handlers; + +public class CreateOrderCommandHandler(IDbContextFactory contextFactory) : IRequestHandler> +{ + public async ValueTask> Handle(CreateOrderCommand request, CancellationToken cancellationToken) + { + try + { + using var context = await contextFactory.CreateDbContextAsync(cancellationToken); + + var newOrder = context.Orders.Add(new Entities.Order + { + CustomerId = request.CustomerId, + ProductPriceId = request.ProductPriceId, + CreatedAt = DateTime.UtcNow + }); + + return await context.SaveChangesAsync(cancellationToken) > 0 + ? Result.Ok(newOrder.Entity.Id) + : Result.Fail(new Error($"Failed to create customer {request.CustomerId} order using product price {request.ProductPriceId}.")); + } + catch (Exception ex) + { + return Result.Fail(new Error(ex.Message).CausedBy(ex)); + } + } +} diff --git a/LiteCharms.Features/Orders/Commands/Handlers/UpdateOrderCommandHandler.cs b/LiteCharms.Features/Orders/Commands/Handlers/UpdateOrderCommandHandler.cs new file mode 100644 index 0000000..f9bf460 --- /dev/null +++ b/LiteCharms.Features/Orders/Commands/Handlers/UpdateOrderCommandHandler.cs @@ -0,0 +1,29 @@ +using LiteCharms.Infrastructure.Database; + +namespace LiteCharms.Features.Orders.Commands.Handlers; + +public class UpdateOrderCommandHandler(IDbContextFactory contextFactory) : IRequestHandler +{ + public async ValueTask Handle(UpdateOrderCommand request, CancellationToken cancellationToken) + { + try + { + using var context = await contextFactory.CreateDbContextAsync(cancellationToken); + + var order = await context.Orders.FirstOrDefaultAsync(o => o.Id == request.OrderId, cancellationToken); + + if (order is null) + return Result.Fail(new Error($"Order {request.OrderId} not found")); + + order.Status = request.Status; + + return await context.SaveChangesAsync(cancellationToken) > 0 + ? Result.Ok() + : Result.Fail(new Error($"Failed to update order {request.OrderId}")); + } + catch (Exception ex) + { + return Result.Fail(new Error(ex.Message).CausedBy(ex)); + } + } +} diff --git a/LiteCharms.Features/Orders/Commands/UpdateOrderCommand.cs b/LiteCharms.Features/Orders/Commands/UpdateOrderCommand.cs new file mode 100644 index 0000000..ee1b844 --- /dev/null +++ b/LiteCharms.Features/Orders/Commands/UpdateOrderCommand.cs @@ -0,0 +1,30 @@ +using LiteCharms.Models; + +namespace LiteCharms.Features.Orders.Commands; + +public class UpdateOrderCommand : IRequest +{ + public Guid OrderId { get; set; } + + public OrderStatus Status { get; set; } + + public string? Note { get; set; } + + private UpdateOrderCommand(Guid orderId, OrderStatus status, string? note) + { + OrderId = orderId; + Status = status; + Note = note; + } + + public static UpdateOrderCommand Create(Guid orderId, OrderStatus status, string? note) + { + if (orderId == Guid.Empty) + throw new ArgumentException("OrderId is required.", nameof(orderId)); + + if (!Enum.IsDefined(typeof(OrderStatus), status)) + throw new ArgumentException("Invalid order status.", nameof(status)); + + return new(orderId, status, note); + } +} diff --git a/LiteCharms.Features/Orders/Queries/GetOrderRefundQuery.cs b/LiteCharms.Features/Orders/Queries/GetOrderRefundQuery.cs new file mode 100644 index 0000000..887e03b --- /dev/null +++ b/LiteCharms.Features/Orders/Queries/GetOrderRefundQuery.cs @@ -0,0 +1,27 @@ +using LiteCharms.Models; + +namespace LiteCharms.Features.Orders.Queries; + +public class GetOrderRefundQuery : IRequest> +{ + public Guid OrderId { get; set; } + + public Guid OrderRefundId { get; set; } + + private GetOrderRefundQuery(Guid orderId, Guid orderRefundId) + { + OrderId = orderId; + OrderRefundId = orderRefundId; + } + + public static GetOrderRefundQuery Create(Guid orderId, Guid orderRefundId) + { + if (orderId == Guid.Empty) + throw new ArgumentException("OrderId is required.", nameof(orderId)); + + if (orderRefundId == Guid.Empty) + throw new ArgumentException("OrderRefundId is required.", nameof(orderRefundId)); + + return new(orderId, orderRefundId); + } +} diff --git a/LiteCharms.Features/Orders/Queries/GetOrdersQuery.cs b/LiteCharms.Features/Orders/Queries/GetOrdersQuery.cs new file mode 100644 index 0000000..3e1fb8f --- /dev/null +++ b/LiteCharms.Features/Orders/Queries/GetOrdersQuery.cs @@ -0,0 +1,24 @@ +using LiteCharms.Models; + +namespace LiteCharms.Features.Orders.Queries; + +public class GetOrdersQuery : IRequest> +{ + public DateOnly From { get; set; } + + public DateOnly To { get; set; } + + private GetOrdersQuery(DateOnly from, DateOnly to) + { + From = from; + To = to; + } + + public static GetOrdersQuery Create(DateOnly from, DateOnly to) + { + if (from > to) + throw new ArgumentException("From date cannot be greater than To date."); + + return new(from, to); + } +} \ No newline at end of file diff --git a/LiteCharms.Features/Orders/Queries/Handlers/GetOrderRefundQueryHandler.cs b/LiteCharms.Features/Orders/Queries/Handlers/GetOrderRefundQueryHandler.cs new file mode 100644 index 0000000..26bc1f2 --- /dev/null +++ b/LiteCharms.Features/Orders/Queries/Handlers/GetOrderRefundQueryHandler.cs @@ -0,0 +1,27 @@ +using LiteCharms.Extensions; +using LiteCharms.Infrastructure.Database; +using LiteCharms.Models; + +namespace LiteCharms.Features.Orders.Queries.Handlers; + +public class GetOrderRefundQueryHandler(IDbContextFactory contextFactory) : IRequestHandler> +{ + public async ValueTask> Handle(GetOrderRefundQuery request, CancellationToken cancellationToken) + { + try + { + using var context = await contextFactory.CreateDbContextAsync(cancellationToken); + + var refund = await context.OrderRefunds.AsNoTracking() + .FirstOrDefaultAsync(r => r.OrderId == request.OrderId && r.Id == request.OrderRefundId, cancellationToken); + + return refund is not null + ? Result.Ok(refund.ToModel()) + : Result.Fail(new Error($"Refund {request.OrderRefundId} not found for the given OrderId: {request.OrderId}")); + } + catch (Exception ex) + { + return Result.Fail(new Error(ex.Message).CausedBy(ex)); + } + } +} diff --git a/LiteCharms.Features/Orders/Queries/Handlers/GetOrdersQueryHandler.cs b/LiteCharms.Features/Orders/Queries/Handlers/GetOrdersQueryHandler.cs new file mode 100644 index 0000000..719d26b --- /dev/null +++ b/LiteCharms.Features/Orders/Queries/Handlers/GetOrdersQueryHandler.cs @@ -0,0 +1,32 @@ +using LiteCharms.Extensions; +using LiteCharms.Infrastructure.Database; +using LiteCharms.Models; + +namespace LiteCharms.Features.Orders.Queries.Handlers; + +public class GetOrdersQueryHandler(IDbContextFactory contextFactory) : IRequestHandler> +{ + public async ValueTask> Handle(GetOrdersQuery request, CancellationToken cancellationToken) + { + try + { + var fromDate = request.From.ToDateTime(TimeOnly.MinValue); + var toDate = request.To.ToDateTime(TimeOnly.MaxValue); + + using var context = await contextFactory.CreateDbContextAsync(cancellationToken); + + var orders = await context.Orders + .OrderByDescending(o => o.CreatedAt) + .Where(o => o.CreatedAt >= fromDate && o.CreatedAt <= toDate) + .ToArrayAsync(cancellationToken); + + return orders?.Length > 0 + ? Result.Ok(orders.Select(o => o.ToModel()).ToArray()) + : Result.Fail(new Error($"No orders found for the specified date range {request.From} - {request.To}.")); + } + catch (Exception ex) + { + return Result.Fail(new Error(ex.Message).CausedBy(ex)); + } + } +} diff --git a/LiteCharms.Features/Products/Queries/GetProductPriceQuery.cs b/LiteCharms.Features/Products/Queries/GetProductPriceQuery.cs new file mode 100644 index 0000000..347d759 --- /dev/null +++ b/LiteCharms.Features/Products/Queries/GetProductPriceQuery.cs @@ -0,0 +1,18 @@ +using LiteCharms.Models; + +namespace LiteCharms.Features.Products.Queries; + +public class GetProductPriceQuery : IRequest> +{ + public Guid ProductId { get; set; } + + private GetProductPriceQuery(Guid productId) => ProductId = productId; + + public static GetProductPriceQuery Create(Guid productId) + { + if (productId == Guid.Empty) + throw new ArgumentException("ProductId is required.", nameof(productId)); + + return new(productId); + } +} diff --git a/LiteCharms.Features/Products/Queries/GetProductQuery.cs b/LiteCharms.Features/Products/Queries/GetProductQuery.cs new file mode 100644 index 0000000..2f5b2a8 --- /dev/null +++ b/LiteCharms.Features/Products/Queries/GetProductQuery.cs @@ -0,0 +1,18 @@ +using LiteCharms.Models; + +namespace LiteCharms.Features.Products.Queries; + +public class GetProductQuery : IRequest> +{ + public Guid ProductId { get; set; } + + private GetProductQuery(Guid productId) => ProductId = productId; + + public static GetProductQuery Create(Guid productId) + { + if(productId == Guid.Empty) + throw new ArgumentException("Product ID is required.", nameof(productId)); + + return new(productId); + } +} diff --git a/LiteCharms.Features/Products/Queries/GetProductsQuery.cs b/LiteCharms.Features/Products/Queries/GetProductsQuery.cs new file mode 100644 index 0000000..b8cdc8b --- /dev/null +++ b/LiteCharms.Features/Products/Queries/GetProductsQuery.cs @@ -0,0 +1,8 @@ +using LiteCharms.Models; + +namespace LiteCharms.Features.Products.Queries; + +public class GetProductsQuery : IRequest> +{ + public static GetProductsQuery Create() => new(); +} diff --git a/LiteCharms.Features/Products/Queries/Handlers/GetProductPriceQueryHandler.cs b/LiteCharms.Features/Products/Queries/Handlers/GetProductPriceQueryHandler.cs new file mode 100644 index 0000000..28ba212 --- /dev/null +++ b/LiteCharms.Features/Products/Queries/Handlers/GetProductPriceQueryHandler.cs @@ -0,0 +1,29 @@ +using LiteCharms.Extensions; +using LiteCharms.Infrastructure.Database; +using LiteCharms.Models; + +namespace LiteCharms.Features.Products.Queries.Handlers; + +public class GetProductPriceQueryHandler(IDbContextFactory contextFactory) : IRequestHandler> +{ + public async ValueTask> Handle(GetProductPriceQuery request, CancellationToken cancellationToken) + { + try + { + using var context = await contextFactory.CreateDbContextAsync(cancellationToken); + + var productPrice = await context.ProductPrices.AsNoTracking() + .Where(pp => pp.ProductId == request.ProductId && pp.Active) + .OrderByDescending(pp => pp.CreatedAt) + .FirstOrDefaultAsync(cancellationToken); + + return productPrice is not null + ? Result.Ok(productPrice.ToModel()) + : Result.Fail(new Error($"Product price {request.ProductId} not found.")); + } + catch (Exception ex) + { + return Result.Fail(new Error(ex.Message).CausedBy(ex)); + } + } +} diff --git a/LiteCharms.Features/Products/Queries/Handlers/GetProductQueryHandler.cs b/LiteCharms.Features/Products/Queries/Handlers/GetProductQueryHandler.cs new file mode 100644 index 0000000..cca604f --- /dev/null +++ b/LiteCharms.Features/Products/Queries/Handlers/GetProductQueryHandler.cs @@ -0,0 +1,26 @@ +using LiteCharms.Extensions; +using LiteCharms.Infrastructure.Database; +using LiteCharms.Models; + +namespace LiteCharms.Features.Products.Queries.Handlers; + +public class GetProductQueryHandler(IDbContextFactory contextFactory) : IRequestHandler> +{ + public async ValueTask> Handle(GetProductQuery request, CancellationToken cancellationToken) + { + try + { + using var context = await contextFactory.CreateDbContextAsync(cancellationToken); + + var product = await context.Products.FirstOrDefaultAsync(p => p.Id == request.ProductId, cancellationToken); + + return product is not null + ? Result.Ok(product.ToModel()) + : Result.Fail(new Error($"Product with ID {request.ProductId} not found.")); + } + catch (Exception ex) + { + return Result.Fail(new Error(ex.Message).CausedBy(ex)); + } + } +} diff --git a/LiteCharms.Features/Products/Queries/Handlers/GetProductsQueryHandler.cs b/LiteCharms.Features/Products/Queries/Handlers/GetProductsQueryHandler.cs new file mode 100644 index 0000000..54be7b3 --- /dev/null +++ b/LiteCharms.Features/Products/Queries/Handlers/GetProductsQueryHandler.cs @@ -0,0 +1,26 @@ +using LiteCharms.Extensions; +using LiteCharms.Infrastructure.Database; +using LiteCharms.Models; + +namespace LiteCharms.Features.Products.Queries.Handlers; + +public class GetProductsQueryHandler(IDbContextFactory contextFactory) : IRequestHandler> +{ + public async ValueTask> Handle(GetProductsQuery request, CancellationToken cancellationToken) + { + try + { + using var context = await contextFactory.CreateDbContextAsync(cancellationToken); + + var products = await context.Products.AsNoTracking() + .OrderByDescending(o => o.Id) + .ToArrayAsync(cancellationToken); + + return Result.Ok(products.Select(p => p.ToModel()).ToArray()); + } + catch (Exception ex) + { + return Result.Fail(new Error(ex.Message).CausedBy(ex)); + } + } +} diff --git a/LiteCharms.Features/Utilities/Commands/ComputeHashCommand.cs b/LiteCharms.Features/Utilities/Commands/ComputeHashCommand.cs new file mode 100644 index 0000000..ef235fc --- /dev/null +++ b/LiteCharms.Features/Utilities/Commands/ComputeHashCommand.cs @@ -0,0 +1,16 @@ +namespace LiteCharms.Features.Utilities.Commands; + +public class ComputeHashCommand : IRequest> +{ + public string? Input { get; set; } + + private ComputeHashCommand(string input) => Input = input; + + public static ComputeHashCommand Create(string input) + { + if(string.IsNullOrWhiteSpace(input)) + throw new ArgumentException("Input is required", nameof(input)); + + return new(input); + } +} diff --git a/LiteCharms.Features/Utilities/Commands/Handlers/ComputeHashCommandHandler.cs b/LiteCharms.Features/Utilities/Commands/Handlers/ComputeHashCommandHandler.cs new file mode 100644 index 0000000..d4ef5b4 --- /dev/null +++ b/LiteCharms.Features/Utilities/Commands/Handlers/ComputeHashCommandHandler.cs @@ -0,0 +1,18 @@ +namespace LiteCharms.Features.Utilities.Commands.Handlers; + +public class ComputeHashCommandHandler : IRequestHandler> +{ + public async ValueTask> Handle(ComputeHashCommand request, CancellationToken cancellationToken) + { + try + { + var bytes = SHA256.HashData(Encoding.UTF8.GetBytes(request.Input!)); + + return Result.Ok(Convert.ToHexString(bytes)); + } + catch (Exception ex) + { + return Result.Fail(new Error(ex.Message).CausedBy(ex)); + } + } +} diff --git a/LiteCharms.Infrastructure/Database/LeadGeneratorDbContext.cs b/LiteCharms.Infrastructure/Database/LeadGeneratorDbContext.cs new file mode 100644 index 0000000..7daef35 --- /dev/null +++ b/LiteCharms.Infrastructure/Database/LeadGeneratorDbContext.cs @@ -0,0 +1,18 @@ +using LiteCharms.Entities; + +namespace LiteCharms.Infrastructure.Database; + +public class LeadGeneratorDbContext(DbContextOptions options) : DbContext(options) +{ + public DbSet Customers { get; set; } + + public DbSet Leads { get; set; } + + public DbSet Orders { get; set; } + + public DbSet OrderRefunds { get; set; } + + public DbSet Products { get; set; } + + public DbSet ProductPrices { get; set; } +} diff --git a/LiteCharms.Infrastructure/Database/LeadGeneratorDbContextFactory.cs b/LiteCharms.Infrastructure/Database/LeadGeneratorDbContextFactory.cs new file mode 100644 index 0000000..0a18c5b --- /dev/null +++ b/LiteCharms.Infrastructure/Database/LeadGeneratorDbContextFactory.cs @@ -0,0 +1,19 @@ +namespace LiteCharms.Infrastructure.Database; + +public class LeadGeneratorDbContextFactory : IDesignTimeDbContextFactory +{ + public LeadGeneratorDbContext CreateDbContext(string[] args) + { + var configuration = new ConfigurationBuilder() + .SetBasePath(Directory.GetCurrentDirectory()) + .AddUserSecrets(typeof(LeadGeneratorDbContext).Assembly) + .AddJsonFile("appsettings.json") + .AddEnvironmentVariables() + .Build(); + + var optionsBuilder = new DbContextOptionsBuilder(); + optionsBuilder.UseNpgsql(configuration.GetConnectionString("PostgresLeadGenerator")); + + return new LeadGeneratorDbContext(optionsBuilder.Options); + } +} diff --git a/LiteCharms.Infrastructure/Database/Migrations/20260502231708_Init.Designer.cs b/LiteCharms.Infrastructure/Database/Migrations/20260502231708_Init.Designer.cs new file mode 100644 index 0000000..129f9fd --- /dev/null +++ b/LiteCharms.Infrastructure/Database/Migrations/20260502231708_Init.Designer.cs @@ -0,0 +1,272 @@ +// +using System; +using LiteCharms.Infrastructure.Database; +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.Infrastructure.Database.Migrations +{ + [DbContext(typeof(LeadGeneratorDbContext))] + [Migration("20260502231708_Init")] + partial class Init + { + /// + protected override void BuildTargetModel(ModelBuilder modelBuilder) + { +#pragma warning disable 612, 618 + modelBuilder + .HasAnnotation("ProductVersion", "10.0.7") + .HasAnnotation("Relational:MaxIdentifierLength", 63); + + NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder); + + modelBuilder.Entity("LeadGenerator.Database.Entities.Customer", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("Active") + .ValueGeneratedOnAdd() + .HasColumnType("boolean") + .HasDefaultValue(true); + + b.Property("Address") + .HasColumnType("text"); + + b.Property("City") + .HasColumnType("text"); + + b.Property("Company") + .HasColumnType("text"); + + b.Property("Country") + .HasColumnType("text"); + + b.Property("CreatedAt") + .ValueGeneratedOnAdd() + .HasColumnType("timestamp with time zone"); + + b.Property("Discord") + .HasColumnType("text"); + + b.Property("Email") + .IsRequired() + .HasColumnType("text"); + + b.Property("LastName") + .IsRequired() + .HasColumnType("text"); + + b.Property("LinkedIn") + .HasColumnType("text"); + + b.Property("Name") + .IsRequired() + .HasColumnType("text"); + + b.Property("Phone") + .HasColumnType("text"); + + b.Property("PostalCode") + .HasColumnType("text"); + + b.Property("Region") + .HasColumnType("text"); + + b.Property("Slack") + .HasColumnType("text"); + + b.Property("Tax") + .HasColumnType("text"); + + b.Property("UpdatedAt") + .ValueGeneratedOnUpdate() + .HasColumnType("timestamp with time zone"); + + b.Property("Website") + .HasColumnType("text"); + + b.Property("Whatsapp") + .HasColumnType("text"); + + b.HasKey("Id"); + + b.ToTable("Customer", (string)null); + }); + + modelBuilder.Entity("LeadGenerator.Database.Entities.Lead", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("AdGroupId") + .HasColumnType("bigint"); + + b.Property("AdName") + .HasColumnType("bigint"); + + b.Property("AppClickId") + .HasColumnType("text"); + + b.Property("AttribusionHash") + .IsRequired() + .HasColumnType("text"); + + b.Property("CampaignId") + .HasColumnType("bigint"); + + b.Property("ClickLocation") + .HasColumnType("text"); + + b.Property("CreatedAt") + .ValueGeneratedOnAdd() + .HasColumnType("timestamp with time zone"); + + b.Property("FeedItemId") + .HasColumnType("bigint"); + + b.Property("GoogleClickId") + .HasColumnType("text"); + + b.Property("TargetId") + .HasColumnType("bigint"); + + b.Property("UpdatedAt") + .ValueGeneratedOnUpdate() + .HasColumnType("timestamp with time zone"); + + b.Property("WebClickId") + .HasColumnType("text"); + + b.HasKey("Id"); + + b.ToTable("Lead", (string)null); + }); + + modelBuilder.Entity("LeadGenerator.Database.Entities.Order", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("CreatedAt") + .ValueGeneratedOnAdd() + .HasColumnType("timestamp with time zone"); + + b.Property("LeadId") + .HasColumnType("uuid"); + + b.PrimitiveCollection("Notes") + .HasColumnType("jsonb"); + + b.Property("ProductId") + .HasColumnType("uuid"); + + b.Property("ProductPriceId") + .HasColumnType("uuid"); + + b.Property("Status") + .HasColumnType("integer"); + + b.Property("UpdatedAt") + .ValueGeneratedOnUpdate() + .HasColumnType("timestamp with time zone"); + + b.HasKey("Id"); + + b.ToTable("Order", (string)null); + }); + + modelBuilder.Entity("LeadGenerator.Database.Entities.OrderRefund", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("Amount") + .HasPrecision(18, 2) + .HasColumnType("numeric(18,2)"); + + b.Property("CreatedAt") + .ValueGeneratedOnAdd() + .HasColumnType("timestamp with time zone"); + + b.Property("OrderId") + .HasColumnType("uuid"); + + b.Property("Reason") + .IsRequired() + .HasColumnType("text"); + + b.HasKey("Id"); + + b.ToTable("OrderRefund", (string)null); + }); + + modelBuilder.Entity("LeadGenerator.Database.Entities.Product", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("Active") + .ValueGeneratedOnAdd() + .HasColumnType("boolean") + .HasDefaultValue(true); + + b.Property("Description") + .IsRequired() + .HasColumnType("text"); + + b.Property("Name") + .IsRequired() + .HasColumnType("text"); + + b.HasKey("Id"); + + b.ToTable("Product", (string)null); + }); + + modelBuilder.Entity("LeadGenerator.Database.Entities.ProductPrice", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("Active") + .HasColumnType("boolean"); + + b.Property("CreatedAt") + .ValueGeneratedOnAdd() + .HasColumnType("timestamp with time zone"); + + b.Property("Discount") + .HasPrecision(18, 2) + .HasColumnType("numeric(18,2)"); + + b.Property("Price") + .HasPrecision(18, 2) + .HasColumnType("numeric(18,2)"); + + b.Property("ProductId") + .HasColumnType("uuid"); + + b.Property("UpdatedAt") + .ValueGeneratedOnUpdate() + .HasColumnType("timestamp with time zone"); + + b.HasKey("Id"); + + b.ToTable("ProductPrice", (string)null); + }); +#pragma warning restore 612, 618 + } + } +} diff --git a/LiteCharms.Infrastructure/Database/Migrations/20260502231708_Init.cs b/LiteCharms.Infrastructure/Database/Migrations/20260502231708_Init.cs new file mode 100644 index 0000000..60c879e --- /dev/null +++ b/LiteCharms.Infrastructure/Database/Migrations/20260502231708_Init.cs @@ -0,0 +1,154 @@ +using System; +using Microsoft.EntityFrameworkCore.Migrations; + +#nullable disable + +namespace LiteCharms.Infrastructure.Database.Migrations +{ + /// + public partial class Init : Migration + { + /// + protected override void Up(MigrationBuilder migrationBuilder) + { + migrationBuilder.CreateTable( + name: "Customer", + columns: table => new + { + Id = table.Column(type: "uuid", nullable: false), + CreatedAt = table.Column(type: "timestamp with time zone", nullable: false), + UpdatedAt = table.Column(type: "timestamp with time zone", nullable: true), + Company = table.Column(type: "text", nullable: true), + Name = table.Column(type: "text", nullable: false), + LastName = table.Column(type: "text", nullable: false), + Tax = table.Column(type: "text", nullable: true), + Email = table.Column(type: "text", nullable: false), + Discord = table.Column(type: "text", nullable: true), + Slack = table.Column(type: "text", nullable: true), + LinkedIn = table.Column(type: "text", nullable: true), + Whatsapp = table.Column(type: "text", nullable: true), + Website = table.Column(type: "text", nullable: true), + Phone = table.Column(type: "text", nullable: true), + Address = table.Column(type: "text", nullable: true), + City = table.Column(type: "text", nullable: true), + Region = table.Column(type: "text", nullable: true), + Country = table.Column(type: "text", nullable: true), + PostalCode = table.Column(type: "text", nullable: true), + Active = table.Column(type: "boolean", nullable: false, defaultValue: true) + }, + constraints: table => + { + table.PrimaryKey("PK_Customer", x => x.Id); + }); + + migrationBuilder.CreateTable( + name: "Lead", + columns: table => new + { + Id = table.Column(type: "uuid", nullable: false), + CreatedAt = table.Column(type: "timestamp with time zone", nullable: false), + UpdatedAt = table.Column(type: "timestamp with time zone", nullable: true), + GoogleClickId = table.Column(type: "text", nullable: true), + WebClickId = table.Column(type: "text", nullable: true), + AppClickId = table.Column(type: "text", nullable: true), + CampaignId = table.Column(type: "bigint", nullable: true), + AdGroupId = table.Column(type: "bigint", nullable: true), + AdName = table.Column(type: "bigint", nullable: true), + TargetId = table.Column(type: "bigint", nullable: true), + FeedItemId = table.Column(type: "bigint", nullable: true), + ClickLocation = table.Column(type: "text", nullable: true), + AttribusionHash = table.Column(type: "text", nullable: false) + }, + constraints: table => + { + table.PrimaryKey("PK_Lead", x => x.Id); + }); + + migrationBuilder.CreateTable( + name: "Order", + columns: table => new + { + Id = table.Column(type: "uuid", nullable: false), + CreatedAt = table.Column(type: "timestamp with time zone", nullable: false), + UpdatedAt = table.Column(type: "timestamp with time zone", nullable: true), + LeadId = table.Column(type: "uuid", nullable: false), + ProductId = table.Column(type: "uuid", nullable: false), + ProductPriceId = table.Column(type: "uuid", nullable: false), + Status = table.Column(type: "integer", nullable: false), + Notes = table.Column(type: "jsonb", nullable: true) + }, + constraints: table => + { + table.PrimaryKey("PK_Order", x => x.Id); + }); + + migrationBuilder.CreateTable( + name: "OrderRefund", + columns: table => new + { + Id = table.Column(type: "uuid", nullable: false), + CreatedAt = table.Column(type: "timestamp with time zone", nullable: false), + OrderId = table.Column(type: "uuid", nullable: false), + Reason = table.Column(type: "text", nullable: false), + Amount = table.Column(type: "numeric(18,2)", precision: 18, scale: 2, nullable: false) + }, + constraints: table => + { + table.PrimaryKey("PK_OrderRefund", x => x.Id); + }); + + migrationBuilder.CreateTable( + name: "Product", + columns: table => new + { + Id = table.Column(type: "uuid", nullable: false), + Name = table.Column(type: "text", nullable: false), + Description = table.Column(type: "text", nullable: false), + Active = table.Column(type: "boolean", nullable: false, defaultValue: true) + }, + constraints: table => + { + table.PrimaryKey("PK_Product", x => x.Id); + }); + + migrationBuilder.CreateTable( + name: "ProductPrice", + columns: table => new + { + Id = table.Column(type: "uuid", nullable: false), + CreatedAt = table.Column(type: "timestamp with time zone", nullable: false), + UpdatedAt = table.Column(type: "timestamp with time zone", nullable: true), + ProductId = table.Column(type: "uuid", nullable: false), + Price = table.Column(type: "numeric(18,2)", precision: 18, scale: 2, nullable: false), + Discount = table.Column(type: "numeric(18,2)", precision: 18, scale: 2, nullable: false), + Active = table.Column(type: "boolean", nullable: false) + }, + constraints: table => + { + table.PrimaryKey("PK_ProductPrice", x => x.Id); + }); + } + + /// + protected override void Down(MigrationBuilder migrationBuilder) + { + migrationBuilder.DropTable( + name: "Customer"); + + migrationBuilder.DropTable( + name: "Lead"); + + migrationBuilder.DropTable( + name: "Order"); + + migrationBuilder.DropTable( + name: "OrderRefund"); + + migrationBuilder.DropTable( + name: "Product"); + + migrationBuilder.DropTable( + name: "ProductPrice"); + } + } +} diff --git a/LiteCharms.Infrastructure/Database/Migrations/20260503002123_DefinedEntityRelationships.Designer.cs b/LiteCharms.Infrastructure/Database/Migrations/20260503002123_DefinedEntityRelationships.Designer.cs new file mode 100644 index 0000000..4d9b3f9 --- /dev/null +++ b/LiteCharms.Infrastructure/Database/Migrations/20260503002123_DefinedEntityRelationships.Designer.cs @@ -0,0 +1,357 @@ +// +using System; +using LiteCharms.Infrastructure.Database; +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.Infrastructure.Database.Migrations +{ + [DbContext(typeof(LeadGeneratorDbContext))] + [Migration("20260503002123_DefinedEntityRelationships")] + partial class DefinedEntityRelationships + { + /// + protected override void BuildTargetModel(ModelBuilder modelBuilder) + { +#pragma warning disable 612, 618 + modelBuilder + .HasAnnotation("ProductVersion", "10.0.7") + .HasAnnotation("Relational:MaxIdentifierLength", 63); + + NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder); + + modelBuilder.Entity("LeadGenerator.Database.Entities.Customer", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("Active") + .ValueGeneratedOnAdd() + .HasColumnType("boolean") + .HasDefaultValue(true); + + b.Property("Address") + .HasColumnType("text"); + + b.Property("City") + .HasColumnType("text"); + + b.Property("Company") + .HasColumnType("text"); + + b.Property("Country") + .HasColumnType("text"); + + b.Property("CreatedAt") + .ValueGeneratedOnAdd() + .HasColumnType("timestamp with time zone"); + + b.Property("Discord") + .HasColumnType("text"); + + b.Property("Email") + .IsRequired() + .HasColumnType("text"); + + b.Property("LastName") + .IsRequired() + .HasColumnType("text"); + + b.Property("LinkedIn") + .HasColumnType("text"); + + b.Property("Name") + .IsRequired() + .HasColumnType("text"); + + b.Property("Phone") + .HasColumnType("text"); + + b.Property("PostalCode") + .HasColumnType("text"); + + b.Property("Region") + .HasColumnType("text"); + + b.Property("Slack") + .HasColumnType("text"); + + b.Property("Tax") + .HasColumnType("text"); + + b.Property("UpdatedAt") + .ValueGeneratedOnUpdate() + .HasColumnType("timestamp with time zone"); + + b.Property("Website") + .HasColumnType("text"); + + b.Property("Whatsapp") + .HasColumnType("text"); + + b.HasKey("Id"); + + b.ToTable("Customer", (string)null); + }); + + modelBuilder.Entity("LeadGenerator.Database.Entities.Lead", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("AdGroupId") + .HasColumnType("bigint"); + + b.Property("AdName") + .HasColumnType("bigint"); + + b.Property("AppClickId") + .HasColumnType("text"); + + b.Property("AttribusionHash") + .IsRequired() + .HasColumnType("text"); + + b.Property("CampaignId") + .HasColumnType("bigint"); + + b.Property("ClickLocation") + .HasColumnType("text"); + + b.Property("CreatedAt") + .ValueGeneratedOnAdd() + .HasColumnType("timestamp with time zone"); + + b.Property("CustomerId") + .HasColumnType("uuid"); + + b.Property("FeedItemId") + .HasColumnType("bigint"); + + b.Property("GoogleClickId") + .HasColumnType("text"); + + b.Property("LeadId") + .HasColumnType("uuid"); + + b.Property("TargetId") + .HasColumnType("bigint"); + + b.Property("UpdatedAt") + .ValueGeneratedOnUpdate() + .HasColumnType("timestamp with time zone"); + + b.Property("WebClickId") + .HasColumnType("text"); + + b.HasKey("Id"); + + b.HasIndex("CustomerId"); + + b.ToTable("Lead", (string)null); + }); + + modelBuilder.Entity("LeadGenerator.Database.Entities.Order", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("CreatedAt") + .ValueGeneratedOnAdd() + .HasColumnType("timestamp with time zone"); + + b.Property("CustomerId") + .HasColumnType("uuid"); + + b.PrimitiveCollection("Notes") + .HasColumnType("jsonb"); + + b.Property("ProductPriceId") + .HasColumnType("uuid"); + + b.Property("RefundId") + .HasColumnType("uuid"); + + b.Property("Status") + .HasColumnType("integer"); + + b.Property("UpdatedAt") + .ValueGeneratedOnUpdate() + .HasColumnType("timestamp with time zone"); + + b.HasKey("Id"); + + b.HasIndex("CustomerId"); + + b.HasIndex("ProductPriceId"); + + b.ToTable("Order", (string)null); + }); + + modelBuilder.Entity("LeadGenerator.Database.Entities.OrderRefund", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("Amount") + .HasPrecision(18, 2) + .HasColumnType("numeric(18,2)"); + + b.Property("CreatedAt") + .ValueGeneratedOnAdd() + .HasColumnType("timestamp with time zone"); + + b.Property("OrderId") + .HasColumnType("uuid"); + + b.Property("Reason") + .IsRequired() + .HasColumnType("text"); + + b.HasKey("Id"); + + b.HasIndex("OrderId") + .IsUnique(); + + b.ToTable("OrderRefund", (string)null); + }); + + modelBuilder.Entity("LeadGenerator.Database.Entities.Product", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("Active") + .ValueGeneratedOnAdd() + .HasColumnType("boolean") + .HasDefaultValue(true); + + b.Property("Description") + .IsRequired() + .HasColumnType("text"); + + b.Property("Name") + .IsRequired() + .HasColumnType("text"); + + b.HasKey("Id"); + + b.ToTable("Product", (string)null); + }); + + modelBuilder.Entity("LeadGenerator.Database.Entities.ProductPrice", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("Active") + .HasColumnType("boolean"); + + b.Property("CreatedAt") + .ValueGeneratedOnAdd() + .HasColumnType("timestamp with time zone"); + + b.Property("Discount") + .HasPrecision(18, 2) + .HasColumnType("numeric(18,2)"); + + b.Property("Price") + .HasPrecision(18, 2) + .HasColumnType("numeric(18,2)"); + + b.Property("ProductId") + .HasColumnType("uuid"); + + b.Property("UpdatedAt") + .ValueGeneratedOnUpdate() + .HasColumnType("timestamp with time zone"); + + b.HasKey("Id"); + + b.HasIndex("ProductId"); + + b.ToTable("ProductPrice", (string)null); + }); + + modelBuilder.Entity("LeadGenerator.Database.Entities.Lead", b => + { + b.HasOne("LeadGenerator.Database.Entities.Customer", "Customer") + .WithMany("Leads") + .HasForeignKey("CustomerId") + .OnDelete(DeleteBehavior.NoAction); + + b.Navigation("Customer"); + }); + + modelBuilder.Entity("LeadGenerator.Database.Entities.Order", b => + { + b.HasOne("LeadGenerator.Database.Entities.Customer", "Customer") + .WithMany("Orders") + .HasForeignKey("CustomerId") + .OnDelete(DeleteBehavior.Restrict) + .IsRequired(); + + b.HasOne("LeadGenerator.Database.Entities.ProductPrice", "ProductPrice") + .WithMany() + .HasForeignKey("ProductPriceId") + .OnDelete(DeleteBehavior.Restrict) + .IsRequired(); + + b.Navigation("Customer"); + + b.Navigation("ProductPrice"); + }); + + modelBuilder.Entity("LeadGenerator.Database.Entities.OrderRefund", b => + { + b.HasOne("LeadGenerator.Database.Entities.Order", "Order") + .WithOne("Refund") + .HasForeignKey("LeadGenerator.Database.Entities.OrderRefund", "OrderId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.Navigation("Order"); + }); + + modelBuilder.Entity("LeadGenerator.Database.Entities.ProductPrice", b => + { + b.HasOne("LeadGenerator.Database.Entities.Product", "Product") + .WithMany("ProductPrices") + .HasForeignKey("ProductId") + .OnDelete(DeleteBehavior.Restrict) + .IsRequired(); + + b.Navigation("Product"); + }); + + modelBuilder.Entity("LeadGenerator.Database.Entities.Customer", b => + { + b.Navigation("Leads"); + + b.Navigation("Orders"); + }); + + modelBuilder.Entity("LeadGenerator.Database.Entities.Order", b => + { + b.Navigation("Refund"); + }); + + modelBuilder.Entity("LeadGenerator.Database.Entities.Product", b => + { + b.Navigation("ProductPrices"); + }); +#pragma warning restore 612, 618 + } + } +} diff --git a/LiteCharms.Infrastructure/Database/Migrations/20260503002123_DefinedEntityRelationships.cs b/LiteCharms.Infrastructure/Database/Migrations/20260503002123_DefinedEntityRelationships.cs new file mode 100644 index 0000000..059f789 --- /dev/null +++ b/LiteCharms.Infrastructure/Database/Migrations/20260503002123_DefinedEntityRelationships.cs @@ -0,0 +1,175 @@ +using System; +using Microsoft.EntityFrameworkCore.Migrations; + +#nullable disable + +namespace LiteCharms.Infrastructure.Database.Migrations +{ + /// + public partial class DefinedEntityRelationships : Migration + { + /// + protected override void Up(MigrationBuilder migrationBuilder) + { + migrationBuilder.DropColumn( + name: "LeadId", + table: "Order"); + + migrationBuilder.RenameColumn( + name: "ProductId", + table: "Order", + newName: "CustomerId"); + + migrationBuilder.AddColumn( + name: "RefundId", + table: "Order", + type: "uuid", + nullable: true); + + migrationBuilder.AddColumn( + name: "CustomerId", + table: "Lead", + type: "uuid", + nullable: true); + + migrationBuilder.AddColumn( + name: "LeadId", + table: "Lead", + type: "uuid", + nullable: true); + + migrationBuilder.CreateIndex( + name: "IX_ProductPrice_ProductId", + table: "ProductPrice", + column: "ProductId"); + + migrationBuilder.CreateIndex( + name: "IX_OrderRefund_OrderId", + table: "OrderRefund", + column: "OrderId", + unique: true); + + migrationBuilder.CreateIndex( + name: "IX_Order_CustomerId", + table: "Order", + column: "CustomerId"); + + migrationBuilder.CreateIndex( + name: "IX_Order_ProductPriceId", + table: "Order", + column: "ProductPriceId"); + + migrationBuilder.CreateIndex( + name: "IX_Lead_CustomerId", + table: "Lead", + column: "CustomerId"); + + migrationBuilder.AddForeignKey( + name: "FK_Lead_Customer_CustomerId", + table: "Lead", + column: "CustomerId", + principalTable: "Customer", + principalColumn: "Id"); + + migrationBuilder.AddForeignKey( + name: "FK_Order_Customer_CustomerId", + table: "Order", + column: "CustomerId", + principalTable: "Customer", + principalColumn: "Id", + onDelete: ReferentialAction.Restrict); + + migrationBuilder.AddForeignKey( + name: "FK_Order_ProductPrice_ProductPriceId", + table: "Order", + column: "ProductPriceId", + principalTable: "ProductPrice", + principalColumn: "Id", + onDelete: ReferentialAction.Restrict); + + migrationBuilder.AddForeignKey( + name: "FK_OrderRefund_Order_OrderId", + table: "OrderRefund", + column: "OrderId", + principalTable: "Order", + principalColumn: "Id", + onDelete: ReferentialAction.Cascade); + + migrationBuilder.AddForeignKey( + name: "FK_ProductPrice_Product_ProductId", + table: "ProductPrice", + column: "ProductId", + principalTable: "Product", + principalColumn: "Id", + onDelete: ReferentialAction.Restrict); + } + + /// + protected override void Down(MigrationBuilder migrationBuilder) + { + migrationBuilder.DropForeignKey( + name: "FK_Lead_Customer_CustomerId", + table: "Lead"); + + migrationBuilder.DropForeignKey( + name: "FK_Order_Customer_CustomerId", + table: "Order"); + + migrationBuilder.DropForeignKey( + name: "FK_Order_ProductPrice_ProductPriceId", + table: "Order"); + + migrationBuilder.DropForeignKey( + name: "FK_OrderRefund_Order_OrderId", + table: "OrderRefund"); + + migrationBuilder.DropForeignKey( + name: "FK_ProductPrice_Product_ProductId", + table: "ProductPrice"); + + migrationBuilder.DropIndex( + name: "IX_ProductPrice_ProductId", + table: "ProductPrice"); + + migrationBuilder.DropIndex( + name: "IX_OrderRefund_OrderId", + table: "OrderRefund"); + + migrationBuilder.DropIndex( + name: "IX_Order_CustomerId", + table: "Order"); + + migrationBuilder.DropIndex( + name: "IX_Order_ProductPriceId", + table: "Order"); + + migrationBuilder.DropIndex( + name: "IX_Lead_CustomerId", + table: "Lead"); + + migrationBuilder.DropColumn( + name: "RefundId", + table: "Order"); + + migrationBuilder.DropColumn( + name: "CustomerId", + table: "Lead"); + + migrationBuilder.DropColumn( + name: "LeadId", + table: "Lead"); + + migrationBuilder.RenameColumn( + name: "CustomerId", + table: "Order", + newName: "ProductId"); + + migrationBuilder.AddColumn( + name: "LeadId", + table: "Order", + type: "uuid", + nullable: false, + defaultValue: new Guid("00000000-0000-0000-0000-000000000000")); + } + } +} diff --git a/LiteCharms.Infrastructure/Database/Migrations/20260503003624_RemovedLeadIdFromLead.Designer.cs b/LiteCharms.Infrastructure/Database/Migrations/20260503003624_RemovedLeadIdFromLead.Designer.cs new file mode 100644 index 0000000..0fac239 --- /dev/null +++ b/LiteCharms.Infrastructure/Database/Migrations/20260503003624_RemovedLeadIdFromLead.Designer.cs @@ -0,0 +1,354 @@ +// +using System; +using LiteCharms.Infrastructure.Database; +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.Infrastructure.Database.Migrations +{ + [DbContext(typeof(LeadGeneratorDbContext))] + [Migration("20260503003624_RemovedLeadIdFromLead")] + partial class RemovedLeadIdFromLead + { + /// + protected override void BuildTargetModel(ModelBuilder modelBuilder) + { +#pragma warning disable 612, 618 + modelBuilder + .HasAnnotation("ProductVersion", "10.0.7") + .HasAnnotation("Relational:MaxIdentifierLength", 63); + + NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder); + + modelBuilder.Entity("LeadGenerator.Database.Entities.Customer", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("Active") + .ValueGeneratedOnAdd() + .HasColumnType("boolean") + .HasDefaultValue(true); + + b.Property("Address") + .HasColumnType("text"); + + b.Property("City") + .HasColumnType("text"); + + b.Property("Company") + .HasColumnType("text"); + + b.Property("Country") + .HasColumnType("text"); + + b.Property("CreatedAt") + .ValueGeneratedOnAdd() + .HasColumnType("timestamp with time zone"); + + b.Property("Discord") + .HasColumnType("text"); + + b.Property("Email") + .IsRequired() + .HasColumnType("text"); + + b.Property("LastName") + .IsRequired() + .HasColumnType("text"); + + b.Property("LinkedIn") + .HasColumnType("text"); + + b.Property("Name") + .IsRequired() + .HasColumnType("text"); + + b.Property("Phone") + .HasColumnType("text"); + + b.Property("PostalCode") + .HasColumnType("text"); + + b.Property("Region") + .HasColumnType("text"); + + b.Property("Slack") + .HasColumnType("text"); + + b.Property("Tax") + .HasColumnType("text"); + + b.Property("UpdatedAt") + .ValueGeneratedOnUpdate() + .HasColumnType("timestamp with time zone"); + + b.Property("Website") + .HasColumnType("text"); + + b.Property("Whatsapp") + .HasColumnType("text"); + + b.HasKey("Id"); + + b.ToTable("Customer", (string)null); + }); + + modelBuilder.Entity("LeadGenerator.Database.Entities.Lead", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("AdGroupId") + .HasColumnType("bigint"); + + b.Property("AdName") + .HasColumnType("bigint"); + + b.Property("AppClickId") + .HasColumnType("text"); + + b.Property("AttribusionHash") + .IsRequired() + .HasColumnType("text"); + + b.Property("CampaignId") + .HasColumnType("bigint"); + + b.Property("ClickLocation") + .HasColumnType("text"); + + b.Property("CreatedAt") + .ValueGeneratedOnAdd() + .HasColumnType("timestamp with time zone"); + + b.Property("CustomerId") + .HasColumnType("uuid"); + + b.Property("FeedItemId") + .HasColumnType("bigint"); + + b.Property("GoogleClickId") + .HasColumnType("text"); + + b.Property("TargetId") + .HasColumnType("bigint"); + + b.Property("UpdatedAt") + .ValueGeneratedOnUpdate() + .HasColumnType("timestamp with time zone"); + + b.Property("WebClickId") + .HasColumnType("text"); + + b.HasKey("Id"); + + b.HasIndex("CustomerId"); + + b.ToTable("Lead", (string)null); + }); + + modelBuilder.Entity("LeadGenerator.Database.Entities.Order", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("CreatedAt") + .ValueGeneratedOnAdd() + .HasColumnType("timestamp with time zone"); + + b.Property("CustomerId") + .HasColumnType("uuid"); + + b.PrimitiveCollection("Notes") + .HasColumnType("jsonb"); + + b.Property("ProductPriceId") + .HasColumnType("uuid"); + + b.Property("RefundId") + .HasColumnType("uuid"); + + b.Property("Status") + .HasColumnType("integer"); + + b.Property("UpdatedAt") + .ValueGeneratedOnUpdate() + .HasColumnType("timestamp with time zone"); + + b.HasKey("Id"); + + b.HasIndex("CustomerId"); + + b.HasIndex("ProductPriceId"); + + b.ToTable("Order", (string)null); + }); + + modelBuilder.Entity("LeadGenerator.Database.Entities.OrderRefund", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("Amount") + .HasPrecision(18, 2) + .HasColumnType("numeric(18,2)"); + + b.Property("CreatedAt") + .ValueGeneratedOnAdd() + .HasColumnType("timestamp with time zone"); + + b.Property("OrderId") + .HasColumnType("uuid"); + + b.Property("Reason") + .IsRequired() + .HasColumnType("text"); + + b.HasKey("Id"); + + b.HasIndex("OrderId") + .IsUnique(); + + b.ToTable("OrderRefund", (string)null); + }); + + modelBuilder.Entity("LeadGenerator.Database.Entities.Product", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("Active") + .ValueGeneratedOnAdd() + .HasColumnType("boolean") + .HasDefaultValue(true); + + b.Property("Description") + .IsRequired() + .HasColumnType("text"); + + b.Property("Name") + .IsRequired() + .HasColumnType("text"); + + b.HasKey("Id"); + + b.ToTable("Product", (string)null); + }); + + modelBuilder.Entity("LeadGenerator.Database.Entities.ProductPrice", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("Active") + .HasColumnType("boolean"); + + b.Property("CreatedAt") + .ValueGeneratedOnAdd() + .HasColumnType("timestamp with time zone"); + + b.Property("Discount") + .HasPrecision(18, 2) + .HasColumnType("numeric(18,2)"); + + b.Property("Price") + .HasPrecision(18, 2) + .HasColumnType("numeric(18,2)"); + + b.Property("ProductId") + .HasColumnType("uuid"); + + b.Property("UpdatedAt") + .ValueGeneratedOnUpdate() + .HasColumnType("timestamp with time zone"); + + b.HasKey("Id"); + + b.HasIndex("ProductId"); + + b.ToTable("ProductPrice", (string)null); + }); + + modelBuilder.Entity("LeadGenerator.Database.Entities.Lead", b => + { + b.HasOne("LeadGenerator.Database.Entities.Customer", "Customer") + .WithMany("Leads") + .HasForeignKey("CustomerId") + .OnDelete(DeleteBehavior.NoAction); + + b.Navigation("Customer"); + }); + + modelBuilder.Entity("LeadGenerator.Database.Entities.Order", b => + { + b.HasOne("LeadGenerator.Database.Entities.Customer", "Customer") + .WithMany("Orders") + .HasForeignKey("CustomerId") + .OnDelete(DeleteBehavior.Restrict) + .IsRequired(); + + b.HasOne("LeadGenerator.Database.Entities.ProductPrice", "ProductPrice") + .WithMany() + .HasForeignKey("ProductPriceId") + .OnDelete(DeleteBehavior.Restrict) + .IsRequired(); + + b.Navigation("Customer"); + + b.Navigation("ProductPrice"); + }); + + modelBuilder.Entity("LeadGenerator.Database.Entities.OrderRefund", b => + { + b.HasOne("LeadGenerator.Database.Entities.Order", "Order") + .WithOne("Refund") + .HasForeignKey("LeadGenerator.Database.Entities.OrderRefund", "OrderId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.Navigation("Order"); + }); + + modelBuilder.Entity("LeadGenerator.Database.Entities.ProductPrice", b => + { + b.HasOne("LeadGenerator.Database.Entities.Product", "Product") + .WithMany("ProductPrices") + .HasForeignKey("ProductId") + .OnDelete(DeleteBehavior.Restrict) + .IsRequired(); + + b.Navigation("Product"); + }); + + modelBuilder.Entity("LeadGenerator.Database.Entities.Customer", b => + { + b.Navigation("Leads"); + + b.Navigation("Orders"); + }); + + modelBuilder.Entity("LeadGenerator.Database.Entities.Order", b => + { + b.Navigation("Refund"); + }); + + modelBuilder.Entity("LeadGenerator.Database.Entities.Product", b => + { + b.Navigation("ProductPrices"); + }); +#pragma warning restore 612, 618 + } + } +} diff --git a/LiteCharms.Infrastructure/Database/Migrations/20260503003624_RemovedLeadIdFromLead.cs b/LiteCharms.Infrastructure/Database/Migrations/20260503003624_RemovedLeadIdFromLead.cs new file mode 100644 index 0000000..d469ce3 --- /dev/null +++ b/LiteCharms.Infrastructure/Database/Migrations/20260503003624_RemovedLeadIdFromLead.cs @@ -0,0 +1,29 @@ +using System; +using Microsoft.EntityFrameworkCore.Migrations; + +#nullable disable + +namespace LiteCharms.Infrastructure.Database.Migrations +{ + /// + public partial class RemovedLeadIdFromLead : Migration + { + /// + protected override void Up(MigrationBuilder migrationBuilder) + { + migrationBuilder.DropColumn( + name: "LeadId", + table: "Lead"); + } + + /// + protected override void Down(MigrationBuilder migrationBuilder) + { + migrationBuilder.AddColumn( + name: "LeadId", + table: "Lead", + type: "uuid", + nullable: true); + } + } +} diff --git a/LiteCharms.Infrastructure/Database/Migrations/20260503012708_AddedStatusToLead.Designer.cs b/LiteCharms.Infrastructure/Database/Migrations/20260503012708_AddedStatusToLead.Designer.cs new file mode 100644 index 0000000..036f3c2 --- /dev/null +++ b/LiteCharms.Infrastructure/Database/Migrations/20260503012708_AddedStatusToLead.Designer.cs @@ -0,0 +1,357 @@ +// +using System; +using LiteCharms.Infrastructure.Database; +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.Infrastructure.Database.Migrations +{ + [DbContext(typeof(LeadGeneratorDbContext))] + [Migration("20260503012708_AddedStatusToLead")] + partial class AddedStatusToLead + { + /// + protected override void BuildTargetModel(ModelBuilder modelBuilder) + { +#pragma warning disable 612, 618 + modelBuilder + .HasAnnotation("ProductVersion", "10.0.7") + .HasAnnotation("Relational:MaxIdentifierLength", 63); + + NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder); + + modelBuilder.Entity("LeadGenerator.Database.Entities.Customer", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("Active") + .ValueGeneratedOnAdd() + .HasColumnType("boolean") + .HasDefaultValue(true); + + b.Property("Address") + .HasColumnType("text"); + + b.Property("City") + .HasColumnType("text"); + + b.Property("Company") + .HasColumnType("text"); + + b.Property("Country") + .HasColumnType("text"); + + b.Property("CreatedAt") + .ValueGeneratedOnAdd() + .HasColumnType("timestamp with time zone"); + + b.Property("Discord") + .HasColumnType("text"); + + b.Property("Email") + .IsRequired() + .HasColumnType("text"); + + b.Property("LastName") + .IsRequired() + .HasColumnType("text"); + + b.Property("LinkedIn") + .HasColumnType("text"); + + b.Property("Name") + .IsRequired() + .HasColumnType("text"); + + b.Property("Phone") + .HasColumnType("text"); + + b.Property("PostalCode") + .HasColumnType("text"); + + b.Property("Region") + .HasColumnType("text"); + + b.Property("Slack") + .HasColumnType("text"); + + b.Property("Tax") + .HasColumnType("text"); + + b.Property("UpdatedAt") + .ValueGeneratedOnUpdate() + .HasColumnType("timestamp with time zone"); + + b.Property("Website") + .HasColumnType("text"); + + b.Property("Whatsapp") + .HasColumnType("text"); + + b.HasKey("Id"); + + b.ToTable("Customer", (string)null); + }); + + modelBuilder.Entity("LeadGenerator.Database.Entities.Lead", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("AdGroupId") + .HasColumnType("bigint"); + + b.Property("AdName") + .HasColumnType("bigint"); + + b.Property("AppClickId") + .HasColumnType("text"); + + b.Property("AttribusionHash") + .IsRequired() + .HasColumnType("text"); + + b.Property("CampaignId") + .HasColumnType("bigint"); + + b.Property("ClickLocation") + .HasColumnType("text"); + + b.Property("CreatedAt") + .ValueGeneratedOnAdd() + .HasColumnType("timestamp with time zone"); + + b.Property("CustomerId") + .HasColumnType("uuid"); + + b.Property("FeedItemId") + .HasColumnType("bigint"); + + b.Property("GoogleClickId") + .HasColumnType("text"); + + b.Property("Status") + .HasColumnType("integer"); + + b.Property("TargetId") + .HasColumnType("bigint"); + + b.Property("UpdatedAt") + .ValueGeneratedOnUpdate() + .HasColumnType("timestamp with time zone"); + + b.Property("WebClickId") + .HasColumnType("text"); + + b.HasKey("Id"); + + b.HasIndex("CustomerId"); + + b.ToTable("Lead", (string)null); + }); + + modelBuilder.Entity("LeadGenerator.Database.Entities.Order", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("CreatedAt") + .ValueGeneratedOnAdd() + .HasColumnType("timestamp with time zone"); + + b.Property("CustomerId") + .HasColumnType("uuid"); + + b.PrimitiveCollection("Notes") + .HasColumnType("jsonb"); + + b.Property("ProductPriceId") + .HasColumnType("uuid"); + + b.Property("RefundId") + .HasColumnType("uuid"); + + b.Property("Status") + .HasColumnType("integer"); + + b.Property("UpdatedAt") + .ValueGeneratedOnUpdate() + .HasColumnType("timestamp with time zone"); + + b.HasKey("Id"); + + b.HasIndex("CustomerId"); + + b.HasIndex("ProductPriceId"); + + b.ToTable("Order", (string)null); + }); + + modelBuilder.Entity("LeadGenerator.Database.Entities.OrderRefund", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("Amount") + .HasPrecision(18, 2) + .HasColumnType("numeric(18,2)"); + + b.Property("CreatedAt") + .ValueGeneratedOnAdd() + .HasColumnType("timestamp with time zone"); + + b.Property("OrderId") + .HasColumnType("uuid"); + + b.Property("Reason") + .IsRequired() + .HasColumnType("text"); + + b.HasKey("Id"); + + b.HasIndex("OrderId") + .IsUnique(); + + b.ToTable("OrderRefund", (string)null); + }); + + modelBuilder.Entity("LeadGenerator.Database.Entities.Product", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("Active") + .ValueGeneratedOnAdd() + .HasColumnType("boolean") + .HasDefaultValue(true); + + b.Property("Description") + .IsRequired() + .HasColumnType("text"); + + b.Property("Name") + .IsRequired() + .HasColumnType("text"); + + b.HasKey("Id"); + + b.ToTable("Product", (string)null); + }); + + modelBuilder.Entity("LeadGenerator.Database.Entities.ProductPrice", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("Active") + .HasColumnType("boolean"); + + b.Property("CreatedAt") + .ValueGeneratedOnAdd() + .HasColumnType("timestamp with time zone"); + + b.Property("Discount") + .HasPrecision(18, 2) + .HasColumnType("numeric(18,2)"); + + b.Property("Price") + .HasPrecision(18, 2) + .HasColumnType("numeric(18,2)"); + + b.Property("ProductId") + .HasColumnType("uuid"); + + b.Property("UpdatedAt") + .ValueGeneratedOnUpdate() + .HasColumnType("timestamp with time zone"); + + b.HasKey("Id"); + + b.HasIndex("ProductId"); + + b.ToTable("ProductPrice", (string)null); + }); + + modelBuilder.Entity("LeadGenerator.Database.Entities.Lead", b => + { + b.HasOne("LeadGenerator.Database.Entities.Customer", "Customer") + .WithMany("Leads") + .HasForeignKey("CustomerId") + .OnDelete(DeleteBehavior.NoAction); + + b.Navigation("Customer"); + }); + + modelBuilder.Entity("LeadGenerator.Database.Entities.Order", b => + { + b.HasOne("LeadGenerator.Database.Entities.Customer", "Customer") + .WithMany("Orders") + .HasForeignKey("CustomerId") + .OnDelete(DeleteBehavior.Restrict) + .IsRequired(); + + b.HasOne("LeadGenerator.Database.Entities.ProductPrice", "ProductPrice") + .WithMany() + .HasForeignKey("ProductPriceId") + .OnDelete(DeleteBehavior.Restrict) + .IsRequired(); + + b.Navigation("Customer"); + + b.Navigation("ProductPrice"); + }); + + modelBuilder.Entity("LeadGenerator.Database.Entities.OrderRefund", b => + { + b.HasOne("LeadGenerator.Database.Entities.Order", "Order") + .WithOne("Refund") + .HasForeignKey("LeadGenerator.Database.Entities.OrderRefund", "OrderId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.Navigation("Order"); + }); + + modelBuilder.Entity("LeadGenerator.Database.Entities.ProductPrice", b => + { + b.HasOne("LeadGenerator.Database.Entities.Product", "Product") + .WithMany("ProductPrices") + .HasForeignKey("ProductId") + .OnDelete(DeleteBehavior.Restrict) + .IsRequired(); + + b.Navigation("Product"); + }); + + modelBuilder.Entity("LeadGenerator.Database.Entities.Customer", b => + { + b.Navigation("Leads"); + + b.Navigation("Orders"); + }); + + modelBuilder.Entity("LeadGenerator.Database.Entities.Order", b => + { + b.Navigation("Refund"); + }); + + modelBuilder.Entity("LeadGenerator.Database.Entities.Product", b => + { + b.Navigation("ProductPrices"); + }); +#pragma warning restore 612, 618 + } + } +} diff --git a/LiteCharms.Infrastructure/Database/Migrations/20260503012708_AddedStatusToLead.cs b/LiteCharms.Infrastructure/Database/Migrations/20260503012708_AddedStatusToLead.cs new file mode 100644 index 0000000..71b82d1 --- /dev/null +++ b/LiteCharms.Infrastructure/Database/Migrations/20260503012708_AddedStatusToLead.cs @@ -0,0 +1,29 @@ +using Microsoft.EntityFrameworkCore.Migrations; + +#nullable disable + +namespace LiteCharms.Infrastructure.Database.Migrations +{ + /// + public partial class AddedStatusToLead : Migration + { + /// + protected override void Up(MigrationBuilder migrationBuilder) + { + migrationBuilder.AddColumn( + name: "Status", + table: "Lead", + type: "integer", + nullable: false, + defaultValue: 0); + } + + /// + protected override void Down(MigrationBuilder migrationBuilder) + { + migrationBuilder.DropColumn( + name: "Status", + table: "Lead"); + } + } +} diff --git a/LiteCharms.Infrastructure/Database/Migrations/20260503133855_CorrectedAttributionHashColumnOnLead.Designer.cs b/LiteCharms.Infrastructure/Database/Migrations/20260503133855_CorrectedAttributionHashColumnOnLead.Designer.cs new file mode 100644 index 0000000..0a1ad72 --- /dev/null +++ b/LiteCharms.Infrastructure/Database/Migrations/20260503133855_CorrectedAttributionHashColumnOnLead.Designer.cs @@ -0,0 +1,357 @@ +// +using System; +using LiteCharms.Infrastructure.Database; +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.Infrastructure.Database.Migrations +{ + [DbContext(typeof(LeadGeneratorDbContext))] + [Migration("20260503133855_CorrectedAttributionHashColumnOnLead")] + partial class CorrectedAttributionHashColumnOnLead + { + /// + protected override void BuildTargetModel(ModelBuilder modelBuilder) + { +#pragma warning disable 612, 618 + modelBuilder + .HasAnnotation("ProductVersion", "10.0.7") + .HasAnnotation("Relational:MaxIdentifierLength", 63); + + NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder); + + modelBuilder.Entity("LiteCharms.Entities.Customer", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("Active") + .ValueGeneratedOnAdd() + .HasColumnType("boolean") + .HasDefaultValue(true); + + b.Property("Address") + .HasColumnType("text"); + + b.Property("City") + .HasColumnType("text"); + + b.Property("Company") + .HasColumnType("text"); + + b.Property("Country") + .HasColumnType("text"); + + b.Property("CreatedAt") + .ValueGeneratedOnAdd() + .HasColumnType("timestamp with time zone"); + + b.Property("Discord") + .HasColumnType("text"); + + b.Property("Email") + .IsRequired() + .HasColumnType("text"); + + b.Property("LastName") + .IsRequired() + .HasColumnType("text"); + + b.Property("LinkedIn") + .HasColumnType("text"); + + b.Property("Name") + .IsRequired() + .HasColumnType("text"); + + b.Property("Phone") + .HasColumnType("text"); + + b.Property("PostalCode") + .HasColumnType("text"); + + b.Property("Region") + .HasColumnType("text"); + + b.Property("Slack") + .HasColumnType("text"); + + b.Property("Tax") + .HasColumnType("text"); + + b.Property("UpdatedAt") + .ValueGeneratedOnUpdate() + .HasColumnType("timestamp with time zone"); + + b.Property("Website") + .HasColumnType("text"); + + b.Property("Whatsapp") + .HasColumnType("text"); + + b.HasKey("Id"); + + b.ToTable("Customer", (string)null); + }); + + modelBuilder.Entity("LiteCharms.Entities.Lead", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("AdGroupId") + .HasColumnType("bigint"); + + b.Property("AdName") + .HasColumnType("bigint"); + + b.Property("AppClickId") + .HasColumnType("text"); + + b.Property("AttributionHash") + .IsRequired() + .HasColumnType("text"); + + b.Property("CampaignId") + .HasColumnType("bigint"); + + b.Property("ClickLocation") + .HasColumnType("text"); + + b.Property("CreatedAt") + .ValueGeneratedOnAdd() + .HasColumnType("timestamp with time zone"); + + b.Property("CustomerId") + .HasColumnType("uuid"); + + b.Property("FeedItemId") + .HasColumnType("bigint"); + + b.Property("GoogleClickId") + .HasColumnType("text"); + + b.Property("Status") + .HasColumnType("integer"); + + b.Property("TargetId") + .HasColumnType("bigint"); + + b.Property("UpdatedAt") + .ValueGeneratedOnUpdate() + .HasColumnType("timestamp with time zone"); + + b.Property("WebClickId") + .HasColumnType("text"); + + b.HasKey("Id"); + + b.HasIndex("CustomerId"); + + b.ToTable("Lead", (string)null); + }); + + modelBuilder.Entity("LiteCharms.Entities.Order", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("CreatedAt") + .ValueGeneratedOnAdd() + .HasColumnType("timestamp with time zone"); + + b.Property("CustomerId") + .HasColumnType("uuid"); + + b.PrimitiveCollection("Notes") + .HasColumnType("jsonb"); + + b.Property("ProductPriceId") + .HasColumnType("uuid"); + + b.Property("RefundId") + .HasColumnType("uuid"); + + b.Property("Status") + .HasColumnType("integer"); + + b.Property("UpdatedAt") + .ValueGeneratedOnUpdate() + .HasColumnType("timestamp with time zone"); + + b.HasKey("Id"); + + b.HasIndex("CustomerId"); + + b.HasIndex("ProductPriceId"); + + b.ToTable("Order", (string)null); + }); + + modelBuilder.Entity("LiteCharms.Entities.OrderRefund", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("Amount") + .HasPrecision(18, 2) + .HasColumnType("numeric(18,2)"); + + b.Property("CreatedAt") + .ValueGeneratedOnAdd() + .HasColumnType("timestamp with time zone"); + + b.Property("OrderId") + .HasColumnType("uuid"); + + b.Property("Reason") + .IsRequired() + .HasColumnType("text"); + + b.HasKey("Id"); + + b.HasIndex("OrderId") + .IsUnique(); + + b.ToTable("OrderRefund", (string)null); + }); + + modelBuilder.Entity("LiteCharms.Entities.Product", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("Active") + .ValueGeneratedOnAdd() + .HasColumnType("boolean") + .HasDefaultValue(true); + + b.Property("Description") + .IsRequired() + .HasColumnType("text"); + + b.Property("Name") + .IsRequired() + .HasColumnType("text"); + + b.HasKey("Id"); + + b.ToTable("Product", (string)null); + }); + + modelBuilder.Entity("LiteCharms.Entities.ProductPrice", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("Active") + .HasColumnType("boolean"); + + b.Property("CreatedAt") + .ValueGeneratedOnAdd() + .HasColumnType("timestamp with time zone"); + + b.Property("Discount") + .HasPrecision(18, 2) + .HasColumnType("numeric(18,2)"); + + b.Property("Price") + .HasPrecision(18, 2) + .HasColumnType("numeric(18,2)"); + + b.Property("ProductId") + .HasColumnType("uuid"); + + b.Property("UpdatedAt") + .ValueGeneratedOnUpdate() + .HasColumnType("timestamp with time zone"); + + b.HasKey("Id"); + + b.HasIndex("ProductId"); + + b.ToTable("ProductPrice", (string)null); + }); + + modelBuilder.Entity("LiteCharms.Entities.Lead", b => + { + b.HasOne("LiteCharms.Entities.Customer", "Customer") + .WithMany("Leads") + .HasForeignKey("CustomerId") + .OnDelete(DeleteBehavior.NoAction); + + b.Navigation("Customer"); + }); + + modelBuilder.Entity("LiteCharms.Entities.Order", b => + { + b.HasOne("LiteCharms.Entities.Customer", "Customer") + .WithMany("Orders") + .HasForeignKey("CustomerId") + .OnDelete(DeleteBehavior.Restrict) + .IsRequired(); + + b.HasOne("LiteCharms.Entities.ProductPrice", "ProductPrice") + .WithMany() + .HasForeignKey("ProductPriceId") + .OnDelete(DeleteBehavior.Restrict) + .IsRequired(); + + b.Navigation("Customer"); + + b.Navigation("ProductPrice"); + }); + + modelBuilder.Entity("LiteCharms.Entities.OrderRefund", b => + { + b.HasOne("LiteCharms.Entities.Order", "Order") + .WithOne("Refund") + .HasForeignKey("LiteCharms.Entities.OrderRefund", "OrderId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.Navigation("Order"); + }); + + modelBuilder.Entity("LiteCharms.Entities.ProductPrice", b => + { + b.HasOne("LiteCharms.Entities.Product", "Product") + .WithMany("ProductPrices") + .HasForeignKey("ProductId") + .OnDelete(DeleteBehavior.Restrict) + .IsRequired(); + + b.Navigation("Product"); + }); + + modelBuilder.Entity("LiteCharms.Entities.Customer", b => + { + b.Navigation("Leads"); + + b.Navigation("Orders"); + }); + + modelBuilder.Entity("LiteCharms.Entities.Order", b => + { + b.Navigation("Refund"); + }); + + modelBuilder.Entity("LiteCharms.Entities.Product", b => + { + b.Navigation("ProductPrices"); + }); +#pragma warning restore 612, 618 + } + } +} diff --git a/LiteCharms.Infrastructure/Database/Migrations/20260503133855_CorrectedAttributionHashColumnOnLead.cs b/LiteCharms.Infrastructure/Database/Migrations/20260503133855_CorrectedAttributionHashColumnOnLead.cs new file mode 100644 index 0000000..9d1fd30 --- /dev/null +++ b/LiteCharms.Infrastructure/Database/Migrations/20260503133855_CorrectedAttributionHashColumnOnLead.cs @@ -0,0 +1,28 @@ +using Microsoft.EntityFrameworkCore.Migrations; + +#nullable disable + +namespace LiteCharms.Infrastructure.Database.Migrations +{ + /// + public partial class CorrectedAttributionHashColumnOnLead : Migration + { + /// + protected override void Up(MigrationBuilder migrationBuilder) + { + migrationBuilder.RenameColumn( + name: "AttribusionHash", + table: "Lead", + newName: "AttributionHash"); + } + + /// + protected override void Down(MigrationBuilder migrationBuilder) + { + migrationBuilder.RenameColumn( + name: "AttributionHash", + table: "Lead", + newName: "AttribusionHash"); + } + } +} diff --git a/LiteCharms.Infrastructure/Database/Migrations/LeadGeneratorDbContextModelSnapshot.cs b/LiteCharms.Infrastructure/Database/Migrations/LeadGeneratorDbContextModelSnapshot.cs new file mode 100644 index 0000000..20a5632 --- /dev/null +++ b/LiteCharms.Infrastructure/Database/Migrations/LeadGeneratorDbContextModelSnapshot.cs @@ -0,0 +1,354 @@ +// +using System; +using LiteCharms.Infrastructure.Database; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata; + +#nullable disable + +namespace LiteCharms.Infrastructure.Migrations +{ + [DbContext(typeof(LeadGeneratorDbContext))] + partial class LeadGeneratorDbContextModelSnapshot : ModelSnapshot + { + protected override void BuildModel(ModelBuilder modelBuilder) + { +#pragma warning disable 612, 618 + modelBuilder + .HasAnnotation("ProductVersion", "10.0.7") + .HasAnnotation("Relational:MaxIdentifierLength", 63); + + NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder); + + modelBuilder.Entity("LiteCharms.Entities.Customer", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("Active") + .ValueGeneratedOnAdd() + .HasColumnType("boolean") + .HasDefaultValue(true); + + b.Property("Address") + .HasColumnType("text"); + + b.Property("City") + .HasColumnType("text"); + + b.Property("Company") + .HasColumnType("text"); + + b.Property("Country") + .HasColumnType("text"); + + b.Property("CreatedAt") + .ValueGeneratedOnAdd() + .HasColumnType("timestamp with time zone"); + + b.Property("Discord") + .HasColumnType("text"); + + b.Property("Email") + .IsRequired() + .HasColumnType("text"); + + b.Property("LastName") + .IsRequired() + .HasColumnType("text"); + + b.Property("LinkedIn") + .HasColumnType("text"); + + b.Property("Name") + .IsRequired() + .HasColumnType("text"); + + b.Property("Phone") + .HasColumnType("text"); + + b.Property("PostalCode") + .HasColumnType("text"); + + b.Property("Region") + .HasColumnType("text"); + + b.Property("Slack") + .HasColumnType("text"); + + b.Property("Tax") + .HasColumnType("text"); + + b.Property("UpdatedAt") + .ValueGeneratedOnUpdate() + .HasColumnType("timestamp with time zone"); + + b.Property("Website") + .HasColumnType("text"); + + b.Property("Whatsapp") + .HasColumnType("text"); + + b.HasKey("Id"); + + b.ToTable("Customer", (string)null); + }); + + modelBuilder.Entity("LiteCharms.Entities.Lead", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("AdGroupId") + .HasColumnType("bigint"); + + b.Property("AdName") + .HasColumnType("bigint"); + + b.Property("AppClickId") + .HasColumnType("text"); + + b.Property("AttributionHash") + .IsRequired() + .HasColumnType("text"); + + b.Property("CampaignId") + .HasColumnType("bigint"); + + b.Property("ClickLocation") + .HasColumnType("text"); + + b.Property("CreatedAt") + .ValueGeneratedOnAdd() + .HasColumnType("timestamp with time zone"); + + b.Property("CustomerId") + .HasColumnType("uuid"); + + b.Property("FeedItemId") + .HasColumnType("bigint"); + + b.Property("GoogleClickId") + .HasColumnType("text"); + + b.Property("Status") + .HasColumnType("integer"); + + b.Property("TargetId") + .HasColumnType("bigint"); + + b.Property("UpdatedAt") + .ValueGeneratedOnUpdate() + .HasColumnType("timestamp with time zone"); + + b.Property("WebClickId") + .HasColumnType("text"); + + b.HasKey("Id"); + + b.HasIndex("CustomerId"); + + b.ToTable("Lead", (string)null); + }); + + modelBuilder.Entity("LiteCharms.Entities.Order", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("CreatedAt") + .ValueGeneratedOnAdd() + .HasColumnType("timestamp with time zone"); + + b.Property("CustomerId") + .HasColumnType("uuid"); + + b.PrimitiveCollection("Notes") + .HasColumnType("jsonb"); + + b.Property("ProductPriceId") + .HasColumnType("uuid"); + + b.Property("RefundId") + .HasColumnType("uuid"); + + b.Property("Status") + .HasColumnType("integer"); + + b.Property("UpdatedAt") + .ValueGeneratedOnUpdate() + .HasColumnType("timestamp with time zone"); + + b.HasKey("Id"); + + b.HasIndex("CustomerId"); + + b.HasIndex("ProductPriceId"); + + b.ToTable("Order", (string)null); + }); + + modelBuilder.Entity("LiteCharms.Entities.OrderRefund", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("Amount") + .HasPrecision(18, 2) + .HasColumnType("numeric(18,2)"); + + b.Property("CreatedAt") + .ValueGeneratedOnAdd() + .HasColumnType("timestamp with time zone"); + + b.Property("OrderId") + .HasColumnType("uuid"); + + b.Property("Reason") + .IsRequired() + .HasColumnType("text"); + + b.HasKey("Id"); + + b.HasIndex("OrderId") + .IsUnique(); + + b.ToTable("OrderRefund", (string)null); + }); + + modelBuilder.Entity("LiteCharms.Entities.Product", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("Active") + .ValueGeneratedOnAdd() + .HasColumnType("boolean") + .HasDefaultValue(true); + + b.Property("Description") + .IsRequired() + .HasColumnType("text"); + + b.Property("Name") + .IsRequired() + .HasColumnType("text"); + + b.HasKey("Id"); + + b.ToTable("Product", (string)null); + }); + + modelBuilder.Entity("LiteCharms.Entities.ProductPrice", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("Active") + .HasColumnType("boolean"); + + b.Property("CreatedAt") + .ValueGeneratedOnAdd() + .HasColumnType("timestamp with time zone"); + + b.Property("Discount") + .HasPrecision(18, 2) + .HasColumnType("numeric(18,2)"); + + b.Property("Price") + .HasPrecision(18, 2) + .HasColumnType("numeric(18,2)"); + + b.Property("ProductId") + .HasColumnType("uuid"); + + b.Property("UpdatedAt") + .ValueGeneratedOnUpdate() + .HasColumnType("timestamp with time zone"); + + b.HasKey("Id"); + + b.HasIndex("ProductId"); + + b.ToTable("ProductPrice", (string)null); + }); + + modelBuilder.Entity("LiteCharms.Entities.Lead", b => + { + b.HasOne("LiteCharms.Entities.Customer", "Customer") + .WithMany("Leads") + .HasForeignKey("CustomerId") + .OnDelete(DeleteBehavior.NoAction); + + b.Navigation("Customer"); + }); + + modelBuilder.Entity("LiteCharms.Entities.Order", b => + { + b.HasOne("LiteCharms.Entities.Customer", "Customer") + .WithMany("Orders") + .HasForeignKey("CustomerId") + .OnDelete(DeleteBehavior.Restrict) + .IsRequired(); + + b.HasOne("LiteCharms.Entities.ProductPrice", "ProductPrice") + .WithMany() + .HasForeignKey("ProductPriceId") + .OnDelete(DeleteBehavior.Restrict) + .IsRequired(); + + b.Navigation("Customer"); + + b.Navigation("ProductPrice"); + }); + + modelBuilder.Entity("LiteCharms.Entities.OrderRefund", b => + { + b.HasOne("LiteCharms.Entities.Order", "Order") + .WithOne("Refund") + .HasForeignKey("LiteCharms.Entities.OrderRefund", "OrderId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.Navigation("Order"); + }); + + modelBuilder.Entity("LiteCharms.Entities.ProductPrice", b => + { + b.HasOne("LiteCharms.Entities.Product", "Product") + .WithMany("ProductPrices") + .HasForeignKey("ProductId") + .OnDelete(DeleteBehavior.Restrict) + .IsRequired(); + + b.Navigation("Product"); + }); + + modelBuilder.Entity("LiteCharms.Entities.Customer", b => + { + b.Navigation("Leads"); + + b.Navigation("Orders"); + }); + + modelBuilder.Entity("LiteCharms.Entities.Order", b => + { + b.Navigation("Refund"); + }); + + modelBuilder.Entity("LiteCharms.Entities.Product", b => + { + b.Navigation("ProductPrices"); + }); +#pragma warning restore 612, 618 + } + } +} diff --git a/LiteCharms.Infrastructure/HealthChecks/PostgresHealthCheck.cs b/LiteCharms.Infrastructure/HealthChecks/PostgresHealthCheck.cs new file mode 100644 index 0000000..6680c17 --- /dev/null +++ b/LiteCharms.Infrastructure/HealthChecks/PostgresHealthCheck.cs @@ -0,0 +1,26 @@ +namespace LiteCharms.Infrastructure.HealthChecks; + +public class PostgresHealthCheck(IConfiguration configuration) : IHealthCheck +{ + private readonly string connectionString = configuration.GetConnectionString("PostgresLeadGenerator")!; + + public async Task 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("PostgreSQL is responsive."); + } + catch (Exception ex) + { + return HealthCheckResult.Unhealthy("PostgreSQL is unreachable.", ex); + } + } +} \ No newline at end of file diff --git a/LiteCharms.Infrastructure/LiteCharms.Infrastructure.csproj b/LiteCharms.Infrastructure/LiteCharms.Infrastructure.csproj new file mode 100644 index 0000000..144ef8e --- /dev/null +++ b/LiteCharms.Infrastructure/LiteCharms.Infrastructure.csproj @@ -0,0 +1,83 @@ + + + + net10.0 + enable + enable + 7770ab3b-72ee-4897-8e06-57d6613e050a + True + ..\LiteCharms.snk + + + + + LiteCharms.Infrastructure + 1.0.1 + Khwezi Mngoma + Lite Charms (PTY) Ltd + Infrastructure components for Lite Charms applications. + https://gitea.khongisa.co.za/litecharms/leadgenerator + https://gitea.khongisa.co.za/litecharms/leadgenerator.git + git + LICENSE + icon.png + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + all + runtime; build; native; contentfiles; analyzers; buildtransitive + + + + all + runtime; build; native; contentfiles; analyzers; buildtransitive + + + + + + + + + + + + + + + + + + PreserveNewest + + + + diff --git a/LiteCharms.Infrastructure/appsettings.json b/LiteCharms.Infrastructure/appsettings.json new file mode 100644 index 0000000..0db3279 --- /dev/null +++ b/LiteCharms.Infrastructure/appsettings.json @@ -0,0 +1,3 @@ +{ + +} diff --git a/LiteCharms.Models/Customer.cs b/LiteCharms.Models/Customer.cs new file mode 100644 index 0000000..b322f8a --- /dev/null +++ b/LiteCharms.Models/Customer.cs @@ -0,0 +1,44 @@ +namespace LiteCharms.Models; + +public class Customer +{ + public Guid Id { get; set; } + + public DateTimeOffset CreatedAt { get; set; } + + public DateTimeOffset? UpdatedAt { 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; } + + public bool Active { get; set; } +} diff --git a/LiteCharms.Models/Enums.cs b/LiteCharms.Models/Enums.cs new file mode 100644 index 0000000..deb97b0 --- /dev/null +++ b/LiteCharms.Models/Enums.cs @@ -0,0 +1,21 @@ +namespace LiteCharms.Models; + +public enum OrderStatus : int +{ + Pending = 0, + Completed = 1, + Cancelled = 2, + Failed = 3, + Refunded = 4, + Error = 5 +} + +public enum LeadStatus : int +{ + New = 0, + Contacted = 1, + Qualified = 2, + Unqualified = 3, + Converted = 4, + Lost = 5 +} diff --git a/LiteCharms.Models/Lead.cs b/LiteCharms.Models/Lead.cs new file mode 100644 index 0000000..a221561 --- /dev/null +++ b/LiteCharms.Models/Lead.cs @@ -0,0 +1,34 @@ +namespace LiteCharms.Models; + +public class Lead +{ + public Guid Id { get; set; } + + public DateTimeOffset CreatedAt { get; set; } + + public DateTimeOffset? UpdatedAt { get; set; } + + public Guid? CustomerId { get; set; } + + public string? GoogleClickId { get; set; } + + public string? WebClickId { get; set; } + + public 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? AttributionHash { get; set; } + + public LeadStatus Status { get; set; } +} diff --git a/LiteCharms.Models/LiteCharms.Models.csproj b/LiteCharms.Models/LiteCharms.Models.csproj new file mode 100644 index 0000000..c041fe0 --- /dev/null +++ b/LiteCharms.Models/LiteCharms.Models.csproj @@ -0,0 +1,30 @@ + + + + net10.0 + enable + enable + ..\LiteCharms.snk + True + + + + + LiteCharms.Models + 1.0.1 + Khwezi Mngoma + Lite Charms (PTY) Ltd + Shared models for Lite Charms applications. + https://gitea.khongisa.co.za/litecharms/leadgenerator + https://gitea.khongisa.co.za/litecharms/leadgenerator.git + git + LICENSE + utility;dotnet + icon.png + + + + + + + diff --git a/LiteCharms.Models/Order.cs b/LiteCharms.Models/Order.cs new file mode 100644 index 0000000..366160e --- /dev/null +++ b/LiteCharms.Models/Order.cs @@ -0,0 +1,20 @@ +namespace LiteCharms.Models; + +public class Order +{ + public Guid Id { get; set; } + + public DateTimeOffset CreatedAt { get; set; } + + public DateTimeOffset? UpdatedAt { get; set; } + + public Guid CustomerId { get; set; } + + public Guid ProductPriceId { get; set; } + + public Guid? RefundId { get; set; } + + public OrderStatus Status { get; set; } + + public string[]? Notes { get; set; } +} diff --git a/LiteCharms.Models/OrderRefund.cs b/LiteCharms.Models/OrderRefund.cs new file mode 100644 index 0000000..292e918 --- /dev/null +++ b/LiteCharms.Models/OrderRefund.cs @@ -0,0 +1,14 @@ +namespace LiteCharms.Models; + +public class OrderRefund +{ + public Guid Id { get; set; } + + public DateTimeOffset CreatedAt { get; set; } + + public Guid OrderId { get; set; } + + public string? Reason { get; set; } + + public decimal Amount { get; set; } +} diff --git a/LiteCharms.Models/Product.cs b/LiteCharms.Models/Product.cs new file mode 100644 index 0000000..406452c --- /dev/null +++ b/LiteCharms.Models/Product.cs @@ -0,0 +1,12 @@ +namespace LiteCharms.Models; + +public class Product +{ + public Guid Id { get; set; } + + public string? Name { get; set; } + + public string? Description { get; set; } + + public bool Active { get; set; } +} diff --git a/LiteCharms.Models/ProductPrice.cs b/LiteCharms.Models/ProductPrice.cs new file mode 100644 index 0000000..49931ea --- /dev/null +++ b/LiteCharms.Models/ProductPrice.cs @@ -0,0 +1,18 @@ +namespace LiteCharms.Models; + +public class ProductPrice +{ + public Guid Id { get; set; } + + public DateTimeOffset CreatedAt { get; set; } + + public DateTimeOffset? UpdatedAt { get; set; } + + public Guid ProductId { get; set; } + + public decimal Price { get; set; } + + public decimal Discount { get; set; } + + public bool Active { get; set; } +} diff --git a/LiteCharms.snk b/LiteCharms.snk new file mode 100644 index 0000000000000000000000000000000000000000..598e6da5f7e77787fbeadbb2954df6e5bd746eb4 GIT binary patch literal 596 zcmV-a0;~N80ssI2Bme+XQ$aES1ONa50096&+=lRest0wWw(tq7LAG|~ZSW?q97mRG z#DH_dF=Cf8kx5HAqsu@td^tjYMVMR}L#aE0McWuUHKurMW8|}wu@s<#9Ey)<4%xQR znyR8E?~*CbdDc%EcSQGpLBY2G&CfT?kW?)trH%iwAAAV^lmUdsK`pQ58UX! zb8N8Rfv0q1G#!V5m+a3Nt2BXyRk)&^_J6Vu;n1TBSuQHp zX!a$Di84u0U5`KxgIoq^Gp7SVOF_pDA{Ed?iWVM%*-I}WM8)9nZu8PAAv>&vfhEKDp?v%U*|BrpvY^$nAf8EA?*y1AcN@h3 literal 0 HcmV?d00001 diff --git a/LiteCharmsShared.slnx b/LiteCharmsShared.slnx index 4e2253d..10ae06d 100644 --- a/LiteCharmsShared.slnx +++ b/LiteCharmsShared.slnx @@ -1 +1,7 @@ - + + + + + + + diff --git a/icon.png b/icon.png new file mode 100644 index 0000000000000000000000000000000000000000..9c3f82966626f257b0f7334750a743d9d2c3098e GIT binary patch literal 287591 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

WGITbXbLxhqPza(m^%nqLcw24L}@=={Gy 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

5sCHrDm+9xRFM>+InRu0>@M8k z2{PzPS%DHDblIUjq;h?OR_zmM%7hFEn2G~8Qg5h!J_ZI!f#4&%eekc)%TZrl=DpJB zYt;Mgb_UP4vQdLIbm9(UXWBmUFle7Ofb05-rsFDv9Y4S;geqLD_Nrvb>-%?U7xv3^ zx9Hj#TeaLOb(7zK3A4?P70&EuMH@hHbk=s*`W^TbEXeVzvv@G+dXTAt#IF_HeDq)k zfC(Ih&16L4Le^n%ZAwBU|v?tS*W-|UB& zgp3NXLZ5q+NbwY+aB_-aYEBioSt6Y*qJy}@6pmB6SmHW6^|?B_?nsfBN1^`0VRs5w zu60uCFA{mG0hcvTK_(TPpKiJUnOKp1;Yo}|;6dl*prODJcFcq6uoUJsbs3V0@BO64 zT;1+H0|O}Qg>3+9{AXTqKPa4tlr-g%@npb-se)k=C&MUtyRvt{W~e#$$wSN_ta2NM zv{X!2ucTW``hpN)vJ4oEn?%nPS7*`<9*Jrf#P)9gJSjFFg9&oZWWQ=EEhbh2-5w5l z#XfdZ>J$3abob_=8eS`fL4lZClNe?m-I-Sk_3iYUKrH1K+Yla_Pp}5AyI3F65S|vY zhF&|`N9cQ%cid2~YypPANZBBL zPD;NyqdG*+Y^>mbf+@nB_#fq?Awv*S+VoBQ zNtzr8iRe~Me|uJ`z&??l#pzJXBps#p-a76)n|mB=WDWJyE@*s-s<0GcU9~g#^X51N zs(xTGWGM(mV~V*d%=iPu|xcnTi5du5~-R{DuN%p&R zC0tc0+lw%@lz;O>Y#7 z^E9XQjScj+{`ZfroN|z*0!8*7&B#Jcgx`*BuPL|7h%KnRbnwhUZQv!T_^;ofGXs18 zl?qzChS??6(f!OyQ|4o!m|wPh=jj&AmDtb9yT6|Yay+t7Jecu-fTx1%2b{u)c-?nl zC`8j3Dz>PDO-!EFM>ml!8aen@2I;yB<@hsJGVi9Y^Z^V8S?Quf$YVV?74FWQYueE(% zPmf%lze%6O51le$^8j643+^t7KOf6{Bgxgh;HBbL9DL?7M2leyp``F-C%d;-Ry~$u zAN%$sXgW6#dGt@yx6gHUC7b6lUktlVW%M{+c!KIe_F)9ncc(F7Rt~%aj;aKUEc6v z{&(c+|NcDnTBGgG=xjk-`ub8Y?U>g?BMJ(sxH>Y@3=&N+J8Ea(JilZ!1^fW-wX z^cf_j!_!y()y=tnM4JsG!Ih~3Svzo2mi^)Flq$O8dL$Zpt~2D_^lajy61Nb(JO4}| zDt(7r&Li{Zrv5sPmSDb#e96SGBxe7?0up41fMx~R3iVd&taqfQW9UO^C0Y#zCnU=osbySW!GP$I86_2*t7O)*)=USDy7lFiL^I|1jp={ zUh*UKGz*a zNm0?s7t1-Z=e?P`SH1fzs@wRl&_Htqib|zXNf4=jUW}DluvM&lsn&l``_cB-r=8A4 zJHeP^(xan`&HYRilV#!`Qeo*nv{%yO&oefbb%~C%Oh}>FsLI#DU~~7~ioNkQmGe+T z%L~wj*!#{TWh>#1ra{@YCxCC++njIlQdL;X4FW4wtQjjW>o4%=ubKulOk?iEo(~9X%gVfi?2H~g5li61W+LTi zENY#GKwAzk_eE|ke2z}Id-9!A(N6>%jY7jQ0f)GN|KFn1$l$#$j-c1m-UqA+_e}RW zn}d%K5Lw ziJAb*WaRnAXkvR^YN#da)m33?g#ds+^W-`&VQy55d>1!3Jo3doG4lq@kHRU;^N!p{cg{QH{!f&%UpGX}aPG4p&vDclUK&gI!4~q8fIHY%AU@xxA+Jbd znqzoQ&PvEDvqX-d(a12Uq?dMsE_?5e^T^J(d9zjC5Pf(Rz0sfm5gM+rnEKn2Ls6GK zUSTW<0IKfSyN53DUYekQH2cjcSh5m1nTf`sa)O?IY`IQ+#X@&tG8^qIO^Ll%p1shO=$%4W*fb*uUU_aFnW!;wqXF z(&e5f3ha8O%)zrh<7~^N8=9mzIh$Zf^%6r9rH=JCFSr_qNa#EYp@A3$U%CsgOU)Oz zbN4HMcFD@d?n6|jxf&dS%!>Vld$eGYPksLH@E$d7W0Y+FjUAjII7JxXW_zwF%ckGa zi-G=p_dJ3jA1XL&twYjzM#~1Jv`U5!ULKTPqEkhpu?^mNhlJ_2r&~`U4u!1Nc9vVV z5hGttB|qIu^11vpj2&E}!n%*WVI!&8^CVJJps`AWstFvK2uZ$*1>C<0bBRtQm`! z`Qp0Zt9p3vazBfb9=1BXlH2;@1MVGA@ZHYP{F36~^qJ(?nFP1m6w{VE z)SX=%JyM^fJ?8Vb@vV=!;~Q)5zWr+h=$nnN{iatp`MAqyymw;m_30Og+51Ze&B^Qt z`AK8=Z`y5}c@e!9%j_pm zqU#giI24#wz=E}DNTf*I0tB|uXmuZOZc)MU-&eS;EV?_ji4E$cDbr>|8DbxeTuviO zhxDTBQ6mA5r?OT&yIC+MshN-uo9#p&lrwXPg0XvIH6T?95T#&47`G~E0!gS~ImRp% zh-Mmvii9@KQRn%9IZy5hp|$uE^2NfNu!P~g_DHyS@j~IROkR?*Dc2=<&aQ_}}0EqhV;!cYOJW`tSP!ZiOY87ci<7`js|wPa;82A|p&0 z=}zm|wnOiWp0C{iAXHEwfk`J|o~H8}L)*dJjsws@BiR6mkf~*&vFfI;<9I!Gq>U7k z-hR;-LjuB%SJK*L1Peo#vKTvQS^SfUvq%&&&xM5LL!}n5-h=8MJvk0rUf>>ZP?v9r`@i7^n-j;LNl){4Bpv2AIIK4{J{*Ip+pUrk$740=4UDeJ2D3J?cN&K0sDZdYLM|TbYF}_5nB^E>*<^vSVqhA#qKb zuo>+pPq+e^>u%7Ps5(uAnVH3}S8ZK87~n+?_&gIhHdaS_x?qL0k2QidS`Y$7{jJk^ zRthlB&m4o|24UrIqq^_s7W*&H>rSLZDD9@80C&hL6;4%JHgIkT=I@YV&Q~3H4iTK* zanOWVBGn#u5`xI_;O#e5sc8zj;E)bT{fBf zdYog#1d&VECOx)i7wWHWw_s!m+edws72+Kg+PAxhccxxms5SVW)3ABLCKH*g0x{Ia zUI^3q{>QE;8Vftp+$EvZw@@BD3n2}JEMKtf<=m;P4 zIn%gwjY2^2C&K1yRKr*IZfzNiZxR>uJs2oFFf>S|%UCKjbH0#%-H)yua^`Veq>_-o z%!xjhgKzca;#&t9{B{0%dRHu1$~s?)mk%sx~DHfbCpf(gv^7CV1svsJ4nZbG!sXfGe1W?F7$_HW&cklkhzs8 zBo-bhV+SQCA%>;J^>JTw>!%KmIW*eMf7XQ~XrCYXy5Mm+>VOOPOuu%z7)ABpFi-`r WFP}6MCo2&bz%R#79eZ+=n*4uEZFhSB literal 0 HcmV?d00001