Project Introduction

The Chatbot System is a web application designed to facilitate user interactions through automated responses powered by artificial intelligence. Built using Node.js, this platform allows users to engage with a chatbot that can understand and respond to various queries. The system supports multiple user roles, including admin and user, ensuring a comprehensive management interface for administrators. The underlying MySQL database schema is structured to manage users, their interactions, intents, training phrases, entities, and conversation context, providing a robust foundation for an intelligent chatbot experience.

Project Objectives

• To develop a user-friendly interface for users to interact with the chatbot.
• To implement a secure user authentication system with role-based access control.
• To track user interactions with the chatbot for analysis and improvement.
• To define intents and training phrases to enhance the chatbot's understanding of user queries.
• To manage entities and their values to provide more contextual responses.
• To maintain conversation context to improve the continuity of interactions.
• To ensure the application is scalable and maintainable for future enhancements.

Project Modules

1. User Management Module:

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

2. User Session Management Module:

   This module manages user sessions, including session tokens and expiration times, to ensure secure interactions.

3. User Interaction Module:

   This module tracks user inputs and chatbot responses, storing interaction data for analysis and improvement.

4. Intent Management Module:

   This module allows administrators to define and manage intents, including their descriptions and associated training phrases.

5. Training Phrase Management Module:

   This module enables the addition and management of training phrases that help the chatbot understand user queries better.

6. Entity Management Module:

   This module manages entities and their values, allowing the chatbot to provide more contextual and relevant responses.

7. Conversation Context Module:

   This module maintains conversation context for users, allowing for more coherent and context-aware interactions.

Set Up the Project

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

Step 1: Set Up the Project

mkdir chatbot-management-app
cd chatbot-management-app
npm init -y
npm install express sequelize mysql2 body-parser ejs 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: Create 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,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'User ',
    timestamps: false,
});
module.exports = User;

models/Session.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class Session extends Model {}
Session.init({
    SessionId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Users',
            key: 'User Id',
        },
    },
    SessionStart: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    SessionEnd: {
        type: DataTypes.DATE,
    },
}, {
    sequelize,
    modelName: 'Session',
    timestamps: false,
});
module.exports = Session;

models/Intent.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class Intent extends Model {}
Intent.init({
    IntentId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    IntentName: {
        type: DataTypes.STRING(100),
        allowNull: false,
        unique: true,
    },
    Description: {
        type: DataTypes.TEXT,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'Intent',
    timestamps: false,
});
module.exports = Intent;

models/Entity.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class Entity extends Model {}
Entity.init({
    EntityId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    EntityName: {
        type: DataTypes.STRING(100),
        allowNull: false,
        unique: true,
    },
    EntityType: {
        type: DataTypes.STRING(100),
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'Entity',
    timestamps: false,
});
module.exports = Entity;

models/Response.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class Response extends Model {}
Response.init({
    ResponseId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    IntentId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Intents',
            key: 'IntentId',
        },
    },
    ResponseText: {
        type: DataTypes.TEXT,
        allowNull: false,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'Response',
    timestamps: false,
});
module.exports = Response;

models/FAQ.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class FAQ extends Model {}
FAQ.init({
    FAQId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    Question: {
        type: DataTypes.TEXT,
        allowNull: false,
    },
    Answer: {
        type: DataTypes.TEXT,
        allowNull: false,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'FAQ',
    timestamps: false,
});
module.exports = FAQ;

models/KnowledgeBase.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class KnowledgeBase extends Model {}
KnowledgeBase.init({
    KnowledgeBaseId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    Title: {
        type: DataTypes.STRING(100),
        allowNull: false,
    },
    Content: {
        type: DataTypes.TEXT,
        allowNull: false,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'KnowledgeBase',
    timestamps: false,
});
module.exports = KnowledgeBase;

models/InteractionAnalytics.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class InteractionAnalytics extends Model {}
InteractionAnalytics.init({
    InteractionId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Users',
            key: 'User Id',
        },
    },
    SessionId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Sessions',
            key: 'SessionId',
        },
    },
    IntentId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Intents',
            key: 'IntentId',
        },
    },
    Timestamp: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    ResponseTime: {
        type: DataTypes.INTEGER,
    },
}, {
    sequelize,
    modelName: 'InteractionAnalytics',
    timestamps: false,
});
module.exports = InteractionAnalytics;

models/PerformanceMetrics.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class PerformanceMetrics extends Model {}
PerformanceMetrics.init({
    MetricId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    IntentId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Intents',
            key: 'IntentId',
        },
    },
    TotalInteractions: {
        type: DataTypes.INTEGER,
        defaultValue: 0,
    },
    SuccessRate: {
        type: DataTypes.DECIMAL(5, 2),
        defaultValue: 0.00,
    },
    AverageResponseTime: {
        type: DataTypes.INTEGER,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'PerformanceMetrics',
    timestamps: false,
});
module.exports = PerformanceMetrics;

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,
        references: {
            model: 'Users ',
            key: 'User Id',
        },
    },
    SessionId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Sessions',
            key: 'SessionId',
        },
    },
    Rating: {
        type: DataTypes.INTEGER,
        allowNull: false,
        validate: {
            min: 1,
            max: 5,
        },
    },
    Comments: {
        type: DataTypes.TEXT,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'Feedback',
    timestamps: false,
});
module.exports = Feedback;

Step 4: Create Repositories

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

repositories/userRepository.js

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

Step 5: Create Controllers

Create a folder named controllers and implement controller functions to handle requests.

controllers/userController.js

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

Step 6: Set Up Routes

Create a folder named routes and define routes for the application.

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/edit', userController.getUser ById);
router.post('/:id', userController.updateUser );
router.post('/:id/delete', userController.deleteUser );
module.exports = router;

Step 7: Create Views

Create a folder named views/users and create EJS views with Bootstrap 5 for the user interface.

views/users/index.ejs

<% layout('layouts/layout') -%>
<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 %>/edit" class="btn btn-warning">Edit</a>
                    <form action="/users/<%= user.UserId %>/delete" method="POST" style="display:inline;">
                        <button type="submit" class="btn btn-danger">Delete</button>
                    </form>
                </td>
            </tr>
        <% }) %>
    </tbody>
</table>

views/users/create.ejs

<% layout('layouts/layout') -%>
<h1>Create User</h1>
<form action="/users" method="POST">
    <div class="mb-3">
        <label for="Username" class="form-label">Username</label>
        <input type="text" class="form-control" id="Username" name="Username" required>
    </div>
    <div class="mb-3">
        <label for="Email" class="form-label">Email</label>
        <input type="email" class="form-control" id="Email" name="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" required>
    </div>
    <button type="submit" class="btn btn-primary">Create User</button>
</form>

views/users/edit.ejs

<% layout('layouts/layout') -%>
<h1>Edit User</h1>
<form action="/users/<%= user.UserId %>" method="POST">
    <div class="mb-3">
        <label for="Username" class="form-label">Username</label>
        <input type="text" class="form-control" id="Username" name="Username" value="<%= user.Username %>" required>
    </div>
    <div class="mb-3">
        <label for="Email" class="form-label">Email</label>
        <input type="email" class="form-control" id="Email" name="Email" value="<%= user.Email %>" required>
    </div>
    <button type="submit" class="btn btn-primary">Update User</button>
</form>

Step 8: Run the Application

In your main application file (e.g., app.js), include the user routes and set up the server.

app.js

const express = require('express');
const bodyParser = require('body-parser');
const methodOverride = require('method-override');
const sequelize = require('./config');
const userRoutes = require('./routes/userRoutes');
const app = express();
app.set('view engine', 'ejs');
app.use(bodyParser.urlencoded({ extended: true }));
app.use(methodOverride('_method'));
app.use(express.static('public'));
app.use('/users', userRoutes);
const PORT = process.env.PORT || 3000;
app.listen(PORT, async () => {
    try {
        await sequelize.sync(); // Sync models with the database
        console.log(`Server is running on port ${PORT}`);
    } catch (error) {
        console.error('Unable to connect to the database:', error);
    }
});

Final Notes

Ensure Database Connection: Make sure your MySQL database is running and the connection details in config.js are correct.

Test CRUD Operations: Navigate to /users to test the CRUD operations for users.

Expand Functionality: You can replicate the above steps for other models (Sessions, Intents, etc.) to create a complete CRUD application for all entities in your schema.

Step 1: Create Remaining Models

models/Session.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class Session extends Model {}
Session.init({
    SessionId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Users',
            key: 'User Id',
        },
    },
    SessionStart: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    SessionEnd: {
        type: DataTypes.DATE,
    },
}, {
    sequelize,
    modelName: 'Session',
    timestamps: false,
});
module.exports = Session;

models/Intent.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class Intent extends Model {}
Intent.init({
    IntentId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    IntentName: {
        type: DataTypes.STRING(100),
        allowNull: false,
        unique: true,
    },
    Description: {
        type: DataTypes.TEXT,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'Intent',
    timestamps: false,
});
module.exports = Intent;

models/Entity.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class Entity extends Model {}
Entity.init({
    EntityId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    EntityName: {
        type: DataTypes.STRING(100),
        allowNull: false,
        unique: true,
    },
    EntityType: {
        type: DataTypes.STRING(100),
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'Entity',
    timestamps: false,
});
module.exports = Entity;

models/Response.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class Response extends Model {}
Response.init({
    ResponseId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    IntentId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Intents',
            key: 'IntentId',
        },
    },
    ResponseText: {
        type: DataTypes.TEXT,
        allowNull: false,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'Response',
    timestamps: false,
});
module.exports = Response;

models/FAQ.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class FAQ extends Model {}
FAQ.init({
    FAQId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    Question: {
        type: DataTypes.TEXT,
        allowNull: false,
    },
    Answer: {
        type: DataTypes.TEXT,
        allowNull: false,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'FAQ',
    timestamps: false,
});
module.exports = FAQ;

models/KnowledgeBase.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class KnowledgeBase extends Model {}
KnowledgeBase.init({
    KnowledgeBaseId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    Title: {
        type: DataTypes.STRING(100),
        allowNull: false,
    },
    Content: {
        type: DataTypes.TEXT,
        allowNull: false,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW },
}, {
    sequelize,
    modelName: 'KnowledgeBase',
    timestamps: false,
});
module.exports = KnowledgeBase;

models/InteractionAnalytics.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class InteractionAnalytics extends Model {}
InteractionAnalytics.init({
    InteractionId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Users',
            key: 'User Id',
        },
    },
    SessionId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Sessions',
            key: 'SessionId',
        },
    },
    IntentId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Intents',
            key: 'IntentId',
        },
    },
    Timestamp: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    ResponseTime: {
        type: DataTypes.INTEGER,
    },
}, {
    sequelize,
    modelName: 'InteractionAnalytics',
    timestamps: false,
});
module.exports = InteractionAnalytics;

models/PerformanceMetrics.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class PerformanceMetrics extends Model {}
PerformanceMetrics.init({
    MetricId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    IntentId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Intents',
            key: 'IntentId',
        },
    },
    TotalInteractions: {
        type: DataTypes.INTEGER,
        defaultValue: 0,
    },
    SuccessRate: {
        type: DataTypes.DECIMAL(5, 2),
        defaultValue: 0.00,
    },
    AverageResponseTime: {
        type: DataTypes.INTEGER,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'PerformanceMetrics',
    timestamps: false,
});
module.exports = PerformanceMetrics;

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,
        references: {
            model: 'Users',
            key: 'User Id',
        },
    },
    SessionId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Sessions',
            key: 'SessionId',
        },
    },
    Rating: {
        type: DataTypes.INTEGER,
        allowNull: false,
        validate: {
            min: 1,
            max: 5,
        },
    },
    Comments: {
        type: DataTypes.TEXT,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'Feedback',
    timestamps: false,
});
module.exports = Feedback;

Step 2: Create Remaining Repositories

repositories/sessionRepository.js

const Session = require('../models/Session');
exports.createSession = async (sessionData) => {
    return await Session.create(sessionData);
};
exports.getAllSessions = async () => {
    return await Session.findAll();
};
exports.getSessionById = async (sessionId) => {
    return await Session.findByPk(sessionId);
};
exports.updateSession = async (sessionId, sessionData) => {
    return await Session.update(sessionData, { where: { SessionId: sessionId } });
};
exports.deleteSession = async (sessionId) => {
    return await Session.destroy({ where: { SessionId: sessionId } });
};
repositories/intentRepository.js
const Intent = require('../models/Intent');
exports.createIntent = async (intentData) => {
    return await Intent.create(intentData);
};
exports.getAllIntents = async () => {
    return await Intent.findAll();
};
exports.getIntentById = async (intentId) => {
    return await Intent.findByPk(intentId);
};
exports.updateIntent = async (intentId, intentData) => {
    return await Intent.update(intentData, { where: { IntentId: intentId } });
};
exports.deleteIntent = async (intentId) => {
    return await Intent.destroy({ where: { IntentId: intentId } });
};

repositories/entityRepository.js

const Entity = require('../models/Entity');
exports.createEntity = async (entityData) => { return await Entity.create(entityData); };
exports.getAllEntities = async () => { return await Entity.findAll(); };
exports.getEntityById = async (entityId) => { return await Entity.findByPk(entityId); };
exports.updateEntity = async (entityId, entityData) => { return await Entity.update(entityData, { where: { EntityId: entityId } }); };
exports.deleteEntity = async (entityId) => { return await Entity.destroy({ where: { EntityId: entityId } }); };

repositories/responseRepository.js

 
const Response = require('../models/Response');
exports.createResponse = async (responseData) => {
    return await Response.create(responseData);
};
exports.getAllResponses = async () => {
    return await Response.findAll();
};
exports.getResponseById = async (responseId) => {
    return await Response.findByPk(responseId);
};
exports.updateResponse = async (responseId, responseData) => {
    return await Response.update(responseData, { where: { ResponseId: responseId } });
};
exports.deleteResponse = async (responseId) => {
    return await Response.destroy({ where: { ResponseId: responseId } });
};

repositories/faqRepository.js

 
const FAQ = require('../models/FAQ');
exports.createFAQ = async (faqData) => {
    return await FAQ.create(faqData);
};
exports.getAllFAQs = async () => {
    return await FAQ.findAll();
};
exports.getFAQById = async (faqId) => {
    return await FAQ.findByPk(faqId);
};
exports.updateFAQ = async (faqId, faqData) => {
    return await FAQ.update(faqData, { where: { FAQId: faqId } });
};
exports.deleteFAQ = async (faqId) => {
    return await FAQ.destroy({ where: { FAQId: faqId } });
};

repositories/knowledgeBaseRepository.js

 
const KnowledgeBase = require('../models/KnowledgeBase');
exports.createKnowledgeBase = async (kbData) => {
    return await KnowledgeBase.create(kbData);
};
exports.getAllKnowledgeBases = async () => {
    return await KnowledgeBase.findAll();
};
exports.getKnowledgeBaseById = async (kbId) => {
    return await KnowledgeBase.findByPk(kbId);
};
exports.updateKnowledgeBase = async (kbId, kbData) => {
    return await KnowledgeBase.update(kbData, { where: { KnowledgeBaseId: kbId } });
};
exports.deleteKnowledgeBase = async (kbId) => {
    return await KnowledgeBase.destroy({ where: { KnowledgeBaseId: kbId } });
};

repositories/interactionAnalyticsRepository.js

 
const InteractionAnalytics = require('../models/InteractionAnalytics');
exports.createInteraction = async (interactionData) => {
    return await InteractionAnalytics.create(interactionData);
};
exports.getAllInteractions = async () => {
    return await InteractionAnalytics.findAll();
};
exports.getInteractionById = async (interactionId) => {
    return await InteractionAnalytics.findByPk(interactionId);
};
exports.updateInteraction = async (interactionId, interactionData) => {
    return await InteractionAnalytics.update(interactionData, { where: { InteractionId: interactionId } });
};
exports.deleteInteraction = async (interactionId) => {
    return await InteractionAnalytics.destroy({ where: { InteractionId: interactionId } });
};

repositories/performanceMetricsRepository.js

 
const PerformanceMetrics = require('../models/PerformanceMetrics');
exports.createPerformanceMetric = async (metricData) => {
    return await PerformanceMetrics.create(metricData);
};
exports.getAllPerformanceMetrics = async () => {
    return await PerformanceMetrics.findAll();
};
exports.getPerformanceMetricById = async (metricId) => {
    return await PerformanceMetrics.findByPk(metricId);
};
exports.updatePerformanceMetric = async (metricId, metricData) => {
    return await PerformanceMetrics.update(metricData, { where: { MetricId: metricId } });
};
exports.deletePerformanceMetric = async (metricId) => {
    return await PerformanceMetrics.destroy({ where: { MetricId: metricId } });
};

repositories/feedbackRepository.js

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

Step 3: Create Remaining Controllers

controllers/sessionController.js

 
const sessionRepository = require('../repositories/sessionRepository');
exports.createSession = async (req, res) => {
    try {
        const session = await sessionRepository.createSession(req.body);
        res.redirect('/sessions');
    } catch (error) {
        console.error(error);
        res.status(500).send('Server Error');
    }
};
exports.getAllSessions = async (req, res) => {
    try {
        const sessions = await sessionRepository.getAllSessions();
        res.render('sessions/index', { sessions });
    } catch (error) {
        console.error(error);
        res.status(500).send('Server Error');
    }
};
exports.getSessionById = async (req, res) => {
    try {
        const session = await sessionRepository.getSessionById(req.params.id);
        res.render('sessions/edit', { session });
    } catch (error) {
        console.error(error);
        res.status(500).send('Server Error');
    }
};
exports.updateSession = async (req, res) => {
    try {
        await sessionRepository.updateSession(req.params.id, req.body);
        res.redirect('/sessions');
    } catch (error) {
        console.error(error);
        res.status(500).send('Server Error');
    }
};
exports.deleteSession = async (req, res) => {
    try {
        await sessionRepository.deleteSession(req.params.id);
        res.redirect('/sessions');
    } catch (error) {
        console.error(error);
        res.status(500).send('Server Error');
    }
};

controllers/intentController.js

 
const intentRepository = require('../repositories/intentRepository');
exports.createIntent = async (req, res) => {
    try {
        const intent = await intentRepository.createIntent(req.body);
        res.redirect('/intents');
    } catch (error) {
        console.error(error);
        res.status(500).send('Server Error');
    }
};
exports.getAllIntents = async (req, res) => {
    try {
        const intents = await intentRepository.getAllIntents();
        res.render('intents/index', { intents });
    } catch (error) {
        console.error(error);
        res.status(500).send('Server Error');
    }
};
exports.getIntentById = async (req, res) => {
    try {
        const intent = await intentRepository.getIntentById(req.params.id);
        res.render('intents/edit', { intent });
    } catch (error) {
        console.error(error);
        res.status(500).send('Server Error');
    }
};
exports.updateIntent = async (req, res) => {
    try {
        await intentRepository.updateIntent(req.params.id, req.body);
        res.redirect('/intents');
    } catch (error) {
        console.error(error);
        res.status(500).send('Server Error');
    }
};
exports.deleteIntent = async (req, res) => {
    try {
        await intentRepository.deleteIntent(req.params.id);
        res.redirect('/intents');
    } catch (error) {
        console.error(error);
        res.status(500).send('Server Error');
    }
};

controllers/entityController.js

 
const entityRepository = require('../repositories/entityRepository');
exports.createEntity = async (req, res) => {
    try {
        const entity = await entityRepository.createEntity(req.body);
        res.redirect('/entities');
    } catch (error) {
        console.error(error);
        res.status(500).send('Server Error');
    }
};
exports.getAllEntities = async (req, res) => {
    try {
        const entities = await entityRepository.getAllEntities();
        res.render('entities/index', { entities });
    } catch (error) {
        console.error(error);
        res.status(500).send('Server Error');
    }
};
exports.getEntityById = async (req, res) => {
    try {
        const entity = await entityRepository.getEntityById(req.params.id);
        res.render('entities/edit', { entity });
    } catch (error) {
        console.error(error);
        res.status(500).send('Server Error');
    }
};
exports.updateEntity = async (req, res) => {
    try {
        await entityRepository.updateEntity(req.params.id, req.body);
        res.redirect('/entities');
    } catch (error) {
        console.error(error);
        res.status(500).send('Server Error');
    }
};
exports.deleteEntity = async (req, res) => {
    try {
        await entityRepository.deleteEntity(req.params.id);
        res.redirect('/entities');
    } catch (error) {
        console.error(error);
        res.status(500).send('Server Error');
    }
};

controllers/responseController.js

 
const responseRepository = require('../repositories/responseRepository');
exports.createResponse = async (req, res) => {
    try {
        const response = await responseRepository.createResponse(req.body);
        res.redirect('/responses');
    } catch (error) {
        console.error(error);
        res.status(500).send('Server Error');
    }
};
exports.getAllResponses = async (req, res) => {
    try {
        const responses = await responseRepository.getAllResponses();
        res.render('responses/index', { responses });
    } catch (error) {
        console.error(error);
        res.status(500).send('Server Error');
    }
};
exports.getResponseById = async (req, res) => {
    try {
        const response = await responseRepository.getResponseById(req.params.id);
        res.render('responses/edit', { response });
    } catch (error) {
        console.error(error);
        res.status(500).send('Server Error');
    }
};
exports.updateResponse = async (req, res) => {
    try {
        await responseRepository.updateResponse(req.params.id, req.body);
        res.redirect('/responses');
    } catch (error) {
        console.error(error);
        res.status(500).send('Server Error');
    }
};
exports.deleteResponse = async (req, res) => {
    try {
        await responseRepository.deleteResponse(req.params.id);
        res.redirect('/responses');
    } catch (error) {
        console.error(error);
        res.status(500).send('Server Error');
    }
};

controllers/faqController.js

 
const faqRepository = require('../repositories/faqRepository');
exports.createFAQ = async (req, res) => {
    try {
        const faq = await faqRepository.createFAQ(req.body);
        res.redirect('/faqs');
    } catch (error) {
        console.error(error);
        res.status(500).send('Server Error');
    }
};
exports.getAllFAQs = async (req, res) => {
    try {
        const faqs = await faqRepository.getAllFAQs();
        res.render('faqs/index', { faqs });
    } catch (error) {
        console.error(error);
        res.status(500).send('Server Error');
    }
};
exports.getFAQById = async (req, res) => {
    try {
        const faq = await faqRepository.getFAQById(req.params.id);
        res.render('faqs/edit', { faq });
    } catch (error) {
        console.error(error);
        res.status(500).send('Server Error');
    }
};
exports.updateFAQ = async (req, res) => {
    try {
        await faqRepository.updateFAQ(req.params.id, req.body);
        res.redirect('/faqs');
    } catch (error) {
        console.error(error);
        res.status(500).send('Server Error');
    }
};
exports.deleteFAQ = async (req, res) => {
    try {
        await faqRepository.deleteFAQ(req.params.id);
        res.redirect('/faqs');
    } catch (error) {
        console.error(error);
        res.status(500).send('Server Error');
    }
};

controllers/knowledgeBaseController.js

const knowledgeBaseRepository = require('../repositories/knowledgeBaseRepository');
exports.createKnowledgeBase = async (req, res) => {
    try {
        const kb = await knowledgeBaseRepository.createKnowledgeBase(req.body);
        res.redirect('/knowledgebase');
    } catch (error) {
        console.error(error);
        res.status(500).send('Server Error');
    }
};
exports.getAllKnowledgeBases = async (req, res) => {
    try {
        const knowledgeBases = await knowledgeBaseRepository.getAllKnowledgeBases();
        res.render('knowledgebase/index', { knowledgeBases });
    } catch (error) {
        console.error(error);
        res.status(500).send('Server Error');
    }
};
exports.getKnowledgeBaseById = async (req, res) => {
    try {
        const kb = await knowledgeBaseRepository.getKnowledgeBaseById(req.params.id);
        res.render('knowledgebase/edit', { kb });
    } catch (error) {
        console.error(error);
        res.status(500).send('Server Error');
    }
};
exports.updateKnowledgeBase = async (req, res) => {
    try {
        await knowledgeBaseRepository.updateKnowledgeBase(req.params.id, req.body);
        res.redirect('/knowledgebase');
    } catch (error) {
        console.error(error);
        res.status(500).send('Server Error');
    }
};
exports.deleteKnowledgeBase = async (req, res) => {
    try {
        await knowledgeBaseRepository.deleteKnowledgeBase(req.params.id);
        res.redirect('/knowledgebase');
    } catch (error) {
        console.error(error);
        res.status(500).send('Server Error');
    }
};

controllers/interactionAnalyticsController.js

 
const interactionAnalyticsRepository = require('../repositories/interactionAnalyticsRepository');
exports.createInteraction = async (req, res) => {
    try {
        const interaction = await interactionAnalyticsRepository.createInteraction(req.body);
        res.redirect('/interactions');
    } catch (error) {
        console.error(error);
        res.status(500).send('Server Error');
    }
};
exports.getAllInteractions = async (req, res) => {
    try {
        const interactions = await interactionAnalyticsRepository.getAllInteractions();
        res.render('interactions/index', { interactions });
    } catch (error) {
        console.error(error);
        res.status(500).send('Server Error');
    }
};
exports.getInteractionById = async (req, res) => {
    try {
        const interaction = await interactionAnalyticsRepository.getInteractionById(req.params.id);
        res.render('interactions/edit', { interaction });
    } catch (error) {
        console.error(error);
        res.status(500).send('Server Error');
    }
};
exports.updateInteraction = async (req, res) => {
    try {
        await interactionAnalyticsRepository.updateInteraction(req.params.id, req.body);
        res.redirect('/interactions');
    } catch (error) {
        console.error(error);
        res.status(500).send('Server Error');
    }
};
exports.deleteInteraction = async (req, res) => {
    try {
        await interactionAnalyticsRepository.deleteInteraction(req.params.id);
        res.redirect('/interactions');
    } catch (error) {
        console.error(error);
        res.status(500).send('Server Error');
    }
};

controllers/performanceMetricsController.js

 
const performanceMetricsRepository = require('../repositories/performanceMetricsRepository');
exports.createPerformanceMetric = async (req, res) => {
    try {
        const metric = await performanceMetricsRepository.createPerformanceMetric(req.body);
        res.redirect('/performance-metrics');
    } catch (error) {
        console.error(error);
        res.status(500).send('Server Error');
    }
};
exports.getAllPerformanceMetrics = async (req, res) => {
    try {
        const metrics = await performanceMetricsRepository.getAllPerformanceMetrics();
        res.render('performance-metrics/index', { metrics });
    } catch (error) {
        console.error(error);
        res.status(500).send('Server Error');
    }
};
exports.getPerformanceMetricById = async (req, res) => {
    try {
        const metric = await performanceMetricsRepository.getPerformanceMetricById(req.params.id);
        res.render('performance-metrics/edit', { metric });
    } catch (error) {
        console.error(error);
        res.status(500).send('Server Error');
    }
};
exports.updatePerformanceMetric = async (req, res) => {
    try {
        await performanceMetricsRepository.updatePerformanceMetric(req.params.id, req.body);
        res.redirect('/performance-metrics');
    } catch (error) {
        console.error(error);
        res.status(500).send('Server Error');
    }
};
exports.deletePerformanceMetric = async (req, res) => {
    try {
        await performanceMetricsRepository.deletePerformanceMetric(req.params.id);
        res.redirect('/performance-metrics');
    } catch (error) {
        console.error(error);
        res.status(500).send('Server Error');
    }
};

controllers/feedbackController.js

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

Step 4: Create Remaining Routes

routes/sessionRoutes.js

 
const express = require('express');
const router = express.Router();
const sessionController = require('../controllers/sessionController');
router.get('/', sessionController.getAllSessions);
router.get('/create', (req, res) => res.render('sessions/create'));
router.post('/', sessionController.createSession);
router.get('/:id/edit', sessionController.getSessionById);
router.post('/:id', sessionController.updateSession);
router.post('/:id/delete', sessionController.deleteSession);
module.exports = router;

routes/intentRoutes.js

 
const express = require('express');
const router = express.Router();
const intentController = require('../controllers/intentController');
router.get('/', intentController.getAllIntents);
router.get('/create', (req, res) => res.render('intents/create'));
router.post('/', intentController.createIntent);
router.get('/:id/edit', intentController.getIntentById);
router.post('/:id', intentController.updateIntent);
router.post('/:id/delete', intentController.deleteIntent);
module.exports = router;

routes/entityRoutes.js

 
const express = require('express');
const router = express.Router();
const entityController = require('../controllers/entityController');
router.get('/', entityController.getAllEntities);
router.get('/create', (req, res) => res.render('entities/create'));
router.post('/', entityController.createEntity);
router.get('/:id/edit', entityController.getEntityById);
router.post('/:id', entityController.updateEntity);
router.post('/:id/delete', entityController.deleteEntity);
module.exports = router;

routes/responseRoutes.js

 
const express = require('express');
const router = express.Router();
const responseController = require('../controllers/responseController');
router.get('/', responseController.getAllResponses);
router.get('/create', (req, res) => res.render('responses/create'));
router.post('/', responseController.createResponse);
router.get('/:id/edit', responseController.getResponseById);
router.post('/:id', responseController.updateResponse);
router.post('/:id/delete', responseController.deleteResponse);
module.exports = router;

routes/faqRoutes.js

 
const express = require('express');
const router = express.Router();
const faqController = require('../controllers/faqController');
router.get('/', faqController.getAllFAQs);
router.get('/create', (req, res) => res.render('faqs/create'));
router.post('/', faqController.createFAQ);
router.get('/:id/edit', faqController.getFAQById);
router.post('/:id', faqController.updateFAQ);
router.post('/:id/delete', faqController.deleteFAQ);
module.exports = router;

routes/knowledgeBaseRoutes.js

 
const express = require('express');
const router = express.Router();
const knowledgeBaseController = require('../controllers/knowledgeBaseController');
router.get('/', knowledgeBaseController.getAllKnowledgeBases);
router.get('/create', (req, res) => res.render('knowledgebase/create'));
router.post('/', knowledgeBaseController.createKnowledgeBase);
router.get('/:id/edit', knowledgeBaseController.getKnowledgeBaseById);
router.post('/:id', knowledgeBaseController.updateKnowledgeBase);
router.post('/:id/delete', knowledgeBaseController.deleteKnowledgeBase);
module.exports = router;

routes/interactionAnalyticsRoutes.js

 
const express = require('express');
const router = express.Router();
const interactionAnalyticsController = require('../controllers/interactionAnalyticsController');
router.get('/', interactionAnalyticsController.getAllInteractions);
router.get('/create', (req, res) => res.render('interactions/create'));
router.post('/', interactionAnalyticsController.createInteraction);
router.get('/:id/edit', interactionAnalyticsController.getInteractionById);
router.post('/:id', interactionAnalyticsController.updateInteraction);
router.post('/:id/delete', interactionAnalyticsController.deleteInteraction);
module.exports = router;

routes/performanceMetricsRoutes.js

 
const express = require('express');
const router = express.Router();
const performanceMetricsController = require('../controllers/performanceMetricsController');
router.get('/', performanceMetricsController.getAllPerformanceMetrics);
router.get('/create', (req, res) => res.render('performance-metrics/create'));
router.post('/', performanceMetricsController.createPerformanceMetric);
router.get('/:id/edit', performanceMetricsController.getPerformanceMetricById);
router.post('/:id', performanceMetricsController.updatePerformanceMetric);
router.post('/:id/delete', performanceMetricsController.deletePerformanceMetric);
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/edit', feedbackController.getFeedbackById);
router.post ('/:id', feedbackController.updateFeedback);
router.post('/:id/delete', feedbackController.deleteFeedback);
module.exports = router;

Step 5: Create Remaining Views

views/sessions/index.ejs

<% layout('layouts/layout') -%>
<h1>Sessions</h1>
<a href="/sessions/create" class="btn btn-primary">Create Session</a>
<table class="table">
    <thead>
        <tr>
            <th>Session Start</th>
            <th>User ID</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        <% sessions.forEach(session => { %>
            <tr>
                <td><%= session.SessionStart %></td>
                <td><%= session.UserId %></td>
                <td>
                    <a href="/sessions/<%= session.SessionId %>/edit" class="btn btn-warning">Edit</a>
                    <form action="/sessions/<%= session.SessionId %>/delete" method="POST" style="display:inline;">
                        <button type="submit" class="btn btn-danger">Delete</button>
                    </form>
                </td>
            </tr>
        <% }) %>
    </tbody>
</table>

views/sessions/create.ejs

<% layout('layouts/layout') -%>
<h1>Create Session</h1>
<form action="/sessions" method="POST">
    <div class="mb-3">
        <label for="User Id" class="form-label">User  ID</label>
        <input type="number" class="form-control" id="User Id" name="User Id" required>
    </div>
    <button type="submit" class="btn btn-primary">Create Session</button>
</form>

views/sessions/edit.ejs

<% layout('layouts/layout') -%>
<h1>Edit Session</h1>
<form action="/sessions/<%= session.SessionId %>" method="POST">
    <div class="mb-3">
        <label for="User Id" class="form-label">User  ID</label>
        <input type="number" class="form-control" id="User Id" name="User Id" value="<%= session.UserId %>" required>
    </div>
    <button type="submit" class="btn btn-primary">Update Session</button>
</form>

views/intents/index.ejs

<% layout('layouts/layout') -%>
<h1>Intents</h1>
<a href="/intents/create" class="btn btn-primary">Create Intent</a>
<table class="table">
    <thead>
        <tr>
            <th>Intent Name</th>
            <th>Description</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        <% intents.forEach(intent => { %>
            <tr>
                <td><%= intent.IntentName %></td>
                <td><%= intent.Description %></td>
                <td>
                    <a href="/intents/<%= intent.IntentId %>/edit" class="btn btn-warning">Edit</a>
                    <form action="/intents/<%= intent.IntentId %>/delete" method="POST" style="display:inline;">
                        <button type="submit" class="btn btn-danger">Delete</button>
                    </form>
                </td>
            </tr>
        <% }) %>
    </tbody>
</table>

views/intents/create.ejs

<% layout('layouts/layout') -%>
<h1>Create Intent</h1>
<form action="/intents" method="POST">
    <div class="mb-3">
        <label for="IntentName" class="form-label">Intent Name</label>
        <input type="text" class="form-control" id="IntentName" name="IntentName" required>
    </div>
    <div class="mb-3">
        <label for="Description" class="form-label">Description</label>
        <textarea class="form-control" id="Description" name="Description"></textarea>
    </div>
    <button type="submit" class="btn btn-primary">Create Intent</button>
</form>

views/intents/edit.ejs

<% layout('layouts/layout') -%>
<h1>Edit Intent</h1>
<form action="/intents/<%= intent.IntentId %>" method="POST">
    <div class="mb-3">
        <label for="IntentName" class="form-label">Intent Name</label>
        <input type="text" class="form-control" id="IntentName" name="IntentName" value="<%= intent.IntentName %>" required>
    </div>
    <div class="mb-3">
 <label for="Description" class="form-label">Description</label>
        <textarea class="form-control" id="Description" name="Description"><%= intent.Description %></textarea>
    </div>
    <button type="submit" class="btn btn-primary">Update Intent</button>
</form>

views/entities/index.ejs

<% layout('layouts/layout') -%>
<h1>Entities</h1>
<a href="/entities/create" class="btn btn-primary">Create Entity</a>
<table class="table">
    <thead>
        <tr>
            <th>Entity Name</th>
            <th>Entity Type</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        <% entities.forEach(entity => { %>
            <tr>
                <td><%= entity.EntityName %></td>
                <td><%= entity.EntityType %></td>
                <td>
                    <a href="/entities/<%= entity.EntityId %>/edit" class="btn btn-warning">Edit</a>
                    <form action="/entities/<%= entity.EntityId %>/delete" method="POST" style="display:inline;">
                        <button type="submit" class="btn btn-danger">Delete</button>
                    </form>
                </td>
            </tr>
        <% }) %>
    </tbody>
</table>

views/entities/create.ejs

<% layout('layouts/layout') -%>
<h1>Create Entity</h1>
<form action="/entities" method="POST">
    <div class="mb-3">
        <label for="EntityName" class="form-label">Entity Name</label>
        <input type="text" class="form-control" id="EntityName" name="EntityName" required>
    </div>
    <div class="mb-3">
        <label for="EntityType" class="form-label">Entity Type</label>
        <input type="text" class="form-control" id="EntityType" name="EntityType">
    </div>
    <button type="submit" class="btn btn-primary">Create Entity</button>
</form>

views/entities/edit.ejs

<% layout('layouts/layout') -%>
<h1>Edit Entity</h1>
<form action="/entities/<%= entity.EntityId %>" method="POST">
    <div class="mb-3">
        <label for="EntityName" class="form-label">Entity Name</label>
        <input type="text" class="form-control" id="EntityName" name="EntityName" value="<%= entity.EntityName %>" required>
    </div>
    <div class="mb-3">
        <label for="EntityType" class="form-label">Entity Type</label>
        <input type="text" class="form-control" id="EntityType" name="EntityType" value="<%= entity.EntityType %>">
    </div>
    <button type="submit" class="btn btn-primary">Update Entity</button>
</form>

views/responses/index.ejs

<% layout('layouts/layout') -%>
<h1>Responses</h1>
<a href="/responses/create" class="btn btn-primary">Create Response</a>
<table class="table">
    <thead>
        <tr>
            <th>Response Text</th>
            <th>Intent ID</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        <% responses.forEach(response => { %>
            <tr>
                <td><%= response.ResponseText %></td>
                <td><%= response.IntentId %></td>
                <td>
                    <a href="/responses/<%= response.ResponseId %>/edit" class="btn btn-warning">Edit</a>
                    <form action="/responses/<%= response.ResponseId %>/delete" method="POST" style="display:inline;">
                        <button type="submit" class="btn btn-danger">Delete</button>
                    </form>
                </td>
            </tr>
        <% }) %>
    </tbody>
</table>

views/responses/create.ejs

<% layout('layouts/layout') -%>
<h1>Create Response</h1>
<form action="/responses" method="POST">
    <div class="mb-3">
        <label for="IntentId" class="form-label">Intent ID</label>
        <input type="number" class="form-control" id="IntentId" name="IntentId" required>
    </div>
    <div class="mb-3">
        <label for="ResponseText" class="form-label">Response Text</label>
        <textarea class="form-control" id="ResponseText" name="ResponseText" required></textarea>
    </div>
    <button type="submit" class="btn btn-primary">Create Response</button>
</form>

views/responses/edit.ejs

<% layout('layouts/layout') -%>
<h1>Edit Response</h1>
<form action="/responses/<%= response.ResponseId %>" method="POST">
    <div class="mb-3">
        <label for="IntentId" class="form-label">Intent ID</label>
        <input type="number" class="form-control" id="IntentId" name="IntentId" value="<%= response.IntentId %>" required>
    </div>
    <div class="mb-3">
        <label for="ResponseText" class="form-label">Response Text</label>
        <textarea class="form-control" id="ResponseText" name="ResponseText" required><%= response.ResponseText %></textarea>
    </div>
    <button type="submit" class="btn btn-primary">Update Response</button>
</form>

views/faqs/index.ejs

<% layout('layouts/layout') -%>
<h1>FAQs</h1>
<a href="/faqs/create" class="btn btn-primary">Create FAQ</a>
<table class="table">
    <thead>
        <tr>
            <th>Question</th>
            <th>Answer</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        <% faqs.forEach(faq => { %>
            <tr>
                <td><%= faq.Question %></td>
                <td><%= faq.Answer %></td>
                <td>
                    <a href="/faqs/<%= faq.FAQId %>/edit" class="btn btn-warning">Edit</a>
                    <form action="/faqs/<%= faq.FAQId %>/delete" method="POST" style="display:inline;">
                        <button type="submit" class="btn btn-danger">Delete</button>
                    </form>
                </td>
            </tr>
        <% }) %>
    </tbody>
</table>

views/faqs/create.ejs

<% layout('layouts/layout') -%>
<h1>Create FAQ</h1>
<form action="/faqs" method="POST">
    <div class="mb-3">
        <label for="Question" class="form-label">Question</label>
        <textarea class="form-control" id="Question" name="Question" required></textarea>
    </div>
    <div class="mb-3">
        <label for="Answer" class="form-label">Answer</label>
        <textarea class="form-control" id="Answer" name="Answer" required></textarea>
    </div>
    <button type="submit" class="btn btn-primary">Create FAQ</button>
</form>

views/faqs/edit.ejs

<% layout('layouts/layout') -%>
<h1>Edit FAQ</h1>
<form action="/faqs/<%= faq.FAQId %>" method="POST">
    <div class="mb-3">
        <label for="Question" class="form-label">Question</label>
        <textarea class="form-control" id="Question" name="Question" required><%= faq.Question %></textarea>
    </div>
    <div class="mb-3">
        <label for="Answer" class="form-label">Answer</label>
        <textarea class="form-control" id="Answer" name="Answer" required><%= faq.Answer %></textarea>
    </div>
    <button type="submit" class="btn btn-primary">Update FAQ</button>
</form>

views/knowledgebase/index.ejs

<% layout('layouts/layout') -%>
<h1>Knowledge Base</h1>
<a href="/knowledgebase/create" class="btn btn-primary">Create Knowledge Base Entry</a>
<table class="table">
    <thead>
        <tr>
            <th>Title</th>
            <th>Content</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        <% knowledgeBases.forEach(kb => { %>
            <tr>
                <td><%= kb.Title %></td>
                <td><%= kb.Content %></td>
                <td>
                    <a href="/knowledgebase/<%= kb.KnowledgeBaseId %>/edit" class="btn btn-warning">Edit</a>
                    <form action="/knowledgebase/<%= kb.KnowledgeBaseId %>/delete" method="POST" style="display:inline;">
                        <button type="submit" class="btn btn-danger">Delete</button>
                    </form>
                </td>
            </tr>
        <% }) </tbody>
</table>

<% layout('layouts/layout') -%>
<h1>Create Knowledge Base Entry</h1>
<form action="/knowledgebase" method="POST">
    <div class="mb-3">
        <label for="Title" class="form-label">Title</label>
        <input type="text" class="form-control" id="Title" name="Title" required>
    </div>
    <div class="mb-3">
        <label for="Content" class="form-label">Content</label>
        <textarea class="form-control" id="Content" name="Content" required></textarea>
    </div>
    <button type="submit" class="btn btn-primary">Create Knowledge Base Entry</button>
</form>

views/knowledgebase/edit.ejs

<% layout('layouts/layout') -%>
<h1>Edit Knowledge Base Entry</h1>
<form action="/knowledgebase/<%= kb.KnowledgeBaseId %>" method="POST">
    <div class="mb-3">
        <label for="Title" class="form-label">Title</label>
        <input type="text" class="form-control" id="Title" name="Title" value="<%= kb.Title %>" required>
    </div>
    <div class="mb-3">
        <label for="Content" class="form-label">Content</label>
        <textarea class="form-control" id="Content" name="Content" required><%= kb.Content %></textarea>
    </div>
    <button type="submit" class="btn btn-primary">Update Knowledge Base Entry</button>
</form>

views/interactions/index.ejs

<% layout('layouts/layout') -%>
<h1>Interaction Analytics</h1>
<a href="/interactions/create" class="btn btn-primary">Create Interaction</a>
<table class="table">
    <thead>
        <tr>
            <th>User ID</th>
            <th>Session ID</th>
            <th>Intent ID</th>
            <th>Timestamp</th>
            <th>Response Time</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        <% interactions.forEach(interaction => { %>
            <tr>
                <td><%= interaction.UserId %></td>
                <td><%= interaction.SessionId %></td>
                <td><%= interaction.IntentId %></td>
                <td><%= interaction.Timestamp %></td>
                <td><%= interaction.ResponseTime %></td>
                <td>
                    <a href="/interactions/<%= interaction.InteractionId %>/edit" class="btn btn-warning">Edit</a>
                    <form action="/interactions/<%= interaction.InteractionId %>/delete" method="POST" style="display:inline;">
                        <button type="submit" class="btn btn-danger">Delete</button>
                    </form>
                </td>
            </tr>
        <% }) %>
    </tbody>
</table>

views/interactions/create.ejs

<% layout('layouts/layout') -%>
<h1>Create Interaction</h1>
<form action="/interactions" method="POST">
    <div class="mb-3">
        <label for="User Id" class="form-label">User  ID</label>
        <input type="number" class="form-control" id="User Id" name="User Id" required>
    </div>
    <div class="mb-3">
        <label for="SessionId" class="form-label">Session ID</label>
        <input type="number" class="form-control" id="SessionId" name="SessionId" required>
    </div>
    <div class="mb-3">
        <label for="IntentId" class="form-label">Intent ID</label>
        <input type="number" class="form-control" id="IntentId" name="IntentId" required>
    </div>
    <div class="mb-3">
        <label for="ResponseTime" class="form-label">Response Time (ms)</label>
        <input type="number" class="form-control" id="ResponseTime" name="ResponseTime" required>
    </div>
    <button type="submit" class="btn btn-primary">Create Interaction</button>
</form>

views/interactions/edit.ejs

<% layout('layouts/layout') -%>
<h1>Edit Interaction</h1>
<form action="/interactions/<%= interaction.InteractionId %>" method="POST">
    <div class="mb-3">
        <label for="User Id" class="form-label">User  ID</label>
        <input type=" number" class="form-control" id="User  Id" name="User  Id" value="<%= interaction.UserId %>" required>
    </div>
    <div class="mb-3">
        <label for="SessionId" class="form-label">Session ID</label>
        <input type="number" class="form-control" id="SessionId" name="SessionId" value="<%= interaction.SessionId %>" required>
    </div>
    <div class="mb-3">
        <label for="IntentId" class="form-label">Intent ID</label>
        <input type="number" class="form-control" id="IntentId" name="IntentId" value="<%= interaction.IntentId %>" required>
    </div>
    <div class="mb-3">
        <label for="ResponseTime" class="form-label">Response Time (ms)</label>
        <input type="number" class="form-control" id="ResponseTime" name="ResponseTime" value="<%= interaction.ResponseTime %>" required>
    </div>
    <button type="submit" class="btn btn-primary">Update Interaction</button>
</form>

views/performance-metrics/index.ejs

<% layout('layouts/layout') -%>
<h1>Performance Metrics</h1>
<a href="/performance-metrics/create" class="btn btn-primary">Create Performance Metric</a>
<table class="table">
    <thead>
        <tr>
            <th>Intent ID</th>
            <th>Total Interactions</th>
            <th>Success Rate</th>
            <th>Average Response Time</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        <% metrics.forEach(metric => { %>
            <tr>
                <td><%= metric.IntentId %></td>
                <td><%= metric.TotalInteractions %></td>
                <td><%= metric.SuccessRate %></td>
                <td><%= metric.AverageResponseTime %></td>
                <td>
                    <a href="/performance-metrics/<%= metric.MetricId %>/edit" class="btn btn-warning">Edit</a>
                    <form action="/performance-metrics/<%= metric.MetricId %>/delete" method="POST" style="display:inline;">
                        <button type="submit" class="btn btn-danger">Delete</button>
                    </form>
                </td>
            </tr>
        <% }) %>
    </tbody>
</table>

views/performance-metrics/create.ejs

<% layout('layouts/layout') -%>
<h1>Create Performance Metric</h1>
<form action="/performance-metrics" method="POST">
    <div class="mb-3">
        <label for="IntentId" class="form-label">Intent ID</label>
        <input type="number" class="form-control" id="IntentId" name="IntentId" required>
    </div>
    <div class="mb-3">
        <label for="TotalInteractions" class="form-label">Total Interactions</label>
        <input type="number" class="form-control" id="TotalInteractions" name="TotalInteractions" required>
    </div>
    <div class="mb-3">
        <label for="SuccessRate" class="form-label">Success Rate</label>
        <input type="number" step="0.01" class="form-control" id="SuccessRate" name="SuccessRate" required>
    </div>
    <div class="mb-3">
        <label for="AverageResponseTime" class="form-label">Average Response Time (ms)</label>
        <input type="number" class="form-control" id="AverageResponseTime" name="AverageResponseTime" required>
    </div>
    <button type="submit" class="btn btn-primary">Create Performance Metric</button>
</form>

views/performance-metrics/edit.ejs

<% layout('layouts/layout') -%>
<h1>Edit Performance Metric</h1>
<form action="/performance-metrics/<%= metric.MetricId %>" method="POST">
    <div class="mb-3">
        <label for="IntentId" class="form-label">Intent ID</label>
        <input type="number" class="form-control" id="IntentId" name="IntentId" value="<%= metric.IntentId %>" required>
    </div>
    <div class="mb-3">
        <label for="TotalInteractions" class="form-label">Total Interactions</label>
        <input type="number" class="form-control" id="TotalInteractions" name="TotalInteractions" value="<%= metric.TotalInteractions %>" required>
    </div>
    <div class="mb-3">
        <label for=" SuccessRate" class="form-label">Success Rate</label>
        <input type="number" step="0.01" class="form-control" id="SuccessRate" name="SuccessRate" value="<%= metric.SuccessRate %>" required>
    </div>
    <div class="mb-3">
        <label for="AverageResponseTime" class="form-label">Average Response Time (ms)</label>
        <input type="number" class="form-control" id="AverageResponseTime" name="AverageResponseTime" value="<%= metric.AverageResponseTime %>" required>
    </div>
    <button type="submit" class="btn btn-primary">Update Performance Metric</button>
</form>

views/feedbacks/index.ejs

<% layout('layouts/layout') -%>
<h1>Feedbacks</h1>
<a href="/feedbacks/create" class="btn btn-primary">Create Feedback</a>
<table class="table">
    <thead>
        <tr>
            <th>User ID</th>
            <th>Session ID</th>
            <th>Rating</th>
            <th>Comments</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        <% feedbacks.forEach(feedback => { %>
            <tr>
                <td><%= feedback.UserId %></td>
                <td><%= feedback.SessionId %></td>
                <td><%= feedback.Rating %></td>
                <td><%= feedback.Comments %></td>
                <td>
                    <a href="/feedbacks/<%= feedback.FeedbackId %>/edit" class="btn btn-warning">Edit</a>
                    <form action="/feedbacks/<%= feedback.FeedbackId %>/delete" method="POST" style="display:inline;">
                        <button type="submit" class="btn btn-danger">Delete</button>
                    </form>
                </td>
            </tr>
        <% }) %>
    </tbody>
</table>

views/feedbacks/create.ejs

<% layout('layouts/layout') -%>
<h1>Create Feedback</h1>
<form action="/feedbacks" method="POST">
    <div class="mb-3">
        <label for="User Id" class="form-label">User  ID</label>
        <input type="number" class="form-control" id="User Id" name="User Id" required>
    </div>
    <div class="mb-3">
        <label for="SessionId" class="form-label">Session ID</label>
        <input type="number" class="form-control" id="SessionId" name="SessionId" required>
    </div>
    <div class="mb-3">
        <label for="Rating" class="form-label">Rating</label>
        <input type="number" class="form-control" id="Rating" name="Rating" min="1" max="5" required>
    </div>
    <div class="mb-3">
        <label for="Comments" class="form-label">Comments</label>
        <textarea class="form-control" id="Comments" name="Comments"></textarea>
    </div>
    <button type="submit" class="btn btn-primary">Create Feedback</button>
</form>

views/feedbacks/edit.ejs

<% layout('layouts/layout') -%>
<h1>Edit Feedback</h1>
<form action="/feedbacks/<%= feedback.FeedbackId %>" method="POST">
    <div class="mb-3">
        <label for="User Id" class="form-label">User  ID</label>
        <input type="number" class="form-control" id="User Id" name="User Id" value="<%= feedback.UserId %>" required>
    </div>
    <div class="mb-3">
        <label for="SessionId" class="form-label">Session ID</label>
        <input type="number" class="form-control" id="SessionId" name="SessionId" value="<%= feedback.SessionId %>" required>
    </div>
    <div class="mb-3">
        <label for="Rating" class="form-label">Rating</label>
        <input type="number" class="form-control" id="Rating" name="Rating" value="<%= feedback.Rating %>" min="1" max="5" required>
    </div>
    <div class="mb-3">
        <label for="Comments" class="form-label">Comments</label>
        <textarea class="form-control" id="Comments" name="Comments"><%= feedback.Comments %></textarea>
    </div>
    <button type="submit" class="btn btn-primary">Update Feedback</button>
</form>

Step 6: Update Main Application File

In your main application file (e.g., app.js), include the routes for all entities and set up the server.

app.js

const express = require('express');
const bodyParser = require('body-parser');
const methodOverride = require('method-override');
const sequelize = require('./config');
const userRoutes = require('./routes/userRoutes');
const sessionRoutes = require('./routes/sessionRoutes');
const intentRoutes = require('./routes/intentRoutes');
const entityRoutes = require('./routes/entityRoutes');
const responseRoutes = require('./routes/responseRoutes');
const faqRoutes = require('./routes/faqRoutes');
const knowledgeBaseRoutes = require('./routes/knowledgeBaseRoutes');
const interactionAnalyticsRoutes = require('./routes/interactionAnalyticsRoutes');
const performanceMetricsRoutes = require('./routes/performanceMetricsRoutes');
const feedbackRoutes = require('./routes/feedbackRoutes');
const app = express();
app.set('view engine', 'ejs');
app.use(bodyParser.urlencoded({ extended: true }));
app.use(methodOverride('_method'));
app.use(express.static('public'));
app.use('/users', userRoutes);
app.use('/sessions', sessionRoutes);
app.use('/intents', intentRoutes);
app.use('/entities', entityRoutes);
app.use('/responses', responseRoutes);
app.use('/faqs', faqRoutes);
app.use('/knowledgebase', knowledgeBaseRoutes);
app.use('/interactions', interactionAnalyticsRoutes);
app.use('/performance-metrics', performanceMetricsRoutes);
app.use('/feedbacks', feedbackRoutes);
const PORT = process.env.PORT || 3000;
app.listen(PORT, async () => {
    try {
        await sequelize.sync(); // Sync models with the database
        console.log(`Server is running on port ${PORT}`);
    } catch (error) {
        console.error('Unable to connect to the database:', error);
    }
});

Final Notes

Ensure Database Connection: Verify that your MySQL database is running and the connection details in config.js are correct.

Test CRUD Operations: Navigate to the respective routes (e.g., /users, /sessions, etc.) to test the CRUD operations for all entities.

Expand Functionality: You can further enhance the application by adding features like user authentication, validation, and error handling.

This completes the implementation of a complete CRUD application for your chatbot management system using Node.js, Sequelize, Express, and EJS with Bootstrap 5 templates.

To create a dashboard page for your chatbot management application that displays consolidated data, we will follow these steps:

Create the Dashboard View: This will display the consolidated data.

Create the Dashboard Controller: This will handle the logic for fetching the data.

Set Up the Route: This will define the route for accessing the dashboard.

Fetch and Display Data: The dashboard will show total counts for Users, Sessions, Intents, Entities, Responses, FAQs, KnowledgeBase entries, InteractionAnalytics, PerformanceMetrics, and Feedback.

Step 1: Create the Dashboard View

Create a new EJS file for the dashboard in the views directory.

views/dashboard.ejs

    <% layout('layouts/layout') -%>
<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 Sessions</h5>
                <p class="card-text"><%= totalSessions %></p>
            </div>
        </div>
    </div>
    <div class="col-md-4">
        <div class="card">
            <div class="card-body">
                <h5 class="card-title">Total Intents</h5>
                <p class="card-text"><%= totalIntents %></p>
            </div>
        </div>
    </div>
    <div class="col-md-4">
        <div class="card">
            <div class="card-body">
                <h5 class="card-title">Total Entities</h5>
                <p class="card-text"><%= totalEntities %></p>
            </div>
        </div>
    </div>
    <div class="col-md-4">
        <div class="card">
            <div class="card-body">
                <h5 class="card-title">Total Responses</h5>
                <p class="card-text"><%= totalResponses %></p>
            </div>
        </div>
    </div>
    <div class="col-md-4">
        <div class="card">
            <div class="card-body">
                <h5 class="card-title">Total FAQs</h5>
                <p class="card-text"><%= totalFAQs %></p>
            </div>
        </div>
    </div>
    <div class="col-md-4">
        <div class="card">
            <div class="card-body">
                <h5 class="card-title">Total Knowledge Base Entries</h5>
                <p class="card-text"><%= totalKnowledgeBase %></p>
            </div>
        </div>
    </div>
    <div class="col-md-4">
        <div class="card">
            <div class="card-body">
                <h5 class="card-title">Total Interactions</h5>
                <p class="card-text"><%= totalInteractions %></p>
            </div>
        </div>
    </div>
    <div class="col-md-4">
        <div class="card">
            <div class="card-body">
                <h5 class="card-title">Total Performance Metrics</h5>
                <p class="card-text"><%= totalPerformanceMetrics %></p>
            </div>
        </div>
    </div>
    <div class="col-md-4">
        <div class="card">
            <div class="card-body">
                <h5 class="card-title">Total Feedbacks</h5>
                <p class="card-text"><%= totalFeedbacks %></p>
            </div>
        </div>
    </div>
</div>

Step 2: Create the Dashboard Controller

In your controllers directory, create a new file for the dashboard logic.

controllers/dashboardController.js

const User = require('../models/User');
const Session = require('../models/Session');
const Intent = require('../models/Intent');
const Entity = require('../models/Entity');
const Response = require('../models/Response');
const FAQ = require('../models/FAQ');
const KnowledgeBase = require('../models/KnowledgeBase');
const InteractionAnalytics = require('../models/InteractionAnalytics');
const PerformanceMetrics = require('../models/PerformanceMetrics');
const Feedback = require('../models/Feedback');
exports.getDashboard = async (req, res) => {
    try {
        const totalUsers = await User.count();
        const totalSessions = await Session.count();
        const totalIntents = await Intent.count();
        const totalEntities = await Entity.count();
        const totalResponses = await Response.count();
        const totalFAQs = await FAQ.count();
        const totalKnowledgeBase = await KnowledgeBase.count();
        const totalInteractions = await InteractionAnalytics.count();
        const total PerformanceMetrics = await PerformanceMetrics.count();
        const totalFeedbacks = await Feedback.count();
        res.render('dashboard', {
            totalUsers,
            totalSessions,
            totalIntents,
            totalEntities,
            totalResponses,
            totalFAQs,
            totalKnowledgeBase,
            totalInteractions,
            totalPerformanceMetrics,
            totalFeedbacks
        });
    } catch (error) {
        console.error(error);
        res.status(500).send('Server Error');
    }
};

Step 3: Set Up the Route

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

routes/dashboardRoutes.js

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

Step 4: Update Main Application File

In your main application file (e.g., app.js), include the dashboard routes.

app.js

const express = require('express');
const bodyParser = require('body-parser');
const methodOverride = require('method-override');
const sequelize = require('./config');
const userRoutes = require('./routes/userRoutes');
const sessionRoutes = require('./routes/sessionRoutes');
const intentRoutes = require('./routes/intentRoutes');
const entityRoutes = require('./routes/entityRoutes');
const responseRoutes = require('./routes/responseRoutes');
const faqRoutes = require('./routes/faqRoutes');
const knowledgeBaseRoutes = require('./routes/knowledgeBaseRoutes');
const interactionAnalyticsRoutes = require('./routes/interactionAnalyticsRoutes');
const performanceMetricsRoutes = require('./routes/performanceMetricsRoutes');
const feedbackRoutes = require('./routes/feedbackRoutes');
const dashboardRoutes = require('./routes/dashboardRoutes'); // Include dashboard routes
const app = express();
app.set('view engine', 'ejs');
app.use(bodyParser.urlencoded({ extended: true }));
app.use(methodOverride('_method'));
app.use(express.static('public'));
app.use('/users', userRoutes);
app.use('/sessions', sessionRoutes);
app.use('/intents', intentRoutes);
app.use('/entities', entityRoutes);
app.use('/responses', responseRoutes);
app.use('/faqs', faqRoutes);
app.use('/knowledgebase', knowledgeBaseRoutes);
app.use('/interactions', interactionAnalyticsRoutes);
app.use('/performance-metrics', performanceMetricsRoutes);
app.use('/feedbacks', feedbackRoutes);
app.use('/dashboard', dashboardRoutes); // Add dashboard route
const PORT = process.env.PORT || 3000;
app.listen(PORT, async () => {
    try {
        await sequelize.sync(); // Sync models with the database
        console.log(`Server is running on port ${PORT}`);
    } catch (error) {
        console.error('Unable to connect to the database:', error);
    }
});

Final Notes

Access the Dashboard: You can now access the dashboard by navigating to /dashboard in your application.

Styling: You can enhance the dashboard's appearance using Bootstrap or custom CSS.

Data Validation: Ensure that the data is correctly populated in your database to reflect accurate counts on the dashboard.

This completes the implementation of the dashboard page for your chatbot management application, providing a consolidated view of the project's data.