Project Introduction
The Supply Chain Tracking System is designed to enhance the management and visibility of supply chain operations. Built using ASP.NET and SQL Server, this application provides a comprehensive platform for tracking inventory, managing orders, and overseeing shipments. The system allows users to efficiently manage suppliers, monitor inventory levels, and generate reports, ensuring a streamlined supply chain process that improves operational efficiency and decision-making.
Project Objectives
- To create a secure user authentication system for managing user accounts and roles.
- To enable the management of inventory items, including tracking quantities and reorder levels.
- To facilitate the creation and management of orders placed by users.
- To manage supplier information and maintain contact details for effective communication.
- To track shipments associated with orders, including their status and delivery dates.
- To implement quality inspections for shipments to ensure compliance with standards.
- To track costs associated with orders for better financial management.
- To generate reports on inventory, orders, shipments, and overall supply chain performance.
- To provide notifications to users regarding important updates and actions required.
- To collect user feedback to continuously improve the system's functionality and user experience.
Project Modules
- User Management Module: Handles user registration, login, and role management.
- Inventory Management Module: Allows users to create, edit, and delete inventory items.
- Order Management Module: Facilitates the creation and tracking of orders.
- Supplier Management Module: Manages supplier information and contact details.
- Shipment Management Module: Tracks shipments and their statuses.
- Quality Inspection Module: Manages quality inspections for incoming shipments.
- Cost Tracking Module: Tracks costs associated with orders for financial analysis.
- Report Generation Module: Generates reports on supply chain metrics and performance.
- Notification Module: Sends notifications to users regarding important updates.
- Feedback Module: Collects and manages user feedback to enhance the system.
SQL Server Database Tables
-- Create Users Table
CREATE TABLE Users (
UserId INT PRIMARY KEY IDENTITY(1,1),
Username NVARCHAR(50) NOT NULL UNIQUE,
PasswordHash NVARCHAR(256) NOT NULL,
Email NVARCHAR(100) NOT NULL UNIQUE,
FirstName NVARCHAR(50) NOT NULL,
LastName NVARCHAR(50) NOT NULL,
RoleId INT NOT NULL,
CreatedAt DATETIME DEFAULT GETDATE(),
UpdatedAt DATETIME DEFAULT GETDATE(),
FOREIGN KEY (RoleId) REFERENCES Roles(RoleId)
);
-- Create Roles Table
CREATE TABLE Roles (
RoleId INT PRIMARY KEY IDENTITY(1,1),
RoleName NVARCHAR(50) NOT NULL UNIQUE,
CreatedAt DATETIME DEFAULT GETDATE(),
UpdatedAt DATETIME DEFAULT GETDATE()
);
-- Create InventoryItems Table
CREATE TABLE InventoryItems (
InventoryItemId INT PRIMARY KEY IDENTITY(1,1),
ItemName NVARCHAR(100) NOT NULL,
Quantity INT NOT NULL,
ReorderLevel INT NOT NULL,
SupplierId INT NOT NULL,
CreatedAt DATETIME DEFAULT GETDATE(),
UpdatedAt DATETIME DEFAULT GETDATE(),
FOREIGN KEY (SupplierId) REFERENCES Suppliers(SupplierId)
);
-- Create Orders Table
CREATE TABLE Orders (
OrderId INT PRIMARY KEY IDENTITY(1,1),
UserId INT NOT NULL,
OrderDate DATETIME NOT NULL,
TotalAmount DECIMAL(18, 2) NOT NULL,
Status NVARCHAR(50) NOT NULL, -- e.g., Pending, Completed, Cancelled
CreatedAt DATETIME DEFAULT GETDATE(),
UpdatedAt DATETIME DEFAULT GETDATE(),
FOREIGN KEY (User Id) REFERENCES Users(UserId)
);
-- Create Suppliers Table
CREATE TABLE Suppliers (
SupplierId INT PRIMARY KEY IDENTITY(1,1),
SupplierName NVARCHAR(100) NOT NULL,
ContactPerson NVARCHAR(100),
Phone NVARCHAR(20),
Email NVARCHAR(100),
Address NVARCHAR(255),
CreatedAt DATETIME DEFAULT GETDATE(),
UpdatedAt DATETIME DEFAULT GETDATE()
);
-- Create Shipments Table
CREATE TABLE Shipments (
ShipmentId INT PRIMARY KEY IDENTITY(1,1),
OrderId INT NOT NULL,
ShipmentDate DATETIME NOT NULL,
DeliveryDate DATETIME,
Status NVARCHAR(50) NOT NULL, -- e.g., In Transit, Delivered
CreatedAt DATETIME DEFAULT GETDATE(),
UpdatedAt DATETIME DEFAULT GETDATE(),
FOREIGN KEY (OrderId) REFERENCES Orders(OrderId)
);
-- Create Reports Table
CREATE TABLE Reports (
ReportId INT PRIMARY KEY IDENTITY(1,1),
UserId INT NOT NULL,
ReportDate DATETIME NOT NULL,
ReportContent NVARCHAR(MAX),
CreatedAt DATETIME DEFAULT GETDATE(),
FOREIGN KEY (User Id) REFERENCES Users(UserId)
);
-- Create QualityInspections Table
CREATE TABLE QualityInspections (
InspectionId INT PRIMARY KEY IDENTITY(1,1),
ShipmentId INT NOT NULL,
InspectionDate DATETIME NOT NULL,
Status NVARCHAR(50) NOT NULL, -- e.g., Passed, Failed
Comments NVARCHAR(MAX),
CreatedAt DATETIME DEFAULT GETDATE(),
UpdatedAt DATETIME DEFAULT GETDATE(),
FOREIGN KEY (ShipmentId) REFERENCES Shipments(ShipmentId)
);
-- Create CostTracking Table
CREATE TABLE CostTracking (
CostTrackingId INT PRIMARY KEY IDENTITY(1,1),
OrderId INT NOT NULL,
Cost DECIMAL(18, 2) NOT NULL,
CostDate DATETIME NOT NULL,
CreatedAt DATETIME DEFAULT GETDATE(),
FOREIGN KEY (OrderId) REFERENCES Orders(OrderId)
);
-- Create Notifications Table
CREATE TABLE Notifications (
NotificationId INT PRIMARY KEY IDENTITY(1,1),
UserId INT NOT NULL,
Message NVARCHAR(255) NOT NULL,
IsRead BIT NOT NULL DEFAULT 0,
CreatedAt DATETIME DEFAULT GETDATE(),
FOREIGN KEY (User Id) REFERENCES Users(UserId)
);
-- Create Feedback Table
CREATE TABLE Feedback (
FeedbackId INT PRIMARY KEY IDENTITY(1,1),
UserId INT NOT NULL,
FeedbackContent NVARCHAR(MAX) NOT NULL,
CreatedAt DATETIME DEFAULT GETDATE(),
FOREIGN KEY (User Id) REFERENCES Users(UserId)
);
Explanation of Tables
Users: Stores user information, including their role in the system.
Roles: Defines different roles (e.g., Admin, Manager, Staff) in the system.
InventoryItems: Manages inventory items, including their quantities and associated suppliers.
Orders: Records orders placed by users, including order status and total amount.
Suppliers: Contains information about suppliers, including contact details and address.
Shipments: Tracks shipments related to orders, including shipment and delivery dates.
Reports: Allows users to generate reports related to inventory, orders, and shipments.
QualityInspections: Records quality inspections for shipments, including inspection results and comments.
CostTracking: Monitors costs associated with orders, including cost dates and amounts.
Notifications: Stores notifications for users regarding order updates and other relevant information.
Feedback: Collects user feedback on the Supply Chain Tracking System.
This structure provides a comprehensive framework for managing supply chain operations, facilitating effective tracking of inventory, orders, suppliers, and related processes.
To create a model and repository pattern using ADO.NET for an ASP.NET application based on the SQL Server tables you've defined
We will follow these steps:
Define Models
Create C# classes that represent the tables in your database.
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 FirstName { get; set; }
public string LastName { 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 DateTime CreatedAt { get; set; }
public DateTime UpdatedAt { get; set; }
}
public class InventoryItem
{
public int InventoryItemId { get; set; }
public string ItemName { get; set; }
public int Quantity { get; set; }
public int ReorderLevel { get; set; }
public int SupplierId { get; set; }
public DateTime CreatedAt { get; set; }
public DateTime UpdatedAt { get; set; }
}
public class Order
{
public int OrderId { get; set; }
public int UserId { get; set; }
public DateTime OrderDate { get; set; }
public decimal TotalAmount { get; set; }
public string Status { get; set; }
public DateTime CreatedAt { get; set; }
public DateTime UpdatedAt { get; set; }
}
public class Supplier
{
public int SupplierId { get; set; }
public string SupplierName { get; set; }
public string ContactPerson { get; set; }
public string Phone { get; set; }
public string Email { get; set; }
public string Address { get; set; }
public DateTime CreatedAt { get; set; }
public DateTime UpdatedAt { get; set; }
}
public class Shipment
{
public int ShipmentId { get; set; }
public int OrderId { get; set; }
public DateTime ShipmentDate { get; set; }
public DateTime? DeliveryDate { get; set; }
public string Status { get; set; }
public DateTime CreatedAt { get; set; }
public DateTime UpdatedAt { get; set; }
}
public class Report
{
public int ReportId { get; set; }
public int UserId { get; set; }
public DateTime ReportDate { get; set; }
public string ReportContent { get; set; }
public DateTime CreatedAt { get; set; }
}
public class QualityInspection
{
public int InspectionId { get; set; }
public int ShipmentId { get; set; }
public DateTime InspectionDate { get; set; }
public string Status { get; set; }
public string Comments { get; set; }
public DateTime CreatedAt { get; set; }
public DateTime UpdatedAt { get; set; }
}
public class CostTracking
{
public int CostTrackingId { get; set; }
public int OrderId { get; set; }
public decimal Cost { get; set; }
public DateTime CostDate { get; set; }
public DateTime CreatedAt { get; set; }
}
public class Notification
{
public int NotificationId { get; set; }
public int UserId { get; set; }
public string Message { get; set; }
public bool IsRead { get; set; }
public DateTime CreatedAt { get; set; }
}
public class Feedback
{
public int FeedbackId { get; set; }
public int UserId { get; set; }
public string FeedbackContent { get; set; }
public DateTime CreatedAt { get; set; }
}
Step 2: Create Repository Interfaces
Define interfaces for each repository:
public interface IUserRepository
{
User GetUser ById(int userId);
IEnumerable<User> GetAllUsers();
void AddUser (User user);
void UpdateUser (User user);
void DeleteUser (int userId);
}
public interface IRoleRepository
{
Role GetRoleById(int roleId);
IEnumerable<Role> GetAllRoles();
void AddRole(Role role);
void UpdateRole(Role role);
void DeleteRole(int roleId);
}
Implement Repositories
Here is an example implementation of the User Repository using ADO.NET:
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
public class UserRepository : IUserRepository
{
private readonly string _connectionString;
public UserRepository(string connectionString)
{
_connectionString = connectionString;
}
public User GetUser ById(int userId)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Users WHERE UserId = @User Id", connection);
command.Parameters.AddWithValue("@User Id", userId);
connection.Open();
using (var reader = command.ExecuteReader())
{
if (reader.Read())
{
return new User
{
UserId = (int)reader["User Id"],
Username = reader["Username"].ToString(),
Password Hash = reader["PasswordHash"].ToString(),
Email = reader["Email"].ToString(),
FirstName = reader["FirstName"].ToString(),
LastName = reader["LastName"].ToString(),
RoleId = (int)reader["RoleId"],
CreatedAt = (DateTime)reader["CreatedAt"],
UpdatedAt = (DateTime)reader["UpdatedAt"]
};
}
}
}
return null;
}
public IEnumerable<User> GetAllUsers()
{
var users = new List<User>();
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Users", connection);
connection.Open();
using (var 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(),
FirstName = reader["FirstName"].ToString(),
LastName = reader["LastName"].ToString(),
RoleId = (int)reader["RoleId"],
CreatedAt = (DateTime)reader["CreatedAt"],
UpdatedAt = (DateTime)reader["UpdatedAt"]
});
}
}
}
return users;
}
public void AddUser (User user)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("INSERT INTO Users (Username, PasswordHash, Email, FirstName, LastName, RoleId) VALUES (@Username, @PasswordHash, @Email, @FirstName, @LastName, @RoleId)", connection);
command.Parameters.AddWithValue("@Username", user.Username);
command.Parameters.AddWithValue("@PasswordHash", user.PasswordHash);
command.Parameters.AddWithValue("@Email", user.Email);
command.Parameters.AddWithValue("@FirstName", user.FirstName);
command.Parameters.AddWithValue("@LastName", user.LastName);
command.Parameters.AddWithValue("@RoleId", user.RoleId);
connection.Open();
command.ExecuteNonQuery();
}
}
public void UpdateUser (User user)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("UPDATE Users SET Username = @Username, PasswordHash = @PasswordHash, Email = @Email, FirstName = @FirstName, LastName = @LastName, 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("@FirstName", user.FirstName);
command.Parameters.AddWithValue("@LastName", user.LastName);
command.Parameters.AddWithValue("@RoleId", user.RoleId);
connection.Open();
command.ExecuteNonQuery();
}
}
public void DeleteUser (int userId)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("DELETE FROM Users WHERE UserId = @User Id", connection);
command.Parameters.AddWithValue("@User Id", userId);
connection.Open();
command.ExecuteNonQuery();
}
}
}
Sure! Below are the repository implementations for the remaining models based on the structure provided for the User Repository. Each repository will implement the respective interface and provide methods for CRUD operations.
Role Repository
public class RoleRepository : IRoleRepository
{
private readonly string _connectionString;
public RoleRepository(string connectionString)
{
_connectionString = connectionString;
}
public Role GetRoleById(int roleId)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Roles WHERE RoleId = @RoleId", connection);
command.Parameters.AddWithValue("@RoleId", roleId);
connection.Open();
using (var reader = command.ExecuteReader())
{
if (reader.Read())
{
return new Role
{
RoleId = (int)reader["RoleId"],
RoleName = reader["RoleName"].ToString(),
CreatedAt = (DateTime)reader["CreatedAt"],
UpdatedAt = (DateTime)reader["UpdatedAt"]
};
}
}
}
return null;
}
public IEnumerable<Role> GetAllRoles()
{
var roles = new List<Role>();
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Roles", connection);
connection.Open();
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
roles.Add(new Role
{
RoleId = (int)reader["RoleId"],
RoleName = reader["RoleName"].ToString(),
CreatedAt = (DateTime)reader["CreatedAt"],
UpdatedAt = (DateTime)reader["UpdatedAt"]
});
}
}
}
return roles;
}
public void AddRole(Role role)
{
using (var connection = new SqlConnection(_connectionString))
{
var 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 (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("UPDATE Roles SET RoleName = @RoleName, UpdatedAt = GETDATE() 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 (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("DELETE FROM Roles WHERE RoleId = @RoleId", connection);
command.Parameters.AddWithValue("@RoleId", roleId);
connection.Open();
command.ExecuteNonQuery();
}
}
}
InventoryItem Repository
public class InventoryItemRepository : IInventoryItemRepository
{
private readonly string _connectionString;
public InventoryItemRepository(string connectionString)
{
_connectionString = connectionString;
}
public InventoryItem GetInventoryItemById(int inventoryItemId)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM InventoryItems WHERE InventoryItemId = @InventoryItemId", connection);
command.Parameters.AddWithValue("@InventoryItemId", inventoryItemId);
connection.Open();
using (var reader = command.ExecuteReader())
{
if (reader.Read())
{
return new InventoryItem
{
InventoryItemId = (int)reader["InventoryItemId"],
ItemName = reader["ItemName"].ToString(),
Quantity = (int)reader["Quantity"],
ReorderLevel = (int)reader["ReorderLevel"],
SupplierId = (int)reader["SupplierId"],
CreatedAt = (DateTime)reader["CreatedAt"],
UpdatedAt = (DateTime)reader["UpdatedAt"]
};
}
}
}
return null;
}
public IEnumerable<InventoryItem> GetAllInventoryItems()
{
var items = new List<InventoryItem>();
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM InventoryItems", connection);
connection.Open();
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
items.Add(new InventoryItem
{
InventoryItemId = (int)reader["InventoryItemId"],
ItemName = reader["ItemName"].ToString(),
Quantity = (int)reader["Quantity"],
ReorderLevel = (int)reader["ReorderLevel"],
SupplierId = (int)reader["SupplierId"],
CreatedAt = (DateTime)reader["CreatedAt"],
UpdatedAt = (DateTime)reader["UpdatedAt"]
});
}
}
}
return items;
}
public void AddInventoryItem(InventoryItem item)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("INSERT INTO InventoryItems (ItemName, Quantity, ReorderLevel, SupplierId) VALUES (@ItemName, @Quantity, @ReorderLevel, @SupplierId)", connection);
command.Parameters.AddWithValue("@ItemName", item.ItemName);
command.Parameters.AddWithValue("@Quantity", item.Quantity);
command.Parameters.AddWithValue("@ReorderLevel", item.ReorderLevel);
command.Parameters.AddWithValue("@SupplierId", item.SupplierId);
connection.Open();
command.ExecuteNonQuery();
}
}
public void UpdateInventoryItem(InventoryItem item)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("UPDATE InventoryItems SET ItemName = @ItemName, Quantity = @Quantity, ReorderLevel = @ReorderLevel, SupplierId = @SupplierId, UpdatedAt = GETDATE() WHERE InventoryItemId = @InventoryItemId", connection);
command.Parameters.AddWithValue("@InventoryItemId", item.InventoryItemId);
command.Parameters.AddWithValue("@ItemName", item.ItemName);
command.Parameters.AddWithValue("@Quantity", item.Quantity);
command.Parameters.AddWithValue("@ReorderLevel", item.ReorderLevel);
command.Parameters.AddWithValue("@SupplierId", item.SupplierId);
connection.Open();
command.ExecuteNonQuery();
}
}
public void DeleteInventoryItem(int inventoryItemId)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("DELETE FROM InventoryItems WHERE InventoryItemId = @InventoryItemId", connection);
command.Parameters.AddWithValue("@InventoryItemId", inventoryItemId);
connection.Open();
command.ExecuteNonQuery();
}
}
}
Order Repository
public class OrderRepository : IOrderRepository
{
private readonly string _connectionString;
public OrderRepository(string connectionString)
{
_connectionString = connectionString;
}
public Order GetOrderById(int orderId)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Orders WHERE OrderId = @OrderId", connection);
command.Parameters.AddWithValue("@OrderId", orderId);
connection.Open();
using (var reader = command.ExecuteReader())
{
if (reader.Read())
{
return new Order
{
OrderId = (int)reader["OrderId"],
UserId = (int)reader["User Id"],
OrderDate = (DateTime)reader["OrderDate"],
TotalAmount = (decimal)reader["TotalAmount"],
Status = reader["Status"].ToString(),
CreatedAt = (DateTime)reader["CreatedAt"],
UpdatedAt = (DateTime)reader["UpdatedAt"]
};
}
}
}
return null;
}
public IEnumerable<Order> GetAllOrders()
{
var orders = new List<Order>();
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Orders", connection);
connection.Open();
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
orders.Add(new Order
{
OrderId = (int)reader["OrderId"],
UserId = (int)reader["User Id"],
OrderDate = (DateTime)reader["OrderDate"],
TotalAmount = (decimal)reader["TotalAmount"],
Status = reader["Status"].ToString(),
CreatedAt = (DateTime)reader["CreatedAt"],
UpdatedAt = (DateTime)reader["UpdatedAt"]
});
}
}
}
return orders;
}
public void AddOrder(Order order)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("INSERT INTO Orders (User Id, OrderDate, TotalAmount, Status) VALUES (@User Id, @OrderDate, @TotalAmount, @Status)", connection);
command.Parameters.AddWithValue("@User Id", order.UserId);
command.Parameters.AddWithValue("@OrderDate", order.OrderDate);
command.Parameters.AddWithValue("@TotalAmount", order.TotalAmount);
command.Parameters.AddWithValue("@Status", order.Status);
connection.Open();
command.ExecuteNonQuery();
}
}
public void UpdateOrder(Order order)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("UPDATE Orders SET UserId = @User Id, OrderDate = @OrderDate, TotalAmount = @TotalAmount, Status = @Status, UpdatedAt = GETDATE() WHERE OrderId = @OrderId", connection);
command.Parameters.AddWithValue("@OrderId", order.OrderId);
command.Parameters.AddWithValue("@User Id", order.UserId);
command.Parameters.AddWithValue("@OrderDate", order.OrderDate);
command.Parameters.AddWithValue("@TotalAmount", order.TotalAmount);
command.Parameters.AddWithValue("@Status", order.Status);
connection.Open();
command.ExecuteNonQuery();
}
}
public void DeleteOrder(int orderId)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("DELETE FROM Orders WHERE OrderId = @OrderId", connection);
command.Parameters.AddWithValue("@OrderId", orderId);
connection.Open();
command.ExecuteNonQuery();
}
}
}
Supplier Repository
public class SupplierRepository : ISupplierRepository
{
private readonly string _connectionString;
public SupplierRepository(string connectionString)
{
_connectionString = connectionString;
}
public Supplier GetSupplierById(int supplierId)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Suppliers WHERE SupplierId = @SupplierId", connection);
command.Parameters.AddWithValue("@SupplierId", supplierId);
connection.Open();
using (var reader = command.ExecuteReader())
{
if (reader.Read())
{
return new Supplier
{
SupplierId = (int)reader["SupplierId"],
SupplierName = reader["SupplierName"].ToString(),
ContactPerson = reader["ContactPerson"].ToString(),
Phone = reader["Phone"].ToString(),
Email = reader["Email"].ToString(),
Address = reader["Address"].ToString(),
CreatedAt = (DateTime)reader["CreatedAt"],
UpdatedAt = (DateTime)reader["UpdatedAt"]
};
}
}
}
return null;
}
public IEnumerable<Supplier> GetAllSuppliers()
{
var suppliers = new List<Supplier>();
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Suppliers", connection);
connection.Open();
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
suppliers.Add(new Supplier
{
SupplierId = (int)reader["SupplierId"],
SupplierName = reader["SupplierName"].ToString(),
ContactPerson = reader["ContactPerson"].ToString(),
Phone = reader["Phone"].ToString(),
Email = reader["Email"].ToString(),
Address = reader["Address"].ToString(),
CreatedAt = (DateTime)reader["CreatedAt"],
UpdatedAt = (DateTime)reader["UpdatedAt"]
});
}
}
}
return suppliers;
}
public void AddSupplier(Supplier supplier)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("INSERT INTO Suppliers (SupplierName, ContactPerson, Phone, Email, Address) VALUES (@SupplierName, @ContactPerson, @Phone, @Email, @Address)", connection);
command.Parameters.AddWithValue("@SupplierName", supplier.SupplierName);
command.Parameters.AddWithValue("@ContactPerson", supplier.ContactPerson);
command.Parameters.AddWithValue("@Phone", supplier.Phone);
command.Parameters.AddWithValue("@Email", supplier.Email);
command.Parameters.AddWithValue("@Address", supplier.Address);
connection.Open();
command.ExecuteNonQuery();
}
}
public void UpdateSupplier(Supplier supplier)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("UPDATE Suppliers SET SupplierName = @SupplierName, ContactPerson = @ContactPerson, Phone = @Phone, Email = @Email, Address = @Address, UpdatedAt = GETDATE() WHERE SupplierId = @SupplierId", connection);
command.Parameters.AddWithValue("@SupplierId", supplier.SupplierId);
command.Parameters.AddWithValue("@SupplierName", supplier.SupplierName);
command.Parameters.AddWithValue("@ContactPerson", supplier.ContactPerson);
command.Parameters.AddWithValue("@Phone", supplier.Phone);
command.Parameters.AddWithValue("@Email", supplier.Email);
command.Parameters.AddWithValue("@Address", supplier.Address);
connection.Open();
command.ExecuteNonQuery();
}
}
public void DeleteSupplier(int supplierId)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("DELETE FROM Suppliers WHERE SupplierId = @SupplierId", connection);
command.Parameters.AddWithValue("@SupplierId", supplierId);
connection.Open();
command.ExecuteNonQuery();
}
}
}
Shipment Repository
public class ShipmentRepository : IShipmentRepository
{
private readonly string _connectionString;
public ShipmentRepository(string connectionString)
{
_connectionString = connectionString;
}
public Shipment GetShipmentById(int shipmentId)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Shipments WHERE ShipmentId = @ShipmentId", connection);
command.Parameters.AddWithValue("@ShipmentId", shipmentId);
connection.Open();
using (var reader = command.ExecuteReader())
{
if (reader.Read())
{
return new Shipment
{
ShipmentId = (int)reader["ShipmentId"],
OrderId = (int)reader["OrderId"],
ShipmentDate = (DateTime)reader["ShipmentDate"],
DeliveryDate = reader["DeliveryDate"] as DateTime?,
Status = reader["Status"].ToString(),
CreatedAt = (DateTime)reader["CreatedAt"],
UpdatedAt = (DateTime)reader["UpdatedAt"]
};
}
}
}
return null;
}
public IEnumerable<Shipment> GetAllShipments()
{
var shipments = new List<Shipment>();
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Shipments", connection);
connection.Open();
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
shipments.Add(new Shipment
{
ShipmentId = (int)reader["ShipmentId"],
OrderId = (int)reader["OrderId"],
ShipmentDate = (DateTime)reader["ShipmentDate"],
DeliveryDate = reader["DeliveryDate"] as DateTime?,
Status = reader["Status"].ToString(),
CreatedAt = (DateTime)reader["CreatedAt"],
UpdatedAt = (DateTime)reader["UpdatedAt"]
});
}
}
}
return shipments;
}
public void AddShipment(Shipment shipment)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("INSERT INTO Shipments (OrderId, ShipmentDate, DeliveryDate, Status) VALUES (@OrderId, @ShipmentDate, @DeliveryDate, @Status)", connection);
command.Parameters.AddWithValue("@OrderId", shipment.OrderId);
command.Parameters.AddWithValue("@ShipmentDate", shipment.ShipmentDate);
command.Parameters.AddWithValue("@DeliveryDate", (object)shipment.DeliveryDate ?? DBNull.Value);
command.Parameters.AddWithValue("@Status", shipment.Status);
connection.Open();
command.ExecuteNonQuery();
}
}
public void UpdateShipment(Shipment shipment)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("UPDATE Shipments SET OrderId = @OrderId, ShipmentDate = @ShipmentDate, DeliveryDate = @DeliveryDate, Status = @Status, UpdatedAt = GETDATE() WHERE ShipmentId = @ShipmentId", connection);
command.Parameters.AddWithValue("@ShipmentId", shipment.ShipmentId);
command.Parameters.AddWithValue("@OrderId", shipment.OrderId);
command.Parameters.AddWithValue("@ShipmentDate", shipment.ShipmentDate);
command.Parameters.AddWithValue("@DeliveryDate", (object)shipment.DeliveryDate ?? DBNull.Value);
command.Parameters.AddWithValue("@Status", shipment.Status);
connection.Open();
command.ExecuteNonQuery();
}
}
public void DeleteShipment(int shipmentId)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("DELETE FROM Shipments WHERE ShipmentId = @ShipmentId", connection);
command.Parameters.AddWithValue("@ShipmentId", shipmentId);
connection.Open();
command.ExecuteNonQuery();
}
}
}
Report Repository
public class ReportRepository : IReportRepository
{
private readonly string _connectionString;
public ReportRepository(string connectionString)
{
_connectionString = connectionString;
}
public Report GetReportById(int reportId)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Reports WHERE ReportId = @ReportId", connection);
command.Parameters.AddWithValue("@ReportId", reportId);
connection.Open();
using (var reader = command.ExecuteReader())
{
if (reader.Read())
{
return new Report
{
ReportId = (int)reader["ReportId"],
UserId = (int)reader["User Id"],
ReportDate = (DateTime)reader["ReportDate"],
ReportContent = reader["ReportContent"].ToString(),
CreatedAt = (DateTime)reader["CreatedAt"]
};
}
}
}
return null;
}
public IEnumerable<Report> GetAllReports()
{
var reports = new List<Report>();
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Reports", connection);
connection.Open();
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
reports.Add(new Report
{
ReportId = (int)reader["ReportId"],
UserId = (int)reader["User Id"],
ReportDate = (DateTime)reader["ReportDate"],
ReportContent = reader["ReportContent"].ToString(),
CreatedAt = (DateTime)reader["CreatedAt"]
});
}
}
}
return reports;
}
public void AddReport(Report report)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("INSERT INTO Reports (User Id, ReportDate, ReportContent) VALUES (@User Id, @ReportDate, @ReportContent)", connection);
command.Parameters.AddWithValue("@User Id", report.UserId);
command.Parameters.AddWithValue("@ReportDate", report.ReportDate);
command.Parameters.AddWithValue("@ReportContent", report.ReportContent);
connection.Open();
command.ExecuteNonQuery();
}
}
public void UpdateReport(Report report)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("UPDATE Reports SET UserId = @User Id, ReportDate = @ReportDate, ReportContent = @ReportContent WHERE ReportId = @ReportId", connection);
command.Parameters.AddWithValue("@ReportId", report.ReportId);
command.Parameters.AddWithValue("@User Id", report.UserId);
command.Parameters.AddWithValue("@ReportDate", report.ReportDate);
command.Parameters.AddWithValue("@ReportContent", report.ReportContent);
connection.Open();
command.ExecuteNonQuery();
}
}
public void DeleteReport(int reportId)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("DELETE FROM Reports WHERE ReportId = @ReportId", connection);
command.Parameters.AddWithValue("@ReportId", reportId);
connection.Open();
command.ExecuteNonQuery();
}
}
}
QualityInspection Repository
public class QualityInspectionRepository : IQualityInspectionRepository
{
private readonly string _connectionString;
public QualityInspectionRepository(string connectionString)
{
_connectionString = connectionString;
}
public QualityInspection GetQualityInspectionById(int inspectionId)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM QualityInspections WHERE InspectionId = @InspectionId", connection);
command.Parameters.AddWithValue("@InspectionId", inspectionId);
connection.Open();
using (var reader = command.ExecuteReader())
{
if (reader.Read())
{
return new QualityInspection
{
InspectionId = (int)reader["InspectionId"],
ShipmentId = (int)reader["ShipmentId"],
InspectionDate = (DateTime)reader["InspectionDate"],
Status = reader["Status"].ToString(),
Comments = reader["Comments"].ToString(),
CreatedAt = (DateTime)reader["CreatedAt"],
UpdatedAt = (DateTime)reader["UpdatedAt"]
};
}
}
}
return null;
}
public IEnumerable<QualityInspection> GetAllQualityInspections()
{
var inspections = new List<QualityInspection>();
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM QualityInspections", connection);
connection.Open();
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
inspections.Add(new QualityInspection
{
InspectionId = (int)reader["InspectionId"],
ShipmentId = (int)reader["ShipmentId"],
InspectionDate = (DateTime)reader["InspectionDate"],
Status = reader["Status"].ToString(),
Comments = reader["Comments"].ToString(),
CreatedAt = (DateTime)reader["CreatedAt"],
UpdatedAt = (DateTime)reader["UpdatedAt"]
});
}
}
}
return inspections;
}
public void AddQualityInspection(QualityInspection inspection)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("INSERT INTO QualityInspections (ShipmentId, InspectionDate, Status, Comments) VALUES (@ShipmentId, @InspectionDate, @Status, @Comments)", connection);
command.Parameters.AddWithValue("@ShipmentId", inspection.ShipmentId);
command.Parameters.AddWithValue("@InspectionDate", inspection.InspectionDate);
command.Parameters.AddWithValue("@Status", inspection.Status);
command.Parameters.AddWithValue("@Comments", inspection.Comments);
connection.Open();
command.ExecuteNonQuery();
}
}
public void UpdateQualityInspection(QualityInspection inspection)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("UPDATE QualityInspections SET ShipmentId = @ShipmentId, InspectionDate = @InspectionDate, Status = @Status, Comments = @Comments WHERE InspectionId = @InspectionId", connection);
command.Parameters.AddWithValue("@InspectionId", inspection.InspectionId);
command.Parameters.AddWithValue("@ShipmentId", inspection.ShipmentId);
command.Parameters.AddWithValue("@InspectionDate", inspection.InspectionDate);
command.Parameters.AddWithValue("@Status", inspection.Status);
command.Parameters.AddWithValue("@Comments", inspection.Comments);
connection.Open();
command.ExecuteNonQuery();
}
public void DeleteQualityInspection(int inspectionId)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("DELETE FROM QualityInspections WHERE InspectionId = @InspectionId", connection);
command.Parameters.AddWithValue("@InspectionId", inspectionId);
connection.Open();
command.ExecuteNonQuery();
}
}
}
CostTracking Repository
public class CostTrackingRepository : ICostTrackingRepository
{
private readonly string _connectionString;
public CostTrackingRepository(string connectionString)
{
_connectionString = connectionString;
}
public CostTracking GetCostTrackingById(int costTrackingId)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM CostTracking WHERE CostTrackingId = @CostTrackingId", connection);
command.Parameters.AddWithValue("@CostTrackingId", costTrackingId);
connection.Open();
using (var reader = command.ExecuteReader())
{
if (reader.Read())
{
return new CostTracking
{
CostTrackingId = (int)reader["CostTrackingId"],
OrderId = (int)reader["OrderId"],
Cost = (decimal)reader["Cost"],
CostDate = (DateTime)reader["CostDate"],
CreatedAt = (DateTime)reader["CreatedAt"]
};
}
}
}
return null;
}
public IEnumerable<CostTracking> GetAllCostTrackings()
{
var costTrackings = new List<CostTracking>();
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM CostTracking", connection);
connection.Open();
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
costTrackings.Add(new CostTracking
{
CostTrackingId = (int)reader["CostTrackingId"],
OrderId = (int)reader["OrderId"],
Cost = (decimal)reader["Cost"],
CostDate = (DateTime)reader["CostDate"],
CreatedAt = (DateTime)reader["CreatedAt"]
});
}
}
}
return costTrackings;
}
public void AddCostTracking(CostTracking costTracking)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("INSERT INTO CostTracking (OrderId, Cost, CostDate) VALUES (@OrderId, @Cost, @CostDate)", connection);
command.Parameters.AddWithValue("@OrderId", costTracking.OrderId);
command.Parameters.AddWithValue("@Cost", costTracking.Cost);
command.Parameters.AddWithValue("@CostDate", costTracking.CostDate);
connection.Open();
command.ExecuteNonQuery();
}
}
public void UpdateCostTracking(CostTracking costTracking)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("UPDATE CostTracking SET OrderId = @OrderId, Cost = @Cost, CostDate = @CostDate WHERE CostTrackingId = @CostTrackingId", connection);
command.Parameters.AddWithValue("@CostTrackingId", costTracking.CostTrackingId);
command.Parameters.AddWithValue("@OrderId", costTracking.OrderId);
command.Parameters.AddWithValue("@Cost", costTracking.Cost);
command.Parameters.AddWithValue("@CostDate", costTracking.CostDate);
connection.Open();
command.ExecuteNonQuery();
}
}
public void DeleteCostTracking(int costTrackingId)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("DELETE FROM CostTracking WHERE CostTrackingId = @CostTrackingId", connection);
command.Parameters.AddWithValue("@CostTrackingId", costTrackingId);
connection.Open();
command.ExecuteNonQuery();
}
}
}
Notification Repository
public class NotificationRepository : INotificationRepository
{
private readonly string _connectionString;
public NotificationRepository(string connectionString)
{
_connectionString = connectionString;
}
public Notification GetNotificationById(int notificationId)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Notifications WHERE NotificationId = @NotificationId", connection);
command.Parameters.AddWithValue("@NotificationId", notificationId);
connection.Open();
using (var reader = command.ExecuteReader())
{
if (reader.Read())
{
return new Notification
{
NotificationId = (int)reader["NotificationId"],
UserId = (int)reader["User Id"],
Message = reader["Message"].ToString(),
IsRead = (bool)reader["IsRead"],
CreatedAt = (DateTime)reader["CreatedAt"]
};
}
}
}
return null;
}
public IEnumerable<Notification> GetAllNotifications()
{
var notifications = new List<Notification>();
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Notifications", connection);
connection.Open();
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
notifications.Add(new Notification
{
NotificationId = (int)reader["NotificationId"],
UserId = (int)reader["User Id"],
Message = reader["Message"].ToString(),
IsRead = (bool)reader["IsRead"],
CreatedAt = (DateTime)reader["CreatedAt"]
});
}
}
}
return notifications;
}
public void AddNotification(Notification notification)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("INSERT INTO Notifications (User Id, Message, IsRead) VALUES (@User Id, @Message, @IsRead)", connection);
command.Parameters.AddWithValue("@User Id", notification.UserId);
command.Parameters.AddWithValue("@Message", notification.Message);
command.Parameters.AddWithValue("@IsRead", notification.IsRead);
connection.Open();
command.ExecuteNonQuery();
}
}
public void UpdateNotification(Notification notification)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("UPDATE Notifications SET UserId = @User Id, Message = @Message, IsRead = @IsRead WHERE NotificationId = @NotificationId", connection);
command.Parameters.AddWithValue("@NotificationId", notification.NotificationId);
command.Parameters.AddWithValue("@User Id", notification.UserId);
command.Parameters.AddWithValue("@Message", notification.Message);
command.Parameters.AddWithValue("@IsRead", notification.IsRead);
connection.Open();
command.ExecuteNonQuery();
}
}
public void DeleteNotification(int notificationId)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("DELETE FROM Notifications WHERE NotificationId = @NotificationId", connection);
command.Parameters.AddWithValue("@NotificationId", notificationId);
connection.Open();
command.ExecuteNonQuery();
}
}
}
Feedback Repository
public class FeedbackRepository : IFeedbackRepository
{
private readonly string _connectionString;
public FeedbackRepository(string connectionString)
{
_connectionString = connectionString;
}
public Feedback GetFeedbackById(int feedbackId)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Feedback WHERE FeedbackId = @FeedbackId", connection);
command.Parameters.AddWithValue("@FeedbackId", feedbackId);
connection.Open();
using (var reader = command.ExecuteReader())
{
if (reader.Read())
{
return new Feedback
{
FeedbackId = (int)reader["FeedbackId"],
UserId = (int)reader["User Id"],
FeedbackContent = reader["FeedbackContent"].ToString(),
CreatedAt = (DateTime)reader["CreatedAt"]
};
}
}
}
return null;
}
public IEnumerable<Feedback> GetAllFeedbacks()
{
var feedbacks = new List<Feedback>();
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Feedback", connection);
connection.Open();
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
feedbacks.Add(new Feedback
{
FeedbackId = (int)reader["FeedbackId"],
UserId = (int)reader["User Id"],
FeedbackContent = reader["FeedbackContent"].ToString(),
CreatedAt = (DateTime)reader["CreatedAt"]
});
}
}
}
return feedbacks;
}
public void AddFeedback(Feedback feedback)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("INSERT INTO Feedback (User Id, FeedbackContent) VALUES (@User Id, @FeedbackContent)", connection);
command.Parameters.AddWithValue("@User Id", feedback.UserId);
command.Parameters.AddWithValue("@FeedbackContent", feedback.FeedbackContent);
connection.Open();
command.ExecuteNonQuery();
}
}
public void UpdateFeedback(Feedback feedback)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("UPDATE Feedback SET UserId = @User Id, FeedbackContent = @FeedbackContent WHERE FeedbackId = @FeedbackId", connection);
command.Parameters .AddWithValue("@FeedbackId", feedback.FeedbackId);
command.Parameters.AddWithValue("@User Id", feedback.UserId);
command.Parameters.AddWithValue("@FeedbackContent", feedback.FeedbackContent);
connection.Open();
command.ExecuteNonQuery();
}
}
public void DeleteFeedback(int feedbackId)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("DELETE FROM Feedback WHERE FeedbackId = @FeedbackId", connection);
command.Parameters.AddWithValue("@FeedbackId", feedbackId);
connection.Open();
command.ExecuteNonQuery();
}
}
}
This completes the repository implementations for all the models defined in your SQL Server schema. Each repository provides methods for creating, reading, updating, and deleting records in the corresponding database tables. You can now integrate these repositories into your ASP.NET application to manage data access effectively. If you need further assistance or additional features, feel free to ask!
To create controllers for each repository in an ASP.NET MVC application
We will follow the standard pattern of creating a controller for each entity. Each controller will handle HTTP requests and interact with the corresponding repository to perform CRUD operations. Below are example implementations for each controller.
UserController
using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
public class UserController : Controller
{
private readonly IUserRepository _userRepository;
public UserController(IUser Repository userRepository)
{
_userRepository = userRepository;
}
public IActionResult Index()
{
var users = _userRepository.GetAllUsers();
return View(users);
}
public IActionResult Create()
{
return View();
}
[HttpPost]
public IActionResult Create(User user)
{
if (ModelState.IsValid)
{
_userRepository.AddUser (user);
return RedirectToAction("Index");
}
return View(user);
}
public IActionResult Edit(int id)
{
var user = _userRepository.GetUser ById(id);
return View(user);
}
[HttpPost]
public IActionResult Edit(User user)
{
if (ModelState.IsValid)
{
_userRepository.UpdateUser (user);
return RedirectToAction("Index");
}
return View(user);
}
public IActionResult Delete(int id)
{
var user = _userRepository.GetUser ById(id);
return View(user);
}
[HttpPost, ActionName("Delete")]
public IActionResult DeleteConfirmed(int id)
{
_userRepository.DeleteUser (id);
return RedirectToAction("Index");
}
}
RoleController
public class RoleController : Controller
{
private readonly IRoleRepository _roleRepository;
public RoleController(IRoleRepository roleRepository)
{
_roleRepository = roleRepository;
}
public IActionResult Index()
{
var roles = _roleRepository.GetAllRoles();
return View(roles);
}
public IActionResult Create()
{
return View();
}
[HttpPost]
public IActionResult Create(Role role)
{
if (ModelState.IsValid)
{
_roleRepository.AddRole(role);
return RedirectToAction("Index");
}
return View(role);
}
public IActionResult Edit(int id)
{
var role = _roleRepository.GetRoleById(id);
return View(role);
}
[HttpPost]
public IActionResult Edit(Role role)
{
if (ModelState.IsValid)
{
_roleRepository.UpdateRole(role);
return RedirectToAction("Index");
}
return View(role);
}
public IActionResult Delete(int id)
{
var role = _roleRepository.GetRoleById(id);
return View(role);
}
[HttpPost, ActionName("Delete")]
public IActionResult DeleteConfirmed(int id)
{
_roleRepository.DeleteRole(id);
return RedirectToAction("Index");
}
}
InventoryItemController
public class InventoryItemController : Controller
{
private readonly IInventoryItemRepository _inventoryItemRepository;
public InventoryItemController(IInventoryItemRepository inventoryItemRepository)
{
_inventoryItemRepository = inventoryItemRepository;
}
public IActionResult Index()
{
var items = _inventoryItemRepository.GetAllInventoryItems();
return View(items);
}
public IActionResult Create()
{
return View();
}
[HttpPost]
public IActionResult Create(InventoryItem item)
{
if (ModelState.IsValid)
{
_inventoryItemRepository.AddInventoryItem(item);
return RedirectToAction("Index");
}
return View(item);
}
public IActionResult Edit(int id)
{
var item = _inventoryItemRepository.GetInventoryItemById(id);
return View(item);
}
[HttpPost]
public IActionResult Edit(InventoryItem item)
{
if (ModelState.IsValid)
{
_inventoryItemRepository.UpdateInventoryItem(item);
return RedirectToAction("Index");
}
return View(item);
}
public IActionResult Delete(int id)
{
var item = _inventoryItemRepository.GetInventoryItemById(id);
return View(item);
}
[HttpPost, ActionName("Delete")]
public IActionResult DeleteConfirmed(int id)
{
_inventoryItemRepository.DeleteInventoryItem(id);
return RedirectToAction("Index");
}
}
OrderController
public class OrderController : Controller
{
private readonly IOrderRepository _orderRepository;
public OrderController(IOrderRepository orderRepository)
{
_orderRepository = orderRepository;
}
public IActionResult Index()
{
var orders = _orderRepository.GetAllOrders();
return View(orders);
}
public IActionResult Create()
{
return View();
}
[HttpPost]
public IActionResult Create(Order order)
{
if (ModelState.IsValid)
{
_orderRepository.AddOrder(order);
return RedirectToAction("Index");
}
return View(order);
}
public IActionResult Edit(int id)
{
var order = _orderRepository.GetOrderById(id);
return View(order);
}
[HttpPost]
public IActionResult Edit(Order order)
{
if (ModelState.IsValid)
{
_orderRepository.UpdateOrder(order);
return RedirectToAction("Index");
}
return View(order);
}
public IActionResult Delete(int id)
{
var order = _orderRepository.GetOrderById(id);
return View(order);
}
[HttpPost, ActionName("Delete")]
public IActionResult DeleteConfirmed(int id)
{
_orderRepository.DeleteOrder(id);
return RedirectToAction("Index");
}
}
SupplierController
public class SupplierController : Controller
{
private readonly ISupplierRepository _supplierRepository;
public SupplierController(ISupplierRepository supplierRepository)
{
_supplierRepository = supplierRepository;
}
public IActionResult Index()
{
var suppliers = _supplierRepository.GetAllSuppliers();
return View(suppliers);
}
public IActionResult Create()
{
return View();
}
[HttpPost]
public IActionResult Create(Supplier supplier)
{
if (ModelState.IsValid)
{
_supplierRepository.AddSupplier(supplier);
return RedirectToAction("Index");
}
return View(supplier);
}
public IActionResult Edit(int id)
{
var supplier = _supplierRepository.GetSupplierById(id);
return View(supplier);
}
[HttpPost]
public IActionResult Edit(Supplier supplier)
{
if (ModelState.IsValid)
{
_supplierRepository.UpdateSupplier(supplier);
return RedirectToAction("Index");
}
return View(supplier);
}
public IActionResult Delete(int id)
{
var supplier = _supplierRepository.GetSupplierById(id);
return View(supplier);
}
[HttpPost, ActionName("Delete")]
public IActionResult DeleteConfirmed(int id)
{
_supplierRepository.DeleteSupplier(id);
return RedirectToAction("Index");
}
}
ShipmentController
public class ShipmentController : Controller
{
private readonly IShipmentRepository _shipmentRepository;
public ShipmentController(IShipmentRepository shipmentRepository)
{
_shipmentRepository = shipmentRepository;
}
public IActionResult Index()
{
var shipments = _shipmentRepository.GetAllShipments();
return View(shipments);
}
public IActionResult Create()
{
return View();
}
[HttpPost]
public IActionResult Create(Shipment shipment)
{
if (ModelState.IsValid)
{
_shipmentRepository.AddShipment(shipment);
return RedirectToAction("Index");
}
return View(shipment);
}
public IActionResult Edit(int id)
{
var shipment = _shipmentRepository.GetShipmentById(id);
return View(shipment);
}
[HttpPost]
public IActionResult Edit(Shipment shipment)
{
if (ModelState.IsValid)
{
_shipmentRepository.UpdateShipment(shipment);
return RedirectToAction("Index");
}
return View(shipment);
}
public IActionResult Delete(int id)
{
var shipment = _shipmentRepository.GetShipmentById(id);
return View(shipment);
}
[HttpPost, ActionName("Delete")]
public IActionResult DeleteConfirmed(int id)
{
_shipmentRepository.DeleteShipment(id);
return RedirectToAction("Index");
}
}
ReportController
public class ReportController : Controller
{
private readonly IReportRepository _reportRepository;
public ReportController(IReportRepository reportRepository)
{
_reportRepository = reportRepository;
}
public IActionResult Index()
{
var reports = _reportRepository.GetAllReports();
return View(reports);
}
public IActionResult Create()
{
return View();
}
[HttpPost]
public IActionResult Create(Report report)
{
if (ModelState.IsValid)
{
_reportRepository.AddReport(report);
return RedirectToAction("Index");
}
return View(report);
}
public IActionResult Edit(int id)
{
var report = _reportRepository.GetReportById(id);
return View(report);
}
[HttpPost]
public IActionResult Edit(Report report)
{
if (ModelState.IsValid)
{
_reportRepository.UpdateReport(report);
return RedirectToAction("Index");
}
return View(report);
}
public IActionResult Delete(int id)
{
var report = _reportRepository.GetReportById(id);
return View(report);
}
[HttpPost, ActionName("Delete")]
public IActionResult DeleteConfirmed(int id)
{
_reportRepository.DeleteReport(id);
return RedirectToAction("Index");
}
}
QualityInspectionController
public class QualityInspectionController : Controller
{
private readonly IQualityInspectionRepository _qualityInspectionRepository;
public QualityInspectionController(IQualityInspectionRepository qualityInspectionRepository)
{
_qualityInspectionRepository = qualityInspectionRepository;
}
public IActionResult Index()
{
var inspections = _qualityInspectionRepository.GetAllQualityInspections();
return View(inspections);
}
public IActionResult Create()
{
return View();
}
[HttpPost]
public IActionResult Create(QualityInspection inspection)
{
if (ModelState.Is Valid)
{
_qualityInspectionRepository.AddQualityInspection(inspection);
return RedirectToAction("Index");
}
return View(inspection);
}
public IActionResult Edit(int id)
{
var inspection = _qualityInspectionRepository.GetQualityInspectionById(id);
return View(inspection);
}
[HttpPost]
public IActionResult Edit(QualityInspection inspection)
{
if (ModelState.IsValid)
{
_qualityInspectionRepository.UpdateQualityInspection(inspection);
return RedirectToAction("Index");
}
return View(inspection);
}
public IActionResult Delete(int id)
{
var inspection = _qualityInspectionRepository.GetQualityInspectionById(id);
return View(inspection);
}
[HttpPost, ActionName("Delete")]
public IActionResult DeleteConfirmed(int id)
{
_qualityInspectionRepository.DeleteQualityInspection(id);
return RedirectToAction("Index");
}
}
CostTrackingController
public class CostTrackingController : Controller
{
private readonly ICostTrackingRepository _costTrackingRepository;
public CostTrackingController(ICostTrackingRepository costTrackingRepository)
{
_costTrackingRepository = costTrackingRepository;
}
public IActionResult Index()
{
var costTrackings = _costTrackingRepository.GetAllCostTrackings();
return View(costTrackings);
}
public IActionResult Create()
{
return View();
}
[HttpPost]
public IActionResult Create(CostTracking costTracking)
{
if (ModelState.IsValid)
{
_costTrackingRepository.AddCostTracking(costTracking);
return RedirectToAction("Index");
}
return View(costTracking);
}
public IActionResult Edit(int id)
{
var costTracking = _costTrackingRepository.GetCostTrackingById(id);
return View(costTracking);
}
[HttpPost]
public IActionResult Edit(CostTracking costTracking)
{
if (ModelState.IsValid)
{
_costTrackingRepository.UpdateCostTracking(costTracking);
return RedirectToAction("Index");
}
return View(costTracking);
}
public IActionResult Delete(int id)
{
var costTracking = _costTrackingRepository.GetCostTrackingById(id);
return View(costTracking);
}
[HttpPost, ActionName("Delete")]
public IActionResult DeleteConfirmed(int id)
{
_costTrackingRepository.DeleteCostTracking(id);
return RedirectToAction("Index");
}
}
NotificationController
public class NotificationController : Controller
{
private readonly INotificationRepository _notificationRepository;
public NotificationController(INotificationRepository notificationRepository)
{
_notificationRepository = notificationRepository;
}
public IActionResult Index()
{
var notifications = _notificationRepository.GetAllNotifications();
return View(notifications);
}
public IActionResult Create()
{
return View();
}
[HttpPost]
public IActionResult Create(Notification notification)
{
if (ModelState.IsValid)
{
_notificationRepository.AddNotification(notification);
return RedirectToAction("Index");
}
return View(notification);
}
public IActionResult Edit(int id)
{
var notification = _notificationRepository.GetNotificationById(id);
return View(notification);
}
[HttpPost]
public IActionResult Edit(Notification notification)
{
if (ModelState.IsValid)
{
_notificationRepository.UpdateNotification(notification);
return RedirectToAction("Index");
}
return View(notification);
}
public IActionResult Delete(int id)
{
var notification = _notificationRepository.GetNotificationById(id);
return View(notification);
}
[HttpPost, ActionName("Delete")]
public IActionResult DeleteConfirmed(int id)
{
_notificationRepository.DeleteNotification(id);
return RedirectToAction("Index");
}
}
FeedbackController
public class FeedbackController : Controller
{
private readonly IFeedbackRepository _feedbackRepository;
public FeedbackController(IFeedbackRepository feedbackRepository)
{
_feedbackRepository = feedbackRepository;
}
public IActionResult Index()
{
var feedbacks = _feedbackRepository.GetAllFeedbacks();
return View(feedbacks);
}
public IActionResult Create()
{
return View();
}
[HttpPost]
public IActionResult Create(Feedback feedback)
{
if (ModelState.IsValid)
{
_feedbackRepository.AddFeedback(feedback);
return RedirectToAction("Index");
}
return View(feedback);
}
public IActionResult Edit(int id)
{
var feedback = _feedbackRepository.GetFeedbackById(id);
return View(feedback);
}
[HttpPost]
public IActionResult Edit(Feedback feedback)
{
if (ModelState.IsValid)
{
_feedbackRepository.UpdateFeedback(feedback);
return RedirectToAction("Index");
}
return View(feedback);
}
public IActionResult Delete(int id)
{
var feedback = _feedbackRepository.GetFeedbackById(id);
return View(feedback);
}
[HttpPost, ActionName("Delete")]
public IActionResult DeleteConfirmed(int id)
{
_feedbackRepository.DeleteFeedback(id);
return RedirectToAction("Index");
}
}
This completes the controller implementations for all the repositories defined in your application. Each controller provides methods for handling HTTP requests related to the respective entity, allowing for the creation, reading, updating, and deletion of records. You can now integrate these controllers into your ASP.NET MVC application to manage the views effectively. If you need further assistance or additional features, feel free to ask!
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, Create, Edit, and Delete views.
User Views
Views/User/Index.cshtml
@model IEnumerable<User>
<h2>Users</h2>
<a asp-action="Create">Create New User</a>
<table>
<thead>
<tr>
<th>Username</th>
<th>Email</th>
<th>First Name</th>
<th>Last Name</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
@foreach (var user in Model)
{
<tr>
<td>@user.Username</td>
<td>@user.Email</td>
<td>@user.FirstName</td>
<td>@user.LastName</td>
<td>
<a asp-action="Edit" asp-route-id="@user.UserId">Edit</a> |
<a asp-action="Delete" asp-route-id="@user.UserId">Delete</a>
</td>
</tr>
}
</tbody>
</table>
Views/User/Create.cshtml
@model User
<h2>Create User</h2>
<form asp-action="Create">
<div>
<label asp-for="Username"></label>
<input asp-for="Username" />
</div>
<div>
<label asp-for="PasswordHash"></label>
<input asp-for="PasswordHash" type="password" />
</div>
<div>
<label asp-for="Email"></label>
<input asp-for="Email" />
</div>
<div>
<label asp-for="FirstName"></label>
<input asp-for="FirstName" />
</div>
<div>
<label asp-for="LastName"></label>
<input asp-for="LastName" />
</div>
<div>
<label asp-for="RoleId"></label>
<input asp-for="RoleId" />
</div>
<button type="submit">Create</button>
</form>
Views/User/Edit.cshtml
@model User
<h2>Edit User</h2>
<form asp-action="Edit">
<input type="hidden" asp-for="User Id" />
<div>
<label asp-for="Username"></label>
<input asp-for="Username" />
</div>
<div>
<label asp-for="PasswordHash"></label>
<input asp-for="PasswordHash" type="password" />
</div>
<div>
<label asp-for="Email"></label>
<input asp-for="Email" />
</div>
<div>
<label asp-for="FirstName"></label>
<input asp-for="FirstName" />
</div>
<div>
<label asp-for="LastName"></label>
<input asp-for="LastName" />
</div>
<div>
<label asp-for="RoleId"></label>
<input asp-for="RoleId" />
</div>
<button type="submit">Save</button>
</form>
Views/User/Delete.cshtml
@model User
<h2>Delete User</h2>
<div>
<h4>Are you sure you want to delete this user?</h4>
<div>
<strong>Username:</strong> @Model.Username
</div>
<form asp-action="Delete">
<input type="hidden" asp-for="User Id" />
<button type="submit">Delete</button>
<a asp-action="Index">Cancel</a>
</form>
</div>
Role Views
Views/Role/Index.cshtml
@model IEnumerable<Role>
<h2>Roles</h2>
<a asp-action="Create">Create New Role</a>
<table>
<thead>
<tr>
<th>Role Name</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
@foreach (var role in Model)
{
<tr>
<td>@role.RoleName</td>
<td>
<a asp-action="Edit" asp-route-id="@role.RoleId">Edit</a> |
<a asp-action="Delete" asp-route-id="@role.RoleId">Delete</a>
</td>
</tr>
}
</tbody>
</table>
Views/Role/Create.cshtml
@model Role
<h2>Create Role</h2>
<form asp-action="Create">
<div>
<label asp-for="RoleName"></label>
<input asp-for="RoleName" />
</div>
<button type="submit">Create</button>
</form>
Views/Role/Edit.cshtml
@model Role
<h2>Edit Role</h2>
<form asp-action="Edit">
<input type="hidden" asp-for="RoleId" />
<div>
<label asp-for="RoleName"></label>
<input asp-for="RoleName" />
</div>
<button type="submit">Save</button>
</form>
Views/Role/Delete.cshtml
@model Role
<h2>Delete Role</h2>
<div>
<h4>Are you sure you want to delete this role?</h4>
<div>
<strong>Role Name:</strong> @Model.RoleName
</div>
<form asp-action="Delete">
<input type="hidden" asp-for="RoleId" />
<button type="submit">Delete</button>
<a asp-action="Index">Cancel</a>
</form>
</div>
InventoryItem Views
Views/InventoryItem/Index.cshtml
@model IEnumerable<InventoryItem>
<h2>Inventory Items</h2>
<a asp-action="Create">Create New Item</a>
<table>
<thead>
<tr>
<th>Item Name</th>
<th>Quantity</th>
<th>Price</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
@foreach (var item in Model)
{
<tr>
<td>@item.ItemName</td>
<td>@item.Quantity</td>
<td>@item.Price</td>
<td>
<a asp-action="Edit" asp-route-id="@item.ItemId">Edit</a> |
<a asp-action="Delete" asp-route-id="@item.ItemId">Delete</a>
</td>
</tr>
}
</tbody>
</table>
Views/InventoryItem/Create.cshtml
@model InventoryItem
<h2>Create Inventory Item</h2>
<form asp-action="Create">
<div>
<label asp-for="ItemName"></label>
<input asp-for="ItemName" />
</div>
<div>
<label asp-for="Quantity"></label>
<input asp-for="Quantity" />
</div>
<div>
<label asp-for="Price"></label>
<input asp-for="Price" />
</div>
<button type="submit">Create</button>
</form>
Views/InventoryItem/Edit.cshtml
@model InventoryItem
<h2>Edit Inventory Item</h2>
<form asp-action="Edit">
<input type="hidden" asp-for="ItemId" />
<div>
<label asp-for="ItemName"></label>
<input asp-for="ItemName" />
</div>
<div>
<label asp-for="Quantity"></label>
<input asp-for="Quantity" />
</div>
<div>
<label asp-for="Price"></label>
<input asp-for="Price" />
</div>
<button type="submit">Save</button>
</form>
Views/InventoryItem/Delete.cshtml
@model InventoryItem
<h2>Delete Inventory Item</h2>
<div>
<h4>Are you sure you want to delete this item?</h4>
<div>
<strong>Item Name:</strong> @Model.ItemName
</div>
<form asp-action="Delete">
<input type="hidden" asp-for="ItemId" />
<button type="submit">Delete</button>
<a asp-action="Index">Cancel</a>
</form>
</div>
Order Views
Views/Order/Index.cshtml
@model IEnumerable<Order>
<h2>Orders</h2>
<a asp-action="Create">Create New Order</a>
<table>
<thead>
<tr>
<th>Order Number</th>
<th>Customer Name</th>
<th>Total Amount</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
@foreach (var order in Model)
{
<tr>
<td>@order.OrderNumber</td>
<td>@order.CustomerName</td>
<td>@order.TotalAmount</td>
<td>
<a asp-action="Edit" asp-route-id="@order.OrderId">Edit</a> |
<a asp-action="Delete" asp-route-id="@order.OrderId">Delete</a>
</td>
</tr>
}
</tbody>
</table>
Views/Order/Create.cshtml
@model Order
<h2>Create Order</h2>
<form asp-action="Create">
<div>
<label asp-for="OrderNumber"></label>
<input asp-for="OrderNumber" />
</div>
<div>
<label asp-for="CustomerName"></label>
<input asp-for="CustomerName" />
</div>
<div>
<label asp-for="TotalAmount"></label>
<input asp-for="TotalAmount" />
</div>
<button type="submit">Create</button>
</form>
Views/Order/Edit.cshtml
@model Order
<h2>Edit Order</h2>
<form asp-action="Edit">
<input type="hidden" asp-for="OrderId" />
<div>
<label asp-for="OrderNumber"></label>
<input asp-for="OrderNumber" />
</div>
<div>
<label asp-for="CustomerName"></label>
<input asp-for="CustomerName" />
</div>
<div>
<label asp-for="TotalAmount"></label>
<input asp-for="TotalAmount" />
</div>
<button type="submit">Save</button>
</form>
Views/Order/Delete.cshtml
@model Order
<h2>Delete Order</h2>
<div>
<h4>Are you sure you want to delete this order?</h4>
<div>
<strong>Order Number:</strong> @Model.OrderNumber
</div>
<form asp-action="Delete">
<input type="hidden" asp-for="OrderId" />
<button type="submit">Delete</button>
<a asp-action="Index">Cancel</a>
</form>
</div>
Supplier Views
Views/Supplier/Index.cshtml
@model IEnumerable<Supplier>
<h2>Suppliers</h2>
<a asp-action="Create">Create New Supplier</a>
<table>
<thead>
<tr>
<th>Supplier Name</th>
<th>Contact Info</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
@foreach (var supplier in Model)
{
<tr>
<td>@supplier.SupplierName</td>
<td>@supplier.ContactInfo</td>
<td>
<a asp-action="Edit" asp-route-id="@supplier.SupplierId">Edit</a> |
<a asp-action="Delete" asp-route-id="@supplier.SupplierId">Delete</a>
</td>
</tr>
}
</tbody>
</table>
Views/Supplier/Create.cshtml
@model Supplier
<h2>Create Supplier</h2>
<form asp-action="Create">
<div>
<label asp-for="SupplierName"></label>
<input asp-for="SupplierName" />
</div>
<div>
<label asp-for="ContactInfo"></label>
<input asp-for="ContactInfo" />
</div>
<button type="submit">Create</button>
</form>
Views/Supplier/Edit.cshtml
@model Supplier
<h2>Edit Supplier</h2>
<form asp-action="Edit">
<input type="hidden" asp-for="SupplierId" />
<div>
<label asp-for="SupplierName"></label>
<input asp-for="SupplierName" />
</div>
<div>
<label asp-for="ContactInfo"></label>
<input asp-for="ContactInfo" />
</div>
<button type="submit">Save</button>
</form>
Views/Supplier/Delete.cshtml
@model Supplier
<h2>Delete Supplier</h2>
<div>
<h4>Are you sure you want to delete this supplier?</h4>
<div>
<strong>Supplier Name:</strong> @Model.SupplierName
</div>
<form asp-action="Delete">
<input type="hidden" asp-for="SupplierId" />
<button type="submit">Delete</button>
<a asp-action="Index">Cancel</a>
</form>
</div>
Shipment Views
Views/Shipment/Index.cshtml
@model IEnumerable<Shipment>
<h2>Shipments</h2>
<a asp-action="Create">Create New Shipment</a>
<table>
<thead>
<tr>
<th>Shipment Number</th>
<th>Destination</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
@foreach (var shipment in Model)
{
<tr>
<td>@shipment.ShipmentNumber</td>
<td>@shipment.Destination</td>
<td>
<a asp-action="Edit" asp-route-id="@shipment.ShipmentId">Edit</a> |
<a asp-action="Delete" asp-route-id="@shipment.ShipmentId">Delete</a>
</td>
</tr>
}
</tbody>
</table>
Views/Shipment/Create.cshtml
@model Shipment
<h2>Create Shipment</h2>
<form asp-action="Create">
<div>
<label asp-for="ShipmentNumber"></label>
<input asp-for="ShipmentNumber" />
</div>
<div>
<label asp-for ="Destination"></label>
<input asp-for="Destination" />
</div>
<button type="submit">Create</button>
</form>
Views/Shipment/Edit.cshtml
@model Shipment
<h2>Edit Shipment</h2>
<form asp-action="Edit">
<input type="hidden" asp-for="ShipmentId" />
<div>
<label asp-for="ShipmentNumber"></label>
<input asp-for="ShipmentNumber" />
</div>
<div>
<label asp-for="Destination"></label>
<input asp-for="Destination" />
</div>
<button type="submit">Save</button>
</form>
Views/Shipment/Delete.cshtml
@model Shipment
<h2>Delete Shipment</h2>
<div>
<h4>Are you sure you want to delete this shipment?</h4>
<div>
<strong>Shipment Number:</strong> @Model.ShipmentNumber
</div>
<form asp-action="Delete">
<input type="hidden" asp-for="ShipmentId" />
<button type="submit">Delete</button>
<a asp-action="Index">Cancel</a>
</form>
</div>
Report Views
Views/Report/Index.cshtml
@model IEnumerable<Report>
<h2>Reports</h2>
<a asp-action="Create">Create New Report</a>
<table>
<thead>
<tr>
<th>Report Title</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
@foreach (var report in Model)
{
<tr>
<td>@report.Title</td>
<td>
<a asp-action="Edit" asp-route-id="@report.ReportId">Edit</a> |
<a asp-action="Delete" asp-route-id="@report.ReportId">Delete</a>
</td>
</tr>
}
</tbody>
</table>
Views/Report/Create.cshtml
@model Report
<h2>Create Report</h2>
<form asp-action="Create">
<div>
<label asp-for="Title"></label>
<input asp-for="Title" />
</div>
<div>
<label asp-for="Content"></label>
<textarea asp-for="Content"></textarea>
</div>
<button type="submit">Create</button>
</form>
Views/Report/Edit.cshtml
@model Report
<h2>Edit Report</h2>
<form asp-action="Edit">
<input type="hidden" asp-for="ReportId" />
<div>
<label asp-for="Title"></label>
<input asp-for="Title" />
</div>
<div>
<label asp-for="Content"></label>
<textarea asp-for="Content"></textarea>
</div>
<button type="submit">Save</button>
</form>
Views/Report/Delete.cshtml
@model Report
<h2>Delete Report</h2>
<div>
<h4>Are you sure you want to delete this report?</h4>
<div>
<strong>Title:</strong> @Model.Title
</div>
<form asp-action="Delete">
<input type="hidden" asp-for="ReportId" />
<button type="submit">Delete</button>
<a asp-action="Index">Cancel</a>
</form>
</div>
QualityInspection Views
Views/QualityInspection/Index.cshtml
@model IEnumerable<QualityInspection>
<h2>Quality Inspections</h2>
<a asp-action="Create">Create New Inspection</a>
<table>
<thead>
<tr>
<th>Inspection Date</th>
<th>Inspector Name</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
@foreach (var inspection in Model)
{
<tr>
<td>@inspection.InspectionDate.ToShortDateString()</td>
<td>@inspection.InspectorName</td>
<td>
<a asp-action="Edit" asp-route-id="@inspection.InspectionId">Edit</a> |
<a asp-action="Delete" asp-route-id="@inspection.InspectionId">Delete</a>
</td>
</tr>
}
</tbody>
</table>
Views/QualityInspection/Create.cshtml
@model QualityInspection
<h2>Create Quality Inspection</h2>
<form asp-action="Create">
<div>
<label asp -for="InspectionDate"></label>
<input asp-for="InspectionDate" type="date" />
</div>
<div>
<label asp-for="InspectorName"></label>
<input asp-for="InspectorName" />
</div>
<div>
<label asp-for="Comments"></label>
<textarea asp-for="Comments"></textarea>
</div>
<button type="submit">Create</button>
</form>
Views/QualityInspection/Edit.cshtml
@model QualityInspection
<h2>Edit Quality Inspection</h2>
<form asp-action="Edit">
<input type="hidden" asp-for="InspectionId" />
<div>
<label asp-for="InspectionDate"></label>
<input asp-for="InspectionDate" type="date" />
</div>
<div>
<label asp-for="InspectorName"></label>
<input asp-for="InspectorName" />
</div>
<div>
<label asp-for="Comments"></label>
<textarea asp-for="Comments"></textarea>
</div>
<button type="submit">Save</button>
</form>
Views/QualityInspection/Delete.cshtml
@model QualityInspection
<h2>Delete Quality Inspection</h2>
<div>
<h4>Are you sure you want to delete this inspection?</h4>
<div>
<strong>Inspection Date:</strong> @Model.InspectionDate.ToShortDateString()
</div>
<div>
<strong>Inspector Name:</strong> @Model.InspectorName
</div>
<form asp-action="Delete">
<input type="hidden" asp-for="InspectionId" />
<button type="submit">Delete</button>
<a asp-action="Index">Cancel</a>
</form>
</div>
CostTracking Views
Views/CostTracking/Index.cshtml
@model IEnumerable<CostTracking>
<h2>Cost Tracking</h2>
<a asp-action="Create">Create New Cost Tracking</a>
<table>
<thead>
<tr>
<th>Cost Item</th>
<th>Amount</th>
<th>Date</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
@foreach (var cost in Model)
{
<tr>
<td>@cost.Item</td>
<td>@cost.Amount</td>
<td>@cost.Date.ToShortDateString()</td>
<td>
<a asp-action="Edit" asp-route-id="@cost.CostTrackingId">Edit</a> |
<a asp-action="Delete" asp-route-id="@cost.CostTrackingId">Delete</a>
</td>
</tr>
}
</tbody>
</table>
Views/CostTracking/Create.cshtml
@model CostTracking
<h2>Create Cost Tracking</h2>
<form asp-action="Create">
<div>
<label asp-for="Item"></label>
<input asp-for="Item" />
</div>
<div>
<label asp-for="Amount"></label>
<input asp-for="Amount" />
</div>
<div>
<label asp-for="Date"></label>
<input asp-for="Date" type="date" />
</div>
<button type="submit">Create</button>
</form>
Views/CostTracking/Edit.cshtml
@model CostTracking
<h2>Edit Cost Tracking</h2>
<form asp-action="Edit">
<input type="hidden" asp-for="CostTrackingId" />
<div>
<label asp-for="Item"></label>
<input asp-for="Item" />
</div>
<div>
<label asp-for="Amount"></label>
<input asp-for="Amount" />
</div>
<div>
<label asp-for="Date"></label>
<input asp-for="Date" type="date" />
</div>
<button type="submit">Save</button>
</form>
Views/CostTracking/Delete.cshtml
@model CostTracking
<h2>Delete Cost Tracking</h2>
<div>
<h4>Are you sure you want to delete this cost tracking?</h4>
<div>
<strong>Item:</strong> @Model.Item
</div>
<form asp-action="Delete">
<input type="hidden" asp-for="CostTrackingId" />
<button type="submit">Delete</button>
<a asp-action="Index">Cancel</a>
</form>
</div>
### 10. Notification Views
**Views/Notification/Index.cshtml**
@model IEnumerable<Notification>
<h2>Notifications</h2>
<a asp-action="Create">Create New Notification</a>
<table>
<thead>
<tr>
<th>Title</th>
<th>Message</th>
<th>Date</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
@foreach (var notification in Model)
{
<tr>
<td>@notification.Title</td>
<td>@notification.Message</td>
<td>@notification.Date.ToShortDateString()</td>
<td>
<a asp-action="Edit" asp-route-id="@notification.NotificationId">Edit</a> |
<a asp-action="Delete" asp-route-id="@notification.NotificationId">Delete</a>
</td>
</tr>
}
</tbody>
</table>
Notification Views
Views/Notification/Create.cshtml
@model Notification
<h2>Create Notification</h2>
<form asp-action="Create">
<div>
<label asp-for="Title"></label>
<input asp-for="Title" />
</div>
<div>
<label asp-for="Message"></label>
<textarea asp-for="Message"></textarea>
</div>
<div>
<label asp-for="Date"></label>
<input asp-for="Date" type="date" />
</div>
<button type="submit">Create</button>
</form>
Views/Notification/Edit.cshtml
@model Notification
<h2>Edit Notification</h2>
<form asp-action="Edit">
<input type="hidden" asp-for="NotificationId" />
<div>
<label asp-for="Title"></label>
<input asp-for="Title" />
</div>
<div>
<label asp-for="Message"></label>
<textarea asp-for="Message"></textarea>
</div>
<div>
<label asp-for="Date"></label>
<input asp-for="Date" type="date" />
</div>
<button type="submit">Save</button>
</form>
Views/Notification/Delete.cshtml
@model Notification
<h2>Delete Notification</h2>
<div>
<h4>Are you sure you want to delete this notification?</h4>
<div>
<strong>Title:</strong> @Model.Title
</div>
<form asp-action="Delete">
<input type="hidden" asp-for="NotificationId" />
<button type="submit">Delete</button>
<a asp-action="Index">Cancel</a>
</form>
</div>
Feedback Views
Views/Feedback/Index.cshtml
@model IEnumerable<Feedback>
<h2>Feedbacks</h2>
<a asp-action="Create">Create New Feedback</a>
<table>
<thead>
<tr>
<th>Feedback Title</th>
<th>Comments</th>
<th>Date</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
@foreach (var feedback in Model)
{
<tr>
<td>@feedback.Title</td>
<td>@feedback.Comments</td>
<td>@feedback.Date.ToShortDateString()</td>
<td>
<a asp-action="Edit" asp-route-id="@feedback.FeedbackId">Edit</a> |
<a asp-action="Delete" asp-route-id="@feedback.FeedbackId">Delete</a>
</td>
</tr>
}
</tbody>
</table>
Views/Feedback/Create.cshtml
@model Feedback
<h2>Create Feedback</h2>
<form asp-action="Create">
<div>
<label asp-for="Title"></label>
<input asp-for="Title" />
</div>
<div>
<label asp-for="Comments"></label>
<textarea asp-for="Comments"></textarea>
</div>
<div>
<label asp-for="Date"></label>
<input asp-for="Date" type="date" />
</div>
<button type="submit">Create</button>
</form>
Views/Feedback/Edit.cshtml
@model Feedback
<h2>Edit Feedback</h2>
<form asp-action="Edit">
<input type="hidden" asp-for="FeedbackId" />
<div>
<label asp-for="Title"></label>
<input asp-for="Title" />
</div>
<div>
<label asp -for="Comments"></label>
<textarea asp-for="Comments"></textarea>
</div>
<div>
<label asp-for="Date"></label>
<input asp-for="Date" type="date" />
</div>
<button type="submit">Save</button>
</form>
Views/Feedback/Delete.cshtml
@model Feedback
<h2>Delete Feedback</h2>
<div>
<h4>Are you sure you want to delete this feedback?</h4>
<div>
<strong>Title:</strong> @Model.Title
</div>
<form asp-action="Delete">
<input type="hidden" asp-for="FeedbackId" />
<button type="submit">Delete</button>
<a asp-action="Index">Cancel</a>
</form>
</div>
This completes the view implementations for all the controllers defined in your application. Each view provides a user interface for managing the respective entity, allowing users to create, read, update, and delete records. If you need further assistance or additional features, feel free to ask!
Creating a dashboard page
In an ASP.NET MVC application involves aggregating data from various repositories and presenting it in a user-friendly format. Below, I will outline how to create a simple dashboard that displays consolidated data related to your project, such as the number of users, roles, inventory items, orders, suppliers, shipments, reports, quality inspections, cost tracking, notifications, and feedback.
Step 1: Create a Dashboard ViewModel
First, create a ViewModel that will hold the consolidated data for the dashboard.
Models/DashboardViewModel.cs
public class DashboardViewModel
{
public int UserCount { get; set; }
public int RoleCount { get; set; }
public int InventoryItemCount { get; set; }
public int OrderCount { get; set; }
public int SupplierCount { get; set; }
public int ShipmentCount { get; set; }
public int ReportCount { get; set; }
public int QualityInspectionCount { get; set; }
public int CostTrackingCount { get; set; }
public int NotificationCount { get; set; }
public int FeedbackCount { get; set; }
}
Step 2: Create the Dashboard Controller
Next, create a controller that will handle the logic for the dashboard.
Controllers/DashboardController.cs
using Microsoft.AspNetCore.Mvc;
public class DashboardController : Controller
{
private readonly IUserRepository _userRepository;
private readonly IRoleRepository _roleRepository;
private readonly IInventoryItemRepository _inventoryItemRepository;
private readonly IOrderRepository _orderRepository;
private readonly ISupplierRepository _supplierRepository;
private readonly IShipmentRepository _shipmentRepository;
private readonly IReportRepository _reportRepository;
private readonly IQualityInspectionRepository _qualityInspectionRepository;
private readonly ICostTrackingRepository _costTrackingRepository;
private readonly INotificationRepository _notificationRepository;
private readonly IFeedbackRepository _feedbackRepository;
public DashboardController(
IUserRepository userRepository,
IRoleRepository roleRepository,
IInventoryItemRepository inventoryItemRepository,
IOrderRepository orderRepository,
ISupplierRepository supplierRepository,
IShipmentRepository shipmentRepository,
IReportRepository reportRepository,
IQualityInspectionRepository qualityInspectionRepository,
ICostTrackingRepository costTrackingRepository,
INotificationRepository notificationRepository,
IFeedbackRepository feedbackRepository)
{
_userRepository = userRepository;
_roleRepository = roleRepository;
_inventoryItemRepository = inventoryItemRepository;
_orderRepository = orderRepository;
_supplierRepository = supplierRepository;
_shipmentRepository = shipmentRepository;
_reportRepository = reportRepository;
_qualityInspectionRepository = qualityInspectionRepository;
_costTrackingRepository = costTrackingRepository;
_notificationRepository = notificationRepository;
_feedbackRepository = feedbackRepository;
}
public IActionResult Index()
{
var model = new DashboardViewModel
{
UserCount = _userRepository.GetAllUsers().Count(),
RoleCount = _roleRepository.GetAllRoles().Count(),
InventoryItemCount = _inventoryItemRepository.GetAllInventoryItems().Count(),
OrderCount = _orderRepository.GetAllOrders().Count(),
SupplierCount = _supplierRepository.GetAllSuppliers().Count(),
ShipmentCount = _shipmentRepository.GetAllShipments().Count(),
ReportCount = _reportRepository.GetAllReports().Count(),
QualityInspectionCount = _qualityInspectionRepository.GetAllQualityInspections().Count(),
CostTrackingCount = _costTrackingRepository.GetAllCostTrackings().Count(),
NotificationCount = _notificationRepository.GetAllNotifications().Count(),
FeedbackCount = _feedbackRepository.GetAllFeedbacks().Count()
};
return View(model);
}
}
Step 3: Create the Dashboard View
Now, create a view to display the dashboard data.
Views/Dashboard/Index.cshtml
@model DashboardViewModel
<h2>Dashboard</h2>
<div class="dashboard">
<div class="card">
<h3>Total Users</h3>
<p>@Model.UserCount</p>
</div>
<div class="card">
<h3>Total Roles</h3>
<p>@Model.RoleCount</p>
</div>
<div class="card">
<h3>Total Inventory Items</h3>
<p>@Model.InventoryItemCount</p>
</div>
<div class="card">
<h3>Total Orders</h3>
<p>@Model.OrderCount</p>
</div>
<div class="card">
<h3>Total Suppliers</h3>
<p>@Model.SupplierCount</p>
</div>
<div class="card">
<h3>Total Shipments</h3>
<p>@Model.ShipmentCount</p>
</div>
<div class="card">
<h3>Total Reports</h3>
<p>@Model.ReportCount</p>
</div>
<div class="card">
<h3>Total Quality Inspections</h3>
<p>@Model.QualityInspectionCount</p>
</div>
<div class="card">
<h3>Total Cost Tracking</h3>
<p>@Model.CostTrackingCount</p>
</div>
<div class="card">
<h3>Total Notifications</h3>
<p>@Model.NotificationCount</p>
</div>
<div class="card">
<h3>Total Feedback</h3>
<p>@Model.FeedbackCount</p>
</div>
</div>
<style>
.dashboard {
display: grid;
grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));
gap: 20px;
}
.card {
border: 1px solid #ccc;
padding: 20px;
border-radius: 5px;
text-align: center;
}
.card h3 {
margin: 0 0 10px;
}
.card p {
font-size: 24px;
font-weight: bold;
}
</style>
Step 4: Update the Routing
Ensure that the routing is set up to access the dashboard. You can add a route in your Startup.cs or Program.cs file, depending on your ASP.NET version.
app.UseEndpoints(endpoints =>
{
endpoints.MapControllerRoute(
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}");
endpoints.MapControllerRoute(
name: "dashboard",
pattern: "Dashboard",
defaults: new { controller = "Dashboard", action = "Index" });
});
Step 5: Access the Dashboard
You can now access the dashboard by navigating to /Dashboard in your web application. This page will display consolidated data related to your project, providing a quick overview of key metrics.
If you need further customization or additional features for the dashboard, feel free to ask!
AI 
ASP.NET API 
ASP.NET CLI 
ASP.NET Core 
ASP.NET MVC 
ASP.NET Projects With Source Code 
ASP.NET Web Forms 
ASP.NET Web Pages 
AWS 
Angular 10 
Bash 
Bitcoin 
Blockchain 
C Tutorial 
C# 
CPP 
Chat GPT 
Cheat Sheet 
Cyber Security 
Dart 
Django 
Docker 
Ether.js 
Ethereum 
Flask 
Flask Projects With Source Code 
GEN AI 
Git 
Go Language 
Google Cloud Platform 
GraphQL 
Hardhat 
INI 
JSON 
Java 
JavaScript 
Kotlin 
Kubernetes 
LaTeX 
Laravel 
Laravel 10 E-Commerce Project 
Laravel 11 E-Commerce Project 
Laravel 9 E-Commerce Project 
Laravel 9 React Tutorial 
Laravel E-Commerce Project 
Laravel Home Services Project 
Laravel Projects With Source Code 
Laravel Tutorial Advanced 
Laravel Tutorial Beginners 
Livewire 
Markdown 
Matlab 
Metamask 
Microsoft Azure 
MongoDB Tutorial Advanced 
MongoDB Tutorial Beginners 
MySql Tutorial Advanced 
MySql Tutorial Beginners 
NextJS 
Node JS 
Node JS Projects With Source Code 
PHP Projects With Source Code 
PHP Tutorial Advanced 
PHP Tutorial Beginners 
Project Database Schema 
Python 
React JS 
Ruby 
Rust 
SQL Server Queries 
SQL Server Tutorial Advanced 
SQL Server Tutorial Beginners 
Sass 
Solidity 
Spring Boot 
Truffle 
TypeScript 
VueJS 
Web3.js 
WordPress Tutorial Advanced 
WordPress Tutorial Beginners 
YAML