Project Introduction
The Virtual Classroom Platform is designed to facilitate online learning by providing a comprehensive environment for students and instructors to interact, share resources, and conduct live classes. Built using ASP.NET and SQL Server, this application allows users to create and manage courses, access learning materials, participate in live sessions, and take quizzes. The system aims to enhance the educational experience by offering a structured and interactive platform for learning.
Project Objectives
- To create a secure user authentication system for managing user accounts and roles.
- To enable the creation and management of courses, including descriptions and syllabi.
- To facilitate the scheduling and management of live classes with links for participation.
- To provide a repository for learning resources, including videos, documents, and links.
- To implement quizzes for assessing student knowledge and tracking performance.
- To manage grades for quizzes taken by students and provide feedback on their performance.
- To send notifications to users regarding course updates, live classes, and important announcements.
- To handle payments for course enrollments and track payment statuses.
- To collect user feedback to continuously improve the platform and its offerings.
Project Modules
- User Management Module: Handles user registration, login, and role management.
- Course Management Module: Allows users to create, edit, and delete courses.
- Syllabus Management Module: Facilitates the creation and management of course syllabi.
- Live Class Management Module: Manages scheduling and links for live classes.
- Resource Management Module: Provides a platform for uploading and managing course resources.
- Quiz Management Module: Allows the creation and administration of quizzes for courses.
- Grade Management Module: Tracks and manages grades for quizzes taken by students.
- Notification Module: Sends notifications to users regarding course-related updates.
- Payment Management Module: Handles payments for course enrollments and tracks their statuses.
- Feedback Module: Collects and analyzes user feedback to enhance the platform.
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 Courses Table
CREATE TABLE Courses (
CourseId INT PRIMARY KEY IDENTITY(1,1),
CourseName NVARCHAR(100) NOT NULL,
Description NVARCHAR(MAX),
CreatedBy INT NOT NULL,
CreatedAt DATETIME DEFAULT GETDATE(),
UpdatedAt DATETIME DEFAULT GETDATE(),
FOREIGN KEY (CreatedBy) REFERENCES Users(UserId)
);
-- Create Syllabus Table
CREATE TABLE Syllabus (
SyllabusId INT PRIMARY KEY IDENTITY(1,1),
CourseId INT NOT NULL,
Topic NVARCHAR(100) NOT NULL,
Description NVARCHAR(MAX),
CreatedAt DATETIME DEFAULT GETDATE(),
UpdatedAt DATETIME DEFAULT GETDATE(),
FOREIGN KEY (CourseId) REFERENCES Courses(CourseId)
);
-- Create LiveClasses Table
CREATE TABLE LiveClasses (
LiveClassId INT PRIMARY KEY IDENTITY(1,1),
CourseId INT NOT NULL,
ClassDate DATETIME NOT NULL,
Duration INT NOT NULL, -- Duration in minutes
Link NVARCHAR(255) NOT NULL, -- Link to the live class
CreatedAt DATETIME DEFAULT GETDATE(),
UpdatedAt DATETIME DEFAULT GETDATE(),
FOREIGN KEY (CourseId) REFERENCES Courses(CourseId)
);
-- Create Resources Table
CREATE TABLE Resources (
ResourceId INT PRIMARY KEY IDENTITY(1,1),
CourseId INT NOT NULL,
ResourceName NVARCHAR(100) NOT NULL,
ResourceType NVARCHAR(50) NOT NULL, -- e.g., Video, Document, Link
ResourceLink NVARCHAR(255),
CreatedAt DATETIME DEFAULT GETDATE(),
UpdatedAt DATETIME DEFAULT GETDATE(),
FOREIGN KEY (CourseId) REFERENCES Courses(CourseId)
);
-- Create Quizzes Table
CREATE TABLE Quizzes (
QuizId INT PRIMARY KEY IDENTITY(1,1),
CourseId INT NOT NULL,
QuizName NVARCHAR(100) NOT NULL,
TotalMarks INT NOT NULL,
CreatedAt DATETIME DEFAULT GETDATE(),
UpdatedAt DATETIME DEFAULT GETDATE(),
FOREIGN KEY (CourseId) REFERENCES Courses(CourseId)
);
-- Create Grades Table
CREATE TABLE Grades (
GradeId INT PRIMARY KEY IDENTITY(1,1),
UserId INT NOT NULL,
QuizId INT NOT NULL,
MarksObtained INT NOT NULL,
CreatedAt DATETIME DEFAULT GETDATE(),
FOREIGN KEY (User Id) REFERENCES Users(UserId),
FOREIGN KEY (QuizId) REFERENCES Quizzes(QuizId)
);
-- 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 Payments Table
CREATE TABLE Payments (
PaymentId INT PRIMARY KEY IDENTITY(1,1),
UserId INT NOT NULL,
CourseId INT NOT NULL,
Amount DECIMAL(18, 2) NOT NULL,
PaymentDate DATETIME DEFAULT GETDATE(),
PaymentStatus NVARCHAR(50) NOT NULL, -- e.g., Completed, Pending
CreatedAt DATETIME DEFAULT GETDATE(),
FOREIGN KEY (User Id) REFERENCES Users(UserId),
FOREIGN KEY (CourseId) REFERENCES Courses(CourseId)
);
-- Create Feedback Table
CREATE TABLE Feedback (
FeedbackId INT PRIMARY KEY IDENTITY(1,1),
UserId INT NOT NULL,
CourseId INT NOT NULL,
FeedbackContent NVARCHAR(MAX) NOT NULL,
CreatedAt DATETIME DEFAULT GETDATE(),
FOREIGN KEY (User Id) REFERENCES Users(UserId),
FOREIGN KEY (CourseId) REFERENCES Courses(CourseId)
);
Explanation of Tables
Users: Stores user information, including their role in the platform.
Roles: Defines different roles (e.g., Student, Instructor, Admin) in the system.
Courses: Manages course details, including descriptions and the creator of the course.
Syllabus: Contains topics and descriptions for each course, outlining the curriculum.
LiveClasses: Tracks live class sessions, including dates, durations, and access links.
Resources: Stores educational resources associated with courses, such as videos and documents.
Quizzes: Manages quizzes for courses, including total marks and associated course.
Grades: Records grades for users based on their performance in quizzes.
Notifications: Stores notifications for users regarding course updates and other relevant information.
Payments: Manages payment transactions for course enrollments, including amounts and statuses.
Feedback: Collects user feedback on courses, allowing for improvements and adjustments.
This structure provides a comprehensive framework for managing virtual classroom operations, facilitating effective course delivery, assessment, and user engagement.
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:
Create Models
Define C# classes that represent the database tables.
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 Course
{
public int CourseId { get; set; }
public string CourseName { get; set; }
public string Description { get; set; }
public int CreatedBy { get; set; }
public DateTime CreatedAt { get; set; }
public DateTime UpdatedAt { get; set; }
}
public class Syllabus
{
public int SyllabusId { get; set; }
public int CourseId { get; set; }
public string Topic { get; set; }
public string Description { get; set; }
public DateTime CreatedAt { get; set; }
public DateTime UpdatedAt { get; set; }
}
public class LiveClass
{
public int LiveClassId { get; set; }
public int CourseId { get; set; }
public DateTime ClassDate { get; set; }
public int Duration { get; set; }
public string Link { get; set; }
public DateTime CreatedAt { get; set; }
public DateTime UpdatedAt { get; set; }
}
public class Resource
{
public int ResourceId { get; set; }
public int CourseId { get; set; }
public string ResourceName { get; set; }
public string ResourceType { get; set; }
public string ResourceLink { get; set; }
public DateTime CreatedAt { get; set; }
public DateTime UpdatedAt { get; set; }
}
public class Quiz
{
public int QuizId { get; set; }
public int CourseId { get; set; }
public string QuizName { get; set; }
public int TotalMarks { get; set; }
public DateTime CreatedAt { get; set; }
public DateTime UpdatedAt { get; set; }
}
public class Grade
{
public int GradeId { get; set; }
public int UserId { get; set; }
public int QuizId { get; set; }
public int MarksObtained { 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 Payment
{
public int PaymentId { get; set; }
public int UserId { get; set; }
public int CourseId { get; set; }
public decimal Amount { get; set; }
public DateTime PaymentDate { get; set; }
public string PaymentStatus { get; set; }
public DateTime CreatedAt { get; set; }
}
public class Feedback
{
public int FeedbackId { get; set; }
public int UserId { get; set; }
public int CourseId { get; set; }
public string FeedbackContent { get; set; }
public DateTime CreatedAt { get; set; }
}
Create Repositories
Next, we will create a generic repository interface and a concrete implementation for each model. Here’s an example of how to implement a repository for the User model:
IRepository Interface
public interface IRepository<T>
{
IEnumerable<T> GetAll();
T GetById(int id);
void Add(T entity);
void Update(T entity);
void Delete(int id);
}
UserRepository Implementation
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
public class UserRepository : IRepository<User>
{
private readonly string _connectionString;
public UserRepository(string connectionString)
{
_connectionString = connectionString;
}
public IEnumerable<User> GetAll()
{
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 User GetById(int id)
{
User user = null;
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Users WHERE UserId = @User Id", connection);
command.Parameters.Add ("@User Id", SqlDbType.Int).Value = id;
connection.Open();
using (var reader = command.ExecuteReader())
{
if (reader.Read())
{
user = new User
{
UserId = (int)reader["User Id"],
Username = reader["Username"].ToString(),
PasswordHash = reader["PasswordHash"].ToString(),
Email = reader["Email"].ToString(),
FirstName = reader["FirstName"].ToString(),
LastName = reader["LastName"].ToString(),
RoleId = (int)reader["RoleId"],
CreatedAt = (DateTime)reader["CreatedAt"],
UpdatedAt = (DateTime)reader["UpdatedAt"]
};
}
}
}
return user;
}
public void Add(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 Update(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 Delete(int id)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("DELETE FROM Users WHERE UserId = @User Id", connection);
command.Parameters.AddWithValue("@User Id", id);
connection.Open();
command.ExecuteNonQuery();
}
}
}
This pattern can be replicated for other models such as Role, Course, Syllabus, etc., by creating corresponding repository classes that implement the IRepository
Below are the repository implementations for the remaining models:
Role, Course, Syllabus, LiveClass, Resource, Quiz, Grade, Notification, Payment, and Feedback. Each repository will implement the IRepository
RoleRepository
public class RoleRepository : IRepository<Role>
{
private readonly string _connectionString;
public RoleRepository(string connectionString)
{
_connectionString = connectionString;
}
public IEnumerable<Role> GetAll()
{
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 Role GetById(int id)
{
Role role = null;
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Roles WHERE RoleId = @RoleId", connection);
command.Parameters.AddWithValue("@RoleId", id);
connection.Open();
using (var reader = command.ExecuteReader())
{
if (reader.Read())
{
role = new Role
{
RoleId = (int)reader["RoleId"],
RoleName = reader["RoleName"].ToString(),
CreatedAt = (DateTime)reader["CreatedAt"],
UpdatedAt = (DateTime)reader["UpdatedAt"]
};
}
}
}
return role;
}
public void Add(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 Update(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 Delete(int id)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("DELETE FROM Roles WHERE RoleId = @RoleId", connection);
command.Parameters.AddWithValue("@RoleId", id);
connection.Open();
command.ExecuteNonQuery();
}
}
}
CourseRepository
public class CourseRepository : IRepository<Course>
{
private readonly string _connectionString;
public CourseRepository(string connectionString)
{
_connectionString = connectionString;
}
public IEnumerable<Course> GetAll()
{
var courses = new List<Course>();
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Courses", connection);
connection.Open();
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
courses.Add(new Course
{
CourseId = (int)reader["CourseId"],
CourseName = reader["CourseName"].ToString(),
Description = reader["Description"].ToString(),
CreatedBy = (int)reader["CreatedBy"],
CreatedAt = (DateTime)reader["CreatedAt"],
UpdatedAt = (DateTime)reader["UpdatedAt"]
});
}
}
}
return courses;
}
public Course GetById(int id)
{
Course course = null;
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Courses WHERE CourseId = @CourseId", connection);
command.Parameters.AddWithValue("@CourseId", id);
connection.Open();
using (var reader = command.ExecuteReader())
{
if (reader.Read())
{
course = new Course
{
CourseId = (int)reader["CourseId"],
CourseName = reader["CourseName"].ToString(),
Description = reader["Description"].ToString(),
CreatedBy = (int)reader["CreatedBy"],
CreatedAt = (DateTime)reader["CreatedAt"],
UpdatedAt = (DateTime)reader["UpdatedAt"]
};
}
}
}
return course;
}
public void Add(Course course)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("INSERT INTO Courses (CourseName, Description, CreatedBy) VALUES (@CourseName, @Description, @CreatedBy)", connection);
command.Parameters.AddWithValue("@CourseName", course.CourseName);
command.Parameters.AddWithValue("@Description", course.Description);
command.Parameters.AddWithValue("@CreatedBy", course.CreatedBy);
connection.Open();
command.ExecuteNonQuery();
}
}
public void Update(Course course)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("UPDATE Courses SET CourseName = @CourseName, Description = @Description, UpdatedAt = GETDATE() WHERE CourseId = @CourseId", connection);
command.Parameters.AddWithValue("@CourseId", course.CourseId);
command.Parameters.AddWithValue("@CourseName", course.CourseName);
command.Parameters.AddWithValue("@Description", course.Description);
connection.Open();
command.ExecuteNonQuery();
}
}
public void Delete(int id)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("DELETE FROM Courses WHERE CourseId = @CourseId", connection);
command.Parameters.AddWithValue("@CourseId", id);
connection.Open();
command.ExecuteNonQuery();
}
}
}
SyllabusRepository
public class SyllabusRepository : IRepository<Syllabus>
{
private readonly string _connectionString;
public SyllabusRepository(string connectionString)
{
_connectionString = connectionString;
}
public IEnumerable<Syllabus> GetAll()
{
var syllabuses = new List<Syllabus>();
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Syllabus", connection);
connection.Open();
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
syllabuses.Add(new Syllabus
{
SyllabusId = (int)reader["SyllabusId"],
CourseId = (int)reader["CourseId"],
Topic = reader["Topic"].ToString(),
Description = reader["Description"].ToString(),
CreatedAt = (DateTime)reader["CreatedAt"],
UpdatedAt = (DateTime)reader["UpdatedAt"]
});
}
}
}
return syllabuses;
}
public Syllabus GetById(int id)
{
Syllabus syllabus = null;
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Syllabus WHERE SyllabusId = @SyllabusId", connection);
command.Parameters.AddWithValue("@SyllabusId", id);
connection.Open();
using (var reader = command.ExecuteReader())
{
if (reader.Read())
{
syllabus = new Syllabus
{
SyllabusId = (int)reader["SyllabusId"],
CourseId = (int)reader["CourseId"],
Topic = reader["Topic"].ToString(),
Description = reader["Description"].ToString(),
CreatedAt = (DateTime)reader["CreatedAt"],
UpdatedAt = (DateTime)reader["UpdatedAt"]
};
}
}
}
return syllabus;
}
public void Add(Syllabus syllabus)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("INSERT INTO Syllabus (CourseId, Topic, Description) VALUES (@CourseId, @Topic, @Description)", connection);
command.Parameters.AddWithValue("@CourseId", syllabus.CourseId);
command.Parameters.AddWithValue("@Topic", syllabus.Topic);
command.Parameters.AddWithValue("@Description", syllabus.Description);
connection.Open();
command.ExecuteNonQuery();
}
}
public void Update(Syllabus syllabus)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("UPDATE Syllabus SET CourseId = @CourseId, Topic = @Topic, Description = @Description, UpdatedAt = GETDATE() WHERE SyllabusId = @SyllabusId", connection);
command.Parameters.AddWithValue("@SyllabusId", syllabus.SyllabusId);
command.Parameters.AddWithValue("@CourseId", syllabus.CourseId);
command.Parameters.AddWithValue("@Topic", syllabus.Topic);
command.Parameters.AddWithValue("@Description", syllabus.Description);
connection.Open();
command.ExecuteNonQuery();
}
}
public void Delete(int id)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("DELETE FROM Syllabus WHERE SyllabusId = @SyllabusId", connection);
command.Parameters.AddWithValue("@SyllabusId", id);
connection.Open();
command.ExecuteNonQuery();
}
}
}
LiveClassRepository
public class LiveClassRepository : IRepository<LiveClass>
{
private readonly string _connectionString;
public LiveClassRepository(string connectionString)
{
_connectionString = connectionString;
}
public IEnumerable<LiveClass> GetAll()
{
var liveClasses = new List<LiveClass>();
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM LiveClasses", connection);
connection.Open();
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
liveClasses.Add(new LiveClass
{
LiveClassId = (int)reader["LiveClassId"],
CourseId = (int)reader["CourseId"],
ClassDate = (DateTime)reader["ClassDate"],
Duration = (int)reader["Duration"],
Link = reader["Link"].ToString(),
CreatedAt = (DateTime)reader["CreatedAt"],
UpdatedAt = (DateTime)reader["UpdatedAt"]
});
}
}
}
return liveClasses;
}
public LiveClass GetById(int id)
{
LiveClass liveClass = null;
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM LiveClasses WHERE LiveClassId = @LiveClassId", connection);
command.Parameters.AddWithValue("@LiveClassId", id);
connection.Open();
using (var reader = command.ExecuteReader())
{
if (reader.Read())
{
liveClass = new LiveClass
{
LiveClassId = (int)reader["LiveClassId"],
CourseId = (int)reader["CourseId"],
ClassDate = (DateTime)reader["ClassDate"],
Duration = (int)reader["Duration"],
Link = reader["Link"].ToString(),
CreatedAt = (DateTime)reader["CreatedAt"],
UpdatedAt = (DateTime)reader["UpdatedAt"]
};
}
}
}
return liveClass;
}
public void Add(LiveClass liveClass)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("INSERT INTO LiveClasses (CourseId, ClassDate, Duration, Link) VALUES (@CourseId, @ClassDate, @Duration, @Link)", connection);
command.Parameters.AddWithValue("@CourseId", liveClass.CourseId);
command.Parameters.AddWithValue("@ClassDate", liveClass.ClassDate);
command.Parameters.AddWithValue("@Duration", liveClass.Duration);
command.Parameters.AddWithValue("@Link", liveClass.Link);
connection.Open();
command.ExecuteNonQuery();
}
}
public void Update(LiveClass liveClass)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("UPDATE LiveClasses SET CourseId = @CourseId, ClassDate = @ClassDate, Duration = @Duration, Link = @Link, UpdatedAt = GETDATE() WHERE LiveClassId = @LiveClassId", connection);
command.Parameters.AddWithValue("@LiveClassId", liveClass.LiveClassId);
command.Parameters.AddWithValue("@CourseId", liveClass.CourseId);
command.Parameters.AddWithValue("@ClassDate", liveClass.ClassDate);
command.Parameters.AddWithValue("@Duration", liveClass.Duration);
command.Parameters.AddWithValue("@Link", liveClass.Link);
connection.Open();
command.ExecuteNonQuery();
}
}
public void Delete(int id)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("DELETE FROM LiveClasses WHERE LiveClassId = @LiveClassId", connection);
command.Parameters.AddWithValue("@LiveClassId", id);
connection.Open();
command.ExecuteNonQuery();
}
}
}
ResourceRepository
public class ResourceRepository : IRepository<Resource>
{
private readonly string _connectionString;
public ResourceRepository(string connectionString)
{
_connectionString = connectionString;
}
public IEnumerable<Resource> GetAll()
{
var resources = new List<Resource>();
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Resources", connection);
connection.Open();
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
resources.Add(new Resource
{
ResourceId = (int)reader["ResourceId"],
CourseId = (int)reader["CourseId"],
ResourceName = reader["ResourceName"].ToString(),
ResourceType = reader["ResourceType"].ToString(),
ResourceLink = reader["ResourceLink"].ToString(),
CreatedAt = (DateTime)reader["CreatedAt"],
UpdatedAt = (DateTime)reader["UpdatedAt"]
});
}
}
}
return resources;
}
public Resource GetById(int id)
{
Resource resource = null;
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Resources WHERE ResourceId = @ResourceId", connection);
command.Parameters.AddWithValue("@ResourceId", id);
connection.Open();
using (var reader = command.ExecuteReader())
{
if (reader.Read())
{
resource = new Resource
{
ResourceId = (int)reader["ResourceId"],
CourseId = (int)reader["CourseId"],
ResourceName = reader["ResourceName"].ToString(),
ResourceType = reader["ResourceType"].ToString(),
ResourceLink = reader["ResourceLink"].ToString(),
CreatedAt = (DateTime)reader["CreatedAt"],
UpdatedAt = (DateTime)reader["UpdatedAt"]
};
}
}
}
return resource;
}
public void Add(Resource resource)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("INSERT INTO Resources (CourseId, ResourceName, ResourceType, ResourceLink) VALUES (@CourseId, @ResourceName, @ResourceType, @ResourceLink)", connection);
command.Parameters.AddWithValue("@CourseId", resource.CourseId);
command.Parameters.AddWithValue("@ResourceName", resource.ResourceName);
command.Parameters.AddWithValue("@ResourceType", resource.ResourceType);
command.Parameters.AddWithValue("@ResourceLink", resource.ResourceLink);
connection.Open();
command.ExecuteNonQuery();
}
}
public void Update(Resource resource)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("UPDATE Resources SET CourseId = @CourseId, ResourceName = @ResourceName, ResourceType = @ResourceType, ResourceLink = @ResourceLink, UpdatedAt = GETDATE() WHERE ResourceId = @ResourceId", connection);
command.Parameters.AddWithValue("@ResourceId", resource.ResourceId);
command.Parameters.AddWithValue("@CourseId", resource.CourseId);
command.Parameters.AddWithValue("@ResourceName", resource.ResourceName);
command.Parameters.AddWithValue("@ResourceType", resource.ResourceType);
command.Parameters.AddWithValue("@ResourceLink", resource.ResourceLink);
connection.Open();
command.ExecuteNonQuery();
}
}
public void Delete(int id)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("DELETE FROM Resources WHERE ResourceId = @ResourceId", connection);
command.Parameters.AddWithValue("@ResourceId", id);
connection.Open();
command.ExecuteNonQuery();
}
}
}
QuizRepository
public class QuizRepository : IRepository<Quiz>
{
private readonly string _connectionString;
public QuizRepository(string connectionString)
{
_connectionString = connectionString;
}
public IEnumerable<Quiz> GetAll()
{
var quizzes = new List<Quiz>();
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Quizzes", connection);
connection.Open();
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
quizzes.Add(new Quiz
{
QuizId = (int)reader["QuizId"],
CourseId = (int)reader["CourseId"],
QuizName = reader["QuizName"].ToString(),
TotalMarks = (int)reader["TotalMarks"],
CreatedAt = (DateTime)reader["CreatedAt"],
UpdatedAt = (DateTime)reader["UpdatedAt"]
});
}
}
}
return quizzes;
}
public Quiz GetById(int id)
{
Quiz quiz = null;
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Quizzes WHERE QuizId = @QuizId", connection);
command.Parameters.AddWithValue("@QuizId", id);
connection.Open();
using (var reader = command.ExecuteReader())
{
if (reader.Read())
{
quiz = new Quiz
{
QuizId = (int)reader["QuizId"],
CourseId = (int)reader["CourseId"],
QuizName = reader["QuizName"].ToString(),
TotalMarks = (int)reader["TotalMarks"],
CreatedAt = (DateTime)reader["CreatedAt"],
UpdatedAt = (DateTime)reader["UpdatedAt"]
};
}
}
}
return quiz;
}
public void Add(Quiz quiz)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("INSERT INTO Quizzes (CourseId, QuizName, TotalMarks) VALUES (@CourseId, @QuizName, @TotalMarks)", connection);
command.Parameters.AddWithValue("@CourseId", quiz.CourseId);
command.Parameters.AddWithValue("@QuizName", quiz.QuizName);
command.Parameters.AddWithValue("@TotalMarks", quiz.TotalMarks);
connection.Open();
command.ExecuteNonQuery();
}
}
public void Update(Quiz quiz)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("UPDATE Quizzes SET CourseId = @CourseId, QuizName = @QuizName, TotalMarks = @TotalMarks, UpdatedAt = GETDATE() WHERE QuizId = @QuizId", connection);
command.Parameters.AddWithValue("@QuizId", quiz.QuizId);
command.Parameters.AddWithValue("@CourseId", quiz.CourseId);
command.Parameters.AddWithValue("@QuizName", quiz.QuizName);
command.Parameters.AddWithValue("@TotalMarks", quiz.Total Marks);
connection.Open();
command.ExecuteNonQuery();
}
}
public void Delete(int id)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("DELETE FROM Quizzes WHERE QuizId = @QuizId", connection);
command.Parameters.AddWithValue("@QuizId", id);
connection.Open();
command.ExecuteNonQuery();
}
}
}
GradeRepository
public class GradeRepository : IRepository<Grade>
{
private readonly string _connectionString;
public GradeRepository(string connectionString)
{
_connectionString = connectionString;
}
public IEnumerable<Grade> GetAll()
{
var grades = new List<Grade>();
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Grades", connection);
connection.Open();
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
grades.Add(new Grade
{
GradeId = (int)reader["GradeId"],
UserId = (int)reader["User Id"],
QuizId = (int)reader["QuizId"],
MarksObtained = (int)reader["MarksObtained"],
CreatedAt = (DateTime)reader["CreatedAt"]
});
}
}
}
return grades;
}
public Grade GetById(int id)
{
Grade grade = null;
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Grades WHERE GradeId = @GradeId", connection);
command.Parameters.AddWithValue("@GradeId", id);
connection.Open();
using (var reader = command.ExecuteReader())
{
if (reader.Read())
{
grade = new Grade
{
GradeId = (int)reader["GradeId"],
UserId = (int)reader["User Id"],
QuizId = (int)reader["QuizId"],
MarksObtained = (int)reader["MarksObtained"],
CreatedAt = (DateTime)reader["CreatedAt"]
};
}
}
}
return grade;
}
public void Add(Grade grade)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("INSERT INTO Grades (User Id, QuizId, MarksObtained) VALUES (@User Id, @QuizId, @MarksObtained)", connection);
command.Parameters.AddWithValue("@User Id", grade.UserId);
command.Parameters.AddWithValue("@QuizId", grade.QuizId);
command.Parameters.AddWithValue("@MarksObtained", grade.MarksObtained);
connection.Open();
command.ExecuteNonQuery();
}
}
public void Update(Grade grade)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("UPDATE Grades SET UserId = @User Id, QuizId = @QuizId, MarksObtained = @MarksObtained WHERE GradeId = @GradeId", connection);
command.Parameters.AddWithValue("@GradeId", grade.GradeId);
command.Parameters.AddWithValue("@User Id", grade.UserId);
command.Parameters.AddWithValue("@QuizId", grade.QuizId);
command.Parameters.AddWithValue("@MarksObtained", grade.MarksObtained);
connection.Open();
command.ExecuteNonQuery();
}
}
public void Delete(int id)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("DELETE FROM Grades WHERE GradeId = @GradeId", connection);
command.Parameters.AddWithValue("@GradeId", id);
connection.Open();
command.ExecuteNonQuery();
}
}
}
NotificationRepository
public class NotificationRepository : IRepository<Notification>
{
private readonly string _connectionString;
public NotificationRepository(string connectionString)
{
_connectionString = connectionString;
}
public IEnumerable<Notification> GetAll()
{
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 Notification GetById(int id)
{
Notification notification = null;
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Notifications WHERE NotificationId = @NotificationId", connection);
command.Parameters.AddWithValue("@NotificationId", id);
connection.Open();
using (var reader = command.ExecuteReader())
{
if (reader.Read())
{
notification = new Notification
{
NotificationId = (int)reader["NotificationId"],
UserId = (int)reader["User Id"],
Message = reader["Message"].ToString(),
IsRead = (bool)reader["IsRead"],
CreatedAt = (DateTime)reader["CreatedAt"]
};
}
}
}
return notification;
}
public void Add(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 Update(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 Delete(int id)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("DELETE FROM Notifications WHERE NotificationId = @NotificationId", connection);
command.Parameters.AddWithValue("@NotificationId", id);
connection.Open();
command.ExecuteNonQuery();
}
}
}
PaymentRepository
public class PaymentRepository : IRepository<Payment>
{
private readonly string _connectionString;
public PaymentRepository(string connectionString)
{
_connectionString = connectionString;
}
public IEnumerable<Payment> GetAll()
{
var payments = new List<Payment>();
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Payments", connection);
connection.Open();
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
payments.Add(new Payment
{
PaymentId = (int)reader["PaymentId"],
UserId = (int)reader["User Id"],
CourseId = (int)reader["CourseId"],
Amount = (decimal)reader["Amount"],
PaymentDate = (DateTime)reader["PaymentDate"],
PaymentStatus = reader["PaymentStatus"].ToString(),
CreatedAt = (DateTime)reader["CreatedAt"]
});
}
}
}
return payments;
}
public Payment GetById(int id)
{
Payment payment = null;
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Payments WHERE PaymentId = @PaymentId", connection);
command.Parameters.AddWithValue("@PaymentId", id);
connection.Open();
using (var reader = command.ExecuteReader())
{
if (reader.Read())
{
payment = new Payment
{
PaymentId = (int)reader["PaymentId"],
UserId = (int)reader["User Id"],
CourseId = (int)reader["CourseId"],
Amount = (decimal)reader["Amount"],
PaymentDate = (DateTime)reader["PaymentDate"],
PaymentStatus = reader["PaymentStatus"].ToString(),
CreatedAt = (DateTime)reader["CreatedAt"]
};
}
}
}
return payment;
}
public void Add(Payment payment)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("INSERT INTO Payments (User Id, CourseId, Amount, PaymentStatus) VALUES (@User Id, @CourseId, @Amount, @PaymentStatus)", connection);
command.Parameters.AddWithValue("@User Id", payment.UserId);
command.Parameters.AddWithValue("@CourseId", payment.CourseId);
command.Parameters.AddWithValue("@Amount", payment.Amount);
command.Parameters.AddWithValue("@PaymentStatus", payment.PaymentStatus);
connection.Open();
command.ExecuteNonQuery();
}
}
public void Update(Payment payment)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("UPDATE Payments SET UserId = @User Id, CourseId = @CourseId, Amount = @Amount, PaymentStatus = @PaymentStatus, CreatedAt = GETDATE() WHERE PaymentId = @PaymentId", connection);
command.Parameters.AddWithValue("@PaymentId", payment.PaymentId);
command.Parameters.AddWithValue("@User Id", payment.UserId);
command.Parameters.AddWithValue("@CourseId", payment.CourseId);
command.Parameters.AddWithValue("@Amount", payment.Amount);
command.Parameters.AddWithValue("@PaymentStatus", payment.PaymentStatus);
connection.Open();
command.ExecuteNonQuery();
}
}
public void Delete(int id)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("DELETE FROM Payments WHERE PaymentId = @PaymentId", connection);
command.Parameters.AddWithValue("@PaymentId", id);
connection.Open();
command.ExecuteNonQuery();
}
}
}
FeedbackRepository
public class FeedbackRepository : IRepository<Feedback>
{
private readonly string _connectionString;
public FeedbackRepository(string connectionString)
{
_connectionString = connectionString;
}
public IEnumerable<Feedback> GetAll()
{
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"],
CourseId = (int)reader["CourseId"],
FeedbackContent = reader["FeedbackContent"].ToString(),
CreatedAt = (DateTime)reader["CreatedAt"]
});
}
}
}
return feedbacks;
}
public Feedback GetById(int id)
{
Feedback feedback = null;
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("SELECT * FROM Feedback WHERE FeedbackId = @FeedbackId", connection);
command.Parameters.AddWithValue("@FeedbackId", id);
connection.Open();
using (var reader = command.ExecuteReader())
{
if (reader.Read())
{
feedback = new Feedback
{
FeedbackId = (int)reader["FeedbackId"],
UserId = (int)reader["User Id"],
CourseId = (int)reader["CourseId"],
FeedbackContent = reader["FeedbackContent"].ToString(),
CreatedAt = (DateTime)reader["CreatedAt"]
};
}
}
}
return feedback;
}
public void Add(Feedback feedback)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("INSERT INTO Feedback (User Id, CourseId, FeedbackContent) VALUES (@User Id, @CourseId, @FeedbackContent)", connection);
command.Parameters.AddWithValue("@User Id", feedback.UserId);
command.Parameters.AddWithValue("@CourseId", feedback.CourseId);
command.Parameters.AddWithValue("@FeedbackContent", feedback.FeedbackContent);
connection.Open();
command.ExecuteNonQuery();
}
}
public void Update(Feedback feedback)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("UPDATE Feedback SET UserId = @User Id, CourseId = @CourseId, FeedbackContent = @FeedbackContent WHERE FeedbackId = @FeedbackId", connection);
command.Parameters.AddWithValue("@FeedbackId", feedback.FeedbackId);
command.Parameters.AddWithValue("@User Id", feedback.UserId);
command.Parameters.AddWithValue("@CourseId", feedback.CourseId);
command.Parameters.AddWithValue("@FeedbackContent", feedback.FeedbackContent);
connection.Open();
command.ExecuteNonQuery();
}
}
public void Delete(int id)
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand("DELETE FROM Feedback WHERE FeedbackId = @FeedbackId", connection);
command.Parameters.AddWithValue("@FeedbackId", id);
connection.Open();
command.ExecuteNonQuery();
}
}
}
This completes the repository implementations for all the models defined in your SQL Server schema. Each repository follows the same pattern, ensuring consistency and maintainability across your data access layer.
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.
Below are the controller implementations for each of the repositories:
User, Role, Course, Syllabus, LiveClass, Resource, Quiz, Grade, Notification, Payment, and Feedback.
Base Controller
First, let's create a base controller that can be inherited by all other controllers. This will help in managing common functionalities like dependency injection for the repositories.
using Microsoft.AspNetCore.Mvc;
public class BaseController : Controller
{
protected readonly string _connectionString;
public BaseController(string connectionString)
{
_connectionString = connectionString;
}
}
UserController
public class UserController : BaseController
{
private readonly UserRepository _userRepository;
public UserController(string connectionString) : base(connectionString)
{
_userRepository = new UserRepository(connectionString);
}
public IActionResult Index()
{
var users = _userRepository.GetAll();
return View(users);
}
public IActionResult Details(int id)
{
var user = _userRepository.GetById(id);
return View(user);
}
public IActionResult Create()
{
return View();
}
[HttpPost]
public IActionResult Create(User user)
{
if (ModelState.IsValid)
{
_userRepository.Add(user);
return RedirectToAction("Index");
}
return View(user);
}
public IActionResult Edit(int id)
{
var user = _userRepository.GetById(id);
return View(user);
}
[HttpPost]
public IActionResult Edit(User user)
{
if (ModelState.IsValid)
{
_userRepository.Update(user);
return RedirectToAction("Index");
}
return View(user);
}
public IActionResult Delete(int id)
{
var user = _userRepository.GetById(id);
return View(user);
}
[HttpPost, ActionName("Delete")]
public IActionResult DeleteConfirmed(int id)
{
_userRepository.Delete(id);
return RedirectToAction("Index");
}
}
RoleController
public class RoleController : BaseController
{
private readonly RoleRepository _roleRepository;
public RoleController(string connectionString) : base(connectionString)
{
_roleRepository = new RoleRepository(connectionString);
}
public IActionResult Index()
{
var roles = _roleRepository.GetAll();
return View(roles);
}
public IActionResult Details(int id)
{
var role = _roleRepository.GetById(id);
return View(role);
}
public IActionResult Create()
{
return View();
}
[HttpPost]
public IActionResult Create(Role role)
{
if (ModelState.IsValid)
{
_roleRepository.Add(role);
return RedirectToAction("Index");
}
return View(role);
}
public IActionResult Edit(int id)
{
var role = _roleRepository.GetById(id);
return View(role);
}
[HttpPost]
public IActionResult Edit(Role role)
{
if (ModelState.IsValid)
{
_roleRepository.Update(role);
return RedirectToAction("Index");
}
return View(role);
}
public IActionResult Delete(int id)
{
var role = _roleRepository.GetById(id);
return View(role);
}
[HttpPost, ActionName("Delete")]
public IActionResult DeleteConfirmed(int id)
{
_roleRepository.Delete(id);
return RedirectToAction("Index");
}
}
CourseController
public class CourseController : BaseController
{
private readonly CourseRepository _courseRepository;
public CourseController(string connectionString) : base(connectionString)
{
_courseRepository = new CourseRepository(connectionString);
}
public IActionResult Index()
{
var courses = _courseRepository.GetAll();
return View(courses);
}
public IActionResult Details(int id)
{
var course = _courseRepository.GetById(id);
return View(course);
}
public IActionResult Create()
{
return View();
}
[HttpPost]
public IActionResult Create(Course course)
{
if (ModelState.IsValid)
{
_courseRepository.Add(course);
return RedirectToAction("Index");
}
return View(course);
}
public IActionResult Edit(int id)
{
var course = _courseRepository.GetById(id);
return View(course);
}
[HttpPost]
public IActionResult Edit(Course course)
{
if (ModelState.IsValid)
{
_courseRepository.Update(course);
return RedirectToAction("Index");
}
return View(course);
}
public IActionResult Delete(int id)
{
var course = _courseRepository.GetById(id);
return View(course);
}
[HttpPost, ActionName("Delete")]
public IActionResult DeleteConfirmed(int id)
{
_courseRepository.Delete(id);
return RedirectToAction("Index");
}
}
SyllabusController
public class SyllabusController : BaseController
{
private readonly SyllabusRepository _syllabusRepository;
public SyllabusController(string connectionString) : base(connectionString)
{
_syllabusRepository = new SyllabusRepository(connectionString);
}
public IActionResult Index()
{
var syllabuses = _syllabusRepository.GetAll();
return View(syllabuses);
}
public IActionResult Details(int id)
{
var syllabus = _syllabusRepository.GetById(id);
return View(syllabus);
}
public IActionResult Create()
{
return View();
}
[HttpPost]
public IActionResult Create(Syllabus syllabus)
{
if (ModelState.IsValid)
{
_syllabusRepository.Add(syllabus);
return RedirectToAction("Index");
}
return View(syllabus );
}
public IActionResult Edit(int id)
{
var syllabus = _syllabusRepository.GetById(id);
return View(syllabus);
}
[HttpPost]
public IActionResult Edit(Syllabus syllabus)
{
if (ModelState.IsValid)
{
_syllabusRepository.Update(syllabus);
return RedirectToAction("Index");
}
return View(syllabus);
}
public IActionResult Delete(int id)
{
var syllabus = _syllabusRepository.GetById(id);
return View(syllabus);
}
[HttpPost, ActionName("Delete")]
public IActionResult DeleteConfirmed(int id)
{
_syllabusRepository.Delete(id);
return RedirectToAction("Index");
}
}
LiveClassController
public class LiveClassController : BaseController
{
private readonly LiveClassRepository _liveClassRepository;
public LiveClassController(string connectionString) : base(connectionString)
{
_liveClassRepository = new LiveClassRepository(connectionString);
}
public IActionResult Index()
{
var liveClasses = _liveClassRepository.GetAll();
return View(liveClasses);
}
public IActionResult Details(int id)
{
var liveClass = _liveClassRepository.GetById(id);
return View(liveClass);
}
public IActionResult Create()
{
return View();
}
[HttpPost]
public IActionResult Create(LiveClass liveClass)
{
if (ModelState.IsValid)
{
_liveClassRepository.Add(liveClass);
return RedirectToAction("Index");
}
return View(liveClass);
}
public IActionResult Edit(int id)
{
var liveClass = _liveClassRepository.GetById(id);
return View(liveClass);
}
[HttpPost]
public IActionResult Edit(LiveClass liveClass)
{
if (ModelState.IsValid)
{
_liveClassRepository.Update(liveClass);
return RedirectToAction("Index");
}
return View(liveClass);
}
public IActionResult Delete(int id)
{
var liveClass = _liveClassRepository.GetById(id);
return View(liveClass);
}
[HttpPost, ActionName("Delete")]
public IActionResult DeleteConfirmed(int id)
{
_liveClassRepository.Delete(id);
return RedirectToAction("Index");
}
}
ResourceController
public class ResourceController : BaseController
{
private readonly ResourceRepository _resourceRepository;
public ResourceController(string connectionString) : base(connectionString)
{
_resourceRepository = new ResourceRepository(connectionString);
}
public IActionResult Index()
{
var resources = _resourceRepository.GetAll();
return View(resources);
}
public IActionResult Details(int id)
{
var resource = _resourceRepository.GetById(id);
return View(resource);
}
public IActionResult Create()
{
return View();
}
[HttpPost]
public IActionResult Create(Resource resource)
{
if (ModelState.IsValid)
{
_resourceRepository.Add(resource);
return RedirectToAction("Index");
}
return View(resource);
}
public IActionResult Edit(int id)
{
var resource = _resourceRepository.GetById(id);
return View(resource);
}
[HttpPost]
public IActionResult Edit(Resource resource)
{
if (ModelState.IsValid)
{
_resourceRepository.Update(resource);
return RedirectToAction("Index");
}
return View(resource);
}
public IActionResult Delete(int id)
{
var resource = _resourceRepository.GetById(id);
return View(resource);
}
[HttpPost, ActionName("Delete")]
public IActionResult DeleteConfirmed(int id)
{
_resourceRepository.Delete(id);
return RedirectToAction("Index");
}
}
QuizController
public class QuizController : BaseController
{
private readonly QuizRepository _quizRepository;
public QuizController(string connectionString) : base(connectionString)
{
_quizRepository = new QuizRepository(connectionString);
}
public IActionResult Index()
{
var quizzes = _quizRepository.GetAll();
return View(quizzes);
}
public IActionResult Details(int id)
{
var quiz = _quizRepository.GetById(id);
return View(quiz);
}
public IActionResult Create()
{
return View();
}
[HttpPost]
public IActionResult Create(Quiz quiz)
{
if (ModelState.IsValid)
{
_quizRepository.Add(quiz);
return RedirectToAction("Index");
}
return View(quiz);
}
public IActionResult Edit (int id)
{
var quiz = _quizRepository.GetById(id);
return View(quiz);
}
[HttpPost]
public IActionResult Edit(Quiz quiz)
{
if (ModelState.IsValid)
{
_quizRepository.Update(quiz);
return RedirectToAction("Index");
}
return View(quiz);
}
public IActionResult Delete(int id)
{
var quiz = _quizRepository.GetById(id);
return View(quiz);
}
[HttpPost, ActionName("Delete")]
public IActionResult DeleteConfirmed(int id)
{
_quizRepository.Delete(id);
return RedirectToAction("Index");
}
}
GradeController
public class GradeController : BaseController
{
private readonly GradeRepository _gradeRepository;
public GradeController(string connectionString) : base(connectionString)
{
_gradeRepository = new GradeRepository(connectionString);
}
public IActionResult Index()
{
var grades = _gradeRepository.GetAll();
return View(grades);
}
public IActionResult Details(int id)
{
var grade = _gradeRepository.GetById(id);
return View(grade);
}
public IActionResult Create()
{
return View();
}
[HttpPost]
public IActionResult Create(Grade grade)
{
if (ModelState.IsValid)
{
_gradeRepository.Add(grade);
return RedirectToAction("Index");
}
return View(grade);
}
public IActionResult Edit(int id)
{
var grade = _gradeRepository.GetById(id);
return View(grade);
}
[HttpPost]
public IActionResult Edit(Grade grade)
{
if (ModelState.IsValid)
{
_gradeRepository.Update(grade);
return RedirectToAction("Index");
}
return View(grade);
}
public IActionResult Delete(int id)
{
var grade = _gradeRepository.GetById(id);
return View(grade);
}
[HttpPost, ActionName("Delete")]
public IActionResult DeleteConfirmed(int id)
{
_gradeRepository.Delete(id);
return RedirectToAction("Index");
}
}
NotificationController
public class NotificationController : BaseController
{
private readonly NotificationRepository _notificationRepository;
public NotificationController(string connectionString) : base(connectionString)
{
_notificationRepository = new NotificationRepository(connectionString);
}
public IActionResult Index()
{
var notifications = _notificationRepository.GetAll();
return View(notifications);
}
public IActionResult Details(int id)
{
var notification = _notificationRepository.GetById(id);
return View(notification);
}
public IActionResult Create()
{
return View();
}
[HttpPost]
public IActionResult Create(Notification notification)
{
if (ModelState.IsValid)
{
_notificationRepository.Add(notification);
return RedirectToAction("Index");
}
return View(notification);
}
public IActionResult Edit(int id)
{
var notification = _notificationRepository.GetById(id);
return View(notification);
}
[HttpPost]
public IActionResult Edit(Notification notification)
{
if (ModelState.IsValid)
{
_notificationRepository.Update(notification);
return RedirectToAction("Index");
}
return View(notification);
}
public IActionResult Delete(int id)
{
var notification = _notificationRepository.GetById(id);
return View(notification);
}
[HttpPost, ActionName("Delete")]
public IActionResult DeleteConfirmed(int id)
{
_notificationRepository.Delete(id);
return RedirectToAction("Index");
}
}
PaymentController
public class PaymentController : BaseController
{
private readonly PaymentRepository _paymentRepository;
public PaymentController(string connectionString) : base(connectionString)
{
_paymentRepository = new PaymentRepository(connectionString);
}
public IActionResult Index()
{
var payments = _paymentRepository.GetAll();
return View(payments);
}
public IActionResult Details(int id)
{
var payment = _paymentRepository.GetById(id);
return View(payment);
}
public IActionResult Create()
{
return View();
}
[HttpPost]
public IActionResult Create(Payment payment)
{
if (ModelState.IsValid)
{
_paymentRepository.Add(payment);
return RedirectToAction("Index");
}
return View(payment);
}
public IActionResult Edit(int id)
{
var payment = _paymentRepository.GetById(id);
return View(payment);
}
[HttpPost]
public IActionResult Edit(Payment payment)
{
if (ModelState.IsValid)
{
_paymentRepository.Update(payment);
return RedirectToAction("Index");
}
return View(payment);
}
public IActionResult Delete(int id)
{
var payment = _paymentRepository.GetById(id);
return View(payment);
}
[HttpPost, ActionName("Delete")]
public IActionResult DeleteConfirmed(int id)
{
_paymentRepository.Delete(id);
return RedirectToAction("Index");
}
}
FeedbackController
public class FeedbackController : BaseController
{
private readonly FeedbackRepository _feedbackRepository;
public FeedbackController(string connectionString) : base(connectionString)
{
_feedbackRepository = new FeedbackRepository(connectionString);
}
public IActionResult Index()
{
var feedbacks = _feedbackRepository.GetAll();
return View(feedbacks);
}
public IActionResult Details(int id)
{
var feedback = _feedbackRepository.GetById(id);
return View(feedback);
}
public IActionResult Create()
{
return View();
}
[HttpPost]
public IActionResult Create(Feedback feedback)
{
if (ModelState.IsValid)
{
_feedbackRepository.Add(feedback);
return RedirectToAction("Index");
}
return View(feedback);
}
public IActionResult Edit(int id)
{
var feedback = _feedbackRepository.GetById(id);
return View(feedback);
}
[HttpPost]
public IActionResult Edit(Feedback feedback)
{
if (ModelState.IsValid)
{
_feedbackRepository.Update(feedback);
return RedirectToAction("Index");
}
return View(feedback);
}
public IActionResult Delete(int id)
{
var feedback = _feedbackRepository.GetById(id);
return View(feedback);
}
[HttpPost, ActionName("Delete")]
public IActionResult DeleteConfirmed(int id)
{
_feedbackRepository.Delete(id);
return RedirectToAction("Index");
}
}
This completes the controller implementations for all the repositories defined in your application. Each controller follows the standard CRUD operations, allowing for the management of the respective entities through 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: User, Role, Course, Syllabus, LiveClass, Resource, Quiz, Grade, Notification, Payment, and Feedback.
Directory Structure
Assuming you have a standard ASP.NET MVC project structure, the views for each controller will be placed in their respective folders under the Views directory. For example, the views for the User Controller will be in Views/User/.
User Views
Index.cshtml
@model IEnumerable<YourNamespace.Models.User>
<h2>Users</h2>
<a href='@Url.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 href='@Url.Action("Details", new { id = user.UserId })">Details</a> |
<a href='@Url.Action("Edit", new { id = user.UserId })'>Edit</a> |
<a href='@Url.Action("Delete", new { id = user.UserId })'>Delete</a>
</td>
</tr>
}
</tbody>
</table>
Create.cshtml
@model YourNamespace.Models.User
<h2>Create User</h2>
@using (Html.BeginForm())
{
@Html.AntiForgeryToken()
<div>
@Html.LabelFor(m => m.Username)
@Html.TextBoxFor(m => m.Username)
</div>
<div>
@Html.LabelFor(m => m.PasswordHash)
@Html.PasswordFor(m => m.PasswordHash)
</div>
<div>
@Html.LabelFor(m => m.Email)
@Html.TextBoxFor(m => m.Email)
</div>
<div>
@Html.LabelFor(m => m.FirstName)
@Html.TextBoxFor(m => m.FirstName)
</div>
<div>
@Html.LabelFor(m => m.LastName)
@Html.TextBoxFor(m => m.LastName)
</div>
<div>
@Html.LabelFor(m => m.RoleId)
@Html.TextBoxFor(m => m.RoleId)
</div>
<button type="submit">Create</button>
}
Edit.cshtml
@model YourNamespace.Models.User
<h2>Edit User</h2>
@using (Html.BeginForm())
{
@Html.AntiForgeryToken()
@Html.HiddenFor(m => m.UserId)
<div>
@Html.LabelFor(m => m.Username)
@Html.TextBoxFor(m => m.Username)
</div>
<div>
@Html.LabelFor(m => m.Email)
@Html.TextBoxFor(m => m.Email)
</div>
<div>
@Html.LabelFor(m => m.FirstName)
@Html.TextBoxFor(m => m.FirstName)
</div>
<div>
@Html.LabelFor(m => m.LastName)
@Html.TextBoxFor(m => m.LastName)
</div>
<div>
@Html.LabelFor(m => m.RoleId)
@Html.TextBoxFor(m => m.RoleId)
</div>
<button type="submit">Save</button>
}
Details.cshtml
@model YourNamespace.Models.User
<h2>User Details</h2>
<div>
<h4>@Model.Username</h4>
<p>Email: @Model.Email</p>
<p>First Name: @Model.FirstName</p>
<p>Last Name: @Model.LastName</p>
<p>Role ID: @Model.RoleId</p>
</div>
<a href='@Url.Action("Edit", new { id = Model.UserId })'>Edit</a> |
<a href='@Url.Action("Index")">Back to List</a>
Delete.cshtml
@model YourNamespace.Models.User
<h2>Delete User</h2>
<div>
<h4>Are you sure you want to delete this user?</h4>
<p>@Model.Username</p>
</div>
@using (Html.BeginForm())
{
@Html.AntiForgeryToken()
@Html.HiddenFor(m => m.UserId)
<button type="submit">Delete</button>
<a href='@Url.Action("Index")'>Cancel</a>
}
Role Views
Index.cshtml
@model IEnumerable<YourNamespace.Models.Role>
<h2>Roles</h2>
<a href='@Url.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 href='@Url.Action("Details", new { id = role.RoleId })">Details</a> |
<a href='@Url.Action("Edit", new { id = role.RoleId })'>Edit</a> |
<a href='@Url.Action("Delete", new { id = role.RoleId })'>Delete</a>
</td>
</tr>
}
</tbody>
</table>
Create.cshtml
@model YourNamespace.Models.Role
<h2>Create Role</h2>
@using (Html.BeginForm())
{
@Html.AntiForgeryToken()
<div>
@Html.LabelFor(m => m.RoleName)
@Html.TextBoxFor(m => m.RoleName)
</div>
<button type="submit">Create</button>
}
Edit.cshtml
@model YourNamespace.Models.Role
<h2>Edit Role</h2>
@using (Html.BeginForm())
{
@Html.AntiForgeryToken()
@Html.HiddenFor(m => m.RoleId)
<div>
@Html.LabelFor(m => m.RoleName)
@Html.TextBoxFor(m => m.RoleName)
</div>
<button type="submit">Save</button>
}
Details.cshtml
@model YourNamespace.Models.Role
<h2>Role Details</h2>
<div>
<h4>@Model.RoleName</h4>
</div>
<a href='@Url.Action("Edit", new { id = Model.RoleId })'>Edit</a> |
<a href='@Url.Action("Index")">Back to List</a>
Delete.cshtml
@model YourNamespace.Models.Role
<h2>Delete Role</h2>
<div>
<h4>Are you sure you want to delete this role?</h4>
<p>@Model.RoleName</p>
</div>
@using (Html.BeginForm())
{
@Html.AntiForgeryToken()
@Html.HiddenFor(m => m.RoleId)
<button type="submit">Delete</button>
<a href='@Url.Action("Index")'>Cancel</a>
}
Course Views
Index.cshtml
@model IEnumerable<YourNamespace.Models.Course>
<h2>Courses</h2>
<a href='@Url.Action("Create")'>Create New Course</a>
<table>
<thead>
<tr>
<th>Course Name</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
@foreach (var course in Model)
{
<tr>
<td>@course.CourseName</td>
<td>
<a href='@Url.Action("Details", new { id = course.CourseId })">Details</a> |
<a href='@Url.Action("Edit", new { id = course.CourseId })'>Edit</a> |
<a href='@Url.Action("Delete", new { id = course.CourseId })'>Delete</a>
</td>
</tr>
}
</tbody>
</table>
Create.cshtml
@model YourNamespace.Models.Course
<h2>Create Course</h2>
@using (Html.BeginForm())
{
@Html.AntiForgeryToken()
<div>
@Html.LabelFor(m => m.CourseName)
@Html.TextBoxFor(m => m.CourseName)
</div>
<button type="submit">Create</button>
}
Edit.cshtml
@model YourNamespace.Models.Course
<h2>Edit Course</h2>
@using (Html.BeginForm())
{
@Html.AntiForgeryToken()
@Html.HiddenFor(m => m.CourseId)
<div>
@Html.LabelFor(m => m.CourseName)
@Html.TextBoxFor(m => m.CourseName)
</div>
<button type="submit">Save</button>
}
Details.cshtml
@model YourNamespace.Models.Course
<h2>Course Details</h2>
<div>
<h4>@Model.CourseName</h4>
</div>
<a href='@Url.Action("Edit", new { id = Model.CourseId })'>Edit</a> |
<a href='@Url.Action("Index")">Back to List</a>
Delete.cshtml
@model YourNamespace.Models.Course
<h2>Delete Course</h2>
<div>
<h4>Are you sure you want to delete this course?</h4>
<p>@Model.CourseName</p>
</div>
@using (Html.BeginForm())
{
@Html.AntiForgeryToken()
@Html.HiddenFor(m => m.CourseId)
<button type="submit">Delete</button>
<a href='@Url.Action("Index")'>Cancel</a>
}
Syllabus Views
Index.cshtml
@model IEnumerable<YourNamespace.Models.Syllabus>
<h2>Syllabuses</h2>
<a href='@Url.Action("Create")'>Create New Syllabus</a>
<table>
<thead>
<tr>
<th>Syllabus Title</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
@foreach (var syllabus in Model)
{
<tr>
<td>@syllabus.Title</td>
<td>
<a href='@Url.Action("Details", new { id = syllabus.SyllabusId })">Details</a> |
<a href='@Url.Action("Edit", new { id = syllabus.SyllabusId })'>Edit</a> |
<a href='@Url.Action("Delete", new { id = syllabus.SyllabusId })'>Delete</a>
</td>
</tr>
}
</tbody>
</table>
Create.cshtml
@model YourNamespace.Models.Syllabus
<h2>Create Syllabus</h2>
@using (Html.BeginForm())
{
@Html.AntiForgeryToken()
<div>
@Html.LabelFor(m => m.Title)
@Html.TextBoxFor(m => m.Title)
</div>
<div>
@Html.LabelFor(m => m.Description)
@Html.TextAreaFor(m => m.Description)
</div>
<button type="submit">Create</button>
}
Edit.cshtml
@model YourNamespace.Models.Syllabus
<h2>Edit Syllabus</h2>
@using (Html.BeginForm())
{
@Html.AntiForgeryToken()
@Html.HiddenFor(m => m.SyllabusId)
<div>
@Html.LabelFor(m => m.Title)
@Html.TextBoxFor(m => m.Title)
</div>
<div>
@Html.LabelFor(m => m.Description)
@Html.TextAreaFor(m => m.Description)
</div>
<button type="submit">Save</button>
}
Details.cshtml
@model YourNamespace.Models.Syllabus
<h2>Syllabus Details</h2>
<div>
<h4>@Model.Title</h4>
<p>@Model.Description</p>
</div>
<a href='@Url.Action("Edit", new { id = Model.SyllabusId })'>Edit</a> |
<a href='@Url.Action("Index")">Back to List</a>
Delete.cshtml
@model YourNamespace.Models.Syllabus
<h2>Delete Syllabus</h2>
<div>
<h4>Are you sure you want to delete this syllabus?</h4>
<p>@Model.Title</p>
</div>
@using (Html.BeginForm())
{
@Html.AntiForgeryToken()
@Html.HiddenFor(m => m.SyllabusId)
<button type="submit">Delete</button>
<a href='@Url.Action("Index")'>Cancel</a>
}
LiveClass Views
Index.cshtml
@model IEnumerable<YourNamespace.Models.LiveClass>
<h2>Live Classes</h2>
<a href='@Url.Action("Create")'>Create New Live Class</a>
<table>
<thead>
<tr>
<th>Class Title</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
@foreach (var liveClass in Model)
{
<tr>
<td>@liveClass.Title</td>
<td>
<a href='@Url.Action("Details", new { id = liveClass.LiveClassId })">Details</a> |
<a href='@Url.Action("Edit", new { id = liveClass.LiveClassId })'>Edit</a> |
<a href='@Url.Action("Delete", new { id = liveClass.LiveClassId })'>Delete</a>
</td>
</tr>
}
</tbody>
</table>
Create.cshtml
@model YourNamespace.Models.LiveClass
<h2>Create Live Class</h2>
@using (Html.BeginForm())
{
@Html.AntiForgeryToken()
<div>
@Html.LabelFor(m => m.Title)
@Html.TextBoxFor(m => m.Title)
</div>
<div>
@Html.LabelFor(m => m.StartTime)
@Html.TextBoxFor(m => m.StartTime, "{0:yyyy-MM-ddTHH:mm}")
</div>
<div>
@Html.LabelFor(m => m.EndTime)
@Html.TextBoxFor(m => m.EndTime, "{0:yyyy-MM-ddTHH:mm}")
</div>
<button type="submit">Create</button>
}
Edit.cshtml
@model YourNamespace.Models.LiveClass
<h2>Edit Live Class</h2>
@using (Html.BeginForm())
{
@Html.AntiForgeryToken()
@Html.HiddenFor(m => m.LiveClassId)
<div>
@Html.LabelFor(m => m.Title)
@Html.TextBoxFor(m => m.Title)
</div>
<div>
@Html.LabelFor(m => m.StartTime)
@Html.TextBoxFor(m => m .StartTime, "{0:yyyy-MM-ddTHH:mm}")
</div>
<div>
@Html.LabelFor(m => m.EndTime)
@Html.TextBoxFor(m => m.EndTime, "{0:yyyy-MM-ddTHH:mm}")
</div>
<button type="submit">Save</button>
}
Details.cshtml
@model YourNamespace.Models.LiveClass
<h2>Live Class Details</h2>
<div>
<h4>@Model.Title</h4>
<p>Start Time: @Model.StartTime</p>
<p>End Time: @Model.EndTime</p>
</div>
<a href='@Url.Action("Edit", new { id = Model.LiveClassId })'>Edit</a> |
<a href='@Url.Action("Index")">Back to List</a>
Delete.cshtml
@model YourNamespace.Models.LiveClass
<h2>Delete Live Class</h2>
<div>
<h4>Are you sure you want to delete this live class?</h4>
<p>@Model.Title</p>
</div>
@using (Html.BeginForm())
{
@Html.AntiForgeryToken()
@Html.HiddenFor(m => m.LiveClassId)
<button type="submit">Delete</button>
<a href='@Url.Action("Index")'>Cancel</a>
}
Resource Views
Index.cshtml
@model IEnumerable<YourNamespace.Models.Resource>
<h2>Resources</h2>
<a href='@Url.Action("Create")'>Create New Resource</a>
<table>
<thead>
<tr>
<th>Resource Title</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
@foreach (var resource in Model)
{
<tr>
<td>@resource.Title</td>
<td>
<a href='@Url.Action("Details", new { id = resource.ResourceId })">Details</a> |
<a href='@Url.Action("Edit", new { id = resource.ResourceId })'>Edit</a> |
<a href='@Url.Action("Delete", new { id = resource.ResourceId })'>Delete</a>
</td>
</tr>
}
</tbody>
</table>
Create.cshtml
@model YourNamespace.Models.Resource
<h2>Create Resource</h2>
@using (Html.BeginForm())
{
@Html.AntiForgeryToken()
<div>
@Html.LabelFor(m => m.Title)
@Html.TextBoxFor(m => m.Title)
</div>
<div>
@Html.LabelFor(m => m.Content)
@Html.TextAreaFor(m => m.Content)
</div>
<button type="submit">Create</button>
}
Edit.cshtml
@model YourNamespace.Models.Resource
<h2>Edit Resource</h2>
@using (Html.BeginForm())
{
@Html.AntiForgeryToken()
@Html.HiddenFor(m => m.ResourceId)
<div>
@Html.LabelFor(m => m.Title)
@Html.TextBoxFor(m => m.Title)
</div>
<div>
@Html.LabelFor(m => m.Content)
@Html.TextAreaFor(m => m.Content)
</div>
<button type="submit">Save</button>
}
Details.cshtml
@model YourNamespace.Models.Resource
<h2>Resource Details</h2>
<div>
<h4>@Model.Title</h4>
<p>@Model.Content</p>
</div>
<a href='@Url.Action("Edit", new { id = Model.ResourceId })'>Edit</a> |
<a href='@Url.Action("Index")">Back to List</a>
Delete.cshtml
@model YourNamespace.Models.Resource
<h2>Delete Resource</h2>
<div>
<h4>Are you sure you want to delete this resource?</h4>
<p>@Model.Title</p>
</div>
@using (Html.BeginForm())
{
@Html.AntiForgeryToken()
@Html.HiddenFor(m => m.ResourceId)
<button type="submit">Delete</button>
<a href='@Url.Action("Index")'>Cancel</a>
}
Quiz Views
Index.cshtml
@model IEnumerable<YourNamespace.Models.Quiz>
<h2>Quizzes</h2>
<a href='@Url.Action("Create")'>Create New Quiz</a>
<table>
<thead>
<tr>
<th>Quiz Title</th>
<th>Actions</th>
</tr .StartTime, "{0:yyyy-MM-ddTHH:mm}")
</div>
<div>
@Html.LabelFor(m => m.EndTime)
@Html.TextBoxFor(m => m.EndTime, "{0:yyyy-MM-ddTHH:mm}")
</div>
<button type="submit">Save</button>
}
Details.cshtml
@model YourNamespace.Models.LiveClass
<h2>Live Class Details</h2>
<div>
<h4>@Model.Title</h4>
<p>Start Time: @Model.StartTime</p>
<p>End Time: @Model.EndTime</p>
</div>
<a href='@Url.Action("Edit", new { id = Model.LiveClassId })'>Edit</a> |
<a href='@Url.Action("Index")">Back to List</a>
Delete.cshtml
@model YourNamespace.Models.LiveClass
<h2>Delete Live Class</h2>
<div>
<h4>Are you sure you want to delete this live class?</h4>
<p>@Model.Title</p>
</div>
@using (Html.BeginForm())
{
@Html.AntiForgeryToken()
@Html.HiddenFor(m => m.LiveClassId)
<button type="submit">Delete</button>
<a href='@Url.Action("Index")'>Cancel</a>
}
Grade Views
Index.cshtml
@model IEnumerable<YourNamespace.Models.Grade>
<h2>Grades</h2>
<a href='@Url.Action("Create")'>Create New Grade</a>
<table>
<thead>
<tr>
<th>Grade Name</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
@foreach (var grade in Model)
{
<tr>
<td>@grade.Name</td>
<td>
<a href='@Url.Action("Details", new { id = grade.GradeId })">Details</a> |
<a href='@Url.Action("Edit", new { id = grade.GradeId })'>Edit</a> |
<a href='@Url.Action("Delete", new { id = grade.GradeId })'>Delete</a>
</td>
</tr>
}
</tbody>
</table>
Create.cshtml
@model YourNamespace.Models.Grade
<h2>Create Grade</h2>
@using (Html.BeginForm())
{
@Html.AntiForgeryToken()
<div>
@Html.LabelFor(m => m.Name)
@Html.TextBoxFor(m => m.Name)
</div>
<button type="submit">Create</button>
}
Edit.cshtml
@model YourNamespace.Models.Grade
<h2>Edit Grade</h2>
@using (Html.BeginForm())
{
@Html.AntiForgeryToken()
@Html.HiddenFor(m => m.GradeId)
<div>
@Html.LabelFor(m => m.Name)
@Html.TextBoxFor(m => m.Name)
</div>
<button type="submit">Save</button>
}
Details.cshtml
@model YourNamespace.Models.Grade
<h2>Grade Details</h2>
<div>
<h4>@Model.Name</h4>
</div>
<a href='@Url.Action("Edit", new { id = Model.Grade Id })'>Edit</a> |
<a href='@Url.Action("Index")">Back to List</a>
Delete.cshtml
@model YourNamespace.Models.Grade
<h2>Delete Grade</h2>
<div>
<h4>Are you sure you want to delete this grade?</h4>
<p>@Model.Name</p>
</div>
@using (Html.BeginForm())
{
@Html.AntiForgeryToken()
@Html.HiddenFor(m => m.GradeId)
<button type="submit">Delete</button>
<a href='@Url.Action("Index")'>Cancel</a>
}
Notification Views
Index.cshtml
@model IEnumerable<YourNamespace.Models.Notification>
<h2>Notifications</h2>
<a href='@Url.Action("Create")'>Create New Notification</a>
<table>
<thead>
<tr>
<th>Notification Title</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
@foreach (var notification in Model)
{
<tr>
<td>@notification.Title</td>
<td>
<a href='@Url.Action("Details", new { id = notification.NotificationId })">Details</a> |
<a href='@Url.Action("Edit", new { id = notification.NotificationId })'>Edit</a> |
<a href='@Url.Action("Delete", new { id = notification.NotificationId })'>Delete</a>
</td>
</tr>
}
</tbody>
</table>
Create.cshtml
@model YourNamespace.Models.Notification
<h2>Create Notification</h2>
@using (Html.BeginForm())
{
@Html.AntiForgeryToken()
<div>
@Html.LabelFor(m => m.Title)
@Html.TextBoxFor(m => m.Title)
</div>
<div>
@Html.LabelFor(m => m.Message)
@Html.TextAreaFor(m => m.Message)
</div>
<button type="submit">Create</button>
}
Edit.cshtml
@model YourNamespace.Models.Notification
<h2>Edit Notification</h2>
@using (Html.BeginForm())
{
@Html.AntiForgeryToken()
@Html.HiddenFor(m => m.NotificationId)
<div>
@Html.LabelFor(m => m.Title)
@Html.TextBoxFor(m => m.Title)
</div>
<div>
@Html.LabelFor(m => m.Message)
@Html.TextAreaFor(m => m.Message)
</div>
<button type="submit">Save</button>
}
Details.cshtml
@model YourNamespace.Models.Notification
<h2>Notification Details</h2>
<div>
<h4>@Model.Title</h4>
<p>@Model.Message</p>
</div>
<a href='@Url.Action("Edit", new { id = Model.NotificationId })'>Edit</a> |
<a href='@Url.Action("Index")">Back to List</a>
Delete.cshtml
@model YourNamespace.Models.Notification
<h2>Delete Notification</h2>
<div>
<h4>Are you sure you want to delete this notification?</h4>
<p>@Model.Title</p>
</div>
@using (Html.BeginForm())
{
@Html.AntiForgeryToken()
@Html.HiddenFor(m => m.NotificationId)
<button type="submit">Delete</button>
<a href='@Url.Action("Index")'>Cancel</a>
}
Payment Views
Index.cshtml
@model IEnumerable<YourNamespace.Models.Payment>
<h2>Payments</h2>
<a href='@Url.Action("Create")'>Create New Payment</a>
<table>
<thead>
<tr>
<th>Payment Amount</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
@foreach (var payment in Model)
{
<tr>
<td>@payment.Amount</td>
<td>
<a href='@Url.Action("Details", new { id = payment.PaymentId })">Details</a> |
<a href='@Url.Action("Edit", new { id = payment.PaymentId })'>Edit</a> |
<a href='@Url.Action("Delete", new { id = payment.PaymentId })'>Delete</a>
</td>
</tr>
}
</tbody>
</table>
Create.cshtml
@model YourNamespace.Models.Payment
<h2>Create Payment</h2>
@using (Html.BeginForm())
{
@Html .AntiForgeryToken()
<div>
@Html.LabelFor(m => m.Amount)
@Html.TextBoxFor(m => m.Amount)
</div>
<div>
@Html.LabelFor(m => m.PaymentDate)
@Html.TextBoxFor(m => m.PaymentDate, "{0:yyyy-MM-ddTHH:mm}")
</div>
<button type="submit">Create</button>
}
Edit.cshtml
@model YourNamespace.Models.Payment
<h2>Edit Payment</h2>
@using (Html.BeginForm())
{
@Html.AntiForgeryToken()
@Html.HiddenFor(m => m.PaymentId)
<div>
@Html.LabelFor(m => m.Amount)
@Html.TextBoxFor(m => m.Amount)
</div>
<div>
@Html.LabelFor(m => m.PaymentDate)
@Html.TextBoxFor(m => m.PaymentDate, "{0:yyyy-MM-ddTHH:mm}")
</div>
<button type="submit">Save</button>
}
Details.cshtml
@model YourNamespace.Models.Payment
<h2>Payment Details</h2>
<div>
<h4>Amount: @Model.Amount</h4>
<p>Payment Date: @Model.PaymentDate</p>
</div>
<a href='@Url.Action("Edit", new { id = Model.PaymentId })'>Edit</a> |
<a href='@Url.Action("Index")">Back to List</a>
Delete.cshtml
@model YourNamespace.Models.Payment
<h2>Delete Payment</h2>
<div>
<h4>Are you sure you want to delete this payment?</h4>
<p>Amount: @Model.Amount</p>
</div>
@using (Html.BeginForm())
{
@Html.AntiForgeryToken()
@Html.HiddenFor(m => m.PaymentId)
<button type="submit">Delete</button>
<a href='@Url.Action("Index")'>Cancel</a>
}
Feedback Views
Index.cshtml
@model IEnumerable<YourNamespace.Models.Feedback>
<h2>Feedbacks</h2>
<a href='@Url.Action("Create")'>Create New Feedback</a>
<table>
<thead>
<tr>
<th>Feedback Title</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
@foreach (var feedback in Model)
{
<tr>
<td>@feedback.Title</td>
<td>
<a href='@Url.Action("Details", new { id = feedback.FeedbackId })">Details</a> |
<a href='@Url.Action("Edit", new { id = feedback.FeedbackId })'>Edit</a> |
<a href='@Url.Action("Delete", new { id = feedback.FeedbackId })'>Delete</a>
</td>
</tr>
}
</tbody>
</table>
Create.cshtml
@model YourNamespace.Models.Feedback
<h2>Create Feedback</h2>
@using (Html.BeginForm())
{
@Html.AntiForgeryToken()
<div>
@Html.LabelFor(m => m.Title)
@Html.TextBoxFor(m => m.Title)
</div>
<div>
@Html.LabelFor(m => m.Content)
@Html.TextAreaFor(m => m.Content)
</div>
<button type="submit">Create</button>
}
Edit.cshtml
@model YourNamespace.Models.Feedback
<h2>Edit Feedback</h2>
@using (Html.BeginForm())
{
@Html.AntiForgeryToken()
@Html.HiddenFor(m => m.FeedbackId)
<div>
@Html.LabelFor(m => m.Title)
@Html.TextBoxFor(m => m.Title)
</div>
<div>
@Html.LabelFor(m => m.Content)
@Html.TextAreaFor(m => m.Content)
</div>
<button type="submit">Save</button>
}
Details.cshtml
@model YourNamespace.Models.Feedback
<h2>Feedback Details</h2>
<div>
<h4>@Model.Title</h4>
<p>@Model.Content</p>
</div>
<a href='@Url.Action("Edit", new { id = Model.FeedbackId })'>Edit</a> |
<a href='@Url.Action("Index")">Back to List</a>
Delete.cshtml
@model YourNamespace.Models.Feedback
<h2>Delete Feedback</h2>
<div>
<h4>Are you sure you want to delete this feedback?</h4>
<h4>@Model.Title</h4>
</div>
@using (Html.BeginForm())
{
@Html.AntiForgeryToken()
@Html.HiddenFor(m => m.FeedbackId)
<button type="submit">Delete</button>
<a href='@Url.Action("Index")'>Cancel</a>
}
This completes the view implementations for all the controllers defined in your application. Each view follows the standard CRUD operations, allowing for the management of the respective entities through user-friendly interfaces.
Creating a dashboard page in an ASP.NET MVC application
Involves aggregating data from various models and presenting it in a user-friendly format. Below, I will outline how to create a dashboard view that displays consolidated data related to your project, such as the number of users, roles, courses, live classes, resources, quizzes, grades, notifications, payments, and feedback.
Step 1: Create a Dashboard ViewModel
First, we need to create a ViewModel that will hold the consolidated data for the dashboard.
public class DashboardViewModel
{
public int UserCount { get; set; }
public int RoleCount { get; set; }
public int CourseCount { get; set; }
public int LiveClassCount { get; set; }
public int ResourceCount { get; set; }
public int QuizCount { get; set; }
public int GradeCount { get; set; }
public int NotificationCount { get; set; }
public int PaymentCount { get; set; }
public int FeedbackCount { get; set; }
}
Step 2: Create a Dashboard Controller
Next, we will create a DashboardController that will fetch the data from the repositories and pass it to the view.
public class DashboardController : BaseController
{
private readonly UserRepository _userRepository;
private readonly RoleRepository _roleRepository;
private readonly CourseRepository _courseRepository;
private readonly LiveClassRepository _liveClassRepository;
private readonly ResourceRepository _resourceRepository;
private readonly QuizRepository _quizRepository;
private readonly GradeRepository _gradeRepository;
private readonly NotificationRepository _notificationRepository;
private readonly PaymentRepository _paymentRepository;
private readonly FeedbackRepository _feedbackRepository;
public DashboardController(string connectionString) : base(connectionString)
{
_userRepository = new UserRepository(connectionString);
_roleRepository = new RoleRepository(connectionString);
_courseRepository = new CourseRepository(connectionString);
_liveClassRepository = new LiveClassRepository(connectionString);
_resourceRepository = new ResourceRepository(connectionString);
_quizRepository = new QuizRepository(connectionString);
_gradeRepository = new GradeRepository(connectionString);
_notificationRepository = new NotificationRepository(connectionString);
_paymentRepository = new PaymentRepository(connectionString);
_feedbackRepository = new FeedbackRepository(connectionString);
}
public IActionResult Index()
{
var dashboardViewModel = new DashboardViewModel
{
UserCount = _userRepository.GetAll().Count(),
RoleCount = _roleRepository.GetAll().Count(),
CourseCount = _courseRepository.GetAll().Count(),
LiveClassCount = _liveClassRepository.GetAll().Count(),
ResourceCount = _resourceRepository.GetAll().Count(),
QuizCount = _quizRepository.GetAll().Count(),
GradeCount = _gradeRepository.GetAll().Count(),
NotificationCount = _notificationRepository.GetAll().Count(),
PaymentCount = _paymentRepository.GetAll().Count(),
FeedbackCount = _feedbackRepository.GetAll().Count()
};
return View(dashboardViewModel);
}
}
Step 3: Create the Dashboard View
Now, we will create the view for the dashboard. This view will display the consolidated data in a user-friendly format.
Views/Dashboard/Index.cshtml
@model YourNamespace.ViewModels.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 Courses</h3>
<p>@Model.CourseCount</p>
</div>
<div class="card">
<h3>Total Live Classes</h3>
<p>@Model.LiveClassCount</p>
</div>
<div class="card">
<h3>Total Resources</h3>
<p>@Model.ResourceCount</p>
</div>
<div class="card">
<h3>Total Quizzes</h3>
<p>@Model.QuizCount</p>
</div>
<div class="card">
<h3>Total Grades</h3>
<p>@Model.GradeCount</p>
</div>
<div class="card">
<h3>Total Notifications</h3>
<p>@Model.NotificationCount</p>
</div>
<div class="card">
<h3>Total Payments</h3>
<p>@Model.PaymentCount</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;
}
</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.
Views/Shared/_Layout.cshtml
<ul>
<li><a href='@Url.Action("Index", "Dashboard")'>Dashboard</a></li>
<li><a href='@Url.Action("Index", "User ")'>Users</a></li>
<li><a href='@Url.Action("Index", "Role")'>Roles</a></li>
<li><a href='@Url.Action("Index", "Course")'>Courses</a></li>
</ul>
With these steps, you have created a dashboard page that consolidates data from various models in your ASP.NET MVC application. The dashboard provides a quick overview of key metrics, making it easier for users to understand the state of the application at a glance.
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