Init

Prefab.Web/Gateway/Home.cs

@@ -0,0 +1,206 @@
+using System.Net;
+using FluentValidation;
+using Prefab.Domain.Exceptions;
+using Prefab.Endpoints;
+using Prefab.Shared.Catalog;
+using Prefab.Shared.Catalog.Products;
+using Prefab.Web.Client.Models.Catalog;
+using Prefab.Web.Client.Models.Home;
+using Prefab.Web.Client.Models.Shared;
+using Prefab.Web.Client.Services;
+using Prefab.Web.Client.ViewModels.Catalog;
+using UrlBuilder = Prefab.Web.UrlPolicy.UrlPolicy;
+
+namespace Prefab.Web.Gateway;
+
+public static class Home
+{
+    public sealed class Endpoints : IEndpointRegistrar
+    {
+        public void MapEndpoints(IEndpointRouteBuilder endpoints)
+        {
+            endpoints.MapGet(
+                    "/bff/home",
+                    async (Service service, CancellationToken cancellationToken) =>
+                    {
+                        var result = await service.Get(cancellationToken);
+                        var status = result.Problem?.StatusCode ?? (result.IsSuccess
+                            ? StatusCodes.Status200OK
+                            : StatusCodes.Status500InternalServerError);
+                        return Results.Json(result, statusCode: status);
+                    })
+                .WithTags(nameof(Home));
+        }
+    }
+
+    public sealed class Service(IModuleClient moduleClient, IProductListingService listingService) : IHomePageService
+    {
+        private const int MaxCategories = 8;
+        private const int MaxFeaturedProducts = 8;
+
+        public async Task<Result<HomePageModel>> Get(CancellationToken cancellationToken)
+        {
+            try
+            {
+                var response = await moduleClient.Product.GetCategoryTree(depth: 3, cancellationToken);
+                var nodes = response.Categories ?? [];
+
+                var leafNodes = Flatten(nodes)
+                    .Where(node => node.IsLeaf && !string.IsNullOrWhiteSpace(node.Slug))
+                    .ToList();
+
+                var categories = new List<CategoryCardModel>(MaxCategories);
+                var featuredProducts = new List<ProductCardModel>(MaxFeaturedProducts);
+                var seenCategoryIds = new HashSet<Guid>();
+                var seenProductKeys = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+
+                await CollectAsync(
+                    OrderCandidates(leafNodes.Where(node => node.IsFeatured)),
+                    categories,
+                    featuredProducts,
+                    seenCategoryIds,
+                    seenProductKeys,
+                    cancellationToken);
+
+                if (categories.Count < MaxCategories || featuredProducts.Count < MaxFeaturedProducts)
+                {
+                    await CollectAsync(
+                        OrderCandidates(leafNodes.Where(node => !node.IsFeatured)),
+                        categories,
+                        featuredProducts,
+                        seenCategoryIds,
+                        seenProductKeys,
+                        cancellationToken);
+                }
+
+                var model = new HomePageModel
+                {
+                    LatestCategories = categories,
+                    FeaturedProducts = featuredProducts
+                };
+
+                return Result<HomePageModel>.Success(model);
+            }
+            catch (ValidationException validationException)
+            {
+                var problem = ResultProblem.FromValidation(validationException);
+                return Result<HomePageModel>.Failure(problem);
+            }
+            catch (DomainException domainException)
+            {
+                var problem = ResultProblem.Unexpected(domainException.Message, domainException, HttpStatusCode.UnprocessableEntity);
+                return Result<HomePageModel>.Failure(problem);
+            }
+            catch (Exception exception)
+            {
+                var problem = ResultProblem.Unexpected("Failed to retrieve home page content.", exception);
+                return Result<HomePageModel>.Failure(problem);
+            }
+        }
+
+        private async Task CollectAsync(
+            IEnumerable<GetCategoryModels.CategoryNodeDto> candidates,
+            ICollection<CategoryCardModel> categories,
+            ICollection<ProductCardModel> featuredProducts,
+            ISet<Guid> seenCategoryIds,
+            ISet<string> seenProductKeys,
+            CancellationToken cancellationToken)
+        {
+            foreach (var candidate in candidates)
+            {
+                if (categories.Count >= MaxCategories && featuredProducts.Count >= MaxFeaturedProducts)
+                {
+                    break;
+                }
+
+                Result<ProductListingModel>? listingResult = null;
+                try
+                {
+                    listingResult = await listingService.GetCategoryProducts(candidate.Slug, cancellationToken);
+                }
+                catch (DomainException)
+                {
+                    continue;
+                }
+
+                if (!listingResult.IsSuccess || listingResult.Value is not { Products.Count: > 0 } listing)
+                {
+                    continue;
+                }
+
+                if (categories.Count < MaxCategories && seenCategoryIds.Add(candidate.Id))
+                {
+                    categories.Add(new CategoryCardModel
+                    {
+                        Title = candidate.Name,
+                        Url = UrlBuilder.BrowseProducts(candidate.Slug),
+                        ImageUrl = string.IsNullOrWhiteSpace(candidate.HeroImageUrl) ? null : candidate.HeroImageUrl,
+                        SecondaryText = FormatProductCount(listing.Total)
+                    });
+                }
+
+                if (featuredProducts.Count >= MaxFeaturedProducts)
+                {
+                    continue;
+                }
+
+                foreach (var product in listing.Products)
+                {
+                    var key = GetProductKey(product);
+                    if (!seenProductKeys.Add(key))
+                    {
+                        continue;
+                    }
+
+                    featuredProducts.Add(product);
+
+                    if (featuredProducts.Count >= MaxFeaturedProducts)
+                    {
+                        break;
+                    }
+                }
+            }
+        }
+
+        private static string GetProductKey(ProductCardModel product)
+        {
+            if (!string.IsNullOrWhiteSpace(product.Sku))
+            {
+                return product.Sku!;
+            }
+
+            if (!string.IsNullOrWhiteSpace(product.Url))
+            {
+                return product.Url!;
+            }
+
+            return product.Title;
+        }
+
+        private static IEnumerable<GetCategoryModels.CategoryNodeDto> OrderCandidates(
+            IEnumerable<GetCategoryModels.CategoryNodeDto> candidates) =>
+            candidates
+                .OrderBy(candidate => candidate.DisplayOrder)
+                .ThenBy(candidate => candidate.Name, StringComparer.OrdinalIgnoreCase);
+
+        private static string FormatProductCount(int total) =>
+            total == 1 ? "1 Product" : $"{total} Products";
+
+        private static IEnumerable<GetCategoryModels.CategoryNodeDto> Flatten(
+            IEnumerable<GetCategoryModels.CategoryNodeDto> nodes)
+        {
+            foreach (var node in nodes)
+            {
+                yield return node;
+
+                if (node.Children is { Count: > 0 })
+                {
+                    foreach (var child in Flatten(node.Children))
+                    {
+                        yield return child;
+                    }
+                }
+            }
+        }
+    }
+}