Project Introduction

The Online Voting System is designed to facilitate the organization and management of elections, including candidate nominations, voting processes, and result tabulation. Built using ASP.NET and SQL Server, this application provides a secure and user-friendly platform for voters to cast their votes, view candidates, and track election results. The system also allows administrators to manage elections, candidates, and user roles, ensuring a transparent and efficient electoral process.

Project Objectives

• To create a secure user authentication system for managing user accounts and roles.
• To enable the creation and management of elections, including details such as title, description, and dates.
• To facilitate candidate nominations and management for each election.
• To implement a voting system that allows users to cast their votes securely.
• To track and manage ballots associated with each election.
• To tally votes and generate results for each election.
• To provide notifications to users regarding election updates and important information.
• To manage support tickets for user inquiries and issues related to the election process.
• To collect user feedback to improve the overall system and user experience.

Project Modules

1. User Management Module: Handles user registration, login, and role management.
2. Election Management Module: Allows administrators to create, edit, and delete elections.
3. Candidate Management Module: Facilitates the nomination and management of candidates for elections.
4. Voting Module: Enables users to cast their votes securely and anonymously.
5. Ballot Management Module: Manages the creation and tracking of ballots for each election.
6. Results Management Module: Tallies votes and generates results for each election.
7. Notification Module: Sends notifications to users regarding election updates and important announcements.
8. Support Ticket Module: Manages user support tickets and tracks their status.
9. Feedback Module: Collects and analyzes user feedback to enhance the system.

SQL Server Database Tables

-- Create Users Table
CREATE TABLE Users (
    UserId INT PRIMARY KEY IDENTITY(1,1),
    Username NVARCHAR(50) NOT NULL UNIQUE,
    PasswordHash NVARCHAR(256) NOT NULL,
    Email NVARCHAR(100) NOT NULL UNIQUE,
    RoleId INT,
    CreatedAt 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
);
-- Create Elections Table
CREATE TABLE Elections (
    ElectionId INT PRIMARY KEY IDENTITY(1,1),
    Title NVARCHAR(100) NOT NULL,
    Description NVARCHAR(MAX),
    StartDate DATETIME NOT NULL,
    EndDate DATETIME NOT NULL,
    CreatedAt DATETIME DEFAULT GETDATE()
);
-- Create Candidates Table
CREATE TABLE Candidates (
    CandidateId INT PRIMARY KEY IDENTITY(1,1),
    ElectionId INT,
    Name NVARCHAR(100) NOT NULL,
    Party NVARCHAR(100),
    CreatedAt DATETIME DEFAULT GETDATE(),
    FOREIGN KEY (ElectionId) REFERENCES Elections(ElectionId)
);
-- Create Ballots Table
CREATE TABLE Ballots (
    BallotId INT PRIMARY KEY IDENTITY(1,1),
    ElectionId INT,
    VoterId INT,
    CreatedAt DATETIME DEFAULT GETDATE(),
    FOREIGN KEY (ElectionId) REFERENCES Elections(ElectionId),
    FOREIGN KEY (VoterId) REFERENCES Users(UserId)
);
-- Create Votes Table
CREATE TABLE Votes (
    VoteId INT PRIMARY KEY IDENTITY(1,1),
    BallotId INT,
    CandidateId INT,
    CreatedAt DATETIME DEFAULT GETDATE(),
    FOREIGN KEY (BallotId) REFERENCES Ballots(BallotId),
    FOREIGN KEY (CandidateId) REFERENCES Candidates(CandidateId)
);
-- Create Results Table
CREATE TABLE Results (
    ResultId INT PRIMARY KEY IDENTITY(1,1),
    ElectionId INT,
    CandidateId INT,
    VoteCount INT DEFAULT 0,
    CreatedAt DATETIME DEFAULT GETDATE(),
    FOREIGN KEY (ElectionId) REFERENCES Elections(ElectionId),
    FOREIGN KEY (CandidateId) REFERENCES Candidates(CandidateId)
);
-- Create Notifications Table
CREATE TABLE Notifications (
    NotificationId INT PRIMARY KEY IDENTITY(1,1),
    UserId INT,
    Message NVARCHAR(256) NOT NULL,
    IsRead BIT DEFAULT 0,
    CreatedAt DATETIME DEFAULT GETDATE(),
    FOREIGN KEY (User Id) REFERENCES Users(UserId)
);
-- Create SupportTickets Table
CREATE TABLE SupportTickets (
    SupportTicketId INT PRIMARY KEY IDENTITY(1,1),
    UserId INT,
    CreatedAt DATETIME DEFAULT GETDATE(),
    Subject NVARCHAR(100) NOT NULL,
    Message NVARCHAR(MAX) NOT NULL,
    Status NVARCHAR(50) NOT NULL, -- e.g., Open, Resolved
    FOREIGN KEY (User Id) REFERENCES Users(UserId)
);
-- Create Feedback Table
CREATE TABLE Feedback (
    FeedbackId INT PRIMARY KEY IDENTITY(1,1),
    UserId INT,
    Comments NVARCHAR(MAX),
    CreatedAt DATETIME DEFAULT GETDATE(),
    FOREIGN KEY (User Id) REFERENCES Users(UserId)
);

Explanation of the Tables

Users: Stores user information, including username, password hash, email, and role.

Roles: Defines user roles (e.g., Admin, Voter).

Elections: Contains election details, including title, description, start and end dates.

Candidates: Stores candidates participating in elections, including their names and associated elections.

Ballots: Tracks ballots cast in elections, linking voters to the elections they participate in.

Votes: Records votes for candidates associated with specific ballots.

Results: Stores the results of elections, including vote counts for each candidate.

Notifications: Manages notifications for users, such as alerts for upcoming elections or results.

SupportTickets: Manages support tickets raised by users, including subject, message, and status.

Feedback: Stores feedback from users regarding the platform or services.

To create a model and repository pattern using ADO.NET for the provided SQL Server schema in an ASP.NET application

We will follow these steps:

Create Models

Define C# classes that represent the tables in the database.

public class User
{
    public int UserId { get; set; }
    public string Username { get; set; }
    public string PasswordHash { get; set; }
    public string Email { get; set; }
    public int? RoleId { get; set; }
    public DateTime CreatedAt { get; set; }
}
public class Role
{
    public int RoleId { get; set; }
    public string RoleName { get; set; }
}
public class Election
{
    public int ElectionId { get; set; }
    public string Title { get; set; }
    public string Description { get; set; }
    public DateTime StartDate { get; set; }
    public DateTime EndDate { get; set; }
    public DateTime CreatedAt { get; set; }
}
public class Candidate
{
    public int CandidateId { get; set; }
    public int ElectionId { get; set; }
    public string Name { get; set; }
    public string Party { get; set; }
    public DateTime CreatedAt { get; set; }
}
public class Ballot
{
    public int BallotId { get; set; }
    public int ElectionId { get; set; }
    public int VoterId { get; set; }
    public DateTime CreatedAt { get; set; }
}
public class Vote
{
    public int VoteId { get; set; }
    public int BallotId { get; set; }
    public int CandidateId { get; set; }
    public DateTime CreatedAt { get; set; }
}
public class Result
{
    public int ResultId { get; set; }
    public int ElectionId { get; set; }
    public int CandidateId { get; set; }
    public int VoteCount { 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 SupportTicket
{
    public int SupportTicketId { get; set; }
    public int UserId { get; set; }
    public DateTime CreatedAt { get; set; }
    public string Subject { get; set; }
    public string Message { get; set; }
    public string Status { get; set; }
}
public class Feedback
{
    public int FeedbackId { get; set; }
    public int UserId { get; set; }
    public string Comments { get; set; }
    public DateTime CreatedAt { get; set; }
}

Create Repositories

Next, we will create a repository for each model. Below is an example of a generic repository pattern for the User model. You can create similar repositories for other models.

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

This repository pattern can be replicated for other models such as Role, Election, Candidate, etc., by following the same structure and modifying the SQL queries and parameters accordingly.

public class RoleRepository 
{ 
    private readonly string _connectionString;
public RoleRepository()
{
    _connectionString = ConfigurationManager.ConnectionStrings["YourConnectionString"].ConnectionString;
}
public void AddRole(Role role)
{
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "INSERT INTO Roles (RoleName) VALUES (@RoleName)";
        SqlCommand command = new SqlCommand(query, connection);
        command.Parameters.AddWithValue("@RoleName", role.RoleName);
        connection.Open();
        command.ExecuteNonQuery();
    }
}
public Role GetRoleById(int roleId)
{
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "SELECT * FROM Roles WHERE RoleId = @RoleId";
        SqlCommand command = new SqlCommand(query, connection);
        command.Parameters.AddWithValue("@RoleId", roleId);
        connection.Open();
        using (SqlDataReader reader = command.ExecuteReader())
        {
            if (reader.Read())
            {
                return new Role
                {
                    RoleId = (int)reader["RoleId"],
                    RoleName = reader["RoleName"].ToString()
                };
            }
        }
    }
    return null;
}
public IEnumerable<Role> GetAllRoles()
{
    var roles = new List<Role>();
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "SELECT * FROM Roles";
        SqlCommand command = new SqlCommand(query, connection);
        connection.Open();
        using (SqlDataReader reader = command.ExecuteReader())
        {
            while (reader.Read())
            {
                roles.Add(new Role
                {
                    RoleId = (int)reader["RoleId"],
                    RoleName = reader["RoleName"].ToString()
                });
            }
        }
    }
    return roles;
}
public void UpdateRole(Role role)
{
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "UPDATE Roles SET RoleName = @RoleName WHERE RoleId = @RoleId";
        SqlCommand command = new SqlCommand(query, connection);
        command.Parameters.AddWithValue("@RoleName", role.RoleName);
        command.Parameters.AddWithValue("@RoleId", role.RoleId);
        connection.Open();
        command.ExecuteNonQuery();
    }
}
public void DeleteRole(int roleId)
{
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "DELETE FROM Roles WHERE RoleId = @RoleId";
        SqlCommand command = new SqlCommand(query, connection);
        command.Parameters.AddWithValue("@RoleId", roleId);
        connection.Open();
        command.ExecuteNonQuery();
    }
}
}
public class ElectionRepository { private readonly string _connectionString;
public ElectionRepository()
{
    _connectionString = ConfigurationManager.ConnectionStrings["YourConnectionString"].ConnectionString;
}
public void AddElection(Election election)
{
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "INSERT INTO Elections (Title, Description, StartDate, EndDate) VALUES (@Title, @Description, @StartDate, @EndDate)";
        SqlCommand command = new SqlCommand(query, connection);
        command.Parameters.AddWithValue("@Title", election.Title);
        command.Parameters.AddWithValue("@Description", election.Description);
        command.Parameters.AddWithValue("@StartDate", election.StartDate);
        command.Parameters.AddWithValue("@EndDate", election.EndDate);
        connection.Open();
        command.ExecuteNonQuery();
    }
}
public Election GetElectionById(int electionId)
{
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "SELECT * FROM Elections WHERE ElectionId = @ElectionId";
        SqlCommand command = new SqlCommand(query, connection);
        command.Parameters.AddWithValue("@ElectionId", electionId);
        connection.Open();
        using (SqlDataReader reader = command.ExecuteReader())
        {
            if (reader.Read())
            {
                return new Election
                {
                    ElectionId = (int)reader["ElectionId"],
                    Title = reader["Title"].ToString(),
                    Description = reader["Description"].ToString(),
                    StartDate = (DateTime)reader["StartDate"],
                    EndDate = (DateTime)reader["EndDate"],
                    CreatedAt = (DateTime)reader["CreatedAt"]
                };
            }
        }
    }
    return null;
}
public IEnumerable<Election> GetAllElections()
{
    var elections = new List<Election>();
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "SELECT * FROM Elections";
        SqlCommand command = new SqlCommand(query, connection);
        connection.Open();
        using (SqlDataReader reader = command .ExecuteReader())
        {
            while (reader.Read())
            {
                elections.Add(new Election
                {
                    ElectionId = (int)reader["ElectionId"],
                    Title = reader["Title"].ToString(),
                    Description = reader["Description"].ToString(),
                    StartDate = (DateTime)reader["StartDate"],
                    EndDate = (DateTime)reader["EndDate"],
                    CreatedAt = (DateTime)reader["CreatedAt"]
                });
            }
        }
    }
    return elections;
}
public void UpdateElection(Election election)
{
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "UPDATE Elections SET Title = @Title, Description = @Description, StartDate = @StartDate, EndDate = @EndDate WHERE ElectionId = @ElectionId";
        SqlCommand command = new SqlCommand(query, connection);
        command.Parameters.AddWithValue("@Title", election.Title);
        command.Parameters.AddWithValue("@Description", election.Description);
        command.Parameters.AddWithValue("@StartDate", election.StartDate);
        command.Parameters.AddWithValue("@EndDate", election.EndDate);
        command.Parameters.AddWithValue("@ElectionId", election.ElectionId);
        connection.Open();
        command.ExecuteNonQuery();
    }
}
public void DeleteElection(int electionId)
{
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "DELETE FROM Elections WHERE ElectionId = @ElectionId";
        SqlCommand command = new SqlCommand(query, connection);
        command.Parameters.AddWithValue("@ElectionId", electionId);
        connection.Open();
        command.ExecuteNonQuery();
    }
}
}
public class CandidateRepository { private readonly string _connectionString;
public CandidateRepository()
{
    _connectionString = ConfigurationManager.ConnectionStrings["YourConnectionString"].ConnectionString;
}
public void AddCandidate(Candidate candidate)
{
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "INSERT INTO Candidates (ElectionId, Name, Party) VALUES (@ElectionId, @Name, @Party)";
        SqlCommand command = new SqlCommand(query, connection);
        command.Parameters.AddWithValue("@ElectionId", candidate.ElectionId);
        command.Parameters.AddWithValue("@Name", candidate.Name);
        command.Parameters.AddWithValue("@Party", candidate.Party);
        connection.Open();
        command.ExecuteNonQuery();
    }
}
public Candidate GetCandidateById(int candidateId)
{
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "SELECT * FROM Candidates WHERE CandidateId = @CandidateId";
        SqlCommand command = new SqlCommand(query, connection);
        command.Parameters.AddWithValue("@CandidateId", candidateId);
        connection.Open();
        using (SqlDataReader reader = command.ExecuteReader())
        {
            if (reader.Read())
            {
                return new Candidate
                {
                    CandidateId = (int)reader["CandidateId"],
                    ElectionId = (int)reader["ElectionId"],
                    Name = reader["Name"].ToString(),
                    Party = reader["Party"].ToString(),
                    CreatedAt = (DateTime)reader["CreatedAt"]
                };
            }
        }
    }
    return null;
}
public IEnumerable<Candidate> GetAllCandidates()
{
    var candidates = new List<Candidate>();
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "SELECT * FROM Candidates";
        SqlCommand command = new SqlCommand(query, connection);
        connection.Open();
        using (SqlDataReader reader = command.ExecuteReader())
        {
            while (reader.Read())
            {
                candidates.Add(new Candidate
                {
                    CandidateId = (int)reader["CandidateId"],
                    ElectionId = (int)reader["ElectionId"],
                    Name = reader["Name"].ToString(),
                    Party = reader["Party"].ToString(),
                    CreatedAt = (DateTime)reader["CreatedAt"]
                });
            }
        }
    }
    return candidates;
}
public void UpdateCandidate(Candidate candidate)
{
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "UPDATE Candidates SET ElectionId = @ElectionId, Name = @Name, Party = @Party WHERE CandidateId = @CandidateId";
        SqlCommand command = new SqlCommand(query, connection);
        command.Parameters.AddWithValue("@ElectionId", candidate.ElectionId);
        command.Parameters.AddWithValue("@Name", candidate.Name);
        command.Parameters.AddWithValue("@Party", candidate.Party);
        command.Parameters.AddWithValue("@CandidateId", candidate.CandidateId);
        connection.Open();
        command.ExecuteNonQuery();
    }
}
public void DeleteCandidate(int candidateId)
{
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "DELETE FROM Candidates WHERE Candidate Id = @CandidateId";
        SqlCommand command = new SqlCommand(query, connection);
        command.Parameters.AddWithValue("@CandidateId", candidateId);
        connection.Open();
        command.ExecuteNonQuery();
    }
}
}

public class BallotRepository { private readonly string _connectionString;
public BallotRepository()
{
    _connectionString = ConfigurationManager.ConnectionStrings["YourConnectionString"].ConnectionString;
}
public void AddBallot(Ballot ballot)
{
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "INSERT INTO Ballots (ElectionId, VoterId) VALUES (@ElectionId, @VoterId)";
        SqlCommand command = new SqlCommand(query, connection);
        command.Parameters.AddWithValue("@ElectionId", ballot.ElectionId);
        command.Parameters.AddWithValue("@VoterId", ballot.VoterId);
        connection.Open();
        command.ExecuteNonQuery();
    }
}
public Ballot GetBallotById(int ballotId)
{
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "SELECT * FROM Ballots WHERE BallotId = @BallotId";
        SqlCommand command = new SqlCommand(query, connection);
        command.Parameters.AddWithValue("@BallotId", ballotId);
        connection.Open();
        using (SqlDataReader reader = command.ExecuteReader())
        {
            if (reader.Read())
            {
                return new Ballot
                {
                    BallotId = (int)reader["BallotId"],
                    ElectionId = (int)reader["ElectionId"],
                    VoterId = (int)reader["VoterId"],
                    CreatedAt = (DateTime)reader["CreatedAt"]
                };
            }
        }
    }
    return null;
}
public IEnumerable<Ballot> GetAllBallots()
{
    var ballots = new List<Ballot>();
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "SELECT * FROM Ballots";
        SqlCommand command = new SqlCommand(query, connection);
        connection.Open();
        using (SqlDataReader reader = command.ExecuteReader())
        {
            while (reader.Read())
            {
                ballots.Add(new Ballot
                {
                    BallotId = (int)reader["BallotId"],
                    ElectionId = (int)reader["ElectionId"],
                    VoterId = (int)reader["VoterId"],
                    CreatedAt = (DateTime)reader["CreatedAt"]
                });
            }
        }
    }
    return ballots;
}
public void UpdateBallot(Ballot ballot)
{
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "UPDATE Ballots SET ElectionId = @ElectionId, VoterId = @VoterId WHERE BallotId = @BallotId";
        SqlCommand command = new SqlCommand(query, connection);
        command.Parameters.AddWithValue("@ElectionId", ballot.ElectionId);
        command.Parameters.AddWithValue("@VoterId", ballot.VoterId);
        command.Parameters.AddWithValue("@BallotId", ballot.BallotId);
        connection.Open();
        command.ExecuteNonQuery();
    }
}
public void DeleteBallot(int ballotId)
{
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "DELETE FROM Ballots WHERE BallotId = @BallotId";
        SqlCommand command = new SqlCommand(query, connection);
        command.Parameters.AddWithValue("@BallotId", ballotId);
        connection.Open();
        command.ExecuteNonQuery();
    }
}
}

public class VoteRepository { private readonly string _connectionString;
public VoteRepository()
{
    _connectionString = ConfigurationManager.ConnectionStrings["YourConnectionString"].ConnectionString;
}
public void AddVote(Vote vote)
{
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "INSERT INTO Votes (BallotId, CandidateId) VALUES (@BallotId, @CandidateId)";
        SqlCommand command = new SqlCommand(query, connection);
        command.Parameters.AddWithValue("@BallotId", vote.BallotId);
        command.Parameters.AddWithValue("@CandidateId", vote.CandidateId);
        connection.Open();
        command.ExecuteNonQuery();
    }
}
public Vote GetVoteById(int voteId)
{
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "SELECT * FROM Votes WHERE VoteId = @VoteId";
        SqlCommand command = new SqlCommand(query, connection);
        command.Parameters.AddWithValue("@VoteId", voteId);
        connection.Open();
        using (SqlDataReader reader = command.ExecuteReader())
        {
            if (reader.Read())
            {
                return new Vote
                {
VoteId = (int)reader["VoteId"], BallotId = (int)reader["BallotId"], CandidateId = (int)reader["CandidateId"], CreatedAt = (DateTime)reader["CreatedAt"] }; } } } return null; }
public IEnumerable<Vote> GetAllVotes()
{
    var votes = new List<Vote>();
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "SELECT * FROM Votes";
        SqlCommand command = new SqlCommand(query, connection);
        connection.Open();
        using (SqlDataReader reader = command.ExecuteReader())
        {
            while (reader.Read())
            {
                votes.Add(new Vote
                {
                    VoteId = (int)reader["VoteId"],
                    BallotId = (int)reader["BallotId"],
                    CandidateId = (int)reader["CandidateId"],
                    CreatedAt = (DateTime)reader["CreatedAt"]
                });
            }
        }
    }
    return votes;
}
public void UpdateVote(Vote vote)
{
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "UPDATE Votes SET BallotId = @BallotId, CandidateId = @CandidateId WHERE VoteId = @VoteId";
        SqlCommand command = new SqlCommand(query, connection);
        command.Parameters.AddWithValue("@BallotId", vote.BallotId);
        command.Parameters.AddWithValue("@CandidateId", vote.CandidateId);
        command.Parameters.AddWithValue("@VoteId", vote.VoteId);
        connection.Open();
        command.ExecuteNonQuery();
    }
}
public void DeleteVote(int voteId)
{
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "DELETE FROM Votes WHERE VoteId = @VoteId";
        SqlCommand command = new SqlCommand(query, connection);
        command.Parameters.AddWithValue("@VoteId", voteId);
        connection.Open();
        command.ExecuteNonQuery();
    }
}
}

public class ResultRepository { private readonly string _connectionString;
public ResultRepository()
{
    _connectionString = ConfigurationManager.ConnectionStrings["YourConnectionString"].ConnectionString;
}
public void AddResult(Result result)
{
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "INSERT INTO Results (ElectionId, CandidateId, VoteCount) VALUES (@ElectionId, @CandidateId, @VoteCount)";
        SqlCommand command = new SqlCommand(query, connection);
        command.Parameters.AddWithValue("@ElectionId", result.ElectionId);
        command.Parameters.AddWithValue("@CandidateId", result.CandidateId);
        command.Parameters.AddWithValue("@VoteCount", result.VoteCount);
        connection.Open();
        command.ExecuteNonQuery();
    }
}
public Result GetResultById(int resultId)
{
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "SELECT * FROM Results WHERE ResultId = @ResultId";
        SqlCommand command = new SqlCommand(query, connection);
        command.Parameters.AddWithValue("@ResultId", resultId);
        connection.Open();
        using (SqlDataReader reader = command.ExecuteReader())
        {
            if (reader.Read())
            {
                return new Result
                {
                    ResultId = (int)reader["ResultId"],
                    ElectionId = (int)reader["ElectionId"],
                    CandidateId = (int)reader["CandidateId"],
                    VoteCount = (int)reader["VoteCount"],
                    CreatedAt = (DateTime)reader["CreatedAt"]
                };
            }
        }
    }
    return null;
}
public IEnumerable<Result> GetAllResults()
{
    var results = new List<Result>();
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "SELECT * FROM Results";
        SqlCommand command = new SqlCommand(query, connection);
        connection.Open();
        using (SqlDataReader reader = command.ExecuteReader())
        {
            while (reader.Read())
            {
                results.Add(new Result
                {
                    ResultId = (int)reader["ResultId"],
                    ElectionId = (int)reader["ElectionId"],
                    CandidateId = (int)reader["CandidateId"],
                    VoteCount = (int)reader["VoteCount"],
                    CreatedAt = (DateTime)reader["CreatedAt"]
                });
            }
        }
    }
    return results;
}
public void UpdateResult(Result result)
{
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "UPDATE Results SET ElectionId = @ElectionId, CandidateId = @CandidateId, VoteCount = @VoteCount WHERE ResultId = @ResultId";
        SqlCommand command = new SqlCommand(query, connection);
command.Parameters.AddWithValue("@ElectionId", result.ElectionId); command.Parameters.AddWithValue("@CandidateId", result.CandidateId); command.Parameters.AddWithValue("@VoteCount", result.VoteCount); command.Parameters.AddWithValue("@ResultId", result.ResultId);
        connection.Open();
        command.ExecuteNonQuery();
    }
}
public void DeleteResult(int resultId)
{
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "DELETE FROM Results WHERE ResultId = @ResultId";
        SqlCommand command = new SqlCommand(query, connection);
        command.Parameters.AddWithValue("@ResultId", resultId);
        connection.Open();
        command.ExecuteNonQuery();
    }
}
}

public class NotificationRepository { private readonly string _connectionString;
public NotificationRepository()
{
    _connectionString = ConfigurationManager.ConnectionStrings["YourConnectionString"].ConnectionString;
}
public void AddNotification(Notification notification)
{
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "INSERT INTO Notifications (User Id, Message, IsRead) VALUES (@User Id, @Message, @IsRead)";
        SqlCommand command = new SqlCommand(query, 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 Notification GetNotificationById(int notificationId)
{
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "SELECT * FROM Notifications WHERE NotificationId = @NotificationId";
        SqlCommand command = new SqlCommand(query, connection);
        command.Parameters.AddWithValue("@NotificationId", notificationId);
        connection.Open();
        using (SqlDataReader reader = command.ExecuteReader())
        {
            if (reader.Read())
            {
                return new Notification
                {
                    NotificationId = (int)reader["NotificationId"],
                    UserId = (int)reader["User Id"],
                    Message = reader["Message"].ToString(),
                    IsRead = (bool)reader["IsRead"],
                    CreatedAt = (DateTime)reader["CreatedAt"]
                };
            }
        }
    }
    return null;
}
public IEnumerable<Notification> GetAllNotifications()
{
    var notifications = new List<Notification>();
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "SELECT * FROM Notifications";
        SqlCommand command = new SqlCommand(query, connection);
        connection.Open();
        using (SqlDataReader reader = command.ExecuteReader())
        {
            while (reader.Read())
            {
                notifications.Add(new Notification
                {
                    NotificationId = (int)reader["NotificationId"],
                    UserId = (int)reader["User Id"],
                    Message = reader["Message"].ToString(),
                    IsRead = (bool)reader["IsRead"],
                    CreatedAt = (DateTime)reader["CreatedAt"]
                });
            }
        }
    }
    return notifications;
}
public void UpdateNotification(Notification notification)
{
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "UPDATE Notifications SET UserId = @User Id, Message = @Message, IsRead = @IsRead WHERE NotificationId = @NotificationId";
        SqlCommand command = new SqlCommand(query, connection);
        command.Parameters.AddWithValue("@User Id", notification.UserId);
        command.Parameters.AddWithValue("@Message", notification.Message);
        command.Parameters.AddWithValue("@IsRead", notification.IsRead);
        command.Parameters.AddWithValue("@NotificationId", notification.NotificationId);
        connection.Open();
        command.ExecuteNonQuery();
    }
}
public void DeleteNotification(int notificationId)
{
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "DELETE FROM Notifications WHERE NotificationId = @NotificationId";
        SqlCommand command = new SqlCommand(query, connection);
        command.Parameters.AddWithValue("@NotificationId", notificationId);
        connection.Open();
        command.ExecuteNonQuery();
    }
}
}

public class SupportTicketRepository { private readonly string _connectionString;
public SupportTicketRepository()
{
    _connectionString = ConfigurationManager.ConnectionStrings["YourConnectionString"].ConnectionString;
}
public void AddSupportTicket(SupportTicket supportTicket)
{
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "INSERT INTO SupportTickets (User Id, Subject, Message, Status) VALUES (@User Id, @Subject, @Message, @Status)";
        SqlCommand command = new SqlCommand(query, connection);
        command.Parameters.AddWithValue("@User Id", supportTicket.UserId);
        command.Parameters.AddWithValue("@Subject", supportTicket.Subject);
        command.Parameters.AddWithValue("@Message", supportTicket.Message);
        command.Parameters.AddWithValue("@Status", supportTicket.Status);
        connection.Open();
        command.ExecuteNonQuery();
    }
}
public SupportTicket GetSupportTicketById(int supportTicketId)
{
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "SELECT * FROM SupportTickets WHERE SupportTicketId = @SupportTicketId";
        SqlCommand command = new SqlCommand(query, connection);
        command.Parameters.AddWithValue("@SupportTicketId", supportTicketId);
        connection.Open();
        using (SqlDataReader reader = command.ExecuteReader())
        {
            if (reader.Read())
            {
                return new SupportTicket
                {
                    SupportTicketId = (int)reader["SupportTicketId"],
                    UserId = (int)reader["User  Id"],
                    CreatedAt = (DateTime)reader["CreatedAt"],
                    Subject = reader["Subject"].ToString(),
                    Message = reader["Message"].ToString(),
                    Status = reader["Status"].ToString()
                };
            }
        }
    }
    return null;
}
public IEnumerable<SupportTicket> GetAllSupportTickets()
{
    var supportTickets = new List<SupportTicket>();
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "SELECT * FROM SupportTickets";
        SqlCommand command = new SqlCommand(query, connection);
        connection.Open();
        using (SqlDataReader reader = command.ExecuteReader())
        {
            while (reader.Read())
            {
                supportTickets.Add(new SupportTicket
                {
                    SupportTicketId = (int)reader["SupportTicketId"],
                    UserId = (int)reader["User  Id"],
                    CreatedAt = (DateTime)reader["CreatedAt"],
                    Subject = reader["Subject"].ToString(),
                    Message = reader["Message"].ToString(),
                    Status = reader["Status"].ToString()
                });
            }
        }
    }
    return supportTickets;
}
public void UpdateSupportTicket(SupportTicket supportTicket)
{
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "UPDATE SupportTickets SET UserId = @User  Id, Subject = @Subject, Message = @Message, Status = @Status WHERE SupportTicketId = @SupportTicketId";
        SqlCommand command = new SqlCommand(query, connection);
        command.Parameters.AddWithValue("@User  Id", supportTicket.UserId);
        command.Parameters.AddWithValue("@Subject", supportTicket.Subject);
        command.Parameters.AddWithValue("@Message", supportTicket.Message);
        command.Parameters.AddWithValue("@Status", supportTicket.Status);
        command.Parameters.AddWithValue("@SupportTicketId", supportTicket.SupportTicketId);
        connection.Open();
        command.ExecuteNonQuery();
    }
}
public void DeleteSupportTicket(int supportTicketId)
{
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "DELETE FROM SupportTickets WHERE SupportTicketId = @SupportTicketId";
        SqlCommand command = new SqlCommand(query, connection);
        command.Parameters.AddWithValue("@SupportTicketId", supportTicketId);
        connection.Open();
        command.ExecuteNonQuery();
    }
}
}

public class FeedbackRepository { private readonly string _connectionString;
public FeedbackRepository()
{
    _connectionString = ConfigurationManager.ConnectionStrings["YourConnectionString"].ConnectionString;
}
public void AddFeedback(Feedback feedback)
{
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "INSERT INTO Feedback (User  Id, Comments) VALUES (@User  Id, @Comments)";
        SqlCommand command = new SqlCommand(query, connection);
        command.Parameters.AddWithValue("@User  Id", feedback.UserId);
        command.Parameters.AddWithValue("@Comments", feedback.Comments);
        connection.Open();
        command.ExecuteNonQuery();
    }
}
public Feedback GetFeedbackById(int feedbackId)
{
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "SELECT * FROM Feedback WHERE FeedbackId = @FeedbackId";
        SqlCommand command = new SqlCommand(query, connection);
        command.Parameters.AddWithValue("@FeedbackId", feedbackId);
        connection.Open();
        using (SqlDataReader reader = command.ExecuteReader())
        {
            if (reader.Read())
            {
                return new Feedback
                {
                    FeedbackId = (int)reader["FeedbackId"],
                    UserId = (int)reader["User  Id"],
                    Comments = reader["Comments"].ToString(),
                    CreatedAt = (DateTime)reader["CreatedAt"]
                };
            }
        }
    }
    return null;
}
public IEnumerable<Feedback> GetAllFeedbacks()
{
    var feedbacks = new List<Feedback>();
    using (SqlConnection connection = new SqlConnection(_connectionString ))
    {
        string query = "SELECT * FROM Feedback";
        SqlCommand command = new SqlCommand(query, connection);
        connection.Open();
        using (SqlDataReader reader = command.ExecuteReader())
        {
            while (reader.Read())
            {
                feedbacks.Add(new Feedback
                {
                    FeedbackId = (int)reader["FeedbackId"],
                    UserId = (int)reader["User   Id"],
                    Comments = reader["Comments"].ToString(),
                    CreatedAt = (DateTime)reader["CreatedAt"]
                });
            }
        }
    }
    return feedbacks;
}
public void UpdateFeedback(Feedback feedback)
{
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "UPDATE Feedback SET UserId = @User   Id, Comments = @Comments WHERE FeedbackId = @FeedbackId";
        SqlCommand command = new SqlCommand(query, connection);
        command.Parameters.AddWithValue("@User   Id", feedback.UserId);
        command.Parameters.AddWithValue("@Comments", feedback.Comments);
        command.Parameters.AddWithValue("@FeedbackId", feedback.FeedbackId);
        connection.Open();
        command.ExecuteNonQuery();
    }
}
public void DeleteFeedback(int feedbackId)
{
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        string query = "DELETE FROM Feedback WHERE FeedbackId = @FeedbackId";
        SqlCommand command = new SqlCommand(query, connection);
        command.Parameters.AddWithValue("@FeedbackId", feedbackId);
        connection.Open();
        command.ExecuteNonQuery();
    }
}
}

Now create controller for each repository

To create controllers for each repository in an ASP.NET application, we will follow the MVC (Model-View-Controller) pattern. Each controller will handle HTTP requests, interact with the corresponding repository, and return appropriate responses.

Below are example controllers for each of the repositories we created earlier

These controllers will use dependency injection to access the repositories.

UserController

using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
[Route("api/[controller]")]
[ApiController]
public class UserController : ControllerBase
{
    private readonly UserRepository _userRepository;
    public UserController()
    {
        _userRepository = new UserRepository(); // Ideally, use Dependency Injection
    }
    [HttpGet]
    public ActionResult<IEnumerable<User>> GetAllUsers()
    {
        var users = _userRepository.GetAllUsers();
        return Ok(users);
    }
    [HttpGet("{id}")]
    public ActionResult<User> GetUser ById(int id)
    {
        var user = _userRepository.GetUser ById(id);
        if (user == null)
        {
            return NotFound();
        }
        return Ok(user);
    }
    [HttpPost]
    public ActionResult<User> CreateUser ([FromBody] User user)
    {
        _userRepository.AddUser (user);
        return CreatedAtAction(nameof(GetUser ById), new { id = user.UserId }, user);
    }
    [HttpPut("{id}")]
    public IActionResult UpdateUser (int id, [FromBody] User user)
    {
        if (id != user.UserId)
        {
            return BadRequest();
        }
        _userRepository.UpdateUser (user);
        return NoContent();
    }
    [HttpDelete("{id}")]
    public IActionResult DeleteUser (int id)
    {
        _userRepository.DeleteUser (id);
        return NoContent();
    }
}

RoleController

using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
[Route("api/[controller]")]
[ApiController]
public class RoleController : ControllerBase
{
    private readonly RoleRepository _roleRepository;
    public RoleController()
    {
        _roleRepository = new RoleRepository(); // Ideally, use Dependency Injection
    }
    [HttpGet]
    public ActionResult<IEnumerable<Role>> GetAllRoles()
    {
        var roles = _roleRepository.GetAllRoles();
        return Ok(roles);
    }
    [HttpGet("{id}")]
    public ActionResult<Role> GetRoleById(int id)
    {
        var role = _roleRepository.GetRoleById(id);
        if (role == null)
        {
            return NotFound();
        }
        return Ok(role);
    }
    [HttpPost]
    public ActionResult<Role> CreateRole([FromBody] Role role)
    {
        _roleRepository.AddRole(role);
        return CreatedAtAction(nameof(GetRoleById), new { id = role.RoleId }, role);
    }
    [HttpPut("{id}")]
    public IActionResult UpdateRole(int id, [FromBody] Role role)
    {
        if (id != role.RoleId)
        {
            return BadRequest();
        }
        _roleRepository.UpdateRole(role);
        return NoContent();
    }
    [HttpDelete("{id}")]
    public IActionResult DeleteRole(int id)
    {
        _roleRepository.DeleteRole(id);
        return NoContent();
    }
}

ElectionController

using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
[Route("api/[controller]")]
[ApiController]
public class ElectionController : ControllerBase
{
    private readonly ElectionRepository _electionRepository;
    public ElectionController()
    {
        _electionRepository = new ElectionRepository(); // Ideally, use Dependency Injection
    }
    [HttpGet]
    public ActionResult<IEnumerable<Election>> GetAllElections()
    {
        var elections = _electionRepository.GetAllElections();
        return Ok(elections);
    }
    [HttpGet("{id}")]
    public ActionResult<Election> GetElectionById(int id)
    {
        var election = _electionRepository.GetElectionById(id);
        if (election == null)
        {
            return NotFound();
        }
        return Ok(election);
    }
    [HttpPost]
    public ActionResult<Election> CreateElection([FromBody] Election election)
    {
        _electionRepository.AddElection(election);
        return CreatedAtAction(nameof(GetElectionById), new { id = election.ElectionId }, election);
    }
    [HttpPut("{id}")]
    public IActionResult UpdateElection(int id, [FromBody] Election election)
    {
        if (id != election.ElectionId)
        {
            return BadRequest();
        }
        _electionRepository.UpdateElection(election);
        return NoContent();
    }
    [HttpDelete("{id}")]
    public IActionResult DeleteElection(int id)
    {
        _electionRepository.DeleteElection(id);
        return NoContent();
    }
}

CandidateController

using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
[Route("api/[controller]")]
[ApiController]
public class CandidateController : ControllerBase
{
    private readonly CandidateRepository _candidateRepository;
    public CandidateController()
    {
        _candidateRepository = new CandidateRepository(); // Ideally, use Dependency Injection
    }
    [HttpGet]
    public ActionResult<IEnumerable<Candidate>> GetAllCandidates()
    {
        var candidates = _candidateRepository.GetAllCandidates();
        return Ok(candidates);
    }
    [HttpGet("{id}")]
    public ActionResult<Candidate> GetCandidateById(int id)
    {
        var candidate = _candidateRepository.GetCandidateById(id);
        if (candidate == null)
        {
            return NotFound();
        }
        return Ok(candidate);
    }
    [HttpPost]
    public ActionResult<Candidate> CreateCandidate([FromBody] Candidate candidate)
    {
        _candidateRepository.AddCandidate(candidate);
        return CreatedAtAction(nameof(GetCandidateById), new { id = candidate.CandidateId }, candidate);
    }
    [HttpPut("{id}")]
    public IActionResult UpdateCandidate(int id, [FromBody] Candidate candidate)
    {
        if (id != candidate.CandidateId)
        {
            return BadRequest();
        }
        _candidateRepository.UpdateCandidate(candidate);
        return NoContent();
    }
    [HttpDelete("{id}")]
    public IActionResult DeleteCandidate(int id)
    {
        _candidateRepository.DeleteCandidate(id);
        return NoContent();
    }
}

BallotController

using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
[Route("api/[controller]")]
[ApiController]
public class BallotController : ControllerBase
{
    private readonly BallotRepository _ballotRepository;
    public BallotController()
    {
        _ballotRepository = new BallotRepository(); // Ideally, use Dependency Injection
    }
    [HttpGet]
    public ActionResult<IEnumerable<Ballot>> GetAllBallots()
    {
        var ballots = _ballotRepository.GetAllBallots();
        return Ok(ballots);
    }
    [HttpGet("{id}")]
    public ActionResult<Ballot> GetBallotById(int id)
    {
        var ballot = _ballotRepository.GetBallotById(id);
        if (ballot == null)
        {
            return NotFound();
        }
        return Ok(ballot);
    }
    [HttpPost]
    public ActionResult<Ballot> CreateBallot([FromBody] Ballot ballot)
    {
        _ballotRepository.AddBallot(ballot);
        return CreatedAtAction(nameof(GetBallotById), new { id = ballot.BallotId }, ballot);
    }
    [HttpPut("{id}")]
    public IActionResult UpdateBallot(int id, [FromBody] Ballot ballot)
    {
        if (id != ballot.BallotId)
        {
            return BadRequest();
        }
        _ballotRepository.UpdateBallot(ballot);
        return NoContent();
    }
    [HttpDelete("{id}")]
    public IActionResult DeleteBallot(int id)
    {
        _ballotRepository.DeleteBallot(id);
        return NoContent();
    }
}

VoteController

using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
[Route("api/[controller]")]
[ApiController]
public class VoteController : ControllerBase
{
    private readonly VoteRepository _voteRepository;
    public VoteController()
    {
        _voteRepository = new VoteRepository(); // Ideally, use Dependency Injection
    }
    [HttpGet]
    public ActionResult<IEnumerable<Vote>> GetAllVotes()
    {
        var votes = _voteRepository.GetAllVotes();
        return Ok(votes);
    }
    [HttpGet("{id}")]
    public ActionResult<Vote> GetVoteById(int id)
    {
        var vote = _voteRepository.GetVoteById(id);
        if (vote == null)
        {
            return NotFound();
        }
        return Ok(vote);
    }
    [HttpPost]
    public ActionResult<Vote> CreateVote([FromBody] Vote vote)
    {
        _voteRepository.AddVote(vote);
        return CreatedAtAction(nameof(GetVoteById), new { id = vote.VoteId }, vote);
    }
    [HttpPut("{id}")]
    public IActionResult UpdateVote(int id, [FromBody] Vote vote)
    {
        if (id != vote.VoteId)
        {
            return BadRequest();
        }
        _voteRepository.UpdateVote(vote);
        return NoContent();
    }
    [HttpDelete("{id}")]
    public IActionResult DeleteVote(int id)
    {
        _voteRepository.DeleteVote(id);
        return NoContent();
    }
}

ResultController

using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
[Route("api/[controller]")]
[ApiController]
public class ResultController : ControllerBase
{
    private readonly ResultRepository _resultRepository;
    public ResultController()
    {
        _resultRepository = new ResultRepository(); // Ideally, use Dependency Injection
    }
    [HttpGet]
    public ActionResult<IEnumerable<Result>> GetAllResults()
    {
        var results = _resultRepository.GetAllResults();
        return Ok(results);
    }
    [HttpGet("{id}")]
    public ActionResult<Result> GetResultById(int id)
    {
        var result = _resultRepository.GetResultById(id);
        if (result == null)
        {
            return NotFound();
        }
        return Ok(result);
    }
    [HttpPost]
    public ActionResult<Result> CreateResult([FromBody] Result result)
    {
        _resultRepository.AddResult(result);
        return CreatedAtAction(nameof(GetResultById), new { id = result.ResultId }, result);
    }
    [HttpPut("{id}")]
    public IActionResult UpdateResult(int id, [FromBody] Result result)
    {
        if (id != result.ResultId)
        {
            return BadRequest();
        }
        _resultRepository.UpdateResult(result);
        return NoContent();
    }
    [HttpDelete("{id}")]
    public IActionResult DeleteResult(int id)
    {
        _resultRepository.DeleteResult(id);
        return NoContent();
    }
}

NotificationController

using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
[Route("api/[controller]")]
[ApiController]
public class NotificationController : ControllerBase
{
    private readonly NotificationRepository _notificationRepository;
    public NotificationController()
    {
        _notificationRepository = new NotificationRepository(); // Ideally, use Dependency Injection
    }
    [HttpGet]
    public ActionResult<IEnumerable<Notification>> GetAllNotifications()
    {
        var notifications = _notificationRepository.GetAllNotifications();
        return Ok(notifications);
    }
    [HttpGet("{id}")]
    public ActionResult<Notification> GetNotificationById(int id)
    {
        var notification = _notificationRepository.GetNotificationById(id);
        if (notification == null)
        {
            return NotFound();
        }
        return Ok(notification);
    }
    [HttpPost]
    public ActionResult<Notification> CreateNotification([FromBody] Notification notification)
    {
        _notificationRepository.AddNotification(notification);
        return CreatedAtAction(nameof(GetNotificationById), new { id = notification.NotificationId }, notification);
    }
    [HttpPut("{id}")]
    public IActionResult UpdateNotification(int id, [FromBody] Notification notification)
    {
        if (id != notification.NotificationId)
        {
            return BadRequest();
        }
        _notificationRepository.UpdateNotification(notification);
        return NoContent();
    }
    [HttpDelete("{id}")]
    public IActionResult DeleteNotification(int id)
    {
        _notificationRepository.DeleteNotification(id);
        return NoContent();
    }
}

SupportTicketController

using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
[Route("api/[controller]")]
[ApiController]
public class SupportTicketController : ControllerBase
{
    private readonly SupportTicketRepository _supportTicketRepository;
    public SupportTicketController()
    {
        _supportTicketRepository = new SupportTicketRepository(); // Ideally, use Dependency Injection
    }
    [HttpGet]
    public ActionResult<IEnumerable<SupportTicket>> GetAllSupportTickets()
    {
        var supportTickets = _supportTicketRepository.GetAllSupportTickets();
        return Ok(supportTickets);
    }
    [HttpGet("{id}")]
    public ActionResult<SupportTicket> GetSupportTicketById(int id)
    {
        var supportTicket = _supportTicketRepository.GetSupportTicketById(id);
        if (supportTicket == null)
        {
            return NotFound();
        }
        return Ok(supportTicket);
    }
    [HttpPost]
    public ActionResult<SupportTicket> CreateSupportTicket([FromBody] SupportTicket supportTicket)
    {
        _supportTicketRepository.AddSupportTicket(supportTicket);
        return CreatedAtAction(nameof(GetSupportTicketById), new { id = supportTicket.SupportTicketId }, supportTicket);
    }
    [HttpPut("{id}")]
    public IActionResult UpdateSupportTicket(int id, [FromBody] SupportTicket supportTicket)
    {
        if (id != supportTicket.SupportTicketId)
        {
            return BadRequest();
        }
        _supportTicketRepository.UpdateSupportTicket(supportTicket);
        return NoContent();
    }
    [HttpDelete("{id}")]
    public IActionResult DeleteSupportTicket(int id)
    {
        _supportTicketRepository.DeleteSupportTicket(id);
        return NoContent();
    }
}

FeedbackController

using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
[Route("api/[controller]")]
[ApiController]
public class FeedbackController : ControllerBase
{
    private readonly FeedbackRepository _feedbackRepository;
    public FeedbackController()
    {
        _feedbackRepository = new FeedbackRepository(); // Ideally, use Dependency Injection
    }
    [HttpGet]
    public ActionResult<IEnumerable<Feedback>> GetAllFeedbacks()
    {
        var feedbacks = _feedbackRepository.GetAllFeedbacks();
        return Ok(feedbacks);
    }
    [HttpGet("{id}")]
    public ActionResult<Feedback> GetFeedbackById(int id)
    {
        var feedback = _feedbackRepository.GetFeedbackById(id);
        if (feedback == null)
        {
            return NotFound();
        }
        return Ok(feedback);
    }
    [HttpPost]
    public ActionResult<Feedback> CreateFeedback([FromBody] Feedback feedback)
    {
        _feedbackRepository.AddFeedback(feedback);
        return CreatedAtAction(nameof(GetFeedbackById), new { id = feedback.FeedbackId }, feedback);
    }
    [HttpPut("{id}")]
    public IActionResult UpdateFeedback(int id, [FromBody] Feedback feedback)
    {
        if (id != feedback.FeedbackId)
        {
            return BadRequest();
        }
        _feedbackRepository.UpdateFeedback(feedback);
        return NoContent();
    }
    [HttpDelete("{id}")]
    public IActionResult DeleteFeedback(int id)
    {
        _feedbackRepository.DeleteFeedback(id);
        return NoContent();
    }
}

These controllers provide a RESTful API for each of the repositories

Allowing for CRUD operations on the respective models. Each controller follows a similar structure, ensuring consistency across the application.

Creating view files for each of the controllers in an ASP.NET MVC application

Typically involves creating Razor views that correspond to the actions in the controllers. Below, I will provide a basic structure for the views associated with each controller. These views will be simple and will focus on displaying data and providing forms for creating and editing records.

User Views

Views/User/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("Edit", new { id = user.UserId })'>Edit</a> |
                    <a href='@Url.Action("Delete", new { id = user.UserId })'>Delete</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Views/User/Create.cshtml

@model YourNamespace.Models.User
<h2>Create User</h2>
<form asp-action="Create">
    <div>
        <label>Username</label>
        <input asp-for="Username" />
    </div>
    <div>
        <label>Password</label>
        <input asp-for="PasswordHash" type="password" />
    </div>
    <div>
        <label>Email</label>
        <input asp-for="Email" />
    </div>
    <div>
        <label>Role ID</label>
        <input asp-for="RoleId" />
    </div>
    <button type="submit">Create</button>
</form>

Views/User/Edit.cshtml

@model YourNamespace.Models.User
<h2>Edit User</h2>
<form asp-action="Edit">
    <input type="hidden" asp-for="User Id" />
    <div>
        <label>Username</label>
        <input asp-for="Username" />
    </div>
    <div>
        <label>Password</label>
        <input asp-for="PasswordHash" type="password" />
    </div>
    <div>
        <label>Email</label>
        <input asp-for="Email" />
    </div>
    <div>
        <label>Role ID</label>
        <input asp-for="RoleId" />
    </div>
    <button type="submit">Save</button>
</form>

Role Views

Views/Role/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("Edit", new { id = role.RoleId })'>Edit</a> |
                    <a href='@Url.Action("Delete", new { id = role.RoleId })'>Delete</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Views/Role/Create.cshtml

@model YourNamespace.Models.Role
<h2>Create Role</h2>
<form asp-action="Create">
    <div>
        <label>Role Name</label>
        <input asp-for="RoleName" />
    </div>
    <button type="submit">Create</button>
</form>

Views/Role/Edit.cshtml

@model YourNamespace.Models.Role
<h2>Edit Role</h2>
<form asp-action="Edit">
    <input type="hidden" asp-for="RoleId" />
    <div>
        <label>Role Name</label>
        <input asp-for="RoleName" />
    </div>
    <button type="submit">Save</button>
</form>

Election Views

Views/Election/Index.cshtml

@model IEnumerable<YourNamespace.Models.Election>
<h2>Elections</h2>
<a href='@Url.Action("Create")'>Create New Election</a>
<table>
    <thead>
        <tr>
            <th>Title</th>
            <th>Start Date</th>
            <th>End Date</th>
            <th>Actions</th </tr>
    </thead>
    <tbody>
        @foreach (var election in Model)
        {
            <tr>
                <td>@election.Title</td>
                <td>@election.StartDate.ToShortDateString()</td>
                <td>@election.EndDate.ToShortDateString()</td>
                <td>
                    <a href='@Url.Action("Edit", new { id = election.ElectionId })'>Edit</a> |
                    <a href='@Url.Action("Delete", new { id = election.ElectionId })'>Delete</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Views/Election/Create.cshtml

@model YourNamespace.Models.Election
<h2>Create Election</h2>
<form asp-action="Create">
    <div>
        <label>Title</label>
        <input asp-for="Title" />
    </div>
    <div>
        <label>Start Date</label>
        <input asp-for="StartDate" type="date" />
    </div>
    <div>
        <label>End Date</label>
        <input asp-for="EndDate" type="date" />
    </div>
    <button type="submit">Create</button>
</form>

Views/Election/Edit.cshtml

@model YourNamespace.Models.Election
<h2>Edit Election</h2>
<form asp-action="Edit">
    <input type="hidden" asp-for="ElectionId" />
    <div>
        <label>Title</label>
        <input asp-for="Title" />
    </div>
    <div>
        <label>Start Date</label>
        <input asp-for="StartDate" type="date" />
    </div>
    <div>
        <label>End Date</label>
        <input asp-for="EndDate" type="date" />
    </div>
    <button type="submit">Save</button>
</form>

Candidate Views

Views/Candidate/Index.cshtml

@model IEnumerable<YourNamespace.Models.Candidate>
<h2>Candidates</h2>
<a href='@Url.Action("Create")'>Create New Candidate</a>
<table>
    <thead>
        <tr>
            <th>Name</th>
            <th>Election ID</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var candidate in Model)
        {
            <tr>
                <td>@candidate.Name</td>
                <td>@candidate.ElectionId</td>
                <td>
                    <a href='@Url.Action("Edit", new { id = candidate.CandidateId })'>Edit</a> |
                    <a href='@Url.Action("Delete", new { id = candidate.CandidateId })'>Delete</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Views/Candidate/Create.cshtml

@model YourNamespace.Models.Candidate
<h2>Create Candidate</h2>
<form asp-action="Create">
    <div>
        <label>Name</label>
        <input asp-for="Name" />
    </div>
    <div>
        <label>Election ID</label>
        <input asp-for="ElectionId" />
    </div>
    <button type="submit">Create</button>
</form>

Views/Candidate/Edit.cshtml

@model YourNamespace.Models.Candidate
<h2>Edit Candidate</h2>
<form asp-action="Edit">
    <input type="hidden" asp-for="CandidateId" />
    <div>
        <label>Name</label>
        <input asp-for="Name" />
    </div>
    <div>
        <label>Election ID</label>
        <input asp-for="ElectionId" />
    </div>
    <button type="submit">Save</button>
</form>

Ballot Views

Views/Ballot/Index.cshtml

@model IEnumerable<YourNamespace.Models.Ballot>
<h2>Ballots</h2>
<a href='@Url.Action("Create")'>Create New Ballot</a>
<table>
    <thead>
        <tr>
            <th>Ballot ID</th>
            <th>Election ID</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var ballot in Model)
        {
            <tr>
                <td>@ballot.BallotId</td>
                <td>@ballot.ElectionId</td>
                <td>
                    <a href='@Url.Action("Edit", new { id = ballot.BallotId })'>Edit</a> |
                    <a href ="@Url.Action("Delete", new { id = ballot.BallotId })'>Delete</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Views/Ballot/Create.cshtml

@model YourNamespace.Models.Ballot
<h2>Create Ballot</h2>
<form asp-action="Create">
    <div>
        <label>Election ID</label>
        <input asp-for="ElectionId" />
    </div>
    <button type="submit">Create</button>
</form>

Views/Ballot/Edit.cshtml

@model YourNamespace.Models.Ballot
<h2>Edit Ballot</h2>
<form asp-action="Edit">
    <input type="hidden" asp-for="BallotId" />
    <div>
        <label>Election ID</label>
        <input asp-for="ElectionId" />
    </div>
    <button type="submit">Save</button>
</form>

Vote Views

Views/Vote/Index.cshtml

@model IEnumerable<YourNamespace.Models.Vote>
<h2>Votes</h2>
<a href='@Url.Action("Create")'>Create New Vote</a>
<table>
    <thead>
        <tr>
            <th>Vote ID</th>
            <th>Candidate ID</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var vote in Model)
        {
            <tr>
                <td>@vote.VoteId</td>
                <td>@vote.CandidateId</td>
                <td>
                    <a href='@Url.Action("Edit", new { id = vote.VoteId })'>Edit</a> |
                    <a href='@Url.Action("Delete", new { id = vote.VoteId })'>Delete</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Views/Vote/Create.cshtml

@model YourNamespace.Models.Vote
<h2>Create Vote</h2>
<form asp-action="Create">
    <div>
        <label>Candidate ID</label>
        <input asp-for="CandidateId" />
    </div>
    <button type="submit">Create</button>
</form>

Views/Vote/Edit.cshtml

@model YourNamespace.Models.Vote
<h2>Edit Vote</h2>
<form asp-action="Edit">
    <input type="hidden" asp-for="VoteId" />
    <div>
        <label>Candidate ID</label>
        <input asp-for="CandidateId" />
    </div>
    <button type="submit">Save</button>
</form>

Result Views

Views/Result/Index.cshtml

@model IEnumerable<YourNamespace.Models.Result>
<h2>Results</h2>
<a href='@Url.Action("Create")'>Create New Result</a>
<table>
    <thead>
        <tr>
            <th>Result ID</th>
            <th>Election ID</th>
            <th>Candidate ID</th>
            <th>Votes</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var result in Model)
        {
            <tr>
                <td>@result.ResultId</td>
                <td>@result.ElectionId</td>
                <td>@result.CandidateId</td>
                <td>@result.Votes</td>
                <td>
                    <a href='@Url.Action("Edit", new { id = result.ResultId })'>Edit</a> |
                    <a href='@Url.Action("Delete", new { id = result.ResultId })'>Delete</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Views/Result/Create.cshtml

@model YourNamespace.Models.Result
<h2>Create Result</h2>
<form asp-action="Create">
    <div>
        <label>Election ID</label>
        <input asp-for="ElectionId" />
    </div>
    <div>
        <label>Candidate ID</label>
        <input asp-for="CandidateId" />
    </div>
    <div>
        <label>Votes</label>
        <input asp-for="Votes" />
    </div>
    <button type="submit">Create</button>
</form>

Views/Result/Edit.cshtml

@model YourNamespace.Models.Result
<h2>Edit Result</h2>
<form asp-action="Edit">
    <input type="hidden" asp-for="ResultId" />
    <div>
        <label>Election ID</label>
        <input asp-for="Election Id" />
    </div>
    <div>
        <label>Candidate ID</label>
        <input asp-for="CandidateId" />
    </div>
    <div>
        <label>Votes</label>
        <input asp-for="Votes" />
    </div>
    <button type="submit">Save</button>
</form>

Notification Views

Views/Notification/Index.cshtml

@model IEnumerable<YourNamespace.Models.Notification>
<h2>Notifications</h2>
<a href='@Url.Action("Create")'>Create New Notification</a>
<table>
    <thead>
        <tr>
            <th>Notification ID</th>
            <th>Message</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var notification in Model)
        {
            <tr>
                <td>@notification.NotificationId</td>
                <td>@notification.Message</td>
                <td>
                    <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>

Views/Notification/Create.cshtml

@model YourNamespace.Models.Notification
<h2>Create Notification</h2>
<form asp-action="Create">
    <div>
        <label>Message</label>
        <input asp-for="Message" />
    </div>
    <button type="submit">Create</button>
</form>

Views/Notification/Edit.cshtml

@model YourNamespace.Models.Notification
<h2>Edit Notification</h2>
<form asp-action="Edit">
    <input type="hidden" asp-for="NotificationId" />
    <div>
        <label>Message</label>
        <input asp-for="Message" />
    </div>
    <button type="submit">Save</button>
</form>

SupportTicket Views

Views/SupportTicket/Index.cshtml

@model IEnumerable<YourNamespace.Models.SupportTicket>
<h2>Support Tickets</h2>
<a href='@Url.Action("Create")'>Create New Support Ticket</a>
<table>
    <thead>
        <tr>
            <th>Ticket ID</th>
            <th>Subject</th>
            <th>Status</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var ticket in Model)
        {
            <tr>
                <td>@ticket.SupportTicketId</td>
                <td>@ticket.Subject</td>
                <td>@ticket.Status</td>
                <td>
                    <a href='@Url.Action("Edit", new { id = ticket.SupportTicketId })'>Edit</a> |
                    <a href='@Url.Action("Delete", new { id = ticket.SupportTicketId })'>Delete</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Views/SupportTicket/Create.cshtml

@model YourNamespace.Models.SupportTicket
<h2>Create Support Ticket</h2>
<form asp-action="Create">
    <div>
        <label>Subject</label>
        <input asp-for="Subject" />
    </div>
    <div>
        <label>Description</label>
        <textarea asp-for="Description"></textarea>
    </div>
    <div>
        <label>Status</label>
        <input asp-for="Status" />
    </div>
    <button type="submit">Create</button>
</form>

Views/SupportTicket/Edit.cshtml

@model YourNamespace.Models.SupportTicket
<h2>Edit Support Ticket</h2>
<form asp-action="Edit">
    <input type="hidden" asp-for="SupportTicketId" />
    <div>
        <label>Subject</label>
        <input asp-for="Subject" />
    </div>
    <div>
        <label>Description</label>
        <textarea asp-for="Description"></textarea>
    </div>
    <div>
        <label>Status</label>
        <input asp-for="Status" />
    </div>
    <button type="submit">Save</button>
</form>

Feedback Views

Views/Feedback/Index.cshtml

@model IEnumerable<YourNamespace.Models.Feedback>
<h2>Feedbacks</h2>
<a href='@Url.Action("Create")'>Create New Feedback</a>
<table>
    <thead>
        <tr>
            <th>Feedback ID</th>
            <th>Comment</th>
            <th>Actions</th>
        </tr>
    </thead>
 <tbody>
        @foreach (var feedback in Model)
        {
            <tr>
                <td>@feedback.FeedbackId</td>
                <td>@feedback.Comment</td>
                <td>
                    <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>

Views/Feedback/Create.cshtml

@model YourNamespace.Models.Feedback
<h2>Create Feedback</h2>
<form asp-action="Create">
    <div>
        <label>Comment</label>
        <textarea asp-for="Comment"></textarea>
    </div>
    <button type="submit">Create</button>
</form>

Views/Feedback/Edit.cshtml

@model YourNamespace.Models.Feedback
<h2>Edit Feedback</h2>
<form asp-action="Edit">
    <input type="hidden" asp-for="FeedbackId" />
    <div>
        <label>Comment</label>
        <textarea asp-for="Comment"></textarea>
    </div>
    <button type="submit">Save</button>
</form>

These views provide a basic structure for displaying, creating, and editing records for each of the controllers

You can further enhance these views with additional styling, validation, and features as needed.

Creating a dashboard page in an ASP.NET MVC application

Involves aggregating data from various models and displaying it in a user-friendly format. Below, I will provide an example of how to create a dashboard view that consolidates data related to users, roles, elections, candidates, votes, results, notifications, support tickets, and feedback.

Step 1: Create a Dashboard ViewModel

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

Models/DashboardViewModel.cs

using System.Collections.Generic;
public class DashboardViewModel
{
    public int TotalUsers { get; set; }
    public int TotalRoles { get; set; }
    public int TotalElections { get; set; }
    public int TotalCandidates { get; set; }
    public int TotalVotes { get; set; }
    public int TotalResults { get; set; }
    public int TotalNotifications { get; set; }
    public int TotalSupportTickets { get; set; }
    public int TotalFeedbacks { get; set; }
}

Step 2: Create a Dashboard Controller

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

Controllers/DashboardController.cs

using Microsoft.AspNetCore.Mvc;
public class DashboardController : Controller
{
    private readonly UserRepository _userRepository;
    private readonly RoleRepository _roleRepository;
    private readonly ElectionRepository _electionRepository;
    private readonly CandidateRepository _candidateRepository;
    private readonly VoteRepository _voteRepository;
    private readonly ResultRepository _resultRepository;
    private readonly NotificationRepository _notificationRepository;
    private readonly SupportTicketRepository _supportTicketRepository;
    private readonly FeedbackRepository _feedbackRepository;
    public DashboardController()
    {
        _userRepository = new UserRepository();
        _roleRepository = new RoleRepository();
        _electionRepository = new ElectionRepository();
        _candidateRepository = new CandidateRepository();
        _voteRepository = new VoteRepository();
        _resultRepository = new ResultRepository();
        _notificationRepository = new NotificationRepository();
        _supportTicketRepository = new SupportTicketRepository();
        _feedbackRepository = new FeedbackRepository();
    }
    public IActionResult Index()
    {
        var model = new DashboardViewModel
        {
            TotalUsers = _userRepository.GetAllUsers().Count(),
            TotalRoles = _roleRepository.GetAllRoles().Count(),
            TotalElections = _electionRepository.GetAllElections().Count(),
            TotalCandidates = _candidateRepository.GetAllCandidates().Count(),
            TotalVotes = _voteRepository.GetAllVotes().Count(),
            TotalResults = _resultRepository.GetAllResults().Count(),
            TotalNotifications = _notificationRepository.GetAllNotifications().Count(),
            TotalSupportTickets = _supportTicketRepository.GetAllSupportTickets().Count(),
            TotalFeedbacks = _feedbackRepository.GetAllFeedbacks().Count()
        };
        return View(model);
    }
}

Step 3: Create the Dashboard View

Now, we will create the view that will display the dashboard data.

Views/Dashboard/Index.cshtml

@model YourNamespace.Models.DashboardViewModel
@{
    ViewData["Title"] = "Dashboard";
}
<h2>Dashboard</h2>
<div class="dashboard">
    <div class="card">
        <h3>Total Users</h3>
        <p>@Model.TotalUsers</p>
    </div>
    <div class="card">
        <h3>Total Roles</h3>
        <p>@Model.TotalRoles</p>
    </div>
    <div class="card">
        <h3>Total Elections</h3>
        <p>@Model.TotalElections</p>
    </div>
    <div class="card">
        <h3>Total Candidates</h3>
        <p>@Model.TotalCandidates</p>
    </div>
    <div class="card">
        <h3>Total Votes</h3>
        <p>@Model.TotalVotes</p>
    </div>
    <div class="card">
        <h3>Total Results</h3>
        <p>@Model.TotalResults</p>
    </div>
    <div class="card">
        <h3>Total Notifications</h3>
        <p>@Model.TotalNotifications</p>
    </div>
    <div class="card">
        <h3>Total Support Tickets</h3>
        <p>@Model.TotalSupportTickets</p>
    </div>
    <div class="card">
        <h3>Total Feedbacks</h3>
        <p>@Model.TotalFeedbacks</p>
    </div>
</div>
<style>
    .dashboard {
        display: grid;
        grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));
        gap: 20px;
    }
    .card {
        border: 1px solid #ccc;
        border-radius: 5px;
        padding: 20px;
        text-align: center;
        background-color: #f9f9f9;
    }
    .card h3 {
        margin: 0 0 10px;
    }
    .card p {
        font-size: 24px;
        font-weight: bold;
    }
</style>

Step 4: Update the Routing

Ensure that the routing is set up to access the dashboard. You can add a route in your Startup.cs or Program.cs file, depending on your ASP.NET version.

app.UseEndpoints(endpoints =>
{
    endpoints.MapControllerRoute(
        name: "dashboard",
        pattern: "Dashboard",
        defaults: new { controller = "Dashboard", action = "Index" });
});