DATA-2: new schema entities + Minimal API endpoints + Scalar + DAL teardown

- Entities: Breeder->Contact, +Enclosure/ColorVariety/GerbilPhoto/HealthRecord/WeightRecord;
  Gerbil expanded (single Genotype text col, Status/Gender enums-as-string, FK ids,
  ImportSource/ExternalRef provenance); Litter Strength->TotalBorn +ExpectedGoHomeDate/Notes.
  ColorVariety HasData seed = 18 from GEN-1 catalog. Gerbil<->Litter cycle handled
  (SetNull/Restrict). Enums stored as strings.
- Minimal API (no controllers): Endpoints/*.cs MapGroup+TypedResults for gerbils, litters,
  contacts, enclosures, color-varieties, health/weight-records, inbreeding (converted from
  controller, same routes/shapes), photos (Oscar contract: GET array/POST multipart/DELETE,
  url /photos/files/{fileName}). Gridify paged {items,totalCount,page,pageSize}, camelCase,
  409 conflict-deletes, flat FK ids, litter parent-gender validation (400 {code,...}).
- Scalar replaces Swashbuckle (AddOpenApi/MapOpenApi + MapScalarApiReference at /scalar);
  launchUrl swagger->scalar. GenericRepository/UnitOfWork/Converters deleted; DbContext direct.
- InbreedingService reads real FK props now; pure calculator + 8 tests untouched.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

GerbilManagerWebAPI/Endpoints/PhotoEndpoints.cs

@@ -0,0 +1,104 @@
+using GerbilManagerWebAPI.Dtos;
+using GerbilManagerWebAPI.Models;
+using Microsoft.AspNetCore.Http.HttpResults;
+using Microsoft.EntityFrameworkCore;
+
+namespace GerbilManagerWebAPI.Endpoints
+{
+    /// <summary>
+    /// Gerbil photo endpoints (FEAT-1b phase 2), per the contract agreed with Oscar:
+    ///   GET  /gerbils/{id}/photos      -> plain array (not paged)
+    ///   POST /gerbils/{id}/photos      -> multipart 'file' + optional 'caption' -> 201 PhotoDto
+    ///   DELETE /photos/{id}            -> 204
+    ///   GET  /photos/files/{fileName}  -> the image bytes
+    /// url = "/photos/files/{fileName}"; profile photo = first by SortOrder.
+    /// </summary>
+    public static class PhotoEndpoints
+    {
+        public static IEndpointRouteBuilder MapPhotoEndpoints(this IEndpointRouteBuilder app)
+        {
+            app.MapGet("/gerbils/{id:guid}/photos",
+                async Task<Results<Ok<List<PhotoDto>>, NotFound>> (Guid id, ApplicationContext db) =>
+                {
+                    if (!await db.Gerbils.AnyAsync(g => g.Id == id)) return TypedResults.NotFound();
+                    var photos = await db.GerbilPhotos.AsNoTracking()
+                        .Where(p => p.GerbilId == id)
+                        .OrderBy(p => p.SortOrder)
+                        .ToListAsync();
+                    return TypedResults.Ok(photos.Select(ToDto).ToList());
+                }).WithTags("Photos");
+
+            app.MapPost("/gerbils/{id:guid}/photos",
+                async Task<Results<Created<PhotoDto>, NotFound, BadRequest<string>>> (
+                    Guid id, IFormFile file, [Microsoft.AspNetCore.Mvc.FromForm] string? caption,
+                    ApplicationContext db, IConfiguration config, IWebHostEnvironment env) =>
+                {
+                    if (!await db.Gerbils.AnyAsync(g => g.Id == id)) return TypedResults.NotFound();
+                    if (file is null || file.Length == 0) return TypedResults.BadRequest("No file uploaded.");
+
+                    var ext = Path.GetExtension(file.FileName);
+                    var fileName = $"{Guid.NewGuid():N}{ext}";
+                    var root = PhotoRoot(config, env);
+                    Directory.CreateDirectory(root);
+                    await using (var stream = File.Create(Path.Combine(root, fileName)))
+                        await file.CopyToAsync(stream);
+
+                    int nextSort = (await db.GerbilPhotos.Where(p => p.GerbilId == id)
+                        .Select(p => (int?)p.SortOrder).MaxAsync() ?? -1) + 1;
+
+                    var photo = new GerbilPhoto
+                    {
+                        Id = Guid.NewGuid(),
+                        GerbilId = id,
+                        FileName = fileName,
+                        Caption = caption,
+                        SortOrder = nextSort,
+                        CreatedAt = DateTimeOffset.UtcNow,
+                    };
+                    db.GerbilPhotos.Add(photo);
+                    await db.SaveChangesAsync();
+                    return TypedResults.Created($"/photos/{photo.Id}", ToDto(photo));
+                }).WithTags("Photos").DisableAntiforgery();
+
+            app.MapDelete("/photos/{id:guid}",
+                async Task<Results<NoContent, NotFound>> (Guid id, ApplicationContext db, IConfiguration config, IWebHostEnvironment env) =>
+                {
+                    var photo = await db.GerbilPhotos.FirstOrDefaultAsync(p => p.Id == id);
+                    if (photo is null) return TypedResults.NotFound();
+                    var path = Path.Combine(PhotoRoot(config, env), photo.FileName);
+                    if (File.Exists(path)) File.Delete(path);
+                    db.GerbilPhotos.Remove(photo);
+                    await db.SaveChangesAsync();
+                    return TypedResults.NoContent();
+                }).WithTags("Photos");
+
+            app.MapGet("/photos/files/{fileName}",
+                Results<PhysicalFileHttpResult, NotFound, BadRequest<string>> (string fileName, IConfiguration config, IWebHostEnvironment env) =>
+                {
+                    // guard against path traversal: only a bare file name is allowed
+                    if (fileName.Contains('/') || fileName.Contains('\\') || fileName.Contains(".."))
+                        return TypedResults.BadRequest("Invalid file name.");
+                    var path = Path.Combine(PhotoRoot(config, env), fileName);
+                    if (!File.Exists(path)) return TypedResults.NotFound();
+                    return TypedResults.PhysicalFile(path, ContentType(fileName));
+                }).WithTags("Photos");
+
+            return app;
+        }
+
+        private static string PhotoRoot(IConfiguration config, IWebHostEnvironment env) =>
+            config["Photos:RootPath"] ?? Path.Combine(env.ContentRootPath, "photo-storage");
+
+        private static string ContentType(string fileName) => Path.GetExtension(fileName).ToLowerInvariant() switch
+        {
+            ".png" => "image/png",
+            ".gif" => "image/gif",
+            ".webp" => "image/webp",
+            ".bmp" => "image/bmp",
+            _ => "image/jpeg",
+        };
+
+        private static PhotoDto ToDto(GerbilPhoto p) =>
+            new(p.Id, p.FileName, p.Caption, p.SortOrder, $"/photos/files/{p.FileName}");
+    }
+}