Real Estate Booking Project In Node Js

Project Introduction

The Real Estate Booking System is a web application designed to facilitate the buying, selling, and renting of properties. Built using Node.js, this platform allows users to list properties, make bookings, and manage transactions efficiently. The system supports multiple user roles, including admin, buyer, seller, and agent, ensuring a tailored experience for each user type. The underlying MySQL database schema is structured to manage users, properties, bookings, payments, reviews, notifications, and documents, providing a robust foundation for effective real estate management.

Project Objectives

To develop a user-friendly interface for buyers to search for and book properties.
To allow sellers to list their properties and manage their listings.
To implement a secure user authentication system for managing user roles and permissions.
To facilitate the booking process, allowing users to reserve properties and track their booking status.
To manage payments for bookings, including various payment methods.
To provide a review system for users to rate and comment on properties.
To send notifications to users regarding important updates, such as booking confirmations and property inquiries.
To ensure the application is scalable and maintainable for future enhancements.

Project Modules

User Management Module:
This module handles user registration, authentication, and role management, allowing users to manage their accounts securely.
Property Management Module:
This module allows sellers to create, update, and manage property listings, including details such as title, description, and price.
Booking Management Module:
This module facilitates the booking process, allowing buyers to reserve properties and manage their bookings.
Payment Management Module:
This module manages payment processing for bookings, including tracking payment statuses and methods.
Review Management Module:
This module allows users to leave reviews and ratings for properties they have interacted with.
Notification Module:
This module sends notifications to users regarding important updates, such as booking confirmations and property inquiries.
Document Management Module:
This module manages documents related to properties, such as contracts and agreements, ensuring easy access and organization.

Steps Overview

Set Up the Project: Initialize a Node.js project and install necessary packages.

Configure Sequelize: Set up Sequelize to connect to your MySQL database.

Define Models: Create Sequelize models based on the provided SQL tables.

Create Repositories: Implement repository functions for CRUD operations.

Set Up Controllers: Create controllers to handle requests and responses.

Define Routes: Set up routes to connect URLs to controllers.

Create Views: Use EJS to create views for displaying data.

Implement Bootstrap 5: Style the views using Bootstrap 5.

Create a Dashboard: Implement a dashboard to display consolidated data.

Step 1: Set Up the Project


mkdir real-estate-app
cd real-estate-app
npm init -y
npm install express sequelize mysql2 ejs body-parser method-override

Step 2: Configure Sequelize

Create a file named config.js for database configuration.


// config.js
const { Sequelize } = require('sequelize');
const sequelize = new Sequelize('database_name', 'username', 'password', {
    host: 'localhost',
    dialect: 'mysql',
});
module.exports = sequelize;

Step 3: Define Models

Create a folder named models and create model files for each table.

models/User.js


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

Repeat similar steps for other models: Role, Property, Media, Appointment, Payment, Document, Report, Message, Notification, Campaign, Feedback.

Example Models for Other Tables

models/Role.js


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

models/Property.js


const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class Property extends Model {}
Property.init({
    PropertyId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    Title: {
        type: DataTypes.STRING(100),
        allowNull: false,
    },
    Description: {
        type: DataTypes.TEXT,
    },
    Address: {
        type: DataTypes.STRING(255),
        allowNull: false,
    },
    City: {
        type: DataTypes.STRING(100),
        allowNull: false,
    },
    State: {
        type: DataTypes.STRING(100),
        allowNull: false,
    },
    ZipCode: {
        type: DataTypes.STRING(10),
    },
    Price: {
        type: DataTypes.DECIMAL(10, 2),
        allowNull: false,
    },
    PropertyType: {
        type: DataTypes.STRING(50),
    },
    Status: {
        type: DataTypes.STRING(20),
        defaultValue: 'Available',
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'Property',
    tableName: 'Properties',
    timestamps: false,
});
module.exports = Property;

Step 4: Create Repositories

Create a folder named repositories and implement repository functions for CRUD operations.

repositories/userRepository.js


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

Repeat similar steps for other repositories: RoleRepository, PropertyRepository, etc.

Step 5: Set Up Controllers

Create a folder named controllers and create controller files for handling requests.

controllers/userController.js


const userRepository = require('../repositories/userRepository');
class UserController {
    async createUser (req, res) {
        try {
            const user = await userRepository.createUser (req.body);
            res.redirect('/users');
        } catch (error) {
            console.error(error);
            res.status(500).send('Internal Server Error');
        }
    }
    async getAllUsers(req, res) {
        const users = await userRepository.getAllUsers();
        res.render('users/index', { users });
    }
    async getUser (req, res) {
        const user = await userRepository.getUser ById(req.params.id);
        res.render('users/edit', { user });
    }
    async updateUser (req, res) {
        await userRepository.updateUser (req.params.id, req.body);
        res.redirect('/users');
    }
    async deleteUser (req, res) {
        await userRepository.deleteUser (req.params.id);
        res.redirect('/users');
    }
}
module.exports = new UserController();

Step 6: Define Routes

Create a folder named routes and set up routes for users.

routes/userRoutes.js


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

Step 7: Create Views

Create a folder named views and subfolders for each entity. Use EJS to create views.

views/users/index.ejs


<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/5.0.0-beta1/css/bootstrap.min.css">
    <title>Users</title>
</head>
<body>
    <div class="container">
        <h1>Users</h1>
        <a href="/users/create" class="btn btn-primary">Create User</a>
        <table class="table">
            <thead>
                <tr>
                    <th>Username</th>
                    <th>Email</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% users.forEach(user => { %>
                    <tr>
                        <td><%= user.Username %></td>
                        <td><%= user.Email %></td>
                        <td>
                            <a href="/users/<%= user.UserId %>" class="btn btn-warning">Edit</a>
                            <form action="/users/<%= user.UserId %>?_method=DELETE" method="POST" style="display:inline;">
                                <button type="submit" class="btn btn-danger">Delete</button>
                            </form>
                        </td>
                    </tr>
                <% }) %>
            </tbody>
        </table>
    </div>
</body>
</html>

Step 8: Implement Bootstrap 5

Ensure all views use Bootstrap 5 for styling, as shown in the example above.

Step 9: Create a Dashboard

Implement a dashboard similar to the previous example, summarizing key metrics from the application.

Final Steps

Update the main application file to include all routes.

Test the application to ensure all CRUD operations work as expected.

Consider adding user authentication and authorization for enhanced security.

Following are the complete implementation for the remaining models, repositories, controllers, routes, and views for the entities: Role, Property, Media, Appointment, Payment, Document, Report, Message, Notification, Campaign, and Feedback.

Step 3: Define Models for Remaining Tables

models/Media.js


const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class Media extends Model {}
Media.init({
    MediaId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    PropertyId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    MediaType: {
        type: DataTypes.STRING(50), // e.g., Image, Video
        allowNull: false,
    },
    MediaUrl: {
        type: DataTypes.STRING(255),
        allowNull: false,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'Media',
    tableName: 'Media',
    timestamps: false,
});
module.exports = Media;

models/Appointment.js


const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class Appointment extends Model {}
Appointment.init({
    AppointmentId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    PropertyId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    AppointmentDate: {
        type: DataTypes.DATE,
        allowNull: false,
    },
    Status: {
        type: DataTypes.STRING(20),
        defaultValue: 'Scheduled',
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'Appointment',
    tableName: 'Appointments',
    timestamps: false,
});
module.exports = Appointment;

models/Payment.js


const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class Payment extends Model {}
Payment.init({
    PaymentId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    PropertyId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    Amount: {
        type: DataTypes.DECIMAL(10, 2),
        allowNull: false,
    },
    PaymentDate: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    PaymentMethod: {
        type: DataTypes.STRING(50), // e.g., Credit Card, Bank Transfer
    },
    Status: {
        type: DataTypes.STRING(20),
        defaultValue: 'Pending',
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'Payment',
    tableName: 'Payments',
    timestamps: false,
});
module.exports = Payment;

models/Document.js


const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class Document extends Model {}
Document.init({
    DocumentId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    PropertyId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    DocumentType: {
        type: DataTypes.STRING(50), // e.g., Lease Agreement, Title Deed
        allowNull: false,
    },
    DocumentUrl: {
        type: DataTypes.STRING(255),
        allowNull: false,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'Document',
    tableName: 'Documents',
    timestamps: false,
});
module.exports = Document;

models/Report.js


const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class Report extends Model {}
Report.init({
    ReportId: {
        type: DataTypes.INTEGER,
 primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    PropertyId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    ReportDate: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    Description: {
        type: DataTypes.TEXT,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'Report',
    tableName: 'Reports',
    timestamps: false,
});
module.exports = Report;

models/Message.js


const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class Message extends Model {}
Message.init({
    MessageId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    SenderId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    ReceiverId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    MessageText: {
        type: DataTypes.TEXT,
        allowNull: false,
    },
    SentAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'Message',
    tableName: 'Messages',
    timestamps: false,
});
module.exports = Message;

models/Notification.js


const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class Notification extends Model {}
Notification.init({
    NotificationId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    Message: {
        type: DataTypes.TEXT,
        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;

models/Campaign.js


const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class Campaign extends Model {}
Campaign.init({
    CampaignId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    CampaignName: {
        type: DataTypes.STRING(100),
        allowNull: false,
    },
    StartDate: {
        type: DataTypes.DATE,
    },
    EndDate: {
        type: DataTypes.DATE,
    },
    DiscountPercentage: {
        type: DataTypes.DECIMAL(5, 2),
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'Campaign',
    tableName: 'Campaigns',
    timestamps: false,
});
module.exports = Campaign;

models/Feedback.js


const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class Feedback extends Model {}
Feedback.init({
    FeedbackId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    Comments: {
        type: DataTypes.TEXT,
    },
    Rating: {
        type: DataTypes.INTEGER,
        validate: {
            min: 1,
            max: 5,
        },
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'Feedback',
    tableName: 'Feedbacks',
    timestamps: false,
});
module.exports = Feedback;

Step 4: Create Repositories for Remaining Tables

repositories/roleRepository.js


const Role = require('../models/Role');
class RoleRepository {
    async createRole(roleData) {
        return await Role.create(roleData);
    }
    async getAllRoles() {
        return await Role.findAll();
    }
    async getRoleById(roleId) {
        return await Role.findByPk(roleId);
    }
    async updateRole(roleId, roleData) {
        await Role.update(roleData , { where: { RoleId: roleId } });
    }
    async deleteRole(roleId) {
        await Role.destroy({ where: { RoleId: roleId } });
    }
}
module.exports = new RoleRepository();

repositories/propertyRepository.js


const Property = require('../models/Property');
class PropertyRepository {
    async createProperty(propertyData) {
        return await Property.create(propertyData);
    }
    async getAllProperties() {
        return await Property.findAll();
    }
    async getPropertyById(propertyId) {
        return await Property.findByPk(propertyId);
    }
    async updateProperty(propertyId, propertyData) {
        await Property.update(propertyData, { where: { PropertyId: propertyId } });
    }
    async deleteProperty(propertyId) {
        await Property.destroy({ where: { PropertyId: propertyId } });
    }
}
module.exports = new PropertyRepository();

repositories/mediaRepository.js


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

repositories/appointmentRepository.js


const Appointment = require('../models/Appointment');
class AppointmentRepository {
    async createAppointment(appointmentData) {
        return await Appointment.create(appointmentData);
    }
    async getAllAppointments() {
        return await Appointment.findAll();
    }
    async getAppointmentById(appointmentId) {
        return await Appointment.findByPk(appointmentId);
    }
    async updateAppointment(appointmentId, appointmentData) {
        await Appointment.update(appointmentData, { where: { AppointmentId: appointmentId } });
    }
    async deleteAppointment(appointmentId) {
        await Appointment.destroy({ where: { AppointmentId: appointmentId } });
    }
}
module.exports = new AppointmentRepository();

repositories/paymentRepository.js


const Payment = require('../models/Payment');
class PaymentRepository {
    async createPayment(paymentData) {
        return await Payment.create(paymentData);
    }
    async getAllPayments() {
        return await Payment.findAll();
    }
    async getPaymentById(paymentId) {
        return await Payment.findByPk(paymentId);
    }
    async updatePayment(paymentId, paymentData) {
        await Payment.update(paymentData, { where: { PaymentId: paymentId } });
    }
    async deletePayment(paymentId) {
        await Payment.destroy({ where: { PaymentId: paymentId } });
    }
}
module.exports = new PaymentRepository();

repositories/documentRepository.js


const Document = require('../models/Document');
class DocumentRepository {
    async createDocument(documentData) {
        return await Document.create(documentData);
    }
    async getAllDocuments() {
        return await Document.findAll();
    }
    async getDocumentById(documentId) {
        return await Document.findByPk(documentId);
    }
    async updateDocument(documentId, documentData) {
        await Document.update(documentData, { where: { DocumentId: documentId } });
    }
    async deleteDocument(documentId) {
        await Document.destroy({ where: { DocumentId: documentId } });
    }
}
module.exports = new DocumentRepository();

repositories/reportRepository.js


const Report = require('../models/Report');
class ReportRepository {
    async createReport(reportData) {
        return await Report.create(reportData);
    }
    async getAllReports() {
        return await Report.findAll();
    }
    async getReportById(reportId) {
        return await Report.findByPk(reportId);
    }
    async updateReport(reportId, reportData) {
        await Report.update(reportData, { where: { ReportId: reportId } });
    }
    async deleteReport(reportId) {
        await Report.destroy({ where: { ReportId: reportId } });
    }
}
module.exports = new ReportRepository();

repositories/messageRepository.js


const Message = require('../models/Message');
class MessageRepository {
    async createMessage(messageData) {
        return await Message.create(messageData);
    }
    async getAllMessages() {
        return await Message.findAll();
    }
    async getMessageById(messageId) {
        return await Message.findByPk(messageId);
    }
    async updateMessage(messageId, messageData) {
        await Message.update(messageData, { where: { MessageId: messageId } });
    }
    async deleteMessage(messageId) {
        await Message.destroy({ where: { MessageId: messageId } });
    }
}
module.exports = new MessageRepository();

repositories/notificationRepository.js


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

repositories/campaignRepository.js


const Campaign = require('../models/Campaign');
class CampaignRepository {
    async createCampaign(campaignData) {
        return await Campaign.create(campaignData);
    }
    async getAllCampaigns() {
        return await Campaign.findAll();
    }
    async getCampaignById(campaignId) {
        return await Campaign.findByPk(campaignId);
    }
    async updateCampaign(campaignId, campaignData) {
        await Campaign.update(campaignData, { where: { CampaignId: campaignId } });
    }
    async deleteCampaign(campaignId) {
        await Campaign.destroy({ where: { CampaignId: campaignId } });
    }
}
module.exports = new CampaignRepository();

repositories/feedbackRepository.js


const Feedback = require('../models/Feedback');
class FeedbackRepository {
    async createFeedback(feedbackData) {
        return await Feedback.create(feedbackData);
    }
    async getAllFeedbacks() {
        return await Feedback.findAll();
    }
    async getFeedbackById(feedbackId) {
        return await Feedback.findByPk(feedbackId);
    }
    async updateFeedback(feedbackId, feedbackData) {
        await Feedback.update(feedbackData, { where: { FeedbackId: feedbackId } });
    }
    async deleteFeedback(feedbackId) {
        await Feedback.destroy({ where: { FeedbackId: feedbackId } });
    }
}
module.exports = new FeedbackRepository();

Step 5: Set Up Controllers for Remaining Tables

controllers/roleController.js


const roleRepository = require('../repositories/roleRepository');
class RoleController {
    async createRole(req, res) {
        try {
            await roleRepository.createRole(req.body);
            res.redirect('/roles');
        } catch (error) {
            console.error(error);
            res.status(500).send('Internal Server Error');
        }
    }
    async getAllRoles(req, res) {
        const roles = await roleRepository.getAllRoles();
        res.render('roles/index', { roles });
    }
    async getRole(req, res) {
        const role = await roleRepository.getRoleById(req.params.id);
        res.render('roles/edit', { role });
    }
    async updateRole(req, res) {
        await roleRepository.updateRole(req.params.id, req.body);
        res.redirect('/roles');
    }
    async deleteRole(req, res) {
        await roleRepository.deleteRole(req.params.id);
        res.redirect('/roles');
    }
}
module.exports = new RoleController();

controllers/propertyController.js


const propertyRepository = require('../repositories/propertyRepository');
class PropertyController {
    async createProperty(req, res) {
        try {
            await propertyRepository.createProperty(req.body);
            res.redirect('/properties');
        } catch (error) {
            console.error(error);
            res.status(500).send('Internal Server Error');
        }
    }
    async getAllProperties(req, res) {
        const properties = await propertyRepository.getAllProperties();
        res.render('properties/index', { properties });
    }
    async getProperty(req, res) {
        const property = await propertyRepository.getPropertyById(req.params.id);
        res.render('properties/edit', { property });
    }
    async updateProperty(req, res) {
        await propertyRepository.updateProperty(req.params.id, req.body);
        res.redirect('/properties');
    }
    async deleteProperty(req, res) {
        await propertyRepository.deleteProperty(req.params.id);
        res.redirect('/properties');
    }
}
module.exports = new PropertyController();

controllers/mediaController.js


const mediaRepository = require('../repositories/mediaRepository');
class MediaController {
    async createMedia(req, res) {
        try {
            await mediaRepository.createMedia(req.body);
            res.redirect('/media');
        } catch (error) {
            console.error(error);
            res.status(500).send('Internal Server Error');
        }
    }
    async getAllMedia(req, res) {
        const media = await mediaRepository.getAllMedia();
        res.render('media/index', { media });
    }
    async getMedia(req, res) {
        const mediaItem = await mediaRepository.getMediaById(req.params.id);
        res.render('media/edit', { mediaItem });
    }
    async updateMedia(req, res) {
        await mediaRepository.updateMedia(req.params.id, req.body);
        res.redirect('/media');
    }
    async deleteMedia(req, res) {
        await mediaRepository.deleteMedia(req.params.id);
        res.redirect('/media');
    }
}
module.exports = new MediaController();

controllers/appointmentController.js


const appointmentRepository = require('../repositories/appointmentRepository');
class AppointmentController {
    async createAppointment(req, res) {
        try {
            await appointmentRepository.createAppointment(req.body);
            res.redirect('/appointments');
        } catch (error) {
            console.error(error);
            res.status(500).send('Internal Server Error');
        }
    }
    async getAllAppointments(req, res) {
        const appointments = await appointmentRepository.getAllAppointments();
        res.render('appointments/index', { appointments });
    }
    async getAppointment(req, res) {
        const appointment = await appointmentRepository.getAppointmentById(req.params.id);
        res.render('appointments/edit', { appointment });
    }
    async updateAppointment(req, res) {
        await appointmentRepository.updateAppointment(req.params.id, req.body);
        res.redirect('/appointments');
    }
    async deleteAppointment(req, res) {
        await appointmentRepository.deleteAppointment(req.params.id);
        res.redirect('/appointments');
    }
}
module.exports = new AppointmentController();

controllers/paymentController.js


const paymentRepository = require('../repositories/paymentRepository');
class PaymentController {
    async createPayment(req, res) {
        try {
            await paymentRepository.createPayment(req.body);
            res.redirect('/payments');
        } catch (error) {
            console.error(error);
            res.status(500).send('Internal Server Error');
        }
    }
    async getAllPayments(req, res) {
        const payments = await paymentRepository.getAllPayments();
        res.render('payments/index', { payments });
    }
    async getPayment(req, res) {
        const payment = await paymentRepository.getPaymentById(req.params.id);
        res.render('payments/edit', { payment });
    }
    async updatePayment(req, res) {
        await paymentRepository.updatePayment(req.params.id, req.body);
        res.redirect('/payments');
    }
    async deletePayment(req, res) {
        await paymentRepository.deletePayment(req.params.id);
        res.redirect('/payments');
    }
}
module.exports = new PaymentController();

controllers/documentController.js


const documentRepository = require('../repositories/documentRepository');
class DocumentController {
    async createDocument(req, res) {
        try {
            await documentRepository.createDocument(req.body);
            res.redirect('/documents');
        } catch (error) {
            console.error(error);
            res.status(500).send('Internal Server Error');
        }
    }
    async getAllDocuments(req, res) {
        const documents = await documentRepository.getAllDocuments();
        res.render('documents/index', { documents });
    }
    async getDocument(req, res) {
        const document = await documentRepository.getDocumentById(req.params.id);
        res.render('documents/edit', { document });
    }
    async updateDocument(req, res) {
        await documentRepository.updateDocument(req.params.id, req.body);
        res.redirect('/documents');
    }
    async deleteDocument(req, res) {
        await documentRepository.deleteDocument(req.params.id);
        res.redirect('/documents');
    }
}
module.exports = new DocumentController();

controllers/reportController.js


const reportRepository = require('../repositories/reportRepository');
class ReportController {
    async createReport(req, res) {
        try {
            await reportRepository.createReport(req.body);
            res.redirect('/reports');
        } catch (error) {
            console.error(error);
            res.status(500).send('Internal Server Error');
        }
    }
    async getAllReports(req, res) {
        const reports = await reportRepository.getAllReports();
        res.render('reports/index', { reports });
    }
    async getReport(req, res) {
        const report = await reportRepository.getReportById(req.params.id);
        res.render('reports/edit', { report });
    }
    async updateReport(req, res) {
        await reportRepository.updateReport(req.params.id, req.body);
        res.redirect('/reports');
    }
    async deleteReport(req, res) {
        await reportRepository.deleteReport(req.params.id);
        res.redirect('/reports');
    }
}
module.exports = new ReportController();

controllers/messageController.js


const messageRepository = require('../repositories/messageRepository');
class MessageController {
    async createMessage(req, res) {
        try {
            await messageRepository.create Message(req.body);
            res.redirect('/messages');
        } catch (error) {
            console.error(error);
            res.status(500).send('Internal Server Error');
        }
    }
    async getAllMessages(req, res) {
        const messages = await messageRepository.getAllMessages();
        res.render('messages/index', { messages });
    }
    async getMessage(req, res) {
        const message = await messageRepository.getMessageById(req.params.id);
        res.render('messages/edit', { message });
    }
    async updateMessage(req, res) {
        await messageRepository.updateMessage(req.params.id, req.body);
        res.redirect('/messages');
    }
    async deleteMessage(req, res) {
        await messageRepository.deleteMessage(req.params.id);
        res.redirect('/messages');
    }
}
module.exports = new MessageController();

controllers/notificationController.js


const notificationRepository = require('../repositories/notificationRepository');
class NotificationController {
    async createNotification(req, res) {
        try {
            await notificationRepository.createNotification(req.body);
            res.redirect('/notifications');
        } catch (error) {
            console.error(error);
            res.status(500).send('Internal Server Error');
        }
    }
    async getAllNotifications(req, res) {
        const notifications = await notificationRepository.getAllNotifications();
        res.render('notifications/index', { notifications });
    }
    async getNotification(req, res) {
        const notification = await notificationRepository.getNotificationById(req.params.id);
        res.render('notifications/edit', { notification });
    }
    async updateNotification(req, res) {
        await notificationRepository.updateNotification(req.params.id, req.body);
        res.redirect('/notifications');
    }
    async deleteNotification(req, res) {
        await notificationRepository.deleteNotification(req.params.id);
        res.redirect('/notifications');
    }
}
module.exports = new NotificationController();

controllers/campaignController.js


const campaignRepository = require('../repositories/campaignRepository');
class CampaignController {
    async createCampaign(req, res) {
        try {
            await campaignRepository.createCampaign(req.body);
            res.redirect('/campaigns');
        } catch (error) {
            console.error(error);
            res.status(500).send('Internal Server Error');
        }
    }
    async getAllCampaigns(req, res) {
        const campaigns = await campaignRepository.getAllCampaigns();
        res.render('campaigns/index', { campaigns });
    }
    async getCampaign(req, res) {
        const campaign = await campaignRepository.getCampaignById(req.params.id);
        res.render('campaigns/edit', { campaign });
    }
    async updateCampaign(req, res) {
        await campaignRepository.updateCampaign(req.params.id, req.body);
        res.redirect('/campaigns');
    }
    async deleteCampaign(req, res) {
        await campaignRepository.deleteCampaign(req.params.id);
        res.redirect('/campaigns');
    }
}
module.exports = new CampaignController();

controllers/feedbackController.js


const feedbackRepository = require('../repositories/feedbackRepository');
class FeedbackController {
    async createFeedback(req, res) {
        try {
            await feedbackRepository.createFeedback(req.body);
            res.redirect('/feedbacks');
        } catch (error) {
            console.error(error);
            res.status(500).send('Internal Server Error');
        }
    }
    async getAllFeedbacks(req, res) {
        const feedbacks = await feedbackRepository.getAllFeedbacks();
        res.render('feedbacks/index', { feedbacks });
    }
    async getFeedback(req, res) {
        const feedback = await feedbackRepository.getFeedbackById(req.params.id);
        res.render('feedbacks/edit', { feedback });
    }
    async updateFeedback(req, res) {
        await feedbackRepository.updateFeedback(req.params.id, req.body);
        res.redirect('/feedbacks');
    }
    async deleteFeedback(req, res) {
        await feedbackRepository.deleteFeedback(req.params.id);
        res.redirect('/feedbacks');
    }
}
module.exports = new FeedbackController();

Step 6: Define Routes for Remaining Tables

routes/roleRoutes.js


const express = require('express');
const router = express.Router();
const roleController = require('../controllers/roleController');
router.get('/', roleController.getAllRoles);
router.get('/create', (req, res) => res.render('roles/create'));
router.post('/', roleController.createRole);
router.get('/:id', roleController.getRole);
router.put('/:id', roleController.updateRole);
router.delete('/:id', roleController.deleteRole);
module.exports = router;

routes/propertyRoutes.js


const express = require('express');
const router = express.Router();
const propertyController = require('../controllers/propertyController');
router.get('/', propertyController.getAllProperties);
router.get('/create', (req, res) => res.render('properties/create'));
router.post('/', propertyController.createProperty);
router.get('/:id ', propertyController.getProperty);
router.put('/:id', propertyController.updateProperty);
router.delete('/:id', propertyController.deleteProperty);
module.exports = router;

routes/mediaRoutes.js


const express = require('express');
const router = express.Router();
const mediaController = require('../controllers/mediaController');
router.get('/', mediaController.getAllMedia);
router.get('/create', (req, res) => res.render('media/create'));
router.post('/', mediaController.createMedia);
router.get('/:id', mediaController.getMedia);
router.put('/:id', mediaController.updateMedia);
router.delete('/:id', mediaController.deleteMedia);
module.exports = router;

routes/appointmentRoutes.js


const express = require('express');
const router = express.Router();
const appointmentController = require('../controllers/appointmentController');
router.get('/', appointmentController.getAllAppointments);
router.get('/create', (req, res) => res.render('appointments/create'));
router.post('/', appointmentController.createAppointment);
router.get('/:id', appointmentController.getAppointment);
router.put('/:id', appointmentController.updateAppointment);
router.delete('/:id', appointmentController.deleteAppointment);
module.exports = router;

routes/paymentRoutes.js


const express = require('express');
const router = express.Router();
const paymentController = require('../controllers/paymentController');
router.get('/', paymentController.getAllPayments);
router.get('/create', (req, res) => res.render('payments/create'));
router.post('/', paymentController.createPayment);
router.get('/:id', paymentController.getPayment);
router.put('/:id', paymentController.updatePayment);
router.delete('/:id', paymentController.deletePayment);
module.exports = router;

routes/documentRoutes.js


const express = require('express');
const router = express.Router();
const documentController = require('../controllers/documentController');
router.get('/', documentController.getAllDocuments);
router.get('/create', (req, res) => res.render('documents/create'));
router.post('/', documentController.createDocument);
router.get('/:id', documentController.getDocument);
router.put('/:id', documentController.updateDocument);
router.delete('/:id', documentController.deleteDocument);
module.exports = router;

routes/reportRoutes.js


const express = require('express');
const router = express.Router();
const reportController = require('../controllers/reportController');
router.get('/', reportController.getAllReports);
router.get('/create', (req, res) => res.render('reports/create'));
router.post('/', reportController.createReport);
router.get('/:id', reportController.getReport);
router.put('/:id', reportController.updateReport);
router.delete('/:id', reportController.deleteReport);
module.exports = router;

routes/messageRoutes.js


const express = require('express');
const router = express.Router();
const messageController = require('../controllers/messageController');
router.get('/', messageController.getAllMessages);
router.get('/create', (req, res) => res.render('messages/create'));
router.post('/', messageController.createMessage);
router.get('/:id', messageController.getMessage);
router.put('/:id', messageController.updateMessage);
router.delete('/:id', messageController.deleteMessage);
module.exports = router;

routes/notificationRoutes.js


const express = require('express');
const router = express.Router();
const notificationController = require('../controllers/notificationController');
router.get('/', notificationController.getAllNotifications);
router.get('/create', (req, res) => res.render('notifications/create'));
router.post('/', notificationController.createNotification);
router.get('/:id', notificationController.getNotification);
router.put('/:id', notificationController.updateNotification);
router.delete('/:id', notificationController.deleteNotification);
module.exports = router;

routes/campaignRoutes.js


const express = require('express');
const router = express.Router();
const campaignController = require('../controllers/campaignController');
router.get('/', campaignController.getAllCampaigns);
router.get('/create', (req, res) => res.render('campaigns/create'));
router.post('/', campaignController.createCampaign);
router.get('/:id', campaignController.getCampaign);
router.put('/:id', campaignController.updateCampaign);
router.delete('/:id', campaignController.deleteCampaign);
module.exports = router;

routes/feedbackRoutes.js


const express = require('express');
const router = express.Router();
const feedbackController = require('../controllers/feedbackController');
router.get('/', feedbackController.getAllFeedbacks);
router.get('/create', (req, res) => res.render('feedbacks/create'));
router.post('/', feedbackController.createFeedback);
router.get('/:id', feedbackController.getFeedback);
router.put('/:id', feedbackController.updateFeedback);
router.delete('/:id', feedbackController.deleteFeedback);
module.exports = router;

Step 7: Create Views for Remaining Tables

views/roles/index.ejs


<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width =device-width, initial-scale=1.0">
    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/5.0.0-beta1/css/bootstrap.min.css">
    <title>Roles</title>
</head>
<body>
    <div class="container">
        <h1>Roles</h1>
        <a href="/roles/create" class="btn btn-primary">Create Role</a>
        <table class="table">
            <thead>
                <tr>
                    <th>Role Name</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% roles.forEach(role => { %>
                    <tr>
                        <td><%= role.RoleName %></td>
                        <td>
                            <a href="/roles/<%= role.RoleId %>" class="btn btn-warning">Edit</a>
                            <form action="/roles/<%= role.RoleId %>?_method=DELETE" method="POST" style="display:inline;">
                                <button type="submit" class="btn btn-danger">Delete</button>
                            </form>
                        </td>
                    </tr>
                <% }) %>
            </tbody>
        </table>
    </div>
</body>
</html>

views/properties/index.ejs


<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/5.0.0-beta1/css/bootstrap.min.css">
    <title>Properties</title>
</head>
<body>
    <div class="container">
        <h1>Properties</h1>
        <a href="/properties/create" class="btn btn-primary">Create Property</a>
        <table class="table">
            <thead>
                <tr>
                    <th>Title</th>
                    <th>Price</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% properties.forEach(property => { %>
                    <tr>
                        <td><%= property.Title %></td>
                        <td><%= property.Price %></td>
                        <td>
                            <a href="/properties/<%= property.PropertyId %>" class="btn btn-warning">Edit</a>
                            <form action="/properties/<%= property.PropertyId %>?_method=DELETE" method="POST" style="display:inline;">
                                <button type="submit" class="btn btn-danger">Delete</button>
                            </form>
                        </td>
                    </tr>
                <% }) %>
            </tbody>
        </table>
    </div>
</body>
</html>

views/media/index.ejs


<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/5.0.0-beta1/css/bootstrap.min.css">
    <title>Media</title>
</head>
<body>
    <div class="container">
        <h1>Media</h1>
        <a href="/media/create" class="btn btn-primary">Upload Media</a>
        <table class="table">
            <thead>
                <tr>
                    <th>Media Type</th>
                    <th>Media URL</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% media.forEach(mediaItem => { %>
                    <tr>
                        <td><%= mediaItem.MediaType %></td>
                        <td><%= mediaItem.MediaUrl %></td>
                        <td>
                            <a href="/media/<%= mediaItem.MediaId %>" class="btn btn-warning">Edit</a>
                            <form action="/media/<%= mediaItem.MediaId %>?_method=DELETE" method="POST" style="display:inline;">
                                <button type="submit" class="btn btn-danger">Delete</button>
                            </form>
                        </td>
                    </tr>
                <% }) %>
            </tbody>
        </table>
    </div>
</body>
</html>

views/appointments/index.ejs


<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/5.0.0-beta1/css/bootstrap.min.css">
    <title>Appointments</title>
</head>
<body>
    <div class="container">
        <h1>Appointments </h1>
        <a href="/appointments/create" class="btn btn-primary">Schedule Appointment</a>
        <table class="table">
            <thead>
                <tr>
                    <th>User ID</th>
                    <th>Property ID</th>
                    <th>Appointment Date</th>
                    <th>Status</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% appointments.forEach(appointment => { %>
                    <tr>
                        <td><%= appointment.UserId %></td>
                        <td><%= appointment.PropertyId %></td>
                        <td><%= appointment.AppointmentDate %></td>
                        <td><%= appointment.Status %></td>
                        <td>
                            <a href="/appointments/<%= appointment.AppointmentId %>" class="btn btn-warning">Edit</a>
                            <form action="/appointments/<%= appointment.AppointmentId %>?_method=DELETE" method="POST" style="display:inline;">
                                <button type="submit" class="btn btn-danger">Delete</button>
                            </form>
                        </td>
                    </tr>
                <% }) %>
            </tbody>
        </table>
    </div>
</body>
</html>

views/payments/index.ejs


<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/5.0.0-beta1/css/bootstrap.min.css">
    <title>Payments</title>
</head>
<body>
    <div class="container">
        <h1>Payments</h1>
        <a href="/payments/create" class="btn btn-primary">Add Payment</a>
        <table class="table">
            <thead>
                <tr>
                    <th>User ID</th>
                    <th>Property ID</th>
                    <th>Amount</th>
                    <th>Payment Date</th>
                    <th>Status</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% payments.forEach(payment => { %>
                    <tr>
                        <td><%= payment.UserId %></td>
                        <td><%= payment.PropertyId %></td>
                        <td><%= payment.Amount %></td>
                        <td><%= payment.PaymentDate %></td>
                        <td><%= payment.Status %></td>
                        <td>
                            <a href="/payments/<%= payment.PaymentId %>" class="btn btn-warning">Edit</a>
                            <form action="/payments/<%= payment.PaymentId %>?_method=DELETE" method="POST" style="display:inline;">
                                <button type="submit" class="btn btn-danger">Delete</button>
                            </form>
                        </td>
                    </tr>
                <% }) %>
            </tbody>
        </table>
    </div>
</body>
</html>

views/documents/index.ejs


<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/5.0.0-beta1/css/bootstrap.min.css">
    <title>Documents</title>
</head>
<body>
    <div class="container">
        <h1>Documents</h1>
        <a href="/documents/create" class="btn btn-primary">Upload Document</a>
        <table class="table">
            <thead>
                <tr>
                    <th>Property ID</th>
                    <th>Document Type</th>
                    <th>Document URL</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% documents.forEach(document => { %>
                    <tr>
                        <td><%= document.PropertyId %></td>
                        <td><%= document.DocumentType %></td>
                        <td><%= document.DocumentUrl %></td>
                        <td>
                            <a href="/documents/<%= document.DocumentId %>" class="btn btn-warning">Edit</a>
                            <form action="/documents/<%= document.DocumentId %>?_method=DELETE" method="POST" style="display:inline;">
                                <button type="submit" class="btn btn-danger">Delete</button>
                            </form>
                        </td>
                    </tr>
                <% }) %>
            </tbody>
        </table>
    </div>
</body>
</html>

views/reports/index.ejs


<!DOCTYPE html>
<html lang="en">
<head>    
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/5.0.0-beta1/css/bootstrap.min.css">
    <title>Reports</title>
</head>
<body>
    <div class="container">
        <h1>Reports</h1>
        <a href="/reports/create" class="btn btn-primary">Create Report</a>
        <table class="table">
            <thead>
                <tr>
                    <th>User ID</th>
                    <th>Property ID</th>
                    <th>Report Date</th>
                    <th>Description</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% reports.forEach(report => { %>
                    <tr>
                        <td><%= report.UserId %></td>
                        <td><%= report.PropertyId %></td>
                        <td><%= report.ReportDate %></td>
                        <td><%= report.Description %></td>
                        <td>
                            <a href="/reports/<%= report.ReportId %>" class="btn btn-warning">Edit</a>
                            <form action="/reports/<%= report.ReportId %>?_method=DELETE" method="POST" style="display:inline;">
                                <button type="submit" class="btn btn-danger">Delete</button>
                            </form>
                        </td>
                    </tr>
                <% }) %>
            </tbody>
        </table>
    </div>
</body>
</html>

views/messages/index.ejs


<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/5.0.0-beta1/css/bootstrap.min.css">
    <title>Messages</title>
</head>
<body>
    <div class="container">
        <h1>Messages</h1>
        <a href="/messages/create" class="btn btn-primary">Send Message</a>
        <table class="table">
            <thead>
                <tr>
                    <th>Sender ID</th>
                    <th>Receiver ID</th>
                    <th>Message Text</th>
                    <th>Sent At</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% messages.forEach(message => { %>
                    <tr>
                        <td><%= message.SenderId %></td>
                        <td><%= message.ReceiverId %></td>
                        <td><%= message.MessageText %></td>
                        <td><%= message.SentAt %></td>
                        <td>
                            <a href="/messages/<%= message.MessageId %>" class="btn btn-warning">Edit</a>
                            <form action="/messages/<%= message.MessageId %>?_method=DELETE" method="POST" style="display:inline;">
                                <button type="submit" class="btn btn-danger">Delete</button>
                            </form>
                        </td>
                    </tr>
                <% }) %>
            </tbody>
        </table>
    </div>
</body>
</html>

views/notifications/index.ejs


<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/5.0.0-beta1/css/bootstrap.min.css">
    <title>Notifications</title>
</head>
<body>
    <div class="container">
        <h1>Notifications</h1>
        <a href="/notifications/create" class="btn btn-primary">Create Notification</a>
        <table class="table">
            <thead>
                <tr>
                    <th>User ID</th>
                    <th>Message</th>
                    <th>Is Read</th>
                    <th>Created At</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% notifications.forEach(notification => { %>
                    <tr>
                        <td><%= notification.UserId %></td>
                        <td><%= notification.Message %></td>
                        <td><%= notification.IsRead ? 'Yes' : 'No' %></td>
                        <td><%= notification.CreatedAt %></td>
                        <td>
                            <a href="/notifications/<%= notification.NotificationId %>" class="btn btn-warning">Edit</a>
                            <form action="/notifications/<%= notification.NotificationId %>?_method=DELETE" method="POST" style="display:inline;">
                                <button type="submit" class="btn btn-danger">Delete</button>
                            </form>
                        </td>
                    </tr>
                <% }) %>
            </tbody>
        </table>
    </div>
</body>
</html>

views/campaigns/index.ejs


<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/5.0.0-beta1/css/bootstrap.min.css">
    <title>Campaigns</title>
</head>
<body>
    <div class="container">
        <h1>Campaigns</h1>
        <a href="/campaigns/create" class="btn btn-primary">Create Campaign</a>
        <table class="table">
            <thead>
                <tr>
                    <th>Campaign Name</th>
                    <th>Start Date</th>
                    <th>End Date</th>
                    <th>Discount Percentage</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% campaigns.forEach(campaign => { %>
                    <tr>
                        <td><%= campaign.CampaignName %></td>
                        <td><%= campaign.StartDate %></td>
                        <td><%= campaign.EndDate %></td>
                        <td><%= campaign.DiscountPercentage %></td>
                        <td>
                            <a href="/campaigns/<%= campaign.CampaignId %>" class="btn btn-warning">Edit</a>
                            <form action="/campaigns/<%= campaign.CampaignId %>?_method=DELETE" method="POST" style="display:inline;">
                                <button type="submit" class="btn btn-danger">Delete</button>
                            </form>
                        </td>
                    </tr>
                <% }) %>
            </tbody>
        </table>
    </div>
</body>
</html>

views/feedbacks/index.ejs


<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/5.0.0-beta1/css/bootstrap.min.css">
    <title>Feedbacks</title>
</head>
<body>
    <div class="container">
        <h1>Feedbacks</h1>
        <a href="/feedbacks/create" class="btn btn-primary">Give Feedback</a>
        <table class="table">
            <thead>
                <tr>
                    <th>User ID</th>
                    <th>Comments</th>
                    <th>Rating</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% feedbacks.forEach(feedback => { %>
                    <tr>
                        <td><%= feedback.UserId %></td>
                        <td><%= feedback.Comments %></td>
                        <td><%= feedback.Rating %></td>
                        <td>
                            <a href="/feedbacks/<%= feedback.FeedbackId %>" class="btn btn-warning">Edit</a>
                            <form action="/feedbacks/<%= feedback.FeedbackId %>?_method=DELETE" method="POST" style="display:inline;">
                                <button type="submit" class="btn btn-danger">Delete</button>
                            </form>
                        </td>
                    </tr>
                <% }) %>
            </tbody>
        </table>
    </div>
</body>
</html>

Ensure all routes are included in your main application file (e.g., app.js or server.js).

Test each route and view to confirm that CRUD operations are functioning correctly.

Consider adding user authentication and authorization for enhanced security.

Implement error handling and validation for user inputs to improve the robustness of the application.

Creating a Dashboard Page

To create a dashboard page that displays consolidated data related to your real estate application, we will follow these steps:

Steps Overview

Define the Dashboard Route: Create a route that will handle requests to the dashboard.

Create the Dashboard Controller: Implement a controller that fetches the necessary consolidated data from your models using Sequelize.

Create the Dashboard View: Design a view that will display the consolidated data in a user-friendly format.

Step 1: Define the Dashboard Route

Create a new file for your dashboard routes, e.g., routes/dashboardRoutes.js:


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

Step 2: Create the Dashboard Controller

Create a new file for your dashboard controller, e.g., controllers/dashboardController.js:


const User = require('../models/User');
const Income = require('../models/Income');
const Expense = require('../models/Expense');
const Property = require('../models/Property');
const Appointment = require('../models/Appointment');
const Payment = require('../models/Payment');
const Goal = require('../models/Goal');
const Investment = require('../models/Investment');
class DashboardController {
    async getDashboardData(req, res) {
        try {
            const totalUsers = await User.count();
            const totalIncome = await Income.sum('Amount') || 0;
            const totalExpenses = await Expense.sum('Amount') || 0;
            const totalProperties = await Property.count();
            const totalAppointments = await Appointment.count();
            const totalPayments = await Payment.sum('Amount') || 0;
            const totalGoals = await Goal.count();
            const totalInvestments = await Investment.sum('Amount') || 0;
            res.render('dashboard', {
                totalUsers,
                totalIncome,
                totalExpenses,
                totalProperties,
                totalAppointments,
                totalPayments,
                totalGoals,
                totalInvestments,
            });
        } catch (error) {
            console.error(error);
            res.status(500).send('Internal Server Error');
        }
    }
}
module.exports = new DashboardController();

Step 3: Create the Dashboard View

Create a new view file for the dashboard, e.g., views/dashboard.ejs:


<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/5.0.0-beta1/css/bootstrap.min.css">
    <title>Dashboard</title>
</head>
<body>
    <div class="container">
        <h1>Dashboard</h1>
        <div class="row">
            <div class="col-md-4">
                <div class="card">
                    <div class="card-body">
                        <h5 class="card-title">Total Users</h5>
                        <p class="card-text"><%= totalUsers %></p>
                    </div>
                </div>
            </div>
            <div class="col-md-4">
                <div class="card">
                    <div class="card-body">
                        <h5 class="card-title">Total Income</h5>
                        <p class="card-text">$<%= totalIncome.toFixed(2) %></p>
                    </div>
                </div>
            </div>
            <div class="col-md-4">
                <div class="card">
                    <div class="card-body">
                        <h5 class="card-title">Total Expenses</h5>
                        <p class="card-text">$<%= totalExpenses.toFixed(2) %></p>
                    </div>
                </div>
            </div>
            <div class="col-md-4">
                <div class="card">
                    <div class="card-body">
                        <h5 class="card-title">Total Properties</h5>
                        <p class="card-text"><%= totalProperties %></p>
                    </div>
                </div>
            </div>
            <div class="col-md-4">
                <div class="card">
                    <div class="card-body">
                        <h5 class="card-title">Total Appointments</h5>
                        <p class="card-text"><%= totalAppointments %></p>
                    </div>
                </div>
            </div>
            <div class="col-md-4">
                <div class="card">
                    <div class="card-body">
                        <h5 class="card-title">Total Payments</h5>
                        <p class="card-text">$<%= totalPayments.toFixed(2) %></p>
                    </div>
                </div>
            </div>
            <div class="col-md -4">
                <div class="card">
                    <div class="card-body">
                        <h5 class="card-title">Total Goals</h5>
                        <p class="card-text"><%= totalGoals %></p>
                    </div>
                </div>
            </div>
            <div class="col-md-4">
                <div class="card">
                    <div class="card-body">
                        <h5 class="card-title">Total Investments</h5>
                        <p class="card-text">$<%= totalInvestments.toFixed(2) %></p>
                    </div>
                </div>
            </div>
        </div>
    </div>
</body>
</html>

Step 4: Integrate the Dashboard Route

Make sure to include the dashboard route in your main application file (e.g., app.js or server.js):


const dashboardRoutes = require('./routes/dashboardRoutes');
app.use('/dashboard', dashboardRoutes);

Final Steps

Test the dashboard by navigating to /dashboard in your application.

Ensure that all data is displayed correctly and that the calculations are accurate.

Consider adding charts or graphs for a more visual representation of the data using libraries like Chart.js or D3.js.

Real Estate Booking Project In Node Js

Project Introduction

Project Objectives

Project Modules

Steps Overview

Step 1: Set Up the Project

Step 2: Configure Sequelize

Step 3: Define Models

Example Models for Other Tables

Step 4: Create Repositories

Step 5: Set Up Controllers

Step 6: Define Routes

Step 7: Create Views

Step 8: Implement Bootstrap 5

Step 9: Create a Dashboard

Final Steps

Step 3: Define Models for Remaining Tables

Step 4: Create Repositories for Remaining Tables

Step 5: Set Up Controllers for Remaining Tables

Step 6: Define Routes for Remaining Tables

Step 7: Create Views for Remaining Tables

Creating a Dashboard Page

Steps Overview

Step 1: Define the Dashboard Route

Step 2: Create the Dashboard Controller

Step 3: Create the Dashboard View

Step 4: Integrate the Dashboard Route

Final Steps

You may also like

Supply Chain Tracking System Project In Node Js

Training Management System Project In Node Js

Traffic Management System Project In Node Js

Smart Attendance System Project In Node Js

Virtual Classroom Platform Project In Node Js

Stock Market Prediction System Project In Node Js

Related Post

Real Estate Booking Project In Node Js

Project Introduction

Project Objectives

Project Modules

Steps Overview

Step 1: Set Up the Project

Step 2: Configure Sequelize

Step 3: Define Models

Example Models for Other Tables

Step 4: Create Repositories

Step 5: Set Up Controllers

Step 6: Define Routes

Step 7: Create Views

Step 8: Implement Bootstrap 5

Step 9: Create a Dashboard

Final Steps

Step 3: Define Models for Remaining Tables

Step 4: Create Repositories for Remaining Tables

Step 5: Set Up Controllers for Remaining Tables

Step 6: Define Routes for Remaining Tables

Step 7: Create Views for Remaining Tables

Creating a Dashboard Page

Steps Overview

Step 1: Define the Dashboard Route

Step 2: Create the Dashboard Controller

Step 3: Create the Dashboard View

Step 4: Integrate the Dashboard Route

Final Steps

You may also like

Supply Chain Tracking System Project In Node Js

Training Management System Project In Node Js

Traffic Management System Project In Node Js

Smart Attendance System Project In Node Js

Virtual Classroom Platform Project In Node Js

Stock Market Prediction System Project In Node Js

Categories

Related Post