Project Introduction
The Blood Bank Management System is designed to streamline the processes involved in managing blood donations, donor information, and blood inventory. Built using ASP.NET and SQL Server, this system aims to provide a comprehensive solution for blood banks to efficiently manage their operations. The application will facilitate donor registration, appointment scheduling, blood product management, and reporting, ensuring that blood banks can maintain adequate supplies and respond effectively to the needs of hospitals and patients.
Project Objectives
- To create a user-friendly interface for donors and administrators to manage blood donation activities.
- To implement a secure authentication system for users with different roles (e.g., admin, donor).
- To enable donors to schedule appointments for blood donation and track their donation history.
- To manage blood products, including tracking quantities, expiry dates, and inventory levels.
- To generate reports on donations, inventory status, and quality control inspections.
- To facilitate the organization of blood donation campaigns to encourage community participation.
Project Modules
- User Management Module: Handles user registration, login, and role management.
- Donor Management Module: Allows donors to register, view their donation history, and schedule appointments.
- Appointment Management Module: Manages the scheduling and status of donor appointments.
- Blood Product Management Module: Facilitates the tracking and management of blood products and their inventory.
- Order Management Module: Manages orders for blood products, including tracking order status.
- Quality Control Module: Ensures the quality of blood products through inspections and reporting.
- Reporting Module: Generates various reports for analysis and decision-making.
- Campaign Management Module: Organizes and manages blood donation campaigns to increase donor participation.
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 Donors Table
CREATE TABLE Donors (
DonorId INT PRIMARY KEY IDENTITY(1,1),
UserId INT NOT NULL,
BloodType NVARCHAR(3) NOT NULL, -- e.g., A+, O-, B+
LastDonationDate DATETIME,
CreatedAt DATETIME DEFAULT GETDATE(),
UpdatedAt DATETIME DEFAULT GETDATE(),
FOREIGN KEY (User Id) REFERENCES Users(UserId)
);
-- Create Appointments Table
CREATE TABLE Appointments (
AppointmentId INT PRIMARY KEY IDENTITY(1,1),
DonorId INT NOT NULL,
AppointmentDate DATETIME NOT NULL,
Status NVARCHAR(50) NOT NULL, -- e.g., Scheduled, Completed, Cancelled
CreatedAt DATETIME DEFAULT GETDATE(),
UpdatedAt DATETIME DEFAULT GETDATE(),
FOREIGN KEY (DonorId) REFERENCES Donors(DonorId)
);
-- Create BloodProducts Table
CREATE TABLE BloodProducts (
BloodProductId INT PRIMARY KEY IDENTITY(1,1),
BloodType NVARCHAR(3) NOT NULL, -- e.g., A+, O-, B+
Quantity INT NOT NULL,
ExpiryDate DATETIME NOT NULL,
CollectedAt DATETIME DEFAULT GETDATE(),
CreatedAt DATETIME DEFAULT GETDATE(),
UpdatedAt DATETIME DEFAULT GETDATE()
);
-- Create Inventory Table
CREATE TABLE Inventory (
InventoryId INT PRIMARY KEY IDENTITY(1,1),
BloodProductId INT NOT NULL,
Quantity INT NOT NULL,
CreatedAt DATETIME DEFAULT GETDATE(),
UpdatedAt DATETIME DEFAULT GETDATE(),
FOREIGN KEY (BloodProductId) REFERENCES BloodProducts(BloodProductId)
);
-- Create Orders Table
CREATE TABLE Orders (
OrderId INT PRIMARY KEY IDENTITY(1,1),
BloodProductId INT NOT NULL,
Quantity INT NOT NULL,
OrderDate DATETIME DEFAULT GETDATE(),
Status NVARCHAR(50) NOT NULL, -- e.g., Pending, Completed, Cancelled
CreatedAt DATETIME DEFAULT GETDATE(),
UpdatedAt DATETIME DEFAULT GETDATE(),
FOREIGN KEY (BloodProductId) REFERENCES BloodProducts(BloodProductId)
);
-- 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 QualityControl Table
CREATE TABLE QualityControl (
QualityControlId INT PRIMARY KEY IDENTITY(1,1),
BloodProductId 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 (BloodProductId) REFERENCES BloodProducts(BloodProductId)
);
-- Create Campaigns Table
CREATE TABLE Campaigns (
CampaignId INT PRIMARY KEY IDENTITY(1,1),
CampaignName NVARCHAR(100) NOT NULL,
StartDate DATETIME NOT NULL,
EndDate DATETIME NOT NULL,
CreatedAt DATETIME DEFAULT GETDATE(),
UpdatedAt DATETIME DEFAULT GETDATE()
);
Explanation of Tables
Users: Stores user information, including their role in the system (e.g., Admin, Staff).
Roles: Defines different roles in the system (e.g., Admin, Donor, Staff).
Donors: Contains information about blood donors, including their blood type and last donation date.
Appointments: Manages appointments for donors, including status and appointment date.
BloodProducts: Tracks blood products, including type, quantity, and expiry date.
Inventory: Manages the inventory of blood products, tracking the quantity available.
Orders: Records orders for blood products, including quantity and status of the order.
Reports: Stores reports generated by users, including content and date of the report.
QualityControl: Manages quality control inspections for blood products, including status and comments.
Campaigns: Tracks blood donation campaigns, including their duration and details.
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: Define Models
Create a folder named Models in your ASP.NET project and add the following classes:
// Models/User.cs
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; }
}
// Models/Role.cs
public class Role
{
public int RoleId { get; set; }
public string RoleName { get; set; }
public DateTime CreatedAt { get; set; }
public DateTime UpdatedAt { get; set; }
}
// Models/Donor.cs
public class Donor
{
public int DonorId { get; set; }
public int UserId { get; set; }
public string BloodType { get; set; }
public DateTime? LastDonationDate { get; set; }
public DateTime CreatedAt { get; set; }
public DateTime UpdatedAt { get; set; }
}
// Models/Appointment.cs
public class Appointment
{
public int AppointmentId { get; set; }
public int DonorId { get; set; }
public DateTime AppointmentDate { get; set; }
public string Status { get; set; }
public DateTime CreatedAt { get; set; }
public DateTime UpdatedAt { get; set; }
}
// Models/BloodProduct.cs
public class BloodProduct
{
public int BloodProductId { get; set; }
public string BloodType { get; set; }
public int Quantity { get; set; }
public DateTime ExpiryDate { get; set; }
public DateTime CollectedAt { get; set; }
public DateTime CreatedAt { get; set; }
public DateTime UpdatedAt { get; set; }
}
// Models/Inventory.cs
public class Inventory
{
public int InventoryId { get; set; }
public int BloodProductId { get; set; }
public int Quantity { get; set; }
public DateTime CreatedAt { get; set; }
public DateTime UpdatedAt { get; set; }
}
// Models/Order.cs
public class Order
{
public int OrderId { get; set; }
public int BloodProductId { get; set; }
public int Quantity { get; set; }
public DateTime OrderDate { get; set; }
public string Status { get; set; }
public DateTime CreatedAt { get; set; }
public DateTime UpdatedAt { get; set; }
}
// Models/Report.cs
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; }
}
// Models/QualityControl.cs
public class QualityControl
{
public int QualityControlId { get; set; }
public int BloodProductId { 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; }
}
// Models/Campaign.cs
public class Campaign
{
public int CampaignId { get; set; }
public string CampaignName { get; set; }
public DateTime StartDate { get; set; }
public DateTime EndDate { get; set; }
public DateTime CreatedAt { get; set; }
public DateTime UpdatedAt { get; set; }
}
Step 2: Create Repository Interfaces
Create a folder named Repositories and define interfaces for each model:
// Repositories/IUser Repository.cs
public interface IUserRepository
{
Task<User> GetUser ByIdAsync(int userId);
Task<IEnumerable<User>> GetAllUsersAsync();
Task AddUser Async(User user);
Task UpdateUser Async(User user);
Task DeleteUser Async(int userId);
}
Step 3: Implement Repositories
Implement the repository interfaces using ADO.NET. Here’s an example for the User Repository:
// Repositories/UserRepository.cs
using System.Data;
using System.Data.SqlClient;
using System.Threading.Tasks;
public class UserRepository : IUserRepository
{
private readonly string _connectionString;
public UserRepository(string connectionString)
{
_connectionString = connectionString;
}
public async Task<User> GetUser ByIdAsync(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);
await connection.OpenAsync();
using (var reader = await command.ExecuteReaderAsync())
{
if (await reader.ReadAsync())
{
return 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 null;
}
public async Task<IEnumerable<User>> GetAllUsersAsync()
{
var users = new List<User>();
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Users", connection);
await connection.OpenAsync();
using (var reader = await command.ExecuteReaderAsync())
{
while (await reader.ReadAsync())
{
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 async Task AddUser Async(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);
await connection.OpenAsync();
await command.ExecuteNonQueryAsync();
}
}
public async Task UpdateUser Async(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);
await connection.OpenAsync();
await command.ExecuteNonQueryAsync();
}
}
public async Task DeleteUser Async(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);
await connection.OpenAsync();
await command.ExecuteNonQueryAsync();
}
}
}
This pattern can be replicated for other models and their respective repositories, ensuring that each repository handles its own data access logic while adhering to the interface defined.
Create Remaining Repositories
Sure! Below are the implementations for the remaining repositories based on the models defined earlier. Each repository will follow a similar pattern to the User Repository provided previously.
Role Repository
// Repositories/RoleRepository.cs
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Threading.Tasks;
public class RoleRepository : IRoleRepository
{
private readonly string _connectionString;
public RoleRepository(string connectionString)
{
_connectionString = connectionString;
}
public async Task<Role> GetRoleByIdAsync(int roleId)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Roles WHERE RoleId = @RoleId", connection);
command.Parameters.AddWithValue("@RoleId", roleId);
await connection.OpenAsync();
using (var reader = await command.ExecuteReaderAsync())
{
if (await reader.ReadAsync())
{
return new Role
{
RoleId = (int)reader["RoleId"],
RoleName = reader["RoleName"].ToString(),
CreatedAt = (DateTime)reader["CreatedAt"],
UpdatedAt = (DateTime)reader["UpdatedAt"]
};
}
}
}
return null;
}
public async Task<IEnumerable<Role>> GetAllRolesAsync()
{
var roles = new List<Role>();
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Roles", connection);
await connection.OpenAsync();
using (var reader = await command.ExecuteReaderAsync())
{
while (await reader.ReadAsync())
{
roles.Add(new Role
{
RoleId = (int)reader["RoleId"],
RoleName = reader["RoleName"].ToString(),
CreatedAt = (DateTime)reader["CreatedAt"],
UpdatedAt = (DateTime)reader["UpdatedAt"]
});
}
}
}
return roles;
}
public async Task AddRoleAsync(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);
await connection.OpenAsync();
await command.ExecuteNonQueryAsync();
}
}
public async Task UpdateRoleAsync(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);
await connection.OpenAsync();
await command.ExecuteNonQueryAsync();
}
}
public async Task DeleteRoleAsync(int roleId)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("DELETE FROM Roles WHERE RoleId = @RoleId", connection);
command.Parameters.AddWithValue("@RoleId", roleId);
await connection.OpenAsync();
await command.ExecuteNonQueryAsync();
}
}
}
Donor Repository
// Repositories/DonorRepository.cs
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Threading.Tasks;
public class DonorRepository : IDonorRepository
{
private readonly string _connectionString;
public DonorRepository(string connectionString)
{
_connectionString = connectionString;
}
public async Task<Donor> GetDonorByIdAsync(int donorId)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Donors WHERE DonorId = @DonorId", connection);
command.Parameters.AddWithValue("@DonorId", donorId);
await connection.OpenAsync();
using (var reader = await command.ExecuteReaderAsync())
{
if (await reader.ReadAsync())
{
return new Donor
{
DonorId = (int)reader["DonorId"],
UserId = (int)reader["User Id"],
BloodType = reader["BloodType"].ToString(),
LastDonationDate = reader["LastDonationDate"] as DateTime?,
CreatedAt = (DateTime)reader["CreatedAt"],
UpdatedAt = (DateTime)reader["UpdatedAt"]
};
}
}
}
return null;
}
public async Task<IEnumerable<Donor>> GetAllDonorsAsync()
{
var donors = new List<Donor>();
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Donors", connection);
await connection.OpenAsync();
using (var reader = await command.ExecuteReaderAsync())
{
while (await reader.ReadAsync())
{
donors.Add(new Donor
{
DonorId = (int)reader["DonorId"],
UserId = (int)reader["User Id"],
BloodType = reader["BloodType"].ToString(),
LastDonationDate = reader["LastDonationDate"] as DateTime?,
CreatedAt = (DateTime)reader["CreatedAt"],
UpdatedAt = (DateTime)reader["UpdatedAt"]
});
}
}
}
return donors;
}
public async Task AddDonorAsync(Donor donor)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("INSERT INTO Donors (User Id, BloodType, LastDonationDate) VALUES (@User Id, @BloodType, @LastDonationDate)", connection);
command.Parameters.AddWithValue("@User Id", donor.UserId);
command.Parameters.AddWithValue("@BloodType", donor.BloodType);
command.Parameters.AddWithValue("@LastDonationDate", (object)donor.LastDonationDate ?? DBNull.Value);
await connection.OpenAsync();
await command.ExecuteNonQueryAsync();
}
}
public async Task UpdateDonorAsync(Donor donor)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("UPDATE Donors SET UserId = @User Id, BloodType = @BloodType, LastDonationDate = @LastDonationDate, UpdatedAt = GETDATE() WHERE DonorId = @DonorId", connection);
command.Parameters.AddWithValue("@DonorId", donor.DonorId);
command.Parameters.AddWithValue("@User Id", donor.UserId);
command.Parameters.AddWithValue("@BloodType", donor.BloodType);
command.Parameters.AddWithValue("@LastDonationDate", (object)donor.LastDonationDate ?? DBNull.Value);
await connection.OpenAsync();
await command.ExecuteNonQueryAsync();
}
}
public async Task DeleteDonorAsync(int donorId)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("DELETE FROM Donors WHERE DonorId = @DonorId", connection);
command.Parameters.AddWithValue("@DonorId", donorId);
await connection.OpenAsync();
await command.ExecuteNonQueryAsync();
}
}
}
Appointment Repository
// Repositories/AppointmentRepository.cs
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Threading.Tasks;
public class AppointmentRepository : IAppointmentRepository
{
private readonly string _connectionString;
public AppointmentRepository(string connectionString)
{
_connectionString = connectionString;
}
public async Task<Appointment> GetAppointmentByIdAsync(int appointmentId)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Appointments WHERE AppointmentId = @AppointmentId", connection);
command.Parameters.AddWithValue("@AppointmentId", appointmentId);
await connection.OpenAsync();
using (var reader = await command.ExecuteReaderAsync())
{
if (await reader.ReadAsync())
{
return new Appointment
{
AppointmentId = (int)reader["AppointmentId"],
DonorId = (int)reader["DonorId"],
AppointmentDate = (DateTime)reader["AppointmentDate"],
Status = reader["Status"].ToString(),
CreatedAt = (DateTime)reader["CreatedAt"],
UpdatedAt = (DateTime)reader["UpdatedAt"]
};
}
}
}
return null;
}
public async Task<IEnumerable<Appointment>> GetAllAppointmentsAsync()
{
var appointments = new List<Appointment>();
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Appointments", connection);
await connection.OpenAsync();
using (var reader = await command.ExecuteReaderAsync())
{
while (await reader.ReadAsync())
{
appointments.Add(new Appointment
{
AppointmentId = (int)reader["AppointmentId"],
DonorId = (int)reader["DonorId"],
AppointmentDate = (DateTime)reader["AppointmentDate"],
Status = reader["Status"].ToString(),
CreatedAt = (DateTime)reader["CreatedAt"],
UpdatedAt = (DateTime)reader["UpdatedAt"]
});
}
}
}
return appointments;
}
public async Task AddAppointmentAsync(Appointment appointment)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("INSERT INTO Appointments (DonorId, AppointmentDate, Status) VALUES (@DonorId, @AppointmentDate, @Status)", connection);
command.Parameters.AddWithValue("@DonorId", appointment.DonorId);
command.Parameters.AddWithValue("@AppointmentDate", appointment.AppointmentDate);
command.Parameters.AddWithValue("@Status", appointment.Status);
await connection.OpenAsync();
await command.ExecuteNonQueryAsync();
}
}
public async Task UpdateAppointmentAsync(Appointment appointment)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("UPDATE Appointments SET DonorId = @DonorId, AppointmentDate = @AppointmentDate, Status = @Status, UpdatedAt = GETDATE() WHERE AppointmentId = @AppointmentId", connection);
command.Parameters.AddWithValue("@AppointmentId ", appointment.AppointmentId);
command.Parameters.AddWithValue("@DonorId", appointment.DonorId);
command.Parameters.AddWithValue("@AppointmentDate", appointment.AppointmentDate);
command.Parameters.AddWithValue("@Status", appointment.Status);
await connection.OpenAsync();
await command.ExecuteNonQueryAsync();
}
}
public async Task DeleteAppointmentAsync(int appointmentId)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("DELETE FROM Appointments WHERE AppointmentId = @AppointmentId", connection);
command.Parameters.AddWithValue("@AppointmentId", appointmentId);
await connection.OpenAsync();
await command.ExecuteNonQueryAsync();
}
}
}
BloodProduct Repository
// Repositories/BloodProductRepository.cs
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Threading.Tasks;
public class BloodProductRepository : IBloodProductRepository
{
private readonly string _connectionString;
public BloodProductRepository(string connectionString)
{
_connectionString = connectionString;
}
public async Task<BloodProduct> GetBloodProductByIdAsync(int bloodProductId)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM BloodProducts WHERE BloodProductId = @BloodProductId", connection);
command.Parameters.AddWithValue("@BloodProductId", bloodProductId);
await connection.OpenAsync();
using (var reader = await command.ExecuteReaderAsync())
{
if (await reader.ReadAsync())
{
return new BloodProduct
{
BloodProductId = (int)reader["BloodProductId"],
BloodType = reader["BloodType"].ToString(),
Quantity = (int)reader["Quantity"],
ExpiryDate = (DateTime)reader["ExpiryDate"],
CollectedAt = (DateTime)reader["CollectedAt"],
CreatedAt = (DateTime)reader["CreatedAt"],
UpdatedAt = (DateTime)reader["UpdatedAt"]
};
}
}
}
return null;
}
public async Task<IEnumerable<BloodProduct>> GetAllBloodProductsAsync()
{
var bloodProducts = new List<BloodProduct>();
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM BloodProducts", connection);
await connection.OpenAsync();
using (var reader = await command.ExecuteReaderAsync())
{
while (await reader.ReadAsync())
{
bloodProducts.Add(new BloodProduct
{
BloodProductId = (int)reader["BloodProductId"],
BloodType = reader["BloodType"].ToString(),
Quantity = (int)reader["Quantity"],
ExpiryDate = (DateTime)reader["ExpiryDate"],
CollectedAt = (DateTime)reader["CollectedAt"],
CreatedAt = (DateTime)reader["CreatedAt"],
UpdatedAt = (DateTime)reader["UpdatedAt"]
});
}
}
}
return bloodProducts;
}
public async Task AddBloodProductAsync(BloodProduct bloodProduct)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("INSERT INTO BloodProducts (BloodType, Quantity, ExpiryDate) VALUES (@BloodType, @Quantity, @ExpiryDate)", connection);
command.Parameters.AddWithValue("@BloodType", bloodProduct.BloodType);
command.Parameters.AddWithValue("@Quantity", bloodProduct.Quantity);
command.Parameters.AddWithValue("@ExpiryDate", bloodProduct.ExpiryDate);
await connection.OpenAsync();
await command.ExecuteNonQueryAsync();
}
}
public async Task UpdateBloodProductAsync(BloodProduct bloodProduct)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("UPDATE BloodProducts SET BloodType = @BloodType, Quantity = @Quantity, ExpiryDate = @ExpiryDate, UpdatedAt = GETDATE() WHERE BloodProductId = @BloodProductId", connection);
command.Parameters.AddWithValue("@BloodProductId", bloodProduct.BloodProductId);
command.Parameters.AddWithValue("@BloodType", bloodProduct.BloodType);
command.Parameters.AddWithValue("@Quantity", bloodProduct.Quantity);
command.Parameters.AddWithValue("@ExpiryDate", bloodProduct.ExpiryDate);
await connection.OpenAsync();
await command.ExecuteNonQueryAsync();
}
}
public async Task DeleteBloodProductAsync(int bloodProductId)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("DELETE FROM BloodProducts WHERE BloodProductId = @BloodProductId", connection);
command.Parameters.AddWithValue("@BloodProductId", bloodProductId);
await connection.OpenAsync();
await command.ExecuteNonQueryAsync();
}
}
Inventory Repository
// Repositories/InventoryRepository.cs
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Threading.Tasks;
public class InventoryRepository : IInventoryRepository
{
private readonly string _connectionString;
public InventoryRepository(string connectionString)
{
_connectionString = connectionString;
}
public async Task<Inventory> GetInventoryByIdAsync(int inventoryId)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Inventory WHERE InventoryId = @InventoryId", connection);
command.Parameters.AddWithValue("@InventoryId", inventoryId);
await connection.OpenAsync();
using (var reader = await command.ExecuteReaderAsync())
{
if (await reader.ReadAsync())
{
return new Inventory
{
InventoryId = (int)reader["InventoryId"],
BloodProductId = (int)reader["BloodProductId"],
Quantity = (int)reader["Quantity"],
CreatedAt = (DateTime)reader["CreatedAt"],
UpdatedAt = (DateTime)reader["UpdatedAt"]
};
}
}
}
return null;
}
public async Task<IEnumerable<Inventory>> GetAllInventoriesAsync()
{
var inventories = new List<Inventory>();
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Inventory", connection);
await connection.OpenAsync();
using (var reader = await command.ExecuteReaderAsync())
{
while (await reader.ReadAsync())
{
inventories.Add(new Inventory
{
InventoryId = (int)reader["InventoryId"],
BloodProductId = (int)reader["BloodProductId"],
Quantity = (int)reader["Quantity"],
CreatedAt = (DateTime)reader["CreatedAt"],
UpdatedAt = (DateTime)reader["UpdatedAt"]
});
}
}
}
return inventories;
}
public async Task AddInventoryAsync(Inventory inventory)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("INSERT INTO Inventory (BloodProductId, Quantity) VALUES (@BloodProductId, @Quantity)", connection);
command.Parameters.AddWithValue("@BloodProductId", inventory.BloodProductId);
command.Parameters.AddWithValue("@Quantity", inventory.Quantity);
await connection.OpenAsync();
await command.ExecuteNonQueryAsync();
}
}
public async Task UpdateInventoryAsync(Inventory inventory)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("UPDATE Inventory SET BloodProductId = @BloodProductId, Quantity = @Quantity, UpdatedAt = GETDATE() WHERE InventoryId = @InventoryId", connection);
command.Parameters.AddWithValue("@InventoryId", inventory.InventoryId);
command.Parameters.AddWithValue("@BloodProductId", inventory.BloodProductId);
command.Parameters.AddWithValue("@Quantity", inventory.Quantity);
await connection.OpenAsync();
await command.ExecuteNonQueryAsync();
}
}
public async Task DeleteInventoryAsync(int inventoryId)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("DELETE FROM Inventory WHERE InventoryId = @InventoryId", connection);
command.Parameters.AddWithValue("@InventoryId", inventoryId);
await connection.OpenAsync();
await command.ExecuteNonQueryAsync();
}
}
}
Order Repository
// Repositories/OrderRepository.cs
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Threading.Tasks;
public class OrderRepository : IOrderRepository
{
private readonly string _connectionString;
public OrderRepository(string connectionString)
{
_connectionString = connectionString;
}
public async Task<Order> GetOrderByIdAsync(int orderId)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Orders WHERE OrderId = @OrderId", connection);
command.Parameters.AddWithValue("@OrderId", orderId);
await connection.OpenAsync();
using (var reader = await command.ExecuteReaderAsync())
{
if (await reader.ReadAsync())
{
return new Order
{
OrderId = (int)reader["OrderId"],
BloodProductId = (int)reader["BloodProductId"],
Quantity = (int)reader["Quantity"],
OrderDate = (DateTime)reader["OrderDate"],
Status = reader["Status"].ToString(),
CreatedAt = (DateTime)reader["CreatedAt"],
UpdatedAt = (DateTime)reader["UpdatedAt"]
};
}
}
}
return null;
}
public async Task<IEnumerable <Order>> GetAllOrdersAsync()
{
var orders = new List<Order>();
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Orders", connection);
await connection.OpenAsync();
using (var reader = await command.ExecuteReaderAsync())
{
while (await reader.ReadAsync())
{
orders.Add(new Order
{
OrderId = (int)reader["OrderId"],
BloodProductId = (int)reader["BloodProductId"],
Quantity = (int)reader["Quantity"],
OrderDate = (DateTime)reader["OrderDate"],
Status = reader["Status"].ToString(),
CreatedAt = (DateTime)reader["CreatedAt"],
UpdatedAt = (DateTime)reader["UpdatedAt"]
});
}
}
}
return orders;
}
public async Task AddOrderAsync(Order order)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("INSERT INTO Orders (BloodProductId, Quantity, OrderDate, Status) VALUES (@BloodProductId, @Quantity, @OrderDate, @Status)", connection);
command.Parameters.AddWithValue("@BloodProductId", order.BloodProductId);
command.Parameters.AddWithValue("@Quantity", order.Quantity);
command.Parameters.AddWithValue("@OrderDate", order.OrderDate);
command.Parameters.AddWithValue("@Status", order.Status);
await connection.OpenAsync();
await command.ExecuteNonQueryAsync();
}
}
public async Task UpdateOrderAsync(Order order)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("UPDATE Orders SET BloodProductId = @BloodProductId, Quantity = @Quantity, OrderDate = @OrderDate, Status = @Status, UpdatedAt = GETDATE() WHERE OrderId = @OrderId", connection);
command.Parameters.AddWithValue("@OrderId", order.OrderId);
command.Parameters.AddWithValue("@BloodProductId", order.BloodProductId);
command.Parameters.AddWithValue("@Quantity", order.Quantity);
command.Parameters.AddWithValue("@OrderDate", order.OrderDate);
command.Parameters.AddWithValue("@Status", order.Status);
await connection.OpenAsync();
await command.ExecuteNonQueryAsync();
}
}
public async Task DeleteOrderAsync(int orderId)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("DELETE FROM Orders WHERE OrderId = @OrderId", connection);
command.Parameters.AddWithValue("@OrderId", orderId);
await connection.OpenAsync();
await command.ExecuteNonQueryAsync();
}
}
}
Report Repository
// Repositories/ReportRepository.cs
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Threading.Tasks;
public class ReportRepository : IReportRepository
{
private readonly string _connectionString;
public ReportRepository(string connectionString)
{
_connectionString = connectionString;
}
public async Task<Report> GetReportByIdAsync(int reportId)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Reports WHERE ReportId = @ReportId", connection);
command.Parameters.AddWithValue("@ReportId", reportId);
await connection.OpenAsync();
using (var reader = await command.ExecuteReaderAsync())
{
if (await reader.ReadAsync())
{
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 async Task<IEnumerable<Report>> GetAllReportsAsync()
{
var reports = new List<Report>();
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Reports", connection);
await connection.OpenAsync();
using (var reader = await command.ExecuteReaderAsync())
{
while (await reader.ReadAsync())
{
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 async Task AddReportAsync(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);
await connection.OpenAsync();
await command.ExecuteNonQueryAsync();
}
}
public async Task UpdateReportAsync(Report report)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("UPDATE Reports SET UserId = @User Id, ReportDate = @ReportDate, ReportContent = @ReportContent, CreatedAt = GETDATE() 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);
await connection.OpenAsync();
await command.ExecuteNonQueryAsync();
}
}
public async Task DeleteReportAsync(int reportId)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("DELETE FROM Reports WHERE ReportId = @ReportId", connection);
command.Parameters.AddWithValue("@ReportId", reportId);
await connection.OpenAsync();
await command.ExecuteNonQueryAsync();
}
}
}
QualityControl Repository
// Repositories/QualityControlRepository.cs
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Threading.Tasks;
public class QualityControlRepository : IQualityControlRepository
{
private readonly string _connectionString;
public QualityControlRepository(string connectionString)
{
_connectionString = connectionString;
}
public async Task<QualityControl> GetQualityControlByIdAsync(int qualityControlId)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM QualityControl WHERE QualityControlId = @QualityControlId", connection);
command.Parameters.AddWithValue("@QualityControlId", qualityControlId);
await connection.OpenAsync();
using (var reader = await command.ExecuteReaderAsync())
{
if (await reader.ReadAsync())
{
return new QualityControl
{
QualityControlId = (int)reader["QualityControlId"],
BloodProductId = (int)reader["BloodProductId"],
InspectionDate = (DateTime)reader["InspectionDate"],
Status = reader["Status"].ToString(),
Comments = reader["Comments"].ToString(),
CreatedAt = (DateTime)reader["CreatedAt"],
UpdatedAt = (DateTime)reader["UpdatedAt"]
};
}
}
}
return null;
}
public async Task<IEnumerable<QualityControl>> GetAllQualityControlsAsync()
{
var qualityControls = new List<QualityControl>();
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM QualityControl", connection);
await connection.OpenAsync();
using (var reader = await command.ExecuteReaderAsync())
{
while (await reader.ReadAsync())
{
qualityControls.Add(new QualityControl
{
QualityControlId = (int)reader["QualityControlId"],
BloodProductId = (int)reader["BloodProductId"],
InspectionDate = (DateTime)reader["InspectionDate"],
Status = reader["Status"].ToString(),
Comments = reader["Comments"].ToString(),
CreatedAt = (DateTime)reader["CreatedAt"],
UpdatedAt = (DateTime)reader["UpdatedAt"]
});
}
}
}
return qualityControls;
}
public async Task AddQualityControlAsync(QualityControl qualityControl)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("INSERT INTO QualityControl (BloodProductId, InspectionDate, Status, Comments) VALUES (@BloodProductId, @InspectionDate, @Status, @Comments)", connection);
command.Parameters.AddWithValue("@BloodProductId", qualityControl.BloodProductId);
command.Parameters.AddWithValue("@InspectionDate", qualityControl.InspectionDate);
command.Parameters.AddWithValue("@Status", qualityControl.Status);
command.Parameters.AddWithValue("@Comments", qualityControl.Comments);
await connection.OpenAsync();
await command.ExecuteNonQueryAsync();
}
}
public async Task UpdateQualityControlAsync(QualityControl qualityControl)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("UPDATE QualityControl SET BloodProductId = @BloodProductId , InspectionDate = @InspectionDate, Status = @Status, Comments = @Comments, UpdatedAt = GETDATE() WHERE QualityControlId = @QualityControlId", connection);
command.Parameters.AddWithValue("@QualityControlId", qualityControl.QualityControlId);
command.Parameters.AddWithValue("@BloodProductId", qualityControl.BloodProductId);
command.Parameters.AddWithValue("@InspectionDate", qualityControl.InspectionDate);
command.Parameters.AddWithValue("@Status", qualityControl.Status);
command.Parameters.AddWithValue("@Comments", qualityControl.Comments);
await connection.OpenAsync();
await command.ExecuteNonQueryAsync();
}
}
public async Task DeleteQualityControlAsync(int qualityControlId)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("DELETE FROM QualityControl WHERE QualityControlId = @QualityControlId", connection);
command.Parameters.AddWithValue("@QualityControlId", qualityControlId);
await connection.OpenAsync();
await command.ExecuteNonQueryAsync();
}
}
}
Campaign Repository
// Repositories/CampaignRepository.cs
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Threading.Tasks;
public class CampaignRepository : ICampaignRepository
{
private readonly string _connectionString;
public CampaignRepository(string connectionString)
{
_connectionString = connectionString;
}
public async Task<Campaign> GetCampaignByIdAsync(int campaignId)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Campaigns WHERE CampaignId = @CampaignId", connection);
command.Parameters.AddWithValue("@CampaignId", campaignId);
await connection.OpenAsync();
using (var reader = await command.ExecuteReaderAsync())
{
if (await reader.ReadAsync())
{
return new Campaign
{
CampaignId = (int)reader["CampaignId"],
CampaignName = reader["CampaignName"].ToString(),
StartDate = (DateTime)reader["StartDate"],
EndDate = (DateTime)reader["EndDate"],
CreatedAt = (DateTime)reader["CreatedAt"],
UpdatedAt = (DateTime)reader["UpdatedAt"]
};
}
}
}
return null;
}
public async Task<IEnumerable<Campaign>> GetAllCampaignsAsync()
{
var campaigns = new List<Campaign>();
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Campaigns", connection);
await connection.OpenAsync();
using (var reader = await command.ExecuteReaderAsync())
{
while (await reader.ReadAsync())
{
campaigns.Add(new Campaign
{
CampaignId = (int)reader["CampaignId"],
CampaignName = reader["CampaignName"].ToString(),
StartDate = (DateTime)reader["StartDate"],
EndDate = (DateTime)reader["EndDate"],
CreatedAt = (DateTime)reader["CreatedAt"],
UpdatedAt = (DateTime)reader["UpdatedAt"]
});
}
}
}
return campaigns;
}
public async Task AddCampaignAsync(Campaign campaign)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("INSERT INTO Campaigns (CampaignName, StartDate, EndDate) VALUES (@CampaignName, @StartDate, @EndDate)", connection);
command.Parameters.AddWithValue("@CampaignName", campaign.CampaignName);
command.Parameters.AddWithValue("@StartDate", campaign.StartDate);
command.Parameters.AddWithValue("@EndDate", campaign.EndDate);
await connection.OpenAsync();
await command.ExecuteNonQueryAsync();
}
}
public async Task UpdateCampaignAsync(Campaign campaign)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("UPDATE Campaigns SET CampaignName = @CampaignName, StartDate = @StartDate, EndDate = @EndDate, 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);
await connection.OpenAsync();
await command.ExecuteNonQueryAsync();
}
}
public async Task DeleteCampaignAsync(int campaignId)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("DELETE FROM Campaigns WHERE CampaignId = @CampaignId", connection);
command.Parameters.AddWithValue("@CampaignId", campaignId);
await connection.OpenAsync();
await command.ExecuteNonQueryAsync();
}
}
}
This completes the repository implementations for all the models defined earlier. Each repository follows the same pattern, ensuring that data access logic is encapsulated and adheres to the repository interface.
Creating Controllers
To create controllers for each repository in an ASP.NET MVC application, we will follow the standard MVC pattern. Each controller will handle HTTP requests, interact with the corresponding repository, and return views or data as needed.
Step 1: Create Controllers
Create a folder named Controllers in your ASP.NET project and add the following controllers:
UserController
using Microsoft.AspNetCore.Mvc;
using System.Threading.Tasks;
public class UserController : Controller
{
private readonly IUserRepository _userRepository;
public UserController(IUser Repository userRepository)
{
_userRepository = userRepository;
}
public async Task<IActionResult> Index()
{
var users = await _userRepository.GetAllUsersAsync();
return View(users);
}
public IActionResult Create()
{
return View();
}
[HttpPost]
public async Task<IActionResult> Create(User user)
{
if (ModelState.IsValid)
{
await _userRepository.AddUser Async(user);
return RedirectToAction(nameof(Index));
}
return View(user);
}
public async Task<IActionResult> Edit(int id)
{
var user = await _userRepository.GetUser ByIdAsync(id);
if (user == null)
{
return NotFound();
}
return View(user);
}
[HttpPost]
public async Task<IActionResult> Edit(User user)
{
if (ModelState.IsValid)
{
await _userRepository.UpdateUser Async(user);
return RedirectToAction(nameof(Index));
}
return View(user);
}
public async Task<IActionResult> Delete(int id)
{
var user = await _userRepository.GetUser ByIdAsync(id);
if (user == null)
{
return NotFound();
}
return View(user);
}
[HttpPost, ActionName("Delete")]
public async Task<IActionResult> DeleteConfirmed(int id)
{
await _userRepository.DeleteUser Async(id);
return RedirectToAction(nameof(Index));
}
}
RoleController
using Microsoft.AspNetCore.Mvc;
using System.Threading.Tasks;
public class RoleController : Controller
{
private readonly IRoleRepository _roleRepository;
public RoleController(IRoleRepository roleRepository)
{
_roleRepository = roleRepository;
}
public async Task<IActionResult> Index()
{
var roles = await _roleRepository.GetAllRolesAsync();
return View(roles);
}
public IActionResult Create()
{
return View();
}
[HttpPost]
public async Task<IActionResult> Create(Role role)
{
if (ModelState.IsValid)
{
await _roleRepository.AddRoleAsync(role);
return RedirectToAction(nameof(Index));
}
return View(role);
}
public async Task<IActionResult> Edit(int id)
{
var role = await _roleRepository.GetRoleByIdAsync(id);
if (role == null)
{
return NotFound();
}
return View(role);
}
[HttpPost]
public async Task<IActionResult> Edit(Role role)
{
if (ModelState.IsValid)
{
await _roleRepository.UpdateRoleAsync(role);
return RedirectToAction(nameof(Index));
}
return View(role);
}
public async Task<IActionResult> Delete(int id)
{
var role = await _roleRepository.GetRoleByIdAsync(id);
if (role == null)
{
return NotFound();
}
return View(role);
}
[HttpPost, ActionName("Delete")]
public async Task<IActionResult> DeleteConfirmed(int id)
{
await _roleRepository.DeleteRoleAsync(id);
return RedirectToAction(nameof(Index));
}
}
DonorController
using Microsoft.AspNetCore.Mvc;
using System.Threading.Tasks;
public class DonorController : Controller
{
private readonly IDonorRepository _donorRepository;
public DonorController(IDonorRepository donorRepository)
{
_donorRepository = donorRepository;
}
public async Task<IActionResult> Index()
{
var donors = await _donorRepository.GetAllDonorsAsync();
return View(donors);
}
public IActionResult Create()
{
return View();
}
[HttpPost]
public async Task<IActionResult> Create(Donor donor)
{
if (ModelState.IsValid)
{
await _donorRepository.AddDonorAsync(donor);
return RedirectToAction(nameof(Index));
}
return View(donor);
}
public async Task<IActionResult> Edit(int id)
{
var donor = await _donorRepository.GetDonorByIdAsync(id);
if (donor == null)
{
return NotFound();
}
return View(donor);
}
[HttpPost]
public async Task<IActionResult> Edit(Donor donor)
{
if (ModelState.IsValid)
{
await _donorRepository.UpdateDonorAsync(donor);
return RedirectToAction(nameof(Index));
}
return View(donor);
}
public async Task<IActionResult> Delete(int id)
{
var donor = await _donorRepository.GetDonorByIdAsync(id);
if (donor == null)
{
return NotFound();
}
return View(donor);
}
[HttpPost, ActionName("Delete")]
public async Task<IActionResult> DeleteConfirmed(int id)
{
await _donorRepository.DeleteDonorAsync(id);
return RedirectToAction(nameof(Index));
}
}
AppointmentController
using Microsoft.AspNetCore.Mvc;
using System.Threading.Tasks;
public class AppointmentController : Controller { private readonly IAppointmentRepository _appointmentRepository;
public AppointmentController(IAppointmentRepository appointmentRepository)
{
_appointmentRepository = appointmentRepository;
}
public async Task<IActionResult> Index()
{
var appointments = await _appointmentRepository.GetAllAppointmentsAsync();
return View(appointments);
}
public IActionResult Create()
{
return View();
}
[HttpPost]
public async Task<IActionResult> Create(Appointment appointment)
{
if (ModelState.IsValid)
{
await _appointmentRepository.AddAppointmentAsync(appointment);
return RedirectToAction(nameof(Index));
}
return View(appointment);
}
public async Task<IActionResult> Edit(int id)
{
var appointment = await _appointmentRepository.GetAppointmentByIdAsync(id);
if (appointment == null)
{
return NotFound();
}
return View(appointment);
}
[HttpPost]
public async Task<IActionResult> Edit(Appointment appointment)
{
if (ModelState.IsValid)
{
await _appointmentRepository.UpdateAppointmentAsync(appointment);
return RedirectToAction(nameof(Index));
}
return View(appointment);
}
public async Task<IActionResult> Delete(int id)
{
var appointment = await _appointmentRepository.GetAppointmentByIdAsync(id);
if (appointment == null)
{
return NotFound();
}
return View(appointment);
}
[HttpPost, ActionName("Delete")]
public async Task<IActionResult> DeleteConfirmed(int id)
{
await _appointmentRepository.DeleteAppointmentAsync(id);
return RedirectToAction(nameof(Index));
}
}
BloodProductController
using Microsoft.AspNetCore.Mvc;
using System.Threading.Tasks;
public class BloodProductController : Controller
{
private readonly IBloodProductRepository _bloodProductRepository;
public BloodProductController(IBloodProductRepository bloodProductRepository)
{
_bloodProductRepository = bloodProductRepository;
}
public async Task<IActionResult> Index()
{
var bloodProducts = await _bloodProductRepository.GetAllBloodProductsAsync();
return View(bloodProducts);
}
public IActionResult Create()
{
return View();
}
[HttpPost]
public async Task<IActionResult> Create(BloodProduct bloodProduct)
{
if (ModelState.IsValid)
{
await _bloodProductRepository.AddBloodProductAsync(bloodProduct);
return RedirectToAction(nameof(Index));
}
return View(bloodProduct);
}
public async Task<IActionResult> Edit(int id)
{
var bloodProduct = await _bloodProductRepository.GetBloodProductByIdAsync(id);
if (bloodProduct == null)
{
return NotFound();
}
return View(bloodProduct);
}
[HttpPost]
public async Task<IActionResult> Edit(BloodProduct bloodProduct)
{
if (ModelState.IsValid)
{
await _bloodProductRepository.UpdateBloodProductAsync(bloodProduct);
return RedirectToAction(nameof(Index));
}
return View(bloodProduct);
}
public async Task<IActionResult> Delete(int id)
{
var bloodProduct = await _bloodProductRepository.GetBloodProductByIdAsync(id);
if (bloodProduct == null)
{
return NotFound();
}
return View(bloodProduct);
}
[HttpPost, ActionName("Delete")]
public async Task<IActionResult> DeleteConfirmed(int id)
{
await _bloodProductRepository.DeleteBloodProductAsync(id);
return RedirectToAction(nameof(Index));
}
}
InventoryController
using Microsoft.AspNetCore.Mvc;
using System.Threading.Tasks;
public class InventoryController : Controller
{
private readonly IInventoryRepository _inventoryRepository;
public InventoryController(IInventoryRepository inventoryRepository)
{
_inventoryRepository = inventoryRepository;
}
public async Task<IActionResult> Index()
{
var inventories = await _inventoryRepository.GetAllInventoriesAsync();
return View(inventories);
}
public IActionResult Create()
{
return View();
}
[HttpPost]
public async Task<IActionResult> Create(Inventory inventory)
{
if (ModelState.IsValid)
{
await _inventoryRepository.AddInventoryAsync(inventory);
return RedirectToAction(nameof(Index));
}
return View(inventory);
}
public async Task<IActionResult> Edit(int id)
{
var inventory = await _inventoryRepository.GetInventoryByIdAsync(id);
if (inventory == null)
{
return NotFound();
}
return View(inventory);
}
[HttpPost]
public async Task<IActionResult> Edit(Inventory inventory)
{
if (ModelState.IsValid {
await _inventoryRepository.UpdateInventoryAsync(inventory);
return RedirectToAction(nameof(Index));
}
return View(inventory);
}
public async Task<IActionResult> Delete(int id)
{
var inventory = await _inventoryRepository.GetInventoryByIdAsync(id);
if (inventory == null)
{
return NotFound();
}
return View(inventory);
}
[HttpPost, ActionName("Delete")]
public async Task<IActionResult> DeleteConfirmed(int id)
{
await _inventoryRepository.DeleteInventoryAsync(id);
return RedirectToAction(nameof(Index));
}
}
OrderController
using Microsoft.AspNetCore.Mvc;
using System.Threading.Tasks;
public class OrderController : Controller
{
private readonly IOrderRepository _orderRepository;
public OrderController(IOrderRepository orderRepository)
{
_orderRepository = orderRepository;
}
public async Task<IActionResult> Index()
{
var orders = await _orderRepository.GetAllOrdersAsync();
return View(orders);
}
public IActionResult Create()
{
return View();
}
[HttpPost]
public async Task<IActionResult> Create(Order order)
{
if (ModelState.IsValid)
{
await _orderRepository.AddOrderAsync(order);
return RedirectToAction(nameof(Index));
}
return View(order);
}
public async Task<IActionResult> Edit(int id)
{
var order = await _orderRepository.GetOrderByIdAsync(id);
if (order == null)
{
return NotFound();
}
return View(order);
}
[HttpPost]
public async Task<IActionResult> Edit(Order order)
{
if (ModelState.IsValid)
{
await _orderRepository.UpdateOrderAsync(order);
return RedirectToAction(nameof(Index));
}
return View(order);
}
public async Task<IActionResult> Delete(int id)
{
var order = await _orderRepository.GetOrderByIdAsync(id);
if (order == null)
{
return NotFound();
}
return View(order);
}
[HttpPost, ActionName("Delete")]
public async Task<IActionResult> DeleteConfirmed(int id)
{
await _orderRepository.DeleteOrderAsync(id);
return RedirectToAction(nameof(Index));
}
}
ReportController
using Microsoft.AspNetCore.Mvc;
using System.Threading.Tasks;
public class ReportController : Controller
{
private readonly IReportRepository _reportRepository;
public ReportController(IReportRepository reportRepository)
{
_reportRepository = reportRepository;
}
public async Task<IActionResult> Index()
{
var reports = await _reportRepository.GetAllReportsAsync();
return View(reports);
}
public IActionResult Create()
{
return View();
}
[HttpPost]
public async Task<IActionResult> Create(Report report)
{
if (ModelState.IsValid)
{
await _reportRepository.AddReportAsync(report);
return RedirectToAction(nameof(Index));
}
return View(report);
}
public async Task<IActionResult> Edit(int id)
{
var report = await _reportRepository.GetReportByIdAsync(id);
if (report == null)
{
return NotFound();
}
return View(report);
}
[HttpPost]
public async Task<IActionResult> Edit(Report report)
{
if (ModelState.IsValid)
{
await _reportRepository.UpdateReportAsync(report);
return RedirectToAction(nameof(Index));
}
return View(report);
}
public async Task<IActionResult> Delete(int id)
{
var report = await _reportRepository.GetReportByIdAsync(id);
if (report == null)
{
return NotFound();
}
return View(report);
}
[HttpPost, ActionName("Delete")]
public async Task<IActionResult> DeleteConfirmed(int id)
{
await _reportRepository.DeleteReportAsync(id);
return RedirectToAction(nameof(Index));
}
}
QualityControlController
using Microsoft.AspNetCore.Mvc;
using System.Threading.Tasks;
public class QualityControlController : Controller
{
private readonly IQualityControlRepository _qualityControlRepository;
public QualityControlController(IQualityControlRepository qualityControlRepository)
{
_qualityControlRepository = qualityControlRepository;
}
public async Task<IActionResult> Index()
{
var qualityControls = await _qualityControlRepository.GetAllQualityControlsAsync();
return View(qualityControls);
}
public IActionResult Create()
{
return View();
}
[HttpPost]
public async Task<IActionResult> Create(QualityControl qualityControl)
{
if (ModelState.IsValid)
{
await _qualityControlRepository.AddQualityControlAsync( qualityControl);
return RedirectToAction(nameof(Index));
}
return View(qualityControl);
}
public async Task<IActionResult> Edit(int id)
{
var qualityControl = await _qualityControlRepository.GetQualityControlByIdAsync(id);
if (qualityControl == null)
{
return NotFound();
}
return View(qualityControl);
}
[HttpPost]
public async Task<IActionResult> Edit(QualityControl qualityControl)
{
if (ModelState.IsValid)
{
await _qualityControlRepository.UpdateQualityControlAsync(qualityControl);
return RedirectToAction(nameof(Index));
}
return View(qualityControl);
}
public async Task<IActionResult> Delete(int id)
{
var qualityControl = await _qualityControlRepository.GetQualityControlByIdAsync(id);
if (qualityControl == null)
{
return NotFound();
}
return View(qualityControl);
}
[HttpPost, ActionName("Delete")]
public async Task<IActionResult> DeleteConfirmed(int id)
{
await _qualityControlRepository.DeleteQualityControlAsync(id);
return RedirectToAction(nameof(Index));
}
}
CampaignController
using Microsoft.AspNetCore.Mvc;
using System.Threading.Tasks;
public class CampaignController : Controller
{
private readonly ICampaignRepository _campaignRepository;
public CampaignController(ICampaignRepository campaignRepository)
{
_campaignRepository = campaignRepository;
}
public async Task<IActionResult> Index()
{
var campaigns = await _campaignRepository.GetAllCampaignsAsync();
return View(campaigns);
}
public IActionResult Create()
{
return View();
}
[HttpPost]
public async Task<IActionResult> Create(Campaign campaign)
{
if (ModelState.IsValid)
{
await _campaignRepository.AddCampaignAsync(campaign);
return RedirectToAction(nameof(Index));
}
return View(campaign);
}
public async Task<IActionResult> Edit(int id)
{
var campaign = await _campaignRepository.GetCampaignByIdAsync(id);
if (campaign == null)
{
return NotFound();
}
return View(campaign);
}
[HttpPost]
public async Task<IActionResult> Edit(Campaign campaign)
{
if (ModelState.IsValid)
{
await _campaignRepository.UpdateCampaignAsync(campaign);
return RedirectToAction(nameof(Index));
}
return View(campaign);
}
public async Task<IActionResult> Delete(int id)
{
var campaign = await _campaignRepository.GetCampaignByIdAsync(id);
if (campaign == null)
{
return NotFound();
}
return View(campaign);
}
[HttpPost, ActionName("Delete")]
public async Task<IActionResult> DeleteConfirmed(int id)
{
await _campaignRepository.DeleteCampaignAsync(id);
return RedirectToAction(nameof(Index));
}
}
This completes the controller implementations for each repository. Each controller provides actions for listing, creating, editing, and deleting records, following the standard MVC pattern.
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. Each view will typically include a form for creating and editing records, as well as a list view for displaying records.
Folder Structure
First, ensure you have the following folder structure in your Views directory:
Views
│
├── User
│ ├── Create.cshtml
│ ├── Delete.cshtml
│ ├── Edit.cshtml
│ └── Index.cshtml
│
├── Role
│ ├── Create.cshtml
│ ├── Delete.cshtml
│ ├── Edit.cshtml
│ └── Index.cshtml
│
├── Donor
│ ├── Create.cshtml
│ ├── Delete.cshtml
│ ├── Edit.cshtml
│ └── Index.cshtml
│
├── Appointment
│ ├── Create.cshtml
│ ├── Delete.cshtml
│ ├── Edit.cshtml
│ └── Index.cshtml
│
├── BloodProduct
│ ├── Create.cshtml
│ ├── Delete.cshtml
│ ├── Edit.cshtml
│ └── Index.cshtml
│
├── Inventory
│ ├── Create.cshtml
│ ├── Delete.cshtml
│ ├── Edit.cshtml
│ └── Index.cshtml
│
├── Order
│ ├── Create.cshtml
│ ├── Delete.cshtml
│ ├── Edit.cshtml
│ └── Index.cshtml
│
├── Report
│ ├── Create.cshtml
│ ├── Delete.cshtml
│ ├── Edit.cshtml
│ └── Index.cshtml
│
├── QualityControl
│ ├── Create.cshtml
│ ├── Delete.cshtml
│ ├── Edit.cshtml
│ └── Index.cshtml
│
└── Campaign
├── Create.cshtml
├── Delete.cshtml
├── Edit.cshtml
└── Index.cshtml
User Views
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>Actions</th>
</tr>
</thead>
<tbody>
@foreach (var user in Model)
{
<tr>
<td>@user.Username</td>
<td>@user.Email</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>
Create.cshtml
@model User
<h2>Create User</h2>
<form asp-action="Create">
<div>
<label>Username</label>
<input asp-for="Username" />
</div>
<div>
<label>Password</label>
<input asp-for="PasswordHash" type="password" />
</div>
<div>
<label>Email</label>
<input asp-for="Email" />
</div>
<div>
<label>First Name</label>
<input asp-for="FirstName" />
</div>
<div>
<label>Last Name</label>
<input asp-for="LastName" />
</div>
<div>
<label>Role ID</label>
<input asp-for="RoleId" />
</div>
<button type="submit">Create</button>
</form>
Edit.cshtml
@model User
<h2>Edit User</h2>
<form asp-action="Edit">
<input type="hidden" asp-for="User Id" />
<div>
<label>Username</label>
<input asp-for="Username" />
</div>
<div>
<label>Password</label>
<input asp-for="PasswordHash" type="password" />
</div>
<div>
<label>Email</label>
<input asp-for="Email" />
</div>
<div>
<label>First Name</label>
<input asp-for="FirstName" />
</div>
<div>
<label>Last Name</label>
<input asp-for="LastName" />
</div>
<div>
<label>Role ID</label>
<input asp-for="RoleId" />
</div>
<button type="submit">Save</button>
</form>
Delete.cshtml
@model User
<h2>Delete User</h2>
<p>Are you sure you want to delete user @Model.Username?</p>
<form asp-action="Delete">
<input type="hidden" asp-for="User Id" />
<button type="submit">Delete</ button>
<a asp-action="Index">Cancel</a>
</form>
Role Views
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.Name</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>
Create.cshtml
@model Role
<h2>Create Role</h2>
<form asp-action="Create">
<div>
<label>Role Name</label>
<input asp-for="Name" />
</div>
<button type="submit">Create</button>
</form>
Edit.cshtml
@model Role
<h2>Edit Role</h2>
<form asp-action="Edit">
<input type="hidden" asp-for="RoleId" />
<div>
<label>Role Name</label>
<input asp-for="Name" />
</div>
<button type="submit">Save</button>
</form>
Delete.cshtml
@model Role
<h2>Delete Role</h2>
<p>Are you sure you want to delete role @Model.Name?</p>
<form asp-action="Delete">
<input type="hidden" asp-for="RoleId" />
<button type="submit">Delete</button>
<a asp-action="Index">Cancel</a>
</form>
Donor Views
Index.cshtml
@model IEnumerable<Donor>
<h2>Donors</h2>
<a asp-action="Create">Create New Donor</a>
<table>
<thead>
<tr>
<th>Name</th>
<th>Email</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
@foreach (var donor in Model)
{
<tr>
<td>@donor.Name</td>
<td>@donor.Email</td>
<td>
<a asp-action="Edit" asp-route-id="@donor.DonorId">Edit</a> |
<a asp-action="Delete" asp-route-id="@donor.DonorId">Delete</a>
</td>
</tr>
}
</tbody>
</table>
Create.cshtml
@model Donor
<h2>Create Donor</h2>
<form asp-action="Create">
<div>
<label>Name</label>
<input asp-for="Name" />
</div>
<div>
<label>Email</label>
<input asp-for="Email" />
</div>
<button type="submit">Create</button>
</form>
Edit.cshtml
@model Donor
<h2>Edit Donor</h2>
<form asp-action="Edit">
<input type="hidden" asp-for="DonorId" />
<div>
<label>Name</label>
<input asp-for="Name" />
</div>
<div>
<label>Email</label>
<input asp-for="Email" />
</div>
<button type="submit">Save</button>
</form>
Delete.cshtml
@model Donor
<h2>Delete Donor</h2>
<p>Are you sure you want to delete donor @Model.Name?</p>
<form asp-action="Delete">
<input type="hidden" asp-for="DonorId" />
<button type="submit">Delete</button>
<a asp-action="Index">Cancel</a>
</form>
Appointment Views
Index.cshtml
@model IEnumerable<Appointment>
<h2>Appointments</h2>
<a asp-action="Create">Create New Appointment</a>
<table>
<thead>
<tr>
<th>Date</th>
<th>Time</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
@foreach (var appointment in Model)
{
<tr>
<td>@appointment.Date</td>
<td>@appointment.Time</td>
<td>
<a asp-action="Edit" asp-route -id="@appointment.AppointmentId">Edit</a> |
<a asp-action="Delete" asp-route-id="@appointment.AppointmentId">Delete</a>
</td>
</tr>
}
</tbody>
</table>
Create.cshtml
@model Appointment
<h2>Create Appointment</h2>
<form asp-action="Create">
<div>
<label>Date</label>
<input asp-for="Date" type="date" />
</div>
<div>
<label>Time</label>
<input asp-for="Time" type="time" />
</div>
<div>
<label>Donor ID</label>
<input asp-for="DonorId" />
</div>
<button type="submit">Create</button>
</form>
Edit.cshtml
@model Appointment
<h2>Edit Appointment</h2>
<form asp-action="Edit">
<input type="hidden" asp-for="AppointmentId" />
<div>
<label>Date</label>
<input asp-for="Date" type="date" />
</div>
<div>
<label>Time</label>
<input asp-for="Time" type="time" />
</div>
<div>
<label>Donor ID</label>
<input asp-for="DonorId" />
</div>
<button type="submit">Save</button>
</form>
Delete.cshtml
@model Appointment
<h2>Delete Appointment</h2>
<p>Are you sure you want to delete the appointment on @Model.Date at @Model.Time?</p>
<form asp-action="Delete">
<input type="hidden" asp-for="AppointmentId" />
<button type="submit">Delete</button>
<a asp-action="Index">Cancel</a>
</form>
BloodProduct Views
Index.cshtml
@model IEnumerable<BloodProduct>
<h2>Blood Products</h2>
<a asp-action="Create">Create New Blood Product</a>
<table>
<thead>
<tr>
<th>Product Name</th>
<th>Quantity</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
@foreach (var bloodProduct in Model)
{
<tr>
<td>@bloodProduct.Name</td>
<td>@bloodProduct.Quantity</td>
<td>
<a asp-action="Edit" asp-route-id="@bloodProduct.BloodProductId">Edit</a> |
<a asp-action="Delete" asp-route-id="@bloodProduct.BloodProductId">Delete</a>
</td>
</tr>
}
</tbody>
</table>
Create.cshtml
@model BloodProduct
<h2>Create Blood Product</h2>
<form asp-action="Create">
<div>
<label>Product Name</label>
<input asp-for="Name" />
</div>
<div>
<label>Quantity</label>
<input asp-for="Quantity" />
</div>
<button type="submit">Create</button>
</form>
Edit.cshtml
@model BloodProduct
<h2>Edit Blood Product</h2>
<form asp-action="Edit">
<input type="hidden" asp-for="BloodProductId" />
<div>
<label>Product Name</label>
<input asp-for="Name" />
</div>
<div>
<label>Quantity</label>
<input asp-for="Quantity" />
</div>
<button type="submit">Save</button>
</form>
Delete.cshtml
@model BloodProduct
<h2>Delete Blood Product</h2>
<p>Are you sure you want to delete the blood product @Model.Name?</p>
<form asp-action="Delete">
<input type="hidden" asp-for="BloodProductId" />
<button type="submit">Delete</button>
<a asp-action="Index">Cancel</a>
</form>
Inventory Views
Index.cshtml
@model IEnumerable<Inventory>
<h2>Inventories</h2>
<a asp-action="Create">Create New Inventory</a>
<table>
<thead>
<tr>
<th>Product Name</th>
<th>Quantity</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
@foreach (var inventory in Model)
{
<tr>
<td>@inventory.ProductName</td>
<td>@inventory.Quantity</td>
<td>
<a asp-action="Edit" asp-route-id="@inventory.InventoryId">Edit</a> |
<a asp-action="Delete" asp-route-id="@inventory.InventoryId">Delete</a>
</td>
</tr>
}
</tbody>
</table>
Create.cshtml
@model Inventory
<h2>Create Inventory</h2>
<form asp-action="Create">
<div>
<label>Product Name</label>
<input asp-for="ProductName" />
</div>
<div>
<label>Quantity</label>
<input asp-for="Quantity" />
</div>
<button type="submit">Create</button>
</form>
Edit.cshtml
@model Inventory
<h2>Edit Inventory</h2>
<form asp-action="Edit">
<input type="hidden" asp-for="InventoryId" />
<div>
<label>Product Name</label>
<input asp-for="ProductName" />
</div>
<div>
<label>Quantity</label>
<input asp-for="Quantity" />
</div>
<button type="submit">Save</button>
</form>
Delete.cshtml
@model Inventory
<h2>Delete Inventory</h2>
<p>Are you sure you want to delete the inventory item @Model.ProductName?</p>
<form asp-action="Delete">
<input type="hidden" asp-for="InventoryId" />
<button type="submit">Delete</button>
<a asp-action="Index">Cancel</a>
</form>
Order Views
Index.cshtml
@model IEnumerable<Order>
<h2>Orders</h2>
<a asp-action="Create">Create New Order</a>
<table>
<thead>
<tr>
<th>Order Date</th>
<th>Customer Name</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
@foreach (var order in Model)
{
<tr>
<td>@order.OrderDate</td>
<td>@order.CustomerName</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>
Create.cshtml
@model Order
<h2>Create Order</h2>
<form asp-action="Create">
<div>
<label>Order Date</label>
<input asp-for="OrderDate" type="date" />
</div>
<div>
<label>Customer Name</label>
<input asp-for="CustomerName" />
</div>
<button type="submit">Create</button>
</form>
Edit.cshtml
@model Order
<h2>Edit Order</h2>
<form asp-action="Edit">
<input type="hidden" asp-for="OrderId" />
<div>
<label>Order Date</label>
<input asp-for="OrderDate" type="date" />
</div>
<div>
<label>Customer Name</label>
<input asp-for="CustomerName" />
</div>
<button type="submit">Save</button>
</form>
Delete.cshtml
@model Order
<h2>Delete Order</h2>
<p>Are you sure you want to delete the order placed on @Model.OrderDate by @Model.CustomerName?</p>
<form asp-action="Delete">
<input type="hidden" asp-for="OrderId" />
<button type="submit">Delete</button>
<a asp-action="Index">Cancel</a>
</form>
Report Views
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>
Create.cshtml
@model Report
<h2>Create Report</h2>
<form asp-action="Create">
<div>
<label>Title</label>
<input asp-for="Title" />
</div>
<div>
<label>Content</label>
<textarea asp-for="Content"></textarea>
</div>
<button type="submit">Create</button>
</form>
Edit.cshtml
@model Report
<h2>Edit Report</h2>
<form asp-action="Edit">
<input type="hidden" asp-for="ReportId" />
<div>
<label>Title</label>
<input asp-for="Title" />
</div>
<div>
<label>Content</label>
<textarea asp-for="Content"></textarea>
</div>
<button type="submit">Save</button>
</form>
Delete.cshtml
@model Report
<h2>Delete Report</h2>
<p>Are you sure you want to delete the report titled "@Model.Title"?</p>
<form asp-action="Delete">
<input type="hidden" asp-for="ReportId" />
<button type="submit">Delete</button>
<a asp-action="Index">Cancel</a>
</form>
QualityControl Views
Index.cshtml
@model IEnumerable<QualityControl>
<h2>Quality Controls</h2>
<a asp-action="Create">Create New Quality Control</a>
<table>
<thead>
<tr>
<th>Control Name</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
@foreach (var qualityControl in Model)
{
<tr>
<td>@qualityControl.Name</td>
<td>
<a asp-action="Edit" asp-route-id="@qualityControl.QualityControlId">Edit</a> |
<a asp-action="Delete" asp-route-id="@qualityControl.QualityControlId">Delete</a>
</td>
</tr>
}
</tbody>
</table>
Create.cshtml
@model QualityControl
<h2>Create Quality Control</h2>
<form asp-action="Create">
<div>
<label>Name</label>
<input asp-for="Name" />
</div>
<button type="submit">Create</button>
</form>
Edit.cshtml
@model QualityControl
<h2>Edit Quality Control</h2>
<form asp-action="Edit">
<input type="hidden" asp-for="QualityControlId" />
<div>
<label>Name</label>
<input asp-for="Name" />
</div>
<button type="submit">Save</button>
</form>
Delete.cshtml
@model QualityControl
<h2>Delete Quality Control</h2>
<p>Are you sure you want to delete the quality control named "@Model.Name"?</p>
<form asp-action="Delete">
<input type="hidden" asp-for="QualityControlId" />
<button type="submit">Delete</button>
<a asp-action="Index">Cancel</a>
</form>
Campaign Views
Index.cshtml
@model IEnumerable<Campaign>
<h2>Campaigns</h2>
<a asp-action="Create">Create New Campaign</a>
<table>
<thead>
<tr>
<th>Campaign Name</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
@foreach (var campaign in Model)
{
<tr>
<td>@campaign.Name</td>
<td>
<a asp-action="Edit" asp-route-id="@campaign.CampaignId">Edit</a> |
<a asp-action="Delete" asp-route-id="@campaign.CampaignId">Delete</a>
</td>
</tr>
}
</tbody>
</table>
Create.cshtml
@model Campaign
<h2>Create Campaign</h2>
<form asp-action="Create">
<div>
<label>Name</label>
<input asp-for="Name" />
</div>
<div>
<label>Description</label>
<textarea asp-for="Description"></textarea>
</div>
<button type="submit">Create</button>
</form>
Edit.cshtml
@model Campaign
<h2>Edit Campaign</h2>
<form asp-action="Edit">
<input type="hidden" asp-for="CampaignId" />
<div>
<label>Name</label>
<input asp-for="Name" />
</div>
<div>
<label>Description</label>
<textarea asp-for="Description"></textarea>
</div>
<button type="submit">Save</button>
</form>
Delete.cshtml
@model Campaign
<h2>Delete Campaign</h2>
<p>Are you sure you want to delete the campaign named "@Model.Name"?</p>
<form asp-action="Delete">
<input type="hidden" asp-for="CampaignId" />
<button type="submit">Delete</button>
<a asp-action="Index">Cancel</a>
</form>
This completes the view files for all the controllers in your ASP.NET MVC application. Each view is structured to provide a user-friendly interface for managing the respective entities. You can further enhance these views with additional styling and validation as needed.
Creating a Dashboard Page
Creating a dashboard page in an ASP.NET MVC application involves aggregating data from various repositories and displaying it in a user-friendly format. Below, I will outline how to create a simple dashboard that consolidates data related to users, donors, appointments, blood products, and campaigns.
Step 1: Create a Dashboard ViewModel
First, create a ViewModel that will hold the consolidated data for the dashboard. Create a new folder named ViewModels in your project and add a class named DashboardViewModel.cs.
// ViewModels/DashboardViewModel.cs
public class DashboardViewModel
{
public int TotalUsers { get; set; }
public int TotalDonors { get; set; }
public int TotalAppointments { get; set; }
public int TotalBloodProducts { get; set; }
public int TotalCampaigns { get; set; }
}
Step 2: Create a Dashboard Controller
Next, create a new controller named DashboardController.cs in the Controllers folder. This controller will aggregate data from the various repositories and pass it to the dashboard view.
using Microsoft.AspNetCore.Mvc;
using System.Threading.Tasks;
public class DashboardController : Controller
{
private readonly IUserRepository _userRepository;
private readonly IDonorRepository _donorRepository;
private readonly IAppointmentRepository _appointmentRepository;
private readonly IBloodProductRepository _bloodProductRepository;
private readonly ICampaignRepository _campaignRepository;
public DashboardController(IUser Repository userRepository, IDonorRepository donorRepository,
IAppointmentRepository appointmentRepository,
IBloodProductRepository bloodProductRepository,
ICampaignRepository campaignRepository)
{
_userRepository = userRepository;
_donorRepository = donorRepository;
_appointmentRepository = appointmentRepository;
_bloodProductRepository = bloodProductRepository;
_campaignRepository = campaignRepository;
}
public async Task<IActionResult> Index()
{
var dashboardViewModel = new DashboardViewModel
{
TotalUsers = (await _userRepository.GetAllUsersAsync()).Count(),
TotalDonors = (await _donorRepository.GetAllDonorsAsync()).Count(),
TotalAppointments = (await _appointmentRepository.GetAllAppointmentsAsync()).Count(),
TotalBloodProducts = (await _bloodProductRepository.GetAllBloodProductsAsync()).Count(),
TotalCampaigns = (await _campaignRepository.GetAllCampaignsAsync()).Count()
};
return View(dashboardViewModel);
}
}
Step 3: Create the Dashboard View
Create a new folder named Dashboard in the Views directory and add a view named Index.cshtml.
@model DashboardViewModel
<h2>Dashboard</h2>
<div class="dashboard">
<div class="card">
<h3>Total Users</h3>
<p>@Model.TotalUsers</p>
</div>
<div class="card">
<h3>Total Donors</h3>
<p>@Model.TotalDonors</p>
</div>
<div class="card">
<h3>Total Appointments</h3>
<p>@Model.TotalAppointments</p>
</div>
<div class="card">
<h3>Total Blood Products</h3>
<p>@Model.TotalBloodProducts</p>
</div>
<div class="card">
<h3>Total Campaigns</h3>
<p>@Model.TotalCampaigns</p>
</div>
</div>
<style>
.dashboard {
display: flex;
flex-wrap: wrap;
gap: 20px;
}
.card {
border: 1px solid #ccc;
border-radius: 5px;
padding: 20px;
width: 200px;
text-align: center;
}
</style>
Step 4: Update the Navigation
To access the dashboard, you may want to add a link to it in your main layout or navigation menu. Open your _Layout.cshtml file (usually found in Views/Shared) and add a link to the dashboard.
<ul class="navbar-nav">
<li class="nav-item">
<a class="nav-link" asp-controller="Dashboard" asp-action="Index">Dashboard</a>
</li>
<!-- Other links -->
</ul>
Step 5: Run the Application
Now, run your application. You should be able to navigate to the dashboard page, where you will see consolidated data related to users, donors, appointments, blood products, and campaigns.
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