A.

Y 2023-24
Java Inhouse Internship

Track: JAVA With Advanced Concept

Project Report:
Patient Monitoring Dashboard
Team Member Details:
Group 17
Jeet Trivedi SE COMP C (34)
Karan Upadhyay SE COMP C (36)
Karan Vishwakarma SE COMP C (42)
Sachinkumar Gupta SE COMP C (65)
 INDEX

CHAPTER NAME OF TOPIC PAGE NO.

1. ABSTRACT 3

2. INTRODUCTION 4

3. MOTIVATION 5

4. PROBLEM STATEMENT 6

5. IMPLEMENTATION 7, 8, 9,

7. FLOWCHART 10

8. CODE 11,12, 13, 14, 15

9. RESULTS & DISCUSSION 16,17,18

10. CONCLUSION 19

11. FUTURE SCOPE 20

12. REFERENCES 21
 Abstract
In this project, a Java-based Patient Monitoring Dashboard is designed
to revolutionize healthcare management by providing a centralized
platform for real-time patient data visualization and analysis. The user-
friendly design prioritizes accessibility and clarity, enabling healthcare
professionals to make informed decisions promptly. This Patient
Monitoring Dashboard has a very user friendly interface and is easy to
use. No knowledge of tech is required to use it as it has a very easy to
use gui. It also has real time database changes. This innovative system
seamlessly connects to a MySQL database through JDBC, ensuring
secure and efficient management of patient data. The dashboard
incorporates a user-friendly interface that displays critical patient
information, enabling healthcare professionals to make informed
decisions promptly and enhance the overall quality of patient care.
 Introduction
The Java-based Patient Monitoring Dashboard represents a significant
leap forward in healthcare technology, offering a dynamic solution for
real-time patient data management and analysis. In the ever-evolving
landscape of healthcare, the need for efficient and comprehensive
patient monitoring systems is paramount. The total user experience is
improved by the use of modern Java technologies, such as JDBC,
JavaFX, and SQL, which guarantee a stable and interactive system. The
objective is to improve patient outcomes, encourage data-driven
medical decision-making, and expedite the monitoring process. This
program is in line with the overarching goal of using technology to raise
the standard of patient care and improve healthcare services.
 Motivation
The goal of employing cutting-edge Java principles to create a Patient
Monitor Dashboard is to enhance patient care and healthcare efficiency.
Healthcare workers can obtain real-time patient data by creating an
advanced dashboard, which facilitates speedier decision-making and
better patient management. The total user experience is improved by
the use of modern Java technologies, such as JDBC, JavaFX, and SQL,
which guarantee a stable and interactive system. The objective is to
improve patient outcomes, encourage data-driven medical decision-
making, and expedite the monitoring process. This program is in line
with the overarching goal of using technology to raise the standard of
patient care and improve healthcare services.
 Problem Statement

To create a patient monitoring dashboard using advanced java concepts such as

JDBC , JavaFX, SQL, etc. It describes the development of a Patient Monitoring
Dashboard using advanced Java technologies. This dashboard aims to provide
healthcare professionals with real-time information about patients. Key
components include JDBC for database interaction, JavaFX for creating an
interactive user interface, and SQL for managing the underlying database. The
project involves integrating these advanced Java concepts to build a
comprehensive system for monitoring and managing patient data efficiently.
 Implementation
The patient monitoring system is developed via the various Java
technologies such as JavaFX libraries, JDBC and bit of servlet in
updating the data from the server. You may ask why we use java
language to develop our project because we always have a stereotype
that it is hard language and yes its true! But we should not forget that
it is one of the most secure languages among many other. This
outstands java from other languages. This was the reason why we
implemented our project using Java.
Development phase:
Frontend using scene builder:

Frontend data of the JavaFX project is handled via the xml files in the
project. All the necessary layout, button, text boxes, etc. have to be
added inside the xml file. However, writing them manually is quite
difficult and not so efficient way to do that. Thus we use scene
builder. It is amazing tool which allows us to design our xml page
very easily via just drag and drop system. This helps us to easily work
with frontend part reducing our time and energy on developing the
code. Also, the changes we make in scene builder is directly reflected
in the xml file. Thus, how we use scene builder in frontend
development.
Backend using JavaFX controller class:

After successfully completing the frontend part we can head on to the

backend part of handling the event calls. For that purpose, we need to
use a controller class which will contain all the buttons, labels and
other elements with ID in scene builder. These elements will now
allow us to access their values or set their values or perform any
functions reqd. Thus, we can now easily construct our backend logic
using the elements. We also need to implement various other
functions via JDBC which will be discussed later on.
Database using SQL and JDBC:

The database part is the most tricky and logical part to be constructed
in the project as it requires choosing the correct attributes with their
necessary datatypes which should match with the JavaFX elements.
The Database we created consist of the 2 tables viz patient and doctor.
The doctor and patient table were used to store and retrieve the data in
the Java FX for various purposes like validation of data at login site or
registration site, etc. The JDBC implementation is relatively straight
forward in various cases. We need to store the query to be executed in
the string variable, prepare the statement, stores the execute query
result in the result and via if or while loop we can then retrieve the
data.
Flowchart
 Code
Doctor page code:
package com.application.mark1; result = prepare.executeQuery();
import javafx.collections.FXCollections; if(!result.next()){
import javafx.collections.ObservableList; if(Login_ShowPASSWORD.isVisible()){
import javafx.event.ActionEvent;
import javafx.fxml.FXML; if(!Login_ShowPASSWORD.getText().equals(Login_PASSWORD.g
import javafx.fxml.FXMLLoader; etText())){
import javafx.fxml.Initializable;
import javafx.scene.Parent; Login_ShowPASSWORD.setText(Login_PASSWORD.getText());
import javafx.scene.Scene; }else{
import javafx.scene.control.Button;
import javafx.scene.control.CheckBox; if(!Login_ShowPASSWORD.getText().equals(Login_PASSWORD.g
import javafx.scene.control.ComboBox; etText())) {
import javafx.scene.control.Hyperlink;
import javafx.scene.control.PasswordField; Login_PASSWORD.setText(Login_ShowPASSWORD.getText());
import javafx.scene.control.TextField; }
import javafx.scene.layout.AnchorPane; }
import javafx.stage.Stage; }
alert.errorMessage("Need the confirmation of the
import java.io.IOException; Admin");
import java.net.URL; } else{
import java.sql.Connection; prepare = connect.prepareStatement(sql);
import java.sql.PreparedStatement; prepare.setString(1,Login_DoctorID.getText());
import java.sql.ResultSet; prepare.setString(2,Login_PASSWORD.getText());
import java.sql.SQLException; result = prepare.executeQuery();
import java.util.*; if(result.next()){
Data.Doctor_Id = result.getString("D_DID");
public class DoctorPageController implements Initializable Data.Doctor_Username =
{ result.getString("D_Name");
@FXML
private AnchorPane Login; alert.successMessage("Login successfully");
@FXML Parent root =
private Button Login_Cancel; FXMLLoader.load(Objects.requireNonNull(getClass().getResourc
@FXML e("DoctorDash.fxml")));
private CheckBox Login_Checkbox; Stage stage = new Stage();
@FXML stage.setTitle("Patient Monitoring System|Doctor
private TextField Login_DoctorID; Main Dashboard");
@FXML stage.setScene(new Scene(root));
private Hyperlink Login_New; stage.show();
@FXML }else{
private PasswordField Login_PASSWORD; alert.errorMessage("Incorrect
@FXML Username/Password");
private TextField Login_ShowPASSWORD; }
@FXML }
private ComboBox<String> Login_User; } catch (SQLException | IOException e) {
@FXML throw new RuntimeException(e);
private Button Login_login; }
@FXML }
private AnchorPane Register; }
@FXML @FXML
private CheckBox Register_CheckBox; public void loginShowPassword(ActionEvent event) {
@FXML if(Login_Checkbox.isSelected()){
private TextField Register_DoctorID;
@FXML Login_ShowPASSWORD.setText(Login_PASSWORD.getText());
private TextField Register_Doctor_USERNAME; Login_PASSWORD.setVisible(false);
@FXML Login_ShowPASSWORD.setVisible(true);
private TextField Register_Email; }else{
@FXML
 private Hyperlink Register_New;
@FXML Login_ShowPASSWORD.setText(Login_PASSWORD.getText());
private PasswordField Register_PASSWORD; Login_PASSWORD.setVisible(true);
@FXML Login_ShowPASSWORD.setVisible(false);
private TextField Register_ShowPASSWORD; }
@FXML }
private Button Register_register;
private Connection connect; private String DoctorID;
private PreparedStatement prepare; public void Register_DoctorID() {
private ResultSet result; String doctorId = "DID-";
private final AlertSystem alert = new AlertSystem(); String sql = "SELECT MAX(D_ID) FROM Doctor";
@FXML int tempID = 0;
public void RegisterAccount() { connect = Database.connectDB();
if(Register_Doctor_USERNAME.getText().isEmpty() || try{
Register_Email.getText().isEmpty()||Register_PASSWORD if(!Register_ShowPASSWORD.isVisible()){
.getText().isEmpty()){
alert.errorMessage("Please fill all the blank fields"); if(!Register_ShowPASSWORD.getText().equals(Register_PASSW
} else{ ORD.getText())){
String checkDoctorID = "SELECT * FROM Doctor
WHERE D_DID = '" + Register_DoctorID.getText() + "';"; Register_ShowPASSWORD.setText(Register_PASSWORD.getText
connect = Database.connectDB(); ());
try{ }else{
assert connect != null;
prepare = if(!Register_ShowPASSWORD.getText().equals(Register_PASSW
connect.prepareStatement(checkDoctorID); ORD.getText())){
result = prepare.executeQuery();
Register_PASSWORD.setText(Register_ShowPASSWORD.getText
if(result.next()){ ());
}
alert.errorMessage(Register_DoctorID.getText() + " is }
already taken"); }
} else if (Register_PASSWORD.getText().length() < assert connect != null;
8) { prepare = connect.prepareStatement(sql);
alert.errorMessage("Invalid password, At least result = prepare.executeQuery();
8 character needed"); if(result.next()){
}else{ tempID = result.getInt("MAX(D_Id)");
String insertData = "INSERT INTO }
Doctor(D_Name,Email,D_DID,Pass,D_Date,D_Status)" if(tempID == 0){
+"VALUES(?,?,?,?,?,?)"; tempID += 1;
prepare = doctorId +=tempID;
connect.prepareStatement(insertData); }else{
Date date = new Date(); doctorId += (tempID+1);
java.sql.Date sqDate = new }
java.sql.Date(date.getTime()); Register_DoctorID.setText(doctorId);
Register_DoctorID.setDisable(true);
prepare.setString(1,Register_Doctor_USERNAME.getText( } catch (SQLException e) {
)); throw new RuntimeException(e);
prepare.setString(2,Register_Email.getText()); }
}
prepare.setString(3,Register_DoctorID.getText()); @FXML
public void registerShowPassword (){
prepare.setString(4,Register_PASSWORD.getText()); if(Register_CheckBox.isSelected()){
prepare.setString(5,String.valueOf(sqDate));
prepare.setString(6,"Confirm"); Register_ShowPASSWORD.setText(Register_PASSWORD.getText
prepare.executeUpdate(); ());
alert.successMessage("Registered Register_PASSWORD.setVisible(false);
Successfully!"); Register_ShowPASSWORD.setVisible(true);
} }else{
} catch (Exception e) {
throw new RuntimeException(e); Register_PASSWORD.setText(Register_ShowPASSWORD.getText
} ());
} Register_ShowPASSWORD.setVisible(true);
} Register_PASSWORD.setVisible(true);
 }
@FXML }
public void loginAccount(ActionEvent event) { public void userList(){
List<String> listU = new ArrayList<>();
if(Login_DoctorID.getText().isEmpty()||Login_PASSWORD Collections.addAll(listU, Users.user);
.getText().isEmpty()){ ObservableList<String> listData =
alert.errorMessage("Empty Data Fields"); FXCollections.observableList(listU);
}else{ Login_User.setItems(listData);
try{ }
String sql = "SELECT * FROM Doctor WHERE D_DID = public void switchPage(){
? AND PASS = ? AND Delete_Date IS NULL;";
connect = Database.connectDB(); if(Objects.equals(Login_User.getSelectionModel().getSelectedIte
m(), "Doctor Portal")) {
String checkStatus = "SELECT D_Status FROM try {
Doctor WHERE D_DID = '" + Login_DoctorID.getText() + "' Parent root =
AND D_Status = 'Confirm';"; FXMLLoader.load(Objects.requireNonNull(getClass().getResourc
e("DoctorPage.fxml")));
assert connect != null; Stage stage = new Stage();
prepare = connect.prepareStatement(checkStatus); stage.setMinWidth(320);
stage.setMinHeight(525);
stage.setScene(new Scene(root));
stage.show();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
else
if(Objects.equals(Login_User.getSelectionModel().getSelectedIte
m(), "Patient Portal")) {
try {
Parent root =
FXMLLoader.load(Objects.requireNonNull(getClass().getResourc
e("PatientPage.fxml")));
Stage stage = new Stage();

stage.setMinWidth(320);
stage.setMinHeight(525);
stage.setScene(new Scene(root));
stage.show();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
Login_User.getScene().getWindow().hide();
}
@FXML
public void switchForm(ActionEvent event) {
if(event.getSource() == Login_New){
Login.setVisible(false);
Register.setVisible(true);
}else if(event.getSource() == Register_New){
Login.setVisible(true);
Register.setVisible(false);
}
}

@Override
public void initialize(URL location, ResourceBundle resources)
{
userList();
Register_DoctorID();
}
}
Patient Page Code:
package com.application.mark1; public void switchPage(){

import javafx.collections.FXCollections; if(Objects.equals(Login_User.getSelectionModel().getSelecte

import javafx.collections.ObservableList; dItem(), "Doctor Portal")) {
import javafx.event.ActionEvent; try {
import javafx.fxml.FXML; Parent root =
import javafx.fxml.FXMLLoader; FXMLLoader.load(Objects.requireNonNull(getClass().getReso
import javafx.fxml.Initializable; urce("DoctorPage.fxml")));
import javafx.scene.Parent; Stage stage = new Stage();
import javafx.scene.Scene; stage.setMinWidth(320);
import javafx.scene.control.Button; stage.setMinHeight(500);
import javafx.scene.control.CheckBox; stage.setScene(new Scene(root));
import javafx.scene.control.ComboBox; stage.show();
import javafx.scene.control.Hyperlink; } catch (IOException e) {
import javafx.scene.control.PasswordField; throw new RuntimeException(e);
import javafx.scene.control.TextField; }
import javafx.scene.layout.AnchorPane; }else
import javafx.stage.Stage; if(Objects.equals(Login_User.getSelectionModel().getSelecte
dItem(), "Patient Portal")) {
import java.io.IOException; try {
import java.net.URL; }
import java.sql.Connection; Parent root =
import java.sql.PreparedStatement; FXMLLoader.load(Objects.requireNonNull(getClass().getReso
import java.sql.ResultSet; urce("PatientPage.fxml")));
import java.sql.SQLException; Stage stage = new Stage();
import java.util.*; stage.setMinWidth(320);
public class PatientPageController implements stage.setMinHeight(500);
Initializable { stage.setScene(new Scene(root));
@FXML stage.show();
private AnchorPane Login; } catch (IOException e) {
@FXML throw new RuntimeException(e);
private Button Login_Cancel; }
@FXML }
private CheckBox Login_Checkbox; Login_User.getScene().getWindow().hide();
@FXML }
private PasswordField Login_PASSWORD; public void userList(){
@FXML List<String> listU = new ArrayList<>();
private TextField Login_PatientID; Collections.addAll(listU, Users.user);
@FXML ObservableList<String> listData =
private TextField Login_ShowPASSWORD; FXCollections.observableList(listU);
@FXML Login_User.setItems(listData);
private ComboBox<String> Login_User; }
@FXML @Override
private Button Login_login; public void initialize(URL location, ResourceBundle
private Connection connect; resources) {
private PreparedStatement prepare; userList();
private ResultSet result; }
private final AlertSystem alert = new AlertSystem(); assert connect != null;
@FXML prepare = connect.prepareStatement(sql);
void loginAccount(ActionEvent event) { prepare.setString(1,Login_PatientID.getText());
prepare.setString(2,Login_PASSWORD.getText());
if(Login_PatientID.getText().isEmpty()||Login_PASSWO result = prepare.executeQuery();
RD.getText().isEmpty()){ if(!result.next()){
alert.errorMessage("Incorrect if(Login_ShowPASSWORD.isVisible()){
Username/Password");
}else{ if(!Login_ShowPASSWORD.getText().equals(Login_PASSWOR
try{ D.getText())){
 String sql = "SELECT * FROM Patient WHERE
P_Id = ? AND PASS = ? AND Date_Delete IS NULL;"; Login_ShowPASSWORD.setText(Login_PASSWORD.getText());
connect = Database.connectDB(); }else{

if(!Login_ShowPASSWORD.getText().equals(Login_PASSWOR
D.getText())) {

Login_PASSWORD.setText(Login_ShowPASSWORD.getText());
}
}
}
alert.errorMessage("You might be not registered,
please contact the Consultant doctor for registration");
} else{
alert.successMessage("Login successfully");
Data.PatientID = Login_PatientID.getText();
Parent root =
FXMLLoader.load(Objects.requireNonNull(getClass().getReso
urce("PatientDash.fxml")));
Stage stage = new Stage();
stage.setTitle("Patient Monitoring
System|Patient Main Dashboard");
stage.setScene(new Scene(root));
stage.show();
}
} catch (SQLException | IOException e) {
throw new RuntimeException(e);
}
}
}

@FXML
public void loginShowPassword(ActionEvent event) {
if(Login_Checkbox.isSelected()){

Login_ShowPASSWORD.setText(Login_PASSWORD.getText());
Login_PASSWORD.setVisible(false);
Login_ShowPASSWORD.setVisible(true);
}else{

Login_PASSWORD.setText(Login_ShowPASSWORD.getText());
Login_ShowPASSWORD.setVisible(true);
Login_PASSWORD.setVisible(true);
}

@FXML
 Result and Discussion
Login and Register page of Doctor portal:
Patient login portal:

Doctor Dashboard:
Patient Dashboard:
Conclusion
The development of the Java-based Patient Monitoring Dashboard marks a
significant milestone in enhancing healthcare management through streamlined
data visualization and analysis. Although the dashboard does not directly
connect with medical devices, its emphasis on database integration provides
healthcare professionals with a centralized platform for accessing and
interpreting patient data efficiently.The user-friendly interface ensures ease of
navigation, enabling healthcare providers to make timely and informed
decisions. Customizable alerts and historical data analysis contribute to a
proactive approach to patient care, promoting enhanced safety and tailored
treatment plans.
While the current scope focuses on database connectivity, there is ample room
for future expansion. The dashboard's adaptability and scalability make it well-
positioned for potential integration with medical devices, offering a holistic
solution for comprehensive patient monitoring. Additionally, ongoing
refinements in user interface design and the incorporation of advanced analytics
could further elevate its capabilities.As healthcare technology continues to
evolve, the Java-based Patient Monitoring Dashboard stands as a foundational
tool, showcasing the potential for efficient data management and decision-
making in healthcare settings. Its platform-independent nature ensures
accessibility, and the commitment to data security underscores its relevance in an
era where privacy and compliance are paramount. This project lays the
groundwork for future innovations, emphasizing the importance of adaptability
and continuous improvement in the dynamic landscape of healthcare technology.
Future Scope
1.Advanced Predictive Analytics: Integrate machine learning algorithms to
predict health deterioration based on historical and real-time data. This could
enable healthcare providers to intervene proactively and prevent potential
complications.
2.IoT Integration: Expand the dashboard's capabilities by integrating a broader
range of Internet of Things (IoT) devices, allowing for a more comprehensive
monitoring of patient health beyond traditional vital signs. This could include
wearable devices and smart implants.
3.Telemedicine Integration: Incorporate features that facilitate telemedicine
consultations directly through the dashboard. This could enhance remote patient
monitoring and extend healthcare services to geographically distant or
underserved areas.
Enhanced Mobile Application: Develop a dedicated mobile application for the
dashboard, optimizing the user experience on smartphones and tablets. This can
further increase accessibility for healthcare providers on the go.
References :
1. https://www.w3schools.com/java/Oracle.com
2. https://www.javatpoint.com/java-jdbc
3. https://www.tutorialspoint.com/jsp/index.htm
4. https://www.geeksforgeeks.org/introduction-to-jsp/
5. Stack Overflow