Project Introduction

The Blogging Platform is a web application designed to facilitate the creation, management, and sharing of blog content. Built using Node.js, this platform allows users to register, create posts, comment on articles, and manage their profiles. The application supports multiple user roles, including admin, author, editor, and reader, ensuring a versatile and user-friendly experience. The underlying database schema is structured to efficiently handle users, posts, comments, categories, tags, media, and notifications, providing a robust foundation for a dynamic blogging environment.

Project Objectives

• To develop a user-friendly blogging platform that allows users to create and manage blog posts.
• To implement a secure user authentication system with role-based access control.
• To enable users to comment on posts and manage their comments effectively.
• To categorize and tag posts for better organization and searchability.
• To provide a media management system for users to upload and manage images and files.
• To implement a notification system to keep users informed about relevant activities.
• To ensure the application is scalable and maintainable for future enhancements.

Project Modules

1. User Management Module:

   This module handles user registration, authentication, and profile management, allowing users to manage their accounts based on their roles.

2. Post Management Module:

   This module allows users to create, edit, delete, and publish blog posts, as well as manage their status (draft or published).

3. Comment Management Module:

   This module enables users to add comments to posts, manage their comments, and view comments from other users.

4. Category and Tag Management Module:

   This module allows users to create and manage categories and tags for better organization of posts.

5. Media Management Module:

   This module provides functionality for users to upload and manage media files associated with their posts.

6. Notification Module:

   This module sends notifications to users about important events, such as new comments on their posts or updates from other users.

Set Up the Project

Initialize a new Node.js project and install the necessary packages.

Create a new directory for your project and navigate into it:

mkdir blogging-app
cd blogging-app

Initialize a new Node.js project:

npm init -y

Install the required packages:

npm install express sequelize mysql2 ejs body-parser

Create the following directory structure:

blogging-app/
├── models/
├── repositories/
├── controllers/
├── routes/
├── views/
├── public/
├── config/
├── app.js
└── package.json

Step 2: Define Sequelize Models

Create Sequelize models for each table in the models directory.

models/User.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config/database');
class User extends Model {}
User .init({
    UserId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true
    },
    Username: {
        type: DataTypes.STRING,
        allowNull: false,
        unique: true
    },
    PasswordHash: {
        type: DataTypes.STRING,
        allowNull: false
    },
    Email: {
        type: DataTypes.STRING,
        allowNull: false,
        unique: true
    },
    RoleId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Roles',
            key: 'RoleId'
        }
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW
    }
}, {
    sequelize,
    modelName: 'User ',
    tableName: 'Users',
    timestamps: false
});
module.exports = User;

models/Role.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config/database');
class Role extends Model {}
Role.init({
    RoleId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true
    },
    RoleName: {
        type: DataTypes.STRING,
        allowNull: false,
        unique: true
    }
}, {
    sequelize,
    modelName: 'Role',
    tableName: 'Roles',
    timestamps: false
});
module.exports = Role;

models/Post.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config/database');
class Post extends Model {}
Post.init({
    PostId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true
    },
    Title: {
        type: DataTypes.STRING,
        allowNull: false
    },
    Content: {
        type: DataTypes.TEXT,
        allowNull: false
    },
    UserId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Users',
            key: 'User Id'
        }
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW
    }
}, {
    sequelize,
    modelName: 'Post',
    tableName: 'Posts',
    timestamps: false
});
module.exports = Post;

models/Comment.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config/database');
class Comment extends Model {}
Comment.init({
    CommentId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true
    },
    PostId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Posts',
            key: 'PostId'
        }
    },
    UserId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Users',
            key: 'User Id'
        }
    },
    Content: {
 type: DataTypes.TEXT,
        allowNull: false
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW
    }
}, {
    sequelize,
    modelName: 'Comment',
    tableName: 'Comments',
    timestamps: false
});
module.exports = Comment;

models/Category.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config/database');
class Category extends Model {}
Category.init({
    CategoryId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true
    },
    Name: {
        type: DataTypes.STRING,
        allowNull: false,
        unique: true
    }
}, {
    sequelize,
    modelName: 'Category',
    tableName: 'Categories',
    timestamps: false
});
module.exports = Category;

models/Tag.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config/database');
class Tag extends Model {}
Tag.init({
    TagId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true
    },
    Name: {
        type: DataTypes.STRING,
        allowNull: false,
        unique: true
    }
}, {
    sequelize,
    modelName: 'Tag',
    tableName: 'Tags',
    timestamps: false
});
module.exports = Tag;

models/PostTag.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config/database');
class PostTag extends Model {}
PostTag.init({
    PostId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Posts',
            key: 'PostId'
        }
    },
    TagId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Tags',
            key: 'TagId'
        }
    }
}, {
    sequelize,
    modelName: 'PostTag',
    tableName: 'PostTags',
    timestamps: false
});
module.exports = PostTag;

models/Media.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config/database');
class Media extends Model {}
Media.init({
    MediaId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true
    },
    FilePath: {
        type: DataTypes.STRING,
        allowNull: false
    },
    PostId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Posts',
            key: 'PostId'
        }
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW
    }
}, {
    sequelize,
    modelName: 'Media',
    tableName: 'Media',
    timestamps: false
});
module.exports = Media;

models/Notification.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config/database');
class Notification extends Model {}
Notification.init({
    NotificationId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true
    },
    UserId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Users',
            key: 'User  Id'
        }
    },
    Message: {
        type: DataTypes.STRING,
        allowNull: false
    },
    IsRead: {
        type: DataTypes.BOOLEAN,
        defaultValue: false
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW
    }
}, {
    sequelize,
    modelName: 'Notification',
    tableName: 'Notifications',
    timestamps: false
});
module.exports = Notification;

Step 3: Create Repositories

In the repositories directory, create repository files for each model to handle CRUD operations.

repositories/userRepository.js

const User = require('../models/User');
class UserRepository {
    async createUser (data) {
        return await User.create(data);
    }
    async getUser ById(userId) {
        return await User.findByPk(userId);
    }
    async updateUser (userId, data) {
        return await User.update(data, { where: { UserId: userId } });
    }
    async deleteUser (userId) {
        return await User.destroy({ where: { UserId: userId } });
    }
    async getAllUsers() {
        return await User.findAll();
    }
}
module.exports = new UserRepository();

repositories/postRepository.js

const Post = require('../models/Post');
class PostRepository {
    async createPost(data) {
        return await Post.create(data);
    }
    async getPostById(postId){
        return await Post.findByPk(postId);
    }
    async updatePost(postId, data) {
        return await Post.update(data, { where: { PostId: postId } });
    }
    async deletePost(postId) {
        return await Post.destroy({ where: { PostId: postId } });
    }
    async getAllPosts() {
        return await Post.findAll();
    }
}
module.exports = new PostRepository();

repositories/commentRepository.js

const Comment = require('../models/Comment');
class CommentRepository {
    async createComment(data) {
        return await Comment.create(data);
    }
    async getCommentById(commentId) {
        return await Comment.findByPk(commentId);
    }
    async updateComment(commentId, data) {
        return await Comment.update(data, { where: { CommentId: commentId } });
    }
    async deleteComment(commentId) {
        return await Comment.destroy({ where: { CommentId: commentId } });
    }
    async getAllComments() {
        return await Comment.findAll();
    }
}
module.exports = new CommentRepository();

repositories/categoryRepository.js

const Category = require('../models/Category');
class CategoryRepository {
    async createCategory(data) {
        return await Category.create(data);
    }
    async getCategoryById(categoryId) {
        return await Category.findByPk(categoryId);
    }
    async updateCategory(categoryId, data) {
        return await Category.update(data, { where: { CategoryId: categoryId } });
    }
    async deleteCategory(categoryId) {
        return await Category.destroy({ where: { CategoryId: categoryId } });
    }
    async getAllCategories() {
        return await Category.findAll();
    }
}
module.exports = new CategoryRepository();

repositories/tagRepository.js

const Tag = require('../models/Tag');
class TagRepository {
    async createTag(data) {
        return await Tag.create(data);
    }
    async getTagById(tagId) {
        return await Tag.findByPk(tagId);
    }
    async updateTag(tagId, data) {
        return await Tag.update(data, { where: { TagId: tagId } });
    }
    async deleteTag(tagId) {
        return await Tag.destroy({ where: { TagId: tagId } });
    }
    async getAllTags() {
        return await Tag.findAll();
    }
}
module.exports = new TagRepository();

repositories/mediaRepository.js

const Media = require('../models/Media');
class MediaRepository {
    async createMedia(data) {
        return await Media.create(data);
    }
    async getMediaById(mediaId) {
        return await Media.findByPk(mediaId);
    }
    async updateMedia(mediaId, data) {
        return await Media.update(data, { where: { MediaId: mediaId } });
    }
    async deleteMedia(mediaId) {
        return await Media.destroy({ where: { MediaId: mediaId } });
    }
    async getAllMedia() {
        return await Media.findAll();
    }
}
module.exports = new MediaRepository();

repositories/notificationRepository.js

const Notification = require('../models/Notification');
class NotificationRepository {
    async createNotification(data) {
        return await Notification.create(data);
    }
    async getNotificationById(notificationId) {
        return await Notification.findByPk(notificationId);
    }
    async updateNotification(notificationId, data) {
        return await Notification.update(data, { where: { NotificationId: notificationId } });
    }
    async deleteNotification(notificationId) {
        return await Notification.destroy({ where: { NotificationId: notificationId } });
    }
    async getAllNotifications() {
        return await Notification.findAll();
    }
}
module.exports = new NotificationRepository();

Step 4: Set Up Controllers

In the controllers directory, create controller files for each model to handle the business logic.

controllers/userController.js

const userRepository = require('../repositories/userRepository');
class UserController {
    async createUser (req, res) {
        const user = await userRepository.createUser (req.body);
        res.status(201).json(user);
    }
    async getUser ById(req, res) {
        const user = await userRepository.getUser ById(req.params.id);
        res.status(200).json(user);
    }
    async updateUser (req, res) {
        await userRepository.updateUser (req.params.id, req.body);
        res.status(204).send();
    }
    async deleteUser (req, res) {
        await userRepository.deleteUser (req.params.id);
        res.status(204).send();
    }
    async getAllUsers(req, res) {
        const users = await userRepository.getAllUsers();
        res.status(200).json(users);
    }
}
module.exports = new UserController();

controllers/postController.js

const postRepository = require('../repositories/postRepository');
class PostController {
    async createPost(req, res) {
        const post = await postRepository.createPost(req.body);
        res.status(201).json(post);
    }
    async getPostById(req, res) {
        const post = await postRepository.getPostById(req.params.id);
        res.status(200).json(post);
    }
    async updatePost(req, res) {
        await postRepository.updatePost(req.params.id, req.body);
        res.status(204).send();
    }
    async deletePost(req, res) {
        await postRepository.deletePost(req.params.id);
        res.status(204).send();
    }
    async getAllPosts(req, res) {
        const posts = await postRepository.getAllPosts();
        res.status(200).json(posts);
    }
}
module.exports = new PostController();

controllers/commentController.js

const commentRepository = require('../repositories/commentRepository');
class CommentController {
    async createComment(req, res) {
        const comment = await commentRepository.createComment(req.body);
        res.status(201).json(comment);
    }
    async getCommentById(req, res) {
        const comment = await commentRepository.getCommentById(req.params.id);
        res.status(200).json(comment);
    }
    async updateComment(req, res) {
        await commentRepository.updateComment(req.params.id, req.body);
        res.status(204).send();
    }
    async deleteComment(req, res) {
        await commentRepository.deleteComment(req.params.id);
        res.status(204).send();
    }
    async getAllComments(req, res) {
        const comments = await commentRepository.getAllComments();
        res.status(200).json(comments);
    }
}
module.exports = new CommentController();

controllers/categoryController.js

const categoryRepository = require('../repositories/categoryRepository');
class CategoryController {
    async createCategory(req, res) {
        const category = await categoryRepository.createCategory(req.body);
        res.status(201).json(category);
    }
    async getCategoryById(req, res) {
        const category = await categoryRepository.getCategoryById(req.params.id);
        res.status(200).json(category);
    }
    async updateCategory(req, res) {
        await categoryRepository.updateCategory(req.params.id, req.body);
        res.status(204).send();
    }
    async deleteCategory(req, res) {
        await categoryRepository.deleteCategory(req.params.id);
        res.status(204).send();
    }
    async getAllCategories(req, res) {
        const categories = await categoryRepository.getAllCategories();
        res.status(200).json(categories);
    }
}
module.exports = new CategoryController();

controllers/tagController.js

const tagRepository = require('../repositories/tagRepository');
class TagController {
    async createTag(req, res) {
        const tag = await tagRepository.createTag(req.body);
        res.status(201).json(tag);
    }
    async getTagById(req, res) {
        const tag = await tagRepository.getTagById(req.params.id);
        res.status(200).json(tag);
    }
    async updateTag(req, res) {
        await tagRepository.updateTag(req.params.id, req.body);
        res.status(204).send();
    }
    async deleteTag(req, res) {
        await tagRepository.deleteTag(req.params.id);
        res.status(204).send();
    }
    async getAllTags(req, res) {
        const tags = await tagRepository.getAllTags();
        res.status(200).json(tags);
    }
}
module.exports = new TagController();

controllers/mediaController.js

const mediaRepository = require('../repositories/mediaRepository');
class MediaController {
    async createMedia(req, res) {
        const media = await mediaRepository.createMedia(req.body);
        res.status(201).json(media);
    }
    async getMediaById(req, res) {
        const media = await mediaRepository.getMediaById(req.params.id);
        res.status(200).json(media);
    }
    async updateMedia(req, res) {
        await mediaRepository.updateMedia(req.params.id, req.body);
        res.status(204).send();
    }
    async deleteMedia(req, res) {
        await mediaRepository.deleteMedia(req.params.id);
        res.status(204).send();
    }
    async getAllMedia(req, res) {
        const mediaItems = await mediaRepository.getAllMedia();
        res.status(200).json(mediaItems);
    }
}
module.exports = new MediaController();

controllers/notificationController.js

const notificationRepository = require('../repositories/notificationRepository');
class NotificationController {
    async createNotification(req, res) {
        const notification = await notificationRepository.createNotification(req.body);
        res.status(201).json(notification);
    }
    async getNotificationById(req, res) {
        const notification = await notificationRepository.getNotificationById(req.params.id);
        res.status(200).json(notification);
    }
    async updateNotification(req, res) {
        await notificationRepository.updateNotification(req.params.id, req.body);
        res.status(204).send();
    }
    async deleteNotification(req, res) {
        await notificationRepository.deleteNotification(req.params.id);
        res.status(204).send();
    }
    async getAllNotifications(req, res) {
        const notifications = await notificationRepository.getAllNotifications();
        res.status(200).json(notifications);
    }
}
module.exports = new NotificationController();

Step 5: Define Routes

In the routes directory, create route files for each model to define the API endpoints.

routes/userRoutes.js

const express = require('express');
const router = express.Router();
const userController = require('../controllers/userController');
router.post('/', userController.createUser );
router.get('/:id', userController.getUser ById);
router.put('/:id', userController.updateUser );
router.delete('/:id', userController.deleteUser );
router.get('/', userController.getAllUsers);
module.exports = router;

routes/postRoutes.js

const express = require('express');
const router = express.Router();
const postController = require('../controllers/postController');
router.post('/', postController.createPost);
router.get('/:id', postController.getPostById);
router.put('/:id', postController.updatePost);
router.delete('/:id', postController.deletePost);
router.get('/', postController.getAllPosts);
module.exports = router;

routes/commentRoutes.js

const express = require('express');
const router = express.Router();
const commentController = require('../controllers/commentController');
router.post('/', commentController.createComment);
router.get('/:id', commentController.getCommentById);
router.put('/:id', commentController.updateComment);
router.delete('/:id', commentController.deleteComment);
router.get('/', commentController.getAllComments);
module.exports = router;

routes/categoryRoutes.js

const express = require('express');
const router = express.Router();
const categoryController = require('../controllers/categoryController');
router.post('/', categoryController.createCategory);
router.get('/:id', categoryController.getCategoryById);
router.put('/:id', categoryController.updateCategory);
router.delete('/:id', categoryController.deleteCategory);
router.get('/', categoryController.getAllCategories);
module.exports = router;

routes/tagRoutes.js

const express = require('express');
const router = express.Router();
const tagController = require('../controllers/tagController');
router.post('/', tagController.createTag);
router.get('/:id', tagController.getTagById);
router.put('/:id', tagController.updateTag);
router.delete('/:id', tagController.deleteTag);
router.get('/', tagController.getAllTags);
module.exports = router;

routes/mediaRoutes.js

const express = require('express');
const router = express.Router();
const mediaController = require('../controllers/mediaController');
router.post('/', mediaController.createMedia);
router.get('/:id', mediaController.getMediaById);
router.put('/:id', mediaController.updateMedia);
router.delete('/:id', mediaController.deleteMedia);
router.get('/', mediaController.getAllMedia);
module.exports = router;

routes/notificationRoutes.js

const express = require('express');
const router = express.Router();
const notificationController = require('../controllers/notificationController');
router.post('/', notificationController.createNotification);
router.get('/:id', notificationController.getNotificationById);
router.put('/:id', notificationController.updateNotification);
router.delete('/:id', notificationController.deleteNotification);
router.get('/', notificationController.getAllNotifications);
module.exports = router;

Step 6: Create EJS Views

In the views directory, create EJS templates for the frontend. For example, create a file named index.ejs for the homepage.

views/index.ejs

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css" rel="stylesheet">
    <title>CRUD App</title>
</head>
<body>
    <div class="container">
        <h1 class="mt-5">CRUD Application</h1>
        <div id="content"></div>
    </div>
    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/js/bootstrap.bundle.min.js"></script>
</body>
</html>

Step 7: Run the Application

In the app.js file, set up the Express server and include the routes.

app.js

const express = require('express');
const bodyParser = require('body-parser');
const userRoutes = require('./routes/userRoutes');
const postRoutes = require('./routes/postRoutes');
const commentRoutes = require('./routes/commentRoutes');
const categoryRoutes = require('./routes/categoryRoutes');
const tagRoutes = require('./routes/tagRoutes');
const mediaRoutes = require('./routes/mediaRoutes');
const notificationRoutes = require('./routes/notificationRoutes');
const sequelize = require('./config/database');
const app = express();
const PORT = process.env.PORT || 3000;
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));
app.set('view engine', 'ejs');
app.use(express.static('public'));
app.use('/api/users', userRoutes);
app.use('/api/posts', postRoutes);
app.use('/api/comments', commentRoutes);
app.use('/api/categories', categoryRoutes);
app.use('/api/tags', tagRoutes);
app.use('/api/media', mediaRoutes);
app.use('/api/notifications', notificationRoutes);
app.get('/', (req, res) => {
    res.render('index');
});
sequelize.sync().then(() => {
    app.listen(PORT, () => {
        console.log(`Server is running on http://localhost:${PORT}`);
    });
}).catch(err => {
    console.error('Unable to connect to the database:', err);
});

Directory Structure for Views

views/
├── users/
│   ├── index.ejs
│   ├── create.ejs
│   └── edit.ejs
├── posts/
│   ├── index.ejs
│   ├── create.ejs
│   └── edit.ejs
├── comments/
│   ├── index.ejs
│   ├── create.ejs
│   └── edit.ejs
├── categories/
│   ├── index.ejs
│   ├── create.ejs
│   └── edit.ejs
├── tags/
│   ├── index.ejs
│   ├── create.ejs
│   └── edit.ejs
├── media/
│   ├── index.ejs
│   ├── create.ejs
│   └── edit.ejs
├── notifications/
│   ├── index.ejs
│   ├── create.ejs
│   └── edit.ejs
└── layout.ejs

Layout File

views/layout.ejs

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css" rel="stylesheet">
    <title><%= title %></title>
</head>
<body>
    <div class="container">
        <h1 class="mt-5"><%= title %></h1>
        <nav class="navbar navbar-expand-lg navbar-light bg-light">
            <div class="container-fluid">
                <a class="navbar-brand" href="/">Home</a>
                <div class="collapse navbar-collapse" id="navbarNav">
                    <ul class="navbar-nav">
                        <li class="nav-item">
                            <a class="nav-link" href="/users">Users</a>
                        </li>
                        <li class="nav-item">
                            <a class="nav-link" href="/posts">Posts</a>
                        </li>
                        <li class="nav-item">
                            <a class="nav-link" href="/comments">Comments</a>
                        </li>
                        <li class="nav-item">
                            <a class="nav-link" href="/categories">Categories</a>
                        </li>
                        <li class="nav-item">
                            <a class="nav-link" href="/tags">Tags</a>
                        </li>
                        <li class="nav-item">
                            <a class="nav-link" href="/media">Media</a>
                        </li>
                        <li class="nav-item">
                            <a class="nav-link" href="/notifications">Notifications</a>
                        </li>
                    </ul>
                </div>
            </div>
        </nav>
        <div class="mt-4">
            <%- body %>
        </div>
    </div>
    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/js/bootstrap.bundle.min.js"></script>
</body>
</html>

User Views

views/users/index.ejs

<% layout('layout') -%>
<h2>Users</h2>
<a href="/users/create" class="btn btn-primary mb-3">Create User</a>
<table class="table">
    <thead>
        <tr>
            <th>UserId</th>
            <th>Username</th>
            <th>Email</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        <% users.forEach(user => { %>
            <tr>
                <td><%= user.UserId %></td>
                <td><%= user.Username %></td>
                <td><%= user.Email %></td>
                <td>
                    <a href="/users/edit/<%= user.UserId %>" class="btn btn-warning">Edit</a>
                    <form action="/users/<%= user.UserId %>" method="POST" style="display:inline;">
                        <input type="hidden" name="_method" value="DELETE">
                        <button type="submit" class="btn btn-danger">Delete</button>
                    </form>
                </td>
            </tr>
        <% }) %>
    </tbody>
</table>

views/users/create.ejs

<% layout('layout') -%>
<h2>Create User</h2>
 <form action="/users" method="POST">
    <div class="mb-3">
        <label for="username" class="form-label">Username</label>
        <input type="text" class="form-control" id="username" name="Username" required>
    </div>
    <div class="mb-3">
        <label for="password" class="form-label">Password</label>
        <input type="password" class="form-control" id="password" name="PasswordHash" required>
    </div>
    <div class="mb-3">
        <label for="email" class="form-label">Email</label>
        <input type="email" class="form-control" id="email" name="Email" required>
    </div>
    <button type="submit" class="btn btn-primary">Create User</button>
    <a href="/users" class="btn btn-secondary">Cancel</a>
</form>

views/users/edit.ejs

<% layout('layout') -%>
<h2>Edit User</h2>
<form action="/users/<%= user.UserId %>" method="POST">
    <input type="hidden" name="_method" value="PUT">
    <div class="mb-3">
        <label for="username" class="form-label">Username</label>
        <input type="text" class="form-control" id="username" name="Username" value="<%= user.Username %>" required>
    </div>
    <div class="mb-3">
        <label for="email" class="form-label">Email</label>
        <input type="email" class="form-control" id="email" name="Email" value="<%= user.Email %>" required>
    </div>
    <button type="submit" class="btn btn-primary">Update User</button>
    <a href="/users" class="btn btn-secondary">Cancel</a>
</form>

Post Views

views/posts/index.ejs

<% layout('layout') -%>
<h2>Posts</h2>
<a href="/posts/create" class="btn btn-primary mb-3">Create Post</a>
<table class="table">
    <thead>
        <tr>
            <th>PostId</th>
            <th>Title</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        <% posts.forEach(post => { %>
            <tr>
                <td><%= post.PostId %></td>
                <td><%= post.Title %></td>
                <td>
                    <a href="/posts/edit/<%= post.PostId %>" class="btn btn-warning">Edit</a>
                    <form action="/posts/<%= post.PostId %>" method="POST" style="display:inline;">
                        <input type="hidden" name="_method" value="DELETE">
                        <button type="submit" class="btn btn-danger">Delete</button>
                    </form>
                </td>
            </tr>
        <% }) %>
    </tbody>
</table>

views/posts/create.ejs

<% layout('layout') -%>
<h2>Create Post</h2>
<form action="/posts" method="POST">
    <div class="mb-3">
        <label for="title" class="form-label">Title</label>
        <input type="text" class="form-control" id="title" name="Title" required>
    </div>
    <div class="mb-3">
        <label for="content" class="form-label">Content</label>
        <textarea class="form-control" id="content" name="Content" required></textarea>
    </div>
    <button type="submit" class="btn btn-primary">Create Post</button>
    <a href="/posts" class="btn btn-secondary">Cancel</a>
</form>

views/posts/edit.ejs

<% layout('layout') -%>
<h2>Edit Post</h2>
<form action="/posts/<%= post.PostId %>" method="POST">
    <input type="hidden" name="_method" value="PUT">
    <div class="mb-3">
        <label for="title" class="form-label">Title</label>
        <input type="text" class="form-control" id="title" name="Title" value="<%= post.Title %>" required>
    </div>
    <div class="mb-3">
        <label for="content" class="form-label">Content</label>
        <textarea class="form-control" id="content" name="Content" required><%= post.Content %></textarea>
    </div>
    <button type="submit" class="btn btn-primary">Update Post</button>
    <a href="/posts" class="btn btn-secondary">Cancel</a>
</form>

Comment Views

views/comments/index.ejs

<% layout('layout') -%>
<h2>Comments</h2>
<a href="/comments/create" class="btn btn-primary mb-3">Create Comment</a>
<table class="table">
    <thead>
        <tr>
            <th>CommentId</th>
            <th>Content</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        <% comments.forEach(comment => { %>
            <tr>
                <td><%= comment.CommentId %></td>
                <td><%= comment.Content %></td>
                <td>
                    <a href="/comments/edit/<%= comment.CommentId %>" class="btn btn-warning">Edit</a>
                    <form action="/comments/<%= comment.CommentId %>" method="POST" style="display:inline;">
                        <input type="hidden" name="_method" value="DELETE">
                        <button type="submit" class="btn btn-danger">Delete</button>
                    </form>
                </td>
            </tr>
        <% }) %>
    </tbody>
</table>

views/comments/create.ejs

<% layout('layout') -%>
<h2>Create Comment</h2>
<form action="/comments" method="POST">
    <div class="mb-3">
        <label for="content" class="form-label">Content</label>
        <textarea class="form-control" id="content" name="Content" required></textarea>
    </div>
    <button type="submit" class="btn btn-primary">Create Comment</button>
    <a href="/comments" class="btn btn-secondary">Cancel</a>
</form>

views/comments/edit.ejs

<% layout('layout') -%>
<h2>Edit Comment</h2>
<form action="/comments/<%= comment.CommentId %>" method="POST">
    <input type="hidden" name="_method" value="PUT">
    <div class="mb-3">
        <label for="content" class="form-label">Content</label>
        <textarea class="form-control" id="content" name="Content" required><%= comment.Content %></textarea>
    </div>
    <button type="submit" class="btn btn-primary">Update Comment</button>
    <a href="/comments" class="btn btn-secondary">Cancel</a>
</form>

Category Views

views/categories/index.ejs

<% layout('layout') -%>
<h2>Categories</h2>
<a href="/categories/create" class="btn btn-primary mb-3">Create Category</a>
<table class="table">
    <thead>
        <tr>
            <th>CategoryId</th>
            <th>Name</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        <% categories.forEach(category => { %>
            <tr>
                <td><%= category.CategoryId %></td>
                <td><%= category.Name %></td>
                <td>
                    <a href="/categories/edit/<%= category.CategoryId %>" class="btn btn-warning">Edit</a>
                    <form action="/categories/<%= category.CategoryId %>" method="POST" style="display:inline;">
                        <input type="hidden" name="_method" value="DELETE">
                        <button type="submit" class="btn btn-danger">Delete</button>
                    </form>
                </td>
            </tr>
        <% }) %>
    </tbody>
</table>

views/categories/create.ejs

<% layout('layout') -%>
<h2>Create Category</h2>
<form action="/categories" method="POST">
    <div class="mb-3">
        <label for="name" class="form-label">Name</label>
        <input type="text" class="form-control" id="name" name="Name" required>
    </div>
    <button type="submit" class="btn btn-primary">Create Category</button>
    <a href="/categories" class="btn btn-secondary">Cancel</a>
</form>

views/categories/edit.ejs

<% layout('layout') -%>
<h2>Edit Category</h2>
<form action="/categories/<%= category.CategoryId %>" method="POST">
    <input type="hidden" name="_method" value="PUT">
    <div class="mb-3">
        <label for="name" class="form-label">Name</label>
        <input type="text" class="form-control" id="name" name="Name" value="<%= category.Name %>" required>
    </div>
    <button type="submit" class="btn btn-primary">Update Category</button>
    <a href="/categories" class="btn btn-secondary">Cancel</a>
</form>

Tag Views

views/tags/index.ejs

<% layout('layout') -%>
<h2>Tags</h2>
<a href="/tags/create" class="btn btn-primary mb-3">Create Tag</a>
<table class="table">
    <thead>
        <tr>
            <th>TagId</th>
            <th>Name</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        <% tags.forEach(tag => { %>
            <tr>
                <td><%= tag.TagId %></td>
                <td><%= tag.Name %></td>
                <td>
                    <a href="/tags/edit/<%= tag.TagId %>" class="btn btn-warning">Edit</a>
                    <form action="/tags/<%= tag.TagId %>" method="POST" style="display:inline;">
                        <input type="hidden" name="_method" value="DELETE">
                        <button type="submit" class="btn btn-danger">Delete</button>
                    </form>
                </td>
            </tr>
        <% }) %>
    </tbody>
</table>

views/tags/create.ejs

<% layout('layout') -%>
<h2>Create Tag</h2>
<form action="/tags" method="POST">
    <div class="mb-3">
        <label for="name" class="form-label">Name</label>
        <input type="text" class="form-control" id="name" name="Name" required>
    </div>
    <button type="submit" class="btn btn-primary">Create Tag</button>
    <a href="/tags" class="btn btn-secondary">Cancel</a>
</form>

views/tags/edit.ejs

<% layout('layout') -%>
<h2>Edit Tag</h2>
<form action="/tags/<%= tag.TagId %>" method="POST">
    <input type="hidden" name="_method" value="PUT">
    <div class="mb-3">
        <label for="name" class="form-label">Name</label>
        <input type="text" class="form-control" id="name" name="Name" value="<%= tag.Name %>" required>
    </div>
    <button type="submit" class="btn btn-primary">Update Tag</button>
    <a href="/tags" class="btn btn-secondary">Cancel</a>
</form>

Media Views

views/media/index.ejs

<% layout('layout') -%>
<h2>Media</h2>
<a href="/media/create" class="btn btn-primary mb-3">Upload Media</a>
<table class="table">
    <thead>
        <tr>
            <th>MediaId</th>
            <th>FilePath</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        <% media.forEach(mediaItem => { %>
            <tr>
                <td><%= mediaItem.MediaId %></td>
                <td><%= mediaItem.FilePath %></td>
                <td>
                    <a href="/media/edit/<%= mediaItem.MediaId %>" class="btn btn-warning">Edit</a>
                    <form action="/media/<%= mediaItem.MediaId %>" method="POST" style="display:inline;">
                        <input type="hidden" name="_method" value="DELETE">
                        <button type="submit" class="btn btn-danger">Delete</button>
                    </form>
                </td>
            </tr>
        <% }) %>
    </tbody>
</table>

views/media/create.ejs

<% layout('layout') -%>
<h2>Upload Media</h2>
<form action="/media" method="POST" enctype="multipart/form-data">
    <div class="mb-3">
        <label for="filePath" class="form-label">File Path</label>
        <input type="text" class="form-control" id="filePath" name="FilePath" required>
    </div>
    <button type="submit" class="btn btn-primary">Upload Media</button>
    <a href="/media" class="btn btn-secondary">Cancel</a>
</form>

views/media/edit.ejs

<% layout('layout') -%>
<h2>Edit Media</h2>
<form action="/media/<%= media.MediaId %>" method="POST">
    <input type="hidden" name="_method">
    <input type="hidden" name="_method" value="PUT">
    <div class="mb-3">
        <label for="filePath" class="form-label">File Path</label>
        <input type="text" class="form-control" id="filePath" name="FilePath" value="<%= media.FilePath %>" required>
    </div>
    <button type="submit" class="btn btn-primary">Update Media</button>
    <a href="/media" class="btn btn-secondary">Cancel</a>
</form>

Notification Views

views/notifications/index.ejs

<% layout('layout') -%>
<h2>Notifications</h2>
<a href="/notifications/create" class="btn btn-primary mb-3">Create Notification</a>
<table class="table">
    <thead>
        <tr>
            <th>NotificationId</th>
            <th>Message</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        <% notifications.forEach(notification => { %>
            <tr>
                <td><%= notification.NotificationId %></td>
                <td><%= notification.Message %></td>
                <td>
                    <a href="/notifications/edit/<%= notification.NotificationId %>" class="btn btn-warning">Edit</a>
                    <form action="/notifications/<%= notification.NotificationId %>" method="POST" style="display:inline;">
                        <input type="hidden" name="_method" value="DELETE">
                        <button type="submit" class="btn btn-danger">Delete</button>
                    </form>
                </td>
            </tr>
        <% }) %>
    </tbody>
</table>

views/notifications/create.ejs

<% layout('layout') -%>
<h2>Create Notification</h2>
<form action="/notifications" method="POST">
    <div class="mb-3">
        <label for="message" class="form-label">Message</label>
        <input type="text" class="form-control" id="message" name="Message" required>
    </div>
    <button type="submit" class="btn btn-primary">Create Notification</button>
    <a href="/notifications" class="btn btn-secondary">Cancel</a>
</form>

views/notifications/edit.ejs

<% layout('layout') -%>
<h2>Edit Notification</h2>
<form action="/notifications/<%= notification.NotificationId %>" method="POST">
    <input type="hidden" name="_method" value="PUT">
    <div class="mb-3">
        <label for="message" class="form-label">Message</label>
        <input type="text" class="form-control" id="message" name="Message" value="<%= notification.Message %>" required>
    </div>
    <button type="submit" class="btn btn-primary">Update Notification</button>
    <a href="/notifications" class="btn btn-secondary">Cancel</a>
</form>

These EJS views provide a complete interface for managing Users, Posts, Comments, Categories, Tags, Media, and Notifications in your CRUD application. Each view includes forms for creating and editing records, as well as tables for displaying existing records, allowing for a fully functional user experience.

To create a complete dashboard page with a controller, routes, and the necessary logic to display consolidated data related to your project, follow these steps:

Step 1: Create the Dashboard View

We already created the dashboard view in the previous response. Here’s a recap of the views/dashboard/index.ejs file:

views/dashboard/index.ejs

<% layout('layout') -%>
<h2>Project Dashboard</h2>
<div class="row">
    <div class="col-md-4">
        <div class="card text-white bg-primary mb-3">
            <div class="card-header">Total Users</div>
            <div class="card-body">
                <h5 class="card-title"><%= totalUsers %></h5>
                <p class="card-text">Number of registered users in the project.</p>
            </div>
        </div>
    </div>
    <div class="col-md-4">
        <div class="card text-white bg-success mb-3">
            <div class="card-header">Total Posts</div>
            <div class="card-body">
                <h5 class="card-title"><%= totalPosts %></h5>
                <p class="card-text">Total number of posts created.</p>
            </div>
        </div>
    </div>
    <div class="col-md-4">
        <div class="card text-white bg-danger mb-3">
            <div class="card-header">Total Comments</div>
            <div class="card-body">
                <h5 class="card-title"><%= totalComments %></h5>
                <p class="card-text">Total comments made on posts.</p>
            </div>
        </div>
    </div>
</div>
<div class="row">
    <div class="col-md-12">
        <h3>Recent Activity</h3>
        <table class="table table-striped">
            <thead>
                <tr>
                    <th>Activity</th>
                    <th>User</th>
                    <th>Date</th>
                </tr>
            </thead>
            <tbody>
                <% recentActivities.forEach(activity => { %>
                    <tr>
                        <td><%= activity.description %></td>
                        <td><%= activity.user %></td>
                        <td><%= activity.date %></td>
                    </tr>
                <% }) %>
            </tbody>
        </table>
    </div>
</div>
<div class="row">
    <div class="col-md-12">
        <h3>Project Overview</h3>
        <canvas id="projectChart" width="400" height="200"></canvas>
    </div>
</div>
<script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
<script>
    const ctx = document.getElementById('projectChart').getContext('2d');
    const projectChart = new Chart(ctx, {
        type: 'line',
        data: {
            labels: <%= JSON.stringify(chartLabels) %>,
            datasets: [{
                label: 'Project Progress',
                data: <%= JSON.stringify(chartData) %>,
                borderColor: 'rgba(75, 192, 192, 1)',
                borderWidth: 2,
                fill: false
            }]
        },
        options: {
            responsive: true,
            scales: {
                y: {
                    beginAtZero: true
                }
            }
        }
    });
</script>

Step 2: Create the Dashboard Controller

Create a new controller file for the dashboard in the controllers directory.

controllers/dashboardController.js

const User = require('../models/User');
const Post = require('../models/Post');
const Comment = require('../models/Comment');
class DashboardController {
    async getDashboard(req, res) {
        try {
            const totalUsers = await User.count();
            const totalPosts = await Post.count();
            const totalComments = await Comment.count();
            // Example recent activities (you can fetch this from your database)
            const recentActivities = [
                { description: 'User  JohnDoe created a post.', user: 'JohnDoe', date: new Date().toLocaleString() },
                { description: 'User  JaneDoe commented on a post.', user: 'JaneDoe', date: new Date().toLocaleString() },
                // Add more activities as needed
            ];
            // Example chart data (you can fetch this from your database)
            const chartLabels = ['January', 'February', 'March', 'April', 'May', 'June', 'July'];
            const chartData = [65, 59, 80, 81, 56, 55, 40]; // Example data
            res.render('dashboard/index', {
                title: 'Dashboard',
                totalUsers,
                totalPosts,
                totalComments,
                recentActivities,
                chartLabels,
                chartData
            });
        } catch (error) {
            console.error('Error fetching dashboard data:', error);
            res.status(500).send('Internal Server Error');
        }
    }
}
module.exports = new DashboardController();

Step 3: Set Up Routes

Create a new route for the dashboard in your routes directory.

routes/dashboard.js

const express = require('express');
const router = express.Router();
const dashboardController = require('../controllers/dashboardController');
router.get('/', dashboardController.getDashboard);
module.exports = router;

Step 4: Integrate the Dashboard Route

Make sure to integrate the dashboard route into your main application file (usually app.js or server.js).

app.js

const express = require('express');
const app = express();
const dashboardRoutes = require('./routes/dashboard');
// Other middleware and configurations...
app.use('/dashboard', dashboardRoutes);

// Start the server...

With these steps, you have created a complete dashboard page that includes a controller to fetch consolidated project data, routes to handle requests, and a view to display the data. This setup allows users to see key metrics, recent activities, and project progress in a visually appealing format.