Retructured solution

LiteCharms.Features/Shop/Leads/Commands/CreateLeadCommand.cs

@@ -0,0 +1,55 @@
+namespace LiteCharms.Features.Leads.Commands;
+
+public class CreateLeadCommand : IRequest<Result<Guid>>
+{
+    public Guid? CustomerId { get; set; }
+
+    public string? Source { get; set; }
+
+    public string? ClickId { 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 source, string clickId, string webClickId, string appClickId, long? campaignId, long? adGroupId, long? adName, long? targetId, long? feedItemId, string? clickLocation, string? attribusionHash)
+    {
+        CustomerId = customerId;
+        Source = source;
+        ClickId = clickId;
+        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 source, string clickId, string webClickId, string appClickId, long? campaignId, long? adGroupId, long? adName, long? targetId, long? feedItemId, string? clickLocation, string? attribusionHash)
+    {
+        if(string.IsNullOrWhiteSpace(source))
+            throw new ArgumentNullException("Lead source is required to create a lead.", nameof(source));
+
+        if (string.IsNullOrWhiteSpace(clickId) || string.IsNullOrWhiteSpace(appClickId) || string.IsNullOrWhiteSpace(webClickId))
+            throw new ArgumentException("ClickId, App ClickId and Web ClickId are required to create a lead.");
+
+        return new(customerId, source, clickId, webClickId, appClickId, campaignId, adGroupId, adName, targetId, feedItemId, clickLocation, attribusionHash);
+    }
+}

LiteCharms.Features/Shop/Leads/Commands/Handlers/CreateLeadCommandHandler.cs

@@ -0,0 +1,47 @@
+using LiteCharms.Features.Shop.Postgres;
+using LiteCharms.Features.Utilities.Hash.Commands;
+
+namespace LiteCharms.Features.Leads.Commands.Handlers;
+
+public class CreateLeadCommandHandler(IDbContextFactory<ShopDbContext> contextFactory, ISender mediator) : IRequestHandler<CreateLeadCommand, Result<Guid>>
+{
+    public async ValueTask<Result<Guid>> Handle(CreateLeadCommand request, CancellationToken cancellationToken)
+    {
+        try
+        {
+            var hashCommand = ComputeHashCommand.Create($"{request.ClickId}{request.AppClickId}{request.WebClickId}");
+            var hashResult = await mediator.Send(hashCommand, cancellationToken);
+
+            if(hashResult.IsFailed)
+                return Result.Fail<Guid>(new Error($"Failed to compute hash for lead -> Google ClickId: {request.ClickId}, 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,
+                Source = request.Source,
+                ClickId = request.ClickId,
+                AdGroupId = request.AdGroupId,
+                AdName = request.AdName,
+                CampaignId = request.CampaignId,
+                ClickLocation = request.ClickLocation,
+                CustomerId = request.CustomerId,
+                FeedItemId = request.FeedItemId,
+                Status = Models.LeadStatus.New,
+                TargetId = request.TargetId,
+                AttributionHash = hashResult.Value
+            });
+
+            return await context.SaveChangesAsync(cancellationToken) > 0
+                ? Result.Ok(newLead.Entity.Id)
+                : Result.Fail<Guid>(new Error($"Failed to create lead -> Google ClickId: {request.ClickId}, App ClickId: {request.AppClickId}, Web ClickId: {request.WebClickId}"));
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail<Guid>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+}

LiteCharms.Features/Shop/Leads/Commands/Handlers/UpdateLeadCommandHandler.cs

@@ -0,0 +1,29 @@
+using LiteCharms.Features.Shop.Postgres;
+
+namespace LiteCharms.Features.Leads.Commands.Handlers;
+
+public class UpdateLeadCommandHandler(IDbContextFactory<ShopDbContext> contextFactory) : IRequestHandler<UpdateLeadCommand, Result>
+{
+    public async ValueTask<Result> 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));
+        }
+    }
+}

LiteCharms.Features/Shop/Leads/Commands/UpdateLeadCommand.cs

@@ -0,0 +1,28 @@
+using LiteCharms.Features.Shop;
+using LiteCharms.Models;
+
+namespace LiteCharms.Features.Leads.Commands;
+
+public class UpdateLeadCommand : IRequest<Result>
+{
+    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);
+    }
+}

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

@@ -0,0 +1,9 @@
+using LiteCharms.Features.Shop.Customers.Models;
+
+namespace LiteCharms.Features.Shop.Leads.Entities;
+
+[EntityTypeConfiguration<LeadConfiguration, Lead>]
+public class Lead : Models.Lead
+{
+    public virtual Customer? Customer { get; set; }
+}

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

@@ -0,0 +1,26 @@
+namespace LiteCharms.Features.Shop.Leads.Entities;
+
+public class LeadConfiguration : IEntityTypeConfiguration<Lead>
+{
+    public void Configure(EntityTypeBuilder<Lead> builder)
+    {
+        builder.ToTable(nameof(Lead));
+
+        builder.HasKey(f => f.Id);
+        builder.Property(f => f.CreatedAt).ValueGeneratedOnAdd().HasDefaultValueSql("now()");
+        builder.Property(f => f.UpdatedAt).IsRequired(false);
+        builder.Property(f => f.CustomerId).IsRequired(false);
+        builder.Property(f => f.Source);
+        builder.Property(f => f.ClickId);
+        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);
+    }
+}

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

@@ -0,0 +1,36 @@
+namespace LiteCharms.Features.Shop.Leads.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? Source { get; set; }
+
+    public string? ClickId { 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; }
+}

LiteCharms.Features/Shop/Leads/Queries/GetCustomerLeadsQuery.cs

@@ -0,0 +1,30 @@
+using LiteCharms.Features.Shop.Leads.Models;
+
+namespace LiteCharms.Features.Leads.Queries;
+
+public class GetCustomerLeadsQuery : IRequest<Result<Lead[]>>
+{
+    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);
+    }
+}

LiteCharms.Features/Shop/Leads/Queries/GetLeadsQuery.cs

@@ -0,0 +1,30 @@
+using LiteCharms.Features.Shop.Leads.Models;
+
+namespace LiteCharms.Features.Leads.Queries;
+
+public class GetLeadsQuery : IRequest<Result<Lead[]>>
+{
+    public DateOnly From { get; set; }
+
+    public DateOnly To { get; set; }
+
+    public int MaxRecords { get; set; }
+
+    private GetLeadsQuery(DateOnly from, DateOnly to, int maxRecords = 1000)
+    {
+        From = from;
+        To = to;
+        MaxRecords = maxRecords;
+    }
+
+    public static GetLeadsQuery Create(DateOnly from, DateOnly to, int maxRecords = 1000)
+    {
+        if (from > to)
+            throw new ArgumentException("From date cannot be greater than To date.");
+
+        if(maxRecords <= 0)
+            throw new ArgumentException("MaxRecords must be a positive integer.");
+
+        return new(from, to, maxRecords);
+    }
+}

LiteCharms.Features/Shop/Leads/Queries/Handlers/GetCustomerLeadsQueryHandler.cs

@@ -0,0 +1,33 @@
+using LiteCharms.Extensions;
+using LiteCharms.Features.Shop.Leads.Models;
+using LiteCharms.Features.Shop.Postgres;
+
+namespace LiteCharms.Features.Leads.Queries.Handlers;
+
+public class GetCustomerLeadsQueryHandler(IDbContextFactory<ShopDbContext> contextFactory) : IRequestHandler<GetCustomerLeadsQuery, Result<Lead[]>>
+{
+    public async ValueTask<Result<Lead[]>> 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<Lead[]>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+}

LiteCharms.Features/Shop/Leads/Queries/Handlers/GetLeadsQueryHandler.cs

@@ -0,0 +1,33 @@
+using LiteCharms.Extensions;
+using LiteCharms.Features.Shop.Leads.Models;
+using LiteCharms.Features.Shop.Postgres;
+
+namespace LiteCharms.Features.Leads.Queries.Handlers;
+
+public class GetLeadsQueryHandler(IDbContextFactory<ShopDbContext> contextFactory) : IRequestHandler<GetLeadsQuery, Result<Lead[]>>
+{
+    public async ValueTask<Result<Lead[]>> 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)
+                .Take(request.MaxRecords)
+                .ToArrayAsync(cancellationToken);
+
+            return leads?.Length > 0 
+                ? Result.Ok(leads.Select(l => l.ToModel()).ToArray()) 
+                : Result.Fail(new Error($"No leads found for the specified date range {request.From} to {request.To}."));
+        }
+		catch (Exception ex)
+		{
+            return Result.Fail(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+}