Added shared projects

2026-05-03 16:10:27 +02:00
parent 66c08dc54b
commit 1b997013bb
81 changed files with 4507 additions and 1 deletions
@@ -0,0 +1,49 @@
+namespace LiteCharms.Features.Leads.Commands;
+
+public class CreateLeadCommand : IRequest<Result<Guid>>
+{
+    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);
+    }
+}
@@ -0,0 +1,46 @@
+using LiteCharms.Features.Utilities.Commands;
+using LiteCharms.Infrastructure.Database;
+
+namespace LiteCharms.Features.Leads.Commands.Handlers;
+
+public class CreateLeadCommandHandler(IDbContextFactory<LeadGeneratorDbContext> contextFactory, ISender mediator) : IRequestHandler<CreateLeadCommand, Result<Guid>>
+{
+    public async ValueTask<Result<Guid>> 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<Guid>(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<Guid>(new Error($"Failed to create lead -> Google ClickId: {request.GoogleClickId}, App ClickId: {request.AppClickId}, Web ClickId: {request.WebClickId}"));
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail<Guid>(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+}
@@ -0,0 +1,29 @@
+using LiteCharms.Infrastructure.Database;
+
+namespace LiteCharms.Features.Leads.Commands.Handlers;
+
+public class UpdateLeadCommandHandler(IDbContextFactory<LeadGeneratorDbContext> 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));
+        }
+    }
+}
@@ -0,0 +1,27 @@
+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);
+    }
+}
@@ -0,0 +1,30 @@
+using LiteCharms.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);
+    }
+}
@@ -0,0 +1,24 @@
+using LiteCharms.Models;
+
+namespace LiteCharms.Features.Leads.Queries;
+
+public class GetLeadsQuery : IRequest<Result<Lead[]>>
+{
+    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);
+    }
+}
@@ -0,0 +1,33 @@
+using LiteCharms.Extensions;
+using LiteCharms.Infrastructure.Database;
+using LiteCharms.Models;
+
+namespace LiteCharms.Features.Leads.Queries.Handlers;
+
+public class GetCustomerLeadsQueryHandler(IDbContextFactory<LeadGeneratorDbContext> 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));
+        }
+    }
+}
@@ -0,0 +1,32 @@
+using LiteCharms.Extensions;
+using LiteCharms.Infrastructure.Database;
+using LiteCharms.Models;
+
+namespace LiteCharms.Features.Leads.Queries.Handlers;
+
+public class GetLeadsQueryHandler(IDbContextFactory<LeadGeneratorDbContext> 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)
+                .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));
+        }
+    }
+}