📦 Warehouse Inventory Management System

(ASP.NET Core 8 – Razor Pages – Clean Architecture)

A full-featured Warehouse Inventory Management System built with ASP.NET Core 8 Razor Pages and Entity Framework Core, following Clean Architecture principles.

This project demonstrates how to structure a real-world ASP.NET Core application with:

• Domain layer
• Application layer
• Infrastructure layer
• Web (UI) layer

It includes authentication, role-based access (Admin & Customer), inventory management, orders, and clean separation of concerns.

🚀 Key Features

🔐 Authentication & Authorization

• ASP.NET Identity integration
• Separate Admin and Customer roles
• Login & Register for both roles
• Role-based page access

📦 Inventory Management (Admin)

• Create and edit inventory items
• Manage categories and suppliers
• Track item status and stock quantity
• View warehouse logs

🛒 Orders & Cart System (Customer)

• Browse item catalog
• View item details
• Add items to cart
• Place orders
• View order history

🧱 Clean Architecture Design

• Domain entities isolated from UI & database
• Repository pattern
• Service layer for business logic
• DTOs for data transfer
• AutoMapper for mapping entities to DTOs

🗃️ Database & Data Management

• Entity Framework Core (Code First)
• SQL Server database
• Migrations support
• Database seeding
• Generic repository implementation

🧪 Error Handling & Validation

• Custom exceptions (NotFound, OperationFailed)
• Server-side validation
• Model binding

🛠️ Technologies

• ASP.NET Core 8.0 (Razor Pages)
• Entity Framework Core 8.0
• SQL Server
• ASP.NET Identity
• AutoMapper
• Clean Architecture

📸 Snapshots / Screenshots

• Customer Login

• Customer Dashboard

• Catalog View (Customer)

• View Item Details

• Customer Cart

• Admin Login

• Admin Dashboard

• Warehouse Item List

• Add New Item

• Filter Items Modal

• Supplier List

• Add New Supplier

• Warehouse Orders List

• Order Details View

• Receive Shipment

• Adjust Stock Levels

• Add Item-Supplier Relation

📂 Project Structure (Clean Architecture – Detailed)

📦 ASP.NET-Core-8-Warehouse-Inventory-System
│
├── Domain                        → Core business layer
│   ├── Entities (Item, Category, Supplier, Order, OrderItem, WarehouseLog, Status enums)
│   ├── Interfaces (IRepository, IOrderItemRepository)
│   └── Domain.csproj
│
├── Application                   → Application contracts & DTOs
│   ├── DTOs (ItemDto, OrderDto, SupplierDto, CategoryDto, ItemFilterDto, WarehouseLogDto)
│   ├── Interfaces (IItemsService, IOrderService, ISupplierService, ICategoryService, IAdminService, ICustomerService)
│   ├── Mappings (AutoMapper profile)
│   ├── Common/Exceptions (NotFoundException, OperationFailedException)
│   └── Application.csproj
│
├── Infrastructure                → Implementations & data access
│   ├── Data (AppDbContext, Repository, OrderItemRepository)
│   ├── Services (ItemService, OrderService, SupplierService, CategoryService, WarehouseLogService, ItemStatusService)
│   ├── Identity (ApplicationUser, IdentityService, AdminService, CustomerService, Role seeding)
│   ├── Migrations
│   └── Infrastructure.csproj
│
├── Web                           → Presentation layer (Razor Pages UI)
│   ├── Pages
│   │   ├── Admin (Auth, Items, Orders, Suppliers)
│   │   ├── Customer (Auth, Catalogs, Carts)
│   │   ├── Shared (_Layout, Sidebars)
│   │   └── Index.cshtml
│   │
│   ├── wwwroot (CSS, JS, images)
│   ├── Program.cs (Dependency Injection & middleware)
│   ├── appsettings.json
│   └── Web.csproj
│
└── Warehouse.sln

🧠 Architecture Overview

This project follows Clean Architecture:

🔹 Domain Layer

Contains only business entities and repository contracts:

• Item, Order, Supplier, WarehouseLog
• IRepository

No dependency on EF Core or UI.

🔹 Application Layer

Defines use-cases and data transfer:

• DTOs
• Service interfaces
• AutoMapper profile
• Custom exceptions

🔹 Infrastructure Layer

Implements application contracts using:

• EF Core (AppDbContext)
• Repository pattern
• Business services
• ASP.NET Identity
• Database migrations

🔹 Web Layer

Razor Pages UI:

• Admin area
• Customer area
• Authentication pages
• Layout & shared components
• Dependency injection configuration

⚙️ Installation & Setup

1. Clone the repository:

git clone https://github.com/Alireza-Jafari-tech/ASP.NET-Core-8-Warehouse-Inventory-System.git
cd ASP.NET-Core-8-Warehouse-Inventory-System

2. Update connection string in Web/appsettings.json:

"ConnectionStrings": {
  "DefaultConnection": "Server=localhost;Database=WarehouseDb;Trusted_Connection=True;TrustServerCertificate=True"
}

3. Apply migrations:

dotnet ef database update

4. Run the application:

dotnet run --project Web

5. Open in browser:

[http://localhost:5258]

6. Demo Accounts:

• Admin User:

• Email: michael.anderson@warehouse.com
• Password: Admin123!

• Customer Account:

• Email: john.smith@amazon.com
• Password: Amazon12!

🧑‍💻 Usage

Admin

• Login/Register as Admin
• Manage items, categories, suppliers
• View and manage orders
• Track warehouse logs

Customer

• Register/Login
• Browse catalog
• Add items to cart
• Place orders
• View order history

🎯 Learning Goals

• Apply Clean Architecture in ASP.NET Core
• Implement Repository & Service patterns
• Work with ASP.NET Identity
• Build real-world Razor Pages UI
• Practice EF Core migrations
• Implement DTOs and AutoMapper
• Understand layered architecture

📝 License

This project is licensed under the MIT License. See the LICENSE file for details.

🤝 Contributing

This project is for learning purposes, but feel free to fork and improve it. Suggestions, issues, and pull requests are welcome!