Project Introduction

The Car Sales and Inventory Store Project is designed to provide a comprehensive solution for managing the sales and inventory of vehicles. Built using ASP.NET and SQL Server, this application aims to streamline the processes involved in vehicle sales, customer management, inventory tracking, and reporting. The system will allow users to manage vehicle listings, track sales transactions, and generate reports, enhancing the overall efficiency of car dealerships.

Project Objectives

• To create a user-friendly interface for managing vehicle sales and inventory.
• To implement a secure authentication system for users with different roles (e.g., admin, sales staff).
• To manage vehicle details, including make, model, year, and pricing.
• To facilitate customer management, including registration and tracking of customer interactions.
• To handle sales transactions, including payment processing and invoice generation.
• To generate reports on sales performance, revenue, and inventory status.
• To manage promotional campaigns and test drive requests for potential customers.

Project Modules

1. User Management Module: Handles user registration, login, and role management.
2. Vehicle Management Module: Manages vehicle details, including inventory and pricing.
3. Customer Management Module: Facilitates the registration and management of customer information.
4. Sales Management Module: Handles sales transactions, including payment processing and invoice generation.
5. Payment Management Module: Manages payment details and statuses for sales.
6. Reporting Module: Generates reports on sales, revenue, and inventory metrics.
7. Campaign Management Module: Manages promotional campaigns and discounts for vehicles.
8. Test Drive Management Module: Facilitates scheduling and tracking of test drives for customers.
9. Service Record Management Module: Tracks service records and maintenance for vehicles.

SQL Server Database Tables

-- Users Table
CREATE TABLE Users (
    UserId INT PRIMARY KEY IDENTITY(1,1),
    Username NVARCHAR(50) NOT NULL UNIQUE,
    PasswordHash NVARCHAR(255) NOT NULL,
    Email NVARCHAR(100) NOT NULL UNIQUE,
    Phone NVARCHAR(15),
    RoleId INT,
    CreatedAt DATETIME DEFAULT GETDATE(),
    UpdatedAt DATETIME DEFAULT GETDATE(),
    FOREIGN KEY (RoleId) REFERENCES Roles(RoleId)
);
-- Roles Table
CREATE TABLE Roles (
    RoleId INT PRIMARY KEY IDENTITY(1,1),
    RoleName NVARCHAR(50) NOT NULL UNIQUE
);
-- Vehicles Table
CREATE TABLE Vehicles (
    VehicleId INT PRIMARY KEY IDENTITY(1,1),
    Make NVARCHAR(50) NOT NULL,
    Model NVARCHAR(50) NOT NULL,
    Year INT NOT NULL,
    VIN NVARCHAR(17) NOT NULL UNIQUE,
    Color NVARCHAR(30),
    Price DECIMAL(10, 2) NOT NULL,
    CreatedAt DATETIME DEFAULT GETDATE(),
    UpdatedAt DATETIME DEFAULT GETDATE()
);
-- Inventory Table
CREATE TABLE Inventory (
    InventoryId INT PRIMARY KEY IDENTITY(1,1),
    VehicleId INT,
    Quantity INT NOT NULL,
    CreatedAt DATETIME DEFAULT GETDATE(),
    UpdatedAt DATETIME DEFAULT GETDATE(),
    FOREIGN KEY (VehicleId) REFERENCES Vehicles(VehicleId)
);
-- Customers Table
CREATE TABLE Customers (
    CustomerId INT PRIMARY KEY IDENTITY(1,1),
    FirstName NVARCHAR(50) NOT NULL,
    LastName NVARCHAR(50) NOT NULL,
    Email NVARCHAR(100) NOT NULL UNIQUE,
    Phone NVARCHAR(15),
    CreatedAt DATETIME DEFAULT GETDATE(),
    UpdatedAt DATETIME DEFAULT GETDATE()
);
-- Sales Table
CREATE TABLE Sales (
    SaleId INT PRIMARY KEY IDENTITY(1,1),
    VehicleId INT,
    CustomerId INT,
    SaleDate DATETIME DEFAULT GETDATE(),
    SalePrice DECIMAL(10, 2) NOT NULL,
    PaymentId INT,
    FOREIGN KEY (VehicleId) REFERENCES Vehicles(VehicleId),
    FOREIGN KEY (CustomerId) REFERENCES Customers(CustomerId),
    FOREIGN KEY (PaymentId) REFERENCES Payments(PaymentId)
);
-- Payments Table
CREATE TABLE Payments (
    PaymentId INT PRIMARY KEY IDENTITY(1,1),
    SaleId INT,
    PaymentDate DATETIME DEFAULT GETDATE(),
    Amount DECIMAL(10, 2) NOT NULL,
    PaymentMethod NVARCHAR(50),
    Status NVARCHAR(20) DEFAULT 'Pending',
    FOREIGN KEY (SaleId) REFERENCES Sales(SaleId)
);
-- Invoices Table
CREATE TABLE Invoices (
    InvoiceId INT PRIMARY KEY IDENTITY(1,1),
    SaleId INT,
    InvoiceDate DATETIME DEFAULT GETDATE(),
    TotalAmount DECIMAL(10, 2) NOT NULL,
    FOREIGN KEY (SaleId) REFERENCES Sales(SaleId)
);
-- Reports Table
CREATE TABLE Reports (
    ReportId INT PRIMARY KEY IDENTITY(1,1),
    ReportDate DATETIME DEFAULT GETDATE(),
    TotalSales INT,
    TotalRevenue DECIMAL(10, 2),
    CreatedAt DATETIME DEFAULT GETDATE()
);
-- Campaigns Table
CREATE TABLE Campaigns (
    CampaignId INT PRIMARY KEY IDENTITY(1,1),
    CampaignName NVARCHAR(100) NOT NULL,
    StartDate DATETIME,
    EndDate DATETIME,
    DiscountPercentage DECIMAL(5, 2),
    CreatedAt DATETIME DEFAULT GETDATE(),
    UpdatedAt DATETIME DEFAULT GETDATE()
);
-- Test Drives Table
CREATE TABLE TestDrives (
    TestDriveId INT PRIMARY KEY IDENTITY(1,1),
    CustomerId INT,
    VehicleId INT,
    TestDriveDate DATETIME,
    Status NVARCHAR(20) DEFAULT 'Scheduled',
    FOREIGN KEY (CustomerId) REFERENCES Customers(CustomerId),
    FOREIGN KEY (VehicleId) REFERENCES Vehicles(VehicleId)
);
-- Service Records Table
CREATE TABLE ServiceRecords (
    ServiceRecordId INT PRIMARY KEY IDENTITY(1,1),
    VehicleId INT,
    ServiceDate DATETIME,
    Description NVARCHAR(MAX),
    Cost DECIMAL(10, 2),
    FOREIGN KEY (VehicleId) REFERENCES Vehicles(VehicleId)
);

Explanation of Tables

Users: Stores user information, including their role.

Roles: Defines different roles (e.g., Admin, Salesperson) in the system.

Vehicles: Contains details about the vehicles available for sale.

Inventory: Tracks the quantity of each vehicle in stock.

Customers: Stores customer information for sales and service records.

Sales: Records details of each sale, linking vehicles to customers.

Payments: Manages payment information related to sales.

Invoices: Generates invoices for completed sales.

Reports: Summarizes sales data for analysis.

Campaigns: Manages marketing campaigns and discounts.

Test Drives: Records test drive requests and their statuses.

Service Records: Tracks service history for vehicles sold.

Creating a Model and Repository Pattern

To create a model and repository pattern using ADO.NET for the provided SQL Server tables in an ASP.NET application, we will follow these steps:

Step 1: Create Models

Here are the C# model classes for each table:

public class User
{
    public int UserId { get; set; }
    public string Username { get; set; }
    public string PasswordHash { get; set; }
    public string Email { get; set; }
    public string Phone { get; set; }
    public int? RoleId { get; set; }
    public DateTime CreatedAt { get; set; }
    public DateTime UpdatedAt { get; set; }
}
public class Role
{
    public int RoleId { get; set; }
    public string RoleName { get; set; }
}
public class Vehicle
{
    public int VehicleId { get; set; }
    public string Make { get; set; }
    public string Model { get; set; }
    public int Year { get; set; }
    public string VIN { get; set; }
    public string Color { get; set; }
    public decimal Price { get; set; }
    public DateTime CreatedAt { get; set; }
    public DateTime UpdatedAt { get; set; }
}
public class Inventory
{
    public int InventoryId { get; set; }
    public int VehicleId { get; set; }
    public int Quantity { get; set; }
    public DateTime CreatedAt { get; set; }
    public DateTime UpdatedAt { get; set; }
}
public class Customer
{
    public int CustomerId { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Email { get; set; }
    public string Phone { get; set; }
    public DateTime CreatedAt { get; set; }
    public DateTime UpdatedAt { get; set; }
}
public class Sale
{
    public int SaleId { get; set; }
    public int VehicleId { get; set; }
    public int CustomerId { get; set; }
    public DateTime SaleDate { get; set; }
    public decimal SalePrice { get; set; }
    public int? PaymentId { get; set; }
}
public class Payment
{
    public int PaymentId { get; set; }
    public int SaleId { get; set; }
    public DateTime PaymentDate { get; set; }
    public decimal Amount { get; set; }
    public string PaymentMethod { get; set; }
    public string Status { get; set; }
}
public class Invoice
{
    public int InvoiceId { get; set; }
    public int SaleId { get; set; }
    public DateTime InvoiceDate { get; set; }
    public decimal TotalAmount { get; set; }
}
public class Report
{
    public int ReportId { get; set; }
    public DateTime ReportDate { get; set; }
    public int TotalSales { get; set; }
    public decimal TotalRevenue { get; set; }
    public DateTime CreatedAt { get; set; }
}
public class Campaign
{
    public int CampaignId { get; set; }
    public string CampaignName { get; set; }
    public DateTime? StartDate { get; set; }
    public DateTime? EndDate { get; set; }
    public decimal? DiscountPercentage { get; set; }
    public DateTime CreatedAt { get; set; }
    public DateTime UpdatedAt { get; set; }
}
public class TestDrive
{
    public int TestDriveId { get; set; }
    public int CustomerId { get; set; }
    public int VehicleId { get; set; }
    public DateTime TestDriveDate { get; set; }
    public string Status { get; set; }
}
public class ServiceRecord
{
    public int ServiceRecordId { get; set; }
    public int VehicleId { get; set; }
    public DateTime ServiceDate { get; set; }
    public string Description { get; set; }
    public decimal? Cost { get; set; }
}

Step 2: Create Repositories

Here is an example of a repository for the User model. You can create similar repositories for other models.

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Configuration;
public class UserRepository
{
    private readonly string _connectionString;
    public UserRepository()
    {
        _connectionString = ConfigurationManager.ConnectionStrings["YourConnectionStringName"].ConnectionString;
    }
    public IEnumerable<User> GetAllUsers()
    {
        var users = new List<User>();
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("SELECT * FROM Users", connection);
            connection.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                users.Add(new User
                {
                    UserId = (int)reader["User Id"],
                    Username = reader["Username"].ToString(),
                    PasswordHash = reader["PasswordHash"].ToString(),
                    Email = reader["Email"].ToString(),
                    Phone = reader["Phone"]?.ToString(),
                    RoleId = reader["RoleId"] as int?,
                    CreatedAt = (DateTime)reader["CreatedAt"],
                    UpdatedAt = (DateTime)reader["UpdatedAt"]
                });
            }
 }
        return users;
    }
    public User GetUser ById(int userId)
    {
        User user = null;
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("SELECT * FROM Users WHERE UserId = @User Id", connection);
            command.Parameters.AddWithValue("@User Id", userId);
            connection.Open();
            SqlDataReader reader = command.ExecuteReader();
            if (reader.Read())
            {
                user = new User
                {
                    UserId = (int)reader["User Id"],
                    Username = reader["Username"].ToString(),
                    PasswordHash = reader["PasswordHash"].ToString(),
                    Email = reader["Email"].ToString(),
                    Phone = reader["Phone"]?.ToString(),
                    RoleId = reader["RoleId"] as int?,
                    CreatedAt = (DateTime)reader["CreatedAt"],
                    UpdatedAt = (DateTime)reader["UpdatedAt"]
                };
            }
        }
        return user;
    }
    public void AddUser (User user)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("INSERT INTO Users (Username, PasswordHash, Email, Phone, RoleId) VALUES (@Username, @PasswordHash, @Email, @Phone, @RoleId)", connection);
            command.Parameters.AddWithValue("@Username", user.Username);
            command.Parameters.AddWithValue("@PasswordHash", user.PasswordHash);
            command.Parameters.AddWithValue("@Email", user.Email);
            command.Parameters.AddWithValue("@Phone", user.Phone);
            command.Parameters.AddWithValue("@RoleId", user.RoleId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void UpdateUser (User user)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("UPDATE Users SET Username = @Username, PasswordHash = @PasswordHash, Email = @Email, Phone = @Phone, RoleId = @RoleId, UpdatedAt = GETDATE() WHERE UserId = @User Id", connection);
            command.Parameters.AddWithValue("@User Id", user.UserId);
            command.Parameters.AddWithValue("@Username", user.Username);
            command.Parameters.AddWithValue("@PasswordHash", user.PasswordHash);
            command.Parameters.AddWithValue("@Email", user.Email);
            command.Parameters.AddWithValue("@Phone", user.Phone);
            command.Parameters.AddWithValue("@RoleId", user.RoleId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void DeleteUser (int userId)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("DELETE FROM Users WHERE UserId = @User Id", connection);
            command.Parameters.AddWithValue("@User Id", userId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

This repository pattern can be replicated for other models such as Role, Vehicle, Customer, etc., by creating similar classes and methods tailored to their respective database operations.

Sure! Below are the repository classes for the remaining models: Role, Vehicle, Inventory, Customer, Sale, Payment, Invoice, Report, Campaign, TestDrive, and ServiceRecord. Each repository will include methods for basic CRUD operations.

RoleRepository

public class RoleRepository
{
    private readonly string _connectionString;
    public RoleRepository()
    {
        _connectionString = ConfigurationManager.ConnectionStrings["YourConnectionStringName"].ConnectionString;
    }
    public IEnumerable<Role> GetAllRoles()
    {
        var roles = new List<Role>();
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("SELECT * FROM Roles", connection);
            connection.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                roles.Add(new Role
                {
                    RoleId = (int)reader["RoleId"],
                    RoleName = reader["RoleName"].ToString()
                });
            }
        }
        return roles;
    }
    public Role GetRoleById(int roleId)
    {
        Role role = null;
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("SELECT * FROM Roles WHERE RoleId = @RoleId", connection);
            command.Parameters.AddWithValue("@RoleId", roleId);
            connection.Open();
            SqlDataReader reader = command.ExecuteReader();
            if (reader.Read())
            {
                role = new Role
                {
                    RoleId = (int)reader["RoleId"],
                    RoleName = reader["RoleName"].ToString()
                };
            }
        }
        return role;
    }
    public void AddRole(Role role)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("INSERT INTO Roles (RoleName) VALUES (@RoleName)", connection);
            command.Parameters.AddWithValue("@RoleName", role.RoleName);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void UpdateRole(Role role)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("UPDATE Roles SET RoleName = @RoleName WHERE RoleId = @RoleId", connection);
            command.Parameters.AddWithValue("@RoleId", role.RoleId);
            command.Parameters.AddWithValue("@RoleName", role.RoleName);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void DeleteRole(int roleId)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("DELETE FROM Roles WHERE RoleId = @RoleId", connection);
            command.Parameters.AddWithValue("@RoleId", roleId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

VehicleRepository

public class VehicleRepository
{
    private readonly string _connectionString;
    public VehicleRepository()
    {
        _connectionString = ConfigurationManager.ConnectionStrings["YourConnectionStringName"].ConnectionString;
    }
    public IEnumerable<Vehicle> GetAllVehicles()
    {
        var vehicles = new List<Vehicle>();
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("SELECT * FROM Vehicles", connection);
            connection.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                vehicles.Add(new Vehicle
                {
                    VehicleId = (int)reader["VehicleId"],
                    Make = reader["Make"].ToString(),
                    Model = reader["Model"].ToString(),
                    Year = (int)reader["Year"],
                    VIN = reader["VIN"].ToString(),
                    Color = reader["Color"]?.ToString(),
                    Price = (decimal)reader["Price"],
                    CreatedAt = (DateTime)reader["CreatedAt"],
                    UpdatedAt = (DateTime)reader["UpdatedAt"]
                });
            }
        }
        return vehicles;
    }
    public Vehicle GetVehicleById(int vehicleId)
    {
        Vehicle vehicle = null;
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("SELECT * FROM Vehicles WHERE VehicleId = @VehicleId", connection);
            command.Parameters.AddWithValue("@VehicleId", vehicleId);
            connection.Open();
            SqlDataReader reader = command.ExecuteReader();
            if (reader.Read())
            {
                vehicle = new Vehicle
                {
                    VehicleId = (int)reader["VehicleId"],
                    Make = reader["Make"].ToString(),
                    Model = reader["Model"].ToString(),
                    Year = (int)reader["Year"],
                    VIN = reader["VIN"].ToString(),
                    Color = reader["Color"]?.ToString(),
                    Price = (decimal)reader["Price"],
                    CreatedAt = (DateTime)reader["CreatedAt"],
                    UpdatedAt = (DateTime)reader["UpdatedAt"]
                };
            }
        }
        return vehicle;
    }
    public void AddVehicle(Vehicle vehicle)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("INSERT INTO Vehicles (Make, Model, Year, VIN, Color, Price) VALUES (@Make, @Model, @Year, @VIN, @Color, @Price)", connection);
            command.Parameters.AddWithValue("@Make", vehicle.Make);
            command.Parameters.AddWithValue("@Model", vehicle.Model);
            command.Parameters.AddWithValue("@Year", vehicle.Year);
            command.Parameters.AddWithValue("@VIN", vehicle.VIN);
            command.Parameters.AddWithValue("@Color", vehicle.Color);
            command.Parameters.AddWithValue("@Price", vehicle.Price);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void UpdateVehicle(Vehicle vehicle)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("UPDATE Vehicles SET Make = @Make, Model = @Model, Year = @Year, VIN = @VIN, Color = @Color, Price = @Price, UpdatedAt = GETDATE() WHERE VehicleId = @VehicleId", connection);
            command.Parameters.AddWithValue("@VehicleId", vehicle.VehicleId);
            command.Parameters.AddWithValue("@Make", vehicle.Make);
            command.Parameters.AddWithValue("@Model", vehicle.Model);
            command.Parameters.AddWithValue("@Year", vehicle.Year);
            command.Parameters.AddWithValue("@VIN", vehicle.VIN);
            command.Parameters.AddWithValue("@Color", vehicle.Color);
            command.Parameters.AddWithValue("@Price", vehicle.Price);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void DeleteVehicle(int vehicleId)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("DELETE FROM Vehicles WHERE VehicleId = @VehicleId", connection);
            command.Parameters.AddWithValue("@VehicleId", vehicleId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

InventoryRepository

public class InventoryRepository
{
    private readonly string _connectionString;
    public InventoryRepository()
    {
        _connectionString = ConfigurationManager.ConnectionStrings["YourConnectionStringName"].ConnectionString;
    }
    public IEnumerable<Inventory> GetAllInventories()
    {
        var inventories = new List<Inventory>();
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("SELECT * FROM Inventory", connection);
            connection.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                inventories.Add(new Inventory
                {
                    InventoryId = (int)reader["InventoryId"],
                    VehicleId = (int)reader["VehicleId"],
                    Quantity = (int)reader["Quantity"],
                    CreatedAt = (DateTime)reader["CreatedAt"],
                    UpdatedAt = (DateTime)reader["UpdatedAt"]
                });
            }
        }
        return inventories;
    }
    public Inventory GetInventoryById(int inventoryId)
    {
        Inventory inventory = null;
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("SELECT * FROM Inventory WHERE InventoryId = @InventoryId", connection);
            command.Parameters.AddWithValue("@InventoryId", inventoryId);
            connection.Open();
            SqlDataReader reader = command.ExecuteReader();
            if (reader.Read())
            {
                inventory = new Inventory
                {
                    InventoryId = (int)reader["InventoryId"],
                    VehicleId = (int)reader["VehicleId"],
                    Quantity = (int)reader["Quantity"],
                    CreatedAt = (DateTime)reader["CreatedAt"],
                    UpdatedAt = (DateTime)reader["UpdatedAt"]
                };
            }
        }
        return inventory;
    }
    public void AddInventory(Inventory inventory)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("INSERT INTO Inventory (VehicleId, Quantity) VALUES (@VehicleId, @Quantity)", connection);
            command.Parameters.AddWithValue("@VehicleId", inventory.VehicleId);
            command.Parameters.AddWithValue("@Quantity", inventory.Quantity);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void UpdateInventory(Inventory inventory)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("UPDATE Inventory SET VehicleId = @VehicleId, Quantity = @Quantity, UpdatedAt = GETDATE() WHERE InventoryId = @InventoryId", connection);
            command.Parameters.AddWithValue("@InventoryId", inventory.InventoryId);
            command.Parameters.AddWithValue("@VehicleId", inventory.VehicleId);
            command.Parameters.AddWithValue("@Quantity", inventory.Quantity);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void DeleteInventory(int inventoryId)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("DELETE FROM Inventory WHERE InventoryId = @InventoryId", connection);
            command.Parameters.AddWithValue("@InventoryId", inventoryId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

CustomerRepository

public class CustomerRepository
{
    private readonly string _connectionString;
    public CustomerRepository()
    {
        _connectionString = ConfigurationManager.ConnectionStrings["YourConnectionStringName"].ConnectionString;
    }
    public IEnumerable<Customer> GetAllCustomers()
    {
        var customers = new List<Customer>();
        
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("SELECT * FROM Customers", connection);
            connection.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                customers.Add(new Customer
                {
                    CustomerId = (int)reader["CustomerId"],
                    FirstName = reader["FirstName"].ToString(),
                    LastName = reader["LastName"].ToString(),
                    Email = reader["Email"].ToString(),
                    Phone = reader["Phone"]?.ToString(),
                    CreatedAt = (DateTime)reader["CreatedAt"],
                    UpdatedAt = (DateTime)reader["UpdatedAt"]
                });
            }
        }
        return customers;
    }
    public Customer GetCustomerById(int customerId)
    {
        Customer customer = null;
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("SELECT * FROM Customers WHERE CustomerId = @CustomerId", connection);
            command.Parameters.AddWithValue("@CustomerId", customerId);
            connection.Open();
            SqlDataReader reader = command.ExecuteReader();
            if (reader.Read())
            {
                customer = new Customer
                {
                    CustomerId = (int)reader["CustomerId"],
                    FirstName = reader["FirstName"].ToString(),
                    LastName = reader["LastName"].ToString(),
                    Email = reader["Email"].ToString(),
                    Phone = reader["Phone"]?.ToString(),
                    CreatedAt = (DateTime)reader["CreatedAt"],
                    UpdatedAt = (DateTime)reader["UpdatedAt"]
                };
            }
        }
        return customer;
    }
    public void AddCustomer(Customer customer)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("INSERT INTO Customers (FirstName, LastName, Email, Phone) VALUES (@FirstName, @LastName, @Email, @Phone)", connection);
            command.Parameters.AddWithValue("@FirstName", customer.FirstName);
            command.Parameters.AddWithValue("@LastName", customer.LastName);
            command.Parameters.AddWithValue("@Email", customer.Email);
            command.Parameters.AddWithValue("@Phone", customer.Phone);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void UpdateCustomer(Customer customer)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("UPDATE Customers SET FirstName = @FirstName, LastName = @LastName, Email = @Email, Phone = @Phone, UpdatedAt = GETDATE() WHERE CustomerId = @CustomerId", connection);
            command.Parameters.AddWithValue("@CustomerId", customer.CustomerId);
            command.Parameters.AddWithValue("@FirstName", customer.FirstName);
            command.Parameters.AddWithValue("@LastName", customer.LastName);
            command.Parameters.AddWithValue("@Email", customer.Email);
            command.Parameters.AddWithValue("@Phone", customer.Phone);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void DeleteCustomer(int customerId)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("DELETE FROM Customers WHERE CustomerId = @CustomerId", connection);
            command.Parameters.AddWithValue("@CustomerId", customerId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

SaleRepository

public class SaleRepository
{
    private readonly string _connectionString;
    public SaleRepository()
    {
        _connectionString = ConfigurationManager.ConnectionStrings["YourConnectionStringName"].ConnectionString;
    }
    public IEnumerable<Sale> GetAllSales()
    {
        var sales = new List<Sale>();
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("SELECT * FROM Sales", connection);
            connection.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                sales.Add(new Sale
                {
                    SaleId = (int)reader["SaleId"],
                    VehicleId = (int)reader["VehicleId"],
                    CustomerId = (int)reader["CustomerId"],
                    SaleDate = (DateTime)reader["SaleDate"],
                    SalePrice = (decimal)reader["SalePrice"],
                    PaymentId = reader["PaymentId"] as int?
                });
            }
        }
        return sales;
    }
    public Sale GetSaleById(int saleId)
    {
        Sale sale = null;
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("SELECT * FROM Sales WHERE SaleId = @SaleId", connection);
            command.Parameters.AddWithValue("@SaleId", saleId);
            connection.Open();
            SqlDataReader reader = command.ExecuteReader();
            if (reader.Read())
            {
                sale = new Sale
                {
                    SaleId = (int)reader["SaleId"],
                    VehicleId = (int)reader["VehicleId"],
                    CustomerId = (int)reader["CustomerId"],
                    SaleDate = (DateTime)reader["SaleDate"],
                    SalePrice = (decimal)reader["SalePrice"],
                    PaymentId = reader["PaymentId"] as int?
                };
            }
        }
        return sale;
    }
    public void AddSale(Sale sale)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("INSERT INTO Sales (VehicleId, CustomerId, SaleDate, SalePrice, PaymentId) VALUES (@VehicleId, @CustomerId, @SaleDate, @SalePrice, @PaymentId)", connection);
            command.Parameters.AddWithValue("@VehicleId", sale.VehicleId);
            command.Parameters.AddWithValue("@CustomerId", sale.CustomerId);
            command.Parameters.AddWithValue("@SaleDate", sale.SaleDate);
            command.Parameters.AddWithValue("@SalePrice", sale.SalePrice);
            command.Parameters.AddWithValue("@PaymentId", sale.PaymentId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void UpdateSale(Sale sale)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("UPDATE Sales SET VehicleId = @VehicleId, CustomerId = @CustomerId, SaleDate = @SaleDate, SalePrice = @SalePrice, PaymentId = @PaymentId WHERE SaleId = @SaleId", connection);
            command.Parameters.AddWithValue("@SaleId", sale.SaleId);
            command.Parameters.AddWithValue("@VehicleId", sale.VehicleId);
            command.Parameters.AddWithValue("@CustomerId", sale.CustomerId);
            command.Parameters.AddWithValue("@SaleDate", sale.SaleDate);
            command.Parameters.AddWithValue("@SalePrice", sale.SalePrice);
            command.Parameters.AddWithValue("@PaymentId", sale.PaymentId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void DeleteSale(int saleId)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("DELETE FROM Sales WHERE SaleId = @SaleId", connection);
            command.Parameters.AddWithValue("@SaleId", saleId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

PaymentRepository

public class PaymentRepository
{
    private readonly string _connectionString;
    public PaymentRepository()
    {
        _connectionString = ConfigurationManager.ConnectionStrings["YourConnectionStringName"].ConnectionString;
    }
    public IEnumerable<Payment> GetAllPayments()
    {
        var payments = new List<Payment>();
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("SELECT * FROM Payments", connection);
            connection.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                payments.Add(new Payment
                {
                    PaymentId = (int)reader["PaymentId"],
                    SaleId = (int)reader["SaleId"],
                    PaymentDate = (DateTime)reader["PaymentDate"],
                    Amount = (decimal)reader["Amount"],
                    PaymentMethod = reader["PaymentMethod"].ToString(),
                    Status = reader["Status"].ToString()
                });
            }
        }
        return payments;
    }
    public Payment GetPaymentById(int paymentId)
    {
        Payment payment = null;
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("SELECT * FROM Payments WHERE PaymentId = @PaymentId", connection);
            command.Parameters.AddWithValue("@PaymentId", paymentId);
            connection.Open();
            SqlDataReader reader = command.ExecuteReader();
            if (reader.Read())
            {
                payment = new Payment
                {
                    PaymentId = (int)reader["PaymentId"],
                    SaleId = (int)reader["SaleId"],
                    PaymentDate = (DateTime)reader["PaymentDate"],
                    Amount = (decimal)reader["Amount"],
                    PaymentMethod = reader["PaymentMethod"].ToString(),
                    Status = reader["Status"].ToString()
                };
            }
        }
        return payment;
    }
    public void AddPayment(Payment payment)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("INSERT INTO Payments (SaleId, PaymentDate, Amount, PaymentMethod, Status) VALUES (@SaleId, @PaymentDate, @Amount, @PaymentMethod, @Status)", connection);
            command.Parameters.AddWithValue("@SaleId", payment.SaleId);
            command.Parameters.AddWithValue("@Payment Date", payment.PaymentDate);
            command.Parameters.AddWithValue("@Amount", payment.Amount);
            command.Parameters.AddWithValue("@PaymentMethod", payment.PaymentMethod);
            command.Parameters.AddWithValue("@Status", payment.Status);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void UpdatePayment(Payment payment)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("UPDATE Payments SET SaleId = @SaleId, PaymentDate = @PaymentDate, Amount = @Amount, PaymentMethod = @PaymentMethod, Status = @Status WHERE PaymentId = @PaymentId", connection);
            command.Parameters.AddWithValue("@PaymentId", payment.PaymentId);
            command.Parameters.AddWithValue("@SaleId", payment.SaleId);
            command.Parameters.AddWithValue("@PaymentDate", payment.PaymentDate);
            command.Parameters.AddWithValue("@Amount", payment.Amount);
            command.Parameters.AddWithValue("@PaymentMethod", payment.PaymentMethod);
            command.Parameters.AddWithValue("@Status", payment.Status);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void DeletePayment(int paymentId)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("DELETE FROM Payments WHERE PaymentId = @PaymentId", connection);
            command.Parameters.AddWithValue("@PaymentId", paymentId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

InvoiceRepository

public class InvoiceRepository
{
    private readonly string _connectionString;
    public InvoiceRepository()
    {
        _connectionString = ConfigurationManager.ConnectionStrings["YourConnectionStringName"].ConnectionString;
    }
    public IEnumerable<Invoice> GetAllInvoices()
    {
        var invoices = new List<Invoice>();
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("SELECT * FROM Invoices", connection);
            connection.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                invoices.Add(new Invoice
                {
                    InvoiceId = (int)reader["InvoiceId"],
                    SaleId = (int)reader["SaleId"],
                    InvoiceDate = (DateTime)reader["InvoiceDate"],
                    TotalAmount = (decimal)reader["TotalAmount"]
                });
            }
        }
        return invoices;
    }
    public Invoice GetInvoiceById(int invoiceId)
    {
        Invoice invoice = null;
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("SELECT * FROM Invoices WHERE InvoiceId = @InvoiceId", connection);
            command.Parameters.AddWithValue("@InvoiceId", invoiceId);
            connection.Open();
            SqlDataReader reader = command.ExecuteReader();
            if (reader.Read())
            {
                invoice = new Invoice
                {
                    InvoiceId = (int)reader["InvoiceId"],
                    SaleId = (int)reader["SaleId"],
                    InvoiceDate = (DateTime)reader["InvoiceDate"],
                    TotalAmount = (decimal)reader["TotalAmount"]
                };
            }
        }
        return invoice;
    }
    public void AddInvoice(Invoice invoice)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("INSERT INTO Invoices (SaleId, InvoiceDate, TotalAmount) VALUES (@SaleId, @InvoiceDate, @TotalAmount)", connection);
            command.Parameters.AddWithValue("@SaleId", invoice.SaleId);
            command.Parameters.AddWithValue("@InvoiceDate", invoice.InvoiceDate);
            command.Parameters.AddWithValue("@TotalAmount", invoice.TotalAmount);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void UpdateInvoice(Invoice invoice)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("UPDATE Invoices SET SaleId = @SaleId, InvoiceDate = @InvoiceDate, TotalAmount = @TotalAmount WHERE InvoiceId = @InvoiceId", connection);
            command.Parameters.AddWithValue("@InvoiceId", invoice.InvoiceId);
            command.Parameters.AddWithValue("@SaleId", invoice.SaleId);
            command.Parameters.AddWithValue("@InvoiceDate", invoice.InvoiceDate);
            command.Parameters.AddWithValue("@TotalAmount", invoice.TotalAmount);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void DeleteInvoice(int invoiceId)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("DELETE FROM Invoices WHERE InvoiceId = @InvoiceId", connection);
            command.Parameters.AddWithValue("@InvoiceId", invoiceId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

ReportRepository

public class ReportRepository 
{
    private readonly string _connectionString;
    public ReportRepository()
    {
        _connectionString = ConfigurationManager.ConnectionStrings["YourConnectionStringName"].ConnectionString;
    }
    public IEnumerable<Report> GetAllReports()
    {
        var reports = new List<Report>();
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("SELECT * FROM Reports", connection);
            connection.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                reports.Add(new Report
                {
                    ReportId = (int)reader["ReportId"],
                    ReportDate = (DateTime)reader["ReportDate"],
                    TotalSales = (int)reader["TotalSales"],
                    TotalRevenue = (decimal)reader["TotalRevenue"],
                    CreatedAt = (DateTime)reader["CreatedAt"]
                });
            }
        }
        return reports;
    }
    public Report GetReportById(int reportId)
    {
        Report report = null;
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("SELECT * FROM Reports WHERE ReportId = @ReportId", connection);
            command.Parameters.AddWithValue("@ReportId", reportId);
            connection.Open();
            SqlDataReader reader = command.ExecuteReader();
            if (reader.Read())
            {
                report = new Report
                {
                    ReportId = (int)reader["ReportId"],
                    ReportDate = (DateTime)reader["ReportDate"],
                    TotalSales = (int)reader["TotalSales"],
                    TotalRevenue = (decimal)reader["TotalRevenue"],
                    CreatedAt = (DateTime)reader["CreatedAt"]
                };
            }
        }
        return report;
    }
    public void AddReport(Report report)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("INSERT INTO Reports (ReportDate, TotalSales, TotalRevenue) VALUES (@ReportDate, @TotalSales, @TotalRevenue)", connection);
            command.Parameters.AddWithValue("@ReportDate", report.ReportDate);
            command.Parameters.AddWithValue("@TotalSales", report.TotalSales);
            command.Parameters.AddWithValue("@TotalRevenue", report.TotalRevenue);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void UpdateReport(Report report)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("UPDATE Reports SET ReportDate = @ReportDate, TotalSales = @TotalSales, TotalRevenue = @TotalRevenue WHERE ReportId = @ReportId", connection);
            command.Parameters.AddWithValue("@ReportId", report.ReportId);
            command.Parameters.AddWithValue("@ReportDate", report.ReportDate);
            command.Parameters.AddWithValue("@TotalSales", report.TotalSales);
            command.Parameters.AddWithValue("@TotalRevenue", report.TotalRevenue);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void DeleteReport(int reportId)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("DELETE FROM Reports WHERE ReportId = @ReportId", connection);
            command.Parameters.AddWithValue("@ReportId", reportId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

CampaignRepository

public class CampaignRepository
{
    private readonly string _connectionString;
    public CampaignRepository()
    {
        _connectionString = ConfigurationManager.ConnectionStrings["YourConnectionStringName"].ConnectionString;
    }
    public IEnumerable<Campaign> GetAllCampaigns()
    {
        var campaigns = new List<Campaign>();
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("SELECT * FROM Campaigns", connection);
            connection.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                campaigns.Add(new Campaign
                {
                    CampaignId = (int)reader["CampaignId"],
                    CampaignName = reader["CampaignName"].ToString(),
                    StartDate = reader["StartDate"] as DateTime?,
                    EndDate = reader["EndDate"] as DateTime?,
                    DiscountPercentage = reader["DiscountPercentage"] as decimal?,
                    CreatedAt = (DateTime)reader["CreatedAt"],
                    UpdatedAt = (DateTime)reader["UpdatedAt"]
                });
            }
        }
        return campaigns;
    }
    public Campaign GetCampaignById(int campaignId)
    {
        Campaign campaign = null;
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("SELECT * FROM Campaigns WHERE CampaignId = @CampaignId", connection);
            command.Parameters.AddWithValue("@CampaignId", campaignId);
            connection.Open();
            SqlDataReader reader = command.ExecuteReader();
            if (reader.Read())
            {
                campaign = new Campaign
                {
                    CampaignId = (int)reader["CampaignId"],
                    CampaignName = reader["CampaignName"].ToString(),
                    StartDate = reader["StartDate"] as DateTime?,
                    EndDate = reader["EndDate"] as DateTime?,
                    DiscountPercentage = reader["DiscountPercentage"] as decimal?,
                    CreatedAt = (DateTime)reader["CreatedAt"],
                    UpdatedAt = (DateTime)reader["UpdatedAt"]
                };
            }
        }
        return campaign;
    }
    public void AddCampaign(Campaign campaign)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("INSERT INTO Campaigns (CampaignName, StartDate, EndDate, DiscountPercentage) VALUES (@CampaignName, @StartDate, @EndDate, @DiscountPercentage)", connection);
            command.Parameters.AddWithValue("@CampaignName", campaign.CampaignName);
            command.Parameters.AddWithValue("@StartDate", campaign.StartDate);
            command.Parameters.AddWithValue("@EndDate", campaign.EndDate);
            command.Parameters.AddWithValue("@DiscountPercentage", campaign.DiscountPercentage);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void UpdateCampaign(Campaign campaign)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("UPDATE Campaigns SET CampaignName = @CampaignName, StartDate = @StartDate, EndDate = @EndDate, DiscountPercentage = @DiscountPercentage, UpdatedAt = GETDATE() WHERE CampaignId = @CampaignId", connection);
            command.Parameters.AddWithValue("@CampaignId", campaign.CampaignId);
            command.Parameters.AddWithValue("@CampaignName", campaign.CampaignName);
            command.Parameters.AddWithValue("@StartDate", campaign.StartDate);
            command.Parameters.AddWithValue("@EndDate", campaign.EndDate);
            command.Parameters.AddWithValue("@DiscountPercentage", campaign.DiscountPercentage);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void DeleteCampaign(int campaignId)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("DELETE FROM Campaigns WHERE CampaignId = @CampaignId", connection);
            command.Parameters.AddWithValue("@CampaignId", campaignId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

TestDriveRepository

public class TestDriveRepository
{
    private readonly string _connectionString;
    public TestDriveRepository()
    {
        _connectionString = ConfigurationManager.ConnectionStrings["YourConnectionStringName"].ConnectionString;
    }
    public IEnumerable<TestDrive> GetAllTestDrives()
    {
        var testDrives = new List<TestDrive>();
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("SELECT * FROM TestDrives", connection);
            connection.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                testDrives.Add(new TestDrive
                {
                    TestDriveId = (int)reader["TestDriveId"],
                    CustomerId = (int)reader["CustomerId"],
                    VehicleId = (int)reader["VehicleId"],
                    TestDriveDate = (DateTime)reader["TestDriveDate"],
                    Status = reader["Status"].ToString()
                });
            }
        }
        return testDrives;
    }
    public TestDrive GetTestDriveById(int testDriveId)
    {
        TestDrive testDrive = null;
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("SELECT * FROM TestDrives WHERE TestDriveId = @TestDriveId", connection);
            command.Parameters.AddWithValue("@TestDriveId", testDriveId);
            connection.Open();
            SqlDataReader reader = command.ExecuteReader();
            if (reader.Read())
            {
                testDrive = new TestDrive
                {
                    TestDriveId = (int)reader["TestDriveId"],
                    CustomerId = (int)reader["CustomerId"],
                    VehicleId = (int)reader["VehicleId"],
                    TestDriveDate = (DateTime)reader["TestDriveDate"],
                    Status = reader["Status"].ToString()
                };
            }
        }
        return testDrive;
    }
    public void AddTestDrive(TestDrive testDrive)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("INSERT INTO TestDrives (CustomerId, VehicleId, TestDriveDate, Status) VALUES (@CustomerId, @VehicleId, @TestDriveDate, @Status)", connection);
            command.Parameters.AddWithValue("@CustomerId", testDrive.CustomerId);
            command.Parameters.AddWithValue("@VehicleId", testDrive.VehicleId);
            command.Parameters.AddWithValue("@TestDriveDate", testDrive.TestDriveDate);
            command.Parameters.AddWithValue("@Status", testDrive.Status);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void UpdateTestDrive(TestDrive testDrive)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("UPDATE TestDrives SET CustomerId = @CustomerId, VehicleId = @VehicleId, TestDriveDate = @TestDriveDate, Status = @Status WHERE TestDriveId = @TestDriveId", connection);
            command.Parameters.AddWithValue("@TestDriveId", testDrive.TestDriveId);
            command.Parameters.AddWithValue("@CustomerId", testDrive.CustomerId);
            command.Parameters.AddWithValue("@VehicleId", testDrive.VehicleId);
            command.Parameters.AddWithValue("@TestDriveDate", testDrive.TestDriveDate);
            command.Parameters.AddWithValue("@Status", testDrive.Status);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void DeleteTestDrive(int testDriveId)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("DELETE FROM TestDrives WHERE TestDriveId = @TestDriveId", connection);
            command.Parameters.AddWithValue("@TestDriveId", testDriveId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

ServiceRecordRepository

public class ServiceRecordRepository
{
    private readonly string _connectionString;
    public ServiceRecordRepository()
    {
        _connectionString = ConfigurationManager.ConnectionStrings["YourConnectionStringName"].ConnectionString;
    }
    public IEnumerable<ServiceRecord> GetAllServiceRecords()
    {
        var serviceRecords = new List<ServiceRecord>();
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("SELECT * FROM ServiceRecords", connection);
            connection.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                serviceRecords.Add(new ServiceRecord
                {
                    ServiceRecordId = (int)reader["ServiceRecordId"],
                    VehicleId = (int)reader["VehicleId"],
                    ServiceDate = (DateTime)reader["ServiceDate"],
                    Description = reader["Description"].ToString(),
                    Cost = reader["Cost"] as decimal?
                });
            }
        }
        return serviceRecords;
    }
    public ServiceRecord GetServiceRecordById(int serviceRecordId)
    {
        ServiceRecord serviceRecord = null;
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("SELECT * FROM ServiceRecords WHERE ServiceRecordId = @ServiceRecordId", connection);
            command.Parameters.AddWithValue("@ServiceRecordId", serviceRecordId);
            connection.Open();
            SqlDataReader reader = command.ExecuteReader();
            if (reader.Read())
            {
                serviceRecord = new ServiceRecord
                {
                    ServiceRecordId = (int)reader["ServiceRecordId"],
                    VehicleId = (int)reader["VehicleId"],
                    ServiceDate = (DateTime)reader["ServiceDate"],
                    Description = reader["Description"].ToString(),
                    Cost = reader["Cost"] as decimal?
                };
            }
        }
        return serviceRecord;
    }
    public void AddServiceRecord(ServiceRecord serviceRecord)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("INSERT INTO ServiceRecords (VehicleId, ServiceDate, Description, Cost) VALUES (@VehicleId, @ServiceDate, @Description, @Cost)", connection);
            command.Parameters.AddWithValue("@VehicleId", serviceRecord.VehicleId);
            command.Parameters.AddWithValue("@ServiceDate", serviceRecord.ServiceDate);
            command.Parameters.AddWithValue("@Description", serviceRecord.Description);
            command.Parameters.AddWithValue("@Cost", serviceRecord.Cost);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void UpdateServiceRecord(ServiceRecord serviceRecord)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("UPDATE ServiceRecords SET VehicleId = @VehicleId, ServiceDate = @ServiceDate, Description = @Description, Cost = @Cost WHERE ServiceRecordId = @ServiceRecordId", connection);
            command.Parameters.AddWithValue("@ServiceRecordId", serviceRecord.ServiceRecordId);
            command.Parameters.AddWithValue("@VehicleId", serviceRecord.VehicleId);
            command.Parameters.AddWithValue("@ServiceDate", serviceRecord.ServiceDate);
            command.Parameters.AddWithValue("@Description", serviceRecord.Description);
            command.Parameters.AddWithValue("@Cost", serviceRecord.Cost);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void Delete ServiceRecord(int serviceRecordId)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("DELETE FROM ServiceRecords WHERE ServiceRecordId = @ServiceRecordId", connection);
            command.Parameters.AddWithValue("@ServiceRecordId", serviceRecordId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

This completes the repository classes for all the models defined in your SQL Server schema. Each repository provides methods for basic CRUD operations, allowing for easy data manipulation within your ASP.NET application using ADO.NET.

Creating Controllers

To create controllers for each repository in an ASP.NET MVC application, we will follow the standard pattern of creating a controller for each model. Each controller will handle HTTP requests and interact with the corresponding repository to perform CRUD operations. Below are example controllers for each of the repositories we created earlier.

UserController

using System.Web.Mvc;
public class UserController : Controller
{
    private readonly UserRepository _userRepository;
    public UserController()
    {
        _userRepository = new UserRepository();
    }
    public ActionResult Index()
    {
        var users = _userRepository.GetAllUsers();
        return View(users);
    }
    public ActionResult Details(int id)
    {
        var user = _userRepository.GetUser ById(id);
        return View(user);
    }
    public ActionResult Create()
    {
        return View();
    }
    [HttpPost]
    public ActionResult Create(User user)
    {
        if (ModelState.IsValid)
        {
            _userRepository.AddUser (user);
            return RedirectToAction("Index");
        }
        return View(user);
    }
    public ActionResult Edit(int id)
    {
        var user = _userRepository.GetUser ById(id);
        return View(user);
    }
    [HttpPost]
    public ActionResult Edit(User user)
    {
        if (ModelState.IsValid)
        {
            _userRepository.UpdateUser (user);
            return RedirectToAction("Index");
        }
        return View(user);
    }
    public ActionResult Delete(int id)
    {
        var user = _userRepository.GetUser ById(id);
        return View(user);
    }
    [HttpPost, ActionName("Delete")]
    public ActionResult DeleteConfirmed(int id)
    {
        _userRepository.DeleteUser (id);
        return RedirectToAction("Index");
    }
}

RoleController

public class RoleController : Controller
{
    private readonly RoleRepository _roleRepository;
    public RoleController()
    {
        _roleRepository = new RoleRepository();
    }
    public ActionResult Index()
    {
        var roles = _roleRepository.GetAllRoles();
        return View(roles);
    }
    public ActionResult Details(int id)
    {
        var role = _roleRepository.GetRoleById(id);
        return View(role);
    }
    public ActionResult Create()
    {
        return View();
    }
    [HttpPost]
    public ActionResult Create(Role role)
    {
        if (ModelState.IsValid)
        {
            _roleRepository.AddRole(role);
            return RedirectToAction("Index");
        }
        return View(role);
    }
    public ActionResult Edit(int id)
    {
        var role = _roleRepository.GetRoleById(id);
        return View(role);
    }
    [HttpPost]
    public ActionResult Edit(Role role)
    {
        if (ModelState.IsValid)
        {
            _roleRepository.UpdateRole(role);
            return RedirectToAction("Index");
        }
        return View(role);
    }
    public ActionResult Delete(int id)
    {
        var role = _roleRepository.GetRoleById(id);
        return View(role);
    }
    [HttpPost, ActionName("Delete")]
    public ActionResult DeleteConfirmed(int id)
    {
        _roleRepository.DeleteRole(id);
        return RedirectToAction("Index");
    }
}

VehicleController

public class VehicleController : Controller
{
    private readonly VehicleRepository _vehicleRepository;
    public VehicleController()
    {
        _vehicleRepository = new VehicleRepository();
    }
    public ActionResult Index()
    {
        var vehicles = _vehicleRepository.GetAllVehicles();
        return View(vehicles);
    }
    public ActionResult Details(int id)
    {
        var vehicle = _vehicleRepository.GetVehicleById(id);
        return View(vehicle);
    }
    public ActionResult Create()
    {
        return View();
    }
    [HttpPost]
    public ActionResult Create(Vehicle vehicle)
    {
        if (ModelState.IsValid)
        {
            _vehicleRepository.AddVehicle(vehicle);
            return RedirectToAction("Index");
        }
        return View(vehicle);
    }
    public ActionResult Edit(int id)
    {
        var vehicle = _vehicleRepository.GetVehicleById(id);
        return View(vehicle);
    }
    [HttpPost]
    public ActionResult Edit(Vehicle vehicle)
    {
        if (ModelState.IsValid)
        {
            _vehicleRepository.UpdateVehicle(vehicle);
            return RedirectToAction("Index");
        }
        return View(vehicle);
    }
    public ActionResult Delete(int id)
    {
        var vehicle = _vehicleRepository.GetVehicleById(id);
        return View(vehicle);
    }
    [HttpPost, ActionName("Delete")]
    public ActionResult DeleteConfirmed(int id)
    {
        _vehicleRepository.DeleteVehicle(id);
        return RedirectToAction("Index");
    }
}

InventoryController

public class InventoryController : Controller
{
    private readonly InventoryRepository _inventoryRepository;
    public InventoryController()
    {
        _inventoryRepository = new InventoryRepository();
    }
    public ActionResult Index()
    {
        var inventories = _inventoryRepository.GetAllInventories();
        return View(inventories);
    }
    public ActionResult Details(int id)
    {
        var inventory = _inventoryRepository.GetInventoryById(id);
        return View(inventory);
    }
    public ActionResult Create()
    {
        return View();
    }
    [HttpPost]
    public ActionResult Create(Inventory inventory)
    {
        if (ModelState.IsValid)
        {
            _inventoryRepository.AddInventory(inventory);
            return RedirectToAction("Index");
        }
        return View(inventory);
    }
    public ActionResult Edit(int id)
    {
        var inventory = _inventoryRepository.GetInventoryById(id);
        return View(inventory);
    }
    [HttpPost]
    public ActionResult Edit(Inventory inventory)
    {
        if (ModelState.IsValid)
        {
            _inventoryRepository.UpdateInventory(inventory);
            return RedirectToAction("Index");
        }
        return View(inventory);
    }
    public ActionResult Delete(int id)
    {
        var inventory = _inventoryRepository.GetInventoryById(id);
        return View(inventory);
    }
    [HttpPost, ActionName("Delete")]
    public ActionResult DeleteConfirmed(int id)
    {
        _inventoryRepository.DeleteInventory(id);
        return RedirectToAction("Index");
    }
}

CustomerController

public class CustomerController : Controller
{
    private readonly CustomerRepository _customerRepository;
    public CustomerController()
    {
        _customerRepository = new CustomerRepository();
    }
    public ActionResult Index()
    {
        var customers = _customerRepository.GetAllCustomers();
        return View(customers);
    }
    public ActionResult Details(int id)
    {
        var customer = _customerRepository.GetCustomerById(id);
        return View(customer);
    }
    public ActionResult Create()
    {
        return View();
    }
    [HttpPost]
    public ActionResult Create(Customer customer)
    {
        if (ModelState.IsValid)
        {
            _customerRepository.AddCustomer(customer);
            return RedirectToAction("Index");
        }
        return View(customer);
    }
    public ActionResult Edit(int id)
    {
        var customer = _customerRepository.GetCustomerById(id);
        return View(customer);
    }
    [HttpPost]
    public ActionResult Edit(Customer customer)
    {
        if (ModelState.IsValid)
        {
            _customerRepository.UpdateCustomer(customer);
            return RedirectToAction("Index");
        }
        return View(customer);
    }
    public ActionResult Delete(int id)
    {
        var customer = _customerRepository.GetCustomerById(id);
        return View(customer);
    }
    [HttpPost, ActionName("Delete")]
    public ActionResult DeleteConfirmed(int id)
    {
        _customerRepository.DeleteCustomer(id);
        return RedirectToAction("Index");
    }
}

SaleController

public class SaleController : Controller
{
    private readonly SaleRepository _saleRepository;
    public SaleController()
    {
        _saleRepository = new SaleRepository();
    }
    public ActionResult Index()
    {
        var sales = _saleRepository.GetAllSales();
        return View(sales);
    }
    public ActionResult Details(int id)
    {
        var sale = _saleRepository.GetSaleById(id);
        return View(sale);
    }
    public ActionResult Create()
    {
        return View();
    }
    [HttpPost]
    public ActionResult Create(Sale sale)
    {
        if (ModelState.IsValid)
        {
            _saleRepository.AddSale(sale);
            return RedirectToAction("Index");
        }
        return View(sale);
    }
    public ActionResult Edit(int id)
    {
        var sale = _saleRepository.GetSaleById(id);
        return View(sale);
    }
    [HttpPost]
    public ActionResult Edit(Sale sale)
    {
        if (ModelState.IsValid)
        {
            _saleRepository.UpdateSale(sale);
            return RedirectToAction("Index");
        }
        return View(sale);
    }
    public ActionResult Delete(int id)
    {
        var sale = _saleRepository.GetSaleById(id);
        return View(sale);
    }
    [HttpPost, ActionName("Delete")]
    public ActionResult DeleteConfirmed(int id)
    {
        _saleRepository.DeleteSale(id);
        return RedirectToAction("Index");
    }
}

PaymentController

public class PaymentController : Controller
{
    private readonly PaymentRepository _paymentRepository;
    public PaymentController()
    {
        _paymentRepository = new PaymentRepository();
    }
    public ActionResult Index()
    {
        var payments = _paymentRepository.GetAllPayments();
        return View(payments);
    }
    public ActionResult Details(int id)
    {
        var payment = _paymentRepository.GetPaymentById(id);
        return View(payment);
    }
    public ActionResult Create()
    {
        return View();
    }
    [HttpPost]
    public ActionResult Create(Payment payment)
    {
        if (ModelState.IsValid)
        {
            _paymentRepository.AddPayment(payment);
            return RedirectToAction("Index");
        }
        return View(payment);
    }
    public ActionResult Edit(int id)
    {
        var payment = _paymentRepository.GetPaymentById(id);
        return View(payment);
    }
    [HttpPost]
    public ActionResult Edit(Payment payment)
    {
        if (ModelState.IsValid)
        {
            _paymentRepository.UpdatePayment(payment);
            return RedirectToAction("Index");
        }
        return View(payment);
    }
    public ActionResult Delete(int id)
    {
        var payment = _paymentRepository.GetPaymentById(id);
        return View(payment);
    }
    [HttpPost, ActionName("Delete")]
    public ActionResult DeleteConfirmed(int id)
    {
        _paymentRepository.DeletePayment(id);
        return RedirectToAction("Index");
    }
}

InvoiceController

public class InvoiceController : Controller
{
    private readonly InvoiceRepository _invoiceRepository;
    public InvoiceController()
    {
        _invoiceRepository = new InvoiceRepository();
    }
    public ActionResult Index()
    {
        var invoices = _invoiceRepository.GetAllInvoices();
        return View(invoices);
    }
    public ActionResult Details(int id)
    {
        var invoice = _invoiceRepository.GetInvoiceById(id);
        return View(invoice);
    }
    public ActionResult Create()
    {
        return View();
    }
    [HttpPost]
    public ActionResult Create(Invoice invoice)
    {
        if (ModelState.IsValid)
        {
            _invoiceRepository.AddInvoice(invoice);
            return RedirectToAction("Index");
        }
        return View(invoice);
    }
    public ActionResult Edit(int id)
    {
        var invoice = _invoiceRepository.GetInvoiceById(id);
        return View(invoice);
    }
    [HttpPost]
    public ActionResult Edit(Invoice invoice)
    {
        if (ModelState.IsValid)
        {
            _invoiceRepository.UpdateInvoice(invoice);
            return RedirectToAction("Index");
        }
        return View(invoice);
    }
    public ActionResult Delete(int id)
    {
        var invoice = _invoiceRepository.GetInvoiceById(id);
        return View(invoice);
    }
    [HttpPost, ActionName("Delete")]
    public ActionResult DeleteConfirmed(int id)
    {
        _invoiceRepository.DeleteInvoice(id);
        return RedirectToAction("Index");
    }
}

ReportController

public class ReportController : Controller
{
    private readonly ReportRepository _reportRepository;
    public ReportController()
    {
        _reportRepository = new ReportRepository();
    }
    public ActionResult Index()
    {
        var reports = _reportRepository.GetAllReports();
        return View(reports);
    }
    public ActionResult Details(int id)
    {
        var report = _reportRepository.GetReportById(id);
        return View(report);
    }
    public ActionResult Create()
    {
        return View();
    }
    [HttpPost]
    public ActionResult Create(Report report)
    {
        if (ModelState.IsValid)
        {
            _reportRepository.AddReport(report);
            return RedirectToAction("Index");
        }
        return View(report);
    }
    public ActionResult Edit(int id)
    {
        var report = _reportRepository.GetReportById(id);
        return View(report);
    }
    [HttpPost]
    public ActionResult Edit(Report report)
    {
        if (ModelState.IsValid)
        {
            _reportRepository.UpdateReport(report);
            return RedirectToAction("Index");
        }
        return View(report);
    }
    public ActionResult Delete(int id)
    {
        var report = _reportRepository.GetReportById(id);
        return View(report);
    }
    [HttpPost, ActionName("Delete")]
    public ActionResult DeleteConfirmed(int id)
    {
        _reportRepository.DeleteReport(id);
        return RedirectToAction("Index");
    }
}

CampaignController

public class CampaignController : Controller
{
    private readonly CampaignRepository _campaignRepository;
    public CampaignController()
    {
        _campaignRepository = new CampaignRepository();
    }
    public ActionResult Index()
    {
        var campaigns = _campaignRepository.GetAllCampaigns();
        return View(campaigns);
    }
    public ActionResult Details(int id)
    {
        var campaign = _campaignRepository.GetCampaignById(id);
        return View(campaign);
    }
    public ActionResult Create()
    {
        return View();
    }
    [HttpPost]
    public ActionResult Create(Campaign campaign)
    {
        if (ModelState.IsValid)
        {
            _campaignRepository.AddCampaign(campaign);
            return RedirectToAction("Index");
        }
        return View(campaign);
    }
    public ActionResult Edit(int id)
    {
        var campaign = _campaignRepository.GetCampaignById(id);
        return View(campaign);
    }
    [HttpPost]
    public ActionResult Edit(Campaign campaign)
    {
        if (ModelState.IsValid)
        {
            _campaignRepository.UpdateCampaign(campaign);
            return RedirectToAction("Index");
        }
        return View(campaign);
    }
    public ActionResult Delete(int id)
    {
        var campaign = _campaignRepository.GetCampaignById(id);
        return View(campaign);
    }
    [HttpPost, ActionName("Delete")]
    public ActionResult DeleteConfirmed(int id)
    {
        _campaignRepository.DeleteCampaign(id);
        return RedirectToAction(" Index");
    }
}

TestDriveController

public class TestDriveController : Controller
{
    private readonly TestDriveRepository _testDriveRepository;
    public TestDriveController()
    {
        _testDriveRepository = new TestDriveRepository();
    }
    public ActionResult Index()
    {
        var testDrives = _testDriveRepository.GetAllTestDrives();
        return View(testDrives);
    }
    public ActionResult Details(int id)
    {
        var testDrive = _testDriveRepository.GetTestDriveById(id);
        return View(testDrive);
    }
    public ActionResult Create()
    {
        return View();
    }
    [HttpPost]
    public ActionResult Create(TestDrive testDrive)
    {
        if (ModelState.IsValid)
        {
            _testDriveRepository.AddTestDrive(testDrive);
            return RedirectToAction("Index");
        }
        return View(testDrive);
    }
    public ActionResult Edit(int id)
    {
        var testDrive = _testDriveRepository.GetTestDriveById(id);
        return View(testDrive);
    }
    [HttpPost]
    public ActionResult Edit(TestDrive testDrive)
    {
        if (ModelState.IsValid)
        {
            _testDriveRepository.UpdateTestDrive(testDrive);
            return RedirectToAction("Index");
        }
        return View(testDrive);
    }
    public ActionResult Delete(int id)
    {
        var testDrive = _testDriveRepository.GetTestDriveById(id);
        return View(testDrive);
    }
    [HttpPost, ActionName("Delete")]
    public ActionResult DeleteConfirmed(int id)
    {
        _testDriveRepository.DeleteTestDrive(id);
        return RedirectToAction("Index");
    }
}

ServiceRecordController

public class ServiceRecordController : Controller
{
    private readonly ServiceRecordRepository _serviceRecordRepository;
    public ServiceRecordController()
    {
        _serviceRecordRepository = new ServiceRecordRepository();
    }
    public ActionResult Index()
    {
        var serviceRecords = _serviceRecordRepository.GetAllServiceRecords();
        return View(serviceRecords);
    }
    public ActionResult Details(int id)
    {
        var serviceRecord = _serviceRecordRepository.GetServiceRecordById(id);
        return View(serviceRecord);
    }
    public ActionResult Create()
    {
        return View();
    }
    [HttpPost]
    public ActionResult Create(ServiceRecord serviceRecord)
    {
        if (ModelState.IsValid)
        {
            _serviceRecordRepository.AddServiceRecord(serviceRecord);
            return RedirectToAction("Index");
        }
        return View(serviceRecord);
    }
    public ActionResult Edit(int id)
    {
        var serviceRecord = _serviceRecordRepository.GetServiceRecordById(id);
        return View(serviceRecord);
    }
    [HttpPost]
    public ActionResult Edit(ServiceRecord serviceRecord)
    {
        if (ModelState.IsValid)
        {
            _serviceRecordRepository.UpdateServiceRecord(serviceRecord);
            return RedirectToAction("Index");
        }
        return View(serviceRecord);
    }
    public ActionResult Delete(int id)
    {
        var serviceRecord = _serviceRecordRepository.GetServiceRecordById(id);
        return View(serviceRecord);
    }
    [HttpPost, ActionName("Delete")]
    public ActionResult DeleteConfirmed(int id)
    {
        _serviceRecordRepository.DeleteServiceRecord(id);
        return RedirectToAction("Index");
    }
}

This completes the creation of controllers for each repository, allowing for full CRUD operations through the views in your ASP.NET MVC application. Each controller follows the same pattern, ensuring consistency and ease of maintenance.

Creating Views

Creating views for each controller in an ASP.NET MVC application involves creating Razor view files that correspond to the actions in the controllers. Below, I will provide a basic structure for the views for each controller, including the Index, Details, Create, Edit, and Delete views.

User Views

Views/User/Index.cshtml

@model IEnumerable<YourNamespace.Models.User>
@{
    ViewBag.Title = "Users";
}
<h2>Users</h2>
<p>
    @Html.ActionLink("Create New", "Create")
</p>
<table class="table">
    <thead>
        <tr>
            <th>
                @Html.DisplayNameFor(model => model.Username)
            </th>
            <th>
                @Html.DisplayNameFor(model => model.Email)
            </th>
            <th></th>
        </tr>
    </thead>
    <tbody>
        @foreach (var item in Model)
        {
            <tr>
                <td>@Html.DisplayFor(modelItem => item.Username)</td>
                <td>@Html.DisplayFor(modelItem => item.Email)</td>
                <td>
                    @Html.ActionLink("Edit", "Edit", new { id = item.UserId }) |
                    @Html.ActionLink("Details", "Details", new { id = item.UserId }) |
                    @Html.ActionLink("Delete", "Delete", new { id = item.UserId })
                </td>
            </tr>
        }
    </tbody>
</table>

Views/User/Details.cshtml

@model YourNamespace.Models.User
@{
    ViewBag.Title = "User  Details";
}
<h2>User Details</h2>
<div>
    <h4>User</h4>
    <hr />
    <dl class="dl-horizontal">
        <dt>
            @Html.DisplayNameFor(model => model.Username)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Username)
        </dd>
        <dt>
            @Html.DisplayNameFor(model => model.Email)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Email)
        </dd>
        <dt>
            @Html.DisplayNameFor(model => model.Phone)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Phone)
        </dd>
    </dl>
</div>
<div>
    @Html.ActionLink("Edit", "Edit", new { id = Model.UserId }) |
    @Html.ActionLink("Back to List", "Index")
</div>

Views/User/Create.cshtml

@model YourNamespace.Models.User
@{
    ViewBag.Title = "Create User";
}
<h2>Create User</h2>
@using (Html.BeginForm())
{
    @Html.AntiForgeryToken()
    <div class="form-horizontal">
        <h4>User</h4>
        <hr />
        <div class="form-group">
            @Html.LabelFor(model => model.Username, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.Username, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.Username, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            @Html.LabelFor(model => model.Email, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.Email, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.Email, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            @Html.LabelFor(model => model.Phone, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.Phone, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.Phone, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            <div class="col-md-offset-2 col-md-10">
                <input type="submit" value="Create" class="btn btn-default" />
            </div>
        </div>
    </div>
}

Views/User/Edit.cshtml

@model YourNamespace.Models.User
@{
    ViewBag.Title = "Edit User";
}
<h2>Edit User</h2>
@using (Html.BeginForm())
{
    @Html.AntiForgeryToken()
    <div class="form-horizontal">
        <h4>User</h4>
        <hr />
        @Html.HiddenFor(model => model.UserId)
        <div class="form-group">
            @Html.LabelFor(model => model.Username, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.Username, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.Username, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            @Html.LabelFor(model => model.Email, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.Email, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.Email, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            @Html.LabelFor(model => model.Phone, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.Phone, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.Phone, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            <div class="col-md-offset-2 col-md-10">
                <input type="submit" value="Save" class="btn btn-default" />
            </div>
        </div>
    </div>
}

Views/User/Delete.cshtml

@model YourNamespace.Models.User
@{
    ViewBag.Title = "Delete User";
}
<h2>Delete User</h2>
<div>
    <h4>User</h4>
    <hr />
    <dl class="dl-horizontal">
        <dt>
            @Html.DisplayNameFor(model => model.Username)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Username)
        </dd>
        <dt>
            @Html.DisplayNameFor(model => model.Email)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Email)
        </dd>
        <dt>
            @Html.DisplayNameFor(model => model.Phone)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Phone)
        </dd>
    </dl>
</div>
@using (Html.BeginForm())
{
    @Html.AntiForgeryToken()
    @Html.HiddenFor(model => model.UserId)
    <div>
        <input type="submit" value="Delete" class="btn btn-danger" /> |
        @Html.ActionLink("Back to List", "Index")
    </div>
}
Role Views

Role Views

Views/Role/Index.cshtml

@model IEnumerable<YourNamespace.Models.Role>
@{
    ViewBag.Title = "Roles";
}
<h2>Roles</h2>
<p>
    @Html.ActionLink("Create New", "Create")
</p>
<table class="table">
    <thead>
        <tr>
            <th>
                @Html.DisplayNameFor(model => model.RoleName)
            </th>
            <th></th>
        </tr>
    </thead>
    <tbody>
        @foreach (var item in Model)
        {
            <tr>
                <td>@Html.DisplayFor(modelItem => item.RoleName)</td>
                <td>
                    @Html.ActionLink("Edit", "Edit", new { id = item.RoleId }) |
                    @Html.ActionLink("Details", "Details", new { id = item.RoleId }) |
                    @Html.ActionLink("Delete", "Delete", new { id = item.RoleId })
                </td>
            </tr>
        }
    </tbody>
</table>

Views/Role/Details.cshtml

@model YourNamespace.Models.Role
@{
    ViewBag.Title = "Role Details";
}
<h2>Role Details</h2>
<div>
    <h4>Role</h4>
    <hr />
    <dl class="dl-horizontal">
        <dt>
            @Html.DisplayNameFor(model => model.RoleName)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.RoleName)
        </dd>
    </dl>
</div>
<div>
    @Html.ActionLink("Edit", "Edit", new { id = Model.RoleId }) |
    @Html.ActionLink("Back to List", "Index")
</div>

Views/Role/Create.cshtml

@model YourNamespace.Models.Role
@{
    ViewBag.Title = "Create Role";
}
<h2>Create Role</h2>
@using (Html.BeginForm())
{
    @Html.AntiForgeryToken()
    <div class="form-horizontal">
        <h4>Role</h4>
        <hr />
        <div class="form-group">
            @Html.LabelFor(model => model.RoleName, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.RoleName, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.RoleName, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            <div class="col-md-offset-2 col -md-10">
                <input type="submit" value="Create" class="btn btn-default" />
            </div>
        </div>
    </div>
}

Views/Role/Edit.cshtml

@model YourNamespace.Models.Role
@{
    ViewBag.Title = "Edit Role";
}
<h2>Edit Role</h2>
@using (Html.BeginForm())
{
    @Html.AntiForgeryToken()
    <div class="form-horizontal">
        <h4>Role</h4>
        <hr />
        @Html.HiddenFor(model => model.RoleId)
        <div class="form-group">
            @Html.LabelFor(model => model.RoleName, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.RoleName, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.RoleName, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            <div class="col-md-offset-2 col-md-10">
                <input type="submit" value="Save" class="btn btn-default" />
            </div>
        </div>
    </div>
}

Views/Role/Delete.cshtml

@model YourNamespace.Models.Role
@{
    ViewBag.Title = "Delete Role";
}
<h2>Delete Role</h2>
<div>
    <h4>Role</h4>
    <hr />
    <dl class="dl-horizontal">
        <dt>
            @Html.DisplayNameFor(model => model.RoleName)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.RoleName)
        </dd>
    </dl>
</div>
@using (Html.BeginForm())
{
    @Html.AntiForgeryToken()
    @Html.HiddenFor(model => model.RoleId)
    <div>
        <input type="submit" value="Delete" class="btn btn-danger" /> |
        @Html.ActionLink("Back to List", "Index")
    </div>
}
Vehicle Views

Vehicle Views

Views/Vehicle/Index.cshtml

@model IEnumerable<YourNamespace.Models.Vehicle>
@{
    ViewBag.Title = "Vehicles";
}
<h2>Vehicles</h2>
<p>
    @Html.ActionLink("Create New", "Create")
</p>
<table class="table">
    <thead>
        <tr>
            <th>
                @Html.DisplayNameFor(model => model.Make)
            </th>
            <th>
                @Html.DisplayNameFor(model => model.Model)
            </th>
            <th></th>
        </tr>
    </thead>
    <tbody>
        @foreach (var item in Model)
        {
            <tr>
                <td>@Html.DisplayFor(modelItem => item.Make)</td>
                <td>@Html.DisplayFor(modelItem => item.Model)</td>
                <td>
                    @Html.ActionLink("Edit", "Edit", new { id = item.VehicleId }) |
                    @Html.ActionLink("Details", "Details", new { id = item.VehicleId }) |
                    @Html.ActionLink("Delete", "Delete", new { id = item.VehicleId })
                </td>
            </tr>
        }
    </tbody>
</table>

Views/Vehicle/Details.cshtml

@model YourNamespace.Models.Vehicle
@{
    ViewBag.Title = "Vehicle Details";
}
<h2>Vehicle Details</h2>
<div>
    <h4>Vehicle</h4>
    <hr />
    <dl class="dl-horizontal">
        <dt>
            @Html.DisplayNameFor(model => model.Make)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Make)
        </dd>
        <dt>
            @Html.DisplayNameFor(model => model.Model)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Model)
        </dd>
    </dl>
</div>
<div>
    @Html.ActionLink("Edit", "Edit", new { id = Model.VehicleId }) |
    @Html.ActionLink("Back to List", "Index")
</div>

Views/Vehicle/Create.cshtml

@model YourNamespace.Models.Vehicle
@{
    ViewBag.Title = "Create Vehicle";
}
<h2>Create Vehicle</h2>
@using (Html.BeginForm())
{
    @Html.AntiForgeryToken()
    <div class="form-horizontal">
        <h4>Vehicle</h4>
        <hr />
        <div class="form-group">
            @Html.LabelFor(model => model.Make, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md- 10">
                @Html.EditorFor(model => model.Make, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.Make, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            @Html.LabelFor(model => model.Model, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.Model, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.Model, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            <div class="col-md-offset-2 col-md-10">
                <input type="submit" value="Create" class="btn btn-default" />
            </div>
        </div>
    </div>
}

Views/Vehicle/Edit.cshtml

@model YourNamespace.Models.Vehicle
@{
    ViewBag.Title = "Edit Vehicle";
}
<h2>Edit Vehicle</h2>
@using (Html.BeginForm())
{
    @Html.AntiForgeryToken()
    <div class="form-horizontal">
        <h4>Vehicle</h4>
        <hr />
        @Html.HiddenFor(model => model.VehicleId)
        <div class="form-group">
            @Html.LabelFor(model => model.Make, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.Make, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.Make, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            @Html.LabelFor(model => model.Model, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.Model, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.Model, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            <div class="col-md-offset-2 col-md-10">
                <input type="submit" value="Save" class="btn btn-default" />
            </div>
        </div>
    </div>
}

Views/Vehicle/Delete.cshtml

@model YourNamespace.Models.Vehicle
@{
    ViewBag.Title = "Delete Vehicle";
}
<h2>Delete Vehicle</h2>
<div>
    <h4>Vehicle</h4>
    <hr />
    <dl class="dl-horizontal">
        <dt>
            @Html.DisplayNameFor(model => model.Make)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Make)
        </dd>
        <dt>
            @Html.DisplayNameFor(model => model.Model)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Model)
        </dd>
    </dl>
</div>
@using (Html.BeginForm())
{
    @Html.AntiForgeryToken()
    @Html.HiddenFor(model => model.VehicleId)
    <div>
        <input type="submit" value="Delete" class="btn btn-danger" /> |
        @Html.ActionLink("Back to List", "Index")
    </div>
}
Inventory Views

Inventory Views

Views/Inventory/Index.cshtml

@model IEnumerable<YourNamespace.Models.Inventory>
@{
    ViewBag.Title = "Inventories";
}
<h2>Inventories</h2>
<p>
    @Html.ActionLink("Create New", "Create")
</p>
<table class="table">
    <thead>
        <tr>
            <th>
                @Html.DisplayNameFor(model => model.ItemName)
            </th>
            <th>
                @Html.DisplayNameFor(model => model.Quantity)
            </th>
            <th></th>
        </tr>
    </thead>
    <tbody>
        @foreach (var item in Model)
        {
            <tr>
                <td>@Html.DisplayFor(modelItem => item.ItemName)</td>
                <td>@Html.DisplayFor(modelItem => item.Quantity)</td>
                <td>
                    @Html.ActionLink("Edit", "Edit", new { id = item.InventoryId }) |
                    @Html.ActionLink("Details", "Details", new { id = item.InventoryId }) |
                    @Html.ActionLink("Delete", "Delete", new { id = item.InventoryId })
                </td>
            </tr>
 }
    </tbody>
</table>

Views/Inventory/Details.cshtml

@model YourNamespace.Models.Inventory
@{
    ViewBag.Title = "Inventory Details";
}
<h2>Inventory Details</h2>
<div>
    <h4>Inventory</h4>
    <hr />
    <dl class="dl-horizontal">
        <dt>
            @Html.DisplayNameFor(model => model.ItemName)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.ItemName)
        </dd>
        <dt>
            @Html.DisplayNameFor(model => model.Quantity)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Quantity)
        </dd>
    </dl>
</div>
<div>
    @Html.ActionLink("Edit", "Edit", new { id = Model.InventoryId }) |
    @Html.ActionLink("Back to List", "Index")
</div>

Views/Inventory/Create.cshtml

@model YourNamespace.Models.Inventory
@{
    ViewBag.Title = "Create Inventory";
}
<h2>Create Inventory</h2>
@using (Html.BeginForm())
{
    @Html.AntiForgeryToken()
    <div class="form-horizontal">
        <h4>Inventory</h4>
        <hr />
        <div class="form-group">
            @Html.LabelFor(model => model.ItemName, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.ItemName, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.ItemName, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            @Html.LabelFor(model => model.Quantity, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.Quantity, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.Quantity, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            <div class="col-md-offset-2 col-md-10">
                <input type="submit" value="Create" class="btn btn-default" />
            </div>
        </div>
    </div>
}

Views/Inventory/Edit.cshtml

@model YourNamespace.Models.Inventory
@{
    ViewBag.Title = "Edit Inventory";
}
<h2>Edit Inventory</h2>
@using (Html.BeginForm())
{
    @Html.AntiForgeryToken()
    <div class="form-horizontal">
        <h4>Inventory</h4>
        <hr />
        @Html.HiddenFor(model => model.InventoryId)
        <div class="form-group">
            @Html.LabelFor(model => model.ItemName, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.ItemName, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.ItemName, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            @Html.LabelFor(model => model.Quantity, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.Quantity, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.Quantity, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            <div class="col-md-offset-2 col-md-10">
                <input type="submit" value="Save" class="btn btn-default" />
            </div>
        </div>
    </div>
}

Views/Inventory/Delete.cshtml

@model YourNamespace.Models.Inventory
@{
    ViewBag.Title = "Delete Inventory";
}
<h2>Delete Inventory</h2>
<div>
    <h4>Inventory</h4>
    <hr />
    <dl class="dl-horizontal">
        <dt>
            @Html.DisplayNameFor(model => model.ItemName)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.ItemName)
        </dd>
        <dt>
            @Html.DisplayNameFor(model => model.Quantity)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Quantity)
        </dd>    
    </dl>
</div>
@using (Html.BeginForm())
{
    @Html.AntiForgeryToken()
    @Html.HiddenFor(model => model.InventoryId)
    <div>
        <input type="submit" value="Delete" class="btn btn-danger" /> |
        @Html.ActionLink("Back to List", "Index")
    </div>
}
Customer Views

Customer Views

Views/Customer/Index.cshtml

@model IEnumerable<YourNamespace.Models.Customer>
@{
    ViewBag.Title = "Customers";
}
<h2>Customers</h2>
<p>
    @Html.ActionLink("Create New", "Create")
</p>
<table class="table">
    <thead>
        <tr>
            <th>
                @Html.DisplayNameFor(model => model.Name)
            </th>
            <th>
                @Html.DisplayNameFor(model => model.Email)
            </th>
            <th></th>
        </tr>
    </thead>
    <tbody>
        @foreach (var item in Model)
        {
            <tr>
                <td>@Html.DisplayFor(modelItem => item.Name)</td>
                <td>@Html.DisplayFor(modelItem => item.Email)</td>
                <td>
                    @Html.ActionLink("Edit", "Edit", new { id = item.CustomerId }) |
                    @Html.ActionLink("Details", "Details", new { id = item.CustomerId }) |
                    @Html.ActionLink("Delete", "Delete", new { id = item.CustomerId })
                </td>
            </tr>
        }
    </tbody>
</table>

Views/Customer/Details.cshtml

@model YourNamespace.Models.Customer
@{
    ViewBag.Title = "Customer Details";
}
<h2>Customer Details</h2>
<div>
    <h4>Customer</h4>
    <hr />
    <dl class="dl-horizontal">
        <dt>
            @Html.DisplayNameFor(model => model.Name)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Name)
        </dd>
        <dt>
            @Html.DisplayNameFor(model => model.Email)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Email)
        </dd>
    </dl>
</div>
<div>
    @Html.ActionLink("Edit", "Edit", new { id = Model.CustomerId }) |
    @Html.ActionLink("Back to List", "Index")
</div>

Views/Customer/Create.cshtml

@model YourNamespace.Models.Customer
@{
    ViewBag.Title = "Create Customer";
}
<h2>Create Customer</h2>
@using (Html.BeginForm())
{
    @Html.AntiForgeryToken()
    <div class="form-horizontal">
        <h4>Customer</h4>
        <hr />
        <div class="form-group">
            @Html.LabelFor(model => model.Name, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.Name, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.Name, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            @Html.LabelFor(model => model.Email, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.Email, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.Email, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            <div class="col-md-offset-2 col-md-10">
                <input type="submit" value="Create" class="btn btn-default" />
            </div>
        </div>
    </div>
}

Views/Customer/Edit.cshtml

@model YourNamespace.Models.Customer
@{
    ViewBag.Title = "Edit Customer";
}
<h2>Edit Customer</h2>
@using (Html.BeginForm())
{
    @Html.AntiForgeryToken()
    <div class="form-horizontal">
        <h4>Customer</h4>
        <hr />
        @Html.HiddenFor(model => model.CustomerId)
        <div class="form-group">
            @Html.LabelFor(model => model.Name, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.Name, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.Name, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            @Html.LabelFor(model => model.Email, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.Email, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.Email, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            <div class="col-md-offset-2 col-md-10">
                <input type="submit" value="Save" class="btn btn-default" />
            </div>
        </div>
    </div>
}

Views/Customer/Delete.cshtml

@model YourNamespace.Models.Customer
@{
    ViewBag.Title = "Delete Customer";
}
<h2>Delete Customer</h2>
<div>
    <h4>Customer</h4>
    <hr />
    <dl class="dl-horizontal">
        <dt>
            @Html.DisplayNameFor(model => model.Name)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Name)
        </dd>
        <dt>
            @Html.DisplayNameFor(model => model.Email)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Email)
        </dd>
    </dl>
</div>
@using (Html.BeginForm())
{
    @Html.AntiForgeryToken()
    @Html.HiddenFor(model => model.CustomerId)
    <div>
        <input type="submit" value="Delete" class="btn btn-danger" /> |
        @Html.ActionLink("Back to List", "Index")
    </div>
}
Sale Views

Sale Views

Views/Sale/Index.cshtml

@model IEnumerable<YourNamespace.Models.Sale>
@{
    ViewBag.Title = "Sales";
}
<h2>Sales</h2>
<p>
    @Html.ActionLink("Create New", "Create")
</p>
<table class="table">
    <thead>
        <tr>
            <th>
                @Html.DisplayNameFor(model => model.SaleDate)
            </th>
            <th>
                @Html.DisplayNameFor(model => model.Amount)
            </th>
            <th></th>
        </tr>
    </thead>
    <tbody>
        @foreach (var item in Model)
        {
            <tr>
                <td>@Html.DisplayFor(modelItem => item.SaleDate)</td>
                <td>@Html.DisplayFor(modelItem => item.Amount)</td>
                <td>
                    @Html.ActionLink("Edit", "Edit", new { id = item.SaleId }) |
                    @Html.ActionLink("Details", "Details", new { id = item.SaleId }) |
                    @Html.ActionLink("Delete", "Delete", new { id = item.SaleId })
                </td>
            </tr>
        }
    </tbody>
</table>

Views/Sale/Details.cshtml

@model YourNamespace.Models.Sale
@{
    ViewBag.Title = "Sale Details";
}
<h2>Sale Details</h2>
<div>
    <h4>Sale</h4>
    <hr />
    <dl class="dl-horizontal">
        <dt>
            @Html.DisplayNameFor(model => model.SaleDate)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.SaleDate)
        </dd>
        <dt>
            @Html.DisplayNameFor(model => model.Amount)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Amount)
        </dd>
    </dl>
</div>
<div>
    @Html.ActionLink("Edit", "Edit", new { id = Model.SaleId }) |
    @Html.ActionLink("Back to List", "Index")
</div>

Views/Sale/Create.cshtml

@model YourNamespace.Models.Sale
@{
    ViewBag.Title = "Create Sale";
}
<h2>Create Sale</h2>
@using (Html.BeginForm())
{
    @Html.AntiForgeryToken()
    <div class="form-horizontal">
        <h4>Sale</h4>
        <hr />
        <div class="form-group">
            @Html.LabelFor(model => model.SaleDate, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.SaleDate, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.SaleDate, "", new { @class = "text-danger" })            
        </div>
    </div>
    <div class="form-group">
        @Html.LabelFor(model => model.Amount, htmlAttributes: new { @class = "control-label col-md-2" })
        <div class="col-md-10">
            @Html.EditorFor(model => model.Amount, new { htmlAttributes = new { @class = "form-control" } })
            @Html.ValidationMessageFor(model => model.Amount, "", new { @class = "text-danger" })
        </div>
    </div>
    <div class="form-group">
        <div class="col-md-offset-2 col-md-10">
            <input type="submit" value="Create" class="btn btn-default" />
        </div>
    </div>
</div>
}

Views/Sale/Edit.cshtml

@model YourNamespace.Models.Sale
@{
    ViewBag.Title = "Edit Sale";
}
<h2>Edit Sale</h2>
@using (Html.BeginForm())
{
    @Html.AntiForgeryToken()
    <div class="form-horizontal">
        <h4>Sale</h4>
        <hr />
        @Html.HiddenFor(model => model.SaleId)
        <div class="form-group">
            @Html.LabelFor(model => model.SaleDate, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.SaleDate, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.SaleDate, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            @Html.LabelFor(model => model.Amount, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.Amount, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.Amount, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            <div class="col-md-offset-2 col-md-10">
                <input type="submit" value="Save" class="btn btn-default" />
            </div>
        </div>
    </div>
}

Views/Sale/Delete.cshtml

@model YourNamespace.Models.Sale
@{
    ViewBag.Title = "Delete Sale";
}
<h2>Delete Sale</h2>
<div>
    <h4>Sale</h4>
    <hr />
    <dl class="dl-horizontal">
        <dt>
            @Html.DisplayNameFor(model => model.SaleDate)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.SaleDate)
        </dd>
        <dt>
            @Html.DisplayNameFor(model => model.Amount)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Amount)
        </dd>
    </dl>
</div>
@using (Html.BeginForm())
{
    @Html.AntiForgeryToken()
    @Html.HiddenFor(model => model.SaleId)
    <div>
        <input type="submit" value="Delete" class="btn btn-danger" /> |
        @Html.ActionLink("Back to List", "Index")
    </div>
}
Payment Views

Payment Views

Views/Payment/Index.cshtml

@model IEnumerable<YourNamespace.Models.Payment>
@{
    ViewBag.Title = "Payments";
}
<h2>Payments</h2>
<p>
    @Html.ActionLink("Create New", "Create")
</p>
<table class="table">
    <thead>
        <tr>
            <th>
                @Html.DisplayNameFor(model => model.PaymentDate)
            </th>
            <th>
                @Html.DisplayNameFor(model => model.Amount)
            </th>
            <th></th>
        </tr>
    </thead>
    <tbody>
        @foreach (var item in Model)
        {
            <tr>
                <td>@Html.DisplayFor(modelItem => item.PaymentDate)</td>
                <td>@Html.DisplayFor(modelItem => item.Amount)</td>
                <td>
                    @Html.ActionLink("Edit", "Edit", new { id = item.PaymentId }) |
                    @Html.ActionLink("Details", "Details", new { id = item.PaymentId }) |
                    @Html.ActionLink("Delete", "Delete", new { id = item.PaymentId })
                </td>
            </tr>
        }
    </tbody>
</table>

Views/Payment/Details.cshtml

@model YourNamespace.Models.Payment
@{
    ViewBag.Title = "Payment Details";
}
<h2>Payment Details</h2>
<div>
    <h4>Payment</h4>
    <hr />
    <dl class="dl-horizontal">
        <dt>
            @Html.DisplayNameFor(model => model.PaymentDate)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.PaymentDate)
        </dd>
        <dt>
            @Html.DisplayNameFor(model => model.Amount)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Amount)
        </dd>
    </dl>
</div>
<div>
    @Html.ActionLink("Edit", "Edit", new { id = Model.PaymentId }) |
    @Html.ActionLink("Back to List", "Index")
</div>

Views/Payment/Create.cshtml

@model YourNamespace.Models.Payment
@{
    ViewBag.Title = "Create Payment";
}
<h2>Create Payment</h2>
@using (Html.BeginForm())
{
    @Html.AntiForgeryToken()
    <div class="form-horizontal">
        <h4>Payment</h4>
        <hr />
        <div class="form-group">
            @Html.LabelFor(model => model.PaymentDate, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.PaymentDate, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.PaymentDate, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            @Html.LabelFor(model => model.Amount, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.Amount, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.Amount, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            <div class="col-md-offset-2 col-md-10">
                <input type="submit" value="Create" class="btn btn-default" />
            </div>
        </div>
    </div>
}

Views/Payment/Edit.cshtml

@model YourNamespace.Models.Payment
@{
    ViewBag.Title = "Edit Payment";
}
<h2>Edit Payment</h2>
@using (Html.BeginForm())
{
    @Html.AntiForgeryToken()
    <div class="form-horizontal">
        <h4>Payment</h4>
        <hr />
        @Html.HiddenFor(model => model.PaymentId)
        <div class="form-group">
            @Html.LabelFor(model => model.PaymentDate, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.PaymentDate, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.PaymentDate, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            @Html.LabelFor(model => model.Amount, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.Amount, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.Amount, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            <div class="col-md-offset-2 col-md-10">
                <input type="submit" value="Save" class="btn btn-default" />
            </div>
        </div>
    </div>
}

Views/Payment/Delete.cshtml

@model YourNamespace.Models.Payment
@{
    ViewBag.Title = "Delete Payment";
}
<h2>Delete Payment</h2>
<div>
    <h4>Payment</h4>
    <hr />
    <dl class="dl-horizontal">
        <dt>
            @Html.DisplayNameFor(model => model.PaymentDate)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.PaymentDate)
        </dd>
        <dt>
            @Html.DisplayNameFor(model => model.Amount)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Amount)
        </dd>
    </dl>
</div>
@using (Html.BeginForm())
{
    @Html.AntiForgeryToken()
    @Html.HiddenFor(model => model.PaymentId)
    <div>
 <input type="submit" value="Delete" class="btn btn-danger" /> |
        @Html.ActionLink("Back to List", "Index")
    </div>
}
Invoice Views

Invoice Views

Views/Invoice/Index.cshtml

@model IEnumerable<YourNamespace.Models.Invoice>
@{
    ViewBag.Title = "Invoices";
}
<h2>Invoices</h2>
<p>
    @Html.ActionLink("Create New", "Create")
</p>
<table class="table">
    <thead>
        <tr>
            <th>
                @Html.DisplayNameFor(model => model.InvoiceDate)
            </th>
            <th>
                @Html.DisplayNameFor(model => model.TotalAmount)
            </th>
            <th></th>
        </tr>
    </thead>
    <tbody>
        @foreach (var item in Model)
        {
            <tr>
                <td>@Html.DisplayFor(modelItem => item.InvoiceDate)</td>
                <td>@Html.DisplayFor(modelItem => item.TotalAmount)</td>
                <td>
                    @Html.ActionLink("Edit", "Edit", new { id = item.InvoiceId }) |
                    @Html.ActionLink("Details", "Details", new { id = item.InvoiceId }) |
                    @Html.ActionLink("Delete", "Delete", new { id = item.InvoiceId })
                </td>
            </tr>
        }
    </tbody>
</table>

Views/Invoice/Details.cshtml

@model YourNamespace.Models.Invoice
@{
    ViewBag.Title = "Invoice Details";
}
<h2>Invoice Details</h2>
<div>
    <h4>Invoice</h4>
    <hr />
    <dl class="dl-horizontal">
        <dt>
            @Html.DisplayNameFor(model => model.InvoiceDate)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.InvoiceDate)
        </dd>
        <dt>
            @Html.DisplayNameFor(model => model.TotalAmount)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.TotalAmount)
        </dd>
    </dl>
</div>
<div>
    @Html.ActionLink("Edit", "Edit", new { id = Model.InvoiceId }) |
    @Html.ActionLink("Back to List", "Index")
</div>

Views/Invoice/Create.cshtml

@model YourNamespace.Models.Invoice
@{
    ViewBag.Title = "Create Invoice";
}
<h2>Create Invoice</h2>
@using (Html.BeginForm())
{
    @Html.AntiForgeryToken()
    <div class="form-horizontal">
        <h4>Invoice</h4>
        <hr />
        <div class="form-group">
            @Html.LabelFor(model => model.InvoiceDate, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.InvoiceDate, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.InvoiceDate, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            @Html.LabelFor(model => model.TotalAmount, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.TotalAmount, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.TotalAmount, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            <div class="col-md-offset-2 col-md-10">
                <input type="submit" value="Create" class="btn btn-default" />
            </div>
        </div>
    </div>
}

Views/Invoice/Edit.cshtml

@model YourNamespace.Models.Invoice
@{
    ViewBag.Title = "Edit Invoice";
}
<h2>Edit Invoice</h2>
@using (Html.BeginForm())
{
    @Html.AntiForgeryToken()
    <div class="form-horizontal">
        <h4>Invoice</h4>
        <hr />
        @Html.HiddenFor(model => model.InvoiceId)
        <div class="form-group">
            @Html.LabelFor(model => model.InvoiceDate, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.InvoiceDate, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.InvoiceDate, "", new { @class = "text-danger" })
            </div>
        </div>
        
        <div class="form-group">
            @Html.LabelFor(model => model.TotalAmount, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.TotalAmount, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.TotalAmount, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            <div class="col-md-offset-2 col-md-10">
                <input type="submit" value="Save" class="btn btn-default" />
            </div>
        </div>
    </div>
}

Views/Invoice/Delete.cshtml

@model YourNamespace.Models.Invoice
@{
    ViewBag.Title = "Delete Invoice";
}
<h2>Delete Invoice</h2>
<div>
    <h4>Invoice</h4>
    <hr />
    <dl class="dl-horizontal">
        <dt>
            @Html.DisplayNameFor(model => model.InvoiceDate)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.InvoiceDate)
        </dd>
        <dt>
            @Html.DisplayNameFor(model => model.TotalAmount)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.TotalAmount)
        </dd>
    </dl>
</div>
@using (Html.BeginForm())
{
    @Html.AntiForgeryToken()
    @Html.HiddenFor(model => model.InvoiceId)
    <div>
        <input type="submit" value="Delete" class="btn btn-danger" /> |
        @Html.ActionLink("Back to List", "Index")
    </div>
}
Report Views

Report Views

Views/Report/Index.cshtml

@model IEnumerable<YourNamespace.Models.Report>
@{
    ViewBag.Title = "Reports";
}
<h2>Reports</h2>
<p>
    @Html.ActionLink("Create New", "Create")
</p>
<table class="table">
    <thead>
        <tr>
            <th>
                @Html.DisplayNameFor(model => model.ReportDate)
            </th>
            <th>
                @Html.DisplayNameFor(model => model.Description)
            </th>
            <th></th>
        </tr>
    </thead>
    <tbody>
        @foreach (var item in Model)
        {
            <tr>
                <td>@Html.DisplayFor(modelItem => item.ReportDate)</td>
                <td>@Html.DisplayFor(modelItem => item.Description)</td>
                <td>
                    @Html.ActionLink("Edit", "Edit", new { id = item.ReportId }) |
                    @Html.ActionLink("Details", "Details", new { id = item.ReportId }) |
                    @Html.ActionLink("Delete", "Delete", new { id = item.ReportId })
                </td>
            </tr>
        }
    </tbody>
</table>

Views/Report/Details.cshtml

@model YourNamespace.Models.Report
@{
    ViewBag.Title = "Report Details";
}
<h2>Report Details</h2>
<div>
    <h4>Report</h4>
    <hr />
    <dl class="dl-horizontal">
        <dt>
            @Html.DisplayNameFor(model => model.ReportDate)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.ReportDate)
        </dd>
        <dt>
            @Html.DisplayNameFor(model => model.Description)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Description)
        </dd>
    </dl>
</div>
<div>
    @Html.ActionLink("Edit", "Edit", new { id = Model.ReportId }) |
    @Html.ActionLink("Back to List", "Index")
</div>

Views/Report/Create.cshtml

@model YourNamespace.Models.Report
@{
    ViewBag.Title = "Create Report";
}
<h2>Create Report</h2>
@using (Html.BeginForm())
{
    @Html.AntiForgeryToken()
    <div class="form-horizontal">
        <h4>Report</h4>
        <hr />
        <div class="form-group">
            @Html.LabelFor(model => model.ReportDate, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.ReportDate, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.ReportDate, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            @Html.LabelFor(model => model.Description , htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.Description, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.Description, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            <div class="col-md-offset-2 col-md-10">
                <input type="submit" value="Create" class="btn btn-default" />
            </div>
        </div>
    </div>
}

Views/Report/Edit.cshtml

@model YourNamespace.Models.Report
@{
    ViewBag.Title = "Edit Report";
}
<h2>Edit Report</h2>
@using (Html.BeginForm())
{
    @Html.AntiForgeryToken()
    <div class="form-horizontal">
        <h4>Report</h4>
        <hr />
        @Html.HiddenFor(model => model.ReportId)
        <div class="form-group">
            @Html.LabelFor(model => model.ReportDate, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.ReportDate, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.ReportDate, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            @Html.LabelFor(model => model.Description, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.Description, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.Description, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            <div class="col-md-offset-2 col-md-10">
                <input type="submit" value="Save" class="btn btn-default" />
            </div>
        </div>
    </div>
}

Views/Report/Delete.cshtml

@model YourNamespace.Models.Report
@{
    ViewBag.Title = "Delete Report";
}
<h2>Delete Report</h2>
<div>
    <h4>Report</h4>
    <hr />
    <dl class="dl-horizontal">
        <dt>
            @Html.DisplayNameFor(model => model.ReportDate)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.ReportDate)
        </dd>
        <dt>
            @Html.DisplayNameFor(model => model.Description)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Description)
        </dd>
    </dl>
</div>
@using (Html.BeginForm())
{
    @Html.AntiForgeryToken()
    @Html.HiddenFor(model => model.ReportId)
    <div>
        <input type="submit" value="Delete" class="btn btn-danger" /> |
        @Html.ActionLink("Back to List", "Index")
    </div>
}

Campaign Views

Views/Campaign/Index.cshtml

@model IEnumerable<YourNamespace.Models.Campaign>
@{
    ViewBag.Title = "Campaigns";
}
<h2>Campaigns</h2>
<p>
    @Html.ActionLink("Create New", "Create")
</p>
<table class="table">
    <thead>
        <tr>
            <th>
                @Html.DisplayNameFor(model => model.CampaignName)
            </th>
            <th>
                @Html.DisplayNameFor(model => model.StartDate)
            </th>
            <th></th>
        </tr>
    </thead>
    <tbody>
        @foreach (var item in Model)
        {
            <tr>
                <td>@Html.DisplayFor(modelItem => item.CampaignName)</td>
                <td>@Html.DisplayFor(modelItem => item.StartDate)</td>
                <td>
                    @Html.ActionLink("Edit", "Edit", new { id = item.CampaignId }) |
                    @Html.ActionLink("Details", "Details", new { id = item.CampaignId }) |
                    @Html.ActionLink("Delete", "Delete", new { id = item.CampaignId })
                </td>
            </tr>
        }
    </tbody>
</table>

Views/Campaign/Details.cshtml

@model YourNamespace.Models.Campaign
@{
    ViewBag.Title = "Campaign Details";
}
<h2>Campaign Details</h2>
<div>    
    <h4>Campaign</h4>
    <hr />
    <dl class="dl-horizontal">
        <dt>
            @Html.DisplayNameFor(model => model.CampaignName)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.CampaignName)
        </dd>
        <dt>
            @Html.DisplayNameFor(model => model.StartDate)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.StartDate)
        </dd>
    </dl>
</div>
<div>
    @Html.ActionLink("Edit", "Edit", new { id = Model.CampaignId }) |
    @Html.ActionLink("Back to List", "Index")
</div>

Views/Campaign/Create.cshtml

@model YourNamespace.Models.Campaign
@{
    ViewBag.Title = "Create Campaign";
}
<h2>Create Campaign</h2>
@using (Html.BeginForm())
{
    @Html.AntiForgeryToken()
    <div class="form-horizontal">
        <h4>Campaign</h4>
        <hr />
        <div class="form-group">
            @Html.LabelFor(model => model.CampaignName, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.CampaignName, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.CampaignName, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            @Html.LabelFor(model => model.StartDate, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.StartDate, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.StartDate, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            <div class="col-md-offset-2 col-md-10">
                <input type="submit" value="Create" class="btn btn-default" />
            </div>
        </div>
    </div>
}

Views/Campaign/Edit.cshtml

@model YourNamespace.Models.Campaign
@{
    ViewBag.Title = "Edit Campaign";
}
<h2>Edit Campaign</h2>
@using (Html.BeginForm())
{
    @Html.AntiForgeryToken()
    <div class="form-horizontal">
        <h4>Campaign</h4>
        <hr />
        @Html.HiddenFor(model => model.CampaignId)
        <div class="form-group">
            @Html.LabelFor(model => model.CampaignName, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.CampaignName, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.CampaignName, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            @Html.LabelFor(model => model.StartDate, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.StartDate, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.StartDate, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            <div class="col-md-offset-2 col-md-10">
                <input type="submit" value="Save" class="btn btn-default" />
            </div>
        </div>
    </div>
}

Views/Campaign/Delete.cshtml

@model YourNamespace.Models.Campaign
@{
    ViewBag.Title = "Delete Campaign";
}
<h2>Delete Campaign</h2>
<div>
    <h4>Campaign</h4>
    <hr />
    <dl class="dl-horizontal">
        <dt>
            @Html.DisplayNameFor(model => model.CampaignName)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.CampaignName)
        </dd>
        <dt>
            @Html.DisplayNameFor(model => model.StartDate)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.StartDate)
        </dd>
    </dl>
</div>
@using (Html.BeginForm())
{
    @Html.AntiForgeryToken()
    @Html.Hidden For model => model.CampaignId)
    <div>
        <input type="submit" value="Delete" class="btn btn-danger" /> |
        @Html.ActionLink("Back to List", "Index")
    </div>
}
TestDrive Views

TestDrive Views

Views/TestDrive/Index.cshtml

@model IEnumerable<YourNamespace.Models.TestDrive>
@{
    ViewBag.Title = "Test Drives";
}
<h2>Test Drives</h2>
<p>
    @Html.ActionLink("Create New", "Create")
</p>
<table class="table">
    <thead>
        <tr>
            <th>
                @Html.DisplayNameFor(model => model.TestDriveDate)
            </th>
            <th>
                @Html.DisplayNameFor(model => model.CustomerName)
            </th>
            <th></th>
        </tr>
    </thead>
    <tbody>
        @foreach (var item in Model)
        {
            <tr>
                <td>@Html.DisplayFor(modelItem => item.TestDriveDate)</td>
                <td>@Html.DisplayFor(modelItem => item.CustomerName)</td>
                <td>
                    @Html.ActionLink("Edit", "Edit", new { id = item.TestDriveId }) |
                    @Html.ActionLink("Details", "Details", new { id = item.TestDriveId }) |
                    @Html.ActionLink("Delete", "Delete", new { id = item.TestDriveId })
                </td>
            </tr>
        }
    </tbody>
</table>

Views/TestDrive/Details.cshtml

@model YourNamespace.Models.TestDrive
@{
    ViewBag.Title = "Test Drive Details";
}
<h2>Test Drive Details</h2>
<div>
    <h4>Test Drive</h4>
    <hr />
    <dl class="dl-horizontal">
        <dt>
            @Html.DisplayNameFor(model => model.TestDriveDate)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.TestDriveDate)
        </dd>
        <dt>
            @Html.DisplayNameFor(model => model.CustomerName)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.CustomerName)
        </dd>
    </dl>
</div>
<div>
    @Html.ActionLink("Edit", "Edit", new { id = Model.TestDriveId }) |
    @Html.ActionLink("Back to List", "Index")
</div>

Views/TestDrive/Create.cshtml

@model YourNamespace.Models.TestDrive
@{
    ViewBag.Title = "Create Test Drive";
}
<h2>Create Test Drive</h2>
@using (Html.BeginForm())
{
    @Html.AntiForgeryToken()
    <div class="form-horizontal">
        <h4>Test Drive</h4>
        <hr />
        <div class="form-group">
            @Html.LabelFor(model => model.TestDriveDate, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.TestDriveDate, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.TestDriveDate, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            @Html.LabelFor(model => model.CustomerName, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.CustomerName, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.CustomerName, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            <div class="col-md-offset-2 col-md-10">
                <input type="submit" value="Create" class="btn btn-default" />
            </div>
        </div>
    </div>
}

Views/TestDrive/Edit.cshtml

@model YourNamespace.Models.TestDrive
@{
    ViewBag.Title = "Edit Test Drive";
}
<h2>Edit Test Drive</h2>
@using (Html.BeginForm())
{
    @Html.AntiForgeryToken()
    <div class="form-horizontal">
        <h4>Test Drive</h4>
        <hr />
        @Html.HiddenFor(model => model.TestDriveId)
        <div class="form-group">
            @Html.LabelFor(model => model.TestDriveDate, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.TestDriveDate, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.TestDriveDate, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            @Html.LabelFor(model => model.CustomerName, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.CustomerName, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.CustomerName, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            <div class="col-md-offset-2 col-md-10">
                <input type="submit" value="Save" class="btn btn-default" />
            </div>
        </div>
    </div>
}

Views/TestDrive/Delete.cshtml

@model YourNamespace.Models.TestDrive
@{
    ViewBag.Title = "Delete Test Drive";
}
<h2>Delete Test Drive</h2>
<div>
    <h4>Test Drive</h4>
    <hr />
    <dl class="dl-horizontal">
        <dt>
            @Html.DisplayNameFor(model => model.TestDriveDate)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.TestDriveDate)
        </dd>
        <dt>
            @Html.DisplayNameFor(model => model.CustomerName)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.CustomerName)
        </dd>
    </dl>
</div>
@using (Html.BeginForm())
{
    @Html.AntiForgeryToken()
    @Html.HiddenFor(model => model.TestDriveId)
    <div>
        <input type="submit" value="Delete" class="btn btn-danger" /> |
        @Html.ActionLink("Back to List", "Index")
    </div>
}

ServiceRecord Views

Views/ServiceRecord/Index.cshtml

@model IEnumerable<YourNamespace.Models.ServiceRecord>
@{
    ViewBag.Title = "Service Records";
}
<h2>Service Records</h2>
<p>
    @Html.ActionLink("Create New", "Create")
</p>
<table class="table">
    <thead>
        <tr>
            <th>
                @Html.DisplayNameFor(model => model.ServiceDate)
            </th>
            <th>
                @Html.DisplayNameFor(model => model.Description)
            </th>
            <th></th>
        </tr>
    </thead>
    <tbody>
        @foreach (var item in Model)
        {
            <tr>
                <td>@Html.DisplayFor(modelItem => item.ServiceDate)</td>
                <td>@Html.DisplayFor(modelItem => item.Description)</td>
                <td>
                    @Html.ActionLink("Edit", "Edit", new { id = item.ServiceRecordId }) |
                    @Html.ActionLink("Details", "Details", new { id = item.ServiceRecordId }) |
                    @Html.ActionLink("Delete", "Delete", new { id = item.ServiceRecordId })
                </td>
            </tr>
        }
    </tbody>
</table>

Views/ServiceRecord/Details.cshtml

@model YourNamespace.Models.ServiceRecord
@{
    ViewBag.Title = "Service Record Details";
}
<h2>Service Record Details</h2>
<div>
    <h4>Service Record</h4>
    <hr />
    <dl class="dl-horizontal">
        <dt>
            @Html.DisplayNameFor(model => model.ServiceDate)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.ServiceDate)
        </dd>
        <dt>
            @Html.DisplayNameFor(model => model.Description)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Description)
        </dd>
    </dl>
</div>
<div>
    @Html.ActionLink("Edit", "Edit", new { id = Model.ServiceRecordId }) |
    @Html.ActionLink("Back to List", "Index")
</div>

Views/ServiceRecord/Create.cshtml

@model YourNamespace.Models.ServiceRecord
@{
    ViewBag.Title = "Create Service Record";
}
<h2>Create Service Record</h2>
@using (Html.BeginForm())
{
    @Html.AntiForgeryToken()
    <div class="form-horizontal">
        <h4>Service Record</h4>
        <hr />
        <div class="form-group">
            @Html.LabelFor(model => model.ServiceDate, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.ServiceDate, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.ServiceDate, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            @Html.LabelFor(model => model.Description, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.Description, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.Description, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            <div class="col-md-offset-2 col-md-10">
                <input type="submit" value="Create" class="btn btn-default" />
            </div>
        </div>
    </div>
}

Views/ServiceRecord/Edit.cshtml

@model YourNamespace.Models.ServiceRecord
@{
    ViewBag.Title = "Edit Service Record";
}
<h2>Edit Service Record</h2>
@using (Html.BeginForm())
{
    @Html.AntiForgeryToken()
    <div class="form-horizontal">
        <h4>Service Record</h4>
        <hr />
        @Html.HiddenFor(model => model.ServiceRecordId)
        <div class="form-group">
            @Html.LabelFor(model => model.ServiceDate, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.ServiceDate, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.ServiceDate, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            @Html.LabelFor(model => model.Description, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.Description, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.Description, "", new { @class = "text-danger" })
            </div>
        </div>
        <div class="form-group">
            <div class="col-md-offset-2 col-md-10">
                <input type="submit" value="Save" class="btn btn-default" />
            </div>
        </div>
    </div>
}

Views/ServiceRecord/Delete.cshtml

@model YourNamespace.Models.ServiceRecord
@{
    ViewBag.Title = "Delete Service Record";
}
<h2>Delete Service Record</h2>
<div>
    <h4>Service Record</h4>
    <hr />
    <dl class="dl-horizontal">
        <dt>
            @Html.DisplayNameFor(model => model.ServiceDate)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.ServiceDate)
        </dd>
        <dt>
            @Html.DisplayNameFor(model => model.Description)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Description)
        </dd>
    </dl>
</div>
@using (Html.BeginForm())
{
    @Html.AntiForgeryToken()
    @Html.HiddenFor(model => model.ServiceRecordId)
    <div>
        <input type="submit" value="Delete" class="btn btn-danger" /> |
        @Html.ActionLink("Back to List", "Index")
    </div>
}

This completes the creation of view files for all the controllers in your ASP.NET MVC application, allowing for full CRUD operations through the user interface. Each view follows a consistent structure, ensuring ease of use and maintainability.

Creating a Dashboard

Creating a dashboard page in an ASP.NET MVC application involves aggregating data from various models and displaying it in a user-friendly format. Below, I will outline how to create a simple dashboard that consolidates data from the different repositories we have created.

Step 1: Create a Dashboard ViewModel

First, we need to create a ViewModel that will hold the consolidated data for the dashboard.

Models/DashboardViewModel.cs

public class DashboardViewModel
{
    public int TotalUsers { get; set; }
    public int TotalRoles { get; set; }
    public int TotalVehicles { get; set; }
    public int TotalCustomers { get; set; }
    public int TotalSales { get; set; }
    public decimal TotalRevenue { get; set; }
    public int TotalPayments { get; set; }
    public int TotalInvoices { get; set; }
    public int TotalCampaigns { get; set; }
    public int TotalTestDrives { get; set; }
    public int TotalServiceRecords { get; set; }
}

Step 2: Create a Dashboard Controller

Next, we will create a controller that will fetch the necessary data from the repositories and pass it to the dashboard view.

Controllers/DashboardController.cs

using System.Web.Mvc;
public class DashboardController : Controller
{
    private readonly UserRepository _userRepository;
    private readonly RoleRepository _roleRepository;
    private readonly VehicleRepository _vehicleRepository;
    private readonly CustomerRepository _customerRepository;
    private readonly SaleRepository _saleRepository;
    private readonly PaymentRepository _paymentRepository;
    private readonly InvoiceRepository _invoiceRepository;
    private readonly CampaignRepository _campaignRepository;
    private readonly TestDriveRepository _testDriveRepository;
    private readonly ServiceRecordRepository _serviceRecordRepository;
    public DashboardController()
    {
        _userRepository = new UserRepository();
        _roleRepository = new RoleRepository();
        _vehicleRepository = new VehicleRepository();
        _customerRepository = new CustomerRepository();
        _saleRepository = new SaleRepository();
        _paymentRepository = new PaymentRepository();
        _invoiceRepository = new InvoiceRepository();
        _campaignRepository = new CampaignRepository();
        _testDriveRepository = new TestDriveRepository();
        _serviceRecordRepository = new ServiceRecordRepository();
    }
    public ActionResult Index()
    {
        var model = new DashboardViewModel
        {
            TotalUsers = _userRepository.GetAllUsers().Count(),
            TotalRoles = _roleRepository.GetAllRoles().Count(),
            TotalVehicles = _vehicleRepository.GetAllVehicles().Count(),
            TotalCustomers = _customerRepository.GetAllCustomers().Count(),
            TotalSales = _saleRepository.GetAllSales().Count(),
            TotalRevenue = _saleRepository.GetAllSales().Sum(s => s.SalePrice),
            TotalPayments = _paymentRepository.GetAllPayments().Count(),
            TotalInvoices = _invoiceRepository.GetAllInvoices().Count(),
            TotalCampaigns = _campaignRepository.GetAllCampaigns().Count(),
            TotalTestDrives = _testDriveRepository.GetAllTestDrives().Count(),
            TotalServiceRecords = _serviceRecordRepository.GetAllServiceRecords().Count()
        };
        return View(model);
    }
}

Step 3: Create the Dashboard View

Now, we will create a view that will display the data from the DashboardViewModel.

Views/Dashboard/Index.cshtml

@model YourNamespace.Models.DashboardViewModel
@{
    ViewBag.Title = "Dashboard";
}
<h2>Dashboard</h2>
<div class="row">
    <div class="col-md-3">
        <div class="panel panel-default">
            <div class="panel-heading">Total Users</div>
            <div class="panel-body">
                <h3>@Model.TotalUsers</h3>
            </div>
        </div>
    </div>
    <div class="col-md-3">
        <div class="panel panel-default">
            <div class="panel-heading">Total Roles</div>
            <div class="panel-body">
                <h3>@Model.TotalRoles</h3>
            </div>
        </div>
    </div>
    <div class="col-md-3">
        <div class="panel panel-default">
            <div class="panel-heading">Total Vehicles</div>
            <div class="panel-body">
                <h3>@Model.TotalVehicles</h3>
            </div>
        </div>
    </div>
    <div class="col-md-3">
        <div class="panel panel-default">
            <div class="panel-heading">Total Customers</div>
            <div class="panel-body">
                <h3>@Model.TotalCustomers</h3>
            </div>
        </div>
    </div>
</div>
<div class="row">
    <div class="col-md-3">
        <div class="panel panel-default">
            <div class="panel-heading">Total Sales</div>
            <div class="panel-body">
                <h3>@Model.TotalSales</h3>
            </div>
        </div>
    </div>
    <div class="col-md-3">
        <div class="panel panel-default">
            <div class="panel-heading">Total Revenue</div>
            <div class="panel-body">
                <h3>@Model.TotalRevenue.ToString("C")</h3>
            </div>
        </div>
    </div>
    <div class="col-md-3">
        <div class="panel panel-default">
            <div class="panel-heading">Total Payments</div>
            <div class="panel-body">
                <h3>@Model.TotalPayments</h3>
            </div>
        </div>
    </div>
    
    <div class="col-md-3">
        <div class="panel panel-default">
            <div class="panel-heading">Total Invoices</div>
            <div class="panel-body">
                <h3>@Model.TotalInvoices</h3>
            </div>
        </div>
    </div>
</div>
<div class="row">
    <div class="col-md-3">
        <div class="panel panel-default">
            <div class="panel-heading">Total Campaigns</div>
            <div class="panel-body">
                <h3>@Model.TotalCampaigns</h3>
            </div>
        </div>
    </div>
    <div class="col-md-3">
        <div class="panel panel-default">
            <div class="panel-heading">Total Test Drives</div>
            <div class="panel-body">
                <h3>@Model.TotalTestDrives</h3>
            </div>
        </div>
    </div>
    <div class="col-md-3">
        <div class="panel panel-default">
            <div class="panel-heading">Total Service Records</div>
            <div class="panel-body">
                <h3>@Model.TotalServiceRecords</h3>
            </div>
        </div>
    </div>
</div>

Step 4: Update the Route Configuration

Make sure to add a route for the dashboard in your RouteConfig.cs if it’s not already set up.

RouteConfig.cs

routes.MapRoute(
    name: "Dashboard",
    url: "Dashboard",
    defaults: new { controller = "Dashboard", action = "Index" }
);