Project Introduction

The Smart Attendance System is designed to automate the process of tracking attendance in educational institutions. Built using ASP.NET and SQL Server, this application provides a user-friendly interface for teachers and administrators to manage classes, sessions, and attendance records efficiently. The system allows users to log attendance, generate reports, and receive notifications, ensuring accurate tracking of student presence and enhancing overall administrative efficiency.

Project Objectives

• To create a secure user authentication system for managing user accounts and roles.
• To enable the creation and management of classes and sessions for attendance tracking.
• To facilitate the logging of attendance status for each student in a session.
• To generate detailed reports on attendance records for students and classes.
• To implement a notification system to inform users about important updates and reminders.
• To collect user feedback to continuously improve the system's functionality and user experience.
• To provide a backup system for attendance data to ensure data integrity and security.

Project Modules

1. User Management Module: Handles user registration, login, and role management.
2. Class Management Module: Allows users to create, edit, and delete classes.
3. Session Management Module: Facilitates the scheduling and management of attendance sessions.
4. Attendance Management Module: Enables users to log and track attendance for each session.
5. Report Generation Module: Generates reports on attendance statistics and trends.
6. Notification Module: Sends notifications to users regarding attendance updates and reminders.
7. Feedback Module: Collects and manages user feedback to enhance the system.
8. Backup Module: Manages data backups to ensure the security and recoverability of attendance records.

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 Classes Table
CREATE TABLE Classes (
    ClassId INT PRIMARY KEY IDENTITY(1,1),
    ClassName NVARCHAR(100) NOT NULL,
    CreatedAt DATETIME DEFAULT GETDATE(),
    UpdatedAt DATETIME DEFAULT GETDATE()
);
-- Create Sessions Table
CREATE TABLE Sessions (
    SessionId INT PRIMARY KEY IDENTITY(1,1),
    ClassId INT NOT NULL,
    SessionDate DATETIME NOT NULL,
    CreatedAt DATETIME DEFAULT GETDATE(),
    UpdatedAt DATETIME DEFAULT GETDATE(),
    FOREIGN KEY (ClassId) REFERENCES Classes(ClassId)
);
-- Create Attendance Table
CREATE TABLE Attendance (
    AttendanceId INT PRIMARY KEY IDENTITY(1,1),
    UserId INT NOT NULL,
    SessionId INT NOT NULL,
    Status NVARCHAR(20) NOT NULL, -- e.g., Present, Absent, Late
    CreatedAt DATETIME DEFAULT GETDATE(),
    UpdatedAt DATETIME DEFAULT GETDATE(),
    FOREIGN KEY (User Id) REFERENCES Users(UserId),
    FOREIGN KEY (SessionId) REFERENCES Sessions(SessionId)
);
-- 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 Notifications Table
CREATE TABLE Notifications (
    NotificationId INT PRIMARY KEY IDENTITY(1,1),
    UserId INT NOT NULL,
    Message NVARCHAR(255) NOT NULL,
    IsRead BIT NOT NULL DEFAULT 0,
    CreatedAt DATETIME DEFAULT GETDATE(),
    FOREIGN KEY (User Id) REFERENCES Users(UserId)
);
-- Create Feedback Table
CREATE TABLE Feedback (
    FeedbackId INT PRIMARY KEY IDENTITY(1,1),
    UserId INT NOT NULL,
    FeedbackContent NVARCHAR(MAX) NOT NULL,
    CreatedAt DATETIME DEFAULT GETDATE(),
    FOREIGN KEY (User Id) REFERENCES Users(UserId)
);
-- Create Backup Table
CREATE TABLE Backups (
    BackupId INT PRIMARY KEY IDENTITY(1,1),
    UserId INT NOT NULL,
    BackupDate DATETIME DEFAULT GETDATE(),
    BackupFile NVARCHAR(255) NOT NULL,
    CreatedAt DATETIME DEFAULT GETDATE(),
    FOREIGN KEY (User Id) REFERENCES Users(UserId)
);

Explanation of Tables

Users: Stores user information, including their role (e.g., student, teacher, admin).

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

Classes: Contains information about different classes or courses.

Sessions: Records attendance sessions for each class, including the date of the session.

Attendance: Tracks attendance records for users in each session, including their status (e.g., Present, Absent, Late).

Reports: Allows users to generate reports related to attendance and other metrics.

Notifications: Stores notifications for users regarding attendance updates and other relevant information.

Feedback: Collects user feedback on the Smart Attendance System.

Backups: Keeps records of user data backups for recovery purposes.

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 Class
{
    public int ClassId { get; set; }
    public string ClassName { get; set; }
    public DateTime CreatedAt { get; set; }
    public DateTime UpdatedAt { get; set; }
}
public class Session
{
    public int SessionId { get; set; }
    public int ClassId { get; set; }
    public DateTime SessionDate { get; set; }
    public DateTime CreatedAt { get; set; }
    public DateTime UpdatedAt { get; set; }
}
public class Attendance
{
    public int AttendanceId { get; set; }
    public int UserId { get; set; }
    public int SessionId { get; set; }
    public string Status { get; set; }
    public DateTime CreatedAt { get; set; }
    public DateTime UpdatedAt { get; set; }
}
public class Report
{
    public int ReportId { get; set; }
    public int UserId { get; set; }
    public DateTime ReportDate { get; set; }
    public string ReportContent { get; set; }
    public DateTime CreatedAt { get; set; }
}
public class Notification
{
    public int NotificationId { get; set; }
    public int UserId { get; set; }
    public string Message { get; set; }
    public bool IsRead { get; set; }
    public DateTime CreatedAt { get; set; }
}
public class Feedback
{
    public int FeedbackId { get; set; }
    public int UserId { get; set; }
    public string FeedbackContent { get; set; }
    public DateTime CreatedAt { get; set; }
}
public class Backup
{
    public int BackupId { get; set; }
    public int UserId { get; set; }
    public DateTime BackupDate { get; set; }
    public string BackupFile { get; set; }
    public DateTime CreatedAt { get; set; }
}

Create Repositories

Next, we will create a generic repository interface and a concrete implementation for each model. Below is an example of a generic repository interface and a concrete repository for the User model.

Generic Repository Interface

public interface IRepository<T>
{
    IEnumerable<T> GetAll();
    T GetById(int id);
    void Add(T entity);
    void Update(T entity);
    void Delete(int id);
}

User Repository 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.AddWithValue("@User Id", 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, Class, Session, Attendance, Report, Notification, Feedback, and Backup by creating similar repository classes for each. Each repository will implement the IRepository interface and provide the necessary methods for data access.

Sure! Below are the repository implementations for the remaining models

Role, Class, Session, Attendance, Report, Notification, Feedback, and Backup. Each repository will follow the same pattern as the User Repository.

Role Repository

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();
        }
    }
}

Class Repository

public class ClassRepository : IRepository<Class>
{
    private readonly string _connectionString;
    public ClassRepository(string connectionString)
    {
        _connectionString = connectionString;
    }
    public IEnumerable<Class> GetAll()
    {
        var classes = new List<Class>();
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Classes", connection);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                while (reader.Read())
                {
                    classes.Add(new Class
                    {
                        ClassId = (int)reader["ClassId"],
                        ClassName = reader["ClassName"].ToString(),
                        CreatedAt = (DateTime)reader["CreatedAt"],
                        UpdatedAt = (DateTime)reader["UpdatedAt"]
                    });
                }
            }
        }
        return classes;
    }
    public Class GetById(int id)
    {
        Class classObj = null;
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Classes WHERE ClassId = @ClassId", connection);
            command.Parameters.AddWithValue("@ClassId", id);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                if (reader.Read())
                {
                    classObj = new Class
                    {
                        ClassId = (int)reader["ClassId"],
                        ClassName = reader["ClassName"].ToString(),
                        CreatedAt = (DateTime)reader["CreatedAt"],
                        UpdatedAt = (DateTime)reader["UpdatedAt"]
                    };
                }
            }
        }
        return classObj;
    }
    public void Add(Class classObj)
    {
        using (var connection = new SqlConnection(_connection String))
        {
            var command = new SqlCommand("INSERT INTO Classes (ClassName) VALUES (@ClassName)", connection);
            command.Parameters.AddWithValue("@ClassName", classObj.ClassName);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void Update(Class classObj)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("UPDATE Classes SET ClassName = @ClassName, UpdatedAt = GETDATE() WHERE ClassId = @ClassId", connection);
            command.Parameters.AddWithValue("@ClassId", classObj.ClassId);
            command.Parameters.AddWithValue("@ClassName", classObj.ClassName);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void Delete(int id)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("DELETE FROM Classes WHERE ClassId = @ClassId", connection);
            command.Parameters.AddWithValue("@ClassId", id);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

Session Repository

public class SessionRepository : IRepository<Session>
{
    private readonly string _connectionString;
    public SessionRepository(string connectionString)
    {
        _connectionString = connectionString;
    }
    public IEnumerable<Session> GetAll()
    {
        var sessions = new List<Session>();
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Sessions", connection);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                while (reader.Read())
                {
                    sessions.Add(new Session
                    {
                        SessionId = (int)reader["SessionId"],
                        ClassId = (int)reader["ClassId"],
                        SessionDate = (DateTime)reader["SessionDate"],
                        CreatedAt = (DateTime)reader["CreatedAt"],
                        UpdatedAt = (DateTime)reader["UpdatedAt"]
                    });
                }
            }
        }
        return sessions;
    }
    public Session GetById(int id)
    {
        Session session = null;
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Sessions WHERE SessionId = @SessionId", connection);
            command.Parameters.AddWithValue("@SessionId", id);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                if (reader.Read())
                {
                    session = new Session
                    {
                        SessionId = (int)reader["SessionId"],
                        ClassId = (int)reader["ClassId"],
                        SessionDate = (DateTime)reader["SessionDate"],
                        CreatedAt = (DateTime)reader["CreatedAt"],
                        UpdatedAt = (DateTime)reader["UpdatedAt"]
                    };
                }
            }
        }
        return session;
    }
    public void Add(Session session)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("INSERT INTO Sessions (ClassId, SessionDate) VALUES (@ClassId, @SessionDate)", connection);
            command.Parameters.AddWithValue("@ClassId", session.ClassId);
            command.Parameters.AddWithValue("@SessionDate", session.SessionDate);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void Update(Session session)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("UPDATE Sessions SET ClassId = @ClassId, SessionDate = @SessionDate, UpdatedAt = GETDATE() WHERE SessionId = @SessionId", connection);
            command.Parameters.AddWithValue("@SessionId", session.SessionId);
            command.Parameters.AddWithValue("@ClassId", session.ClassId);
            command.Parameters.AddWithValue("@SessionDate", session.SessionDate);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void Delete(int id)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("DELETE FROM Sessions WHERE SessionId = @SessionId", connection);
            command.Parameters.AddWithValue("@SessionId", id);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

Attendance Repository

public class AttendanceRepository : IRepository<Attendance>
{
    private readonly string _connectionString;
    public AttendanceRepository(string connectionString)
    {
        _connectionString = connectionString;
    }
    public IEnumerable<Attendance> GetAll()
    {
        var attendanceList = new List<Attendance>();
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Attendance", connection);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                while (reader.Read())
                {
                    attendanceList.Add(new Attendance
                    {
                        AttendanceId = (int)reader["AttendanceId"],
                        UserId = (int)reader["User Id"],
                        SessionId = (int)reader["SessionId"],
                        Status = reader["Status"].ToString(),
                        CreatedAt = (DateTime)reader["CreatedAt"],
                        UpdatedAt = (DateTime)reader["UpdatedAt"]
                    });
                }
            }
        }
        return attendanceList;
    }
    public Attendance GetById(int id)
    {
        Attendance attendance = null;
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Attendance WHERE AttendanceId = @AttendanceId", connection);
            command.Parameters.AddWithValue("@AttendanceId", id);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                if (reader.Read())
                {
                    attendance = new Attendance
                    {
                        AttendanceId = (int)reader["AttendanceId"],
                        UserId = (int)reader["User Id"],
                        SessionId = (int)reader["SessionId"],
                        Status = reader["Status"].ToString(),
                        CreatedAt = (DateTime)reader["CreatedAt"],
                        UpdatedAt = (DateTime)reader["UpdatedAt"]
                    };
                }
            }
        }
        return attendance;
    }
    public void Add(Attendance attendance)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("INSERT INTO Attendance (User Id, SessionId, Status) VALUES (@User Id, @SessionId, @Status)", connection);
            command.Parameters.AddWithValue("@User Id", attendance.UserId);
            command.Parameters.AddWithValue("@SessionId", attendance.SessionId);
            command.Parameters.AddWithValue("@Status", attendance.Status);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void Update(Attendance attendance)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("UPDATE Attendance SET UserId = @User Id, SessionId = @SessionId, Status = @Status, UpdatedAt = GETDATE() WHERE AttendanceId = @AttendanceId", connection);
            command.Parameters.AddWithValue("@AttendanceId", attendance.AttendanceId);
            command.Parameters.AddWithValue("@User Id", attendance.UserId);
            command.Parameters.AddWithValue("@SessionId", attendance.SessionId);
            command.Parameters.AddWithValue("@Status", attendance.Status);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void Delete(int id)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("DELETE FROM Attendance WHERE AttendanceId = @AttendanceId", connection);
            command.Parameters.AddWithValue("@AttendanceId", id);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

Report Repository

public class ReportRepository : IRepository<Report>
{
    private readonly string _connectionString;
    public ReportRepository(string connectionString)
    {
        _connectionString = connectionString;
    }
    public IEnumerable<Report> GetAll()
    {
        var reports = new List<Report>();
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Reports", connection);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                while (reader.Read())
                {
                    reports.Add(new Report
                    {
                        ReportId = (int)reader["ReportId"],
                        UserId = (int)reader["User Id"],
                        ReportDate = (DateTime)reader["ReportDate"],
                        ReportContent = reader["ReportContent"].ToString(),
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    });
                }
            }
        }
        return reports;
    }
    public Report GetById(int id)
    {
        Report report = null;
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Reports WHERE ReportId = @ReportId", connection);
            command.Parameters.AddWithValue("@ReportId", id);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                if (reader.Read())
                {
                    report = new Report
                    {
                        ReportId = (int)reader["ReportId"],
                        UserId = (int)reader["User Id"],
                        ReportDate = (DateTime)reader["ReportDate"],
                        ReportContent = reader["ReportContent"].ToString(),
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    };
                }
            }
        }
        return report;
    }
    public void Add(Report report)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("INSERT INTO Reports (User Id, ReportDate, ReportContent) VALUES (@User Id, @ReportDate, @ReportContent)", connection);
            command.Parameters.AddWithValue("@User Id", report.UserId);
            command.Parameters.AddWithValue("@ReportDate", report.ReportDate);
            command.Parameters.AddWithValue("@ReportContent", report.ReportContent);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void Update(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);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void Delete(int id)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("DELETE FROM Reports WHERE ReportId = @ReportId", connection);
            command.Parameters.AddWithValue("@ReportId", id);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

Notification Repository

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, CreatedAt = GETDATE() 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();
        }
    }
}

Feedback Repository

public class FeedbackRepository : IRepository<Feedback>
{
    private readonly string _connectionString;
    public FeedbackRepository(string connectionString)
    {
        _connectionString = connectionString;
    }
    public IEnumerable<Feedback> GetAll()
    {
        var feedbackList = 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())
                {
                    feedbackList.Add(new Feedback
                    {
                        FeedbackId = (int)reader["FeedbackId"],
                        UserId = (int)reader["User  Id"],
                        FeedbackContent = reader["FeedbackContent"].ToString(),
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    });
                }
            }
        }
        return feedbackList;
    }
    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"],
                        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, FeedbackContent) VALUES (@User  Id, @FeedbackContent)", connection);
            command.Parameters.AddWithValue("@User  Id", feedback.UserId);
            command.Parameters.AddWithValue("@FeedbackContent", feedback.FeedbackContent);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void Update(Feedback feedback)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("UPDATE Feedback SET UserId = @User  Id, FeedbackContent = @FeedbackContent, CreatedAt = GETDATE() WHERE FeedbackId = @FeedbackId", connection);
            command.Parameters.AddWithValue("@FeedbackId", feedback.FeedbackId);
            command.Parameters.AddWithValue("@User  Id", feedback.UserId);
            command.Parameters.AddWithValue("@FeedbackContent", feedback.FeedbackContent);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void 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();
        }
    }
}

Backup Repository

public class BackupRepository : IRepository<Backup>
{
    private readonly string _connectionString;
    public BackupRepository(string connectionString)
    {
        _connectionString = connectionString;
    }
    public IEnumerable<Backup> GetAll()
    {
        var backups = new List<Backup>();
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Backups", connection);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                while (reader.Read())
                {
                    backups.Add(new Backup
                    {
                        BackupId = (int)reader["BackupId"],
                        UserId = (int)reader["User  Id"],
                        BackupDate = (DateTime)reader["BackupDate"],
                        BackupFile = reader["BackupFile"].ToString(),
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    });
                }
            }
        }
        return backups;
    }
    public Backup GetById(int id)
    {
        Backup backup = null;
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Backups WHERE BackupId = @BackupId", connection);
            command.Parameters.AddWithValue("@BackupId", id);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                if (reader.Read())
                {
                    backup = new Backup
                    {
                        BackupId = (int)reader["BackupId"],
                        UserId = (int)reader["User  Id"],
                        BackupDate = (DateTime)reader["BackupDate"],
                        BackupFile = reader["BackupFile"].ToString(),
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    };
                }
            }
        }
        return backup;
    }
    public void Add(Backup backup)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("INSERT INTO Backups (User   Id, BackupDate, BackupFile) VALUES (@User   Id, @BackupDate, @BackupFile)", connection);
            command.Parameters.AddWithValue("@User   Id", backup.UserId);
            command.Parameters.AddWithValue("@BackupDate", backup.BackupDate);
            command.Parameters.AddWithValue("@BackupFile", backup.BackupFile);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void Update(Backup backup)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("UPDATE Backups SET UserId = @User   Id, BackupDate = @BackupDate, BackupFile = @BackupFile, CreatedAt = GETDATE() WHERE BackupId = @BackupId", connection);
            command.Parameters.AddWithValue("@BackupId", backup.BackupId);
            command.Parameters.AddWithValue("@User   Id", backup.UserId);
            command.Parameters.AddWithValue("@BackupDate", backup.BackupDate);
            command.Parameters.AddWithValue("@BackupFile", backup.BackupFile);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void Delete(int id)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("DELETE FROM Backups WHERE BackupId = @BackupId", connection);
            command.Parameters.AddWithValue("@BackupId", id);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

This completes the repository implementations for all the models

Each repository follows the same structure, allowing for consistent data access patterns across the application.

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 example controllers for each of the repositories

User, Role, Class, Session, Attendance, Report, Notification, Feedback, and Backup. Each controller will include basic CRUD operations.

UserController

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

RoleController

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

ClassController

public class ClassController : Controller
{
    private readonly ClassRepository _classRepository;
    public ClassController()
    {
        _classRepository = new ClassRepository("YourConnectionStringHere");
    }
    public ActionResult Index()
    {
        var classes = _classRepository.GetAll();
        return View(classes);
    }
    public ActionResult Details(int id)
    {
        var classObj = _classRepository.GetById(id);
        return View(classObj);
    }
    public ActionResult Create()
    {
        return View();
    }
    [HttpPost]
    public ActionResult Create(Class classObj)
    {
        if (ModelState.IsValid)
        {
            _classRepository.Add(classObj);
            return RedirectToAction("Index");
        }
        return View(classObj);
    }
    public ActionResult Edit(int id)
    {
        var classObj = _classRepository.GetById(id);
        return View(classObj);
    }
    [HttpPost]
    public ActionResult Edit(Class classObj)
    {
        if (ModelState.IsValid)
        {
            _classRepository.Update(classObj);
            return RedirectToAction("Index");
        }
        return View(classObj);
    }
    public ActionResult Delete(int id)
    {
        var classObj = _classRepository.GetById(id);
        return View(classObj);
    }
    [HttpPost, ActionName("Delete")]
    public ActionResult DeleteConfirmed(int id)
    {
        _classRepository.Delete(id);
        return RedirectToAction("Index");
    }
}

SessionController

public class SessionController : Controller
{
    private readonly SessionRepository _sessionRepository;
    public SessionController()
    {
        _sessionRepository = new SessionRepository("YourConnectionStringHere");
    }
    public ActionResult Index()
    {
        var sessions = _sessionRepository.GetAll();
        return View(sessions);
    }
    public ActionResult Details(int id)
    {
        var session = _sessionRepository.GetById(id);
        return View(session);
    }
    public ActionResult Create()
    {
        return View();
    }
    [HttpPost]
    public ActionResult Create(Session session)
    {
        if (ModelState.IsValid)
        {
            _sessionRepository.Add(session);
            return RedirectToAction("Index");
        }
        return View(session);
    }
    public ActionResult Edit(int id)
    {
        var session = _sessionRepository.GetById(id);
        return View(session);
    }
    [HttpPost]
    public ActionResult Edit(Session session)
    {
        if (ModelState.IsValid)
        {
            _sessionRepository.Update(session);
            return RedirectToAction("Index");
        }
        return View(session);
    }
    public ActionResult Delete(int id)
    {
        var session = _sessionRepository.GetById(id);
        return View(session);
    }
    [HttpPost, ActionName("Delete")]
    public ActionResult DeleteConfirmed(int id)
    {
        _sessionRepository.Delete(id);
        return RedirectToAction("Index");
    }
}

AttendanceController

public class AttendanceController : Controller
{
    private readonly AttendanceRepository _attendanceRepository;
    public AttendanceController()
    {
        _attendanceRepository = new AttendanceRepository("YourConnectionStringHere");
    }
    public ActionResult Index()
    {
        var attendanceList = _attendanceRepository.GetAll();
        return View(attendanceList);
    }
    public ActionResult Details(int id)
    {
        var attendance = _attendanceRepository.GetById(id);
        return View(attendance);
    }
    public ActionResult Create()
    {
        return View();
    }
    [HttpPost]
    public ActionResult Create(Attendance attendance)
    {
        if (ModelState.IsValid)
        {
            _attendanceRepository.Add(attendance);
            return RedirectToAction("Index");
        }
        return View(attendance);
    }
    public ActionResult Edit(int id)
    {
        var attendance = _attendanceRepository.GetById(id);
        return View(attendance);
    }
    [HttpPost]
    public ActionResult Edit(Attendance attendance)
    {
        if (ModelState.IsValid)
        {
            _attendanceRepository.Update(attendance);
            return RedirectToAction("Index");
        }
        return View(attendance);
    }
    public ActionResult Delete(int id)
    {
        var attendance = _attendanceRepository.GetById(id);
        return View(attendance);
    }
    [HttpPost, ActionName("Delete")]
    public ActionResult DeleteConfirmed(int id)
    {
        _attendanceRepository.Delete(id);
        return RedirectToAction("Index");
    }
}

ReportController

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

NotificationController

public class NotificationController : Controller
{
    private readonly NotificationRepository _notificationRepository;
    public NotificationController()
    {
        _notificationRepository = new NotificationRepository("YourConnectionStringHere");
    }
    public ActionResult Index()
    {
        var notifications = _notificationRepository.GetAll();
        return View(notifications);
    }
    public ActionResult Details(int id)
    {
        var notification = _notificationRepository.GetById(id);
        return View(notification);
    }
    public ActionResult Create()
    {
        return View();
    }
    [HttpPost]
    public ActionResult Create(Notification notification)
    {
        if (ModelState.IsValid)
        {
            _notificationRepository.Add(notification);
            return RedirectToAction("Index");
        }
        return View(notification);
    }
    public ActionResult Edit(int id)
    {
        var notification = _notificationRepository.GetById(id);
        return View(notification);
    }
    [HttpPost]
    public ActionResult Edit(Notification notification)
    {
        if (ModelState.IsValid)
        {
            _notificationRepository.Update(notification);
            return RedirectToAction("Index");
        }
        return View(notification);
    }
    public ActionResult Delete(int id)
    {
        var notification = _notificationRepository.GetById(id);
        return View(notification);
    }
    [HttpPost, ActionName("Delete")]
    public ActionResult DeleteConfirmed(int id)
    {
        _notificationRepository.Delete(id);
        return RedirectToAction("Index");
    }
}

FeedbackController

public class FeedbackController : Controller
{
    private readonly FeedbackRepository _feedbackRepository;
    public FeedbackController()
    {
        _feedbackRepository = new FeedbackRepository("YourConnectionStringHere");
    }
    public ActionResult Index()
    {
        var feedbackList = _feedbackRepository.GetAll();
        return View(feedbackList);
    }
    public ActionResult Details(int id)
    {
        var feedback = _feedbackRepository.GetById(id);
        return View(feedback);
    }
    public ActionResult Create()
    {
        return View();
    }
    [HttpPost]
    public ActionResult Create(Feedback feedback)
    {
        if (ModelState.IsValid)
        {
            _feedbackRepository.Add(feedback);
            return RedirectToAction("Index");
        }
        return View(feedback);
    }
    public ActionResult Edit(int id)
    {
        var feedback = _feedbackRepository.GetById(id);
        return View(feedback);
    }
    [HttpPost]
    public ActionResult Edit(Feedback feedback)
    {
        if (ModelState.IsValid)
        {
            _feedbackRepository.Update(feedback);
            return RedirectToAction("Index");
        }
        return View(feedback);
    }
    public ActionResult Delete(int id)
    {
        var feedback = _feedbackRepository.GetById(id);
        return View(feedback);
    }
    [HttpPost, ActionName("Delete")]
    public ActionResult DeleteConfirmed(int id)
    {
        _feedbackRepository.Delete(id);
        return RedirectToAction("Index");
    }
}

BackupController

public class BackupController : Controller
{
    private readonly BackupRepository _backupRepository;
    public BackupController()
    {
        _backupRepository = new BackupRepository("YourConnectionStringHere");
    }
    public ActionResult Index()
    {
        var backups = _backupRepository.GetAll();
        return View(backups);
    }
    public ActionResult Details(int id)
    {
        var backup = _backupRepository.GetById(id);
        return View(backup);
    }
    public ActionResult Create()
    {
        return View();
    }
    [HttpPost]
    public ActionResult Create(Backup backup)
    {
        if (ModelState.IsValid)
        {
            _backupRepository.Add(backup);
            return RedirectToAction("Index");
        }
        return View(backup);
    }
    public ActionResult Edit(int id)
    {
        var backup = _backupRepository.GetById(id);
        return View(backup);
    }
    [HttpPost]
    public ActionResult Edit(Backup backup)
    {
        if (ModelState.IsValid)
        {
            _backupRepository.Update(backup);
            return RedirectToAction("Index");
        }
        return View(backup);
    }
    public ActionResult Delete(int id)
    {
        var backup = _backupRepository.GetById(id);
        return View(backup);
    }
    [HttpPost, ActionName("Delete")]
    public ActionResult DeleteConfirmed(int id)
    {
        _backupRepository.Delete(id);
        return RedirectToAction("Index");
    }
}

This completes the controller implementations for all the repositories

Each controller provides the necessary actions to manage the corresponding model, allowing for a complete CRUD interface in the application.

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 the basic structure for the views for each controller: User, Role, Class, Session, Attendance, Report, Notification, Feedback, and Backup.

Folder Structure

Assuming you have a standard MVC project structure, the views for each controller will be placed in their respective folders under the Views directory:

User Views

Index.cshtml

@model IEnumerable<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 User
<h2>Create User</h2>
@using (Html.BeginForm())
{
    @Html.LabelFor(m => m.Username)
    @Html.TextBoxFor(m => m.Username)
    @Html.ValidationMessageFor(m => m.Username)
    @Html.LabelFor(m => m.PasswordHash)
    @Html.TextBoxFor(m => m.PasswordHash)
    @Html.ValidationMessageFor(m => m.PasswordHash)
    @Html.LabelFor(m => m.Email)
    @Html.TextBoxFor(m => m.Email)
    @Html.ValidationMessageFor(m => m.Email)
    @Html.LabelFor(m => m.FirstName)
    @Html.TextBoxFor(m => m.FirstName)
    @Html.ValidationMessageFor(m => m.FirstName)
    @Html.LabelFor(m => m.LastName)
    @Html.TextBoxFor(m => m.LastName)
    @Html.ValidationMessageFor(m => m.LastName)
    @Html.LabelFor(m => m.RoleId)
    @Html.TextBoxFor(m => m.RoleId)
    @Html.ValidationMessageFor(m => m.RoleId)
    <input type="submit" value="Create" />
}

Edit.cshtml

@model User
<h2>Edit User</h2>
@using (Html.BeginForm())
{
    @Html.HiddenFor(m => m.UserId)
    @Html.LabelFor(m => m.Username)
    @Html.TextBoxFor(m => m.Username)
    @Html.ValidationMessageFor(m => m.Username)
    @Html.LabelFor(m => m.PasswordHash)
    @Html.TextBoxFor(m => m.PasswordHash)
    @Html.ValidationMessageFor(m => m.PasswordHash)
    @Html.LabelFor(m => m.Email)
    @Html.TextBoxFor(m => m.Email)
    @Html.ValidationMessageFor(m => m.Email)
    @Html.LabelFor(m => m.FirstName)
    @Html.TextBoxFor(m => m.FirstName)
    @Html.ValidationMessageFor(m => m.FirstName)
    @Html.LabelFor(m => m.Last Name)
    @Html.TextBoxFor(m => m.LastName)
    @Html.ValidationMessageFor(m => m.LastName)
    @Html.LabelFor(m => m.RoleId)
    @Html.TextBoxFor(m => m.RoleId)
    @Html.ValidationMessageFor(m => m.RoleId)
    <input type="submit" value="Save" />
}

Details.cshtml

@model User
<h2>User Details</h2>
<div>
    <h4>User</h4>
    <hr />
    <dl class="dl-horizontal">
        <dt>
            @Html.DisplayNameFor(model => model.Username)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Username)
        </dd>
        <dt>
            @Html.DisplayNameFor(model => model.Email)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Email)
        </dd>
        <dt>
            @Html.DisplayNameFor(model => model.FirstName)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.FirstName)
        </dd>
        <dt>
            @Html.DisplayNameFor(model => model.LastName)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.LastName)
        </dd>
    </dl>
</div>
<p>
    <a href='@Url.Action("Edit", new { id = Model.UserId })'>Edit</a> |
    <a href='@Url.Action("Index")'>Back to List</a>
</p>

Delete.cshtml

@model User
<h2>Delete User</h2>
<div>
    <h4>Are you sure you want to delete this?</h4>
    <hr />
    <dl class="dl-horizontal">
        <dt>
            @Html.DisplayNameFor(model => model.Username)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Username)
        </dd>
        <dt>
            @Html.DisplayNameFor(model => model.Email)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Email)
        </dd>
    </dl>
</div>
@using (Html.BeginForm())
{
    @Html.HiddenFor(m => m.UserId)
    <input type="submit" value="Delete" />
}
<p>
    @Html.ActionLink("Back to List", "Index")
</p>

Role Views

Index.cshtml

@model IEnumerable<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.Name</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 Role
<h2>Create Role</h2>
@using (Html.BeginForm())
{
    @Html.LabelFor(m => m.Name)
    @Html.TextBoxFor(m => m.Name)
    @Html.ValidationMessageFor(m => m.Name)
    <input type="submit" value="Create" />
}

Edit.cshtml

@model Role
<h2>Edit Role</h2>
@using (Html.BeginForm())
{
    @Html.HiddenFor(m => m.RoleId)
    @Html.LabelFor(m => m.Name)
    @Html.TextBoxFor(m => m.Name)
    @Html.ValidationMessageFor(m => m.Name)
    <input type="submit" value="Save" />
}

Details.cshtml

@model Role
<h2>Role Details</h2>
<div>
    <h4>Role</h4>
    <hr />
    <dl class="dl-horizontal">
        <dt>
            @Html.DisplayNameFor(model => model.Name)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Name)
        </dd>
    </dl>
</div>
<p>
    <a href='@Url.Action("Edit", new { id = Model.RoleId })'>Edit</a> |
    <a href='@Url.Action("Index")'>Backto List</a>
</p>

Delete.cshtml

@model Role
<h2>Delete Role</h2>
<div>
    <h4>Are you sure you want to delete this?</h4>
    <hr />
    <dl class="dl-horizontal">
        <dt>
            @Html.DisplayNameFor(model => model.Name)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Name)
        </dd>
    </dl>
</div>
@using (Html.BeginForm())
{
    @Html.HiddenFor(m => m.RoleId)
    <input type="submit" value="Delete" />
}
<p>
    @Html.ActionLink("Back to List", "Index")
</p>

Class Views

Index.cshtml

@model IEnumerable<Class>
<h2>Classes</h2>
<a href='@Url.Action("Create")'>Create New Class</a>
<table>
    <thead>
        <tr>
            <th>Class Name</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var classObj in Model)
        {
            <tr>
                <td>@classObj.Name</td>
                <td>
                    <a href='@Url.Action("Details", new { id = classObj.ClassId })'>Details</a> |
                    <a href='@Url.Action("Edit", new { id = classObj.ClassId })'>Edit</a> |
                    <a href='@Url.Action("Delete", new { id = classObj.ClassId })'>Delete</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Create.cshtml

@model Class
<h2>Create Class</h2>
@using (Html.BeginForm())
{
    @Html.LabelFor(m => m.Name)
    @Html.TextBoxFor(m => m.Name)
    @Html.ValidationMessageFor(m => m.Name)
    <input type="submit" value="Create" />
}

Edit.cshtml

@model Class
<h2>Edit Class</h2>
@using (Html.BeginForm())
{
    @Html.HiddenFor(m => m.ClassId)
    @Html.LabelFor(m => m.Name)
    @Html.TextBoxFor(m => m.Name)
    @Html.ValidationMessageFor(m => m.Name)
    <input type="submit" value="Save" />
}

Details.cshtml

@model Class
<h2>Class Details</h2>
<div>
    <h4>Class</h4>
    <hr />
    <dl class="dl-horizontal">
        <dt>
            @Html.DisplayNameFor(model => model.Name)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Name)
        </dd>
    </dl>
</div>
<p>
    <a href='@Url.Action("Edit", new { id = Model.ClassId })'>Edit</a> |
    <a href='@Url.Action("Index")'>Back to List</a>
</p>

Delete.cshtml

@model Class
<h2>Delete Class</h2>
<div>
    <h4>Are you sure you want to delete this?</h4>
    <hr />
    <dl class="dl-horizontal">
        <dt>
            @Html.DisplayNameFor(model => model.Name)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Name)
        </dd>
    </dl>
</div>
@using (Html.BeginForm())
{
    @Html.HiddenFor(m => m.ClassId)
    <input type="submit" value="Delete" />
}
<p>
    @Html.ActionLink("Back to List", "Index")
</p>

Session Views

Index.cshtml

@model IEnumerable<Session>
<h2>Sessions</h2>
<a href='@Url.Action("Create")'>Create New Session</a>
<table>
    <thead>
        <tr>
            <th>Session Name</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var session in Model)
        {
            <tr>
                <td>@session.Name</td>
                <td>
                    <a href='@Url.Action("Details", new { id = session.SessionId })'>Details</a> |
                    <a href='@Url.Action("Edit", new { id = session.SessionId })'>Edit</a> |
                    <a href='@Url.Action("Delete", new { id = session.SessionId })'>Delete</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Create.cshtml

@model Session
<h2>Create Session</h2>
@using (Html.BeginForm())
{
    @Html.LabelFor(m => m.Name)    
    @Html.TextBoxFor(m => m.Name)
    @Html.ValidationMessageFor(m => m.Name)
    <input type="submit" value="Create" />
}

Edit.cshtml

@model Session
<h2>Edit Session</h2>
@using (Html.BeginForm())
{
    @Html.HiddenFor(m => m.SessionId)
    @Html.LabelFor(m => m.Name)
    @Html.TextBoxFor(m => m.Name)
    @Html.ValidationMessageFor(m => m.Name)
    <input type="submit" value="Save" />
}

Details.cshtml

@model Session
<h2>Session Details</h2>
<div>
    <h4>Session</h4>
    <hr />
    <dl class="dl-horizontal">
        <dt>
            @Html.DisplayNameFor(model => model.Name)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Name)
        </dd>
    </dl>
</div>
<p>
    <a href='@Url.Action("Edit", new { id = Model.SessionId })'>Edit</a> |
    <a href='@Url.Action("Index")'>Back to List</a>
</p>

Delete.cshtml

@model Session
<h2>Delete Session</h2>
<div>
    <h4>Are you sure you want to delete this?</h4>
    <hr />
    <dl class="dl-horizontal">
        <dt>
            @Html.DisplayNameFor(model => model.Name)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Name)
        </dd>
    </dl>
</div>
@using (Html.BeginForm())
{
    @Html.HiddenFor(m => m.SessionId)
    <input type="submit" value="Delete" />
}
<p>
    @Html.ActionLink("Back to List", "Index")
</p>

Attendance Views

Index.cshtml

@model IEnumerable<Attendance>
<h2>Attendance Records</h2>
<a href='@Url.Action("Create")'>Create New Attendance</a>
<table>
    <thead>
        <tr>
            <th>Student Name</th>
            <th>Class</th>
            <th>Date</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var attendance in Model)
        {
            <tr>
                <td>@attendance.StudentName</td>
                <td>@attendance.ClassName</td>
                <td>@attendance.Date.ToShortDateString()</td>
                <td>
                    <a href='@Url.Action("Details", new { id = attendance.AttendanceId })'>Details</a> |
                    <a href='@Url.Action("Edit", new { id = attendance.AttendanceId })'>Edit</a> |
                    <a href='@Url.Action("Delete", new { id = attendance.AttendanceId })'>Delete</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Create.cshtml

@model Attendance
<h2>Create Attendance Record</h2>
@using (Html.BeginForm())
{
    @Html.LabelFor(m => m.StudentName)
    @Html.TextBoxFor(m => m.StudentName)
    @Html.ValidationMessageFor(m => m.StudentName)
    @Html.LabelFor(m => m.ClassName)
    @Html.TextBoxFor(m => m.ClassName)
    @Html.ValidationMessageFor(m => m.ClassName)
    @Html.LabelFor(m => m.Date)
    @Html.TextBoxFor(m => m.Date, "{0:yyyy-MM-dd}", new { @type = "date" })
    @Html.ValidationMessageFor(m => m.Date)
    <input type="submit" value="Create" />
}

Edit.cshtml

@model Attendance
<h2>Edit Attendance Record</h2>
@using (Html.BeginForm())
{
    @Html.HiddenFor(m => m.AttendanceId)
    @Html.LabelFor(m => m.StudentName)
    @Html.TextBoxFor(m => m.StudentName)
    @Html.ValidationMessageFor(m => m.StudentName)
    @Html.LabelFor(m => m.ClassName)
    @Html.TextBoxFor(m => m.ClassName)
    @Html.ValidationMessageFor(m => m.ClassName)
    @Html.LabelFor(m => m.Date)
    @Html.TextBoxFor(m => m.Date, "{0:yyyy-MM-dd}", new { @type = "date" })
    @Html.ValidationMessageFor(m => m.Date)
    <input type="submit" value="Save" />
}

Details.cshtml

@model Attendance
<h2>Attendance Record Details</h2>
<div>
    <h4>Attendance</h4>    
    <hr />
    <dl class="dl-horizontal">
        <dt>
            @Html.DisplayNameFor(model => model.StudentName)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.StudentName)
        </dd>
        <dt>
            @Html.DisplayNameFor(model => model.ClassName)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.ClassName)
        </dd>
        <dt>
            @Html.DisplayNameFor(model => model.Date)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Date)
        </dd>
    </dl>
</div>
<p>
    <a href='@Url.Action("Edit", new { id = Model.AttendanceId })'>Edit</a> |
    <a href='@Url.Action("Index")'>Back to List</a>
</p>

Delete.cshtml

@model Attendance
<h2>Delete Attendance Record</h2>
<div>
    <h4>Are you sure you want to delete this?</h4>
    <hr />
    <dl class="dl-horizontal">
        <dt>
            @Html.DisplayNameFor(model => model.StudentName)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.StudentName)
        </dd>
        <dt>
            @Html.DisplayNameFor(model => model.ClassName)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.ClassName)
        </dd>
        <dt>
            @Html.DisplayNameFor(model => model.Date)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Date)
        </dd>
    </dl>
</div>
@using (Html.BeginForm())
{
    @Html.HiddenFor(m => m.AttendanceId)
    <input type="submit" value="Delete" />
}
<p>
    @Html.ActionLink("Back to List", "Index")
</p>

Report Views

Index.cshtml

@model IEnumerable<Report>
<h2>Reports</h2>
<a href='@Url.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 href='@Url.Action("Details", new { id = report.ReportId })'>Details</a> |
                    <a href='@Url.Action("Edit", new { id = report.ReportId })'>Edit</a> |
                    <a href='@Url.Action("Delete", new { id = report.ReportId })'>Delete</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Create.cshtml

@model Report
<h2>Create Report</h2>
@using (Html.BeginForm())
{
    @Html.LabelFor(m => m.Title)
    @Html.TextBoxFor(m => m.Title)
    @Html.ValidationMessageFor(m => m.Title)
    @Html.LabelFor(m => m.Content)
    @Html.TextAreaFor(m => m.Content)
    @Html.ValidationMessageFor(m => m.Content)
    <input type="submit" value="Create" />
}

Edit.cshtml

@model Report
<h2>Edit Report</h2>
@using (Html.BeginForm())
{
    @Html.HiddenFor(m => m.ReportId)
    @Html.LabelFor(m => m.Title)
    @Html.TextBoxFor(m => m.Title)
    @Html.ValidationMessageFor(m => m.Title)
    @Html.LabelFor(m => m.Content)
    @Html.TextAreaFor(m => m.Content)
    @Html.ValidationMessageFor(m => m.Content)
    <input type="submit" value="Save" />
}

Details.cshtml

@model Report
<h2>Report Details</h2>
<div>
    <h4>Report</h4>
    <hr />
    <dl class="dl-horizontal">
        <dt>
            @Html.DisplayNameFor(model => model.Title)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Title)
        </dd>
        <dt>
            @Html.DisplayNameFor(model => model.Content)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Content)
        </dd>
    </dl>
</div>
<p>
    <a href='@Url.Action("Edit", new { id = Model.ReportId })'>Edit</a> |
    <a href='@Url.Action("Index")'>Back to List</a>
</p>

Delete.cshtml

@model Report
<h2> Delete Report</h2>
<div>
    <h4>Are you sure you want to delete this?</h4>
    <hr />
    <dl class="dl-horizontal">
        <dt>
            @Html.DisplayNameFor(model => model.Title)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Title)
        </dd>
    </dl>
</div>
@using (Html.BeginForm())
{
    @Html.HiddenFor(m => m.ReportId)
    <input type="submit" value="Delete" />
}
<p>
    @Html.ActionLink("Back to List", "Index")
</p>

Notification Views

Index.cshtml

@model IEnumerable<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 Notification
<h2>Create Notification</h2>
@using (Html.BeginForm())
{
    @Html.LabelFor(m => m.Title)
    @Html.TextBoxFor(m => m.Title)
    @Html.ValidationMessageFor(m => m.Title)
    @Html.LabelFor(m => m.Message)
    @Html.TextAreaFor(m => m.Message)
    @Html.ValidationMessageFor(m => m.Message)
    <input type="submit" value="Create" />
}

Edit.cshtml

@model Notification
<h2>Edit Notification</h2>
@using (Html.BeginForm())
{
    @Html.HiddenFor(m => m.NotificationId)
    @Html.LabelFor(m => m.Title)
    @Html.TextBoxFor(m => m.Title)
    @Html.ValidationMessageFor(m => m.Title)
    @Html.LabelFor(m => m.Message)
    @Html.TextAreaFor(m => m.Message)
    @Html.ValidationMessageFor(m => m.Message)
    <input type="submit" value="Save" />
}

Details.cshtml

@model Notification
<h2>Notification Details</h2>
<div>
    <h4>Notification</h4>
    <hr />
    <dl class="dl-horizontal">
        <dt>
            @Html.DisplayNameFor(model => model.Title)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Title)
        </dd>
        <dt>
            @Html.DisplayNameFor(model => model.Message)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Message)
        </dd>
    </dl>
</div>
<p>
    <a href='@Url.Action("Edit", new { id = Model.NotificationId })'>Edit</a> |
    <a href='@Url.Action("Index")'>Back to List</a>
</p>

Delete.cshtml

@model Notification
<h2>Delete Notification</h2>
<div>
    <h4>Are you sure you want to delete this?</h4>
    <hr />
    <dl class="dl-horizontal">
        <dt>
            @Html.DisplayNameFor(model => model.Title)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Title)
        </dd>
    </dl>
</div>
@using (Html.BeginForm())
{
    @Html.HiddenFor(m => m.NotificationId)
    <input type="submit" value="Delete" />
}
<p>
    @Html.ActionLink("Back to List", "Index")
</p>

Feedback Views

Index.cshtml

@model IEnumerable<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 Feedback
<h2>Create Feedback</h2>
@using (Html.BeginForm())
{
    @Html.LabelFor(m => m.Title)
    @Html.TextBoxFor(m => m.Title)
    @Html.ValidationMessageFor(m => m.Title)
    @Html.LabelFor(m => m.Content)
    @Html.TextAreaFor(m => m.Content)
    @Html.ValidationMessageFor(m => m.Content)
    <input type="submit" value="Create" />
}

Edit.cshtml

@model Feedback
<h2>Edit Feedback</h2>
@using (Html.BeginForm())
{
    @Html.HiddenFor(m => m.FeedbackId)
    @Html.LabelFor(m => m.Title)
    @Html.TextBoxFor(m => m.Title)
    @Html.ValidationMessageFor(m => m.Title)
    @Html.LabelFor(m => m.Content)
    @Html.TextAreaFor(m => m.Content)
    @Html.ValidationMessageFor(m => m.Content)
    <input type="submit" value="Save" />
}

Details.cshtml

@model Feedback
<h2>Feedback Details</h2>
<div>
    <h4>Feedback</h4>
    <hr />
    <dl class="dl-horizontal">
        <dt>
            @Html.DisplayNameFor(model => model.Title)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Title)
        </dd>
        <dt>
            @Html.DisplayNameFor(model => model.Content)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Content)
        </dd>
    </dl>
</div>
<p>
    <a href='@Url.Action("Edit", new { id = Model.FeedbackId })'>Edit</a> |
    <a href='@Url.Action("Index")'>Back to List</a>
</p>

Delete.cshtml

@model Feedback
<h2>Delete Feedback</h2>
<div>
    <h4>Are you sure you want to delete this?</h4>
    <hr />
    <dl class="dl-horizontal">
        <dt>
            @Html.DisplayNameFor(model => model.Title)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Title)
        </dd>
    </dl>
</div>
@using (Html.BeginForm())
{
    @Html.HiddenFor(m => m.FeedbackId)
    <input type="submit" value="Delete" />
}
<p>
    @Html.ActionLink("Back to List", "Index")
</p>

Backup Views

Index.cshtml

@model IEnumerable<Backup>
<h2>Backups</h2>
<a href='@Url.Action("Create")'>Create New Backup</a>
<table>
    <thead>
        <tr>
            <th>Backup Name</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var backup in Model)
        {
            <tr>
                <td>@backup.Name</td>
                <td>
                    <a href='@Url.Action("Details", new { id = backup.BackupId })'>Details</a> |
                    <a href='@Url.Action("Edit", new { id = backup.BackupId })'>Edit</a> |
                    <a href='@Url.Action("Delete", new { id = backup.BackupId })'>Delete</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Create.cshtml

@model Backup
<h2>Create Backup</h2>
@using (Html.BeginForm())
{
    @Html.LabelFor(m => m.Name)
    @Html.TextBoxFor(m => m.Name)
    @Html.ValidationMessageFor(m => m.Name)
    <input type="submit" value="Create" />
}

Edit.cshtml

@model Backup
<h2>Edit Backup</h2>
@using (Html.BeginForm())
{
    @Html.HiddenFor(m => m.BackupId)
    @Html.LabelFor(m => m.Name)
    @Html.TextBoxFor(m => m.Name)
    @Html.ValidationMessageFor(m => m.Name)
    <input type="submit" value="Save" />
}

Details.cshtml

@model Backup
<h2>Backup Details</h2>
<div>
    <h4>Backup</h4>
    <hr />
    <dl class="dl-horizontal">
        <dt>
            @Html.DisplayName For model => model.Name)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Name)
        </dd>
    </dl>
</div>
<p>
    <a href='@Url.Action("Edit", new { id = Model.BackupId })'>Edit</a> |
    <a href='@Url.Action("Index")'>Back to List</a>
</p>

Delete.cshtml

@model Backup
<h2>Delete Backup</h2>
<div>
    <h4>Are you sure you want to delete this?</h4>
    <hr />
    <dl class="dl-horizontal">
        <dt>
            @Html.DisplayNameFor(model => model.Name)
        </dt>
        <dd>
            @Html.DisplayFor(model => model.Name)
        </dd>
    </dl>
</div>
@using (Html.BeginForm())
{
    @Html.HiddenFor(m => m.BackupId)
    <input type="submit" value="Delete" />
}
<p>
    @Html.ActionLink("Back to List", "Index")
</p>

This completes the view implementations for all the controllers

Each view provides the necessary interface for managing the corresponding model, allowing for a complete CRUD experience in the application.

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 simple dashboard that displays consolidated data related to the project, such as the number of users, roles, classes, sessions, attendance records, reports, notifications, feedback, and backups.

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 ClassCount { get; set; }
    public int SessionCount { get; set; }
    public int AttendanceCount { get; set; }
    public int ReportCount { get; set; }
    public int NotificationCount { get; set; }
    public int FeedbackCount { get; set; }
    public int BackupCount { get; set; }
}

Step 2: Create a Dashboard Controller

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

using System.Web.Mvc;
public class DashboardController : Controller
{
    private readonly UserRepository _userRepository;
    private readonly RoleRepository _roleRepository;
    private readonly ClassRepository _classRepository;
    private readonly SessionRepository _sessionRepository;
    private readonly AttendanceRepository _attendanceRepository;
    private readonly ReportRepository _reportRepository;
    private readonly NotificationRepository _notificationRepository;
    private readonly FeedbackRepository _feedbackRepository;
    private readonly BackupRepository _backupRepository;
    public DashboardController()
    {
        string connectionString = "YourConnectionStringHere";
        _userRepository = new UserRepository(connectionString);
        _roleRepository = new RoleRepository(connectionString);
        _classRepository = new ClassRepository(connectionString);
        _sessionRepository = new SessionRepository(connectionString);
        _attendanceRepository = new AttendanceRepository(connectionString);
        _reportRepository = new ReportRepository(connectionString);
        _notificationRepository = new NotificationRepository(connectionString);
        _feedbackRepository = new FeedbackRepository(connectionString);
        _backupRepository = new BackupRepository(connectionString);
    }
    public ActionResult Index()
    {
        var model = new DashboardViewModel
        {
            UserCount = _userRepository.GetAll().Count(),
            RoleCount = _roleRepository.GetAll().Count(),
            ClassCount = _classRepository.GetAll().Count(),
            SessionCount = _sessionRepository.GetAll().Count(),
            AttendanceCount = _attendanceRepository.GetAll().Count(),
            ReportCount = _reportRepository.GetAll().Count(),
            NotificationCount = _notificationRepository.GetAll().Count(),
            FeedbackCount = _feedbackRepository.GetAll().Count(),
            BackupCount = _backupRepository.GetAll().Count()
        };
        return View(model);
    }
}

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 DashboardViewModel
@{
    ViewBag.Title = "Dashboard";
}
<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 Classes</h3>
        <p>@Model.ClassCount</p>
    </div>
    <div class="card">
        <h3>Total Sessions</h3>
        <p>@Model.SessionCount</p>
    </div>
    <div class="card">
        <h3>Total Attendance Records</h3>
        <p>@Model.AttendanceCount</p>
    </div>
    <div class="card">
        <h3>Total Reports</h3>
        <p>@Model.ReportCount</p>
    </div>
    <div class="card">
        <h3>Total Notifications</h3>
        <p>@Model.NotificationCount</p>
    </div>
    <div class="card">
        <h3>Total Feedbacks</h3>
        <p>@Model.FeedbackCount</p>
    </div>
    <div class="card">
        <h3>Total Backups</h3>
        <p>@Model.BackupCount</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;
    }
    .card h3 {
        margin: 0;
        font-size: 1.5em;
    }
    .card p {
        font-size: 2em;
        color: #333;
    }
</style>

Step 4: Update the Route Configuration

Ensure that the route configuration allows access to the dashboard. You can add a route in RouteConfig.cs if necessary.

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