Added Customer, Contact and Address with Service

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