Project Introduction

The Search Engine is a web application designed to crawl, index, and retrieve web pages based on user queries. Built using Node.js, this platform allows users to search for information across a vast database of crawled pages. The system supports user authentication and provides a personalized experience for each user. The underlying MySQL database schema is structured to manage users, crawled pages, an inverted index, query logs, feedback, and analytics, providing a robust foundation for effective search functionality.

Project Objectives

• To develop a user-friendly interface for users to perform searches and view results.
• To implement a secure user authentication system for managing user accounts.
• To facilitate the crawling of web pages and storing relevant data for indexing.
• To create an inverted index for efficient retrieval of pages based on keywords.
• To log user queries for analysis and improvement of search results.
• To allow users to provide feedback on search results, including ratings and comments.
• To track analytics related to search queries, including clicks and impressions.
• 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 securely.

2. Crawling Module:

   This module manages the crawling of web pages, storing URLs, titles, and content for indexing.

3. Indexing Module:

   This module creates and maintains the inverted index, mapping keywords to the pages where they appear.

4. Search Module:

   This module processes user queries, retrieves relevant pages from the inverted index, and displays results.

5. Query Logging Module:

   This module logs user queries for analysis, allowing for improvements in search algorithms and user experience.

6. Feedback Module:

   This module allows users to provide feedback on search results, including ratings and comments on pages.

7. Analytics Module:

   This module tracks search analytics, including clicks and impressions for each query, to assess performance and user engagement.

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 seo-app
cd seo-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;

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/URL.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class URL extends Model {}
URL.init({
    URLId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    URL: {
        type: DataTypes.STRING(255),
        allowNull: false,
        unique: true,
    },
    Status: {
        type: DataTypes.STRING(20),
        defaultValue: 'Pending',
    },
    LastCrawled: {
        type: DataTypes.DATE,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'URL',
    tableName: 'URLs',
    timestamps: false,
});
module.exports = URL;

models/IndexedPage.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class IndexedPage extends Model {}
IndexedPage.init({
    PageId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    URLId: {
        type: DataTypes.INTEGER,
    },
    Title: {
        type: DataTypes.STRING(255),
    },
    Content: {
        type: DataTypes.TEXT,
    },
    MetaDescription: {
        type: DataTypes.STRING(255),
    },
    CreatedAt: {
        type: DataTypes.DATE,
        default Value: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'IndexedPage',
    tableName: 'IndexedPages',
    timestamps: false,
});
module.exports = IndexedPage;

models/Query.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class Query extends Model {}
Query.init({
    QueryId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
    },
    SearchTerm: {
        type: DataTypes.STRING(255),
        allowNull: false,
    },
    SearchDate: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'Query',
    tableName: 'Queries',
    timestamps: false,
});
module.exports = Query;

models/SearchResult.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class SearchResult extends Model {}
SearchResult.init({
    ResultId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    QueryId: {
        type: DataTypes.INTEGER,
    },
    PageId: {
        type: DataTypes.INTEGER,
    },
    Rank: {
        type: DataTypes.INTEGER,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'SearchResult',
    tableName: 'SearchResults',
    timestamps: false,
});
module.exports = SearchResult;

models/CacheItem.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class CacheItem extends Model {}
CacheItem.init({
    CacheItemId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    Key: {
        type: DataTypes.STRING(255),
        allowNull: false,
        unique: true,
    },
    Value: {
        type: DataTypes.TEXT,
    },
    Expiration: {
        type: DataTypes.DATE,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'CacheItem',
    tableName: 'CacheItems',
    timestamps: false,
});
module.exports = CacheItem;

models/AnalyticsData.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class AnalyticsData extends Model {}
AnalyticsData.init({
    AnalyticsId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    QueryId: {
        type: DataTypes.INTEGER,
    },
    Clicks: {
        type: DataTypes.INTEGER,
        defaultValue: 0,
    },
    Impressions: {
        type: DataTypes.INTEGER,
        defaultValue: 0,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'AnalyticsData',
    tableName: 'AnalyticsData',
    timestamps: false,
});
module.exports = AnalyticsData;

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,
    },
    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;

models/SecuritySetting.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class SecuritySetting extends Model {}
SecuritySetting.init({
    SettingId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    SettingName: {
        type: DataTypes.STRING(100),
        allowNull: false,
        unique: true,
    },
    SettingValue: {
        type: DataTypes.STRING(255),
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'SecuritySetting',
    tableName: 'SecuritySettings',
    timestamps: false,
});
module.exports = SecuritySetting;

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) {
        const user = await this.getUser ById(userId);
        if (user) {
            return await user.update(userData);
        }
        return null;
    }
    async deleteUser (userId) {
        const user = await this.getUser ById(userId);
        if (user) {
            return await user.destroy();
        }
        return null;
    }
}
module.exports = new UserRepository();

Step 5: Set Up Controllers

Create a folder named controllers and create a controller for users.

controllers/userController.js

const userRepository = require('../repositories/userRepository');
class UserController {
    async createUser (req, res) {
        try {
            const user = await userRepository.createUser (req.body);
            res.status(201).json(user);
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
    async getAllUsers(req, res) {
        try {
            const users = await userRepository.getAllUsers();
            res.status(200).json(users);
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
    async getUser ById(req, res) {
        try {
            const user = await userRepository.getUser ById(req.params.id);
            if (user) {
                res.status(200).json(user);
            } else {
                res.status(404).json({ message: 'User  not found' });
            }
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
    async updateUser (req, res) {
        try {
            const user = await userRepository.updateUser (req.params.id, req.body);
            if (user) {
                res.status(200).json(user);
            } else {
                res.status(404).json({ message: 'User  not found' });
            }
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
    async deleteUser (req, res) {
        try {
            const result = await userRepository.deleteUser (req.params.id);
            if (result) {
                res.status(204).send();
            } else {
                res.status(404).json({ message: 'User  not found' });
            }
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
}
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.post('/', userController.createUser );
router.get('/', userController.getAllUsers);
router.get('/:id', userController.getUser ById);
router.put('/:id', userController.updateUser );
router.delete('/:id', userController.deleteUser );
module.exports = router;

Step 7: Create Views

Create a folder named views and create EJS templates for user management.

views/users.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>User Management</title>
</head>
<body>
    <div class="container">
        <h1>User Management</h1>
        <table class="table">
            <thead>
                <tr>
                    <th>User ID</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/<%= user.UserId %>" class="btn btn-info">View</a>
                            <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>
        <a href="/users/new" class="btn btn-primary">Add User</a>
    </div>
</body>
</html>

views/userForm.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><%= user ? 'Edit User' : 'Add User' %></title>
</head>
<body>
    <div class="container">
        <h1><%= user ? 'Edit User' : 'Add User' %></h1>
        <form action="<%= user ? '/users/' + user.UserId : '/users' %>" method="POST">
            <% if (user) { %>
                <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 ? 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 ? user.Email : '' %>" required>
            </div>
            <div class="mb-3">
                <label for="PasswordHash" class="form-label">Password</label>
                <input type="password" class="form-control" id="PasswordHash" name="PasswordHash" <%= user ? '' : 'required' %>>
            </div>
            <button type="submit" class="btn btn-primary"><%= user ? 'Update User' : 'Create User' %></button>
        </form>
    </div>
</body>
</html>

Step 8: Implement Bootstrap 5

The views already include Bootstrap 5 for styling. Ensure that all forms and tables are styled appropriately using Bootstrap classes.

Step 9: Create a Dashboard

You can create a dashboard similar to the one previously described, integrating data from the various models to provide an overview of the application.

Final Steps

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

Test all CRUD operations to ensure they work as expected.

Consider adding error handling and validation for user inputs.

Expand the application by creating similar repositories, controllers, and views for other models like Roles, URLs, and Feedbacks.

Complete Implementation for Remaining Models

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

Step 3: Define Models for Remaining Tables

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;

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,
    },
    UpdatedAt: {
        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
        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,
    },
    ReportType: {
        type: DataTypes.STRING(50), // e.g., Maintenance, Complaint
        allowNull: false,
    },
    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,
    },
    Content: {
        type: DataTypes.TEXT,
        allowNull: false,
    },
    CreatedAt: {
        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.STRING(255),
        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,
    },
    Title: {
        type: DataTypes.STRING(100),
        allowNull: false,
    },
    Description: {
        type: DataTypes.TEXT,
    },
    StartDate: {
        type: DataTypes.DATE,
        allowNull: false,
    },
    EndDate: {
        type: DataTypes.DATE,
        allowNull: false,
    },
    Status: {
        type: DataTypes.STRING(20),
        defaultValue: 'Active',
 },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'Campaign',
    tableName: 'Campaigns',
    timestamps: false,
});
module.exports = Campaign;

Step 4: Create Repositories for Remaining Tables

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) {
        const property = await this.getPropertyById(propertyId);
        if (property) {
            return await property.update(propertyData);
        }
        return null;
    }
    async deleteProperty(propertyId) {
        const property = await this.getPropertyById(propertyId);
        if (property) {
            return await property.destroy();
        }
        return null;
    }
}
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) {
        const media = await this.getMediaById(mediaId);
        if (media) {
            return await media.update(mediaData);
        }
        return null;
    }
    async deleteMedia(mediaId) {
        const media = await this.getMediaById(mediaId);
        if (media) {
            return await media.destroy();
        }
        return null;
    }
}
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) {
        const appointment = await this.getAppointmentById(appointmentId);
        if (appointment) {
            return await appointment.update(appointmentData);
        }
        return null;
    }
    async deleteAppointment(appointmentId) {
        const appointment = await this.getAppointmentById(appointmentId);
        if (appointment) {
            return await appointment.destroy();
        }
        return null;
    }
}
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) {
        const payment = await this.getPaymentById(paymentId);
        if (payment) {
            return await payment.update(paymentData);
        }
        return null;
    }
    async deletePayment(paymentId) {
        const payment = await this.getPaymentById(paymentId);
        if (payment) {
            return await payment.destroy();
        }
        return null;
    }
}
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) {
        const document = await this.getDocumentById(documentId);
        if (document) {
            return await document.update(documentData);
        }
        return null;
    }
    async deleteDocument(documentId) {
        const document = await this.getDocumentById(documentId);
        if (document) {
            return await document.destroy();
        }
        return null;
    }
}
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) {
        const report = await this.getReportById(reportId);
        if (report) {
            return await report.update(reportData);
        }
        return null;
    }
    async deleteReport(reportId) {
        const report = await this.getReportById(reportId);
        if (report) {
            return await report.destroy();
        }
        return null;
    }
}
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) {
        const message = await this.getMessageById(messageId);
        if (message) {
            return await message.update(messageData);
        }
        return null;
    }
    async deleteMessage(messageId) {
        const message = await this.getMessageById(messageId);
        if (message) {
            return await message.destroy();
        }
        return null;
    }
}
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) {
        const notification = await this.getNotificationById(notificationId);
        if (notification) {
            return await notification.update(notificationData);
        }
        return null;
    }
    async deleteNotification(notificationId) {
        const notification = await this.getNotificationById(notificationId);
        if (notification) {
            return await notification.destroy();
        }
        return null;
    }
}
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) {
        const campaign = await this.getCampaignById(campaignId);
        if (campaign) {
            return await campaign.update(campaignData);
        }
        return null;
    }
    async deleteCampaign(campaignId) {
        const campaign = await this.getCampaignById(campaignId);
        if (campaign) {
            return await campaign.destroy();
        }
        return null;
    }
}
module.exports = new CampaignRepository();

Step 5: Set Up Controllers for Remaining Tables

controllers/propertyController.js

const propertyRepository = require('../repositories/propertyRepository');
class PropertyController {
    async createProperty(req, res) {
        try {
            const property = await propertyRepository.createProperty(req.body);
            res.status(201).json(property);
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
    async getAllProperties(req, res) {
        try {
            const properties = await propertyRepository.getAllProperties();
            res.status(200).json(properties);
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
    async getPropertyById(req, res) {
        try {
            const property = await propertyRepository.getPropertyById(req.params.id);
            if (property) {
                res.status(200).json(property);
            } else {
                res.status(404).json({ message: 'Property not found' });
            }
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
    async updateProperty(req, res) {
        try {
            const property = await propertyRepository.updateProperty(req.params.id, req.body);
            if (property) {
                res.status(200).json(property);
            } else {
                res.status(404).json({ message: 'Property not found' });
            }
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
    async deleteProperty(req, res) {
        try {
            const result = await propertyRepository.deleteProperty(req.params.id);
            if ( result) {
                res.status(204).send();
            } else {
                res.status(404).json({ message: 'Property not found' });
            }
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
}
module.exports = new PropertyController();

controllers/mediaController.js

const mediaRepository = require('../repositories/mediaRepository');
class MediaController {
    async createMedia(req, res) {
        try {
            const media = await mediaRepository.createMedia(req.body);
            res.status(201).json(media);
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
    async getAllMedia(req, res) {
        try {
            const media = await mediaRepository.getAllMedia();
            res.status(200).json(media);
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
    async getMediaById(req, res) {
        try {
            const media = await mediaRepository.getMediaById(req.params.id);
            if (media) {
                res.status(200).json(media);
            } else {
                res.status(404).json({ message: 'Media not found' });
            }
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
    async updateMedia(req, res) {
        try {
            const media = await mediaRepository.updateMedia(req.params.id, req.body);
            if (media) {
                res.status(200).json(media);
            } else {
                res.status(404).json({ message: 'Media not found' });
            }
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
    async deleteMedia(req, res) {
        try {
            const result = await mediaRepository.deleteMedia(req.params.id);
            if (result) {
                res.status(204).send();
            } else {
                res.status(404).json({ message: 'Media not found' });
            }
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
}
module.exports = new MediaController();

controllers/appointmentController.js

const appointmentRepository = require('../repositories/appointmentRepository');
class AppointmentController {
    async createAppointment(req, res) {
        try {
            const appointment = await appointmentRepository.createAppointment(req.body);
            res.status(201).json(appointment);
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
    async getAllAppointments(req, res) {
        try {
            const appointments = await appointmentRepository.getAllAppointments();
            res.status(200).json(appointments);
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
    async getAppointmentById(req, res) {
        try {
            const appointment = await appointmentRepository.getAppointmentById(req.params.id);
            if (appointment) {
                res.status(200).json(appointment);
            } else {
                res.status(404).json({ message: 'Appointment not found' });
            }
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
    async updateAppointment(req, res) {
        try {
            const appointment = await appointmentRepository.updateAppointment(req.params.id, req.body);
            if (appointment) {
                res.status(200).json(appointment);
            } else {
                res.status(404).json({ message: 'Appointment not found' });
            }
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
    async deleteAppointment(req, res) {
        try {
            const result = await appointmentRepository.deleteAppointment(req.params.id);
            if (result) {
                res.status(204).send();
            } else {
                res.status(404).json({ message: 'Appointment not found' });
            }
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
}
module.exports = new AppointmentController();

controllers/paymentController.js

const paymentRepository = require('../repositories/paymentRepository');
class PaymentController {
    async createPayment(req, res) {
        try {
            const payment = await paymentRepository.createPayment(req.body);
            res.status(201).json(payment);
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
    async getAllPayments(req, res) {
        try {
            const payments = await paymentRepository.getAllPayments();
            res.status(200).json(payments);
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
    async getPaymentById(req, res) {
        try {
            const payment = await paymentRepository.getPaymentById(req.params.id);
            if (payment) {
                res.status(200).json(payment);
            } else {
                res.status(404).json({ message: 'Payment not found' });
            }
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
    async updatePayment(req, res) {
        try {
            const payment = await paymentRepository.updatePayment(req.params.id, req.body);
            if (payment) {
                res.status(200).json(payment);
            } else {
                res.status(404).json({ message: 'Payment not found' });
            }
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
    async deletePayment(req, res) {
        try {
            const result = await paymentRepository.deletePayment(req.params.id);
            if (result) {
                res.status(204).send();
            } else {
                res.status(404).json({ message: 'Payment not found' });
            }
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
}
module.exports = new PaymentController();

controllers/documentController.js

const documentRepository = require('../repositories/documentRepository');
class DocumentController {
    async createDocument(req, res) {
        try {
            const document = await documentRepository.createDocument(req.body);
            res.status(201).json(document);
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
    async getAllDocuments(req, res) {
        try {
            const documents = await documentRepository.getAllDocuments();
            res.status(200).json(documents);
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
    async getDocumentById(req, res) {
        try {
            const document = await documentRepository.getDocumentById(req.params.id);
            if (document) {
                res.status(200).json(document);
            } else {
                res.status(404).json({ message: 'Document not found' });
            }
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
    async updateDocument(req, res) {
        try {
            const document = await documentRepository.updateDocument(req.params.id, req.body);
            if (document) {
                res.status(200).json(document);
            } else {
                res.status(404).json({ message: 'Document not found' });
            }
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
    async deleteDocument(req, res) {
        try {
            const result = await documentRepository.deleteDocument(req.params.id);
            if (result) {
                res.status(204).send();
            } else {
                res.status(404).json({ message: 'Document not found' });
            }
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
}
module.exports = new DocumentController();

controllers/reportController.js

const reportRepository = require('../repositories/reportRepository');
class ReportController {
    async createReport(req, res) {
        try {
            const report = await reportRepository.createReport(req.body);
            res.status(201).json(report);
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
    async getAllReports(req, res) {
        try {
            const reports = await reportRepository.getAllReports();
            res.status(200).json(reports);
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
    async getReportById(req, res) {
        try {
            const report = await reportRepository.getReportById(req.params.id);
            if (report) {
                res.status(200).json(report);
            } else {
                res.status(404).json({ message: 'Report not found' });
            }
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
    async updateReport(req, res) {
        try {
            const report = await reportRepository.updateReport(req.params.id, req.body);
            if (report) {
                res.status(200).json(report);
            } else {
                res.status(404).json({ message: 'Report not found' });
            }
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
    async deleteReport(req, res) {
        try {
            const result = await reportRepository.deleteReport(req.params.id);
            if (result) {
                res.status(204).send();
            } else {
                res.status(404).json({ message: 'Report not found' });
            }
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
}
module.exports = new ReportController();

controllers/messageController.js

const messageRepository = require('../repositories/messageRepository');
class MessageController {
    async createMessage(req, res) {
        try {
            const message = await messageRepository.createMessage(req.body);
            res.status(201).json(message);
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
    async getAllMessages(req, res) {
        try {
            const messages = await messageRepository.getAllMessages();
            res.status(200).json(messages);
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
    async getMessageById(req, res) {
        try {
            const message = await messageRepository.getMessageById(req.params.id);
            if (message) {
                res.status(200).json(message);
            } else {
                res.status(404).json({ message: 'Message not found' });
            }
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
    async updateMessage(req, res) {
        try {
            const message = await messageRepository.updateMessage(req.params.id, req.body);
            if (message) {
                res.status(200).json(message);
            } else {
                res.status(404).json({ message: 'Message not found' });
            }
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
    async deleteMessage(req, res) {
        try {
            const result = await messageRepository.deleteMessage(req.params.id);
            if (result) {
                res.status(204).send();
            } else {
                res.status(404).json({ message: 'Message not found' });
            }
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
}
module.exports = new MessageController();

controllers/notificationController.js

const notificationRepository = require('../repositories/notificationRepository');
class NotificationController {
    async createNotification(req, res) {
        try {
            const notification = await notificationRepository.createNotification(req.body);
            res.status(201).json(notification);
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
    async getAllNotifications(req, res) {
        try {
            const notifications = await notificationRepository.getAllNotifications();
            res.status(200).json(notifications);
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
    async getNotificationById(req, res) {
        try {
            const notification = await notificationRepository.getNotificationById(req.params.id);
            if (notification) {
                res.status(200).json(notification);
            } else {
                res.status(404).json({ message: 'Notification not found' });
            }
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
    async updateNotification(req, res) {
        try {
            const notification = await notificationRepository.updateNotification(req.params.id, req.body);
            if (notification) {
                res.status(200).json(notification);
            } else {
                res.status(404).json({ message: 'Notification not found' });
            }
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
    async deleteNotification(req, res) {
        try {
            const result = await notificationRepository.deleteNotification(req.params.id);
            if (result) {
                res.status(204).send();
            } else {
                res.status(404).json({ message: 'Notification not found' });
            }
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
}
module.exports = new NotificationController();

controllers/campaignController.js

const campaignRepository = require('../repositories/campaignRepository');
class CampaignController {
    async createCampaign(req, res) {
        try {
            const campaign = await campaignRepository.createCampaign(req.body);
            res.status(201).json(campaign);
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
    async getAllCampaigns(req, res) {
        try {
            const campaigns = await campaignRepository.getAllCampaigns();
            res.status(200).json (campaigns);
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
    async getCampaignById(req, res) {
        try {
            const campaign = await campaignRepository.getCampaignById(req.params.id);
            if (campaign) {
                res.status(200).json(campaign);
            } else {
                res.status(404).json({ message: 'Campaign not found' });
            }
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
    async updateCampaign(req, res) {
        try {
            const campaign = await campaignRepository.updateCampaign(req.params.id, req.body);
            if (campaign) {
                res.status(200).json(campaign);
            } else {
                res.status(404).json({ message: 'Campaign not found' });
            }
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
    async deleteCampaign(req, res) {
        try {
            const result = await campaignRepository.deleteCampaign(req.params.id);
            if (result) {
                res.status(204).send();
            } else {
                res.status(404).json({ message: 'Campaign not found' });
            }
        } catch (error) {
            res.status(500).json({ error: error.message });
        }
    }
}
module.exports = new CampaignController();

Step 6: Define Routes for Remaining Tables

routes/propertyRoutes.js

const express = require('express');
const router = express.Router();
const propertyController = require('../controllers/propertyController');
router.post('/', propertyController.createProperty);
router.get('/', propertyController.getAllProperties);
router.get('/:id', propertyController.getPropertyById);
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.post('/', mediaController.createMedia);
router.get('/', mediaController.getAllMedia);
router.get('/:id', mediaController.getMediaById);
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.post('/', appointmentController.createAppointment);
router.get('/', appointmentController.getAllAppointments);
router.get('/:id', appointmentController.getAppointmentById);
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.post('/', paymentController.createPayment);
router.get('/', paymentController.getAllPayments);
router.get('/:id', paymentController.getPaymentById);
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.post('/', documentController.createDocument);
router.get('/', documentController.getAllDocuments);
router.get('/:id', documentController.getDocumentById);
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.post('/', reportController.createReport);
router.get('/', reportController.getAllReports);
router.get('/:id', reportController.getReportById);
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.post('/', messageController.createMessage);
router.get('/', messageController.getAllMessages);
router.get('/:id', messageController.getMessageById);
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.post('/', notificationController.createNotification);
router.get('/', notificationController.getAllNotifications);
router.get('/:id', notificationController.getNotificationById);
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.post('/', campaignController.createCampaign);
router.get('/', campaignController.getAllCampaigns);
router.get('/:id', campaignController.getCampaignById);
router.put('/:id', campaignController.updateCampaign);
router.delete('/:id', campaignController.deleteCampaign);
module.exports = router;

Step 7: Create Views for Remaining Tables

views/properties.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>Property Management</title>
</head>
<body>
    <div class="container">
        <h1>Property Management</h1>
        <table class="table">
            <thead>
                <tr>
                    <th>Property ID</th>
                    <th>Title</th>
                    <th>Price</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% properties.forEach(property => { %>
                    <tr>
                        <td><%= property.PropertyId %></td>
                        <td><%= property.Title %></td>
                        <td><%= property.Price %></td>
                        <td>
                            <a href="/properties/<%= property.PropertyId %>" class="btn btn-info">View</a>
                            <a href="/properties/edit/<%= property.PropertyId %>" class="btn btn-warning">Edit</a>
                            <form action="/properties/<%= property.PropertyId %>" 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>
        <a href="/properties/new" class="btn btn-primary">Add Property</a>
    </div>
</body>
</html>

views/media.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 Management</title>
</head>
<body>
    <div class="container">
        <h1>Media Management</h1>
        <table class="table">
            <thead>
                <tr>
                    <th>Media ID</th>
                    <th>Property ID</th>
                    <th>Media Type</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% media.forEach(mediaItem => { %>
                    <tr>
                        <td><%= mediaItem.MediaId %></td>
                        <td><%= mediaItem.PropertyId %></td>
                        <td><%= mediaItem.MediaType %></td>
                        <td>
                            <a href="/media/<%= mediaItem.MediaId %>" class="btn btn-info">View</a>
                            <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>
        <a href="/media/new" class="btn btn-primary">Add Media</a>
    </div>
</body>
</html>

views/appointments.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>Appointment Management</title>
</head>
<body>
    <div class="container">
        <h1>Appointment Management</h1>
        <table class="table">
            <thead>
                <tr>
                    <th>Appointment ID</th>
                    <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.AppointmentId %></td>
                        <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-info">View</a>
                            <a href="/appointments/edit/<%= appointment.AppointmentId %>" class="btn btn-warning">Edit</a>
                            <form action="/appointments/<%= appointment.AppointmentId %>" 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>
        <a href="/appointments/new" class="btn btn-primary">Add Appointment</a>
    </div>
</body>
</html>

views/payments.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>Payment Management</title>
</head>
<body>
    <div class="container">
        <h1>Payment Management</h1>
        <table class="table">
            <thead>
                <tr>
                    <th>Payment ID</th>
                    <th>User ID</th>
                    <th>Property ID</th>
                    <th>Amount</th>
                    <th>Status</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% payments.forEach(payment => { %>
                    <tr>
                        <td><%= payment.PaymentId %></td>
                        <td><%= payment.UserId %></td>
                        <td><%= payment.PropertyId %></td>
                        <td><%= payment.Amount %></td>
                        <td><%= payment.Status %></td>
                        <td>
                            <a href="/payments/<%= payment.PaymentId %>" class="btn btn-info">View</a>
                            <a href="/payments/edit/<%= payment.PaymentId %>" class="btn btn-warning">Edit</a>
                            <form action="/payments/<%= payment.PaymentId %>" 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>
        <a href="/payments/new" class="btn btn-primary">Add Payment</a>
    </div>
</body>
</html>

views/documents.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>Document Management</title>
</head>
<body>
    <div class="container">
        <h1>Document Management</h1>
        <table class="table">
            <thead>
                <tr>
                    <th>Document ID</th>
                    <th>Property ID</th>
                    <th>Document Type</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% documents.forEach(document => { %>
                    <tr>
                        <td><%= document.DocumentId %></td>
                        <td><%= document.PropertyId %></td>
                        <td><%= document.DocumentType %></td>
                        <td>
                            <a href="/documents/<%= document.DocumentId %>" class="btn btn-info">View</a>
                            <a href="/documents/edit/<%= document.DocumentId %>" class="btn btn-warning">Edit</a>
                            <form action="/documents/<%= document.DocumentId %>" 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>
        <a href="/documents/new" class="btn btn-primary">Add Document</a>
    </div>
</body>
</html>

views/reports.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>Report Management</title>
</head>
<body>
    <div class="container">
        <h1>Report Management</h1>
        <table class="table">
            <thead>
                <tr>
                    <th>Report ID</th>
                    <th>User ID</th>
                    <th>Property ID</th>
                    <th>Report Type</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% reports.forEach(report => { %>
                    <tr>
                        <td><%= report.ReportId %></td>
                        <td><%= report.UserId %></td>
                        <td><%= report.PropertyId %></td>
                        <td><%= report.ReportType %></td>
                        <td>
                            <a href="/reports/<%= report.ReportId %>" class="btn btn-info">View</a>
                            <a href="/reports/edit/<%= report.ReportId %>" class="btn btn-warning">Edit</a>
                            <form action="/reports/<%= report.ReportId %>" 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>
        <a href="/reports/new" class="btn btn-primary">Add Report</a>
    </div>
</body>
</html>

views/messages.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>Message Management</title>
</head>
<body>
    <div class="container">
        <h1>Message Management</h1>
        <table class="table">
            <thead>
                <tr>
                    <th>Message ID</th>
                    <th>Sender ID</th>
                    <th>Receiver ID</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% messages.forEach(message => { %>
                    <tr>
                        <td><%= message.MessageId %></td>
                        <td><%= message.SenderId %></td>
                        <td><%= message.ReceiverId %></td>
                        <td>
                            <a href="/messages/<%= message.MessageId %>" class="btn btn-info">View</a>
                            <a href="/messages/edit/<%= message.MessageId %>" class="btn btn-warning">Edit</a>
                            <form action="/messages/<%= message.MessageId %>" 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>
        <a href="/messages/new" class="btn btn-primary">Add Message</a>
    </div>
</body>
</html>

views/notifications.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>Notification Management</title>
</head>
<body>
    <div class="container">
        <h1>Notification Management</h1>
        <table class="table">
            <thead>
                <tr>
                    <th>Notification ID</th>
                    <th>User ID</th>
                    <th>Message</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% notifications.forEach(notification => { %>
                    <tr>
                        <td><%= notification.NotificationId %></td>
                        <td><%= notification.UserId %></td>
                        <td><%= notification.Message %></td>
                        <td>
                            <a href="/notifications/<%= notification.NotificationId %>" class="btn btn-info">View</a>
                            <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>
        <a href="/notifications/new" class="btn btn-primary">Add Notification</a>
    </div>
</body>
</html>

views/campaigns.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>Campaign Management</title>
</head>
<body>
    <div class="container">
        <h1>Campaign Management</h1>
        <table class="table">
            <thead>
                <tr>
                    <th>Campaign ID</th>
                    <th>Title</th>
                    <th>Status</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% campaigns.forEach(campaign => { %>
                    <tr>
                        <td><%= campaign.CampaignId %></td>
                        <td><%= campaign.Title %></td>
                        <td><%= campaign.Status %></td>
                        <td>
                            <a href="/campaigns/<%= campaign.CampaignId %>" class="btn btn-info">View</a>
                            <a href="/campaigns/edit/<%= campaign.CampaignId %>" class="btn btn-warning">Edit</a>
                            <form action="/campaigns/<%= campaign.CampaignId %>" 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>
        <a href="/campaigns/new" class="btn btn-primary">Add Campaign</a>
    </div>
</body>
</html>

Final Steps

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

Test all CRUD operations to ensure they work as expected.

Consider adding error handling and validation for user inputs.

Expand the application by creating similar repositories, controllers, and views for other models as needed.

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

In your main application file (e.g., app.js or server.js), make sure to include the dashboard routes:

const express = require('express');
const app = express();
const dashboardRoutes = require('./routes/dashboardRoutes');
// Other middleware and routes...
app.use('/dashboard', dashboardRoutes);
// Set view engine
app.set('view engine', 'ejs');
// Start the server
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
    console.log(`Server is running on port ${PORT}`);
});

Final Steps

Ensure that all models (User , Income, Expense, Property, Appointment, Payment, Goal, Investment) are correctly defined and imported in the controller.

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

You can further enhance the dashboard by adding charts or graphs using libraries like Chart.js or D3.js for better data visualization.

This completes the implementation of the dashboard page with a controller, routes, and a view to display consolidated data related to your project.