unrealbg/BlazorShop

BlazorShop is a full-featured e-commerce platform built on .NET 10 and .NET Aspire, providing a public storefront for browsing products and managing carts, alongside a secure admin back-office for managing inventory, orders, and users. The system supports robust checkout workflows with idempotency guarantees, handling payments via Stripe and bank transfers, while maintaining data integrity through atomic inventory reservations. It also includes comprehensive SEO management, analytics, and isolated demo sessions for safe testing without affecting production data.

71 changes.

The project established its foundational .NET 10 architecture, defining the domain model, infrastructure, and API for an e-commerce platform. This period focused on implementing core capabilities including product catalog management, user authentication, and a durable checkout system with payment integration. The work also included scaffolding the Blazor WebAssembly storefront and admin interface to support these backend services.

41 changes.

The project migrated its development and orchestration infrastructure to .NET Aspire, introducing centralized service defaults and local AppHost management. Significant features were added to the public storefront, including server-rendered SEO capabilities, responsive design, and catalog sitemaps, while a comprehensive admin back-office MVP was built for managing orders, inventory, users, and audit logs. The period also established robust testing coverage, including Playwright E2E tests for checkout flows and integration tests for payment and inventory integrity.

Introduces a new toast notification system in the shared presentation layer, providing the core data models (ToastOptions, ToastEventArgs), configuration enums (ToastLevel, ToastIcon, ToastPosition), and helper classes (ToastBuilder, ToastIcons, ToastPositions) required to construct and display toast messages with customizable levels, icons, positions, and durations.

BlazorShop.Presentation/BlazorShop.Web.Shared/Toast · high confidence

A new 'Today's Deals' page has been added to the public storefront, displaying a grid of the 100 newest products fetched from the catalog. Users can view product images, names, and prices, and interact with items via 'Add to Cart' or 'See More' buttons. Products with variants trigger a details modal for selection, while simple products are added directly to the cart with toast notifications. The page also includes dynamic SEO metadata for search engine optimization.

BlazorShop.Presentation/BlazorShop.Web/Pages/Public/Deals · high confidence

The application now includes a new ExceptionHandlingMiddleware that intercepts unhandled errors during request processing. For database conflicts (DbUpdateException), it returns a 409 Conflict status with a generic message in production or detailed error information in development. For all other exceptions, it returns a 500 Internal Server Error with a generic message in production or the specific error details in development. All errors are logged via IAppLogger, and responses are returned as JSON objects containing the status code, message, and trace identifier.

BlazorShop.Infrastructure/ExceptionsMiddleware · high confidence

The header now includes a cart icon that displays a live badge count synchronized with the shopping cart cookie, an account dropdown menu that conditionally shows Admin, Profile, Login, or Register links based on authentication state, a search bar with autocomplete suggestions from the product catalog, and a side navigation panel listing product categories.

BlazorShop.Presentation/BlazorShop.Web/Components/Header · high confidence

The application now includes a new \ImageFileSignatureValidator\ in the API layer that verifies uploaded image files (PNG, JPEG, GIF, BMP, WebP) by checking their binary headers against known signatures, ensuring file integrity beyond MIME types. Additionally, a new \BrowserSessionStorageService\ has been added to the shared web layer, providing a typed interface (\IBrowserSessionStorageService\) to interact with the browser's session storage via JavaScript interop, allowing client-side components to persist session-specific data.

BlazorShop.Presentation/BlazorShop.API/Validation, BlazorShop.Presentation/BlazorShop.Web.Shared/BrowserStorage · high confidence

The UI now includes a new 'You Might Also Like' section that displays related products based on the current item, featuring product images, names, categories, and prices, along with a 'Quick View' button and navigation to product details. Additionally, a reusable Tooltip component has been added to support contextual hover/focus hints across the interface.

BlazorShop.Presentation/BlazorShop.Web/Components · high confidence

The public-facing storefront now includes dedicated pages for About, Customer Service, FAQ, Privacy, and Terms, providing users with company information, support contact details, and policy documentation. A new dynamic Hero Banner component displays rotating promotional slides with various visual types (gradient cards, product stacks, discount badges, and promo banners) and feature badges like free shipping and secure payment. The main product listing page (MainPage) allows users to browse products by category, add items to the cart (including variant selection), and view product details in a modal. The account home page (Home) provides navigation to profile, orders, notifications, and the public storefront, with admin access for authorized users.

BlazorShop.Presentation/BlazorShop.Web/Pages/Public · high confidence

New DTOs have been introduced in the application layer to support analytics features: MetricPointDto for individual data points, MetricsGranularity enum defining Day, Week, and Month intervals, and MetricsSeriesDto which aggregates series metadata (time range, granularity, totals, trend) along with a list of MetricPointDto values.

BlazorShop.Application/DTOs/Analytics · high confidence

The BlazorShop.ServiceDefaults library now provides a unified extension method to configure common infrastructure features for .NET Aspire services. This includes automatic OpenTelemetry instrumentation for logging, metrics, and tracing (exported via OTLP), built-in health check endpoints (/health and /alive) that are only exposed in development environments, service discovery integration, and default HTTP client resilience handlers.

BlazorShop.ServiceDefaults · high confidence

New DTOs and presentation models have been introduced to support the structure of a public catalog sitemap. These include \GetCategorySitemapEntry\ and \GetProductSitemapEntry\ (each containing a slug and last modified date) within both the Application and Web.Shared layers, as well as a \GetPublicCatalogSitemap\ container that aggregates these lists. This change provides the underlying data structures required for the SEO sitemap feature mentioned in the commit message.

BlazorShop.Application/DTOs/Discovery, BlazorShop.Presentation/BlazorShop.Web.Shared/Models/Discovery · high confidence

The application now includes domain models for extended user identity and session management. A new AppUser class extends the standard identity user to store a full name, creation timestamp, and a flag indicating whether a password change is required. Additionally, a RefreshToken entity has been introduced to manage secure token rotation, tracking token hashes, expiration times, revocation details, and metadata such as the originating IP address and user agent.

BlazorShop.Domain/Entities/Identity · high confidence

A new \NewsletterSubscriberRepository\ has been introduced in the infrastructure layer to support retrieving newsletter subscribers within a specific time window. This implementation provides a \GetByDateRangeAsync\ method that queries the database for subscribers created between a specified start and end UTC date, returning the results ordered chronologically.

BlazorShop.Infrastructure/Repositories/Newsletters · high confidence

This change introduces the data access layer for the new SEO management system. It adds the \ISeoRedirectRepository\ and \ISeoSettingsRepository\ interfaces in the domain layer, along with their Entity Framework Core implementations (\SeoRedirectRepository\ and \SeoSettingsRepository\) in the infrastructure layer. These repositories enable the application to query SEO redirect rules by old path (including active status checks) and retrieve current SEO settings, supporting the automated redirect system for slugs and public paths.

BlazorShop.Domain/Contracts/Seo, BlazorShop.Infrastructure/Repositories/Seo · high confidence

Added the shared data models required for the new admin SEO management feature, including classes for managing SEO settings (site name, meta descriptions, social links), product and category SEO fields (slugs, meta titles, canonical URLs), and URL redirect rules (old/new paths, status codes).

BlazorShop.Presentation/BlazorShop.Web.Shared/Models/Seo · high confidence

The admin back office now includes a minimum viable product for managing core store operations. Administrators can view and filter an audit log of system actions, manage user accounts and roles (including locking accounts and preventing self-removal of admin privileges), manage product inventory with stock updates and conflict detection, and handle orders by updating tracking details, fulfillment status, and admin notes. Store configuration settings for the shop, orders, and notifications are also now manageable through the admin interface.

BlazorShop.Infrastructure/Services/Admin · high confidence

The API now exposes a comprehensive set of new controllers to support the admin back office and public storefront. Admin capabilities include managing users (roles, locking, email confirmation), inventory (stock updates for products and variants), orders (tracking, shipping status, notes), audit logs, and SEO settings (redirects, metadata, product/category SEO). The storefront provides public access to the product catalog, categories, and newsletter subscription, while authenticated users can manage their profiles, change passwords, and handle checkout with idempotency support. Payment processing endpoints for PayPal and general payment methods are also available, along with a demo session controller for isolated testing environments.

BlazorShop.Presentation/BlazorShop.API/Controllers · high confidence

This change introduces the data transfer objects (DTOs) and presentation models required for the new admin back-office capabilities. It adds structures for querying and displaying audit logs, managing inventory (including product and variant stock levels and low-stock thresholds), filtering orders by status, and configuring store, order, notification, and system settings. It also defines models for listing, viewing details, and managing roles and lockout status for admin users. These files provide the contract between the application layer and the Blazor Web Shared UI for these administrative features.

BlazorShop.Application/DTOs/Admin, BlazorShop.Presentation/BlazorShop.Web.Shared/Models/Admin · high confidence

The shared presentation layer now consolidates API endpoint strings into a new \Constant.cs\ class, covering product, category, SEO, authentication, cart, payment, and admin management routes, which standardizes how the frontend communicates with backend services. Additionally, dedicated models for the newsletter subscription feature (\SubscribeRequest\, \SubscribeResponse\) have been added to support the new subscription capability.

BlazorShop.Presentation/BlazorShop.Web.Shared · high confidence

This change introduces Entity Framework Core configuration classes that define the database structure for the admin back office, SEO foundation, and order management. Specifically, it adds configurations for the AdminAuditLog and AdminSettings entities to support the new admin MVP, including audit trails and store settings. It also defines the schema for SEO entities (Categories, Products, SeoRedirects, SeoSettings) with constraints for slugs, meta data, and redirects. Finally, it establishes the data model for Orders, OrderLines, PaymentTransactions, PaymentProviderEvents, InventoryReservations, and CheckoutIdempotencyRecords, enforcing strict validation rules for order statuses, payment lifecycles, and inventory integrity.

BlazorShop.Infrastructure/Data/Configurations · high confidence

This change introduces the core domain entities for the BlazorShop application, establishing the data structure for product management, SEO, and administration. It adds the Product and Category entities with support for product variants (including SKU, size scales, and pricing), along with comprehensive SEO fields (slugs, meta tags, Open Graph data) and redirect handling. Additionally, it includes entities for admin settings, audit logging, and newsletter subscriptions, providing the foundational schema for the store's content and administrative features.

BlazorShop.Domain/Entities · high confidence

The repository is established with a layered .NET 10 architecture (Domain, Application, Infrastructure, Presentation) and includes a new solution file defining projects for the API, server-rendered Storefront, Blazor WebAssembly Web workspace, and shared components. Production readiness is supported by Docker Compose configurations for both general production and VPS environments, alongside an Aspire AppHost for local orchestration. The project also introduces essential operational documentation, including a Code of Conduct, Contributing guide, and Security policy, while pinning the development environment to .NET SDK 10.0.107.

(repo-wide) · high confidence

This change introduces the core Blazor WebAssembly presentation layer, establishing the application shell with authentication-aware routing and a loading state in App.razor, while wiring up service registrations for cart, checkout, and SEO in Program.cs. It adds a dynamic SEO system for the storefront, including components to inject metadata tags (SeoHead) and fetch dynamic SEO fields (StaticPageSeo), alongside an admin UI for editing these fields (SeoFieldsEditor). The entry also sets up the deployment infrastructure with a multi-stage Dockerfile and Nginx configuration, configures Tailwind CSS for styling, and provides JavaScript interop for file downloads and line charts.

BlazorShop.Presentation/BlazorShop.Web · high confidence

The application now exposes explicit interfaces for authentication and logging capabilities. The new IAuthenticationService defines the contract for user lifecycle operations, including creating users, logging in, reviving tokens via refresh tokens, logging out, changing passwords, confirming email addresses, and updating user profiles. Additionally, the IAppLogger interface provides a standardized contract for logging information, warnings, and errors across the application.

BlazorShop.Application/Services/Contracts/Authentication · high confidence

Added a set of new models in the shared presentation layer to represent category data, including base, create, update, and retrieval structures. The GetCategory model now includes fields for SEO metadata (meta title, description, canonical URL, Open Graph tags, robots settings) and a collection of associated products, enabling richer category pages and public catalog exposure.

BlazorShop.Presentation/BlazorShop.Web.Shared/Models/Category · high confidence

This change introduces a new set of Data Transfer Objects in the \BlazorShop.Application/DTOs/Payment\ namespace to support expanded checkout and order tracking capabilities. Key additions include \BankTransferInfo\ and \BankTransferSettings\ to enable bank transfer payments, alongside \StripeCheckoutInitialization\ and \PaymentInitializationResult\ for Stripe integration. The \Checkout\ and \CheckoutExecutionResult\ types define the authoritative checkout flow, including idempotency claims (\CheckoutIdempotencyClaim\) to prevent duplicate processing. Order visibility is enhanced with \GetOrder\ and \GetOrderLine\ DTOs, which expose detailed status, financial breakdowns, and line-item snapshots. Finally, shipping and tracking updates are structured via \UpdateShippingStatusRequest\ and \UpdateTrackingRequest\, allowing users to manage fulfillment details.

BlazorShop.Application/DTOs/Payment · high confidence

The application now features dedicated, redesigned UI components for account management, including Login, Register, Logout, and a new Email Confirmation page. Users can now confirm their email addresses via a secure link, receive clear success or error feedback during registration, and access isolated 30-minute sandbox environments for both Customer and Administrator roles directly from the login screen to test the application without creating a permanent account.

BlazorShop.Presentation/BlazorShop.Web/Authentication/Components · high confidence

The application now includes concrete repository implementations for managing orders and payment methods within the infrastructure layer. The new OrderRepository provides data access capabilities for creating orders, retrieving them by ID, reference, or user, listing all orders, and querying orders within a specific date range, including associated order lines. Additionally, the PaymentMethodRepository exposes a method to retrieve available payment methods from the database, enabling the system to support various payment options such as bank transfers and PayPal.

BlazorShop.Infrastructure/Repositories/Payment · high confidence

This change adds a new set of data models in the shared presentation layer to support the checkout flow, order retrieval, and shipping tracking. Specifically, it introduces \Checkout\ and \CheckoutResult\ to handle payment method selection and result statuses (including bank transfer details), \GetOrder\ and \GetOrderLine\ to expose order details and line-item variants, and request models (\UpdateShippingStatusRequest\, \UpdateTrackingRequest\) to allow updating fulfillment and tracking information.

BlazorShop.Presentation/BlazorShop.Web.Shared/Models/Payment · high confidence

Added a comprehensive set of DTOs in the BlazorShop.Application layer to support product management, including base classes for validation, specific commands for creating and updating products, and detailed read models for catalog listings, individual product details, and recommendations. The changes also introduce a full set of DTOs for product variants, enabling the representation of SKU, size, color, and stock attributes for product variations.

BlazorShop.Application/DTOs/Product · high confidence

The BlazorShop.Web.Shared.Helper namespace now provides three new classes to standardize HTTP interactions and authentication in the shared UI layer. ApiCallHelper centralizes API request execution (GET, POST, PUT, DELETE) with structured error handling and logging, returning typed ServiceResponse or QueryResult objects for consistent user feedback. HttpClientHelper manages HttpClient instances via IHttpClientFactory, automatically attaching Bearer tokens for authenticated requests using ITokenService. TokenService handles JWT storage and retrieval via browser session storage, ensuring tokens are available for private API calls while gracefully handling storage errors.

BlazorShop.Presentation/BlazorShop.Web.Shared/Helper · high confidence

Added new shared models to support a more granular notification system: AppNotification for storing notification state (including read status and creation time), NotificationRequest for defining toast and inbox parameters (such as position, duration, and persistence), and the NotificationKind enum to categorize notifications into General, Authentication, Order, Payment, and Promotion types.

BlazorShop.Presentation/BlazorShop.Web.Shared/Models/Notifications · high confidence

This change adds a comprehensive set of data models for the product domain, replacing previous ad-hoc structures with explicit DTOs for creating, updating, and retrieving products. It introduces \CreateProduct\ and \UpdateProduct\ for input validation, alongside \GetProduct\ and \GetCatalogProduct\ for detailed and list-view product data respectively. The models now support product variants via \GetProductVariant\, enabling users to see different SKUs, sizes, and colors. Additionally, \ProductCatalogQuery\ and \ProductCatalogSortBy\ are added to support paginated, searchable, and sortable product catalogs, while \GetProductRecommendation\ provides the data structure for product recommendation features.

BlazorShop.Presentation/BlazorShop.Web.Shared/Models/Product · high confidence

Adds a set of Data Transfer Objects for managing categories, including base validation for the category name and specific models for creating, updating, and retrieving category details. The retrieval DTOs (GetCategory, GetCategoryPage) expose SEO-specific fields such as meta titles, descriptions, canonical URLs, and Open Graph data, while also linking to associated products to support storefront catalog views.

BlazorShop.Application/DTOs/Category · high confidence

This change adds a new set of Data Transfer Objects (DTOs) within the \BlazorShop.Application/DTOs/Seo\ namespace to support SEO management capabilities. The diff introduces \SeoFieldsDto\ as a base for common SEO attributes (slugs, meta titles, descriptions, canonical URLs, Open Graph tags, and robot directives) and specific DTOs for managing SEO data for \Product\ and \Category\ entities. It also defines DTOs for global \SeoSettings\ (site name, default metadata, company info, social links), \SeoRedirect\ management (mapping old paths to new ones with status codes), and a \SeoMetadataBuildRequest\ for constructing page metadata. These types provide the structured data contracts required for the application layer to handle SEO configuration and redirect logic.

BlazorShop.Application/DTOs/Seo · high confidence

A new \JsModuleHandler\ class and its \IJsModuleHandler\ interface have been added to the shared interop layer, providing a standardized way to import and invoke JavaScript modules from Blazor components. This handler manages the lazy loading of JS modules via \IJSRuntime\, exposes methods to invoke both void and typed JS functions, and implements \IAsyncDisposable\ to ensure proper cleanup of the underlying JS object references, simplifying how Blazor components interact with external JavaScript libraries.

BlazorShop.Presentation/BlazorShop.Web.Shared/Interop · high confidence

The application now exposes explicit domain contracts for authentication operations, defining how user, role, and token management are handled. New interfaces include IAppUserManager for user lifecycle tasks (creation, login, password changes, email confirmation, and profile updates), IAppRoleManager for role assignments, and IAppTokenManager for handling access and refresh tokens. A new UserLoginResult record type standardizes login response data, indicating success, lockout status, and allowance.

BlazorShop.Domain/Contracts/Authentication · high confidence

A new contract, INewsletterSubscriberRepository, has been added to the domain layer to define how newsletter subscriber data is accessed. This interface specifies a single method, GetByDateRangeAsync, which allows retrieving a list of NewsletterSubscriber entities filtered by a specific UTC date range. This change establishes the abstraction for date-based subscriber queries within the application's architecture.

BlazorShop.Domain/Contracts/Newsletters · high confidence

The BlazorShop.Web.Shared.Models namespace now includes a suite of new types to standardize data handling across the application. This includes ApiCall for structuring HTTP requests, PagedResult for handling paginated product catalogs, and QueryResult/ServiceResponse (along with ServiceResponseType) for consistent API success/failure states and error messages. Additionally, ToastModel and Unit have been added to support user interface notifications and generic unit-type placeholders, while FileUploadResponse and LoginResponse provide specific structures for file uploads and authentication flows.

BlazorShop.Presentation/BlazorShop.Web.Shared/Models · high confidence

This update adds structured diagnostic logging for public-facing SEO operations, including product and category resolution, redirect handling, and sitemap/robots.txt discovery failures, ensuring these events are captured with specific event IDs and log levels. It also introduces a suite of new application services and their corresponding interface contracts to support the admin back office and public storefront: Category and Product services for catalog management, SEO services for managing meta data and slugs, a Product Recommendation service with caching, a Newsletter subscription service, and a Metrics service for sales and traffic analytics. Additionally, new admin service contracts are defined for managing users, orders, inventory, and system settings, laying the groundwork for the admin back office MVP.

BlazorShop.Application/Services · high confidence

New model classes have been added to the shared analytics layer to support data representation and filtering. MetricPointModel defines individual data points with a period and value, MetricsFilterModel handles date range and granularity settings for queries, and MetricsSeriesModel aggregates series data including totals, trend percentages, and the underlying metric points.

BlazorShop.Presentation/BlazorShop.Web.Shared/Models/Analytics · high confidence

Users can now start temporary, isolated demo sessions for either the Customer (User) or Admin role. The system provisions a separate database environment for each session, manages session lifecycle and expiration via a background cleanup service, and handles authentication through a dedicated middleware that validates session tokens and cookies. This allows safe exploration of the application without affecting real data.

(repo-wide) · high confidence

The BlazorShop.API project now includes an AssemblyInfo file that grants internal visibility to the test assembly (BlazorShop.Tests) and a launchSettings.json file defining HTTP and HTTPS profiles for local development, along with a dedicated 'e2e' profile configured for Playwright end-to-end testing.

BlazorShop.Presentation/BlazorShop.API/Properties · high confidence

The shared helper contracts now define interfaces for standardized API calls (IApiCallHelper), HTTP client retrieval (IHttpClientHelper), and JWT token lifecycle management (ITokenService). These additions establish the structural foundation for consistent API interaction and authentication handling within the BlazorShop web shared layer.

BlazorShop.Presentation/BlazorShop.Web.Shared/Helper/Contracts · high confidence

This change introduces a suite of new Razor pages for the BlazorShop web application. For customers, it adds an Account Dashboard, Order History, Profile management, Settings (including password changes), and a Notifications inbox. For administrators, it provides an Audit Log viewer with filtering and details, and a Categories management interface that supports adding, editing (including SEO fields), and deleting categories.

BlazorShop.Presentation/BlazorShop.Web/Pages/Admin · high confidence

A new TemplateTable Blazor component has been added to the Templates area, allowing users to render tables with configurable header, content, and button sections. The component supports extensive visual customization through parameters for table format (Striped, Hover, Bordered, Dark, Light), background and text colors, font families (Arial, Calibri, Times New Roman, Comic Sans, Georgia), and specific font sizes (12px–24px). A new Styles helper class provides the underlying logic for mapping these parameters to CSS classes, while retaining deprecated color and table format methods for backward compatibility.

BlazorShop.Presentation/BlazorShop.Web/Components/Templates · high confidence

A new Toast component has been added to the BlazorShop web presentation layer to display transient notifications. This component renders toast cards in four screen corners (top-right, bottom-right, bottom-left, top-left) and supports four visual levels: Info, Success, Warning, and Error, each with distinct accent colors and icons. Users can manually dismiss toasts via a close button, and non-persistent toasts automatically disappear after a configurable duration. The component subscribes to the application's ToastService to receive and display notification events.

BlazorShop.Presentation/BlazorShop.Web/Components/Notifications · high confidence

This update introduces a comprehensive set of new client-side services in the shared presentation layer, enabling the new admin back-office and enhanced storefront features. For administrators, new services (AdminAuditService, AdminInventoryService, AdminOrderService, AdminSettingsService, AdminUserService) provide the API integration for managing audit logs, inventory stock levels, order fulfillment and tracking, store settings, and user accounts. For the storefront, new services (CartService, CategoryService, ProductService, ProductRecommendationService, CategorySeoService, ProductSeoService, MetricsClient, NewsletterService, PaymentMethodService, FileUploadService) enable product browsing, category filtering, SEO management, sales/traffic metrics, newsletter subscriptions, and file uploads. Additionally, the AuthenticationService has been refactored to support isolated demo sessions and improved error handling, while a new CheckoutAttemptStore implements durable idempotency for checkout requests to prevent duplicate charges.

BlazorShop.Presentation/BlazorShop.Web.Shared/Services · high confidence

The application layer now includes a set of new Data Transfer Objects to support upcoming features. EmailSettings defines configuration for SMTP-based email delivery. LoginResponse provides a structured return type for authentication, including access and refresh tokens. FileUploadResponse standardizes the output of file upload operations. A new service response pattern is introduced via ServiceResponse and the generic ServiceResponse\<TPayload\>, which include a Success flag, optional message, ID, and a typed Payload, supported by the ServiceResponseType enum to distinguish between success, validation errors, not found, conflict, and failure states.

BlazorShop.Application/DTOs · high confidence

This update introduces a comprehensive set of new service interfaces within the application layer, defining the backend capabilities for the storefront and administration. Key additions include \IProductService\ and \ICategoryService\ for managing product catalogs, \IPublicCatalogService\ to expose published content via slugs and paged queries, and a full suite of SEO services (\ISeoSettingsService\, \ISeoRedirectService\, \IProductSeoService\, etc.) for managing metadata, redirects, and settings. The diff also adds contracts for \INewsletterService\, \IProductRecommendationService\, \IMetricsService\, and \IApplicationTransactionManager\, establishing the foundation for these new features.

BlazorShop.Application/Services/Contracts · high confidence

The application introduces a set of new data models in the shared presentation layer to support user account management. These include \CreateUser\ and \LoginUser\ for registration and sign-in, \PasswordChangeModel\ for updating passwords, \UpdateProfileModel\ for editing user details, and \DemoSessionModel\ to facilitate isolated demo sessions for customers and admins. These models define the structure and validation rules (such as email format, password complexity, and required fields) for these authentication and profile operations.

BlazorShop.Presentation/BlazorShop.Web.Shared/Models/Authentication · high confidence

The application introduces a new authentication layer in the infrastructure repository, featuring role-based user management via AppRoleManager, secure JWT access and refresh token handling in AppTokenManager, and comprehensive user operations in AppUserManager. Users can now log in with password verification, have their roles checked during authentication, and manage their profiles including password changes and email confirmation. The system supports isolated demo sessions by injecting session claims into user tokens, and implements secure refresh token rotation with family revocation to enhance security.

BlazorShop.Infrastructure/Repositories/Authentication · high confidence

A new \BrowserCookieStorageService\ has been added to the shared presentation layer to manage cookies directly in the browser via JavaScript interop. This service implements the \IBrowserCookieStorageService\ interface, providing methods to set, get, and remove cookies, and relies on a JavaScript module located at \./js/cookieStorage.js\ to perform the actual browser operations.

BlazorShop.Presentation/BlazorShop.Web.Shared/CookieStorage · high confidence

A new category repository has been introduced to manage category-related data operations. This includes retrieving products by category, fetching published categories, and accessing category data for SEO sitemaps. The repository also supports retrieving categories by ID or slug, and checking for slug existence, all optimized for performance with AsNoTracking and efficient querying.

BlazorShop.Domain/Contracts/CategoryPersistence, BlazorShop.Infrastructure/Repositories/CategoryPersistence · high confidence

The checkout experience now includes a dedicated cart page at /account/checkout that displays line items, handles quantity updates, and presents a modal for selecting from available payment methods. A new BankTransfer.razor page provides specific banking instructions (bank name, IBAN, reference) when that method is chosen. Additionally, new /payment-success and /payment-cancel pages inform users of the final order status, clarifying that card payments rely on server-side Stripe notifications while bank transfers are awaiting receipt.

BlazorShop.Presentation/BlazorShop.Web/Pages/Payments · high confidence

The web application now includes a set of new JavaScript modules in the wwwroot/js directory to enhance the user experience and support Blazor interop. The app.js module manages the loading progress indicator and error UI handling. New storage helpers (cookieStorage.js, sessionStorage.js) provide safe, standardized wrappers for reading, writing, and removing cookies and session storage. The authSessionSync.js module enables cross-tab synchronization of authentication state via local storage events. Cart functionality is supported by cartBadge.js, which polls for cookie changes to update the cart count badge in real-time. Finally, interop.js adds capabilities for downloading files via Blob and rendering/disposing Chart.js line charts on the client side.

BlazorShop.Presentation/BlazorShop.Web/wwwroot/js · high confidence

The domain layer now includes a comprehensive set of entities to support robust checkout and fulfillment processes. This introduces \CheckoutIdempotencyRecord\ and \CheckoutIdempotencyState\ to prevent duplicate checkout attempts, and \InventoryReservation\ with its status enum to manage stock holds during transactions. The \Order\ entity has been expanded to track distinct order, payment, and fulfillment statuses, along with snapshots of customer and line-item details. Supporting this are \OrderLifecyclePolicy\ rules for validating fulfillment transitions and coordinating payment states, as well as new enums for \FulfillmentStatus\, \OrderPaymentMethod\, and \OrderPaymentStatus\. Additionally, \PaymentTransaction\ and \PaymentProviderEvent\ entities are added to track Stripe payment interactions and provider webhooks.

BlazorShop.Domain/Entities/Payment · high confidence

Added six new Blazor form control components in the FormControls directory: FloatingTextInput, FloatingNumberInput, and FloatingTextAreaInput, which render inputs with floating labels using Bootstrap's 'form-floating' styling, and their standard counterparts TextInput, NumberInput, and TextAreaInput. These components provide consistent binding and rendering for text, number, and textarea inputs, enhancing the form-building capabilities of the presentation layer.

BlazorShop.Presentation/BlazorShop.Web/Components/FormControls · high confidence

The storefront now includes dedicated pages for the latest products and new releases, featuring paginated product grids and an interactive modal for viewing product details. Users can now select specific variants (such as size) for products that support them before adding them to the cart, with the cart quantity and variant details updated accordingly.

BlazorShop.Presentation/BlazorShop.Web/Pages/Products · high confidence

The infrastructure layer now includes a new set of repositories to manage product data and inventory operations. A generic repository provides standard CRUD operations, while specialized repositories handle complex product catalog queries (including pagination and SEO metadata), atomic inventory topology changes for product variants (ensuring safe addition/deletion with transactional integrity), and product recommendations (such as related items, frequently bought together, and recently viewed products). This change introduces the data-access logic required for the new product variant system, paged catalog browsing, and recommendation features.

BlazorShop.Infrastructure/Repositories · high confidence

Users can now browse search results via a dedicated /search-result page that supports filtering by category, sorting by name, date, or price, and adding products directly to the cart. The page preserves filters in the URL for easy sharing and reloading, displays product details including images and pricing, and handles loading states and errors gracefully.

BlazorShop.Presentation/BlazorShop.Web/Components/Search · high confidence

The BlazorShop Storefront now provides a dedicated public-facing shop experience built on server-rendered Razor components. This introduces a responsive layout with a new header, footer, and mobile navigation, alongside product catalog pages featuring a new ProductCard component and grid. To improve search engine visibility, the storefront includes automatic SEO metadata generation, Open Graph tags, JSON-LD structured data, and breadcrumb navigation. The deployment pipeline has been updated to include Node.js and Tailwind CSS for static asset generation, and configuration validation ensures the public URL and API endpoints are correctly set for production environments.

BlazorShop.Presentation/BlazorShop.Storefront · high confidence

The shared component library now includes a reusable ModalDialog component that supports customizable headers, bodies, and footers, with visibility control, backdrop click dismissal, Escape key handling, and configurable sizes (sm, md, lg, xl). Additionally, a Spinner component has been added to provide a consistent visual loading indicator across the application.

BlazorShop.Presentation/BlazorShop.Web/Components/Shared · high confidence

The BlazorShop.Web.Shared project now exposes a comprehensive set of service interfaces that define the client-side API for the application's expanded capabilities. These contracts enable the storefront to manage product variants and recommendations, support SEO management for products and categories, and handle file uploads. For administrators, the new interfaces provide the foundation for the back-office features, including user management, inventory tracking, order processing, audit logging, and system settings. Additionally, core commerce and UX capabilities are formalized through contracts for cart operations, checkout attempt idempotency, payment methods, and a robust notification and toast system for user feedback.

BlazorShop.Presentation/BlazorShop.Web.Shared/Services/Contracts · high confidence

The web presentation layer now includes a suite of new services to enhance user feedback and storefront capabilities. A dynamic SEO system has been added, featuring a metadata builder that constructs titles, descriptions, and Open Graph tags from page data and global settings, exposed via the StorefrontSeoService. User feedback is improved through a centralized NotificationService that manages toast pop-ups and an inbox, along with specific cart notification extensions for add-to-cart and quantity-change events. Error handling is standardized via a QueryFailureNotifier that displays user-friendly messages based on HTTP status codes, and a PublicStorefrontUrlResolver that determines the correct storefront URL from configuration or development fallbacks.

BlazorShop.Presentation/BlazorShop.Web/Services · high confidence

The application now includes a set of Data Transfer Objects (DTOs) in the UserIdentity namespace to support user registration, login, profile updates, and password changes. These models define the structure for creating users (including full name and password confirmation), logging in, updating profile details (name, email, phone), and changing passwords (with validation for current password, new password length, and confirmation matching).

BlazorShop.Application/DTOs/UserIdentity · high confidence

The infrastructure layer now provides a durable, transactional foundation for the checkout flow. A new \ApplicationTransactionManager\ and \CheckoutIdempotencyStore\ ensure that checkout operations are atomic and idempotent, preventing duplicate charges or orders during network retries. \InventoryReservationService\ handles stock reservations with optimistic locking and conflict resolution, while \OrderTrackingService\ manages fulfillment status transitions and customer notifications. Payment reliability is enhanced through \StripePaymentReconciliationService\ for processing webhooks and \PaymentTransactionStore\ for persisting provider identities, alongside a stubbed \PayPalPaymentService\ for future expansion.

BlazorShop.Infrastructure/Services · high confidence

The API now includes a dedicated administrator bootstrapping process that safely creates the first admin user from configuration settings, ensuring no duplicate admins are created and validating that the database schema is ready. Additionally, a new database migration bootstrapper automatically detects and baselines legacy database schemas that lack EF Core migration history, allowing the application to safely apply migrations to existing databases without manual intervention.

BlazorShop.Presentation/BlazorShop.API · high confidence

The BlazorShop application now uses a centralized \DependencyInjection\ class to register its core services, including product, category, SEO, payment, checkout, and newsletter capabilities, alongside validation and authentication services. This change also introduces configuration binding and validation for recommendation settings, client app URLs, and commerce options (such as currency support), ensuring that these settings are correctly loaded and verified at startup.

BlazorShop.Application · high confidence

The application now uses a centralized \MappingConfig\ class to define AutoMapper profiles, ensuring consistent transformation between domain entities and Data Transfer Objects (DTOs). This configuration covers mappings for Categories and Products (including SEO fields and variants), User Identity, Payment Methods, and SEO settings/redirects, providing a single source of truth for object mapping across the application.

BlazorShop.Application/Mapping · high confidence

The BlazorShop.Infrastructure layer now provides a unified entry point for registering application services, repositories, and external integrations. This change introduces support for PostgreSQL via Npgsql, configures JWT authentication with strict token validation, and registers services for Stripe and PayPal payment processing, inventory reservation, and order tracking. It also sets up admin management capabilities (audit, users, inventory, orders), SEO redirect systems, and isolated demo session management with configurable constraints.

BlazorShop.Infrastructure · high confidence

The application's database schema has been significantly updated to support new capabilities. SEO fields (slugs, meta tags, canonical URLs) and a redirect table have been added to Products and Categories. A new AdminAuditLog table supports the admin back office. Security has been hardened by replacing plain-text refresh tokens with hashed versions and adding IP/user-agent tracking. Additionally, ASP.NET Identity tables and a newsletter subscriber table are now part of the schema.

BlazorShop.Infrastructure/Migrations · high confidence

The checkout flow now enforces strict idempotency and deterministic payment intent validation to prevent duplicate charges and ensure data consistency. A new canonicalization process normalizes cart lines and payment methods into a unique fingerprint, which is used to claim and track checkout operations, ensuring that repeated requests with the same intent key are safely replayed or rejected. The system validates that the immutable order total matches the card payment line snapshot before processing, and introduces a currency normalization layer to handle minor unit precision for supported currencies (EUR, GBP, USD). Additionally, PayPal payments are disabled by default, and the payment method service filters out unsupported or disabled methods based on configuration.

BlazorShop.Application/Services/Payment · high confidence

The application now enforces email confirmation for new user registrations, sending a confirmation link via email before allowing full access. During login, the system validates this confirmation status and returns a specific response if the account is not yet confirmed. Additionally, authentication now utilizes refresh tokens to manage session longevity, storing them securely and issuing them alongside access tokens upon successful login.

BlazorShop.Application/Services/Authentication · high confidence

The BlazorShop.AppHost project has been updated to use the Aspire SDK, providing a unified entry point for launching and configuring the application's services locally. This change introduces a Program.cs that orchestrates the PostgreSQL database, the API service, the server-rendered storefront, and the admin client, ensuring they start in the correct dependency order. It also adds support for configurable PostgreSQL image tags and volume usage, exposes external HTTP endpoints for the services, and includes improved error handling for port conflicts during startup.

BlazorShop.AppHost · high confidence

The web application now automatically maintains active user sessions by intercepting unauthorized API responses and silently refreshing JWT tokens in the background, preventing unexpected logouts during inactivity. Additionally, a new cross-tab synchronization system ensures that authentication state changes (such as logging out from another browser window) are instantly reflected across all open tabs, keeping the local UI consistent with the server.

BlazorShop.Presentation/BlazorShop.Web/Authentication/Providers · high confidence

The application now uses a new \ProtectedRouteRedirectResolver\ component to handle authentication flows. When an unauthenticated user attempts to access a protected route, they are redirected to the login page, with the original destination preserved in the URL path. After logging in, users are redirected back to their intended page, unless it is an admin path (which redirects non-admins to the account page) or the cart (which redirects to the account or admin dashboard based on role). This change also adds an import for authentication providers in the authentication area's Razor imports.

BlazorShop.Presentation/BlazorShop.Web/Authentication · high confidence

The BlazorShop.Domain/Contracts layer now defines the core abstractions and data models required for the new product catalog, inventory management, and SEO features. This includes the \CatalogProductReadModel\ and \PagedResult\ types to support paginated product listings, \IProductReadRepository\ and \ProductCatalogQuery\ to enable searching and filtering by category or term, and \IProductInventoryTopologyRepository\ to handle atomic variant additions and deletions. Additionally, \IProductRecommendationRepository\ exposes interfaces for related and frequently bought-together product logic, while \IEmailService\ provides the contract for sending notifications. The addition of \PublishedProductSitemapEntryReadModel\ and \PublishedCategorySitemapEntryReadModel\ establishes the data structures needed for generating sitemaps and robots.txt files.

BlazorShop.Domain/Contracts · high confidence

This change establishes the core domain interfaces and request models for the payment and order management subsystem. It adds the \CartLineRequest\ record to define cart line inputs, \IPaymentMethod\ to abstract payment method retrieval, and \IInventoryReservationService\ to handle atomic inventory reservations and status transitions. Additionally, it defines \IOrderRepository\ for order persistence (including date-range queries) and \IOrderTrackingService\ for managing shipping status and tracking details, laying the groundwork for the checkout and fulfillment workflows.

BlazorShop.Domain/Contracts/Payment · high confidence

The application now exposes dedicated configuration classes for managing checkout idempotency (retention, lease, and recovery windows), client app base URLs, commerce currency, Stripe payment integration, identity confirmation requirements, and product recommendations (including cache settings and order-based logic). Additionally, isolated demo session settings are now configurable, allowing administrators to control session lifetime, concurrency limits, and default demo credentials.

BlazorShop.Application/Options · high confidence

The application now uses a new AppDbContext that defines the full data model, including entities for products, variants, orders, inventory reservations, and identity management. This context is configured with specific database constraints, such as unique indexes on product variants and orders, and seed data for default payment methods and admin roles. Additionally, an AppDbContextFactory has been added to support Entity Framework Core design-time operations, explicitly configuring the connection to use PostgreSQL via Npgsql.

BlazorShop.Infrastructure/Data · high confidence

The application now includes two new exception classes in the BlazorShop.Application.Exceptions namespace: ItemNotFoundException, which is thrown when an item is not found by its ID, and ServiceResponseException, which carries a specific ServiceResponseType alongside its error message. These changes allow for more granular error handling and response typing within the application layer.

BlazorShop.Application/Exceptions · high confidence

The application introduces a set of new interfaces in the payment service layer to support durable checkout processes and multiple payment providers. These contracts define the capabilities for checkout idempotency (ICheckoutIdempotencyStore), checkout orchestration (ICheckoutOrchestrator), and order querying (IOrderQueryService). Additionally, specific interfaces are added for payment processing, including IPaymentService and IPayPalPaymentService for handling Stripe and PayPal transactions, IPaymentMethodService for retrieving available methods, IPaymentTransactionStore for persisting transaction identities, and IStripePaymentStateTransitionService for managing Stripe payment state changes. These interfaces establish the API surface for the underlying implementations that will handle payment reconciliation and order-first checkout logic.

BlazorShop.Application/Services/Contracts/Payment · high confidence

The application now enforces structured validation for user authentication and SEO configuration data. For authentication, creating a user requires a password meeting complexity rules (8+ characters, uppercase, lowercase, digit, special character) and matching confirmation, while changing a password requires the current password and a new password of at least 6 characters. For SEO, the system validates that slugs are URL-safe and present for published entries, ensures redirect paths are root-relative and distinct, and enforces length limits and URL formats for meta titles, descriptions, canonical URLs, and social media links.

BlazorShop.Application/Validations · high confidence

Added a validator for email settings that enforces strict configuration requirements in non-development environments. The system now checks that the sender address is a valid email, and that the SMTP server, port, username, and password are provided and not placeholders, failing startup if these are missing or invalid.

BlazorShop.Infrastructure/Configuration · high confidence

The web application's entry point and static assets have been replaced with a new structure. The default favicon is replaced by a custom SVG icon, and the main HTML page now includes a custom loading spinner and a styled error popup for unexpected failures. Styling is handled by locally hosted Tailwind and custom CSS files, while Font Awesome is loaded via CDN for toast icons. A Content Security Policy is enforced to restrict script and resource origins, and the application now integrates Chart.js for data visualization.

BlazorShop.Presentation/BlazorShop.Web/wwwroot · high confidence

The application now features completely redesigned error pages for access issues and missing routes. The NotAuthorized page provides a clearer user experience by distinguishing between a redirecting state (signing in) and a permanent access denial, offering direct links to the account page or logout. The NotFound page has been updated with a more prominent 404 display and a direct link to the homepage, replacing the previous generic styling with a centered, card-based layout.

BlazorShop.Presentation/BlazorShop.Web/Pages/Errors · high confidence

The web presentation layer has been overhauled to use Tailwind CSS v3.4.17 for styling, replacing previous approaches. This introduces a new visual identity featuring the Inter variable font and IcoMoon icon set. Users will see a redesigned storefront with a branded loading spinner and a polished, animated error popup overlay. The interface now supports distinct visual modes for the customer storefront, the admin workspace, and operations, each with specific color palettes and layout styles defined in the new CSS variables.

BlazorShop.Presentation/BlazorShop.Web/wwwroot/css · high confidence

The layout system has been restructured to provide distinct, role-aware workspaces for the storefront, customer account, and admin operations. MainLayout now dynamically renders the appropriate header based on authentication and roles, offering specific navigation for Admin (Dashboard, Orders, Products, Inventory, Users, SEO, Redirects, Settings, Audit), Customer Account (Dashboard, Orders, Notifications, Profile), and public users (Access, Sign in, Create account). A new WorkspaceHeader component standardizes the top navigation and mobile menu across these modes. Additionally, a new CategoryComponent has been introduced to the storefront header, allowing users to browse and filter products by category via a toggleable dropdown.

BlazorShop.Presentation/BlazorShop.Web/Layout · high confidence

The self-hosted Font Awesome assets in the web application have been upgraded to version 6.7.1. This update includes new JavaScript files (\fontawesome.js\ and \fontawesome.min.js\) and sprite definitions (e.g., \brands.svg\), which provide the latest icon set, enhanced functionality, and updated licensing information for the client-side rendering of icons.

BlazorShop.Presentation/BlazorShop.Web/wwwroot/font-awesome · high confidence

Add staging rehearsal for upgraded database validation; Added E2E test verification and Playwright installation scripts; Added Playwright E2E tests for storefront checkout flow; Added authentication smoke tests and markup validation; Added infrastructure test coverage for middleware, migrations, and Stripe payments; Added integration tests for PostgreSQL checkout, inventory, and payment infrastructure; Added test coverage for storefront API client, cart flow, SEO discovery, and layout markup; Added test infrastructure for live authentication smoke tests; Added test utility for AutoMapper configuration; Added tests for SEO mapping and redirect validation; Added tests for SEO runtime event stability and a test logging utility; Added tests for checkout payment presentation and contract mapping; Added tests for email settings validation; Added tests for order lifecycle policy and admin presentation; Added tests for secure administrator bootstrap; Added unit tests for API call and token management helpers; Added unit tests for API controllers and validation logic; Added unit tests for email, order tracking, and PayPal payment services; Added unit tests for infrastructure repositories; Added unit tests for payment and checkout services; Added unit tests for search catalog URL generation; Added unit tests for the authentication service.

The project has been upgraded to target .NET 10.0 across all components, including the API, web, and storefront projects. This change introduces .NET Aspire for application hosting and orchestration, adding the \Aspire.Hosting.AppHost\ and \Aspire.Hosting.PostgreSQL\ packages to the \BlazorShop.AppHost\ project. Additionally, the \BlazorShop.ServiceDefaults\ project now includes OpenTelemetry packages for distributed tracing and metrics, while the \BlazorShop.Web\ project integrates Tailwind CSS for styling.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 48.

• Code Health 65
• Architecture 80
• Maturity 64
• Readiness 41
• Security 70
• Accessibility 43
• Performance 61

• 300 commits — 298 feature/other, 2 fixes

• BlazorShop.Presentation/BlazorShop.Web — 107 commits
• (repo) — 52 commits
• (root) — 19 commits
• BlazorShop.Presentation/BlazorShop.Web.Shared — 18 commits
• BlazorShop.Presentation/BlazorShop.API — 13 commits
• BlazorShop.Presentation/BlazorShop.Storefront — 13 commits
• .github/workflows — 10 commits
• BlazorShop.Application/Services — 10 commits
• BlazorShop.Tests/Presentation — 7 commits
• BlazorShop.Application/DTOs — 6 commits
• BlazorShop.AppHost/BlazorShop.AppHost.csproj — 5 commits
• BlazorShop.Infrastructure/Migrations — 5 commits
• BlazorShop.Tests/Application — 5 commits
• docs/screenshots — 3 commits
• .github/ISSUE_TEMPLATE — 2 commits
• BlazorShop.Application/BlazorShop.Application.csproj — 2 commits
• BlazorShop.Application/DependencyInjection.cs — 2 commits
• BlazorShop.Application/Mapping — 2 commits
• BlazorShop.Domain/Contracts — 2 commits
• BlazorShop.Infrastructure/Data — 2 commits

• fix: Fix footer links and add policy pages
• fix: Merge pull request #12 from unrealbg/copilot/fix-88b89c25-2ca9-4b6b-9fe3-a46aa8666624
• change: """ Add admin SEO management: settings, redirects, UI, tests
• change: #27
• change: #47
• change: #47
• change: #47
• change: #47
• change: #47
• change: #47
• change: #47
• change: Add About, Customer Service, FAQ, and Main Page features
• change: Add Analytics namespace to _Imports.razor
• change: Add AppDbContextFactory and enhance DI configuration
• change: Add Blazor script and remove navigation functions
• change: Add BlazorShop.AppHost and BlazorShop.ServiceDefaults
• change: Add Categories nav link and improve SEO tab routing
• change: Add DI for NewsletterSubscriberRepository
• change: Add FileUploadResponse for structured upload responses
• change: Add GetByDateRangeAsync method to IOrderRepository
• …and 280 more

• 81 HTTP endpoints (baseline)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

unrealbg/BlazorShop was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.