1.

usecaseDiagram code
@startuml
skinparam backgroundColor #FFFFFF
skinparam usecase {
ArrowColor Black
ActorBorderColor Black
ActorFontColor Black
ActorBackgroundColor White
UsecaseBackgroundColor White
UsecaseBorderColor Black
}

' Ensure vertical alignment of actors

left to right direction

actor HOD
actor ExamAdministrator

HOD -down-> (Login as HOD)

ExamAdministrator -down-> (Login as Exam Administrator)

(Login as HOD) --> (Manage Faculty)

(Login as HOD) --> (Check Faculty Availability)
(Check Faculty Availability) --> (Update Faculty Availability)
(Update Faculty Availability) --> (Generate Faculty Report)

(Login as Exam Administrator) --> (Check Faculty Availability)

(Check Faculty Availability) --> (Update Faculty Availability)
(Update Faculty Availability) --> (Generate Faculty Report)
(Login as Exam Administrator) --> (Allocate Faculty)
(Login as Exam Administrator) --> (Send Notification)
@enduml

-----------------------------------------------------------------------------------
----------------

2.classDiagram Code
@startuml
skinparam backgroundColor #FFFFFF
skinparam class {
BackgroundColor White
ArrowColor Black
BorderColor Black
FontColor Black
FontSize 12
}

class HOD {
+username: String
+password: String
+login(username: String, password: String): Boolean
+checkFacultyAvailability(): List<String> // List of faculty statuses
+updateFacultyAvailability(): void
}

class ExamAdministrator {
+username: String
 +password: String
+login(username: String, password: String): Boolean
+checkFacultyAvailability(): List<String> // List of faculty statuses
}

class FacultyAvailability {
+checkFacultyAvailability(): List<String> // List of faculty statuses
+updateFacultyAvailability(): void
+generateReport(): Report // Faculty availability can generate reports
}

class Notification {
+message: String
+send(): void
}

class FacultyAllocation {
+allocateFaculty(date: Date, numRooms: int, numFaculty: int, duration: int,
timing: Time): void
+sendNotification(facultyList: List<String>): void // List of faculty names or
IDs
}

class Report {
+reportData: String
+generate(): void
+generateFromAvailability(facultyList: List<String>): void // List of faculty
statuses
}

class FacultyManagement {
+editFaculty(facultyId: String, updatedInfo: String): void
+deleteFaculty(facultyId: String): void
+updateFacultyList(): void
}

' Relationships
HOD --> FacultyAvailability
HOD --> FacultyManagement
ExamAdministrator --> FacultyAvailability
ExamAdministrator --> FacultyAllocation
FacultyAvailability --> Report
FacultyAllocation --> Notification
@enduml

-----------------------------------------------------------------------------------
---------------------------------

3.objectDiagram code
@startuml
skinparam backgroundColor #FFFFFF

object HOD {
username = "hod1"
password = "securePassword"
}
object ExamAdministrator {
username = "admin1"
password = "adminPassword"
}

object FacultyAvailability {
statuses = ["Available", "Busy", "On Leave"]
}

object FacultyManagement {
facultyList = ["Faculty1", "Faculty2"]
}

object Report {
reportData = "Faculty availability report"
}

' Relationships
HOD --> FacultyAvailability : checkAvailability()
HOD --> FacultyManagement : manageFaculty()
FacultyAvailability --> Report : generateFromAvailability()

ExamAdministrator --> FacultyAvailability : checkAvailability()

FacultyAvailability --> Report : generateFromAvailability()
@enduml

-----------------------------------------------------------------------------------
----------------

4.stateDiagram code
@startuml
skinparam backgroundColor #FFFFFF

[*] --> LoggedOut

LoggedOut --> EnterCredentialsHOD : HOD login(username, password)

LoggedOut --> EnterCredentialsAdmin : Admin login(username, password)

EnterCredentialsHOD --> LoggedInHOD : successful login

EnterCredentialsAdmin --> LoggedInAdmin : successful login

LoggedInHOD --> FacultyAvailabilityHOD : checkFacultyAvailability()

FacultyAvailabilityHOD --> GenerateReportHOD : generateReport()
FacultyAvailabilityHOD --> LoggedInHOD : return to LoggedInHOD
LoggedInHOD --> FacultyManagementHOD : manageFaculty()
FacultyManagementHOD --> LoggedInHOD : return to LoggedInHOD
LoggedInHOD --> LoggedOut : logout()

LoggedInAdmin --> FacultyAvailabilityAdmin : checkFacultyAvailability()

FacultyAvailabilityAdmin --> GenerateReportAdmin : generateReport()
FacultyAvailabilityAdmin --> LoggedInAdmin : return to LoggedInAdmin
LoggedInAdmin --> LoggedOut : logout()
@enduml

-----------------------------------------------------------------------------------
------------------
5.ActivityDiagram code
@startuml
skinparam backgroundColor #FFFFFF

start

:Login;

-> HOD;
:Check Credentials;
if (Credentials Valid?) then (yes)
:Logged In;
:Manage Faculty; // First action for HOD
:Check Faculty Availability; // Then check availability
:Logout;
else (no)
:Show Error Message;
endif

-> Exam Administrator;

:Check Credentials;
if (Credentials Valid?) then (yes)
:Logged In;
:Check Faculty Availability;
:Allocate Faculty;
:Send Notifications;
:Logout;
else (no)
:Show Error Message;
endif

stop
@enduml

-----------------------------------------------------------------------------------
--------------------

6.sequenceDiagram Code
@startuml
skinparam backgroundColor #FFFFFF

actor HOD
actor ExamAdministrator

HOD -> HOD: Login(username, password)

HOD -> HOD: Manage Faculty
HOD -> FacultyAvailability: Check Availability()
FacultyAvailability -> HOD: Return Faculty Status
HOD -> Report: Generate Report()
Report -> HOD: Return Report Data
HOD -> HOD: Logout()

ExamAdministrator -> ExamAdministrator: Login(username, password)

ExamAdministrator -> FacultyAvailability: Check Availability()
FacultyAvailability -> ExamAdministrator: Return Faculty Status
ExamAdministrator -> FacultyAllocation: Allocate Faculty()
FacultyAllocation -> Notification: Send Notification()
Notification -> ExamAdministrator: Confirm Notification Sent
ExamAdministrator -> ExamAdministrator: Logout()
@enduml

-----------------------------------------------------------------------------------
---------------------

7.collaborationDiagram code
@startuml
skinparam backgroundColor #FFFFFF

actor HOD
actor ExamAdministrator

HOD -> FacultyManagement : manageFaculty()

HOD -> FacultyAvailability : checkAvailability()
HOD -> Report : generateReport()

ExamAdministrator -> FacultyAvailability : checkAvailability()

ExamAdministrator -> FacultyAllocation : allocateFaculty()
ExamAdministrator -> Notification : sendNotification()
ExamAdministrator -> Report : generateReport()
@enduml

-----------------------------------------------------------------------------------
-----------------------

8.ComponentDiagram Code
@startuml
skinparam backgroundColor #FFFFFF

[HOD] <<actor>>
[Exam Administrator] <<actor>>

[Faculty Management] <<component>>

[Faculty Availability] <<component>>
[Faculty Allocation] <<component>>
[Notification Service] <<component>>

' Interactions for HOD

[HOD] --> [Faculty Management] : manageFaculty()
[HOD] --> [Faculty Availability] : checkAvailability()

' Interactions for Exam Administrator

[Exam Administrator] --> [Faculty Availability] : checkAvailability()
[Exam Administrator] --> [Faculty Allocation] : allocateFaculty()
[Exam Administrator] --> [Notification Service] : sendNotification()

' Additional relationships for better clarity

[Faculty Management] --> [Faculty Availability] : updateAvailability()
[Faculty Allocation] --> [Notification Service] : notifyFaculty()
@enduml

-----------------------------------------------------------------------------------
-------------------------

9.DataFlowDiagramCode
@startuml
skinparam backgroundColor #FFFFFF
skinparam rectangle {
BackgroundColor #FFFFFF
BorderColor black
}

actor "HOD" as hod

actor "Exam Administrator" as admin

rectangle "Faculty Management" as FM {

[Manage Faculty]
[Generate Report]
}

rectangle "Faculty Availability" as FA {

[Update Availability]
[Check Availability]
}

rectangle "Faculty Allocation" as FA1 {

[Allocate Faculty]
}

rectangle "Notification Service" as N {

[Send Notification]
}

rectangle "Database" as DB {
[Faculty Data]
[Availability Data]
}

' Organizing layout

hod --> FM : manageFaculty()
hod --> FA : checkAvailability()

admin --> FA : checkAvailability()

admin --> FA1 : allocateFaculty()
admin --> N : sendNotification()

' Data flow to/from database

FM --> DB : store/update faculty data
FA --> DB : store/update availability data
FA1 --> DB : allocate faculty data
@enduml

-----------------------------------------------------------------------------------
-----------------------
10.DeploymentDiagram Code
@startuml
skinparam backgroundColor #FFFFFF
skinparam rectangle {
BackgroundColor #FFFFFF
BorderColor black
}

node "Server" {
rectangle "Application Server" {
[HOD Interface]
[Exam Administrator Interface]
[Faculty Management Service]
[Faculty Availability Service]
[Faculty Allocation Service]
[Notification Service]
}

rectangle "Database Server" {

[Database]
}
}

' Connections between nodes

[HOD Interface] --> [Faculty Management Service] : Manage Faculty
[HOD Interface] --> [Faculty Availability Service] : Check Availability

[Exam Administrator Interface] --> [Faculty Availability Service] : Check

Availability
[Exam Administrator Interface] --> [Faculty Allocation Service] : Allocate Faculty
[Exam Administrator Interface] --> [Notification Service] : Send Notification

[Faculty Management Service] --> [Database] : Store/Update Faculty Data

[Faculty Availability Service] --> [Database] : Store/Update Availability Data
[Faculty Allocation Service] --> [Database] : Allocate Faculty Data
@enduml

-----------------------------------------------------------------------------------
------------------------

11.ArchitectureDiagram Code
@startuml
skinparam backgroundColor #F5F5F5

' Define colors for each layer

skinparam rectangle {
BackgroundColor #FFF9C4 ' Light Yellow for User Interface
BorderColor #FFEB3B
}

package "User Interface" {

rectangle "HOD Interface" as HOD_UI <<UI>> {
[HOD Interface]
}
 rectangle "Exam Admin Interface" as ADMIN_UI <<UI>> {
[Exam Admin Interface]
}
}

skinparam rectangle {
BackgroundColor #FFE0B2 ' Light Orange for Application Layer
BorderColor #FF9800
}

package "Application Layer" {

rectangle "HOD Controller" as HOD_CTRL <<Controller>> {
[Handle HOD Requests]
}
rectangle "Admin Controller" as ADMIN_CTRL <<Controller>> {
[Handle Admin Requests]
}
}

skinparam rectangle {
BackgroundColor #B2EBF2 ' Light Teal for Service Layer
BorderColor #0097A7
}

package "Service Layer" {

rectangle "Faculty Management Service" as FM_SERVICE <<Service>> {
[Manage Faculty Data]
}
rectangle "Availability Service" as AVAIL_SERVICE <<Service>> {
[Check Availability]
}
rectangle "Notification Service" as NOTIF_SERVICE <<Service>> {
[Send Notifications]
}
rectangle "Report Generation Service" as REPORT_SERVICE <<Service>> {
[Generate Reports]
}
}

skinparam rectangle {
BackgroundColor #C8E6C9 ' Light Green for Data Layer
BorderColor #388E3C
}

package "Data Layer" {

rectangle "Faculty Repository" as FM_REPO <<Repository>> {
[CRUD Faculty Data]
}
rectangle "Availability Repository" as AVAIL_REPO <<Repository>> {
[CRUD Availability Data]
}
}

skinparam rectangle {
BackgroundColor #BBDEFB ' Light Blue for External Services
BorderColor #1976D2
}

package "External Services" {

 rectangle "Email Service" as EMAIL_SERVICE <<Service>> {
[Email Service]
}
rectangle "Database" as DB <<Database>> {
[Database]
}
}

' User Interface connections

HOD_UI --> HOD_CTRL : request
ADMIN_UI --> ADMIN_CTRL : request

' Controller connections

HOD_CTRL --> FM_SERVICE : manageFaculty()
HOD_CTRL --> AVAIL_SERVICE : checkAvailability()

ADMIN_CTRL --> AVAIL_SERVICE : checkAvailability()

ADMIN_CTRL --> FM_SERVICE : manageFaculty()
ADMIN_CTRL --> NOTIF_SERVICE : sendNotification()
ADMIN_CTRL --> REPORT_SERVICE : generateReport()

' Service connections

FM_SERVICE --> FM_REPO : CRUD Operations
AVAIL_SERVICE --> AVAIL_REPO : CRUD Operations

NOTIF_SERVICE --> EMAIL_SERVICE : sendEmail()

REPORT_SERVICE --> FM_REPO : generateReportData()

' Data connections

FM_REPO --> DB : store/retrieve data
AVAIL_REPO --> DB : store/retrieve data
@enduml