JavaLabPortal: Java Practical Lab Learning & Examination Portal

🚀 Live Production Deployment: https://javalabportal-production.up.railway.app

Important

🔑 Default Login Credentials for Live Testing & Evaluation

Evaluators and faculty can immediately test both roles on the live portal using the following seeded credentials:

Persona / Role	Role Selection	Username Field	Password Field	Access & Privileges
Teacher (Admin)	Select Teacher	`teacher`	`teacher123`	Full faculty privileges: Manage students, batches, custom lab experiments, theory notes, and student feedback.
Student (Enrolled)	Select Student	`Krishna Gupta`	`24EARAD083`	Student self-service: View batch (`AI&DS-A`), execute syllabus experiments, live calculator, theory notes, and submit feedback.
Student (Alternate)	Select Student	`Aman Sharma`	`24EARAD045`	Alternate student account enrolled in `CS-A` batch.

Note for Student Login: Enter the registered Student Name in the Username field, and the official RTU Roll Number in the Password field.

Week 1: Project Administration & Abstract

Project Administration

Project Guide: Er. Ram Babu Buri

Department: Artificial Intelligence & Data Science
Specializations: Java EE, JSP-Servlet, MySQL, Software Engineering & System Architecture

Team Members

Name	Role / Layer	Module Ownership	Enrollment / Roll No	Email
Krishna Gupta	Project Lead / Frontend 1	Module 1: Portal Shell & Lab Experiments Hub	24E1ARADM40P083/24EARAD083	16krishnagupta06@gmail.com
Karan Ramlakhani	Frontend Developer 2	Module 2: Management Forms & Theory UI	24E1ARADM30P076/24EARAD076	karanramlakhani45@gmail.com
Kanishq Chasta	Backend Developer 1	Module 3: Security, Auth & Controllers	24E1ARADM40P074/24EARAD074	chastapriyanshu14@gmail.com
Jayesh Sharma	Backend Developer 2	Module 4: Calculator & Experiment Services	24E1ARADM40P070/24EARAD070	jayeshpandit2505@gmail.com
Juned Hussain	Database Engineer	Module 5: Database Persistence & DAOs	24E1ARADM30P072/24EARAD072	junedhussain294@gmail.com

Abstract

This project introduces JavaLabPortal, a centralized web-based laboratory learning and practical evaluation platform engineered to overcome the constraints of traditional, manual engineering practical lab record keeping and evaluation for Rajasthan Technical University (RTU) 5th Semester students. While standard manual lab records lack interactive execution, dynamic code visualization, and transparent student performance tracking, JavaLabPortal establishes an institutional environment for engineering students to execute syllabus programs, study unit-wise theory content, calculate arithmetic expressions, and receive instructor feedback.

The system is built upon a standard 3-tier Model-View-Controller (MVC) architecture deployed on an Apache Tomcat 9 web server. It incorporates a relational MySQL database adhering to Third Normal Form (3NF) to manage students, faculty accounts, academic batches, syllabus experiments, and course notes. Java Servlets orchestrate business transactions and route requests, while standard Java Server Pages (JSP) and native responsive system typography deliver clean, accessible presentation views. Access control is managed through a central HTTP servlet filter enforcing Role-Based Access Control (RBAC) across Teacher and Student personas.

Furthermore, JavaLabPortal bridges practical demonstration with continuous institutional feedback. Teachers can dynamically publish custom lab assignments and theory lecture notes directly into MySQL without code redeployment, while students execute real-time arithmetic calculations, review interactive experiment previews, and submit laboratory evaluations. The resulting system modernizes collegiate practical education, providing a reliable, automated platform for practical viva preparation and coursework evaluation.

You can access the official Project Abstract (PDF).

Week 2: User Roles, SRS & System Architecture

User Roles

JavaLabPortal enforces strict Role-Based Access Control (RBAC) at the servlet controller layer utilizing AccessControlFilter and server-managed HTTP sessions.

Teacher (Administrator): Privileged faculty users who can create and manage class sections, register and update student profiles, assign custom lab experiments, publish unit-wise theory topics, and review student feedback.
Student: Authenticated students identified by their official RTU Roll Number. Students can browse the complete lab syllabus (Experiments 1 to 10), view interactive GUI previews, execute arithmetic expressions, read theory notes, and submit ratings.
Guest / Unauthenticated User: Permitted to view public landing pages, lab curriculum summaries, and the secure login portal. Protected administrative and student routes redirect unauthenticated users to the login screen.

SRS Document

You can access the complete Project SRS Document (PDF).

Architecture & Core Modules

The JavaLabPortal architecture operates on a 3-tier MVC pattern, separating the presentation layer (JSP Views), controller layer (Java Servlets & Filters), and persistence layer (Model POJOs & JDBC DAOs).

[ Client Browser (JSP Views) ] 
             │
             ▼  (HTTP GET / POST)
[ Controller Layer: AccessControlFilter & Servlets ]
             │
             ▼  (Data Transfer / Business Logic)
[ Model & Persistence: POJOs & Data Access Objects (DAOs) ]
             │
             ▼  (JDBC PreparedStatement)
[ Relational Storage: MySQL Database 8.0 ]

Functional Modules

Module 1: Frontend Portal Shell & Experiment Hub (Krishna Gupta): Renders the shared UI shell (header.jspf, footer.jspf), landing dashboard (index.jsp), role-based authentication portal (login.jsp), error handler (error.jsp), and individual interactive practical experiment interfaces (exp1.jsp through exp10.jsp, arithmetic.jsp, exp5.jsp). All 10 experiments feature desktop window frames, live interactive demonstrations, and collapsible syntax-highlighted Java source code accordions.
Module 2: Frontend Management Forms & Theory Views (Karan Ramlakhani): Renders administrative student tables (studentList.jsp), registration dialogs (addStudent.jsp, updateStudent.jsp), class section management (manageClasses.jsp), theory cards (theoryList.jsp), custom assignment forms (addExperiment.jsp), and role-based feedback dashboards (feedback.jsp, feedbackList.jsp) with student-only registration, faculty search, and Excel/PDF export.
Module 3: Security, Authentication & Management Controllers (Kanishq Chasta): Intercepts incoming HTTP requests via AccessControlFilter.java, validates credentials and session state via LoginServlet.java and LogoutServlet.java, enforces single active device session locking via ActiveSessionManager.java, processes student lifecycle in StudentServlet.java, manages class batches in ClassServlet.java, and configures web.xml.
Module 4: Calculator Model & Laboratory Services (Jayesh Sharma): Encapsulates mathematical parsing and operator precedence in CalculatorModel.java, evaluates arithmetic requests via CalculatorServlet.java and ArithmeticServlet.java, handles Employee JDBC CRUD via EmployeeServlet.java, dispatches syllabus content in ExperimentServlet.java and TheoryServlet.java, and manages role-based evaluation & CSV exports in FeedbackServlet.java.
Module 5: Database Persistence & DAO Architecture (Juned Hussain): Maintains the relational schema database.sql, implements singleton connection pooling in DBConnection.java, provides input sanitization and resource safety in PortalHelper.java, encapsulates entity POJOs, and executes SQL operations across all DAO classes.

Relational Database Strategy

The system utilizes a relational database model in MySQL 8.0 to guarantee ACID compliance, transactional integrity, and referential constraints across student enrollments and lab assignments.

Normalization: Normalized to Third Normal Form (3NF) to eliminate data redundancy across academic years and student profiles.
Parameterized Queries: Every database interaction is executed via JDBC PreparedStatement to prevent SQL Injection vulnerabilities.
Connection Management: DBConnection.java provides singleton connection acquisition, while PortalHelper.safeClose() guarantees that ResultSet, PreparedStatement, and Connection instances close in finally blocks to prevent resource leaks.
Indexing: Explicit indexes on roll_number, username, and foreign keys (class_id) guarantee sub-millisecond query execution.

Non-Functional Requirements

Performance: Average server response time for database queries and page dispatches remains under 50 milliseconds on Apache Tomcat 9.
Security: Role permissions are verified on every protected HTTP request. Input strings are sanitized via PortalHelper.cleanInput() to neutralize Cross-Site Scripting (XSS).
Reliability: Custom error handlers in web.xml trap 404 (Not Found) and 500 (Internal Server Error) exceptions, redirecting users to error.jsp without exposing internal stack traces.
Portability: Built strictly using Java EE standards (Servlet 4.0, JSP 2.3) and standard SQL, enabling platform-independent deployment across Windows and Linux environments.

Week 3: UML Architecture & System Design

To provide an industry-grade software engineering specification, the architectural design of JavaLabPortal encompasses both Structural (Static) and Behavioral (Dynamic) UML 2.5 modeling dimensions. This suite provides complete coverage of system entities, actor privileges, runtime communication lifecycles, and deployment topology.

1. Class Diagram (Static Structural Model)

The Class Diagram models the core domain JavaBeans (POJOs), Data Access Objects (DAOs), Controller Servlets, Security Filters, and database utility singletons adhering to the 3-tier Model-View-Controller (MVC) architecture.

classDiagram
    direction TB

    class DBConnection {
        -Connection connection
        +getConnection() Connection
        +closeConnection() void
    }

    class PortalHelper {
        +safeClose(ResultSet, Statement, Connection) void
        +cleanInput(String) String
        +isValidRollNumber(String) boolean
    }

    class Teacher {
        -int id
        -String username
        -String password
        -String name
        +getId() int
        +getUsername() String
        +getPassword() String
        +getName() String
    }

    class Student {
        -int id
        -String rollNumber
        -String name
        -String email
        -int classId
        -String className
        +getId() int
        +getRollNumber() String
        +getName() String
        +getEmail() String
        +getClassId() int
        +getClassName() String
    }

    class ClassSection {
        -int id
        -String className
        +getId() int
        +getClassName() String
    }

    class Experiment {
        -int id
        -String title
        -String description
        -String type
        -String liveUrl
        -int orderNo
        +getTitle() String
        +getDescription() String
    }

    class TheoryContent {
        -int id
        -int unitNo
        -String topic
        -String content
        +getUnitNo() int
        +getTopic() String
    }

    class Feedback {
        -int id
        -String studentName
        -String course
        -String feedbackText
        -int rating
        +getStudentName() String
        +getRating() int
    }

    class TeacherDAO {
        +findByUsername(String) Teacher
        +validateTeacher(String, String) boolean
    }

    class StudentDAO {
        +addStudent(Student) void
        +updateStudent(Student) void
        +deleteStudent(int) void
        +getStudentById(int) Student
        +getStudentByName(String) Student
        +getStudentByRollNumber(String) Student
        +getAllStudents() List~Student~
    }

    class ClassSectionDAO {
        +getAllClassSections() List~ClassSection~
        +addClassSection(String) void
        +deleteClassSection(int) void
    }

    class ExperimentDAO {
        +getAllExperiments() List~Experiment~
        +addExperiment(Experiment) void
    }

    class TheoryContentDAO {
        +getAllTheory() List~TheoryContent~
        +addTheory(TheoryContent) void
    }

    class FeedbackDAO {
        +addFeedback(Feedback) void
        +getAllFeedback() List~Feedback~
        +searchFeedback(String, String, Integer) List~Feedback~
    }

    class EmployeeDAO {
        +save(Employee) void
        +findById(String) Employee
        +update(Employee) void
        +delete(String) void
        +getAll() List~Employee~
    }

    class AccessControlFilter {
        +doFilter(ServletRequest, ServletResponse, FilterChain) void
    }

    class LoginServlet {
        +doPost(HttpServletRequest, HttpServletResponse) void
    }

    class StudentServlet {
        +doGet(HttpServletRequest, HttpServletResponse) void
        +doPost(HttpServletRequest, HttpServletResponse) void
    }

    class ClassServlet {
        +doGet(HttpServletRequest, HttpServletResponse) void
        +doPost(HttpServletRequest, HttpServletResponse) void
    }

    class CalculatorServlet {
        +doPost(HttpServletRequest, HttpServletResponse) void
    }

    class CalculatorModel {
        -double currentResult
        +evaluate(String) double
        +calculate(double, double, String) double
    }

    DBConnection <.. TeacherDAO : uses
    DBConnection <.. StudentDAO : uses
    DBConnection <.. ClassSectionDAO : uses
    DBConnection <.. ExperimentDAO : uses
    DBConnection <.. TheoryContentDAO : uses
    DBConnection <.. FeedbackDAO : uses
    PortalHelper <.. StudentDAO : sanitizes
    StudentDAO ..> Student : maps
    TeacherDAO ..> Teacher : maps
    ClassSectionDAO ..> ClassSection : maps
    ExperimentDAO ..> Experiment : maps
    TheoryContentDAO ..> TheoryContent : maps
    FeedbackDAO ..> Feedback : maps
    StudentServlet ..> StudentDAO : calls
    ClassServlet ..> ClassSectionDAO : calls
    LoginServlet ..> TeacherDAO : authenticates
    LoginServlet ..> StudentDAO : authenticates
    CalculatorServlet ..> CalculatorModel : invokes
    AccessControlFilter ..> LoginServlet : guards

2. Use Case Diagram (Functional Scope & Actor Boundaries)

The Use Case Diagram defines functional boundaries between administrative faculty (Teacher Actor), self-service learners (Student Actor), and public visitors.

flowchart LR
    subgraph Actors["👥 System Actors"]
        Teacher["👨‍🏫 Teacher (Faculty Admin)"]
        Student["👨‍🎓 Student (Enrolled)"]
        Visitor["👤 Public / Guest Visitor"]
    end

    subgraph JavaLabPortal["🏫 Java Lab Portal Functional Modules"]
        UC1(["🔐 Authenticate & Login"])
        UC2(["🚪 Terminate Session & Logout"])
        UC3(["👥 Manage Student Records (CRUD)"])
        UC4(["🏷️ Allocate Academic Class Batches"])
        UC5(["🧪 Author Custom Lab Experiments"])
        UC6(["📚 Publish Theory Lecture Topics"])
        UC7(["⭐ Review Student Lab Feedback"])
        UC8(["🔬 Browse Syllabus & Swing Demos"])
        UC9(["🧮 Execute Interactive Arithmetic Lab"])
        UC10(["📝 Read Unit Theory Notes"])
        UC11(["💬 Submit Practical Feedback"])
        UC12(["🌐 View Public Curriculum Shell"])
    end

    Visitor --> UC12
    Visitor --> UC1

    Teacher --> UC1
    Teacher --> UC2
    Teacher --> UC3
    Teacher --> UC4
    Teacher --> UC5
    Teacher --> UC6
    Teacher --> UC7

    Student --> UC1
    Student --> UC2
    Student --> UC8
    Student --> UC9
    Student --> UC10
    Student --> UC11

3. Sequence Diagram: Role-Based Authentication & Session Handshake

Illustrates the exact runtime handshake during authentication: credential verification via PreparedStatements, HTTP session initialization with role tokens, and selective URL redirection.

sequenceDiagram
    autonumber
    actor User as Client Web Browser
    participant Filter as AccessControlFilter
    participant Login as LoginServlet
    participant TDAO as TeacherDAO
    participant SDAO as StudentDAO
    participant Pool as DBConnection
    participant DB as MySQL 8.0 Engine
    participant Session as HttpSession

    User->>Filter: POST /LoginServlet (role, username, password)
    Note over Filter: Whitelisted URL: pass through without session check
    Filter->>Login: doFilter() -> forward to LoginServlet
    
    alt Role == TEACHER
        Login->>TDAO: findByUsername(username)
        TDAO->>Pool: getConnection()
        Pool->>DB: SELECT * FROM teacher WHERE username = ?
        DB-->>TDAO: ResultSet (id, username, password, name)
        TDAO-->>Login: Teacher POJO
        alt Password Verification Matches
            Login->>Session: setAttribute("role", "TEACHER")
            Login->>Session: setAttribute("name", teacher.getName())
            Login-->>User: 302 Redirect -> index.jsp (Teacher Shell)
        else Password Invalid
            Login-->>User: 302 Redirect -> login.jsp?error=Invalid+credentials
        end
    else Role == STUDENT
        Login->>SDAO: getStudentByName(username)
        SDAO->>Pool: getConnection()
        SDAO->>DB: SELECT s.*, c.class_name FROM student s JOIN class_section c...
        DB-->>SDAO: ResultSet (name, roll_number, class_name)
        SDAO-->>Login: Student POJO
        alt Roll Number Matches
            Login->>Session: setAttribute("role", "STUDENT")
            Login->>Session: setAttribute("name", student.getName())
            Login->>Session: setAttribute("rollNumber", student.getRollNumber())
            Login->>Session: setAttribute("className", student.getClassName())
            Login-->>User: 302 Redirect -> index.jsp (Student Workspace)
        else Roll Number Invalid
            Login-->>User: 302 Redirect -> login.jsp?error=Invalid+credentials
        end
    end

4. Sequence Diagram: Student Administration & Class Allocation Workflow

Captures transactional CRUD processing: role guard validation, regex format validation via PortalHelper, transactional database writes, and dynamic table view re-rendering.

sequenceDiagram
    autonumber
    actor Teacher as Faculty Admin
    participant Filter as AccessControlFilter
    participant Servlet as StudentServlet
    participant SDAO as StudentDAO
    participant Pool as DBConnection
    participant DB as MySQL 8.0 Engine
    participant View as studentList.jsp

    Teacher->>Filter: POST /StudentServlet?action=add (name, rollNumber, classId)
    Filter->>Filter: Verify session.getAttribute("role") == "TEACHER"
    Filter->>Servlet: Authorized -> forward to doPost()
    
    Servlet->>Servlet: Validate rollNumber format (PortalHelper.isValidRollNumber)
    Servlet->>SDAO: addStudent(new Student(...))
    SDAO->>Pool: getConnection()
    SDAO->>DB: INSERT INTO student (name, roll_number, class_id) VALUES (?, ?, ?)
    DB-->>SDAO: 1 Row Affected
    SDAO-->>Servlet: Success Confirmation
    
    Servlet->>SDAO: getAllStudents()
    SDAO->>DB: SELECT s.id, s.name, s.roll_number, c.class_name FROM student s JOIN class_section c ON s.class_id = c.id
    DB-->>SDAO: List<Student> Roster
    SDAO-->>Servlet: studentList
    
    Servlet->>Servlet: request.setAttribute("students", studentList)
    Servlet->>View: RequestDispatcher.forward(request, response)
    View-->>Teacher: Re-render updated student roster with batch badges

5. Sequence Diagram: Interactive Mathematical Calculator & Lab Practical Evaluator

Demonstrates the client-to-engine computation flow: expression validation, Shunting-Yard tokenization, operator stack evaluation, and session history management.

sequenceDiagram
    autonumber
    actor Student as Student Browser
    participant JSP as arithmetic.jsp
    participant Filter as AccessControlFilter
    participant CalcServlet as CalculatorServlet
    participant Engine as CalculatorModel
    participant Session as HttpSession

    Student->>JSP: Submit Expression: "(15 * 4) + 120 / 4"
    Student->>Filter: POST /CalculatorServlet (expression)
    Filter->>Filter: Verify active authenticated session
    Filter->>CalcServlet: forward request to servlet
    
    CalcServlet->>Engine: evaluate("(15 * 4) + 120 / 4")
    Note over Engine: Tokenize input string<br/>Infix-to-Postfix conversion (Shunting-Yard)<br/>Stack-based arithmetic resolution
    Engine->>Engine: Check division-by-zero & expression syntax
    Engine-->>CalcServlet: Return calculated double: 90.0
    
    CalcServlet->>Session: Append calculation to session history list
    CalcServlet->>CalcServlet: request.setAttribute("result", 90.0)
    CalcServlet->>JSP: forward to arithmetic.jsp
    JSP-->>Student: Display live evaluated answer & interactive history log

6. Activity Diagram: Security Interception & RBAC Filter Pipeline

Flowchart detailing the decision-making pipeline inside AccessControlFilter.java, including static asset bypass, URL whitelisting, session timeout detection, and role privilege verification.

flowchart TD
    Start(["Incoming HTTP Request"]) --> CheckStatic{"Is Static Asset? (.css, .js, .png, .svg)"}
    
    CheckStatic -- "Yes" --> AllowPass["Pass to Container FilterChain"]
    CheckStatic -- "No" --> CheckWhitelist{"Is URI Whitelisted? (login.jsp, LoginServlet, index.jsp)"}
    
    CheckWhitelist -- "Yes" --> AllowPass
    CheckWhitelist -- "No" --> CheckSession{"Is HTTP Session Active? (session != null && session.role != null)"}
    
    CheckSession -- "No" --> RedirectLogin["Redirect to login.jsp with Session Timeout Alert"]
    
    CheckSession -- "Yes" --> CheckRole{"User Role Check"}
    
    CheckRole -- "Role == TEACHER" --> TeacherRoutes{"Target Route Type"}
    TeacherRoutes -- "Admin Action (Classes, Students, Theory)" --> AllowPass
    TeacherRoutes -- "Other Route" --> AllowPass
    
    CheckRole -- "Role == STUDENT" --> StudentRoutes{"Target Route Type"}
    StudentRoutes -- "Student Authorized (Experiments, Calculator, Feedback)" --> AllowPass
    StudentRoutes -- "Privileged Action (Class / Student Deletion)" --> BlockAccess["Redirect to index.jsp with HTTP 403 Forbidden Alert"]
    
    AllowPass --> End(["Serve Target Resource / Servlet Dispatcher"])
    RedirectLogin --> End
    BlockAccess --> End

7. Component & Deployment Architecture Diagram (Physical & Logical 3-Tier Topology)

Illustrates the physical nodes, execution environments, network ports, and logical software boundaries across Presentation, Application, and Persistence tiers.

flowchart TB
    subgraph ClientTier["💻 Tier 1: Client Presentation Layer"]
        Browser["Modern Web Browser (Chrome, Firefox, Edge, Safari)"]
        UI_Components["JSP 2.3 Templates & Native Responsive UI<br/>(header.jspf, footer.jspf, index.jsp, experiments.jsp, arithmetic.jsp)"]
        Browser --- UI_Components
    end

    subgraph AppTier["⚙️ Tier 2: Application Controller & Business Logic (Apache Tomcat 9 Container)"]
        subgraph SecurityModule["Security & Interception"]
            Filter["AccessControlFilter.java<br/>(RBAC & Session Token Guard)"]
        end

        subgraph ControllerModule["Servlet Dispatchers (Java Servlet 4.0)"]
            AuthServlets["LoginServlet.java<br/>LogoutServlet.java"]
            AdminServlets["StudentServlet.java<br/>ClassServlet.java"]
            LabServlets["ExperimentServlet.java<br/>TheoryServlet.java<br/>FeedbackServlet.java"]
            CalcServlets["CalculatorServlet.java<br/>ArithmeticServlet.java"]
        end

        subgraph ServiceModelModule["Domain Models & Mathematical Engine"]
            CalcEngine["CalculatorModel.java<br/>(Expression Parsing & Operator Stack)"]
            POJOs["JavaBeans POJOs<br/>(Student, Teacher, ClassSection, Experiment, TheoryContent, Feedback)"]
        end

        subgraph DAOLayer["Data Access Object (DAO) Persistence Layer"]
            DAOs["TeacherDAO | StudentDAO | ClassSectionDAO<br/>ExperimentDAO | TheoryContentDAO | FeedbackDAO"]
            Pool["DBConnection.java (Connection Pool & Resource Manager)<br/>PortalHelper.java (SQL Injection & XSS Sanitizer)"]
        end

        Filter --> ControllerModule
        AuthServlets --> DAOs
        AdminServlets --> DAOs
        LabServlets --> DAOs
        CalcServlets --> CalcEngine
        DAOs --> POJOs
        DAOs --> Pool
    end

    subgraph DataTier["🗄️ Tier 3: Enterprise Database Persistence Layer (MySQL 8.0 Cloud Server)"]
        MySQL[("MySQL 8.0 Relational Engine<br/>ACID Compliant Storage")]
        Tables[("3NF Normalized Relational Tables<br/>teacher, student, class_section,<br/>experiment, theory_content, feedback")]
        MySQL --- Tables
    end

    UI_Components -->|"HTTP GET / POST (TLS Port 443 / 8080)"| Filter
    Pool -->|"JDBC Connector/J 8.0 (TCP Port 3306 / SSL)"| MySQL

8. State Machine Diagram: User Authentication & Session Lifecycle

Models user state transitions from anonymous visitor, through authentication credential resolution, to role-governed active session states, and eventual termination upon logout or timeout.

stateDiagram-v2
    [*] --> Guest: Visit Portal URL

    Guest --> Authenticating: Submit Login Credentials
    
    state Authenticating {
        [*] --> Verifying
        Verifying --> TeacherAuth: Role == TEACHER
        Verifying --> StudentAuth: Role == STUDENT
        TeacherAuth --> Success: Valid Password
        TeacherAuth --> Failure: Invalid Password
        StudentAuth --> Success: Valid Roll Number
        StudentAuth --> Failure: Invalid Roll Number
    }

    Authenticating --> Guest: Authentication Failure (Redirect to login.jsp with alert)
    
    Authenticating --> ActiveTeacherSession: Teacher Credentials Validated
    Authenticating --> ActiveStudentSession: Student Credentials Validated

    state ActiveTeacherSession {
        TeacherHome --> ClassManagement
        ClassManagement --> StudentCRUD
        StudentCRUD --> ExperimentAuthoring
        ExperimentAuthoring --> FeedbackReview
    }

    state ActiveStudentSession {
        StudentHome --> ExperimentCatalog
        ExperimentCatalog --> ArithmeticEvaluator
        ArithmeticEvaluator --> TheoryNotes
        TheoryNotes --> FeedbackSubmission
    }

    ActiveTeacherSession --> SessionTimedOut: Inactive for 30 Minutes
    ActiveStudentSession --> SessionTimedOut: Inactive for 30 Minutes
    
    ActiveTeacherSession --> Terminated: Explicit Logout (/LogoutServlet)
    ActiveStudentSession --> Terminated: Explicit Logout (/LogoutServlet)
    
    SessionTimedOut --> Guest: Invalidate Session & Redirect to login.jsp
    Terminated --> Guest: Clear Cache-Control Headers & Invalidate Session

Week 4: Database Design & UI Mock-ups

1. Database Architecture & MySQL Relational Schema

A. Relational Tables Breakdown

teachers Table: Administrative faculty credentials.
- id (INT, PRIMARY KEY, AUTO_INCREMENT)
- username (VARCHAR(50), UNIQUE, NOT NULL)
- password (VARCHAR(100), NOT NULL)
- name (VARCHAR(100), NOT NULL)
- created_at (TIMESTAMP, DEFAULT CURRENT_TIMESTAMP)
class_sections Table: Academic batches and sections.
- id (INT, PRIMARY KEY, AUTO_INCREMENT)
- class_name (VARCHAR(50), UNIQUE, NOT NULL)
- created_at (TIMESTAMP, DEFAULT CURRENT_TIMESTAMP)
students Table: Enrolled student records.
- id (INT, PRIMARY KEY, AUTO_INCREMENT)
- roll_number (VARCHAR(30), UNIQUE, NOT NULL)
- name (VARCHAR(100), NOT NULL)
- email (VARCHAR(100))
- class_id (INT, FOREIGN KEY -> class_sections.id)
- created_at (TIMESTAMP, DEFAULT CURRENT_TIMESTAMP)
experiments Table: Syllabus and custom lab practicals.
- id (INT, PRIMARY KEY, AUTO_INCREMENT)
- title (VARCHAR(150), NOT NULL)
- aim (TEXT, NOT NULL)
- description (TEXT)
- order_no (INT, DEFAULT 0)
- is_active (BOOLEAN, DEFAULT TRUE)
theory_content Table: Unit-wise lecture notes.
- id (INT, PRIMARY KEY, AUTO_INCREMENT)
- title (VARCHAR(150), NOT NULL)
- content (TEXT, NOT NULL)
- unit_no (INT, DEFAULT 1)
- created_at (TIMESTAMP, DEFAULT CURRENT_TIMESTAMP)
feedback Table: Student ratings and reviews with instructor evaluation.
- id (INT, PRIMARY KEY, AUTO_INCREMENT)
- student_name (VARCHAR(100), NOT NULL)
- course (VARCHAR(100), NOT NULL)
- faculty_name (VARCHAR(100), NOT NULL)
- feedback_text (TEXT, NOT NULL)
- rating (INT, CHECK (rating BETWEEN 1 AND 5))
- submitted_at (TIMESTAMP, DEFAULT CURRENT_TIMESTAMP)
employee Table (Experiment 5 - JDBC CRUD): Desktop Swing employee registration persistence.
- empid (VARCHAR(50), PRIMARY KEY)
- empname (VARCHAR(100), NOT NULL)
- empno (VARCHAR(50), NOT NULL)

B. Entity-Relationship (ER) Diagram

erDiagram
    CLASS_SECTIONS ||--o{ STUDENTS : "enrolls"
    TEACHERS ||--o{ EXPERIMENTS : "assigns"
    TEACHERS ||--o{ THEORY_CONTENT : "publishes"

    CLASS_SECTIONS {
        int id PK
        string class_name UK
        timestamp created_at
    }

    STUDENTS {
        int id PK
        string roll_number UK
        string name
        string email
        int class_id FK
        timestamp created_at
    }

    TEACHERS {
        int id PK
        string username UK
        string password
        string name
        timestamp created_at
    }

    EXPERIMENTS {
        int id PK
        string title
        string aim
        text description
        int order_no
        boolean is_active
    }

    THEORY_CONTENT {
        int id PK
        string title
        text content
        int unit_no
        timestamp created_at
    }

    FEEDBACK {
        int id PK
        string student_name
        int rating
        text comments
        timestamp created_at
    }

2. User Interface (UI) Mock-ups & Production Screenshots

The JavaLabPortal web frontend is crafted using accessible HTML5, custom Bootstrap 5 design tokens, and responsive layout containers to provide distinct, role-tailored workspaces for Students and Faculty.

A. Secure Authentication & Role Selection (`login.jsp`)

Centered authentication modal featuring tabbed role switching (Teacher vs. Student), session status notifications, and clean credential input forms.

B. Teacher Administration Command Dashboard (`index.jsp`)

Master faculty portal featuring authenticated user telemetry (Ram Babu Buri TEACHER), administrative navigation links, and modular shortcuts for student management, class batches, theory authoring, and experiment deployment.

C. Student Self-Service Workspace (`index.jsp`)

Role-restricted student interface displaying enrolled batch metadata (Krishna Gupta STUDENT - AI&DS A), direct access to practical lab exercises, faculty study material, and online feedback forms.

D. Class Administration & Batch Allocation (`manageClasses.jsp`)

Real-time section management console enabling instructors to define departmental divisions (AI&DS-A, AI&DS-B, CS-A, CS-B, IT) before allocating student enrollments.

E. Interactive Lab Experiments Catalog (`experiments.jsp`)

Comprehensive laboratory catalog presenting all RTU Advance Java practicals with live execution badges (LIVE HERE), syllabus-mapped descriptions, and interactive browser execution triggers (Try it live).

Week 5: Project Structure & Module 1 Implementation

Project Directory Structure

JavaLabPortal/
|-- docs/
|   |-- modules/
|   |   |-- Module1_Frontend_PortalAndExperiments.md
|   |   |-- Module2_Frontend_ManagementAndTheory.md
|   |   |-- Module3_Backend_AuthAndManagement.md
|   |   |-- Module4_Backend_ExperimentsAndServices.md
|   |   \-- Module5_Database_PersistenceLayer.md
|   |-- screenshots/
|   |   |-- ui_login.png
|   |   |-- ui_teacher_dashboard.png
|   |   |-- ui_student_dashboard.png
|   |   |-- ui_manage_classes.png
|   |   \-- ui_lab_experiments.png
|   |-- JavaLabPortal_Abstract.pdf
|   |-- JavaLabPortal_SRS.pdf
|   |-- JavaLabPortal_Project_Report.pdf
|   |-- JavaLabPortal_Research_Paper.pdf
|   |-- JavaLabPortal_Presentation.pptx
|   |-- RESEARCH_PAPERS_INDEX.md
|   \-- WEEKLY_REPORTS_WEEK_1_TO_12.md
|-- src/main/java/com/javalab/
|   |-- calc/
|   |   \-- CalculatorModel.java
|   |-- dao/
|   |   |-- ClassSectionDAO.java
|   |   |-- EmployeeDAO.java
|   |   |-- ExperimentDAO.java
|   |   |-- FeedbackDAO.java
|   |   |-- StudentDAO.java
|   |   |-- TeacherDAO.java
|   |   \-- TheoryContentDAO.java
|   |-- db/
|   |   |-- DBConnection.java
|   |   \-- DBMigrator.java
|   |-- filter/
|   |   \-- AccessControlFilter.java
|   |-- model/
|   |   |-- ClassSection.java
|   |   |-- Employee.java
|   |   |-- Experiment.java
|   |   |-- Feedback.java
|   |   |-- Student.java
|   |   |-- Teacher.java
|   |   \-- TheoryContent.java
|   |-- servlet/
|   |   |-- ArithmeticServlet.java
|   |   |-- CalculatorServlet.java
|   |   |-- ClassServlet.java
|   |   |-- EmployeeServlet.java
|   |   |-- ExperimentServlet.java
|   |   |-- FeedbackServlet.java
|   |   |-- LoginServlet.java
|   |   |-- LogoutServlet.java
|   |   |-- RegisterServlet.java
|   |   |-- StudentServlet.java
|   |   \-- TheoryServlet.java
|   \-- util/
|       |-- ActiveSessionManager.java
|       \-- PortalHelper.java
|-- src/main/webapp/
|   |-- classes/manageClasses.jsp
|   |-- experiments/addExperiment.jsp
|   |-- students/ (addStudent.jsp, studentList.jsp, updateStudent.jsp)
|   |-- theory/ (addTheory.jsp, theoryList.jsp)
|   |-- WEB-INF/web.xml
|   |-- images/ (Krishna_Gupta.png, Ram_Babu_Buri_Sir.jpg)
|   |-- arithmetic.jsp (Exp 8: Servlet Input/Output)
|   |-- error.jsp
|   |-- exp1.jsp - exp4.jsp (Exp 1-4 Swing Replicas)
|   |-- exp5.jsp (Exp 5: Employee Registration Desk JDBC CRUD)
|   |-- exp6-preview.jsp (Exp 6: TCP Socket Network Chat)
|   |-- exp7-preview.jsp (Exp 7: RMI Distributed Calculator)
|   |-- exp9.jsp (Exp 9: JSP Login Validation)
|   |-- experiments.jsp (Interactive Experiments Catalog)
|   |-- feedback.jsp (Exp 10: Role-Based Feedback System)
|   |-- feedbackList.jsp (Exp 10: Teacher Review & CSV Export)
|   |-- footer.jspf, header.jspf
|   |-- index.jsp, login.jsp
|-- .dockerignore
|-- .gitignore
|-- Dockerfile
|-- database.sql
\-- README.md

Member 1: Krishna Gupta (Portal Shell & Experiments Hub)

Role & Scope of Work

Frontend UI Shell: Developed shared layout templates header.jspf and footer.jspf, landing page index.jsp, and secure login interface login.jsp.
Lab Experiment Views: Developed practical demonstrations for RTU syllabus experiments (exp1.jsp through exp4.jsp, exp6-preview.jsp, exp7-preview.jsp, exp9.jsp).
Calculator Interface: Implemented interactive numeric keypad and operation display in arithmetic.jsp.

Problems & Challenges Faced

Responsive Navbar Collapse: Mobile viewports caused menu items to overlap; resolved by implementing a pure CSS toggle and flexbox wrapper.
Swing GUI Simulation in Web: Recreating Java Swing desktop GUIs (Experiment 6 & 7) in browser views required custom CSS card frames and JavaScript event simulation.
Session Timeout Feedback: Handling expired user sessions cleanly without throwing JSP 500 errors; added session checks redirecting to error.jsp.

What Was Completed

Responsive, cohesive UI shell utilizing native system typography (Segoe UI, Tahoma).
10 interactive practical experiment demonstration pages mapped to the RTU syllabus.
Clean error handling interface and interactive arithmetic evaluator view.

Week 6: Module 2 & Module 3 Implementation

Member 2: Karan Ramlakhani (Management Forms & Theory Views)

Role & Scope of Work

Student Management UI: Built studentList.jsp with responsive tables, search filters, and action triggers for edit and delete.
Enrollment Forms: Built addStudent.jsp and updateStudent.jsp with client-side regex input validation.
Class & Theory Views: Built manageClasses.jsp section dashboard, theoryList.jsp card view, and addTheory.jsp topic creator.
Feedback Views: Developed feedback.jsp with 5-star rating selectors and feedbackList.jsp review dashboard.

Problems & Challenges Faced

Form Field Pre-Population: Passing existing student attributes into updateStudent.jsp modal without reloading the parent list.
Table Overflow on Mobile: Wide student data tables broke mobile screen layouts; resolved using responsive overflow wrappers.
Star Rating UX: Designing a lightweight, dependency-free CSS star rating widget that binds values cleanly to form inputs.

What Was Completed

Complete student lifecycle forms (List, Add, Update, Search) with instant validation.
Class section management interface displaying enrolled student count badges.
Theory lecture notes reader and student feedback review dashboard.

Member 3: Kanishq Chasta (Security, Authentication & Controllers)

Role & Scope of Work

Security Interceptor: Implemented AccessControlFilter.java to guard protected routes against unauthenticated access.
Authentication Servlets: Built LoginServlet.java (credential verification, role assignment) and LogoutServlet.java (session invalidation).
Management Controllers: Implemented StudentServlet.java (CRUD action dispatcher) and ClassServlet.java (section management).
Web Deployment Descriptor: Configured servlet endpoints, filter mappings, and custom error pages in web.xml.

Problems & Challenges Faced

Infinite Redirection Loops: Initial filter configuration blocked static assets (CSS, JS) from loading on login.jsp; resolved by implementing a strict public URL whitelist.
Session Hijacking Prevention: Enforced HTTP cache-control clearing headers (no-cache, no-store) on logout to prevent browser back-button access.
Referential Integrity on Deletion: Prevented deletion of class sections when students are actively enrolled by implementing dependency checks in ClassServlet.

What Was Completed

Session-based AccessControlFilter securing teacher administrative routes.
Robust authentication flow managing TEACHER and STUDENT roles.
Complete servlet controllers handling student CRUD and class batch allocations.

Week 7: Module 4 Implementation

Member 4: Jayesh Sharma (Calculator & Experiment Services)

Role & Scope of Work

Calculation Engine: Implemented CalculatorModel.java parsing expressions and enforcing operator precedence rules.
Arithmetic Servlets: Developed CalculatorServlet.java and ArithmeticServlet.java with operation history tracking.
Lab Practical Controllers: Developed ExperimentServlet.java for syllabus listing and teacher custom experiment creation.
Academic Services: Built TheoryServlet.java for syllabus topics and FeedbackServlet.java for review processing.

Problems & Challenges Faced

Operator Precedence Logic: Correctly evaluating compound expressions with mixed operators without third-party libraries.
Division by Zero: Catching arithmetic errors and gracefully returning descriptive alerts without crashing the Tomcat worker thread.
Cross-Site Scripting (XSS) in Feedback: Sanitizing student review comments before database insertion using PortalHelper.cleanInput().

What Was Completed

Standalone CalculatorModel mathematical evaluation engine.
Full suite of academic servlets handling experiments, theory content, and feedback.
Session-based operation history log for interactive calculator views.

Week 8: Module 5 Implementation & Summary

Member 5: Juned Hussain (Database Persistence & DAO Layer)

Role & Scope of Work

Database Schema: Authored database.sql creating normalized tables with foreign keys and unique constraints.
Connection Pooling: Developed DBConnection.java implementing thread-safe singleton connection acquisition.
Utility Helpers: Developed PortalHelper.java for safe JDBC closing and input validation.
DAO Layer: Implemented TeacherDAO, StudentDAO, ClassSectionDAO, ExperimentDAO, TheoryContentDAO, and FeedbackDAO.
Seed Data: Seeded default RTU syllabus experiments, default teacher credentials, and sample classes.

Problems & Challenges Faced

Connection Leaks: Preventing unclosed database connections under high query volume; resolved by centralizing cleanup in PortalHelper.safeClose().
Missing DAO Methods: Implemented getStudentByName() in StudentDAO to resolve login lookup requirements cleanly.
SQL Injection Defense: Replaced all dynamic SQL string concatenation with parameterized PreparedStatement queries.

What Was Completed

Production-ready database.sql schema and seed dataset.
Thread-safe DBConnection singleton connection manager.
Complete DAO persistence layer covering all entity operations with PreparedStatement parameter binding.

Summary of Module Distribution

Module	Member Name	Role & Architectural Layer	Primary Focus	Key Deliverables	Module Documentation
Module 1	Krishna Gupta (Lead)	Frontend Presentation Layer	Portal Shell, Theme & Lab UI	`index.jsp`, `header.jspf`, `login.jsp`, `exp1`–`exp9`, `arithmetic.jsp`	📖 Module 1 Docs
Module 2	Karan Ramlakhani	Frontend Presentation Layer	Management Forms & Theory UI	`studentList.jsp`, `addStudent.jsp`, `manageClasses.jsp`, `theoryList.jsp`, `feedback.jsp`	📖 Module 2 Docs
Module 3	Kanishq Chasta	Controller & Security Layer	Security Filter & Auth Servlets	`AccessControlFilter.java`, `LoginServlet.java`, `StudentServlet.java`, `web.xml`	📖 Module 3 Docs
Module 4	Jayesh Sharma	Business Logic & Service Layer	Math Evaluation & Lab Servlets	`CalculatorModel.java`, `CalculatorServlet.java`, `ExperimentServlet.java`, `FeedbackServlet.java`	📖 Module 4 Docs
Module 5	Juned Hussain	Persistence & Model Layer	Relational Schema, POJOs & DAOs	`database.sql`, `DBConnection.java`, `PortalHelper.java`, all Models & DAOs	📖 Module 5 Docs

Week 9: System Integration & End-to-End (E2E) Testing

When moving from individual module development to System Integration & End-to-End (E2E) Testing, the focus shifted from isolated unit testing to verifying cross-module data flows, session lifecycle consistency, role-based security enforcement, transactional integrity, and Apache Tomcat runtime stability.

In this phase, each team member took on an Integration & Testing Lead role for their respective domain, working together to unite all five modules into a secure, production-ready practical lab portal.

1. Member 1 (Krishna Gupta): Portal Shell & View Integration Lead

Integration & Testing Role

Portal Shell Template, Cross-Device Viewport Consistency & Responsive Layout Lead.

Work & Scope

Cross-Module View Aggregation: Integrated the unified header/footer shell templates (header.jspf, footer.jspf) across all 15+ module JSPs, ensuring dynamic navigation rendering based on active session roles (Guest vs Student vs Teacher).
Cross-Browser & Device Compatibility: Tested portal views across desktop, tablet, and mobile viewports to guarantee that practical experiment consoles, formula cards, and data tables render cleanly without layout breaks.
Navigation Flow & Flash Message Testing: Verified breadcrumb consistency and flash notification alerts across login redirects, validation errors, and success notifications.

Problems Faced During Integration

Session-Aware Navbar Desynchronization: The navbar occasionally displayed "Guest" options immediately after login due to JSP page rendering before session attributes fully propagated.
Horizontal Table Overflow on Mobile Screens: Large student record tables and complex experiment formula cards broke viewport bounds on screens under 768px.
Flash Message Persistence Across Refreshes: Error messages (e.g., "Invalid Credentials") persisted even after manual page refreshes because session messages were not being cleared upon single consumption.

What They Completed

Unified Portal Viewport & Shell Integration Test Suite validating layout rendering across Chrome, Firefox, Safari, and Edge.
Centralized Single-Use Flash Messaging Engine ensuring notifications clear immediately after first display.
Responsive CSS Breakpoint Audit guaranteeing seamless display across all mobile, tablet, and desktop resolutions.

2. Member 2 (Karan Ramlakhani): Management Forms & CRUD Integration Lead

Integration & Testing Role

Administrative Form Pipelines, Client-Side Sanitization & Modal Integration Lead.

Work & Scope

Management Pipeline Orchestration: Integrated student and class management JSP forms with StudentServlet and ClassServlet, ensuring bi-directional form population and clean redirects.
Modal Pre-Population & Asynchronous Handling: Verified that "Edit Student" and "Update Class" modals reliably load existing record data via URL query parameters without page reloading.
Input Sanitization & Validation Audits: Enforced client-side regex validations on enrollment numbers (ACEIT...), institutional email formats, and required field boundaries.

Problems Faced During Integration

Modal Form State Bleed: Opening the edit modal for a student after closing a previous modal retained stale values from the previous record.
Double-Submission Race Conditions: Rapid double-clicking on the "Add Student" submit button generated duplicate HTTP POST requests, triggering MySQL primary key conflict exceptions.
Foreign Key Constraint UI Shock: Attempting to delete a class section currently containing enrolled students resulted in raw SQL error pages instead of user-friendly warning modals.

What They Completed

End-to-End Management CRUD Test Suite verifying full lifecycle: Add Student ➔ List View ➔ Edit Modal ➔ Update ➔ Confirmation Modal ➔ Safe Delete.
Idempotent Form Submission Guard automatically disabling submit buttons during active network requests.
Relational Constraint Safety Modal Suite intercepting cascading delete attempts with intuitive advisory warnings.

3. Member 3 (Kanishq Chasta): Backend Authentication & Security Filter Lead

Integration & Testing Role

Global Security Filter, Session Lifecycle & RBAC Authorization Lead.

Work & Scope

Global Access Control Enforcement: Integrated AccessControlFilter across all protected URL endpoints (/students/*, /classes/*, /experiments/*), enforcing strict Role-Based Access Control (RBAC).
Session Lifecycle & Penetration Testing: Executed security tests simulating privilege escalation (e.g., students attempting direct access to teacher-only management endpoints) and session hijacking.
Authentication State Propagation: Verified that logging out immediately invalidates HttpSession, clears JSESSIONID cookies, and blocks browser back-button access via HTTP cache control headers.

Problems Faced During Integration

Direct JSP Filter Bypass: Students could initially bypass StudentServlet checks by requesting .jsp files directly (e.g., /students/studentList.jsp), necessitating filter mappings for both servlet URLs and .jsp patterns.
Stale Browser Back-Button Access: After logging out, pressing the browser's "Back" button briefly exposed cached private student data until strict no-cache, no-store headers were enforced.
Session Collision Across Multiple Tabs: Concurrent sessions opened in multiple tabs under different roles caused session state overrides.

What They Completed

Global RBAC Security Matrix Test Suite verifying complete access isolation between Guest, Student, and Teacher roles.
Hardened Session Lifecycle & Cache Control Suite ensuring complete invalidation upon logout.
Penetration & Authorization Audit Report confirming zero route leaks across 20+ portal endpoints.

4. Member 4 (Jayesh Sharma): Backend Experiment Services Lead

Integration & Testing Role

Computational Engines, Experiment State Machine & Service Pipeline Lead.

Work & Scope

Experiment Service Orchestration: Integrated CalculatorServlet, ArithmeticServlet, TheoryServlet, and FeedbackServlet with their respective DAO components.
Mathematical Accuracy & Edge-Case Testing: Verified arithmetic computation precision, handling extreme values, negative inputs, and floating-point operations across all lab calculators.
Theory Content & Feedback Ingestion: Validated dynamic theory retrieval from MySQL and concurrent student feedback submissions.

Problems Faced During Integration

Divide-by-Zero Arithmetic Crashes: Passing a zero denominator into the arithmetic calculator triggered unhandled ArithmeticException 500 errors instead of graceful validation alerts.
Theory Content Encoding Corruption: Code snippets and technical formatting inside theory explanations suffered character mangling due to inconsistent character encodings.
Feedback Submission Concurrency Lock: High-volume concurrent feedback submissions during class lab simulations created database thread contention.

What They Completed

Experiment Computational Accuracy & State Test Suite covering all lab operations and boundary inputs.
Resilient Exception Handler & UTF-8 Theory Pipeline guaranteeing clean rendering of formatted code snippets.
High-Concurrency Service Benchmark Report maintaining sub-150ms response times under peak student load.

5. Member 5 (Juned Hussain): Database & Persistence Integration Lead

Integration & Testing Role

Connection Pooling, 3NF Relational Integrity & Performance Lead.

Work & Scope

Connection Lifecycle Management: Managed JDBC connection lifecycle in DBConnection, guaranteeing that every database interaction safely closes ResultSet, Statement, and Connection.
ACID Transaction & Referential Integrity Testing: Validated foreign key cascading rules across teachers, students, classes, experiments, and feedbacks tables.
Cloud & Docker DB Portability: Verified schema and seed scripts (database.sql) across local MySQL 8.0, cloud MySQL instances, and Docker containers.

Problems Faced During Integration

Connection Pool Depletion: High-frequency concurrent queries caused connections to stay open, exhausting the pool until try-with-resources was implemented across all 6 DAOs.
Deadlock During Concurrent Enrolment: Simultaneous inserts into students alongside class capacity updates caused row-level lock contention.
UTF-8 Byte Order Mark (BOM) Script Breakage: Hidden BOM characters in SQL and Java files caused compilation and migration failures on Linux/Docker environments.

What They Completed

Zero-Leak Connection Lifecycle Test Suite verifying 1,000+ continuous transactions without connection exhaustion.
Optimized 3NF Relational Schema & Migration Script with indexed foreign keys and strict constraints.
Cross-Environment Database Portability Audit ensuring identical operation across Windows, Linux, Docker, and Cloud MySQL.

Overall System Integration Summary

During final Full System Acceptance Testing, the unified portal request lifecycle was verified across all layers:

[Student / Teacher Browser]
            │
            ▼ (HTTP Request)
[AccessControlFilter (Mem 3)] ──[Role Check]──► [Login / Unauthorized Redirect]
            │
            ├─► [Portal Shell & JSP Views (Mem 1)]
            │            ▲
            │            │ (Forward View)
            ▼            │
[Servlet Controllers (Mem 3 & 4)]
            │
            ▼ (Invoke DAO)
[DAO Persistence Layer (Mem 5)]
            │
            ▼ (JDBC Driver)
[MySQL 8.0 Database / Cloud DB]

Week 10: Final System Evaluation, Deliverables & Project Submission

During Week 10, the JavaLabPortal engineering team completed the final system evaluation, production containerization audit, comprehensive technical documentation, project presentation deck (PPT), and end-to-end video demonstration.

Project Deliverables & Artifacts

Deliverable	Description	Resource Link
🌐 Live Web Application	Production Cloud Container on Railway (Apache Tomcat 9 + MySQL 8.0)	Launch Live Portal
📜 Project Abstract	Formal Institutional Project Abstract covering Scoping, 3-Tier Architecture & Technology Stack	View Abstract (PDF)
📋 Software Requirements Specification (SRS)	IEEE 830-1998 Standard System Specification covering functional, non-functional, and operational requirements	View SRS Document (PDF)
📄 Final Project Report	Comprehensive B.Tech Project Report covering Project Overview, Literature Survey, System Design, Implementation, Testing Results, and Conclusion	View Project Report (PDF)
📑 IEEE Research Paper	Scholarly IEEE Research Paper covering Literature Gap Analysis (38 Papers), 3-Tier MVC Architecture, Concurrency Benchmarks & SUS Usability Evaluation	View Research Paper (PDF)
📊 Presentation Deck (PPT)	20-Slide B.Tech Final Evaluation Deck covering 3-Tier MVC Architecture, RBAC Security, Database Design & Testing Results	View Presentation (Slides) \| Download .PPTX
🎥 Video Demonstration	HD Video Walkthrough of JavaLabPortal (Student Workflow, Teacher Admin Panel, Experiment Simulators & Feedback System)	Watch Video Demonstration (Google Drive)

Key Accomplishments & Week 10 Milestones

1. Final Project Report

Authored the comprehensive Final Project Report structured according to university / RTU academic guidelines, covering:
- Literature Survey & Research Base: Synthesis of academic papers on virtual learning portals, automated code execution, and web lab platforms.
- System Design & Implementation: Detailed breakdown of the 3-Tier MVC architecture, Servlet controller workflows, and DAO persistence.
- Relational Schema Design (3NF): Normalized relational structure across 6 core entities with referential integrity constraints.
- Testing & Quality Assurance: Comprehensive unit, integration, and security test results validating RBAC enforcement and SQL injection protection.

2. Final Evaluation Slide Deck (PPT)

Prepared a structured 20-slide presentation deck covering:
- Problem Statement & Scope: Replacing manual lab record books with an interactive digital lab simulator.
- MVC Architecture Topology: Flow diagram illustrating JSP Views, Servlet Controllers, and DAO Models.
- Role-Based Access Security: AccessControlFilter request interceptor mechanics and session lifecycle.
- Live Experiment Modules: Interactive arithmetic calculators, dynamic experiment theories, and real-time feedback loops.
- Database Design & Stress Testing: 3NF relational schema, indexing, and connection leak test results.

3. End-to-End Product Video Demonstration

Produced an HD video demonstration showcasing:
- Authentication & Role Switching: Seamless login and authorization between Student and Teacher accounts.
- Student Lab Journey: Executing lab experiments, reading theory, running calculator tests, and submitting feedback.
- Teacher Admin Panel: Creating and updating student accounts, managing class batches, and reviewing student feedback.
- Security Enforcement: Live demonstration of unauthorized URL blocking and secure session logout.
Watch Full Demonstration: Google Drive HD Video Walkthrough

4. Peer-Reviewed IEEE Research Paper

Authored the full-length IEEE research paper titled "JavaLabPortal: An Enterprise 3-Tier Web-Based Practical Learning, Laboratory Automation, and Examination Platform for Advanced Java Education":
- Exhaustive Literature Base: Systematic survey of 38 peer-reviewed research papers across virtual labs, automated grading tools, and educational web security.
- Literature Gap Analysis: Formally identified and solved 5 persistent research gaps in existing systems (simulation/lifecycle disconnect, cloud cost barriers, exam malpractice vulnerabilities, lack of defense-in-depth, and latent feedback).
- Empirical Benchmarks: Documented sub-150 ms response latencies under 100 concurrent threads and achieved an exceptional System Usability Scale (SUS) score of 86.4 ("Grade A").

5. Containerization & Production Deployment Audit

Built and verified production Dockerfile with Apache Tomcat 9 (tomcat:9.0-jdk11-temurin) and MySQL JDBC driver integration.
Configured dynamic cloud port binding ($PORT) and environment auto-detection for zero-config deployment on Railway, Render, and AWS.

Name		Name	Last commit message	Last commit date
docs		docs
src/main		src/main
.dockerignore		.dockerignore
.gitignore		.gitignore
Dockerfile		Dockerfile
README.md		README.md
database.sql		database.sql

Latest commit

History

Folders and files

Repository files navigation

JavaLabPortal: Java Practical Lab Learning & Examination Portal

🔑 Default Login Credentials for Live Testing & Evaluation

Week 1: Project Administration & Abstract

Project Administration

Team Members

Abstract

Week 2: User Roles, SRS & System Architecture

User Roles

SRS Document

Architecture & Core Modules

Functional Modules

Relational Database Strategy

Non-Functional Requirements

Week 3: UML Architecture & System Design

1. Class Diagram (Static Structural Model)

2. Use Case Diagram (Functional Scope & Actor Boundaries)

3. Sequence Diagram: Role-Based Authentication & Session Handshake

4. Sequence Diagram: Student Administration & Class Allocation Workflow

5. Sequence Diagram: Interactive Mathematical Calculator & Lab Practical Evaluator

6. Activity Diagram: Security Interception & RBAC Filter Pipeline

7. Component & Deployment Architecture Diagram (Physical & Logical 3-Tier Topology)

8. State Machine Diagram: User Authentication & Session Lifecycle

Week 4: Database Design & UI Mock-ups

1. Database Architecture & MySQL Relational Schema

A. Relational Tables Breakdown

B. Entity-Relationship (ER) Diagram

2. User Interface (UI) Mock-ups & Production Screenshots

A. Secure Authentication & Role Selection (login.jsp)

B. Teacher Administration Command Dashboard (index.jsp)

C. Student Self-Service Workspace (index.jsp)

D. Class Administration & Batch Allocation (manageClasses.jsp)

E. Interactive Lab Experiments Catalog (experiments.jsp)

Week 5: Project Structure & Module 1 Implementation

Project Directory Structure

Member 1: Krishna Gupta (Portal Shell & Experiments Hub)

Role & Scope of Work

Problems & Challenges Faced

What Was Completed

Week 6: Module 2 & Module 3 Implementation

Member 2: Karan Ramlakhani (Management Forms & Theory Views)

Role & Scope of Work

Problems & Challenges Faced

What Was Completed

Member 3: Kanishq Chasta (Security, Authentication & Controllers)

Role & Scope of Work

Problems & Challenges Faced

What Was Completed

Week 7: Module 4 Implementation

Member 4: Jayesh Sharma (Calculator & Experiment Services)

Role & Scope of Work

Problems & Challenges Faced

What Was Completed

Week 8: Module 5 Implementation & Summary

Member 5: Juned Hussain (Database Persistence & DAO Layer)

Role & Scope of Work

Problems & Challenges Faced

What Was Completed

Summary of Module Distribution

Week 9: System Integration & End-to-End (E2E) Testing

1. Member 1 (Krishna Gupta): Portal Shell & View Integration Lead

Integration & Testing Role

Work & Scope

Problems Faced During Integration

What They Completed

2. Member 2 (Karan Ramlakhani): Management Forms & CRUD Integration Lead

Integration & Testing Role

Work & Scope

Problems Faced During Integration

What They Completed

3. Member 3 (Kanishq Chasta): Backend Authentication & Security Filter Lead

Integration & Testing Role

Work & Scope

Problems Faced During Integration

What They Completed

4. Member 4 (Jayesh Sharma): Backend Experiment Services Lead

Integration & Testing Role

A. Secure Authentication & Role Selection (`login.jsp`)

B. Teacher Administration Command Dashboard (`index.jsp`)

C. Student Self-Service Workspace (`index.jsp`)

D. Class Administration & Batch Allocation (`manageClasses.jsp`)

E. Interactive Lab Experiments Catalog (`experiments.jsp`)