haritha99ch/FoodDesire

FoodDesire is a multi-platform food ordering and inventory management system comprising a Blazor web client, a WinUI desktop application, and a .NET Web API backend. The system enables customers to browse recipes, manage shopping carts, and process payments, while providing an internal interface for managing ingredients, suppliers, and deliveries. It supports distinct user roles including customers, chefs, suppliers, and delivery personnel, backed by a comprehensive data access layer and machine learning-based recipe recommendations.

The client-side component library now includes new UI elements for the food ordering workflow. This adds a recipe card for browsing, a dialog for adding a recipe to the cart, and an enhanced dialog that allows users to edit ingredients and quantities before adding to the cart. Additionally, a component for listing food items in the cart with edit/delete actions and a new dialog for submitting recipe reviews have been introduced.

Src/FoodDesire.Web.Client/Components · high confidence

The \FoodDesire.IMS.Core\ project now includes a new \Json\ helper class that provides asynchronous wrappers for JSON serialization and deserialization using \Newtonsoft.Json\. Additionally, the \FoodDesire.sln\ solution file was created, defining the build configuration for multiple projects including Models, DAL, Core, AppSettings, IMS, Web.API, ML.Model, and Web.Client/Shared.

Src · high confidence

New model classes have been introduced to support the inventory management system: FoodItemDetail for tracking food items with their recipes, quantities, and status; IngredientDetails for managing ingredient attributes like quantity, price, and inventory levels; IngredientForm for handling ingredient creation and editing logic; and InventorySummary for calculating overall stock capacity and low inventory counts. These models provide the underlying data structures for the IMS feature.

Src/FoodDesire.IMS.Core/Models · high confidence

Introduced new model classes to support the application's data layer, including Address, Entity, FoodItemIngredient, RecipeIngredient, and Usings. These models define the structure for managing food items, ingredients, and recipes, with specific attributes for validation and database mapping.

Src/FoodDesire.Models · high confidence

The IMS module now includes a suite of new services that manage application state and navigation. A new ActivationService handles app launch and theme initialization, while a ThemeSelectorService persists and applies the user's light/dark mode preference. LocalSettingsService provides a mechanism for storing and retrieving local configuration data. Additionally, a NavigationService and NavigationViewService coordinate page transitions and menu interactions, all backed by a PageService that maps view models to their corresponding XAML pages.

Src/FoodDesire.IMS/Services · high confidence

The application now includes several new views for managing ingredients, recipes, employees, and deliveries. Specifically, this change introduces the DeliveriesPage, EditRecipePage, EmployeesPage, FoodItemsPage, HomePage, IngredientsPage, and NewRecipePage, each with their corresponding code-behind files. Additionally, new XAML style resources are added to the application, including FontSizes, PrograssBar, TextBlock, and Thickness styles, which define the visual appearance of these new pages.

Src/FoodDesire.IMS/Views · high confidence

The FoodDesire.IMS.Models namespace now includes new model classes to support recipe management. LocalSettingsOptions provides configuration for local storage. RecipeDetail, RecipeListItemDetail, and RecipeForm handle recipe data, including image handling, categories, and ingredient lists. RecipeIngredientForm manages the details for individual ingredients, including pricing and measurement logic. UserDetail handles user profile information and profile picture loading. These models enable the UI to display and edit recipes and ingredients within the IMS system.

Src/FoodDesire.IMS/Models · medium confidence

The application now includes a shared navigation bar and footer for consistent site-wide layout. The navigation bar provides a search function that redirects to the recipe index page, displays user authentication status to show either profile/sign-out or sign-up/sign-in options, and includes a drawer menu with links to Home, Store, Cart, and Orders. The footer component displays company information, contact details, and social media links.

Src/FoodDesire.Web.Client/Shared · high confidence

The IMS module introduces a suite of new viewmodels to support core operational workflows. Suppliers can now manage pending and accepted supplies via the new SuppliesViewModel and CompleteSupplyViewModel. Delivery personnel can view and manage orders through DeliveriesViewModel and DeliveriesDetailViewModel. The system also adds comprehensive management for ingredients and recipes, including creation, editing, and deletion via NewIngredientFormViewModel, EditIngredientViewModel, RecipeFormViewModel, and related components. Additionally, the HomeViewModel now provides a financial overview with income and expense charts, while the SettingsViewModel enables user sign-out and theme switching. These changes collectively enable end-to-end management of ingredients, recipes, supplies, and deliveries within the IMS application.

Src/FoodDesire.IMS/ViewModels · high confidence

The FoodDesire web client is bootstrapped as a Blazor WebAssembly application using the MudBlazor UI framework. The entry point (Program.cs) registers the root App component, head outlet, and MudBlazor services. The App.razor template configures authentication state cascading, authorization-based route views, and 404 handling. The MainLayout.razor integrates the MudBlazor theme provider, dialog provider, snackbar, and app bar, while the accompanying CSS ensures the main content area scrolls within the viewport. Global imports are standardized to include MudBlazor and authorization namespaces.

Src/FoodDesire.Web.Client · high confidence

The Food Desire Web API project has been introduced, providing the backend service for the application. The API is configured to handle user authentication via JWT Bearer tokens and exposes endpoints for recipe management, user authentication, cart management, and order processing. Additionally, the API serves the Blazor client application and includes Swagger UI for interactive API documentation and testing.

Src/FoodDesire.Web.API · high confidence

The application now registers core client-side services and data mappers. The AppConfigurator sets up dependency injection for page-specific services (Home, Recipe, Cart, Account, Order), the component communication service, Blazored LocalStorage, and authentication state providers. The DtoConfigurator defines mapping rules for converting between DTOs and domain models (e.g., FoodItem, Recipe, ShippingAddress).

Src/FoodDesire.Web.Client/Helpers · high confidence

The FoodDesire.ML.Model project has been introduced to host and manage the machine learning model for recipe recommendations. This includes the implementation of a RecommendationService that trains a matrix factorization model using Microsoft ML.NET, evaluating it against a 30% test set, and saving the resulting model to Azure Blob Storage. Additionally, a PredictionService is provided to load the trained model from the cloud and generate individual recipe predictions based on customer and recipe IDs.

Src/FoodDesire.ML.Model · high confidence

Added the primary database context (ApplicationDbContext) which defines the data model for users, accounts, recipes, orders, and related entities, along with configuration for relationships, unique constraints, and complex type conversions. Included a design-time factory to support database migrations.

Src/FoodDesire.DAL/Context · high confidence

The Data Access Layer (DAL) now provides a unified entry point for configuring the application's database context and repository services. A new \Configure\ class registers the \ApplicationDbContext\ with a SQL Server provider and explicitly registers all repository interfaces (such as \IRepository\<Ingredient\>\, \ITrackingRepository\<Payment\>\, and others) as scoped services. This change simplifies the application's startup configuration by consolidating the registration of data access components, ensuring consistent scoped lifetimes for database contexts and repositories across the application.

Src/FoodDesire.DAL · high confidence

The FoodDesire.Core project now provides a centralized \Configure\ class that registers all core business services with the dependency injection container. This includes services for orders, food items, payments, recipes, customers, authentication, accounts, users, suppliers, and reviews, making it easier to initialize the application's service layer.

Src/FoodDesire.Core · high confidence

Added new service interfaces and implementations in the API layer to handle business logic for account management (sign-in, account creation, JWT token generation), cart operations (order creation, cancellation, payment processing), home page content (top 10 recipes, predicted recipes), order retrieval, PayPal integration, and recipe management (search, reviews). This introduces a structured service layer that decouples controllers from direct data access, enabling features like secure user authentication, personalized recipe recommendations, and integrated payment processing.

Src/FoodDesire.Web.API/Services · high confidence

The application now includes a set of new client-side services that handle core user interactions. An \AuthenticationService\ manages access tokens in local storage, while a \UserAuthenticationStateProvider\ integrates with Blazor's authentication system to track user login status. The \AccountPageService\ exposes endpoints for signing up, signing in, and managing customer profiles. A \CartPageService\ allows users to view, update, and pay for orders, and a \RecipePageService\ enables searching for recipes, viewing details, adding items to the cart, and submitting reviews. Additionally, a \ComponentCommunicationService\ is provided to facilitate state changes between components.

Src/FoodDesire.Web.Client/Services · high confidence

The FoodDesire.Models package now includes the foundational entity classes that define the application's data structure. This includes user role definitions (Admin, Chef, Supplier, Deliverer, Customer) and their specific attributes, alongside models for Orders, Deliveries, Payments, Recipes, Ingredients, and their associated statuses. These models establish the relationships and constraints required for the food ordering and delivery system.

FoodDesire.Models · high confidence

The application now includes a comprehensive set of backend services to manage the core entities of the FoodDesire platform. This includes services for handling user authentication and account management (AccountService, AdminService, ChefService, CustomerService, DelivererService, CoreUserService), as well as services for managing orders (OrderService, CustomerOrderService, OrderDeliveryService), food items, ingredients, and recipes. Additionally, new capabilities have been added for processing payments, managing ingredient supplies, and handling recipe reviews.

Src/FoodDesire.Core/Services · high confidence

Added new service classes to handle business logic for various application pages, including deliveries, employees, food items, home, ingredients, recipes, settings, and supplies. These services coordinate with underlying repositories and other services to provide data and actions for the user interface, such as retrieving employee lists, managing supply requests, and handling order deliveries.

Src/FoodDesire.IMS.Core/Services · high confidence

The repository layer now provides two generic base classes, \Repository\<T\>\ and \TrackingRepository\<T\>\, which encapsulate common data access patterns. \Repository\<T\>\ implements standard CRUD operations (Add, Update, Delete, Get) using direct database interactions. \TrackingRepository\<T\>\ extends this with support for soft deletes (marking entities as deleted rather than removing them) and database transaction management. Both classes support filtering, ordering, and eager loading of related entities, providing a consistent interface for database operations across the application.

Src/FoodDesire.DAL/Repositories · high confidence

Adds a suite of helper classes in the IMS module to support application startup, data mapping, and UI interactions. This includes AppConfigurator for registering core services (including AutoMapper and view models), DtoConfigurator for mapping between DTOs and domain models, and various UI helpers such as ContentDialogFactory, FrameExtensions, NavigationHelper, and converters. These changes establish the foundational services and utilities required for the IMS feature set.

Src/FoodDesire.IMS/Helpers · high confidence

The application now defines explicit interfaces for core services, including IActivationService, ILocalSettingsService, INavigationService, INavigationViewService, IPageService, and IThemeSelectorService. These contracts establish the foundation for managing app activation, local storage, navigation flow, and theme selection, enabling a more modular and testable architecture.

Src/FoodDesire.IMS/Contracts/Services · medium confidence

The shared library now includes new C\# classes that define the structure for core domain objects: RecipeDetail and RecipeListItem for recipe data, FoodItemListItem and FoodItemIngredientDetail for food items, OrderRequest and OrderResponse for order processing, SignIn and TokenResponse for authentication, and supporting types like ShippingAddress and AmountWithBreakdown. These models provide the data contracts required for the new recipe, order, and sign-in pages.

Src/FoodDesire.Web.Shared · high confidence

The FoodDesire Inventory Management System (IMS) is now a fully functional WinUI 3 desktop application. Users can now launch the IMS independently, with a dedicated main window featuring Mica backdrop styling and proper DPI awareness. The application initializes via a dependency injection container, automatically ensuring an admin account exists and restoring the current user's session from local settings. The app includes standard configuration files (appsettings.json, Package.appxmanifest) and a README for setup, marking the completion of the IMS module as a distinct, runnable product.

Src/FoodDesire.IMS · high confidence

The API now exposes new controllers for managing user accounts (sign-up, sign-in, edit, delete, and profile retrieval), handling shopping cart operations (viewing, creating, updating, and canceling orders, plus PayPal integration), retrieving and reviewing recipes, and serving a personalized or top-10 recipe list on the home page. These endpoints enable users to authenticate, manage their profile, browse and review recipes, add items to a cart, and complete purchases.

Src/FoodDesire.Web.API/Controllers · high confidence

Added a suite of UI components for the Inventory Management System (IMS), including dialogs and forms for creating and editing ingredients, recipe ingredients, and employee records, as well as detail and list controls for deliveries and food items.

Src/FoodDesire.IMS/Components · high confidence

The application now includes dedicated pages for account management, home, recipes, cart, and orders. Users can sign in or sign up for a new account, view their profile details, and manage their address. The home page displays top recipes and allows users to browse and add items to their cart. Users can view detailed recipe information, including ingredients and reviews. The cart page allows users to review their order, remove items, and proceed to payment via PayPal. Additionally, users can view their order history and individual order details, including status and delivery address.

Src/FoodDesire.Web.Client/Pages · high confidence

The core contracts layer now exposes a set of new service interfaces that define the data operations for each major page in the IMS application. Specifically, IDeliveriesPageService, IEmployeePageService, IFoodItemsPageService, IHomeService, IIngredientsPageService, IRecipesPageService, ISettingsPageService, and ISuppliesPageService have been added to specify the asynchronous methods for retrieving, creating, editing, and deleting entities such as orders, employees, food items, recipes, and supplies. Additionally, IFileService and Usings.cs were added to support file operations and global model references. These interfaces establish the API for the UI to interact with the business logic, enabling features like searching ingredients, managing deliveries, and viewing home dashboards.

Src/FoodDesire.IMS.Core/Contracts · high confidence

The application introduces new repository interfaces, IRepository and ITrackingRepository, which define the contract for data access operations. IRepository provides methods for adding, retrieving, updating, and deleting entities, while ITrackingRepository extends this with soft delete, save changes, and transaction support for tracked entities.

Src/FoodDesire.DAL/Contracts · high confidence

The application now exposes a comprehensive set of service interfaces in the Contracts layer, defining the API for managing users, recipes, orders, ingredients, supplies, and payments. These interfaces (such as IRecipeService, IOrderService, and IIngredientService) establish the boundaries for business logic, enabling the implementation of features like recipe management, order tracking, and supply chain operations.

Src/FoodDesire.Core/Contracts · high confidence

The application now registers a set of page services via dependency injection, including ingredients, supplies, employees, settings, recipes, food items, and deliveries. This wiring enables the corresponding UI pages to access their respective services.

Src/FoodDesire.IMS.Core · high confidence

The legacy Draw.io diagram files for the FoodDesire project have been removed. This includes the backup file (.$FoodDesire.drawio.bkp) and the primary diagram file (FoodDesire.drawio), which previously contained eight pages of diagrams including an ER diagram, use case diagrams, activity diagrams, and an application architecture diagram.

Diagrams · high confidence

The application now includes new activation and behavior classes to support the WinUI 3 Template Studio architecture. The Activation folder introduces an abstract ActivationHandler and a DefaultActivationHandler that manages initial navigation to the Home view. The Behaviors folder adds a NavigationViewHeaderBehavior that dynamically updates the header and title of the navigation view based on the current page's context and mode settings.

Src/FoodDesire.IMS/Activation, Src/FoodDesire.IMS/Behaviors · high confidence

The application now validates required configuration keys at startup, ensuring that essential settings such as database and storage connection strings, JWT signing keys, and PayPal credentials are present. It also switches from appsettings files to dotnet user-secrets for storing sensitive data, with a README providing instructions for setting these secrets.

Src/FoodDesire.AppSettings · medium confidence

The application now uses a centralized \AppConfigurator\ helper to register core services, including database connections, HTTP clients, and specific controller services such as PayPal, Home, Recipe, Cart, Account, and Order controllers. This consolidates the dependency injection setup, ensuring all necessary services are wired up at startup.

Src/FoodDesire.Web.API/Helpers · high confidence

Added IInitializable and INavigationAware interfaces to the ViewModels contract layer, enabling a standardized approach for initializing view models and handling navigation state transitions within the application.

Src/FoodDesire.IMS/Contracts/ViewModels · high confidence

The client-side CSS assets in the wwwroot folder have been updated to include the full Bootstrap 5.1.0 stylesheet, providing a modern, responsive grid system and component styles. Additionally, a new \app.css\ file was introduced to apply a custom theme, defining specific colors for buttons and links, setting up validation state outlines, and styling the Blazor error UI and loading progress indicators.

Src/FoodDesire.Web.Client/wwwroot · high confidence

Added comprehensive unit tests for core domain services; Added test helpers for application host, database context, and test data generation; Added unit tests for the data access layer repositories.

The project has been upgraded to target .NET 7 across all components, including the IMS, Web API, and Blazor client applications. This update introduces modern C\# features such as implicit usings and nullable reference types by default. Additionally, the solution has been restructured into distinct projects (Core, DAL, Models, etc.) with updated NuGet package references, including EF Core 7.0.5, Blazor libraries, and WinUI dependencies, ensuring compatibility with the new framework version.

(dependencies) · high confidence

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

• CAI 44 → 42 (-1.7)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 63 → 52 (-10.4)
• Architecture 66 → 66 (+0.2)
• Maturity 66 → 66 (+0.0)
• Readiness 31 → 32 (+1.1)
• Security 52 → 48 (-3.9)
• Accessibility 49 → 46 (-3.4)

• Bounded contexts not declared
• Build did not complete in the analyzer
• Change coupling clique: AdminService.cs, ChefService.cs, CustomerService.cs, DelivererService.cs, SupplierService.cs (Src/FoodDesire.Core/Services/AdminService.cs)
• Coverage not measured — analyzer environment
• Duplicated block (11 lines × 2) (Src/FoodDesire.IMS/ViewModels/EditIngredientViewModel.cs)
• Duplicated block (5 lines × 2) (Src/FoodDesire.DAL/Context/ApplicationDbContext.cs)
• Duplicated block (6 lines × 2) (Src/FoodDesire.IMS/ViewModels/HomeViewModel.cs)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 13 more

• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (10–11 lines × 2) (Src/FoodDesire.Web.Client/Components/AddRecipeToCartDialogComponent.razor.cs)
• Duplicated block (11 lines × 2) (Src/FoodDesire.Models/FoodItemIngredient.cs)
• Duplicated block (12 lines × 2) (Src/FoodDesire.IMS/ViewModels/SettingsViewModel.cs)
• Duplicated block (13 lines × 2) (Src/FoodDesire.IMS/ViewModels/EditIngredientViewModel.cs)
• Duplicated block (13 lines × 2) (Src/FoodDesire.IMS/ViewModels/EditIngredientViewModel.cs)
• Duplicated block (5 lines × 2) (Src/FoodDesire.DAL/Context/ApplicationDbContext.cs)
• Duplicated block (6 lines × 2) (Src/FoodDesire.IMS/ViewModels/HomeViewModel.cs)
• Duplicated block (6 lines × 2) (Src/FoodDesire.Web.Client/Pages/HomePages/Index.razor.cs)
• Duplicated block (7 lines × 2) (Src/FoodDesire.IMS/ViewModels/HomeViewModel.cs)
• Duplicated block (8–9 lines × 2) (Src/FoodDesire.Web.Client/Pages/HomePages/Index.razor.cs)
• Duplicated block (9 lines × 2) (Src/FoodDesire.Web.Client/Pages/HomePages/Index.razor.cs)
• End-of-life runtime: .NET net7.0
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 39 more

• Unchanged — 3 HTTP endpoints

• Unchanged — 3 containers · 1 contexts · 0 edges

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

haritha99ch/FoodDesire 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.