Customer service: extract Customer bounded context from monolith (.NET 10)

src/Services/Customer/Customer.API/Controllers/CustomerController.cs

@@ -1,29 +1,165 @@
+using Customer.API.ViewModels;
+using Customer.Infrastructure.Data;
+using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using CustomerEntity = Customer.Domain.Entities.Customer;
+using GenderEnum = Customer.Domain.Entities.Gender;
 
 namespace Customer.API.Controllers;
 
 [ApiController]
-[Route("api/[controller]")]
+[Authorize]
+[Produces("application/json")]
 public class CustomerController : ControllerBase
 {
+    private readonly CustomerDbContext _dbContext;
     private readonly ILogger<CustomerController> _logger;
 
-    public CustomerController(ILogger<CustomerController> logger)
+    public CustomerController(CustomerDbContext dbContext, ILogger<CustomerController> logger)
     {
+        _dbContext = dbContext;
         _logger = logger;
     }
 
-    [HttpGet]
-    public IActionResult GetAll()
+    // External: GET /api/customers  ->  service GET /
+    [HttpGet("/")]
+    [ProducesResponseType(typeof(IEnumerable<CustomerVM>), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+    public async Task<ActionResult<IEnumerable<CustomerVM>>> GetAll()
     {
-        // TODO: Implement — migrate logic from monolith's CustomerController
-        return Ok(new { service = "Customer", status = "scaffold" });
+        var customers = await _dbContext.Customers
+            .OrderBy(c => c.Name)
+            .ToListAsync();
+
+        return Ok(customers.Select(ToViewModel));
+    }
+
+    // External: GET /api/customers/{id}  ->  service GET /{id}
+    [HttpGet("/{id:int}")]
+    [ProducesResponseType(typeof(CustomerVM), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+    public async Task<ActionResult<CustomerVM>> GetById(int id)
+    {
+        var customer = await _dbContext.Customers.FindAsync(id);
+        if (customer == null)
+            return NotFound();
+
+        return Ok(ToViewModel(customer));
+    }
+
+    // External: POST /api/customers  ->  service POST /
+    [HttpPost("/")]
+    [ProducesResponseType(typeof(CustomerVM), StatusCodes.Status201Created)]
+    [ProducesResponseType(StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+    public async Task<ActionResult<CustomerVM>> Create([FromBody] CustomerVM model)
+    {
+        if (string.IsNullOrWhiteSpace(model.Name))
+            ModelState.AddModelError(nameof(model.Name), "Customer name cannot be empty");
+        if (string.IsNullOrWhiteSpace(model.Email))
+            ModelState.AddModelError(nameof(model.Email), "Email cannot be empty");
+        if (string.IsNullOrWhiteSpace(model.Gender))
+            ModelState.AddModelError(nameof(model.Gender), "Gender cannot be empty");
+        else if (!Enum.TryParse<GenderEnum>(model.Gender, ignoreCase: true, out var parsedGender) || !Enum.IsDefined(parsedGender))
+            ModelState.AddModelError(nameof(model.Gender), "Invalid gender value");
+        if (!ModelState.IsValid)
+            return BadRequest(ModelState);
+
+        var customer = new CustomerEntity
+        {
+            Name = model.Name!,
+            Email = model.Email!,
+            PhoneNumber = model.PhoneNumber,
+            Address = model.Address,
+            City = model.City,
+            Gender = ParseGender(model.Gender),
+            CreatedBy = CurrentUser(),
+            UpdatedBy = CurrentUser(),
+            CreatedDate = DateTime.UtcNow,
+            UpdatedDate = DateTime.UtcNow
+        };
+
+        _dbContext.Customers.Add(customer);
+        await _dbContext.SaveChangesAsync();
+
+        var vm = ToViewModel(customer);
+        return CreatedAtAction(nameof(GetById), new { id = customer.Id }, vm);
+    }
+
+    // External: PUT /api/customers/{id}  ->  service PUT /{id}
+    [HttpPut("/{id:int}")]
+    [ProducesResponseType(StatusCodes.Status204NoContent)]
+    [ProducesResponseType(StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+    public async Task<IActionResult> Update(int id, [FromBody] CustomerVM model)
+    {
+        var customer = await _dbContext.Customers.FindAsync(id);
+        if (customer == null)
+            return NotFound();
+
+        if (string.IsNullOrWhiteSpace(model.Name))
+            ModelState.AddModelError(nameof(model.Name), "Customer name cannot be empty");
+        if (string.IsNullOrWhiteSpace(model.Email))
+            ModelState.AddModelError(nameof(model.Email), "Email cannot be empty");
+        if (string.IsNullOrWhiteSpace(model.Gender))
+            ModelState.AddModelError(nameof(model.Gender), "Gender cannot be empty");
+        else if (!Enum.TryParse<GenderEnum>(model.Gender, ignoreCase: true, out var parsedGender) || !Enum.IsDefined(parsedGender))
+            ModelState.AddModelError(nameof(model.Gender), "Invalid gender value");
+        if (!ModelState.IsValid)
+            return BadRequest(ModelState);
+
+        customer.Name = model.Name!;
+        customer.Email = model.Email!;
+        customer.PhoneNumber = model.PhoneNumber;
+        customer.Address = model.Address;
+        customer.City = model.City;
+        customer.Gender = ParseGender(model.Gender);
+        customer.UpdatedBy = CurrentUser();
+        customer.UpdatedDate = DateTime.UtcNow;
+
+        await _dbContext.SaveChangesAsync();
+        return NoContent();
+    }
+
+    // External: DELETE /api/customers/{id}  ->  service DELETE /{id}
+    [HttpDelete("/{id:int}")]
+    [ProducesResponseType(StatusCodes.Status204NoContent)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+    public async Task<IActionResult> Delete(int id)
+    {
+        var customer = await _dbContext.Customers.FindAsync(id);
+        if (customer == null)
+            return NotFound();
+
+        _dbContext.Customers.Remove(customer);
+        await _dbContext.SaveChangesAsync();
+        return NoContent();
     }
 
-    [HttpGet("{id}")]
-    public IActionResult GetById(int id)
+    private static CustomerVM ToViewModel(CustomerEntity c) => new()
+    {
+        Id = c.Id,
+        Name = c.Name,
+        Email = c.Email,
+        PhoneNumber = c.PhoneNumber,
+        Address = c.Address,
+        City = c.City,
+        Gender = c.Gender.ToString()
+    };
+
+    private static GenderEnum ParseGender(string? value) =>
+        Enum.TryParse<GenderEnum>(value, ignoreCase: true, out var gender) ? gender : GenderEnum.None;
+
+    // CreatedBy/UpdatedBy column is varchar(40); truncate the JWT identity to fit.
+    private string? CurrentUser()
     {
-        // TODO: Implement — migrate logic from monolith
-        return Ok(new { service = "Customer", id });
+        var name = User.Identity?.Name;
+        if (string.IsNullOrEmpty(name))
+            return null;
+        return name.Length > 40 ? name[..40] : name;
     }
 }

src/Services/Customer/Customer.API/Customer.API.csproj

@@ -7,10 +7,9 @@
   <ItemGroup>
     <ProjectReference Include="..\Customer.Domain\Customer.Domain.csproj" />
     <ProjectReference Include="..\Customer.Infrastructure\Customer.Infrastructure.csproj" />
-    <ProjectReference Include="..\..\Shared\Shared.Contracts\Shared.Contracts.csproj" />
-    <ProjectReference Include="..\..\Shared\Shared.Infrastructure\Shared.Infrastructure.csproj" />
   </ItemGroup>
   <ItemGroup>
+    <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="10.*" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="10.*" />
     <PackageReference Include="Swashbuckle.AspNetCore" Version="7.*" />
   </ItemGroup>

src/Services/Customer/Customer.API/Dockerfile

@@ -7,8 +7,6 @@ WORKDIR /src
 COPY ["Services/Customer/Customer.API/Customer.API.csproj", "Services/Customer/Customer.API/"]
 COPY ["Services/Customer/Customer.Domain/Customer.Domain.csproj", "Services/Customer/Customer.Domain/"]
 COPY ["Services/Customer/Customer.Infrastructure/Customer.Infrastructure.csproj", "Services/Customer/Customer.Infrastructure/"]
-COPY ["Shared/Shared.Contracts/Shared.Contracts.csproj", "Shared/Shared.Contracts/"]
-COPY ["Shared/Shared.Infrastructure/Shared.Infrastructure.csproj", "Shared/Shared.Infrastructure/"]
 RUN dotnet restore "Services/Customer/Customer.API/Customer.API.csproj"
 COPY . .
 WORKDIR "/src/Services/Customer/Customer.API"

src/Services/Customer/Customer.API/Program.cs

@@ -1,24 +1,93 @@
+using System.Text;
 using Customer.Infrastructure.Data;
+using Microsoft.AspNetCore.Authentication.JwtBearer;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.IdentityModel.Tokens;
+using Microsoft.OpenApi.Models;
 
 var builder = WebApplication.CreateBuilder(args);
 
 builder.Services.AddControllers();
 builder.Services.AddEndpointsApiExplorer();
-builder.Services.AddSwaggerGen();
+builder.Services.AddSwaggerGen(options =>
+{
+    options.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
+    {
+        Name = "Authorization",
+        Type = SecuritySchemeType.Http,
+        Scheme = "bearer",
+        BearerFormat = "JWT",
+        In = ParameterLocation.Header,
+        Description = "Enter the JWT bearer token issued by the Identity service."
+    });
+    options.AddSecurityRequirement(new OpenApiSecurityRequirement
+    {
+        {
+            new OpenApiSecurityScheme
+            {
+                Reference = new OpenApiReference { Type = ReferenceType.SecurityScheme, Id = "Bearer" }
+            },
+            Array.Empty<string>()
+        }
+    });
+});
 builder.Services.AddHealthChecks();
 
 builder.Services.AddDbContext<CustomerDbContext>(options =>
     options.UseNpgsql(builder.Configuration.GetConnectionString("DefaultConnection")));
 
+var jwtSection = builder.Configuration.GetSection("Jwt");
+builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
+    .AddJwtBearer(options =>
+    {
+        options.MapInboundClaims = false;
+        options.TokenValidationParameters = new TokenValidationParameters
+        {
+            ValidateIssuer = true,
+            ValidateAudience = true,
+            ValidateLifetime = true,
+            ValidateIssuerSigningKey = true,
+            ValidIssuer = jwtSection["Issuer"],
+            ValidAudience = jwtSection["Audience"],
+            IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(jwtSection["Key"]!)),
+            NameClaimType = "name",
+            RoleClaimType = "role"
+        };
+    });
+builder.Services.AddAuthorization();
+
 var app = builder.Build();
 
+using (var scope = app.Services.CreateScope())
+{
+    var db = scope.ServiceProvider.GetRequiredService<CustomerDbContext>();
+    var logger = scope.ServiceProvider.GetRequiredService<ILoggerFactory>().CreateLogger("Startup");
+
+    const int maxAttempts = 12;
+    for (var attempt = 1; ; attempt++)
+    {
+        try
+        {
+            db.Database.EnsureCreated();
+            break;
+        }
+        catch (Exception ex) when (attempt < maxAttempts)
+        {
+            logger.LogWarning(ex, "Database not ready (attempt {Attempt}/{Max}); retrying in 5s...", attempt, maxAttempts);
+            Thread.Sleep(TimeSpan.FromSeconds(5));
+        }
+    }
+}
+
 if (app.Environment.IsDevelopment())
 {
     app.UseSwagger();
     app.UseSwaggerUI();
 }
 
+app.UseAuthentication();
+app.UseAuthorization();
+
 app.MapControllers();
 app.MapHealthChecks("/healthz");
 

src/Services/Customer/Customer.API/ViewModels/CustomerVM.cs

@@ -0,0 +1,12 @@
+namespace Customer.API.ViewModels;
+
+public class CustomerVM
+{
+    public int Id { get; set; }
+    public string? Name { get; set; }
+    public string? Email { get; set; }
+    public string? PhoneNumber { get; set; }
+    public string? Address { get; set; }
+    public string? City { get; set; }
+    public string? Gender { get; set; }
+}

src/Services/Customer/Customer.API/appsettings.json

@@ -7,5 +7,10 @@
   },
   "ConnectionStrings": {
     "DefaultConnection": "Host=localhost;Database=customerdb;Username=postgres;Password=postgres"
+  },
+  "Jwt": {
+    "Key": "quickapp-dev-only-signing-key-change-me-please-32+chars",
+    "Issuer": "quickapp-identity",
+    "Audience": "quickapp"
   }
 }

src/Services/Customer/Customer.Domain/Entities/BaseEntity.cs

@@ -0,0 +1,18 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Customer.Domain.Entities;
+
+public class BaseEntity
+{
+    public int Id { get; set; }
+
+    [MaxLength(40)]
+    public string? CreatedBy { get; set; }
+
+    [MaxLength(40)]
+    public string? UpdatedBy { get; set; }
+
+    public DateTime UpdatedDate { get; set; }
+
+    public DateTime CreatedDate { get; set; }
+}

src/Services/Customer/Customer.Domain/Entities/Customer.cs

@@ -0,0 +1,11 @@
+namespace Customer.Domain.Entities;
+
+public class Customer : BaseEntity
+{
+    public required string Name { get; set; }
+    public required string Email { get; set; }
+    public string? PhoneNumber { get; set; }
+    public string? Address { get; set; }
+    public string? City { get; set; }
+    public Gender Gender { get; set; }
+}

src/Services/Customer/Customer.Domain/Entities/Gender.cs

@@ -0,0 +1,8 @@
+namespace Customer.Domain.Entities;
+
+public enum Gender
+{
+    None,
+    Female,
+    Male
+}

src/Services/Customer/Customer.Infrastructure/Data/CustomerDbContext.cs

@@ -1,4 +1,5 @@
 using Microsoft.EntityFrameworkCore;
+using CustomerEntity = Customer.Domain.Entities.Customer;
 
 namespace Customer.Infrastructure.Data;
 
@@ -8,9 +9,17 @@ public CustomerDbContext(DbContextOptions<CustomerDbContext> options) : base(opt
     {
     }
 
+    public DbSet<CustomerEntity> Customers => Set<CustomerEntity>();
+
     protected override void OnModelCreating(ModelBuilder modelBuilder)
     {
         base.OnModelCreating(modelBuilder);
-        // TODO: Configure entity mappings migrated from monolith
+
+        modelBuilder.Entity<CustomerEntity>().Property(c => c.Name).IsRequired().HasMaxLength(100);
+        modelBuilder.Entity<CustomerEntity>().HasIndex(c => c.Name);
+        modelBuilder.Entity<CustomerEntity>().Property(c => c.Email).HasMaxLength(100);
+        modelBuilder.Entity<CustomerEntity>().Property(c => c.PhoneNumber).IsUnicode(false).HasMaxLength(30);
+        modelBuilder.Entity<CustomerEntity>().Property(c => c.City).HasMaxLength(50);
+        modelBuilder.Entity<CustomerEntity>().ToTable("AppCustomers");
     }
 }