Project Introduction
The Hospital Management System is a comprehensive web application designed to streamline the management of hospital operations, including patient care, appointments, billing, and inventory management. Built using Node.js, this platform allows healthcare professionals to efficiently manage patient records, appointments, and medical history while providing a user-friendly experience for patients. The system supports multiple user roles, including admin, doctor, nurse, admin staff, and patient, ensuring tailored access and functionality for each role. The underlying MySQL database schema is structured to manage users, patients, appointments, medical records, billing, inventory, laboratory tests, pharmacy, staff management, emergency cases, and notifications, providing a robust foundation for effective hospital management.
Project Objectives
- To develop a user-friendly interface for healthcare professionals to manage patient information and appointments.
- To implement a secure user authentication system with role-based access control.
- To facilitate the management of patient medical records, including history and allergies.
- To enable scheduling and tracking of patient appointments with doctors.
- To manage billing processes, including payment statuses and amounts.
- To maintain an inventory of medical supplies and medications.
- To provide functionality for laboratory tests and results management.
- To handle emergency cases and triage levels effectively.
- To implement a notification system for important updates and reminders.
- To ensure the application is scalable and maintainable for future enhancements.
Project Modules
- User Management Module:
This module handles user registration, authentication, and role management, allowing users to manage their accounts securely.
- Patient Management Module:
This module allows healthcare professionals to add, update, and manage patient records, including personal information and medical history.
- Appointment Management Module:
This module facilitates scheduling and tracking of patient appointments with doctors, including appointment statuses.
- Medical Records Management Module:
This module manages patient medical records, including descriptions of visits and treatments.
- Billing Management Module:
This module handles billing processes, including tracking payments and managing billing statuses.
- Inventory Management Module:
This module maintains an inventory of medical supplies and medications, including reorder levels.
- Laboratory Tests Management Module:
This module manages laboratory tests for patients, including test names, dates, and results.
- Pharmacy Management Module:
This module manages medications available in the pharmacy, including dosages and quantities.
- Staff Management Module:
This module handles staff records, including positions, hire dates, and salaries.
- Emergency Cases Management Module:
This module manages emergency cases, including descriptions and triage levels for patients.
- Notification Module:
This module sends notifications to users regarding important updates, reminders, and alerts.
Set Up the Project
Step 1: Set Up the Project
Initialize a new Node.js project:
mkdir healthcare-management
cd healthcare-management
npm init -y
Install required packages:
npm install express sequelize mysql2 ejs body-parser
Create the project structure:
mkdir models repositories controllers routes views publicStep 2: Create Sequelize Models
Create a file for each model in the models directory. Below are the models based on your SQL schema.
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;
Role Model (models/Role.js):
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;
Patient Model (models/Patient.js):
const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const Patient = sequelize.define('Patient', {
PatientId: {
type: DataTypes.INTEGER,
primaryKey: true,
autoIncrement: true,
},
FirstName: {
type: DataTypes.STRING(50),
allowNull: false,
},
LastName: {
type: DataTypes.STRING(50),
allowNull: false,
},
DateOfBirth: {
type: DataTypes.DATE,
allowNull: false,
},
Gender: {
type: DataTypes.STRING(10),
},
Phone: {
type: DataTypes.STRING(15),
},
Email: {
type: DataTypes.STRING(100),
unique: true,
},
Address: {
type: DataTypes.STRING(255),
},
CreatedAt: {
type: DataTypes.DATE,
defaultValue: DataTypes.NOW,
},
UpdatedAt: {
type: DataTypes.DATE,
defaultValue: DataTypes.NOW,
},
});
module.exports = Patient;
Doctor Model (models/Doctor.js):
const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const Doctor = sequelize.define('Doctor', {
DoctorId: {
type: DataTypes.INTEGER,
primaryKey: true,
autoIncrement: true,
},
FirstName: {
type: DataTypes.STRING(50),
allowNull: false,
},
LastName: {
type: DataTypes.STRING(50),
allowNull: false,
},
Specialty: {
type: DataTypes.STRING(100),
},
Phone: {
type: DataTypes.STRING(15),
},
Email: {
type: DataTypes.STRING(100),
unique: true,
},
CreatedAt: {
type: DataTypes.DATE,
defaultValue: DataTypes.NOW,
},
UpdatedAt: {
type: DataTypes.DATE,
defaultValue: DataTypes.NOW,
},
});
module.exports = Doctor;
Appointment Model (models/Appointment.js):
const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const Appointment = sequelize.define('Appointment', {
AppointmentId: {
type: DataTypes.INTEGER,
primaryKey: true,
autoIncrement: true,
},
PatientId: {
type: DataTypes.INTEGER,
allowNull: false,
},
DoctorId: {
type: DataTypes.INTEGER,
allowNull: false,
},
AppointmentDate: {
type: DataTypes.DATE,
allowNull: false,
},
Status: {
type: DataTypes.STRING(20),
default Value: 'Scheduled',
},
CreatedAt: {
type: DataTypes.DATE,
defaultValue: DataTypes.NOW,
},
UpdatedAt: {
type: DataTypes.DATE,
defaultValue: DataTypes.NOW,
},
});
module.exports = Appointment;
Invoice Model (models/Invoice.js):
const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const Invoice = sequelize.define('Invoice', {
InvoiceId: {
type: DataTypes.INTEGER,
primaryKey: true,
autoIncrement: true,
},
PatientId: {
type: DataTypes.INTEGER,
allowNull: false,
},
TotalAmount: {
type: DataTypes.DECIMAL(10, 2),
allowNull: false,
},
CreatedAt: {
type: DataTypes.DATE,
defaultValue: DataTypes.NOW,
},
UpdatedAt: {
type: DataTypes.DATE,
defaultValue: DataTypes.NOW,
},
});
module.exports = Invoice;
Payment Model (models/Payment.js):
const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const Payment = sequelize.define('Payment', {
PaymentId: {
type: DataTypes.INTEGER,
primaryKey: true,
autoIncrement: true,
},
InvoiceId: {
type: DataTypes.INTEGER,
allowNull: false,
},
PaymentDate: {
type: DataTypes.DATE,
defaultValue: DataTypes.NOW,
},
Amount: {
type: DataTypes.DECIMAL(10, 2),
allowNull: false,
},
PaymentMethod: {
type: DataTypes.STRING(50),
},
Status: {
type: DataTypes.STRING(20),
defaultValue: 'Pending',
},
});
module.exports = Payment;
InventoryItem Model (models/InventoryItem.js):
const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const InventoryItem = sequelize.define('InventoryItem', {
ItemId: {
type: DataTypes.INTEGER,
primaryKey: true,
autoIncrement: true,
},
ItemName: {
type: DataTypes.STRING(100),
allowNull: false,
},
Quantity: {
type: DataTypes.INTEGER,
allowNull: false,
},
UnitPrice: {
type: DataTypes.DECIMAL(10, 2),
allowNull: false,
},
CreatedAt: {
type: DataTypes.DATE,
defaultValue: DataTypes.NOW,
},
UpdatedAt: {
type: DataTypes.DATE,
defaultValue: DataTypes.NOW,
},
});
module.exports = InventoryItem;
LabTest Model (models/LabTest.js):
const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const LabTest = sequelize.define('LabTest', {
LabTestId: {
type: DataTypes.INTEGER,
primaryKey: true,
autoIncrement: true,
},
TestName: {
type: DataTypes.STRING(100),
allowNull: false,
},
Description: {
type: DataTypes.TEXT,
},
Price: {
type: DataTypes.DECIMAL(10, 2),
allowNull: false,
},
CreatedAt: {
type: DataTypes.DATE,
defaultValue: DataTypes.NOW,
},
UpdatedAt: {
type: DataTypes.DATE,
defaultValue: DataTypes.NOW,
},
});
module.exports = LabTest;
Prescription Model (models/Prescription.js):
const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const Prescription = sequelize.define('Prescription', {
PrescriptionId: {
type: DataTypes.INTEGER,
primaryKey: true,
autoIncrement: true,
},
PatientId: {
type: DataTypes.INTEGER,
allowNull: false,
},
DoctorId: {
type: DataTypes.INTEGER,
allowNull: false,
},
PrescriptionDate: {
type: DataTypes.DATE,
defaultValue: DataTypes.NOW,
},
CreatedAt: {
type: DataTypes.DATE,
defaultValue: DataTypes.NOW,
},
UpdatedAt: {
type: DataTypes.DATE,
defaultValue: DataTypes.NOW,
},
});
module.exports = Prescription;
Report Model (models/Report.js):
const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const Report = sequelize.define('Report', {
ReportId: {
type: DataTypes.INTEGER,
primaryKey: true,
autoIncrement: true,
},
PatientId: {
type: DataTypes.INTEGER,
allowNull: false,
},
ReportDate: {
type: DataTypes.DATE,
defaultValue: DataTypes.NOW,
},
Description: {
type: DataTypes.TEXT,
},
CreatedAt: {
type: DataTypes.DATE,
defaultValue: DataTypes.NOW,
},
UpdatedAt: {
type: DataTypes.DATE,
defaultValue: DataTypes.NOW,
},
});
module.exports = Report;
Message Model (models/Message.js):
const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const Message = sequelize.define('Message', {
MessageId: {
type: DataTypes.INTEGER,
primaryKey: true,
autoIncrement: true,
},
SenderId: {
type: DataTypes.INTEGER,
allowNull: false,
},
ReceiverId: {
type: DataTypes.INTEGER,
allowNull: false,
},
MessageText: {
type: DataTypes.TEXT,
},
SentAt: {
type: DataTypes.DATE,
defaultValue: DataTypes.NOW,
},
});
module.exports = Message;
EmergencyContact Model (models/EmergencyContact.js):
const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const EmergencyContact = sequelize.define('EmergencyContact', {
EmergencyContactId: {
type: DataTypes.INTEGER,
primaryKey: true,
autoIncrement: true,
},
PatientId: {
type: DataTypes.INTEGER,
allowNull: false,
},
ContactName: {
type: DataTypes.STRING(100),
allowNull: false,
},
Relationship: {
type: DataTypes.STRING(50),
},
Phone: {
type: DataTypes.STRING(15),
},
});
module.exports = EmergencyContact;
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;
Step 3: Create Repositories
Create a repository for each model in the repositories directory. Below is an example for the User repository.
User Repository (repositories/UserRepository.js):
const User = require('../models/User');
class UserRepository {
async findAll() {
return await User.findAll();
}
async findById(id) {
return await User.findByPk(id);
}
async create(userData) {
return await User.create(userData);
}
async update(id, userData) {
const user = await this.findById(id);
if (user) {
return await user.update(userData);
}
return null;
}
async delete(id) {
const user = await this.findById(id);
if (user) {
await user.destroy();
return true;
}
return false;
}
}
module.exports = new UserRepository();
Step 4: Create Controllers
Create a controller for each model in the controllers directory. Below is an example for the User controller.
User Controller (controllers/UserController.js):
const UserRepository = require('../repositories/UserRepository');
class UserController {
async index(req, res) {
const users = await UserRepository.findAll();
res.render('users/index', { users });
}
async create(req, res) {
if (req.method === 'POST') {
await UserRepository.create(req.body);
res.redirect('/users');
} else {
res.render('users/create');
}
}
async edit(req, res) {
const user = await UserRepository.findById(req.params.id);
if (req.method === 'POST') {
await UserRepository.update(req.params .id, req.body);
res.redirect('/users');
} else {
res.render('users/edit', { user });
}
}
async delete(req, res) {
await UserRepository.delete(req.params.id);
res.redirect('/users');
}
}
module.exports = new UserController();
Step 5: Create Routes
Create a route for each model in the routes directory. Below is an example for the User routes.
User Routes (routes/userRoutes.js):
const express = require('express');
const router = express.Router();
const UserController = require('../controllers/UserController');
router.get('/', UserController.index);
router.get('/create', UserController.create);
router.post('/create', UserController.create);
router.get('/edit/:id', UserController.edit);
router.post('/edit/:id', UserController.edit);
router.post('/delete/:id', UserController.delete);
module.exports = router;
Step 6: Create EJS Views
Create EJS views for each model in the views directory. Below is an example for the User views.
User Index View (views/users/index.ejs):
<%- include('partials/header') %>
<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/edit/<%= user.UserId %>" class="btn btn-warning">Edit</a>
<form action="/users/delete/<%= user.UserId %>" method="POST" style="display:inline;">
<button type="submit" class="btn btn-danger">Delete</button>
</form>
</td>
</tr>
<% }) %>
</tbody>
</table>
<%- include('partials/footer') %>
User Create View (views/users/create.ejs):
<%- include('partials/header') %>
<h1>Create User</h1>
<form action="/users/create" method="POST">
<div class="mb-3">
<label for="Username" class="form-label">Username</label>
<input type="text" class="form-control" name="Username" required>
</div>
<div class="mb-3">
<label for="Email" class="form-label">Email</label>
<input type="email" class="form-control" name="Email" required>
</div>
<div class="mb-3">
<label for="PasswordHash" class="form-label">Password</label>
<input type="password" class="form-control" name="PasswordHash" required>
</div>
<button type="submit" class="btn btn-primary">Create</button>
</form>
<%- include('partials/footer') %>
User Edit View (views/users/edit.ejs):
<%- include('partials/header') %>
<h1>Edit User</h1>
<form action="/users/edit/<%= user.UserId %>" method="POST">
<div class="mb-3">
<label for="Username" class="form-label">Username</label>
<input type="text" class="form-control" name="Username" value="<%= user.Username %>" required>
</div>
<div class="mb-3">
<label for="Email" class="form-label">Email</label>
<input type="email" class="form-control" name="Email" value="<%= user.Email %>" required>
</div>
<button type="submit" class="btn btn-primary">Update</button>
</form>
<%- include('partials/footer') %>
Step 7: Set Up the Main Application File
Set up the main application file to include the necessary middleware and routes.
Main Application File (app.js):
const express = require('express');
const bodyParser = require('body-parser');
const path = require('path');
const userRoutes = require('./routes/userRoutes');
const app = express();
app.set('view engine', 'ejs');
app.set('views', path.join(__dirname, 'views'));
app.use(bodyParser.urlencoded({ extended: true }));
app.use(express.static(path.join(__dirname, 'public')));
app.use('/users', userRoutes);
const PORT = process.env.PORT || 3000;
app .listen(PORT, () => {
console.log(`Server is running on http://localhost:${PORT}`);
});
Step 8: Run the Application
Create the database and tables using Sequelize: Ensure you have a config.js file to configure Sequelize with your MySQL database credentials.
Run the application:
node app.js
Access the User Management: Open your browser and navigate to http://localhost:3000/users to view the user management interface.
You now have a complete CRUD application for managing users in a healthcare management system using Node.js, Sequelize, Express, and EJS with Bootstrap 5 templates. You can replicate the same structure for other models like Patients, Doctors, Appointments, etc., by following the same steps for creating models, repositories, controllers, routes, and views.
Following are the complete setup for the remaining models (Patients, Doctors, Appointments, Invoices, Payments, InventoryItems, LabTests, Prescriptions, Reports, Messages, EmergencyContacts, Feedbacks) including their Sequelize models, repositories, controllers, routes, and EJS views.
Step 1: Create Remaining Models
Patient Model (models/Patient.js):
const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const Patient = sequelize.define('Patient', {
PatientId: {
type: DataTypes.INTEGER,
primaryKey: true,
autoIncrement: true,
},
FirstName: {
type: DataTypes.STRING(50),
allowNull: false,
},
LastName: {
type: DataTypes.STRING(50),
allowNull: false,
},
DateOfBirth: {
type: DataTypes.DATE,
allowNull: false,
},
Gender: {
type: DataTypes.STRING(10),
},
Phone: {
type: DataTypes.STRING(15),
},
Email: {
type: DataTypes.STRING(100),
unique: true,
},
Address: {
type: DataTypes.STRING(255),
},
CreatedAt: {
type: DataTypes.DATE,
defaultValue: DataTypes.NOW,
},
UpdatedAt: {
type: DataTypes.DATE,
defaultValue: DataTypes.NOW,
},
});
module.exports = Patient;
Doctor Model (models/Doctor.js):
const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const Doctor = sequelize.define('Doctor', {
DoctorId: {
type: DataTypes.INTEGER,
primaryKey: true,
autoIncrement: true,
},
FirstName: {
type: DataTypes.STRING(50),
allowNull: false,
},
LastName: {
type: DataTypes.STRING(50),
allowNull: false,
},
Specialty: {
type: DataTypes.STRING(100),
},
Phone: {
type: DataTypes.STRING(15),
},
Email: {
type: DataTypes.STRING(100),
unique: true,
},
CreatedAt: {
type: DataTypes.DATE,
defaultValue: DataTypes.NOW,
},
UpdatedAt: {
type: DataTypes.DATE,
defaultValue: DataTypes.NOW,
},
});
module.exports = Doctor;
Appointment Model (models/Appointment.js):
const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const Appointment = sequelize.define('Appointment', {
AppointmentId: {
type: DataTypes.INTEGER,
primaryKey: true,
autoIncrement: true,
},
PatientId: {
type: DataTypes.INTEGER,
allowNull: false,
},
DoctorId: {
type: DataTypes.INTEGER,
allowNull: false,
},
AppointmentDate: {
type: DataTypes.DATE,
allowNull: false,
},
Status: {
type: DataTypes.STRING(20),
defaultValue: 'Scheduled',
},
CreatedAt: {
type: DataTypes.DATE,
defaultValue: DataTypes.NOW,
},
UpdatedAt: {
type: DataTypes.DATE,
defaultValue: DataTypes.NOW,
},
});
module.exports = Appointment;
Invoice Model (models/Invoice.js):
const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const Invoice = sequelize.define('Invoice', {
InvoiceId: {
type: DataTypes.INTEGER,
primaryKey: true,
autoIncrement: true,
},
PatientId: {
type: DataTypes.INTEGER,
allowNull: false,
},
TotalAmount: {
type: DataTypes.DECIMAL(10, 2),
allowNull: false,
},
CreatedAt: {
type: DataTypes.DATE,
defaultValue: DataTypes.NOW,
},
UpdatedAt: {
type: DataTypes.DATE,
defaultValue: DataTypes.NOW,
},
});
module.exports = Invoice;
Payment Model (models/Payment.js):
const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const Payment = sequelize.define('Payment', {
PaymentId: {
type: DataTypes.INTEGER,
primaryKey: true,
autoIncrement: true,
},
InvoiceId: {
type: DataTypes.INTEGER,
allowNull: false,
},
PaymentDate: {
type: DataTypes.DATE,
defaultValue: DataTypes.NOW,
},
Amount: {
type: DataTypes.DECIMAL(10, 2),
allowNull: false,
},
PaymentMethod: {
type: DataTypes.STRING(50),
},
Status: {
type: DataTypes.STRING(20),
defaultValue: 'Pending',
},
});
module.exports = Payment;
InventoryItem Model (models/InventoryItem.js):
const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const InventoryItem = sequelize.define('InventoryItem', {
ItemId: {
type: DataTypes.INTEGER,
primaryKey: true, autoIncrement: true, }, ItemName: { type: DataTypes.STRING(100), allowNull: false, }, Quantity: { type: DataTypes.INTEGER, allowNull: false, }, UnitPrice: { type: DataTypes.DECIMAL(10, 2), allowNull: false, }, CreatedAt: { type: DataTypes.DATE, defaultValue: DataTypes.NOW, }, UpdatedAt: { type: DataTypes.DATE, defaultValue: DataTypes.NOW, }, });
module.exports = InventoryItem;
LabTest Model (models/LabTest.js):
const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const LabTest = sequelize.define('LabTest', {
LabTestId: {
type: DataTypes.INTEGER,
primaryKey: true,
autoIncrement: true,
},
TestName: {
type: DataTypes.STRING(100),
allowNull: false,
},
Description: {
type: DataTypes.TEXT,
},
Price: {
type: DataTypes.DECIMAL(10, 2),
allowNull: false,
},
CreatedAt: {
type: DataTypes.DATE,
defaultValue: DataTypes.NOW,
},
UpdatedAt: {
type: DataTypes.DATE,
defaultValue: DataTypes.NOW,
},
});
module.exports = LabTest;
Prescription Model (models/Prescription.js):
const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const Prescription = sequelize.define('Prescription', {
PrescriptionId: {
type: DataTypes.INTEGER,
primaryKey: true,
autoIncrement: true,
},
PatientId: {
type: DataTypes.INTEGER,
allowNull: false,
},
DoctorId: {
type: DataTypes.INTEGER,
allowNull: false,
},
PrescriptionDate: {
type: DataTypes.DATE,
defaultValue: DataTypes.NOW,
},
CreatedAt: {
type: DataTypes.DATE,
defaultValue: DataTypes.NOW,
},
UpdatedAt: {
type: DataTypes.DATE,
defaultValue: DataTypes.NOW,
},
});
module.exports = Prescription;
Report Model (models/Report.js):
const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const Report = sequelize.define('Report', {
ReportId: {
type: DataTypes.INTEGER,
primaryKey: true,
autoIncrement: true,
},
PatientId: {
type: DataTypes.INTEGER,
allowNull: false,
},
ReportDate: {
type: DataTypes.DATE,
defaultValue: DataTypes.NOW,
},
Description: {
type: DataTypes.TEXT,
},
CreatedAt: {
type: DataTypes.DATE,
defaultValue: DataTypes.NOW,
},
UpdatedAt: {
type: DataTypes.DATE,
defaultValue: DataTypes.NOW,
},
});
module.exports = Report;
Message Model (models/Message.js):
const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const Message = sequelize.define('Message', {
MessageId: {
type: DataTypes.INTEGER,
primaryKey: true,
autoIncrement: true,
},
SenderId: {
type: DataTypes.INTEGER,
allowNull: false,
},
ReceiverId: {
type: DataTypes.INTEGER,
allowNull: false,
},
MessageText: {
type: DataTypes.TEXT,
},
SentAt: {
type: DataTypes.DATE,
defaultValue: DataTypes.NOW,
},
});
module.exports = Message;
EmergencyContact Model (models/EmergencyContact.js):
const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const EmergencyContact = sequelize.define('EmergencyContact', {
EmergencyContactId: {
type: DataTypes.INTEGER,
primaryKey: true,
autoIncrement: true,
},
PatientId: {
type: DataTypes.INTEGER,
allowNull: false,
},
ContactName: {
type: DataTypes.STRING(100),
allowNull: false,
},
Relationship: {
type: DataTypes.STRING(50),
},
Phone: {
type: DataTypes.STRING(15),
},
});
module.exports = EmergencyContact;
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;
Step 2: Create Repositories for Remaining Models
Patient Repository (repositories/PatientRepository.js):
const Patient = require('../models/Patient');
class PatientRepository {
async findAll() {
return await Patient.findAll();
}
async findById(id) {
return await Patient.findByPk(id);
}
async create(patientData) {
return await Patient.create(patientData);
}
async update(id, patientData) {
const patient = await this.findById(id);
if (patient) {
return await patient.update(patientData);
}
return null;
}
async delete(id) {
const patient = await this.findById(id);
if (patient) {
await patient.destroy();
return true;
}
return false;
}
}
module.exports = new PatientRepository();
Doctor Repository (repositories/DoctorRepository.js):
const Doctor = require('../models/Doctor');
class DoctorRepository {
async findAll() {
return await Doctor.findAll();
}
async findById(id) {
return await Doctor.findByPk(id);
}
async create(doctorData) {
return await Doctor.create(doctorData);
}
async update(id, doctorData) {
const doctor = await this.findById(id);
if (doctor) {
return await doctor.update(doctorData);
}
return null;
}
async delete(id) {
const doctor = await this.findById(id);
if (doctor) {
await doctor.destroy();
return true;
}
return false;
}
}
module.exports = new DoctorRepository();
Appointment Repository (repositories/AppointmentRepository.js):
const Appointment = require('../models/Appointment');
class AppointmentRepository {
async findAll() {
return await Appointment.findAll();
}
async findById(id) {
return await Appointment.findByPk(id);
}
async create(appointmentData) {
return await Appointment.create(appointmentData);
}
async update(id, appointmentData) {
const appointment = await this.findById(id);
if (appointment) {
return await appointment.update(appointmentData);
}
return null;
}
async delete(id) {
const appointment = await this.findById(id);
if (appointment) {
await appointment.destroy();
return true;
}
return false;
}
}
module.exports = new AppointmentRepository();
Invoice Repository (repositories/InvoiceRepository.js):
const Invoice = require('../models/Invoice');
class InvoiceRepository {
async findAll() {
return await Invoice.findAll();
}
async findById(id) {
return await Invoice.findByPk(id);
}
async create(invoiceData) {
return await Invoice.create(invoiceData);
}
async update(id, invoiceData) {
const invoice = await this.findById(id);
if (invoice) {
return await invoice.update(invoiceData);
}
return null;
}
async delete(id) {
const invoice = await this.findById(id);
if (invoice) {
await invoice.destroy();
return true;
}
return false;
}
}
module.exports = new InvoiceRepository();
Payment Repository (repositories/PaymentRepository.js):
const Payment = require('../models/Payment');
class PaymentRepository {
async findAll() {
return await Payment.findAll();
}
async findById(id) {
return await Payment.findByPk(id);
}
async create(paymentData) {
return await Payment.create(paymentData);
}
async update(id, paymentData) {
const payment = await this.findById(id);
if (payment ) {
return await payment.update(paymentData);
}
return null;
}
async delete(id) {
const payment = await this.findById(id);
if (payment) {
await payment.destroy();
return true;
}
return false;
}
}
module.exports = new PaymentRepository();
InventoryItem Repository (repositories/InventoryItemRepository.js):
const InventoryItem = require('../models/InventoryItem');
class InventoryItemRepository {
async findAll() {
return await InventoryItem.findAll();
}
async findById(id) {
return await InventoryItem.findByPk(id);
}
async create(itemData) {
return await InventoryItem.create(itemData);
}
async update(id, itemData) {
const item = await this.findById(id);
if (item) {
return await item.update(itemData);
}
return null;
}
async delete(id) {
const item = await this.findById(id);
if (item) {
await item.destroy();
return true;
}
return false;
}
}
module.exports = new InventoryItemRepository();
LabTest Repository (repositories/LabTestRepository.js):
const LabTest = require('../models/LabTest');
class LabTestRepository {
async findAll() {
return await LabTest.findAll();
}
async findById(id) {
return await LabTest.findByPk(id);
}
async create(testData) {
return await LabTest.create(testData);
}
async update(id, testData) {
const test = await this.findById(id);
if (test) {
return await test.update(testData);
}
return null;
}
async delete(id) {
const test = await this.findById(id);
if (test) {
await test.destroy();
return true;
}
return false;
}
}
module.exports = new LabTestRepository();
Prescription Repository (repositories/PrescriptionRepository.js):
const Prescription = require('../models/Prescription');
class PrescriptionRepository {
async findAll() {
return await Prescription.findAll();
}
async findById(id) {
return await Prescription.findByPk(id);
}
async create(prescriptionData) {
return await Prescription.create(prescriptionData);
}
async update(id, prescriptionData) {
const prescription = await this.findById(id);
if (prescription) {
return await prescription.update(prescriptionData);
}
return null;
}
async delete(id) {
const prescription = await this.findById(id);
if (prescription) {
await prescription.destroy();
return true;
}
return false;
}
}
module.exports = new PrescriptionRepository();
Report Repository (repositories/ReportRepository.js):
const Report = require('../models/Report');
class ReportRepository {
async findAll() {
return await Report.findAll();
}
async findById(id) {
return await Report.findByPk(id);
}
async create(reportData) {
return await Report.create(reportData);
}
async update(id, reportData) {
const report = await this.findById(id);
if (report) {
return await report.update(reportData);
}
return null;
}
async delete(id) {
const report = await this.findById(id);
if (report) {
await report.destroy();
return true;
}
return false;
}
}
module.exports = new ReportRepository();
Message Repository (repositories/MessageRepository.js):
const Message = require('../models/Message');
class MessageRepository {
async findAll() {
return await Message.findAll();
}
async findById(id) {
return await Message.findByPk(id);
}
async create(messageData) {
return await Message.create(messageData);
}
async update(id, messageData) {
const message = await this.findById(id);
if (message) {
return await message.update(messageData);
}
return null;
}
async delete(id) {
const message = await this.findById(id);
if (message) {
await message.destroy();
return true;
}
return false;
}
}
module.exports = new MessageRepository();
EmergencyContact Repository (repositories/EmergencyContactRepository.js):
const EmergencyContact = require('../models/Emergency Contact');
class EmergencyContactRepository {
async findAll() {
return await EmergencyContact.findAll();
}
async findById(id) {
return await EmergencyContact.findByPk(id);
}
async create(contactData) {
return await EmergencyContact.create(contactData);
}
async update(id, contactData) {
const contact = await this.findById(id);
if (contact) {
return await contact.update(contactData);
}
return null;
}
async delete(id) {
const contact = await this.findById(id);
if (contact) {
await contact.destroy();
return true;
}
return false;
}
}
module.exports = new EmergencyContactRepository();
Feedback Repository (repositories/FeedbackRepository.js):
const Feedback = require('../models/Feedback');
class FeedbackRepository {
async findAll() {
return await Feedback.findAll();
}
async findById(id) {
return await Feedback.findByPk(id);
}
async create(feedbackData) {
return await Feedback.create(feedbackData);
}
async update(id, feedbackData) {
const feedback = await this.findById(id);
if (feedback) {
return await feedback.update(feedbackData);
}
return null;
}
async delete(id) {
const feedback = await this.findById(id);
if (feedback) {
await feedback.destroy();
return true;
}
return false;
}
}
module.exports = new FeedbackRepository();
Step 3: Create Controllers for Remaining Models
Patient Controller (controllers/PatientController.js):
const PatientRepository = require('../repositories/PatientRepository');
class PatientController {
async index(req, res) {
const patients = await PatientRepository.findAll();
res.render('patients/index', { patients });
}
async create(req, res) {
if (req.method === 'POST') {
await PatientRepository.create(req.body);
res.redirect('/patients');
} else {
res.render('patients/create');
}
}
async edit(req, res) {
const patient = await PatientRepository.findById(req.params.id);
if (req.method === 'POST') {
await PatientRepository.update(req.params.id, req.body);
res.redirect('/patients');
} else {
res.render('patients/edit', { patient });
}
}
async delete(req, res) {
await PatientRepository.delete(req.params.id);
res.redirect('/patients');
}
}
module.exports = new PatientController();
Doctor Controller (controllers/DoctorController.js):
const DoctorRepository = require('../repositories/DoctorRepository');
class DoctorController {
async index(req, res) {
const doctors = await DoctorRepository.findAll();
res.render('doctors/index', { doctors });
}
async create(req, res) {
if (req.method === 'POST') {
await DoctorRepository.create(req.body);
res.redirect('/doctors');
} else {
res.render('doctors/create');
}
}
async edit(req, res) {
const doctor = await DoctorRepository.findById(req.params.id);
if (req.method === 'POST') {
await DoctorRepository.update(req.params.id, req.body);
res.redirect('/doctors');
} else {
res.render('doctors/edit', { doctor });
}
}
async delete(req, res) {
await DoctorRepository.delete(req.params.id);
res.redirect('/doctors');
}
}
module.exports = new DoctorController();
Appointment Controller (controllers/AppointmentController.js):
const AppointmentRepository = require('../repositories/AppointmentRepository');
class AppointmentController {
async index(req, res) {
const appointments = await AppointmentRepository.findAll();
res.render('appointments/index', { appointments });
}
async create(req, res) {
if (req.method === 'POST') {
await AppointmentRepository.create(req.body);
res.redirect('/appointments');
} else {
res.render('appointments/create');
}
}
async edit(req, res) {
const appointment = await AppointmentRepository.findById(req.params.id);
if (req.method === 'POST') {
await AppointmentRepository.update(req.params.id, req.body);
res.redirect('/appointments');
} else {
res.render('appointments/edit', { appointment });
}
}
async delete(req, res) {
await AppointmentRepository.delete(req.params.id);
res.redirect('/appointments');
}
}
module.exports = new AppointmentController();
Invoice Controller (controllers/InvoiceController.js):
const InvoiceRepository = require('../repositories/InvoiceRepository');
class InvoiceController { async index(req, res) { const invoices = await InvoiceRepository.findAll(); res.render('invoices/index', { invoices }); }
async create(req, res) {
if (req.method === 'POST') {
await InvoiceRepository.create(req.body);
res.redirect('/invoices');
} else {
res.render('invoices/create');
}
}
async edit(req, res) {
const invoice = await InvoiceRepository.findById(req.params.id);
if (req.method === 'POST') {
await InvoiceRepository.update(req.params.id, req.body);
res.redirect('/invoices');
} else {
res.render('invoices/edit', { invoice });
}
}
async delete(req, res) {
await InvoiceRepository.delete(req.params.id);
res.redirect('/invoices');
}
}
module.exports = new InvoiceController();
Payment Controller (controllers/PaymentController.js):
const PaymentRepository = require('../repositories/PaymentRepository');
class PaymentController {
async index(req, res) {
const payments = await PaymentRepository.findAll();
res.render('payments/index', { payments });
}
async create(req, res) {
if (req.method === 'POST') {
await PaymentRepository.create(req.body);
res.redirect('/payments');
} else {
res.render('payments/create');
}
}
async edit(req, res) {
const payment = await PaymentRepository.findById(req.params.id);
if (req.method === 'POST') {
await PaymentRepository.update(req.params.id, req.body);
res.redirect('/payments');
} else {
res.render('payments/edit', { payment });
}
}
async delete(req, res) {
await PaymentRepository.delete(req.params.id);
res.redirect('/payments');
}
}
module.exports = new PaymentController();
InventoryItem Controller (controllers/InventoryItemController.js):
const InventoryItemRepository = require('../repositories/InventoryItemRepository');
class InventoryItemController {
async index(req, res) {
const items = await InventoryItemRepository.findAll();
res.render('inventoryItems/index', { items });
}
async create(req, res) {
if (req.method === 'POST') {
await InventoryItemRepository.create(req.body);
res.redirect('/inventoryItems');
} else {
res.render('inventoryItems/create');
}
}
async edit(req, res) {
const item = await InventoryItemRepository.findById(req.params.id);
if (req.method === 'POST') {
await InventoryItemRepository.update(req.params.id, req.body);
res.redirect('/inventoryItems');
} else {
res.render('inventoryItems/edit', { item });
}
}
async delete(req, res) {
await InventoryItemRepository.delete(req.params.id);
res.redirect('/inventoryItems');
}
}
module.exports = new InventoryItemController();
LabTest Controller (controllers/LabTestController.js):
const LabTestRepository = require('../repositories/LabTestRepository');
class LabTestController {
async index(req, res) {
const tests = await LabTestRepository.findAll();
res.render('labTests/index', { tests });
}
async create(req, res) {
if (req.method === 'POST') {
await LabTestRepository.create(req.body);
res.redirect('/labTests');
} else {
res.render('labTests/create');
}
}
async edit(req, res) {
const test = await LabTestRepository.findById(req.params.id);
if (req.method === 'POST') {
await LabTestRepository.update(req.params.id, req.body);
res.redirect('/labTests');
} else {
res.render('labTests/edit', { test });
}
}
async delete(req, res) {
await LabTestRepository.delete(req.params.id);
res.redirect('/labTests');
}
}
module.exports = new LabTestController();
Prescription Controller (controllers/PrescriptionController.js):
const PrescriptionRepository = require('../repositories/PrescriptionRepository');
class PrescriptionController {
async index(req, res) {
const prescriptions = await PrescriptionRepository.findAll();
res.render('prescriptions/index', { prescriptions });
}
async create(req, res) {
if (req.method === 'POST') {
await PrescriptionRepository.create(req.body);
res.redirect('/prescriptions');
} else {
res.render('prescriptions/create');
}
}
async edit(req, res) {
const prescription = await PrescriptionRepository.findById(req.params.id);
if (req.method === 'POST') {
await PrescriptionRepository.update(req .params.id, req.body);
res.redirect('/prescriptions');
} else {
res.render('prescriptions/edit', { prescription });
}
}
async delete(req, res) {
await PrescriptionRepository.delete(req.params.id);
res.redirect('/prescriptions');
}
}
module.exports = new PrescriptionController();
Report Controller (controllers/ReportController.js):
const ReportRepository = require('../repositories/ReportRepository');
class ReportController {
async index(req, res) {
const reports = await ReportRepository.findAll();
res.render('reports/index', { reports });
}
async create(req, res) {
if (req.method === 'POST') {
await ReportRepository.create(req.body);
res.redirect('/reports');
} else {
res.render('reports/create');
}
}
async edit(req, res) {
const report = await ReportRepository.findById(req.params.id);
if (req.method === 'POST') {
await ReportRepository.update(req.params.id, req.body);
res.redirect('/reports');
} else {
res.render('reports/edit', { report });
}
}
async delete(req, res) {
await ReportRepository.delete(req.params.id);
res.redirect('/reports');
}
}
module.exports = new ReportController();
Message Controller (controllers/MessageController.js):
const MessageRepository = require('../repositories/MessageRepository');
class MessageController {
async index(req, res) {
const messages = await MessageRepository.findAll();
res.render('messages/index', { messages });
}
async create(req, res) {
if (req.method === 'POST') {
await MessageRepository.create(req.body);
res.redirect('/messages');
} else {
res.render('messages/create');
}
}
async edit(req, res) {
const message = await MessageRepository.findById(req.params.id);
if (req.method === 'POST') {
await MessageRepository.update(req.params.id, req.body);
res.redirect('/messages');
} else {
res.render('messages/edit', { message });
}
}
async delete(req, res) {
await MessageRepository.delete(req.params.id);
res.redirect('/messages');
}
}
module.exports = new MessageController();
EmergencyContact Controller (controllers/EmergencyContactController.js):
const EmergencyContactRepository = require('../repositories/EmergencyContactRepository');
class EmergencyContactController {
async index(req, res) {
const contacts = await EmergencyContactRepository.findAll();
res.render('emergencyContacts/index', { contacts });
}
async create(req, res) {
if (req.method === 'POST') {
await EmergencyContactRepository.create(req.body);
res.redirect('/emergencyContacts');
} else {
res.render('emergencyContacts/create');
}
}
async edit(req, res) {
const contact = await EmergencyContactRepository.findById(req.params.id);
if (req.method === 'POST') {
await EmergencyContactRepository.update(req.params.id, req.body);
res.redirect('/emergencyContacts');
} else {
res.render('emergencyContacts/edit', { contact });
}
}
async delete(req, res) {
await EmergencyContactRepository.delete(req.params.id);
res.redirect('/emergencyContacts');
}
}
module.exports = new EmergencyContactController();
Feedback Controller (controllers/FeedbackController.js):
const FeedbackRepository = require('../repositories/FeedbackRepository');
class FeedbackController {
async index(req, res) {
const feedbacks = await FeedbackRepository.findAll();
res.render('feedbacks/index', { feedbacks });
}
async create(req, res) {
if (req.method === 'POST') {
await FeedbackRepository.create(req.body);
res.redirect('/feedbacks');
} else {
res.render('feedbacks/create');
}
}
async edit(req, res) {
const feedback = await FeedbackRepository.findById(req.params.id);
if (req.method === 'POST') {
await FeedbackRepository.update(req.params.id, req.body);
res.redirect('/feedbacks');
} else {
res.render('feedbacks/edit', { feedback });
}
}
async delete(req, res) {
await FeedbackRepository.delete(req.params.id);
res.redirect('/feedbacks');
}
}
module.exports = new FeedbackController();
Step 4: Create Routes for Remaining Models
Patient Routes (routes/patientRoutes.js):
const express = require('express');
const router = express.Router();
const PatientController = require('../controllers/PatientController');
router.get('/', PatientController.index);
router.get('/create', PatientController.create);
router.post('/create', PatientController .create);
router.get('/edit/:id', PatientController.edit);
router.post('/edit/:id', PatientController.edit);
router.post('/delete/:id', PatientController.delete);
module.exports = router;
Doctor Routes (routes/doctorRoutes.js):
const express = require('express');
const router = express.Router();
const DoctorController = require('../controllers/DoctorController');
router.get('/', DoctorController.index);
router.get('/create', DoctorController.create);
router.post('/create', DoctorController.create);
router.get('/edit/:id', DoctorController.edit);
router.post('/edit/:id', DoctorController.edit);
router.post('/delete/:id', DoctorController.delete);
module.exports = router;
Appointment Routes (routes/appointmentRoutes.js):
const express = require('express');
const router = express.Router();
const AppointmentController = require('../controllers/AppointmentController');
router.get('/', AppointmentController.index);
router.get('/create', AppointmentController.create);
router.post('/create', AppointmentController.create);
router.get('/edit/:id', AppointmentController.edit);
router.post('/edit/:id', AppointmentController.edit);
router.post('/delete/:id', AppointmentController.delete);
module.exports = router;
Invoice Routes (routes/invoiceRoutes.js):
const express = require('express');
const router = express.Router();
const InvoiceController = require('../controllers/InvoiceController');
router.get('/', InvoiceController.index);
router.get('/create', InvoiceController.create);
router.post('/create', InvoiceController.create);
router.get('/edit/:id', InvoiceController.edit);
router.post('/edit/:id', InvoiceController.edit);
router.post('/delete/:id', InvoiceController.delete);
module.exports = router;
Payment Routes (routes/paymentRoutes.js):
const express = require('express');
const router = express.Router();
const PaymentController = require('../controllers/PaymentController');
router.get('/', PaymentController.index);
router.get('/create', PaymentController.create);
router.post('/create', PaymentController.create);
router.get('/edit/:id', PaymentController.edit);
router.post('/edit/:id', PaymentController.edit);
router.post('/delete/:id', PaymentController.delete);
module.exports = router;
InventoryItem Routes (routes/inventoryItemRoutes.js):
const express = require('express');
const router = express.Router();
const InventoryItemController = require('../controllers/InventoryItemController');
router.get('/', InventoryItemController.index);
router.get('/create', InventoryItemController.create);
router.post('/create', InventoryItemController.create);
router.get('/edit/:id', InventoryItemController.edit);
router.post('/edit/:id', InventoryItemController.edit);
router.post('/delete/:id', InventoryItemController.delete);
module.exports = router;
LabTest Routes (routes/labTestRoutes.js):
const express = require('express');
const router = express.Router();
const LabTestController = require('../controllers/LabTestController');
router.get('/', LabTestController.index);
router.get('/create', LabTestController.create);
router.post('/create', LabTestController.create);
router.get('/edit/:id', LabTestController.edit);
router.post('/edit/:id', LabTestController.edit);
router.post('/delete/:id', LabTestController.delete);
module.exports = router;
Prescription Routes (routes/prescriptionRoutes.js):
const express = require('express');
const router = express.Router();
const PrescriptionController = require('../controllers/PrescriptionController');
router.get('/', PrescriptionController.index);
router.get('/create', PrescriptionController.create);
router.post('/create', PrescriptionController.create);
router.get('/edit/:id', PrescriptionController.edit);
router.post('/edit/:id', PrescriptionController.edit);
router.post('/delete/:id', PrescriptionController.delete);
module.exports = router;
Report Routes (routes/reportRoutes.js):
const express = require('express');
const router = express.Router();
const ReportController = require('../controllers/ReportController');
router.get('/', ReportController.index);
router.get('/create', ReportController.create);
router.post('/create', ReportController.create);
router.get('/edit/:id', ReportController.edit);
router.post('/edit/:id', ReportController.edit);
router.post('/delete/:id', ReportController.delete);
module.exports = router;
Message Routes (routes/messageRoutes.js):
const express = require('express');
const router = express.Router();
const MessageController = require('../controllers/MessageController');
router.get('/', MessageController.index);
router.get('/create', MessageController.create);
router.post('/create', MessageController.create);
router.get('/edit/:id', MessageController.edit);
router.post('/edit/:id', MessageController.edit);
router.post('/delete/:id', MessageController.delete);
module.exports = router;
EmergencyContact Routes (routes/emergencyContactRoutes.js):
const express = require('express');
const router = express.Router();
const EmergencyContactController = require('../controllers/EmergencyContactController');
router.get('/', EmergencyContactController.index);
router.get('/create', EmergencyContactController.create);
router.post('/create', EmergencyContactController.create);
router.get('/edit/:id', EmergencyContactController.edit);
router.post('/edit/:id', EmergencyContactController.edit);
router.post('/delete/:id', EmergencyContactController.delete);
module.exports = router;
Feedback Routes (routes/feedbackRoutes.js):
const express = require('express');
const router = express.Router();
const FeedbackController = require('../controllers/FeedbackController');
router.get('/', FeedbackController.index);
router.get('/create', FeedbackController.create);
router.post('/create', FeedbackController.create);
router.get('/edit/:id', FeedbackController.edit);
router.post('/edit/:id', FeedbackController.edit);
router.post('/delete/:id', FeedbackController.delete);
module.exports = router;
Step 5: Create EJS Views for Remaining Models
Patient Views:
Index View (views/patients/index.ejs):
<%- include('partials/header') %>
<h1>Patients</h1>
<a href="/patients/create" class="btn btn-primary">Create Patient</a>
<table class="table">
<thead>
<tr>
<th>First Name</th>
<th>Last Name</th>
<th>Email</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
<% patients.forEach(patient => { %>
<tr>
<td><%= patient.FirstName %></td>
<td><%= patient.LastName %></td>
<td><%= patient.Email %></td>
<td>
<a href="/patients/edit/<%= patient.PatientId %>" class="btn btn-warning">Edit</a>
<form action="/patients/delete/<%= patient.PatientId %>" method="POST" style="display:inline;">
<button type="submit" class="btn btn-danger">Delete</button>
</form>
</td>
</tr>
<% }) %>
</tbody>
</table>
<%- include('partials/footer') %>
Create View (views/patients/create.ejs):
<%- include('partials/header') %>
<h1>Create Patient</h1>
<form action="/patients/create" method="POST">
<div class="mb-3">
<label for="FirstName" class="form-label">First Name</label>
<input type="text" class="form-control" name="FirstName" required>
</div>
<div class="mb-3">
<label for="LastName" class="form-label">Last Name</label>
<input type="text" class="form-control" name="LastName" required>
</div>
<div class="mb-3">
<label for="Email" class="form-label">Email</label>
<input type="email" class="form-control" name="Email" required>
</div>
<button type="submit" class="btn btn-primary">Create</button>
</form>
<%- include('partials/footer') %>
Edit View (views/patients/edit.ejs):
<%- include('partials/header') %>
<h1>Edit Patient</h1>
<form action="/patients/edit/<%= patient.PatientId %>" method="POST">
<div class="mb-3">
<label for="FirstName" class="form-label">First Name</label>
<input type="text" class="form-control" name="FirstName" value="<%= patient.FirstName %>" required>
</div>
<div class="mb-3">
<label for="LastName" class="form-label">Last Name</label>
<input type="text" class="form-control" name="LastName" value="<%= patient.LastName %>" required>
</div>
<div class="mb-3">
<label for="Email" class="form-label">Email</label>
<input type="email" class="form-control" name="Email" value="<%= patient.Email %>" required>
</div>
<button type="submit" class="btn btn-primary">Update</button>
</form>
<%- include('partials/footer') %>
Doctor Views:
Index View (views/doctors/index.ejs):
<%- include('partials/header') %>
<h1>Doctors</h1>
<a href="/doctors/create" class="btn btn-primary">Create Doctor</a>
<table class="table">
<thead>
<tr>
<th>First Name</th>
<th>Last Name</th>
<th>Email</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
<% doctors.forEach(doctor => { %>
<tr>
<td><%= doctor.FirstName %></td>
<td><%= doctor.LastName %></td>
<td><%= doctor.Email %></td>
<td>
<a href="/doctors/edit/<%= doctor.DoctorId %>" class="btn btn-warning">Edit</a>
<form action="/doctors/delete/<%= doctor.DoctorId %>" method="POST" style="display:inline;">
<button type="submit" class="btn btn-danger">Delete</button>
</form>
</td>
</tr>
<% }) %>
</tbody>
</table>
<%- include('partials/footer') %>
Create View (views/doctors/create.ejs):
<%- include('partials/header') %>
<h1>Create Doctor</h1>
<form action="/doctors/create" method="POST">
<div class="mb-3">
<label for="FirstName" class="form-label">First Name</label>
<input type="text" class="form-control" name="FirstName" required>
</div>
<div class="mb-3">
<label for="LastName" class="form-label">Last Name</label>
<input type="text" class="form-control" name="LastName" required>
</div>
<div class="mb-3">
<label for="Email" class="form-label">Email</label>
<input type="email" class="form-control" name="Email" required>
</div>
<button type="submit" class="btn btn-primary">Create</button>
</form>
<%- include('partials/footer') %>
Edit View (views/doctors/edit.ejs):
<%- include('partials/header') %>
<h1>Edit Doctor</h1>
<form action="/doctors/edit/<%= doctor.DoctorId %>" method="POST">
<div class="mb-3">
<label for="FirstName" class="form-label">First Name</label>
<input type="text" class="form-control" name="FirstName" value="<%= doctor.FirstName %>" required>
</div>
<div class="mb-3">
<label for="LastName" class="form-label">Last Name</label>
<input type="text" class="form-control" name="LastName" value="<%= doctor.LastName %>" required>
</div>
<div class="mb-3">
<label for="Email" class="form-label">Email</label>
<input type="email" class="form-control" name="Email" value="<%= doctor.Email %>" required>
</div>
<button type="submit" class="btn btn-primary">Update</button>
</form>
<%- include('partials/footer') %>
Appointment Views:
Index View (views/appointments/index.ejs):
<%- include('partials/header') %>
<h1>Appointments</h1>
<a href="/appointments/create" class="btn btn-primary">Create Appointment</a>
<table class="table">
<thead>
<tr>
<th>Patient ID</th>
<th>Doctor ID</th>
<th>Appointment Date</th>
<th>Status</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
<% appointments.forEach(appointment => { %>
<tr>
<td><%= appointment.PatientId %></td>
<td><%= appointment.DoctorId %></td>
<td><%= appointment.AppointmentDate %></td>
<td><%= appointment.Status %></td>
<td>
<a href="/appointments/edit/<%= appointment.AppointmentId %>" class="btn btn-warning">Edit</a>
<form action="/appointments/delete/<%= appointment.AppointmentId %>" method="POST" style="display:inline;">
<button type="submit" class="btn btn-danger">Delete</button>
</form>
</td>
</tr>
<% }) %>
</tbody>
</table>
<%- include('partials/footer') %>
Create View (views/appointments/create.ejs):
<%- include('partials/header') %>
<h1>Create Appointment</h1>
<form action="/appointments/create" method="POST">
<div class="mb-3">
<label for="PatientId" class="form-label">Patient ID</label>
<input type="number" class="form-control" name="PatientId" required>
</div>
<div class="mb-3">
<label for="DoctorId" class="form-label">Doctor ID</label>
<input type="number" class="form-control" name="DoctorId" required>
</div>
<div class="mb-3">
<label for="AppointmentDate" class="form-label">Appointment Date</label>
<input type="datetime-local" class="form-control" name="AppointmentDate" required>
</div>
<button type="submit" class="btn btn-primary">Create</button>
</form>
<%- include('partials/footer') %>
Edit View (views/appointments/edit.ejs):
<%- include('partials/header') %>
<h1>Edit Appointment</h1>
<form action="/appointments/edit/<%= appointment.AppointmentId %>" method="POST">
<div class="mb-3">
<label for="PatientId" class="form-label">Patient ID</label>
<input type="number" class="form-control" name="PatientId" value="<%= appointment.PatientId %>" required>
</div>
<div class="mb-3">
<label for="DoctorId" class="form-label">Doctor ID</label>
<input type="number" class="form-control" name="DoctorId" value="<%= appointment.DoctorId %>" required>
</div>
<div class="mb-3">
<label for="AppointmentDate" class="form-label">Appointment Date</label>
<input type="datetime-local" class="form-control" name="AppointmentDate" value="<%= appointment.AppointmentDate.toISOString().slice(0, 16) %>" required>
</div>
<button type="submit" class="btn btn-primary">Update</button>
</form>
<%- include('partials/footer') %>
Invoice Views:
Index View (views/invoices/index.ejs):
<%- include('partials/header') %>
<h1>Invoices</h1>
<a href="/invoices/create" class="btn btn-primary">Create Invoice</a>
<table class="table">
<thead>
<tr>
<th>Patient ID</th>
<th>Total Amount</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
<% invoices.forEach(invoice => { %>
<tr>
<td><%= invoice.PatientId %></td>
<td><%= invoice.TotalAmount %></td>
<td>
<a href="/invoices/edit/<%= invoice.InvoiceId %>" class="btn btn-warning">Edit</a>
<form action="/invoices/delete/<%= invoice.InvoiceId %>" method="POST" style="display:inline;">
<button type="submit" class="btn btn-danger">Delete</button>
</form>
</td>
</tr>
<% }) %>
</tbody>
</table>
<%- include('partials/footer') %>
Create View (views/invoices/create.ejs):
<%- include('partials/header') %>
<h1>Create Invoice</h1>
<form action="/invoices/create" method="POST">
<div class="mb-3">
<label for="PatientId" class="form-label">Patient ID</label>
<input type="number" class="form-control" name="PatientId" required>
</div>
<div class="mb-3">
<label for="TotalAmount" class="form-label">Total Amount</label>
<input type="number" step="0.01" class="form-control" name="TotalAmount" required>
</div>
<button type="submit" class="btn btn-primary">Create</button>
</form>
<%- include('partials/footer') %>
Edit View (views/invoices/edit.ejs):
<%- include('partials/header') %>
<h1>Edit Invoice</h1>
<form action="/invoices/edit/<%= invoice.InvoiceId %>" method="POST">
<div class="mb-3">
<label for="PatientId" class="form-label">Patient ID</label>
<input type="number" class="form-control" name="PatientId" value="<%= invoice.PatientId %>" required>
</div>
<div class="mb-3">
<label for="TotalAmount" class="form-label">Total Amount</label>
<input type="number" step="0.01" class="form-control" name="TotalAmount" value="<%= invoice.TotalAmount %>" required>
</div>
<button type="submit" class="btn btn-primary">Update</button>
</form>
<%- include('partials/footer') %>
Payment Views:
Index View (views/payments/index.ejs):
<%- include('partials/header') %>
<h1>Payments</h1>
<a href="/payments/create" class="btn btn-primary">Create Payment</a>
<table class="table">
<thead>
<tr>
<th>Invoice ID</th>
<th>Amount</th>
<th>Status</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
<% payments.forEach(payment => { %>
<tr>
<td><%= payment.InvoiceId %></td>
<td><%= payment.Amount %></td>
<td><%= payment.Status %></td>
<td>
<a href="/payments/edit/<%= payment.PaymentId %>" class="btn btn-warning">Edit</a>
<form action="/payments/delete/<%= payment.PaymentId %>" method="POST" style="display:inline;">
<button type="submit" class="btn btn-danger">Delete</button>
</form>
</td>
</tr>
<% }) %>
</tbody>
</table>
<%- include('partials/footer') %>
Create View (views/payments/create.ejs):
<%- include('partials/header') %>
<h1>Create Payment</h1>
<form action="/payments/create" method="POST">
<div class="mb-3">
<label for="InvoiceId" class="form-label">Invoice ID</label>
<input type="number" class="form-control" name="InvoiceId" required>
</div>
<div class="mb-3">
<label for="Amount" class="form-label">Amount</label>
<input type="number" step="0.01" class="form-control" name="Amount" required>
</div>
<div class="mb-3">
<label for="PaymentMethod" class="form-label">Payment Method</label>
<input type="text" class="form-control" name="PaymentMethod" required>
</div>
<button type="submit" class="btn btn-primary">Create</button>
</form>
<%- include('partials/footer') %>
Edit View (views/payments/edit.ejs):
<%- include('partials/header') %>
<h1>Edit Payment</h1>
<form action="/payments/edit/<%= payment.PaymentId %>" method="POST">
<div class="mb-3">
<label for="InvoiceId" class="form-label">Invoice ID</label>
<input type="number" class="form-control" name="InvoiceId" value="<%= payment.InvoiceId %>" required>
</div>
<div class="mb-3">
<label for="Amount" class="form-label">Amount</label>
<input type="number" step="0.01" class="form-control" name="Amount" value="<%= payment.Amount %>" required>
</div>
<div class="mb-3">
<label for="PaymentMethod" class="form-label">Payment Method</label>
<input type="text" class="form-control" name="PaymentMethod" value="<%= payment.PaymentMethod %>" required>
</div>
<button type="submit" class="btn btn-primary">Update</button>
</form>
<%- include('partials/footer') %>
InventoryItem Views:
Index View (views/inventoryItems/index.ejs):
<%- include('partials/header') %>
<h1>Inventory Items</h1>
<a href="/inventoryItems/create" class="btn btn-primary">Create Inventory Item</a>
<table class="table">
<thead>
<tr>
<th>Item Name</th>
<th>Quantity</th>
<th>Unit Price</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
<% items.forEach(item => { %>
<tr>
<td><%= item.ItemName %></td>
< td><%= item.Quantity %></td>
<td><%= item.UnitPrice %></td>
<td>
<a href="/inventoryItems/edit/<%= item.ItemId %>" class="btn btn-warning">Edit</a>
<form action="/inventoryItems/delete/<%= item.ItemId %>" method="POST" style="display:inline;">
<button type="submit" class="btn btn-danger">Delete</button>
</form>
</td>
</tr>
<% }) %>
</tbody>
</table>
<%- include('partials/footer') %>
Create View (views/inventoryItems/create.ejs):
<%- include('partials/header') %>
<h1>Create Inventory Item</h1>
<form action="/inventoryItems/create" method="POST">
<div class="mb-3">
<label for="ItemName" class="form-label">Item Name</label>
<input type="text" class="form-control" name="ItemName" required>
</div>
<div class="mb-3">
<label for="Quantity" class="form-label">Quantity</label>
<input type="number" class="form-control" name="Quantity" required>
</div>
<div class="mb-3">
<label for="UnitPrice" class="form-label">Unit Price</label>
<input type="number" step="0.01" class="form-control" name="UnitPrice" required>
</div>
<button type="submit" class="btn btn-primary">Create</button>
</form>
<%- include('partials/footer') %>
Edit View (views/inventoryItems/edit.ejs):
<%- include('partials/header') %>
<h1>Edit Inventory Item</h1>
<form action="/inventoryItems/edit/<%= item.ItemId %>" method="POST">
<div class="mb-3">
<label for="ItemName" class="form-label">Item Name</label>
<input type="text" class="form-control" name="ItemName" value="<%= item.ItemName %>" required>
</div>
<div class="mb-3">
<label for="Quantity" class="form-label">Quantity</label>
<input type="number" class="form-control" name="Quantity" value="<%= item.Quantity %>" required>
</div>
<div class="mb-3">
<label for="UnitPrice" class="form-label">Unit Price</label>
<input type="number" step="0.01" class="form-control" name="UnitPrice" value="<%= item.UnitPrice %>" required>
</div>
<button type="submit" class="btn btn-primary">Update</button>
</form>
<%- include('partials/footer') %>
LabTest Views:
Index View (views/labTests/index.ejs):
<%- include('partials/header') %>
<h1>Lab Tests</h1>
<a href="/labTests/create" class="btn btn-primary">Create Lab Test</a>
<table class="table">
<thead>
<tr>
<th>Test Name</th>
<th>Description</th>
<th>Price</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
<% tests.forEach(test => { %>
<tr>
<td><%= test.TestName %></td>
<td><%= test.Description %></td>
<td><%= test.Price %></td>
<td>
<a href="/labTests/edit/<%= test.LabTestId %>" class="btn btn-warning">Edit</a>
<form action="/labTests/delete/<%= test.LabTestId %>" method="POST" style="display:inline;">
<button type="submit" class="btn btn-danger">Delete</button>
</form>
</td>
</tr>
<% }) %>
</tbody>
</table>
<%- include('partials/footer') %>
Create View (views/labTests/create.ejs):
<%- include('partials/header') %>
<h1>Create Lab Test</h1>
<form action="/labTests/create" method="POST">
<div class="mb-3">
<label for="TestName" class="form-label">Test Name</label>
<input type="text" class="form-control" name="TestName" required>
</div>
<div class="mb-3">
<label for="Description" class="form-label">Description</label>
<textarea class="form-control" name="Description" required></textarea>
</div>
<div class="mb-3">
<label for="Price" class="form-label">Price</label>
<input type="number" step="0.01" class="form-control" name="Price" required>
</div>
<button type="submit" class="btn btn-primary">Create</button>
</form>
<%- include('partials/footer') %>
Edit View (views/labTests/edit.ejs):
<%- include('partials/header') %>
<h1>Edit Lab Test</h1>
<form action="/labTests/edit/<%= test.LabTestId %>" method="POST">
<div class="mb-3">
<label for="TestName" class="form-label">Test Name</label>
<input type="text" class="form-control" name="TestName" value="<%= test.TestName %>" required>
</div>
<div class="mb-3">
<label for="Description" class="form-label">Description</label>
<textarea class="form-control" name="Description" required><%= test.Description %></textarea>
</div>
<div class="mb-3">
<label for="Price" class="form-label">Price</label>
<input type="number" step="0.01" class="form-control" name="Price" value="<%= test.Price %>" required>
</div>
<button type="submit" class="btn btn-primary">Update</button>
</form>
<%- include('partials/footer') %>
Prescription Views:
Index View (views/prescriptions/index.ejs):
<%- include('partials/header') %>
<h1>Prescriptions</h1>
<a href="/prescriptions/create" class="btn btn-primary">Create Prescription</a>
<table class="table">
<thead>
<tr>
<th>Patient ID</th>
<th>Doctor ID</th>
<th>Prescription Date</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
<% prescriptions.forEach(prescription => { %>
<tr>
<td><%= prescription.PatientId %></td>
<td><%= prescription.DoctorId %></td>
<td><%= prescription.PrescriptionDate %></td>
<td>
<a href="/prescriptions/edit/<%= prescription.PrescriptionId %>" class="btn btn-warning">Edit</a>
<form action="/prescriptions/delete/<%= prescription.PrescriptionId %>" method="POST" style="display:inline;">
<button type="submit" class="btn btn-danger">Delete</button>
</form>
</td>
</tr>
<% }) %>
</tbody>
</table>
<%- include('partials/footer') %>
Create View (views/prescriptions/create.ejs):
<%- include('partials/header') %>
<h1>Create Prescription</h1>
<form action="/prescriptions/create" method="POST">
<div class="mb-3">
<label for="PatientId" class="form-label">Patient ID</label>
<input type="number" class="form-control" name="PatientId" required>
</div>
<div class="mb-3">
<label for="DoctorId" class="form-label">Doctor ID</label>
<input type="number" class="form-control" name="DoctorId" required>
</div>
<div class="mb-3">
<label for="PrescriptionDate" class="form-label">Prescription Date</label>
<input type="datetime-local" class="form-control" name="PrescriptionDate" required>
</div>
<button type="submit" class="btn btn-primary">Create</button>
</form>
<%- include('partials/footer') %>
Edit View (views/prescriptions/edit.ejs):
<%- include('partials/header') %>
<h1>Edit Prescription</h1>
<form action="/prescriptions/edit/<%= prescription.PrescriptionId %>" method="POST">
<div class="mb-3">
<label for="PatientId" class="form-label">Patient ID</label>
<input type="number" class="form-control" name="PatientId" value="<%= prescription.PatientId %>" required>
</div>
<div class="mb-3">
<label for="DoctorId" class="form-label">Doctor ID</label>
<input type="number" class="form -control" name="DoctorId" value="<%= prescription.DoctorId %>" required>
</div>
<div class="mb-3">
<label for="PrescriptionDate" class="form-label">Prescription Date</label>
<input type="datetime-local" class="form-control" name="PrescriptionDate" value="<%= prescription.PrescriptionDate.toISOString().slice(0, 16) %>" required>
</div>
<button type="submit" class="btn btn-primary">Update</button>
</form>
<%- include('partials/footer') %>
Report Views:
Index View (views/reports/index.ejs):
<%- include('partials/header') %>
<h1>Reports</h1>
<a href="/reports/create" class="btn btn-primary">Create Report</a>
<table class="table">
<thead>
<tr>
<th>Patient ID</th>
<th>Report Date</th>
<th>Description</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
<% reports.forEach(report => { %>
<tr>
<td><%= report.PatientId %></td>
<td><%= report.ReportDate %></td>
<td><%= report.Description %></td>
<td>
<a href="/reports/edit/<%= report.ReportId %>" class="btn btn-warning">Edit</a>
<form action="/reports/delete/<%= report.ReportId %>" method="POST" style="display:inline;">
<button type="submit" class="btn btn-danger">Delete</button>
</form>
</td>
</tr>
<% }) %>
</tbody>
</table>
<%- include('partials/footer') %>
Create View (views/reports/create.ejs):
<%- include('partials/header') %>
<h1>Create Report</h1>
<form action="/reports/create" method="POST">
<div class="mb-3">
<label for="PatientId" class="form-label">Patient ID</label>
<input type="number" class="form-control" name="PatientId" required>
</div>
<div class="mb-3">
<label for="ReportDate" class="form-label">Report Date</label>
<input type="datetime-local" class="form-control" name="ReportDate" required>
</div>
<div class="mb-3">
<label for="Description" class="form-label">Description</label>
<textarea class="form-control" name="Description" required></textarea>
</div>
<button type="submit" class="btn btn-primary">Create</button>
</form>
<%- include('partials/footer') %>
Edit View (views/reports/edit.ejs):
<%- include('partials/header') %>
<h1>Edit Report</h1>
<form action="/reports/edit/<%= report.ReportId %>" method="POST">
<div class="mb-3">
<label for="PatientId" class="form-label">Patient ID</label>
<input type="number" class="form-control" name="PatientId" value="<%= report.PatientId %>" required>
</div>
<div class="mb-3">
<label for="ReportDate" class="form-label">Report Date</label>
<input type="datetime-local" class="form-control" name="ReportDate" value="<%= report.ReportDate.toISOString().slice(0, 16) %>" required>
</div>
<div class="mb-3">
<label for="Description" class="form-label">Description</label>
<textarea class="form-control" name="Description" required><%= report.Description %></textarea>
</div>
<button type="submit" class="btn btn-primary">Update</button>
</form>
<%- include('partials/footer') %>
Message Views:
Index View (views/messages/index.ejs):
<%- include('partials/header') %>
<h1>Messages</h1>
<a href="/messages/create" class="btn btn-primary">Create Message</a>
<table class="table">
<thead>
<tr>
<th>Sender ID</th>
<th>Receiver ID</th>
<th>Message Text</th>
<th>Sent At</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
<% messages.forEach(message => { %>
<tr>
<td><%= message.SenderId %></td>
<td><%= message.ReceiverId %></td>
<td><%= message.MessageText %></td>
<td><%= message.SentAt %></td>
<td>
<a href="/messages/edit/<%= message.MessageId %>" class="btn btn-warning">Edit</a>
<form action="/messages/delete/<%= message.MessageId %>" method="POST" style="display:inline;">
<button type="submit" class="btn btn-danger">Delete</button>
</form>
</td>
</tr>
<% }) %>
</tbody>
</table>
<%- include('partials/footer') %>
Create View (views/messages/create.ejs):
<%- include('partials/header') %>
<h1>Create Message</h1>
<form action="/messages/create" method="POST">
<div class="mb-3">
<label for="SenderId" class="form-label">Sender ID</label>
<input type="number" class="form-control" name="SenderId" required>
</div>
<div class="mb-3">
<label for="ReceiverId" class="form-label">Receiver ID</label>
<input type="number" class="form-control" name="ReceiverId" required>
</div>
<div class="mb-3">
<label for="MessageText" class="form-label">Message Text</label>
<textarea class="form-control" name="MessageText" required></textarea>
</div>
<button type="submit" class="btn btn-primary">Create</button>
</form>
<%- include('partials/footer') %>
Edit View (views/messages/edit.ejs):
<%- include('partials/header') %>
<h1>Edit Message</h1>
<form action="/messages/edit/<%= message.MessageId %>" method="POST">
<div class="mb-3">
<label for="SenderId" class="form-label">Sender ID</label>
<input type="number" class="form-control" name="SenderId" value="<%= message.SenderId %>" required>
</div>
<div class="mb-3">
<label for="ReceiverId" class="form-label">Receiver ID</label>
<input type="number" class="form-control" name="ReceiverId" value="<%= message.ReceiverId %>" required>
</div>
<div class="mb-3">
<label for="MessageText" class="form-label">Message Text</label>
<textarea class="form-control" name="MessageText" required><%= message.MessageText %></textarea>
</div>
<button type="submit" class="btn btn-primary">Update</button>
</form>
<%- include('partials/footer') %>
EmergencyContact Views:
Index View (views/emergencyContacts/index.ejs):
<%- include('partials/header') %>
<h1>Emergency Contacts</h1>
<a href="/emergencyContacts/create" class="btn btn-primary">Create Emergency Contact</a>
<table class="table">
<thead>
<tr>
<th>Patient ID</th>
<th>Contact Name</th>
<th>Relationship</th>
<th>Phone</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
<% contacts.forEach(contact => { %>
<tr>
<td><%= contact.PatientId %></td>
<td><%= contact.ContactName %></td>
<td><%= contact.Relationship %></td>
<td><%= contact.Phone %></td>
<td>
<a href="/emergencyContacts/edit/<%= contact.EmergencyContactId %>" class="btn btn-warning">Edit</a>
<form action="/emergencyContacts/delete/<%= contact.EmergencyContactId %>" method="POST" style="display:inline;">
<button type="submit" class="btn btn-danger">Delete</button>
</form>
</td>
</tr>
<% }) %>
</tbody>
</table>
<%- include('partials/footer') %>
Create View (views/emergencyContacts/create.ejs):
<%- include('partials/header') %>
<h1>Create Emergency Contact</h1>
<form action="/emergencyContacts/create" method="POST">
<div class="mb-3">
<label for="PatientId" class="form-label">Patient ID</label>
<input type="number" class="form-control" name="PatientId" required>
</div>
<div class="mb-3">
<label for="ContactName" class="form-label">Contact Name</label>
<input type="text" class="form-control" name="ContactName" required>
</div>
<div class="mb-3">
<label for="Relationship" class="form-label">Relationship</label>
<input type="text" class="form-control" name="Relationship" required>
</div>
<div class="mb-3">
<label for="Phone" class="form-label">Phone</label>
<input type="text" class="form-control" name="Phone" required>
</div>
<button type="submit" class="btn btn-primary">Create</button>
</form>
<%- include('partials/footer') %>
Edit View (views/emergencyContacts/edit.ejs):
<%- include('partials/header') %>
<h1>Edit Emergency Contact</h1>
<form action="/emergencyContacts/edit/<%= contact.EmergencyContactId %>" method="POST">
<div class="mb-3">
<label for="PatientId" class="form-label">Patient ID</label>
<input type="number" class="form-control" name="PatientId" value="<%= contact.PatientId %>" required>
</div>
<div class="mb-3">
<label for="ContactName" class="form-label">Contact Name</label>
<input type="text" class="form-control" name="ContactName" value="<%= contact.ContactName %>" required>
</div>
<div class="mb-3">
<label for="Relationship" class="form-label">Relationship</label>
<input type="text" class="form-control" name="Relationship" value="<%= contact.Relationship %>" required>
</div>
<div class="mb-3">
<label for="Phone" class="form-label">Phone</label>
<input type="text" class="form-control" name="Phone" value="<%= contact.Phone %>" required>
</div>
<button type="submit" class="btn btn-primary">Update</button>
</form>
<%- include('partials/footer') %>
Feedback Views:
Index View (views/feedbacks/index.ejs):
<%- include('partials/header') %>
<h1>Feedbacks</h1>
<a href="/feedbacks/create" class="btn btn-primary">Create Feedback</a>
<table class="table">
<thead>
<tr>
<th>User ID</th>
<th>Comments</th>
<th>Rating</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
<% feedbacks.forEach(feedback => { %>
<tr>
<td><%= feedback.UserId %></td>
<td><%= feedback.Comments %></td>
<td><%= feedback.Rating %></td>
<td>
<a href="/feedbacks/edit/<%= feedback.FeedbackId %>" class="btn btn-warning">Edit</a>
<form action="/feedbacks/delete/<%= feedback.FeedbackId %>" method="POST" style="display:inline;">
<button type="submit" class="btn btn-danger">Delete</button>
</form>
</td>
</tr>
<% }) %>
</tbody>
</table>
<%- include('partials/footer') %>
Create View (views/feedbacks/create.ejs):
<%- include('partials/header') %>
<h1>Create Feedback</h1>
<form action="/feedbacks/create" method="POST">
<div class="mb-3">
<label for="User Id" class="form-label">User ID</label>
<input type="number" class="form-control" name="User Id" required>
</div>
<div class="mb-3">
<label for="Comments" class="form-label">Comments</label>
<textarea class="form-control" name="Comments" required></textarea>
</div>
<div class="mb-3">
<label for="Rating" class="form-label">Rating</label>
<input type="number" class="form-control" name="Rating" min="1" max="5" required>
</div>
<button type="submit" class="btn btn-primary">Create</button>
</form>
<%- include('partials/footer') %>
Edit View (views/feedbacks/edit.ejs):
<%- include ('partials/header') %>
<h1>Edit Feedback</h1>
<form action="/feedbacks/edit/<%= feedback.FeedbackId %>" method="POST">
<div class="mb-3">
<label for="User Id" class="form-label">User ID</label>
<input type="number" class="form-control" name="User Id" value="<%= feedback.UserId %>" required>
</div>
<div class="mb-3">
<label for="Comments" class="form-label">Comments</label>
<textarea class="form-control" name="Comments" required><%= feedback.Comments %></textarea>
</div>
<div class="mb-3">
<label for="Rating" class="form-label">Rating</label>
<input type="number" class="form-control" name="Rating" value="<%= feedback.Rating %>" min="1" max="5" required>
</div>
<button type="submit" class="btn btn-primary">Update</button>
</form>
<%- include('partials/footer') %>
Step 6: Update Main Application File
Update the main application file to include the new routes.
Main Application File (app.js):
const express = require('express');
const bodyParser = require('body-parser');
const path = require('path');
const userRoutes = require('./routes/userRoutes');
const patientRoutes = require('./routes/patientRoutes');
const doctorRoutes = require('./routes/doctorRoutes');
const appointmentRoutes = require('./routes/appointmentRoutes');
const invoiceRoutes = require('./routes/invoiceRoutes');
const paymentRoutes = require('./routes/paymentRoutes');
const inventoryItemRoutes = require('./routes/inventoryItemRoutes');
const labTestRoutes = require('./routes/labTestRoutes');
const prescriptionRoutes = require('./routes/prescriptionRoutes');
const reportRoutes = require('./routes/reportRoutes');
const messageRoutes = require('./routes/messageRoutes');
const emergencyContactRoutes = require('./routes/emergencyContactRoutes');
const feedbackRoutes = require('./routes/feedbackRoutes');
const app = express();
app.set('view engine', 'ejs');
app.set('views', path.join(__dirname, 'views'));
app.use(bodyParser.urlencoded({ extended: true }));
app.use(express.static(path.join(__dirname, 'public')));
app.use('/users', userRoutes);
app.use('/patients', patientRoutes);
app.use('/doctors', doctorRoutes);
app.use('/appointments', appointmentRoutes);
app.use('/invoices', invoiceRoutes);
app.use('/payments', paymentRoutes);
app.use('/inventoryItems', inventoryItemRoutes);
app.use('/labTests', labTestRoutes);
app.use('/prescriptions', prescriptionRoutes);
app.use('/reports', reportRoutes);
app.use('/messages', messageRoutes);
app.use('/emergencyContacts', emergencyContactRoutes);
app.use('/feedbacks', feedbackRoutes);
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
console.log(`Server is running on http://localhost:${PORT}`);
});
You now have a complete CRUD application for managing all entities in a healthcare management system using Node.js, Sequelize, Express, and EJS with Bootstrap 5 templates. Each model has its own routes, controllers, repositories, and views, allowing for full management of users, patients, doctors, appointments, invoices, payments, inventory items, lab tests, prescriptions, reports, messages, emergency contacts, and feedbacks. You can run the application and access each section through the respective routes.
To create a dashboard page that consolidates data related to the healthcare management project, we will follow these steps:
Create a Dashboard Route
Create a Dashboard Controller
Create a Dashboard View
Update the Main Application File to Include the Dashboard Route
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 PatientRepository = require('../repositories/PatientRepository');
const DoctorRepository = require('../repositories/DoctorRepository');
const AppointmentRepository = require('../repositories/AppointmentRepository');
const InvoiceRepository = require('../repositories/InvoiceRepository');
const PaymentRepository = require('../repositories/PaymentRepository');
class DashboardController {
async showDashboard(req, res) {
try {
const totalUsers = await UserRepository.findAll();
const totalPatients = await PatientRepository.findAll();
const totalDoctors = await DoctorRepository.findAll();
const totalAppointments = await AppointmentRepository.findAll();
const totalInvoices = await InvoiceRepository.findAll();
const totalPayments = await PaymentRepository.findAll();
res.render('dashboard', {
totalUsers: totalUsers.length,
totalPatients: totalPatients.length,
totalDoctors: totalDoctors.length,
totalAppointments: totalAppointments.length,
totalInvoices: totalInvoices.length,
totalPayments: totalPayments.length,
});
} 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):
<%- include('partials/header') %>
<h1>Dashboard</h1>
<div class="row">
<div class="col-md-4">
<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-4">
<div class="card text-white bg-success mb-3">
<div class="card-header">Total Patients</div>
<div class="card-body">
<h5 class="card-title"><%= totalPatients %></h5>
</div>
</div>
</div>
<div class="col-md-4">
<div class="card text-white bg-warning mb-3">
<div class="card-header">Total Doctors</div>
<div class="card-body">
<h5 class="card-title"><%= totalDoctors %></h5>
</div>
</div>
</div>
<div class="col-md-4">
<div class="card text-white bg-info mb-3">
<div class="card-header">Total Appointments</div>
<div class="card-body">
<h5 class="card-title"><%= totalAppointments %></h5>
</div>
</div>
</div>
<div class="col-md-4">
<div class="card text-white bg-danger mb-3">
<div class="card-header">Total Invoices</div>
<div class="card-body">
<h5 class="card-title"><%= totalInvoices %></h5>
</div>
</div>
</div>
<div class="col-md-4">
<div class="card text-white bg-secondary mb-3">
<div class="card-header">Total Payments</div>
<div class="card-body">
<h5 class="card-title"><%= totalPayments %></h5>
</div>
</div>
</div>
</div>
<%- include('partials/footer') %>
Step 4: Update the Main Application File
Update your main application file (app.js) to include the dashboard route:
const express = require('express');
const bodyParser = require('body-parser');
const path = require('path');
const userRoutes = require('./routes/userRoutes');
const patientRoutes = require('./routes/patientRoutes');
const doctorRoutes = require('./routes/doctorRoutes');
const appointmentRoutes = require('./routes/appointmentRoutes');
const invoiceRoutes = require('./routes/invoiceRoutes');
const paymentRoutes = require('./routes/paymentRoutes');
const inventoryItemRoutes = require('./routes/inventoryItemRoutes');
const labTestRoutes = require('./routes/labTestRoutes');
const prescriptionRoutes = require('./routes/prescriptionRoutes');
const reportRoutes = require('./routes/reportRoutes');
const messageRoutes = require('./routes/messageRoutes');
const emergencyContactRoutes = require('./routes/emergencyContactRoutes');
const feedbackRoutes = require('./routes/feedbackRoutes');
const dashboardRoutes = require('./routes/dashboardRoutes');
const app = express();
app.set('view engine', 'ejs');
app.set('views', path.join(__dirname, 'views'));
app.use(bodyParser.urlencoded({ extended: true }));
app.use(express.static(path.join(__dirname, 'public')));
app.use('/users', userRoutes);
app.use('/patients', patientRoutes);
app.use('/ doctors', doctorRoutes);
app.use('/appointments', appointmentRoutes);
app.use('/invoices', invoiceRoutes);
app.use('/payments', paymentRoutes);
app.use('/inventoryItems', inventoryItemRoutes);
app.use('/labTests', labTestRoutes);
app.use('/prescriptions', prescriptionRoutes);
app.use('/reports', reportRoutes);
app.use('/messages', messageRoutes);
app.use('/emergencyContacts', emergencyContactRoutes);
app.use('/feedbacks', feedbackRoutes);
app.use('/dashboard', dashboardRoutes);
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
console.log(`Server is running on http://localhost:${PORT}`);
});
AI 
ASP.NET API 
ASP.NET CLI 
ASP.NET Core 
ASP.NET MVC 
ASP.NET Projects With Source Code 
ASP.NET Web Forms 
ASP.NET Web Pages 
AWS 
Angular 10 
Bash 
Bitcoin 
Blockchain 
C Tutorial 
C# 
CPP 
Chat GPT 
Cheat Sheet 
Cyber Security 
Dart 
Django 
Docker 
Ether.js 
Ethereum 
Flask 
Flask Projects With Source Code 
GEN AI 
Git 
Go Language 
Google Cloud Platform 
GraphQL 
Hardhat 
INI 
JSON 
Java 
JavaScript 
Kotlin 
Kubernetes 
LaTeX 
Laravel 
Laravel 10 E-Commerce Project 
Laravel 11 E-Commerce Project 
Laravel 9 E-Commerce Project 
Laravel 9 React Tutorial 
Laravel E-Commerce Project 
Laravel Home Services Project 
Laravel Projects With Source Code 
Laravel Tutorial Advanced 
Laravel Tutorial Beginners 
Livewire 
Markdown 
Matlab 
Metamask 
Microsoft Azure 
MongoDB Tutorial Advanced 
MongoDB Tutorial Beginners 
MySql Tutorial Advanced 
MySql Tutorial Beginners 
NextJS 
Node JS 
Node JS Projects With Source Code 
PHP Projects With Source Code 
PHP Tutorial Advanced 
PHP Tutorial Beginners 
Project Database Schema 
Python 
React JS 
Ruby 
Rust 
SQL Server Queries 
SQL Server Tutorial Advanced 
SQL Server Tutorial Beginners 
Sass 
Solidity 
Spring Boot 
Truffle 
TypeScript 
VueJS 
Web3.js 
WordPress Tutorial Advanced 
WordPress Tutorial Beginners 
YAML