Project Introduction

The Blogging Platform project aims to create a comprehensive web application that allows users to create, manage, and interact with blog posts. This platform will facilitate user registration, role management, and content creation, enabling users to share their thoughts and ideas with a wider audience. The application will be built using ASP.NET, leveraging its robust framework to ensure scalability, security, and performance. The underlying database will be managed using SQL Server, where we will define the necessary tables to support the application's functionality.

Project Objectives

• To design and implement a user-friendly interface for creating and managing blog posts.
• To establish a secure user authentication and authorization system.
• To enable users to comment on posts and engage in discussions.
• To categorize and tag posts for better organization and searchability.
• To implement a notification system to keep users informed about relevant activities.
• To ensure data integrity and relationships through well-defined database tables.

Project Modules

1. User Management Module: Handles user registration, login, and role assignment.
2. Post Management Module: Allows users to create, edit, delete, and view blog posts.
3. Comment Management Module: Enables users to add comments to posts and manage their comments.
4. Category and Tag Management Module: Facilitates the creation and management of categories and tags for posts.
5. Media Management Module: Supports uploading and managing media files associated with posts.
6. Notification Module: Sends notifications to users about new comments, posts, or other relevant activities.

To create the necessary database tables for your Blogging Platform project in SQL Server

We will define the tables based on the models you have listed. Below is the SQL script that creates the required tables along with their relationships.

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 Posts Table
CREATE TABLE Posts (
    PostId INT PRIMARY KEY IDENTITY(1,1),
    Title NVARCHAR(200) NOT NULL,
    Content NVARCHAR(MAX) NOT NULL,
    UserId INT,
    CreatedAt DATETIME DEFAULT GETDATE(),
    UpdatedAt DATETIME DEFAULT GETDATE(),
    FOREIGN KEY (User Id) REFERENCES Users(UserId)
);
-- Create Comments Table
CREATE TABLE Comments (
    CommentId INT PRIMARY KEY IDENTITY(1,1),
    PostId INT,
    UserId INT,
    Content NVARCHAR(MAX) NOT NULL,
    CreatedAt DATETIME DEFAULT GETDATE(),
    FOREIGN KEY (PostId) REFERENCES Posts(PostId),
    FOREIGN KEY (User Id) REFERENCES Users(UserId)
);
-- Create Categories Table
CREATE TABLE Categories (
    CategoryId INT PRIMARY KEY IDENTITY(1,1),
    Name NVARCHAR(100) NOT NULL UNIQUE
);
-- Create Tags Table
CREATE TABLE Tags (
    TagId INT PRIMARY KEY IDENTITY(1,1),
    Name NVARCHAR(100) NOT NULL UNIQUE
);
-- Create PostTags Table (Many-to-Many relationship between Posts and Tags)
CREATE TABLE PostTags (
    PostId INT,
    TagId INT,
    PRIMARY KEY (PostId, TagId),
    FOREIGN KEY (PostId) REFERENCES Posts(PostId),
    FOREIGN KEY (TagId) REFERENCES Tags(TagId)
);
-- Create Media Table
CREATE TABLE Media (
    MediaId INT PRIMARY KEY IDENTITY(1,1),
    FilePath NVARCHAR(256) NOT NULL,
    PostId INT,
    CreatedAt DATETIME DEFAULT GETDATE(),
    FOREIGN KEY (PostId) REFERENCES Posts(PostId)
);
-- 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)
);

Explanation of the Tables

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

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

Posts: Contains blog post details, including title, content, author (User Id), and timestamps.

Comments: Stores comments made on posts, linking to both the post and the user who made the comment.

Categories: Organizes posts into categories.

Tags: Allows tagging of posts for better organization and searchability.

PostTags: A junction table to manage the many-to-many relationship between posts and tags.

Media: Stores media files associated with posts (e.g., images).

Notifications: Stores notifications for users, such as alerts for new comments or replies.

To create models and repositories 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 each table.

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 Post
{
    public int PostId { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }
    public int UserId { get; set; }
    public DateTime CreatedAt { get; set; }
    public DateTime UpdatedAt { get; set; }
}
public class Comment
{
    public int CommentId { get; set; }
    public int PostId { get; set; }
    public int UserId { get; set; }
    public string Content { get; set; }
    public DateTime CreatedAt { get; set; }
}
public class Category
{
    public int CategoryId { get; set; }
    public string Name { get; set; }
}
public class Tag
{
    public int TagId { get; set; }
    public string Name { get; set; }
}
public class PostTag
{
    public int PostId { get; set; }
    public int TagId { get; set; }
}
public class Media
{
    public int MediaId { get; set; }
    public string FilePath { get; set; }
    public int PostId { 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; }
}

Create Repositories

Next, we will create repository classes for each model. Each repository will implement basic CRUD operations using ADO.NET.

User Repository Implementation

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
public class UserRepository
{
    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(),
                        RoleId = reader["RoleId"] as int?,
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    });
                }
            }
        }
        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(),
                        RoleId = reader["RoleId"] as int?,
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    };
                }
            }
        }
        return user;
    }
    public void Add(User user)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("INSERT INTO Users (Username, PasswordHash, Email, RoleId) VALUES (@Username, @PasswordHash, @Email, @RoleId)", 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 void Update(User user)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("UPDATE Users SET Username = @Username, PasswordHash = @PasswordHash, Email = @Email, RoleId = @RoleId 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("@RoleId", (object)user.RoleId ?? DBNull.Value);
            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();
        }
    }
}

Role Repository Implementation

public class RoleRepository
{
    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()
                    });
                }
            }
        }
        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()
                    };
                }
            }
        }
        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 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();
        }
    }
}

Post Repository Implementation

public class PostRepository
{
    private readonly string _connectionString;
    public PostRepository(string connectionString)
    {
        _connectionString = connectionString;
    }
    public IEnumerable<Post> GetAll()
    {
        var posts = new List<Post>();
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Posts", connection);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                while (reader.Read())
                {
                    posts.Add(new Post
                    {
                        PostId = (int)reader["PostId"],
                        Title = reader["Title"].ToString(),
                        Content = reader["Content"].ToString(),
                        UserId = (int)reader["User Id"],
                        CreatedAt = (DateTime)reader["CreatedAt"],
                        UpdatedAt = (DateTime)reader["UpdatedAt"]
                    });
                }
            }
        }
        return posts;
    }
    public Post GetById(int id)
    {
        Post post = null;
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Posts WHERE PostId = @PostId", connection);
            command.Parameters.AddWithValue("@PostId", id);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                if (reader.Read())
                {
                    post = new Post
                    {
                        PostId = (int)reader["PostId"],
                        Title = reader["Title"].ToString(),
                        Content = reader["Content"].ToString(),
                        UserId = (int)reader["User Id"],
                        CreatedAt = (DateTime)reader["CreatedAt"],
                        UpdatedAt = (DateTime)reader["UpdatedAt"]
                    };
                }
            }
        }
        return post;
    }
    public void Add(Post post)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("INSERT INTO Posts (Title, Content, UserId) VALUES (@Title, @Content, @User Id)", connection);
            command.Parameters.AddWithValue("@Title", post.Title);
            command.Parameters.AddWithValue("@Content", post.Content);
            command.Parameters.AddWithValue("@User Id", post.UserId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void Update(Post post)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("UPDATE Posts SET Title = @Title, Content = @Content, UserId = @User Id, UpdatedAt = GETDATE() WHERE PostId = @PostId", connection);
            command.Parameters.AddWithValue("@PostId", post.PostId);
            command.Parameters.AddWithValue("@Title", post.Title);
            command.Parameters.AddWithValue("@Content", post.Content);
            command.Parameters.AddWithValue("@User Id", post.UserId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void Delete(int id)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("DELETE FROM Posts WHERE PostId = @PostId", connection);
            command.Parameters.AddWithValue("@PostId", id);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

Comment Repository Implementation

public class CommentRepository
{
    private readonly string _connectionString;
    public CommentRepository(string connectionString)
    {
        _connectionString = connectionString;
    }
    public IEnumerable<Comment> GetAll()
    {
        var comments = new List<Comment>();
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Comments", connection);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                while (reader.Read())
                {
                    comments.Add(new Comment
                    {
                        CommentId = (int)reader["CommentId"],
                        PostId = (int)reader["PostId"],
                        UserId = (int)reader["User Id"],
                        Content = reader["Content"].ToString(),
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    });
                }
            }
        }
        return comments;
    }
    public Comment GetById(int id)
    {
        Comment comment = null;
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Comments WHERE CommentId = @CommentId", connection);
            command.Parameters.Add WithValue("@CommentId", id);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                if (reader.Read())
                {
                    comment = new Comment
                    {
                        CommentId = (int)reader["CommentId"],
                        PostId = (int)reader["PostId"],
                        UserId = (int)reader["User  Id"],
                        Content = reader["Content"].ToString(),
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    };
                }
            }
        }
        return comment;
    }
    public void Add(Comment comment)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("INSERT INTO Comments (PostId, UserId, Content) VALUES (@PostId, @User  Id, @Content)", connection);
            command.Parameters.AddWithValue("@PostId", comment.PostId);
            command.Parameters.AddWithValue("@User  Id", comment.UserId);
            command.Parameters.AddWithValue("@Content", comment.Content);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void Update(Comment comment)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("UPDATE Comments SET PostId = @PostId, UserId = @User  Id, Content = @Content WHERE CommentId = @CommentId", connection);
            command.Parameters.AddWithValue("@CommentId", comment.CommentId);
            command.Parameters.AddWithValue("@PostId", comment.PostId);
            command.Parameters.AddWithValue("@User  Id", comment.UserId);
            command.Parameters.AddWithValue("@Content", comment.Content);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void Delete(int id)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("DELETE FROM Comments WHERE CommentId = @CommentId", connection);
            command.Parameters.AddWithValue("@CommentId", id);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

Category Repository Implementation

public class CategoryRepository
{
    private readonly string _connectionString;
    public CategoryRepository(string connectionString)
    {
        _connectionString = connectionString;
    }
    public IEnumerable<Category> GetAll()
    {
        var categories = new List<Category>();
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Categories", connection);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                while (reader.Read())
                {
                    categories.Add(new Category
                    {
                        CategoryId = (int)reader["CategoryId"],
                        Name = reader["Name"].ToString()
                    });
                }
            }
        }
        return categories;
    }
    public Category GetById(int id)
    {
        Category category = null;
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Categories WHERE CategoryId = @CategoryId", connection);
            command.Parameters.AddWithValue("@CategoryId", id);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                if (reader.Read())
                {
                    category = new Category
                    {
                        CategoryId = (int)reader["CategoryId"],
                        Name = reader["Name"].ToString()
                    };
                }
            }
        }
        return category;
    }
    public void Add(Category category)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("INSERT INTO Categories (Name) VALUES (@Name)", connection);
            command.Parameters.AddWithValue("@Name", category.Name);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void Update(Category category)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("UPDATE Categories SET Name = @Name WHERE CategoryId = @CategoryId", connection);
            command.Parameters.AddWithValue("@CategoryId", category.CategoryId);
            command.Parameters.AddWithValue("@Name", category.Name);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void Delete(int id)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("DELETE FROM Categories WHERE CategoryId = @CategoryId", connection);
            command.Parameters.AddWithValue("@CategoryId", id);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

Tag Repository Implementation

public class TagRepository
{
    private readonly string _connectionString;
    public TagRepository(string connectionString)
    {
        _connectionString = connectionString;
    }
    public IEnumerable<Tag> GetAll()
    {
        var tags = new List<Tag>();        
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Tags", connection);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                while (reader.Read())
                {
                    tags.Add(new Tag
                    {
                        TagId = (int)reader["TagId"],
                        Name = reader["Name"].ToString()
                    });
                }
            }
        }
        return tags;
    }
    public Tag GetById(int id)
    {
        Tag tag = null;
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Tags WHERE TagId = @TagId", connection);
            command.Parameters.AddWithValue("@TagId", id);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                if (reader.Read())
                {
                    tag = new Tag
                    {
                        TagId = (int)reader["TagId"],
                        Name = reader["Name"].ToString()
                    };
                }
            }
        }
        return tag;
    }
    public void Add(Tag tag)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("INSERT INTO Tags (Name) VALUES (@Name)", connection);
            command.Parameters.AddWithValue("@Name", tag.Name);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void Update(Tag tag)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("UPDATE Tags SET Name = @Name WHERE TagId = @TagId", connection);
            command.Parameters.AddWithValue("@TagId", tag.TagId);
            command.Parameters.AddWithValue("@Name", tag.Name);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void Delete(int id)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("DELETE FROM Tags WHERE TagId = @TagId", connection);
            command.Parameters.AddWithValue("@TagId", id);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

PostTag Repository Implementation

public class PostTagRepository
{
    private readonly string _connectionString;
    public PostTagRepository(string connectionString)
    {
        _connectionString = connectionString;
    }
    public void Add(PostTag postTag)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("INSERT INTO PostTags (PostId, TagId) VALUES (@PostId, @TagId)", connection);
            command.Parameters.AddWithValue("@PostId", postTag.PostId);
            command.Parameters.AddWithValue("@TagId", postTag.TagId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void Delete(int postId, int tagId)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("DELETE FROM PostTags WHERE PostId = @PostId AND TagId = @TagId", connection);
            command.Parameters.AddWithValue("@PostId", postId);
            command.Parameters.AddWithValue("@TagId", tagId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

Media Repository Implementation

public class MediaRepository
{
    private readonly string _connectionString;
    public MediaRepository(string connectionString)
    {
        _connectionString = connectionString;
    }
    public IEnumerable<Media> GetAll()
    {
        var mediaList = new List<Media>();
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Media", connection);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                while (reader.Read())
                {
                    mediaList.Add(new Media
                    {
                        MediaId = (int)reader["MediaId"],
                        FilePath = reader["FilePath"].ToString(),
                        PostId = (int)reader["PostId"],
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    });
                }
            }
        }
        return mediaList;
    }
    public Media GetById(int id)
    {
        Media media = null;
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Media WHERE MediaId = @MediaId", connection);
            command.Parameters.AddWithValue("@MediaId", id);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                if (reader.Read())
                {
                    media = new Media
                    {
                        MediaId = (int)reader["MediaId"],
                        FilePath = reader["FilePath"].ToString(),
                        PostId = (int)reader["PostId"],
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    };
                }
            }
        }
        return media;
    }
    public void Add(Media media)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("INSERT INTO Media (FilePath, PostId) VALUES (@FilePath, @PostId)", connection);
            command.Parameters.AddWithValue("@FilePath", media.FilePath);
            command.Parameters.AddWithValue("@PostId", media.PostId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void Delete(int id)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("DELETE FROM Media WHERE MediaId = @MediaId", connection);
            command.Parameters.AddWithValue("@MediaId", id);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

Notification Repository Implementation

public class NotificationRepository
{
    private readonly string _connectionString;
    public NotificationRepository(string connectionString)
    {
        _connectionString = connectionString;
    }
    public IEnumerable<Notification> GetAll()
    {
        var notifications = new List<Notification>();
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Notifications", connection);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                while (reader.Read())
                {
                    notifications.Add(new Notification
                    {
                        NotificationId = (int)reader["NotificationId"],
                        UserId = (int)reader["User  Id"],
                        Message = reader["Message"].ToString(),
                        IsRead = (bool)reader["IsRead"],
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    });
                }
            }
        }
        return notifications;
    }
    public Notification GetById(int id)
    {
        Notification notification = null;
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Notifications WHERE NotificationId = @NotificationId", connection);
            command.Parameters.AddWithValue("@NotificationId", id);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                if (reader.Read())
                {
                    notification = new Notification
                    {
                        NotificationId = (int)reader["NotificationId"],
                        UserId = (int)reader["User  Id"],
                        Message = reader["Message"].ToString(),
                        IsRead = (bool)reader["IsRead"],
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    };
                }
            }
        }
        return notification;
    }
    public void Add(Notification notification)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("INSERT INTO Notifications (User Id, Message, IsRead) VALUES (@User Id, @Message, @IsRead)", connection);
            command.Parameters.AddWithValue("@User Id", notification.UserId);
            command.Parameters.AddWithValue("@Message", notification.Message);
            command.Parameters.AddWithValue("@IsRead", notification.IsRead);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void Update(Notification notification)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("UPDATE Notifications SET UserId = @User Id, Message = @Message, IsRead = @IsRead WHERE NotificationId = @NotificationId", connection);
            command.Parameters.AddWithValue("@NotificationId", notification.NotificationId);
            command.Parameters.AddWithValue("@User Id", notification.UserId);
            command.Parameters.AddWithValue("@Message", notification.Message);
            command.Parameters.AddWithValue("@IsRead", notification.IsRead);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void Delete(int id)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("DELETE FROM Notifications WHERE NotificationId = @NotificationId", connection);
            command.Parameters.AddWithValue("@NotificationId", id);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

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 controllers for each of the repositories we created earlier:

User, Role, Post, Comment, Category, Tag, Media, and Notification. Each controller will include basic CRUD actions (Create, Read, Update, Delete) and will use dependency injection to access the repositories.

UserController

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

RoleController

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

PostController

using Microsoft.AspNetCore.Mvc;
public class PostController : Controller
{
    private readonly PostRepository _postRepository;
    public PostController(PostRepository postRepository)
    {
        _postRepository = postRepository;
    }
    public IActionResult Index()
    {
        var posts = _postRepository.GetAll();
        return View(posts);
    }
    public IActionResult Details(int id)
    {
        var post = _postRepository.GetById(id);
        return View(post);
    }
    public IActionResult Create()
    {
        return View();
    }
    [HttpPost]
    public IActionResult Create(Post post)
    {
        if (ModelState.IsValid)
        {
            _postRepository.Add(post);
            return RedirectToAction(nameof(Index));
        }
        return View(post);
    }
    public IActionResult Edit(int id)
    {
        var post = _postRepository.GetById(id);
        return View(post);
    }
    [HttpPost]
    public IActionResult Edit(Post post)
    {
        if (ModelState.IsValid)
        {
            _postRepository.Update(post);
            return RedirectToAction(nameof(Index));
        }
        return View(post);
    }
    public IActionResult Delete(int id)
    {
        var post = _postRepository.GetById(id);
        return View(post);
    }
    [HttpPost, ActionName("Delete")]
    public IActionResult DeleteConfirmed(int id)
    {
        _postRepository.Delete(id);
        return RedirectToAction(nameof(Index));
    }
}

CommentController

using Microsoft.AspNetCore.Mvc;
public class CommentController : Controller
{
    private readonly CommentRepository _commentRepository;
    public CommentController(CommentRepository commentRepository)
    {
        _commentRepository = commentRepository;
    }
    public IActionResult Index()
    {
        var comments = _commentRepository.GetAll();
        return View(comments);
    }
    public IActionResult Details(int id)
    {
        var comment = _commentRepository.GetById(id);
        return View(comment);
    }
    public IActionResult Create()
    {
        return View();
    }
    [HttpPost]
    public IActionResult Create(Comment comment)
    {
        if (ModelState.IsValid)
        {
            _commentRepository.Add(comment);
            return RedirectToAction(nameof(Index));
        }
        return View(comment);
    }
    public IActionResult Edit(int id)
    {
        var comment = _commentRepository.GetById(id);
        return View(comment);
    }
    [HttpPost]
    public IActionResult Edit(Comment comment)
    {
        if (ModelState.IsValid)
        {
            _commentRepository.Update(comment);
            return RedirectToAction(nameof(Index));
        }
        return View(comment);
    }
    public IActionResult Delete(int id)
    {
        var comment = _commentRepository.GetById(id);
        return View(comment);
    }
    [HttpPost, ActionName("Delete")]
    public IActionResult DeleteConfirmed(int id)
    {
        _commentRepository.Delete(id);
        return RedirectToAction(nameof(Index));
    }
}

CategoryController

using Microsoft.AspNetCore.Mvc;
public class CategoryController : Controller
{
    private readonly CategoryRepository _categoryRepository;
    public CategoryController(CategoryRepository categoryRepository)
    {
        _categoryRepository = categoryRepository;
    }
    public IActionResult Index()
    {
        var categories = _categoryRepository.GetAll();
        return View(categories);
    }
    public IActionResult Details(int id)
    {
        var category = _categoryRepository.GetById(id);
        return View(category);
    }
    public IActionResult Create()
    {
        return View();
    }
    [HttpPost]
    public IActionResult Create(Category category)
    {
        if (ModelState.IsValid)
        {
            _categoryRepository.Add(category);
            return RedirectToAction(nameof(Index));
        }
        return View(category);
    }
    public IActionResult Edit(int id)
    {
        var category = _categoryRepository.GetById(id);
        return View(category);
    }
    [HttpPost]
    public IActionResult Edit(Category category)
    {
        if (ModelState.IsValid)
        {
            _categoryRepository.Update(category);
            return RedirectToAction(nameof(Index));
        }
        return View(category);
    }
    public IActionResult Delete(int id)
    {
        var category = _categoryRepository.GetById(id);
        return View(category);
    }
    [HttpPost, ActionName("Delete")]
    public IActionResult DeleteConfirmed(int id)
    {
        _categoryRepository.Delete(id);
        return RedirectToAction(nameof(Index));
    }
}

TagController

using Microsoft.AspNetCore.Mvc;
public class TagController : Controller
{
    private readonly TagRepository _tagRepository;
    public TagController(TagRepository tagRepository)
    {
        _tagRepository = tagRepository;
    }
    public IActionResult Index()
    {
        var tags = _tagRepository.GetAll();
        return View(tags);
    }
    public IActionResult Details(int id)
    {
        var tag = _tagRepository.GetById(id);
        return View(tag);
    }
    public IActionResult Create()
    {
        return View();
    }
    [HttpPost]
    public IActionResult Create(Tag tag)
    {
        if (ModelState.IsValid)
        {
            _tagRepository.Add(tag);
            return RedirectToAction(nameof(Index));
        }
        return View(tag);
    }
    public IActionResult Edit(int id)
    {
        var tag = _tagRepository.GetById(id);
        return View(tag);
    }
    [HttpPost]
    public IActionResult Edit(Tag tag)
    {
        if (ModelState.IsValid)
        {
            _tagRepository.Update(tag);
            return RedirectToAction(nameof(Index));
        }
        return View(tag);
    }
    public IActionResult Delete(int id)
    {
        var tag = _tagRepository.GetById(id);
        return View(tag);
    }
    [HttpPost, ActionName("Delete")]
    public IActionResult DeleteConfirmed(int id)
    {
        _tagRepository.Delete(id);
        return RedirectToAction(nameof(Index));
    }
}

MediaController

using Microsoft.Asp NetCore.Mvc;
public class MediaController : Controller
{
    private readonly MediaRepository _mediaRepository;
    public MediaController(MediaRepository mediaRepository)
    {
        _mediaRepository = mediaRepository;
    }
    public IActionResult Index()
    {
        var mediaList = _mediaRepository.GetAll();
        return View(mediaList);
    }
    public IActionResult Details(int id)
    {
        var media = _mediaRepository.GetById(id);
        return View(media);
    }
    public IActionResult Create()
    {
        return View();
    }
    [HttpPost]
    public IActionResult Create(Media media)
    {
        if (ModelState.IsValid)
        {
            _mediaRepository.Add(media);
            return RedirectToAction(nameof(Index));
        }
        return View(media);
    }
    public IActionResult Edit(int id)
    {
        var media = _mediaRepository.GetById(id);
        return View(media);
    }
    [HttpPost]
    public IActionResult Edit(Media media)
    {
        if (ModelState.IsValid)
        {
            _mediaRepository.Update(media);
            return RedirectToAction(nameof(Index));
        }
        return View(media);
    }
    public IActionResult Delete(int id)
    {
        var media = _mediaRepository.GetById(id);
        return View(media);
    }
    [HttpPost, ActionName("Delete")]
    public IActionResult DeleteConfirmed(int id)
    {
        _mediaRepository.Delete(id);
        return RedirectToAction(nameof(Index));
    }
}

NotificationController

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

These controllers provide a complete set of CRUD operations for each of the repositories. They handle user interactions, validate input, and manage the flow of data between the views and the repositories, ensuring a clean separation of concerns in your ASP.NET MVC application. Each controller can be further customized to include additional features such as filtering, searching, or pagination as needed.

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

We will create Razor view files that correspond to the actions in the controllers. Each view will provide a user interface for managing the respective entities, allowing users to create, read, update, and delete records.

Below are the view files for each controller:

User, Role, Post, Comment, Category, Tag, Media, and Notification.

User Views

Views/User/Index.cshtml

@model IEnumerable<User>
<h2>Users</h2>
<a asp-action="Create">Create New User</a>
<table>
    <thead>
        <tr>
            <th>Username</th>
            <th>Email</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var user in Model)
        {
            <tr>
                <td>@user.Username</td>
                <td>@user.Email</td>
                <td>
                    <a asp-action="Edit" asp-route-id="@user.UserId">Edit</a> |
                    <a asp-action="Delete" asp-route-id="@user.UserId">Delete</a> |
                    <a asp-action="Details" asp-route-id="@user.UserId">Details</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Views/User/Create.cshtml

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

Views/User/Edit.cshtml

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

Views/User/Delete.cshtml

@model User
<h2>Delete User</h2>
<h3>Are you sure you want to delete this user?</h3>
<div>
    <h4>@Model.Username</h4>
    <p>Email: @Model.Email</p>
</div>
<form asp-action="DeleteConfirmed">
    <input type="hidden" asp-for="User Id" />
    <button type="submit">Delete</button>
    <a asp-action="Index">Cancel</a>
</form>

Views/User/Details.cshtml

@model User
<h2>User Details</h2>
<div>
    <h4>@Model.Username</h4>
    <p>Email: @Model.Email</p>
    <p>Role ID: @Model.RoleId</p>
    <p>Created At: @Model.CreatedAt</p>
</div>
<a asp-action="Edit" asp-route-id="@Model.UserId">Edit</a> |
<a asp-action="Index">Back to List</a>
2. Role Views

Views/Role/Index.cshtml

@model IEnumerable<Role>
<h2>Roles</h2>
<a asp-action="Create">Create New Role</a>
<table>
    <thead>
        <tr>
            <th>Role Name</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var role in Model)
        {
            <tr>
                <td>@role.RoleName</td>
                <td>
                    <a asp-action="Edit" asp-route-id="@role.RoleId">Edit</a> |
                    <a asp-action="Delete" asp-route-id="@role.RoleId">Delete</a> |
                    <a asp-action="Details" asp-route-id="@ role.RoleId">Details</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Views/Role/Create.cshtml

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

Views/Role/Edit.cshtml

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

Views/Role/Delete.cshtml

@model Role
<h2>Delete Role</h2>
<h3>Are you sure you want to delete this role?</h3>
<div>
    <h4>@Model.RoleName</h4>
</div>
<form asp-action="DeleteConfirmed">
    <input type="hidden" asp-for="RoleId" />
    <button type="submit">Delete</button>
    <a asp-action="Index">Cancel</a>
</form>

Views/Role/Details.cshtml

@model Role
<h2>Role Details</h2>
<div>
    <h4>@Model.RoleName</h4>
</div>
<a asp-action="Edit" asp-route-id="@Model.RoleId">Edit</a> |
<a asp-action="Index">Back to List</a>
3. Post Views

Views/Post/Index.cshtml

@model IEnumerable<Post>
<h2>Posts</h2>
<a asp-action="Create">Create New Post</a>
<table>
    <thead>
        <tr>
            <th>Title</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var post in Model)
        {
            <tr>
                <td>@post.Title</td>
                <td>
                    <a asp-action="Edit" asp-route-id="@post.PostId">Edit</a> |
                    <a asp-action="Delete" asp-route-id="@post.PostId">Delete</a> |
                    <a asp-action="Details" asp-route-id="@post.PostId">Details</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Views/Post/Create.cshtml

@model Post
<h2>Create Post</h2>
<form asp-action="Create">
    <div>
        <label asp-for="Title"></label>
        <input asp-for="Title" />
    </div>
    <div>
        <label asp-for="Content"></label>
        <textarea asp-for="Content"></textarea>
    </div>
    <button type="submit">Create</button>
</form>

Views/Post/Edit.cshtml

@model Post
<h2>Edit Post</h2>
<form asp-action="Edit">
    <input type="hidden" asp-for="PostId" />
    <div>
        <label asp-for="Title"></label>
        <input asp-for="Title" />
    </div>
    <div>
        <label asp-for="Content"></label>
        <textarea asp-for="Content"></textarea>
    </div>
    <button type="submit">Save</button>
</form>

Views/Post/Delete.cshtml

@model Post
<h2>Delete Post</h2>
<h3>Are you sure you want to delete this post?</h3>
<div>
    <h4>@Model.Title</h4>
</div>
<form asp-action="DeleteConfirmed">
    <input type="hidden" asp-for="PostId" />
    <button type="submit">Delete</button>
    <a asp-action="Index">Cancel</a>
</form>

Views/Post/Details.cshtml

@model Post
<h2>Post Details</h2>
<div>
    <h4>@Model.Title</h4>
    <p>@Model.Content</p>
</div>
<a asp-action="Edit" asp-route-id="@Model.PostId">Edit</a> |
<a asp-action="Index">Back to List</a>
4. Comment Views

Views/Comment/Index.cshtml

@model IEnumerable<Comment>
<h2>Comments</h2>
<a asp-action="Create">Create New Comment</a>
<table>
    <thead>
        <tr>
            <th>Content</th>
            <th> Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var comment in Model)
        {
            <tr>
                <td>@comment.Content</td>
                <td>
                    <a asp-action="Edit" asp-route-id="@comment.CommentId">Edit</a> |
                    <a asp-action="Delete" asp-route-id="@comment.CommentId">Delete</a> |
                    <a asp-action="Details" asp-route-id="@comment.CommentId">Details</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Views/Comment/Create.cshtml

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

Views/Comment/Edit.cshtml

@model Comment
<h2>Edit Comment</h2>
<form asp-action="Edit">
    <input type="hidden" asp-for="CommentId" />
    <div>
        <label asp-for="Content"></label>
        <textarea asp-for="Content"></textarea>
    </div>
    <button type="submit">Save</button>
</form>

Views/Comment/Delete.cshtml

@model Comment
<h2>Delete Comment</h2>
<h3>Are you sure you want to delete this comment?</h3>
<div>
    <h4>@Model.Content</h4>
</div>
<form asp-action="DeleteConfirmed">
    <input type="hidden" asp-for="CommentId" />
    <button type="submit">Delete</button>
    <a asp-action="Index">Cancel</a>
</form>

Views/Comment/Details.cshtml

@model Comment
<h2>Comment Details</h2>
<div>
    <h4>@Model.Content</h4>
</div>
<a asp-action="Edit" asp-route-id="@Model.CommentId">Edit</a> |
<a asp-action="Index">Back to List</a>
5. Category Views

Views/Category/Index.cshtml

@model IEnumerable<Category>
<h2>Categories</h2>
<a asp-action="Create">Create New Category</a>
<table>
    <thead>
        <tr>
            <th>Category Name</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var category in Model)
        {
            <tr>
                <td>@category.CategoryName</td>
                <td>
                    <a asp-action="Edit" asp-route-id="@category.CategoryId">Edit</a> |
                    <a asp-action="Delete" asp-route-id="@category.CategoryId">Delete</a> |
                    <a asp-action="Details" asp-route-id="@category.CategoryId">Details</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Views/Category/Create.cshtml

@model Category
<h2>Create Category</h2>
<form asp-action="Create">
    <div>
        <label asp-for="CategoryName"></label>
        <input asp-for="CategoryName" />
    </div>
    <button type="submit">Create</button>
</form>

Views/Category/Edit.cshtml

@model Category
<h2>Edit Category</h2>
<form asp-action="Edit">
    <input type="hidden" asp-for="CategoryId" />
    <div>
        <label asp-for="CategoryName"></label>
        <input asp-for="CategoryName" />
    </div>
    <button type="submit">Save</button>
</form>

Views/Category/Delete.cshtml

@model Category
<h2>Delete Category</h2>
<h3>Are you sure you want to delete this category?</h3>
<div>
    <h4>@Model.CategoryName</h4>
</div>
<form asp-action="DeleteConfirmed">
    <input type="hidden" asp-for="CategoryId" />
    <button type="submit">Delete</button>
    <a asp-action="Index">Cancel</a>
</form>

Views/Category/Details.cshtml

@model Category
<h2>Category Details</h2>
<div>
    <h4>@Model.CategoryName</h4>
</div>
<a asp-action="Edit" asp-route-id="@Model.CategoryId">Edit</a> |
<a asp-action="Index">Back to List</a>
6. Tag Views

Views/Tag/Index.cshtml

@model IEnumerable<Tag>
 <h2>Tags</h2>
<a asp-action="Create">Create New Tag</a>
<table>
    <thead>
        <tr>
            <th>Tag Name</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var tag in Model)
        {
            <tr>
                <td>@tag.TagName</td>
                <td>
                    <a asp-action="Edit" asp-route-id="@tag.TagId">Edit</a> |
                    <a asp-action="Delete" asp-route-id="@tag.TagId">Delete</a> |
                    <a asp-action="Details" asp-route-id="@tag.TagId">Details</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Views/Tag/Create.cshtml

@model Tag
<h2>Create Tag</h2>
<form asp-action="Create">
    <div>
        <label asp-for="TagName"></label>
        <input asp-for="TagName" />
    </div>
    <button type="submit">Create</button>
</form>

Views/Tag/Edit.cshtml

@model Tag
<h2>Edit Tag</h2>
<form asp-action="Edit">
    <input type="hidden" asp-for="TagId" />
    <div>
        <label asp-for="TagName"></label>
        <input asp-for="TagName" />
    </div>
    <button type="submit">Save</button>
</form>

Views/Tag/Delete.cshtml

@model Tag
<h2>Delete Tag</h2>
<h3>Are you sure you want to delete this tag?</h3>
<div>
    <h4>@Model.TagName</h4>
</div>
<form asp-action="DeleteConfirmed">
    <input type="hidden" asp-for="TagId" />
    <button type="submit">Delete</button>
    <a asp-action="Index">Cancel</a>
</form>

Views/Tag/Details.cshtml

@model Tag
<h2>Tag Details</h2>
<div>
    <h4>@Model.TagName</h4>
</div>
<a asp-action="Edit" asp-route-id="@Model.TagId">Edit</a> |
<a asp-action="Index">Back to List</a>

Media Views

Views/Media/Index.cshtml

@model IEnumerable<Media>
<h2>Media</h2>
<a asp-action="Create">Upload New Media</a>
<table>
    <thead>
        <tr>
            <th>File Name</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var media in Model)
        {
            <tr>
                <td>@media.FileName</td>
                <td>
                    <a asp-action="Edit" asp-route-id="@media.MediaId">Edit</a> |
                    <a asp-action="Delete" asp-route-id="@media.MediaId">Delete</a> |
                    <a asp-action="Details" asp-route-id="@media.MediaId">Details</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Views/Media/Create.cshtml

@model Media
<h2>Upload Media</h2>
<form asp-action="Create" enctype="multipart/form-data">
    <div>
        <label asp-for="FileName"></label>
        <input asp-for="FileName" type="file" />
    </div>
    <button type="submit">Upload</button>
</form>

Views/Media/Edit.cshtml

@model Media
<h2>Edit Media</h2>
<form asp-action="Edit">
    <input type="hidden" asp-for="MediaId" />
    <div>
        <label asp-for="FileName"></label>
        <input asp-for="FileName" />
    </div>
    <button type="submit">Save</button>
</form>

Views/Media/Delete.cshtml

@model Media
<h2>Delete Media</h2>
<h3>Are you sure you want to delete this media?</h3>
<div>
    <h4>@Model.FileName</h4>
</div>
<form asp-action="DeleteConfirmed">
    <input type="hidden" asp-for="MediaId" />
    <button type="submit">Delete</button>
    <a asp-action="Index">Cancel</a>
</form>

Views/Media/Details.cshtml

@model Media
<h2>Media Details</h2>
<div>
    <h4>@Model.FileName</h4>
 <p>Uploaded At: @Model.UploadedAt</p>
</div>
<a asp-action="Edit" asp-route-id="@Model.MediaId">Edit</a> |
<a asp-action="Index">Back to List</a>
8. Notification Views

Views/Notification/Index.cshtml

@model IEnumerable<Notification>
<h2>Notifications</h2>
<a asp-action="Create">Create New Notification</a>
<table>
    <thead>
        <tr>
            <th>Message</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var notification in Model)
        {
            <tr>
                <td>@notification.Message</td>
                <td>
                    <a asp-action="Edit" asp-route-id="@notification.NotificationId">Edit</a> |
                    <a asp-action="Delete" asp-route-id="@notification.NotificationId">Delete</a> |
                    <a asp-action="Details" asp-route-id="@notification.NotificationId">Details</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Views/Notification/Create.cshtml

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

Views/Notification/Edit.cshtml

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

Views/Notification/Delete.cshtml

@model Notification
<h2>Delete Notification</h2>
<h3>Are you sure you want to delete this notification?</h3>
<div>
    <h4>@Model.Message</h4>
</div>
<form asp-action="DeleteConfirmed">
    <input type="hidden" asp-for="NotificationId" />
    <button type="submit">Delete</button>
    <a asp-action="Index">Cancel</a>
</form>

Views/Notification/Details.cshtml

@model Notification
<h2>Notification Details</h2>
<div>
    <h4>@Model.Message</h4>
    <p>Created At: @Model.CreatedAt</p>
</div>
<a asp-action="Edit" asp-route-id="@Model.NotificationId">Edit</a> |
<a asp-action="Index">Back to List</a>

These view files provide a user-friendly interface for managing the entities associated with each controller. Each view corresponds to the actions defined in the controllers, allowing users to create, read, update, and delete records effectively. You can further enhance these views with additional features such as validation messages, styling, and client-side scripting as needed.

To create a dashboard page that displays consolidated data related to your project

We will follow these steps:

Create a Dashboard ViewModel

This will hold the consolidated data.

public class DashboardViewModel
{
   public int TotalUsers { get; set; }
   public int TotalRoles { get; set; }
   public int TotalPosts { get; set; }
   public int TotalComments { get; set; }
   public int TotalCategories { get; set; }
   public int TotalTags { get; set; }
   public int TotalMedia { get; set; }
   public int TotalNotifications { get; set; }
}

Create a Dashboard Controller

Create a new controller named DashboardController that will handle the logic for fetching the consolidated data.

public class DashboardController : Controller
{
    private readonly IUserRepository _userRepository;
    private readonly IRoleRepository _roleRepository;
    private readonly IPostRepository _postRepository;
    private readonly ICommentRepository _commentRepository;
    private readonly ICategoryRepository _categoryRepository;
    private readonly ITagRepository _tagRepository;
    private readonly IMediaRepository _mediaRepository;
    private readonly INotificationRepository _notificationRepository;
    public DashboardController(IUser Repository userRepository, IRoleRepository roleRepository, IPostRepository postRepository,
                               ICommentRepository commentRepository, ICategoryRepository categoryRepository,
                               ITagRepository tagRepository, IMediaRepository mediaRepository,
                               INotificationRepository notificationRepository)
    {
        _userRepository = userRepository;
        _roleRepository = roleRepository;
        _postRepository = postRepository;
        _commentRepository = commentRepository;
        _categoryRepository = categoryRepository;
        _tagRepository = tagRepository;
        _mediaRepository = mediaRepository;
        _notificationRepository = notificationRepository;
    }
    public IActionResult Index()
    {
        var model = new DashboardViewModel
        {
            TotalUsers = _userRepository.GetAll().Count(),
            TotalRoles = _roleRepository.GetAll().Count(),
            TotalPosts = _postRepository.GetAll().Count(),
            TotalComments = _commentRepository.GetAll().Count(),
            TotalCategories = _categoryRepository.GetAll().Count(),
            TotalTags = _tagRepository.GetAll().Count(),
            TotalMedia = _mediaRepository.GetAll().Count(),
            TotalNotifications = _notificationRepository.GetAll().Count()
        };
        return View(model);
    }
}

Create the Dashboard View

Create a new view named Index.cshtml under the Views/Dashboard folder to display the consolidated data.

@model DashboardViewModel
<h2>Dashboard</h2>
<div class="dashboard">
    <div class="card">
        <h3>Total Users</h3>
        <p>@Model.TotalUsers</p>
    </div>
    <div class="card">
        <h3>Total Roles</h3>
        <p>@Model.TotalRoles</p>
    </div>
    <div class="card">
        <h3>Total Posts</h3>
        <p>@Model.TotalPosts</p>
    </div>
    <div class="card">
        <h3>Total Comments</h3>
        <p>@Model.TotalComments</p>
    </div>
    <div class="card">
        <h3>Total Categories</h3>
        <p>@Model.TotalCategories</p>
    </div>
    <div class="card">
        <h3>Total Tags</h3>
        <p>@Model.TotalTags</p>
    </div>
    <div class="card">
        <h3>Total Media</h3>
        <p>@Model.TotalMedia</p>
    </div>
    <div class="card">
        <h3>Total Notifications</h3>
        <p>@Model.TotalNotifications</p>
    </div>
</div>
<style>
    .dashboard {
        display: flex;
        flex-wrap: wrap;
        gap: 20px;
    }
    .card {
        border: 1px solid #ccc;
        padding: 20px;
        border-radius: 5px;
        width: 200px;
        text-align: center;
    }
</style>