ACADEMIC SOFTWARE ENGINEERING PROJECT
A JavaFX disaster-response application developed through two individual assessment stages and expanded collaboratively into a MySQL-backed client-server system.
I completed the original requirements, system design and working JavaFX prototype. During the final group stage, I contributed JavaFX screens, role-aware navigation, client request integration, public alerts, shelters and administrator interfaces.
The original analysis, design and JavaFX prototype were completed individually. The final client-server application includes collaborative server, database, integration, testing and documentation work.
01 / CONTEXT
CrisisOps models the movement from a public disaster report to incident assessment, resource dispatch, status updates and community information.
Reports must be reviewed before they become structured incidents. Staff then need consistent severity and priority information, visibility of available resources and a record of response activity.
The application also separates community-facing functions from Emergency Control Centre and administrator work through role-aware JavaFX navigation.
Public submissions need review before staff register an operational incident.
A calculated risk score supports consistent priority recommendations using severity and affected-population data.
Dispatch decisions depend on current available, assigned, unavailable and maintenance states.
Public users, Emergency Control Centre staff and administrators require different screens and actions.
02 / PROJECT EVOLUTION
The first two assessment stages were completed individually. The final stage retained the JavaFX foundation and added collaborative client-server and database work.
I defined the original system boundary, actors, requirements, use cases, interaction sequences and MVC direction.
I implemented the core workflow as a JavaFX desktop prototype with in-memory storage and JUnit 4 tests.
The team expanded the prototype into a broader local client-server application.
03 / CORE WORKFLOW
The six-step sequence established in the individual prototype remained central to the completed academic application.
A public user submits a disaster or hazard report.
Emergency Control Centre staff validate the report and create an incident record.
Staff record severity and the number of affected people.
The application calculates a risk score and recommends a response priority.
Available resources are selected and response activity is recorded.
Staff maintain incident progress and publish relevant community information.
04 / ACCESS MODEL
After a successful login, the JavaFX client stores the returned role and shows or hides dashboard functions for that user type.
Community-facing access for account registration, disaster reporting and published alerts.
Operational screens covering incident assessment, resource coordination, shelters and alerts.
Access to the operational workspace with an additional user-management interface.
Role separation is implemented in the JavaFX client. The socket server does not issue session tokens or enforce role checks for every request, so this is an academic access model rather than production-grade authorisation.
05 / ARCHITECTURE
The desktop client sends serialised requests over sockets. The server routes each request, calls DAO classes and returns a response from the MySQL-backed application.
06 / MY CONTRIBUTION
I completed the original analysis, design and working JavaFX prototype individually. That application was selected as the foundation for the final group assessment.
During the collaborative stage, my work centred on JavaFX interfaces, role-aware navigation, frontend request components and connecting screens to backend request and response flows.
Defined the original system boundary, actors, requirements, use cases, sequence flows and MVC direction.
Implemented the report, incident registration, severity, priority, dispatch, status, resource-tracking and search workflows.
Built the resource-availability tracker and priority-recommendation behaviour based on severity and affected population.
Contributed login, public registration, dashboards, alerts, shelters and administrator user-management screens.
Prepared frontend request components and connected JavaFX screens to server responses for selected workflows.
Removed private database credentials, applied CrisisOps branding and organised setup, attribution and project-evolution documentation.
07 / INTERFACE GALLERY
The repository includes screenshots of the main public, Emergency Control Centre and administrator workflows.
08 / TESTING EVIDENCE
A full local JUnit 4 run of the current CrisisOps repository completed with 40 tests passing across selected models, services, validation rules, session state and repository behaviour.
The complete project test suite was run locally from the current CrisisOps repository. The result is presented as local JUnit evidence rather than an automated continuous-integration result.
Tests cover disaster reports, emergency resources and emergency responses.
Service tests cover incidents, priority recommendations, alerts, shelters and registration.
Alert and shelter validation tests exercise selected rules outside the JavaFX interface.
The suite includes tests for user-session state and the in-memory application repository.
09 / ENGINEERING DECISIONS
The design connects interface structure, business rules, request handling and persistence while retaining the constraints of the submitted academic application.
The interface progresses from report and validation through assessment, dispatch and status updates.
The JavaFX dashboard changes its visible navigation for public, operational and administrator roles.
Database operations are grouped in dedicated data-access components rather than embedded in interface controllers.
The server creates a client handler and a new thread for each accepted socket connection.
10 / CURRENT SCOPE
CrisisOps demonstrates requirements engineering, JavaFX development, decision-support logic, socket communication, relational persistence, testing and collaborative integration.
The original requirements, architecture and working prototype establish my personal contribution.
The final stage expanded the prototype with a server, database and broader integrated workflows.
The application connects JavaFX, sockets, threads, JDBC, DAO classes, MySQL and JUnit.
The repository provides source code, setup guidance, screenshots, contribution history and known constraints.
CASE STUDY 03