Scribd
Upload
6 views9 pages

Faculty Management System Diagrams

Uploaded by

dask84779
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
6 views9 pages

Faculty Management System Diagrams

Uploaded by

dask84779
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd

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

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

[Link] 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

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

[Link] 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

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

[Link] 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

-----------------------------------------------------------------------------------
------------------
[Link] 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

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

[Link] 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

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

[Link] 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

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

[Link] 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

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

[Link]
@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

-----------------------------------------------------------------------------------
-----------------------
[Link] 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

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

[Link] 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

Common questions

Powered by AI

The Exam Administrator allocates faculty according to exam needs by using the Faculty Allocation component. This includes defining parameters such as date, number of rooms, number of faculty, duration, and timing. The role is critical as it ensures that exams are supervised properly with the necessary faculty present, thus preserving the integrity and smooth operation of the examination process .

The Notification Service is responsible for sending notifications to faculty members once certain actions, such as allocation or status updates, are completed. Through the Faculty Allocation and Faculty Availability components, the Notification Service ensures that faculty are promptly informed of their responsibilities and any schedule changes. This function is crucial for effective communication and coordination, reducing the likelihood of scheduling errors and improving overall responsiveness in the faculty management system .

Activity diagrams enhance understanding of decision-making processes by visualizing the flow of actions and decisions within faculty management, such as validating credentials or selecting actions like managing faculty or checking availability. They depict decision points (e.g., validity checks) where the flow can proceed in different directions based on conditions being met or not. This helps in identifying how decisions affect subsequent actions and outcomes, clarifying potential workflows within the faculty management system .

The deployment diagrams provide insights into the system's physical architecture by showing how different components like the Application Server and Database Server are distributed across a network. They highlight interactions between user interfaces, services, and the database, detailing how data is processed and communicated across the system. Such diagrams clarify the hardware infrastructure and software architecture, crucial for understanding scalability, server load distribution, and potential bottlenecks in the faculty management system .

The HOD manages faculty data by logging in and interacting with the Faculty Management service to perform actions such as editing and deleting faculty records. This involves checking faculty availability and updating it as needed through designated interfaces and services. The significance of this process lies in ensuring that faculty resources are optimally allocated and managed within the university, maintaining efficient scheduling and availability checks to support both administrative operations and academic commitments .

In use case diagrams, faculty availability is represented as actions or tasks that users (HOD or Exam Administrator) can perform, such as checking or updating availability. These are depicted as activities linked to the respective actors, signifying user roles and responsibilities. In contrast, state diagrams focus on the process flow, illustrating the state transitions like entering a 'Check Availability' state from a 'LoggedIn' state. The state diagrams convey procedural dynamics rather than discrete tasks, emphasizing operational states and transitions over user interactions .

The class diagrams illustrate that the FacultyManagement class interacts with the FacultyAvailability class to obtain current faculty statuses. Upon modifying or confirming faculty availability, this information is then used by the Report class to generate comprehensive faculty reports. The diagrams show direct dependencies where Report generation relies on updated data provided by FacultyAvailability, revealing the structured flow and interaction necessary between faculty management tools and reporting functionalities .

In the architecture diagram, the Controllers (HOD Controller and Admin Controller) interface between the User Interface and Services layers. They handle requests from the UI, invoking various services such as Faculty Management, Availability, Notification, and Report Generation Services. These services are dependent on repositories in the Data Layer for CRUD operations, and may further depend on external services like the Email Service for sending notifications. This hierarchical dependency ensures a modular and organized flow of information and functionality, facilitating maintainability and scalability .

In the UML architecture, the database server plays a critical role in maintaining faculty and availability data by serving as the centralized repository for storing and retrieving information. The Faculty Management Service and Faculty Availability Service interact with the database to perform CRUD operations on faculty data and update availability records. This centralization facilitates consistency and reliability of data, ensuring all system interactions reflect the latest information, which is essential for generating accurate reports and coordinating faculty allocations .

The sequence diagrams effectively depict the login process for HOD and Exam Administrator by showing step-by-step interactions and responses. Each step—from entering credentials to verifying them and accessing different system features—is mapped out, providing a clear, chronological order of operations. This clarity aids in understanding the flow of information and action responses during the login process, making it easier to identify potential points of failure or delay in the system .

You might also like