Project Introduction

The Personal Finance Manager is a web application designed to help users manage their finances effectively. Built using Node.js, this platform allows users to track their income, expenses, budgets, savings, investments, and debts in one place. The system supports user authentication and provides a personalized experience for each user. The underlying MySQL database schema is structured to manage users, accounts, transactions, budgets, financial goals, savings and investments, debts, and notifications, providing a robust foundation for effective financial management.

Project Objectives

• To develop a user-friendly interface for users to manage their financial accounts and transactions.
• To implement a secure user authentication system for personalized financial management.
• To allow users to create and manage budgets for different categories.
• To enable users to set and track financial goals, including target amounts and due dates.
• To provide functionality for tracking savings and investments across various types.
• To manage debts, including total amounts, remaining balances, and interest rates.
• To send alerts and notifications to users regarding important financial updates.
• 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. Account Management Module:

   This module allows users to create and manage their financial accounts, including bank accounts, credit cards, and investments.

3. Transaction Management Module:

   This module facilitates the recording and tracking of transactions, including income and expenses.

4. Budget Management Module:

   This module enables users to set budgets for different categories and track their spending against these budgets.

5. Financial Goals Management Module:

   This module allows users to set and track financial goals, including target amounts and due dates.

6. Savings and Investments Management Module:

   This module tracks savings and investments, allowing users to manage their financial growth.

7. Debt Management Module:

   This module helps users manage their debts, including tracking total amounts, remaining balances, and interest rates.

8. Notification Module:

   This module sends alerts and notifications to users regarding important financial updates and reminders.

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.

Step 1: Set Up the Project

mkdir finance-app
cd finance-app
npm init -y
npm install express sequelize mysql2 ejs body-parser

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(256),
        allowNull: false,
    },
    Email: {
        type: DataTypes.STRING(100),
        allowNull: false,
        unique: true,
    },
    FirstName: {
        type: DataTypes.STRING(50),
        allowNull: false,
    },
    LastName: {
        type: DataTypes.STRING(50),
        allowNull: false,
    },
    RoleId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'User ',
    tableName: 'Users',
    timestamps: false,
});
module.exports = User;

Repeat similar steps for other models: Role, Income, Expense, Budget, Report, Goal, Investment, Notification, Backup, Feedback.

Example Models for Other Tables

models/Role.js

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

models/Income.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class Income extends Model {}
Income.init({
    IncomeId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    Amount: {
        type: DataTypes.DECIMAL(18, 2),
        allowNull: false,
    },
    Source: {
        type: DataTypes.STRING(100),
        allowNull: false,
    },
    DateReceived: {
        type: DataTypes.DATE,
        allowNull: false,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'Income',
    tableName: 'Income',
    timestamps: false,
});
module.exports = Income;

Repeat similar steps for other models: Expense, Budget, Report, Goal, Investment, Notification, Backup, 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');
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) {
            await user.destroy();
            return true;
        }
        return false;
    }
}
module.exports = new UserRepository();

Repeat similar steps for other repositories: RoleRepository, IncomeRepository, ExpenseRepository, BudgetRepository, ReportRepository, GoalRepository, InvestmentRepository, NotificationRepository, BackupRepository, FeedbackRepository.

Step 5: Set Up Controllers

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

controllers/userController.js

const userRepository = require('../repositories/userRepository');
class UserController {
    async createUser (req, res) {
        try {
            const user = await userRepository.createUser (req.body);
            res.status(201).json(user);
        } catch (error) {
            res.status(500).json({ error: 'Failed to create user' });
        }
    }
    async getAllUsers(req, res) {
        try {
            const users = await userRepository.getAllUsers();
            res.status(200).json(users);
        } catch (error) {
            res.status(500).json({ error: 'Failed to fetch users' });
        }
    }
    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({ error: 'User  not found' });
            }
        } catch (error) {
            res.status(500).json({ error: 'Failed to fetch user' });
        }
    }
    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({ error: 'User  not found' });
            }
        } catch (error) {
            res.status(500).json({ error: 'Failed to update user' });
        }
    }
    async deleteUser (req, res) {
        try {
            const success = await userRepository.deleteUser (req.params.id);
            if (success) {
                res.status(204).send();
            } else {
                res.status(404).json({ error: 'User  not found' });
            }
        } catch (error) {
            res.status(500).json({ error: 'Failed to delete user' });
        }
    }
}
module.exports = new UserController();

Repeat similar steps for other controllers: RoleController, IncomeController, ExpenseController, BudgetController, ReportController, GoalController, InvestmentController, NotificationController, BackupController, FeedbackController.

Step 6: Define Routes

Create a folder named routes and set up routes for each resource.

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;

Repeat similar steps for other routes: roleRoutes, incomeRoutes, expenseRoutes, budgetRoutes, reportRoutes, goalRoutes, investmentRoutes, notificationRoutes, backupRoutes, feedbackRoutes.

Step 7: Create Views

Create a folder named views and create EJS files for displaying data.

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>Users</title>
</head>
<body>
    <div class="container">
        <h1>Users</h1>
        <table class="table">
            <thead>
                <tr>
                    <th>UserId</th>
                    <th>Username</th>
                    <th>Email</th>
                    <th>First Name</th>
                    <th>Last Name</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% users.forEach(user => { %>
                    <tr>
                        <td><%= user.UserId %></td>
                        <td><%= user.Username %></td>
                        <td><%= user.Email %></td>
                        <td><%= user.FirstName %></td>
                        <td><%= user.LastName %></td>
                        <td>
                            <a href="/users/<%= user.UserId %>/edit" 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>

Step 8: Implement Bootstrap 5

Ensure that all views utilize Bootstrap 5 for styling. You can create similar views for other entities like roles, income, expenses, etc., following the same structure as the users view.

Step 9: Update Main Application File

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

const express = require('express');
const bodyParser = require('body-parser');
const methodOverride = require('method-override');
const userRoutes = require('./routes/userRoutes');
const sequelize = require('./config');
const app = express();
app.set('view engine', 'ejs');
app.use(bodyParser.urlencoded({ extended: true }));
app.use(methodOverride('_method'));
app.use('/users', userRoutes);
sequelize.sync().then(() => {
    app.listen(3000, () => {
        console.log('Server is running on http://localhost:3000');
    });
}).catch(err => {
    console.error('Unable to connect to the database:', err);
});

Final Considerations

Ensure that all models, repositories, controllers, and routes are correctly set up for each entity.

Implement error handling and validation as needed.

Consider adding authentication and authorization for user management.

Test all CRUD operations to ensure they work as expected.

This setup provides a complete CRUD application for managing users and related entities using Node.js, Sequelize, EJS, and Bootstrap 5.

Complete Implementation for Remaining Models

Following are the complete implementation for the remaining models, repositories, controllers, routes, and views for the entities: Role, Income, Expense, Budget, Report, Goal, Investment, Notification, Backup, and Feedback.

Step 3: Define Models for Remaining Tables

models/Role.js

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

models/Income.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class Income extends Model {}
Income.init({
    IncomeId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    Amount: {
        type: DataTypes.DECIMAL(18, 2),
        allowNull: false,
    },
    Source: {
        type: DataTypes.STRING(100),
        allowNull: false,
    },
    DateReceived: {
        type: DataTypes.DATE,
        allowNull: false,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'Income',
    tableName: 'Income',
    timestamps: false,
});
module.exports = Income;

models/Expense.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class Expense extends Model {}
Expense.init({
    ExpenseId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    Amount: {
        type: DataTypes.DECIMAL(18, 2),
        allowNull: false,
    },
    Category: {
        type: DataTypes.STRING(100),
        allowNull: false,
    },
    DateIncurred: {
        type: DataTypes.DATE,
        allowNull: false,
    },
    Description: {
        type: DataTypes.TEXT,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'Expense',
    tableName: 'Expenses',
    timestamps: false,
});
module.exports = Expense;

models/Budget.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class Budget extends Model {}
Budget.init({
    BudgetId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    Category: {
        type: DataTypes.STRING(100),
        allowNull: false,
    },
    Amount: {
        type: DataTypes.DECIMAL(18, 2),
        allowNull: false,
    },
    StartDate: {
        type: DataTypes.DATE,
        allowNull: false,
    },
    EndDate: {
        type: DataTypes.DATE,
        allowNull: false,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'Budget',
    tableName: 'Budgets',
    timestamps: false,
});
module.exports = Budget;

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,
    },
    ReportDate: {
        type: DataTypes.DATE,
        allowNull: false,
    },
    ReportContent: {
        type: DataTypes.TEXT,
        allowNull: false,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'Report',
    tableName: 'Reports',
    timestamps: false,
});
module.exports = Report;

models/Goal.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class Goal extends Model {}
Goal.init({
    GoalId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    GoalName: {
        type: DataTypes.STRING(100),
        allowNull: false,
    },
    TargetAmount: {
        type: DataTypes.DECIMAL(18, 2),
        allowNull: false,
    },
    CurrentAmount: {
        type: DataTypes.DECIMAL(18, 2),
        defaultValue: 0,
    },
    TargetDate: {
        type: DataTypes.DATE,
        allowNull: false,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'Goal',
    tableName: 'Goals',
    timestamps: false,
});
module.exports = Goal;

models/Investment.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class Investment extends Model {}
Investment.init({
    InvestmentId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    InvestmentName: {
        type: DataTypes.STRING(100),
        allowNull: false,
    },
    Amount: {
        type: DataTypes.DECIMAL(18, 2),
        allowNull: false,
    },
    InvestmentDate: {
        type: DataTypes.DATE,
        allowNull: false,
    },
    CurrentValue: {
        type: DataTypes.DECIMAL(18, 2),
        allowNull: false,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'Investment',
    tableName: 'Investments',
    timestamps: false,
});
module.exports = Investment;

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

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class Backup extends Model {}
Backup.init({
    BackupId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    BackupDate: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    BackupFile: {
        type: DataTypes.STRING(255),
        allowNull: false,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'Backup',
    tableName: 'Backups',
    timestamps: false,
});
module.exports = Backup;

models/Feedback.js

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

Step 4: Create Repositories for Remaining Entities

repositories/roleRepository.js

const Role = require('../models/Role');
class RoleRepository {
    async createRole(roleData) {
        return await Role.create(roleData);
    }
    async getAllRoles() {
        return await Role.findAll();
    }
    async getRoleById(roleId) {
        return await Role.findByPk(roleId);
    }
    async updateRole(roleId, roleData) {
        const role = await this.getRoleById(roleId);
        if (role) {
            return await role.update(roleData);
        }
        return null;
    }
    async deleteRole(roleId) {
        const role = await this.getRoleById(roleId);
        if (role) {
            await role.destroy();
            return true;
        }
        return false;
    }
}
module.exports = new RoleRepository();

repositories/incomeRepository.js

const Income = require('../models/Income');
class IncomeRepository {
    async createIncome(incomeData) {
        return await Income.create(incomeData);
    }
    async getAllIncomes() {
        return await Income.findAll();
    }
    async getIncomeById(incomeId) {
        return await Income.findByPk(incomeId);
    }
    async updateIncome(incomeId, incomeData) {
        const income = await this.getIncomeById(incomeId);
        if (income) {
            return await income.update(incomeData);
        }
        return null;
    }
    async deleteIncome(incomeId) {
        const income = await this.getIncomeById(incomeId);
        if (income) {
            await income.destroy();
            return true;
        }
        return false;
    }
}
module.exports = new IncomeRepository();

repositories/expenseRepository.js

const Expense = require('../models/Expense');
class ExpenseRepository {
    async createExpense(expenseData) {
        return await Expense.create(expenseData);
    }
    async getAllExpenses() {
        return await Expense.findAll();
    }
    async getExpenseById(expenseId) {
        return await Expense.findByPk(expenseId);
    }
    async updateExpense(expenseId, expenseData) {
        const expense = await this.getExpenseById(expenseId);
        if (expense) {
            return await expense.update(expenseData);
        }
        return null;
    }
    async deleteExpense(expenseId) {
        const expense = await this.getExpenseById(expenseId);
        if (expense) {
            await expense.destroy();
            return true;
        }
        return false;
    }
}
module.exports = new ExpenseRepository();

repositories/budgetRepository.js

const Budget = require('../models/Budget');
class BudgetRepository {
    async createBudget(budgetData) {
        return await Budget.create(budgetData);
    }
    async getAllBudgets() {
        return await Budget.findAll();
    }
    async getBudgetById(budgetId) {
        return await Budget.findByPk(budgetId);
    }
    async updateBudget(budgetId, budgetData) {
        const budget = await this.getBudgetById(budgetId);
        if (budget) {
            return await budget.update(budgetData);
        }
        return null;
    }
    async deleteBudget(budgetId) {
        const budget = await this.getBudgetById(budgetId);
        if (budget) {
            await budget.destroy();
            return true;
        }
        return false;
    }
}
module.exports = new BudgetRepository();

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) {
            await report.destroy();
            return true;
        }
        return false;
    }
}
module.exports = new ReportRepository();

repositories/goalRepository.js

const Goal = require('../models/Goal');
class GoalRepository {
    async createGoal(goalData) {
        return await Goal.create(goalData);
    }
    async getAllGoals() {
        return await Goal.findAll();
    }
    async getGoalById(goalId) {
        return await Goal.findByPk(goalId);
    }
    async updateGoal(goalId, goalData) {
        const goal = await this.getGoalById(goalId);
        if (goal) {
            return await goal.update(goalData);
        }
        return null;
    }
    async deleteGoal(goalId) {
        const goal = await this.getGoalById(goalId);
        if (goal) {
            await goal.destroy();
            return true;
        }
        return false;
    }
}
module.exports = new GoalRepository();

repositories/investmentRepository.js

const Investment = require('../models/Investment');
class InvestmentRepository {
    async createInvestment(investmentData) {
        return await Investment.create(investmentData);
    }
    async getAllInvestments() {
        return await Investment.findAll();
    }
    async getInvestmentById(investmentId) {
        return await Investment.findByPk(investmentId);
    }
    async updateInvestment(investmentId, investmentData) {
        const investment = await this.getInvestmentById(investmentId);
        if (investment) {
            return await investment.update(investmentData);
        }
        return null;
    }
    async deleteInvestment(investmentId) {
        const investment = await this.getInvestmentById(investmentId);
        if (investment) {
            await investment.destroy();
            return true;
        }
        return false;
    }
}
module.exports = new InvestmentRepository();

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) {
            await notification.destroy();
            return true;
        }
        return false;
    }
}
module.exports = new NotificationRepository();

repositories/backupRepository.js

const Backup = require('../models/Backup');
class BackupRepository {
    async createBackup(backupData) {
        return await Backup.create(backupData);
    }
    async getAllBackups() {
        return await Backup.findAll();
    }
    async getBackupById(backupId) {
        return await Backup.findByPk(backupId);
    }
    async updateBackup(backupId, backupData) {
        const backup = await this.getBackupById(backupId);
        if (backup) {
            return await backup.update(backupData);
        }
        return null;
    }
    async deleteBackup(backupId) {
        const backup = await this.getBackupById(backupId);
        if (backup) {
            await backup.destroy();
            return true;
        }
        return false;
    }
}
module.exports = new BackupRepository();

repositories/feedbackRepository.js

const Feedback = require('../models/Feedback');
class FeedbackRepository {
    async createFeedback(feedbackData) {
        return await Feedback.create(feedbackData);
    }
    async getAllFeedbacks() {
        return await Feedback.findAll();
    }
    async getFeedbackById(feedbackId) {
        return await Feedback.findByPk(feedbackId);
    }
    async updateFeedback(feedbackId, feedbackData) {
        const feedback = await this.getFeedbackById(feedbackId);
        if (feedback) {
            return await feedback.update(feedbackData);
        }
        return null;
    }
    async deleteFeedback(feedbackId) {
        const feedback = await this.getFeedbackById(feedbackId);
        if (feedback) {
            await feedback.destroy();
            return true;
        }
        return false;
    }
}
module.exports = new FeedbackRepository();

Step 5: Set Up Controllers for Remaining Entities

controllers/roleController.js

const roleRepository = require('../repositories/roleRepository');
class RoleController {
    async createRole(req, res) {
        try {
            const role = await roleRepository.createRole(req.body);
            res.status(201).json(role);
        } catch (error) {
            res.status(500).json({ error: 'Failed to create role' });
        }
    }
    async getAllRoles(req, res) {
        try {
            const roles = await roleRepository.getAllRoles();
            res.status(200).json(roles);
        } catch (error) {
            res.status(500).json({ error: 'Failed to fetch roles' });
        }
    }
    async getRoleById(req, res) {
        try {
            const role = await roleRepository.getRoleById(req.params.id);
            if (role) {
                res.status(200).json(role);
            } else {
                res.status(404).json({ error: 'Role not found' });
            }
        } catch (error) {
            res.status(500).json({ error: 'Failed to fetch role' });
        }
    }
    async updateRole(req, res) {
        try {
            const role = await roleRepository.updateRole(req.params.id, req.body);
            if (role) {
                res.status(200).json(role);
            } else {
                res.status(404).json({ error: 'Role not found' });
            }
        } catch (error) {
            res.status(500).json({ error: 'Failed to update role' });
        }
    }
    async deleteRole(req, res) {
        try {
            const success = await roleRepository.deleteRole(req.params.id);
            if (success) {
                res.status(204).send();
            } else {
                res.status(404).json({ error: 'Role not found' });
            }
        } catch (error) {
            res.status(500).json({ error: 'Failed to delete role' });
        }
    }
}
module.exports = new RoleController();

controllers/incomeController.js

const incomeRepository = require('../repositories/incomeRepository');
class IncomeController {
    async createIncome(req, res) {
        try {
            const income = await incomeRepository.createIncome(req.body);
            res.status(201).json(income);
        } catch (error) {
            res.status(500).json({ error: 'Failed to create income' });
        }
    }
    async getAllIncomes(req, res) {
        try {
            const incomes = await incomeRepository.getAllIncomes();
            res.status(200).json(incomes);
        } catch (error) {
            res.status(500).json({ error: 'Failed to fetch incomes' });
        }
    }
    async getIncomeById(req, res) {
        try {
            const income = await incomeRepository.getIncomeById(req.params.id);
            if (income) {
                res.status(200).json(income);
            } else {
                res.status(404).json({ error: 'Income not found' });
            }
        } catch (error) {
            res.status(500).json({ error: 'Failed to fetch income' });
        }
    }
    async updateIncome(req, res) {
        try {
            const income = await incomeRepository.updateIncome(req.params.id, req.body);
            if (income) {
                res.status(200).json(income);
            } else {
                res.status(404).json({ error: 'Income not found' });
            }
        } catch (error) {
            res.status(500).json({ error: 'Failed to update income' });
        }
    }
    async deleteIncome(req, res) {
        try {
            const success = await incomeRepository.deleteIncome(req.params.id);
            if (success) {
                res.status(204).send();
            } else {
                res.status(404).json({ error: 'Income not found' });
            }
        } catch (error) {
            res.status(500).json({ error: 'Failed to delete income' });
        }
    }
}
module.exports = new IncomeController();

controllers/expenseController.js

const expenseRepository = require('../repositories/expenseRepository');
class ExpenseController {
    async createExpense(req, res) {
        try {
            const expense = await expenseRepository.createExpense(req.body);
            res.status(201).json(expense);
        } catch (error) {
            res.status(500).json({ error: 'Failed to create expense' });
        }
    }
    async getAllExpenses(req, res) {
        try {
            const expenses = await expenseRepository.getAllExpenses();
            res.status(200).json(expenses);
        } catch (error) {
            res.status(500).json({ error: 'Failed to fetch expenses' });
        }
    }
    async getExpenseById(req, res) {
        try {
            const expense = await expenseRepository.getExpenseById(req.params.id);
            if (expense) {
                res.status(200).json(expense);
            } else {
                res .status(404).json({ error: 'Expense not found' });
            }
        } catch (error) {
            res.status(500).json({ error: 'Failed to fetch expense' });
        }
    }
    async updateExpense(req, res) {
        try {
            const expense = await expenseRepository.updateExpense(req.params.id, req.body);
            if (expense) {
                res.status(200).json(expense);
            } else {
                res.status(404).json({ error: 'Expense not found' });
            }
        } catch (error) {
            res.status(500).json({ error: 'Failed to update expense' });
        }
    }
    async deleteExpense(req, res) {
        try {
            const success = await expenseRepository.deleteExpense(req.params.id);
            if (success) {
                res.status(204).send();
            } else {
                res.status(404).json({ error: 'Expense not found' });
            }
        } catch (error) {
            res.status(500).json({ error: 'Failed to delete expense' });
        }
    }
}
module.exports = new ExpenseController();

controllers/budgetController.js

const budgetRepository = require('../repositories/budgetRepository');
class BudgetController {
    async createBudget(req, res) {
        try {
            const budget = await budgetRepository.createBudget(req.body);
            res.status(201).json(budget);
        } catch (error) {
            res.status(500).json({ error: 'Failed to create budget' });
        }
    }
    async getAllBudgets(req, res) {
        try {
            const budgets = await budgetRepository.getAllBudgets();
            res.status(200).json(budgets);
        } catch (error) {
            res.status(500).json({ error: 'Failed to fetch budgets' });
        }
    }
    async getBudgetById(req, res) {
        try {
            const budget = await budgetRepository.getBudgetById(req.params.id);
            if (budget) {
                res.status(200).json(budget);
            } else {
                res.status(404).json({ error: 'Budget not found' });
            }
        } catch (error) {
            res.status(500).json({ error: 'Failed to fetch budget' });
        }
    }
    async updateBudget(req, res) {
        try {
            const budget = await budgetRepository.updateBudget(req.params.id, req.body);
            if (budget) {
                res.status(200).json(budget);
            } else {
                res.status(404).json({ error: 'Budget not found' });
            }
        } catch (error) {
            res.status(500).json({ error: 'Failed to update budget' });
        }
    }
    async deleteBudget(req, res) {
        try {
            const success = await budgetRepository.deleteBudget(req.params.id);
            if (success) {
                res.status(204).send();
            } else {
                res.status(404).json({ error: 'Budget not found' });
            }
        } catch (error) {
            res.status(500).json({ error: 'Failed to delete budget' });
        }
    }
}
module.exports = new BudgetController();

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: 'Failed to create report' });
        }
    }
    async getAllReports(req, res) {
        try {
            const reports = await reportRepository.getAllReports();
            res.status(200).json(reports);
        } catch (error) {
            res.status(500).json({ error: 'Failed to fetch reports' });
        }
    }
    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({ error: 'Report not found' });
            }
        } catch (error) {
            res.status(500).json({ error: 'Failed to fetch report' });
        }
    }
    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({ error: 'Report not found' });
            }
        } catch (error) {
            res.status(500).json({ error: 'Failed to update report' });
        }
    }
    async deleteReport(req, res) {
        try {
            const success = await reportRepository.deleteReport(req.params.id);
            if (success) {
                res.status(204).send();
            } else {
                res.status(404).json({ error: 'Report not found' });
            }
        } catch (error) {
            res.status(500).json({ error: 'Failed to delete report' });
        }
    }
}
module.exports = new ReportController();

controllers/goalController.js

const goalRepository = require('../repositories/goalRepository');
class GoalController {
    async createGoal(req, res) {
        try {
            const goal = await goalRepository.createGoal(req.body);
            res.status(201).json(goal);
        } catch (error) {
            res.status(500).json({ error: 'Failed to create goal' });
        }
    }
    async getAllGoals(req, res) {
        try {
            const goals = await goalRepository.getAllGoals();
            res.status(200).json(goals);
        } catch (error) {
            res.status(500).json({ error: 'Failed to fetch goals' });
        }
    }
    async getGoalById(req, res) {
        try {
            const goal = await goalRepository.getGoalById(req.params.id);
            if (goal) {
                res.status(200).json(goal);
            } else {
                res.status(404).json({ error: 'Goal not found' });
            }
        } catch (error) {
            res.status(500).json({ error: 'Failed to fetch goal' });
        }
    }
    async updateGoal(req, res) {
        try {
            const goal = await goalRepository.updateGoal(req.params.id, req.body);
            if (goal) {
                res.status(200).json(goal);
            } else {
                res.status(404).json({ error: 'Goal not found' });
            }
        } catch (error) {
            res.status(500).json({ error: 'Failed to update goal' });
        }
    }
    async deleteGoal(req, res) {
        try {
            const success = await goalRepository.deleteGoal(req.params.id);
            if (success) {
                res.status(204).send();
            } else {
                res.status(404).json({ error: 'Goal not found' });
            }
        } catch (error) {
            res.status(500).json({ error: 'Failed to delete goal' });
        }
    }
}
module.exports = new GoalController();

controllers/investmentController.js

const investmentRepository = require('../repositories/investmentRepository');
class InvestmentController {
    async createInvestment(req, res) {
        try {
            const investment = await investmentRepository.createInvestment(req.body);
            res.status(201).json(investment);
        } catch (error) {
            res.status(500).json({ error: 'Failed to create investment' });
        }
    }
    async getAllInvestments(req, res) {
        try {
            const investments = await investmentRepository.getAllInvestments();
            res.status(200).json(investments);
        } catch (error) {
            res.status(500).json({ error: 'Failed to fetch investments' });
        }
    }
    async getInvestmentById(req, res) {
        try {
            const investment = await investmentRepository.getInvestmentById(req.params.id);
            if (investment) {
                res.status(200).json(investment);
            } else {
                res.status(404).json({ error: 'Investment not found' });
            }
        } catch (error) {
            res.status(500).json({ error: 'Failed to fetch investment' });
        }
    }
    async updateInvestment(req, res) {
        try {
            const investment = await investmentRepository.updateInvestment(req.params.id, req.body);
            if (investment) {
                res.status(200).json(investment);
            } else {
                res.status(404).json({ error: 'Investment not found' });
            }
        } catch (error) {
            res.status(500).json({ error: 'Failed to update investment' });
        }
    }
    async deleteInvestment(req, res) {
        try {
            const success = await investmentRepository.deleteInvestment(req.params.id);
            if (success) {
                res.status(204).send();
            } else {
                res.status(404).json({ error: 'Investment not found' });
            }
        } catch (error) {
            res.status(500).json({ error: 'Failed to delete investment' });
        }
    }
}
module.exports = new InvestmentController();

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: 'Failed to create notification' });
        }
    }
    async getAllNotifications(req, res) {
        try {
            const notifications = await notificationRepository.getAllNotifications();
            res.status(200).json(notifications);
        } catch (error) {
            res.status(500).json({ error: 'Failed to fetch notifications' });
        }
    }
    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({ error: 'Notification not found' });
            }
        } catch (error) {
            res.status(500).json({ error: 'Failed to fetch notification' });
        }
    }
    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({ error: 'Notification not found' });
            }
        } catch (error) {
            res.status(500).json({ error: 'Failed to update notification' });
        }
    }
    async deleteNotification(req, res) {
        try {
            const success = await notificationRepository.deleteNotification(req.params.id);
            if (success) {
                res.status(204).send();
            } else {
                res.status(404).json({ error: 'Notification not found' });
            }
        } catch (error) {
            res.status(500).json({ error: 'Failed to delete notification' });
        }
    }
}
module.exports = new NotificationController();

controllers/backupController.js

const backupRepository = require('../repositories/backupRepository');
class BackupController {
    async createBackup(req, res) {
        try {
            const backup = await backupRepository.createBackup(req.body);
            res.status(201).json(backup);
        } catch (error) {
            res.status(500).json({ error: 'Failed to create backup' });
        }
    }
    async getAllBackups(req, res) {
        try {
            const backups = await backupRepository.getAllBackups();
            res.status(200).json(backups);
        } catch (error) {
            res.status(500).json({ error: 'Failed to fetch backups' });
        }
    }
    async getBackupById(req, res) {
        try {
            const backup = await backupRepository.getBackupById(req.params.id);
            if (backup) {
                res.status(200).json(backup);
            } else {
                res.status(404).json({ error: 'Backup not found' });
            }
        } catch (error) {
            res.status(500).json({ error: 'Failed to fetch backup' });
        }
    }
    async updateBackup(req, res) {
        try {
            const backup = await backupRepository.updateBackup(req.params.id, req.body);
            if (backup) {
                res.status(200).json(backup);
            } else {
                res.status(404).json({ error: 'Backup not found' });
            }
        } catch (error) {
            res.status(500).json({ error: 'Failed to update backup' });
        }
    }
    async deleteBackup(req, res) {
        try {
            const success = await backupRepository.deleteBackup(req.params.id);
            if (success) {
                res.status(204).send();
            } else {
                res.status(404).json({ error: 'Backup not found' });
            }
        } catch (error) {
            res.status(500).json({ error: 'Failed to delete backup' });
        }
    }
}
module.exports = new BackupController();

controllers/feedbackController.js

const feedbackRepository = require('../repositories/feedbackRepository');
class FeedbackController {
    async createFeedback(req, res) {
        try {
            const feedback = await feedbackRepository.createFeedback(req.body);
            res.status(201).json(feedback);
        } catch (error) {
            res.status(500).json({ error: 'Failed to create feedback' });
        }
    }
    async getAllFeedbacks(req, res) {
        try {
            const feedbacks = await feedbackRepository.getAllFeedbacks();
            res.status(200).json(feedbacks);
        } catch (error) {
            res.status(500).json({ error: 'Failed to fetch feedbacks' });
        }
    }
    async getFeedbackById(req, res) {
        try {
            const feedback = await feedbackRepository.getFeedbackById(req.params.id);
            if (feedback) {
                res.status(200).json(feedback);
            } else {
                res.status(404 ).json({ error: 'Feedback not found' });
            }
        } catch (error) {
            res.status(500).json({ error: 'Failed to fetch feedback' });
        }
    }
    async updateFeedback(req, res) {
        try {
            const feedback = await feedbackRepository.updateFeedback(req.params.id, req.body);
            if (feedback) {
                res.status(200).json(feedback);
            } else {
                res.status(404).json({ error: 'Feedback not found' });
            }
        } catch (error) {
            res.status(500).json({ error: 'Failed to update feedback' });
        }
    }
    async deleteFeedback(req, res) {
        try {
            const success = await feedbackRepository.deleteFeedback(req.params.id);
            if (success) {
                res.status(204).send();
            } else {
                res.status(404).json({ error: 'Feedback not found' });
            }
        } catch (error) {
            res.status(500).json({ error: 'Failed to delete feedback' });
        }
    }
}
module.exports = new FeedbackController();

Step 6: Define Routes for Remaining Entities

routes/roleRoutes.js

const express = require('express');
const router = express.Router();
const roleController = require('../controllers/roleController');
router.post('/', roleController.createRole);
router.get('/', roleController.getAllRoles);
router.get('/:id', roleController.getRoleById);
router.put('/:id', roleController.updateRole);
router.delete('/:id', roleController.deleteRole);
module.exports = router;

routes/incomeRoutes.js

const express = require('express');
const router = express.Router();
const incomeController = require('../controllers/incomeController');
router.post('/', incomeController.createIncome);
router.get('/', incomeController.getAllIncomes);
router.get('/:id', incomeController.getIncomeById);
router.put('/:id', incomeController.updateIncome);
router.delete('/:id', incomeController.deleteIncome);
module.exports = router;

routes/expenseRoutes.js

const express = require('express');
const router = express.Router();
const expenseController = require('../controllers/expenseController');
router.post('/', expenseController.createExpense);
router.get('/', expenseController.getAllExpenses);
router.get('/:id', expenseController.getExpenseById);
router.put('/:id', expenseController.updateExpense);
router.delete('/:id', expenseController.deleteExpense);
module.exports = router;

routes/budgetRoutes.js

const express = require('express');
const router = express.Router();
const budgetController = require('../controllers/budgetController');
router.post('/', budgetController.createBudget);
router.get('/', budgetController.getAllBudgets);
router.get('/:id', budgetController.getBudgetById);
router.put('/:id', budgetController.updateBudget);
router.delete('/:id', budgetController.deleteBudget);
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/goalRoutes.js

const express = require('express');
const router = express.Router();
const goalController = require('../controllers/goalController');
router.post('/', goalController.createGoal);
router.get('/', goalController.getAllGoals);
router.get('/:id', goalController.getGoalById);
router.put('/:id', goalController.updateGoal);
router.delete('/:id', goalController.deleteGoal);
module.exports = router;

routes/investmentRoutes.js

const express = require('express');
const router = express.Router();
const investmentController = require('../controllers/investmentController');
router.post('/', investmentController.createInvestment);
router.get('/', investmentController.getAllInvestments);
router.get('/:id', investmentController.getInvestmentById);
router.put('/:id', investmentController.updateInvestment);
router.delete('/:id', investmentController.deleteInvestment);
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/backupRoutes.js

const express = require('express');
const router = express.Router();
const backupController = require('../controllers/backupController');
router.post('/', backupController.createBackup);
router.get('/', backupController.getAllBackups);
router.get('/:id', backupController.getBackupById);
router.put('/:id', backupController.updateBackup);
router.delete('/:id', backupController.deleteBackup);
module.exports = router;

routes/feedbackRoutes.js

const express = require('express');
const router = express.Router();
const feedbackController = require('../controllers/feedbackController');
router.post('/', feedbackController.createFeedback);
router.get('/', feedbackController.getAllFeedbacks);
router.get('/:id', feedbackController.getFeedbackById);
router.put('/:id', feedbackController.updateFeedback);
router.delete('/:id', feedbackController.deleteFeedback);
module.exports = router;

Step 7: Create Views for Remaining Entities

views/roles.ejs

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/5.0.0-beta1/css/bootstrap.min.css">
    <title>Roles</title>
</head>
<body>
    <div class="container">
        <h1>Roles</h1>
        <table class="table">
            <thead>
                <tr>
                    <th>RoleId</th>
                    <th>RoleName</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% roles.forEach(role => { %>
                    <tr>
                        <td><%= role.RoleId %></td>
                        <td><%= role.RoleName %></td>
                        <td>
                            <a href="/roles/<%= role.RoleId %>/edit" class="btn btn-warning">Edit</a>
                            <form action="/roles/<%= role.RoleId %>" 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="/roles/new" class="btn btn-primary">Add Role</a>
    </div>
</body>
</html>

views/incomes.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>Incomes</title>
</head>
<body>
    <div class="container">
        <h1>Incomes</h1>
        <table class="table">
            <thead>
                <tr>
                    <th>IncomeId</th>
                    <th>UserId</th>
                    <th>Amount</th>
                    <th>Source</th>
                    <th>DateReceived</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% incomes.forEach(income => { %>
                    <tr>
                        <td><%= income.IncomeId %></td>
                        <td><%= income.UserId %></td>
                        <td><%= income.Amount %></td>
                        <td><%= income.Source %></td>
                        <td><%= income.DateReceived %></td>
                        <td>
                            <a href="/incomes/<%= income.IncomeId %>/edit" class="btn btn-warning">Edit</a>
                            <form action="/incomes/<%= income.IncomeId %>" 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="/incomes/new" class="btn btn-primary">Add Income</a>
    </div>
</body>
</html>

views/expenses.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>Expenses</title>
</head>
<body>
    <div class="container">
        <h1>Expenses</h1>
        <table class="table">
            <thead>
                <tr>
                    <th>ExpenseId</th>
                    <th>UserId</th>
                    < th>Amount</th>
                    <th>Category</th>
                    <th>DateIncurred</th>
                    <th>Description</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% expenses.forEach(expense => { %>
                    <tr>
                        <td><%= expense.ExpenseId %></td>
                        <td><%= expense.UserId %></td>
                        <td><%= expense.Amount %></td>
                        <td><%= expense.Category %></td>
                        <td><%= expense.DateIncurred %></td>
                        <td><%= expense.Description %></td>
                        <td>
                            <a href="/expenses/<%= expense.ExpenseId %>/edit" class="btn btn-warning">Edit</a>
                            <form action="/expenses/<%= expense.ExpenseId %>" 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="/expenses/new" class="btn btn-primary">Add Expense</a>
    </div>
</body>
</html>

views/budgets.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>Budgets</title>
</head>
<body>
    <div class="container">
        <h1>Budgets</h1>
        <table class="table">
            <thead>
                <tr>
                    <th>BudgetId</th>
                    <th>UserId</th>
                    <th>Category</th>
                    <th>Amount</th>
                    <th>StartDate</th>
                    <th>EndDate</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% budgets.forEach(budget => { %>
                    <tr>
                        <td><%= budget.BudgetId %></td>
                        <td><%= budget.UserId %></td>
                        <td><%= budget.Category %></td>
                        <td><%= budget.Amount %></td>
                        <td><%= budget.StartDate %></td>
                        <td><%= budget.EndDate %></td>
                        <td>
                            <a href="/budgets/<%= budget.BudgetId %>/edit" class="btn btn-warning">Edit</a>
                            <form action="/budgets/<%= budget.BudgetId %>" 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="/budgets/new" class="btn btn-primary">Add Budget</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>Reports</title>
</head>
<body>
    <div class="container">
        <h1>Reports</h1>
        <table class="table">
            <thead>
                <tr>
                    <th>ReportId</th>
                    <th>UserId</th>
                    <th>ReportDate</th>
                    <th>ReportContent</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% reports.forEach(report => { %>
                    <tr>
                        <td><%= report.ReportId %></td>
                        <td><%= report.UserId %></td>
                        <td><%= report.ReportDate %></td>
                        <td><%= report.ReportContent %></td>
                        <td>
                            <a href="/reports/<%= report.ReportId %>/edit" 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/goals.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>Goals</title>
</head>
<body>
    <div class="container">
        <h1>Goals</h1>
        <table class="table">
            <thead>
                <tr>
                    <th>GoalId</th>
                    <th>UserId</th>
                    <th>GoalName</th>
                    <th>TargetAmount</th>
                    <th>CurrentAmount</th>
                    <th>TargetDate</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% goals.forEach(goal => { %>
                    <tr>
                        <td><%= goal.GoalId %></td>
                        <td><%= goal.UserId %></td>
                        <td><%= goal.GoalName %></td>
                        <td><%= goal.TargetAmount %></td>
                        <td><%= goal.CurrentAmount %></td>
                        <td><%= goal.TargetDate %></td>
                        <td>
                            <a href="/goals/<%= goal.GoalId %>/edit" class="btn btn-warning">Edit</a>
                            <form action="/goals/<%= goal.GoalId %>" 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="/goals/new" class="btn btn-primary">Add Goal</a>
    </div>
</body>
</html>

views/investments.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>Investments</title>
</head>
<body>
    <div class="container">
        <h1>Investments</h1>
        <table class="table">
            <thead>
                <tr>
                    <th>InvestmentId</th>
                    <th>UserId</th>
                    <th>InvestmentName</th>
                    <th>Amount</th>
                    <th>InvestmentDate</th>
                    <th>CurrentValue</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% investments.forEach(investment => { %>
                    <tr>
                        <td><%= investment.InvestmentId %></td>
                        <td><%= investment.UserId %></td>
                        <td><%= investment.InvestmentName %></td>
                        <td><%= investment.Amount %></td>
                        <td><%= investment.InvestmentDate %></td>
                        <td><%= investment.CurrentValue %></td>
                        <td>
                            <a href="/investments/<%= investment.InvestmentId %>/edit" class="btn btn-warning">Edit</a>
                            <form action="/investments/<%= investment.InvestmentId %>" 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="/investments/new" class="btn btn-primary">Add Investment</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>Notifications</title>
</head>
<body>
    <div class="container">
 <h1>Notifications</h1>
        <table class="table">
            <thead>
                <tr>
                    <th>NotificationId</th>
                    <th>UserId</th>
                    <th>Message</th>
                    <th>IsRead</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% notifications.forEach(notification => { %>
                    <tr>
                        <td><%= notification.NotificationId %></td>
                        <td><%= notification.UserId %></td>
                        <td><%= notification.Message %></td>
                        <td><%= notification.IsRead ? 'Yes' : 'No' %></td>
                        <td>
                            <a href="/notifications/<%= notification.NotificationId %>/edit" 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/backups.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>Backups</title>
</head>
<body>
    <div class="container">
        <h1>Backups</h1>
        <table class="table">
            <thead>
                <tr>
                    <th>BackupId</th>
                    <th>UserId</th>
                    <th>BackupDate</th>
                    <th>BackupFile</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% backups.forEach(backup => { %>
                    <tr>
                        <td><%= backup.BackupId %></td>
                        <td><%= backup.UserId %></td>
                        <td><%= backup.BackupDate %></td>
                        <td><%= backup.BackupFile %></td>
                        <td>
                            <a href="/backups/<%= backup.BackupId %>/edit" class="btn btn-warning">Edit</a>
                            <form action="/backups/<%= backup.BackupId %>" 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="/backups/new" class="btn btn-primary">Add Backup</a>
    </div>
</body>
</html>

views/feedbacks.ejs

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/5.0.0-beta1/css/bootstrap.min.css">
    <title>Feedbacks</title>
</head>
<body>
    <div class="container">
        <h1>Feedbacks</h1>
        <table class="table">
            <thead>
                <tr>
                    <th>FeedbackId</th>
                    <th>UserId</th>
                    <th>FeedbackContent</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% feedbacks.forEach(feedback => { %>
                    <tr>
                        <td><%= feedback.FeedbackId %></td>
                        <td><%= feedback.UserId %></td>
                        <td><%= feedback.FeedbackContent %></td>
                        <td>
                            <a href="/feedbacks/<%= feedback.FeedbackId %>/edit" class="btn btn-warning">Edit</a>
                            <form action="/feedbacks/<%= feedback.FeedbackId %>" 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="/feedbacks/new" class="btn btn-primary">Add Feedback</a>
    </div>
</body>
</html>

Step 8: Update Main Application File

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

const express = require('express');
const bodyParser = require('body-parser');
const methodOverride = require('method-override');
const userRoutes = require('./routes/userRoutes');
const roleRoutes = require('./routes/roleRoutes');
const incomeRoutes = require('./routes/incomeRoutes');
const expenseRoutes = require('./routes/expenseRoutes');
const budgetRoutes = require('./routes/budgetRoutes');
const reportRoutes = require('./routes/reportRoutes');
const goalRoutes = require('./routes/goalRoutes');
const investmentRoutes = require('./routes/investmentRoutes');
const notificationRoutes = require('./routes/notificationRoutes');
const backupRoutes = require('./routes/backupRoutes');
const feedbackRoutes = require('./routes/feedbackRoutes');
const sequelize = require('./config');
const app = express();
app.set('view engine', 'ejs');
app.use(bodyParser.urlencoded({ extended: true }));
app.use(methodOverride('_method'));
app.use('/users', userRoutes);
app.use('/roles', roleRoutes);
app.use('/incomes', incomeRoutes);
app.use('/expenses', expenseRoutes);
app.use('/budgets', budgetRoutes);
app.use('/reports', reportRoutes);
app.use('/goals', goalRoutes);
app.use('/investments', investmentRoutes);
app.use('/notifications', notificationRoutes);
app.use('/backups', backupRoutes);
app.use('/feedbacks', feedbackRoutes);
sequelize.sync().then(() => {
    app.listen(3000, () => {
        console.log('Server is running on http://localhost:3000');
    });
}).catch(err => {
    console.error('Unable to connect to the database:', err);
});

Final Considerations

Ensure that all models, repositories, controllers, and routes are correctly set up for each entity.

Implement error handling and validation as needed.

Consider adding authentication and authorization for user management.

Test all CRUD operations to ensure they work as expected.

This setup provides a complete CRUD application for managing users, roles, incomes, expenses, budgets, reports, goals, investments, notifications, backups, and feedback using Node.js, Sequelize, EJS, and Bootstrap 5.

Creating a Dashboard Page

To create a dashboard page that displays consolidated data related to your finance 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 Budget = require('../models/Budget');
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');
            const totalExpenses = await Expense.sum('Amount');
            const totalBudgets = await Budget.sum('Amount');
            const totalGoals = await Goal.count();
            const totalInvestments = await Investment.sum('Amount');
            res.render('dashboard', {
                totalUsers,
                totalIncome: totalIncome || 0,
                totalExpenses: totalExpenses || 0,
                totalBudgets: totalBudgets || 0,
                totalGoals,
                totalInvestments: totalInvestments || 0,
            });
        } 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 Budgets</h5>
                        <p class="card-text">$<%= totalBudgets.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: Update Main Application File

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

const express = require('express');
const bodyParser = require('body-parser');
const methodOverride = require('method-override');
const userRoutes = require('./routes/userRoutes');
const roleRoutes = require('./routes/roleRoutes');
const incomeRoutes = require('./routes/incomeRoutes');
const expenseRoutes = require('./routes/expenseRoutes');
const budgetRoutes = require('./routes/budgetRoutes');
const reportRoutes = require('./routes/reportRoutes');
const goalRoutes = require('./routes/goalRoutes');
const investmentRoutes = require('./routes/investmentRoutes');
const notificationRoutes = require('./routes/notificationRoutes');
const backupRoutes = require('./routes/backupRoutes');
const feedbackRoutes = require('./routes/feedbackRoutes');
const dashboardRoutes = require('./routes/dashboardRoutes'); // Include dashboard routes
const sequelize = require('./config');
const app = express();
app.set('view engine', 'ejs');
app.use(bodyParser.urlencoded({ extended: true }));
app.use(methodOverride('_method'));
app.use('/users', userRoutes);
app.use('/roles', roleRoutes);
app.use('/incomes', incomeRoutes);
app.use('/expenses', expenseRoutes);
app.use('/budgets', budgetRoutes);
app.use('/reports', reportRoutes);
app.use('/goals', goalRoutes);
app.use('/investments', investmentRoutes);
app.use('/notifications', notificationRoutes);
app.use('/backups', backupRoutes);
app.use('/feedbacks', feedbackRoutes);
app.use('/dashboard', dashboardRoutes); // Use dashboard routes
sequelize.sync().then(() => {
    app.listen(3000, () => {
        console.log('Server is running on http://localhost:3000');
    });
}).catch(err => {
    console.error('Unable to connect to the database:', err);
});

Final Considerations

Ensure that all necessary models are imported in the dashboard controller.

Test the dashboard to verify that it correctly displays the consolidated data.

You can further enhance the dashboard by adding charts or graphs to visualize the data using libraries like Chart.js or D3.js.

Consider adding user authentication to restrict access to the dashboard.

This setup provides a comprehensive dashboard that summarizes key metrics related to your finance application, allowing users to quickly assess their financial status.