Project Introduction

The Health Monitoring Wearable System is a web application designed to track and analyze health metrics collected from wearable devices such as smartwatches and fitness bands. Built using Node.js, this platform allows users to monitor their health data, set health goals, and receive notifications based on their activity levels. The system supports user authentication and provides a personalized experience for each user. The underlying MySQL database schema is structured to manage users, user profiles, devices, health data, health goals, notifications, and reports, providing a robust foundation for effective health monitoring.

Project Objectives

  • To develop a user-friendly interface for users to manage their health data and wearable devices.
  • To implement a secure user authentication system for personalized health tracking.
  • To allow users to set and track health goals related to steps, weight loss, and exercise time.
  • To enable users to view and analyze their health data, including heart rate, steps, calories burned, and sleep duration.
  • To provide notifications for reminders and updates related to health goals and device status.
  • To generate reports summarizing health data and progress towards goals.
  • 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. User Profile Management Module:

    This module allows users to create and update their profiles, including personal information such as age, gender, height, and weight.

  3. Device Management Module:

    This module enables users to add and manage their wearable devices, including device types, pairing status, and battery levels.

  4. Health Data Management Module:

    This module tracks and stores health data collected from wearable devices, including heart rate, steps, calories burned, and sleep duration.

  5. Health Goals Management Module:

    This module allows users to set and track their health goals, including target values and due dates.

  6. Notification Module:

    This module sends notifications to users regarding important updates, reminders for health goals, and device status alerts.

  7. Report Generation Module:

    This module generates reports summarizing health data and progress towards health goals, providing insights for users.

Step 1: Project Setup

Initialize a new Node.js project:


mkdir health-tracker
cd health-tracker
npm init -y

Install required packages:


npm install express sequelize mysql2 ejs body-parser

Create the project structure:


mkdir models controllers routes views public

Step 2: Configure Sequelize

Create a Sequelize configuration file: Create a file named config.js in the root directory:


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

Step 3: Create Models

Create User model (models/User.js):


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

Create other models similarly (models/Role.js, models/Device.js, etc.): Follow the same structure as the User model for the other tables. Here’s an example for the Role model:


const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const Role = sequelize.define('Role', {
    RoleId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    RoleName: {
        type: DataTypes.STRING(50),
        allowNull: false,
        unique: true,
    },
});
module.exports = Role;

Step 4: Create Repositories

Create a User repository (repositories/UserRepository.js):


const User = require('../models/User');
class UserRepository {
    async create(userData) {
        return await User.create(userData);
    }
    async findAll() {
        return await User.findAll();
    }
    async findById(id) {
        return await User.findByPk(id);
    }
    async update(id, userData) {
        return await User.update(userData, { where: { UserId: id } });
    }
    async delete(id) {
        return await User.destroy({ where: { UserId: id } });
    }
}
module.exports = new UserRepository();

Create repositories for other models similarly.

Step 5: Create Controllers

Create a User controller (controllers/UserController.js):


const UserRepository = require('../repositories/UserRepository');
class UserController {
    async create(req, res) {
        const user = await UserRepository.create(req.body);
        res.redirect('/users');
    }
    async findAll(req, res) {
        const users = await UserRepository.findAll();
        res.render('users/index', { users });
    }
    async findById(req, res) {
        const user = await UserRepository.findById(req.params.id);
        res.render('users/edit', { user });
    }
    async update(req, res) {
        await UserRepository.update(req.params.id, req.body);
        res.redirect('/users');
    }
    async delete(req, res) {
        await UserRepository.delete(req.params.id);
        res.redirect('/users');
    }
}
module.exports = new UserController();

Create controllers for other models similarly.

Step 6: Create Routes

Create user routes (routes/userRoutes.js):


const express = require('express');
const router = express.Router();
const UserController = require('../controllers/UserController');
router.get('/', UserController.findAll);
router.get('/create', (req, res) => res.render('users/create'));
router.post('/', UserController.create);
router.get('/:id/edit', UserController.findById);
router.post('/:id', UserController.update);
router.post('/:id/delete', UserController.delete);
module.exports = router;

Create routes for other models similarly.

Step 7: Set Up Express Application

Create the main application file (app.js):


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

Step 8: Create EJS Views

Create a layout file (views/layout.ejs):


<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/5.1.3/css/bootstrap.min.css">
    <title>Health Tracker</title>
</head>
<body>
    <div class="container">
        <%- body %>
    </div>
</body>
</html>

Create user index view (views/users/index.ejs):

<% layout('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>

Create user create view (views/users/create.ejs):


<% layout('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</button>
</form>

Step 9: Run the Application

Start the server:

node app.js

Access the application: Open your browser and navigate to http://localhost:3000/users to see the user management interface.

This setup provides a basic structure for a CRUD application using Node.js, Sequelize, Express, and EJS with Bootstrap 5 templates. You can expand this by adding more models, repositories, controllers, and views for other entities like Devices, HealthData, etc.

Further Implementation for Remaining Models

Following are the complete setup for the remaining models (Devices, HealthData, HeartRate, Activities, SleepData, HealthReports, Alerts, Feedbacks, CommunityPosts) including their Sequelize models, repositories, controllers, routes, and EJS views.

Step 1: Create Remaining Models

Device Model (models/Device.js):


const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const Device = sequelize.define('Device', {
    DeviceId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    DeviceName: {
        type: DataTypes.STRING(100),
        allowNull: false,
    },
    DeviceType: {
        type: DataTypes.STRING(50),
    },
    SerialNumber: {
        type: DataTypes.STRING(100),
        unique: true,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
});
module.exports = Device;

HealthData Model (models/HealthData.js):


const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const HealthData = sequelize.define('HealthData', {
    HealthDataId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    Timestamp: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    HeartRate: {
        type: DataTypes.INTEGER,
    },
    BloodPressure: {
        type: DataTypes.STRING(20),
    },
    BloodOxygenLevel: {
        type: DataTypes.DECIMAL(5, 2),
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
});
module.exports = HealthData;

HeartRate Model (models/HeartRate.js):


const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const HeartRate = sequelize.define('HeartRate', {
    HeartRateId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    Timestamp: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    HeartRate: {
        type: DataTypes.INTEGER,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
});
module.exports = HeartRate;

Activity Model (models/Activity.js):


const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const Activity = sequelize.define('Activity', {
    ActivityId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    ActivityType: {
        type: DataTypes.STRING(50),
    },
    Duration: {
        type: DataTypes.INTEGER,
    },
    CaloriesBurned: {
        type: DataTypes.INTEGER,
    },
    Timestamp: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
});
module.exports = Activity;

SleepData Model (models/SleepData.js):


const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const SleepData = sequelize.define('SleepData', {
    SleepDataId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    SleepStart: {
        type: DataTypes.DATE,
    },
    SleepEnd: {
        type: DataTypes.DATE,
    },
    Duration: {
        type: DataTypes.INTEGER,
    },
    Quality: {
        type: DataTypes.STRING(50),
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
});
module.exports = SleepData;

HealthReports Model (models/HealthReport.js):


const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const HealthReport = sequelize.define('HealthReport', {
    HealthReportId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    ReportDate: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    Summary: {
        type: DataTypes.TEXT,
    },
    Recommendations: {
        type: DataTypes.TEXT,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.N OW,
    },
});
module.exports = HealthReport;

Alerts Model (models/Alert.js):


const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const Alert = sequelize.define('Alert', {
    AlertId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    AlertType: {
        type: DataTypes.STRING(50),
    },
    Message: {
        type: DataTypes.TEXT,
    },
    IsAcknowledged: {
        type: DataTypes.BOOLEAN,
        defaultValue: false,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
});
module.exports = Alert;

Feedback Model (models/Feedback.js):


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

CommunityPosts Model (models/CommunityPost.js):


const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const CommunityPost = sequelize.define('CommunityPost', {
    PostId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    PostContent: {
        type: DataTypes.TEXT,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
});
module.exports = CommunityPost;

Step 2: Create Remaining Repositories

Device Repository (repositories/DeviceRepository.js):


const Device = require('../models/Device');
class DeviceRepository {
    async create(deviceData) {
        return await Device.create(deviceData);
    }
    async findAll() {
        return await Device.findAll();
    }
    async findById(id) {
        return await Device.findByPk(id);
    }
    async update(id, deviceData) {
        return await Device.update(deviceData, { where: { DeviceId: id } });
    }
    async delete(id) {
        return await Device.destroy({ where: { DeviceId: id } });
    }
}
module.exports = new DeviceRepository();

Create repositories for HealthData, HeartRate, Activities, SleepData, HealthReports, Alerts, Feedbacks, CommunityPosts similarly.

Step 3: Create Remaining Controllers

Device Controller (controllers/DeviceController.js):


const DeviceRepository = require('../repositories/DeviceRepository');
class DeviceController {
    async create(req, res) {
        const device = await DeviceRepository.create(req.body);
        res.redirect('/devices');
    }
    async findAll(req, res) {
        const devices = await DeviceRepository.findAll();
        res.render('devices/index', { devices });
    }
    async findById(req, res) {
        const device = await DeviceRepository.findById(req.params.id);
        res.render('devices/edit', { device });
    }
    async update(req, res) {
        await DeviceRepository.update(req.params.id, req.body);
        res.redirect('/devices');
    }
    async delete(req, res) {
        await DeviceRepository.delete(req.params.id);
        res.redirect('/devices');
    }
}
module.exports = new DeviceController();

Create controllers for HealthData, HeartRate, Activities, SleepData, HealthReports, Alerts, Feedbacks, CommunityPosts similarly.

Step 4: Create Remaining Routes

Device Routes (routes/deviceRoutes.js):


const express = require('express');
const router = express.Router();
const DeviceController = require('../controllers/DeviceController');
router.get('/', DeviceController.findAll);
router.get('/create', (req, res) => res.render('devices/create'));
router.post('/', DeviceController.create);
router.get('/:id /edit', DeviceController.findById);
router.post('/:id', DeviceController.update);
router.post('/:id/delete', DeviceController.delete);
module.exports = router;

Create routes for HealthData, HeartRate, Activities, SleepData, HealthReports, Alerts, Feedbacks, CommunityPosts similarly.

Step 5: Set Up Views for Remaining Models

Device Index View (views/devices/index.ejs):


<% layout('layout') %>
<h1>Devices</h1>
<a href="/devices/create" class="btn btn-primary">Create Device</a>
<table class="table">
    <thead>
        <tr>
            <th>Device Name</th>
            <th>Device Type</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        <% devices.forEach(device => { %>
            <tr>
                <td><%= device.DeviceName %></td>
                <td><%= device.DeviceType %></td>
                <td>
                    <a href="/devices/<%= device.DeviceId %>/edit" class="btn btn-warning">Edit</a>
                    <form action="/devices/<%= device.DeviceId %>/delete" method="POST" style="display:inline;">
                        <button type="submit" class="btn btn-danger">Delete</button>
                    </form>
                </td>
            </tr>
        <% }) %>
    </tbody>
</table>

Device Create View (views/devices/create.ejs):


<% layout('layout') %>
<h1>Create Device</h1>
<form action="/devices" method="POST">
    <div class="mb-3">
        <label for="DeviceName" class="form-label">Device Name</label>
        <input type="text" class="form-control" id="DeviceName" name="DeviceName" required>
    </div>
    <div class="mb-3">
        <label for="DeviceType" class="form-label">Device Type</label>
        <input type="text" class="form-control" id="DeviceType" name="DeviceType">
    </div>
    <div class="mb-3">
        <label for="SerialNumber" class="form-label">Serial Number</label>
        <input type="text" class="form-control" id="SerialNumber" name="SerialNumber" required>
    </div>
    <button type="submit" class="btn btn-primary">Create</button>
</form>

Repeat similar steps for HealthData, HeartRate, Activities, SleepData, HealthReports, Alerts, Feedbacks, CommunityPosts views.

Step 6: Update Main Application File

Update app.js to include new routes:


const deviceRoutes = require('./routes/deviceRoutes');
// Import other routes similarly

app.use('/devices', deviceRoutes);
// Use other routes similarly

Step 7: Run the Application

Start the server:

node app.js

Access the application: Open your browser and navigate to http://localhost:3000/devices to manage devices, and similarly for other entities.

This completes the setup for the remaining models, repositories, controllers, routes, and views for a complete CRUD application using Node.js, Sequelize, Express, and EJS with Bootstrap 5 templates. You can further enhance the application by adding validation, authentication, and more features as needed.

Creating a Dashboard Page

To create a dashboard page that consolidates data related to the project, we will follow these steps:

Step 1: Create a Dashboard Route

Create a new file for the dashboard routes (routes/dashboardRoutes.js):


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

Step 2: Create a Dashboard Controller

Create a new file for the dashboard controller (controllers/DashboardController.js):


const UserRepository = require('../repositories/UserRepository');
const DeviceRepository = require('../repositories/DeviceRepository');
const HealthDataRepository = require('../repositories/HealthDataRepository');
const ActivityRepository = require('../repositories/ActivityRepository');
class DashboardController {
    async showDashboard(req, res) {
        try {
            const users = await UserRepository.findAll();
            const devices = await DeviceRepository.findAll();
            const healthData = await HealthDataRepository.findAll();
            const activities = await ActivityRepository.findAll();
            // You can perform any aggregation or calculations here if needed
            const totalUsers = users.length;
            const totalDevices = devices.length;
            const totalHealthDataEntries = healthData.length;
            const totalActivities = activities.length;
            res.render('dashboard', {
                totalUsers,
                totalDevices,
                totalHealthDataEntries,
                totalActivities,
            });
        } catch (error) {
            console.error('Error fetching dashboard data:', error);
            res.status(500).send('Internal Server Error');
        }
    }
}
module.exports = new DashboardController();

Step 3: Create a Dashboard View

Create a new view file for the dashboard (views/dashboard.ejs):


<% layout('layout') %>
<h1>Dashboard</h1>
<div class="row">
    <div class="col-md-3">
        <div class="card text-white bg-primary mb-3">
            <div class="card-header">Total Users</div>
            <div class="card-body">
                <h5 class="card-title"><%= totalUsers %></h5>
            </div>
        </div>
    </div>
    <div class="col-md-3">
        <div class="card text-white bg-success mb-3">
            <div class="card-header">Total Devices</div>
            <div class="card-body">
                <h5 class="card-title"><%= totalDevices %></h5>
            </div>
        </div>
    </div>
    <div class="col-md-3">
        <div class="card text-white bg-warning mb-3">
            <div class="card-header">Total Health Data Entries</div>
            <div class="card-body">
                <h5 class="card-title"><%= totalHealthDataEntries %></h5>
            </div>
        </div>
    </div>
    <div class="col-md-3">
        <div class="card text-white bg-danger mb-3">
            <div class="card-header">Total Activities</div>
            <div class="card-body">
                <h5 class="card-title"><%= totalActivities %></h5>
            </div>
        </div>
    </div>
</div>

Step 4: Update the Main Application File

Update your main application file (app.js) to include the dashboard route:


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

Step 5: Access the Dashboard

Start the server:


node app.js

Access the dashboard: Open your browser and navigate to http://localhost:3000/dashboard to view the dashboard with consolidated data.

Now you have a dashboard page that displays consolidated data related to users, devices, health data entries, and activities. You can further enhance the dashboard by adding charts, graphs, or more detailed statistics as needed. You can use libraries like Chart.js or D3.js for visualizing data if you want to take it a step further.