DTO updates

src/Core/API/API.Core/API.Core.csproj

@@ -31,6 +31,7 @@
         <ProjectReference Include="..\..\Infrastructure\Infrastructure.Repository\Infrastructure.Repository.csproj" />
         <ProjectReference Include="..\..\Infrastructure\Infrastructure.Jwt\Infrastructure.Jwt.csproj" />
         <ProjectReference Include="..\..\Service\Service.Auth\Service.Auth.csproj" />
+        <ProjectReference Include="..\..\Service\Service.Breweries\Service.Breweries.csproj" />
         <ProjectReference Include="..\..\Service\Service.UserManagement\Service.UserManagement.csproj" />
     </ItemGroup>
 

src/Core/API/API.Core/Contracts/Breweries/BreweryCreateRequestValidator.cs

@@ -0,0 +1,50 @@
+using FluentValidation;
+
+namespace API.Core.Contracts.Breweries;
+
+public class BreweryCreateDtoValidator : AbstractValidator<BreweryCreateDto>
+{
+    public BreweryCreateDtoValidator()
+    {
+        RuleFor(x => x.PostedById)
+            .NotEmpty()
+            .WithMessage("PostedById is required.");
+
+        RuleFor(x => x.BreweryName)
+            .NotEmpty()
+            .WithMessage("Brewery name is required.")
+            .MaximumLength(256)
+            .WithMessage("Brewery name cannot exceed 256 characters.");
+
+        RuleFor(x => x.Description)
+            .NotEmpty()
+            .WithMessage("Description is required.")
+            .MaximumLength(512)
+            .WithMessage("Description cannot exceed 512 characters.");
+
+        RuleFor(x => x.Location)
+            .NotNull()
+            .WithMessage("Location is required.");
+
+        RuleFor(x => x.Location.CityId)
+            .NotEmpty()
+            .When(x => x.Location is not null)
+            .WithMessage("CityId is required.");
+
+        RuleFor(x => x.Location.AddressLine1)
+            .NotEmpty()
+            .When(x => x.Location is not null)
+            .WithMessage("Address line 1 is required.")
+            .MaximumLength(256)
+            .When(x => x.Location is not null)
+            .WithMessage("Address line 1 cannot exceed 256 characters.");
+
+        RuleFor(x => x.Location.PostalCode)
+            .NotEmpty()
+            .When(x => x.Location is not null)
+            .WithMessage("Postal code is required.")
+            .MaximumLength(20)
+            .When(x => x.Location is not null)
+            .WithMessage("Postal code cannot exceed 20 characters.");
+    }
+}

src/Core/API/API.Core/Contracts/Breweries/BreweryDto.cs

@@ -0,0 +1,41 @@
+namespace API.Core.Contracts.Breweries;
+
+public class BreweryLocationCreateDto
+{
+    public Guid CityId { get; set; }
+    public string AddressLine1 { get; set; } = string.Empty;
+    public string? AddressLine2 { get; set; }
+    public string PostalCode { get; set; } = string.Empty;
+    public byte[]? Coordinates { get; set; }
+}
+
+public class BreweryLocationDto
+{
+    public Guid BreweryPostLocationId { get; set; }
+    public Guid BreweryPostId { get; set; }
+    public Guid CityId { get; set; }
+    public string AddressLine1 { get; set; } = string.Empty;
+    public string? AddressLine2 { get; set; }
+    public string PostalCode { get; set; } = string.Empty;
+    public byte[]? Coordinates { get; set; }
+}
+
+public class BreweryCreateDto
+{
+    public Guid PostedById { get; set; }
+    public string BreweryName { get; set; } = string.Empty;
+    public string Description { get; set; } = string.Empty;
+    public BreweryLocationCreateDto Location { get; set; } = null!;
+}
+
+public class BreweryDto
+{
+    public Guid BreweryPostId { get; set; }
+    public Guid PostedById { get; set; }
+    public string BreweryName { get; set; } = string.Empty;
+    public string Description { get; set; } = string.Empty;
+    public DateTime CreatedAt { get; set; }
+    public DateTime? UpdatedAt { get; set; }
+    public byte[]? Timer { get; set; }
+    public BreweryLocationDto? Location { get; set; }
+}

src/Core/API/API.Core/Controllers/AuthController.cs

@@ -86,6 +86,13 @@ namespace API.Core.Controllers
             );
         }
 
+        [HttpPost("confirm/resend")]
+        public async Task<ActionResult> ResendConfirmation([FromQuery] Guid userId)
+        {
+            await confirmationService.ResendConfirmationEmailAsync(userId);
+            return Ok(new ResponseBody { Message = "confirmation email has been resent" });
+        }
+
         [AllowAnonymous]
         [HttpPost("refresh")]
         public async Task<ActionResult> Refresh(

src/Core/API/API.Core/Controllers/BreweryController.cs

@@ -0,0 +1,129 @@
+using API.Core.Contracts.Breweries;
+using API.Core.Contracts.Common;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Service.Breweries;
+
+namespace API.Core.Controllers;
+
+[ApiController]
+[Route("api/[controller]")]
+[Authorize(AuthenticationSchemes = "JWT")]
+public class BreweryController(IBreweryService breweryService) : ControllerBase
+{
+    [AllowAnonymous]
+    [HttpGet("{id:guid}")]
+    public async Task<ActionResult<ResponseBody<BreweryDto>>> GetById(Guid id)
+    {
+        var brewery = await breweryService.GetByIdAsync(id);
+        if (brewery is null)
+            return NotFound(new ResponseBody { Message = $"Brewery with ID {id} not found." });
+
+        return Ok(new ResponseBody<BreweryDto>
+        {
+            Message = "Brewery retrieved successfully.",
+            Payload = MapToDto(brewery),
+        });
+    }
+
+    [AllowAnonymous]
+    [HttpGet]
+    public async Task<ActionResult<ResponseBody<IEnumerable<BreweryDto>>>> GetAll(
+        [FromQuery] int? limit,
+        [FromQuery] int? offset)
+    {
+        var breweries = await breweryService.GetAllAsync(limit, offset);
+        return Ok(new ResponseBody<IEnumerable<BreweryDto>>
+        {
+            Message = "Breweries retrieved successfully.",
+            Payload = breweries.Select(MapToDto),
+        });
+    }
+
+    [HttpPost]
+    public async Task<ActionResult<ResponseBody<BreweryDto>>> Create([FromBody] BreweryCreateDto dto)
+    {
+        var request = new BreweryCreateRequest(
+            dto.PostedById,
+            dto.BreweryName,
+            dto.Description,
+            new BreweryLocationCreateRequest(
+                dto.Location.CityId,
+                dto.Location.AddressLine1,
+                dto.Location.AddressLine2,
+                dto.Location.PostalCode,
+                dto.Location.Coordinates
+            )
+        );
+
+        var result = await breweryService.CreateAsync(request);
+        if (!result.Success)
+            return BadRequest(new ResponseBody { Message = result.Message });
+
+        return Created($"/api/brewery/{result.Brewery.BreweryPostId}", new ResponseBody<BreweryDto>
+        {
+            Message = "Brewery created successfully.",
+            Payload = MapToDto(result.Brewery),
+        });
+    }
+
+    [HttpPut("{id:guid}")]
+    public async Task<ActionResult<ResponseBody<BreweryDto>>> Update(Guid id, [FromBody] BreweryDto dto)
+    {
+        if (dto.BreweryPostId != id)
+            return BadRequest(new ResponseBody { Message = "Route ID does not match payload ID." });
+
+        var request = new BreweryUpdateRequest(
+            dto.BreweryPostId,
+            dto.PostedById,
+            dto.BreweryName,
+            dto.Description,
+            dto.Location is null ? null : new BreweryLocationUpdateRequest(
+                dto.Location.BreweryPostLocationId,
+                dto.Location.CityId,
+                dto.Location.AddressLine1,
+                dto.Location.AddressLine2,
+                dto.Location.PostalCode,
+                dto.Location.Coordinates
+            )
+        );
+
+        var result = await breweryService.UpdateAsync(request);
+        if (!result.Success)
+            return BadRequest(new ResponseBody { Message = result.Message });
+
+        return Ok(new ResponseBody<BreweryDto>
+        {
+            Message = "Brewery updated successfully.",
+            Payload = MapToDto(result.Brewery),
+        });
+    }
+
+    [HttpDelete("{id:guid}")]
+    public async Task<ActionResult<ResponseBody>> Delete(Guid id)
+    {
+        await breweryService.DeleteAsync(id);
+        return Ok(new ResponseBody { Message = "Brewery deleted successfully." });
+    }
+
+    private static BreweryDto MapToDto(Domain.Entities.BreweryPost b) => new()
+    {
+        BreweryPostId = b.BreweryPostId,
+        PostedById = b.PostedById,
+        BreweryName = b.BreweryName,
+        Description = b.Description,
+        CreatedAt = b.CreatedAt,
+        UpdatedAt = b.UpdatedAt,
+        Timer = b.Timer,
+        Location = b.Location is null ? null : new BreweryLocationDto
+        {
+            BreweryPostLocationId = b.Location.BreweryPostLocationId,
+            BreweryPostId = b.Location.BreweryPostId,
+            CityId = b.Location.CityId,
+            AddressLine1 = b.Location.AddressLine1,
+            AddressLine2 = b.Location.AddressLine2,
+            PostalCode = b.Location.PostalCode,
+            Coordinates = b.Location.Coordinates,
+        },
+    };
+}

src/Core/Core.slnx

@@ -26,6 +26,7 @@
         <Project Path="Service/Service.Auth.Tests/Service.Auth.Tests.csproj" />
         <Project Path="Service/Service.Emails/Service.Emails.csproj" />
         <Project Path="Service/Service.UserManagement/Service.UserManagement.csproj" />
-        <Project Path="Service\Service.Auth\Service.Auth.csproj" />
+        <Project Path="Service/Service.Auth/Service.Auth.csproj" />
+        <Project Path="Service/Service.Breweries/Service.Breweries.csproj" />
     </Folder>
 </Solution>

src/Core/Infrastructure/Infrastructure.Repository.Tests/Auth/AuthRepository.test.cs

@@ -17,10 +17,34 @@ public class AuthRepositoryTest
         var conn = new MockDbConnection();
 
         conn.Mocks.When(cmd => cmd.CommandText == "USP_RegisterUser")
+            .ReturnsScalar(expectedUserId);
+
+        // Mock the subsequent read for the newly created user by id
+        conn.Mocks.When(cmd => cmd.CommandText == "usp_GetUserAccountById")
             .ReturnsTable(
                 MockTable
-                    .WithColumns(("UserAccountId", typeof(Guid)))
+                    .WithColumns(
-                    .AddRow(expectedUserId)
+                        ("UserAccountId", typeof(Guid)),
+                        ("Username", typeof(string)),
+                        ("FirstName", typeof(string)),
+                        ("LastName", typeof(string)),
+                        ("Email", typeof(string)),
+                        ("CreatedAt", typeof(DateTime)),
+                        ("UpdatedAt", typeof(DateTime?)),
+                        ("DateOfBirth", typeof(DateTime)),
+                        ("Timer", typeof(byte[]))
+                    )
+                    .AddRow(
+                        expectedUserId,
+                        "testuser",
+                        "Test",
+                        "User",
+                        "test@example.com",
+                        DateTime.UtcNow,
+                        null,
+                        new DateTime(1990, 1, 1),
+                        null
+                    )
             );
 
         var repo = CreateRepo(conn);

src/Core/Infrastructure/Infrastructure.Repository/Auth/AuthRepository.cs

@@ -33,7 +33,37 @@ public class AuthRepository(ISqlConnectionFactory connectionFactory)
         AddParameter(command, "@Hash", passwordHash);
 
         var result = await command.ExecuteScalarAsync();
-        var userAccountId = result != null ? (Guid)result : Guid.Empty;
+
+        Guid userAccountId = Guid.Empty;
+        if (result != null && result != DBNull.Value)
+        {
+            if (result is Guid g)
+            {
+                userAccountId = g;
+            }
+            else if (result is string s && Guid.TryParse(s, out var parsed))
+            {
+                userAccountId = parsed;
+            }
+            else if (result is byte[] bytes && bytes.Length == 16)
+            {
+                userAccountId = new Guid(bytes);
+            }
+            else
+            {
+                // Fallback: try to convert and parse string representation
+                try
+                {
+                    var str = result.ToString();
+                    if (!string.IsNullOrEmpty(str) && Guid.TryParse(str, out var p))
+                        userAccountId = p;
+                }
+                catch
+                {
+                    userAccountId = Guid.Empty;
+                }
+            }
+        }
 
         return await GetUserByIdAsync(userAccountId) ?? throw new Exception("Failed to retrieve newly registered user.");
     }

src/Core/Infrastructure/Infrastructure.Repository/Breweries/BreweryRepository.cs

@@ -4,24 +4,10 @@ using Infrastructure.Repository.Sql;
 
 namespace Infrastructure.Repository.Breweries;
 
-public interface IBreweryRepository
+public class BreweryRepository(ISqlConnectionFactory connectionFactory)
+    : Repository<BreweryPost>(connectionFactory), IBreweryRepository
 {
-    Task<BreweryPost?> GetByIdAsync(Guid id);
+    private readonly ISqlConnectionFactory _connectionFactory = connectionFactory;
-    Task<IEnumerable<BreweryPost>> GetAllAsync(int? limit, int? offset);
-    Task UpdateAsync(BreweryPost brewery);
-    Task DeleteAsync(Guid id);
-    Task CreateAsync(BreweryPost brewery);
-}
-
-public class BreweryRepository : Repository<BreweryPost>, IBreweryRepository
-{
-    private readonly ISqlConnectionFactory _connectionFactory;
-
-    public BreweryRepository(ISqlConnectionFactory connectionFactory)
-        : base(connectionFactory)
-    {
-        _connectionFactory = connectionFactory;
-    }
 
     public async Task<BreweryPost?> GetByIdAsync(Guid id)
     {

src/Core/Infrastructure/Infrastructure.Repository/Breweries/IBreweryRepository.cs

@@ -0,0 +1,12 @@
+using Domain.Entities;
+
+namespace Infrastructure.Repository.Breweries;
+
+public interface IBreweryRepository
+{
+    Task<BreweryPost?> GetByIdAsync(Guid id);
+    Task<IEnumerable<BreweryPost>> GetAllAsync(int? limit, int? offset);
+    Task UpdateAsync(BreweryPost brewery);
+    Task DeleteAsync(Guid id);
+    Task CreateAsync(BreweryPost brewery);
+}

src/Core/Service/Service.Breweries.Tests/BreweryService.test.cs

@@ -0,0 +1,69 @@
+using FluentAssertions;
+using Xunit;
+using Service.Breweries;
+using API.Core.Contracts.Breweries;
+using Domain.Entities;
+
+namespace Service.Breweries.Tests;
+
+public class BreweryServiceTests
+{
+   private class FakeRepo : IBreweryRepository
+   {
+      public BreweryPost? Created;
+
+      public Task<BreweryPost?> GetByIdAsync(Guid id) => Task.FromResult<BreweryPost?>(null);
+      public Task<IEnumerable<BreweryPost>> GetAllAsync(int? limit, int? offset) => Task.FromResult<IEnumerable<BreweryPost>>(Array.Empty<BreweryPost>());
+      public Task UpdateAsync(BreweryPost brewery) { Created = brewery; return Task.CompletedTask; }
+      public Task DeleteAsync(Guid id) => Task.CompletedTask;
+      public Task CreateAsync(BreweryPost brewery) { Created = brewery; return Task.CompletedTask; }
+   }
+
+   [Fact]
+   public async Task CreateAsync_ReturnsFailure_WhenLocationMissing()
+   {
+      var repo = new FakeRepo();
+      var svc = new BreweryService(repo);
+
+      var dto = new BreweryCreateDto
+      {
+         PostedById = Guid.NewGuid(),
+         BreweryName = "X",
+         Description = "Y",
+         Location = null!
+      };
+
+      var result = await svc.CreateAsync(dto);
+      result.Success.Should().BeFalse();
+      result.Message.Should().Contain("Location");
+   }
+
+   [Fact]
+   public async Task CreateAsync_ReturnsSuccess_AndPersistsEntity()
+   {
+      var repo = new FakeRepo();
+      var svc = new BreweryService(repo);
+
+      var loc = new BreweryLocationCreateDto
+      {
+         CityId = Guid.NewGuid(),
+         AddressLine1 = "123 Main",
+         PostalCode = "12345"
+      };
+
+      var dto = new BreweryCreateDto
+      {
+         PostedById = Guid.NewGuid(),
+         BreweryName = "MyBrew",
+         Description = "Desc",
+         Location = loc
+      };
+
+      var result = await svc.CreateAsync(dto);
+
+      result.Success.Should().BeTrue();
+      repo.Created.Should().NotBeNull();
+      repo.Created!.BreweryName.Should().Be("MyBrew");
+      result.Brewery.BreweryName.Should().Be("MyBrew");
+   }
+}

src/Core/Service/Service.Breweries.Tests/Service.Breweries.Tests.csproj

@@ -0,0 +1,28 @@
+<Project Sdk="Microsoft.NET.Sdk">
+   <PropertyGroup>
+      <TargetFramework>net10.0</TargetFramework>
+      <ImplicitUsings>enable</ImplicitUsings>
+      <Nullable>enable</Nullable>
+      <IsPackable>false</IsPackable>
+      <RootNamespace>Service.Breweries.Tests</RootNamespace>
+   </PropertyGroup>
+
+   <ItemGroup>
+      <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.0.1" />
+      <PackageReference Include="xunit" Version="2.9.2" />
+      <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2" />
+      <PackageReference Include="FluentAssertions" Version="6.9.0" />
+   </ItemGroup>
+
+   <ItemGroup>
+      <Using Include="Xunit" />
+   </ItemGroup>
+
+   <ItemGroup>
+      <ProjectReference Include="..\Service.Breweries\Service.Breweries.csproj" />
+      <ProjectReference Include="..\Service.Auth\Service.Auth.csproj" />
+      <ProjectReference
+         Include="..\..\Infrastructure\Infrastructure.Repository\Infrastructure.Repository.csproj" />
+      <ProjectReference Include="..\..\API\API.Core\API.Core.csproj" />
+   </ItemGroup>
+</Project>

src/Core/Service/Service.Breweries/BreweryService.cs

@@ -0,0 +1,65 @@
+using Domain.Entities;
+using Infrastructure.Repository.Breweries;
+
+namespace Service.Breweries;
+
+public class BreweryService(IBreweryRepository repository) : IBreweryService
+{
+    public Task<BreweryPost?> GetByIdAsync(Guid id) =>
+        repository.GetByIdAsync(id);
+
+    public Task<IEnumerable<BreweryPost>> GetAllAsync(int? limit = null, int? offset = null) =>
+        repository.GetAllAsync(limit, offset);
+
+    public async Task<BreweryServiceReturn> CreateAsync(BreweryCreateRequest request)
+    {
+        var entity = new BreweryPost
+        {
+            BreweryPostId = Guid.NewGuid(),
+            PostedById = request.PostedById,
+            BreweryName = request.BreweryName,
+            Description = request.Description,
+            CreatedAt = DateTime.UtcNow,
+            Location = new BreweryPostLocation
+            {
+                BreweryPostLocationId = Guid.NewGuid(),
+                CityId = request.Location.CityId,
+                AddressLine1 = request.Location.AddressLine1,
+                AddressLine2 = request.Location.AddressLine2,
+                PostalCode = request.Location.PostalCode,
+                Coordinates = request.Location.Coordinates,
+            },
+        };
+
+        await repository.CreateAsync(entity);
+        return new BreweryServiceReturn(entity);
+    }
+
+    public async Task<BreweryServiceReturn> UpdateAsync(BreweryUpdateRequest request)
+    {
+        var entity = new BreweryPost
+        {
+            BreweryPostId = request.BreweryPostId,
+            PostedById = request.PostedById,
+            BreweryName = request.BreweryName,
+            Description = request.Description,
+            UpdatedAt = DateTime.UtcNow,
+            Location = request.Location is null ? null : new BreweryPostLocation
+            {
+                BreweryPostLocationId = request.Location.BreweryPostLocationId,
+                BreweryPostId = request.BreweryPostId,
+                CityId = request.Location.CityId,
+                AddressLine1 = request.Location.AddressLine1,
+                AddressLine2 = request.Location.AddressLine2,
+                PostalCode = request.Location.PostalCode,
+                Coordinates = request.Location.Coordinates,
+            },
+        };
+
+        await repository.UpdateAsync(entity);
+        return new BreweryServiceReturn(entity);
+    }
+
+    public Task DeleteAsync(Guid id) =>
+        repository.DeleteAsync(id);
+}

src/Core/Service/Service.Breweries/IBreweryService.cs

@@ -0,0 +1,64 @@
+using Domain.Entities;
+
+namespace Service.Breweries;
+
+public record BreweryCreateRequest(
+    Guid PostedById,
+    string BreweryName,
+    string Description,
+    BreweryLocationCreateRequest Location
+);
+
+public record BreweryLocationCreateRequest(
+    Guid CityId,
+    string AddressLine1,
+    string? AddressLine2,
+    string PostalCode,
+    byte[]? Coordinates
+);
+
+public record BreweryUpdateRequest(
+    Guid BreweryPostId,
+    Guid PostedById,
+    string BreweryName,
+    string Description,
+    BreweryLocationUpdateRequest? Location
+);
+
+public record BreweryLocationUpdateRequest(
+    Guid BreweryPostLocationId,
+    Guid CityId,
+    string AddressLine1,
+    string? AddressLine2,
+    string PostalCode,
+    byte[]? Coordinates
+);
+
+public record BreweryServiceReturn
+{
+    public bool Success { get; init; }
+    public BreweryPost Brewery { get; init; }
+    public string Message { get; init; } = string.Empty;
+
+    public BreweryServiceReturn(BreweryPost brewery)
+    {
+        Success = true;
+        Brewery = brewery;
+    }
+
+    public BreweryServiceReturn(string message)
+    {
+        Success = false;
+        Brewery = default!;
+        Message = message;
+    }
+}
+
+public interface IBreweryService
+{
+    Task<BreweryPost?> GetByIdAsync(Guid id);
+    Task<IEnumerable<BreweryPost>> GetAllAsync(int? limit = null, int? offset = null);
+    Task<BreweryServiceReturn> CreateAsync(BreweryCreateRequest request);
+    Task<BreweryServiceReturn> UpdateAsync(BreweryUpdateRequest request);
+    Task DeleteAsync(Guid id);
+}

src/Core/Service/Service.Breweries/Service.Breweries.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+    <PropertyGroup>
+        <TargetFramework>net10.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <ProjectReference Include="..\..\Domain\Domain.Entities\Domain.Entities.csproj" />
+        <ProjectReference Include="..\..\Infrastructure\Infrastructure.Repository\Infrastructure.Repository.csproj" />
+    </ItemGroup>
+</Project>