From 18765653b623b3100beaf6b25a1456674a714567 Mon Sep 17 00:00:00 2001
From: hlpaa <hlpaa@cin.ufpe.br>
Date: Sat, 15 Nov 2025 20:03:39 -0300
Subject: [PATCH 001/102] adding backend routes

---
 server/src/server.ts | 27 ++++++++++++++++++++++++++-
 1 file changed, 26 insertions(+), 1 deletion(-)

diff --git a/server/src/server.ts b/server/src/server.ts
index 6e2597b3..cfc45ad1 100644
--- a/server/src/server.ts
+++ b/server/src/server.ts
@@ -25,6 +25,7 @@ app.use(express.json());
 const studentSet = new StudentSet();
 const classes = new Classes();
 const dataFile = path.resolve('./data/app-data.json');
+const scripts: any[] = [];
 
 // Persistence functions
 const ensureDataDirectory = (): void => {
@@ -451,4 +452,28 @@ app.post('/api/classes/gradeImport/:classId', upload_dir.single('file'), async (
 
 app.listen(PORT, () => {
   console.log(`Server running on http://localhost:${PORT}`);
-});
\ No newline at end of file
+});
+
+
+//POST /api/scripts - Create a new script
+app.post('/api/scripts', (req: Request, res: Response) => {
+  const script = { id: Date.now().toString(), ...req.body };
+  scripts.push(script);
+  res.status(201).json(script);
+});
+
+//GET /api/scripts - Get all scripts
+app.get('/api/scripts', (req: Request, res: Response) => {
+  res.json(scripts);
+});
+
+//PUT /api/scripts/:id - Update a script
+app.put('/api/scripts/:id', (req: Request, res: Response) => {
+  const { id } = req.params;
+  const index = scripts.findIndex(r => r.id === id);
+
+  if (index === -1) return res.status(404).json({ error: 'Script not found' });
+
+  scripts[index] = { ...scripts[index], ...req.body };
+  res.json(scripts[index]);
+});

From dba030bea69bbf86bf8a4584446248c9b7496cbc Mon Sep 17 00:00:00 2001
From: hlpaa <hlpaa@cin.ufpe.br>
Date: Sat, 15 Nov 2025 20:25:30 -0300
Subject: [PATCH 002/102] adding classes and methos to create, get by id and
 update a scirpt

---
 server/src/models/Script.ts  | 32 ++++++++++++++++++++++++++++++++
 server/src/models/Scritps.ts | 28 ++++++++++++++++++++++++++++
 server/src/server.ts         | 25 ++++++++++++++-----------
 3 files changed, 74 insertions(+), 11 deletions(-)
 create mode 100644 server/src/models/Script.ts
 create mode 100644 server/src/models/Scritps.ts

diff --git a/server/src/models/Script.ts b/server/src/models/Script.ts
new file mode 100644
index 00000000..e85e2efa
--- /dev/null
+++ b/server/src/models/Script.ts
@@ -0,0 +1,32 @@
+export class Script {
+  private id: string;
+  public title?: string;
+  public content?: any;
+
+  constructor(id: string, title?: string, content?: any) {
+    this.id = id;
+    this.title = title;
+    this.content = content;
+  }
+
+  getId(): string {
+    return this.id;
+  }
+
+  toJSON() {
+    return {
+      id: this.id,
+      title: this.title,
+      content: this.content
+    };
+  }
+
+  update(data: Partial<{ title: any; content: any }>) {
+    if (data.title !== undefined) this.title = data.title;
+    if (data.content !== undefined) this.content = data.content;
+  }
+
+  static fromJSON(obj: any): Script {
+    return new Script(obj.id, obj.title, obj.content);
+  }
+}
\ No newline at end of file
diff --git a/server/src/models/Scritps.ts b/server/src/models/Scritps.ts
new file mode 100644
index 00000000..81ec50dd
--- /dev/null
+++ b/server/src/models/Scritps.ts
@@ -0,0 +1,28 @@
+import { Script } from './Script';
+
+export class Scripts {
+  private items: Script[] = [];
+
+  addScript(data: any): Script {
+    const id = data.id ?? Date.now().toString();
+    const script = new Script(id, data.title, data.content);
+    this.items.push(script);
+    return script;
+  }
+
+  getAllScripts(): Script[] {
+    return this.items;
+  }
+
+  findById(id: string): Script | undefined {
+    return this.items.find(s => s.getId() === id);
+  }
+
+  updateScript(id: string, data: any): Script | undefined {
+    const script = this.findById(id);
+    if (!script) return undefined;
+    script.update(data);
+    return script;
+  }
+  
+}
\ No newline at end of file
diff --git a/server/src/server.ts b/server/src/server.ts
index cfc45ad1..5a449583 100644
--- a/server/src/server.ts
+++ b/server/src/server.ts
@@ -5,6 +5,7 @@ import { Student } from './models/Student';
 import { Evaluation } from './models/Evaluation';
 import { Classes } from './models/Classes';
 import { Class } from './models/Class';
+import { Scripts } from './models/Scritps';
 import * as fs from 'fs';
 import * as path from 'path';
 
@@ -25,7 +26,7 @@ app.use(express.json());
 const studentSet = new StudentSet();
 const classes = new Classes();
 const dataFile = path.resolve('./data/app-data.json');
-const scripts: any[] = [];
+const scripts = new Scripts();
 
 // Persistence functions
 const ensureDataDirectory = (): void => {
@@ -457,23 +458,25 @@ app.listen(PORT, () => {
 
 //POST /api/scripts - Create a new script
 app.post('/api/scripts', (req: Request, res: Response) => {
-  const script = { id: Date.now().toString(), ...req.body };
-  scripts.push(script);
+  const script = scripts.addScript(req.body);
   res.status(201).json(script);
 });
 
-//GET /api/scripts - Get all scripts
-app.get('/api/scripts', (req: Request, res: Response) => {
-  res.json(scripts);
+//GET /api/scripts/:id - Get one script by ID
+app.get('/api/scripts/:id', (req: Request, res: Response) => {
+  const { id } = req.params;
+  const script = scripts.findById(id);
+  if (!script) {
+    return res.status(404).json({ error: 'Script not found' });
+  }
+  res.json(script.toJSON());
 });
 
 //PUT /api/scripts/:id - Update a script
 app.put('/api/scripts/:id', (req: Request, res: Response) => {
   const { id } = req.params;
-  const index = scripts.findIndex(r => r.id === id);
-
-  if (index === -1) return res.status(404).json({ error: 'Script not found' });
+  const script = scripts.updateScript(id, req.body);
 
-  scripts[index] = { ...scripts[index], ...req.body };
-  res.json(scripts[index]);
+  if (!script) return res.status(404).json({ error: 'Script not found' });
+  res.json(script.toJSON());
 });

From e0f7a23965d6a3d4fe076f8f2a6bccfcac4da0f2 Mon Sep 17 00:00:00 2001
From: hlpaa <hlpaa@cin.ufpe.br>
Date: Sun, 16 Nov 2025 14:19:44 -0300
Subject: [PATCH 003/102] adding frontend infra to implement scripts
 functionality

---
 client/src/App.tsx                   |  31 ++++--
 client/src/components/Scripts.tsx    | 151 +++++++++++++++++++++++++++
 client/src/services/ScriptService.ts |  46 ++++++++
 client/src/types/Script.ts           |  24 +++++
 4 files changed, 242 insertions(+), 10 deletions(-)
 create mode 100644 client/src/components/Scripts.tsx
 create mode 100644 client/src/services/ScriptService.ts
 create mode 100644 client/src/types/Script.ts

diff --git a/client/src/App.tsx b/client/src/App.tsx
index 86a0962e..da9c835f 100644
--- a/client/src/App.tsx
+++ b/client/src/App.tsx
@@ -1,15 +1,16 @@
-import React, { useState, useEffect, useCallback } from 'react';
-import { Student } from './types/Student';
-import { Class } from './types/Class';
-import { studentService } from './services/StudentService';
-import ClassService from './services/ClassService';
-import StudentList from './components/StudentList';
-import StudentForm from './components/StudentForm';
-import Evaluations from './components/Evaluations';
-import Classes from './components/Classes';
+import React, { useCallback, useEffect, useState } from 'react';
 import './App.css';
+import Classes from './components/Classes';
+import Evaluations from './components/Evaluations';
+import Scripts from './components/Scripts';
+import StudentForm from './components/StudentForm';
+import StudentList from './components/StudentList';
+import ClassService from './services/ClassService';
+import { studentService } from './services/StudentService';
+import { Class } from './types/Class';
+import { Student } from './types/Student';
 
-type TabType = 'students' | 'evaluations' | 'classes';
+type TabType = 'students' | 'evaluations' | 'classes' | 'scripts';
 
 const App: React.FC = () => {
   const [students, setStudents] = useState<Student[]>([]);
@@ -143,6 +144,12 @@ const App: React.FC = () => {
           >
             Classes
           </button>
+          <button
+            className={`tab-button ${activeTab === 'scripts' ? 'active' : ''}`}
+            onClick={() => setActiveTab('scripts')}
+          >
+            Scripts
+          </button>
         </div>
 
         {/* Tab Content */}
@@ -212,6 +219,10 @@ const App: React.FC = () => {
               onError={handleError}
             />
           )}
+
+          {activeTab === 'scripts' && (
+            <Scripts onError={handleError} />
+          )}
         </div>
       </main>
     </div>
diff --git a/client/src/components/Scripts.tsx b/client/src/components/Scripts.tsx
new file mode 100644
index 00000000..270a327f
--- /dev/null
+++ b/client/src/components/Scripts.tsx
@@ -0,0 +1,151 @@
+import React, { useState } from 'react';
+import ScriptService from '../services/ScriptService';
+import { CreateScriptRequest, Script, UpdateScriptRequest, isValidJSON } from '../types/Script';
+
+interface Props {
+  onError: (msg: string) => void;
+}
+
+const Scripts: React.FC<Props> = ({ onError }) => {
+  const [loading, setLoading] = useState(false);
+  const [message, setMessage] = useState('');
+
+  // Create form
+  const [createTitle, setCreateTitle] = useState('');
+  const [createContentText, setCreateContentText] = useState('');
+
+  // Load/update
+  const [scriptIdToLoad, setScriptIdToLoad] = useState('');
+  const [loadedScript, setLoadedScript] = useState<Script | null>(null);
+  const [editTitle, setEditTitle] = useState('');
+  const [editContentText, setEditContentText] = useState('');
+
+  const clearMessages = () => {
+    setMessage('');
+    onError('');
+  };
+
+  const handleCreate = async (e: React.FormEvent) => {
+    e.preventDefault();
+    clearMessages();
+
+    let content: any = createContentText;
+    if (createContentText && isValidJSON(createContentText)) {
+      try { content = JSON.parse(createContentText); } catch { content = createContentText; }
+    }
+
+    setLoading(true);
+    try {
+      const req: CreateScriptRequest = { title: createTitle || undefined, content };
+      const res = await ScriptService.createScript(req);
+      setMessage(`Created script with id ${res.id}`);
+      setCreateTitle('');
+      setCreateContentText('');
+      setLoadedScript(res);
+      setEditTitle(res.title || '');
+      setEditContentText(JSON.stringify(res.content, null, 2));
+    } catch (err) {
+      const msg = (err as Error).message || 'Error creating script';
+      onError(msg);
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  const handleLoad = async () => {
+    clearMessages();
+    if (!scriptIdToLoad.trim()) return onError('Enter script id to load');
+    setLoading(true);
+    try {
+      const res = await ScriptService.getScriptById(scriptIdToLoad.trim());
+      setLoadedScript(res);
+      setEditTitle(res.title || '');
+      setEditContentText(JSON.stringify(res.content, null, 2));
+      setMessage('Script loaded');
+    } catch (err) {
+      const msg = (err as Error).message || 'Error loading script';
+      onError(msg);
+      setLoadedScript(null);
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  const handleUpdate = async () => {
+    clearMessages();
+    if (!loadedScript) return onError('No script loaded to update');
+
+    let content: any = editContentText;
+    if (editContentText && isValidJSON(editContentText)) {
+      try { content = JSON.parse(editContentText); } catch { content = editContentText; }
+    }
+
+    setLoading(true);
+    try {
+      const req: UpdateScriptRequest = { title: editTitle || undefined, content };
+      const res = await ScriptService.updateScript(loadedScript.id, req);
+      setLoadedScript(res);
+      setEditTitle(res.title || '');
+      setEditContentText(JSON.stringify(res.content, null, 2));
+      setMessage('Script updated');
+    } catch (err) {
+      onError((err as Error).message || 'Error updating script');
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  return (
+    <div className="scripts-container">
+      <h3>Scripts</h3>
+
+      <section className="create-script">
+        <h4>Create New Script</h4>
+        <form onSubmit={handleCreate}>
+          <div>
+            <label>Title</label>
+            <input value={createTitle} onChange={e => setCreateTitle(e.target.value)} />
+          </div>
+          <div>
+            <label>Content (JSON or text)</label>
+            <textarea rows={6} value={createContentText} onChange={e => setCreateContentText(e.target.value)} />
+          </div>
+          <div>
+            <button type="submit" disabled={loading}>{loading ? 'Creating...' : 'Create Script'}</button>
+          </div>
+        </form>
+      </section>
+
+      <hr />
+
+      <section className="load-script">
+        <h4>Load / Edit Script</h4>
+        <div style={{ display: 'flex', gap: '8px', alignItems: 'center' }}>
+          <input placeholder="Script ID" value={scriptIdToLoad} onChange={e => setScriptIdToLoad(e.target.value)} />
+          <button onClick={handleLoad} disabled={loading}>{loading ? 'Loading...' : 'Load'}</button>
+          {loadedScript && <span style={{ marginLeft: '8px' }}>Loaded id: <strong>{loadedScript.id}</strong></span>}
+        </div>
+
+        {loadedScript && (
+          <div style={{ marginTop: '12px' }}>
+            <div>
+              <label>Title</label>
+              <input value={editTitle} onChange={e => setEditTitle(e.target.value)} />
+            </div>
+            <div>
+              <label>Content (JSON or text)</label>
+              <textarea rows={8} value={editContentText} onChange={e => setEditContentText(e.target.value)} />
+            </div>
+            <div>
+              <button onClick={handleUpdate} disabled={loading}>{loading ? 'Saving...' : 'Update Script'}</button>
+            </div>
+          </div>
+        )}
+      </section>
+
+      {message && <div className="info-message">{message}</div>}
+    </div>
+  );
+};
+
+export default Scripts;
diff --git a/client/src/services/ScriptService.ts b/client/src/services/ScriptService.ts
new file mode 100644
index 00000000..b9c2005f
--- /dev/null
+++ b/client/src/services/ScriptService.ts
@@ -0,0 +1,46 @@
+import { CreateScriptRequest, Script, UpdateScriptRequest } from '../types/Script';
+
+class ScriptService {
+  private readonly baseUrl = 'http://localhost:3005/api/scripts';
+
+  async createScript(data: CreateScriptRequest): Promise<Script> {
+    const res = await fetch(this.baseUrl, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(data),
+    });
+
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      throw new Error(err.error || `Failed to create script: ${res.statusText}`);
+    }
+
+    return await res.json();
+  }
+
+  async getScriptById(id: string): Promise<Script> {
+    const res = await fetch(`${this.baseUrl}/${encodeURIComponent(id)}`);
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      throw new Error(err.error || `Failed to load script: ${res.statusText}`);
+    }
+    return await res.json();
+  }
+
+  async updateScript(id: string, data: UpdateScriptRequest): Promise<Script> {
+    const res = await fetch(`${this.baseUrl}/${encodeURIComponent(id)}`, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(data),
+    });
+
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      throw new Error(err.error || `Failed to update script: ${res.statusText}`);
+    }
+
+    return await res.json();
+  }
+}
+
+export default new ScriptService();
diff --git a/client/src/types/Script.ts b/client/src/types/Script.ts
new file mode 100644
index 00000000..521d5940
--- /dev/null
+++ b/client/src/types/Script.ts
@@ -0,0 +1,24 @@
+export interface Script {
+  id: string;
+  title?: string;
+  content?: any;
+}
+
+export interface CreateScriptRequest {
+  title?: string;
+  content?: any;
+}
+
+export interface UpdateScriptRequest {
+  title?: string;
+  content?: any;
+}
+
+export const isValidJSON = (text: string): boolean => {
+  try {
+    JSON.parse(text);
+    return true;
+  } catch {
+    return false;
+  }
+};

From 2f1ae8bb1042c0b8eeb45ad8b49dfb46f4da17d6 Mon Sep 17 00:00:00 2001
From: hlpaa <hlpaa@cin.ufpe.br>
Date: Sun, 16 Nov 2025 14:33:19 -0300
Subject: [PATCH 004/102] adjusting frontend formattting

---
 client/src/App.css                | 11 +++++++
 client/src/components/Scripts.tsx | 48 +++++++++++++++++++------------
 2 files changed, 40 insertions(+), 19 deletions(-)

diff --git a/client/src/App.css b/client/src/App.css
index 8cabd26f..3de94ec3 100644
--- a/client/src/App.css
+++ b/client/src/App.css
@@ -98,6 +98,17 @@ body {
   background-color: #fff;
 }
 
+.form-group textarea {
+  width: 100%;
+  padding: 0.75rem;
+  border: 2px solid #e2e8f0;
+  border-radius: 6px;
+  font-size: 1rem;
+  transition: all 0.2s ease;
+  background-color: #fff;
+  resize: vertical;
+}
+
 .form-group input:focus {
   outline: none;
   border-color: #667eea;
diff --git a/client/src/components/Scripts.tsx b/client/src/components/Scripts.tsx
index 270a327f..5b6edd61 100644
--- a/client/src/components/Scripts.tsx
+++ b/client/src/components/Scripts.tsx
@@ -99,51 +99,61 @@ const Scripts: React.FC<Props> = ({ onError }) => {
     <div className="scripts-container">
       <h3>Scripts</h3>
 
-      <section className="create-script">
-        <h4>Create New Script</h4>
+      <div className="student-form">
+        <h4 style={{ marginBottom: '1rem' }}>Create New Script</h4>
         <form onSubmit={handleCreate}>
-          <div>
+          <div className="form-group">
             <label>Title</label>
             <input value={createTitle} onChange={e => setCreateTitle(e.target.value)} />
           </div>
-          <div>
+
+          <div className="form-group">
             <label>Content (JSON or text)</label>
             <textarea rows={6} value={createContentText} onChange={e => setCreateContentText(e.target.value)} />
           </div>
-          <div>
+
+          <div className="form-buttons">
             <button type="submit" disabled={loading}>{loading ? 'Creating...' : 'Create Script'}</button>
           </div>
         </form>
-      </section>
+      </div>
 
-      <hr />
+      <hr style={{ margin: '1.5rem 0' }} />
 
-      <section className="load-script">
-        <h4>Load / Edit Script</h4>
-        <div style={{ display: 'flex', gap: '8px', alignItems: 'center' }}>
-          <input placeholder="Script ID" value={scriptIdToLoad} onChange={e => setScriptIdToLoad(e.target.value)} />
-          <button onClick={handleLoad} disabled={loading}>{loading ? 'Loading...' : 'Load'}</button>
-          {loadedScript && <span style={{ marginLeft: '8px' }}>Loaded id: <strong>{loadedScript.id}</strong></span>}
+      <div className="student-form">
+        <h4 style={{ marginBottom: '1rem' }}>Load / Edit Script</h4>
+
+        <div className="form-row" style={{ alignItems: 'center' }}>
+          <div style={{ flex: 1 }} className="form-group">
+            <label>Script ID</label>
+            <input placeholder="Script ID" value={scriptIdToLoad} onChange={e => setScriptIdToLoad(e.target.value)} />
+          </div>
+          <div style={{ display: 'flex', gap: '0.5rem', alignItems: 'flex-end' }}>
+            <button type="button" onClick={handleLoad} disabled={loading}>{loading ? 'Loading...' : 'Load'}</button>
+          </div>
         </div>
 
         {loadedScript && (
           <div style={{ marginTop: '12px' }}>
-            <div>
+            <div className="form-group">
               <label>Title</label>
               <input value={editTitle} onChange={e => setEditTitle(e.target.value)} />
             </div>
-            <div>
+
+            <div className="form-group">
               <label>Content (JSON or text)</label>
               <textarea rows={8} value={editContentText} onChange={e => setEditContentText(e.target.value)} />
             </div>
-            <div>
-              <button onClick={handleUpdate} disabled={loading}>{loading ? 'Saving...' : 'Update Script'}</button>
+
+            <div className="form-buttons">
+              <button type="button" onClick={handleUpdate} disabled={loading}>{loading ? 'Saving...' : 'Update Script'}</button>
+              <div style={{ alignSelf: 'center', marginLeft: '8px', color: '#4a5568' }}>Loaded id: <strong>{loadedScript.id}</strong></div>
             </div>
           </div>
         )}
-      </section>
+      </div>
 
-      {message && <div className="info-message">{message}</div>}
+      {message && <div className="info-message" style={{ marginTop: '1rem' }}>{message}</div>}
     </div>
   );
 };

From 12d17cd07621c9c8dc3c3547fcf78d57237a18e6 Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Sun, 16 Nov 2025 19:40:52 -0300
Subject: [PATCH 005/102] creation of the "Task" and "TaskSet" helper classes
 for Script refactor

---
 server/src/models/Task.ts    | 32 ++++++++++++++++++++++++++++++++
 server/src/models/TaskSet.ts | 28 ++++++++++++++++++++++++++++
 2 files changed, 60 insertions(+)
 create mode 100644 server/src/models/Task.ts
 create mode 100644 server/src/models/TaskSet.ts

diff --git a/server/src/models/Task.ts b/server/src/models/Task.ts
new file mode 100644
index 00000000..561f4aac
--- /dev/null
+++ b/server/src/models/Task.ts
@@ -0,0 +1,32 @@
+export class Task {
+  private id: string;
+  public statement: string;
+  public attachments?: any;
+
+  constructor(id: string, statement: string, attachments?: any) {
+    this.id = id;
+    this.statement = statement;
+    this.attachments = attachments;;
+  }
+
+  getId(): string {
+    return this.id;
+  }
+
+  toJSON() {
+    return {
+      id: this.id,
+      statement: this.statement,
+      attachments: this.attachments
+    };
+  }
+
+  update(data: Partial<{ statement: any; attachment: any }>) {
+    if (data.statement !== undefined) this.statement = data.statement;
+    if (data.attachment !== undefined) this.attachments = data.attachment;
+  }
+
+  static fromJSON(obj: any): Task {
+    return new Task(obj.id, obj.statement, obj.attachments);
+  }
+}
\ No newline at end of file
diff --git a/server/src/models/TaskSet.ts b/server/src/models/TaskSet.ts
new file mode 100644
index 00000000..621cd0fd
--- /dev/null
+++ b/server/src/models/TaskSet.ts
@@ -0,0 +1,28 @@
+import { Task } from './Task';
+
+export class TaskSet {
+  private items: Task[] = [];
+
+  addTask(data: any): Task {
+    const id = data.id ?? Date.now().toString();
+    const task = new Task(id, data.title, data.content);
+    this.items.push(task);
+    return task;
+  }
+
+  getAllTasks(): Task[] {
+    return this.items;
+  }
+
+  findById(id: string): Task | undefined {
+    return this.items.find(s => s.getId() === id);
+  }
+
+  updateTask(id: string, data: any): Task | undefined {
+    const task = this.findById(id);
+    if (!task) return undefined;
+    task.update(data);
+    return task;
+  }
+  
+}
\ No newline at end of file

From 3c9c2d2146ecf65347c0bb0b33858a4117fde972 Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Sun, 16 Nov 2025 19:47:08 -0300
Subject: [PATCH 006/102] Implementation of the routes for Task class in server

---
 server/src/models/TaskSet.ts |  2 +-
 server/src/server.ts         | 36 ++++++++++++++++++++++++++++++++++++
 2 files changed, 37 insertions(+), 1 deletion(-)

diff --git a/server/src/models/TaskSet.ts b/server/src/models/TaskSet.ts
index 621cd0fd..0c55fb2b 100644
--- a/server/src/models/TaskSet.ts
+++ b/server/src/models/TaskSet.ts
@@ -5,7 +5,7 @@ export class TaskSet {
 
   addTask(data: any): Task {
     const id = data.id ?? Date.now().toString();
-    const task = new Task(id, data.title, data.content);
+    const task = new Task(id, data.statement, data.attachments);
     this.items.push(task);
     return task;
   }
diff --git a/server/src/server.ts b/server/src/server.ts
index 5a449583..6cc4459f 100644
--- a/server/src/server.ts
+++ b/server/src/server.ts
@@ -8,6 +8,7 @@ import { Class } from './models/Class';
 import { Scripts } from './models/Scritps';
 import * as fs from 'fs';
 import * as path from 'path';
+import {TaskSet} from './models/TaskSet'
 
 // usado para ler arquivos em POST
 const multer = require('multer');
@@ -27,6 +28,7 @@ const studentSet = new StudentSet();
 const classes = new Classes();
 const dataFile = path.resolve('./data/app-data.json');
 const scripts = new Scripts();
+const taskset = new TaskSet();
 
 // Persistence functions
 const ensureDataDirectory = (): void => {
@@ -456,6 +458,40 @@ app.listen(PORT, () => {
 });
 
 
+// POST /api/tasks => create new task
+app.post('/api/tasks', (req: Request, res: Response) =>{
+  const task = taskset.addTask(req.body);
+  res.status(201).json(task);
+});
+
+// GET /api/tasks/:id => get task by id
+app.get('/api/tasks/:id', (req: Request, res: Response) => {
+  const { id } = req.params;
+  const task = taskset.findById(id);
+  if (!task) {
+    return res.status(404).json({ error: 'Task not found' });
+  }
+  res.json(task.toJSON());
+});
+
+// GET /api/tasks - Get all students
+app.get('/api/tasks', (req: Request, res: Response) => {
+  try {
+    const tasks = taskset.getAllTasks();
+    res.json(tasks.map(t => t.toJSON()));
+  } catch (error) {
+    res.status(500).json({ error: 'Failed to fetch students' });
+  }
+});
+// PUT /api/tasks/:id => update task
+app.put('/api/tasks/:id', (req: Request, res: Response) => {
+  const { id } = req.params;
+  const task = taskset.updateTask(id, req.body);
+
+  if (!task) return res.status(404).json({ error: 'Task not found' });
+  res.json(task.toJSON());
+});
+
 //POST /api/scripts - Create a new script
 app.post('/api/scripts', (req: Request, res: Response) => {
   const script = scripts.addScript(req.body);

From a32355c9ab49124c5c874cea41283f688ec8d39f Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Sun, 16 Nov 2025 20:20:13 -0300
Subject: [PATCH 007/102] creation of "Task" and "TaskService" classes for
 frontend

---
 client/src/services/TaskService.ts | 46 ++++++++++++++++++++++++++++++
 client/src/types/Task.ts           | 24 ++++++++++++++++
 2 files changed, 70 insertions(+)
 create mode 100644 client/src/services/TaskService.ts
 create mode 100644 client/src/types/Task.ts

diff --git a/client/src/services/TaskService.ts b/client/src/services/TaskService.ts
new file mode 100644
index 00000000..207773b0
--- /dev/null
+++ b/client/src/services/TaskService.ts
@@ -0,0 +1,46 @@
+import { CreateTaskRequest, Task, UpdateTaskRequest } from '../types/Task';
+
+class TaskService {
+  private readonly baseUrl = 'http://localhost:3005/api/tasks';
+
+  async createTask(data: CreateTaskRequest): Promise<Task> {
+    const res = await fetch(this.baseUrl, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(data),
+    });
+
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      throw new Error(err.error || `Failed to create Task: ${res.statusText}`);
+    }
+
+    return await res.json();
+  }
+
+  async getTaskById(id: string): Promise<Task> {
+    const res = await fetch(`${this.baseUrl}/${encodeURIComponent(id)}`);
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      throw new Error(err.error || `Failed to load Task: ${res.statusText}`);
+    }
+    return await res.json();
+  }
+
+  async updateTask(id: string, data: UpdateTaskRequest): Promise<Task> {
+    const res = await fetch(`${this.baseUrl}/${encodeURIComponent(id)}`, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(data),
+    });
+
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      throw new Error(err.error || `Failed to update Task: ${res.statusText}`);
+    }
+
+    return await res.json();
+  }
+}
+
+export default new TaskService();
diff --git a/client/src/types/Task.ts b/client/src/types/Task.ts
new file mode 100644
index 00000000..d0a7193f
--- /dev/null
+++ b/client/src/types/Task.ts
@@ -0,0 +1,24 @@
+export interface Task {
+  id: string;
+  statement?: string;
+  attachments?: any;
+}
+
+export interface CreateTaskRequest {
+  statement?: string;
+  attachments?: any;
+}
+
+export interface UpdateTaskRequest {
+  statement?: string;
+  attachments?: any;
+}
+
+export const isValidJSON = (text: string): boolean => {
+  try {
+    JSON.parse(text);
+    return true;
+  } catch {
+    return false;
+  }
+};

From 8906855b042624c1131294dfac121f5375913e67 Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Tue, 18 Nov 2025 01:05:55 -0300
Subject: [PATCH 008/102] add getallscripts to server

---
 server/src/server.ts | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/server/src/server.ts b/server/src/server.ts
index 6cc4459f..abe7b949 100644
--- a/server/src/server.ts
+++ b/server/src/server.ts
@@ -508,6 +508,16 @@ app.get('/api/scripts/:id', (req: Request, res: Response) => {
   res.json(script.toJSON());
 });
 
+// GET /api/scripts - Get all scripts
+app.get('/api/scripts', (req: Request, res: Response) => {
+  try {
+    const allScripts = scripts.getAllScripts();
+    res.json(allScripts.map(s => s.toJSON()));
+  } catch (error) {
+    res.status(500).json({ error: 'Failed to fetch scripts' });
+  }
+});
+
 //PUT /api/scripts/:id - Update a script
 app.put('/api/scripts/:id', (req: Request, res: Response) => {
   const { id } = req.params;

From b2c9eaacdba841497546cb1ab7faa84a5ccdf01e Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Tue, 18 Nov 2025 01:06:56 -0300
Subject: [PATCH 009/102] BREAKING Change task

---
 client/src/types/Script.ts   |  7 ++--
 server/src/models/Script.ts  | 67 ++++++++++++++++++++++++++++--------
 server/src/models/Scripts.ts | 34 ++++++++++++++++++
 3 files changed, 91 insertions(+), 17 deletions(-)
 create mode 100644 server/src/models/Scripts.ts

diff --git a/client/src/types/Script.ts b/client/src/types/Script.ts
index 521d5940..e1b4b67f 100644
--- a/client/src/types/Script.ts
+++ b/client/src/types/Script.ts
@@ -1,17 +1,18 @@
+import { Task } from "./Task";
 export interface Script {
   id: string;
   title?: string;
-  content?: any;
+  tasks?: Task[]
 }
 
 export interface CreateScriptRequest {
   title?: string;
-  content?: any;
+  tasks?: Task[];
 }
 
 export interface UpdateScriptRequest {
   title?: string;
-  content?: any;
+  tasks?: Task[];
 }
 
 export const isValidJSON = (text: string): boolean => {
diff --git a/server/src/models/Script.ts b/server/src/models/Script.ts
index e85e2efa..5b3644db 100644
--- a/server/src/models/Script.ts
+++ b/server/src/models/Script.ts
@@ -1,32 +1,71 @@
+import { Task } from "./Task";
+
 export class Script {
   private id: string;
   public title?: string;
-  public content?: any;
+  public tasks: Task[] = [];
 
-  constructor(id: string, title?: string, content?: any) {
+  constructor(id: string, title?: string, tasks?: Task[]) {
     this.id = id;
     this.title = title;
-    this.content = content;
+    this.tasks = tasks || [];
   }
 
   getId(): string {
     return this.id;
   }
 
-  toJSON() {
-    return {
-      id: this.id,
-      title: this.title,
-      content: this.content
-    };
+toJSON() {
+  return {
+    id: this.id,
+    title: this.title,
+    tasks: this.tasks.map(task => {
+      if (task && typeof task.toJSON === "function") {
+        return task.toJSON();
+      }
+      console.warn("Invalid task detected:", task);
+      return null;
+    }).filter(Boolean)
+  };
+}
+
+
+  // task management
+
+  findTaskById(taskId: string): Task | undefined {
+    return this.tasks.find(task => 
+      task.getId() === taskId
+    );
   }
 
-  update(data: Partial<{ title: any; content: any }>) {
-    if (data.title !== undefined) this.title = data.title;
-    if (data.content !== undefined) this.content = data.content;
+  addTask(task: Task): Task {
+    // Check if task already in script
+    const existingTask = this.findTaskById(task.getId());
+    if (existingTask) {
+      throw new Error('Task already in script');
+    }
+
+    this.tasks.push(task);
+    return task;
   }
 
-  static fromJSON(obj: any): Script {
-    return new Script(obj.id, obj.title, obj.content);
+  
+ removeTask(taskId: string): boolean {
+    const index = this.tasks.findIndex(task => 
+      task.getId() === taskId
+    );
+    
+    if (index === -1) {
+      return false;
+    }
+
+    this.tasks.splice(index, 1);
+    return true;
   }
+
+  update(data: Partial<{ title: any; tasks: any }>) {
+    if (data.title !== undefined) this.title = data.title;
+    if (data.tasks !== undefined) this.tasks = data.tasks;
+  }
+
 }
\ No newline at end of file
diff --git a/server/src/models/Scripts.ts b/server/src/models/Scripts.ts
new file mode 100644
index 00000000..af1194a9
--- /dev/null
+++ b/server/src/models/Scripts.ts
@@ -0,0 +1,34 @@
+import { Script } from './Script';
+import { Task } from './Task';
+
+export class Scripts {
+  private items: Script[] = [];
+
+addScript(data: any): Script {
+  const id = data.id ?? Date.now().toString();
+  const script = new Script(id, data.title);
+
+  if (Array.isArray(data.tasks)) {
+    script.tasks = data.tasks.map((t: any) => Task.fromJSON(t));
+  }
+
+  this.items.push(script);
+  return script;
+}
+
+  getAllScripts(): Script[] {
+    return this.items;
+  }
+
+  findById(id: string): Script | undefined {
+    return this.items.find(s => s.getId() === id);
+  }
+
+  updateScript(id: string, data: any): Script | undefined {
+    const script = this.findById(id);
+    if (!script) return undefined;
+    script.update(data);
+    return script;
+  }
+  
+}
\ No newline at end of file

From 0d79e482de3331750cadae45b60d38143a77471e Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Tue, 18 Nov 2025 01:10:18 -0300
Subject: [PATCH 010/102] Revamp of Script page to task based content

---
 client/src/App.tsx                            |   4 +-
 client/src/components/Scripts.tsx             | 161 ------------------
 .../src/components/scripts/ScriptEditor.tsx   |  74 ++++++++
 client/src/components/scripts/ScriptList.tsx  |  30 ++++
 client/src/components/scripts/ScriptsPage.tsx |  55 ++++++
 client/src/components/scripts/UseScripts.ts   |  57 +++++++
 client/src/services/ScriptService.ts          |   9 +
 client/src/types/Task.ts                      |   3 -
 server/src/models/Scritps.ts                  |  28 ---
 server/src/models/Task.ts                     |  13 +-
 server/src/server.ts                          |   4 +-
 11 files changed, 234 insertions(+), 204 deletions(-)
 delete mode 100644 client/src/components/Scripts.tsx
 create mode 100644 client/src/components/scripts/ScriptEditor.tsx
 create mode 100644 client/src/components/scripts/ScriptList.tsx
 create mode 100644 client/src/components/scripts/ScriptsPage.tsx
 create mode 100644 client/src/components/scripts/UseScripts.ts
 delete mode 100644 server/src/models/Scritps.ts

diff --git a/client/src/App.tsx b/client/src/App.tsx
index da9c835f..3f82aacb 100644
--- a/client/src/App.tsx
+++ b/client/src/App.tsx
@@ -2,7 +2,7 @@ import React, { useCallback, useEffect, useState } from 'react';
 import './App.css';
 import Classes from './components/Classes';
 import Evaluations from './components/Evaluations';
-import Scripts from './components/Scripts';
+import ScriptsPage from './components/scripts/ScriptsPage';
 import StudentForm from './components/StudentForm';
 import StudentList from './components/StudentList';
 import ClassService from './services/ClassService';
@@ -221,7 +221,7 @@ const App: React.FC = () => {
           )}
 
           {activeTab === 'scripts' && (
-            <Scripts onError={handleError} />
+            <ScriptsPage onError={handleError} />
           )}
         </div>
       </main>
diff --git a/client/src/components/Scripts.tsx b/client/src/components/Scripts.tsx
deleted file mode 100644
index 5b6edd61..00000000
--- a/client/src/components/Scripts.tsx
+++ /dev/null
@@ -1,161 +0,0 @@
-import React, { useState } from 'react';
-import ScriptService from '../services/ScriptService';
-import { CreateScriptRequest, Script, UpdateScriptRequest, isValidJSON } from '../types/Script';
-
-interface Props {
-  onError: (msg: string) => void;
-}
-
-const Scripts: React.FC<Props> = ({ onError }) => {
-  const [loading, setLoading] = useState(false);
-  const [message, setMessage] = useState('');
-
-  // Create form
-  const [createTitle, setCreateTitle] = useState('');
-  const [createContentText, setCreateContentText] = useState('');
-
-  // Load/update
-  const [scriptIdToLoad, setScriptIdToLoad] = useState('');
-  const [loadedScript, setLoadedScript] = useState<Script | null>(null);
-  const [editTitle, setEditTitle] = useState('');
-  const [editContentText, setEditContentText] = useState('');
-
-  const clearMessages = () => {
-    setMessage('');
-    onError('');
-  };
-
-  const handleCreate = async (e: React.FormEvent) => {
-    e.preventDefault();
-    clearMessages();
-
-    let content: any = createContentText;
-    if (createContentText && isValidJSON(createContentText)) {
-      try { content = JSON.parse(createContentText); } catch { content = createContentText; }
-    }
-
-    setLoading(true);
-    try {
-      const req: CreateScriptRequest = { title: createTitle || undefined, content };
-      const res = await ScriptService.createScript(req);
-      setMessage(`Created script with id ${res.id}`);
-      setCreateTitle('');
-      setCreateContentText('');
-      setLoadedScript(res);
-      setEditTitle(res.title || '');
-      setEditContentText(JSON.stringify(res.content, null, 2));
-    } catch (err) {
-      const msg = (err as Error).message || 'Error creating script';
-      onError(msg);
-    } finally {
-      setLoading(false);
-    }
-  };
-
-  const handleLoad = async () => {
-    clearMessages();
-    if (!scriptIdToLoad.trim()) return onError('Enter script id to load');
-    setLoading(true);
-    try {
-      const res = await ScriptService.getScriptById(scriptIdToLoad.trim());
-      setLoadedScript(res);
-      setEditTitle(res.title || '');
-      setEditContentText(JSON.stringify(res.content, null, 2));
-      setMessage('Script loaded');
-    } catch (err) {
-      const msg = (err as Error).message || 'Error loading script';
-      onError(msg);
-      setLoadedScript(null);
-    } finally {
-      setLoading(false);
-    }
-  };
-
-  const handleUpdate = async () => {
-    clearMessages();
-    if (!loadedScript) return onError('No script loaded to update');
-
-    let content: any = editContentText;
-    if (editContentText && isValidJSON(editContentText)) {
-      try { content = JSON.parse(editContentText); } catch { content = editContentText; }
-    }
-
-    setLoading(true);
-    try {
-      const req: UpdateScriptRequest = { title: editTitle || undefined, content };
-      const res = await ScriptService.updateScript(loadedScript.id, req);
-      setLoadedScript(res);
-      setEditTitle(res.title || '');
-      setEditContentText(JSON.stringify(res.content, null, 2));
-      setMessage('Script updated');
-    } catch (err) {
-      onError((err as Error).message || 'Error updating script');
-    } finally {
-      setLoading(false);
-    }
-  };
-
-  return (
-    <div className="scripts-container">
-      <h3>Scripts</h3>
-
-      <div className="student-form">
-        <h4 style={{ marginBottom: '1rem' }}>Create New Script</h4>
-        <form onSubmit={handleCreate}>
-          <div className="form-group">
-            <label>Title</label>
-            <input value={createTitle} onChange={e => setCreateTitle(e.target.value)} />
-          </div>
-
-          <div className="form-group">
-            <label>Content (JSON or text)</label>
-            <textarea rows={6} value={createContentText} onChange={e => setCreateContentText(e.target.value)} />
-          </div>
-
-          <div className="form-buttons">
-            <button type="submit" disabled={loading}>{loading ? 'Creating...' : 'Create Script'}</button>
-          </div>
-        </form>
-      </div>
-
-      <hr style={{ margin: '1.5rem 0' }} />
-
-      <div className="student-form">
-        <h4 style={{ marginBottom: '1rem' }}>Load / Edit Script</h4>
-
-        <div className="form-row" style={{ alignItems: 'center' }}>
-          <div style={{ flex: 1 }} className="form-group">
-            <label>Script ID</label>
-            <input placeholder="Script ID" value={scriptIdToLoad} onChange={e => setScriptIdToLoad(e.target.value)} />
-          </div>
-          <div style={{ display: 'flex', gap: '0.5rem', alignItems: 'flex-end' }}>
-            <button type="button" onClick={handleLoad} disabled={loading}>{loading ? 'Loading...' : 'Load'}</button>
-          </div>
-        </div>
-
-        {loadedScript && (
-          <div style={{ marginTop: '12px' }}>
-            <div className="form-group">
-              <label>Title</label>
-              <input value={editTitle} onChange={e => setEditTitle(e.target.value)} />
-            </div>
-
-            <div className="form-group">
-              <label>Content (JSON or text)</label>
-              <textarea rows={8} value={editContentText} onChange={e => setEditContentText(e.target.value)} />
-            </div>
-
-            <div className="form-buttons">
-              <button type="button" onClick={handleUpdate} disabled={loading}>{loading ? 'Saving...' : 'Update Script'}</button>
-              <div style={{ alignSelf: 'center', marginLeft: '8px', color: '#4a5568' }}>Loaded id: <strong>{loadedScript.id}</strong></div>
-            </div>
-          </div>
-        )}
-      </div>
-
-      {message && <div className="info-message" style={{ marginTop: '1rem' }}>{message}</div>}
-    </div>
-  );
-};
-
-export default Scripts;
diff --git a/client/src/components/scripts/ScriptEditor.tsx b/client/src/components/scripts/ScriptEditor.tsx
new file mode 100644
index 00000000..ecc9d3a9
--- /dev/null
+++ b/client/src/components/scripts/ScriptEditor.tsx
@@ -0,0 +1,74 @@
+// src/components/Scripts/ScriptEditor.tsx
+import React, { useState } from 'react';
+import { Script, CreateScriptRequest, UpdateScriptRequest } from '../../types/Script';
+import { Task } from '../../types/Task';
+
+interface ScriptEditorProps {
+  script: Script | null; 
+  onSave: (data: CreateScriptRequest | UpdateScriptRequest) => void;
+  onCancel?: () => void;
+}
+
+export default function ScriptEditor({
+  script,
+  onSave,
+  onCancel
+}: ScriptEditorProps) {
+  const [title, setTitle] = useState(script?.title || "");
+  const [tasks, setTasks] = useState<Task[]>(script?.tasks || []);
+  const [taskText, setTaskText] = useState("");
+
+  const addTask = () => {
+    if (!taskText.trim()) return;
+
+    const newTask: Task = {
+      id: crypto.randomUUID(),
+      statement: taskText
+    };
+
+    setTasks(prev => [...prev, newTask]);
+    setTaskText("");
+  };
+
+  const handleSubmit = () => {
+    onSave({ title, tasks });
+  };
+
+  return (
+    <div style={{ marginBottom: "1.5rem" }}>
+      <h3>{script ? "Edit Script" : "Create Script"}</h3>
+
+      <div>
+        <label>Title:</label>
+        <input
+          value={title}
+          onChange={(e) => setTitle(e.target.value)}
+          style={{ marginLeft: "1rem" }}
+        />
+      </div>
+
+      <div style={{ marginTop: "1rem" }}>
+        <label>New Task:</label>
+        <input
+          value={taskText}
+          onChange={(e) => setTaskText(e.target.value)}
+          style={{ marginLeft: "1rem" }}
+        />
+        <button onClick={addTask} style={{ marginLeft: "1rem" }}>Add Task</button>
+      </div>
+
+      <ul>
+        {tasks.map(t => (
+          <li key={t.id}>{t.statement}</li>
+        ))}
+      </ul>
+
+      <button onClick={handleSubmit}>Save</button>
+      {onCancel && (
+        <button onClick={onCancel} style={{ marginLeft: "1rem" }}>
+          Cancel
+        </button>
+      )}
+    </div>
+  );
+}
diff --git a/client/src/components/scripts/ScriptList.tsx b/client/src/components/scripts/ScriptList.tsx
new file mode 100644
index 00000000..508d56cd
--- /dev/null
+++ b/client/src/components/scripts/ScriptList.tsx
@@ -0,0 +1,30 @@
+// src/components/Scripts/ScriptList.tsx
+import React from 'react';
+import { Script } from '../../types/Script';
+
+interface ScriptListProps {
+  scripts: Script[];
+  onEdit: (script: Script) => void;
+}
+
+export default function ScriptList({ scripts, onEdit }: ScriptListProps) {
+  if (scripts.length === 0) {
+    return <p>No scripts yet.</p>;
+  }
+
+  return (
+    <div>
+      <h3>Existing Scripts</h3>
+      <ul>
+        {scripts.map((s) => (
+          <li key={s.id}>
+            <strong>{s.title || "(untitled)"}</strong>
+            <button onClick={() => onEdit(s)} style={{ marginLeft: "1rem" }}>
+              Edit
+            </button>
+          </li>
+        ))}
+      </ul>
+    </div>
+  );
+}
diff --git a/client/src/components/scripts/ScriptsPage.tsx b/client/src/components/scripts/ScriptsPage.tsx
new file mode 100644
index 00000000..7d1f5953
--- /dev/null
+++ b/client/src/components/scripts/ScriptsPage.tsx
@@ -0,0 +1,55 @@
+// src/components/Scripts/ScriptsPage.tsx
+import React, { useState } from 'react';
+import { Script } from '../../types/Script';
+import { useScripts } from './UseScripts';
+import ScriptList from './ScriptList';
+import ScriptEditor from './ScriptEditor';
+
+interface ScriptsPageProps {
+  onError: (message: string) => void;
+}
+
+export default function ScriptsPage({ onError }: ScriptsPageProps) {
+  const {
+    scripts,
+    loading,
+    createScript,
+    updateScript,
+    reloadScripts,
+  } = useScripts(onError);
+
+  const [editingScript, setEditingScript] = useState<Script | null>(null);
+
+  const handleEdit = (script: Script) => {
+    setEditingScript(script);
+  };
+
+  const handleCancelEdit = () => {
+    setEditingScript(null);
+  };
+
+  return (
+    <div style={{ padding: "1rem" }}>
+      <h2>Scripts</h2>
+
+      <ScriptEditor
+        script={editingScript}
+        onSave={(data) => {
+          if (editingScript) {
+            updateScript(editingScript.id, data);
+          } else {
+            createScript(data);
+          }
+          setEditingScript(null);
+        }}
+        onCancel={editingScript ? handleCancelEdit : undefined}
+      />
+
+      <hr />
+
+      {loading && <p>Loading scripts...</p>}
+
+      <ScriptList scripts={scripts} onEdit={handleEdit} />
+    </div>
+  );
+}
diff --git a/client/src/components/scripts/UseScripts.ts b/client/src/components/scripts/UseScripts.ts
new file mode 100644
index 00000000..4f355949
--- /dev/null
+++ b/client/src/components/scripts/UseScripts.ts
@@ -0,0 +1,57 @@
+// src/components/Scripts/useScripts.ts
+import { useEffect, useState } from 'react';
+import ScriptService from '../../services/ScriptService';
+import {
+  Script,
+  CreateScriptRequest,
+  UpdateScriptRequest,
+} from '../../types/Script';
+
+export function useScripts(onError: (msg: string) => void) {
+  const [scripts, setScripts] = useState<Script[]>([]);
+  const [loading, setLoading] = useState<boolean>(false);
+
+  const reloadScripts = async () => {
+    setLoading(true);
+    try {
+      const data = await ScriptService.getAllScripts();
+      setScripts(data);
+    } catch (err) {
+      onError("Failed to load scripts.");
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  const createScript = async (req: CreateScriptRequest) => {
+    try {
+      const created = await ScriptService.createScript(req);
+      setScripts(prev => [...prev, created]);
+    } catch {
+      onError("Failed to create script.");
+    }
+  };
+
+  const updateScript = async (id: string, req: UpdateScriptRequest) => {
+    try {
+      const updated = await ScriptService.updateScript(id, req);
+      setScripts(prev =>
+        prev.map(s => (s.id === id ? updated : s))
+      );
+    } catch {
+      onError("Failed to update script.");
+    }
+  };
+
+  useEffect(() => {
+    reloadScripts();
+  }, []);
+
+  return {
+    scripts,
+    loading,
+    reloadScripts,
+    createScript,
+    updateScript,
+  };
+}
diff --git a/client/src/services/ScriptService.ts b/client/src/services/ScriptService.ts
index b9c2005f..63cb67bc 100644
--- a/client/src/services/ScriptService.ts
+++ b/client/src/services/ScriptService.ts
@@ -18,6 +18,15 @@ class ScriptService {
     return await res.json();
   }
 
+  async getAllScripts(): Promise<Script[]> {
+    const res = await fetch(this.baseUrl);
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      throw new Error(err.error || `Failed to load scripts: ${res.statusText}`);
+    }
+    return await res.json();
+  }
+
   async getScriptById(id: string): Promise<Script> {
     const res = await fetch(`${this.baseUrl}/${encodeURIComponent(id)}`);
     if (!res.ok) {
diff --git a/client/src/types/Task.ts b/client/src/types/Task.ts
index d0a7193f..f2ed5633 100644
--- a/client/src/types/Task.ts
+++ b/client/src/types/Task.ts
@@ -1,17 +1,14 @@
 export interface Task {
   id: string;
   statement?: string;
-  attachments?: any;
 }
 
 export interface CreateTaskRequest {
   statement?: string;
-  attachments?: any;
 }
 
 export interface UpdateTaskRequest {
   statement?: string;
-  attachments?: any;
 }
 
 export const isValidJSON = (text: string): boolean => {
diff --git a/server/src/models/Scritps.ts b/server/src/models/Scritps.ts
deleted file mode 100644
index 81ec50dd..00000000
--- a/server/src/models/Scritps.ts
+++ /dev/null
@@ -1,28 +0,0 @@
-import { Script } from './Script';
-
-export class Scripts {
-  private items: Script[] = [];
-
-  addScript(data: any): Script {
-    const id = data.id ?? Date.now().toString();
-    const script = new Script(id, data.title, data.content);
-    this.items.push(script);
-    return script;
-  }
-
-  getAllScripts(): Script[] {
-    return this.items;
-  }
-
-  findById(id: string): Script | undefined {
-    return this.items.find(s => s.getId() === id);
-  }
-
-  updateScript(id: string, data: any): Script | undefined {
-    const script = this.findById(id);
-    if (!script) return undefined;
-    script.update(data);
-    return script;
-  }
-  
-}
\ No newline at end of file
diff --git a/server/src/models/Task.ts b/server/src/models/Task.ts
index 561f4aac..98feb027 100644
--- a/server/src/models/Task.ts
+++ b/server/src/models/Task.ts
@@ -1,12 +1,10 @@
 export class Task {
   private id: string;
   public statement: string;
-  public attachments?: any;
 
-  constructor(id: string, statement: string, attachments?: any) {
+  constructor(id: string, statement: string) {
     this.id = id;
     this.statement = statement;
-    this.attachments = attachments;;
   }
 
   getId(): string {
@@ -16,17 +14,16 @@ export class Task {
   toJSON() {
     return {
       id: this.id,
-      statement: this.statement,
-      attachments: this.attachments
+      statement: this.statement
     };
   }
 
   update(data: Partial<{ statement: any; attachment: any }>) {
     if (data.statement !== undefined) this.statement = data.statement;
-    if (data.attachment !== undefined) this.attachments = data.attachment;
   }
 
   static fromJSON(obj: any): Task {
-    return new Task(obj.id, obj.statement, obj.attachments);
+    return new Task(obj.id, obj.statement);
   }
-}
\ No newline at end of file
+}
+
diff --git a/server/src/server.ts b/server/src/server.ts
index abe7b949..3adac185 100644
--- a/server/src/server.ts
+++ b/server/src/server.ts
@@ -5,7 +5,7 @@ import { Student } from './models/Student';
 import { Evaluation } from './models/Evaluation';
 import { Classes } from './models/Classes';
 import { Class } from './models/Class';
-import { Scripts } from './models/Scritps';
+import { Scripts } from './models/Scripts';
 import * as fs from 'fs';
 import * as path from 'path';
 import {TaskSet} from './models/TaskSet'
@@ -495,7 +495,7 @@ app.put('/api/tasks/:id', (req: Request, res: Response) => {
 //POST /api/scripts - Create a new script
 app.post('/api/scripts', (req: Request, res: Response) => {
   const script = scripts.addScript(req.body);
-  res.status(201).json(script);
+  res.status(201).json(script.toJSON());
 });
 
 //GET /api/scripts/:id - Get one script by ID

From 3f01820815a556240312aba1486592b854b34aea Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Tue, 18 Nov 2025 01:10:32 -0300
Subject: [PATCH 011/102] correction to taskset

---
 server/src/models/TaskSet.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/server/src/models/TaskSet.ts b/server/src/models/TaskSet.ts
index 0c55fb2b..16e3ea23 100644
--- a/server/src/models/TaskSet.ts
+++ b/server/src/models/TaskSet.ts
@@ -5,7 +5,7 @@ export class TaskSet {
 
   addTask(data: any): Task {
     const id = data.id ?? Date.now().toString();
-    const task = new Task(id, data.statement, data.attachments);
+    const task = new Task(id, data.statement);
     this.items.push(task);
     return task;
   }

From 6c2d2f56d0d3dfb8aad87fd0cb1ea353fdf6b7bf Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Tue, 18 Nov 2025 01:21:43 -0300
Subject: [PATCH 012/102] FEAT: now able to edit tasks

---
 .../src/components/scripts/ScriptEditor.tsx   | 40 ++--------
 .../src/components/scripts/TaskListEditor.tsx | 75 +++++++++++++++++++
 server/src/models/Script.ts                   |  4 +-
 3 files changed, 83 insertions(+), 36 deletions(-)
 create mode 100644 client/src/components/scripts/TaskListEditor.tsx

diff --git a/client/src/components/scripts/ScriptEditor.tsx b/client/src/components/scripts/ScriptEditor.tsx
index ecc9d3a9..63acfa15 100644
--- a/client/src/components/scripts/ScriptEditor.tsx
+++ b/client/src/components/scripts/ScriptEditor.tsx
@@ -1,34 +1,17 @@
-// src/components/Scripts/ScriptEditor.tsx
 import React, { useState } from 'react';
 import { Script, CreateScriptRequest, UpdateScriptRequest } from '../../types/Script';
+import TaskListEditor from './TaskListEditor'; // NEW COMPONENT
 import { Task } from '../../types/Task';
 
 interface ScriptEditorProps {
-  script: Script | null; 
+  script: Script | null;
   onSave: (data: CreateScriptRequest | UpdateScriptRequest) => void;
   onCancel?: () => void;
 }
 
-export default function ScriptEditor({
-  script,
-  onSave,
-  onCancel
-}: ScriptEditorProps) {
+export default function ScriptEditor({ script, onSave, onCancel }: ScriptEditorProps) {
   const [title, setTitle] = useState(script?.title || "");
   const [tasks, setTasks] = useState<Task[]>(script?.tasks || []);
-  const [taskText, setTaskText] = useState("");
-
-  const addTask = () => {
-    if (!taskText.trim()) return;
-
-    const newTask: Task = {
-      id: crypto.randomUUID(),
-      statement: taskText
-    };
-
-    setTasks(prev => [...prev, newTask]);
-    setTaskText("");
-  };
 
   const handleSubmit = () => {
     onSave({ title, tasks });
@@ -38,6 +21,7 @@ export default function ScriptEditor({
     <div style={{ marginBottom: "1.5rem" }}>
       <h3>{script ? "Edit Script" : "Create Script"}</h3>
 
+      {/* Script title input */}
       <div>
         <label>Title:</label>
         <input
@@ -47,21 +31,7 @@ export default function ScriptEditor({
         />
       </div>
 
-      <div style={{ marginTop: "1rem" }}>
-        <label>New Task:</label>
-        <input
-          value={taskText}
-          onChange={(e) => setTaskText(e.target.value)}
-          style={{ marginLeft: "1rem" }}
-        />
-        <button onClick={addTask} style={{ marginLeft: "1rem" }}>Add Task</button>
-      </div>
-
-      <ul>
-        {tasks.map(t => (
-          <li key={t.id}>{t.statement}</li>
-        ))}
-      </ul>
+      <TaskListEditor tasks={tasks} setTasks={setTasks} />
 
       <button onClick={handleSubmit}>Save</button>
       {onCancel && (
diff --git a/client/src/components/scripts/TaskListEditor.tsx b/client/src/components/scripts/TaskListEditor.tsx
new file mode 100644
index 00000000..b8be577d
--- /dev/null
+++ b/client/src/components/scripts/TaskListEditor.tsx
@@ -0,0 +1,75 @@
+import React, { useState } from 'react';
+import { Task } from '../../types/Task';
+
+interface Props {
+  tasks: Task[];
+  setTasks: React.Dispatch<React.SetStateAction<Task[]>>;
+}
+
+export default function TaskListEditor({ tasks, setTasks }: Props) {
+  const [taskText, setTaskText] = useState("");
+  const [editingTaskId, setEditingTaskId] = useState<string | null>(null);
+  const [editingText, setEditingText] = useState("");
+
+  const addTask = () => {
+    if (!taskText.trim()) return;
+    setTasks([...tasks, { id: crypto.randomUUID(), statement: taskText.trim() }]);
+    setTaskText("");
+  };
+
+  const startEdit = (task: Task) => {
+    setEditingTaskId(task.id);
+    setEditingText(task.statement || "");
+  };
+
+  const saveEdit = () => {
+    setTasks(tasks.map(t => t.id === editingTaskId ? { ...t, statement: editingText } : t));
+    setEditingTaskId(null);
+  };
+
+  const deleteTask = (id: string) => {
+    setTasks(tasks.filter(t => t.id !== id));
+  };
+
+  return (
+    <div style={{ marginTop: "1rem" }}>
+      <h4>Tasks</h4>
+
+      {/* Add new task */}
+      <div>
+        <input
+          value={taskText}
+          onChange={(e) => setTaskText(e.target.value)}
+          placeholder="New task..."
+        />
+        <button onClick={addTask} style={{ marginLeft: "1rem" }}>
+          Add
+        </button>
+      </div>
+
+      {/* Display and edit tasks */}
+      <ul>
+        {tasks.map((task) => (
+          <li key={task.id}>
+            {editingTaskId === task.id ? (
+              <>
+                <input
+                  value={editingText}
+                  onChange={(e) => setEditingText(e.target.value)}
+                />
+                <button onClick={saveEdit} style={{ marginLeft: "0.5rem" }}>Save</button>
+                <button onClick={() => setEditingTaskId(null)} style={{ marginLeft: "0.5rem" }}>Cancel</button>
+              </>
+            ) : (
+              <>
+                {task.statement}
+                <button onClick={() => startEdit(task)} style={{ marginLeft: "0.5rem" }}>Edit</button>
+                <button onClick={() => deleteTask(task.id)} style={{ marginLeft: "0.5rem", color: "red" }}>Delete</button>
+              </>
+            )}
+          </li>
+        ))}
+      </ul>
+    </div>
+  );
+}
diff --git a/server/src/models/Script.ts b/server/src/models/Script.ts
index 5b3644db..0ba9d66d 100644
--- a/server/src/models/Script.ts
+++ b/server/src/models/Script.ts
@@ -65,7 +65,9 @@ toJSON() {
 
   update(data: Partial<{ title: any; tasks: any }>) {
     if (data.title !== undefined) this.title = data.title;
-    if (data.tasks !== undefined) this.tasks = data.tasks;
+    if (data.tasks !== undefined){
+      this.tasks = data.tasks.map((t: any) => Task.fromJSON(t));
+    };
   }
 
 }
\ No newline at end of file

From aefe55284ff58f2dd5d1ad7ee2a74d4e4a19ebb7 Mon Sep 17 00:00:00 2001
From: hlpaa <hlpaa@cin.ufpe.br>
Date: Wed, 19 Nov 2025 09:28:50 -0300
Subject: [PATCH 013/102] BUFFIX: now able to FETCH THE TASKS SPECIFIC TO THE
 SCRIPT BEING EDITED

---
 client/src/components/scripts/ScriptEditor.tsx | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/client/src/components/scripts/ScriptEditor.tsx b/client/src/components/scripts/ScriptEditor.tsx
index 63acfa15..b7e91a9a 100644
--- a/client/src/components/scripts/ScriptEditor.tsx
+++ b/client/src/components/scripts/ScriptEditor.tsx
@@ -1,7 +1,7 @@
-import React, { useState } from 'react';
-import { Script, CreateScriptRequest, UpdateScriptRequest } from '../../types/Script';
-import TaskListEditor from './TaskListEditor'; // NEW COMPONENT
+import { useEffect, useState } from 'react';
+import { CreateScriptRequest, Script, UpdateScriptRequest } from '../../types/Script';
 import { Task } from '../../types/Task';
+import TaskListEditor from './TaskListEditor'; // NEW COMPONENT
 
 interface ScriptEditorProps {
   script: Script | null;
@@ -13,6 +13,12 @@ export default function ScriptEditor({ script, onSave, onCancel }: ScriptEditorP
   const [title, setTitle] = useState(script?.title || "");
   const [tasks, setTasks] = useState<Task[]>(script?.tasks || []);
 
+  // Update state when script prop changes
+  useEffect(() => {
+    setTitle(script?.title || "");
+    setTasks(script?.tasks || []);
+  }, [script]);
+
   const handleSubmit = () => {
     onSave({ title, tasks });
   };

From 16d9bc38e3b9bb63bdb7fef88a76a2664ca3720b Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Wed, 26 Nov 2025 23:08:16 -0300
Subject: [PATCH 014/102] ScriptAnswer interface development

---
 server/src/models/ScriptAnswer.ts | 97 +++++++++++++++++++++++++++++++
 server/src/models/TaskAnswer.ts   | 41 +++++++++++++
 2 files changed, 138 insertions(+)
 create mode 100644 server/src/models/ScriptAnswer.ts
 create mode 100644 server/src/models/TaskAnswer.ts

diff --git a/server/src/models/ScriptAnswer.ts b/server/src/models/ScriptAnswer.ts
new file mode 100644
index 00000000..e52676f4
--- /dev/null
+++ b/server/src/models/ScriptAnswer.ts
@@ -0,0 +1,97 @@
+import { Grade } from "./Evaluation";
+import { TaskAnswer } from "./TaskAnswer";
+import { Student } from "./Student";
+
+export class ScriptAnswer {
+  private id: string;
+  private student: Student; 
+  public answers: TaskAnswer[] = [];
+  public grade?: Grade
+
+  constructor(id: string, student: Student, answers?: TaskAnswer[], grade?: Grade) {
+    this.id = id;
+    this.student = student;
+    this.answers = answers || [];
+    this.grade = grade;
+  }
+
+
+getId(): string {
+    return this.id;
+}
+
+toJSON() {
+  return {
+    id: this.id,
+    student: this.student.toJSON(),
+    answers: this.answers.map(answer => {
+      if (answer && typeof answer.toJSON === "function") {
+        return answer.toJSON();
+      }
+      console.warn("Invalid answer detected:", answer);
+      return null;
+    }).filter(Boolean),
+    grade: this.grade ? this.grade : undefined
+  };
+}
+
+
+
+
+  // answer management
+
+  findAnswerByTaskId(taskId: string): TaskAnswer | undefined {
+    return this.answers.find(answer => 
+      answer.getTaskId() === taskId
+    );
+  }
+
+  addAnswer(answer: TaskAnswer): TaskAnswer {
+    // Check if task already in script
+    const existingAnswer = this.findAnswerByTaskId(answer.task.getId());
+    if (existingAnswer) {
+      throw new Error('Answer for task already in script');
+    }
+
+    this.answers.push(answer);
+    return answer;
+  }
+
+  
+ removeAnswer(taskId: string): boolean {
+    const index = this.answers.findIndex(answer => 
+      answer.getTaskId() === taskId
+    );
+    
+    if (index === -1) {
+      return false;
+    }
+
+    this.answers.splice(index, 1);
+    return true;
+  }
+
+
+  
+// grade Management
+
+ private getNumberOfAnswersWithGrade(grade : Grade): number { 
+    if (grade !== 'MANA' && grade !== 'MPA' && grade !== 'MA') {
+      throw new Error('Invalid grade');
+    }
+    return this.answers.filter(answer => answer.getGrade() === grade).length;
+ }
+
+
+
+ getGradeDistribution(): Record<Grade, number> {
+    return {
+      'MANA': this.getNumberOfAnswersWithGrade('MANA'),
+      'MPA': this.getNumberOfAnswersWithGrade('MPA'),
+      'MA': this.getNumberOfAnswersWithGrade('MA'),
+    };
+ }
+
+
+
+}
\ No newline at end of file
diff --git a/server/src/models/TaskAnswer.ts b/server/src/models/TaskAnswer.ts
new file mode 100644
index 00000000..db46f9d5
--- /dev/null
+++ b/server/src/models/TaskAnswer.ts
@@ -0,0 +1,41 @@
+import { Task } from "./Task";
+import { Grade } from "./Evaluation";
+
+export class TaskAnswer {
+  public task: Task;
+  private grade?: Grade;
+  public comments?: string;
+
+  constructor(task: Task, grade?: Grade, comments?: string) {
+    this.task = task;
+    this.grade = grade;
+    this.comments = comments;
+  }
+
+  getTaskId(): string {
+    return this.task.getId();
+  }
+
+  toJSON() {
+    return {
+      task: this.task.toJSON(),
+      grade: this.grade ? this.grade : undefined,
+      comments: this.comments
+    };
+  }
+
+  update(data: Partial<{task: any; grade: any; comments: any }>) {
+    if (data.task) this.task = Task.fromJSON(data.task);
+    if (data.grade !== undefined) this.grade = data.grade;
+    if (data.comments !== undefined) this.comments = data.comments;
+  }
+
+  static fromJSON(obj: any): TaskAnswer {
+    return new TaskAnswer(obj.task, obj.grade, obj.comments);
+  }
+
+  getGrade(): Grade | undefined {
+    return this.grade;
+  }
+}
+

From 08b55846e13ac38607018bda607743a2870a8b07 Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Thu, 4 Dec 2025 17:41:28 -0300
Subject: [PATCH 015/102] FEAT: frontend for taskanswer grading + mock data

---
 client/src/App.tsx                            |  13 +-
 .../components/ScriptGrading/GradingPage.tsx  |  41 +++++
 .../ScriptGrading/ScriptAnswerGrid.tsx        |  35 ++++
 .../ScriptGrading/ScriptGrading.tsx           |  45 +++++
 .../ScriptGrading/TaskAnswerEditor.tsx        |  99 +++++++++++
 client/src/services/ScriptAnswerService.ts    | 163 ++++++++++++++++++
 client/src/types/ScriptAnswer.ts              |  37 ++++
 server/src/models/TaskAnswer.ts               |  13 +-
 8 files changed, 442 insertions(+), 4 deletions(-)
 create mode 100644 client/src/components/ScriptGrading/GradingPage.tsx
 create mode 100644 client/src/components/ScriptGrading/ScriptAnswerGrid.tsx
 create mode 100644 client/src/components/ScriptGrading/ScriptGrading.tsx
 create mode 100644 client/src/components/ScriptGrading/TaskAnswerEditor.tsx
 create mode 100644 client/src/services/ScriptAnswerService.ts
 create mode 100644 client/src/types/ScriptAnswer.ts

diff --git a/client/src/App.tsx b/client/src/App.tsx
index f812c43d..8f252d6f 100644
--- a/client/src/App.tsx
+++ b/client/src/App.tsx
@@ -3,6 +3,7 @@ import './App.css';
 import Classes from './components/Classes';
 import Evaluations from './components/Evaluations';
 import ScriptsPage from './components/scripts/ScriptsPage';
+import GradingPage from './components/ScriptGrading/GradingPage'
 import StudentForm from './components/StudentForm';
 import StudentList from './components/StudentList';
 import ClassService from './services/ClassService';
@@ -10,7 +11,7 @@ import { studentService } from './services/StudentService';
 import { Class } from './types/Class';
 import { Student } from './types/Student';
 
-type TabType = 'students' | 'evaluations' | 'classes' | 'scripts';
+type TabType = 'students' | 'evaluations' | 'classes' | 'scripts' | 'Script Grading';
 
 const App: React.FC = () => {
   const [students, setStudents] = useState<Student[]>([]);
@@ -153,6 +154,12 @@ const App: React.FC = () => {
           >
             Scripts
           </button>
+          <button
+            className={`tab-button ${activeTab === 'Script Grading' ? 'active' : ''}`}
+            onClick={() => setActiveTab('Script Grading')}
+          >
+            Script Grading
+          </button>
         </div>
 
         {/* Tab Content */}
@@ -226,6 +233,10 @@ const App: React.FC = () => {
           {activeTab === 'scripts' && (
             <ScriptsPage onError={handleError} />
           )}
+
+          {activeTab == 'Script Grading' && (
+            <GradingPage onError={handleError} />
+          )}
         </div>
       </main>
     </div>
diff --git a/client/src/components/ScriptGrading/GradingPage.tsx b/client/src/components/ScriptGrading/GradingPage.tsx
new file mode 100644
index 00000000..0b7ff68f
--- /dev/null
+++ b/client/src/components/ScriptGrading/GradingPage.tsx
@@ -0,0 +1,41 @@
+// pages/GradingPage.tsx
+import React, { useState, useEffect } from "react";
+import { ScriptAnswer } from "../../types/ScriptAnswer";
+import { ScriptAnswerService } from "../../services/ScriptAnswerService";
+import ScriptAnswerGrid from "./ScriptAnswerGrid"
+import ScriptGrading from "./ScriptGrading";
+
+interface Props {
+    onError: (errorMessage: string) => void;
+}
+
+export default function GradingPage({onError}: Props) {
+  const [scriptAnswers, setScriptAnswers] = useState<ScriptAnswer[]>([]);
+  const [selected, setSelected] = useState<ScriptAnswer | null>(null);
+
+  useEffect(() => {
+    setScriptAnswers(ScriptAnswerService.getAllScriptAnswers());
+  }, []);
+
+  if (selected) {
+    return (
+      <ScriptGrading
+        scriptAnswer={selected}
+        onClose={() => {
+          setScriptAnswers(ScriptAnswerService.getAllScriptAnswers());
+          setSelected(null);
+        }}
+      />
+    );
+  }
+
+  return (
+    <div>
+      <h1>Grade Scripts</h1>
+      <ScriptAnswerGrid
+        scriptAnswers={scriptAnswers}
+        onSelect={(sa) => setSelected(sa)}
+      />
+    </div>
+  );
+}
diff --git a/client/src/components/ScriptGrading/ScriptAnswerGrid.tsx b/client/src/components/ScriptGrading/ScriptAnswerGrid.tsx
new file mode 100644
index 00000000..d8d1a5db
--- /dev/null
+++ b/client/src/components/ScriptGrading/ScriptAnswerGrid.tsx
@@ -0,0 +1,35 @@
+// components/ScriptAnswerGrid.tsx
+import React from "react";
+import { ScriptAnswer } from "../../types/ScriptAnswer";
+
+interface Props {
+  scriptAnswers: ScriptAnswer[];
+  onSelect: (s: ScriptAnswer) => void;
+}
+
+export default function ScriptAnswerGrid({ scriptAnswers, onSelect }: Props) {
+  return (
+    <div style={{
+      display: "grid",
+      gridTemplateColumns: "repeat(auto-fill, 200px)",
+      gap: "10px"
+    }}>
+      {scriptAnswers.map(sa => (
+        <div
+          key={sa.id}
+          onClick={() => onSelect(sa)}
+          style={{
+            padding: "12px",
+            border: "1px solid #ccc",
+            borderRadius: "8px",
+            cursor: "pointer",
+          }}
+        >
+          <strong>Script: {sa.scriptId}</strong><br />
+          Student: {sa.studentId}<br />
+          Grade: {sa.grade ?? "—"}
+        </div>
+      ))}
+    </div>
+  );
+}
diff --git a/client/src/components/ScriptGrading/ScriptGrading.tsx b/client/src/components/ScriptGrading/ScriptGrading.tsx
new file mode 100644
index 00000000..5a624842
--- /dev/null
+++ b/client/src/components/ScriptGrading/ScriptGrading.tsx
@@ -0,0 +1,45 @@
+// pages/ScriptGrading.tsx
+import React, { useState } from "react";
+import { ScriptAnswer, TaskAnswer } from "../../types/ScriptAnswer";
+import { ScriptAnswerService } from "../../services/ScriptAnswerService";
+import TaskAnswerEditor from "./TaskAnswerEditor";
+
+interface Props {
+  scriptAnswer: ScriptAnswer;
+  onClose: () => void;
+}
+
+export default function ScriptGrading({ scriptAnswer, onClose }: Props) {
+  const [current, setCurrent] = useState<ScriptAnswer>(scriptAnswer);
+
+  const handleUpdateTask = (updated: TaskAnswer) => {
+    ScriptAnswerService.updateTaskAnswer({
+      TaskAnswerId: updated.id,
+      grade: updated.grade,
+      comments: updated.comments
+    });
+
+    // Reload updated script answer
+    const refreshed = ScriptAnswerService
+      .getAllScriptAnswers()
+      .find(sa => sa.id === current.id);
+
+    if (refreshed) setCurrent(refreshed);
+  };
+
+  return (
+    <div>
+      <button onClick={onClose}>← Back</button>
+      <h2>Grading Script {current.scriptId}</h2>
+      <h3>Student {current.studentId}</h3>
+
+      {current.taskAnswers.map(task => (
+        <TaskAnswerEditor
+          key={task.id}
+          taskAnswer={task}
+          onChange={handleUpdateTask}
+        />
+      ))}
+    </div>
+  );
+}
diff --git a/client/src/components/ScriptGrading/TaskAnswerEditor.tsx b/client/src/components/ScriptGrading/TaskAnswerEditor.tsx
new file mode 100644
index 00000000..9501d809
--- /dev/null
+++ b/client/src/components/ScriptGrading/TaskAnswerEditor.tsx
@@ -0,0 +1,99 @@
+// components/TaskAnswerEditor.tsx
+import React, { useEffect, useState } from "react";
+import { TaskAnswer } from "../../types/ScriptAnswer";
+import { Grade } from "../../types/EspecificacaoDoCalculoDaMedia";
+import TaskService from "../../services/TaskService";
+import { Task } from "../../types/Task";
+
+interface Props {
+  taskAnswer: TaskAnswer;
+  onChange: (updated: TaskAnswer) => void;
+}
+
+const gradeOptions: Grade[] = ["MA", "MANA", "MPA"];
+
+export default function TaskAnswerEditor({ taskAnswer, onChange }: Props) {
+  const [task, setTask] = useState<Task | null>(null);
+  const [loading, setLoading] = useState(true);
+
+  const update = (changes: Partial<TaskAnswer>) => {
+    onChange({ ...taskAnswer, ...changes });
+  };
+
+  // 🔥 Load task details from backend
+  useEffect(() => {
+    let cancelled = false;
+
+    async function load() {
+      setLoading(true);
+      try {
+        const t = await TaskService.getTaskById(taskAnswer.taskId);
+        if (!cancelled) setTask(t);
+      } catch (err) {
+        console.error("Failed to load task:", err);
+      } finally {
+        if (!cancelled) setLoading(false);
+      }
+    }
+
+    load();
+
+    return () => {
+      cancelled = true;
+    };
+  }, [taskAnswer.taskId]);
+
+  return (
+    <div
+      style={{
+        border: "1px solid #ddd",
+        padding: "12px",
+        marginBottom: "12px",
+        borderRadius: "6px",
+      }}
+    >
+      {/* 🔥 Replace old line */}
+      <strong>
+        Task:{" "}
+        {loading
+          ? "Loading task..."
+          : task
+          ? task.statement // <–– SHOW THE TASK STATEMENT HERE
+          : `Unknown task ${taskAnswer.taskId}`}
+      </strong>
+
+
+      {/* 🔽 User answer */}
+      <div style={{ marginTop: 8 }}>
+        <strong>Answer:</strong> {taskAnswer.answer}
+      </div>
+
+      {/* 🔽 Grade selector */}
+      <div style={{ marginTop: 8 }}>
+        Grade:
+        <select
+          value={taskAnswer.grade ?? ""}
+          onChange={(e) => update({ grade: e.target.value as Grade })}
+        >
+          <option value="">—</option>
+          {gradeOptions.map((g) => (
+            <option key={g} value={g}>
+              {g}
+            </option>
+          ))}
+        </select>
+      </div>
+
+      {/* 🔽 Comments */}
+      <div style={{ marginTop: 8 }}>
+        Comments:
+        <textarea
+          value={taskAnswer.comments ?? ""}
+          onChange={(e) => update({ comments: e.target.value })}
+          rows={3}
+          style={{ width: "100%" }}
+        />
+      </div>
+    </div>
+  );
+}
diff --git a/client/src/services/ScriptAnswerService.ts b/client/src/services/ScriptAnswerService.ts
new file mode 100644
index 00000000..dba59534
--- /dev/null
+++ b/client/src/services/ScriptAnswerService.ts
@@ -0,0 +1,163 @@
+// ScriptAnswerService.ts
+import {
+  ScriptAnswer,
+  TaskAnswer,
+  UpdateSriptAnswerGradeRequest,
+  updateTaskAnswerGradeRequest
+} from "../types/ScriptAnswer"; // adjust path
+import { Grade } from "../types/EspecificacaoDoCalculoDaMedia";
+
+const STORAGE_KEY = "scriptAnswers";
+
+// ----------------------------------------
+// Utilities
+// ----------------------------------------
+
+function load(): ScriptAnswer[] {
+  const data = localStorage.getItem(STORAGE_KEY);
+  if (!data) return [];
+  try {
+    return JSON.parse(data);
+  } catch {
+    return [];
+  }
+}
+
+
+function save(data: ScriptAnswer[]) {
+  localStorage.setItem(STORAGE_KEY, JSON.stringify(data));
+}
+
+
+
+// ----------------------------------------
+// Mock Data Initialization
+// ----------------------------------------
+
+function initializeMockData() {
+  const existing = load();
+  if (existing.length > 0) return; // already initialized
+
+  const starter: ScriptAnswer[] = [
+    {
+      id: "SA1",
+      scriptId: "Script-01",
+      studentId: "Student-001",
+      grade: undefined,
+      taskAnswers: [
+        {
+          id: "TA1-1",
+          taskId: "Task-1",
+          answer: "Answer to Task 1",
+          grade: undefined,
+          comments: ""
+        },
+        {
+          id: "TA1-2",
+          taskId: "Task-2",
+          answer: "Answer to Task 2",
+          grade: undefined,
+          comments: ""
+        }
+      ]
+    },
+    {
+      id: "SA2",
+      scriptId: "Script-01",
+      studentId: "Student-002",
+      grade: "MA",
+      taskAnswers: [
+        {
+          id: "TA2-1",
+          taskId: "Task-1",
+          answer: "Answer to Task 1",
+          grade: "MA",
+          comments: "Good work!"
+        },
+        {
+          id: "TA2-2",
+          taskId: "Task-2",
+          answer: "Answer to Task 2",
+          grade: "MANA",
+          comments: ""
+        }
+      ]
+    },
+    {
+      id: "SA3",
+      scriptId: "Script-02",
+      studentId: "Student-003",
+      grade: undefined,
+      taskAnswers: [
+        {
+          id: "TA3-1",
+          taskId: "Task-1",
+          answer: "Answer to Task 1",
+          grade: "MPA",
+          comments: "Needs improvement"
+        }
+      ]
+    }
+  ];
+
+  save(starter);
+  console.log("[ScriptAnswerService] Mock data initialized.");
+}
+
+// Run initialization at import time
+initializeMockData();
+
+// ----------------------------------------
+// ScriptAnswerService
+// ----------------------------------------
+
+export const ScriptAnswerService = {
+  /** Returns ALL ScriptAnswers */
+  getAllScriptAnswers(): ScriptAnswer[] {
+    return load();
+  },
+
+  /** Returns all ScriptAnswers by student ID */
+  getScriptAnswersByStudentId(studentId: string): ScriptAnswer[] {
+    return load().filter(sa => sa.studentId === studentId);
+  },
+
+  /** Add or replace a ScriptAnswer (for testing/mock writing) */
+  saveScriptAnswer(scriptAnswer: ScriptAnswer): void {
+    const list = load();
+    const index = list.findIndex(sa => sa.id === scriptAnswer.id);
+
+    if (index >= 0) list[index] = scriptAnswer;
+    else list.push(scriptAnswer);
+
+    save(list);
+  },
+
+  /** Update only the ScriptAnswer grade */
+  updateScriptAnswerGrade(req: UpdateSriptAnswerGradeRequest): void {
+    const list = load();
+    const sa = list.find(s => s.id === req.scriptAnswerId);
+    if (!sa) return;
+
+    sa.grade = req.grade;
+    save(list);
+  },
+
+  /** Update a single TaskAnswer inside a ScriptAnswer */
+  updateTaskAnswer(req: updateTaskAnswerGradeRequest): void {
+    const list = load();
+
+    for (const sa of list) {
+      const task = sa.taskAnswers.find(t => t.id === req.TaskAnswerId);
+      if (task) {
+        if (req.grade !== undefined) task.grade = req.grade;
+        if (req.comments !== undefined) task.comments = req.comments;
+        break;
+      }
+    }
+
+    save(list);
+  }
+
+  /* Get task by taskanswerid */
+};
diff --git a/client/src/types/ScriptAnswer.ts b/client/src/types/ScriptAnswer.ts
new file mode 100644
index 00000000..db79a2c9
--- /dev/null
+++ b/client/src/types/ScriptAnswer.ts
@@ -0,0 +1,37 @@
+import {Grade} from './EspecificacaoDoCalculoDaMedia';
+
+export interface TaskAnswer {
+    id: string;
+    taskId: string;
+    answer: string;
+    grade?: Grade;
+    comments?: string;
+}
+
+export interface ScriptAnswer {
+    id: string;
+    scriptId: string;
+    studentId: string;
+    taskAnswers: TaskAnswer[];
+    grade?: Grade;
+}
+
+export interface UpdateSriptAnswerGradeRequest {
+    scriptAnswerId: string;
+    grade: Grade;
+}
+
+export interface updateTaskAnswerGradeRequest {
+    TaskAnswerId: string;
+    grade?: Grade;
+    comments?: string;
+}
+
+export const isValidJSON = (text: string): boolean => {
+  try {
+    JSON.parse(text);
+    return true;
+  } catch {
+    return false;
+  }
+};
diff --git a/server/src/models/TaskAnswer.ts b/server/src/models/TaskAnswer.ts
index db46f9d5..2b24eab4 100644
--- a/server/src/models/TaskAnswer.ts
+++ b/server/src/models/TaskAnswer.ts
@@ -2,12 +2,16 @@ import { Task } from "./Task";
 import { Grade } from "./Evaluation";
 
 export class TaskAnswer {
+  public id: string;
   public task: Task;
+  public answer?: string;
   private grade?: Grade;
   public comments?: string;
 
-  constructor(task: Task, grade?: Grade, comments?: string) {
+  constructor(id: string, task: Task, answer?: string, grade?: Grade, comments?: string) {
+    this.id = id;
     this.task = task;
+    this.answer = answer;
     this.grade = grade;
     this.comments = comments;
   }
@@ -18,20 +22,23 @@ export class TaskAnswer {
 
   toJSON() {
     return {
+      id: this.id,
       task: this.task.toJSON(),
+      answer: this.answer,
       grade: this.grade ? this.grade : undefined,
       comments: this.comments
     };
   }
 
-  update(data: Partial<{task: any; grade: any; comments: any }>) {
+  update(data: Partial<{task: any; answer : any; grade: any; comments: any }>) {
     if (data.task) this.task = Task.fromJSON(data.task);
+    if (data.answer) this.answer = data.answer;
     if (data.grade !== undefined) this.grade = data.grade;
     if (data.comments !== undefined) this.comments = data.comments;
   }
 
   static fromJSON(obj: any): TaskAnswer {
-    return new TaskAnswer(obj.task, obj.grade, obj.comments);
+    return new TaskAnswer(obj.id, obj.task, obj.answer, obj.grade, obj.comments);
   }
 
   getGrade(): Grade | undefined {

From a1398d55cb65d765afa6854ae7b0d3ed7fe56aad Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Thu, 4 Dec 2025 17:57:58 -0300
Subject: [PATCH 016/102] Feat: api endpoints implemented for scriptanswer
 object

---
 server/src/models/ScriptAnswerSet.ts | 48 ++++++++++++++++++++++
 server/src/server.ts                 | 60 ++++++++++++++++++++++++++++
 server/tsconfig.json                 |  3 +-
 3 files changed, 110 insertions(+), 1 deletion(-)
 create mode 100644 server/src/models/ScriptAnswerSet.ts

diff --git a/server/src/models/ScriptAnswerSet.ts b/server/src/models/ScriptAnswerSet.ts
new file mode 100644
index 00000000..21df663d
--- /dev/null
+++ b/server/src/models/ScriptAnswerSet.ts
@@ -0,0 +1,48 @@
+import { v4 as uuid } from 'uuid';
+
+export class ScriptAnswerSet {
+  private scriptAnswers: any[] = [];
+
+  addScriptAnswer(data: any) {
+    const newAnswer = {
+      id: uuid(),
+      scriptId: data.scriptId,
+      studentId: data.studentId,
+      taskAnswers: data.taskAnswers ?? [],
+      grade: data.grade ?? null
+    };
+    this.scriptAnswers.push(newAnswer);
+    return newAnswer;
+  }
+
+  getAll() {
+    return this.scriptAnswers;
+  }
+
+  findByStudentId(studentId: string) {
+    return this.scriptAnswers.filter(a => a.studentId === studentId);
+  }
+
+  findById(id: string) {
+    return this.scriptAnswers.find(a => a.id === id) || null;
+  }
+
+  updateGrade(id: string, grade: string) {
+    const answer = this.findById(id);
+    if (!answer) return null;
+    answer.grade = grade;
+    return answer;
+  }
+
+  updateTaskAnswer(taskAnswerId: string, update: any) {
+    for (const scriptAnswer of this.scriptAnswers) {
+      const ta = scriptAnswer.taskAnswers.find(t => t.id === taskAnswerId);
+      if (ta) {
+        if (update.grade !== undefined) ta.grade = update.grade;
+        if (update.comments !== undefined) ta.comments = update.comments;
+        return ta;
+      }
+    }
+    return null;
+  }
+}
diff --git a/server/src/server.ts b/server/src/server.ts
index 9be51e80..1d812c02 100644
--- a/server/src/server.ts
+++ b/server/src/server.ts
@@ -11,6 +11,8 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { EspecificacaoDoCalculoDaMedia, DEFAULT_ESPECIFICACAO_DO_CALCULO_DA_MEDIA } from './models/EspecificacaoDoCalculoDaMedia';
 import {TaskSet} from './models/TaskSet'
+import { ScriptAnswerSet } from './models/ScriptAnswerSet';
+
 
 // usado para ler arquivos em POST
 const multer = require('multer');
@@ -31,6 +33,7 @@ const classes = new Classes();
 const dataFile = path.resolve('./data/app-data.json');
 const scripts = new Scripts();
 const taskset = new TaskSet();
+const scriptAnswerSet = new ScriptAnswerSet();
 
 // Persistence functions
 const ensureDataDirectory = (): void => {
@@ -600,3 +603,60 @@ app.put('/api/scripts/:id', (req: Request, res: Response) => {
   if (!script) return res.status(404).json({ error: 'Script not found' });
   res.json(script.toJSON());
 });
+
+
+app.post('/api/scriptAnswers', (req: Request, res: Response) => {
+  try {
+    const newAnswer = scriptAnswerSet.addScriptAnswer(req.body);
+    res.status(201).json(newAnswer);
+  } catch (error) {
+    res.status(400).json({ error: (error as Error).message });
+  }
+});
+
+app.get('/api/scriptAnswers', (req: Request, res: Response) => {
+  try {
+    res.json(scriptAnswerSet.getAll());
+  } catch (error) {
+    res.status(500).json({ error: 'Failed to fetch script answers' });
+  }
+});
+
+
+app.get('/api/scriptAnswers/student/:studentId', (req: Request, res: Response) => {
+  const { studentId } = req.params;
+  const answers = scriptAnswerSet.findByStudentId(studentId);
+  res.json(answers);
+});
+
+
+app.put('/api/scriptAnswers/:id/grade', (req: Request, res: Response) => {
+  const { id } = req.params;
+  const { grade } = req.body;
+
+  const updated = scriptAnswerSet.updateGrade(id, grade);
+  if (!updated) return res.status(404).json({ error: 'ScriptAnswer not found' });
+
+  res.json(updated);
+});
+
+app.put('/api/scriptAnswers/:id/grade', (req: Request, res: Response) => {
+  const { id } = req.params;
+  const { grade } = req.body;
+
+  const updated = scriptAnswerSet.updateGrade(id, grade);
+  if (!updated) return res.status(404).json({ error: 'ScriptAnswer not found' });
+
+  res.json(updated);
+});
+
+app.put('/api/taskAnswers/:taskAnswerId', (req: Request, res: Response) => {
+  const { taskAnswerId } = req.params;
+
+  const updated = scriptAnswerSet.updateTaskAnswer(taskAnswerId, req.body);
+  if (!updated) {
+    return res.status(404).json({ error: 'TaskAnswer not found' });
+  }
+
+  res.json(updated);
+});
diff --git a/server/tsconfig.json b/server/tsconfig.json
index 4664ef56..58ffa882 100644
--- a/server/tsconfig.json
+++ b/server/tsconfig.json
@@ -8,7 +8,8 @@
     "esModuleInterop": true,
     "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true
+    "resolveJsonModule": true,
+    "noImplicitAny": false
   },
   "include": ["src/**/*"],
   "exclude": ["node_modules", "dist"]

From aa0bf1c4a722dfd334b45f8162514534f00afa9d Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Thu, 4 Dec 2025 18:23:01 -0300
Subject: [PATCH 017/102] DOCUMENTATION: added comments to taskanswer endpoints

---
 server/src/server.ts | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/server/src/server.ts b/server/src/server.ts
index 1d812c02..1f1b6386 100644
--- a/server/src/server.ts
+++ b/server/src/server.ts
@@ -604,6 +604,9 @@ app.put('/api/scripts/:id', (req: Request, res: Response) => {
   res.json(script.toJSON());
 });
 
+/* API endpoints for ScriptAnswers and TaskAnswers */
+
+// POST /api/scriptAnswers - Create a new ScriptAnswer
 
 app.post('/api/scriptAnswers', (req: Request, res: Response) => {
   try {
@@ -614,6 +617,8 @@ app.post('/api/scriptAnswers', (req: Request, res: Response) => {
   }
 });
 
+// GET /api/scriptAnswers - Get all ScriptAnswers
+
 app.get('/api/scriptAnswers', (req: Request, res: Response) => {
   try {
     res.json(scriptAnswerSet.getAll());
@@ -622,14 +627,14 @@ app.get('/api/scriptAnswers', (req: Request, res: Response) => {
   }
 });
 
-
+// GET /api/scriptAnswers/student/:studentId - Get ScriptAnswers for a specific student
 app.get('/api/scriptAnswers/student/:studentId', (req: Request, res: Response) => {
   const { studentId } = req.params;
   const answers = scriptAnswerSet.findByStudentId(studentId);
   res.json(answers);
 });
 
-
+// PUT /api/scriptAnswers/:id/grade - Update only the grade of a ScriptAnswer
 app.put('/api/scriptAnswers/:id/grade', (req: Request, res: Response) => {
   const { id } = req.params;
   const { grade } = req.body;
@@ -640,6 +645,8 @@ app.put('/api/scriptAnswers/:id/grade', (req: Request, res: Response) => {
   res.json(updated);
 });
 
+
+// PUT /api/taskAnswers/:taskAnswerId - Update one TaskAnswer: grade and/or comments
 app.put('/api/scriptAnswers/:id/grade', (req: Request, res: Response) => {
   const { id } = req.params;
   const { grade } = req.body;
@@ -650,6 +657,8 @@ app.put('/api/scriptAnswers/:id/grade', (req: Request, res: Response) => {
   res.json(updated);
 });
 
+
+
 app.put('/api/taskAnswers/:taskAnswerId', (req: Request, res: Response) => {
   const { taskAnswerId } = req.params;
 

From f37c2f793f9461c77093c2b78380d88c7cd6862b Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Thu, 4 Dec 2025 18:23:40 -0300
Subject: [PATCH 018/102] INTEGRATION: Grading pages connected to api endpoints

---
 .../components/ScriptGrading/GradingPage.tsx  |  23 +-
 .../ScriptGrading/ScriptGrading.tsx           |   9 +-
 client/src/services/ScriptAnswerService.ts    | 218 +++++++-----------
 client/tsconfig.json                          |   5 +-
 4 files changed, 113 insertions(+), 142 deletions(-)

diff --git a/client/src/components/ScriptGrading/GradingPage.tsx b/client/src/components/ScriptGrading/GradingPage.tsx
index 0b7ff68f..d139f0eb 100644
--- a/client/src/components/ScriptGrading/GradingPage.tsx
+++ b/client/src/components/ScriptGrading/GradingPage.tsx
@@ -14,7 +14,15 @@ export default function GradingPage({onError}: Props) {
   const [selected, setSelected] = useState<ScriptAnswer | null>(null);
 
   useEffect(() => {
-    setScriptAnswers(ScriptAnswerService.getAllScriptAnswers());
+    async function fetchData() {
+      try {
+        const data = await ScriptAnswerService.getAllScriptAnswers();
+        setScriptAnswers(data);
+      } catch (error) {
+        onError("Failed to load script answers.");
+      }
+    }
+    fetchData();
   }, []);
 
   if (selected) {
@@ -22,8 +30,17 @@ export default function GradingPage({onError}: Props) {
       <ScriptGrading
         scriptAnswer={selected}
         onClose={() => {
-          setScriptAnswers(ScriptAnswerService.getAllScriptAnswers());
-          setSelected(null);
+          async function setData() {
+            try {
+              const data = await ScriptAnswerService.getAllScriptAnswers();
+              setScriptAnswers(data);
+            } catch (error) {
+              onError("Failed to load script answers.");
+            }
+          }
+          setData().then(() => {
+            setSelected(null);
+          });
         }}
       />
     );
diff --git a/client/src/components/ScriptGrading/ScriptGrading.tsx b/client/src/components/ScriptGrading/ScriptGrading.tsx
index 5a624842..010ae7b0 100644
--- a/client/src/components/ScriptGrading/ScriptGrading.tsx
+++ b/client/src/components/ScriptGrading/ScriptGrading.tsx
@@ -20,11 +20,12 @@ export default function ScriptGrading({ scriptAnswer, onClose }: Props) {
     });
 
     // Reload updated script answer
-    const refreshed = ScriptAnswerService
-      .getAllScriptAnswers()
-      .find(sa => sa.id === current.id);
+    const refreshed = async () =>{
+      const list = await ScriptAnswerService.getAllScriptAnswers(); // <-- Await
+      const refreshed = list.find(sa => sa.id === current.id);      // Now OK
 
-    if (refreshed) setCurrent(refreshed);
+      if (refreshed) setCurrent(refreshed);
+    }
   };
 
   return (
diff --git a/client/src/services/ScriptAnswerService.ts b/client/src/services/ScriptAnswerService.ts
index dba59534..74b5b0c3 100644
--- a/client/src/services/ScriptAnswerService.ts
+++ b/client/src/services/ScriptAnswerService.ts
@@ -1,163 +1,115 @@
 // ScriptAnswerService.ts
+
 import {
   ScriptAnswer,
-  TaskAnswer,
   UpdateSriptAnswerGradeRequest,
   updateTaskAnswerGradeRequest
-} from "../types/ScriptAnswer"; // adjust path
+} from "../types/ScriptAnswer";
 import { Grade } from "../types/EspecificacaoDoCalculoDaMedia";
 
-const STORAGE_KEY = "scriptAnswers";
+const API_URL = "http://localhost:3005/api";
 
 // ----------------------------------------
-// Utilities
+// ScriptAnswerService (REAL backend version)
 // ----------------------------------------
 
-function load(): ScriptAnswer[] {
-  const data = localStorage.getItem(STORAGE_KEY);
-  if (!data) return [];
-  try {
-    return JSON.parse(data);
-  } catch {
-    return [];
-  }
-}
-
-
-function save(data: ScriptAnswer[]) {
-  localStorage.setItem(STORAGE_KEY, JSON.stringify(data));
-}
-
+export const ScriptAnswerService = {
+  /** Fetch ALL ScriptAnswers */
+  async getAllScriptAnswers(): Promise<ScriptAnswer[]> {
+    const res = await fetch(`${API_URL}/scriptAnswers`);
+    if (!res.ok) throw new Error("Failed to fetch scriptAnswers");
+    return res.json();
+  },
 
+  /** Fetch ScriptAnswers for a specific student */
+  async getScriptAnswersByStudentId(studentId: string): Promise<ScriptAnswer[]> {
+    const res = await fetch(`${API_URL}/scriptAnswers/student/${studentId}`);
+    if (!res.ok) throw new Error("Failed to fetch scriptAnswers by student");
+    return res.json();
+  },
 
-// ----------------------------------------
-// Mock Data Initialization
-// ----------------------------------------
+  /** Create (or save) a ScriptAnswer */
+  async saveScriptAnswer(scriptAnswer: ScriptAnswer): Promise<ScriptAnswer> {
+    const res = await fetch(`${API_URL}/scriptAnswers`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(scriptAnswer)
+    });
 
-function initializeMockData() {
-  const existing = load();
-  if (existing.length > 0) return; // already initialized
-
-  const starter: ScriptAnswer[] = [
-    {
-      id: "SA1",
-      scriptId: "Script-01",
-      studentId: "Student-001",
-      grade: undefined,
-      taskAnswers: [
-        {
-          id: "TA1-1",
-          taskId: "Task-1",
-          answer: "Answer to Task 1",
-          grade: undefined,
-          comments: ""
-        },
-        {
-          id: "TA1-2",
-          taskId: "Task-2",
-          answer: "Answer to Task 2",
-          grade: undefined,
-          comments: ""
-        }
-      ]
-    },
-    {
-      id: "SA2",
-      scriptId: "Script-01",
-      studentId: "Student-002",
-      grade: "MA",
-      taskAnswers: [
-        {
-          id: "TA2-1",
-          taskId: "Task-1",
-          answer: "Answer to Task 1",
-          grade: "MA",
-          comments: "Good work!"
-        },
-        {
-          id: "TA2-2",
-          taskId: "Task-2",
-          answer: "Answer to Task 2",
-          grade: "MANA",
-          comments: ""
-        }
-      ]
-    },
-    {
-      id: "SA3",
-      scriptId: "Script-02",
-      studentId: "Student-003",
-      grade: undefined,
-      taskAnswers: [
-        {
-          id: "TA3-1",
-          taskId: "Task-1",
-          answer: "Answer to Task 1",
-          grade: "MPA",
-          comments: "Needs improvement"
-        }
-      ]
-    }
-  ];
-
-  save(starter);
-  console.log("[ScriptAnswerService] Mock data initialized.");
-}
-
-// Run initialization at import time
-initializeMockData();
+    if (!res.ok) throw new Error("Failed to save ScriptAnswer");
+    return res.json();
+  },
 
-// ----------------------------------------
-// ScriptAnswerService
-// ----------------------------------------
+  /** Update only the GRADE of a ScriptAnswer */
+  async updateScriptAnswerGrade(req: UpdateSriptAnswerGradeRequest): Promise<ScriptAnswer> {
+    const res = await fetch(`${API_URL}/scriptAnswers/${req.scriptAnswerId}/grade`, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ grade: req.grade })
+    });
 
-export const ScriptAnswerService = {
-  /** Returns ALL ScriptAnswers */
-  getAllScriptAnswers(): ScriptAnswer[] {
-    return load();
+    if (!res.ok) throw new Error("Failed to update ScriptAnswer grade");
+    return res.json();
   },
 
-  /** Returns all ScriptAnswers by student ID */
-  getScriptAnswersByStudentId(studentId: string): ScriptAnswer[] {
-    return load().filter(sa => sa.studentId === studentId);
+  /** Update one TaskAnswer: grade and/or comments */
+  async updateTaskAnswer(req: updateTaskAnswerGradeRequest): Promise<any> {
+    const res = await fetch(`${API_URL}/taskAnswers/${req.TaskAnswerId}`, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        grade: req.grade,
+        comments: req.comments
+      })
+    });
+
+    if (!res.ok) throw new Error("Failed to update TaskAnswer");
+    return res.json();
   },
 
-  /** Add or replace a ScriptAnswer (for testing/mock writing) */
-  saveScriptAnswer(scriptAnswer: ScriptAnswer): void {
-    const list = load();
-    const index = list.findIndex(sa => sa.id === scriptAnswer.id);
+  /** Get the grade of a task inside a ScriptAnswer */
+  async getTaskAnswerGrade(scriptAnswerId: string, taskId: string): Promise<Grade | undefined> {
+    const res = await fetch(
+      `${API_URL}/scriptAnswers/${scriptAnswerId}/tasks/${taskId}`
+    );
+    if (res.status === 404) return undefined;
+    if (!res.ok) throw new Error("Failed to fetch task grade");
 
-    if (index >= 0) list[index] = scriptAnswer;
-    else list.push(scriptAnswer);
-
-    save(list);
+    const data = await res.json();
+    return data.grade;
   },
 
-  /** Update only the ScriptAnswer grade */
-  updateScriptAnswerGrade(req: UpdateSriptAnswerGradeRequest): void {
-    const list = load();
-    const sa = list.find(s => s.id === req.scriptAnswerId);
-    if (!sa) return;
+  /** Add comment to a ScriptAnswer */
+  async updateScriptAnswerComment(scriptAnswerId: string, comment: string): Promise<any> {
+    const res = await fetch(
+      `${API_URL}/scriptAnswers/${scriptAnswerId}/comments`,
+      {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ comment })
+      }
+    );
 
-    sa.grade = req.grade;
-    save(list);
+    if (!res.ok) throw new Error("Failed to update comment");
+    return res.json();
   },
 
-  /** Update a single TaskAnswer inside a ScriptAnswer */
-  updateTaskAnswer(req: updateTaskAnswerGradeRequest): void {
-    const list = load();
-
-    for (const sa of list) {
-      const task = sa.taskAnswers.find(t => t.id === req.TaskAnswerId);
-      if (task) {
-        if (req.grade !== undefined) task.grade = req.grade;
-        if (req.comments !== undefined) task.comments = req.comments;
-        break;
+  /** Add comment to a TaskAnswer inside a ScriptAnswer */
+  async updateTaskAnswerComment(
+    scriptAnswerId: string,
+    taskId: string,
+    comment: string
+  ): Promise<any> {
+    const res = await fetch(
+      `${API_URL}/scriptAnswers/${scriptAnswerId}/tasks/${taskId}/comments`,
+      {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ comment })
       }
-    }
+    );
 
-    save(list);
+    if (!res.ok) throw new Error("Failed to update task comment");
+    return res.json();
   }
-
-  /* Get task by taskanswerid */
 };
diff --git a/client/tsconfig.json b/client/tsconfig.json
index 78e1536f..93e18a06 100644
--- a/client/tsconfig.json
+++ b/client/tsconfig.json
@@ -10,7 +10,7 @@
     "skipLibCheck": true,
     "esModuleInterop": true,
     "allowSyntheticDefaultImports": true,
-    "strict": true,
+    "strict": false,
     "forceConsistentCasingInFileNames": true,
     "noFallthroughCasesInSwitch": true,
     "module": "esnext",
@@ -18,7 +18,8 @@
     "resolveJsonModule": true,
     "isolatedModules": true,
     "noEmit": true,
-    "jsx": "react-jsx"
+    "jsx": "react-jsx",
+    "noImplicitAny": false
   },
   "include": [
     "src"

From 2675f93275ac8bba9d08981b7769ac1033f470ca Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Sun, 7 Dec 2025 16:41:29 -0300
Subject: [PATCH 019/102] HOTFEAT: removescriptanswer functionality added to
 answerset object

---
 server/src/models/ScriptAnswerSet.ts | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/server/src/models/ScriptAnswerSet.ts b/server/src/models/ScriptAnswerSet.ts
index 21df663d..acbee7ec 100644
--- a/server/src/models/ScriptAnswerSet.ts
+++ b/server/src/models/ScriptAnswerSet.ts
@@ -15,6 +15,16 @@ export class ScriptAnswerSet {
     return newAnswer;
   }
 
+  removeScriptAnswer(id: string) {
+    const index = this.scriptAnswers.findIndex(a => a.id === id);
+    if (index !== -1) {
+      this.scriptAnswers.splice(index, 1);
+      return true;
+    }
+    return false;
+  }
+  
+
   getAll() {
     return this.scriptAnswers;
   }

From 36a701be4a74c8632673919d3d527c28333cdeba Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Sun, 7 Dec 2025 17:09:13 -0300
Subject: [PATCH 020/102] FIX: Routes renamed to reflect scenarios + reordering
 of routes needed as consequence of renaming

---
 client/src/services/ScriptAnswerService.ts |  42 +++--
 server/src/server.ts                       | 185 ++++++++++++++-------
 2 files changed, 155 insertions(+), 72 deletions(-)

diff --git a/client/src/services/ScriptAnswerService.ts b/client/src/services/ScriptAnswerService.ts
index 74b5b0c3..61690aa9 100644
--- a/client/src/services/ScriptAnswerService.ts
+++ b/client/src/services/ScriptAnswerService.ts
@@ -10,27 +10,27 @@ import { Grade } from "../types/EspecificacaoDoCalculoDaMedia";
 const API_URL = "http://localhost:3005/api";
 
 // ----------------------------------------
-// ScriptAnswerService (REAL backend version)
+// ScriptAnswerService – UPDATED TO MATCH NEW ROUTES
 // ----------------------------------------
 
 export const ScriptAnswerService = {
   /** Fetch ALL ScriptAnswers */
   async getAllScriptAnswers(): Promise<ScriptAnswer[]> {
-    const res = await fetch(`${API_URL}/scriptAnswers`);
+    const res = await fetch(`${API_URL}/scripts/answers`);
     if (!res.ok) throw new Error("Failed to fetch scriptAnswers");
     return res.json();
   },
 
   /** Fetch ScriptAnswers for a specific student */
   async getScriptAnswersByStudentId(studentId: string): Promise<ScriptAnswer[]> {
-    const res = await fetch(`${API_URL}/scriptAnswers/student/${studentId}`);
+    const res = await fetch(`${API_URL}/scripts/answers/${studentId}`);
     if (!res.ok) throw new Error("Failed to fetch scriptAnswers by student");
     return res.json();
   },
 
   /** Create (or save) a ScriptAnswer */
   async saveScriptAnswer(scriptAnswer: ScriptAnswer): Promise<ScriptAnswer> {
-    const res = await fetch(`${API_URL}/scriptAnswers`, {
+    const res = await fetch(`${API_URL}/scripts/answers`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify(scriptAnswer)
@@ -41,12 +41,17 @@ export const ScriptAnswerService = {
   },
 
   /** Update only the GRADE of a ScriptAnswer */
-  async updateScriptAnswerGrade(req: UpdateSriptAnswerGradeRequest): Promise<ScriptAnswer> {
-    const res = await fetch(`${API_URL}/scriptAnswers/${req.scriptAnswerId}/grade`, {
-      method: "PUT",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ grade: req.grade })
-    });
+  async updateScriptAnswerGrade(
+    req: UpdateSriptAnswerGradeRequest
+  ): Promise<ScriptAnswer> {
+    const res = await fetch(
+      `${API_URL}/scripts/answers/${req.scriptAnswerId}/grade`,
+      {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ grade: req.grade })
+      }
+    );
 
     if (!res.ok) throw new Error("Failed to update ScriptAnswer grade");
     return res.json();
@@ -68,10 +73,14 @@ export const ScriptAnswerService = {
   },
 
   /** Get the grade of a task inside a ScriptAnswer */
-  async getTaskAnswerGrade(scriptAnswerId: string, taskId: string): Promise<Grade | undefined> {
+  async getTaskAnswerGrade(
+    scriptAnswerId: string,
+    taskId: string
+  ): Promise<Grade | undefined> {
     const res = await fetch(
-      `${API_URL}/scriptAnswers/${scriptAnswerId}/tasks/${taskId}`
+      `${API_URL}/scripts/answers/${scriptAnswerId}/tasks/${taskId}`
     );
+
     if (res.status === 404) return undefined;
     if (!res.ok) throw new Error("Failed to fetch task grade");
 
@@ -80,9 +89,12 @@ export const ScriptAnswerService = {
   },
 
   /** Add comment to a ScriptAnswer */
-  async updateScriptAnswerComment(scriptAnswerId: string, comment: string): Promise<any> {
+  async updateScriptAnswerComment(
+    scriptAnswerId: string,
+    comment: string
+  ): Promise<any> {
     const res = await fetch(
-      `${API_URL}/scriptAnswers/${scriptAnswerId}/comments`,
+      `${API_URL}/scripts/answers/${scriptAnswerId}/comments`,
       {
         method: "PUT",
         headers: { "Content-Type": "application/json" },
@@ -101,7 +113,7 @@ export const ScriptAnswerService = {
     comment: string
   ): Promise<any> {
     const res = await fetch(
-      `${API_URL}/scriptAnswers/${scriptAnswerId}/tasks/${taskId}/comments`,
+      `${API_URL}/scripts/answers/${scriptAnswerId}/tasks/${taskId}/comments`,
       {
         method: "PUT",
         headers: { "Content-Type": "application/json" },
diff --git a/server/src/server.ts b/server/src/server.ts
index 1f1b6386..081d08da 100644
--- a/server/src/server.ts
+++ b/server/src/server.ts
@@ -525,7 +525,7 @@ app.get('/api/classes/:classId/report', (req: Request, res: Response) => {
 
 
 // Export the app for testing
-export { app, studentSet, classes };
+export { app, studentSet, classes, scriptAnswerSet};
 
 // Only start the server if this file is run directly (not imported for testing)
 if (require.main === module) {
@@ -534,6 +534,129 @@ if (require.main === module) {
   });
 }
 
+// --------------------------------------------------------------
+// GET /api/scripts/answers  → Return all OR return by ?id=
+// --------------------------------------------------------------
+// GET /api/scripts/answers  → get ALL answers
+app.get('/api/scripts/answers', (req: Request, res: Response) => {
+  try {
+    const all = scriptAnswerSet.getAll();
+    return res.status(200).json(all);
+  } catch (err) {
+    return res.status(500).json({ error: 'Failed to fetch script answers' });
+  }
+});
+
+// GET /api/scripts/answers/:id  → get ONE answer by ID
+app.get('/api/scripts/answers/:id', (req: Request, res: Response) => {
+  const { id } = req.params;
+
+  const found = scriptAnswerSet.findById(id);
+  if (!found) {
+    return res.status(404).json({ error: 'ScriptAnswer not found' });
+  }
+
+  return res.status(200).json(found);
+});
+
+
+// --------------------------------------------------------------
+// GET /api/scripts/answers/:studentId → Answers for a student
+// --------------------------------------------------------------
+app.get('/api/scripts/answers/:studentId', (req: Request, res: Response) => {
+  const { studentId } = req.params;
+
+  const student = studentSet.findStudentByCPF(studentId);
+  if (!student) {
+    return res.status(404).json({ error: 'Student not found' });
+  }
+
+  const answers = scriptAnswerSet.findByStudentId(studentId);
+  return res.status(200).json(answers);
+});
+
+// --------------------------------------------------------------
+// GET /api/scripts/answers/:id/tasks/:taskId → Get grade of task
+// --------------------------------------------------------------
+app.get('/api/scripts/answers/:id/tasks/:taskId', (req: Request, res: Response) => {
+  const { id, taskId } = req.params;
+
+  const scriptAnswer = scriptAnswerSet.findById(id);
+  if (!scriptAnswer) {
+    return res.status(404).json({ error: 'ScriptAnswer not found' });
+  }
+
+  const task = scriptAnswer.taskAnswers.find(t => t.taskId === taskId);
+  if (!task) {
+    return res.status(404).json({ error: 'Task not found' });
+  }
+
+  return res.status(200).json({ grade: task.grade });
+});
+
+// --------------------------------------------------------------
+// PUT /api/scripts/answers/:id/tasks/:taskId → Update grade
+// --------------------------------------------------------------
+app.put('/api/scripts/answers/:id/tasks/:taskId', (req: Request, res: Response) => {
+  const { id, taskId } = req.params;
+  const { grade } = req.body;
+
+  const scriptAnswer = scriptAnswerSet.findById(id);
+  if (!scriptAnswer) {
+    return res.status(404).json({ error: 'ScriptAnswer not found' });
+  }
+
+  const task = scriptAnswer.taskAnswers.find(t => t.taskId === taskId);
+  if (!task) {
+    return res.status(404).json({ error: 'Task not found' });
+  }
+
+  if (!['MANA', 'MPA', 'MA'].includes(grade)) {
+    return res.status(400).json({ error: 'Invalid grade' });
+  }
+
+  task.grade = grade;
+  return res.status(200).json({ taskId, grade });
+});
+
+// --------------------------------------------------------------
+// PUT /api/scripts/answers/:id/comments → Add comment to script
+// --------------------------------------------------------------
+app.put('/api/scripts/answers/:id/comments', (req: Request, res: Response) => {
+  const { id } = req.params;
+  const { comment } = req.body;
+
+  const scriptAnswer = scriptAnswerSet.findById(id);
+  if (!scriptAnswer) {
+    return res.status(404).json({ error: 'ScriptAnswer not found' });
+  }
+
+  scriptAnswer.comment = comment;
+
+  return res.status(200).json({ id, comment });
+});
+
+// --------------------------------------------------------------
+// PUT /api/scripts/answers/:id/tasks/:taskId/comments
+// --------------------------------------------------------------
+app.put('/api/scripts/answers/:id/tasks/:taskId/comments', (req: Request, res: Response) => {
+  const { id, taskId } = req.params;
+  const { comment } = req.body;
+
+  const scriptAnswer = scriptAnswerSet.findById(id);
+  if (!scriptAnswer) {
+    return res.status(404).json({ error: 'ScriptAnswer not found' });
+  }
+
+  const task = scriptAnswer.taskAnswers.find(t => t.taskId === taskId);
+  if (!task) {
+    return res.status(404).json({ error: 'Task not found' });
+  }
+
+  task.comments = comment;
+
+  return res.status(200).json({ taskId, comment });
+});
 
 // POST /api/tasks => create new task
 app.post('/api/tasks', (req: Request, res: Response) =>{
@@ -604,11 +727,11 @@ app.put('/api/scripts/:id', (req: Request, res: Response) => {
   res.json(script.toJSON());
 });
 
-/* API endpoints for ScriptAnswers and TaskAnswers */
-
-// POST /api/scriptAnswers - Create a new ScriptAnswer
 
-app.post('/api/scriptAnswers', (req: Request, res: Response) => {
+// --------------------------------------------------------------
+// POST /api/scripts/answers  → Create a script answer
+// --------------------------------------------------------------
+app.post('/api/scripts/answers', (req: Request, res: Response) => {
   try {
     const newAnswer = scriptAnswerSet.addScriptAnswer(req.body);
     res.status(201).json(newAnswer);
@@ -617,55 +740,3 @@ app.post('/api/scriptAnswers', (req: Request, res: Response) => {
   }
 });
 
-// GET /api/scriptAnswers - Get all ScriptAnswers
-
-app.get('/api/scriptAnswers', (req: Request, res: Response) => {
-  try {
-    res.json(scriptAnswerSet.getAll());
-  } catch (error) {
-    res.status(500).json({ error: 'Failed to fetch script answers' });
-  }
-});
-
-// GET /api/scriptAnswers/student/:studentId - Get ScriptAnswers for a specific student
-app.get('/api/scriptAnswers/student/:studentId', (req: Request, res: Response) => {
-  const { studentId } = req.params;
-  const answers = scriptAnswerSet.findByStudentId(studentId);
-  res.json(answers);
-});
-
-// PUT /api/scriptAnswers/:id/grade - Update only the grade of a ScriptAnswer
-app.put('/api/scriptAnswers/:id/grade', (req: Request, res: Response) => {
-  const { id } = req.params;
-  const { grade } = req.body;
-
-  const updated = scriptAnswerSet.updateGrade(id, grade);
-  if (!updated) return res.status(404).json({ error: 'ScriptAnswer not found' });
-
-  res.json(updated);
-});
-
-
-// PUT /api/taskAnswers/:taskAnswerId - Update one TaskAnswer: grade and/or comments
-app.put('/api/scriptAnswers/:id/grade', (req: Request, res: Response) => {
-  const { id } = req.params;
-  const { grade } = req.body;
-
-  const updated = scriptAnswerSet.updateGrade(id, grade);
-  if (!updated) return res.status(404).json({ error: 'ScriptAnswer not found' });
-
-  res.json(updated);
-});
-
-
-
-app.put('/api/taskAnswers/:taskAnswerId', (req: Request, res: Response) => {
-  const { taskAnswerId } = req.params;
-
-  const updated = scriptAnswerSet.updateTaskAnswer(taskAnswerId, req.body);
-  if (!updated) {
-    return res.status(404).json({ error: 'TaskAnswer not found' });
-  }
-
-  res.json(updated);
-});

From 7f8e96fa9d0a22bc0d84af4676a9d581f777d72b Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Sun, 7 Dec 2025 17:54:04 -0300
Subject: [PATCH 021/102] FIX: now ScriptAnswerSet().getAll() returns a COPY of
 its internal ScriptAnswer array, instead of returning the array itself

---
 server/src/models/ScriptAnswerSet.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/server/src/models/ScriptAnswerSet.ts b/server/src/models/ScriptAnswerSet.ts
index acbee7ec..1ac97897 100644
--- a/server/src/models/ScriptAnswerSet.ts
+++ b/server/src/models/ScriptAnswerSet.ts
@@ -5,7 +5,7 @@ export class ScriptAnswerSet {
 
   addScriptAnswer(data: any) {
     const newAnswer = {
-      id: uuid(),
+      id: data.id ??  uuid(),
       scriptId: data.scriptId,
       studentId: data.studentId,
       taskAnswers: data.taskAnswers ?? [],
@@ -26,7 +26,7 @@ export class ScriptAnswerSet {
   
 
   getAll() {
-    return this.scriptAnswers;
+    return this.scriptAnswers.slice()
   }
 
   findByStudentId(studentId: string) {

From 09213efd4ae0fb58eb26c00c6891e4de11f4cca7 Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Sun, 7 Dec 2025 17:55:29 -0300
Subject: [PATCH 022/102] BUGFIX: moved post method up in the order so that its
 route isnt shadowed by the /api/scripts routes

---
 server/src/server.ts | 24 +++++++++++++-----------
 1 file changed, 13 insertions(+), 11 deletions(-)

diff --git a/server/src/server.ts b/server/src/server.ts
index 081d08da..74cecb8e 100644
--- a/server/src/server.ts
+++ b/server/src/server.ts
@@ -594,6 +594,19 @@ app.get('/api/scripts/answers/:id/tasks/:taskId', (req: Request, res: Response)
   return res.status(200).json({ grade: task.grade });
 });
 
+
+// --------------------------------------------------------------
+// POST /api/scripts/answers  → Create a script answer
+// --------------------------------------------------------------
+app.post('/api/scripts/answers', (req: Request, res: Response) => {
+  try {
+    const newAnswer = scriptAnswerSet.addScriptAnswer(req.body);
+    res.status(201).json(newAnswer);
+  } catch (error) {
+    res.status(400).json({ error: (error as Error).message });
+  }
+});
+
 // --------------------------------------------------------------
 // PUT /api/scripts/answers/:id/tasks/:taskId → Update grade
 // --------------------------------------------------------------
@@ -728,15 +741,4 @@ app.put('/api/scripts/:id', (req: Request, res: Response) => {
 });
 
 
-// --------------------------------------------------------------
-// POST /api/scripts/answers  → Create a script answer
-// --------------------------------------------------------------
-app.post('/api/scripts/answers', (req: Request, res: Response) => {
-  try {
-    const newAnswer = scriptAnswerSet.addScriptAnswer(req.body);
-    res.status(201).json(newAnswer);
-  } catch (error) {
-    res.status(400).json({ error: (error as Error).message });
-  }
-});
 

From 5a59d75246956d6493a4e01c3e484a397c4fada0 Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Sun, 7 Dec 2025 17:55:51 -0300
Subject: [PATCH 023/102] FEAT: error handling for taskanswers initialized with
 invalid grades

---
 server/src/models/TaskAnswer.ts | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/server/src/models/TaskAnswer.ts b/server/src/models/TaskAnswer.ts
index 2b24eab4..6484862e 100644
--- a/server/src/models/TaskAnswer.ts
+++ b/server/src/models/TaskAnswer.ts
@@ -14,6 +14,10 @@ export class TaskAnswer {
     this.answer = answer;
     this.grade = grade;
     this.comments = comments;
+
+    if(grade && grade != "MA" && grade != "MPA" && grade != "MANA") {
+      throw new Error('Invalid grade value');
+    }
   }
 
   getTaskId(): string {

From dd341ef18e9e8e60f4cc77219193bed5d4c4d4ca Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Sun, 7 Dec 2025 18:24:18 -0300
Subject: [PATCH 024/102] fix: solve shadowing of
 /api/scripts/answers/:studentID route by adding /student prefix. Now
 /api/scripts/answers/student/:studentId

---
 client/src/services/ScriptAnswerService.ts |  2 +-
 server/src/server.ts                       | 37 ++++++++++++++--------
 2 files changed, 24 insertions(+), 15 deletions(-)

diff --git a/client/src/services/ScriptAnswerService.ts b/client/src/services/ScriptAnswerService.ts
index 61690aa9..067294e2 100644
--- a/client/src/services/ScriptAnswerService.ts
+++ b/client/src/services/ScriptAnswerService.ts
@@ -23,7 +23,7 @@ export const ScriptAnswerService = {
 
   /** Fetch ScriptAnswers for a specific student */
   async getScriptAnswersByStudentId(studentId: string): Promise<ScriptAnswer[]> {
-    const res = await fetch(`${API_URL}/scripts/answers/${studentId}`);
+    const res = await fetch(`${API_URL}/scripts/answers/student/${studentId}`);
     if (!res.ok) throw new Error("Failed to fetch scriptAnswers by student");
     return res.json();
   },
diff --git a/server/src/server.ts b/server/src/server.ts
index 74cecb8e..68c3d437 100644
--- a/server/src/server.ts
+++ b/server/src/server.ts
@@ -547,6 +547,21 @@ app.get('/api/scripts/answers', (req: Request, res: Response) => {
   }
 });
 
+// --------------------------------------------------------------
+// GET /api/scripts/answers/student/:studentId → Answers for a student
+// --------------------------------------------------------------
+app.get('/api/scripts/answers/student/:studentId', (req: Request, res: Response) => {
+  const { studentId } = req.params;
+
+  const student = studentSet.findStudentByCPF(studentId);
+  if (!student) {
+    return res.status(404).json({ error: 'Student not found' });
+  }
+
+  const answers = scriptAnswerSet.findByStudentId(studentId);
+  return res.status(200).json(answers);
+});
+
 // GET /api/scripts/answers/:id  → get ONE answer by ID
 app.get('/api/scripts/answers/:id', (req: Request, res: Response) => {
   const { id } = req.params;
@@ -560,20 +575,6 @@ app.get('/api/scripts/answers/:id', (req: Request, res: Response) => {
 });
 
 
-// --------------------------------------------------------------
-// GET /api/scripts/answers/:studentId → Answers for a student
-// --------------------------------------------------------------
-app.get('/api/scripts/answers/:studentId', (req: Request, res: Response) => {
-  const { studentId } = req.params;
-
-  const student = studentSet.findStudentByCPF(studentId);
-  if (!student) {
-    return res.status(404).json({ error: 'Student not found' });
-  }
-
-  const answers = scriptAnswerSet.findByStudentId(studentId);
-  return res.status(200).json(answers);
-});
 
 // --------------------------------------------------------------
 // GET /api/scripts/answers/:id/tasks/:taskId → Get grade of task
@@ -671,6 +672,10 @@ app.put('/api/scripts/answers/:id/tasks/:taskId/comments', (req: Request, res: R
   return res.status(200).json({ taskId, comment });
 });
 
+// --------------------------------------------------------------
+// TASKS endpoints
+// --------------------------------------------------------------
+
 // POST /api/tasks => create new task
 app.post('/api/tasks', (req: Request, res: Response) =>{
   const task = taskset.addTask(req.body);
@@ -705,6 +710,10 @@ app.put('/api/tasks/:id', (req: Request, res: Response) => {
   res.json(task.toJSON());
 });
 
+// --------------------------------------------------------------
+// SCRIPTS endpoints
+// --------------------------------------------------------------
+
 //POST /api/scripts - Create a new script
 app.post('/api/scripts', (req: Request, res: Response) => {
   const script = scripts.addScript(req.body);

From 3efd4b18b5323bf404310f81689bcf692753ab68 Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Sun, 7 Dec 2025 18:27:31 -0300
Subject: [PATCH 025/102] fix: solved problem where ScriptAnswerSet's internal
 scriptAnswers array was returned directly via findByStudentId. Now, copy is
 returned instead

---
 server/src/models/ScriptAnswerSet.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/server/src/models/ScriptAnswerSet.ts b/server/src/models/ScriptAnswerSet.ts
index 1ac97897..9e9682cc 100644
--- a/server/src/models/ScriptAnswerSet.ts
+++ b/server/src/models/ScriptAnswerSet.ts
@@ -30,7 +30,7 @@ export class ScriptAnswerSet {
   }
 
   findByStudentId(studentId: string) {
-    return this.scriptAnswers.filter(a => a.studentId === studentId);
+    return this.getAll().filter(a => a.studentId === studentId).slice();
   }
 
   findById(id: string) {

From f70ef13821472980856e653c36ee583031871cbe Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Sun, 7 Dec 2025 18:28:04 -0300
Subject: [PATCH 026/102] feat: grade validation before updating TaskAnswer
 grade

---
 server/src/models/TaskAnswer.ts | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/server/src/models/TaskAnswer.ts b/server/src/models/TaskAnswer.ts
index 6484862e..03a5f51c 100644
--- a/server/src/models/TaskAnswer.ts
+++ b/server/src/models/TaskAnswer.ts
@@ -34,10 +34,17 @@ export class TaskAnswer {
     };
   }
 
+  updateGrade(grade: Grade | undefined) {
+    if(grade && grade != "MA" && grade != "MPA" && grade != "MANA") {
+      throw new Error('Invalid grade value');
+    }
+    this.grade = grade;
+  }
+
   update(data: Partial<{task: any; answer : any; grade: any; comments: any }>) {
     if (data.task) this.task = Task.fromJSON(data.task);
     if (data.answer) this.answer = data.answer;
-    if (data.grade !== undefined) this.grade = data.grade;
+    if (data.grade !== undefined) this.updateGrade(data.grade);
     if (data.comments !== undefined) this.comments = data.comments;
   }
 

From 72951ca34a001764d186dd244729a386b7cf5ebd Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Sun, 7 Dec 2025 18:29:15 -0300
Subject: [PATCH 027/102] feat: error handling for invalid grade values inside
 ScriptAnswer object

---
 server/src/models/ScriptAnswer.ts | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/server/src/models/ScriptAnswer.ts b/server/src/models/ScriptAnswer.ts
index e52676f4..555720a7 100644
--- a/server/src/models/ScriptAnswer.ts
+++ b/server/src/models/ScriptAnswer.ts
@@ -13,6 +13,9 @@ export class ScriptAnswer {
     this.student = student;
     this.answers = answers || [];
     this.grade = grade;
+    if(grade && grade != "MA" && grade != "MPA" && grade != "MANA") {
+      throw new Error('Invalid grade value');
+    }
   }
 
 
@@ -75,6 +78,13 @@ toJSON() {
   
 // grade Management
 
+  updateGrade(grade: Grade | undefined) {
+    if(grade && grade != "MA" && grade != "MPA" && grade != "MANA") {
+      throw new Error('Invalid grade value');
+    }
+    this.grade = grade;
+  }
+
  private getNumberOfAnswersWithGrade(grade : Grade): number { 
     if (grade !== 'MANA' && grade !== 'MPA' && grade !== 'MA') {
       throw new Error('Invalid grade');

From 234ac8aeca3e860a15fafbb12cbfbfbd29ebdc1d Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Sun, 7 Dec 2025 18:32:07 -0300
Subject: [PATCH 028/102] testing: scriptanswer tests

---
 server/src/__tests__/ScriptAnswer.test.ts | 120 ++++++++++++++++++++++
 1 file changed, 120 insertions(+)
 create mode 100644 server/src/__tests__/ScriptAnswer.test.ts

diff --git a/server/src/__tests__/ScriptAnswer.test.ts b/server/src/__tests__/ScriptAnswer.test.ts
new file mode 100644
index 00000000..e9211a2a
--- /dev/null
+++ b/server/src/__tests__/ScriptAnswer.test.ts
@@ -0,0 +1,120 @@
+import { ScriptAnswer } from "../models/ScriptAnswer";
+import { Student } from "../models/Student";
+import { Task } from "../models/Task";
+import { TaskAnswer } from "../models/TaskAnswer";
+import { Grade } from "../models/Evaluation";
+
+describe("ScriptAnswer", () => {
+  let student: Student;
+  let script: ScriptAnswer;
+
+  beforeEach(() => {
+    student = new Student("John Doe", "12345678909", "john@example.com");
+    script = new ScriptAnswer("sa1", student);
+  });
+
+  // ---------------------------------------------------------------
+  test("constructor initializes fields", () => {
+    expect(script.getId()).toBe("sa1");
+    expect(script.answers.length).toBe(0);
+  });
+
+  // ---------------------------------------------------------------
+  test("toJSON() returns correct structure", () => {
+    const t1 = new Task("t1", "Example task");
+    const ta1 = new TaskAnswer("a1", t1, "my answer", "MA");
+
+    script.addAnswer(ta1);
+
+    const json = script.toJSON();
+
+    expect(json).toEqual({
+      id: "sa1",
+      student: {
+        name: "John Doe",
+        cpf: "123.456.789-09", // normalized by Student class
+        email: "john@example.com",
+      },
+      answers: [
+        {
+          id: "a1",
+          task: {
+            id: "t1",
+            statement: "Example task",
+          },
+          answer: "my answer",
+          grade: "MA",
+          comments: undefined,
+        },
+      ],
+      grade: undefined,
+    });
+  });
+
+  // ---------------------------------------------------------------
+  test("addAnswer() adds new answer", () => {
+    const answer = new TaskAnswer("a1", new Task("t1", "task1"));
+    script.addAnswer(answer);
+
+    expect(script.answers.length).toBe(1);
+    expect(script.answers[0]).toBe(answer);
+  });
+
+  test("addAnswer() throws when adding duplicate task", () => {
+    const t1 = new Task("t1", "task1");
+    const answer1 = new TaskAnswer("a1", t1);
+    const answer2 = new TaskAnswer("a2", t1);
+
+    script.addAnswer(answer1);
+
+    expect(() => script.addAnswer(answer2)).toThrow("Answer for task already in script");
+  });
+
+  // ---------------------------------------------------------------
+  test("findAnswerByTaskId() returns correct answer", () => {
+    const a1 = new TaskAnswer("a1", new Task("t1", "task1"));
+    const a2 = new TaskAnswer("a2", new Task("t2", "task2"));
+
+    script.addAnswer(a1);
+    script.addAnswer(a2);
+
+    expect(script.findAnswerByTaskId("t2")).toBe(a2);
+    expect(script.findAnswerByTaskId("missing")).toBeUndefined();
+  });
+
+  // ---------------------------------------------------------------
+  test("removeAnswer() removes existing answer", () => {
+    const a1 = new TaskAnswer("a1", new Task("t1", "t1"));
+    script.addAnswer(a1);
+    expect(script.answers.length).toBe(1);
+
+    const removed = script.removeAnswer("t1");
+
+    expect(removed).toBe(true);
+    expect(script.answers.length).toBe(0);
+  });
+
+  test("removeAnswer() returns false if answer not found", () => {
+    const removed = script.removeAnswer("missing");
+    expect(removed).toBe(false);
+  });
+
+  // ---------------------------------------------------------------
+  describe("grade distribution", () => {
+    test("getGradeDistribution counts correctly", () => {
+      script.addAnswer(new TaskAnswer("a1", new Task("1", "x"), "a", "MA"));
+      script.addAnswer(new TaskAnswer("a2", new Task("2", "x"), "a", "MA"));
+      script.addAnswer(new TaskAnswer("a3", new Task("3", "x"), "a", "MPA"));
+      script.addAnswer(new TaskAnswer("a4", new Task("4", "x"), "a", "MANA"));
+
+      const dist = script.getGradeDistribution();
+
+      expect(dist).toEqual({
+        MA: 2,
+        MPA: 1,
+        MANA: 1,
+      });
+    });
+
+  });
+});

From 002c6af76fc8dcd0ff5ba7baac3c43b9c97457ee Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Sun, 7 Dec 2025 18:37:13 -0300
Subject: [PATCH 029/102] testing: unit tests for corrigir-roteiro service
 routes and objects

---
 server/src/__tests__/ScriptAnswer.test.ts    |  37 +++-
 server/src/__tests__/ScriptAnswerSet.test.ts | 187 +++++++++++++++++++
 server/src/__tests__/TaskAnswer.test.ts      | 163 ++++++++++++++++
 server/src/__tests__/scriptgrading.test.ts   | 115 ++++++++++++
 4 files changed, 501 insertions(+), 1 deletion(-)
 create mode 100644 server/src/__tests__/ScriptAnswerSet.test.ts
 create mode 100644 server/src/__tests__/TaskAnswer.test.ts
 create mode 100644 server/src/__tests__/scriptgrading.test.ts

diff --git a/server/src/__tests__/ScriptAnswer.test.ts b/server/src/__tests__/ScriptAnswer.test.ts
index e9211a2a..3f5571b0 100644
--- a/server/src/__tests__/ScriptAnswer.test.ts
+++ b/server/src/__tests__/ScriptAnswer.test.ts
@@ -32,7 +32,7 @@ describe("ScriptAnswer", () => {
       id: "sa1",
       student: {
         name: "John Doe",
-        cpf: "123.456.789-09", // normalized by Student class
+        cpf: "123.456.789-09",
         email: "john@example.com",
       },
       answers: [
@@ -116,5 +116,40 @@ describe("ScriptAnswer", () => {
       });
     });
 
+    // NEW TEST
+    test("getNumberOfAnswersWithGrade throws on invalid grade", () => {
+      expect(() => (script as any).getNumberOfAnswersWithGrade("INVALID"))
+        .toThrow("Invalid grade");
+    });
+  });
+
+  // ---------------------------------------------------------------
+  // NEW TESTS: Grade validation in constructor and updateGrade()
+  // ---------------------------------------------------------------
+  describe("grade validation", () => {
+    test("constructor throws when initialized with invalid grade", () => {
+      expect(() => {
+        // @ts-expect-error intentionally invalid
+        new ScriptAnswer("bad", student, [], "INVALID");
+      }).toThrow("Invalid grade value");
+    });
+
+    test("updateGrade updates grade when valid", () => {
+      script.updateGrade("MA");
+      expect(script.grade).toBe("MA");
+
+      script.updateGrade("MPA");
+      expect(script.grade).toBe("MPA");
+
+      script.updateGrade(undefined);
+      expect(script.grade).toBeUndefined();
+    });
+
+    test("updateGrade throws on invalid grade", () => {
+      expect(() => {
+        // @ts-expect-error intentional invalid
+        script.updateGrade("WRONG");
+      }).toThrow("Invalid grade value");
+    });
   });
 });
diff --git a/server/src/__tests__/ScriptAnswerSet.test.ts b/server/src/__tests__/ScriptAnswerSet.test.ts
new file mode 100644
index 00000000..0237fa94
--- /dev/null
+++ b/server/src/__tests__/ScriptAnswerSet.test.ts
@@ -0,0 +1,187 @@
+import { ScriptAnswerSet } from '../models/ScriptAnswerSet';
+
+describe('ScriptAnswerSet', () => {
+  let set: ScriptAnswerSet;
+
+  beforeEach(() => {
+    set = new ScriptAnswerSet();
+  });
+
+  // -----------------------------------------
+  // addScriptAnswer
+  // -----------------------------------------
+  describe('addScriptAnswer', () => {
+    test('should add a new ScriptAnswer with explicit ID', () => {
+      const data = {
+        id: 'A1',
+        scriptId: 'S1',
+        studentId: 'ST1',
+        taskAnswers: [],
+        grade: 'MA'
+      };
+
+      const result = set.addScriptAnswer(data);
+
+      expect(result.id).toBe('A1');
+      expect(result.scriptId).toBe('S1');
+      expect(result.studentId).toBe('ST1');
+      expect(result.grade).toBe('MA');
+      expect(set.getAll().length).toBe(1);
+    });
+
+    test('should generate an ID if not provided', () => {
+      const data = {
+        scriptId: 'S1',
+        studentId: 'ST1'
+      };
+
+      const result = set.addScriptAnswer(data);
+
+      expect(result.id).toBeDefined();
+      expect(typeof result.id).toBe('string');
+      expect(set.getAll().length).toBe(1);
+    });
+  });
+
+  // -----------------------------------------
+  // removeScriptAnswer
+  // -----------------------------------------
+  describe('removeScriptAnswer', () => {
+    test('should remove existing script answer and return true', () => {
+      const a = set.addScriptAnswer({ id: 'A1', scriptId: 'S1', studentId: 'ST1' });
+      expect(set.getAll().length).toBe(1);
+    
+      const removed = set.removeScriptAnswer(a.id);
+
+      expect(removed).toBe(true);
+      expect(set.getAll().length).toBe(0);
+    });
+
+    test('should return false when answer does not exist', () => {
+      set.addScriptAnswer({ id: 'A1', scriptId: 'S1', studentId: 'ST1' });
+
+      const removed = set.removeScriptAnswer('INVALID');
+
+      expect(removed).toBe(false);
+      expect(set.getAll().length).toBe(1);
+    });
+  });
+
+  // -----------------------------------------
+  // getAll
+  // -----------------------------------------
+  describe('getAll', () => {
+    test('should return all stored script answers', () => {
+      set.addScriptAnswer({ id: 'A1', scriptId: 'S1', studentId: 'ST1' });
+      set.addScriptAnswer({ id: 'A2', scriptId: 'S2', studentId: 'ST2' });
+
+      const all = set.getAll();
+
+      expect(all.length).toBe(2);
+      expect(all.map(a => a.id)).toEqual(['A1', 'A2']);
+    });
+  });
+
+  // -----------------------------------------
+  // findByStudentId
+  // -----------------------------------------
+  describe('findByStudentId', () => {
+    test('should return all answers for a specific student', () => {
+      set.addScriptAnswer({ id: 'A1', scriptId: 'S1', studentId: 'ST1' });
+      set.addScriptAnswer({ id: 'A2', scriptId: 'S2', studentId: 'ST1' });
+      set.addScriptAnswer({ id: 'A3', scriptId: 'S3', studentId: 'ST2' });
+
+      const results = set.findByStudentId('ST1');
+
+      expect(results.length).toBe(2);
+      expect(results.map(a => a.id)).toEqual(['A1', 'A2']);
+    });
+
+    test('should return an empty array if student has no answers', () => {
+      set.addScriptAnswer({ id: 'A1', scriptId: 'S1', studentId: 'ST1' });
+
+      const results = set.findByStudentId('NOPE');
+
+      expect(results).toEqual([]);
+    });
+  });
+
+  // -----------------------------------------
+  // findById
+  // -----------------------------------------
+  describe('findById', () => {
+    test('should return the correct answer by ID', () => {
+      set.addScriptAnswer({ id: 'A1', scriptId: 'S1', studentId: 'ST1' });
+
+      const result = set.findById('A1');
+
+      expect(result).not.toBeNull();
+      expect(result?.scriptId).toBe('S1');
+    });
+
+    test('should return null for nonexistent ID', () => {
+      const result = set.findById('INVALID');
+
+      expect(result).toBeNull();
+    });
+  });
+
+  // -----------------------------------------
+  // updateGrade
+  // -----------------------------------------
+  describe('updateGrade', () => {
+    test('should update grade of an existing script answer', () => {
+      set.addScriptAnswer({ id: 'A1', scriptId: 'S1', studentId: 'ST1', grade: null });
+
+      const updated = set.updateGrade('A1', 'MA');
+
+      expect(updated).not.toBeNull();
+      expect(updated?.grade).toBe('MA');
+    });
+
+    test('should return null when updating a nonexistent answer', () => {
+      const updated = set.updateGrade('NOPE', 'MA');
+
+      expect(updated).toBeNull();
+    });
+  });
+
+  // -----------------------------------------
+  // updateTaskAnswer
+  // -----------------------------------------
+  describe('updateTaskAnswer', () => {
+    test('should update grade and comments of a task answer', () => {
+      set.addScriptAnswer({
+        id: 'A1',
+        scriptId: 'S1',
+        studentId: 'ST1',
+        taskAnswers: [
+          { id: 'TA1', grade: 'MA', comments: 'old comment' }
+        ]
+      });
+
+      const result = set.updateTaskAnswer('TA1', {
+        grade: 'MANA',
+        comments: 'new comment'
+      });
+
+      expect(result).not.toBeNull();
+      expect(result?.grade).toBe('MANA');
+      expect(result?.comments).toBe('new comment');
+    });
+
+    test('should return null when taskAnswerId does not exist', () => {
+      set.addScriptAnswer({
+        id: 'A1',
+        scriptId: 'S1',
+        studentId: 'ST1',
+        taskAnswers: []
+      });
+
+      const result = set.updateTaskAnswer('INVALID', { grade: 'MA' });
+
+      expect(result).toBeNull();
+    });
+  });
+
+});
diff --git a/server/src/__tests__/TaskAnswer.test.ts b/server/src/__tests__/TaskAnswer.test.ts
new file mode 100644
index 00000000..c0d3724b
--- /dev/null
+++ b/server/src/__tests__/TaskAnswer.test.ts
@@ -0,0 +1,163 @@
+import { TaskAnswer } from "../models/TaskAnswer";
+import { Task } from "../models/Task";
+import { Grade } from "../models/Evaluation";
+
+describe("TaskAnswer", () => {
+  let task: Task;
+
+  beforeEach(() => {
+    task = new Task("t1", "Example Task");
+  });
+
+  // ---------------------------------------------------------------
+  test("constructor initializes fields correctly", () => {
+    const ta = new TaskAnswer("a1", task, "my answer", "MA", "good job");
+
+    expect(ta.id).toBe("a1");
+    expect(ta.task).toBe(task);
+    expect(ta.answer).toBe("my answer");
+    expect(ta.getGrade()).toBe("MA");
+    expect(ta.comments).toBe("good job");
+  });
+
+  // ---------------------------------------------------------------
+  test("constructor throws on invalid grade", () => {
+    expect(() => {
+      new TaskAnswer("a1", task, "ans", "INVALID" as Grade);
+    }).toThrow("Invalid grade value");
+  });
+
+  test("constructor accepts undefined grade", () => {
+    const ta = new TaskAnswer("a1", task, "x", undefined);
+    expect(ta.getGrade()).toBeUndefined();
+  });
+
+  // ---------------------------------------------------------------
+  test("getTaskId() returns task id", () => {
+    const ta = new TaskAnswer("a1", task);
+    expect(ta.getTaskId()).toBe("t1");
+  });
+
+  // ---------------------------------------------------------------
+  test("toJSON() returns correct structure", () => {
+    const ta = new TaskAnswer("a1", task, "answer", "MPA");
+
+    expect(ta.toJSON()).toEqual({
+      id: "a1",
+      task: {
+        id: "t1",
+        statement: "Example Task",
+      },
+      answer: "answer",
+      grade: "MPA",
+      comments: undefined,
+    });
+  });
+
+  test("toJSON() omits grade when undefined", () => {
+    const ta = new TaskAnswer("a1", task, "ans", undefined);
+
+    expect(ta.toJSON()).toEqual({
+      id: "a1",
+      task: {
+        id: "t1",
+        statement: "Example Task",
+      },
+      answer: "ans",
+      grade: undefined,
+      comments: undefined,
+    });
+  });
+
+  // ---------------------------------------------------------------
+  describe("updateGrade()", () => {
+    test("updates grade correctly", () => {
+      const ta = new TaskAnswer("a1", task);
+      ta.updateGrade("MANA");
+
+      expect(ta.getGrade()).toBe("MANA");
+    });
+
+    test("removes grade when passed undefined", () => {
+      const ta = new TaskAnswer("a1", task, "x", "MA");
+      ta.updateGrade(undefined);
+
+      expect(ta.getGrade()).toBeUndefined();
+    });
+
+    test("throws on invalid grade", () => {
+      const ta = new TaskAnswer("a1", task);
+
+      expect(() => ta.updateGrade("BAD" as Grade)).toThrow("Invalid grade value");
+    });
+  });
+
+  // ---------------------------------------------------------------
+  describe("update()", () => {
+    test("updates answer", () => {
+      const ta = new TaskAnswer("a1", task);
+      ta.update({ answer: "new answer" });
+
+      expect(ta.answer).toBe("new answer");
+    });
+
+    test("updates comments", () => {
+      const ta = new TaskAnswer("a1", task);
+      ta.update({ comments: "hello" });
+
+      expect(ta.comments).toBe("hello");
+    });
+
+    test("updates grade", () => {
+      const ta = new TaskAnswer("a1", task);
+      ta.update({ grade: "MPA" });
+
+      expect(ta.getGrade()).toBe("MPA");
+    });
+
+    test("throws on invalid grade", () => {
+      const ta = new TaskAnswer("a1", task);
+
+      expect(() => ta.update({ grade: "WRONG" as Grade }))
+        .toThrow("Invalid grade value");
+    });
+
+    test("updates task via fromJSON()", () => {
+      const ta = new TaskAnswer("a1", task);
+      ta.update({ task: { id: "t2", statement: "New task" } });
+
+      expect(ta.getTaskId()).toBe("t2");
+      expect(ta.task.toJSON()).toEqual({
+        id: "t2",
+        statement: "New task",
+      });
+    });
+  });
+
+  // ---------------------------------------------------------------
+  describe("fromJSON()", () => {
+    test("creates TaskAnswer instance from JSON", () => {
+      const json = {
+        id: "a1",
+        task: task,
+        answer: "ans",
+        grade: "MA",
+        comments: "ok",
+      };
+
+      const ta = TaskAnswer.fromJSON(json);
+
+      expect(ta.id).toBe("a1");
+      expect(ta.answer).toBe("ans");
+      expect(ta.getGrade()).toBe("MA");
+      expect(ta.comments).toBe("ok");
+      expect(ta.task).toBe(task); // because constructor receives the task directly
+    });
+  });
+
+  // ---------------------------------------------------------------
+  test("getGrade() returns internal grade", () => {
+    const ta = new TaskAnswer("a1", task, "ans", "MANA");
+    expect(ta.getGrade()).toBe("MANA");
+  });
+});
diff --git a/server/src/__tests__/scriptgrading.test.ts b/server/src/__tests__/scriptgrading.test.ts
new file mode 100644
index 00000000..b6a3229d
--- /dev/null
+++ b/server/src/__tests__/scriptgrading.test.ts
@@ -0,0 +1,115 @@
+import request from 'supertest';
+import { app, scriptAnswerSet, studentSet } from '../server';
+import { Student } from '../models/Student';
+
+describe('Server API – Script Answers Endpoints', () => {
+
+  // Clean state before each test
+  beforeEach(() => {
+    // Clear students
+    const allStudents = studentSet.getAllStudents();
+    allStudents.forEach(s => studentSet.removeStudent(s.getCPF()));
+
+    // Clear script answers
+    const allAnswers = scriptAnswerSet.getAll();
+    allAnswers.forEach(a => scriptAnswerSet.removeScriptAnswer(a.id));
+    expect(scriptAnswerSet.getAll().length).toBe(0);
+  });
+
+  // ----------------------------------------------------------
+  // 1) Recuperar todas as respostas cadastradas
+  // ----------------------------------------------------------
+
+  test('GET /api/scripts/answers → returns all registered answers', async () => {
+    scriptAnswerSet.addScriptAnswer({ id: '123', scriptId: '1', studentId: 'S1' });
+    scriptAnswerSet.addScriptAnswer({ id: '321', scriptId: '2', studentId: 'S2' });
+    scriptAnswerSet.addScriptAnswer({ id: '890', scriptId: '3', studentId: 'S3' });
+
+    const res = await request(app).get('/api/scripts/answers');
+
+    expect(res.status).toBe(200);
+    const ids = res.body.map((a: any) => a.id);
+    expect(ids).toContain('123');
+    expect(ids).toContain('321');
+    expect(ids).toContain('890');
+  });
+
+  // ----------------------------------------------------------
+  // 2) Recuperar respostas quando não há nenhuma cadastrada
+  // ----------------------------------------------------------
+
+  test('GET /api/scripts/answers → returns empty list when none exist', async () => {
+    const res = await request(app).get('/api/scripts/answers');
+
+    expect(res.status).toBe(200);
+    expect(res.body).toEqual([]);
+  });
+
+  // ----------------------------------------------------------
+  // 3) Recuperar respostas de um aluno cadastrado
+  // ----------------------------------------------------------
+
+  test('GET /api/scripts/answers/student/:studentId → returns answers of a specific student', async () => {
+    studentSet.addStudent(new Student('Alice', '15029035478', 'alice@gmail.com'));
+    scriptAnswerSet.addScriptAnswer({ id: '40', scriptId: '1', studentId: '15029035478' });
+    scriptAnswerSet.addScriptAnswer({ id: '41', scriptId: '2', studentId: '15029035478' });
+    scriptAnswerSet.addScriptAnswer({ id: '999', scriptId: 'X', studentId: 'other' });
+
+    const res = await request(app).get('/api/scripts/answers/student/15029035478');
+
+    expect(res.status).toBe(200);
+    const ids = res.body.map((a: any) => a.id);
+    expect(ids).toEqual(['40', '41']);
+  });
+
+  // ----------------------------------------------------------
+  // 4) Tentar recuperar respostas de aluno não cadastrado
+  // ----------------------------------------------------------
+
+  test('GET /api/scripts/answers/student/:studentId → returns 404 if student not found', async () => {
+    const res = await request(app).get('/api/scripts/answers/student/999');
+
+    expect(res.status).toBe(404);
+    expect(res.body.error).toBe('Student not found');
+  });
+
+  // ----------------------------------------------------------
+  // 5) Recuperar a nota de uma questão existente
+  // ----------------------------------------------------------
+
+  test('GET /api/scripts/answers/:id/tasks/:taskId → returns grade for existing task', async () => {
+    scriptAnswerSet.addScriptAnswer({
+      id: '50',
+      scriptId: '1',
+      studentId: 'stu',
+      taskAnswers: [
+        { id: 'TA2', taskId: '2', grade: 'MA', comments: '' }
+      ]
+    });
+
+    const res = await request(app).get('/api/scripts/answers/50/tasks/2');
+
+    expect(res.status).toBe(200);
+    expect(res.body.grade).toBe('MA');
+  });
+
+  // ----------------------------------------------------------
+  // 6) Nota de questão inexistente
+  // ----------------------------------------------------------
+
+  test('GET /api/scripts/answers/:id/tasks/:taskId → returns 404 for missing task', async () => {
+    scriptAnswerSet.addScriptAnswer({
+      id: '50',
+      scriptId: '1',
+      studentId: 'stu',
+      taskAnswers: [
+        { id: 'TA2', taskId: '2', grade: 'MA', comments: '' }
+      ]
+    });
+
+    const res = await request(app).get('/api/scripts/answers/50/tasks/9');
+
+    expect(res.status).toBe(404);
+    expect(res.body.error).toBe('Task not found');
+  });
+});

From 6bb97ee28e6b5bda1395ae29297e213b63f208ce Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Sun, 7 Dec 2025 21:37:30 -0300
Subject: [PATCH 030/102] dependencies: testing dependencies added

---
 client/package.json |   4 +-
 package-lock.json   | 549 +++++++++++++++++++++-----------------------
 package.json        |   5 +-
 3 files changed, 270 insertions(+), 288 deletions(-)

diff --git a/client/package.json b/client/package.json
index c6d61325..4fdb008d 100644
--- a/client/package.json
+++ b/client/package.json
@@ -8,7 +8,7 @@
     "react-scripts": "5.0.1"
   },
   "devDependencies": {
-    "@cucumber/cucumber": "^12.2.0",
+    "@cucumber/cucumber": "^12.3.0",
     "@testing-library/jest-dom": "^6.9.1",
     "@testing-library/react": "^16.3.0",
     "@testing-library/user-event": "^14.6.1",
@@ -18,7 +18,7 @@
     "@types/react-dom": "^18.2.7",
     "expect": "^27.5.1",
     "jest-cucumber": "^4.5.0",
-    "puppeteer": "^24.30.0",
+    "puppeteer": "^24.32.0",
     "ts-node": "^10.9.2",
     "typescript": "^4.9.5"
   },
diff --git a/package-lock.json b/package-lock.json
index 5f18ab05..81203a01 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -14,7 +14,8 @@
         "server"
       ],
       "devDependencies": {
-        "concurrently": "^8.2.2"
+        "concurrently": "^8.2.2",
+        "jest-cucumber": "^4.5.0"
       }
     },
     "client": {
@@ -26,7 +27,7 @@
         "react-scripts": "5.0.1"
       },
       "devDependencies": {
-        "@cucumber/cucumber": "^12.2.0",
+        "@cucumber/cucumber": "^12.3.0",
         "@testing-library/jest-dom": "^6.9.1",
         "@testing-library/react": "^16.3.0",
         "@testing-library/user-event": "^14.6.1",
@@ -36,7 +37,7 @@
         "@types/react-dom": "^18.2.7",
         "expect": "^27.5.1",
         "jest-cucumber": "^4.5.0",
-        "puppeteer": "^24.30.0",
+        "puppeteer": "^24.32.0",
         "ts-node": "^10.9.2",
         "typescript": "^4.9.5"
       }
@@ -408,7 +409,6 @@
     "client/node_modules/@babel/plugin-syntax-flow": {
       "version": "7.27.1",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@babel/helper-plugin-utils": "^7.27.1"
       },
@@ -1031,7 +1031,6 @@
     "client/node_modules/@babel/plugin-transform-react-jsx": {
       "version": "7.27.1",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@babel/helper-annotate-as-pure": "^7.27.1",
         "@babel/helper-module-imports": "^7.27.1",
@@ -2552,7 +2551,6 @@
       "version": "18.3.26",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@types/prop-types": "*",
         "csstype": "^3.0.2"
@@ -2616,7 +2614,6 @@
     "client/node_modules/@typescript-eslint/eslint-plugin": {
       "version": "5.62.0",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@eslint-community/regexpp": "^4.4.0",
         "@typescript-eslint/scope-manager": "5.62.0",
@@ -2666,7 +2663,6 @@
     "client/node_modules/@typescript-eslint/parser": {
       "version": "5.62.0",
       "license": "BSD-2-Clause",
-      "peer": true,
       "dependencies": {
         "@typescript-eslint/scope-manager": "5.62.0",
         "@typescript-eslint/types": "5.62.0",
@@ -3041,7 +3037,6 @@
     "client/node_modules/ajv": {
       "version": "6.12.6",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "fast-deep-equal": "^3.1.1",
         "fast-json-stable-stringify": "^2.0.0",
@@ -4905,7 +4900,6 @@
     "client/node_modules/eslint": {
       "version": "8.57.1",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@eslint-community/eslint-utils": "^4.2.0",
         "@eslint-community/regexpp": "^4.6.1",
@@ -6851,7 +6845,6 @@
     "client/node_modules/jest": {
       "version": "27.5.1",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@jest/core": "^27.5.1",
         "import-local": "^3.0.2",
@@ -7630,7 +7623,6 @@
     "client/node_modules/jiti": {
       "version": "1.21.7",
       "license": "MIT",
-      "peer": true,
       "bin": {
         "jiti": "bin/jiti.js"
       }
@@ -8365,7 +8357,6 @@
         }
       ],
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "nanoid": "^3.3.11",
         "picocolors": "^1.1.1",
@@ -9364,7 +9355,6 @@
     "client/node_modules/postcss-selector-parser": {
       "version": "6.1.2",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "cssesc": "^3.0.0",
         "util-deprecate": "^1.0.2"
@@ -9749,7 +9739,6 @@
     "client/node_modules/react-refresh": {
       "version": "0.11.0",
       "license": "MIT",
-      "peer": true,
       "engines": {
         "node": ">=0.10.0"
       }
@@ -10082,7 +10071,6 @@
     "client/node_modules/rollup": {
       "version": "2.79.2",
       "license": "MIT",
-      "peer": true,
       "bin": {
         "rollup": "dist/bin/rollup"
       },
@@ -10270,7 +10258,6 @@
     "client/node_modules/schema-utils/node_modules/ajv": {
       "version": "8.17.1",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "fast-deep-equal": "^3.1.3",
         "fast-uri": "^3.0.1",
@@ -10311,16 +10298,6 @@
         "node": ">=10"
       }
     },
-    "client/node_modules/semver": {
-      "version": "7.7.3",
-      "license": "ISC",
-      "bin": {
-        "semver": "bin/semver.js"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
     "client/node_modules/send": {
       "version": "0.19.0",
       "license": "MIT",
@@ -11365,7 +11342,6 @@
     "client/node_modules/type-fest": {
       "version": "0.20.2",
       "license": "(MIT OR CC0-1.0)",
-      "peer": true,
       "engines": {
         "node": ">=10"
       },
@@ -11648,7 +11624,6 @@
     "client/node_modules/webpack": {
       "version": "5.102.1",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@types/eslint-scope": "^3.7.7",
         "@types/estree": "^1.0.8",
@@ -11716,7 +11691,6 @@
     "client/node_modules/webpack-dev-server": {
       "version": "4.15.2",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@types/bonjour": "^3.5.9",
         "@types/connect-history-api-fallback": "^1.3.5",
@@ -12066,7 +12040,6 @@
     "client/node_modules/workbox-build/node_modules/ajv": {
       "version": "8.17.1",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "fast-deep-equal": "^3.1.3",
         "fast-uri": "^3.0.1",
@@ -12357,7 +12330,6 @@
       "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.28.5.tgz",
       "integrity": "sha512-e7jT4DxYvIDLk1ZHmU/m/mB19rex9sv0c2ftBtjSBv+kVM/902eh0fINUzD7UwLLNR+jU585GxUJ8/EBfAM5fw==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@babel/code-frame": "^7.27.1",
         "@babel/generator": "^7.28.5",
@@ -12862,31 +12834,30 @@
       }
     },
     "node_modules/@cucumber/ci-environment": {
-      "version": "10.0.1",
-      "resolved": "https://registry.npmjs.org/@cucumber/ci-environment/-/ci-environment-10.0.1.tgz",
-      "integrity": "sha512-/+ooDMPtKSmvcPMDYnMZt4LuoipfFfHaYspStI4shqw8FyKcfQAmekz6G+QKWjQQrvM+7Hkljwx58MEwPCwwzg==",
+      "version": "12.0.0",
+      "resolved": "https://registry.npmjs.org/@cucumber/ci-environment/-/ci-environment-12.0.0.tgz",
+      "integrity": "sha512-SqCEnbCNl3zCXCFpqGUuoaSNhLC0jLw4tKeFcAxTw9MD/QRlJjeAC/fyvVLFuXuSq0OunJlFfxLu+Z3HE+oLPg==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/@cucumber/cucumber": {
-      "version": "12.2.0",
-      "resolved": "https://registry.npmjs.org/@cucumber/cucumber/-/cucumber-12.2.0.tgz",
-      "integrity": "sha512-b7W4snvXYi1T2puUjxamASCCNhNzVSzb/fQUuGSkdjm/AFfJ24jo8kOHQyOcaoArCG71sVQci4vkZaITzl/V1w==",
+      "version": "12.3.0",
+      "resolved": "https://registry.npmjs.org/@cucumber/cucumber/-/cucumber-12.3.0.tgz",
+      "integrity": "sha512-36cIyplE1iDl12s4k6lBVpceua8tKLklFTf7CUITPrNHTLlQ/KBr7NYUUHviPzCbj2Ox3BPTZ6qkSLd6WMvVQg==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
-        "@cucumber/ci-environment": "10.0.1",
+        "@cucumber/ci-environment": "12.0.0",
         "@cucumber/cucumber-expressions": "18.0.1",
-        "@cucumber/gherkin": "34.0.0",
-        "@cucumber/gherkin-streams": "5.0.1",
-        "@cucumber/gherkin-utils": "9.2.0",
-        "@cucumber/html-formatter": "21.14.0",
-        "@cucumber/junit-xml-formatter": "0.8.1",
+        "@cucumber/gherkin": "37.0.0",
+        "@cucumber/gherkin-streams": "6.0.0",
+        "@cucumber/gherkin-utils": "10.0.0",
+        "@cucumber/html-formatter": "22.2.0",
+        "@cucumber/junit-xml-formatter": "0.9.0",
         "@cucumber/message-streams": "4.0.1",
-        "@cucumber/messages": "28.1.0",
+        "@cucumber/messages": "31.0.0",
         "@cucumber/pretty-formatter": "1.0.1",
-        "@cucumber/tag-expressions": "6.2.0",
+        "@cucumber/tag-expressions": "8.1.0",
         "assertion-error-formatter": "^3.0.0",
         "capital-case": "^1.0.4",
         "chalk": "^4.1.2",
@@ -12895,7 +12866,7 @@
         "debug": "^4.3.4",
         "error-stack-parser": "^2.1.4",
         "figures": "^3.2.0",
-        "glob": "^11.0.0",
+        "glob": "^13.0.0",
         "has-ansi": "^4.0.1",
         "indent-string": "^4.0.0",
         "is-installed-globally": "^0.4.0",
@@ -12903,19 +12874,19 @@
         "knuth-shuffle-seeded": "^1.0.6",
         "lodash.merge": "^4.6.2",
         "lodash.mergewith": "^4.6.2",
-        "luxon": "3.7.1",
+        "luxon": "3.7.2",
         "mime": "^3.0.0",
         "mkdirp": "^3.0.0",
         "mz": "^2.7.0",
         "progress": "^2.0.3",
-        "read-package-up": "^11.0.0",
-        "semver": "7.7.2",
+        "read-package-up": "^12.0.0",
+        "semver": "7.7.3",
         "string-argv": "0.3.1",
         "supports-color": "^8.1.1",
         "type-fest": "^4.41.0",
         "util-arity": "^1.1.0",
         "yaml": "^2.2.2",
-        "yup": "1.7.0"
+        "yup": "1.7.1"
       },
       "bin": {
         "cucumber-js": "bin/cucumber.js"
@@ -12937,6 +12908,17 @@
         "regexp-match-indices": "1.0.2"
       }
     },
+    "node_modules/@cucumber/cucumber/node_modules/@cucumber/messages": {
+      "version": "31.0.0",
+      "resolved": "https://registry.npmjs.org/@cucumber/messages/-/messages-31.0.0.tgz",
+      "integrity": "sha512-Dqhatp4AjMsH9SREfWz3Q8nlGuwJMTW7YAW5L3OzRId86ZUEu/a8vIL1RO2c0agQefuBS2SVH9fEZ66ovrMYRA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "class-transformer": "0.5.1",
+        "reflect-metadata": "0.2.2"
+      }
+    },
     "node_modules/@cucumber/cucumber/node_modules/mkdirp": {
       "version": "3.0.1",
       "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-3.0.1.tgz",
@@ -12954,24 +12936,23 @@
       }
     },
     "node_modules/@cucumber/gherkin": {
-      "version": "34.0.0",
-      "resolved": "https://registry.npmjs.org/@cucumber/gherkin/-/gherkin-34.0.0.tgz",
-      "integrity": "sha512-659CCFsrsyvuBi/Eix1fnhSheMnojSfnBcqJ3IMPNawx7JlrNJDcXYSSdxcUw3n/nG05P+ptCjmiZY3i14p+tA==",
+      "version": "37.0.0",
+      "resolved": "https://registry.npmjs.org/@cucumber/gherkin/-/gherkin-37.0.0.tgz",
+      "integrity": "sha512-vKJVJ6h4HCktG870wgYUUskNpFxbFI0WmAkVLPTz1LlLwJX7/KOBqFcr2/L3u0pPoHjbLRW+IpbiXLT2T13/wg==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
-        "@cucumber/messages": ">=19.1.4 <29"
+        "@cucumber/messages": ">=31.0.0 <32"
       }
     },
     "node_modules/@cucumber/gherkin-streams": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/@cucumber/gherkin-streams/-/gherkin-streams-5.0.1.tgz",
-      "integrity": "sha512-/7VkIE/ASxIP/jd4Crlp4JHXqdNFxPGQokqWqsaCCiqBiu5qHoKMxcWNlp9njVL/n9yN4S08OmY3ZR8uC5x74Q==",
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/@cucumber/gherkin-streams/-/gherkin-streams-6.0.0.tgz",
+      "integrity": "sha512-HLSHMmdDH0vCr7vsVEURcDA4WwnRLdjkhqr6a4HQ3i4RFK1wiDGPjBGVdGJLyuXuRdJpJbFc6QxHvT8pU4t6jw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "commander": "9.1.0",
+        "commander": "14.0.0",
         "source-map-support": "0.5.21"
       },
       "bin": {
@@ -12984,26 +12965,26 @@
       }
     },
     "node_modules/@cucumber/gherkin-streams/node_modules/commander": {
-      "version": "9.1.0",
-      "resolved": "https://registry.npmjs.org/commander/-/commander-9.1.0.tgz",
-      "integrity": "sha512-i0/MaqBtdbnJ4XQs4Pmyb+oFQl+q0lsAmokVUH92SlSw4fkeAcG3bVon+Qt7hmtF+u3Het6o4VgrcY3qAoEB6w==",
+      "version": "14.0.0",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-14.0.0.tgz",
+      "integrity": "sha512-2uM9rYjPvyq39NwLRqaiLtWHyDC1FvryJDa2ATTVims5YAS4PupsEQsDvP14FqhFr0P49CYDugi59xaxJlTXRA==",
       "dev": true,
       "license": "MIT",
       "engines": {
-        "node": "^12.20.0 || >=14"
+        "node": ">=20"
       }
     },
     "node_modules/@cucumber/gherkin-utils": {
-      "version": "9.2.0",
-      "resolved": "https://registry.npmjs.org/@cucumber/gherkin-utils/-/gherkin-utils-9.2.0.tgz",
-      "integrity": "sha512-3nmRbG1bUAZP3fAaUBNmqWO0z0OSkykZZotfLjyhc8KWwDSOrOmMJlBTd474lpA8EWh4JFLAX3iXgynBqBvKzw==",
+      "version": "10.0.0",
+      "resolved": "https://registry.npmjs.org/@cucumber/gherkin-utils/-/gherkin-utils-10.0.0.tgz",
+      "integrity": "sha512-BcujlDT343GXXNrMPl3ws6Il3zs8dQw3Yp/d3HnOJF8i2snGGgiapoTbko7MdvAt7ivDL7SDo+e1d5Cnpl3llA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@cucumber/gherkin": "^31.0.0",
-        "@cucumber/messages": "^27.0.0",
+        "@cucumber/gherkin": "^34.0.0",
+        "@cucumber/messages": "^29.0.0",
         "@teppeis/multimaps": "3.0.0",
-        "commander": "13.1.0",
+        "commander": "14.0.0",
         "source-map-support": "^0.5.21"
       },
       "bin": {
@@ -13011,83 +12992,64 @@
       }
     },
     "node_modules/@cucumber/gherkin-utils/node_modules/@cucumber/gherkin": {
-      "version": "31.0.0",
-      "resolved": "https://registry.npmjs.org/@cucumber/gherkin/-/gherkin-31.0.0.tgz",
-      "integrity": "sha512-wlZfdPif7JpBWJdqvHk1Mkr21L5vl4EfxVUOS4JinWGf3FLRV6IKUekBv5bb5VX79fkDcfDvESzcQ8WQc07Wgw==",
+      "version": "34.0.0",
+      "resolved": "https://registry.npmjs.org/@cucumber/gherkin/-/gherkin-34.0.0.tgz",
+      "integrity": "sha512-659CCFsrsyvuBi/Eix1fnhSheMnojSfnBcqJ3IMPNawx7JlrNJDcXYSSdxcUw3n/nG05P+ptCjmiZY3i14p+tA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@cucumber/messages": ">=19.1.4 <=26"
+        "@cucumber/messages": ">=19.1.4 <29"
       }
     },
     "node_modules/@cucumber/gherkin-utils/node_modules/@cucumber/gherkin/node_modules/@cucumber/messages": {
-      "version": "26.0.1",
-      "resolved": "https://registry.npmjs.org/@cucumber/messages/-/messages-26.0.1.tgz",
-      "integrity": "sha512-DIxSg+ZGariumO+Lq6bn4kOUIUET83A4umrnWmidjGFl8XxkBieUZtsmNbLYgH/gnsmP07EfxxdTr0hOchV1Sg==",
+      "version": "28.1.0",
+      "resolved": "https://registry.npmjs.org/@cucumber/messages/-/messages-28.1.0.tgz",
+      "integrity": "sha512-2LzZtOwYKNlCuNf31ajkrekoy2M4z0Z1QGiPH40n4gf5t8VOUFb7m1ojtR4LmGvZxBGvJZP8voOmRqDWzBzYKA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@types/uuid": "10.0.0",
         "class-transformer": "0.5.1",
         "reflect-metadata": "0.2.2",
-        "uuid": "10.0.0"
-      }
-    },
-    "node_modules/@cucumber/gherkin-utils/node_modules/@cucumber/gherkin/node_modules/uuid": {
-      "version": "10.0.0",
-      "resolved": "https://registry.npmjs.org/uuid/-/uuid-10.0.0.tgz",
-      "integrity": "sha512-8XkAphELsDnEGrDxUOHB3RGvXz6TeuYSGEZBOjtTtPm2lwhGBjLgOzLHB63IUWfBpNucQjND6d3AOudO+H3RWQ==",
-      "dev": true,
-      "funding": [
-        "https://github.com/sponsors/broofa",
-        "https://github.com/sponsors/ctavan"
-      ],
-      "license": "MIT",
-      "bin": {
-        "uuid": "dist/bin/uuid"
+        "uuid": "11.1.0"
       }
     },
     "node_modules/@cucumber/gherkin-utils/node_modules/@cucumber/messages": {
-      "version": "27.2.0",
-      "resolved": "https://registry.npmjs.org/@cucumber/messages/-/messages-27.2.0.tgz",
-      "integrity": "sha512-f2o/HqKHgsqzFLdq6fAhfG1FNOQPdBdyMGpKwhb7hZqg0yZtx9BVqkTyuoNk83Fcvk3wjMVfouFXXHNEk4nddA==",
+      "version": "29.0.1",
+      "resolved": "https://registry.npmjs.org/@cucumber/messages/-/messages-29.0.1.tgz",
+      "integrity": "sha512-aAvIYfQD6/aBdF8KFQChC3CQ1Q+GX9orlR6GurGiX6oqaCnBkxA4WU3OQUVepDynEFrPayerqKRFcAMhdcXReQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@types/uuid": "10.0.0",
         "class-transformer": "0.5.1",
-        "reflect-metadata": "0.2.2",
-        "uuid": "11.0.5"
+        "reflect-metadata": "0.2.2"
       }
     },
     "node_modules/@cucumber/gherkin-utils/node_modules/commander": {
-      "version": "13.1.0",
-      "resolved": "https://registry.npmjs.org/commander/-/commander-13.1.0.tgz",
-      "integrity": "sha512-/rFeCpNJQbhSZjGVwO9RFV3xPqbnERS8MmIQzCtD/zl6gpJuV/bMLuN92oG3F7d8oDEHHRrujSXNUr8fpjntKw==",
+      "version": "14.0.0",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-14.0.0.tgz",
+      "integrity": "sha512-2uM9rYjPvyq39NwLRqaiLtWHyDC1FvryJDa2ATTVims5YAS4PupsEQsDvP14FqhFr0P49CYDugi59xaxJlTXRA==",
       "dev": true,
       "license": "MIT",
       "engines": {
-        "node": ">=18"
+        "node": ">=20"
       }
     },
-    "node_modules/@cucumber/gherkin-utils/node_modules/uuid": {
-      "version": "11.0.5",
-      "resolved": "https://registry.npmjs.org/uuid/-/uuid-11.0.5.tgz",
-      "integrity": "sha512-508e6IcKLrhxKdBbcA2b4KQZlLVp2+J5UwQ6F7Drckkc5N9ZJwFa4TgWtsww9UG8fGHbm6gbV19TdM5pQ4GaIA==",
+    "node_modules/@cucumber/gherkin/node_modules/@cucumber/messages": {
+      "version": "31.0.0",
+      "resolved": "https://registry.npmjs.org/@cucumber/messages/-/messages-31.0.0.tgz",
+      "integrity": "sha512-Dqhatp4AjMsH9SREfWz3Q8nlGuwJMTW7YAW5L3OzRId86ZUEu/a8vIL1RO2c0agQefuBS2SVH9fEZ66ovrMYRA==",
       "dev": true,
-      "funding": [
-        "https://github.com/sponsors/broofa",
-        "https://github.com/sponsors/ctavan"
-      ],
       "license": "MIT",
-      "bin": {
-        "uuid": "dist/esm/bin/uuid"
+      "dependencies": {
+        "class-transformer": "0.5.1",
+        "reflect-metadata": "0.2.2"
       }
     },
     "node_modules/@cucumber/html-formatter": {
-      "version": "21.14.0",
-      "resolved": "https://registry.npmjs.org/@cucumber/html-formatter/-/html-formatter-21.14.0.tgz",
-      "integrity": "sha512-vQqbmQZc0QiN4c+cMCffCItpODJlOlYtPG7pH6We096dBOa7u0ttDMjT6KrMAnQlcln54rHL46r408IFpuznAw==",
+      "version": "22.2.0",
+      "resolved": "https://registry.npmjs.org/@cucumber/html-formatter/-/html-formatter-22.2.0.tgz",
+      "integrity": "sha512-fUNC/KngTIz+hAQ2Yr4XjdYq+MO60PwK9SidxBQ54jNI1Vw7erlgsPq0TOWneCIvdjU3qp+YDqYG1hw3zuUuDA==",
       "dev": true,
       "license": "MIT",
       "peerDependencies": {
@@ -13095,13 +13057,13 @@
       }
     },
     "node_modules/@cucumber/junit-xml-formatter": {
-      "version": "0.8.1",
-      "resolved": "https://registry.npmjs.org/@cucumber/junit-xml-formatter/-/junit-xml-formatter-0.8.1.tgz",
-      "integrity": "sha512-FT1Y96pyd9/ifbE9I7dbkTCjkwEdW9C0MBobUZoKD13c8EnWAt0xl1Yy/v/WZLTk4XfCLte1DATtLx01jt+YiA==",
+      "version": "0.9.0",
+      "resolved": "https://registry.npmjs.org/@cucumber/junit-xml-formatter/-/junit-xml-formatter-0.9.0.tgz",
+      "integrity": "sha512-WF+A7pBaXpKMD1i7K59Nk5519zj4extxY4+4nSgv5XLsGXHDf1gJnb84BkLUzevNtp2o2QzMG0vWLwSm8V5blw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@cucumber/query": "^13.0.2",
+        "@cucumber/query": "^14.0.1",
         "@teppeis/multimaps": "^3.0.0",
         "luxon": "^3.5.0",
         "xmlbuilder": "^15.1.1"
@@ -13116,7 +13078,6 @@
       "integrity": "sha512-Kxap9uP5jD8tHUZVjTWgzxemi/0uOsbGjd4LBOSxcJoOCRbESFwemUzilJuzNTB8pcTQUh8D5oudUyxfkJOKmA==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "peerDependencies": {
         "@cucumber/messages": ">=17.1.1"
       }
@@ -13166,9 +13127,9 @@
       }
     },
     "node_modules/@cucumber/query": {
-      "version": "13.6.0",
-      "resolved": "https://registry.npmjs.org/@cucumber/query/-/query-13.6.0.tgz",
-      "integrity": "sha512-tiDneuD5MoWsJ9VKPBmQok31mSX9Ybl+U4wqDoXeZgsXHDURqzM3rnpWVV3bC34y9W6vuFxrlwF/m7HdOxwqRw==",
+      "version": "14.6.0",
+      "resolved": "https://registry.npmjs.org/@cucumber/query/-/query-14.6.0.tgz",
+      "integrity": "sha512-bPbfpkDsFCBn95erh3un76QViPqGAo3T7iYews0yA3/JRNoV009s7acxxY+f+OMABPFl0TJVIZlvqX+KayQ+Eg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -13180,9 +13141,9 @@
       }
     },
     "node_modules/@cucumber/tag-expressions": {
-      "version": "6.2.0",
-      "resolved": "https://registry.npmjs.org/@cucumber/tag-expressions/-/tag-expressions-6.2.0.tgz",
-      "integrity": "sha512-KIF0eLcafHbWOuSDWFw0lMmgJOLdDRWjEL1kfXEWrqHmx2119HxVAr35WuEd9z542d3Yyg+XNqSr+81rIKqEdg==",
+      "version": "8.1.0",
+      "resolved": "https://registry.npmjs.org/@cucumber/tag-expressions/-/tag-expressions-8.1.0.tgz",
+      "integrity": "sha512-UFeOVUyc711/E7VHjThxMwg3jbGod9TlbM1gxNixX/AGDKg82Eha4cE0tKki3GGUs7uB2NyI+hQAuhB8rL2h5A==",
       "dev": true,
       "license": "MIT"
     },
@@ -13193,6 +13154,7 @@
       "dev": true,
       "license": "MIT",
       "optional": true,
+      "peer": true,
       "dependencies": {
         "@emnapi/wasi-threads": "1.1.0",
         "tslib": "^2.4.0"
@@ -13205,6 +13167,7 @@
       "dev": true,
       "license": "MIT",
       "optional": true,
+      "peer": true,
       "dependencies": {
         "tslib": "^2.4.0"
       }
@@ -13216,6 +13179,7 @@
       "dev": true,
       "license": "MIT",
       "optional": true,
+      "peer": true,
       "dependencies": {
         "tslib": "^2.4.0"
       }
@@ -13955,6 +13919,7 @@
       "dev": true,
       "license": "MIT",
       "optional": true,
+      "peer": true,
       "dependencies": {
         "@emnapi/core": "^1.4.3",
         "@emnapi/runtime": "^1.4.3",
@@ -14008,9 +13973,9 @@
       }
     },
     "node_modules/@puppeteer/browsers": {
-      "version": "2.10.13",
-      "resolved": "https://registry.npmjs.org/@puppeteer/browsers/-/browsers-2.10.13.tgz",
-      "integrity": "sha512-a9Ruw3j3qlnB5a/zHRTkruppynxqaeE4H9WNj5eYGRWqw0ZauZ23f4W2ARf3hghF5doozyD+CRtt7XSYuYRI/Q==",
+      "version": "2.11.0",
+      "resolved": "https://registry.npmjs.org/@puppeteer/browsers/-/browsers-2.11.0.tgz",
+      "integrity": "sha512-n6oQX6mYkG8TRPuPXmbPidkUbsSRalhmaaVAQxvH1IkQy63cwsH+kOjB3e4cpCDHg0aSvsiX9bQ4s2VB6mGWUQ==",
       "dev": true,
       "license": "Apache-2.0",
       "dependencies": {
@@ -14029,19 +13994,6 @@
         "node": ">=18"
       }
     },
-    "node_modules/@puppeteer/browsers/node_modules/semver": {
-      "version": "7.7.3",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.3.tgz",
-      "integrity": "sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==",
-      "dev": true,
-      "license": "ISC",
-      "bin": {
-        "semver": "bin/semver.js"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
     "node_modules/@sinclair/typebox": {
       "version": "0.34.41",
       "resolved": "https://registry.npmjs.org/@sinclair/typebox/-/typebox-0.34.41.tgz",
@@ -14211,6 +14163,7 @@
       "dev": true,
       "license": "MIT",
       "optional": true,
+      "peer": true,
       "dependencies": {
         "tslib": "^2.4.0"
       }
@@ -14220,7 +14173,8 @@
       "resolved": "https://registry.npmjs.org/@types/aria-query/-/aria-query-5.0.4.tgz",
       "integrity": "sha512-rfT93uj5s0PRL7EzccGMs3brplhcrghnDoV26NqKhCAS1hVo+WdNsPvE/yb6ilfr5hi2MEk6d5EWJTKdxg8jVw==",
       "dev": true,
-      "license": "MIT"
+      "license": "MIT",
+      "peer": true
     },
     "node_modules/@types/babel__core": {
       "version": "7.20.5",
@@ -14349,7 +14303,6 @@
       "integrity": "sha512-XTYugzhuwqWjws0CVz8QpM36+T+Dz5mTEBKhNs/esGLnCIlGdRy+Dq78NRjd7ls7r8BC8ZRMOrKlkO1hU0JOwA==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "expect": "^30.0.0",
         "pretty-format": "^30.0.0"
@@ -14563,7 +14516,8 @@
       "optional": true,
       "os": [
         "android"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/@unrs/resolver-binding-android-arm64": {
       "version": "1.11.1",
@@ -14577,7 +14531,8 @@
       "optional": true,
       "os": [
         "android"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/@unrs/resolver-binding-darwin-arm64": {
       "version": "1.11.1",
@@ -14591,7 +14546,8 @@
       "optional": true,
       "os": [
         "darwin"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/@unrs/resolver-binding-darwin-x64": {
       "version": "1.11.1",
@@ -14605,7 +14561,8 @@
       "optional": true,
       "os": [
         "darwin"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/@unrs/resolver-binding-freebsd-x64": {
       "version": "1.11.1",
@@ -14619,7 +14576,8 @@
       "optional": true,
       "os": [
         "freebsd"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/@unrs/resolver-binding-linux-arm-gnueabihf": {
       "version": "1.11.1",
@@ -14633,7 +14591,8 @@
       "optional": true,
       "os": [
         "linux"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/@unrs/resolver-binding-linux-arm-musleabihf": {
       "version": "1.11.1",
@@ -14647,7 +14606,8 @@
       "optional": true,
       "os": [
         "linux"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/@unrs/resolver-binding-linux-arm64-gnu": {
       "version": "1.11.1",
@@ -14661,7 +14621,8 @@
       "optional": true,
       "os": [
         "linux"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/@unrs/resolver-binding-linux-arm64-musl": {
       "version": "1.11.1",
@@ -14675,7 +14636,8 @@
       "optional": true,
       "os": [
         "linux"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/@unrs/resolver-binding-linux-ppc64-gnu": {
       "version": "1.11.1",
@@ -14689,7 +14651,8 @@
       "optional": true,
       "os": [
         "linux"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/@unrs/resolver-binding-linux-riscv64-gnu": {
       "version": "1.11.1",
@@ -14703,7 +14666,8 @@
       "optional": true,
       "os": [
         "linux"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/@unrs/resolver-binding-linux-riscv64-musl": {
       "version": "1.11.1",
@@ -14717,7 +14681,8 @@
       "optional": true,
       "os": [
         "linux"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/@unrs/resolver-binding-linux-s390x-gnu": {
       "version": "1.11.1",
@@ -14731,7 +14696,8 @@
       "optional": true,
       "os": [
         "linux"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/@unrs/resolver-binding-linux-x64-gnu": {
       "version": "1.11.1",
@@ -14745,7 +14711,8 @@
       "optional": true,
       "os": [
         "linux"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/@unrs/resolver-binding-linux-x64-musl": {
       "version": "1.11.1",
@@ -14759,7 +14726,8 @@
       "optional": true,
       "os": [
         "linux"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/@unrs/resolver-binding-wasm32-wasi": {
       "version": "1.11.1",
@@ -14771,6 +14739,7 @@
       "dev": true,
       "license": "MIT",
       "optional": true,
+      "peer": true,
       "dependencies": {
         "@napi-rs/wasm-runtime": "^0.2.11"
       },
@@ -14790,7 +14759,8 @@
       "optional": true,
       "os": [
         "win32"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/@unrs/resolver-binding-win32-ia32-msvc": {
       "version": "1.11.1",
@@ -14804,7 +14774,8 @@
       "optional": true,
       "os": [
         "win32"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/@unrs/resolver-binding-win32-x64-msvc": {
       "version": "1.11.1",
@@ -14818,14 +14789,14 @@
       "optional": true,
       "os": [
         "win32"
-      ]
+      ],
+      "peer": true
     },
     "node_modules/acorn": {
       "version": "8.15.0",
       "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz",
       "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
       "license": "MIT",
-      "peer": true,
       "bin": {
         "acorn": "bin/acorn"
       },
@@ -15125,9 +15096,9 @@
       }
     },
     "node_modules/bare-fs": {
-      "version": "4.5.1",
-      "resolved": "https://registry.npmjs.org/bare-fs/-/bare-fs-4.5.1.tgz",
-      "integrity": "sha512-zGUCsm3yv/ePt2PHNbVxjjn0nNB1MkIaR4wOCxJ2ig5pCf5cCVAYJXVhQg/3OhhJV6DB1ts7Hv0oUaElc2TPQg==",
+      "version": "4.5.2",
+      "resolved": "https://registry.npmjs.org/bare-fs/-/bare-fs-4.5.2.tgz",
+      "integrity": "sha512-veTnRzkb6aPHOvSKIOy60KzURfBdUflr5VReI+NSaPL6xf+XLdONQgZgpYvUuZLVQ8dCqxpBAudaOM1+KpAUxw==",
       "dev": true,
       "license": "Apache-2.0",
       "optional": true,
@@ -15266,7 +15237,6 @@
         }
       ],
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "baseline-browser-mapping": "^2.8.25",
         "caniuse-lite": "^1.0.30001754",
@@ -15816,12 +15786,11 @@
       }
     },
     "node_modules/devtools-protocol": {
-      "version": "0.0.1521046",
-      "resolved": "https://registry.npmjs.org/devtools-protocol/-/devtools-protocol-0.0.1521046.tgz",
-      "integrity": "sha512-vhE6eymDQSKWUXwwA37NtTTVEzjtGVfDr3pRbsWEQ5onH/Snp2c+2xZHWJJawG/0hCCJLRGt4xVtEVUVILol4w==",
+      "version": "0.0.1534754",
+      "resolved": "https://registry.npmjs.org/devtools-protocol/-/devtools-protocol-0.0.1534754.tgz",
+      "integrity": "sha512-26T91cV5dbOYnXdJi5qQHoTtUoNEqwkHcAyu/IKtjIAxiEqPMrDiRkDOPWVsGfNZGmlQVHQbZRSjD8sxagWVsQ==",
       "dev": true,
-      "license": "BSD-3-Clause",
-      "peer": true
+      "license": "BSD-3-Clause"
     },
     "node_modules/dezalgo": {
       "version": "1.0.4",
@@ -15849,7 +15818,8 @@
       "resolved": "https://registry.npmjs.org/dom-accessibility-api/-/dom-accessibility-api-0.5.16.tgz",
       "integrity": "sha512-X7BJ2yElsnOJ30pZF4uIIDfBEVgF4XEBxL9Bxhy6dnrm5hkzqmsWHGTiHqRiITNhMyFLyAiWndIJP7Z1NTteDg==",
       "dev": true,
-      "license": "MIT"
+      "license": "MIT",
+      "peer": true
     },
     "node_modules/dunder-proto": {
       "version": "1.0.1",
@@ -16419,22 +16389,16 @@
       }
     },
     "node_modules/glob": {
-      "version": "11.0.3",
-      "resolved": "https://registry.npmjs.org/glob/-/glob-11.0.3.tgz",
-      "integrity": "sha512-2Nim7dha1KVkaiF4q6Dj+ngPPMdfvLJEOpZk/jKiUAkqKebpGAWQXAq9z1xu9HKu5lWfqw/FASuccEjyznjPaA==",
+      "version": "13.0.0",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-13.0.0.tgz",
+      "integrity": "sha512-tvZgpqk6fz4BaNZ66ZsRaZnbHvP/jG3uKJvAZOwEVUL4RTA5nJeeLYfyN9/VA8NX/V3IBG+hkeuGpKjvELkVhA==",
       "dev": true,
-      "license": "ISC",
+      "license": "BlueOak-1.0.0",
       "dependencies": {
-        "foreground-child": "^3.3.1",
-        "jackspeak": "^4.1.1",
-        "minimatch": "^10.0.3",
+        "minimatch": "^10.1.1",
         "minipass": "^7.1.2",
-        "package-json-from-dist": "^1.0.0",
         "path-scurry": "^2.0.0"
       },
-      "bin": {
-        "glob": "dist/esm/bin.mjs"
-      },
       "engines": {
         "node": "20 || >=22"
       },
@@ -16570,25 +16534,18 @@
       }
     },
     "node_modules/hosted-git-info": {
-      "version": "7.0.2",
-      "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-7.0.2.tgz",
-      "integrity": "sha512-puUZAUKT5m8Zzvs72XWy3HtvVbTWljRE66cP60bxJzAqf2DgICo7lYTY2IHUmLnNpjYvw5bvmoHvPc0QO2a62w==",
+      "version": "9.0.2",
+      "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-9.0.2.tgz",
+      "integrity": "sha512-M422h7o/BR3rmCQ8UHi7cyyMqKltdP9Uo+J2fXK+RSAY+wTcKOIRyhTuKv4qn+DJf3g+PL890AzId5KZpX+CBg==",
       "dev": true,
       "license": "ISC",
       "dependencies": {
-        "lru-cache": "^10.0.1"
+        "lru-cache": "^11.1.0"
       },
       "engines": {
-        "node": "^16.14.0 || >=18.0.0"
+        "node": "^20.17.0 || >=22.9.0"
       }
     },
-    "node_modules/hosted-git-info/node_modules/lru-cache": {
-      "version": "10.4.3",
-      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz",
-      "integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==",
-      "dev": true,
-      "license": "ISC"
-    },
     "node_modules/html-escaper": {
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/html-escaper/-/html-escaper-2.0.2.tgz",
@@ -16904,29 +16861,12 @@
         "node": ">=8"
       }
     },
-    "node_modules/jackspeak": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-4.1.1.tgz",
-      "integrity": "sha512-zptv57P3GpL+O0I7VdMJNBZCu+BPHVQUk55Ft8/QCJjTVxrnJHuVuX/0Bl2A6/+2oyR/ZMEuFKwmzqqZ/U5nPQ==",
-      "dev": true,
-      "license": "BlueOak-1.0.0",
-      "dependencies": {
-        "@isaacs/cliui": "^8.0.2"
-      },
-      "engines": {
-        "node": "20 || >=22"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
     "node_modules/jest": {
       "version": "30.2.0",
       "resolved": "https://registry.npmjs.org/jest/-/jest-30.2.0.tgz",
       "integrity": "sha512-F26gjC0yWN8uAA5m5Ss8ZQf5nDHWGlN/xWZIh8S5SRbsEKBovwZhxGd6LJlbZYxBgCYOtreSUyb8hpXyGC5O4A==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@jest/core": "30.2.0",
         "@jest/types": "30.2.0",
@@ -18323,19 +18263,19 @@
       }
     },
     "node_modules/lru-cache": {
-      "version": "11.2.2",
-      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.2.2.tgz",
-      "integrity": "sha512-F9ODfyqML2coTIsQpSkRHnLSZMtkU8Q+mSfcaIyKwy58u+8k5nvAYeiNhsyMARvzNcXJ9QfWVrcPsC9e9rAxtg==",
+      "version": "11.2.4",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.2.4.tgz",
+      "integrity": "sha512-B5Y16Jr9LB9dHVkh6ZevG+vAbOsNOYCX+sXvFWFu7B3Iz5mijW3zdbMyhsh8ANd2mSWBYdJgnqi+mL7/LrOPYg==",
       "dev": true,
-      "license": "ISC",
+      "license": "BlueOak-1.0.0",
       "engines": {
         "node": "20 || >=22"
       }
     },
     "node_modules/luxon": {
-      "version": "3.7.1",
-      "resolved": "https://registry.npmjs.org/luxon/-/luxon-3.7.1.tgz",
-      "integrity": "sha512-RkRWjA926cTvz5rAb1BqyWkKbbjzCGchDUIKMCUvNi17j6f6j8uHGDV82Aqcqtzd+icoYpELmG3ksgGiFNNcNg==",
+      "version": "3.7.2",
+      "resolved": "https://registry.npmjs.org/luxon/-/luxon-3.7.2.tgz",
+      "integrity": "sha512-vtEhXh/gNjI9Yg1u4jX/0YVPMvxzHuGgCm6tC5kZyb08yjGWGnqAjGJvcXbqQR2P3MyMEFnRbpcdFS6PBcLqew==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -18348,6 +18288,7 @@
       "integrity": "sha512-h5bgJWpxJNswbU7qCrV0tIKQCaS3blPDrqKWx+QxzuzL1zGUzij9XCWLrSLsJPu5t+eWA/ycetzYAO5IOMcWAQ==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "bin": {
         "lz-string": "bin/bin.js"
       }
@@ -18643,18 +18584,18 @@
       "license": "MIT"
     },
     "node_modules/normalize-package-data": {
-      "version": "6.0.2",
-      "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-6.0.2.tgz",
-      "integrity": "sha512-V6gygoYb/5EmNI+MEGrWkC+e6+Rr7mTmfHrxDbLzxQogBkgzo76rkok0Am6thgSF7Mv2nLOajAJj5vDJZEFn7g==",
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-8.0.0.tgz",
+      "integrity": "sha512-RWk+PI433eESQ7ounYxIp67CYuVsS1uYSonX3kA6ps/3LWfjVQa/ptEg6Y3T6uAMq1mWpX9PQ+qx+QaHpsc7gQ==",
       "dev": true,
       "license": "BSD-2-Clause",
       "dependencies": {
-        "hosted-git-info": "^7.0.0",
+        "hosted-git-info": "^9.0.0",
         "semver": "^7.3.5",
         "validate-npm-package-license": "^3.0.4"
       },
       "engines": {
-        "node": "^16.14.0 || >=18.0.0"
+        "node": "^20.17.0 || >=22.9.0"
       }
     },
     "node_modules/normalize-path": {
@@ -19025,18 +18966,18 @@
       }
     },
     "node_modules/puppeteer": {
-      "version": "24.30.0",
-      "resolved": "https://registry.npmjs.org/puppeteer/-/puppeteer-24.30.0.tgz",
-      "integrity": "sha512-A5OtCi9WpiXBQgJ2vQiZHSyrAzQmO/WDsvghqlN4kgw21PhxA5knHUaUQq/N3EMt8CcvSS0RM+kmYLJmedR3TQ==",
+      "version": "24.32.0",
+      "resolved": "https://registry.npmjs.org/puppeteer/-/puppeteer-24.32.0.tgz",
+      "integrity": "sha512-exyxHPV5DSsigIhM/pzLcyzl5XU4Dp5lNP+APwIeStDxAdYqpMnJ1qN0QHXghjJx+cQJczby+ySH5rgv/5GQLw==",
       "dev": true,
       "hasInstallScript": true,
       "license": "Apache-2.0",
       "dependencies": {
-        "@puppeteer/browsers": "2.10.13",
+        "@puppeteer/browsers": "2.11.0",
         "chromium-bidi": "11.0.0",
         "cosmiconfig": "^9.0.0",
-        "devtools-protocol": "0.0.1521046",
-        "puppeteer-core": "24.30.0",
+        "devtools-protocol": "0.0.1534754",
+        "puppeteer-core": "24.32.0",
         "typed-query-selector": "^2.12.0"
       },
       "bin": {
@@ -19047,18 +18988,18 @@
       }
     },
     "node_modules/puppeteer-core": {
-      "version": "24.30.0",
-      "resolved": "https://registry.npmjs.org/puppeteer-core/-/puppeteer-core-24.30.0.tgz",
-      "integrity": "sha512-2S3Smy0t0W4wJnNvDe7W0bE7wDmZjfZ3ljfMgJd6hn2Hq/f0jgN+x9PULZo2U3fu5UUIJ+JP8cNUGllu8P91Pg==",
+      "version": "24.32.0",
+      "resolved": "https://registry.npmjs.org/puppeteer-core/-/puppeteer-core-24.32.0.tgz",
+      "integrity": "sha512-MqzLLeJjqjtHK9J44+KE3kjtXXhFpPvg+AvXl/oy/jB8MeeNH66/4MNotOTqGZ6MPaxWi51YJ1ASga6OIff6xw==",
       "dev": true,
       "license": "Apache-2.0",
       "dependencies": {
-        "@puppeteer/browsers": "2.10.13",
+        "@puppeteer/browsers": "2.11.0",
         "chromium-bidi": "11.0.0",
         "debug": "^4.4.3",
-        "devtools-protocol": "0.0.1521046",
+        "devtools-protocol": "0.0.1534754",
         "typed-query-selector": "^2.12.0",
-        "webdriver-bidi-protocol": "0.3.8",
+        "webdriver-bidi-protocol": "0.3.9",
         "ws": "^8.18.3"
       },
       "engines": {
@@ -19103,7 +19044,6 @@
       "resolved": "https://registry.npmjs.org/react/-/react-18.3.1.tgz",
       "integrity": "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "loose-envify": "^1.1.0"
       },
@@ -19116,7 +19056,6 @@
       "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-18.3.1.tgz",
       "integrity": "sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "loose-envify": "^1.1.0",
         "scheduler": "^0.23.2"
@@ -19132,38 +19071,54 @@
       "license": "MIT"
     },
     "node_modules/read-package-up": {
-      "version": "11.0.0",
-      "resolved": "https://registry.npmjs.org/read-package-up/-/read-package-up-11.0.0.tgz",
-      "integrity": "sha512-MbgfoNPANMdb4oRBNg5eqLbB2t2r+o5Ua1pNt8BqGp4I0FJZhuVSOj3PaBPni4azWuSzEdNn2evevzVmEk1ohQ==",
+      "version": "12.0.0",
+      "resolved": "https://registry.npmjs.org/read-package-up/-/read-package-up-12.0.0.tgz",
+      "integrity": "sha512-Q5hMVBYur/eQNWDdbF4/Wqqr9Bjvtrw2kjGxxBbKLbx8bVCL8gcArjTy8zDUuLGQicftpMuU0riQNcAsbtOVsw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "find-up-simple": "^1.0.0",
-        "read-pkg": "^9.0.0",
-        "type-fest": "^4.6.0"
+        "find-up-simple": "^1.0.1",
+        "read-pkg": "^10.0.0",
+        "type-fest": "^5.2.0"
       },
       "engines": {
-        "node": ">=18"
+        "node": ">=20"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/read-package-up/node_modules/type-fest": {
+      "version": "5.3.1",
+      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-5.3.1.tgz",
+      "integrity": "sha512-VCn+LMHbd4t6sF3wfU/+HKT63C9OoyrSIf4b+vtWHpt2U7/4InZG467YDNMFMR70DdHjAdpPWmw2lzRdg0Xqqg==",
+      "dev": true,
+      "license": "(MIT OR CC0-1.0)",
+      "dependencies": {
+        "tagged-tag": "^1.0.0"
+      },
+      "engines": {
+        "node": ">=20"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
     "node_modules/read-pkg": {
-      "version": "9.0.1",
-      "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-9.0.1.tgz",
-      "integrity": "sha512-9viLL4/n1BJUCT1NXVTdS1jtm80yDEgR5T4yCelII49Mbj0v1rZdKqj7zCiYdbB0CuCgdrvHcNogAKTFPBocFA==",
+      "version": "10.0.0",
+      "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-10.0.0.tgz",
+      "integrity": "sha512-A70UlgfNdKI5NSvTTfHzLQj7NJRpJ4mT5tGafkllJ4wh71oYuGm/pzphHcmW4s35iox56KSK721AihodoXSc/A==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@types/normalize-package-data": "^2.4.3",
-        "normalize-package-data": "^6.0.0",
-        "parse-json": "^8.0.0",
-        "type-fest": "^4.6.0",
-        "unicorn-magic": "^0.1.0"
+        "@types/normalize-package-data": "^2.4.4",
+        "normalize-package-data": "^8.0.0",
+        "parse-json": "^8.3.0",
+        "type-fest": "^5.2.0",
+        "unicorn-magic": "^0.3.0"
       },
       "engines": {
-        "node": ">=18"
+        "node": ">=20"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
@@ -19187,6 +19142,35 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/read-pkg/node_modules/parse-json/node_modules/type-fest": {
+      "version": "4.41.0",
+      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-4.41.0.tgz",
+      "integrity": "sha512-TeTSQ6H5YHvpqVwBRcnLDCBnDOHWYu7IvGbHT6N8AOymcr9PJGjc1GTtiWZTYg0NCgYwvnYWEkVChQAr9bjfwA==",
+      "dev": true,
+      "license": "(MIT OR CC0-1.0)",
+      "engines": {
+        "node": ">=16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/read-pkg/node_modules/type-fest": {
+      "version": "5.3.1",
+      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-5.3.1.tgz",
+      "integrity": "sha512-VCn+LMHbd4t6sF3wfU/+HKT63C9OoyrSIf4b+vtWHpt2U7/4InZG467YDNMFMR70DdHjAdpPWmw2lzRdg0Xqqg==",
+      "dev": true,
+      "license": "(MIT OR CC0-1.0)",
+      "dependencies": {
+        "tagged-tag": "^1.0.0"
+      },
+      "engines": {
+        "node": ">=20"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/readable-stream": {
       "version": "3.6.2",
       "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz",
@@ -19338,9 +19322,9 @@
       "license": "MIT"
     },
     "node_modules/semver": {
-      "version": "7.7.2",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.2.tgz",
-      "integrity": "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==",
+      "version": "7.7.3",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.3.tgz",
+      "integrity": "sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==",
       "license": "ISC",
       "bin": {
         "semver": "bin/semver.js"
@@ -19843,6 +19827,19 @@
         "url": "https://opencollective.com/synckit"
       }
     },
+    "node_modules/tagged-tag": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/tagged-tag/-/tagged-tag-1.0.0.tgz",
+      "integrity": "sha512-yEFYrVhod+hdNyx7g5Bnkkb0G6si8HJurOoOEgC8B/O0uXLHlaey/65KRv6cuWBNhBgHKAROVpc7QyYqE5gFng==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=20"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/tar-fs": {
       "version": "3.1.1",
       "resolved": "https://registry.npmjs.org/tar-fs/-/tar-fs-3.1.1.tgz",
@@ -20097,26 +20094,12 @@
         }
       }
     },
-    "node_modules/ts-jest/node_modules/semver": {
-      "version": "7.7.3",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.3.tgz",
-      "integrity": "sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==",
-      "dev": true,
-      "license": "ISC",
-      "bin": {
-        "semver": "bin/semver.js"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
     "node_modules/ts-node": {
       "version": "10.9.2",
       "resolved": "https://registry.npmjs.org/ts-node/-/ts-node-10.9.2.tgz",
       "integrity": "sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ==",
       "devOptional": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@cspotcode/source-map-support": "^0.8.0",
         "@tsconfig/node10": "^1.0.7",
@@ -20214,7 +20197,6 @@
       "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.9.5.tgz",
       "integrity": "sha512-1FXk9E2Hm+QzZQ7z+McJiHL4NW1F2EzMu9Nq9i3zAaGqibafqYwCVU6WyWAuyQRRzOlxou8xZSyXLEN8oKj24g==",
       "license": "Apache-2.0",
-      "peer": true,
       "bin": {
         "tsc": "bin/tsc",
         "tsserver": "bin/tsserver"
@@ -20244,9 +20226,9 @@
       "license": "MIT"
     },
     "node_modules/unicorn-magic": {
-      "version": "0.1.0",
-      "resolved": "https://registry.npmjs.org/unicorn-magic/-/unicorn-magic-0.1.0.tgz",
-      "integrity": "sha512-lRfVq8fE8gz6QMBuDM6a+LO3IAzTi05H6gCVaUpir2E1Rwpo4ZUog45KpNXKC/Mn3Yb9UDuHumeFTo9iV/D9FQ==",
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/unicorn-magic/-/unicorn-magic-0.3.0.tgz",
+      "integrity": "sha512-+QBBXBCvifc56fsbuxZQ6Sic3wqqc3WWaqxs58gvJrcOuN83HGTCwz3oS5phzU9LthRNE9VrJCFCLUgHeeFnfA==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -20412,9 +20394,9 @@
       }
     },
     "node_modules/webdriver-bidi-protocol": {
-      "version": "0.3.8",
-      "resolved": "https://registry.npmjs.org/webdriver-bidi-protocol/-/webdriver-bidi-protocol-0.3.8.tgz",
-      "integrity": "sha512-21Yi2GhGntMc671vNBCjiAeEVknXjVRoyu+k+9xOMShu+ZQfpGQwnBqbNz/Sv4GXZ6JmutlPAi2nIJcrymAWuQ==",
+      "version": "0.3.9",
+      "resolved": "https://registry.npmjs.org/webdriver-bidi-protocol/-/webdriver-bidi-protocol-0.3.9.tgz",
+      "integrity": "sha512-uIYvlRQ0PwtZR1EzHlTMol1G0lAlmOe6wPykF9a77AK3bkpvZHzIVxRE2ThOx5vjy2zISe0zhwf5rzuUfbo1PQ==",
       "dev": true,
       "license": "Apache-2.0"
     },
@@ -20627,9 +20609,9 @@
       }
     },
     "node_modules/yup": {
-      "version": "1.7.0",
-      "resolved": "https://registry.npmjs.org/yup/-/yup-1.7.0.tgz",
-      "integrity": "sha512-VJce62dBd+JQvoc+fCVq+KZfPHr+hXaxCcVgotfwWvlR0Ja3ffYKaJBT8rptPOSKOGJDCUnW2C2JWpud7aRP6Q==",
+      "version": "1.7.1",
+      "resolved": "https://registry.npmjs.org/yup/-/yup-1.7.1.tgz",
+      "integrity": "sha512-GKHFX2nXul2/4Dtfxhozv701jLQHdf6J34YDh2cEkpqoo8le5Mg6/LrdseVLrFarmFygZTlfIhHx/QKfb/QWXw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -21405,7 +21387,6 @@
       "version": "5.9.3",
       "dev": true,
       "license": "Apache-2.0",
-      "peer": true,
       "bin": {
         "tsc": "bin/tsc",
         "tsserver": "bin/tsserver"
diff --git a/package.json b/package.json
index 598c2a90..369b1ec3 100644
--- a/package.json
+++ b/package.json
@@ -16,7 +16,8 @@
     "lint": "npm run lint --prefix client"
   },
   "devDependencies": {
-    "concurrently": "^8.2.2"
+    "concurrently": "^8.2.2",
+    "jest-cucumber": "^4.5.0"
   },
   "keywords": [
     "react",
@@ -32,4 +33,4 @@
     "client",
     "server"
   ]
-}
\ No newline at end of file
+}

From c5b915708e8b2de56d285fcd072e6a136301cd68 Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Sun, 7 Dec 2025 21:38:10 -0300
Subject: [PATCH 031/102] testing: scenarios defined for scriptAnswer
 functionality

---
 .../server-scriptAnswer-management.feature    | 150 ++++++++++++++++++
 1 file changed, 150 insertions(+)
 create mode 100644 client/src/features/server-scriptAnswer-management.feature

diff --git a/client/src/features/server-scriptAnswer-management.feature b/client/src/features/server-scriptAnswer-management.feature
new file mode 100644
index 00000000..47a24c9d
--- /dev/null
+++ b/client/src/features/server-scriptAnswer-management.feature
@@ -0,0 +1,150 @@
+@server
+Feature: Server Script Answers Management
+  As a system
+  I want to manage script answers through the API
+  So that student submissions are properly retrieved and updated
+
+  Background:
+    Given the server API is available
+
+  # ============================================================
+  # Retrieval of all script answers
+  # ============================================================
+
+  Scenario: Retrieve all registered script answers
+    Given there are script answers registered with IDs "123", "321", "890"
+    When I send a GET request to "/api/scripts/answers"
+    Then the server should return 200 OK
+    And the server should return a list containing answers "123", "321", "890"
+
+  Scenario: Retrieve script answers when none exist
+    Given there are no script answers registered
+    When I send a GET request to "/api/scripts/answers"
+    Then the server should return 200 OK
+    And the server should return an empty list
+
+  # ============================================================
+  # Retrieval by student (CPF-based)
+  # ============================================================
+
+  Scenario: Retrieve answers of a registered student
+    Given there is a student with CPF "12345678901"
+    And this student has script answers with IDs "40", "41"
+    When I send a GET request to "/api/scripts/answers/student/12345678901"
+    Then the server should return 200 OK
+    And the server should return a list containing answers "40", "41"
+
+  Scenario: Attempt to retrieve answers of a non-existent student
+    Given there is no student with CPF "99999999999"
+    When I send a GET request to "/api/scripts/answers/student/99999999999"
+    Then the server should return 404 Not Found
+    And the server should return an error message stating the student was not found
+
+  # ============================================================
+  # Retrieval of grade for specific task
+  # ============================================================
+
+  Scenario: Retrieve grade of an existing task in an answer
+    Given there is a script answer with ID "50"
+    And this answer contains a task with ID "2" and grade "MA"
+    When I send a GET request to "/api/scripts/answers/50/tasks/2"
+    Then the server should return 200 OK
+    And the server should return grade "MA"
+
+  Scenario: Attempt to retrieve grade for a missing task
+    Given there is a script answer with ID "50"
+    And this answer does not contain a task with ID "9"
+    When I send a GET request to "/api/scripts/answers/50/tasks/9"
+    Then the server should return 404 Not Found
+    And the server should return an error message stating the task was not found
+
+  # ============================================================
+  # Updating grades
+  # ============================================================
+
+  Scenario: Update grade of an existing task with a valid value
+    Given there is a script answer with ID "50"
+    And this answer contains a task with ID "3" and grade "MANA"
+    When I send a PUT request to "/api/scripts/answers/50/tasks/3" with:
+      | field | value |
+      | grade | MPA   |
+    Then the server should return 200 OK
+    And the server should update the task grade to "MPA"
+    And the server should return the updated grade
+
+  Scenario: Attempt to update grade with an invalid value
+    Given there is a script answer with ID "50"
+    And this answer contains a task with ID "3"
+    When I send a PUT request to "/api/scripts/answers/50/tasks/3" with:
+      | field | value |
+      | grade | AAA   |
+    Then the server should return 400 Bad Request
+    And the server should return an error message stating the grade is invalid
+
+  # ============================================================
+  # Retrieval by ID
+  # ============================================================
+
+  Scenario: Retrieve a script answer by ID
+    Given there is a script answer registered with ID "123"
+    When I send a GET request to "/api/scripts/answers/123"
+    Then the server should return 200 OK
+    And the server should return the script answer with ID "123"
+
+  Scenario: Attempt to retrieve a non-existent script answer
+    Given there is no script answer registered with ID "777"
+    When I send a GET request to "/api/scripts/answers/777"
+    Then the server should return 404 Not Found
+    And the server should return an error message stating the script answer was not found
+
+  # ============================================================
+  # Updating script-level comments
+  # ============================================================
+
+  Scenario: Successfully add a comment to a script answer
+    Given there is a script answer with ID "50"
+    When I send a PUT request to "/api/scripts/answers/50/comments" with:
+      | field   | value               |
+      | comment | Reveja a explicação |
+    Then the server should return 200 OK
+    And the server should store the comment in the script answer with ID "50"
+    And the server should return the updated comment
+
+  Scenario: Attempt to add a comment to a non-existent script answer
+    Given there is no script answer with ID "777"
+    When I send a PUT request to "/api/scripts/answers/777/comments" with:
+      | field   | value        |
+      | comment | Bom trabalho |
+    Then the server should return 404 Not Found
+    And the server should return an error message stating the script answer was not found
+
+  # ============================================================
+  # Updating task-level comments
+  # ============================================================
+
+  Scenario: Successfully add a comment to a task inside a script answer
+    Given there is a script answer with ID "50"
+    And this answer contains a task with ID "3"
+    When I send a PUT request to "/api/scripts/answers/50/tasks/3/comments" with:
+      | field   | value                                   |
+      | comment | Correto, mas poderia detalhar melhor    |
+    Then the server should return 200 OK
+    And the server should store the comment in task "3"
+    And the server should return the updated comment
+
+  Scenario: Attempt to add a comment to a non-existent task inside a script answer
+    Given there is a script answer with ID "50"
+    And this answer does not contain a task with ID "999"
+    When I send a PUT request to "/api/scripts/answers/50/tasks/999/comments" with:
+      | field   | value     |
+      | comment | Verifique |
+    Then the server should return 404 Not Found
+    And the server should return an error message stating the task was not found
+
+  Scenario: Attempt to add a comment to a task inside a non-existent script answer
+    Given there is no script answer with ID "888"
+    When I send a PUT request to "/api/scripts/answers/888/tasks/3/comments" with:
+      | field   | value                    |
+      | comment | Precisa revisar este ponto |
+    Then the server should return 404 Not Found
+    And the server should return an error message stating the script answer was not found

From e45a8b56bcef19d4bb57aaf16c1d39d48569106c Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Sun, 7 Dec 2025 21:39:18 -0300
Subject: [PATCH 032/102] testing/NOT FUNCTIONAL: step layout for corrigir
 roteiro feature

---
 .../server-scriptAnswer-steps.ts              | 268 ++++++++++++++++++
 1 file changed, 268 insertions(+)
 create mode 100644 client/src/step-definitions/server-scriptAnswer-steps.ts

diff --git a/client/src/step-definitions/server-scriptAnswer-steps.ts b/client/src/step-definitions/server-scriptAnswer-steps.ts
new file mode 100644
index 00000000..a2c3af79
--- /dev/null
+++ b/client/src/step-definitions/server-scriptAnswer-steps.ts
@@ -0,0 +1,268 @@
+import { Given, When, Then, Before, After, DataTable, setDefaultTimeout } from '@cucumber/cucumber';
+import { Browser, Page, launch } from 'puppeteer';
+import expect from 'expect';
+
+// Set default timeout for all steps
+setDefaultTimeout(30 * 1000); // 30 seconds
+
+// Helper function to format CPF like the frontend does
+function formatCPF(value: string): string {
+  const digits = value.replace(/\D/g, '');
+  if (digits.length <= 11) {
+    return digits.replace(/(\d{3})(\d{3})(\d{3})(\d{2})/, '$1.$2.$3-$4');
+  }
+  return digits.slice(0, 11).replace(/(\d{3})(\d{3})(\d{3})(\d{2})/, '$1.$2.$3-$4');
+}
+
+let browser: Browser;
+let page: Page;
+const baseUrl = 'http://localhost:3004';
+const serverUrl = 'http://localhost:3005';
+
+// Test data to clean up
+let testStudentCPF: string;
+
+Before({ tags: '@gui' }, async function () {
+  browser = await launch({ 
+    headless: false, // Set to true for CI/CD
+    slowMo: 50 // Slow down actions for visibility
+  });
+  page = await browser.newPage();
+  await page.setViewport({ width: 1280, height: 720 });
+});
+
+After({ tags: '@gui' }, async function () {
+  // Clean up test student if it exists by using the GUI delete function
+  if (testStudentCPF) {
+    try {
+      // Navigate to Students area
+      await page.goto(baseUrl);
+      await page.waitForSelector('.students-list table', { timeout: 5000 });
+      
+      // Look for our test student in the table and delete it if found
+      const studentRows = await page.$$('[data-testid^="student-row-"]');
+      for (const row of studentRows) {
+        const cpfCell = await row.$('[data-testid="student-cpf"]');
+        if (cpfCell) {
+          const cpf = await page.evaluate(el => el.textContent, cpfCell);
+          // Check for both plain and formatted CPF
+          if (cpf === testStudentCPF || cpf === formatCPF(testStudentCPF)) {
+            // Set up dialog handler before clicking delete
+            page.once('dialog', async (dialog) => {
+              console.log(`GUI cleanup: Confirming deletion dialog: ${dialog.message()}`);
+              await dialog.accept(); // Confirm deletion
+            });
+            
+            // Click the delete button for this student
+            const deleteButton = await row.$(`[data-testid="delete-student-${cpf}"]`);
+            if (deleteButton) {
+              await deleteButton.click();
+              // Wait for deletion to complete
+              await new Promise(resolve => setTimeout(resolve, 1000));
+              console.log(`GUI cleanup: Removed test student with CPF: ${cpf}`);
+              break;
+            }
+          }
+        }
+      }
+    } catch (error) {
+      console.log('GUI cleanup: Student may not exist or GUI unavailable');
+    }
+  }
+  
+  if (browser) {
+    await browser.close();
+  }
+});
+
+Given('the student management system is running', async function () {
+  await page.goto(baseUrl);
+  await page.waitForSelector('h1', { timeout: 10000 });
+  const title = await page.$eval('h1', el => el.textContent);
+  expect(title || '').toContain('Teaching Assistant React');
+});
+
+Given('the server is available', async function () {
+  try {
+    const response = await fetch(`${serverUrl}/api/students`);
+    expect(response.status).toBe(200);
+  } catch (error) {
+    throw new Error('Server is not available. Make sure the backend server is running on port 3005');
+  }
+});
+
+Given('there is no student with CPF {string} in the system', async function (cpf: string) {
+  testStudentCPF = cpf;
+  const formattedCPF = formatCPF(cpf);
+  
+  // Navigate to the application and check if student exists through GUI
+  await page.goto(baseUrl);
+  await page.waitForSelector('.students-list', { timeout: 10000 });
+  
+  // Try to find and delete the student if it exists (cleanup before test)
+  const studentRows = await page.$$('[data-testid^="student-row-"]');
+  for (const row of studentRows) {
+    const cpfCell = await row.$('[data-testid="student-cpf"]');
+    if (cpfCell) {
+      const displayedCPF = await page.evaluate(el => el.textContent, cpfCell);
+      // Check for both plain and formatted CPF
+      if (displayedCPF === cpf || displayedCPF === formattedCPF) {
+        // Student exists, delete it for clean test state
+        // Set up dialog handler before clicking delete
+        page.once('dialog', async (dialog) => {
+          console.log(`GUI cleanup: Confirming deletion dialog: ${dialog.message()}`);
+          await dialog.accept(); // Confirm deletion
+        });
+        
+        const deleteButton = await row.$(`[data-testid="delete-student-${displayedCPF}"]`);
+        if (deleteButton) {
+          await deleteButton.click();
+          // Wait for deletion to complete
+          await new Promise(resolve => setTimeout(resolve, 1000));
+          console.log(`GUI cleanup: Removed existing student with CPF: ${displayedCPF}`);
+          break;
+        }
+      }
+    }
+  }
+  
+  // Verify student doesn't exist by checking the GUI
+  await page.reload(); // Refresh to ensure clean state
+  await page.waitForSelector('.students-list', { timeout: 5000 });
+  
+  const updatedRows = await page.$$('[data-testid^="student-row-"]');
+  for (const row of updatedRows) {
+    const cpfCell = await row.$('[data-testid="student-cpf"]');
+    if (cpfCell) {
+      const displayedCPF = await page.evaluate(el => el.textContent, cpfCell);
+      if (displayedCPF === cpf || displayedCPF === formattedCPF) {
+        throw new Error(`Student with CPF ${displayedCPF} still exists in the system after cleanup`);
+      }
+    }
+  }
+});
+
+When('I navigate to the Students area', async function () {
+  // Click on the Students tab
+  const studentsTab = await page.$('[data-testid="students-tab"]');
+  if (studentsTab) {
+    const isActive = await page.evaluate(el => el?.classList.contains('active'), studentsTab);
+    
+    if (!isActive) {
+      await studentsTab.click();
+    }
+  }
+  
+  // Wait for the student form to be visible
+  await page.waitForSelector('[data-testid="student-form"]', { timeout: 5000 });
+});
+
+When('I provide the student information:', async function (dataTable: DataTable) {
+  const data = dataTable.rowsHash();
+  
+  // Fill in the name field using semantic ID
+  await page.waitForSelector('#name');
+  await page.click('#name');
+  await page.type('#name', data.name);
+  
+  // Fill in the CPF field using semantic ID
+  await page.click('#cpf');
+  await page.type('#cpf', data.cpf);
+  
+  // Fill in the email field using semantic ID
+  await page.click('#email');
+  await page.type('#email', data.email);
+});
+
+When('I send the student information', async function () {
+  // Click the submit button using semantic test ID
+  const submitButton = await page.$('[data-testid="submit-student-button"]');
+  expect(submitButton).toBeTruthy();
+  
+  await submitButton?.click();
+  
+  // Wait for the information to be processed and student to appear
+  await new Promise(resolve => setTimeout(resolve, 2000));
+});
+
+Then('I should see {string} in the student list', async function (studentName: string) {
+  // Wait for the student list to update
+  await page.waitForSelector('.students-list table', { timeout: 10000 });
+  
+  // Find the student row that matches our test student's CPF and verify the name
+  const studentRows = await page.$$('[data-testid^="student-row-"]');
+  let foundStudent = null;
+  
+  for (const row of studentRows) {
+    const cpfCell = await row.$('[data-testid="student-cpf"]');
+    if (cpfCell) {
+      const cpf = await page.evaluate(el => el.textContent, cpfCell);
+      if (cpf === formatCPF(testStudentCPF) || cpf === testStudentCPF) {
+        foundStudent = row;
+        break;
+      }
+    }
+  }
+  
+  expect(foundStudent).toBeTruthy();
+  
+  // Verify the name matches exactly for this specific student
+  const nameCell = await foundStudent!.$('[data-testid="student-name"]');
+  const actualName = await page.evaluate(el => el.textContent, nameCell!);
+  expect(actualName).toBe(studentName);
+});
+
+Then('the student should have CPF {string}', async function (expectedCPF: string) {
+  // Wait for the student list to update
+  await page.waitForSelector('.students-list table', { timeout: 10000 });
+  
+  // Find all student information from the current test student
+  const studentRows = await page.$$('[data-testid^="student-row-"]');
+  let foundStudent = null;
+  
+  // First, find the student row that matches our test CPF
+  for (const row of studentRows) {
+    const cpfCell = await row.$('[data-testid="student-cpf"]');
+    if (cpfCell) {
+      const cpf = await page.evaluate(el => el.textContent, cpfCell);
+      if (cpf === expectedCPF || cpf === testStudentCPF || cpf === formatCPF(testStudentCPF)) {
+        foundStudent = row;
+        break;
+      }
+    }
+  }
+  
+  expect(foundStudent).toBeTruthy();
+  
+  // Verify the CPF matches exactly
+  const cpfCell = await foundStudent!.$('[data-testid="student-cpf"]');
+  const actualCPF = await page.evaluate(el => el.textContent, cpfCell!);
+  expect(actualCPF).toBe(expectedCPF);
+});
+
+Then('the student should have email {string}', async function (expectedEmail: string) {
+  // Wait for the student list to update
+  await page.waitForSelector('.students-list table', { timeout: 10000 });
+  
+  // Find the student row that matches our test student's CPF
+  const studentRows = await page.$$('[data-testid^="student-row-"]');
+  let foundStudent = null;
+  
+  for (const row of studentRows) {
+    const cpfCell = await row.$('[data-testid="student-cpf"]');
+    if (cpfCell) {
+      const cpf = await page.evaluate(el => el.textContent, cpfCell);
+      if (cpf === formatCPF(testStudentCPF) || cpf === testStudentCPF) {
+        foundStudent = row;
+        break;
+      }
+    }
+  }
+  
+  expect(foundStudent).toBeTruthy();
+  
+  // Verify the email matches exactly for this specific student
+  const emailCell = await foundStudent!.$('[data-testid="student-email"]');
+  const actualEmail = await page.evaluate(el => el.textContent, emailCell!);
+  expect(actualEmail).toBe(expectedEmail);
+});
\ No newline at end of file

From 58fdbeb64224d6a9595468f07b970299b343c441 Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Mon, 8 Dec 2025 15:52:49 -0300
Subject: [PATCH 033/102] fix: scriptanswer now references studentid and has
 scriptid field

---
 server/src/models/ScriptAnswer.ts | 73 ++++++++++++++++---------------
 1 file changed, 38 insertions(+), 35 deletions(-)

diff --git a/server/src/models/ScriptAnswer.ts b/server/src/models/ScriptAnswer.ts
index 555720a7..cd171842 100644
--- a/server/src/models/ScriptAnswer.ts
+++ b/server/src/models/ScriptAnswer.ts
@@ -4,12 +4,14 @@ import { Student } from "./Student";
 
 export class ScriptAnswer {
   private id: string;
-  private student: Student; 
+  private scriptId: string;
+  private student: string; 
   public answers: TaskAnswer[] = [];
   public grade?: Grade
 
-  constructor(id: string, student: Student, answers?: TaskAnswer[], grade?: Grade) {
+  constructor(id: string, scriptId: string, student: string, answers?: TaskAnswer[], grade?: Grade) {
     this.id = id;
+    this.scriptId = scriptId;
     this.student = student;
     this.answers = answers || [];
     this.grade = grade;
@@ -18,28 +20,38 @@ export class ScriptAnswer {
     }
   }
 
-
-getId(): string {
+  getId(): string {
     return this.id;
-}
+  }
 
-toJSON() {
-  return {
-    id: this.id,
-    student: this.student.toJSON(),
-    answers: this.answers.map(answer => {
-      if (answer && typeof answer.toJSON === "function") {
-        return answer.toJSON();
-      }
-      console.warn("Invalid answer detected:", answer);
-      return null;
-    }).filter(Boolean),
-    grade: this.grade ? this.grade : undefined
-  };
-}
+  getstudentId(): string {
+    return this.student;
+  }
 
+  getScriptId(): string {
+    return this.scriptId;
+  }
 
+  toJSON() {
+    return {
+      id: this.id,
+      scriptId: this.scriptId,
+      student: this.student,
+      answers: this.answers.map(answer => {
+        if (answer && typeof answer.toJSON === "function") {
+          return answer.toJSON();
+        }
+        console.warn("Invalid answer detected:", answer);
+        return null;
+      }).filter(Boolean),
+      grade: this.grade ? this.grade : undefined
+    };
+  }
 
+  static fromJSON(obj: any): ScriptAnswer {
+    const answers = obj.answers ? obj.answers.map((ansObj: any) => TaskAnswer.fromJSON(ansObj)) : [];
+    return new ScriptAnswer(obj.id, obj.scriptId, obj.student, answers, obj.grade);
+  }
 
   // answer management
 
@@ -50,8 +62,7 @@ toJSON() {
   }
 
   addAnswer(answer: TaskAnswer): TaskAnswer {
-    // Check if task already in script
-    const existingAnswer = this.findAnswerByTaskId(answer.task.getId());
+    const existingAnswer = this.findAnswerByTaskId(answer.task);
     if (existingAnswer) {
       throw new Error('Answer for task already in script');
     }
@@ -60,8 +71,7 @@ toJSON() {
     return answer;
   }
 
-  
- removeAnswer(taskId: string): boolean {
+  removeAnswer(taskId: string): boolean {
     const index = this.answers.findIndex(answer => 
       answer.getTaskId() === taskId
     );
@@ -74,9 +84,7 @@ toJSON() {
     return true;
   }
 
-
-  
-// grade Management
+  // grade Management
 
   updateGrade(grade: Grade | undefined) {
     if(grade && grade != "MA" && grade != "MPA" && grade != "MANA") {
@@ -85,23 +93,18 @@ toJSON() {
     this.grade = grade;
   }
 
- private getNumberOfAnswersWithGrade(grade : Grade): number { 
+  private getNumberOfAnswersWithGrade(grade : Grade): number { 
     if (grade !== 'MANA' && grade !== 'MPA' && grade !== 'MA') {
       throw new Error('Invalid grade');
     }
     return this.answers.filter(answer => answer.getGrade() === grade).length;
- }
-
-
+  }
 
- getGradeDistribution(): Record<Grade, number> {
+  getGradeDistribution(): Record<Grade, number> {
     return {
       'MANA': this.getNumberOfAnswersWithGrade('MANA'),
       'MPA': this.getNumberOfAnswersWithGrade('MPA'),
       'MA': this.getNumberOfAnswersWithGrade('MA'),
     };
- }
-
-
-
+  }
 }
\ No newline at end of file

From 329702820a7f07befe93aa33a5c70fb4c476f5dd Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Mon, 8 Dec 2025 15:53:25 -0300
Subject: [PATCH 034/102] fix: scriptanswerset now has stricter type definition
 (any[] -> ScriptAnswer[])

---
 server/src/models/ScriptAnswerSet.ts | 28 +++++++++++++++++-----------
 1 file changed, 17 insertions(+), 11 deletions(-)

diff --git a/server/src/models/ScriptAnswerSet.ts b/server/src/models/ScriptAnswerSet.ts
index 9e9682cc..9728cb1f 100644
--- a/server/src/models/ScriptAnswerSet.ts
+++ b/server/src/models/ScriptAnswerSet.ts
@@ -1,22 +1,24 @@
 import { v4 as uuid } from 'uuid';
+import  { ScriptAnswer } from './ScriptAnswer';
+import { Grade } from './Evaluation';
 
 export class ScriptAnswerSet {
-  private scriptAnswers: any[] = [];
+  private scriptAnswers: ScriptAnswer[] = [];
 
   addScriptAnswer(data: any) {
-    const newAnswer = {
+    const newAnswer = ScriptAnswer.fromJSON({
       id: data.id ??  uuid(),
       scriptId: data.scriptId,
-      studentId: data.studentId,
-      taskAnswers: data.taskAnswers ?? [],
+      student: data.studentId,
+      answers: data.taskAnswers ?? [],
       grade: data.grade ?? null
-    };
+    });
     this.scriptAnswers.push(newAnswer);
     return newAnswer;
   }
 
   removeScriptAnswer(id: string) {
-    const index = this.scriptAnswers.findIndex(a => a.id === id);
+    const index = this.scriptAnswers.findIndex(a => a.getId() === id);
     if (index !== -1) {
       this.scriptAnswers.splice(index, 1);
       return true;
@@ -30,14 +32,18 @@ export class ScriptAnswerSet {
   }
 
   findByStudentId(studentId: string) {
-    return this.getAll().filter(a => a.studentId === studentId).slice();
+    return this.getAll().filter(a => a.getstudentId() === studentId).slice();
   }
 
   findById(id: string) {
-    return this.scriptAnswers.find(a => a.id === id) || null;
+    return this.scriptAnswers.find(a => a.getId() === id) || null;
   }
 
-  updateGrade(id: string, grade: string) {
+  findbyScriptId(scriptId: string) {
+    return this.getAll().filter(a => a.getScriptId() === scriptId).slice();
+  }
+
+  updateGrade(id: string, grade: Grade | undefined) {
     const answer = this.findById(id);
     if (!answer) return null;
     answer.grade = grade;
@@ -46,9 +52,9 @@ export class ScriptAnswerSet {
 
   updateTaskAnswer(taskAnswerId: string, update: any) {
     for (const scriptAnswer of this.scriptAnswers) {
-      const ta = scriptAnswer.taskAnswers.find(t => t.id === taskAnswerId);
+      const ta = scriptAnswer.answers.find(t => t.id === taskAnswerId);
       if (ta) {
-        if (update.grade !== undefined) ta.grade = update.grade;
+        if (update.grade !== undefined) ta.updateGrade(update.grade);
         if (update.comments !== undefined) ta.comments = update.comments;
         return ta;
       }

From 3f454a8df4cb64c46b499ab0f41c1e89cc324845 Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Mon, 8 Dec 2025 15:53:56 -0300
Subject: [PATCH 035/102] fix: TaskAnswer now uses task id instead of full
 embedded task object

---
 server/src/models/TaskAnswer.ts | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/server/src/models/TaskAnswer.ts b/server/src/models/TaskAnswer.ts
index 03a5f51c..4c3c47cf 100644
--- a/server/src/models/TaskAnswer.ts
+++ b/server/src/models/TaskAnswer.ts
@@ -3,12 +3,12 @@ import { Grade } from "./Evaluation";
 
 export class TaskAnswer {
   public id: string;
-  public task: Task;
+  public task: string;
   public answer?: string;
   private grade?: Grade;
   public comments?: string;
 
-  constructor(id: string, task: Task, answer?: string, grade?: Grade, comments?: string) {
+  constructor(id: string, task: string, answer?: string, grade?: Grade, comments?: string) {
     this.id = id;
     this.task = task;
     this.answer = answer;
@@ -21,13 +21,13 @@ export class TaskAnswer {
   }
 
   getTaskId(): string {
-    return this.task.getId();
+    return this.task;
   }
 
   toJSON() {
     return {
       id: this.id,
-      task: this.task.toJSON(),
+      task: this.task,
       answer: this.answer,
       grade: this.grade ? this.grade : undefined,
       comments: this.comments
@@ -42,7 +42,7 @@ export class TaskAnswer {
   }
 
   update(data: Partial<{task: any; answer : any; grade: any; comments: any }>) {
-    if (data.task) this.task = Task.fromJSON(data.task);
+    if (data.task) this.task = data.task;
     if (data.answer) this.answer = data.answer;
     if (data.grade !== undefined) this.updateGrade(data.grade);
     if (data.comments !== undefined) this.comments = data.comments;

From 53bab7eb5ea822d43424f4550e40629808e43f2e Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Mon, 8 Dec 2025 15:54:30 -0300
Subject: [PATCH 036/102] refactor: routes for scriptanswer, scripts and tasks
 logic now in separate files

---
 server/src/server.ts                     | 226 ++---------------------
 server/src/server_routes/scriptanswer.ts | 118 ++++++++++++
 server/src/server_routes/scripts.ts      |  40 ++++
 server/src/server_routes/tasks.ts        |  44 +++++
 4 files changed, 214 insertions(+), 214 deletions(-)
 create mode 100644 server/src/server_routes/scriptanswer.ts
 create mode 100644 server/src/server_routes/scripts.ts
 create mode 100644 server/src/server_routes/tasks.ts

diff --git a/server/src/server.ts b/server/src/server.ts
index 68c3d437..069fd32c 100644
--- a/server/src/server.ts
+++ b/server/src/server.ts
@@ -524,8 +524,18 @@ app.get('/api/classes/:classId/report', (req: Request, res: Response) => {
 });
 
 
-// Export the app for testing
-export { app, studentSet, classes, scriptAnswerSet};
+// Export the app for testing and routes files
+export { app, studentSet, classes, scriptAnswerSet, taskset, scripts};
+
+
+// Setup routes (after exports)
+import { setupScriptAnswerRoutes } from './server_routes/scriptanswer';
+import { setupTaskRoutes } from './server_routes/tasks';
+import { setupScriptRoutes } from './server_routes/scripts';
+
+setupScriptAnswerRoutes(app, scriptAnswerSet, studentSet);
+setupTaskRoutes(app, taskset);
+setupScriptRoutes(app, scripts);
 
 // Only start the server if this file is run directly (not imported for testing)
 if (require.main === module) {
@@ -534,220 +544,8 @@ if (require.main === module) {
   });
 }
 
-// --------------------------------------------------------------
-// GET /api/scripts/answers  → Return all OR return by ?id=
-// --------------------------------------------------------------
-// GET /api/scripts/answers  → get ALL answers
-app.get('/api/scripts/answers', (req: Request, res: Response) => {
-  try {
-    const all = scriptAnswerSet.getAll();
-    return res.status(200).json(all);
-  } catch (err) {
-    return res.status(500).json({ error: 'Failed to fetch script answers' });
-  }
-});
-
-// --------------------------------------------------------------
-// GET /api/scripts/answers/student/:studentId → Answers for a student
-// --------------------------------------------------------------
-app.get('/api/scripts/answers/student/:studentId', (req: Request, res: Response) => {
-  const { studentId } = req.params;
-
-  const student = studentSet.findStudentByCPF(studentId);
-  if (!student) {
-    return res.status(404).json({ error: 'Student not found' });
-  }
-
-  const answers = scriptAnswerSet.findByStudentId(studentId);
-  return res.status(200).json(answers);
-});
-
-// GET /api/scripts/answers/:id  → get ONE answer by ID
-app.get('/api/scripts/answers/:id', (req: Request, res: Response) => {
-  const { id } = req.params;
-
-  const found = scriptAnswerSet.findById(id);
-  if (!found) {
-    return res.status(404).json({ error: 'ScriptAnswer not found' });
-  }
-
-  return res.status(200).json(found);
-});
-
-
-
-// --------------------------------------------------------------
-// GET /api/scripts/answers/:id/tasks/:taskId → Get grade of task
-// --------------------------------------------------------------
-app.get('/api/scripts/answers/:id/tasks/:taskId', (req: Request, res: Response) => {
-  const { id, taskId } = req.params;
-
-  const scriptAnswer = scriptAnswerSet.findById(id);
-  if (!scriptAnswer) {
-    return res.status(404).json({ error: 'ScriptAnswer not found' });
-  }
-
-  const task = scriptAnswer.taskAnswers.find(t => t.taskId === taskId);
-  if (!task) {
-    return res.status(404).json({ error: 'Task not found' });
-  }
-
-  return res.status(200).json({ grade: task.grade });
-});
-
-
-// --------------------------------------------------------------
-// POST /api/scripts/answers  → Create a script answer
-// --------------------------------------------------------------
-app.post('/api/scripts/answers', (req: Request, res: Response) => {
-  try {
-    const newAnswer = scriptAnswerSet.addScriptAnswer(req.body);
-    res.status(201).json(newAnswer);
-  } catch (error) {
-    res.status(400).json({ error: (error as Error).message });
-  }
-});
-
-// --------------------------------------------------------------
-// PUT /api/scripts/answers/:id/tasks/:taskId → Update grade
-// --------------------------------------------------------------
-app.put('/api/scripts/answers/:id/tasks/:taskId', (req: Request, res: Response) => {
-  const { id, taskId } = req.params;
-  const { grade } = req.body;
-
-  const scriptAnswer = scriptAnswerSet.findById(id);
-  if (!scriptAnswer) {
-    return res.status(404).json({ error: 'ScriptAnswer not found' });
-  }
-
-  const task = scriptAnswer.taskAnswers.find(t => t.taskId === taskId);
-  if (!task) {
-    return res.status(404).json({ error: 'Task not found' });
-  }
-
-  if (!['MANA', 'MPA', 'MA'].includes(grade)) {
-    return res.status(400).json({ error: 'Invalid grade' });
-  }
-
-  task.grade = grade;
-  return res.status(200).json({ taskId, grade });
-});
 
-// --------------------------------------------------------------
-// PUT /api/scripts/answers/:id/comments → Add comment to script
-// --------------------------------------------------------------
-app.put('/api/scripts/answers/:id/comments', (req: Request, res: Response) => {
-  const { id } = req.params;
-  const { comment } = req.body;
 
-  const scriptAnswer = scriptAnswerSet.findById(id);
-  if (!scriptAnswer) {
-    return res.status(404).json({ error: 'ScriptAnswer not found' });
-  }
-
-  scriptAnswer.comment = comment;
-
-  return res.status(200).json({ id, comment });
-});
-
-// --------------------------------------------------------------
-// PUT /api/scripts/answers/:id/tasks/:taskId/comments
-// --------------------------------------------------------------
-app.put('/api/scripts/answers/:id/tasks/:taskId/comments', (req: Request, res: Response) => {
-  const { id, taskId } = req.params;
-  const { comment } = req.body;
-
-  const scriptAnswer = scriptAnswerSet.findById(id);
-  if (!scriptAnswer) {
-    return res.status(404).json({ error: 'ScriptAnswer not found' });
-  }
-
-  const task = scriptAnswer.taskAnswers.find(t => t.taskId === taskId);
-  if (!task) {
-    return res.status(404).json({ error: 'Task not found' });
-  }
-
-  task.comments = comment;
-
-  return res.status(200).json({ taskId, comment });
-});
-
-// --------------------------------------------------------------
-// TASKS endpoints
-// --------------------------------------------------------------
-
-// POST /api/tasks => create new task
-app.post('/api/tasks', (req: Request, res: Response) =>{
-  const task = taskset.addTask(req.body);
-  res.status(201).json(task);
-});
-
-// GET /api/tasks/:id => get task by id
-app.get('/api/tasks/:id', (req: Request, res: Response) => {
-  const { id } = req.params;
-  const task = taskset.findById(id);
-  if (!task) {
-    return res.status(404).json({ error: 'Task not found' });
-  }
-  res.json(task.toJSON());
-});
-
-// GET /api/tasks - Get all students
-app.get('/api/tasks', (req: Request, res: Response) => {
-  try {
-    const tasks = taskset.getAllTasks();
-    res.json(tasks.map(t => t.toJSON()));
-  } catch (error) {
-    res.status(500).json({ error: 'Failed to fetch students' });
-  }
-});
-// PUT /api/tasks/:id => update task
-app.put('/api/tasks/:id', (req: Request, res: Response) => {
-  const { id } = req.params;
-  const task = taskset.updateTask(id, req.body);
-
-  if (!task) return res.status(404).json({ error: 'Task not found' });
-  res.json(task.toJSON());
-});
-
-// --------------------------------------------------------------
-// SCRIPTS endpoints
-// --------------------------------------------------------------
-
-//POST /api/scripts - Create a new script
-app.post('/api/scripts', (req: Request, res: Response) => {
-  const script = scripts.addScript(req.body);
-  res.status(201).json(script.toJSON());
-});
-
-//GET /api/scripts/:id - Get one script by ID
-app.get('/api/scripts/:id', (req: Request, res: Response) => {
-  const { id } = req.params;
-  const script = scripts.findById(id);
-  if (!script) {
-    return res.status(404).json({ error: 'Script not found' });
-  }
-  res.json(script.toJSON());
-});
-
-// GET /api/scripts - Get all scripts
-app.get('/api/scripts', (req: Request, res: Response) => {
-  try {
-    const allScripts = scripts.getAllScripts();
-    res.json(allScripts.map(s => s.toJSON()));
-  } catch (error) {
-    res.status(500).json({ error: 'Failed to fetch scripts' });
-  }
-});
-
-//PUT /api/scripts/:id - Update a script
-app.put('/api/scripts/:id', (req: Request, res: Response) => {
-  const { id } = req.params;
-  const script = scripts.updateScript(id, req.body);
-
-  if (!script) return res.status(404).json({ error: 'Script not found' });
-  res.json(script.toJSON());
-});
 
 
 
diff --git a/server/src/server_routes/scriptanswer.ts b/server/src/server_routes/scriptanswer.ts
new file mode 100644
index 00000000..66c74d53
--- /dev/null
+++ b/server/src/server_routes/scriptanswer.ts
@@ -0,0 +1,118 @@
+import { Request, Response, Express } from 'express';
+
+export function setupScriptAnswerRoutes(app: Express, scriptAnswerSet: any, studentSet: any) {
+  const scriptAnswerurl = '/api/scriptanswers/';
+
+  // GET /api/scriptanswers → get ALL answers
+  app.get(scriptAnswerurl+'', (req: Request, res: Response) => {
+    try {
+      const all = scriptAnswerSet.getAll();
+      return res.status(200).json(all.map((a: any) => a.toJSON()));
+    } catch (err) {
+      return res.status(500).json({ error: 'Failed to fetch script answers' });
+    }
+  });
+
+  // GET /api/scriptanswers/student/:studentId → Answers for a student
+  app.get(scriptAnswerurl+'student/:studentId', (req: Request, res: Response) => {
+    const { studentId } = req.params;
+
+    const student = studentSet.findStudentByCPF(studentId);
+    if (!student) {
+      return res.status(404).json({ error: 'Student not found' });
+    }
+
+    const answers = scriptAnswerSet.findByStudentId(studentId);
+    return res.status(200).json(answers.map((a: any) => a.toJSON()));
+  });
+
+  // GET /api/scriptanswers/script/:scriptId → Answers for a script
+  app.get(scriptAnswerurl+'script/:scriptId', (req: Request, res: Response) => {
+    const { scriptId } = req.params;
+
+    const answers = scriptAnswerSet.findbyScriptId(scriptId);
+    return res.status(200).json(answers.map((a: any) => a.toJSON()));
+  });
+
+  // GET /api/scriptanswers/:id → get ONE answer by ID
+  app.get(scriptAnswerurl+':id', (req: Request, res: Response) => {
+    const { id } = req.params;
+
+    const found = scriptAnswerSet.findById(id);
+    if (!found) {
+      return res.status(404).json({ error: 'ScriptAnswer not found' });
+    }
+
+    return res.status(200).json(found.toJSON());
+  });
+
+  // GET /api/scriptanswers/:id/tasks/:taskId → Get grade of task
+  app.get(scriptAnswerurl+':id/tasks/:taskId', (req: Request, res: Response) => {
+    const { id, taskId } = req.params;
+
+    const scriptAnswer = scriptAnswerSet.findById(id);
+    if (!scriptAnswer) {
+      return res.status(404).json({ error: 'ScriptAnswer not found' });
+    }
+
+    const task = scriptAnswer.findAnswerByTaskId(taskId);
+    if (!task) {
+      return res.status(404).json({ error: 'Task not found' });
+    }
+
+    return res.status(200).json({ taskId, grade: task.getGrade() });
+  });
+
+  // POST /api/scriptanswers → Create a script answer
+  app.post(scriptAnswerurl+'', (req: Request, res: Response) => {
+    try {
+      const newAnswer = scriptAnswerSet.addScriptAnswer(req.body);
+      res.status(201).json(newAnswer.toJSON());
+    } catch (error) {
+      res.status(400).json({ error: (error as Error).message });
+    }
+  });
+
+  // PUT /api/scriptanswers/:id/tasks/:taskId → Update grade
+  app.put(scriptAnswerurl+':id/tasks/:taskId', (req: Request, res: Response) => {
+    const { id, taskId } = req.params;
+    const { grade } = req.body;
+
+    const scriptAnswer = scriptAnswerSet.findById(id);
+    if (!scriptAnswer) {
+      return res.status(404).json({ error: 'ScriptAnswer not found' });
+    }
+
+    const task = scriptAnswer.findAnswerByTaskId(taskId);
+    if (!task) {
+      return res.status(404).json({ error: 'Task not found' });
+    }
+
+    if (!['MANA', 'MPA', 'MA'].includes(grade)) {
+      return res.status(400).json({ error: 'Invalid grade' });
+    }
+
+    task.updateGrade(grade);
+    return res.status(200).json({ taskId, grade });
+  });
+
+  // PUT /api/scriptanswers/:id/tasks/:taskId/comments → Add comment to task
+  app.put(scriptAnswerurl+':id/tasks/:taskId/comments', (req: Request, res: Response) => {
+    const { id, taskId } = req.params;
+    const { comment } = req.body;
+
+    const scriptAnswer = scriptAnswerSet.findById(id);
+    if (!scriptAnswer) {
+      return res.status(404).json({ error: 'ScriptAnswer not found' });
+    }
+
+    const task = scriptAnswer.findAnswerByTaskId(taskId);
+    if (!task) {
+      return res.status(404).json({ error: 'Task not found' });
+    }
+
+    task.comments = comment;
+
+    return res.status(200).json({ taskId, comment });
+  });
+}
\ No newline at end of file
diff --git a/server/src/server_routes/scripts.ts b/server/src/server_routes/scripts.ts
new file mode 100644
index 00000000..4de29b4f
--- /dev/null
+++ b/server/src/server_routes/scripts.ts
@@ -0,0 +1,40 @@
+import { Request, Response, Express } from 'express';
+
+export function setupScriptRoutes(app: Express, scripts: any) {
+  const scripturl = '/api/scripts/';
+
+  // POST /api/scripts - Create a new script
+  app.post(scripturl+'', (req: Request, res: Response) => {
+    const script = scripts.addScript(req.body);
+    res.status(201).json(script.toJSON());
+  });
+
+  // GET /api/scripts/:id - Get one script by ID
+  app.get(scripturl+'/:id', (req: Request, res: Response) => {
+    const { id } = req.params;
+    const script = scripts.findById(id);
+    if (!script) {
+      return res.status(404).json({ error: 'Script not found' });
+    }
+    res.json(script.toJSON());
+  });
+
+  // GET /api/scripts - Get all scripts
+  app.get(scripturl+'', (req: Request, res: Response) => {
+    try {
+      const allScripts = scripts.getAllScripts();
+      res.json(allScripts.map((s: any) => s.toJSON()));
+    } catch (error) {
+      res.status(500).json({ error: 'Failed to fetch scripts' });
+    }
+  });
+
+  // PUT /api/scripts/:id - Update a script
+  app.put(scripturl+'/:id', (req: Request, res: Response) => {
+    const { id } = req.params;
+    const script = scripts.updateScript(id, req.body);
+
+    if (!script) return res.status(404).json({ error: 'Script not found' });
+    res.json(script.toJSON());
+  });
+}
\ No newline at end of file
diff --git a/server/src/server_routes/tasks.ts b/server/src/server_routes/tasks.ts
new file mode 100644
index 00000000..8429b931
--- /dev/null
+++ b/server/src/server_routes/tasks.ts
@@ -0,0 +1,44 @@
+import { Request, Response, Express } from 'express';
+
+// --------------------------------------------------------------
+// TASKS endpoints
+// --------------------------------------------------------------
+
+export function setupTaskRoutes(app: Express, taskset: any) {
+  const taskurl = '/api/tasks/';
+
+  // POST /api/tasks => create new task
+  app.post(taskurl+'', (req: Request, res: Response) =>{
+    const task = taskset.addTask(req.body);
+    res.status(201).json(task);
+  });
+
+  // GET /api/tasks/:id => get task by id
+  app.get(taskurl+'/:id', (req: Request, res: Response) => {
+    const { id } = req.params;
+    const task = taskset.findById(id);
+    if (!task) {
+      return res.status(404).json({ error: 'Task not found' });
+    }
+    res.json(task.toJSON());
+  });
+
+  // GET /api/tasks - Get all tasks
+  app.get(taskurl+'', (req: Request, res: Response) => {
+    try {
+      const tasks = taskset.getAllTasks();
+      res.json(tasks.map((t: any) => t.toJSON()));
+    } catch (error) {
+      res.status(500).json({ error: 'Failed to fetch tasks' });
+    }
+  });
+
+  // PUT /api/tasks/:id => update task
+  app.put(taskurl+'/:id', (req: Request, res: Response) => {
+    const { id } = req.params;
+    const task = taskset.updateTask(id, req.body);
+
+    if (!task) return res.status(404).json({ error: 'Task not found' });
+    res.json(task.toJSON());
+  });
+}
\ No newline at end of file

From 14c658dae387915295743834c7ea09a39fa9e11e Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Mon, 8 Dec 2025 15:55:03 -0300
Subject: [PATCH 037/102] testing: updated unit tests for types associated with
 script grading

---
 server/src/__tests__/ScriptAnswer.test.ts    | 80 +++++++++++---------
 server/src/__tests__/ScriptAnswerSet.test.ts | 53 +++++++++----
 server/src/__tests__/TaskAnswer.test.ts      | 64 ++++++----------
 3 files changed, 111 insertions(+), 86 deletions(-)

diff --git a/server/src/__tests__/ScriptAnswer.test.ts b/server/src/__tests__/ScriptAnswer.test.ts
index 3f5571b0..a807c43d 100644
--- a/server/src/__tests__/ScriptAnswer.test.ts
+++ b/server/src/__tests__/ScriptAnswer.test.ts
@@ -1,28 +1,24 @@
 import { ScriptAnswer } from "../models/ScriptAnswer";
-import { Student } from "../models/Student";
-import { Task } from "../models/Task";
 import { TaskAnswer } from "../models/TaskAnswer";
 import { Grade } from "../models/Evaluation";
 
 describe("ScriptAnswer", () => {
-  let student: Student;
   let script: ScriptAnswer;
 
   beforeEach(() => {
-    student = new Student("John Doe", "12345678909", "john@example.com");
-    script = new ScriptAnswer("sa1", student);
+    script = new ScriptAnswer("sa1", "script1", "student123");
   });
 
   // ---------------------------------------------------------------
   test("constructor initializes fields", () => {
     expect(script.getId()).toBe("sa1");
+    expect(script.getScriptId()).toBe("script1");
     expect(script.answers.length).toBe(0);
   });
 
   // ---------------------------------------------------------------
   test("toJSON() returns correct structure", () => {
-    const t1 = new Task("t1", "Example task");
-    const ta1 = new TaskAnswer("a1", t1, "my answer", "MA");
+    const ta1 = new TaskAnswer("a1", "t1", "my answer", "MA");
 
     script.addAnswer(ta1);
 
@@ -30,18 +26,12 @@ describe("ScriptAnswer", () => {
 
     expect(json).toEqual({
       id: "sa1",
-      student: {
-        name: "John Doe",
-        cpf: "123.456.789-09",
-        email: "john@example.com",
-      },
+      scriptId: "script1",
+      student: "student123",
       answers: [
         {
           id: "a1",
-          task: {
-            id: "t1",
-            statement: "Example task",
-          },
+          task: "t1",
           answer: "my answer",
           grade: "MA",
           comments: undefined,
@@ -53,7 +43,7 @@ describe("ScriptAnswer", () => {
 
   // ---------------------------------------------------------------
   test("addAnswer() adds new answer", () => {
-    const answer = new TaskAnswer("a1", new Task("t1", "task1"));
+    const answer = new TaskAnswer("a1", "t1");
     script.addAnswer(answer);
 
     expect(script.answers.length).toBe(1);
@@ -61,9 +51,8 @@ describe("ScriptAnswer", () => {
   });
 
   test("addAnswer() throws when adding duplicate task", () => {
-    const t1 = new Task("t1", "task1");
-    const answer1 = new TaskAnswer("a1", t1);
-    const answer2 = new TaskAnswer("a2", t1);
+    const answer1 = new TaskAnswer("a1", "t1");
+    const answer2 = new TaskAnswer("a2", "t1");
 
     script.addAnswer(answer1);
 
@@ -72,8 +61,8 @@ describe("ScriptAnswer", () => {
 
   // ---------------------------------------------------------------
   test("findAnswerByTaskId() returns correct answer", () => {
-    const a1 = new TaskAnswer("a1", new Task("t1", "task1"));
-    const a2 = new TaskAnswer("a2", new Task("t2", "task2"));
+    const a1 = new TaskAnswer("a1", "t1");
+    const a2 = new TaskAnswer("a2", "t2");
 
     script.addAnswer(a1);
     script.addAnswer(a2);
@@ -84,7 +73,7 @@ describe("ScriptAnswer", () => {
 
   // ---------------------------------------------------------------
   test("removeAnswer() removes existing answer", () => {
-    const a1 = new TaskAnswer("a1", new Task("t1", "t1"));
+    const a1 = new TaskAnswer("a1", "t1");
     script.addAnswer(a1);
     expect(script.answers.length).toBe(1);
 
@@ -102,10 +91,10 @@ describe("ScriptAnswer", () => {
   // ---------------------------------------------------------------
   describe("grade distribution", () => {
     test("getGradeDistribution counts correctly", () => {
-      script.addAnswer(new TaskAnswer("a1", new Task("1", "x"), "a", "MA"));
-      script.addAnswer(new TaskAnswer("a2", new Task("2", "x"), "a", "MA"));
-      script.addAnswer(new TaskAnswer("a3", new Task("3", "x"), "a", "MPA"));
-      script.addAnswer(new TaskAnswer("a4", new Task("4", "x"), "a", "MANA"));
+      script.addAnswer(new TaskAnswer("a1", "t1", "a", "MA"));
+      script.addAnswer(new TaskAnswer("a2", "t2", "a", "MA"));
+      script.addAnswer(new TaskAnswer("a3", "t3", "a", "MPA"));
+      script.addAnswer(new TaskAnswer("a4", "t4", "a", "MANA"));
 
       const dist = script.getGradeDistribution();
 
@@ -116,21 +105,17 @@ describe("ScriptAnswer", () => {
       });
     });
 
-    // NEW TEST
     test("getNumberOfAnswersWithGrade throws on invalid grade", () => {
       expect(() => (script as any).getNumberOfAnswersWithGrade("INVALID"))
         .toThrow("Invalid grade");
     });
   });
 
-  // ---------------------------------------------------------------
-  // NEW TESTS: Grade validation in constructor and updateGrade()
   // ---------------------------------------------------------------
   describe("grade validation", () => {
     test("constructor throws when initialized with invalid grade", () => {
       expect(() => {
-        // @ts-expect-error intentionally invalid
-        new ScriptAnswer("bad", student, [], "INVALID");
+        new ScriptAnswer("bad", "script1", "student123", [], "INVALID" as Grade);
       }).toThrow("Invalid grade value");
     });
 
@@ -147,9 +132,36 @@ describe("ScriptAnswer", () => {
 
     test("updateGrade throws on invalid grade", () => {
       expect(() => {
-        // @ts-expect-error intentional invalid
-        script.updateGrade("WRONG");
+        script.updateGrade("WRONG" as Grade);
       }).toThrow("Invalid grade value");
     });
   });
+
+  // ---------------------------------------------------------------
+  describe("static methods", () => {
+    test("fromJSON creates ScriptAnswer instance", () => {
+      const json = {
+        id: "sa1",
+        scriptId: "script1",
+        student: "student123",
+        answers: [
+          {
+            id: "a1",
+            task: "t1",
+            answer: "test answer",
+            grade: "MA",
+            comments: "good",
+          },
+        ],
+        grade: "MPA",
+      };
+
+      const script = ScriptAnswer.fromJSON(json);
+
+      expect(script.getId()).toBe("sa1");
+      expect(script.getScriptId()).toBe("script1");
+      expect(script.answers.length).toBe(1);
+      expect(script.grade).toBe("MPA");
+    });
+  });
 });
diff --git a/server/src/__tests__/ScriptAnswerSet.test.ts b/server/src/__tests__/ScriptAnswerSet.test.ts
index 0237fa94..b3a9fb17 100644
--- a/server/src/__tests__/ScriptAnswerSet.test.ts
+++ b/server/src/__tests__/ScriptAnswerSet.test.ts
@@ -1,4 +1,6 @@
 import { ScriptAnswerSet } from '../models/ScriptAnswerSet';
+import { ScriptAnswer } from '../models/ScriptAnswer';
+import { TaskAnswer } from '../models/TaskAnswer';
 
 describe('ScriptAnswerSet', () => {
   let set: ScriptAnswerSet;
@@ -22,9 +24,9 @@ describe('ScriptAnswerSet', () => {
 
       const result = set.addScriptAnswer(data);
 
-      expect(result.id).toBe('A1');
-      expect(result.scriptId).toBe('S1');
-      expect(result.studentId).toBe('ST1');
+      expect(result.getId()).toBe('A1');
+      expect(result.getScriptId()).toBe('S1');
+      expect(result.answers.length).toBe(0);
       expect(result.grade).toBe('MA');
       expect(set.getAll().length).toBe(1);
     });
@@ -37,8 +39,8 @@ describe('ScriptAnswerSet', () => {
 
       const result = set.addScriptAnswer(data);
 
-      expect(result.id).toBeDefined();
-      expect(typeof result.id).toBe('string');
+      expect(result.getId()).toBeDefined();
+      expect(typeof result.getId()).toBe('string');
       expect(set.getAll().length).toBe(1);
     });
   });
@@ -51,7 +53,7 @@ describe('ScriptAnswerSet', () => {
       const a = set.addScriptAnswer({ id: 'A1', scriptId: 'S1', studentId: 'ST1' });
       expect(set.getAll().length).toBe(1);
     
-      const removed = set.removeScriptAnswer(a.id);
+      const removed = set.removeScriptAnswer(a.getId());
 
       expect(removed).toBe(true);
       expect(set.getAll().length).toBe(0);
@@ -78,7 +80,7 @@ describe('ScriptAnswerSet', () => {
       const all = set.getAll();
 
       expect(all.length).toBe(2);
-      expect(all.map(a => a.id)).toEqual(['A1', 'A2']);
+      expect(all.map(a => a.getId())).toEqual(['A1', 'A2']);
     });
   });
 
@@ -94,7 +96,7 @@ describe('ScriptAnswerSet', () => {
       const results = set.findByStudentId('ST1');
 
       expect(results.length).toBe(2);
-      expect(results.map(a => a.id)).toEqual(['A1', 'A2']);
+      expect(results.map(a => a.getId())).toEqual(['A1', 'A2']);
     });
 
     test('should return an empty array if student has no answers', () => {
@@ -116,7 +118,7 @@ describe('ScriptAnswerSet', () => {
       const result = set.findById('A1');
 
       expect(result).not.toBeNull();
-      expect(result?.scriptId).toBe('S1');
+      expect(result?.getScriptId()).toBe('S1');
     });
 
     test('should return null for nonexistent ID', () => {
@@ -131,7 +133,7 @@ describe('ScriptAnswerSet', () => {
   // -----------------------------------------
   describe('updateGrade', () => {
     test('should update grade of an existing script answer', () => {
-      set.addScriptAnswer({ id: 'A1', scriptId: 'S1', studentId: 'ST1', grade: null });
+      set.addScriptAnswer({ id: 'A1', scriptId: 'S1', studentId: 'ST1', grade: undefined });
 
       const updated = set.updateGrade('A1', 'MA');
 
@@ -151,12 +153,12 @@ describe('ScriptAnswerSet', () => {
   // -----------------------------------------
   describe('updateTaskAnswer', () => {
     test('should update grade and comments of a task answer', () => {
-      set.addScriptAnswer({
+      const scriptAnswer = set.addScriptAnswer({
         id: 'A1',
         scriptId: 'S1',
         studentId: 'ST1',
         taskAnswers: [
-          { id: 'TA1', grade: 'MA', comments: 'old comment' }
+          { id: 'TA1', task: 'T1', grade: 'MA', comments: 'old comment' }
         ]
       });
 
@@ -166,7 +168,7 @@ describe('ScriptAnswerSet', () => {
       });
 
       expect(result).not.toBeNull();
-      expect(result?.grade).toBe('MANA');
+      expect(result?.getGrade()).toBe('MANA');
       expect(result?.comments).toBe('new comment');
     });
 
@@ -184,4 +186,29 @@ describe('ScriptAnswerSet', () => {
     });
   });
 
+  // -----------------------------------------
+  // findByScriptId
+  // -----------------------------------------
+  describe('findByScriptId', () => {
+    test('should return all answers for a specific script', () => {
+      set.addScriptAnswer({ id: 'A1', scriptId: 'S1', studentId: 'ST1' });
+      set.addScriptAnswer({ id: 'A2', scriptId: 'S1', studentId: 'ST2' });
+      set.addScriptAnswer({ id: 'A3', scriptId: 'S2', studentId: 'ST3' });
+
+      const results = set.findbyScriptId('S1');
+
+  
+
+      expect(results.length).toBe(2);
+      expect(results.map(a => a.getId())).toEqual(['A1', 'A2']);
+    });
+
+    test('should return an empty array if script has no answers', () => {
+      set.addScriptAnswer({ id: 'A1', scriptId: 'S1', studentId: 'ST1' });
+
+      const results = set.findbyScriptId('NOPE');
+
+      expect(results).toEqual([]);
+    });
+  });
 });
diff --git a/server/src/__tests__/TaskAnswer.test.ts b/server/src/__tests__/TaskAnswer.test.ts
index c0d3724b..99336b80 100644
--- a/server/src/__tests__/TaskAnswer.test.ts
+++ b/server/src/__tests__/TaskAnswer.test.ts
@@ -1,20 +1,15 @@
 import { TaskAnswer } from "../models/TaskAnswer";
-import { Task } from "../models/Task";
 import { Grade } from "../models/Evaluation";
 
 describe("TaskAnswer", () => {
-  let task: Task;
-
-  beforeEach(() => {
-    task = new Task("t1", "Example Task");
-  });
+  const taskId = "t1";
 
   // ---------------------------------------------------------------
   test("constructor initializes fields correctly", () => {
-    const ta = new TaskAnswer("a1", task, "my answer", "MA", "good job");
+    const ta = new TaskAnswer("a1", taskId, "my answer", "MA", "good job");
 
     expect(ta.id).toBe("a1");
-    expect(ta.task).toBe(task);
+    expect(ta.task).toBe(taskId);
     expect(ta.answer).toBe("my answer");
     expect(ta.getGrade()).toBe("MA");
     expect(ta.comments).toBe("good job");
@@ -23,31 +18,28 @@ describe("TaskAnswer", () => {
   // ---------------------------------------------------------------
   test("constructor throws on invalid grade", () => {
     expect(() => {
-      new TaskAnswer("a1", task, "ans", "INVALID" as Grade);
+      new TaskAnswer("a1", taskId, "ans", "INVALID" as Grade);
     }).toThrow("Invalid grade value");
   });
 
   test("constructor accepts undefined grade", () => {
-    const ta = new TaskAnswer("a1", task, "x", undefined);
+    const ta = new TaskAnswer("a1", taskId, "x", undefined);
     expect(ta.getGrade()).toBeUndefined();
   });
 
   // ---------------------------------------------------------------
   test("getTaskId() returns task id", () => {
-    const ta = new TaskAnswer("a1", task);
-    expect(ta.getTaskId()).toBe("t1");
+    const ta = new TaskAnswer("a1", taskId);
+    expect(ta.getTaskId()).toBe(taskId);
   });
 
   // ---------------------------------------------------------------
   test("toJSON() returns correct structure", () => {
-    const ta = new TaskAnswer("a1", task, "answer", "MPA");
+    const ta = new TaskAnswer("a1", taskId, "answer", "MPA");
 
     expect(ta.toJSON()).toEqual({
       id: "a1",
-      task: {
-        id: "t1",
-        statement: "Example Task",
-      },
+      task: taskId,
       answer: "answer",
       grade: "MPA",
       comments: undefined,
@@ -55,14 +47,11 @@ describe("TaskAnswer", () => {
   });
 
   test("toJSON() omits grade when undefined", () => {
-    const ta = new TaskAnswer("a1", task, "ans", undefined);
+    const ta = new TaskAnswer("a1", taskId, "ans", undefined);
 
     expect(ta.toJSON()).toEqual({
       id: "a1",
-      task: {
-        id: "t1",
-        statement: "Example Task",
-      },
+      task: taskId,
       answer: "ans",
       grade: undefined,
       comments: undefined,
@@ -72,21 +61,21 @@ describe("TaskAnswer", () => {
   // ---------------------------------------------------------------
   describe("updateGrade()", () => {
     test("updates grade correctly", () => {
-      const ta = new TaskAnswer("a1", task);
+      const ta = new TaskAnswer("a1", taskId);
       ta.updateGrade("MANA");
 
       expect(ta.getGrade()).toBe("MANA");
     });
 
     test("removes grade when passed undefined", () => {
-      const ta = new TaskAnswer("a1", task, "x", "MA");
+      const ta = new TaskAnswer("a1", taskId, "x", "MA");
       ta.updateGrade(undefined);
 
       expect(ta.getGrade()).toBeUndefined();
     });
 
     test("throws on invalid grade", () => {
-      const ta = new TaskAnswer("a1", task);
+      const ta = new TaskAnswer("a1", taskId);
 
       expect(() => ta.updateGrade("BAD" as Grade)).toThrow("Invalid grade value");
     });
@@ -95,42 +84,39 @@ describe("TaskAnswer", () => {
   // ---------------------------------------------------------------
   describe("update()", () => {
     test("updates answer", () => {
-      const ta = new TaskAnswer("a1", task);
+      const ta = new TaskAnswer("a1", taskId);
       ta.update({ answer: "new answer" });
 
       expect(ta.answer).toBe("new answer");
     });
 
     test("updates comments", () => {
-      const ta = new TaskAnswer("a1", task);
+      const ta = new TaskAnswer("a1", taskId);
       ta.update({ comments: "hello" });
 
       expect(ta.comments).toBe("hello");
     });
 
     test("updates grade", () => {
-      const ta = new TaskAnswer("a1", task);
+      const ta = new TaskAnswer("a1", taskId);
       ta.update({ grade: "MPA" });
 
       expect(ta.getGrade()).toBe("MPA");
     });
 
     test("throws on invalid grade", () => {
-      const ta = new TaskAnswer("a1", task);
+      const ta = new TaskAnswer("a1", taskId);
 
       expect(() => ta.update({ grade: "WRONG" as Grade }))
         .toThrow("Invalid grade value");
     });
 
-    test("updates task via fromJSON()", () => {
-      const ta = new TaskAnswer("a1", task);
-      ta.update({ task: { id: "t2", statement: "New task" } });
+    test("updates task", () => {
+      const ta = new TaskAnswer("a1", taskId);
+      ta.update({ task: "t2" });
 
       expect(ta.getTaskId()).toBe("t2");
-      expect(ta.task.toJSON()).toEqual({
-        id: "t2",
-        statement: "New task",
-      });
+      expect(ta.task).toBe("t2");
     });
   });
 
@@ -139,7 +125,7 @@ describe("TaskAnswer", () => {
     test("creates TaskAnswer instance from JSON", () => {
       const json = {
         id: "a1",
-        task: task,
+        task: taskId,
         answer: "ans",
         grade: "MA",
         comments: "ok",
@@ -151,13 +137,13 @@ describe("TaskAnswer", () => {
       expect(ta.answer).toBe("ans");
       expect(ta.getGrade()).toBe("MA");
       expect(ta.comments).toBe("ok");
-      expect(ta.task).toBe(task); // because constructor receives the task directly
+      expect(ta.task).toBe(taskId);
     });
   });
 
   // ---------------------------------------------------------------
   test("getGrade() returns internal grade", () => {
-    const ta = new TaskAnswer("a1", task, "ans", "MANA");
+    const ta = new TaskAnswer("a1", taskId, "ans", "MANA");
     expect(ta.getGrade()).toBe("MANA");
   });
 });

From 65b3511e4a87b175e002d9e5c79c7d6e5a89b854 Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Mon, 8 Dec 2025 15:55:23 -0300
Subject: [PATCH 038/102] testing: scriptgrading backend integration tests

---
 server/src/__tests__/scriptgrading.test.ts | 172 +++++++++++++++++----
 1 file changed, 146 insertions(+), 26 deletions(-)

diff --git a/server/src/__tests__/scriptgrading.test.ts b/server/src/__tests__/scriptgrading.test.ts
index b6a3229d..ec4f4472 100644
--- a/server/src/__tests__/scriptgrading.test.ts
+++ b/server/src/__tests__/scriptgrading.test.ts
@@ -1,6 +1,7 @@
 import request from 'supertest';
 import { app, scriptAnswerSet, studentSet } from '../server';
 import { Student } from '../models/Student';
+import { TaskAnswer } from '../models/TaskAnswer';
 
 describe('Server API – Script Answers Endpoints', () => {
 
@@ -12,7 +13,7 @@ describe('Server API – Script Answers Endpoints', () => {
 
     // Clear script answers
     const allAnswers = scriptAnswerSet.getAll();
-    allAnswers.forEach(a => scriptAnswerSet.removeScriptAnswer(a.id));
+    allAnswers.forEach(a => scriptAnswerSet.removeScriptAnswer(a.getId()));
     expect(scriptAnswerSet.getAll().length).toBe(0);
   });
 
@@ -20,12 +21,12 @@ describe('Server API – Script Answers Endpoints', () => {
   // 1) Recuperar todas as respostas cadastradas
   // ----------------------------------------------------------
 
-  test('GET /api/scripts/answers → returns all registered answers', async () => {
+  test('GET /api/scriptanswers → returns all registered answers', async () => {
     scriptAnswerSet.addScriptAnswer({ id: '123', scriptId: '1', studentId: 'S1' });
     scriptAnswerSet.addScriptAnswer({ id: '321', scriptId: '2', studentId: 'S2' });
     scriptAnswerSet.addScriptAnswer({ id: '890', scriptId: '3', studentId: 'S3' });
 
-    const res = await request(app).get('/api/scripts/answers');
+    const res = await request(app).get('/api/scriptanswers/');
 
     expect(res.status).toBe(200);
     const ids = res.body.map((a: any) => a.id);
@@ -38,8 +39,8 @@ describe('Server API – Script Answers Endpoints', () => {
   // 2) Recuperar respostas quando não há nenhuma cadastrada
   // ----------------------------------------------------------
 
-  test('GET /api/scripts/answers → returns empty list when none exist', async () => {
-    const res = await request(app).get('/api/scripts/answers');
+  test('GET /api/scriptanswers → returns empty list when none exist', async () => {
+    const res = await request(app).get('/api/scriptanswers/');
 
     expect(res.status).toBe(200);
     expect(res.body).toEqual([]);
@@ -49,13 +50,13 @@ describe('Server API – Script Answers Endpoints', () => {
   // 3) Recuperar respostas de um aluno cadastrado
   // ----------------------------------------------------------
 
-  test('GET /api/scripts/answers/student/:studentId → returns answers of a specific student', async () => {
+  test('GET /api/scriptanswers/student/:studentId → returns answers of a specific student', async () => {
     studentSet.addStudent(new Student('Alice', '15029035478', 'alice@gmail.com'));
     scriptAnswerSet.addScriptAnswer({ id: '40', scriptId: '1', studentId: '15029035478' });
     scriptAnswerSet.addScriptAnswer({ id: '41', scriptId: '2', studentId: '15029035478' });
     scriptAnswerSet.addScriptAnswer({ id: '999', scriptId: 'X', studentId: 'other' });
 
-    const res = await request(app).get('/api/scripts/answers/student/15029035478');
+    const res = await request(app).get('/api/scriptanswers/student/15029035478');
 
     expect(res.status).toBe(200);
     const ids = res.body.map((a: any) => a.id);
@@ -66,50 +67,169 @@ describe('Server API – Script Answers Endpoints', () => {
   // 4) Tentar recuperar respostas de aluno não cadastrado
   // ----------------------------------------------------------
 
-  test('GET /api/scripts/answers/student/:studentId → returns 404 if student not found', async () => {
-    const res = await request(app).get('/api/scripts/answers/student/999');
+  test('GET /api/scriptanswers/student/:studentId → returns 404 if student not found', async () => {
+    const res = await request(app).get('/api/scriptanswers/student/999');
 
     expect(res.status).toBe(404);
     expect(res.body.error).toBe('Student not found');
   });
 
   // ----------------------------------------------------------
-  // 5) Recuperar a nota de uma questão existente
+  // 5) Recuperar respostas por script ID
   // ----------------------------------------------------------
 
-  test('GET /api/scripts/answers/:id/tasks/:taskId → returns grade for existing task', async () => {
-    scriptAnswerSet.addScriptAnswer({
-      id: '50',
+  test('GET /api/scriptanswers/script/:scriptId → returns answers for a specific script', async () => {
+    scriptAnswerSet.addScriptAnswer({ id: '50', scriptId: '1', studentId: 'S1' });
+    scriptAnswerSet.addScriptAnswer({ id: '51', scriptId: '1', studentId: 'S2' });
+    scriptAnswerSet.addScriptAnswer({ id: '52', scriptId: '2', studentId: 'S3' });
+
+    const res = await request(app).get('/api/scriptanswers/script/1');
+
+    expect(res.status).toBe(200);
+    const ids = res.body.map((a: any) => a.id);
+    expect(ids).toEqual(['50', '51']);
+  });
+
+  // ----------------------------------------------------------
+  // 6) Recuperar uma resposta por ID
+  // ----------------------------------------------------------
+
+  test('GET /api/scriptanswers/:id → returns a specific script answer', async () => {
+    scriptAnswerSet.addScriptAnswer({ id: '60', scriptId: '1', studentId: 'S1', grade: 'MA' });
+
+    const res = await request(app).get('/api/scriptanswers/60');
+
+    expect(res.status).toBe(200);
+    expect(res.body.id).toBe('60');
+    expect(res.body.scriptId).toBe('1');
+    expect(res.body.grade).toBe('MA');
+  });
+
+  // ----------------------------------------------------------
+  // 7) Recuperar resposta inexistente
+  // ----------------------------------------------------------
+
+  test('GET /api/scriptanswers/:id → returns 404 for nonexistent answer', async () => {
+    const res = await request(app).get('/api/scriptanswers/invalid');
+
+    expect(res.status).toBe(404);
+    expect(res.body.error).toBe('ScriptAnswer not found');
+  });
+
+  // ----------------------------------------------------------
+  // 8) Recuperar a nota de uma questão existente
+  // ----------------------------------------------------------
+
+  test('GET /api/scriptanswers/:id/tasks/:taskId → returns grade for existing task', async () => {
+    const answer = scriptAnswerSet.addScriptAnswer({
+      id: '70',
       scriptId: '1',
-      studentId: 'stu',
-      taskAnswers: [
-        { id: 'TA2', taskId: '2', grade: 'MA', comments: '' }
-      ]
+      studentId: 'stu'
     });
+    answer.addAnswer(new TaskAnswer('TA1', 't1', 'my answer', 'MA'));
 
-    const res = await request(app).get('/api/scripts/answers/50/tasks/2');
+    const res = await request(app).get('/api/scriptanswers/70/tasks/t1');
 
     expect(res.status).toBe(200);
+    expect(res.body.taskId).toBe('t1');
     expect(res.body.grade).toBe('MA');
   });
 
   // ----------------------------------------------------------
-  // 6) Nota de questão inexistente
+  // 9) Nota de questão inexistente
   // ----------------------------------------------------------
 
-  test('GET /api/scripts/answers/:id/tasks/:taskId → returns 404 for missing task', async () => {
+  test('GET /api/scriptanswers/:id/tasks/:taskId → returns 404 for missing task', async () => {
     scriptAnswerSet.addScriptAnswer({
-      id: '50',
+      id: '80',
       scriptId: '1',
-      studentId: 'stu',
-      taskAnswers: [
-        { id: 'TA2', taskId: '2', grade: 'MA', comments: '' }
-      ]
+      studentId: 'stu'
     });
 
-    const res = await request(app).get('/api/scripts/answers/50/tasks/9');
+    const res = await request(app).get('/api/scriptanswers/80/tasks/missing');
 
     expect(res.status).toBe(404);
     expect(res.body.error).toBe('Task not found');
   });
+
+  // ----------------------------------------------------------
+  // 10) Criar uma nova resposta de script
+  // ----------------------------------------------------------
+
+  test('POST /api/scriptanswers → creates a new script answer', async () => {
+    const res = await request(app)
+      .post('/api/scriptanswers/')
+      .send({
+        id: '90',
+        scriptId: '1',
+        studentId: 'S1'
+      });
+
+    expect(res.status).toBe(201);
+    expect(res.body.id).toBe('90');
+    expect(res.body.scriptId).toBe('1');
+    expect(res.body.student).toBe('S1');
+  });
+
+  // ----------------------------------------------------------
+  // 11) Atualizar nota de uma questão
+  // ----------------------------------------------------------
+
+  test('PUT /api/scriptanswers/:id/tasks/:taskId → updates task grade', async () => {
+    const answer = scriptAnswerSet.addScriptAnswer({
+      id: '100',
+      scriptId: '1',
+      studentId: 'S1'
+    });
+    answer.addAnswer(new TaskAnswer('TA2', 't2', 'answer', 'MPA'));
+
+    const res = await request(app)
+      .put('/api/scriptanswers/100/tasks/t2')
+      .send({ grade: 'MA' });
+
+    expect(res.status).toBe(200);
+    expect(res.body.taskId).toBe('t2');
+    expect(res.body.grade).toBe('MA');
+  });
+
+  // ----------------------------------------------------------
+  // 12) Atualizar nota com valor inválido
+  // ----------------------------------------------------------
+
+  test('PUT /api/scriptanswers/:id/tasks/:taskId → returns 400 for invalid grade', async () => {
+    const answer = scriptAnswerSet.addScriptAnswer({
+      id: '110',
+      scriptId: '1',
+      studentId: 'S1'
+    });
+    answer.addAnswer(new TaskAnswer('TA3', 't3', 'answer'));
+
+    const res = await request(app)
+      .put('/api/scriptanswers/110/tasks/t3')
+      .send({ grade: 'INVALID' });
+
+    expect(res.status).toBe(400);
+    expect(res.body.error).toBe('Invalid grade');
+  });
+
+  // ----------------------------------------------------------
+  // 13) Adicionar comentário a uma questão
+  // ----------------------------------------------------------
+
+  test('PUT /api/scriptanswers/:id/tasks/:taskId/comments → adds comment to task', async () => {
+    const answer = scriptAnswerSet.addScriptAnswer({
+      id: '120',
+      scriptId: '1',
+      studentId: 'S1'
+    });
+    answer.addAnswer(new TaskAnswer('TA4', 't4', 'answer'));
+
+    const res = await request(app)
+      .put('/api/scriptanswers/120/tasks/t4/comments')
+      .send({ comment: 'Good work!' });
+
+    expect(res.status).toBe(200);
+    expect(res.body.taskId).toBe('t4');
+    expect(res.body.comment).toBe('Good work!');
+  });
 });

From fd4a194d72301edd6342dd23cc3107fc0190dfb8 Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Mon, 8 Dec 2025 17:15:34 -0300
Subject: [PATCH 039/102] testing: mock script, task, and scriptanswer data
 added to server

---
 server/src/mock_scripts.ts | 144 +++++++++++++++++++++++++++++++++++++
 server/src/server.ts       |   3 +
 2 files changed, 147 insertions(+)
 create mode 100644 server/src/mock_scripts.ts

diff --git a/server/src/mock_scripts.ts b/server/src/mock_scripts.ts
new file mode 100644
index 00000000..045671dd
--- /dev/null
+++ b/server/src/mock_scripts.ts
@@ -0,0 +1,144 @@
+import { Express } from 'express';
+import { TaskSet } from './models/TaskSet';
+import { Scripts } from './models/Scripts';
+import { ScriptAnswerSet } from './models/ScriptAnswerSet';
+import { Task } from './models/Task';
+import { TaskAnswer } from './models/TaskAnswer';
+
+export function loadMockScriptsAndAnswers(
+  taskset: TaskSet,
+  scripts: Scripts,
+  scriptAnswerSet: ScriptAnswerSet,
+  studentCPF: string = '11111111111'
+): void {
+  try {
+    // Create mock tasks if none exist
+    if (taskset.getAllTasks().length === 0) {
+      const task1 = taskset.addTask(
+        new Task('task-001', 'Explain the basic concepts covered in class')
+      );
+
+      const task2 = taskset.addTask(
+        new Task('task-002', 'Implement the algorithm discussed')
+      );
+
+      const task3 = taskset.addTask(
+        new Task('task-003', 'Analyze the problem and propose a solution')
+      );
+
+      console.log('Mock tasks created:', [task1.getId(), task2.getId(), task3.getId()]);
+    }
+
+    // Create mock scripts if none exist
+    if (scripts.getAllScripts().length === 0) {
+      const script1 = scripts.addScript(new (require('./models/Script').Script)('script-001', 'Midterm Exam - Math 101'));
+      const foundTask1 = taskset.findById('task-001');
+      const foundTask2 = taskset.findById('task-002');
+      const foundTask3 = taskset.findById('task-003');
+
+      if (foundTask1) script1.addTask(foundTask1);
+      if (foundTask2) script1.addTask(foundTask2);
+      if (foundTask3) script1.addTask(foundTask3);
+
+      const script2 = scripts.addScript(new (require('./models/Script').Script)('script-002', 'Final Exam - Math 101'));
+      if (foundTask1) script2.addTask(foundTask1);
+      if (foundTask2) script2.addTask(foundTask2);
+      if (foundTask3) script2.addTask(foundTask3);
+
+      const script3 = scripts.addScript(new (require('./models/Script').Script)('script-003', 'Quiz - Programming 201'));
+      if (foundTask2) script3.addTask(foundTask2);
+      if (foundTask3) script3.addTask(foundTask3);
+
+      console.log('Mock scripts created:', [script1.getId(), script2.getId(), script3.getId()]);
+    }
+
+    // Create mock script answers if none exist
+    if (scriptAnswerSet.getAll().length === 0) {
+      const answer1 = scriptAnswerSet.addScriptAnswer({
+        id: 'answer-001',
+        scriptId: 'script-001',
+        studentId: studentCPF,
+        taskAnswers: [
+          new TaskAnswer(
+            'ta-001',
+            'task-001',
+            'The basic concepts are fundamental to understanding the subject matter.',
+            'MA',
+            'Excellent explanation with clear examples'
+          ),
+          new TaskAnswer(
+            'ta-002',
+            'task-002',
+            'Here is my implementation of the algorithm using a recursive approach...',
+            'MPA',
+            'Good attempt, but missing edge cases'
+          ),
+          new TaskAnswer(
+            'ta-003',
+            'task-003',
+            'My analysis shows that the time complexity is O(n log n).',
+            'MA',
+            'Well-reasoned analysis with proper mathematical justification'
+          )
+        ],
+        grade: 'MA'
+      });
+
+      const answer2 = scriptAnswerSet.addScriptAnswer({
+        id: 'answer-002',
+        scriptId: 'script-002',
+        studentId: studentCPF,
+        taskAnswers: [
+          new TaskAnswer(
+            'ta-004',
+            'task-001',
+            'Building on previous knowledge, the concepts form the foundation...',
+            'MA',
+            'Excellent continuation of understanding'
+          ),
+          new TaskAnswer(
+            'ta-005',
+            'task-002',
+            'The implementation demonstrates proper use of design patterns.',
+            'MA',
+            'Clean code with good structure'
+          ),
+          new TaskAnswer(
+            'ta-006',
+            'task-003',
+            'Critical analysis reveals that the solution handles all edge cases effectively.',
+            'MA',
+            'Thorough and insightful analysis'
+          )
+        ],
+        grade: 'MA'
+      });
+
+      const answer3 = scriptAnswerSet.addScriptAnswer({
+        id: 'answer-003',
+        scriptId: 'script-003',
+        studentId: studentCPF,
+        taskAnswers: [
+          new TaskAnswer(
+            'ta-007',
+            'task-002',
+            'My implementation uses a basic loop structure.',
+            'MPA',
+            'Works correctly but could be optimized'
+          ),
+          new TaskAnswer(
+            'ta-008',
+            'task-003',
+            'The solution works but could be optimized.',
+            'MPA',
+            'Shows understanding but optimization potential missed'
+          )
+        ]
+      });
+
+      console.log('Mock script answers created:', [answer1.getId(), answer2.getId(), answer3.getId()]);
+    }
+  } catch (error) {
+    console.error('Error loading mock scripts and answers:', error);
+  }
+}
\ No newline at end of file
diff --git a/server/src/server.ts b/server/src/server.ts
index 069fd32c..da1f22aa 100644
--- a/server/src/server.ts
+++ b/server/src/server.ts
@@ -532,11 +532,14 @@ export { app, studentSet, classes, scriptAnswerSet, taskset, scripts};
 import { setupScriptAnswerRoutes } from './server_routes/scriptanswer';
 import { setupTaskRoutes } from './server_routes/tasks';
 import { setupScriptRoutes } from './server_routes/scripts';
+import { loadMockScriptsAndAnswers } from './mock_scripts';
 
 setupScriptAnswerRoutes(app, scriptAnswerSet, studentSet);
 setupTaskRoutes(app, taskset);
 setupScriptRoutes(app, scripts);
 
+loadMockScriptsAndAnswers(taskset, scripts, scriptAnswerSet, "11111111111");
+
 // Only start the server if this file is run directly (not imported for testing)
 if (require.main === module) {
   app.listen(PORT, () => {

From 198ad96cfe228486248920bbdfab86b0d2e7a9ed Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Mon, 8 Dec 2025 17:16:25 -0300
Subject: [PATCH 040/102] fix: fixed double /, which prevented route access to
 tasks and scripts

---
 server/src/server_routes/scripts.ts |  4 +--
 server/src/server_routes/tasks.ts   | 39 ++++++++++++++++-------------
 2 files changed, 23 insertions(+), 20 deletions(-)

diff --git a/server/src/server_routes/scripts.ts b/server/src/server_routes/scripts.ts
index 4de29b4f..7f128a7b 100644
--- a/server/src/server_routes/scripts.ts
+++ b/server/src/server_routes/scripts.ts
@@ -10,7 +10,7 @@ export function setupScriptRoutes(app: Express, scripts: any) {
   });
 
   // GET /api/scripts/:id - Get one script by ID
-  app.get(scripturl+'/:id', (req: Request, res: Response) => {
+  app.get(scripturl+':id', (req: Request, res: Response) => {
     const { id } = req.params;
     const script = scripts.findById(id);
     if (!script) {
@@ -30,7 +30,7 @@ export function setupScriptRoutes(app: Express, scripts: any) {
   });
 
   // PUT /api/scripts/:id - Update a script
-  app.put(scripturl+'/:id', (req: Request, res: Response) => {
+  app.put(scripturl+':id', (req: Request, res: Response) => {
     const { id } = req.params;
     const script = scripts.updateScript(id, req.body);
 
diff --git a/server/src/server_routes/tasks.ts b/server/src/server_routes/tasks.ts
index 8429b931..9fe6a30e 100644
--- a/server/src/server_routes/tasks.ts
+++ b/server/src/server_routes/tasks.ts
@@ -7,22 +7,8 @@ import { Request, Response, Express } from 'express';
 export function setupTaskRoutes(app: Express, taskset: any) {
   const taskurl = '/api/tasks/';
 
-  // POST /api/tasks => create new task
-  app.post(taskurl+'', (req: Request, res: Response) =>{
-    const task = taskset.addTask(req.body);
-    res.status(201).json(task);
-  });
-
-  // GET /api/tasks/:id => get task by id
-  app.get(taskurl+'/:id', (req: Request, res: Response) => {
-    const { id } = req.params;
-    const task = taskset.findById(id);
-    if (!task) {
-      return res.status(404).json({ error: 'Task not found' });
-    }
-    res.json(task.toJSON());
-  });
-
+  
+  
   // GET /api/tasks - Get all tasks
   app.get(taskurl+'', (req: Request, res: Response) => {
     try {
@@ -33,12 +19,29 @@ export function setupTaskRoutes(app: Express, taskset: any) {
     }
   });
 
+
+  // GET /api/tasks/:id => get task by id
+  app.get(taskurl+':id', (req: Request, res: Response) => {
+    const { id } = req.params;
+    const task = taskset.findById(id);
+    if (!task) {
+      return res.status(404).json({ error: 'Task not found' });
+    }
+    res.json(task.toJSON());
+  });
+  
   // PUT /api/tasks/:id => update task
-  app.put(taskurl+'/:id', (req: Request, res: Response) => {
+  app.put(taskurl+':id', (req: Request, res: Response) => {
     const { id } = req.params;
     const task = taskset.updateTask(id, req.body);
-
+    
     if (!task) return res.status(404).json({ error: 'Task not found' });
     res.json(task.toJSON());
   });
+  
+  // POST /api/tasks => create new task
+  app.post(taskurl+'', (req: Request, res: Response) =>{
+    const task = taskset.addTask(req.body);
+    res.status(201).json(task);
+  });
 }
\ No newline at end of file

From 70c9522a3edb4e9b06d3b414fa6f881157638b8d Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Mon, 8 Dec 2025 17:16:54 -0300
Subject: [PATCH 041/102] integration: update scriptanswer service and
 scriptanswer type to better reflect backend

---
 client/src/services/ScriptAnswerService.ts | 87 ++++++++--------------
 client/src/types/ScriptAnswer.ts           |  6 +-
 2 files changed, 36 insertions(+), 57 deletions(-)

diff --git a/client/src/services/ScriptAnswerService.ts b/client/src/services/ScriptAnswerService.ts
index 067294e2..0aeb013e 100644
--- a/client/src/services/ScriptAnswerService.ts
+++ b/client/src/services/ScriptAnswerService.ts
@@ -9,66 +9,63 @@ import { Grade } from "../types/EspecificacaoDoCalculoDaMedia";
 
 const API_URL = "http://localhost:3005/api";
 
-// ----------------------------------------
-// ScriptAnswerService – UPDATED TO MATCH NEW ROUTES
-// ----------------------------------------
-
 export const ScriptAnswerService = {
   /** Fetch ALL ScriptAnswers */
   async getAllScriptAnswers(): Promise<ScriptAnswer[]> {
-    const res = await fetch(`${API_URL}/scripts/answers`);
+    const res = await fetch(`${API_URL}/scriptanswers/`);
     if (!res.ok) throw new Error("Failed to fetch scriptAnswers");
     return res.json();
   },
 
   /** Fetch ScriptAnswers for a specific student */
   async getScriptAnswersByStudentId(studentId: string): Promise<ScriptAnswer[]> {
-    const res = await fetch(`${API_URL}/scripts/answers/student/${studentId}`);
+    const res = await fetch(`${API_URL}/scriptanswers/student/${studentId}`);
     if (!res.ok) throw new Error("Failed to fetch scriptAnswers by student");
     return res.json();
   },
 
-  /** Create (or save) a ScriptAnswer */
-  async saveScriptAnswer(scriptAnswer: ScriptAnswer): Promise<ScriptAnswer> {
-    const res = await fetch(`${API_URL}/scripts/answers`, {
+  /** Fetch ScriptAnswers for a specific script */
+  async getScriptAnswersByScriptId(scriptId: string): Promise<ScriptAnswer[]> {
+    const res = await fetch(`${API_URL}/scriptanswers/script/${scriptId}`);
+    if (!res.ok) throw new Error("Failed to fetch scriptAnswers by script");
+    return res.json();
+  },
+
+  /** Fetch a single ScriptAnswer by ID */
+  async getScriptAnswerById(scriptAnswerId: string): Promise<ScriptAnswer> {
+    const res = await fetch(`${API_URL}/scriptanswers/${scriptAnswerId}`);
+    if (!res.ok) throw new Error("Failed to fetch ScriptAnswer");
+    return res.json();
+  },
+
+  /** Create a new ScriptAnswer */
+  async createScriptAnswer(scriptAnswer: Omit<ScriptAnswer, 'id'>): Promise<ScriptAnswer> {
+    const res = await fetch(`${API_URL}/scriptanswers/`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify(scriptAnswer)
     });
 
-    if (!res.ok) throw new Error("Failed to save ScriptAnswer");
+    if (!res.ok) throw new Error("Failed to create ScriptAnswer");
     return res.json();
   },
 
-  /** Update only the GRADE of a ScriptAnswer */
-  async updateScriptAnswerGrade(
-    req: UpdateSriptAnswerGradeRequest
-  ): Promise<ScriptAnswer> {
+  /** Update the grade of a TaskAnswer inside a ScriptAnswer */
+  async updateTaskAnswerGrade(
+    scriptAnswerId: string,
+    taskId: string,
+    grade: Grade
+  ): Promise<{ taskId: string; grade: Grade }> {
     const res = await fetch(
-      `${API_URL}/scripts/answers/${req.scriptAnswerId}/grade`,
+      `${API_URL}/scriptanswers/${scriptAnswerId}/tasks/${taskId}`,
       {
         method: "PUT",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ grade: req.grade })
+        body: JSON.stringify({ grade })
       }
     );
 
-    if (!res.ok) throw new Error("Failed to update ScriptAnswer grade");
-    return res.json();
-  },
-
-  /** Update one TaskAnswer: grade and/or comments */
-  async updateTaskAnswer(req: updateTaskAnswerGradeRequest): Promise<any> {
-    const res = await fetch(`${API_URL}/taskAnswers/${req.TaskAnswerId}`, {
-      method: "PUT",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        grade: req.grade,
-        comments: req.comments
-      })
-    });
-
-    if (!res.ok) throw new Error("Failed to update TaskAnswer");
+    if (!res.ok) throw new Error("Failed to update task grade");
     return res.json();
   },
 
@@ -78,7 +75,7 @@ export const ScriptAnswerService = {
     taskId: string
   ): Promise<Grade | undefined> {
     const res = await fetch(
-      `${API_URL}/scripts/answers/${scriptAnswerId}/tasks/${taskId}`
+      `${API_URL}/scriptanswers/${scriptAnswerId}/tasks/${taskId}`
     );
 
     if (res.status === 404) return undefined;
@@ -88,32 +85,14 @@ export const ScriptAnswerService = {
     return data.grade;
   },
 
-  /** Add comment to a ScriptAnswer */
-  async updateScriptAnswerComment(
-    scriptAnswerId: string,
-    comment: string
-  ): Promise<any> {
-    const res = await fetch(
-      `${API_URL}/scripts/answers/${scriptAnswerId}/comments`,
-      {
-        method: "PUT",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ comment })
-      }
-    );
-
-    if (!res.ok) throw new Error("Failed to update comment");
-    return res.json();
-  },
-
-  /** Add comment to a TaskAnswer inside a ScriptAnswer */
+  /** Add or update comment on a TaskAnswer inside a ScriptAnswer */
   async updateTaskAnswerComment(
     scriptAnswerId: string,
     taskId: string,
     comment: string
-  ): Promise<any> {
+  ): Promise<{ taskId: string; comment: string }> {
     const res = await fetch(
-      `${API_URL}/scripts/answers/${scriptAnswerId}/tasks/${taskId}/comments`,
+      `${API_URL}/scriptanswers/${scriptAnswerId}/tasks/${taskId}/comments`,
       {
         method: "PUT",
         headers: { "Content-Type": "application/json" },
diff --git a/client/src/types/ScriptAnswer.ts b/client/src/types/ScriptAnswer.ts
index db79a2c9..67410bef 100644
--- a/client/src/types/ScriptAnswer.ts
+++ b/client/src/types/ScriptAnswer.ts
@@ -2,7 +2,7 @@ import {Grade} from './EspecificacaoDoCalculoDaMedia';
 
 export interface TaskAnswer {
     id: string;
-    taskId: string;
+    task: string;
     answer: string;
     grade?: Grade;
     comments?: string;
@@ -11,8 +11,8 @@ export interface TaskAnswer {
 export interface ScriptAnswer {
     id: string;
     scriptId: string;
-    studentId: string;
-    taskAnswers: TaskAnswer[];
+    student: string;
+    answers: TaskAnswer[];
     grade?: Grade;
 }
 

From 4ed3788a231cde3a853a64707b11d98dd87e01c1 Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Mon, 8 Dec 2025 17:17:25 -0300
Subject: [PATCH 042/102] fix: now script titles and task statements are shown
 correctly on screen

---
 .../ScriptGrading/ScriptAnswerGrid.tsx        |  35 +++++-
 .../ScriptGrading/ScriptGrading.tsx           |  49 +++++---
 .../ScriptGrading/TaskAnswerEditor.tsx        | 116 +++++++++++++-----
 3 files changed, 152 insertions(+), 48 deletions(-)

diff --git a/client/src/components/ScriptGrading/ScriptAnswerGrid.tsx b/client/src/components/ScriptGrading/ScriptAnswerGrid.tsx
index d8d1a5db..4ef09ae0 100644
--- a/client/src/components/ScriptGrading/ScriptAnswerGrid.tsx
+++ b/client/src/components/ScriptGrading/ScriptAnswerGrid.tsx
@@ -1,6 +1,7 @@
 // components/ScriptAnswerGrid.tsx
-import React from "react";
+import React, { useEffect, useState } from "react";
 import { ScriptAnswer } from "../../types/ScriptAnswer";
+import ScriptService from "../../services/ScriptService";
 
 interface Props {
   scriptAnswers: ScriptAnswer[];
@@ -8,6 +9,33 @@ interface Props {
 }
 
 export default function ScriptAnswerGrid({ scriptAnswers, onSelect }: Props) {
+  const [scriptTitles, setScriptTitles] = useState<Record<string, string>>({});
+  const [loading, setLoading] = useState(false);
+
+  useEffect(() => {
+    const loadScriptTitles = async () => {
+      setLoading(true);
+      const titles: Record<string, string> = {};
+
+      for (const sa of scriptAnswers) {
+        try {
+          const script = await ScriptService.getScriptById(sa.scriptId);
+          titles[sa.scriptId] = script.title || sa.scriptId;
+        } catch (error) {
+          console.error(`Failed to load script ${sa.scriptId}:`, error);
+          titles[sa.scriptId] = sa.scriptId; // Fallback to ID if fetch fails
+        }
+      }
+
+      setScriptTitles(titles);
+      setLoading(false);
+    };
+
+    if (scriptAnswers.length > 0) {
+      loadScriptTitles();
+    }
+  }, [scriptAnswers]);
+
   return (
     <div style={{
       display: "grid",
@@ -23,10 +51,11 @@ export default function ScriptAnswerGrid({ scriptAnswers, onSelect }: Props) {
             border: "1px solid #ccc",
             borderRadius: "8px",
             cursor: "pointer",
+            opacity: loading ? 0.6 : 1,
           }}
         >
-          <strong>Script: {sa.scriptId}</strong><br />
-          Student: {sa.studentId}<br />
+          <strong>Script: {loading ? "Loading..." : scriptTitles[sa.scriptId] || sa.scriptId}</strong><br />
+          Student: {sa.student}<br />
           Grade: {sa.grade ?? "—"}
         </div>
       ))}
diff --git a/client/src/components/ScriptGrading/ScriptGrading.tsx b/client/src/components/ScriptGrading/ScriptGrading.tsx
index 010ae7b0..10d3e975 100644
--- a/client/src/components/ScriptGrading/ScriptGrading.tsx
+++ b/client/src/components/ScriptGrading/ScriptGrading.tsx
@@ -11,30 +11,51 @@ interface Props {
 
 export default function ScriptGrading({ scriptAnswer, onClose }: Props) {
   const [current, setCurrent] = useState<ScriptAnswer>(scriptAnswer);
+  const [loading, setLoading] = useState(false);
 
-  const handleUpdateTask = (updated: TaskAnswer) => {
-    ScriptAnswerService.updateTaskAnswer({
-      TaskAnswerId: updated.id,
-      grade: updated.grade,
-      comments: updated.comments
-    });
+  const handleUpdateTask = async (updated: TaskAnswer) => {
+    try {
+      setLoading(true);
 
-    // Reload updated script answer
-    const refreshed = async () =>{
-      const list = await ScriptAnswerService.getAllScriptAnswers(); // <-- Await
-      const refreshed = list.find(sa => sa.id === current.id);      // Now OK
+      // Update grade if changed
+      if (updated.grade) {
+        await ScriptAnswerService.updateTaskAnswerGrade(
+          current.id,
+          updated.task,
+          updated.grade
+        );
+      }
 
-      if (refreshed) setCurrent(refreshed);
+      // Update comments if present
+      if (updated.comments) {
+        await ScriptAnswerService.updateTaskAnswerComment(
+          current.id,
+          updated.task,
+          updated.comments
+        );
+      }
+
+      // Reload updated script answer
+      const refreshed = await ScriptAnswerService.getScriptAnswerById(current.id);
+      if (refreshed) {
+        setCurrent(refreshed);
+      }
+    } catch (error) {
+      console.error("Failed to update task answer:", error);
+    } finally {
+      setLoading(false);
     }
   };
 
   return (
     <div>
-      <button onClick={onClose}>← Back</button>
+      <button onClick={onClose} disabled={loading}>
+        ← Back
+      </button>
       <h2>Grading Script {current.scriptId}</h2>
-      <h3>Student {current.studentId}</h3>
+      <h3>Student {current.student}</h3>
 
-      {current.taskAnswers.map(task => (
+      {current.answers.map(task => (
         <TaskAnswerEditor
           key={task.id}
           taskAnswer={task}
diff --git a/client/src/components/ScriptGrading/TaskAnswerEditor.tsx b/client/src/components/ScriptGrading/TaskAnswerEditor.tsx
index 9501d809..3040176a 100644
--- a/client/src/components/ScriptGrading/TaskAnswerEditor.tsx
+++ b/client/src/components/ScriptGrading/TaskAnswerEditor.tsx
@@ -8,16 +8,44 @@ import { Task } from "../../types/Task";
 interface Props {
   taskAnswer: TaskAnswer;
   onChange: (updated: TaskAnswer) => void;
+  disabled?: boolean;
 }
 
 const gradeOptions: Grade[] = ["MA", "MANA", "MPA"];
 
-export default function TaskAnswerEditor({ taskAnswer, onChange }: Props) {
+export default function TaskAnswerEditor({ taskAnswer, onChange, disabled = false }: Props) {
   const [task, setTask] = useState<Task | null>(null);
   const [loading, setLoading] = useState(true);
+  const [localGrade, setLocalGrade] = useState<Grade | undefined>(taskAnswer.grade);
+  const [localComments, setLocalComments] = useState(taskAnswer.comments ?? "");
+  const [saving, setSaving] = useState(false);
+  const [hasChanges, setHasChanges] = useState(false);
 
-  const update = (changes: Partial<TaskAnswer>) => {
-    onChange({ ...taskAnswer, ...changes });
+  const handleGradeChange = (grade: Grade | undefined) => {
+    setLocalGrade(grade);
+    setHasChanges(true);
+  };
+
+  const handleCommentsChange = (comments: string) => {
+    setLocalComments(comments);
+    setHasChanges(true);
+  };
+
+  const handleSave = async () => {
+    setSaving(true);
+    try {
+      const updated: TaskAnswer = {
+        ...taskAnswer,
+        grade: localGrade,
+        comments: localComments
+      };
+      onChange(updated);
+      setHasChanges(false);
+    } catch (err) {
+      console.error("Failed to save changes:", err);
+    } finally {
+      setSaving(false);
+    }
   };
 
   // 🔥 Load task details from backend
@@ -27,7 +55,7 @@ export default function TaskAnswerEditor({ taskAnswer, onChange }: Props) {
     async function load() {
       setLoading(true);
       try {
-        const t = await TaskService.getTaskById(taskAnswer.taskId);
+        const t = await TaskService.getTaskById(taskAnswer.task);
         if (!cancelled) setTask(t);
       } catch (err) {
         console.error("Failed to load task:", err);
@@ -41,7 +69,7 @@ export default function TaskAnswerEditor({ taskAnswer, onChange }: Props) {
     return () => {
       cancelled = true;
     };
-  }, [taskAnswer.taskId]);
+  }, [taskAnswer.task]);
 
   return (
     <div
@@ -50,49 +78,75 @@ export default function TaskAnswerEditor({ taskAnswer, onChange }: Props) {
         padding: "12px",
         marginBottom: "12px",
         borderRadius: "6px",
+        opacity: disabled ? 0.6 : 1,
+        pointerEvents: disabled ? "none" : "auto"
       }}
     >
-      {/* 🔥 Replace old line */}
+      {/* Task statement */}
       <strong>
         Task:{" "}
         {loading
           ? "Loading task..."
           : task
-          ? task.statement // <–– SHOW THE TASK STATEMENT HERE
-          : `Unknown task ${taskAnswer.taskId}`}
+          ? task.statement
+          : `Unknown task ${taskAnswer.task}`}
       </strong>
 
-
-      {/* 🔽 User answer */}
+      {/* User answer */}
       <div style={{ marginTop: 8 }}>
         <strong>Answer:</strong> {taskAnswer.answer}
       </div>
 
-      {/* 🔽 Grade selector */}
+      {/* Grade selector */}
       <div style={{ marginTop: 8 }}>
-        Grade:
-        <select
-          value={taskAnswer.grade ?? ""}
-          onChange={(e) => update({ grade: e.target.value as Grade })}
-        >
-          <option value="">—</option>
-          {gradeOptions.map((g) => (
-            <option key={g} value={g}>
-              {g}
-            </option>
-          ))}
-        </select>
+        <label>
+          Grade:
+          <select
+            value={localGrade ?? ""}
+            onChange={(e) => handleGradeChange(e.target.value as Grade | undefined)}
+            disabled={saving}
+          >
+            <option value="">—</option>
+            {gradeOptions.map((g) => (
+              <option key={g} value={g}>
+                {g}
+              </option>
+            ))}
+          </select>
+        </label>
       </div>
 
-      {/* 🔽 Comments */}
+      {/* Comments */}
       <div style={{ marginTop: 8 }}>
-        Comments:
-        <textarea
-          value={taskAnswer.comments ?? ""}
-          onChange={(e) => update({ comments: e.target.value })}
-          rows={3}
-          style={{ width: "100%" }}
-        />
+        <label>
+          Comments:
+          <textarea
+            value={localComments}
+            onChange={(e) => handleCommentsChange(e.target.value)}
+            rows={3}
+            disabled={saving}
+            style={{ width: "100%" }}
+          />
+        </label>
+      </div>
+
+      {/* Save button */}
+      <div style={{ marginTop: 12 }}>
+        <button
+          onClick={handleSave}
+          disabled={!hasChanges || saving || disabled}
+          style={{
+            padding: "8px 16px",
+            backgroundColor: hasChanges ? "#007bff" : "#ccc",
+            color: "white",
+            border: "none",
+            borderRadius: "4px",
+            cursor: hasChanges && !saving ? "pointer" : "not-allowed",
+            opacity: hasChanges && !saving ? 1 : 0.6
+          }}
+        >
+          {saving ? "Saving..." : "Save Changes"}
+        </button>
       </div>
     </div>
   );

From 851e6dcd471c242544dff84ce3a196cd1ff2e152 Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Mon, 8 Dec 2025 18:22:35 -0300
Subject: [PATCH 043/102] feat: scriptremoval routes implemented with DELETE
 keyoword

---
 server/src/__tests__/ScriptAnswerSet.test.ts | 52 ++++++++++++++++-
 server/src/__tests__/scriptgrading.test.ts   | 59 ++++++++++++++++++++
 server/src/models/ScriptAnswerSet.ts         |  7 ++-
 server/src/server_routes/scriptanswer.ts     | 22 ++++++++
 4 files changed, 137 insertions(+), 3 deletions(-)

diff --git a/server/src/__tests__/ScriptAnswerSet.test.ts b/server/src/__tests__/ScriptAnswerSet.test.ts
index b3a9fb17..d01750c8 100644
--- a/server/src/__tests__/ScriptAnswerSet.test.ts
+++ b/server/src/__tests__/ScriptAnswerSet.test.ts
@@ -69,6 +69,56 @@ describe('ScriptAnswerSet', () => {
     });
   });
 
+  // -----------------------------------------
+  // removeAllScriptAnswers
+  // -----------------------------------------
+  describe('removeAllScriptAnswers', () => {
+    test('should remove all script answers and return the count', () => {
+      set.addScriptAnswer({ id: 'A1', scriptId: 'S1', studentId: 'ST1' });
+      set.addScriptAnswer({ id: 'A2', scriptId: 'S2', studentId: 'ST2' });
+      set.addScriptAnswer({ id: 'A3', scriptId: 'S3', studentId: 'ST3' });
+      expect(set.getAll().length).toBe(3);
+
+      const count = set.removeAllScriptAnswers();
+
+      expect(count).toBe(3);
+      expect(set.getAll().length).toBe(0);
+    });
+
+    test('should return 0 when there are no answers to remove', () => {
+      expect(set.getAll().length).toBe(0);
+
+      const count = set.removeAllScriptAnswers();
+
+      expect(count).toBe(0);
+      expect(set.getAll().length).toBe(0);
+    });
+
+    test('should clear all answers regardless of their properties', () => {
+      set.addScriptAnswer({ 
+        id: 'A1', 
+        scriptId: 'S1', 
+        studentId: 'ST1', 
+        grade: 'MA',
+        taskAnswers: [
+          { id: 'TA1', task: 'T1', grade: 'MPA', comments: 'comment' }
+        ]
+      });
+      set.addScriptAnswer({ 
+        id: 'A2', 
+        scriptId: 'S2', 
+        studentId: 'ST2', 
+        grade: 'MANA'
+      });
+      expect(set.getAll().length).toBe(2);
+
+      const count = set.removeAllScriptAnswers();
+
+      expect(count).toBe(2);
+      expect(set.getAll()).toEqual([]);
+    });
+  });
+
   // -----------------------------------------
   // getAll
   // -----------------------------------------
@@ -197,8 +247,6 @@ describe('ScriptAnswerSet', () => {
 
       const results = set.findbyScriptId('S1');
 
-  
-
       expect(results.length).toBe(2);
       expect(results.map(a => a.getId())).toEqual(['A1', 'A2']);
     });
diff --git a/server/src/__tests__/scriptgrading.test.ts b/server/src/__tests__/scriptgrading.test.ts
index ec4f4472..8d6da633 100644
--- a/server/src/__tests__/scriptgrading.test.ts
+++ b/server/src/__tests__/scriptgrading.test.ts
@@ -232,4 +232,63 @@ describe('Server API – Script Answers Endpoints', () => {
     expect(res.body.taskId).toBe('t4');
     expect(res.body.comment).toBe('Good work!');
   });
+
+  // ----------------------------------------------------------
+  // 14) Deletar resposta existente
+  // ----------------------------------------------------------
+
+  test('DELETE /api/scriptanswers/:id → deletes existing script answer', async () => {
+    scriptAnswerSet.addScriptAnswer({ id: '130', scriptId: '1', studentId: 'S1' });
+    expect(scriptAnswerSet.getAll().length).toBe(1);
+
+    const res = await request(app).delete('/api/scriptanswers/130');
+
+    expect(res.status).toBe(200);
+    expect(res.body.message).toBe('ScriptAnswer deleted successfully');
+    expect(res.body.id).toBe('130');
+    expect(scriptAnswerSet.getAll().length).toBe(0);
+  });
+
+  // ----------------------------------------------------------
+  // 15) Tentar deletar resposta inexistente
+  // ----------------------------------------------------------
+
+  test('DELETE /api/scriptanswers/:id → returns 404 when deleting nonexistent answer', async () => {
+    const res = await request(app).delete('/api/scriptanswers/nonexistent');
+
+    expect(res.status).toBe(404);
+    expect(res.body.error).toBe('ScriptAnswer not found');
+  });
+
+  // ----------------------------------------------------------
+  // 16) Deletar todas as respostas
+  // ----------------------------------------------------------
+
+  test('DELETE /api/scriptanswers → deletes all script answers', async () => {
+    scriptAnswerSet.addScriptAnswer({ id: '140', scriptId: '1', studentId: 'S1' });
+    scriptAnswerSet.addScriptAnswer({ id: '141', scriptId: '2', studentId: 'S2' });
+    scriptAnswerSet.addScriptAnswer({ id: '142', scriptId: '3', studentId: 'S3' });
+    expect(scriptAnswerSet.getAll().length).toBe(3);
+
+    const res = await request(app).delete('/api/scriptanswers/');
+
+    expect(res.status).toBe(200);
+    expect(res.body.message).toBe('All script answers deleted');
+    expect(res.body.count).toBe(3);
+    expect(scriptAnswerSet.getAll().length).toBe(0);
+  });
+
+  // ----------------------------------------------------------
+  // 17) Deletar todas as respostas quando não há nenhuma
+  // ----------------------------------------------------------
+
+  test('DELETE /api/scriptanswers → returns 200 even when no answers exist', async () => {
+    expect(scriptAnswerSet.getAll().length).toBe(0);
+
+    const res = await request(app).delete('/api/scriptanswers/');
+
+    expect(res.status).toBe(200);
+    expect(res.body.message).toBe('All script answers deleted');
+    expect(res.body.count).toBe(0);
+  });
 });
diff --git a/server/src/models/ScriptAnswerSet.ts b/server/src/models/ScriptAnswerSet.ts
index 9728cb1f..83633c48 100644
--- a/server/src/models/ScriptAnswerSet.ts
+++ b/server/src/models/ScriptAnswerSet.ts
@@ -25,7 +25,12 @@ export class ScriptAnswerSet {
     }
     return false;
   }
-  
+
+  removeAllScriptAnswers() {
+    const count = this.scriptAnswers.length;
+    this.scriptAnswers = [];
+    return count;
+  }
 
   getAll() {
     return this.scriptAnswers.slice()
diff --git a/server/src/server_routes/scriptanswer.ts b/server/src/server_routes/scriptanswer.ts
index 66c74d53..8d64238f 100644
--- a/server/src/server_routes/scriptanswer.ts
+++ b/server/src/server_routes/scriptanswer.ts
@@ -115,4 +115,26 @@ export function setupScriptAnswerRoutes(app: Express, scriptAnswerSet: any, stud
 
     return res.status(200).json({ taskId, comment });
   });
+
+  // DELETE /api/scriptanswers/:id → Delete a script answer by ID
+  app.delete(scriptAnswerurl+':id', (req: Request, res: Response) => {
+    const { id } = req.params;
+
+    const removed = scriptAnswerSet.removeScriptAnswer(id);
+    if (!removed) {
+      return res.status(404).json({ error: 'ScriptAnswer not found' });
+    }
+
+    return res.status(200).json({ message: 'ScriptAnswer deleted successfully', id });
+  });
+
+  // DELETE /api/scriptanswers → Delete all script answers
+  app.delete(scriptAnswerurl+'', (req: Request, res: Response) => {
+    try {
+      const count = scriptAnswerSet.removeAllScriptAnswers();
+      return res.status(200).json({ message: 'All script answers deleted', count });
+    } catch (error) {
+      return res.status(500).json({ error: 'Failed to delete all script answers' });
+    }
+  });
 }
\ No newline at end of file

From 15507ae961ca1f4038afc7433472b82c508e6cb6 Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Mon, 8 Dec 2025 18:23:43 -0300
Subject: [PATCH 044/102] testing: server acceptance test for getall
 scriptanswers scenarios

---
 .../server-scriptAnswer-steps.ts              | 308 +++++-------------
 1 file changed, 80 insertions(+), 228 deletions(-)

diff --git a/client/src/step-definitions/server-scriptAnswer-steps.ts b/client/src/step-definitions/server-scriptAnswer-steps.ts
index a2c3af79..38a91617 100644
--- a/client/src/step-definitions/server-scriptAnswer-steps.ts
+++ b/client/src/step-definitions/server-scriptAnswer-steps.ts
@@ -1,268 +1,120 @@
-import { Given, When, Then, Before, After, DataTable, setDefaultTimeout } from '@cucumber/cucumber';
-import { Browser, Page, launch } from 'puppeteer';
+import { Given, When, Then, After, setDefaultTimeout } from '@cucumber/cucumber';
 import expect from 'expect';
 
 // Set default timeout for all steps
 setDefaultTimeout(30 * 1000); // 30 seconds
 
-// Helper function to format CPF like the frontend does
-function formatCPF(value: string): string {
-  const digits = value.replace(/\D/g, '');
-  if (digits.length <= 11) {
-    return digits.replace(/(\d{3})(\d{3})(\d{3})(\d{2})/, '$1.$2.$3-$4');
-  }
-  return digits.slice(0, 11).replace(/(\d{3})(\d{3})(\d{3})(\d{2})/, '$1.$2.$3-$4');
-}
-
-let browser: Browser;
-let page: Page;
-const baseUrl = 'http://localhost:3004';
 const serverUrl = 'http://localhost:3005';
 
 // Test data to clean up
-let testStudentCPF: string;
+let lastResponse: Response;
+let createdScriptAnswerIds: string[] = [];
 
-Before({ tags: '@gui' }, async function () {
-  browser = await launch({ 
-    headless: false, // Set to true for CI/CD
-    slowMo: 50 // Slow down actions for visibility
-  });
-  page = await browser.newPage();
-  await page.setViewport({ width: 1280, height: 720 });
+After({ tags: '@server' }, async function () {
+  // Clean up created script answers if needed
+  if (createdScriptAnswerIds.length > 0) {
+    for (const id of createdScriptAnswerIds) {
+      try {
+        await fetch(`${serverUrl}/api/scriptanswers/${id}`, {
+          method: 'DELETE'
+        });
+        console.log(`Server cleanup: Removed test script answer with ID: ${id}`);
+      } catch (error) {
+        console.log(`Server cleanup: Could not remove script answer ${id}`);
+      }
+    }
+    createdScriptAnswerIds = [];
+  }
 });
 
-After({ tags: '@gui' }, async function () {
-  // Clean up test student if it exists by using the GUI delete function
-  if (testStudentCPF) {
+
+// ============================================================
+// Retrieval of all script answers
+// ============================================================
+
+Given('there are script answers registered with IDs {string}, {string}, {string}', async function (string1, string2, string3) {
+  // Parse the comma-separated IDs from the string
+  const ids = [string1, string2, string3].map(id => id.replace(/"/g, ''));
+  
+  // Create script answers with the given IDs
+  for (const id of ids) {
     try {
-      // Navigate to Students area
-      await page.goto(baseUrl);
-      await page.waitForSelector('.students-list table', { timeout: 5000 });
+      const response = await fetch(`${serverUrl}/api/scriptanswers/`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          id: id,
+          scriptId: `script-${id}`,
+          studentId: '11111111111',
+          answers: []
+        })
+      });
       
-      // Look for our test student in the table and delete it if found
-      const studentRows = await page.$$('[data-testid^="student-row-"]');
-      for (const row of studentRows) {
-        const cpfCell = await row.$('[data-testid="student-cpf"]');
-        if (cpfCell) {
-          const cpf = await page.evaluate(el => el.textContent, cpfCell);
-          // Check for both plain and formatted CPF
-          if (cpf === testStudentCPF || cpf === formatCPF(testStudentCPF)) {
-            // Set up dialog handler before clicking delete
-            page.once('dialog', async (dialog) => {
-              console.log(`GUI cleanup: Confirming deletion dialog: ${dialog.message()}`);
-              await dialog.accept(); // Confirm deletion
-            });
-            
-            // Click the delete button for this student
-            const deleteButton = await row.$(`[data-testid="delete-student-${cpf}"]`);
-            if (deleteButton) {
-              await deleteButton.click();
-              // Wait for deletion to complete
-              await new Promise(resolve => setTimeout(resolve, 1000));
-              console.log(`GUI cleanup: Removed test student with CPF: ${cpf}`);
-              break;
-            }
-          }
-        }
+      if (response.status === 201) {
+        createdScriptAnswerIds.push(id);
+        console.log(`Server setup: Created script answer with ID: ${id}`);
+      } else {
+        console.error(`Failed to create script answer ${id}: Status ${response.status}`);
       }
     } catch (error) {
-      console.log('GUI cleanup: Student may not exist or GUI unavailable');
+      console.error(`Failed to create script answer ${id}:`, error);
     }
   }
-  
-  if (browser) {
-    await browser.close();
-  }
 });
 
-Given('the student management system is running', async function () {
-  await page.goto(baseUrl);
-  await page.waitForSelector('h1', { timeout: 10000 });
-  const title = await page.$eval('h1', el => el.textContent);
-  expect(title || '').toContain('Teaching Assistant React');
-});
-
-Given('the server is available', async function () {
+Given('there are no script answers registered', async function () {
+  // Fetch all script answers and delete them
   try {
-    const response = await fetch(`${serverUrl}/api/students`);
-    expect(response.status).toBe(200);
-  } catch (error) {
-    throw new Error('Server is not available. Make sure the backend server is running on port 3005');
-  }
-});
-
-Given('there is no student with CPF {string} in the system', async function (cpf: string) {
-  testStudentCPF = cpf;
-  const formattedCPF = formatCPF(cpf);
-  
-  // Navigate to the application and check if student exists through GUI
-  await page.goto(baseUrl);
-  await page.waitForSelector('.students-list', { timeout: 10000 });
-  
-  // Try to find and delete the student if it exists (cleanup before test)
-  const studentRows = await page.$$('[data-testid^="student-row-"]');
-  for (const row of studentRows) {
-    const cpfCell = await row.$('[data-testid="student-cpf"]');
-    if (cpfCell) {
-      const displayedCPF = await page.evaluate(el => el.textContent, cpfCell);
-      // Check for both plain and formatted CPF
-      if (displayedCPF === cpf || displayedCPF === formattedCPF) {
-        // Student exists, delete it for clean test state
-        // Set up dialog handler before clicking delete
-        page.once('dialog', async (dialog) => {
-          console.log(`GUI cleanup: Confirming deletion dialog: ${dialog.message()}`);
-          await dialog.accept(); // Confirm deletion
+    const response = await fetch(`${serverUrl}/api/scriptanswers/`);
+    if (response.status === 200) {
+      const answers = await response.json();
+      
+      for (const answer of answers) {
+        await fetch(`${serverUrl}/api/scriptanswers/${answer.id}`, {
+          method: 'DELETE'
         });
-        
-        const deleteButton = await row.$(`[data-testid="delete-student-${displayedCPF}"]`);
-        if (deleteButton) {
-          await deleteButton.click();
-          // Wait for deletion to complete
-          await new Promise(resolve => setTimeout(resolve, 1000));
-          console.log(`GUI cleanup: Removed existing student with CPF: ${displayedCPF}`);
-          break;
-        }
-      }
-    }
-  }
-  
-  // Verify student doesn't exist by checking the GUI
-  await page.reload(); // Refresh to ensure clean state
-  await page.waitForSelector('.students-list', { timeout: 5000 });
-  
-  const updatedRows = await page.$$('[data-testid^="student-row-"]');
-  for (const row of updatedRows) {
-    const cpfCell = await row.$('[data-testid="student-cpf"]');
-    if (cpfCell) {
-      const displayedCPF = await page.evaluate(el => el.textContent, cpfCell);
-      if (displayedCPF === cpf || displayedCPF === formattedCPF) {
-        throw new Error(`Student with CPF ${displayedCPF} still exists in the system after cleanup`);
+        console.log(`Server setup: Removed existing script answer with ID: ${answer.id}`);
       }
     }
+  } catch (error) {
+    console.log('Server setup: Could not clean up existing script answers');
   }
 });
 
-When('I navigate to the Students area', async function () {
-  // Click on the Students tab
-  const studentsTab = await page.$('[data-testid="students-tab"]');
-  if (studentsTab) {
-    const isActive = await page.evaluate(el => el?.classList.contains('active'), studentsTab);
-    
-    if (!isActive) {
-      await studentsTab.click();
-    }
+When('I send a GET request to {string}', async function (endpoint: string) {
+  try {
+    lastResponse = await fetch(`${serverUrl}${endpoint}`);
+    console.log(`Server test: GET request to ${endpoint} returned status ${lastResponse.status}`);
+  } catch (error) {
+    throw new Error(`Failed to send GET request to ${endpoint}: ${error}`);
   }
-  
-  // Wait for the student form to be visible
-  await page.waitForSelector('[data-testid="student-form"]', { timeout: 5000 });
 });
 
-When('I provide the student information:', async function (dataTable: DataTable) {
-  const data = dataTable.rowsHash();
-  
-  // Fill in the name field using semantic ID
-  await page.waitForSelector('#name');
-  await page.click('#name');
-  await page.type('#name', data.name);
-  
-  // Fill in the CPF field using semantic ID
-  await page.click('#cpf');
-  await page.type('#cpf', data.cpf);
-  
-  // Fill in the email field using semantic ID
-  await page.click('#email');
-  await page.type('#email', data.email);
+Then('the server should return {int} OK', async function (statusCode: number) {
+  expect(lastResponse.status).toBe(statusCode);
+  console.log(`Server test: Confirmed response status is ${statusCode}`);
 });
 
-When('I send the student information', async function () {
-  // Click the submit button using semantic test ID
-  const submitButton = await page.$('[data-testid="submit-student-button"]');
-  expect(submitButton).toBeTruthy();
-  
-  await submitButton?.click();
+Then('the server should return a list containing answers {string}, {string}, {string}', async function (string1: string, string2: string, string3: string) {
+  const expectedIds = [string1, string2, string3].map(id => id.replace(/"/g, ''));
   
-  // Wait for the information to be processed and student to appear
-  await new Promise(resolve => setTimeout(resolve, 2000));
-});
-
-Then('I should see {string} in the student list', async function (studentName: string) {
-  // Wait for the student list to update
-  await page.waitForSelector('.students-list table', { timeout: 10000 });
+  const responseBody = await lastResponse.json();
+  expect(Array.isArray(responseBody)).toBe(true);
   
-  // Find the student row that matches our test student's CPF and verify the name
-  const studentRows = await page.$$('[data-testid^="student-row-"]');
-  let foundStudent = null;
+  const returnedIds = responseBody.map((answer: any) => answer.id);
   
-  for (const row of studentRows) {
-    const cpfCell = await row.$('[data-testid="student-cpf"]');
-    if (cpfCell) {
-      const cpf = await page.evaluate(el => el.textContent, cpfCell);
-      if (cpf === formatCPF(testStudentCPF) || cpf === testStudentCPF) {
-        foundStudent = row;
-        break;
-      }
-    }
+  // Verify all expected IDs are in the response
+  for (const expectedId of expectedIds) {
+    expect(returnedIds).toContain(expectedId);
   }
   
-  expect(foundStudent).toBeTruthy();
-  
-  // Verify the name matches exactly for this specific student
-  const nameCell = await foundStudent!.$('[data-testid="student-name"]');
-  const actualName = await page.evaluate(el => el.textContent, nameCell!);
-  expect(actualName).toBe(studentName);
+  console.log(`Server test: Verified response contains answers: ${expectedIds.join(', ')}`);
 });
 
-Then('the student should have CPF {string}', async function (expectedCPF: string) {
-  // Wait for the student list to update
-  await page.waitForSelector('.students-list table', { timeout: 10000 });
-  
-  // Find all student information from the current test student
-  const studentRows = await page.$$('[data-testid^="student-row-"]');
-  let foundStudent = null;
-  
-  // First, find the student row that matches our test CPF
-  for (const row of studentRows) {
-    const cpfCell = await row.$('[data-testid="student-cpf"]');
-    if (cpfCell) {
-      const cpf = await page.evaluate(el => el.textContent, cpfCell);
-      if (cpf === expectedCPF || cpf === testStudentCPF || cpf === formatCPF(testStudentCPF)) {
-        foundStudent = row;
-        break;
-      }
-    }
-  }
-  
-  expect(foundStudent).toBeTruthy();
-  
-  // Verify the CPF matches exactly
-  const cpfCell = await foundStudent!.$('[data-testid="student-cpf"]');
-  const actualCPF = await page.evaluate(el => el.textContent, cpfCell!);
-  expect(actualCPF).toBe(expectedCPF);
-});
-
-Then('the student should have email {string}', async function (expectedEmail: string) {
-  // Wait for the student list to update
-  await page.waitForSelector('.students-list table', { timeout: 10000 });
-  
-  // Find the student row that matches our test student's CPF
-  const studentRows = await page.$$('[data-testid^="student-row-"]');
-  let foundStudent = null;
-  
-  for (const row of studentRows) {
-    const cpfCell = await row.$('[data-testid="student-cpf"]');
-    if (cpfCell) {
-      const cpf = await page.evaluate(el => el.textContent, cpfCell);
-      if (cpf === formatCPF(testStudentCPF) || cpf === testStudentCPF) {
-        foundStudent = row;
-        break;
-      }
-    }
-  }
-  
-  expect(foundStudent).toBeTruthy();
+Then('the server should return an empty list', async function () {
+  const responseBody = await lastResponse.json();
+  expect(Array.isArray(responseBody)).toBe(true);
+  expect(responseBody.length).toBe(0);
   
-  // Verify the email matches exactly for this specific student
-  const emailCell = await foundStudent!.$('[data-testid="student-email"]');
-  const actualEmail = await page.evaluate(el => el.textContent, emailCell!);
-  expect(actualEmail).toBe(expectedEmail);
+  console.log('Server test: Confirmed response is an empty list');
 });
\ No newline at end of file

From 481fbccb2470e55df14ae3c6760b32489b36d74f Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Mon, 8 Dec 2025 19:12:38 -0300
Subject: [PATCH 045/102] testing: retrieval of answers from specific student
 acceptance tests

---
 .../server-scriptAnswer-steps.ts              | 118 +++++++++++++++++-
 client/src/step-definitions/student-steps.ts  |   3 +-
 2 files changed, 115 insertions(+), 6 deletions(-)

diff --git a/client/src/step-definitions/server-scriptAnswer-steps.ts b/client/src/step-definitions/server-scriptAnswer-steps.ts
index 38a91617..74af30d8 100644
--- a/client/src/step-definitions/server-scriptAnswer-steps.ts
+++ b/client/src/step-definitions/server-scriptAnswer-steps.ts
@@ -9,6 +9,7 @@ const serverUrl = 'http://localhost:3005';
 // Test data to clean up
 let lastResponse: Response;
 let createdScriptAnswerIds: string[] = [];
+let createdStudentCPF: string | null = null;
 
 After({ tags: '@server' }, async function () {
   // Clean up created script answers if needed
@@ -25,8 +26,20 @@ After({ tags: '@server' }, async function () {
     }
     createdScriptAnswerIds = [];
   }
-});
 
+  // Clean up created student if needed
+  if (createdStudentCPF) {
+    try {
+      await fetch(`${serverUrl}/api/students/${createdStudentCPF}`, {
+        method: 'DELETE'
+      });
+      console.log(`Server cleanup: Removed test student with CPF: ${createdStudentCPF}`);
+    } catch (error) {
+      console.log(`Server cleanup: Could not remove student ${createdStudentCPF}`);
+    }
+    createdStudentCPF = null;
+  }
+});
 
 // ============================================================
 // Retrieval of all script answers
@@ -81,6 +94,90 @@ Given('there are no script answers registered', async function () {
   }
 });
 
+// ============================================================
+// Retrieval by student (CPF-based)
+// ============================================================
+
+Given('there is a student with CPF {string}', async function (cpf: string) {
+  try {
+    const response = await fetch(`${serverUrl}/api/students`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        name: 'Test Student',
+        cpf: cpf,
+        email: `student${cpf}@test.com`
+      })
+    });
+
+    const get = await fetch(`${serverUrl}/api/students/${cpf}`)
+    expect(get.status).toBe(200);
+
+    if (response.status === 201) {
+      createdStudentCPF = cpf;
+
+      console.log(`Server setup: Created student with CPF: ${cpf}`);
+    } else {
+      console.error(`Failed to create student with CPF ${cpf}: Status ${response.status}`);
+    }
+  } catch (error) {
+    console.error(`Failed to create student with CPF ${cpf}:`, error);
+  }
+});
+
+Given('this student has script answers with IDs {string}, {string}, {string}', async function (string1, string2, string3) {
+  if (!createdStudentCPF) {
+    throw new Error('No student has been created yet. Use "Given there is a student with CPF" first.');
+  }
+
+  // Parse the comma-separated IDs from the string
+  const ids = [string1, string2, string3 ].map(id => id.replace(/"/g, ''));
+
+  // Create script answers for the student with the given IDs
+  for (const id of ids) {
+    try {
+      const response = await fetch(`${serverUrl}/api/scriptanswers/`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          id: id,
+          scriptId: `script-${id}`,
+          studentId: createdStudentCPF,
+          answers: []
+        })
+      });
+
+      if (response.status === 201) {
+        createdScriptAnswerIds.push(id);
+        console.log(`Server setup: Created script answer with ID: ${id} for student ${createdStudentCPF}`);
+      } else {
+        console.error(`Failed to create script answer ${id}: Status ${response.status}`);
+      }
+    } catch (error) {
+      console.error(`Failed to create script answer ${id}:`, error);
+    }
+  }
+});
+
+Given('there is no student with CPF {string}', async function (cpf: string) {
+  // Verify that no student with this CPF exists
+  try {
+    const response = await fetch(`${serverUrl}/api/students/${cpf}`);
+    
+    if (response.status === 200) {
+      throw new Error(`Student with CPF ${cpf} already exists. Please use a different CPF.`);
+    } else if (response.status === 404) {
+      console.log(`Server setup: Confirmed no student with CPF ${cpf} exists`);
+    }
+  } catch (error) {
+    if ((error as Error).message.includes('already exists')) {
+      throw error;
+    }
+    // If there's a network error, we'll proceed anyway
+    console.log(`Server setup: Could not verify student non-existence for CPF ${cpf}`);
+  }
+});
+
 When('I send a GET request to {string}', async function (endpoint: string) {
   try {
     lastResponse = await fetch(`${serverUrl}${endpoint}`);
@@ -90,11 +187,11 @@ When('I send a GET request to {string}', async function (endpoint: string) {
   }
 });
 
-Then('the server should return {int} OK', async function (statusCode: number) {
-  expect(lastResponse.status).toBe(statusCode);
-  console.log(`Server test: Confirmed response status is ${statusCode}`);
+Then(/^the server should return (\d+) (.+)$/, async function (statusCode: string, message: string) {
+  const code = parseInt(statusCode);
+  expect(lastResponse.status).toBe(code);
+  console.log(`Server test: Confirmed response status is ${code} ${message}`);
 });
-
 Then('the server should return a list containing answers {string}, {string}, {string}', async function (string1: string, string2: string, string3: string) {
   const expectedIds = [string1, string2, string3].map(id => id.replace(/"/g, ''));
   
@@ -111,10 +208,21 @@ Then('the server should return a list containing answers {string}, {string}, {st
   console.log(`Server test: Verified response contains answers: ${expectedIds.join(', ')}`);
 });
 
+
+
+
 Then('the server should return an empty list', async function () {
   const responseBody = await lastResponse.json();
   expect(Array.isArray(responseBody)).toBe(true);
   expect(responseBody.length).toBe(0);
   
   console.log('Server test: Confirmed response is an empty list');
+});
+
+Then('the server should return an error message {string}', async function (string) {
+  const responseBody = await lastResponse.json();
+  expect(responseBody.error).toBeDefined();
+  expect(responseBody.error.toLowerCase()).toContain(string);
+  
+  console.log(`Server test: Confirmed error message: ${responseBody.error}`);
 });
\ No newline at end of file
diff --git a/client/src/step-definitions/student-steps.ts b/client/src/step-definitions/student-steps.ts
index a2c3af79..0c39a21c 100644
--- a/client/src/step-definitions/student-steps.ts
+++ b/client/src/step-definitions/student-steps.ts
@@ -265,4 +265,5 @@ Then('the student should have email {string}', async function (expectedEmail: st
   const emailCell = await foundStudent!.$('[data-testid="student-email"]');
   const actualEmail = await page.evaluate(el => el.textContent, emailCell!);
   expect(actualEmail).toBe(expectedEmail);
-});
\ No newline at end of file
+});
+

From 896c48c89afa4a0351ef06b1bb2a98f9c446ae3b Mon Sep 17 00:00:00 2001
From: Davi Guerreiro <daviguerreiro9a@gmail.com>
Date: Mon, 8 Dec 2025 19:26:46 -0300
Subject: [PATCH 046/102] feat(Answer): implementing Answers

---
 client/package-lock.json       | 43 +++++----------------------
 package-lock.json              | 42 ++++-----------------------
 server/package-lock.json       |  6 ----
 server/src/models/Answer.ts    | 53 ++++++++++++++++++++++++++++++++++
 server/src/models/AnswerSet.ts | 32 ++++++++++++++++++++
 5 files changed, 99 insertions(+), 77 deletions(-)
 create mode 100644 server/src/models/Answer.ts
 create mode 100644 server/src/models/AnswerSet.ts

diff --git a/client/package-lock.json b/client/package-lock.json
index 7089679f..02be0646 100644
--- a/client/package-lock.json
+++ b/client/package-lock.json
@@ -75,7 +75,6 @@
       "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.28.5.tgz",
       "integrity": "sha512-e7jT4DxYvIDLk1ZHmU/m/mB19rex9sv0c2ftBtjSBv+kVM/902eh0fINUzD7UwLLNR+jU585GxUJ8/EBfAM5fw==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@babel/code-frame": "^7.27.1",
         "@babel/generator": "^7.28.5",
@@ -725,7 +724,6 @@
       "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-flow/-/plugin-syntax-flow-7.27.1.tgz",
       "integrity": "sha512-p9OkPbZ5G7UT1MofwYFigGebnrzGJacoBSQM0/6bi/PUMVE+qlWDD/OalvQKbwgQzU6dl0xAv6r4X7Jme0RYxA==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@babel/helper-plugin-utils": "^7.27.1"
       },
@@ -1609,7 +1607,6 @@
       "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx/-/plugin-transform-react-jsx-7.27.1.tgz",
       "integrity": "sha512-2KH4LWGSrJIkVf5tSiBFYuXDAoWRq2MMwgivCf+93dd0GQi8RXLjKA/0EvRnVV5G0hrHczsquXuD01L8s6dmBw==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@babel/helper-annotate-as-pure": "^7.27.1",
         "@babel/helper-module-imports": "^7.27.1",
@@ -2428,7 +2425,6 @@
       "integrity": "sha512-b7W4snvXYi1T2puUjxamASCCNhNzVSzb/fQUuGSkdjm/AFfJ24jo8kOHQyOcaoArCG71sVQci4vkZaITzl/V1w==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@cucumber/ci-environment": "10.0.1",
         "@cucumber/cucumber-expressions": "18.0.1",
@@ -2674,7 +2670,6 @@
       "integrity": "sha512-659CCFsrsyvuBi/Eix1fnhSheMnojSfnBcqJ3IMPNawx7JlrNJDcXYSSdxcUw3n/nG05P+ptCjmiZY3i14p+tA==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@cucumber/messages": ">=19.1.4 <29"
       }
@@ -2831,7 +2826,6 @@
       "integrity": "sha512-Kxap9uP5jD8tHUZVjTWgzxemi/0uOsbGjd4LBOSxcJoOCRbESFwemUzilJuzNTB8pcTQUh8D5oudUyxfkJOKmA==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "peerDependencies": {
         "@cucumber/messages": ">=17.1.1"
       }
@@ -2842,7 +2836,6 @@
       "integrity": "sha512-2LzZtOwYKNlCuNf31ajkrekoy2M4z0Z1QGiPH40n4gf5t8VOUFb7m1ojtR4LmGvZxBGvJZP8voOmRqDWzBzYKA==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@types/uuid": "10.0.0",
         "class-transformer": "0.5.1",
@@ -3876,6 +3869,7 @@
       "integrity": "sha512-b0P0sZPKtyu8HkeRAfCq0IfURZK+SuwMjY1UXGBU27wpAiTwQAIlq56IbIO+ytk/JjS1fMR14ee5WBBfKi5J6A==",
       "dev": true,
       "license": "Apache-2.0",
+      "peer": true,
       "dependencies": {
         "dequal": "^2.0.3"
       }
@@ -4007,7 +4001,8 @@
       "resolved": "https://registry.npmjs.org/@types/aria-query/-/aria-query-5.0.4.tgz",
       "integrity": "sha512-rfT93uj5s0PRL7EzccGMs3brplhcrghnDoV26NqKhCAS1hVo+WdNsPvE/yb6ilfr5hi2MEk6d5EWJTKdxg8jVw==",
       "dev": true,
-      "license": "MIT"
+      "license": "MIT",
+      "peer": true
     },
     "node_modules/@types/babel__core": {
       "version": "7.20.5",
@@ -4420,7 +4415,6 @@
       "resolved": "https://registry.npmjs.org/@types/node/-/node-24.10.0.tgz",
       "integrity": "sha512-qzQZRBqkFsYyaSWXuEHc2WR9c0a0CXwiE5FWUvn7ZM+vdy1uZLfCunD38UzhuB7YN/J11ndbDBcTmOdxJo9Q7A==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "undici-types": "~7.16.0"
       }
@@ -4494,7 +4488,6 @@
       "integrity": "sha512-RFA/bURkcKzx/X9oumPG9Vp3D3JUgus/d0b67KB0t5S/raciymilkOa66olh78MUI92QLbEJevO7rvqU/kjwKA==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@types/prop-types": "*",
         "csstype": "^3.0.2"
@@ -4506,7 +4499,6 @@
       "integrity": "sha512-MEe3UeoENYVFXzoXEWsvcpg6ZvlrFNlOQ7EOsvhI3CfAXwzPfO8Qwuxd40nepsYKqyyVQnTdEfv68q91yLcKrQ==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "peerDependencies": {
         "@types/react": "^18.0.0"
       }
@@ -4639,7 +4631,6 @@
       "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-5.62.0.tgz",
       "integrity": "sha512-TiZzBSJja/LbhNPvk6yc0JrX9XqhQ0hdh6M2svYfsHGejaKFIAGd9MQ+ERIMzLGlN/kZoYIgdxFV0PuljTKXag==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@eslint-community/regexpp": "^4.4.0",
         "@typescript-eslint/scope-manager": "5.62.0",
@@ -4693,7 +4684,6 @@
       "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-5.62.0.tgz",
       "integrity": "sha512-VlJEV0fOQ7BExOsHYAGrgbEiZoi8D+Bl2+f6V2RrXerRSylnp+ZBHmPvaIa8cz0Ajx7WO7Z5RqfgYg7ED1nRhA==",
       "license": "BSD-2-Clause",
-      "peer": true,
       "dependencies": {
         "@typescript-eslint/scope-manager": "5.62.0",
         "@typescript-eslint/types": "5.62.0",
@@ -5063,7 +5053,6 @@
       "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz",
       "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
       "license": "MIT",
-      "peer": true,
       "bin": {
         "acorn": "bin/acorn"
       },
@@ -5173,7 +5162,6 @@
       "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
       "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "fast-deep-equal": "^3.1.1",
         "fast-json-stable-stringify": "^2.0.0",
@@ -6216,7 +6204,6 @@
         }
       ],
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "baseline-browser-mapping": "^2.8.19",
         "caniuse-lite": "^1.0.30001751",
@@ -7539,6 +7526,7 @@
       "integrity": "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=6"
       }
@@ -7605,8 +7593,7 @@
       "resolved": "https://registry.npmjs.org/devtools-protocol/-/devtools-protocol-0.0.1521046.tgz",
       "integrity": "sha512-vhE6eymDQSKWUXwwA37NtTTVEzjtGVfDr3pRbsWEQ5onH/Snp2c+2xZHWJJawG/0hCCJLRGt4xVtEVUVILol4w==",
       "dev": true,
-      "license": "BSD-3-Clause",
-      "peer": true
+      "license": "BSD-3-Clause"
     },
     "node_modules/didyoumean": {
       "version": "1.2.2",
@@ -7680,7 +7667,8 @@
       "resolved": "https://registry.npmjs.org/dom-accessibility-api/-/dom-accessibility-api-0.5.16.tgz",
       "integrity": "sha512-X7BJ2yElsnOJ30pZF4uIIDfBEVgF4XEBxL9Bxhy6dnrm5hkzqmsWHGTiHqRiITNhMyFLyAiWndIJP7Z1NTteDg==",
       "dev": true,
-      "license": "MIT"
+      "license": "MIT",
+      "peer": true
     },
     "node_modules/dom-converter": {
       "version": "0.2.0",
@@ -8175,7 +8163,6 @@
       "integrity": "sha512-ypowyDxpVSYpkXr9WPv2PAZCtNip1Mv5KTW0SCurXv/9iOpcrH9PaqUElksqEB6pChqHGDRCFTyrZlGhnLNGiA==",
       "deprecated": "This version is no longer supported. Please see https://eslint.org/version-support for other options.",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@eslint-community/eslint-utils": "^4.2.0",
         "@eslint-community/regexpp": "^4.6.1",
@@ -11928,7 +11915,6 @@
       "resolved": "https://registry.npmjs.org/jiti/-/jiti-1.21.7.tgz",
       "integrity": "sha512-/imKNG4EbWNrVjoNC/1H5/9GFy+tqjGBHCaSsN+P2RnPqjsLmv6UD3Ej+Kj8nBWaRAwyk7kK5ZUc+OEatnTR3A==",
       "license": "MIT",
-      "peer": true,
       "bin": {
         "jiti": "bin/jiti.js"
       }
@@ -12410,6 +12396,7 @@
       "integrity": "sha512-h5bgJWpxJNswbU7qCrV0tIKQCaS3blPDrqKWx+QxzuzL1zGUzij9XCWLrSLsJPu5t+eWA/ycetzYAO5IOMcWAQ==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "bin": {
         "lz-string": "bin/bin.js"
       }
@@ -13494,7 +13481,6 @@
         }
       ],
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "nanoid": "^3.3.11",
         "picocolors": "^1.1.1",
@@ -14629,7 +14615,6 @@
       "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz",
       "integrity": "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "cssesc": "^3.0.0",
         "util-deprecate": "^1.0.2"
@@ -15142,7 +15127,6 @@
       "resolved": "https://registry.npmjs.org/react/-/react-18.3.1.tgz",
       "integrity": "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "loose-envify": "^1.1.0"
       },
@@ -15277,7 +15261,6 @@
       "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-18.3.1.tgz",
       "integrity": "sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "loose-envify": "^1.1.0",
         "scheduler": "^0.23.2"
@@ -15303,7 +15286,6 @@
       "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.11.0.tgz",
       "integrity": "sha512-F27qZr8uUqwhWZboondsPx8tnC3Ct3SxZA3V5WyEvujRyyNv0VYPhoBg1gZ8/MV5tubQp76Trw8lTv9hzRBa+A==",
       "license": "MIT",
-      "peer": true,
       "engines": {
         "node": ">=0.10.0"
       }
@@ -15696,7 +15678,6 @@
       "resolved": "https://registry.npmjs.org/jest/-/jest-27.5.1.tgz",
       "integrity": "sha512-Yn0mADZB89zTtjkPJEXwrac3LHudkQMR+Paqa8uxJHCBr9agxztUifWCyiYrjhMPBoUVBjyny0I7XH6ozDr7QQ==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@jest/core": "^27.5.1",
         "import-local": "^3.0.2",
@@ -16862,7 +16843,6 @@
       "resolved": "https://registry.npmjs.org/rollup/-/rollup-2.79.2.tgz",
       "integrity": "sha512-fS6iqSPZDs3dr/y7Od6y5nha8dW1YnbgtsyotCVvoFGKbERG++CVRFv1meyGDE1SNItQA8BrnCw7ScdAhRJ3XQ==",
       "license": "MIT",
-      "peer": true,
       "bin": {
         "rollup": "dist/bin/rollup"
       },
@@ -17108,7 +17088,6 @@
       "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz",
       "integrity": "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "fast-deep-equal": "^3.1.3",
         "fast-uri": "^3.0.1",
@@ -18900,7 +18879,6 @@
       "integrity": "sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ==",
       "devOptional": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@cspotcode/source-map-support": "^0.8.0",
         "@tsconfig/node10": "^1.0.7",
@@ -19032,7 +19010,6 @@
       "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz",
       "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==",
       "license": "(MIT OR CC0-1.0)",
-      "peer": true,
       "engines": {
         "node": ">=10"
       },
@@ -19148,7 +19125,6 @@
       "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.9.5.tgz",
       "integrity": "sha512-1FXk9E2Hm+QzZQ7z+McJiHL4NW1F2EzMu9Nq9i3zAaGqibafqYwCVU6WyWAuyQRRzOlxou8xZSyXLEN8oKj24g==",
       "license": "Apache-2.0",
-      "peer": true,
       "bin": {
         "tsc": "bin/tsc",
         "tsserver": "bin/tsserver"
@@ -19498,7 +19474,6 @@
       "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.102.1.tgz",
       "integrity": "sha512-7h/weGm9d/ywQ6qzJ+Xy+r9n/3qgp/thalBbpOi5i223dPXKi04IBtqPN9nTd+jBc7QKfvDbaBnFipYp4sJAUQ==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@types/eslint-scope": "^3.7.7",
         "@types/estree": "^1.0.8",
@@ -19570,7 +19545,6 @@
       "resolved": "https://registry.npmjs.org/webpack-dev-server/-/webpack-dev-server-4.15.2.tgz",
       "integrity": "sha512-0XavAZbNJ5sDrCbkpWL8mia0o5WPOd2YGtxrEiZkBK9FjLppIUK2TgxK6qGD2P3hUXTJNNPVibrerKcx5WkR1g==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@types/bonjour": "^3.5.9",
         "@types/connect-history-api-fallback": "^1.3.5",
@@ -19962,7 +19936,6 @@
       "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz",
       "integrity": "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "fast-deep-equal": "^3.1.3",
         "fast-uri": "^3.0.1",
diff --git a/package-lock.json b/package-lock.json
index 5f18ab05..11720a46 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -408,7 +408,6 @@
     "client/node_modules/@babel/plugin-syntax-flow": {
       "version": "7.27.1",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@babel/helper-plugin-utils": "^7.27.1"
       },
@@ -1031,7 +1030,6 @@
     "client/node_modules/@babel/plugin-transform-react-jsx": {
       "version": "7.27.1",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@babel/helper-annotate-as-pure": "^7.27.1",
         "@babel/helper-module-imports": "^7.27.1",
@@ -2552,7 +2550,6 @@
       "version": "18.3.26",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@types/prop-types": "*",
         "csstype": "^3.0.2"
@@ -2616,7 +2613,6 @@
     "client/node_modules/@typescript-eslint/eslint-plugin": {
       "version": "5.62.0",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@eslint-community/regexpp": "^4.4.0",
         "@typescript-eslint/scope-manager": "5.62.0",
@@ -2666,7 +2662,6 @@
     "client/node_modules/@typescript-eslint/parser": {
       "version": "5.62.0",
       "license": "BSD-2-Clause",
-      "peer": true,
       "dependencies": {
         "@typescript-eslint/scope-manager": "5.62.0",
         "@typescript-eslint/types": "5.62.0",
@@ -3041,7 +3036,6 @@
     "client/node_modules/ajv": {
       "version": "6.12.6",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "fast-deep-equal": "^3.1.1",
         "fast-json-stable-stringify": "^2.0.0",
@@ -4905,7 +4899,6 @@
     "client/node_modules/eslint": {
       "version": "8.57.1",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@eslint-community/eslint-utils": "^4.2.0",
         "@eslint-community/regexpp": "^4.6.1",
@@ -6851,7 +6844,6 @@
     "client/node_modules/jest": {
       "version": "27.5.1",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@jest/core": "^27.5.1",
         "import-local": "^3.0.2",
@@ -7630,7 +7622,6 @@
     "client/node_modules/jiti": {
       "version": "1.21.7",
       "license": "MIT",
-      "peer": true,
       "bin": {
         "jiti": "bin/jiti.js"
       }
@@ -8365,7 +8356,6 @@
         }
       ],
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "nanoid": "^3.3.11",
         "picocolors": "^1.1.1",
@@ -9364,7 +9354,6 @@
     "client/node_modules/postcss-selector-parser": {
       "version": "6.1.2",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "cssesc": "^3.0.0",
         "util-deprecate": "^1.0.2"
@@ -9749,7 +9738,6 @@
     "client/node_modules/react-refresh": {
       "version": "0.11.0",
       "license": "MIT",
-      "peer": true,
       "engines": {
         "node": ">=0.10.0"
       }
@@ -10082,7 +10070,6 @@
     "client/node_modules/rollup": {
       "version": "2.79.2",
       "license": "MIT",
-      "peer": true,
       "bin": {
         "rollup": "dist/bin/rollup"
       },
@@ -10270,7 +10257,6 @@
     "client/node_modules/schema-utils/node_modules/ajv": {
       "version": "8.17.1",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "fast-deep-equal": "^3.1.3",
         "fast-uri": "^3.0.1",
@@ -11365,7 +11351,6 @@
     "client/node_modules/type-fest": {
       "version": "0.20.2",
       "license": "(MIT OR CC0-1.0)",
-      "peer": true,
       "engines": {
         "node": ">=10"
       },
@@ -11648,7 +11633,6 @@
     "client/node_modules/webpack": {
       "version": "5.102.1",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@types/eslint-scope": "^3.7.7",
         "@types/estree": "^1.0.8",
@@ -11716,7 +11700,6 @@
     "client/node_modules/webpack-dev-server": {
       "version": "4.15.2",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@types/bonjour": "^3.5.9",
         "@types/connect-history-api-fallback": "^1.3.5",
@@ -12066,7 +12049,6 @@
     "client/node_modules/workbox-build/node_modules/ajv": {
       "version": "8.17.1",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "fast-deep-equal": "^3.1.3",
         "fast-uri": "^3.0.1",
@@ -12357,7 +12339,6 @@
       "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.28.5.tgz",
       "integrity": "sha512-e7jT4DxYvIDLk1ZHmU/m/mB19rex9sv0c2ftBtjSBv+kVM/902eh0fINUzD7UwLLNR+jU585GxUJ8/EBfAM5fw==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@babel/code-frame": "^7.27.1",
         "@babel/generator": "^7.28.5",
@@ -12874,7 +12855,6 @@
       "integrity": "sha512-b7W4snvXYi1T2puUjxamASCCNhNzVSzb/fQUuGSkdjm/AFfJ24jo8kOHQyOcaoArCG71sVQci4vkZaITzl/V1w==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@cucumber/ci-environment": "10.0.1",
         "@cucumber/cucumber-expressions": "18.0.1",
@@ -12959,7 +12939,6 @@
       "integrity": "sha512-659CCFsrsyvuBi/Eix1fnhSheMnojSfnBcqJ3IMPNawx7JlrNJDcXYSSdxcUw3n/nG05P+ptCjmiZY3i14p+tA==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@cucumber/messages": ">=19.1.4 <29"
       }
@@ -13116,7 +13095,6 @@
       "integrity": "sha512-Kxap9uP5jD8tHUZVjTWgzxemi/0uOsbGjd4LBOSxcJoOCRbESFwemUzilJuzNTB8pcTQUh8D5oudUyxfkJOKmA==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "peerDependencies": {
         "@cucumber/messages": ">=17.1.1"
       }
@@ -13127,7 +13105,6 @@
       "integrity": "sha512-2LzZtOwYKNlCuNf31ajkrekoy2M4z0Z1QGiPH40n4gf5t8VOUFb7m1ojtR4LmGvZxBGvJZP8voOmRqDWzBzYKA==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@types/uuid": "10.0.0",
         "class-transformer": "0.5.1",
@@ -14220,7 +14197,8 @@
       "resolved": "https://registry.npmjs.org/@types/aria-query/-/aria-query-5.0.4.tgz",
       "integrity": "sha512-rfT93uj5s0PRL7EzccGMs3brplhcrghnDoV26NqKhCAS1hVo+WdNsPvE/yb6ilfr5hi2MEk6d5EWJTKdxg8jVw==",
       "dev": true,
-      "license": "MIT"
+      "license": "MIT",
+      "peer": true
     },
     "node_modules/@types/babel__core": {
       "version": "7.20.5",
@@ -14349,7 +14327,6 @@
       "integrity": "sha512-XTYugzhuwqWjws0CVz8QpM36+T+Dz5mTEBKhNs/esGLnCIlGdRy+Dq78NRjd7ls7r8BC8ZRMOrKlkO1hU0JOwA==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "expect": "^30.0.0",
         "pretty-format": "^30.0.0"
@@ -14825,7 +14802,6 @@
       "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz",
       "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
       "license": "MIT",
-      "peer": true,
       "bin": {
         "acorn": "bin/acorn"
       },
@@ -15266,7 +15242,6 @@
         }
       ],
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "baseline-browser-mapping": "^2.8.25",
         "caniuse-lite": "^1.0.30001754",
@@ -15820,8 +15795,7 @@
       "resolved": "https://registry.npmjs.org/devtools-protocol/-/devtools-protocol-0.0.1521046.tgz",
       "integrity": "sha512-vhE6eymDQSKWUXwwA37NtTTVEzjtGVfDr3pRbsWEQ5onH/Snp2c+2xZHWJJawG/0hCCJLRGt4xVtEVUVILol4w==",
       "dev": true,
-      "license": "BSD-3-Clause",
-      "peer": true
+      "license": "BSD-3-Clause"
     },
     "node_modules/dezalgo": {
       "version": "1.0.4",
@@ -15849,7 +15823,8 @@
       "resolved": "https://registry.npmjs.org/dom-accessibility-api/-/dom-accessibility-api-0.5.16.tgz",
       "integrity": "sha512-X7BJ2yElsnOJ30pZF4uIIDfBEVgF4XEBxL9Bxhy6dnrm5hkzqmsWHGTiHqRiITNhMyFLyAiWndIJP7Z1NTteDg==",
       "dev": true,
-      "license": "MIT"
+      "license": "MIT",
+      "peer": true
     },
     "node_modules/dunder-proto": {
       "version": "1.0.1",
@@ -16926,7 +16901,6 @@
       "integrity": "sha512-F26gjC0yWN8uAA5m5Ss8ZQf5nDHWGlN/xWZIh8S5SRbsEKBovwZhxGd6LJlbZYxBgCYOtreSUyb8hpXyGC5O4A==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@jest/core": "30.2.0",
         "@jest/types": "30.2.0",
@@ -18348,6 +18322,7 @@
       "integrity": "sha512-h5bgJWpxJNswbU7qCrV0tIKQCaS3blPDrqKWx+QxzuzL1zGUzij9XCWLrSLsJPu5t+eWA/ycetzYAO5IOMcWAQ==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "bin": {
         "lz-string": "bin/bin.js"
       }
@@ -19103,7 +19078,6 @@
       "resolved": "https://registry.npmjs.org/react/-/react-18.3.1.tgz",
       "integrity": "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "loose-envify": "^1.1.0"
       },
@@ -19116,7 +19090,6 @@
       "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-18.3.1.tgz",
       "integrity": "sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "loose-envify": "^1.1.0",
         "scheduler": "^0.23.2"
@@ -20116,7 +20089,6 @@
       "integrity": "sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ==",
       "devOptional": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@cspotcode/source-map-support": "^0.8.0",
         "@tsconfig/node10": "^1.0.7",
@@ -20214,7 +20186,6 @@
       "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.9.5.tgz",
       "integrity": "sha512-1FXk9E2Hm+QzZQ7z+McJiHL4NW1F2EzMu9Nq9i3zAaGqibafqYwCVU6WyWAuyQRRzOlxou8xZSyXLEN8oKj24g==",
       "license": "Apache-2.0",
-      "peer": true,
       "bin": {
         "tsc": "bin/tsc",
         "tsserver": "bin/tsserver"
@@ -21405,7 +21376,6 @@
       "version": "5.9.3",
       "dev": true,
       "license": "Apache-2.0",
-      "peer": true,
       "bin": {
         "tsc": "bin/tsc",
         "tsserver": "bin/tsserver"
diff --git a/server/package-lock.json b/server/package-lock.json
index 0bb93186..f63df85d 100644
--- a/server/package-lock.json
+++ b/server/package-lock.json
@@ -58,7 +58,6 @@
       "integrity": "sha512-e7jT4DxYvIDLk1ZHmU/m/mB19rex9sv0c2ftBtjSBv+kVM/902eh0fINUzD7UwLLNR+jU585GxUJ8/EBfAM5fw==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@babel/code-frame": "^7.27.1",
         "@babel/generator": "^7.28.5",
@@ -1566,7 +1565,6 @@
       "integrity": "sha512-FE5u0ezmi6y9OZEzlJfg37mqqf6ZDSF2V/NLjUyGrR9uTZ7Sb9F7bLNZ03S4XVUNRWGA7Ck4c1kK+YnuWjl+DA==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "undici-types": "~6.21.0"
       }
@@ -2291,7 +2289,6 @@
         }
       ],
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "baseline-browser-mapping": "^2.8.25",
         "caniuse-lite": "^1.0.30001754",
@@ -3795,7 +3792,6 @@
       "integrity": "sha512-F26gjC0yWN8uAA5m5Ss8ZQf5nDHWGlN/xWZIh8S5SRbsEKBovwZhxGd6LJlbZYxBgCYOtreSUyb8hpXyGC5O4A==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@jest/core": "30.2.0",
         "@jest/types": "30.2.0",
@@ -6017,7 +6013,6 @@
       "integrity": "sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@cspotcode/source-map-support": "^0.8.0",
         "@tsconfig/node10": "^1.0.7",
@@ -6160,7 +6155,6 @@
       "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
       "dev": true,
       "license": "Apache-2.0",
-      "peer": true,
       "bin": {
         "tsc": "bin/tsc",
         "tsserver": "bin/tsserver"
diff --git a/server/src/models/Answer.ts b/server/src/models/Answer.ts
new file mode 100644
index 00000000..1c0d76d4
--- /dev/null
+++ b/server/src/models/Answer.ts
@@ -0,0 +1,53 @@
+import { Task } from './Task';
+export class Answer {
+  private id: string;
+  public task: Task;
+  public started_at?: number;
+  public submitted_at?: number;
+  public time_taken_seconds?: number;
+  public response?: any;
+  public status: 'pending' | 'started' | 'submitted' | 'timed_out' = 'pending';
+
+  constructor(id: string, task: Task) {
+    this.id = id;
+    this.task = task;
+  }
+
+  getId() { return this.id; }
+
+  toJSON() {
+    return {
+      id: this.id,
+      taskId: this.task.getId(),
+      started_at: this.started_at,
+      submitted_at: this.submitted_at,
+      time_taken_seconds: this.time_taken_seconds,
+      response: this.response,
+      status: this.status
+    };
+  }
+
+  update(data: Partial<{
+    started_at: number;
+    submitted_at: number;
+    time_taken_seconds: number;
+    response: any;
+    status: 'pending' | 'started' | 'submitted' | 'timed_out';
+  }>) {
+    if (data.started_at !== undefined) this.started_at = data.started_at;
+    if (data.submitted_at !== undefined) this.submitted_at = data.submitted_at;
+    if (data.time_taken_seconds !== undefined) this.time_taken_seconds = data.time_taken_seconds;
+    if (data.response !== undefined) this.response = data.response;
+    if (data.status !== undefined) this.status = data.status;
+  }
+
+  static fromJSON(obj: any, task: Task): Answer {
+    const a = new Answer(obj.id, task);
+    a.started_at = obj.started_at;
+    a.submitted_at = obj.submitted_at;
+    a.time_taken_seconds = obj.time_taken_seconds;
+    a.response = obj.response;
+    a.status = obj.status ?? 'pending';
+    return a;
+  }
+}
\ No newline at end of file
diff --git a/server/src/models/AnswerSet.ts b/server/src/models/AnswerSet.ts
new file mode 100644
index 00000000..ec0cb67d
--- /dev/null
+++ b/server/src/models/AnswerSet.ts
@@ -0,0 +1,32 @@
+import { Answer } from './Answer';
+import { Task } from './Task';
+export class AnswerSet {
+  private items: Answer[] = [];
+
+  addAnswer(data: any): Answer {
+    const id = data.id ?? Date.now().toString();
+    const answer = new Answer(id, data.task);
+    if (data.started_at !== undefined) answer.update({ started_at: data.started_at });
+    if (data.submitted_at !== undefined) answer.update({ submitted_at: data.submitted_at });
+    if (data.time_taken_seconds !== undefined) answer.update({ time_taken_seconds: data.time_taken_seconds });
+    if (data.response !== undefined) answer.update({ response: data.response });
+    if (data.status !== undefined) answer.update({ status: data.status });
+    this.items.push(answer);
+    return answer;
+  }
+
+  getAllAnswers(): Answer[] {
+    return this.items;
+  }
+
+  findById(id: string): Answer | undefined {
+    return this.items.find(a => a.getId() === id);
+  }
+
+  updateAnswer(id: string, data: any): Answer | undefined {
+    const answer = this.findById(id);
+    if (!answer) return undefined;
+    answer.update(data);
+    return answer;
+  }
+}
\ No newline at end of file

From 41928cca06243d9a0c61c6ee4928213e7afc52e4 Mon Sep 17 00:00:00 2001
From: Davi Guerreiro <daviguerreiro9a@gmail.com>
Date: Mon, 8 Dec 2025 19:28:12 -0300
Subject: [PATCH 047/102] feat(ScriptResponses): Implementing the Script
 Responses of the Enrolled Students

---
 server/src/models/ScriptResponse.ts    | 86 ++++++++++++++++++++++++++
 server/src/models/ScriptResponseSet.ts | 54 ++++++++++++++++
 2 files changed, 140 insertions(+)
 create mode 100644 server/src/models/ScriptResponse.ts
 create mode 100644 server/src/models/ScriptResponseSet.ts

diff --git a/server/src/models/ScriptResponse.ts b/server/src/models/ScriptResponse.ts
new file mode 100644
index 00000000..2545354e
--- /dev/null
+++ b/server/src/models/ScriptResponse.ts
@@ -0,0 +1,86 @@
+import { Answer } from './Answer';
+import { Class } from './Class';
+import { Script } from './Script';
+import { Enrollment } from './Enrollment';
+import { Task } from './Task';
+import { Scripts } from './Scripts';
+export class ScriptResponse {
+  private id: string;
+  public script: Script;
+  public enrollment: Enrollment;
+  public started_at?: number;
+  public finished_at?: number;
+  public status: 'in_progress' | 'finished' = 'in_progress';
+  public answers: Answer[] = [];
+
+  constructor(id: string, script: Script, enrollment: Enrollment, started_at?: number) {
+    this.id = id;
+    this.script = script;
+    this.enrollment = enrollment;
+    this.started_at = started_at ?? Date.now();
+  }
+
+  getId(): string {
+    return this.id;
+  }
+
+  toJSON() {
+    return {
+      id: this.id,
+      scriptId: this.script.getId(),
+      studentCPF: this.enrollment.getStudent().getCPF(),
+      started_at: this.started_at,
+      finished_at: this.finished_at,
+      status: this.status,
+      answers: this.answers.map(a => a.toJSON())
+    };
+  }
+
+  update(data: Partial<{
+    finished_at: number;
+    status: 'in_progress' | 'finished';
+    answers: any[];
+  }>) {
+    if (data.finished_at !== undefined) this.finished_at = data.finished_at;
+    if (data.status !== undefined) this.status = data.status;
+    if (data.answers !== undefined) {
+      this.answers = data.answers.map((o: any) => Answer.fromJSON(o, this.script.findTaskById(o.taskId)!));
+    }
+  }
+
+  addOrGetAnswer(task: Task) {
+    let ans = this.answers.find(a => a.task.getId() === task.getId());
+    if (!ans) {
+      const answerId = `${this.id}-${task.getId()}`;
+      ans = new Answer(answerId, task);
+      ans.started_at = Date.now();
+      this.answers.push(ans);
+    }
+    return ans;
+  }
+
+  findAnswerByTaskId(task: Task) {
+    return this.answers.find(a => a.task.getId() === task.getId());
+  }
+
+  markFinished(finishedAt?: number) {
+    this.finished_at = finishedAt ?? Date.now();
+    this.status = 'finished';
+  }
+
+  static fromJSON(obj: any, scriptSet: Scripts, classObj: Class): ScriptResponse {
+    const script = scriptSet.findById(obj.scriptId);
+    if(!script) throw new Error(`Script ${obj.scriptId} not found`);
+    const enrollment = classObj.findEnrollmentByStudentCPF(obj.studentCPF);
+    if (!enrollment) throw new Error(`Enrollment for CPF ${obj.studentCPF} not found`);
+    const r = new ScriptResponse(obj.id, script, enrollment, obj.started_at);
+    r.finished_at = obj.finished_at;
+    r.status = obj.status ?? 'in_progress';
+    r.answers = (obj.answers ?? []).map((a: any) => {
+      const task = script.findTaskById(a.taskId);
+      if (!task) throw new Error(`Task ${a.taskId} not found`);
+      return Answer.fromJSON(a, task);
+    });
+    return r;
+  }
+}
\ No newline at end of file
diff --git a/server/src/models/ScriptResponseSet.ts b/server/src/models/ScriptResponseSet.ts
new file mode 100644
index 00000000..2911fdba
--- /dev/null
+++ b/server/src/models/ScriptResponseSet.ts
@@ -0,0 +1,54 @@
+import { ScriptResponse } from './ScriptResponse';
+import { Script } from './Script';
+import { Enrollment } from './Enrollment';
+export class ScriptResponseSet {
+  private items: ScriptResponse[] = [];
+
+  addScriptResponse(data: {
+    id?: string;
+    script: Script;
+    enrollment: Enrollment;
+    started_at?: number;
+    finished_at?: number;
+    status?: 'in_progress' | 'finished';
+    answers?: any[];
+  }): ScriptResponse {
+    const id = `${data.enrollment.getStudent().getCPF()}-${data.script.getId()}`;
+    const scriptresponse = new ScriptResponse(id, data.script, data.enrollment, data.started_at);
+    if (data.finished_at !== undefined) scriptresponse.update({ finished_at: data.finished_at });
+    if (data.status !== undefined) scriptresponse.update({ status: data.status });
+    if (data.answers !== undefined) scriptresponse.update({ answers: data.answers });
+    this.items.push(scriptresponse);
+    return scriptresponse;
+  }
+
+  getAllScriptResponses(): ScriptResponse[] {
+    return this.items;
+  }
+
+  findById(id: string): ScriptResponse | undefined {
+    return this.items.find(r => r.getId() === id);
+  }
+
+  updateScriptResponse(id: string, data: any): ScriptResponse | undefined {
+    const scriptresponse = this.findById(id);
+    if (!scriptresponse) return undefined;
+    scriptresponse.update(data);
+    return scriptresponse;
+  }
+
+  findByStudentAndScript(enrollment: Enrollment, script: Script): ScriptResponse | undefined {
+    const studentCPF = enrollment.getStudent().getCPF();
+    const scriptId = script.getId();
+    return this.items.find(r =>
+      r.enrollment.getStudent().getCPF() === studentCPF &&
+      r.script.getId() === scriptId
+    );
+  }
+
+  createOrGetActiveScriptResponse(enrollment: Enrollment, script: Script): ScriptResponse {
+    const existing = this.findByStudentAndScript(enrollment, script);
+    if (existing && existing.status === 'in_progress') return existing;
+    return this.addScriptResponse({ script, enrollment, started_at: Date.now() });
+  }
+}
\ No newline at end of file

From ca97069e85764f16f96195a1f458f585f9fbf1e7 Mon Sep 17 00:00:00 2001
From: Davi Guerreiro <daviguerreiro9a@gmail.com>
Date: Mon, 8 Dec 2025 20:08:15 -0300
Subject: [PATCH 048/102] fix(scriptResponse):  uuid in the scriptResponse

---
 client/package-lock.json               | 43 +++++++++++++++++++++-----
 package-lock.json                      | 42 +++++++++++++++++++++----
 server/package-lock.json               |  6 ++++
 server/src/models/ScriptResponseSet.ts |  3 +-
 server/src/server.ts                   | 30 ++++++++++++++++++
 5 files changed, 109 insertions(+), 15 deletions(-)

diff --git a/client/package-lock.json b/client/package-lock.json
index 02be0646..7089679f 100644
--- a/client/package-lock.json
+++ b/client/package-lock.json
@@ -75,6 +75,7 @@
       "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.28.5.tgz",
       "integrity": "sha512-e7jT4DxYvIDLk1ZHmU/m/mB19rex9sv0c2ftBtjSBv+kVM/902eh0fINUzD7UwLLNR+jU585GxUJ8/EBfAM5fw==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@babel/code-frame": "^7.27.1",
         "@babel/generator": "^7.28.5",
@@ -724,6 +725,7 @@
       "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-flow/-/plugin-syntax-flow-7.27.1.tgz",
       "integrity": "sha512-p9OkPbZ5G7UT1MofwYFigGebnrzGJacoBSQM0/6bi/PUMVE+qlWDD/OalvQKbwgQzU6dl0xAv6r4X7Jme0RYxA==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@babel/helper-plugin-utils": "^7.27.1"
       },
@@ -1607,6 +1609,7 @@
       "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx/-/plugin-transform-react-jsx-7.27.1.tgz",
       "integrity": "sha512-2KH4LWGSrJIkVf5tSiBFYuXDAoWRq2MMwgivCf+93dd0GQi8RXLjKA/0EvRnVV5G0hrHczsquXuD01L8s6dmBw==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@babel/helper-annotate-as-pure": "^7.27.1",
         "@babel/helper-module-imports": "^7.27.1",
@@ -2425,6 +2428,7 @@
       "integrity": "sha512-b7W4snvXYi1T2puUjxamASCCNhNzVSzb/fQUuGSkdjm/AFfJ24jo8kOHQyOcaoArCG71sVQci4vkZaITzl/V1w==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@cucumber/ci-environment": "10.0.1",
         "@cucumber/cucumber-expressions": "18.0.1",
@@ -2670,6 +2674,7 @@
       "integrity": "sha512-659CCFsrsyvuBi/Eix1fnhSheMnojSfnBcqJ3IMPNawx7JlrNJDcXYSSdxcUw3n/nG05P+ptCjmiZY3i14p+tA==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@cucumber/messages": ">=19.1.4 <29"
       }
@@ -2826,6 +2831,7 @@
       "integrity": "sha512-Kxap9uP5jD8tHUZVjTWgzxemi/0uOsbGjd4LBOSxcJoOCRbESFwemUzilJuzNTB8pcTQUh8D5oudUyxfkJOKmA==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "peerDependencies": {
         "@cucumber/messages": ">=17.1.1"
       }
@@ -2836,6 +2842,7 @@
       "integrity": "sha512-2LzZtOwYKNlCuNf31ajkrekoy2M4z0Z1QGiPH40n4gf5t8VOUFb7m1ojtR4LmGvZxBGvJZP8voOmRqDWzBzYKA==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@types/uuid": "10.0.0",
         "class-transformer": "0.5.1",
@@ -3869,7 +3876,6 @@
       "integrity": "sha512-b0P0sZPKtyu8HkeRAfCq0IfURZK+SuwMjY1UXGBU27wpAiTwQAIlq56IbIO+ytk/JjS1fMR14ee5WBBfKi5J6A==",
       "dev": true,
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "dequal": "^2.0.3"
       }
@@ -4001,8 +4007,7 @@
       "resolved": "https://registry.npmjs.org/@types/aria-query/-/aria-query-5.0.4.tgz",
       "integrity": "sha512-rfT93uj5s0PRL7EzccGMs3brplhcrghnDoV26NqKhCAS1hVo+WdNsPvE/yb6ilfr5hi2MEk6d5EWJTKdxg8jVw==",
       "dev": true,
-      "license": "MIT",
-      "peer": true
+      "license": "MIT"
     },
     "node_modules/@types/babel__core": {
       "version": "7.20.5",
@@ -4415,6 +4420,7 @@
       "resolved": "https://registry.npmjs.org/@types/node/-/node-24.10.0.tgz",
       "integrity": "sha512-qzQZRBqkFsYyaSWXuEHc2WR9c0a0CXwiE5FWUvn7ZM+vdy1uZLfCunD38UzhuB7YN/J11ndbDBcTmOdxJo9Q7A==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "undici-types": "~7.16.0"
       }
@@ -4488,6 +4494,7 @@
       "integrity": "sha512-RFA/bURkcKzx/X9oumPG9Vp3D3JUgus/d0b67KB0t5S/raciymilkOa66olh78MUI92QLbEJevO7rvqU/kjwKA==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@types/prop-types": "*",
         "csstype": "^3.0.2"
@@ -4499,6 +4506,7 @@
       "integrity": "sha512-MEe3UeoENYVFXzoXEWsvcpg6ZvlrFNlOQ7EOsvhI3CfAXwzPfO8Qwuxd40nepsYKqyyVQnTdEfv68q91yLcKrQ==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "peerDependencies": {
         "@types/react": "^18.0.0"
       }
@@ -4631,6 +4639,7 @@
       "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-5.62.0.tgz",
       "integrity": "sha512-TiZzBSJja/LbhNPvk6yc0JrX9XqhQ0hdh6M2svYfsHGejaKFIAGd9MQ+ERIMzLGlN/kZoYIgdxFV0PuljTKXag==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@eslint-community/regexpp": "^4.4.0",
         "@typescript-eslint/scope-manager": "5.62.0",
@@ -4684,6 +4693,7 @@
       "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-5.62.0.tgz",
       "integrity": "sha512-VlJEV0fOQ7BExOsHYAGrgbEiZoi8D+Bl2+f6V2RrXerRSylnp+ZBHmPvaIa8cz0Ajx7WO7Z5RqfgYg7ED1nRhA==",
       "license": "BSD-2-Clause",
+      "peer": true,
       "dependencies": {
         "@typescript-eslint/scope-manager": "5.62.0",
         "@typescript-eslint/types": "5.62.0",
@@ -5053,6 +5063,7 @@
       "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz",
       "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
       "license": "MIT",
+      "peer": true,
       "bin": {
         "acorn": "bin/acorn"
       },
@@ -5162,6 +5173,7 @@
       "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
       "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "fast-deep-equal": "^3.1.1",
         "fast-json-stable-stringify": "^2.0.0",
@@ -6204,6 +6216,7 @@
         }
       ],
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "baseline-browser-mapping": "^2.8.19",
         "caniuse-lite": "^1.0.30001751",
@@ -7526,7 +7539,6 @@
       "integrity": "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "engines": {
         "node": ">=6"
       }
@@ -7593,7 +7605,8 @@
       "resolved": "https://registry.npmjs.org/devtools-protocol/-/devtools-protocol-0.0.1521046.tgz",
       "integrity": "sha512-vhE6eymDQSKWUXwwA37NtTTVEzjtGVfDr3pRbsWEQ5onH/Snp2c+2xZHWJJawG/0hCCJLRGt4xVtEVUVILol4w==",
       "dev": true,
-      "license": "BSD-3-Clause"
+      "license": "BSD-3-Clause",
+      "peer": true
     },
     "node_modules/didyoumean": {
       "version": "1.2.2",
@@ -7667,8 +7680,7 @@
       "resolved": "https://registry.npmjs.org/dom-accessibility-api/-/dom-accessibility-api-0.5.16.tgz",
       "integrity": "sha512-X7BJ2yElsnOJ30pZF4uIIDfBEVgF4XEBxL9Bxhy6dnrm5hkzqmsWHGTiHqRiITNhMyFLyAiWndIJP7Z1NTteDg==",
       "dev": true,
-      "license": "MIT",
-      "peer": true
+      "license": "MIT"
     },
     "node_modules/dom-converter": {
       "version": "0.2.0",
@@ -8163,6 +8175,7 @@
       "integrity": "sha512-ypowyDxpVSYpkXr9WPv2PAZCtNip1Mv5KTW0SCurXv/9iOpcrH9PaqUElksqEB6pChqHGDRCFTyrZlGhnLNGiA==",
       "deprecated": "This version is no longer supported. Please see https://eslint.org/version-support for other options.",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@eslint-community/eslint-utils": "^4.2.0",
         "@eslint-community/regexpp": "^4.6.1",
@@ -11915,6 +11928,7 @@
       "resolved": "https://registry.npmjs.org/jiti/-/jiti-1.21.7.tgz",
       "integrity": "sha512-/imKNG4EbWNrVjoNC/1H5/9GFy+tqjGBHCaSsN+P2RnPqjsLmv6UD3Ej+Kj8nBWaRAwyk7kK5ZUc+OEatnTR3A==",
       "license": "MIT",
+      "peer": true,
       "bin": {
         "jiti": "bin/jiti.js"
       }
@@ -12396,7 +12410,6 @@
       "integrity": "sha512-h5bgJWpxJNswbU7qCrV0tIKQCaS3blPDrqKWx+QxzuzL1zGUzij9XCWLrSLsJPu5t+eWA/ycetzYAO5IOMcWAQ==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "bin": {
         "lz-string": "bin/bin.js"
       }
@@ -13481,6 +13494,7 @@
         }
       ],
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "nanoid": "^3.3.11",
         "picocolors": "^1.1.1",
@@ -14615,6 +14629,7 @@
       "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz",
       "integrity": "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "cssesc": "^3.0.0",
         "util-deprecate": "^1.0.2"
@@ -15127,6 +15142,7 @@
       "resolved": "https://registry.npmjs.org/react/-/react-18.3.1.tgz",
       "integrity": "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "loose-envify": "^1.1.0"
       },
@@ -15261,6 +15277,7 @@
       "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-18.3.1.tgz",
       "integrity": "sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "loose-envify": "^1.1.0",
         "scheduler": "^0.23.2"
@@ -15286,6 +15303,7 @@
       "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.11.0.tgz",
       "integrity": "sha512-F27qZr8uUqwhWZboondsPx8tnC3Ct3SxZA3V5WyEvujRyyNv0VYPhoBg1gZ8/MV5tubQp76Trw8lTv9hzRBa+A==",
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=0.10.0"
       }
@@ -15678,6 +15696,7 @@
       "resolved": "https://registry.npmjs.org/jest/-/jest-27.5.1.tgz",
       "integrity": "sha512-Yn0mADZB89zTtjkPJEXwrac3LHudkQMR+Paqa8uxJHCBr9agxztUifWCyiYrjhMPBoUVBjyny0I7XH6ozDr7QQ==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@jest/core": "^27.5.1",
         "import-local": "^3.0.2",
@@ -16843,6 +16862,7 @@
       "resolved": "https://registry.npmjs.org/rollup/-/rollup-2.79.2.tgz",
       "integrity": "sha512-fS6iqSPZDs3dr/y7Od6y5nha8dW1YnbgtsyotCVvoFGKbERG++CVRFv1meyGDE1SNItQA8BrnCw7ScdAhRJ3XQ==",
       "license": "MIT",
+      "peer": true,
       "bin": {
         "rollup": "dist/bin/rollup"
       },
@@ -17088,6 +17108,7 @@
       "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz",
       "integrity": "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "fast-deep-equal": "^3.1.3",
         "fast-uri": "^3.0.1",
@@ -18879,6 +18900,7 @@
       "integrity": "sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ==",
       "devOptional": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@cspotcode/source-map-support": "^0.8.0",
         "@tsconfig/node10": "^1.0.7",
@@ -19010,6 +19032,7 @@
       "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz",
       "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==",
       "license": "(MIT OR CC0-1.0)",
+      "peer": true,
       "engines": {
         "node": ">=10"
       },
@@ -19125,6 +19148,7 @@
       "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.9.5.tgz",
       "integrity": "sha512-1FXk9E2Hm+QzZQ7z+McJiHL4NW1F2EzMu9Nq9i3zAaGqibafqYwCVU6WyWAuyQRRzOlxou8xZSyXLEN8oKj24g==",
       "license": "Apache-2.0",
+      "peer": true,
       "bin": {
         "tsc": "bin/tsc",
         "tsserver": "bin/tsserver"
@@ -19474,6 +19498,7 @@
       "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.102.1.tgz",
       "integrity": "sha512-7h/weGm9d/ywQ6qzJ+Xy+r9n/3qgp/thalBbpOi5i223dPXKi04IBtqPN9nTd+jBc7QKfvDbaBnFipYp4sJAUQ==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@types/eslint-scope": "^3.7.7",
         "@types/estree": "^1.0.8",
@@ -19545,6 +19570,7 @@
       "resolved": "https://registry.npmjs.org/webpack-dev-server/-/webpack-dev-server-4.15.2.tgz",
       "integrity": "sha512-0XavAZbNJ5sDrCbkpWL8mia0o5WPOd2YGtxrEiZkBK9FjLppIUK2TgxK6qGD2P3hUXTJNNPVibrerKcx5WkR1g==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@types/bonjour": "^3.5.9",
         "@types/connect-history-api-fallback": "^1.3.5",
@@ -19936,6 +19962,7 @@
       "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz",
       "integrity": "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "fast-deep-equal": "^3.1.3",
         "fast-uri": "^3.0.1",
diff --git a/package-lock.json b/package-lock.json
index 11720a46..5f18ab05 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -408,6 +408,7 @@
     "client/node_modules/@babel/plugin-syntax-flow": {
       "version": "7.27.1",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@babel/helper-plugin-utils": "^7.27.1"
       },
@@ -1030,6 +1031,7 @@
     "client/node_modules/@babel/plugin-transform-react-jsx": {
       "version": "7.27.1",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@babel/helper-annotate-as-pure": "^7.27.1",
         "@babel/helper-module-imports": "^7.27.1",
@@ -2550,6 +2552,7 @@
       "version": "18.3.26",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@types/prop-types": "*",
         "csstype": "^3.0.2"
@@ -2613,6 +2616,7 @@
     "client/node_modules/@typescript-eslint/eslint-plugin": {
       "version": "5.62.0",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@eslint-community/regexpp": "^4.4.0",
         "@typescript-eslint/scope-manager": "5.62.0",
@@ -2662,6 +2666,7 @@
     "client/node_modules/@typescript-eslint/parser": {
       "version": "5.62.0",
       "license": "BSD-2-Clause",
+      "peer": true,
       "dependencies": {
         "@typescript-eslint/scope-manager": "5.62.0",
         "@typescript-eslint/types": "5.62.0",
@@ -3036,6 +3041,7 @@
     "client/node_modules/ajv": {
       "version": "6.12.6",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "fast-deep-equal": "^3.1.1",
         "fast-json-stable-stringify": "^2.0.0",
@@ -4899,6 +4905,7 @@
     "client/node_modules/eslint": {
       "version": "8.57.1",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@eslint-community/eslint-utils": "^4.2.0",
         "@eslint-community/regexpp": "^4.6.1",
@@ -6844,6 +6851,7 @@
     "client/node_modules/jest": {
       "version": "27.5.1",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@jest/core": "^27.5.1",
         "import-local": "^3.0.2",
@@ -7622,6 +7630,7 @@
     "client/node_modules/jiti": {
       "version": "1.21.7",
       "license": "MIT",
+      "peer": true,
       "bin": {
         "jiti": "bin/jiti.js"
       }
@@ -8356,6 +8365,7 @@
         }
       ],
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "nanoid": "^3.3.11",
         "picocolors": "^1.1.1",
@@ -9354,6 +9364,7 @@
     "client/node_modules/postcss-selector-parser": {
       "version": "6.1.2",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "cssesc": "^3.0.0",
         "util-deprecate": "^1.0.2"
@@ -9738,6 +9749,7 @@
     "client/node_modules/react-refresh": {
       "version": "0.11.0",
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=0.10.0"
       }
@@ -10070,6 +10082,7 @@
     "client/node_modules/rollup": {
       "version": "2.79.2",
       "license": "MIT",
+      "peer": true,
       "bin": {
         "rollup": "dist/bin/rollup"
       },
@@ -10257,6 +10270,7 @@
     "client/node_modules/schema-utils/node_modules/ajv": {
       "version": "8.17.1",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "fast-deep-equal": "^3.1.3",
         "fast-uri": "^3.0.1",
@@ -11351,6 +11365,7 @@
     "client/node_modules/type-fest": {
       "version": "0.20.2",
       "license": "(MIT OR CC0-1.0)",
+      "peer": true,
       "engines": {
         "node": ">=10"
       },
@@ -11633,6 +11648,7 @@
     "client/node_modules/webpack": {
       "version": "5.102.1",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@types/eslint-scope": "^3.7.7",
         "@types/estree": "^1.0.8",
@@ -11700,6 +11716,7 @@
     "client/node_modules/webpack-dev-server": {
       "version": "4.15.2",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@types/bonjour": "^3.5.9",
         "@types/connect-history-api-fallback": "^1.3.5",
@@ -12049,6 +12066,7 @@
     "client/node_modules/workbox-build/node_modules/ajv": {
       "version": "8.17.1",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "fast-deep-equal": "^3.1.3",
         "fast-uri": "^3.0.1",
@@ -12339,6 +12357,7 @@
       "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.28.5.tgz",
       "integrity": "sha512-e7jT4DxYvIDLk1ZHmU/m/mB19rex9sv0c2ftBtjSBv+kVM/902eh0fINUzD7UwLLNR+jU585GxUJ8/EBfAM5fw==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@babel/code-frame": "^7.27.1",
         "@babel/generator": "^7.28.5",
@@ -12855,6 +12874,7 @@
       "integrity": "sha512-b7W4snvXYi1T2puUjxamASCCNhNzVSzb/fQUuGSkdjm/AFfJ24jo8kOHQyOcaoArCG71sVQci4vkZaITzl/V1w==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@cucumber/ci-environment": "10.0.1",
         "@cucumber/cucumber-expressions": "18.0.1",
@@ -12939,6 +12959,7 @@
       "integrity": "sha512-659CCFsrsyvuBi/Eix1fnhSheMnojSfnBcqJ3IMPNawx7JlrNJDcXYSSdxcUw3n/nG05P+ptCjmiZY3i14p+tA==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@cucumber/messages": ">=19.1.4 <29"
       }
@@ -13095,6 +13116,7 @@
       "integrity": "sha512-Kxap9uP5jD8tHUZVjTWgzxemi/0uOsbGjd4LBOSxcJoOCRbESFwemUzilJuzNTB8pcTQUh8D5oudUyxfkJOKmA==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "peerDependencies": {
         "@cucumber/messages": ">=17.1.1"
       }
@@ -13105,6 +13127,7 @@
       "integrity": "sha512-2LzZtOwYKNlCuNf31ajkrekoy2M4z0Z1QGiPH40n4gf5t8VOUFb7m1ojtR4LmGvZxBGvJZP8voOmRqDWzBzYKA==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@types/uuid": "10.0.0",
         "class-transformer": "0.5.1",
@@ -14197,8 +14220,7 @@
       "resolved": "https://registry.npmjs.org/@types/aria-query/-/aria-query-5.0.4.tgz",
       "integrity": "sha512-rfT93uj5s0PRL7EzccGMs3brplhcrghnDoV26NqKhCAS1hVo+WdNsPvE/yb6ilfr5hi2MEk6d5EWJTKdxg8jVw==",
       "dev": true,
-      "license": "MIT",
-      "peer": true
+      "license": "MIT"
     },
     "node_modules/@types/babel__core": {
       "version": "7.20.5",
@@ -14327,6 +14349,7 @@
       "integrity": "sha512-XTYugzhuwqWjws0CVz8QpM36+T+Dz5mTEBKhNs/esGLnCIlGdRy+Dq78NRjd7ls7r8BC8ZRMOrKlkO1hU0JOwA==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "expect": "^30.0.0",
         "pretty-format": "^30.0.0"
@@ -14802,6 +14825,7 @@
       "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz",
       "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
       "license": "MIT",
+      "peer": true,
       "bin": {
         "acorn": "bin/acorn"
       },
@@ -15242,6 +15266,7 @@
         }
       ],
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "baseline-browser-mapping": "^2.8.25",
         "caniuse-lite": "^1.0.30001754",
@@ -15795,7 +15820,8 @@
       "resolved": "https://registry.npmjs.org/devtools-protocol/-/devtools-protocol-0.0.1521046.tgz",
       "integrity": "sha512-vhE6eymDQSKWUXwwA37NtTTVEzjtGVfDr3pRbsWEQ5onH/Snp2c+2xZHWJJawG/0hCCJLRGt4xVtEVUVILol4w==",
       "dev": true,
-      "license": "BSD-3-Clause"
+      "license": "BSD-3-Clause",
+      "peer": true
     },
     "node_modules/dezalgo": {
       "version": "1.0.4",
@@ -15823,8 +15849,7 @@
       "resolved": "https://registry.npmjs.org/dom-accessibility-api/-/dom-accessibility-api-0.5.16.tgz",
       "integrity": "sha512-X7BJ2yElsnOJ30pZF4uIIDfBEVgF4XEBxL9Bxhy6dnrm5hkzqmsWHGTiHqRiITNhMyFLyAiWndIJP7Z1NTteDg==",
       "dev": true,
-      "license": "MIT",
-      "peer": true
+      "license": "MIT"
     },
     "node_modules/dunder-proto": {
       "version": "1.0.1",
@@ -16901,6 +16926,7 @@
       "integrity": "sha512-F26gjC0yWN8uAA5m5Ss8ZQf5nDHWGlN/xWZIh8S5SRbsEKBovwZhxGd6LJlbZYxBgCYOtreSUyb8hpXyGC5O4A==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@jest/core": "30.2.0",
         "@jest/types": "30.2.0",
@@ -18322,7 +18348,6 @@
       "integrity": "sha512-h5bgJWpxJNswbU7qCrV0tIKQCaS3blPDrqKWx+QxzuzL1zGUzij9XCWLrSLsJPu5t+eWA/ycetzYAO5IOMcWAQ==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "bin": {
         "lz-string": "bin/bin.js"
       }
@@ -19078,6 +19103,7 @@
       "resolved": "https://registry.npmjs.org/react/-/react-18.3.1.tgz",
       "integrity": "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "loose-envify": "^1.1.0"
       },
@@ -19090,6 +19116,7 @@
       "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-18.3.1.tgz",
       "integrity": "sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "loose-envify": "^1.1.0",
         "scheduler": "^0.23.2"
@@ -20089,6 +20116,7 @@
       "integrity": "sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ==",
       "devOptional": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@cspotcode/source-map-support": "^0.8.0",
         "@tsconfig/node10": "^1.0.7",
@@ -20186,6 +20214,7 @@
       "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.9.5.tgz",
       "integrity": "sha512-1FXk9E2Hm+QzZQ7z+McJiHL4NW1F2EzMu9Nq9i3zAaGqibafqYwCVU6WyWAuyQRRzOlxou8xZSyXLEN8oKj24g==",
       "license": "Apache-2.0",
+      "peer": true,
       "bin": {
         "tsc": "bin/tsc",
         "tsserver": "bin/tsserver"
@@ -21376,6 +21405,7 @@
       "version": "5.9.3",
       "dev": true,
       "license": "Apache-2.0",
+      "peer": true,
       "bin": {
         "tsc": "bin/tsc",
         "tsserver": "bin/tsserver"
diff --git a/server/package-lock.json b/server/package-lock.json
index f63df85d..0bb93186 100644
--- a/server/package-lock.json
+++ b/server/package-lock.json
@@ -58,6 +58,7 @@
       "integrity": "sha512-e7jT4DxYvIDLk1ZHmU/m/mB19rex9sv0c2ftBtjSBv+kVM/902eh0fINUzD7UwLLNR+jU585GxUJ8/EBfAM5fw==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@babel/code-frame": "^7.27.1",
         "@babel/generator": "^7.28.5",
@@ -1565,6 +1566,7 @@
       "integrity": "sha512-FE5u0ezmi6y9OZEzlJfg37mqqf6ZDSF2V/NLjUyGrR9uTZ7Sb9F7bLNZ03S4XVUNRWGA7Ck4c1kK+YnuWjl+DA==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "undici-types": "~6.21.0"
       }
@@ -2289,6 +2291,7 @@
         }
       ],
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "baseline-browser-mapping": "^2.8.25",
         "caniuse-lite": "^1.0.30001754",
@@ -3792,6 +3795,7 @@
       "integrity": "sha512-F26gjC0yWN8uAA5m5Ss8ZQf5nDHWGlN/xWZIh8S5SRbsEKBovwZhxGd6LJlbZYxBgCYOtreSUyb8hpXyGC5O4A==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@jest/core": "30.2.0",
         "@jest/types": "30.2.0",
@@ -6013,6 +6017,7 @@
       "integrity": "sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@cspotcode/source-map-support": "^0.8.0",
         "@tsconfig/node10": "^1.0.7",
@@ -6155,6 +6160,7 @@
       "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
       "dev": true,
       "license": "Apache-2.0",
+      "peer": true,
       "bin": {
         "tsc": "bin/tsc",
         "tsserver": "bin/tsserver"
diff --git a/server/src/models/ScriptResponseSet.ts b/server/src/models/ScriptResponseSet.ts
index 2911fdba..ba55a027 100644
--- a/server/src/models/ScriptResponseSet.ts
+++ b/server/src/models/ScriptResponseSet.ts
@@ -1,6 +1,7 @@
 import { ScriptResponse } from './ScriptResponse';
 import { Script } from './Script';
 import { Enrollment } from './Enrollment';
+import { v4 as uuid } from 'uuid';
 export class ScriptResponseSet {
   private items: ScriptResponse[] = [];
 
@@ -13,7 +14,7 @@ export class ScriptResponseSet {
     status?: 'in_progress' | 'finished';
     answers?: any[];
   }): ScriptResponse {
-    const id = `${data.enrollment.getStudent().getCPF()}-${data.script.getId()}`;
+    const id = data.id ?? uuid();
     const scriptresponse = new ScriptResponse(id, data.script, data.enrollment, data.started_at);
     if (data.finished_at !== undefined) scriptresponse.update({ finished_at: data.finished_at });
     if (data.status !== undefined) scriptresponse.update({ status: data.status });
diff --git a/server/src/server.ts b/server/src/server.ts
index 9be51e80..0e13866c 100644
--- a/server/src/server.ts
+++ b/server/src/server.ts
@@ -7,6 +7,7 @@ import { Classes } from './models/Classes';
 import { Class } from './models/Class';
 import { Report } from './models/Report';
 import { Scripts } from './models/Scripts';
+import { ScriptResponseSet } from './models/ScriptResponseSet';
 import * as fs from 'fs';
 import * as path from 'path';
 import { EspecificacaoDoCalculoDaMedia, DEFAULT_ESPECIFICACAO_DO_CALCULO_DA_MEDIA } from './models/EspecificacaoDoCalculoDaMedia';
@@ -31,6 +32,7 @@ const classes = new Classes();
 const dataFile = path.resolve('./data/app-data.json');
 const scripts = new Scripts();
 const taskset = new TaskSet();
+const scriptResponseSet = new ScriptResponseSet();
 
 // Persistence functions
 const ensureDataDirectory = (): void => {
@@ -600,3 +602,31 @@ app.put('/api/scripts/:id', (req: Request, res: Response) => {
   if (!script) return res.status(404).json({ error: 'Script not found' });
   res.json(script.toJSON());
 });
+
+app.post('/api/scriptResponses', (req, res) => {
+  const { scriptId, studentCPF, classId } = req.body;
+  const script = scripts.findById(scriptId);
+  const classObj = classes.findClassById(classId);
+
+  if (!script || !classObj) {
+    return res.status(404).json({ error: 'Script or Class not found' });
+  }
+
+  const enrollment = classObj.findEnrollmentByStudentCPF(studentCPF);
+  
+  if (!enrollment) { 
+    return res.status(404).json({ error: 'Student not enrolled in this class' });
+  }
+  
+  const response = scriptResponseSet.createOrGetActiveScriptResponse(enrollment, script);
+  res.json(response.toJSON());
+});
+
+// GET /api/script-responses/:id
+app.get('/api/scriptResponses/:id', (req, res) => {
+  const response = scriptResponseSet.findById(req.params.id);
+  if (!response) {
+    return res.status(404).json({ error: 'ScriptResponse not found' });
+  }
+  res.json(response.toJSON());
+});

From ad551b0824e641b1e620b704076dd4f9159f1df9 Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Mon, 8 Dec 2025 21:09:37 -0300
Subject: [PATCH 049/102] feat: add taskanswer to scriptanswer object route

---
 server/src/server_routes/scriptanswer.ts | 68 +++++++++++++++++++++++-
 1 file changed, 66 insertions(+), 2 deletions(-)

diff --git a/server/src/server_routes/scriptanswer.ts b/server/src/server_routes/scriptanswer.ts
index 8d64238f..1525947c 100644
--- a/server/src/server_routes/scriptanswer.ts
+++ b/server/src/server_routes/scriptanswer.ts
@@ -1,4 +1,5 @@
 import { Request, Response, Express } from 'express';
+import { TaskAnswer } from '../models/TaskAnswer';
 
 export function setupScriptAnswerRoutes(app: Express, scriptAnswerSet: any, studentSet: any) {
   const scriptAnswerurl = '/api/scriptanswers/';
@@ -73,7 +74,53 @@ export function setupScriptAnswerRoutes(app: Express, scriptAnswerSet: any, stud
     }
   });
 
-  // PUT /api/scriptanswers/:id/tasks/:taskId → Update grade
+  // POST /api/scriptanswers/:id/tasks → Add a new task answer to a script answer
+  app.post(scriptAnswerurl+':id/tasks', (req: Request, res: Response) => {
+    const { id } = req.params;
+    const { taskAnswerId, taskId, answer, grade, comments } = req.body;
+
+    // Validate required fields
+    if (!taskAnswerId || !taskId) {
+      return res.status(400).json({ error: 'Missing required fields: taskAnswerId and taskId' });
+    }
+
+    try {
+      const scriptAnswer = scriptAnswerSet.findById(id);
+      if (!scriptAnswer) {
+        return res.status(404).json({ error: 'ScriptAnswer not found' });
+      }
+
+      // Check if task answer already exists
+      const existingTask = scriptAnswer.findAnswerByTaskId(taskId);
+      if (existingTask) {
+        return res.status(409).json({ error: 'Task answer already exists for this task' });
+      }
+
+      // Create new TaskAnswer
+      const newTaskAnswer = new TaskAnswer(
+        taskAnswerId,
+        taskId,
+        answer || '',
+        grade,
+        comments
+      );
+
+      // Add the task answer to the script answer
+      scriptAnswer.addAnswer(newTaskAnswer);
+
+      return res.status(201).json({
+        id: taskAnswerId,
+        taskId,
+        answer: answer || '',
+        grade: grade || undefined,
+        comments: comments || undefined
+      });
+    } catch (error) {
+      return res.status(400).json({ error: (error as Error).message });
+    }
+  });
+
+  // PUT /api/scriptanswers/:id/tasks/:taskId → Update task answer grade
   app.put(scriptAnswerurl+':id/tasks/:taskId', (req: Request, res: Response) => {
     const { id, taskId } = req.params;
     const { grade } = req.body;
@@ -96,7 +143,7 @@ export function setupScriptAnswerRoutes(app: Express, scriptAnswerSet: any, stud
     return res.status(200).json({ taskId, grade });
   });
 
-  // PUT /api/scriptanswers/:id/tasks/:taskId/comments → Add comment to task
+  // PUT /api/scriptanswers/:id/tasks/:taskId/comments → Update task answer comments
   app.put(scriptAnswerurl+':id/tasks/:taskId/comments', (req: Request, res: Response) => {
     const { id, taskId } = req.params;
     const { comment } = req.body;
@@ -116,6 +163,23 @@ export function setupScriptAnswerRoutes(app: Express, scriptAnswerSet: any, stud
     return res.status(200).json({ taskId, comment });
   });
 
+  // DELETE /api/scriptanswers/:id/tasks/:taskId → Remove a task answer from script answer
+  app.delete(scriptAnswerurl+':id/tasks/:taskId', (req: Request, res: Response) => {
+    const { id, taskId } = req.params;
+
+    const scriptAnswer = scriptAnswerSet.findById(id);
+    if (!scriptAnswer) {
+      return res.status(404).json({ error: 'ScriptAnswer not found' });
+    }
+
+    const removed = scriptAnswer.removeAnswer(taskId);
+    if (!removed) {
+      return res.status(404).json({ error: 'Task not found' });
+    }
+
+    return res.status(200).json({ message: 'Task answer removed successfully', taskId });
+  });
+
   // DELETE /api/scriptanswers/:id → Delete a script answer by ID
   app.delete(scriptAnswerurl+':id', (req: Request, res: Response) => {
     const { id } = req.params;

From a99097ef5525a99eff519ca30278b6959d6f74e7 Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Mon, 8 Dec 2025 21:11:10 -0300
Subject: [PATCH 050/102] testing/NOT FUNCTIONAL: cureently broken tests for
 adding taskanswer to scriptanswer

---
 .../server-scriptAnswer-management.feature    | 121 ++------------
 .../server-scriptAnswer-steps.ts              | 156 +++++++++++++++++-
 2 files changed, 166 insertions(+), 111 deletions(-)

diff --git a/client/src/features/server-scriptAnswer-management.feature b/client/src/features/server-scriptAnswer-management.feature
index 47a24c9d..19104331 100644
--- a/client/src/features/server-scriptAnswer-management.feature
+++ b/client/src/features/server-scriptAnswer-management.feature
@@ -13,32 +13,34 @@ Feature: Server Script Answers Management
 
   Scenario: Retrieve all registered script answers
     Given there are script answers registered with IDs "123", "321", "890"
-    When I send a GET request to "/api/scripts/answers"
-    Then the server should return 200 OK
+    When I send a GET request to "/api/scriptanswers"
+    Then the server should return 200 "OK"
     And the server should return a list containing answers "123", "321", "890"
 
   Scenario: Retrieve script answers when none exist
     Given there are no script answers registered
-    When I send a GET request to "/api/scripts/answers"
-    Then the server should return 200 OK
+    When I send a GET request to "/api/scriptanswers"
+    Then the server should return 200 "OK"
     And the server should return an empty list
 
+
   # ============================================================
   # Retrieval by student (CPF-based)
   # ============================================================
 
   Scenario: Retrieve answers of a registered student
     Given there is a student with CPF "12345678901"
-    And this student has script answers with IDs "40", "41"
-    When I send a GET request to "/api/scripts/answers/student/12345678901"
+    And this student has script answers with IDs "40", "41", "43"
+    When I send a GET request to "/api/scriptanswers/student/12345678901"
     Then the server should return 200 OK
-    And the server should return a list containing answers "40", "41"
+    And the server should return a list containing answers "40", "41", "43"
 
   Scenario: Attempt to retrieve answers of a non-existent student
     Given there is no student with CPF "99999999999"
-    When I send a GET request to "/api/scripts/answers/student/99999999999"
-    Then the server should return 404 Not Found
-    And the server should return an error message stating the student was not found
+    When I send a GET request to "/api/scriptanswers/student/99999999999"
+    Then the server should return 404 "Not Found"
+    And the server should return an error message "student not found"
+
 
   # ============================================================
   # Retrieval of grade for specific task
@@ -47,104 +49,13 @@ Feature: Server Script Answers Management
   Scenario: Retrieve grade of an existing task in an answer
     Given there is a script answer with ID "50"
     And this answer contains a task with ID "2" and grade "MA"
-    When I send a GET request to "/api/scripts/answers/50/tasks/2"
-    Then the server should return 200 OK
+    When I send a GET request to "/api/scriptanswers/50/tasks/2"
+    Then the server should return 200 "OK"
     And the server should return grade "MA"
 
   Scenario: Attempt to retrieve grade for a missing task
     Given there is a script answer with ID "50"
     And this answer does not contain a task with ID "9"
-    When I send a GET request to "/api/scripts/answers/50/tasks/9"
-    Then the server should return 404 Not Found
-    And the server should return an error message stating the task was not found
-
-  # ============================================================
-  # Updating grades
-  # ============================================================
-
-  Scenario: Update grade of an existing task with a valid value
-    Given there is a script answer with ID "50"
-    And this answer contains a task with ID "3" and grade "MANA"
-    When I send a PUT request to "/api/scripts/answers/50/tasks/3" with:
-      | field | value |
-      | grade | MPA   |
-    Then the server should return 200 OK
-    And the server should update the task grade to "MPA"
-    And the server should return the updated grade
-
-  Scenario: Attempt to update grade with an invalid value
-    Given there is a script answer with ID "50"
-    And this answer contains a task with ID "3"
-    When I send a PUT request to "/api/scripts/answers/50/tasks/3" with:
-      | field | value |
-      | grade | AAA   |
-    Then the server should return 400 Bad Request
-    And the server should return an error message stating the grade is invalid
-
-  # ============================================================
-  # Retrieval by ID
-  # ============================================================
-
-  Scenario: Retrieve a script answer by ID
-    Given there is a script answer registered with ID "123"
-    When I send a GET request to "/api/scripts/answers/123"
-    Then the server should return 200 OK
-    And the server should return the script answer with ID "123"
-
-  Scenario: Attempt to retrieve a non-existent script answer
-    Given there is no script answer registered with ID "777"
-    When I send a GET request to "/api/scripts/answers/777"
-    Then the server should return 404 Not Found
-    And the server should return an error message stating the script answer was not found
-
-  # ============================================================
-  # Updating script-level comments
-  # ============================================================
-
-  Scenario: Successfully add a comment to a script answer
-    Given there is a script answer with ID "50"
-    When I send a PUT request to "/api/scripts/answers/50/comments" with:
-      | field   | value               |
-      | comment | Reveja a explicação |
-    Then the server should return 200 OK
-    And the server should store the comment in the script answer with ID "50"
-    And the server should return the updated comment
-
-  Scenario: Attempt to add a comment to a non-existent script answer
-    Given there is no script answer with ID "777"
-    When I send a PUT request to "/api/scripts/answers/777/comments" with:
-      | field   | value        |
-      | comment | Bom trabalho |
-    Then the server should return 404 Not Found
-    And the server should return an error message stating the script answer was not found
-
-  # ============================================================
-  # Updating task-level comments
-  # ============================================================
-
-  Scenario: Successfully add a comment to a task inside a script answer
-    Given there is a script answer with ID "50"
-    And this answer contains a task with ID "3"
-    When I send a PUT request to "/api/scripts/answers/50/tasks/3/comments" with:
-      | field   | value                                   |
-      | comment | Correto, mas poderia detalhar melhor    |
-    Then the server should return 200 OK
-    And the server should store the comment in task "3"
-    And the server should return the updated comment
-
-  Scenario: Attempt to add a comment to a non-existent task inside a script answer
-    Given there is a script answer with ID "50"
-    And this answer does not contain a task with ID "999"
-    When I send a PUT request to "/api/scripts/answers/50/tasks/999/comments" with:
-      | field   | value     |
-      | comment | Verifique |
-    Then the server should return 404 Not Found
+    When I send a GET request to "/api/scriptanswers/50/tasks/9"
+    Then the server should return 404 "Not Found"
     And the server should return an error message stating the task was not found
-
-  Scenario: Attempt to add a comment to a task inside a non-existent script answer
-    Given there is no script answer with ID "888"
-    When I send a PUT request to "/api/scripts/answers/888/tasks/3/comments" with:
-      | field   | value                    |
-      | comment | Precisa revisar este ponto |
-    Then the server should return 404 Not Found
-    And the server should return an error message stating the script answer was not found
diff --git a/client/src/step-definitions/server-scriptAnswer-steps.ts b/client/src/step-definitions/server-scriptAnswer-steps.ts
index 74af30d8..9cac9697 100644
--- a/client/src/step-definitions/server-scriptAnswer-steps.ts
+++ b/client/src/step-definitions/server-scriptAnswer-steps.ts
@@ -10,6 +10,7 @@ const serverUrl = 'http://localhost:3005';
 let lastResponse: Response;
 let createdScriptAnswerIds: string[] = [];
 let createdStudentCPF: string | null = null;
+let lastCreatedScriptAnswerId: string | null = null;
 
 After({ tags: '@server' }, async function () {
   // Clean up created script answers if needed
@@ -39,8 +40,11 @@ After({ tags: '@server' }, async function () {
     }
     createdStudentCPF = null;
   }
+
+  lastCreatedScriptAnswerId = null;
 });
 
+
 // ============================================================
 // Retrieval of all script answers
 // ============================================================
@@ -178,6 +182,123 @@ Given('there is no student with CPF {string}', async function (cpf: string) {
   }
 });
 
+// ============================================================
+// Retrieval of grade for specific task
+// ============================================================
+
+Given('there is a script answer with ID {string}', async function (answerId: string) {
+  const cleanId = answerId.replace(/"/g, '');
+
+  try {
+    const response = await fetch(`${serverUrl}/api/scriptanswers/`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        id: cleanId,
+        scriptId: `script-${cleanId}`,
+        studentId: '11111111111',
+        answers: []
+      })
+    });
+
+    if (response.status === 201) {
+      createdScriptAnswerIds.push(cleanId);
+      lastCreatedScriptAnswerId = cleanId;
+      console.log(`Server setup: Created script answer with ID: ${cleanId}`);
+    } else {
+      console.error(`Failed to create script answer ${cleanId}: Status ${response.status}`);
+    }
+  } catch (error) {
+    console.error(`Failed to create script answer ${cleanId}:`, error);
+  }
+});
+
+Given('this answer contains a task with ID {string} and grade {string}', async function (taskId: string, grade: string) {
+  if (!lastCreatedScriptAnswerId) {
+    throw new Error('No script answer has been created yet. Use "Given there is a script answer with ID" first.');
+  }
+
+  const cleanTaskId = taskId.replace(/"/g, '');
+  const cleanGrade = grade.replace(/"/g, '');
+
+  try {
+    // Fetch the existing script answer
+    const getResponse = await fetch(`${serverUrl}/api/scriptanswers/${lastCreatedScriptAnswerId}`);
+    
+    if (getResponse.status !== 200) {
+      throw new Error(`Failed to fetch script answer ${lastCreatedScriptAnswerId}`);
+    }
+
+    const scriptAnswer = await getResponse.json();
+    console.log(`Fetched script answer for update:`, scriptAnswer);
+
+    // Add task answer to the script answer
+    scriptAnswer.answers.push({
+      id: `ta-${cleanTaskId}`,
+      task: cleanTaskId,
+      answer: 'Test answer',
+      grade: cleanGrade,
+      comments: ''
+    });
+
+    // Update the script answer with the new task
+    const postResponse = await fetch(`${serverUrl}/api/scriptanswers/${lastCreatedScriptAnswerId}/tasks`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(scriptAnswer)
+    });
+
+    if (postResponse.status === 200) {
+      console.log(`Server setup: Added task ${cleanTaskId} with grade ${cleanGrade} to answer ${lastCreatedScriptAnswerId}`);
+    } else {
+      console.error(`Failed to update script answer: Status ${postResponse.status}`);
+    }
+  } catch (error) {
+    console.error(`Failed to add task to script answer:`, error);
+  }
+});
+
+Given('this answer does not contain a task with ID {string}', async function (taskId: string) {
+  if (!lastCreatedScriptAnswerId) {
+    throw new Error('No script answer has been created yet. Use "Given there is a script answer with ID" first.');
+  }
+
+  const cleanTaskId = taskId.replace(/"/g, '');
+
+  try {
+    // Fetch the existing script answer
+    const getResponse = await fetch(`${serverUrl}/api/scriptanswers/${lastCreatedScriptAnswerId}`);
+    
+    if (getResponse.status !== 200) {
+      throw new Error(`Failed to fetch script answer ${lastCreatedScriptAnswerId}`);
+    }
+
+    const scriptAnswer = await getResponse.json();
+
+    // Ensure the task is NOT in the answer
+    scriptAnswer.answers = scriptAnswer.answers.filter((ta: any) => ta.task !== cleanTaskId);
+
+    // Update the script answer
+    const postResponse = await fetch(`${serverUrl}/api/scriptanswers/${lastCreatedScriptAnswerId}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(scriptAnswer)
+    });
+
+    if (postResponse.status === 200) {
+      console.log(`Server setup: Ensured task ${cleanTaskId} is not in answer ${lastCreatedScriptAnswerId}`);
+    } else {
+      console.error(`Failed to update script answer: Status ${postResponse.status}`);
+    }
+  } catch (error) {
+    console.error(`Failed to update script answer:`, error);
+  }
+});
+
+// ============================================================
+// HTTP Requests
+// ============================================================
+
 When('I send a GET request to {string}', async function (endpoint: string) {
   try {
     lastResponse = await fetch(`${serverUrl}${endpoint}`);
@@ -187,11 +308,16 @@ When('I send a GET request to {string}', async function (endpoint: string) {
   }
 });
 
+// ============================================================
+// Assertions
+// ============================================================
+
 Then(/^the server should return (\d+) (.+)$/, async function (statusCode: string, message: string) {
   const code = parseInt(statusCode);
   expect(lastResponse.status).toBe(code);
   console.log(`Server test: Confirmed response status is ${code} ${message}`);
 });
+
 Then('the server should return a list containing answers {string}, {string}, {string}', async function (string1: string, string2: string, string3: string) {
   const expectedIds = [string1, string2, string3].map(id => id.replace(/"/g, ''));
   
@@ -208,9 +334,6 @@ Then('the server should return a list containing answers {string}, {string}, {st
   console.log(`Server test: Verified response contains answers: ${expectedIds.join(', ')}`);
 });
 
-
-
-
 Then('the server should return an empty list', async function () {
   const responseBody = await lastResponse.json();
   expect(Array.isArray(responseBody)).toBe(true);
@@ -219,10 +342,31 @@ Then('the server should return an empty list', async function () {
   console.log('Server test: Confirmed response is an empty list');
 });
 
-Then('the server should return an error message {string}', async function (string) {
+Then('the server should return an error message {string}', async function (errorMessage: string) {
+  const responseBody = await lastResponse.json();
+  expect(responseBody.error).toBeDefined();
+  const cleanMessage = errorMessage.replace(/"/g, '');
+  expect(responseBody.error.toLowerCase()).toContain(cleanMessage.toLowerCase());
+  
+  console.log(`Server test: Confirmed error message contains: ${cleanMessage}`);
+});
+
+Then('the server should return grade {string}', async function (grade: string) {
+  const responseBody = await lastResponse.json();
+  const cleanGrade = grade.replace(/"/g, '');
+  
+  expect(responseBody.grade).toBeDefined();
+  expect(responseBody.grade).toBe(cleanGrade);
+  
+  console.log(`Server test: Confirmed grade is: ${cleanGrade}`);
+});
+
+Then('the server should return an error message stating the task was not found', async function () {
   const responseBody = await lastResponse.json();
   expect(responseBody.error).toBeDefined();
-  expect(responseBody.error.toLowerCase()).toContain(string);
+  expect(responseBody.error.toLowerCase()).toContain('task');
+  expect(responseBody.error.toLowerCase()).toContain('not found');
   
   console.log(`Server test: Confirmed error message: ${responseBody.error}`);
-});
\ No newline at end of file
+});
+

From 7de2f3c11597bd805dd11ba5792005ee8f0973ee Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Mon, 8 Dec 2025 23:03:55 -0300
Subject: [PATCH 051/102] fix: fixed add taskanswer to scriptanswer endpoint

---
 server/src/server_routes/scriptanswer.ts | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/server/src/server_routes/scriptanswer.ts b/server/src/server_routes/scriptanswer.ts
index 1525947c..a5c8b2e6 100644
--- a/server/src/server_routes/scriptanswer.ts
+++ b/server/src/server_routes/scriptanswer.ts
@@ -76,30 +76,30 @@ export function setupScriptAnswerRoutes(app: Express, scriptAnswerSet: any, stud
 
   // POST /api/scriptanswers/:id/tasks → Add a new task answer to a script answer
   app.post(scriptAnswerurl+':id/tasks', (req: Request, res: Response) => {
-    const { id } = req.params;
-    const { taskAnswerId, taskId, answer, grade, comments } = req.body;
+    const answerId = req.params["id"];
+    const { id, task, answer, grade, comments } = req.body;
 
     // Validate required fields
-    if (!taskAnswerId || !taskId) {
-      return res.status(400).json({ error: 'Missing required fields: taskAnswerId and taskId' });
+    if (!id || !task) {
+      return res.status(400).json({ error: 'Missing required fields: id and task' });
     }
 
     try {
-      const scriptAnswer = scriptAnswerSet.findById(id);
+      const scriptAnswer = scriptAnswerSet.findById(answerId);
       if (!scriptAnswer) {
         return res.status(404).json({ error: 'ScriptAnswer not found' });
       }
 
       // Check if task answer already exists
-      const existingTask = scriptAnswer.findAnswerByTaskId(taskId);
+      const existingTask = scriptAnswer.findAnswerByTaskId(id);
       if (existingTask) {
         return res.status(409).json({ error: 'Task answer already exists for this task' });
       }
 
       // Create new TaskAnswer
       const newTaskAnswer = new TaskAnswer(
-        taskAnswerId,
-        taskId,
+        id,
+        task,
         answer || '',
         grade,
         comments
@@ -109,8 +109,8 @@ export function setupScriptAnswerRoutes(app: Express, scriptAnswerSet: any, stud
       scriptAnswer.addAnswer(newTaskAnswer);
 
       return res.status(201).json({
-        id: taskAnswerId,
-        taskId,
+        id: id,
+        task: task,
         answer: answer || '',
         grade: grade || undefined,
         comments: comments || undefined

From 5b293476ac4107449e03df0d26bc685f6957f5fa Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Mon, 8 Dec 2025 23:05:05 -0300
Subject: [PATCH 052/102] testing/fix: fixed problem where test as failing
 because it was expecting status 200 to post request instead of 201

---
 .../src/step-definitions/server-scriptAnswer-steps.ts | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/client/src/step-definitions/server-scriptAnswer-steps.ts b/client/src/step-definitions/server-scriptAnswer-steps.ts
index 9cac9697..0c5e8819 100644
--- a/client/src/step-definitions/server-scriptAnswer-steps.ts
+++ b/client/src/step-definitions/server-scriptAnswer-steps.ts
@@ -119,6 +119,7 @@ Given('there is a student with CPF {string}', async function (cpf: string) {
 
     if (response.status === 201) {
       createdStudentCPF = cpf;
+      console.log("student created with cpf:", cpf);
 
       console.log(`Server setup: Created student with CPF: ${cpf}`);
     } else {
@@ -233,22 +234,24 @@ Given('this answer contains a task with ID {string} and grade {string}', async f
     console.log(`Fetched script answer for update:`, scriptAnswer);
 
     // Add task answer to the script answer
-    scriptAnswer.answers.push({
+    const taskAnswerReq = {
       id: `ta-${cleanTaskId}`,
       task: cleanTaskId,
       answer: 'Test answer',
       grade: cleanGrade,
       comments: ''
-    });
+    };
+
+    console.log(`Adding task answer to script answer ${lastCreatedScriptAnswerId}:`, taskAnswerReq);
 
     // Update the script answer with the new task
     const postResponse = await fetch(`${serverUrl}/api/scriptanswers/${lastCreatedScriptAnswerId}/tasks`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(scriptAnswer)
+      body: JSON.stringify(taskAnswerReq)
     });
 
-    if (postResponse.status === 200) {
+    if (postResponse.status === 201) {
       console.log(`Server setup: Added task ${cleanTaskId} with grade ${cleanGrade} to answer ${lastCreatedScriptAnswerId}`);
     } else {
       console.error(`Failed to update script answer: Status ${postResponse.status}`);

From 0df5ee2452c2067c4eb163d95e5cb983a580cfd0 Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Tue, 9 Dec 2025 00:35:50 -0300
Subject: [PATCH 053/102] testing/refactor: used regex to make testid and task
 givens more generalized

---
 .../server-scriptAnswer-steps.ts              | 87 ++++++++++---------
 1 file changed, 47 insertions(+), 40 deletions(-)

diff --git a/client/src/step-definitions/server-scriptAnswer-steps.ts b/client/src/step-definitions/server-scriptAnswer-steps.ts
index 0c5e8819..ca15b5a8 100644
--- a/client/src/step-definitions/server-scriptAnswer-steps.ts
+++ b/client/src/step-definitions/server-scriptAnswer-steps.ts
@@ -1,4 +1,4 @@
-import { Given, When, Then, After, setDefaultTimeout } from '@cucumber/cucumber';
+import { Given, When, Then, After, setDefaultTimeout, DataTable } from '@cucumber/cucumber';
 import expect from 'expect';
 
 // Set default timeout for all steps
@@ -11,6 +11,7 @@ let lastResponse: Response;
 let createdScriptAnswerIds: string[] = [];
 let createdStudentCPF: string | null = null;
 let lastCreatedScriptAnswerId: string | null = null;
+let mostRecentTaskId : string | null = null;
 
 After({ tags: '@server' }, async function () {
   // Clean up created script answers if needed
@@ -49,10 +50,10 @@ After({ tags: '@server' }, async function () {
 // Retrieval of all script answers
 // ============================================================
 
-Given('there are script answers registered with IDs {string}, {string}, {string}', async function (string1, string2, string3) {
+Given(/^there (?:is a|are) script answer(?:s)?(?: registered)? with ID(?:s)? ((?:"[^"]+"\s*,\s*)*"[^"]+")$/, async function (idstring : string) {
   // Parse the comma-separated IDs from the string
-  const ids = [string1, string2, string3].map(id => id.replace(/"/g, ''));
-  
+const ids = idstring.match(/"([^"]+)"/g)!.map(id => id.replace(/"/g, ''));
+
   // Create script answers with the given IDs
   for (const id of ids) {
     try {
@@ -187,40 +188,14 @@ Given('there is no student with CPF {string}', async function (cpf: string) {
 // Retrieval of grade for specific task
 // ============================================================
 
-Given('there is a script answer with ID {string}', async function (answerId: string) {
-  const cleanId = answerId.replace(/"/g, '');
-
-  try {
-    const response = await fetch(`${serverUrl}/api/scriptanswers/`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        id: cleanId,
-        scriptId: `script-${cleanId}`,
-        studentId: '11111111111',
-        answers: []
-      })
-    });
 
-    if (response.status === 201) {
-      createdScriptAnswerIds.push(cleanId);
-      lastCreatedScriptAnswerId = cleanId;
-      console.log(`Server setup: Created script answer with ID: ${cleanId}`);
-    } else {
-      console.error(`Failed to create script answer ${cleanId}: Status ${response.status}`);
-    }
-  } catch (error) {
-    console.error(`Failed to create script answer ${cleanId}:`, error);
-  }
-});
-
-Given('this answer contains a task with ID {string} and grade {string}', async function (taskId: string, grade: string) {
+Given( /^this answer contains a task with ID "([^"]+)"(?: and grade "([^"]+)")?$/, async function (taskId: string, grade: string) {
   if (!lastCreatedScriptAnswerId) {
     throw new Error('No script answer has been created yet. Use "Given there is a script answer with ID" first.');
   }
 
   const cleanTaskId = taskId.replace(/"/g, '');
-  const cleanGrade = grade.replace(/"/g, '');
+  const cleanGrade = grade ? grade.replace(/"/g, '') : null;
 
   try {
     // Fetch the existing script answer
@@ -238,10 +213,12 @@ Given('this answer contains a task with ID {string} and grade {string}', async f
       id: `ta-${cleanTaskId}`,
       task: cleanTaskId,
       answer: 'Test answer',
-      grade: cleanGrade,
+      grade: cleanGrade ?? null,
       comments: ''
     };
 
+    mostRecentTaskId = cleanTaskId;
+
     console.log(`Adding task answer to script answer ${lastCreatedScriptAnswerId}:`, taskAnswerReq);
 
     // Update the script answer with the new task
@@ -252,7 +229,10 @@ Given('this answer contains a task with ID {string} and grade {string}', async f
     });
 
     if (postResponse.status === 201) {
-      console.log(`Server setup: Added task ${cleanTaskId} with grade ${cleanGrade} to answer ${lastCreatedScriptAnswerId}`);
+      console.log(`Server setup: Added task ${cleanTaskId}`);
+      if(grade){
+        console.log(`with grade ${cleanGrade} to answer ${lastCreatedScriptAnswerId}`)
+      }
     } else {
       console.error(`Failed to update script answer: Status ${postResponse.status}`);
     }
@@ -311,6 +291,30 @@ When('I send a GET request to {string}', async function (endpoint: string) {
   }
 });
 
+When('I send a PUT request to {string} with:', async function (endpoint: string, dataTable: DataTable) {
+  const data = dataTable.rowsHash();
+  
+  const requestBody: Record<string, any> = {};
+  
+  // Build request body from datatable
+  for (const [field, value] of Object.entries(data)) {
+    requestBody[field] = value;
+  }
+
+  console.log(`Server test: Sending PUT request to ${endpoint} with data:`, requestBody);
+
+  try {
+    lastResponse = await fetch(`${serverUrl}${endpoint}`, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(requestBody)
+    });
+    console.log(`Server test: PUT request to ${endpoint} returned status ${lastResponse.status}`);
+  } catch (error) {
+    throw new Error(`Failed to send PUT request to ${endpoint}: ${error}`);
+  }
+});
+
 // ============================================================
 // Assertions
 // ============================================================
@@ -364,12 +368,15 @@ Then('the server should return grade {string}', async function (grade: string) {
   console.log(`Server test: Confirmed grade is: ${cleanGrade}`);
 });
 
-Then('the server should return an error message stating the task was not found', async function () {
-  const responseBody = await lastResponse.json();
-  expect(responseBody.error).toBeDefined();
-  expect(responseBody.error.toLowerCase()).toContain('task');
-  expect(responseBody.error.toLowerCase()).toContain('not found');
+
+
+Then('the server should update the task grade to {string}', async function (expectedGrade: string) {
+  const cleanGrade = expectedGrade.replace(/"/g, '');
+  const responseBody = await fetch(`${serverUrl}/api/scriptanswers/${lastCreatedScriptAnswerId}/tasks/${mostRecentTaskId}`).then(res => res.json());
+  
+  expect(responseBody.grade).toBeDefined();
+  expect(responseBody.grade).toBe(cleanGrade);
   
-  console.log(`Server test: Confirmed error message: ${responseBody.error}`);
+  console.log(`Server test: Confirmed task grade was updated to: ${cleanGrade}`);
 });
 

From efdee528a2a0c38d9af27f504b628b741588c5b0 Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Tue, 9 Dec 2025 00:48:20 -0300
Subject: [PATCH 054/102] testing: grade updating acceptance tests added

---
 .../server-scriptAnswer-management.feature    | 27 +++++++++++++++++--
 .../server-scriptAnswer-steps.ts              |  2 ++
 2 files changed, 27 insertions(+), 2 deletions(-)

diff --git a/client/src/features/server-scriptAnswer-management.feature b/client/src/features/server-scriptAnswer-management.feature
index 19104331..7ea06d6c 100644
--- a/client/src/features/server-scriptAnswer-management.feature
+++ b/client/src/features/server-scriptAnswer-management.feature
@@ -12,7 +12,7 @@ Feature: Server Script Answers Management
   # ============================================================
 
   Scenario: Retrieve all registered script answers
-    Given there are script answers registered with IDs "123", "321", "890"
+    Given there are script answers with IDs "123", "321", "890"
     When I send a GET request to "/api/scriptanswers"
     Then the server should return 200 "OK"
     And the server should return a list containing answers "123", "321", "890"
@@ -58,4 +58,27 @@ Feature: Server Script Answers Management
     And this answer does not contain a task with ID "9"
     When I send a GET request to "/api/scriptanswers/50/tasks/9"
     Then the server should return 404 "Not Found"
-    And the server should return an error message stating the task was not found
+    And the server should return an error message "task not found"
+
+# ============================================================
+  # Updating grades
+  # ============================================================
+
+  Scenario: Update grade of an existing task with a valid value
+    Given there is a script answer with ID "50"
+    And this answer contains a task with ID "3" and grade "MANA"
+    When I send a PUT request to "/api/scriptanswers/50/tasks/3" with:
+      | field | value |
+      | grade | MPA   |
+    Then the server should return 200 OK
+    And the server should update the task grade to "MPA"
+    And the server should return grade "MPA"
+
+  Scenario: Attempt to update grade with an invalid value
+    Given there is a script answer with ID "50"
+    And this answer contains a task with ID "3"
+    When I send a PUT request to "/api/scriptanswers/50/tasks/3" with:
+      | field | value |
+      | grade | AAA   |
+    Then the server should return 400 "Bad Request"
+    And the server should return an error message "invalid grade"
\ No newline at end of file
diff --git a/client/src/step-definitions/server-scriptAnswer-steps.ts b/client/src/step-definitions/server-scriptAnswer-steps.ts
index ca15b5a8..a59943db 100644
--- a/client/src/step-definitions/server-scriptAnswer-steps.ts
+++ b/client/src/step-definitions/server-scriptAnswer-steps.ts
@@ -68,6 +68,7 @@ const ids = idstring.match(/"([^"]+)"/g)!.map(id => id.replace(/"/g, ''));
         })
       });
       
+      lastCreatedScriptAnswerId = id;
       if (response.status === 201) {
         createdScriptAnswerIds.push(id);
         console.log(`Server setup: Created script answer with ID: ${id}`);
@@ -117,6 +118,7 @@ Given('there is a student with CPF {string}', async function (cpf: string) {
 
     const get = await fetch(`${serverUrl}/api/students/${cpf}`)
     expect(get.status).toBe(200);
+    expect(response.status).toBe(201);
 
     if (response.status === 201) {
       createdStudentCPF = cpf;

From 3ec9f53b34c6b609cd2f3568a1d16ba9ca1404ac Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Tue, 9 Dec 2025 00:51:41 -0300
Subject: [PATCH 055/102] refactor/testing: removed redundant "there is no
 student with cpf {} in the server" Given

---
 .../server-scriptAnswer-management.feature     |  2 +-
 .../server-scriptAnswer-steps.ts               | 18 ------------------
 2 files changed, 1 insertion(+), 19 deletions(-)

diff --git a/client/src/features/server-scriptAnswer-management.feature b/client/src/features/server-scriptAnswer-management.feature
index 7ea06d6c..a93976f5 100644
--- a/client/src/features/server-scriptAnswer-management.feature
+++ b/client/src/features/server-scriptAnswer-management.feature
@@ -36,7 +36,7 @@ Feature: Server Script Answers Management
     And the server should return a list containing answers "40", "41", "43"
 
   Scenario: Attempt to retrieve answers of a non-existent student
-    Given there is no student with CPF "99999999999"
+    Given there is no student with CPF "99999999999" in the server
     When I send a GET request to "/api/scriptanswers/student/99999999999"
     Then the server should return 404 "Not Found"
     And the server should return an error message "student not found"
diff --git a/client/src/step-definitions/server-scriptAnswer-steps.ts b/client/src/step-definitions/server-scriptAnswer-steps.ts
index a59943db..a87a3183 100644
--- a/client/src/step-definitions/server-scriptAnswer-steps.ts
+++ b/client/src/step-definitions/server-scriptAnswer-steps.ts
@@ -167,24 +167,6 @@ Given('this student has script answers with IDs {string}, {string}, {string}', a
   }
 });
 
-Given('there is no student with CPF {string}', async function (cpf: string) {
-  // Verify that no student with this CPF exists
-  try {
-    const response = await fetch(`${serverUrl}/api/students/${cpf}`);
-    
-    if (response.status === 200) {
-      throw new Error(`Student with CPF ${cpf} already exists. Please use a different CPF.`);
-    } else if (response.status === 404) {
-      console.log(`Server setup: Confirmed no student with CPF ${cpf} exists`);
-    }
-  } catch (error) {
-    if ((error as Error).message.includes('already exists')) {
-      throw error;
-    }
-    // If there's a network error, we'll proceed anyway
-    console.log(`Server setup: Could not verify student non-existence for CPF ${cpf}`);
-  }
-});
 
 // ============================================================
 // Retrieval of grade for specific task

From 047c8b73f9422c69a00d451100db376376a25b42 Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Tue, 9 Dec 2025 01:36:06 -0300
Subject: [PATCH 056/102] refactor/testing: MAJOR refactoring in scriptanswer
 acceptance tests

---
 .../server-scriptAnswer-management.feature    |  14 +-
 .../server-scriptAnswer-steps.ts              | 431 ++++++------------
 2 files changed, 140 insertions(+), 305 deletions(-)

diff --git a/client/src/features/server-scriptAnswer-management.feature b/client/src/features/server-scriptAnswer-management.feature
index a93976f5..8b9bf7f6 100644
--- a/client/src/features/server-scriptAnswer-management.feature
+++ b/client/src/features/server-scriptAnswer-management.feature
@@ -32,14 +32,13 @@ Feature: Server Script Answers Management
     Given there is a student with CPF "12345678901"
     And this student has script answers with IDs "40", "41", "43"
     When I send a GET request to "/api/scriptanswers/student/12345678901"
-    Then the server should return 200 OK
+    Then the server should return 200 "OK"
     And the server should return a list containing answers "40", "41", "43"
 
   Scenario: Attempt to retrieve answers of a non-existent student
     Given there is no student with CPF "99999999999" in the server
     When I send a GET request to "/api/scriptanswers/student/99999999999"
-    Then the server should return 404 "Not Found"
-    And the server should return an error message "student not found"
+    Then the server should return 404 "student not found"
 
 
   # ============================================================
@@ -57,8 +56,7 @@ Feature: Server Script Answers Management
     Given there is a script answer with ID "50"
     And this answer does not contain a task with ID "9"
     When I send a GET request to "/api/scriptanswers/50/tasks/9"
-    Then the server should return 404 "Not Found"
-    And the server should return an error message "task not found"
+    Then the server should return 404 "task not found"
 
 # ============================================================
   # Updating grades
@@ -70,9 +68,8 @@ Feature: Server Script Answers Management
     When I send a PUT request to "/api/scriptanswers/50/tasks/3" with:
       | field | value |
       | grade | MPA   |
-    Then the server should return 200 OK
+    Then the server should return 200 "OK"
     And the server should update the task grade to "MPA"
-    And the server should return grade "MPA"
 
   Scenario: Attempt to update grade with an invalid value
     Given there is a script answer with ID "50"
@@ -80,5 +77,4 @@ Feature: Server Script Answers Management
     When I send a PUT request to "/api/scriptanswers/50/tasks/3" with:
       | field | value |
       | grade | AAA   |
-    Then the server should return 400 "Bad Request"
-    And the server should return an error message "invalid grade"
\ No newline at end of file
+    Then the server should return 400 "invalid grade"
\ No newline at end of file
diff --git a/client/src/step-definitions/server-scriptAnswer-steps.ts b/client/src/step-definitions/server-scriptAnswer-steps.ts
index a87a3183..0445ea34 100644
--- a/client/src/step-definitions/server-scriptAnswer-steps.ts
+++ b/client/src/step-definitions/server-scriptAnswer-steps.ts
@@ -1,366 +1,205 @@
+// Refactored Cucumber step definitions with helpers
+// ---------------------------------------------------
+
 import { Given, When, Then, After, setDefaultTimeout, DataTable } from '@cucumber/cucumber';
 import expect from 'expect';
 
-// Set default timeout for all steps
-setDefaultTimeout(30 * 1000); // 30 seconds
+setDefaultTimeout(30 * 1000);
 
 const serverUrl = 'http://localhost:3005';
 
-// Test data to clean up
+// ============================================================
+// Shared test state
+// ============================================================
 let lastResponse: Response;
 let createdScriptAnswerIds: string[] = [];
 let createdStudentCPF: string | null = null;
 let lastCreatedScriptAnswerId: string | null = null;
-let mostRecentTaskId : string | null = null;
+let mostRecentTaskId: string | null = null;
+
+// ============================================================
+// Helper functions
+// ============================================================
+async function createScriptAnswer(id: string, studentId: string) {
+  const response = await fetch(`${serverUrl}/api/scriptanswers/`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ id, scriptId: `script-${id}`, studentId, answers: [] })
+  });
+
+  if (response.status === 201) {
+    createdScriptAnswerIds.push(id);
+    lastCreatedScriptAnswerId = id;
+  }
+
+  lastResponse = response;
+
+  return response;
+}
+
+async function fetchJSON(endpoint: string) {
+  const res = await fetch(`${serverUrl}${endpoint}`);
+  lastResponse = res;
+  return { status: res.status, body: await res.json() };
+}
+
+function extractQuotedList(str: string): string[] {
+  return str.match(/"([^"]+)"/g)?.map(s => s.replace(/"/g, '')) || [];
+}
+
+async function updateScriptAnswerTasks(scriptAnswerId: string, taskPayload: any) {
+    const res = await fetch(`${serverUrl}/api/scriptanswers/${scriptAnswerId}/tasks`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(taskPayload)
+  });
+  lastResponse = res;
+  return res;
+
+}
+
+async function ensureStudentExists(cpf: string) {
+  const response = await fetch(`${serverUrl}/api/students`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ name: 'Test Student', cpf, email: `student${cpf}@test.com` })
+  });
+
+  lastResponse = response;
+
+  if (response.status === 201) createdStudentCPF = cpf;
+  return response;
+}
 
+// ============================================================
+// Cleanup
+// ============================================================
 After({ tags: '@server' }, async function () {
-  // Clean up created script answers if needed
-  if (createdScriptAnswerIds.length > 0) {
-    for (const id of createdScriptAnswerIds) {
-      try {
-        await fetch(`${serverUrl}/api/scriptanswers/${id}`, {
-          method: 'DELETE'
-        });
-        console.log(`Server cleanup: Removed test script answer with ID: ${id}`);
-      } catch (error) {
-        console.log(`Server cleanup: Could not remove script answer ${id}`);
-      }
-    }
-    createdScriptAnswerIds = [];
+  for (const id of createdScriptAnswerIds) {
+    await fetch(`${serverUrl}/api/scriptanswers/${id}`, { method: 'DELETE' });
   }
+  createdScriptAnswerIds = [];
 
-  // Clean up created student if needed
   if (createdStudentCPF) {
-    try {
-      await fetch(`${serverUrl}/api/students/${createdStudentCPF}`, {
-        method: 'DELETE'
-      });
-      console.log(`Server cleanup: Removed test student with CPF: ${createdStudentCPF}`);
-    } catch (error) {
-      console.log(`Server cleanup: Could not remove student ${createdStudentCPF}`);
-    }
+    await fetch(`${serverUrl}/api/students/${createdStudentCPF}`, { method: 'DELETE' });
     createdStudentCPF = null;
   }
 
   lastCreatedScriptAnswerId = null;
 });
 
-
 // ============================================================
-// Retrieval of all script answers
+// Step Definitions
 // ============================================================
 
-Given(/^there (?:is a|are) script answer(?:s)?(?: registered)? with ID(?:s)? ((?:"[^"]+"\s*,\s*)*"[^"]+")$/, async function (idstring : string) {
-  // Parse the comma-separated IDs from the string
-const ids = idstring.match(/"([^"]+)"/g)!.map(id => id.replace(/"/g, ''));
-
-  // Create script answers with the given IDs
-  for (const id of ids) {
-    try {
-      const response = await fetch(`${serverUrl}/api/scriptanswers/`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-          id: id,
-          scriptId: `script-${id}`,
-          studentId: '11111111111',
-          answers: []
-        })
-      });
-      
-      lastCreatedScriptAnswerId = id;
-      if (response.status === 201) {
-        createdScriptAnswerIds.push(id);
-        console.log(`Server setup: Created script answer with ID: ${id}`);
-      } else {
-        console.error(`Failed to create script answer ${id}: Status ${response.status}`);
-      }
-    } catch (error) {
-      console.error(`Failed to create script answer ${id}:`, error);
-    }
-  }
+Given(/^there (?:is a|are) script answer(?:s)?(?: registered)? with ID(?:s)? ((?:"[^"]+"\s*,\s*)*"[^"]+")$/, async function (idString: string) {
+  const ids = extractQuotedList(idString);
+  for (const id of ids) await createScriptAnswer(id, '11111111111');
 });
 
 Given('there are no script answers registered', async function () {
-  // Fetch all script answers and delete them
-  try {
-    const response = await fetch(`${serverUrl}/api/scriptanswers/`);
-    if (response.status === 200) {
-      const answers = await response.json();
-      
-      for (const answer of answers) {
-        await fetch(`${serverUrl}/api/scriptanswers/${answer.id}`, {
-          method: 'DELETE'
-        });
-        console.log(`Server setup: Removed existing script answer with ID: ${answer.id}`);
-      }
+  const res = await fetch(`${serverUrl}/api/scriptanswers/`);
+  if (res.status === 200) {
+    const list = await res.json();
+    for (const item of list) {
+      await fetch(`${serverUrl}/api/scriptanswers/${item.id}`, { method: 'DELETE' });
     }
-  } catch (error) {
-    console.log('Server setup: Could not clean up existing script answers');
   }
 });
 
-// ============================================================
-// Retrieval by student (CPF-based)
-// ============================================================
-
 Given('there is a student with CPF {string}', async function (cpf: string) {
-  try {
-    const response = await fetch(`${serverUrl}/api/students`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        name: 'Test Student',
-        cpf: cpf,
-        email: `student${cpf}@test.com`
-      })
-    });
-
-    const get = await fetch(`${serverUrl}/api/students/${cpf}`)
-    expect(get.status).toBe(200);
-    expect(response.status).toBe(201);
-
-    if (response.status === 201) {
-      createdStudentCPF = cpf;
-      console.log("student created with cpf:", cpf);
-
-      console.log(`Server setup: Created student with CPF: ${cpf}`);
-    } else {
-      console.error(`Failed to create student with CPF ${cpf}: Status ${response.status}`);
-    }
-  } catch (error) {
-    console.error(`Failed to create student with CPF ${cpf}:`, error);
-  }
+  const response = await ensureStudentExists(cpf);
+  expect(response.status).toBe(201);
 });
 
-Given('this student has script answers with IDs {string}, {string}, {string}', async function (string1, string2, string3) {
-  if (!createdStudentCPF) {
-    throw new Error('No student has been created yet. Use "Given there is a student with CPF" first.');
-  }
-
-  // Parse the comma-separated IDs from the string
-  const ids = [string1, string2, string3 ].map(id => id.replace(/"/g, ''));
-
-  // Create script answers for the student with the given IDs
-  for (const id of ids) {
-    try {
-      const response = await fetch(`${serverUrl}/api/scriptanswers/`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-          id: id,
-          scriptId: `script-${id}`,
-          studentId: createdStudentCPF,
-          answers: []
-        })
-      });
-
-      if (response.status === 201) {
-        createdScriptAnswerIds.push(id);
-        console.log(`Server setup: Created script answer with ID: ${id} for student ${createdStudentCPF}`);
-      } else {
-        console.error(`Failed to create script answer ${id}: Status ${response.status}`);
-      }
-    } catch (error) {
-      console.error(`Failed to create script answer ${id}:`, error);
-    }
-  }
+Given('this student has script answers with IDs {string}, {string}, {string}', async function (a: string, b: string, c: string) {
+  if (!createdStudentCPF) throw new Error('Student not created');
+  const ids = [a, b, c].map(x => x.replace(/"/g, ''));
+  for (const id of ids) await createScriptAnswer(id, createdStudentCPF);
 });
 
+Given(/^this answer contains a task with ID "([^"]+)"(?: and grade "([^"]+)")?$/, async function (taskId: string, grade?: string) {
+  if (!lastCreatedScriptAnswerId) throw new Error('No script answer created');
 
-// ============================================================
-// Retrieval of grade for specific task
-// ============================================================
-
-
-Given( /^this answer contains a task with ID "([^"]+)"(?: and grade "([^"]+)")?$/, async function (taskId: string, grade: string) {
-  if (!lastCreatedScriptAnswerId) {
-    throw new Error('No script answer has been created yet. Use "Given there is a script answer with ID" first.');
-  }
-
-  const cleanTaskId = taskId.replace(/"/g, '');
-  const cleanGrade = grade ? grade.replace(/"/g, '') : null;
-
-  try {
-    // Fetch the existing script answer
-    const getResponse = await fetch(`${serverUrl}/api/scriptanswers/${lastCreatedScriptAnswerId}`);
-    
-    if (getResponse.status !== 200) {
-      throw new Error(`Failed to fetch script answer ${lastCreatedScriptAnswerId}`);
-    }
+  const payload = {
+    id: `ta-${taskId}`,
+    task: taskId,
+    answer: 'Test answer',
+    grade: grade ?? null,
+    comments: ''
+  };
 
-    const scriptAnswer = await getResponse.json();
-    console.log(`Fetched script answer for update:`, scriptAnswer);
-
-    // Add task answer to the script answer
-    const taskAnswerReq = {
-      id: `ta-${cleanTaskId}`,
-      task: cleanTaskId,
-      answer: 'Test answer',
-      grade: cleanGrade ?? null,
-      comments: ''
-    };
-
-    mostRecentTaskId = cleanTaskId;
-
-    console.log(`Adding task answer to script answer ${lastCreatedScriptAnswerId}:`, taskAnswerReq);
-
-    // Update the script answer with the new task
-    const postResponse = await fetch(`${serverUrl}/api/scriptanswers/${lastCreatedScriptAnswerId}/tasks`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(taskAnswerReq)
-    });
-
-    if (postResponse.status === 201) {
-      console.log(`Server setup: Added task ${cleanTaskId}`);
-      if(grade){
-        console.log(`with grade ${cleanGrade} to answer ${lastCreatedScriptAnswerId}`)
-      }
-    } else {
-      console.error(`Failed to update script answer: Status ${postResponse.status}`);
-    }
-  } catch (error) {
-    console.error(`Failed to add task to script answer:`, error);
-  }
+  mostRecentTaskId = taskId;
+  const res = await updateScriptAnswerTasks(lastCreatedScriptAnswerId, payload);
+  expect([200, 201]).toContain(res.status);
 });
 
 Given('this answer does not contain a task with ID {string}', async function (taskId: string) {
-  if (!lastCreatedScriptAnswerId) {
-    throw new Error('No script answer has been created yet. Use "Given there is a script answer with ID" first.');
-  }
-
-  const cleanTaskId = taskId.replace(/"/g, '');
-
-  try {
-    // Fetch the existing script answer
-    const getResponse = await fetch(`${serverUrl}/api/scriptanswers/${lastCreatedScriptAnswerId}`);
-    
-    if (getResponse.status !== 200) {
-      throw new Error(`Failed to fetch script answer ${lastCreatedScriptAnswerId}`);
-    }
-
-    const scriptAnswer = await getResponse.json();
-
-    // Ensure the task is NOT in the answer
-    scriptAnswer.answers = scriptAnswer.answers.filter((ta: any) => ta.task !== cleanTaskId);
+  if (!lastCreatedScriptAnswerId) throw new Error('No script answer created');
 
-    // Update the script answer
-    const postResponse = await fetch(`${serverUrl}/api/scriptanswers/${lastCreatedScriptAnswerId}`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(scriptAnswer)
-    });
+  const script = await fetchJSON(`/api/scriptanswers/${lastCreatedScriptAnswerId}`);
+  script.body.answers = script.body.answers.filter((a: any) => a.task !== taskId);
 
-    if (postResponse.status === 200) {
-      console.log(`Server setup: Ensured task ${cleanTaskId} is not in answer ${lastCreatedScriptAnswerId}`);
-    } else {
-      console.error(`Failed to update script answer: Status ${postResponse.status}`);
-    }
-  } catch (error) {
-    console.error(`Failed to update script answer:`, error);
-  }
+  await fetch(`${serverUrl}/api/scriptanswers/${lastCreatedScriptAnswerId}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(script.body)
+  });
 });
 
 // ============================================================
-// HTTP Requests
+// Requests
 // ============================================================
 
 When('I send a GET request to {string}', async function (endpoint: string) {
-  try {
-    lastResponse = await fetch(`${serverUrl}${endpoint}`);
-    console.log(`Server test: GET request to ${endpoint} returned status ${lastResponse.status}`);
-  } catch (error) {
-    throw new Error(`Failed to send GET request to ${endpoint}: ${error}`);
-  }
+  lastResponse = await fetch(`${serverUrl}${endpoint}`);
 });
 
 When('I send a PUT request to {string} with:', async function (endpoint: string, dataTable: DataTable) {
-  const data = dataTable.rowsHash();
-  
-  const requestBody: Record<string, any> = {};
-  
-  // Build request body from datatable
-  for (const [field, value] of Object.entries(data)) {
-    requestBody[field] = value;
-  }
-
-  console.log(`Server test: Sending PUT request to ${endpoint} with data:`, requestBody);
-
-  try {
-    lastResponse = await fetch(`${serverUrl}${endpoint}`, {
-      method: 'PUT',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(requestBody)
-    });
-    console.log(`Server test: PUT request to ${endpoint} returned status ${lastResponse.status}`);
-  } catch (error) {
-    throw new Error(`Failed to send PUT request to ${endpoint}: ${error}`);
-  }
+  const body = dataTable.rowsHash();
+  lastResponse = await fetch(`${serverUrl}${endpoint}`, {
+    method: 'PUT',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body)
+  });
 });
 
 // ============================================================
 // Assertions
 // ============================================================
 
-Then(/^the server should return (\d+) (.+)$/, async function (statusCode: string, message: string) {
+Then(/^the server should return (\d+) "([^"]+)"$/, async function (statusCode: string, message: string) {
+  if(!lastResponse) {
+    throw new Error('No response recorded');
+  }
+  expect(lastResponse).toBeDefined();
   const code = parseInt(statusCode);
   expect(lastResponse.status).toBe(code);
-  console.log(`Server test: Confirmed response status is ${code} ${message}`);
-});
 
-Then('the server should return a list containing answers {string}, {string}, {string}', async function (string1: string, string2: string, string3: string) {
-  const expectedIds = [string1, string2, string3].map(id => id.replace(/"/g, ''));
-  
-  const responseBody = await lastResponse.json();
-  expect(Array.isArray(responseBody)).toBe(true);
-  
-  const returnedIds = responseBody.map((answer: any) => answer.id);
-  
-  // Verify all expected IDs are in the response
-  for (const expectedId of expectedIds) {
-    expect(returnedIds).toContain(expectedId);
-  }
-  
-  console.log(`Server test: Verified response contains answers: ${expectedIds.join(', ')}`);
-});
-
-Then('the server should return an empty list', async function () {
-  const responseBody = await lastResponse.json();
-  expect(Array.isArray(responseBody)).toBe(true);
-  expect(responseBody.length).toBe(0);
-  
-  console.log('Server test: Confirmed response is an empty list');
+  console.log(`Server responded with status ${lastResponse.status} (${message})`);
 });
 
-Then('the server should return an error message {string}', async function (errorMessage: string) {
-  const responseBody = await lastResponse.json();
-  expect(responseBody.error).toBeDefined();
-  const cleanMessage = errorMessage.replace(/"/g, '');
-  expect(responseBody.error.toLowerCase()).toContain(cleanMessage.toLowerCase());
-  
-  console.log(`Server test: Confirmed error message contains: ${cleanMessage}`);
+Then('the server should return grade {string}', async function (grade: string) {
+  const body = await lastResponse.json().then(data => data.grade);
+  expect(body).toBe(grade.replace(/"/g, ''));
+})
+
+Then(/^the server should return a list containing answers ("[^"]+"\s*,\s*)*"[^"]+"/, async function (idString: string) {
+  const expected = extractQuotedList(idString);
+  const body = await lastResponse.json();
+  const returned = body.map((x: any) => x.id);
+  expected.forEach(id => expect(returned).toContain(id));
 });
 
-Then('the server should return grade {string}', async function (grade: string) {
-  const responseBody = await lastResponse.json();
-  const cleanGrade = grade.replace(/"/g, '');
-  
-  expect(responseBody.grade).toBeDefined();
-  expect(responseBody.grade).toBe(cleanGrade);
-  
-  console.log(`Server test: Confirmed grade is: ${cleanGrade}`);
+Then('the server should return an empty list', async function () {
+  const body = await lastResponse.json();
+  expect(Array.isArray(body)).toBe(true);
+  expect(body.length).toBe(0);
 });
 
 
 
-Then('the server should update the task grade to {string}', async function (expectedGrade: string) {
-  const cleanGrade = expectedGrade.replace(/"/g, '');
-  const responseBody = await fetch(`${serverUrl}/api/scriptanswers/${lastCreatedScriptAnswerId}/tasks/${mostRecentTaskId}`).then(res => res.json());
-  
-  expect(responseBody.grade).toBeDefined();
-  expect(responseBody.grade).toBe(cleanGrade);
-  
-  console.log(`Server test: Confirmed task grade was updated to: ${cleanGrade}`);
+Then('the server should update the task grade to {string}', async function (grade: string) {
+  const body = await fetchJSON(`/api/scriptanswers/${lastCreatedScriptAnswerId}/tasks/${mostRecentTaskId}`);
+  expect(body.body.grade).toBe(grade.replace(/"/g, ''));
 });
-

From b96ef66b70def2c2b7b5011d963e9c72cf928960 Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Tue, 9 Dec 2025 02:51:04 -0300
Subject: [PATCH 057/102] testing: comment addition scenarios tests implemented

---
 .../server-scriptAnswer-management.feature    | 31 ++++++++++++++++++-
 .../server-scriptAnswer-steps.ts              | 15 +++++++++
 2 files changed, 45 insertions(+), 1 deletion(-)

diff --git a/client/src/features/server-scriptAnswer-management.feature b/client/src/features/server-scriptAnswer-management.feature
index 8b9bf7f6..bfe0f2e0 100644
--- a/client/src/features/server-scriptAnswer-management.feature
+++ b/client/src/features/server-scriptAnswer-management.feature
@@ -77,4 +77,33 @@ Feature: Server Script Answers Management
     When I send a PUT request to "/api/scriptanswers/50/tasks/3" with:
       | field | value |
       | grade | AAA   |
-    Then the server should return 400 "invalid grade"
\ No newline at end of file
+    Then the server should return 400 "invalid grade"
+
+    
+  # ============================================================
+  # Updating task-level comments
+  # ============================================================
+
+  Scenario: Successfully add a comment to a task inside a script answer
+    Given there is a script answer with ID "50"
+    And this answer contains a task with ID "3"
+    When I send a PUT request to "/api/scriptanswers/50/tasks/3/comments" with:
+      | field   | value                                   |
+      | comment | Correto, mas poderia detalhar melhor    |
+    Then the server should return 200 "OK"
+    And the server should store the comment "Correto, mas poderia detalhar melhor" in task "3"
+
+  Scenario: Attempt to add a comment to a non-existent task inside a script answer
+    Given there is a script answer with ID "50"
+    And this answer does not contain a task with ID "999"
+    When I send a PUT request to "/api/scriptanswers/50/tasks/999/comments" with:
+      | field   | value     |
+      | comment | Verifique |
+    Then the server should return 404 "task not found"
+
+  Scenario: Attempt to add a comment to a task inside a non-existent script answer
+    Given there is no script answer with ID "888"
+    When I send a PUT request to "/api/scriptanswers/888/tasks/3/comments" with:
+      | field   | value                    |
+      | comment | Precisa revisar este ponto |
+    Then the server should return 404 "answer not found"
diff --git a/client/src/step-definitions/server-scriptAnswer-steps.ts b/client/src/step-definitions/server-scriptAnswer-steps.ts
index 0445ea34..097ee90d 100644
--- a/client/src/step-definitions/server-scriptAnswer-steps.ts
+++ b/client/src/step-definitions/server-scriptAnswer-steps.ts
@@ -107,6 +107,14 @@ Given('there are no script answers registered', async function () {
   }
 });
 
+Given('there is no script answer with ID {string}', async function (id: string) {
+  const res = await fetch(`${serverUrl}/api/scriptanswers/${id}`);
+  if (res.status === 200) {
+    await fetch(`${serverUrl}/api/scriptanswers/${id}`, { method: 'DELETE' });
+  }
+  expect((await fetch(`${serverUrl}/api/scriptanswers/${id}`)).status).toBe(404);
+});
+
 Given('there is a student with CPF {string}', async function (cpf: string) {
   const response = await ensureStudentExists(cpf);
   expect(response.status).toBe(201);
@@ -198,6 +206,13 @@ Then('the server should return an empty list', async function () {
 });
 
 
+Then(/^the server should store the comment "([^"]+)" in task "([^"]+)"$/, async function (comment: string, taskId: string) {
+  const body = await fetchJSON(`/api/scriptanswers/${lastCreatedScriptAnswerId}/`);
+  const taskComment = body.body.answers.find((a: any) => a.task === taskId)?.comments;
+  console.log(body.body.answers);
+  expect(taskComment).toBe(comment);
+
+})
 
 Then('the server should update the task grade to {string}', async function (grade: string) {
   const body = await fetchJSON(`/api/scriptanswers/${lastCreatedScriptAnswerId}/tasks/${mostRecentTaskId}`);

From 73f54275e5bdd267f9faf7c21673045cd9449e6a Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Tue, 9 Dec 2025 03:02:20 -0300
Subject: [PATCH 058/102] testing: retreival by id acceptance tests implemented

---
 .../server-scriptAnswer-management.feature       | 16 ++++++++++++++++
 .../server-scriptAnswer-steps.ts                 |  7 ++++++-
 2 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/client/src/features/server-scriptAnswer-management.feature b/client/src/features/server-scriptAnswer-management.feature
index bfe0f2e0..ed47e5bf 100644
--- a/client/src/features/server-scriptAnswer-management.feature
+++ b/client/src/features/server-scriptAnswer-management.feature
@@ -22,7 +22,22 @@ Feature: Server Script Answers Management
     When I send a GET request to "/api/scriptanswers"
     Then the server should return 200 "OK"
     And the server should return an empty list
+    
 
+  # ============================================================
+  # Retrieval by ID
+  # ============================================================
+
+  Scenario: Retrieve a script answer by ID
+    Given there is a script answer registered with ID "123"
+    When I send a GET request to "/api/scriptanswers/123"
+    Then the server should return 200 "OK"
+    And the server should return the script answer with ID "123"
+
+  Scenario: Attempt to retrieve a non-existent script answer
+    Given there is no script answer registered with ID "777"
+    When I send a GET request to "/api/scriptanswers/777"
+    Then the server should return 404 "script not found"
 
   # ============================================================
   # Retrieval by student (CPF-based)
@@ -107,3 +122,4 @@ Feature: Server Script Answers Management
       | field   | value                    |
       | comment | Precisa revisar este ponto |
     Then the server should return 404 "answer not found"
+
diff --git a/client/src/step-definitions/server-scriptAnswer-steps.ts b/client/src/step-definitions/server-scriptAnswer-steps.ts
index 097ee90d..ef8f7f0b 100644
--- a/client/src/step-definitions/server-scriptAnswer-steps.ts
+++ b/client/src/step-definitions/server-scriptAnswer-steps.ts
@@ -107,7 +107,7 @@ Given('there are no script answers registered', async function () {
   }
 });
 
-Given('there is no script answer with ID {string}', async function (id: string) {
+Given(/^there is no script answer(?: registered)? with ID "([^"]+)"/, async function (id: string) {
   const res = await fetch(`${serverUrl}/api/scriptanswers/${id}`);
   if (res.status === 200) {
     await fetch(`${serverUrl}/api/scriptanswers/${id}`, { method: 'DELETE' });
@@ -199,6 +199,11 @@ Then(/^the server should return a list containing answers ("[^"]+"\s*,\s*)*"[^"]
   expected.forEach(id => expect(returned).toContain(id));
 });
 
+Then(/^the server should return the script answer with ID "([^"]+)"$/, async function (id: string) {
+  const body = await lastResponse.json();
+  expect(body.id).toBe(id);
+});
+
 Then('the server should return an empty list', async function () {
   const body = await lastResponse.json();
   expect(Array.isArray(body)).toBe(true);

From d9ea32c497f812a826fd4434429e51b142ab121d Mon Sep 17 00:00:00 2001
From: Davi Guerreiro <daviguerreiro9a@gmail.com>
Date: Tue, 9 Dec 2025 04:40:50 -0300
Subject: [PATCH 059/102] feat(TaskAnswer): Adding time sensitive
 implementation and status to Answers

---
 server/src/models/TaskAnswer.ts | 48 +++++++++++++++++++++++++++++----
 1 file changed, 43 insertions(+), 5 deletions(-)

diff --git a/server/src/models/TaskAnswer.ts b/server/src/models/TaskAnswer.ts
index 4c3c47cf..053149c0 100644
--- a/server/src/models/TaskAnswer.ts
+++ b/server/src/models/TaskAnswer.ts
@@ -4,17 +4,25 @@ import { Grade } from "./Evaluation";
 export class TaskAnswer {
   public id: string;
   public task: string;
+  public started_at?: number;
+  public submitted_at?: number;
+  public time_taken_seconds?: number;
   public answer?: string;
   private grade?: Grade;
   public comments?: string;
+  public status: 'pending' | 'started' | 'submitted' | 'timed_out' = 'pending';
 
-  constructor(id: string, task: string, answer?: string, grade?: Grade, comments?: string) {
+
+  constructor(id: string, task: string, answer?: string, grade?: Grade, comments?: string,started_at?: number,submitted_at?: number,time_taken_seconds?: number,status?: 'pending' | 'started' | 'submitted' | 'timed_out') {
     this.id = id;
     this.task = task;
     this.answer = answer;
     this.grade = grade;
     this.comments = comments;
-
+    this.started_at = started_at ?? Date.now();
+    this.submitted_at = submitted_at;
+    this.time_taken_seconds = time_taken_seconds;
+    this.status = status ?? (submitted_at ? 'submitted' : 'started');
     if(grade && grade != "MA" && grade != "MPA" && grade != "MANA") {
       throw new Error('Invalid grade value');
     }
@@ -29,8 +37,12 @@ export class TaskAnswer {
       id: this.id,
       task: this.task,
       answer: this.answer,
+      started_at: this.started_at,
+      submitted_at: this.submitted_at,
+      time_taken_seconds: this.time_taken_seconds,
       grade: this.grade ? this.grade : undefined,
-      comments: this.comments
+      comments: this.comments,
+      status: this.status,
     };
   }
 
@@ -41,15 +53,41 @@ export class TaskAnswer {
     this.grade = grade;
   }
 
-  update(data: Partial<{task: any; answer : any; grade: any; comments: any }>) {
+  update(data: Partial<{
+    task: any; 
+    answer : any; 
+    grade: any; 
+    comments: any 
+    started_at: number;
+    submitted_at: number;
+    time_taken_seconds: number;
+    status: 'pending' | 'started' | 'submitted' | 'timed_out';
+  }>) {
     if (data.task) this.task = data.task;
     if (data.answer) this.answer = data.answer;
     if (data.grade !== undefined) this.updateGrade(data.grade);
     if (data.comments !== undefined) this.comments = data.comments;
+    if (data.status !== undefined) this.status = data.status;
+    if (data.started_at !== undefined) this.started_at = data.started_at;
+    if (data.submitted_at !== undefined) this.submitted_at = data.submitted_at;
+    if (data.time_taken_seconds !== undefined) this.time_taken_seconds = data.time_taken_seconds;
+  }
+
+  isAnswerEmpty(): boolean {
+    return !this.answer || this.answer.trim() === '';
+  }
+  
+  submit(answer?: string) {
+    if (answer !== undefined) this.answer = answer;
+    this.submitted_at = Date.now();
+    this.status = 'submitted';
+    if (this.started_at) {
+      this.time_taken_seconds = Math.max(0, Math.round((this.submitted_at - this.started_at) / 1000));
+    }
   }
 
   static fromJSON(obj: any): TaskAnswer {
-    return new TaskAnswer(obj.id, obj.task, obj.answer, obj.grade, obj.comments);
+    return new TaskAnswer(obj.id, obj.task, obj.answer, obj.grade, obj.comments, obj.started_at, obj.submitted_at, obj.time_taken_seconds, obj.status);
   }
 
   getGrade(): Grade | undefined {

From 0826b7fbd6e8e34e18c1b0d715828e831a54ac86 Mon Sep 17 00:00:00 2001
From: Davi Guerreiro <daviguerreiro9a@gmail.com>
Date: Tue, 9 Dec 2025 04:43:30 -0300
Subject: [PATCH 060/102] feat(ScriptAnswers): Adding Time/Status dependencies,
 Class connection and Support Methods

---
 server/src/models/Script.ts          |  4 ++
 server/src/models/ScriptAnswer.ts    | 77 +++++++++++++++++++++++++---
 server/src/models/ScriptAnswerSet.ts | 64 ++++++++++++++++++++++-
 3 files changed, 135 insertions(+), 10 deletions(-)

diff --git a/server/src/models/Script.ts b/server/src/models/Script.ts
index 0ba9d66d..f4548c4a 100644
--- a/server/src/models/Script.ts
+++ b/server/src/models/Script.ts
@@ -15,6 +15,10 @@ export class Script {
     return this.id;
   }
 
+  getTasks(): Task[] {
+    return this.tasks;
+  }
+
 toJSON() {
   return {
     id: this.id,
diff --git a/server/src/models/ScriptAnswer.ts b/server/src/models/ScriptAnswer.ts
index cd171842..7bb9b028 100644
--- a/server/src/models/ScriptAnswer.ts
+++ b/server/src/models/ScriptAnswer.ts
@@ -1,23 +1,31 @@
 import { Grade } from "./Evaluation";
 import { TaskAnswer } from "./TaskAnswer";
-import { Student } from "./Student";
+import { v4 as uuid } from 'uuid';
 
 export class ScriptAnswer {
   private id: string;
   private scriptId: string;
+  private classId: string;
   private student: string; 
   public answers: TaskAnswer[] = [];
+  public started_at?: number;
+  public finished_at?: number;
+  public status: 'in_progress' | 'finished' = 'in_progress';
   public grade?: Grade
 
-  constructor(id: string, scriptId: string, student: string, answers?: TaskAnswer[], grade?: Grade) {
+  constructor(id: string, scriptId: string, classId: string, student: string, answers?: TaskAnswer[], grade?: Grade, started_at?: number, finished_at?: number, status?: 'in_progress' | 'finished') {
+    if(grade && grade != "MA" && grade != "MPA" && grade != "MANA") {
+      throw new Error('Invalid grade value');
+    }
     this.id = id;
     this.scriptId = scriptId;
+    this.classId = classId;
     this.student = student;
     this.answers = answers || [];
+    this.started_at = started_at ?? Date.now();
+    this.finished_at = finished_at;
+    this.status = status ?? 'in_progress';
     this.grade = grade;
-    if(grade && grade != "MA" && grade != "MPA" && grade != "MANA") {
-      throw new Error('Invalid grade value');
-    }
   }
 
   getId(): string {
@@ -32,10 +40,15 @@ export class ScriptAnswer {
     return this.scriptId;
   }
 
+  getClassId(): string {
+    return this.classId;
+  }
+
   toJSON() {
     return {
       id: this.id,
       scriptId: this.scriptId,
+      classId: this.classId,
       student: this.student,
       answers: this.answers.map(answer => {
         if (answer && typeof answer.toJSON === "function") {
@@ -44,13 +57,16 @@ export class ScriptAnswer {
         console.warn("Invalid answer detected:", answer);
         return null;
       }).filter(Boolean),
-      grade: this.grade ? this.grade : undefined
+      grade: this.grade ? this.grade : undefined,
+      started_at: this.started_at,
+      finished_at: this.finished_at,
+      status: this.status,
     };
   }
 
   static fromJSON(obj: any): ScriptAnswer {
     const answers = obj.answers ? obj.answers.map((ansObj: any) => TaskAnswer.fromJSON(ansObj)) : [];
-    return new ScriptAnswer(obj.id, obj.scriptId, obj.student, answers, obj.grade);
+    return new ScriptAnswer(obj.id, obj.scriptId, obj.classId, obj.student, answers, obj.grade, obj.started_at, obj.finished_at, obj.status);
   }
 
   // answer management
@@ -60,7 +76,7 @@ export class ScriptAnswer {
       answer.getTaskId() === taskId
     );
   }
-
+  //obsoleto
   addAnswer(answer: TaskAnswer): TaskAnswer {
     const existingAnswer = this.findAnswerByTaskId(answer.task);
     if (existingAnswer) {
@@ -84,6 +100,50 @@ export class ScriptAnswer {
     return true;
   }
 
+  createTaskAnswer(taskId: string, data?: { answer?: string; grade?: Grade; comments?: string }): TaskAnswer | null {
+    const existing = this.findAnswerByTaskId(taskId);
+    if (existing) return null;
+    const ta = new TaskAnswer(
+      `${this.id}-${taskId}`,  // ou use uuid()
+      taskId,
+      data?.answer,
+      data?.grade,
+      data?.comments
+    );
+    this.answers.push(ta);
+    return ta;
+  }
+
+  submitTaskAnswer(taskId: string, data?: { answer?: string; grade?: Grade; comments?: string }): TaskAnswer | null {
+    const ta = this.findAnswerByTaskId(taskId);
+    if (!ta) return null;
+    
+    if (data?.grade !== undefined) ta.updateGrade(data.grade);
+    if (data?.comments !== undefined) ta.comments = data.comments;
+    ta.submit(data?.answer);
+    return ta;
+  }
+
+  markFinished(finishedAt?: number) {
+    this.finished_at = finishedAt ?? Date.now();
+    this.status = 'finished';
+  }
+
+  checkAndMarkIfTimedOut(timeoutSeconds: number = 3600) {
+    if (this.status === 'finished') return; // já finalizou
+    const elapsed = (Date.now() - (this.started_at || 0)) / 1000;
+    if (elapsed > timeoutSeconds) {
+      this.markFinished();
+      this.answers.forEach(ta => {
+        if (ta.status == 'started'){
+          ta.submit();
+        }
+        else if (ta.status !== 'submitted') {
+          ta.status = 'timed_out';
+        }
+      });
+    }
+  }
   // grade Management
 
   updateGrade(grade: Grade | undefined) {
@@ -107,4 +167,5 @@ export class ScriptAnswer {
       'MA': this.getNumberOfAnswersWithGrade('MA'),
     };
   }
+  
 }
\ No newline at end of file
diff --git a/server/src/models/ScriptAnswerSet.ts b/server/src/models/ScriptAnswerSet.ts
index 9728cb1f..5c185284 100644
--- a/server/src/models/ScriptAnswerSet.ts
+++ b/server/src/models/ScriptAnswerSet.ts
@@ -1,17 +1,36 @@
 import { v4 as uuid } from 'uuid';
 import  { ScriptAnswer } from './ScriptAnswer';
 import { Grade } from './Evaluation';
+import { Scripts } from './Scripts';
+import { Classes } from './Classes';
+import { StudentSet } from './StudentSet';
+import { TaskAnswer } from './TaskAnswer';
 
 export class ScriptAnswerSet {
   private scriptAnswers: ScriptAnswer[] = [];
 
-  addScriptAnswer(data: any) {
+  addScriptAnswer(data: any, classes?: any, studentSet?: any, scripts?: any) {
+    if (!data.scriptId || !data.classId || !data.studentId) {
+      throw new Error('scriptId, classId and studentId are required');
+    }
+    if (classes && !classes.findClassById(data.classId)) {
+      throw new Error(`Class with ID ${data.classId} not found`);
+    }
+    if (studentSet && !studentSet.findStudentByCPF(data.studentId)) {
+      throw new Error(`Student with CPF ${data.studentId} not found`);
+    }
+    if (scripts && !scripts.findById(data.scriptId)) {
+      throw new Error(`Script with ID ${data.scriptId} not found`);
+    }
     const newAnswer = ScriptAnswer.fromJSON({
       id: data.id ??  uuid(),
       scriptId: data.scriptId,
+      classId: data.classId,
       student: data.studentId,
       answers: data.taskAnswers ?? [],
-      grade: data.grade ?? null
+      grade: data.grade ?? null,
+      started_at: data.started_at,
+      status: data.status,
     });
     this.scriptAnswers.push(newAnswer);
     return newAnswer;
@@ -43,6 +62,16 @@ export class ScriptAnswerSet {
     return this.getAll().filter(a => a.getScriptId() === scriptId).slice();
   }
 
+  findByClassId(classId: string) {
+    return this.getAll().filter(a => a.getClassId() === classId).slice();
+  }
+
+  findByClassAndStudent(classId: string, studentId: string) {
+    return this.getAll().filter(a => 
+      a.getClassId() === classId && a.getstudentId() === studentId
+    ).slice();
+  }
+
   updateGrade(id: string, grade: Grade | undefined) {
     const answer = this.findById(id);
     if (!answer) return null;
@@ -61,4 +90,35 @@ export class ScriptAnswerSet {
     }
     return null;
   }
+
+  startTaskAnswer(scriptAnswerId: string, taskId: string, data?: { answer?: string; grade?: Grade; comments?: string }) {
+    const sa = this.findById(scriptAnswerId);
+    if (!sa) return null;
+    return sa.createTaskAnswer(taskId, data);
+  }
+
+  submitTaskAnswer(scriptAnswerId: string, taskId: string, data?: { answer?: string; grade?: Grade; comments?: string }) {
+    const sa = this.findById(scriptAnswerId);
+    if (!sa) return null;
+    return sa.submitTaskAnswer(taskId, data); //submit questão.
+  }
+
+  submitLastTaskAnswer(scriptAnswerId: string,taskId: string, scripts: Scripts,data?: { answer?: string; grade?: Grade; comments?: string }) {
+    const sa = this.findById(scriptAnswerId);
+    if (!sa) return null;
+    const ta = sa.submitTaskAnswer(taskId, data);
+    if (!ta) return null;
+    if (this.isLastTaskInScript(sa.getScriptId(), taskId, scripts)) {
+      sa.markFinished(); //se ultima, marca como terminado.
+    }
+    return ta;
+  }
+
+  isLastTaskInScript(scriptId: string, taskId: string, scripts: Scripts): boolean {
+    const script = scripts.findById(scriptId);
+    if (!script) return false;
+    const allTasks = script.getTasks();
+    return allTasks[allTasks.length - 1].getId() === taskId;
+  } //verifica se é a ultima
 }
+

From 71cf05ad7e72319bc3aadf265e270034187647a7 Mon Sep 17 00:00:00 2001
From: Davi Guerreiro <daviguerreiro9a@gmail.com>
Date: Tue, 9 Dec 2025 04:46:46 -0300
Subject: [PATCH 061/102] fix(mock_scripts): Fixing Mock to implement new
 objects for postman route tests

---
 server/src/mock_scripts.ts | 57 ++++++++++++++++++++++++++++++++++----
 1 file changed, 51 insertions(+), 6 deletions(-)

diff --git a/server/src/mock_scripts.ts b/server/src/mock_scripts.ts
index 045671dd..84e7c5be 100644
--- a/server/src/mock_scripts.ts
+++ b/server/src/mock_scripts.ts
@@ -4,14 +4,38 @@ import { Scripts } from './models/Scripts';
 import { ScriptAnswerSet } from './models/ScriptAnswerSet';
 import { Task } from './models/Task';
 import { TaskAnswer } from './models/TaskAnswer';
+import { Classes } from './models/Classes';
+import { Class } from './models/Class';
+import { StudentSet } from './models/StudentSet';
+import { Student } from './models/Student';
+import { DEFAULT_ESPECIFICACAO_DO_CALCULO_DA_MEDIA } from './models/EspecificacaoDoCalculoDaMedia';
 
 export function loadMockScriptsAndAnswers(
   taskset: TaskSet,
   scripts: Scripts,
   scriptAnswerSet: ScriptAnswerSet,
+  classes: Classes,
+  studentSet: StudentSet,
   studentCPF: string = '11111111111'
 ): void {
+  
   try {
+    // Create mock student if not exists
+    let student = studentSet.findStudentByCPF(studentCPF);
+    if (!student) {
+      student = new Student('João Silva', studentCPF, 'joao@example.com');
+      studentSet.addStudent(student);
+      console.log('Mock student created:', studentCPF);
+    }
+    // Create mock class if not exists
+    let classe = classes.findClassById('Math 101-2024-2024');
+    if (!classe) {
+      classe = new Class('Math 101', 2024, 2024, DEFAULT_ESPECIFICACAO_DO_CALCULO_DA_MEDIA);
+      classes.addClass(classe);
+      // Enroll student in class
+      classe.addEnrollment(student);
+      console.log('Mock class created:', classe.getClassId());
+    }
     // Create mock tasks if none exist
     if (taskset.getAllTasks().length === 0) {
       const task1 = taskset.addTask(
@@ -49,7 +73,11 @@ export function loadMockScriptsAndAnswers(
       if (foundTask2) script3.addTask(foundTask2);
       if (foundTask3) script3.addTask(foundTask3);
 
-      console.log('Mock scripts created:', [script1.getId(), script2.getId(), script3.getId()]);
+      const script4 = scripts.addScript(new (require('./models/Script').Script)('script-004', 'Quiz - Programming 202'));
+      if (foundTask2) script4.addTask(foundTask2);
+      if (foundTask3) script4.addTask(foundTask3);
+
+      console.log('Mock scripts created:', [script1.getId(), script2.getId(), script3.getId(), script4.getId()]);
     }
 
     // Create mock script answers if none exist
@@ -57,6 +85,7 @@ export function loadMockScriptsAndAnswers(
       const answer1 = scriptAnswerSet.addScriptAnswer({
         id: 'answer-001',
         scriptId: 'script-001',
+        classId: 'Math 101-2024-2024',
         studentId: studentCPF,
         taskAnswers: [
           new TaskAnswer(
@@ -82,11 +111,12 @@ export function loadMockScriptsAndAnswers(
           )
         ],
         grade: 'MA'
-      });
+      },classes, studentSet, scripts);
 
       const answer2 = scriptAnswerSet.addScriptAnswer({
         id: 'answer-002',
         scriptId: 'script-002',
+        classId: 'Math 101-2024-2024',
         studentId: studentCPF,
         taskAnswers: [
           new TaskAnswer(
@@ -112,11 +142,11 @@ export function loadMockScriptsAndAnswers(
           )
         ],
         grade: 'MA'
-      });
-
+      },classes, studentSet, scripts);
       const answer3 = scriptAnswerSet.addScriptAnswer({
         id: 'answer-003',
         scriptId: 'script-003',
+        classId: 'Math 101-2024-2024',
         studentId: studentCPF,
         taskAnswers: [
           new TaskAnswer(
@@ -134,9 +164,24 @@ export function loadMockScriptsAndAnswers(
             'Shows understanding but optimization potential missed'
           )
         ]
-      });
+      },classes, studentSet, scripts);
+      const answer4 = scriptAnswerSet.addScriptAnswer({
+        id: 'answer-004',
+        scriptId: 'script-004',
+        classId: 'Math 101-2024-2024',
+        studentId: studentCPF,
+        taskAnswers: [
+          new TaskAnswer(
+            'ta-009',
+            'task-002',
+            'My implementation uses a basic loop structure.',
+            'MPA',
+            'Works correctly but could be optimized'
+          )
+        ]
+      },classes, studentSet, scripts);
 
-      console.log('Mock script answers created:', [answer1.getId(), answer2.getId(), answer3.getId()]);
+      console.log('Mock script answers created:', [answer1.getId(), answer2.getId(), answer3.getId(), answer4.getId()]);
     }
   } catch (error) {
     console.error('Error loading mock scripts and answers:', error);

From 21fe53ee4d4831886686fad11ba8ddbc8d79e2bd Mon Sep 17 00:00:00 2001
From: Davi Guerreiro <daviguerreiro9a@gmail.com>
Date: Tue, 9 Dec 2025 04:49:19 -0300
Subject: [PATCH 062/102] feat(ScriptAnswer): Implementing new routes with
 validations

---
 server/src/server.ts                     |  18 ++-
 server/src/server_routes/scriptanswer.ts | 160 ++++++++++++++++++++++-
 2 files changed, 167 insertions(+), 11 deletions(-)

diff --git a/server/src/server.ts b/server/src/server.ts
index 0c9c1ddb..9dc088df 100644
--- a/server/src/server.ts
+++ b/server/src/server.ts
@@ -61,7 +61,8 @@ const saveDataToFile = (): void => {
           studentCPF: enrollment.getStudent().getCPF(),
           evaluations: enrollment.getEvaluations().map(evaluation => evaluation.toJSON())
         }))
-      }))
+      })),
+      scriptAnswers: scriptAnswerSet.getAll().map(sa => sa.toJSON())
     };
     
     ensureDataDirectory();
@@ -77,7 +78,6 @@ const loadDataFromFile = (): void => {
     if (fs.existsSync(dataFile)) {
       const fileContent = fs.readFileSync(dataFile, 'utf-8');
       const data = JSON.parse(fileContent);
-      
       // Load students
       if (data.students && Array.isArray(data.students)) {
         data.students.forEach((studentData: any) => {
@@ -138,6 +138,16 @@ const loadDataFromFile = (): void => {
           }
         });
       }
+      // Load scriptAnswers
+      if (data.scriptAnswers && Array.isArray(data.scriptAnswers)) {
+        data.scriptAnswers.forEach((saData: any) => {
+          try {
+            scriptAnswerSet.addScriptAnswer(saData);
+          } catch (error) {
+            console.error(`Error loading scriptAnswer ${saData.id}:`, error);
+          }
+        });
+      }
     }
   } catch (error) {
     console.error('Error loading data from file:', error);
@@ -535,11 +545,11 @@ import { setupTaskRoutes } from './server_routes/tasks';
 import { setupScriptRoutes } from './server_routes/scripts';
 import { loadMockScriptsAndAnswers } from './mock_scripts';
 
-setupScriptAnswerRoutes(app, scriptAnswerSet, studentSet);
+setupScriptAnswerRoutes(app, scriptAnswerSet, studentSet, taskset, classes, scripts); //saveDataToFile
 setupTaskRoutes(app, taskset);
 setupScriptRoutes(app, scripts);
 
-loadMockScriptsAndAnswers(taskset, scripts, scriptAnswerSet, "11111111111");
+loadMockScriptsAndAnswers(taskset, scripts, scriptAnswerSet, classes, studentSet, "11111111111");
 
 // Only start the server if this file is run directly (not imported for testing)
 if (require.main === module) {
diff --git a/server/src/server_routes/scriptanswer.ts b/server/src/server_routes/scriptanswer.ts
index 66c74d53..0b5284a9 100644
--- a/server/src/server_routes/scriptanswer.ts
+++ b/server/src/server_routes/scriptanswer.ts
@@ -1,6 +1,6 @@
 import { Request, Response, Express } from 'express';
 
-export function setupScriptAnswerRoutes(app: Express, scriptAnswerSet: any, studentSet: any) {
+export function setupScriptAnswerRoutes(app: Express, scriptAnswerSet: any, studentSet: any, TaskSet: any, classes: any, scripts: any, saveCallback?: () => void) {
   const scriptAnswerurl = '/api/scriptanswers/';
 
   // GET /api/scriptanswers → get ALL answers
@@ -26,6 +26,18 @@ export function setupScriptAnswerRoutes(app: Express, scriptAnswerSet: any, stud
     return res.status(200).json(answers.map((a: any) => a.toJSON()));
   });
 
+  // GET /api/scriptanswers/class/:classId → Answers for a class
+  app.get(scriptAnswerurl+'class/:classId', (req: Request, res: Response) => {
+    const { classId } = req.params;
+
+    const classe = classes.findClassById(classId);
+    if (!classe) {
+      return res.status(404).json({ error: 'class not found' });
+    }
+    const answers = scriptAnswerSet.findByClassId(classId);
+    return res.status(200).json(answers.map((a: any) => a.toJSON()));
+  });
+
   // GET /api/scriptanswers/script/:scriptId → Answers for a script
   app.get(scriptAnswerurl+'script/:scriptId', (req: Request, res: Response) => {
     const { scriptId } = req.params;
@@ -34,6 +46,25 @@ export function setupScriptAnswerRoutes(app: Express, scriptAnswerSet: any, stud
     return res.status(200).json(answers.map((a: any) => a.toJSON()));
   });
 
+  // GET /api/scriptanswers/enrollment?classId=X&studentId=Y  → Answers for a enrollment (student in class)
+  app.get(scriptAnswerurl+'enrollment', (req: Request, res: Response) => {
+    const { classId, studentId } = req.query; //retorna tipo generico (especificar tipo depois)
+    if (!classId || !studentId) {
+      return res.status(400).json({ error: 'classId and studentId are required' });
+    }
+    const classe = classes.findClassById(classId as string);
+    if (!classe) {
+      return res.status(404).json({ error: 'Class not found' });
+    }
+    const student = studentSet.findStudentByCPF(studentId as string);
+    if (!student) {
+      return res.status(404).json({ error: 'Student not found' });
+    }
+
+    const answers = scriptAnswerSet.findByClassAndStudent(classId as string, studentId as string);
+    return res.status(200).json(answers.map((a: any) => a.toJSON()));
+  });
+
   // GET /api/scriptanswers/:id → get ONE answer by ID
   app.get(scriptAnswerurl+':id', (req: Request, res: Response) => {
     const { id } = req.params;
@@ -63,16 +94,131 @@ export function setupScriptAnswerRoutes(app: Express, scriptAnswerSet: any, stud
     return res.status(200).json({ taskId, grade: task.getGrade() });
   });
 
-  // POST /api/scriptanswers → Create a script answer
-  app.post(scriptAnswerurl+'', (req: Request, res: Response) => {
+  // POST /api/scriptanswers → create a scriptanswer (obsoleto)
+
+  // app.post(scriptAnswerurl+'', (req: Request, res: Response) => {
+  //   try {
+  //     const newAnswer = scriptAnswerSet.addScriptAnswer(req.body);
+  //     res.status(201).json(newAnswer.toJSON());
+  //   } catch (error) {
+  //     res.status(400).json({ error: (error as Error).message });
+  //   }
+  // });
+
+  // POST /api/scriptanswers → create a script answer
+
+app.post(scriptAnswerurl+'', (req: Request, res: Response) => {
+  try {
+    const { scriptId, classId, studentId } = req.body;
+    if (!scriptId || !classId || !studentId) {
+      return res.status(400).json({ error: 'scriptId, classId and studentId are required' });
+    }
+    const script = scripts.findById(scriptId);
+    if (!script) {
+      return res.status(404).json({ error: 'Script not found' });
+    }
+    const classe = classes.findClassById(classId);
+    if (!classe) {
+      return res.status(404).json({ error: 'Class not found' });
+    }
+    const student = studentSet.findStudentByCPF(studentId);
+    if (!student) {
+      return res.status(404).json({ error: 'Student not found' });
+    }
+    const enrollment = classe.findEnrollmentByStudentCPF(studentId);
+    if (!enrollment) {
+      return res.status(403).json({ error: 'Student is not enrolled in this class' });
+    }
+    const existing = scriptAnswerSet.findByClassAndStudent(classId, studentId).find((sa: any) => sa.getScriptId() === scriptId);
+    if (existing) {
+      return res.status(409).json({ 
+        error: 'ScriptAnswer already exists',
+        scriptAnswerId: existing.getId()
+      });
+    }
+    const newAnswer = scriptAnswerSet.addScriptAnswer({
+      scriptId,
+      classId,
+      studentId,
+      classes, studentSet, scripts
+    });
+    saveCallback?.();
+    res.status(201).json(newAnswer.toJSON());
+  } catch (error) {
+    res.status(400).json({ error: (error as Error).message });
+  }
+});
+
+  // POST /api/scriptanswers/:id/tasks/:taskId/start → start an answer on the scriptAnswer
+
+  app.post(scriptAnswerurl+':id/tasks/:taskId/start', (req: Request, res: Response) => {
     try {
-      const newAnswer = scriptAnswerSet.addScriptAnswer(req.body);
-      res.status(201).json(newAnswer.toJSON());
+      const { id, taskId } = req.params;
+      const { answer, grade, comments } = req.body;
+      const scriptAnswer = scriptAnswerSet.findById(id);
+      if (!scriptAnswer) {
+        return res.status(404).json({ error: 'ScriptAnswer not found' });
+      }
+      const task = TaskSet.findById(taskId);
+      if (!task) {
+        return res.status(404).json({ error: 'Task not found' });
+      }
+      const ta = scriptAnswerSet.startTaskAnswer(id, taskId, {
+        answer,
+        grade,
+        comments,
+      });
+      if (!ta) {
+        return res.status(404).json({ error: 'Answer already exists in ScriptAnswer' });
+      }
+      saveCallback?.();
+      res.status(201).json(ta.toJSON());
     } catch (error) {
       res.status(400).json({ error: (error as Error).message });
     }
   });
 
+  // POST /api/scriptanswers/:id/tasks/:taskId/submit → submit an answer on the scriptAnswer
+
+  app.post(scriptAnswerurl+':id/tasks/:taskId/submit', (req: Request, res: Response) => {
+  try {
+    const { id, taskId } = req.params;
+    const { answer, grade, comments } = req.body;
+    const ta = scriptAnswerSet.submitLastTaskAnswer(id, taskId, scripts, {
+      answer,
+      grade,
+      comments,
+    });
+    if (!ta) {
+      return res.status(404).json({ error: 'ScriptAnswer or Task not found' });
+    }
+    saveCallback?.();
+    res.json(ta.toJSON());
+  } catch (error) {
+    res.status(400).json({ error: (error as Error).message });
+  }
+});
+
+// POST /api/scriptanswers/:id/timeout → Marca roteiro como expirado por timeout
+app.post(scriptAnswerurl+':id/timeout', (req: Request, res: Response) => {
+  try {
+    const { id } = req.params;
+    const { timeoutSeconds } = req.body; //padrão 3600
+    const sa = scriptAnswerSet.findById(id);
+    if (!sa) {
+      return res.status(404).json({ error: 'ScriptAnswer not found' });
+    }
+    sa.checkAndMarkIfTimedOut(timeoutSeconds);
+    saveCallback?.();
+    res.json({
+      message: 'Timeout check completed',
+      scriptAnswer: sa.toJSON(),
+    });
+  } catch (error) {
+    res.status(500).json({ error: (error as Error).message });
+  }
+});
+
   // PUT /api/scriptanswers/:id/tasks/:taskId → Update grade
   app.put(scriptAnswerurl+':id/tasks/:taskId', (req: Request, res: Response) => {
     const { id, taskId } = req.params;
@@ -91,8 +237,8 @@ export function setupScriptAnswerRoutes(app: Express, scriptAnswerSet: any, stud
     if (!['MANA', 'MPA', 'MA'].includes(grade)) {
       return res.status(400).json({ error: 'Invalid grade' });
     }
-
     task.updateGrade(grade);
+    saveCallback?.();
     return res.status(200).json({ taskId, grade });
   });
 
@@ -112,7 +258,7 @@ export function setupScriptAnswerRoutes(app: Express, scriptAnswerSet: any, stud
     }
 
     task.comments = comment;
-
+    saveCallback?.();
     return res.status(200).json({ taskId, comment });
   });
 }
\ No newline at end of file

From 61f4f6b91f56d21c89a4320bfb4ba52be36cdeec Mon Sep 17 00:00:00 2001
From: Davi Guerreiro <daviguerreiro9a@gmail.com>
Date: Tue, 9 Dec 2025 04:55:17 -0300
Subject: [PATCH 063/102] Delete(): Erasing old initial implementation

---
 server/src/models/Answer.ts            | 53 ----------------
 server/src/models/AnswerSet.ts         | 32 ----------
 server/src/models/ScriptResponse.ts    | 86 --------------------------
 server/src/models/ScriptResponseSet.ts | 55 ----------------
 4 files changed, 226 deletions(-)
 delete mode 100644 server/src/models/Answer.ts
 delete mode 100644 server/src/models/AnswerSet.ts
 delete mode 100644 server/src/models/ScriptResponse.ts
 delete mode 100644 server/src/models/ScriptResponseSet.ts

diff --git a/server/src/models/Answer.ts b/server/src/models/Answer.ts
deleted file mode 100644
index 1c0d76d4..00000000
--- a/server/src/models/Answer.ts
+++ /dev/null
@@ -1,53 +0,0 @@
-import { Task } from './Task';
-export class Answer {
-  private id: string;
-  public task: Task;
-  public started_at?: number;
-  public submitted_at?: number;
-  public time_taken_seconds?: number;
-  public response?: any;
-  public status: 'pending' | 'started' | 'submitted' | 'timed_out' = 'pending';
-
-  constructor(id: string, task: Task) {
-    this.id = id;
-    this.task = task;
-  }
-
-  getId() { return this.id; }
-
-  toJSON() {
-    return {
-      id: this.id,
-      taskId: this.task.getId(),
-      started_at: this.started_at,
-      submitted_at: this.submitted_at,
-      time_taken_seconds: this.time_taken_seconds,
-      response: this.response,
-      status: this.status
-    };
-  }
-
-  update(data: Partial<{
-    started_at: number;
-    submitted_at: number;
-    time_taken_seconds: number;
-    response: any;
-    status: 'pending' | 'started' | 'submitted' | 'timed_out';
-  }>) {
-    if (data.started_at !== undefined) this.started_at = data.started_at;
-    if (data.submitted_at !== undefined) this.submitted_at = data.submitted_at;
-    if (data.time_taken_seconds !== undefined) this.time_taken_seconds = data.time_taken_seconds;
-    if (data.response !== undefined) this.response = data.response;
-    if (data.status !== undefined) this.status = data.status;
-  }
-
-  static fromJSON(obj: any, task: Task): Answer {
-    const a = new Answer(obj.id, task);
-    a.started_at = obj.started_at;
-    a.submitted_at = obj.submitted_at;
-    a.time_taken_seconds = obj.time_taken_seconds;
-    a.response = obj.response;
-    a.status = obj.status ?? 'pending';
-    return a;
-  }
-}
\ No newline at end of file
diff --git a/server/src/models/AnswerSet.ts b/server/src/models/AnswerSet.ts
deleted file mode 100644
index ec0cb67d..00000000
--- a/server/src/models/AnswerSet.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-import { Answer } from './Answer';
-import { Task } from './Task';
-export class AnswerSet {
-  private items: Answer[] = [];
-
-  addAnswer(data: any): Answer {
-    const id = data.id ?? Date.now().toString();
-    const answer = new Answer(id, data.task);
-    if (data.started_at !== undefined) answer.update({ started_at: data.started_at });
-    if (data.submitted_at !== undefined) answer.update({ submitted_at: data.submitted_at });
-    if (data.time_taken_seconds !== undefined) answer.update({ time_taken_seconds: data.time_taken_seconds });
-    if (data.response !== undefined) answer.update({ response: data.response });
-    if (data.status !== undefined) answer.update({ status: data.status });
-    this.items.push(answer);
-    return answer;
-  }
-
-  getAllAnswers(): Answer[] {
-    return this.items;
-  }
-
-  findById(id: string): Answer | undefined {
-    return this.items.find(a => a.getId() === id);
-  }
-
-  updateAnswer(id: string, data: any): Answer | undefined {
-    const answer = this.findById(id);
-    if (!answer) return undefined;
-    answer.update(data);
-    return answer;
-  }
-}
\ No newline at end of file
diff --git a/server/src/models/ScriptResponse.ts b/server/src/models/ScriptResponse.ts
deleted file mode 100644
index 2545354e..00000000
--- a/server/src/models/ScriptResponse.ts
+++ /dev/null
@@ -1,86 +0,0 @@
-import { Answer } from './Answer';
-import { Class } from './Class';
-import { Script } from './Script';
-import { Enrollment } from './Enrollment';
-import { Task } from './Task';
-import { Scripts } from './Scripts';
-export class ScriptResponse {
-  private id: string;
-  public script: Script;
-  public enrollment: Enrollment;
-  public started_at?: number;
-  public finished_at?: number;
-  public status: 'in_progress' | 'finished' = 'in_progress';
-  public answers: Answer[] = [];
-
-  constructor(id: string, script: Script, enrollment: Enrollment, started_at?: number) {
-    this.id = id;
-    this.script = script;
-    this.enrollment = enrollment;
-    this.started_at = started_at ?? Date.now();
-  }
-
-  getId(): string {
-    return this.id;
-  }
-
-  toJSON() {
-    return {
-      id: this.id,
-      scriptId: this.script.getId(),
-      studentCPF: this.enrollment.getStudent().getCPF(),
-      started_at: this.started_at,
-      finished_at: this.finished_at,
-      status: this.status,
-      answers: this.answers.map(a => a.toJSON())
-    };
-  }
-
-  update(data: Partial<{
-    finished_at: number;
-    status: 'in_progress' | 'finished';
-    answers: any[];
-  }>) {
-    if (data.finished_at !== undefined) this.finished_at = data.finished_at;
-    if (data.status !== undefined) this.status = data.status;
-    if (data.answers !== undefined) {
-      this.answers = data.answers.map((o: any) => Answer.fromJSON(o, this.script.findTaskById(o.taskId)!));
-    }
-  }
-
-  addOrGetAnswer(task: Task) {
-    let ans = this.answers.find(a => a.task.getId() === task.getId());
-    if (!ans) {
-      const answerId = `${this.id}-${task.getId()}`;
-      ans = new Answer(answerId, task);
-      ans.started_at = Date.now();
-      this.answers.push(ans);
-    }
-    return ans;
-  }
-
-  findAnswerByTaskId(task: Task) {
-    return this.answers.find(a => a.task.getId() === task.getId());
-  }
-
-  markFinished(finishedAt?: number) {
-    this.finished_at = finishedAt ?? Date.now();
-    this.status = 'finished';
-  }
-
-  static fromJSON(obj: any, scriptSet: Scripts, classObj: Class): ScriptResponse {
-    const script = scriptSet.findById(obj.scriptId);
-    if(!script) throw new Error(`Script ${obj.scriptId} not found`);
-    const enrollment = classObj.findEnrollmentByStudentCPF(obj.studentCPF);
-    if (!enrollment) throw new Error(`Enrollment for CPF ${obj.studentCPF} not found`);
-    const r = new ScriptResponse(obj.id, script, enrollment, obj.started_at);
-    r.finished_at = obj.finished_at;
-    r.status = obj.status ?? 'in_progress';
-    r.answers = (obj.answers ?? []).map((a: any) => {
-      const task = script.findTaskById(a.taskId);
-      if (!task) throw new Error(`Task ${a.taskId} not found`);
-      return Answer.fromJSON(a, task);
-    });
-    return r;
-  }
-}
\ No newline at end of file
diff --git a/server/src/models/ScriptResponseSet.ts b/server/src/models/ScriptResponseSet.ts
deleted file mode 100644
index ba55a027..00000000
--- a/server/src/models/ScriptResponseSet.ts
+++ /dev/null
@@ -1,55 +0,0 @@
-import { ScriptResponse } from './ScriptResponse';
-import { Script } from './Script';
-import { Enrollment } from './Enrollment';
-import { v4 as uuid } from 'uuid';
-export class ScriptResponseSet {
-  private items: ScriptResponse[] = [];
-
-  addScriptResponse(data: {
-    id?: string;
-    script: Script;
-    enrollment: Enrollment;
-    started_at?: number;
-    finished_at?: number;
-    status?: 'in_progress' | 'finished';
-    answers?: any[];
-  }): ScriptResponse {
-    const id = data.id ?? uuid();
-    const scriptresponse = new ScriptResponse(id, data.script, data.enrollment, data.started_at);
-    if (data.finished_at !== undefined) scriptresponse.update({ finished_at: data.finished_at });
-    if (data.status !== undefined) scriptresponse.update({ status: data.status });
-    if (data.answers !== undefined) scriptresponse.update({ answers: data.answers });
-    this.items.push(scriptresponse);
-    return scriptresponse;
-  }
-
-  getAllScriptResponses(): ScriptResponse[] {
-    return this.items;
-  }
-
-  findById(id: string): ScriptResponse | undefined {
-    return this.items.find(r => r.getId() === id);
-  }
-
-  updateScriptResponse(id: string, data: any): ScriptResponse | undefined {
-    const scriptresponse = this.findById(id);
-    if (!scriptresponse) return undefined;
-    scriptresponse.update(data);
-    return scriptresponse;
-  }
-
-  findByStudentAndScript(enrollment: Enrollment, script: Script): ScriptResponse | undefined {
-    const studentCPF = enrollment.getStudent().getCPF();
-    const scriptId = script.getId();
-    return this.items.find(r =>
-      r.enrollment.getStudent().getCPF() === studentCPF &&
-      r.script.getId() === scriptId
-    );
-  }
-
-  createOrGetActiveScriptResponse(enrollment: Enrollment, script: Script): ScriptResponse {
-    const existing = this.findByStudentAndScript(enrollment, script);
-    if (existing && existing.status === 'in_progress') return existing;
-    return this.addScriptResponse({ script, enrollment, started_at: Date.now() });
-  }
-}
\ No newline at end of file

From 621ca95daf6d221b5b2f83731686ea53c5aebd58 Mon Sep 17 00:00:00 2001
From: hlpaa <hlpaa@cin.ufpe.br>
Date: Thu, 20 Nov 2025 17:59:12 -0300
Subject: [PATCH 064/102] server doesnt allow new script with title that
 already exists

---
 server/src/models/Script.ts         | 4 ++++
 server/src/models/Scripts.ts        | 8 ++++++++
 server/src/server_routes/scripts.ts | 7 ++++++-
 3 files changed, 18 insertions(+), 1 deletion(-)

diff --git a/server/src/models/Script.ts b/server/src/models/Script.ts
index 0ba9d66d..78609a80 100644
--- a/server/src/models/Script.ts
+++ b/server/src/models/Script.ts
@@ -15,6 +15,10 @@ export class Script {
     return this.id;
   }
 
+  getTitle(): string | undefined {
+    return this.title;
+  }
+
 toJSON() {
   return {
     id: this.id,
diff --git a/server/src/models/Scripts.ts b/server/src/models/Scripts.ts
index af1194a9..cdca8348 100644
--- a/server/src/models/Scripts.ts
+++ b/server/src/models/Scripts.ts
@@ -6,6 +6,10 @@ export class Scripts {
 
 addScript(data: any): Script {
   const id = data.id ?? Date.now().toString();
+  const equalScripts = this.findByName(data.title);
+  if (equalScripts) {
+    throw new Error('Script with this title already exists');
+  }
   const script = new Script(id, data.title);
 
   if (Array.isArray(data.tasks)) {
@@ -24,6 +28,10 @@ addScript(data: any): Script {
     return this.items.find(s => s.getId() === id);
   }
 
+  findByName(name: string): Script | undefined {
+    return this.items.find(s => s.getTitle() === name);
+  }
+
   updateScript(id: string, data: any): Script | undefined {
     const script = this.findById(id);
     if (!script) return undefined;
diff --git a/server/src/server_routes/scripts.ts b/server/src/server_routes/scripts.ts
index 7f128a7b..b40cb1d5 100644
--- a/server/src/server_routes/scripts.ts
+++ b/server/src/server_routes/scripts.ts
@@ -1,12 +1,17 @@
-import { Request, Response, Express } from 'express';
+import { Express, Request, Response } from 'express';
 
 export function setupScriptRoutes(app: Express, scripts: any) {
   const scripturl = '/api/scripts/';
 
   // POST /api/scripts - Create a new script
   app.post(scripturl+'', (req: Request, res: Response) => {
+    try {
     const script = scripts.addScript(req.body);
     res.status(201).json(script.toJSON());
+  }
+  catch (error) {
+    res.status(400).json({ error: (error as Error).message });
+  }
   });
 
   // GET /api/scripts/:id - Get one script by ID

From 6ccf637f1b51437d927a7979f094821c4f09901f Mon Sep 17 00:00:00 2001
From: hlpaa <hlpaa@cin.ufpe.br>
Date: Thu, 20 Nov 2025 18:06:00 -0300
Subject: [PATCH 065/102] server doesnt allow empty script title

---
 server/src/models/Scripts.ts | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/server/src/models/Scripts.ts b/server/src/models/Scripts.ts
index cdca8348..57896cbf 100644
--- a/server/src/models/Scripts.ts
+++ b/server/src/models/Scripts.ts
@@ -6,6 +6,9 @@ export class Scripts {
 
 addScript(data: any): Script {
   const id = data.id ?? Date.now().toString();
+  if (data.title === undefined || data.title.trim() === '') {
+    throw new Error('Script title is required');
+  }
   const equalScripts = this.findByName(data.title);
   if (equalScripts) {
     throw new Error('Script with this title already exists');

From 54c1c66dc84e01b0f368be1cf6e07a60aa9f4c52 Mon Sep 17 00:00:00 2001
From: hlpaa <hlpaa@cin.ufpe.br>
Date: Thu, 20 Nov 2025 18:09:33 -0300
Subject: [PATCH 066/102] client alerts empty script title

---
 client/src/components/scripts/ScriptEditor.tsx | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/client/src/components/scripts/ScriptEditor.tsx b/client/src/components/scripts/ScriptEditor.tsx
index b7e91a9a..f15a7ee3 100644
--- a/client/src/components/scripts/ScriptEditor.tsx
+++ b/client/src/components/scripts/ScriptEditor.tsx
@@ -20,6 +20,10 @@ export default function ScriptEditor({ script, onSave, onCancel }: ScriptEditorP
   }, [script]);
 
   const handleSubmit = () => {
+    if (title.trim() === "") {
+      alert("Title cannot be empty");
+      return;
+    }
     onSave({ title, tasks });
   };
 

From 7c7afd2ed210a78012434bb4f1f451554ae016bc Mon Sep 17 00:00:00 2001
From: Davi Guerreiro <daviguerreiro9a@gmail.com>
Date: Tue, 9 Dec 2025 15:01:19 -0300
Subject: [PATCH 067/102] Testing: Testcases working with class reference.

---
 server/src/__tests__/ScriptAnswer.test.ts    | 34 +++++-----
 server/src/__tests__/ScriptAnswerSet.test.ts | 34 +++++-----
 server/src/__tests__/TaskAnswer.test.ts      | 38 ++++++-----
 server/src/__tests__/scriptgrading.test.ts   | 68 ++++++++++++++------
 server/src/models/ScriptAnswerSet.ts         |  2 +-
 server/src/server.ts                         |  1 -
 server/src/server_routes/scriptanswer.ts     |  3 +-
 7 files changed, 110 insertions(+), 70 deletions(-)

diff --git a/server/src/__tests__/ScriptAnswer.test.ts b/server/src/__tests__/ScriptAnswer.test.ts
index a807c43d..0d33905e 100644
--- a/server/src/__tests__/ScriptAnswer.test.ts
+++ b/server/src/__tests__/ScriptAnswer.test.ts
@@ -6,7 +6,7 @@ describe("ScriptAnswer", () => {
   let script: ScriptAnswer;
 
   beforeEach(() => {
-    script = new ScriptAnswer("sa1", "script1", "student123");
+    script = new ScriptAnswer("sa1", "script1", "class1", "student123");
   });
 
   // ---------------------------------------------------------------
@@ -24,21 +24,21 @@ describe("ScriptAnswer", () => {
 
     const json = script.toJSON();
 
-    expect(json).toEqual({
-      id: "sa1",
-      scriptId: "script1",
-      student: "student123",
-      answers: [
-        {
-          id: "a1",
-          task: "t1",
-          answer: "my answer",
-          grade: "MA",
-          comments: undefined,
-        },
-      ],
-      grade: undefined,
-    });
+    expect(json.id).toBe("sa1");
+    expect(json.scriptId).toBe("script1");
+    expect(json.classId).toBe("class1");
+    expect(json.student).toBe("student123");
+    expect(json.status).toBe("in_progress");
+    expect(json.started_at).toBeDefined();
+    expect(json.finished_at).toBeUndefined();
+    expect(json.grade).toBeUndefined();
+    expect(json.answers.length).toBe(1);
+    const firstAnswer = json.answers[0];
+    expect(firstAnswer).toBeDefined();
+    expect(firstAnswer!.id).toBe("a1");
+    expect(firstAnswer!.task).toBe("t1");
+    expect(firstAnswer!.answer).toBe("my answer");
+    expect(firstAnswer!.grade).toBe("MA");
   });
 
   // ---------------------------------------------------------------
@@ -115,7 +115,7 @@ describe("ScriptAnswer", () => {
   describe("grade validation", () => {
     test("constructor throws when initialized with invalid grade", () => {
       expect(() => {
-        new ScriptAnswer("bad", "script1", "student123", [], "INVALID" as Grade);
+        new ScriptAnswer("bad", "script1", "class1", "student123", [], "INVALID" as Grade);
       }).toThrow("Invalid grade value");
     });
 
diff --git a/server/src/__tests__/ScriptAnswerSet.test.ts b/server/src/__tests__/ScriptAnswerSet.test.ts
index b3a9fb17..caee157d 100644
--- a/server/src/__tests__/ScriptAnswerSet.test.ts
+++ b/server/src/__tests__/ScriptAnswerSet.test.ts
@@ -17,6 +17,7 @@ describe('ScriptAnswerSet', () => {
       const data = {
         id: 'A1',
         scriptId: 'S1',
+        classId: 'C1',
         studentId: 'ST1',
         taskAnswers: [],
         grade: 'MA'
@@ -34,6 +35,7 @@ describe('ScriptAnswerSet', () => {
     test('should generate an ID if not provided', () => {
       const data = {
         scriptId: 'S1',
+        classId: 'C1',
         studentId: 'ST1'
       };
 
@@ -50,7 +52,7 @@ describe('ScriptAnswerSet', () => {
   // -----------------------------------------
   describe('removeScriptAnswer', () => {
     test('should remove existing script answer and return true', () => {
-      const a = set.addScriptAnswer({ id: 'A1', scriptId: 'S1', studentId: 'ST1' });
+      const a = set.addScriptAnswer({ id: 'A1', scriptId: 'S1', classId: 'C1', studentId: 'ST1' });
       expect(set.getAll().length).toBe(1);
     
       const removed = set.removeScriptAnswer(a.getId());
@@ -60,10 +62,8 @@ describe('ScriptAnswerSet', () => {
     });
 
     test('should return false when answer does not exist', () => {
-      set.addScriptAnswer({ id: 'A1', scriptId: 'S1', studentId: 'ST1' });
-
+      set.addScriptAnswer({ id: 'A1', scriptId: 'S1', classId: 'C1', studentId: 'ST1' });
       const removed = set.removeScriptAnswer('INVALID');
-
       expect(removed).toBe(false);
       expect(set.getAll().length).toBe(1);
     });
@@ -74,8 +74,8 @@ describe('ScriptAnswerSet', () => {
   // -----------------------------------------
   describe('getAll', () => {
     test('should return all stored script answers', () => {
-      set.addScriptAnswer({ id: 'A1', scriptId: 'S1', studentId: 'ST1' });
-      set.addScriptAnswer({ id: 'A2', scriptId: 'S2', studentId: 'ST2' });
+      set.addScriptAnswer({ id: 'A1', scriptId: 'S1', classId: 'C1', studentId: 'ST1' });
+      set.addScriptAnswer({ id: 'A2', scriptId: 'S2', classId: 'C2', studentId: 'ST2' });
 
       const all = set.getAll();
 
@@ -89,9 +89,9 @@ describe('ScriptAnswerSet', () => {
   // -----------------------------------------
   describe('findByStudentId', () => {
     test('should return all answers for a specific student', () => {
-      set.addScriptAnswer({ id: 'A1', scriptId: 'S1', studentId: 'ST1' });
-      set.addScriptAnswer({ id: 'A2', scriptId: 'S2', studentId: 'ST1' });
-      set.addScriptAnswer({ id: 'A3', scriptId: 'S3', studentId: 'ST2' });
+      set.addScriptAnswer({ id: 'A1', scriptId: 'S1', classId: 'C1', studentId: 'ST1' });
+      set.addScriptAnswer({ id: 'A2', scriptId: 'S2', classId: 'C1', studentId: 'ST1' });
+      set.addScriptAnswer({ id: 'A3', scriptId: 'S3', classId: 'C2', studentId: 'ST2' });
 
       const results = set.findByStudentId('ST1');
 
@@ -100,7 +100,7 @@ describe('ScriptAnswerSet', () => {
     });
 
     test('should return an empty array if student has no answers', () => {
-      set.addScriptAnswer({ id: 'A1', scriptId: 'S1', studentId: 'ST1' });
+      set.addScriptAnswer({ id: 'A1', scriptId: 'S1', classId: 'C1', studentId: 'ST1' });
 
       const results = set.findByStudentId('NOPE');
 
@@ -113,7 +113,7 @@ describe('ScriptAnswerSet', () => {
   // -----------------------------------------
   describe('findById', () => {
     test('should return the correct answer by ID', () => {
-      set.addScriptAnswer({ id: 'A1', scriptId: 'S1', studentId: 'ST1' });
+      set.addScriptAnswer({ id: 'A1', scriptId: 'S1', classId: 'C1', studentId: 'ST1' });
 
       const result = set.findById('A1');
 
@@ -133,7 +133,7 @@ describe('ScriptAnswerSet', () => {
   // -----------------------------------------
   describe('updateGrade', () => {
     test('should update grade of an existing script answer', () => {
-      set.addScriptAnswer({ id: 'A1', scriptId: 'S1', studentId: 'ST1', grade: undefined });
+      set.addScriptAnswer({ id: 'A1', scriptId: 'S1', classId: 'C1', studentId: 'ST1', grade: undefined });
 
       const updated = set.updateGrade('A1', 'MA');
 
@@ -156,6 +156,7 @@ describe('ScriptAnswerSet', () => {
       const scriptAnswer = set.addScriptAnswer({
         id: 'A1',
         scriptId: 'S1',
+        classId: 'C1',
         studentId: 'ST1',
         taskAnswers: [
           { id: 'TA1', task: 'T1', grade: 'MA', comments: 'old comment' }
@@ -176,6 +177,7 @@ describe('ScriptAnswerSet', () => {
       set.addScriptAnswer({
         id: 'A1',
         scriptId: 'S1',
+        classId: 'C1',
         studentId: 'ST1',
         taskAnswers: []
       });
@@ -191,9 +193,9 @@ describe('ScriptAnswerSet', () => {
   // -----------------------------------------
   describe('findByScriptId', () => {
     test('should return all answers for a specific script', () => {
-      set.addScriptAnswer({ id: 'A1', scriptId: 'S1', studentId: 'ST1' });
-      set.addScriptAnswer({ id: 'A2', scriptId: 'S1', studentId: 'ST2' });
-      set.addScriptAnswer({ id: 'A3', scriptId: 'S2', studentId: 'ST3' });
+      set.addScriptAnswer({ id: 'A1', scriptId: 'S1', classId: 'C1', studentId: 'ST1' });
+      set.addScriptAnswer({ id: 'A2', scriptId: 'S1', classId: 'C1', studentId: 'ST2' });
+      set.addScriptAnswer({ id: 'A3', scriptId: 'S2', classId: 'C2', studentId: 'ST3' });
 
       const results = set.findbyScriptId('S1');
 
@@ -204,7 +206,7 @@ describe('ScriptAnswerSet', () => {
     });
 
     test('should return an empty array if script has no answers', () => {
-      set.addScriptAnswer({ id: 'A1', scriptId: 'S1', studentId: 'ST1' });
+      set.addScriptAnswer({ id: 'A1', scriptId: 'S1', classId: 'C1', studentId: 'ST1' });
 
       const results = set.findbyScriptId('NOPE');
 
diff --git a/server/src/__tests__/TaskAnswer.test.ts b/server/src/__tests__/TaskAnswer.test.ts
index 99336b80..c8b290b3 100644
--- a/server/src/__tests__/TaskAnswer.test.ts
+++ b/server/src/__tests__/TaskAnswer.test.ts
@@ -36,26 +36,32 @@ describe("TaskAnswer", () => {
   // ---------------------------------------------------------------
   test("toJSON() returns correct structure", () => {
     const ta = new TaskAnswer("a1", taskId, "answer", "MPA");
-
-    expect(ta.toJSON()).toEqual({
-      id: "a1",
-      task: taskId,
-      answer: "answer",
-      grade: "MPA",
-      comments: undefined,
-    });
+    const json = ta.toJSON();
+
+    expect(json.id).toBe("a1");
+    expect(json.task).toBe(taskId);
+    expect(json.answer).toBe("answer");
+    expect(json.grade).toBe("MPA");
+    expect(json.comments).toBeUndefined();
+    expect(json.started_at).toBeDefined();
+    expect(json.status).toBe("started");
+    expect(json.submitted_at).toBeUndefined();
+    expect(json.time_taken_seconds).toBeUndefined();
   });
 
   test("toJSON() omits grade when undefined", () => {
     const ta = new TaskAnswer("a1", taskId, "ans", undefined);
-
-    expect(ta.toJSON()).toEqual({
-      id: "a1",
-      task: taskId,
-      answer: "ans",
-      grade: undefined,
-      comments: undefined,
-    });
+    const json = ta.toJSON();
+
+    expect(json.id).toBe("a1");
+    expect(json.task).toBe(taskId);
+    expect(json.answer).toBe("ans");
+    expect(json.grade).toBeUndefined();
+    expect(json.comments).toBeUndefined();
+    expect(json.started_at).toBeDefined();
+    expect(json.status).toBe("started");
+    expect(json.submitted_at).toBeUndefined();
+    expect(json.time_taken_seconds).toBeUndefined();
   });
 
   // ---------------------------------------------------------------
diff --git a/server/src/__tests__/scriptgrading.test.ts b/server/src/__tests__/scriptgrading.test.ts
index ec4f4472..87b0c6bd 100644
--- a/server/src/__tests__/scriptgrading.test.ts
+++ b/server/src/__tests__/scriptgrading.test.ts
@@ -1,7 +1,11 @@
 import request from 'supertest';
-import { app, scriptAnswerSet, studentSet } from '../server';
+import { app, scriptAnswerSet, studentSet, classes, scripts } from '../server';
 import { Student } from '../models/Student';
 import { TaskAnswer } from '../models/TaskAnswer';
+import { Class } from '../models/Class';
+import { Script } from '../models/Script';
+import { Task } from '../models/Task';
+import { EspecificacaoDoCalculoDaMedia } from '../models/EspecificacaoDoCalculoDaMedia';
 
 describe('Server API – Script Answers Endpoints', () => {
 
@@ -15,6 +19,27 @@ describe('Server API – Script Answers Endpoints', () => {
     const allAnswers = scriptAnswerSet.getAll();
     allAnswers.forEach(a => scriptAnswerSet.removeScriptAnswer(a.getId()));
     expect(scriptAnswerSet.getAll().length).toBe(0);
+
+    // Clear classes
+    const allClasses = classes.getAllClasses();
+    allClasses.forEach(c => classes.removeClass(c.getClassId()));
+
+    // Create test student with valid 11-digit CPF
+    const testStudent = new Student('Test Student', '12345678901', 'test@test.com');
+    studentSet.addStudent(testStudent);
+
+    // Create test class
+    const gradeWeights = new Map<'MA'|'MPA'|'MANA', number>([['MA', 3], ['MPA', 2], ['MANA', 1]]);
+    const metaWeights = new Map<string, number>([['Test Meta', 1]]);
+    const testClass = new Class('Test Class', 1, 2024, new EspecificacaoDoCalculoDaMedia(gradeWeights, metaWeights));
+    classes.addClass(testClass);
+
+    // Enroll student in class
+    testClass.addEnrollment(testStudent);
+
+    // Create test script
+    const testScript = new Script('1', 'Test Script');
+    scripts.addScript({ id: '1', title: 'Test Script' });
   });
 
   // ----------------------------------------------------------
@@ -22,9 +47,10 @@ describe('Server API – Script Answers Endpoints', () => {
   // ----------------------------------------------------------
 
   test('GET /api/scriptanswers → returns all registered answers', async () => {
-    scriptAnswerSet.addScriptAnswer({ id: '123', scriptId: '1', studentId: 'S1' });
-    scriptAnswerSet.addScriptAnswer({ id: '321', scriptId: '2', studentId: 'S2' });
-    scriptAnswerSet.addScriptAnswer({ id: '890', scriptId: '3', studentId: 'S3' });
+    const classId = 'Test Class-2024-1';
+    scriptAnswerSet.addScriptAnswer({ id: '123', scriptId: '1', classId, studentId: '12345678901' });
+    scriptAnswerSet.addScriptAnswer({ id: '321', scriptId: '2', classId, studentId: '12345678901' });
+    scriptAnswerSet.addScriptAnswer({ id: '890', scriptId: '3', classId, studentId: '12345678901' });
 
     const res = await request(app).get('/api/scriptanswers/');
 
@@ -52,9 +78,9 @@ describe('Server API – Script Answers Endpoints', () => {
 
   test('GET /api/scriptanswers/student/:studentId → returns answers of a specific student', async () => {
     studentSet.addStudent(new Student('Alice', '15029035478', 'alice@gmail.com'));
-    scriptAnswerSet.addScriptAnswer({ id: '40', scriptId: '1', studentId: '15029035478' });
-    scriptAnswerSet.addScriptAnswer({ id: '41', scriptId: '2', studentId: '15029035478' });
-    scriptAnswerSet.addScriptAnswer({ id: '999', scriptId: 'X', studentId: 'other' });
+    scriptAnswerSet.addScriptAnswer({ id: '40', scriptId: '1', classId: 'Test Class-2024-1', studentId: '15029035478' });
+    scriptAnswerSet.addScriptAnswer({ id: '41', scriptId: '2', classId: 'Test Class-2024-1', studentId: '15029035478' });
+    scriptAnswerSet.addScriptAnswer({ id: '999', scriptId: 'X', classId: 'Test Class-2024-1', studentId: '99999999999' });
 
     const res = await request(app).get('/api/scriptanswers/student/15029035478');
 
@@ -79,9 +105,9 @@ describe('Server API – Script Answers Endpoints', () => {
   // ----------------------------------------------------------
 
   test('GET /api/scriptanswers/script/:scriptId → returns answers for a specific script', async () => {
-    scriptAnswerSet.addScriptAnswer({ id: '50', scriptId: '1', studentId: 'S1' });
-    scriptAnswerSet.addScriptAnswer({ id: '51', scriptId: '1', studentId: 'S2' });
-    scriptAnswerSet.addScriptAnswer({ id: '52', scriptId: '2', studentId: 'S3' });
+    scriptAnswerSet.addScriptAnswer({ id: '50', scriptId: '1', classId: 'Test Class-2024-1', studentId: '12345678901' });
+    scriptAnswerSet.addScriptAnswer({ id: '51', scriptId: '1', classId: 'Test Class-2024-1', studentId: '22222222222' });
+    scriptAnswerSet.addScriptAnswer({ id: '52', scriptId: '2', classId: 'Test Class-2024-1', studentId: '33333333333' });
 
     const res = await request(app).get('/api/scriptanswers/script/1');
 
@@ -95,7 +121,7 @@ describe('Server API – Script Answers Endpoints', () => {
   // ----------------------------------------------------------
 
   test('GET /api/scriptanswers/:id → returns a specific script answer', async () => {
-    scriptAnswerSet.addScriptAnswer({ id: '60', scriptId: '1', studentId: 'S1', grade: 'MA' });
+    scriptAnswerSet.addScriptAnswer({ id: '60', scriptId: '1', classId: 'Test Class-2024-1', studentId: '12345678901', grade: 'MA' });
 
     const res = await request(app).get('/api/scriptanswers/60');
 
@@ -124,7 +150,8 @@ describe('Server API – Script Answers Endpoints', () => {
     const answer = scriptAnswerSet.addScriptAnswer({
       id: '70',
       scriptId: '1',
-      studentId: 'stu'
+      classId: 'Test Class-2024-1',
+      studentId: '12345678901'
     });
     answer.addAnswer(new TaskAnswer('TA1', 't1', 'my answer', 'MA'));
 
@@ -143,7 +170,8 @@ describe('Server API – Script Answers Endpoints', () => {
     scriptAnswerSet.addScriptAnswer({
       id: '80',
       scriptId: '1',
-      studentId: 'stu'
+      classId: 'Test Class-2024-1',
+      studentId: '12345678901'
     });
 
     const res = await request(app).get('/api/scriptanswers/80/tasks/missing');
@@ -162,13 +190,14 @@ describe('Server API – Script Answers Endpoints', () => {
       .send({
         id: '90',
         scriptId: '1',
-        studentId: 'S1'
+        classId: 'Test Class-2024-1',
+        studentId: '12345678901'
       });
 
     expect(res.status).toBe(201);
     expect(res.body.id).toBe('90');
     expect(res.body.scriptId).toBe('1');
-    expect(res.body.student).toBe('S1');
+    expect(res.body.student).toBe('12345678901');
   });
 
   // ----------------------------------------------------------
@@ -179,7 +208,8 @@ describe('Server API – Script Answers Endpoints', () => {
     const answer = scriptAnswerSet.addScriptAnswer({
       id: '100',
       scriptId: '1',
-      studentId: 'S1'
+      classId: 'Test Class-2024-1',
+      studentId: '12345678901'
     });
     answer.addAnswer(new TaskAnswer('TA2', 't2', 'answer', 'MPA'));
 
@@ -200,7 +230,8 @@ describe('Server API – Script Answers Endpoints', () => {
     const answer = scriptAnswerSet.addScriptAnswer({
       id: '110',
       scriptId: '1',
-      studentId: 'S1'
+      classId: 'Test Class-2024-1',
+      studentId: '12345678901'
     });
     answer.addAnswer(new TaskAnswer('TA3', 't3', 'answer'));
 
@@ -220,7 +251,8 @@ describe('Server API – Script Answers Endpoints', () => {
     const answer = scriptAnswerSet.addScriptAnswer({
       id: '120',
       scriptId: '1',
-      studentId: 'S1'
+      classId: 'Test Class-2024-1',
+      studentId: '12345678901'
     });
     answer.addAnswer(new TaskAnswer('TA4', 't4', 'answer'));
 
diff --git a/server/src/models/ScriptAnswerSet.ts b/server/src/models/ScriptAnswerSet.ts
index 5c185284..81cb7126 100644
--- a/server/src/models/ScriptAnswerSet.ts
+++ b/server/src/models/ScriptAnswerSet.ts
@@ -23,7 +23,7 @@ export class ScriptAnswerSet {
       throw new Error(`Script with ID ${data.scriptId} not found`);
     }
     const newAnswer = ScriptAnswer.fromJSON({
-      id: data.id ??  uuid(),
+      id: data.id ?? uuid(),
       scriptId: data.scriptId,
       classId: data.classId,
       student: data.studentId,
diff --git a/server/src/server.ts b/server/src/server.ts
index 9dc088df..05086afb 100644
--- a/server/src/server.ts
+++ b/server/src/server.ts
@@ -7,7 +7,6 @@ import { Classes } from './models/Classes';
 import { Class } from './models/Class';
 import { Report } from './models/Report';
 import { Scripts } from './models/Scripts';
-import { ScriptResponseSet } from './models/ScriptResponseSet';
 import * as fs from 'fs';
 import * as path from 'path';
 import { EspecificacaoDoCalculoDaMedia, DEFAULT_ESPECIFICACAO_DO_CALCULO_DA_MEDIA } from './models/EspecificacaoDoCalculoDaMedia';
diff --git a/server/src/server_routes/scriptanswer.ts b/server/src/server_routes/scriptanswer.ts
index 0b5284a9..4c65d485 100644
--- a/server/src/server_routes/scriptanswer.ts
+++ b/server/src/server_routes/scriptanswer.ts
@@ -109,7 +109,7 @@ export function setupScriptAnswerRoutes(app: Express, scriptAnswerSet: any, stud
 
 app.post(scriptAnswerurl+'', (req: Request, res: Response) => {
   try {
-    const { scriptId, classId, studentId } = req.body;
+    const { id, scriptId, classId, studentId } = req.body;
     if (!scriptId || !classId || !studentId) {
       return res.status(400).json({ error: 'scriptId, classId and studentId are required' });
     }
@@ -137,6 +137,7 @@ app.post(scriptAnswerurl+'', (req: Request, res: Response) => {
       });
     }
     const newAnswer = scriptAnswerSet.addScriptAnswer({
+      id,
       scriptId,
       classId,
       studentId,

From 34a6c01d6ded0b7b598a5fb760c5ad9c1cd04071 Mon Sep 17 00:00:00 2001
From: hlpaa <hlpaa@cin.ufpe.br>
Date: Tue, 9 Dec 2025 15:49:58 -0300
Subject: [PATCH 068/102] new data structure for scripts and new field in
 ScriptEditor

---
 client/src/components/scripts/ScriptEditor.tsx | 13 ++++++++++++-
 client/src/types/Script.ts                     |  3 +++
 server/src/models/Script.ts                    |  5 ++++-
 server/src/models/Scripts.ts                   |  2 +-
 4 files changed, 20 insertions(+), 3 deletions(-)

diff --git a/client/src/components/scripts/ScriptEditor.tsx b/client/src/components/scripts/ScriptEditor.tsx
index f15a7ee3..178fdf2c 100644
--- a/client/src/components/scripts/ScriptEditor.tsx
+++ b/client/src/components/scripts/ScriptEditor.tsx
@@ -11,11 +11,13 @@ interface ScriptEditorProps {
 
 export default function ScriptEditor({ script, onSave, onCancel }: ScriptEditorProps) {
   const [title, setTitle] = useState(script?.title || "");
+  const [description, setDescription] = useState(script?.description || "");
   const [tasks, setTasks] = useState<Task[]>(script?.tasks || []);
 
   // Update state when script prop changes
   useEffect(() => {
     setTitle(script?.title || "");
+    setDescription(script?.description || "");
     setTasks(script?.tasks || []);
   }, [script]);
 
@@ -24,7 +26,7 @@ export default function ScriptEditor({ script, onSave, onCancel }: ScriptEditorP
       alert("Title cannot be empty");
       return;
     }
-    onSave({ title, tasks });
+    onSave({ title, description, tasks });
   };
 
   return (
@@ -41,6 +43,15 @@ export default function ScriptEditor({ script, onSave, onCancel }: ScriptEditorP
         />
       </div>
 
+      <div style={{ marginTop: "0.5rem" }}>
+        <label>Description:</label>
+        <input
+          value={description}
+          onChange={(e) => setDescription(e.target.value)}
+          style={{ marginLeft: "1rem", width: "60%" }}
+        />
+      </div>
+
       <TaskListEditor tasks={tasks} setTasks={setTasks} />
 
       <button onClick={handleSubmit}>Save</button>
diff --git a/client/src/types/Script.ts b/client/src/types/Script.ts
index e1b4b67f..9be790b6 100644
--- a/client/src/types/Script.ts
+++ b/client/src/types/Script.ts
@@ -2,16 +2,19 @@ import { Task } from "./Task";
 export interface Script {
   id: string;
   title?: string;
+  description?: string;
   tasks?: Task[]
 }
 
 export interface CreateScriptRequest {
   title?: string;
+  description?: string;
   tasks?: Task[];
 }
 
 export interface UpdateScriptRequest {
   title?: string;
+  description?: string;
   tasks?: Task[];
 }
 
diff --git a/server/src/models/Script.ts b/server/src/models/Script.ts
index 78609a80..fe64267d 100644
--- a/server/src/models/Script.ts
+++ b/server/src/models/Script.ts
@@ -3,11 +3,13 @@ import { Task } from "./Task";
 export class Script {
   private id: string;
   public title?: string;
+  public description?: string;
   public tasks: Task[] = [];
 
-  constructor(id: string, title?: string, tasks?: Task[]) {
+  constructor(id: string, title?: string, description?: string, tasks?: Task[]) {
     this.id = id;
     this.title = title;
+    this.description = description;
     this.tasks = tasks || [];
   }
 
@@ -23,6 +25,7 @@ toJSON() {
   return {
     id: this.id,
     title: this.title,
+    description: this.description,
     tasks: this.tasks.map(task => {
       if (task && typeof task.toJSON === "function") {
         return task.toJSON();
diff --git a/server/src/models/Scripts.ts b/server/src/models/Scripts.ts
index 57896cbf..1e649630 100644
--- a/server/src/models/Scripts.ts
+++ b/server/src/models/Scripts.ts
@@ -13,7 +13,7 @@ addScript(data: any): Script {
   if (equalScripts) {
     throw new Error('Script with this title already exists');
   }
-  const script = new Script(id, data.title);
+  const script = new Script(id, data.title, data.description);
 
   if (Array.isArray(data.tasks)) {
     script.tasks = data.tasks.map((t: any) => Task.fromJSON(t));

From f40c694641bc66a99e9fcbe7c63b4d12f374eb98 Mon Sep 17 00:00:00 2001
From: hlpaa <hlpaa@cin.ufpe.br>
Date: Tue, 9 Dec 2025 16:18:57 -0300
Subject: [PATCH 069/102] adding "description" to mock

---
 server/src/mock_scripts.ts | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/server/src/mock_scripts.ts b/server/src/mock_scripts.ts
index 045671dd..b54e13c7 100644
--- a/server/src/mock_scripts.ts
+++ b/server/src/mock_scripts.ts
@@ -1,9 +1,8 @@
-import { Express } from 'express';
-import { TaskSet } from './models/TaskSet';
-import { Scripts } from './models/Scripts';
 import { ScriptAnswerSet } from './models/ScriptAnswerSet';
+import { Scripts } from './models/Scripts';
 import { Task } from './models/Task';
 import { TaskAnswer } from './models/TaskAnswer';
+import { TaskSet } from './models/TaskSet';
 
 export function loadMockScriptsAndAnswers(
   taskset: TaskSet,
@@ -31,7 +30,7 @@ export function loadMockScriptsAndAnswers(
 
     // Create mock scripts if none exist
     if (scripts.getAllScripts().length === 0) {
-      const script1 = scripts.addScript(new (require('./models/Script').Script)('script-001', 'Midterm Exam - Math 101'));
+      const script1 = scripts.addScript(new (require('./models/Script').Script)('script-001', 'Midterm Exam - Math 101', 'Comprehensive midterm assessment'));
       const foundTask1 = taskset.findById('task-001');
       const foundTask2 = taskset.findById('task-002');
       const foundTask3 = taskset.findById('task-003');
@@ -40,12 +39,12 @@ export function loadMockScriptsAndAnswers(
       if (foundTask2) script1.addTask(foundTask2);
       if (foundTask3) script1.addTask(foundTask3);
 
-      const script2 = scripts.addScript(new (require('./models/Script').Script)('script-002', 'Final Exam - Math 101'));
+      const script2 = scripts.addScript(new (require('./models/Script').Script)('script-002', 'Final Exam - Math 101', 'Final comprehensive examination'));
       if (foundTask1) script2.addTask(foundTask1);
       if (foundTask2) script2.addTask(foundTask2);
       if (foundTask3) script2.addTask(foundTask3);
 
-      const script3 = scripts.addScript(new (require('./models/Script').Script)('script-003', 'Quiz - Programming 201'));
+      const script3 = scripts.addScript(new (require('./models/Script').Script)('script-003', 'Quiz - Programming 201', 'Quick assessment quiz'));
       if (foundTask2) script3.addTask(foundTask2);
       if (foundTask3) script3.addTask(foundTask3);
 

From daf4a4878edb2ac28be427d3e89ec36f3717b260 Mon Sep 17 00:00:00 2001
From: hlpaa <hlpaa@cin.ufpe.br>
Date: Tue, 9 Dec 2025 17:08:00 -0300
Subject: [PATCH 070/102] small issue

---
 server/src/models/Script.ts | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/server/src/models/Script.ts b/server/src/models/Script.ts
index fe64267d..4ba95999 100644
--- a/server/src/models/Script.ts
+++ b/server/src/models/Script.ts
@@ -21,7 +21,11 @@ export class Script {
     return this.title;
   }
 
-toJSON() {
+  getDescription(): string | undefined {
+    return this.description;
+  }
+
+  toJSON() {
   return {
     id: this.id,
     title: this.title,
@@ -70,8 +74,9 @@ toJSON() {
     return true;
   }
 
-  update(data: Partial<{ title: any; tasks: any }>) {
+  update(data: Partial<{ title: any; description: any; tasks: any }>) {
     if (data.title !== undefined) this.title = data.title;
+    if (data.description !== undefined) this.description = data.description;
     if (data.tasks !== undefined){
       this.tasks = data.tasks.map((t: any) => Task.fromJSON(t));
     };

From baad6f48d1ad35a68add520ae099f5293597195e Mon Sep 17 00:00:00 2001
From: hlpaa <hlpaa@cin.ufpe.br>
Date: Tue, 9 Dec 2025 17:21:09 -0300
Subject: [PATCH 071/102] preventing empty description field

---
 client/src/components/scripts/ScriptEditor.tsx | 4 ++++
 server/src/models/Scripts.ts                   | 3 +++
 2 files changed, 7 insertions(+)

diff --git a/client/src/components/scripts/ScriptEditor.tsx b/client/src/components/scripts/ScriptEditor.tsx
index 178fdf2c..7ab06225 100644
--- a/client/src/components/scripts/ScriptEditor.tsx
+++ b/client/src/components/scripts/ScriptEditor.tsx
@@ -26,6 +26,10 @@ export default function ScriptEditor({ script, onSave, onCancel }: ScriptEditorP
       alert("Title cannot be empty");
       return;
     }
+    if (description.trim() === "") {
+      alert("Description cannot be empty");
+      return;
+    }
     onSave({ title, description, tasks });
   };
 
diff --git a/server/src/models/Scripts.ts b/server/src/models/Scripts.ts
index 1e649630..4cbea99e 100644
--- a/server/src/models/Scripts.ts
+++ b/server/src/models/Scripts.ts
@@ -9,6 +9,9 @@ addScript(data: any): Script {
   if (data.title === undefined || data.title.trim() === '') {
     throw new Error('Script title is required');
   }
+  if (data.description === undefined || data.description.trim() === '') {
+    throw new Error('Script description is required');
+  }
   const equalScripts = this.findByName(data.title);
   if (equalScripts) {
     throw new Error('Script with this title already exists');

From fad5afddd8b534c5732cec5aa7434bff819b782b Mon Sep 17 00:00:00 2001
From: hlpaa <hlpaa@cin.ufpe.br>
Date: Tue, 9 Dec 2025 17:50:50 -0300
Subject: [PATCH 072/102] preventing create script with zero tasks

---
 client/src/components/scripts/ScriptEditor.tsx | 6 +++++-
 server/src/models/Scripts.ts                   | 3 +++
 2 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/client/src/components/scripts/ScriptEditor.tsx b/client/src/components/scripts/ScriptEditor.tsx
index 7ab06225..afc8754c 100644
--- a/client/src/components/scripts/ScriptEditor.tsx
+++ b/client/src/components/scripts/ScriptEditor.tsx
@@ -30,6 +30,10 @@ export default function ScriptEditor({ script, onSave, onCancel }: ScriptEditorP
       alert("Description cannot be empty");
       return;
     }
+    if (tasks.length === 0) {
+      alert("Script must have at least one task");
+      return;
+    }
     onSave({ title, description, tasks });
   };
 
@@ -58,7 +62,7 @@ export default function ScriptEditor({ script, onSave, onCancel }: ScriptEditorP
 
       <TaskListEditor tasks={tasks} setTasks={setTasks} />
 
-      <button onClick={handleSubmit}>Save</button>
+      <button onClick={handleSubmit} disabled={tasks.length === 0}>Save</button>
       {onCancel && (
         <button onClick={onCancel} style={{ marginLeft: "1rem" }}>
           Cancel
diff --git a/server/src/models/Scripts.ts b/server/src/models/Scripts.ts
index 4cbea99e..a692b289 100644
--- a/server/src/models/Scripts.ts
+++ b/server/src/models/Scripts.ts
@@ -9,6 +9,9 @@ addScript(data: any): Script {
   if (data.title === undefined || data.title.trim() === '') {
     throw new Error('Script title is required');
   }
+  if (!Array.isArray(data.tasks) || data.tasks.length === 0) {
+    throw new Error('Script must have at least one task');
+  }
   if (data.description === undefined || data.description.trim() === '') {
     throw new Error('Script description is required');
   }

From 6a1ac8be9a4b1e88bb13228536c274f592898bb3 Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Tue, 9 Dec 2025 17:57:06 -0300
Subject: [PATCH 073/102] BUGFIX: now server check whether or not the
 scriptanswer being added is related to an existing script

---
 server/src/__tests__/scriptgrading.test.ts |  3 ++-
 server/src/server.ts                       |  2 +-
 server/src/server_routes/scriptanswer.ts   | 31 +++++++++++++++-------
 3 files changed, 25 insertions(+), 11 deletions(-)

diff --git a/server/src/__tests__/scriptgrading.test.ts b/server/src/__tests__/scriptgrading.test.ts
index 8d6da633..d2bb6d3b 100644
--- a/server/src/__tests__/scriptgrading.test.ts
+++ b/server/src/__tests__/scriptgrading.test.ts
@@ -1,5 +1,5 @@
 import request from 'supertest';
-import { app, scriptAnswerSet, studentSet } from '../server';
+import { app, scriptAnswerSet, scripts, studentSet } from '../server';
 import { Student } from '../models/Student';
 import { TaskAnswer } from '../models/TaskAnswer';
 
@@ -157,6 +157,7 @@ describe('Server API – Script Answers Endpoints', () => {
   // ----------------------------------------------------------
 
   test('POST /api/scriptanswers → creates a new script answer', async () => {
+    scripts.addScript({ id: '1', title: 'Test Script' });
     const res = await request(app)
       .post('/api/scriptanswers/')
       .send({
diff --git a/server/src/server.ts b/server/src/server.ts
index da1f22aa..23be2955 100644
--- a/server/src/server.ts
+++ b/server/src/server.ts
@@ -534,7 +534,7 @@ import { setupTaskRoutes } from './server_routes/tasks';
 import { setupScriptRoutes } from './server_routes/scripts';
 import { loadMockScriptsAndAnswers } from './mock_scripts';
 
-setupScriptAnswerRoutes(app, scriptAnswerSet, studentSet);
+setupScriptAnswerRoutes(app, scriptAnswerSet, studentSet, scripts);
 setupTaskRoutes(app, taskset);
 setupScriptRoutes(app, scripts);
 
diff --git a/server/src/server_routes/scriptanswer.ts b/server/src/server_routes/scriptanswer.ts
index a5c8b2e6..ba9b9573 100644
--- a/server/src/server_routes/scriptanswer.ts
+++ b/server/src/server_routes/scriptanswer.ts
@@ -1,7 +1,7 @@
 import { Request, Response, Express } from 'express';
 import { TaskAnswer } from '../models/TaskAnswer';
 
-export function setupScriptAnswerRoutes(app: Express, scriptAnswerSet: any, studentSet: any) {
+export function setupScriptAnswerRoutes(app: Express, scriptAnswerSet: any, studentSet: any, scriptSet: any) {
   const scriptAnswerurl = '/api/scriptanswers/';
 
   // GET /api/scriptanswers → get ALL answers
@@ -64,15 +64,28 @@ export function setupScriptAnswerRoutes(app: Express, scriptAnswerSet: any, stud
     return res.status(200).json({ taskId, grade: task.getGrade() });
   });
 
-  // POST /api/scriptanswers → Create a script answer
-  app.post(scriptAnswerurl+'', (req: Request, res: Response) => {
-    try {
-      const newAnswer = scriptAnswerSet.addScriptAnswer(req.body);
-      res.status(201).json(newAnswer.toJSON());
-    } catch (error) {
-      res.status(400).json({ error: (error as Error).message });
+// POST /api/scriptanswers → Create a script answer
+app.post(scriptAnswerurl+'', (req: Request, res: Response) => {
+  try {
+    const { scriptId } = req.body;
+
+    // Validate that scriptId is provided
+    if (!scriptId) {
+      return res.status(400).json({ error: 'Missing required field: scriptId' });
     }
-  });
+
+    // Check if the script exists (assuming you have a scriptSet or similar)
+    const scriptExists = scriptSet.findById(scriptId); // or however you check for script existence
+    if (!scriptExists) {
+      return res.status(404).json({ error: 'Script not found' });
+    }
+
+    const newAnswer = scriptAnswerSet.addScriptAnswer(req.body);
+    res.status(201).json(newAnswer.toJSON());
+  } catch (error) {
+    res.status(400).json({ error: (error as Error).message });
+  }
+});
 
   // POST /api/scriptanswers/:id/tasks → Add a new task answer to a script answer
   app.post(scriptAnswerurl+':id/tasks', (req: Request, res: Response) => {

From 229df4a586512e281a5b3266f4ba5257eeb7319c Mon Sep 17 00:00:00 2001
From: hlpaa <hlpaa@cin.ufpe.br>
Date: Tue, 9 Dec 2025 18:14:14 -0300
Subject: [PATCH 074/102] adding "tasks" to mock

---
 server/src/mock_scripts.ts | 29 ++++++++++++++++++-----------
 1 file changed, 18 insertions(+), 11 deletions(-)

diff --git a/server/src/mock_scripts.ts b/server/src/mock_scripts.ts
index b54e13c7..42b3e787 100644
--- a/server/src/mock_scripts.ts
+++ b/server/src/mock_scripts.ts
@@ -30,23 +30,30 @@ export function loadMockScriptsAndAnswers(
 
     // Create mock scripts if none exist
     if (scripts.getAllScripts().length === 0) {
-      const script1 = scripts.addScript(new (require('./models/Script').Script)('script-001', 'Midterm Exam - Math 101', 'Comprehensive midterm assessment'));
       const foundTask1 = taskset.findById('task-001');
       const foundTask2 = taskset.findById('task-002');
       const foundTask3 = taskset.findById('task-003');
 
-      if (foundTask1) script1.addTask(foundTask1);
-      if (foundTask2) script1.addTask(foundTask2);
-      if (foundTask3) script1.addTask(foundTask3);
+      const script1 = scripts.addScript({
+        id: 'script-001',
+        title: 'Midterm Exam - Math 101',
+        description: 'Comprehensive midterm assessment',
+        tasks: [foundTask1, foundTask2, foundTask3].filter(Boolean)
+      });
 
-      const script2 = scripts.addScript(new (require('./models/Script').Script)('script-002', 'Final Exam - Math 101', 'Final comprehensive examination'));
-      if (foundTask1) script2.addTask(foundTask1);
-      if (foundTask2) script2.addTask(foundTask2);
-      if (foundTask3) script2.addTask(foundTask3);
+      const script2 = scripts.addScript({
+        id: 'script-002',
+        title: 'Final Exam - Math 101',
+        description: 'Final comprehensive examination',
+        tasks: [foundTask1, foundTask2, foundTask3].filter(Boolean)
+      });
 
-      const script3 = scripts.addScript(new (require('./models/Script').Script)('script-003', 'Quiz - Programming 201', 'Quick assessment quiz'));
-      if (foundTask2) script3.addTask(foundTask2);
-      if (foundTask3) script3.addTask(foundTask3);
+      const script3 = scripts.addScript({
+        id: 'script-003',
+        title: 'Quiz - Programming 201',
+        description: 'Quick assessment quiz',
+        tasks: [foundTask2, foundTask3].filter(Boolean)
+      });
 
       console.log('Mock scripts created:', [script1.getId(), script2.getId(), script3.getId()]);
     }

From dd23b5d329edd0ae15bb9c4047647c2c544e7e00 Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Tue, 9 Dec 2025 18:14:59 -0300
Subject: [PATCH 075/102] FEAT: added DELETE route for script deletion

---
 .../server-scriptAnswer-steps.ts              | 27 +++++++++++++++++++
 server/src/server_routes/scripts.ts           | 17 ++++++++++++
 2 files changed, 44 insertions(+)

diff --git a/client/src/step-definitions/server-scriptAnswer-steps.ts b/client/src/step-definitions/server-scriptAnswer-steps.ts
index ef8f7f0b..ee86991a 100644
--- a/client/src/step-definitions/server-scriptAnswer-steps.ts
+++ b/client/src/step-definitions/server-scriptAnswer-steps.ts
@@ -13,6 +13,7 @@ const serverUrl = 'http://localhost:3005';
 // ============================================================
 let lastResponse: Response;
 let createdScriptAnswerIds: string[] = [];
+let createdScriptsIds: string[] = [];
 let createdStudentCPF: string | null = null;
 let lastCreatedScriptAnswerId: string | null = null;
 let mostRecentTaskId: string | null = null;
@@ -20,7 +21,27 @@ let mostRecentTaskId: string | null = null;
 // ============================================================
 // Helper functions
 // ============================================================
+
+async function createScript(title, id: string) {
+  const response = await fetch(`${serverUrl}/api/scripts/`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ id: id, title: title, tasks: [] })
+  });
+
+  lastResponse = response;
+  expect(response.status).toBe(201);
+  createdScriptsIds.push(id);
+
+  return response;
+}
+
+
+
+
 async function createScriptAnswer(id: string, studentId: string) {
+  await createScript(`Script for ${id}`, `script-${id}`);
+
   const response = await fetch(`${serverUrl}/api/scriptanswers/`, {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
@@ -85,6 +106,12 @@ After({ tags: '@server' }, async function () {
     createdStudentCPF = null;
   }
 
+  for (const id of createdScriptsIds) {
+    await fetch(`${serverUrl}/api/scripts/${id}`, { method: 'DELETE' });
+  }
+  createdScriptsIds = [];
+
+
   lastCreatedScriptAnswerId = null;
 });
 
diff --git a/server/src/server_routes/scripts.ts b/server/src/server_routes/scripts.ts
index b40cb1d5..2e880e89 100644
--- a/server/src/server_routes/scripts.ts
+++ b/server/src/server_routes/scripts.ts
@@ -14,6 +14,23 @@ export function setupScriptRoutes(app: Express, scripts: any) {
   }
   });
 
+// DELETE /api/scripts/:id - Delete a script
+  app.delete(scripturl+':id', (req: Request, res: Response) => {
+    const { id } = req.params;
+    const scriptIndex = scripts.getAllScripts().findIndex((s: any) => s.getId() === id);
+    if (scriptIndex === -1) {
+      return res.status(404).json({ error: 'Script not found' });
+    }
+    scripts.getAllScripts().splice(scriptIndex, 1);
+    res.status(204).send();
+  });
+
+// DELETE /api/scripts - Delete all scripts
+  app.delete(scripturl, (req: Request, res: Response) => {
+    scripts.getAllScripts().length = 0;
+    res.status(204).send();
+  });
+
   // GET /api/scripts/:id - Get one script by ID
   app.get(scripturl+':id', (req: Request, res: Response) => {
     const { id } = req.params;

From 82b1c8e094e62cb18fad63d317a4a99e683e94ae Mon Sep 17 00:00:00 2001
From: hlpaa <hlpaa@cin.ufpe.br>
Date: Tue, 9 Dec 2025 18:22:03 -0300
Subject: [PATCH 076/102] new styling ot TaskListEditor

---
 .../src/components/scripts/TaskListEditor.tsx | 28 ++++++++++---------
 1 file changed, 15 insertions(+), 13 deletions(-)

diff --git a/client/src/components/scripts/TaskListEditor.tsx b/client/src/components/scripts/TaskListEditor.tsx
index b8be577d..e48416cd 100644
--- a/client/src/components/scripts/TaskListEditor.tsx
+++ b/client/src/components/scripts/TaskListEditor.tsx
@@ -36,36 +36,38 @@ export default function TaskListEditor({ tasks, setTasks }: Props) {
       <h4>Tasks</h4>
 
       {/* Add new task */}
-      <div>
+      <div style={{ marginBottom: "1rem" }}>
         <input
           value={taskText}
           onChange={(e) => setTaskText(e.target.value)}
           placeholder="New task..."
+          style={{ marginRight: "1rem" }}
         />
-        <button onClick={addTask} style={{ marginLeft: "1rem" }}>
+        <button onClick={addTask}>
           Add
         </button>
       </div>
 
       {/* Display and edit tasks */}
-      <ul>
+      <ul style={{ listStyle: "none", padding: 0 }}>
         {tasks.map((task) => (
-          <li key={task.id}>
+          <li key={task.id} style={{ marginBottom: "1rem", padding: "0.5rem", backgroundColor: "#f5f5f5", borderRadius: "4px" }}>
             {editingTaskId === task.id ? (
-              <>
+              <div style={{ display: "flex", alignItems: "center", gap: "0.75rem" }}>
                 <input
                   value={editingText}
                   onChange={(e) => setEditingText(e.target.value)}
+                  style={{ flex: 1 }}
                 />
-                <button onClick={saveEdit} style={{ marginLeft: "0.5rem" }}>Save</button>
-                <button onClick={() => setEditingTaskId(null)} style={{ marginLeft: "0.5rem" }}>Cancel</button>
-              </>
+                <button onClick={saveEdit}>Save</button>
+                <button onClick={() => setEditingTaskId(null)}>Cancel</button>
+              </div>
             ) : (
-              <>
-                {task.statement}
-                <button onClick={() => startEdit(task)} style={{ marginLeft: "0.5rem" }}>Edit</button>
-                <button onClick={() => deleteTask(task.id)} style={{ marginLeft: "0.5rem", color: "red" }}>Delete</button>
-              </>
+              <div style={{ display: "flex", alignItems: "center", gap: "0.75rem" }}>
+                <span style={{ flex: 1 }}>{task.statement}</span>
+                <button onClick={() => startEdit(task)} style={{ backgroundColor: "#4CAF50", color: "white", border: "none", padding: "0.5rem 1rem", borderRadius: "4px", cursor: "pointer" }}>Edit</button>
+                <button onClick={() => deleteTask(task.id)} style={{ backgroundColor: "#f44336", color: "white", border: "none", padding: "0.5rem 1rem", borderRadius: "4px", cursor: "pointer" }}>Delete</button>
+              </div>
             )}
           </li>
         ))}

From f7bb2f42bae50d4e7b534a769048c3b4a0b342ea Mon Sep 17 00:00:00 2001
From: Davi Guerreiro <daviguerreiro9a@gmail.com>
Date: Tue, 9 Dec 2025 18:22:35 -0300
Subject: [PATCH 077/102] feat(ScriptAnswer): Adding knew implemantation to
 type and Service for client - server communication

---
 client/src/services/ScriptAnswerService.ts | 60 +++++++++++++++++++++-
 client/src/types/ScriptAnswer.ts           | 10 +++-
 2 files changed, 67 insertions(+), 3 deletions(-)

diff --git a/client/src/services/ScriptAnswerService.ts b/client/src/services/ScriptAnswerService.ts
index 0aeb013e..dc06c48e 100644
--- a/client/src/services/ScriptAnswerService.ts
+++ b/client/src/services/ScriptAnswerService.ts
@@ -39,17 +39,73 @@ export const ScriptAnswerService = {
   },
 
   /** Create a new ScriptAnswer */
-  async createScriptAnswer(scriptAnswer: Omit<ScriptAnswer, 'id'>): Promise<ScriptAnswer> {
+  async createScriptAnswer(data: { scriptId: string; classId: string; studentId: string }): Promise<ScriptAnswer> {
     const res = await fetch(`${API_URL}/scriptanswers/`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(scriptAnswer)
+      body: JSON.stringify(data)
     });
 
     if (!res.ok) throw new Error("Failed to create ScriptAnswer");
     return res.json();
   },
 
+  /** Start answering a specific task (creates TaskAnswer with timer) */
+  async startTask(scriptAnswerId: string, taskId: string): Promise<{ taskId: string; started_at: number }> {
+    const res = await fetch(`${API_URL}/scriptanswers/${scriptAnswerId}/tasks/${taskId}/start`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" }
+    });
+
+    if (!res.ok) {
+      const error = await res.json();
+      throw new Error(error.error || "Failed to start task");
+    }
+    return res.json();
+  },
+
+  /** Submit answer for a specific task */
+  async submitTask(
+    scriptAnswerId: string,
+    taskId: string,
+    answer: string
+  ): Promise<{ taskId: string; submitted_at: number; time_taken_seconds: number }> {
+    const res = await fetch(`${API_URL}/scriptanswers/${scriptAnswerId}/tasks/${taskId}/submit`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ answer })
+    });
+
+    if (!res.ok) throw new Error("Failed to submit task");
+    return res.json();
+  },
+
+  /** Check and apply timeout to script answer */
+  async checkTimeout(scriptAnswerId: string, timeoutSeconds: number = 3600): Promise<ScriptAnswer> {
+    const res = await fetch(`${API_URL}/scriptanswers/${scriptAnswerId}/timeout`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ timeoutSeconds })
+    });
+
+    if (!res.ok) throw new Error("Failed to check timeout");
+    return res.json();
+  },
+
+  /** Get ScriptAnswers by class and student (enrollment) */
+  async getScriptAnswersByEnrollment(classId: string, studentId: string): Promise<ScriptAnswer[]> {
+    const res = await fetch(`${API_URL}/scriptanswers/enrollment/${classId}/${studentId}`);
+    if (!res.ok) throw new Error("Failed to fetch scriptAnswers by enrollment");
+    return res.json();
+  },
+
+  /** Get ScriptAnswers by class */
+  async getScriptAnswersByClassId(classId: string): Promise<ScriptAnswer[]> {
+    const res = await fetch(`${API_URL}/scriptanswers/class/${classId}`);
+    if (!res.ok) throw new Error("Failed to fetch scriptAnswers by class");
+    return res.json();
+  },
+
   /** Update the grade of a TaskAnswer inside a ScriptAnswer */
   async updateTaskAnswerGrade(
     scriptAnswerId: string,
diff --git a/client/src/types/ScriptAnswer.ts b/client/src/types/ScriptAnswer.ts
index 67410bef..39c97227 100644
--- a/client/src/types/ScriptAnswer.ts
+++ b/client/src/types/ScriptAnswer.ts
@@ -3,17 +3,25 @@ import {Grade} from './EspecificacaoDoCalculoDaMedia';
 export interface TaskAnswer {
     id: string;
     task: string;
-    answer: string;
+    answer?: string;
     grade?: Grade;
     comments?: string;
+    started_at?: number;
+    submitted_at?: number;
+    time_taken_seconds?: number;
+    status?: 'pending' | 'started' | 'submitted' | 'timed_out';
 }
 
 export interface ScriptAnswer {
     id: string;
     scriptId: string;
+    classId: string;
     student: string;
     answers: TaskAnswer[];
     grade?: Grade;
+    started_at?: number;
+    finished_at?: number;
+    status?: 'in_progress' | 'finished';
 }
 
 export interface UpdateSriptAnswerGradeRequest {

From 79d1046d1115ca529f1d2a1abb9a933143518cc8 Mon Sep 17 00:00:00 2001
From: hlpaa <hlpaa@cin.ufpe.br>
Date: Tue, 9 Dec 2025 18:55:52 -0300
Subject: [PATCH 078/102] adding colors to buttons

---
 client/src/components/scripts/ScriptEditor.tsx   |  4 ++--
 client/src/components/scripts/TaskListEditor.tsx | 10 +++++-----
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/client/src/components/scripts/ScriptEditor.tsx b/client/src/components/scripts/ScriptEditor.tsx
index afc8754c..4f355e11 100644
--- a/client/src/components/scripts/ScriptEditor.tsx
+++ b/client/src/components/scripts/ScriptEditor.tsx
@@ -62,9 +62,9 @@ export default function ScriptEditor({ script, onSave, onCancel }: ScriptEditorP
 
       <TaskListEditor tasks={tasks} setTasks={setTasks} />
 
-      <button onClick={handleSubmit} disabled={tasks.length === 0}>Save</button>
+      <button onClick={handleSubmit} disabled={tasks.length === 0} style={{ backgroundColor: "#4CAF50", color: "white" }}>Save</button>
       {onCancel && (
-        <button onClick={onCancel} style={{ marginLeft: "1rem" }}>
+        <button onClick={onCancel} style={{ marginLeft: "1rem", backgroundColor: "#9E9E9E", color: "white" }}>
           Cancel
         </button>
       )}
diff --git a/client/src/components/scripts/TaskListEditor.tsx b/client/src/components/scripts/TaskListEditor.tsx
index e48416cd..b8ea0b6a 100644
--- a/client/src/components/scripts/TaskListEditor.tsx
+++ b/client/src/components/scripts/TaskListEditor.tsx
@@ -43,7 +43,7 @@ export default function TaskListEditor({ tasks, setTasks }: Props) {
           placeholder="New task..."
           style={{ marginRight: "1rem" }}
         />
-        <button onClick={addTask}>
+        <button onClick={addTask} style={{ backgroundColor: "#2196F3", color: "white" }}>
           Add
         </button>
       </div>
@@ -59,14 +59,14 @@ export default function TaskListEditor({ tasks, setTasks }: Props) {
                   onChange={(e) => setEditingText(e.target.value)}
                   style={{ flex: 1 }}
                 />
-                <button onClick={saveEdit}>Save</button>
-                <button onClick={() => setEditingTaskId(null)}>Cancel</button>
+                <button onClick={saveEdit} style={{ backgroundColor: "#4CAF50", color: "white" }}>Save</button>
+                <button onClick={() => setEditingTaskId(null)} style={{ backgroundColor: "#9E9E9E", color: "white" }}>Cancel</button>
               </div>
             ) : (
               <div style={{ display: "flex", alignItems: "center", gap: "0.75rem" }}>
                 <span style={{ flex: 1 }}>{task.statement}</span>
-                <button onClick={() => startEdit(task)} style={{ backgroundColor: "#4CAF50", color: "white", border: "none", padding: "0.5rem 1rem", borderRadius: "4px", cursor: "pointer" }}>Edit</button>
-                <button onClick={() => deleteTask(task.id)} style={{ backgroundColor: "#f44336", color: "white", border: "none", padding: "0.5rem 1rem", borderRadius: "4px", cursor: "pointer" }}>Delete</button>
+                <button onClick={() => startEdit(task)} style={{ backgroundColor: "#4CAF50", color: "white" }}>Edit</button>
+                <button onClick={() => deleteTask(task.id)} style={{ backgroundColor: "#f44336", color: "white" }}>Delete</button>
               </div>
             )}
           </li>

From 2429834e0db8e4c89271126c9caa8e354e11bc06 Mon Sep 17 00:00:00 2001
From: Davi Guerreiro <daviguerreiro9a@gmail.com>
Date: Tue, 9 Dec 2025 19:29:45 -0300
Subject: [PATCH 079/102] fix(TaskAnswer): TaskAnswer cannot be submitted more
 than once

---
 server/src/server_routes/scriptanswer.ts | 51 +++++++++++++++---------
 1 file changed, 33 insertions(+), 18 deletions(-)

diff --git a/server/src/server_routes/scriptanswer.ts b/server/src/server_routes/scriptanswer.ts
index 4c65d485..8da77efa 100644
--- a/server/src/server_routes/scriptanswer.ts
+++ b/server/src/server_routes/scriptanswer.ts
@@ -170,7 +170,7 @@ app.post(scriptAnswerurl+'', (req: Request, res: Response) => {
         comments,
       });
       if (!ta) {
-        return res.status(404).json({ error: 'Answer already exists in ScriptAnswer' });
+        return res.status(409).json({ error: 'Task answer already exists for this task' });
       }
       saveCallback?.();
       res.status(201).json(ta.toJSON());
@@ -182,23 +182,38 @@ app.post(scriptAnswerurl+'', (req: Request, res: Response) => {
   // POST /api/scriptanswers/:id/tasks/:taskId/submit → submit an answer on the scriptAnswer
 
   app.post(scriptAnswerurl+':id/tasks/:taskId/submit', (req: Request, res: Response) => {
-  try {
-    const { id, taskId } = req.params;
-    const { answer, grade, comments } = req.body;
-    const ta = scriptAnswerSet.submitLastTaskAnswer(id, taskId, scripts, {
-      answer,
-      grade,
-      comments,
-    });
-    if (!ta) {
-      return res.status(404).json({ error: 'ScriptAnswer or Task not found' });
+    try {
+      const { id, taskId } = req.params;
+      const { answer, grade, comments } = req.body;
+
+      const scriptAnswer = scriptAnswerSet.findById(id);
+      if (!scriptAnswer) {
+        return res.status(404).json({ error: 'ScriptAnswer not found' });
+      }
+
+      const existingTask = scriptAnswer.findAnswerByTaskId(taskId);
+      if (!existingTask) {
+        return res.status(404).json({ error: 'Task not found' });
+      }
+
+      if (existingTask.status === 'submitted') {
+        return res.status(409).json({ error: 'Task answer already submitted and cannot be changed' });
+      }
+
+      const ta = scriptAnswerSet.submitLastTaskAnswer(id, taskId, scripts, {
+        answer,
+        grade,
+        comments,
+      });
+      if (!ta) {
+        return res.status(404).json({ error: 'ScriptAnswer or Task not found' });
+      }
+      saveCallback?.();
+      res.status(200).json(ta.toJSON());
+    } catch (error) {
+      res.status(400).json({ error: (error as Error).message });
     }
-    saveCallback?.();
-    res.json(ta.toJSON());
-  } catch (error) {
-    res.status(400).json({ error: (error as Error).message });
-  }
-});
+  });
 
 // POST /api/scriptanswers/:id/timeout → Marca roteiro como expirado por timeout
 app.post(scriptAnswerurl+':id/timeout', (req: Request, res: Response) => {
@@ -211,7 +226,7 @@ app.post(scriptAnswerurl+':id/timeout', (req: Request, res: Response) => {
     }
     sa.checkAndMarkIfTimedOut(timeoutSeconds);
     saveCallback?.();
-    res.json({
+    res.status(200).json({
       message: 'Timeout check completed',
       scriptAnswer: sa.toJSON(),
     });

From b2519dbb22e539632dabc022e189a001dc5e4d3a Mon Sep 17 00:00:00 2001
From: Davi Guerreiro <daviguerreiro9a@gmail.com>
Date: Tue, 9 Dec 2025 19:38:21 -0300
Subject: [PATCH 080/102] fix(ScriptAnswer): scriptAnswers can't receive new
 taskAnswers Requesitions

---
 server/src/server_routes/scriptanswer.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/server/src/server_routes/scriptanswer.ts b/server/src/server_routes/scriptanswer.ts
index 8da77efa..c48281e6 100644
--- a/server/src/server_routes/scriptanswer.ts
+++ b/server/src/server_routes/scriptanswer.ts
@@ -160,6 +160,9 @@ app.post(scriptAnswerurl+'', (req: Request, res: Response) => {
       if (!scriptAnswer) {
         return res.status(404).json({ error: 'ScriptAnswer not found' });
       }
+      if (scriptAnswer.status === 'finished') {
+        return res.status(403).json({ error: 'ScriptAnswer is closed for new answers' });
+      }
       const task = TaskSet.findById(taskId);
       if (!task) {
         return res.status(404).json({ error: 'Task not found' });
@@ -190,6 +193,9 @@ app.post(scriptAnswerurl+'', (req: Request, res: Response) => {
       if (!scriptAnswer) {
         return res.status(404).json({ error: 'ScriptAnswer not found' });
       }
+      if (scriptAnswer.status === 'finished') {
+        return res.status(409).json({ error: 'ScriptAnswer already finished' });
+      }
 
       const existingTask = scriptAnswer.findAnswerByTaskId(taskId);
       if (!existingTask) {

From 3c58d7b58cc44eb5e6855110be2b97371936c7a8 Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Tue, 9 Dec 2025 19:53:51 -0300
Subject: [PATCH 081/102] feat/testing: helper functions for object creation
 ensure if the object doesnt already exist in the server

---
 .../server-scriptAnswer-steps.ts              | 32 ++++++++++++++++---
 1 file changed, 27 insertions(+), 5 deletions(-)

diff --git a/client/src/step-definitions/server-scriptAnswer-steps.ts b/client/src/step-definitions/server-scriptAnswer-steps.ts
index ee86991a..1bd3955e 100644
--- a/client/src/step-definitions/server-scriptAnswer-steps.ts
+++ b/client/src/step-definitions/server-scriptAnswer-steps.ts
@@ -4,7 +4,7 @@
 import { Given, When, Then, After, setDefaultTimeout, DataTable } from '@cucumber/cucumber';
 import expect from 'expect';
 
-setDefaultTimeout(30 * 1000);
+setDefaultTimeout(30 * 10000);
 
 const serverUrl = 'http://localhost:3005';
 
@@ -22,7 +22,13 @@ let mostRecentTaskId: string | null = null;
 // Helper functions
 // ============================================================
 
-async function createScript(title, id: string) {
+async function createScript(title : string, id: string) {
+  const check = await fetch(`${serverUrl}/api/scripts/${id}`);
+  if (check.status === 200) {
+    createdScriptsIds.push(id);
+    return check;
+  }
+
   const response = await fetch(`${serverUrl}/api/scripts/`, {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
@@ -42,6 +48,13 @@ async function createScript(title, id: string) {
 async function createScriptAnswer(id: string, studentId: string) {
   await createScript(`Script for ${id}`, `script-${id}`);
 
+  const check = await fetch(`${serverUrl}/api/scriptanswers/${id}`);
+  if (check.status === 200) {
+    createdScriptAnswerIds.push(id);
+    lastCreatedScriptAnswerId = id;
+    return check;
+  }
+
   const response = await fetch(`${serverUrl}/api/scriptanswers/`, {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
@@ -80,6 +93,12 @@ async function updateScriptAnswerTasks(scriptAnswerId: string, taskPayload: any)
 }
 
 async function ensureStudentExists(cpf: string) {
+  const check = await fetch(`${serverUrl}/api/students/${cpf}`);
+  if (check.status === 200) {
+    lastResponse = check;
+    return check;
+  }
+
   const response = await fetch(`${serverUrl}/api/students`, {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
@@ -92,6 +111,8 @@ async function ensureStudentExists(cpf: string) {
   return response;
 }
 
+
+
 // ============================================================
 // Cleanup
 // ============================================================
@@ -107,7 +128,7 @@ After({ tags: '@server' }, async function () {
   }
 
   for (const id of createdScriptsIds) {
-    await fetch(`${serverUrl}/api/scripts/${id}`, { method: 'DELETE' });
+   await fetch(`${serverUrl}/api/scripts/${id}`, { method: 'DELETE' });
   }
   createdScriptsIds = [];
 
@@ -129,7 +150,7 @@ Given('there are no script answers registered', async function () {
   if (res.status === 200) {
     const list = await res.json();
     for (const item of list) {
-      await fetch(`${serverUrl}/api/scriptanswers/${item.id}`, { method: 'DELETE' });
+      //await fetch(`${serverUrl}/api/scriptanswers/${item.id}`, { method: 'DELETE' });
     }
   }
 });
@@ -144,7 +165,8 @@ Given(/^there is no script answer(?: registered)? with ID "([^"]+)"/, async func
 
 Given('there is a student with CPF {string}', async function (cpf: string) {
   const response = await ensureStudentExists(cpf);
-  expect(response.status).toBe(201);
+  createdStudentCPF = cpf;
+  expect(response.ok).toBe(true);
 });
 
 Given('this student has script answers with IDs {string}, {string}, {string}', async function (a: string, b: string, c: string) {

From 3f7b8f33a07ccc48e8dbfcd0d475e617beb5bb8d Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Tue, 9 Dec 2025 19:54:38 -0300
Subject: [PATCH 082/102] testing: data-testingid for objects to facilitatde
 frontend testing of scrip grading

---
 client/src/App.tsx                                       | 1 +
 client/src/components/ScriptGrading/GradingPage.tsx      | 2 +-
 client/src/components/ScriptGrading/ScriptAnswerGrid.tsx | 3 ++-
 3 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/client/src/App.tsx b/client/src/App.tsx
index 8f252d6f..7c105467 100644
--- a/client/src/App.tsx
+++ b/client/src/App.tsx
@@ -157,6 +157,7 @@ const App: React.FC = () => {
           <button
             className={`tab-button ${activeTab === 'Script Grading' ? 'active' : ''}`}
             onClick={() => setActiveTab('Script Grading')}
+            data-testid="script-grading-tab"
           >
             Script Grading
           </button>
diff --git a/client/src/components/ScriptGrading/GradingPage.tsx b/client/src/components/ScriptGrading/GradingPage.tsx
index d139f0eb..8884aafe 100644
--- a/client/src/components/ScriptGrading/GradingPage.tsx
+++ b/client/src/components/ScriptGrading/GradingPage.tsx
@@ -48,7 +48,7 @@ export default function GradingPage({onError}: Props) {
 
   return (
     <div>
-      <h1>Grade Scripts</h1>
+      <h1 data-testid="grading-page-title">Grade Scripts</h1>
       <ScriptAnswerGrid
         scriptAnswers={scriptAnswers}
         onSelect={(sa) => setSelected(sa)}
diff --git a/client/src/components/ScriptGrading/ScriptAnswerGrid.tsx b/client/src/components/ScriptGrading/ScriptAnswerGrid.tsx
index 4ef09ae0..4ec88f7a 100644
--- a/client/src/components/ScriptGrading/ScriptAnswerGrid.tsx
+++ b/client/src/components/ScriptGrading/ScriptAnswerGrid.tsx
@@ -41,10 +41,11 @@ export default function ScriptAnswerGrid({ scriptAnswers, onSelect }: Props) {
       display: "grid",
       gridTemplateColumns: "repeat(auto-fill, 200px)",
       gap: "10px"
-    }}>
+    }} data-testid="script-answer-grid">
       {scriptAnswers.map(sa => (
         <div
           key={sa.id}
+          data-testid={`script-answer-row-${sa.id}`}
           onClick={() => onSelect(sa)}
           style={{
             padding: "12px",

From 177a9dc5829a304ca5c878d8ff0fff06896c8c96 Mon Sep 17 00:00:00 2001
From: Davi Guerreiro <daviguerreiro9a@gmail.com>
Date: Tue, 9 Dec 2025 20:07:35 -0300
Subject: [PATCH 083/102] fix(scriptAnswerService): fixing passage of query
 elements

---
 client/src/services/ScriptAnswerService.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/client/src/services/ScriptAnswerService.ts b/client/src/services/ScriptAnswerService.ts
index dc06c48e..e0812222 100644
--- a/client/src/services/ScriptAnswerService.ts
+++ b/client/src/services/ScriptAnswerService.ts
@@ -94,7 +94,7 @@ export const ScriptAnswerService = {
 
   /** Get ScriptAnswers by class and student (enrollment) */
   async getScriptAnswersByEnrollment(classId: string, studentId: string): Promise<ScriptAnswer[]> {
-    const res = await fetch(`${API_URL}/scriptanswers/enrollment/${classId}/${studentId}`);
+    const res = await fetch(`${API_URL}/scriptanswers/enrollment?classId=${classId}&studentId=${studentId}`);
     if (!res.ok) throw new Error("Failed to fetch scriptAnswers by enrollment");
     return res.json();
   },

From 3175321b9773dded13e0e9ec7e11ed9719752c6c Mon Sep 17 00:00:00 2001
From: Davi Guerreiro <daviguerreiro9a@gmail.com>
Date: Tue, 9 Dec 2025 20:08:54 -0300
Subject: [PATCH 084/102] feat(Server-scriptAnswer-features): Adding time and
 Answer features

---
 .../server-scriptAnswer-management.feature    | 84 +++++++++++++++++++
 1 file changed, 84 insertions(+)

diff --git a/client/src/features/server-scriptAnswer-management.feature b/client/src/features/server-scriptAnswer-management.feature
index 47a24c9d..83156c78 100644
--- a/client/src/features/server-scriptAnswer-management.feature
+++ b/client/src/features/server-scriptAnswer-management.feature
@@ -148,3 +148,87 @@ Feature: Server Script Answers Management
       | comment | Precisa revisar este ponto |
     Then the server should return 404 Not Found
     And the server should return an error message stating the script answer was not found
+
+    #############
+    #############
+    #############
+
+  Scenario: Criar um ScriptAnswer quando aluno inicia roteiro
+    Given O estudante de CPF "11111111111" está cadastrado no sistema
+    And O aluno está matriculado na turma "Math 101-2024-2024"
+    And Existe um roteiro de ID "script-001" na turma
+    When O aluno cria um ScriptAnswer para o roteiro
+    Then O servidor retorna status "201"
+    And O ScriptAnswer tem status "in_progress"
+    And O campo "started_at" contém um timestamp válido
+    And O campo "answers" está vazio
+
+  Scenario: Iniciar resposta de uma questão
+    Given O estudante de CPF "11111111111" tem um ScriptAnswer ativo de ID "script-002"
+    And A tarefa "task-001" existe no roteiro
+    And A tarefa ainda não foi iniciada
+    When O aluno inicia a resposta da tarefa "task-001"
+    Then O servidor retorna status "201"
+    And A TaskAnswer tem status "started"
+    And O campo "started_at" contém timestamp válido
+    And O campo "submitted_at" está vazio
+
+  Scenario: Enviar resposta de uma questão que não é a última
+    Given O estudante de CPF "11111111111" tem um ScriptAnswer ativo
+    And A tarefa "task-001" foi iniciada
+    And A tarefa não é a última do roteiro
+    When O aluno submete a resposta "Minha resposta aqui" para a tarefa
+    Then O servidor retorna status "200"
+    And A TaskAnswer tem status "submitted"
+    And O campo "submitted_at" contém timestamp válido
+    And O campo "time_taken_seconds" é calculado corretamente
+    And O ScriptAnswer continua com status "in_progress"
+
+  Scenario: Enviar resposta da última questão e finalizar roteiro
+    Given O estudante de CPF "11111111111" tem um ScriptAnswer ativo
+    And A tarefa "task-003" foi iniciada
+    And A tarefa é a última do roteiro
+    When O aluno submete a resposta "Resposta final" para a tarefa
+    Then O servidor retorna status "200"
+    And A TaskAnswer tem status "submitted"
+    And O ScriptAnswer tem status "finished"
+    And O campo "finished_at" do ScriptAnswer contém timestamp válido
+
+  Scenario: Marcar roteiro como expirado por timeout
+    Given O estudante de CPF "11111111111" tem um ScriptAnswer ativo
+    And Passaram-se 3601 segundos desde o início
+    When O sistema verifica timeout do ScriptAnswer
+    Then O servidor retorna status "200"
+    And O ScriptAnswer tem status "finished"
+    And Todas as tarefas "started" foram marcadas como "submitted"
+    And Todas as tarefas "pending" foram marcadas como "timed_out"
+
+  Scenario: Falha ao criar ScriptAnswer para aluno não matriculado
+    Given O estudante de CPF "99999999999" está cadastrado no sistema
+    And O aluno NÃO está matriculado na turma "Math 101-2024-2024"
+    And Existe um roteiro de ID "script-001" na turma
+    When O aluno tenta criar um ScriptAnswer para o roteiro
+    Then O servidor retorna status "403"
+    And A mensagem de erro indica "Student is not enrolled in this class"
+    
+    Scenario: Falha ao submeter tarefa já submetida
+    Given O estudante de CPF "11111111111" tem um ScriptAnswer ativo
+    And A tarefa "task-001" já foi submetida
+    When O aluno tenta submeter novamente a tarefa "task-001" com resposta "Resposta duplicada"
+    Then O servidor retorna status "409"
+    And A mensagem de erro indica "Task answer already submitted and cannot be changed"
+
+    Scenario: Buscar ScriptAnswers de uma turma
+    Given A turma "Math 101-2024-2024" tem "5" alunos com ScriptAnswers
+    When O sistema busca todos os ScriptAnswers da turma
+    Then O servidor retorna status "200"
+    And A resposta contém pelo menos "5" ScriptAnswers
+    And Todos os ScriptAnswers pertencem à turma correta
+
+    Scenario: Buscar ScriptAnswers de um aluno matriculado em uma turma
+    Given Existe uma turma com ID "Math-101-2024"
+    And Existe um estudante com CPF "12345678901" matriculado na turma "Math-101-2024"
+    And Este estudante possui ScriptAnswers de IDs "201", "202" na turma "Math-101-2024"
+    When Eu envio uma requisição GET para "/api/scriptanswers/enrollment?classId=Math-101-2024&studentId=12345678901"
+    Then O servidor retorna status "200"
+    And O servidor deve retornar uma lista contendo as respostas "201", "202"

From b79d6dbe3818c4f4b028b3d2952dc55d42e7087d Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Tue, 9 Dec 2025 21:19:39 -0300
Subject: [PATCH 085/102] testing: added testids for ease of selection in e2e
 frontend tests

---
 client/src/components/ScriptGrading/ScriptGrading.tsx    | 2 +-
 client/src/components/ScriptGrading/TaskAnswerEditor.tsx | 7 +++++--
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/client/src/components/ScriptGrading/ScriptGrading.tsx b/client/src/components/ScriptGrading/ScriptGrading.tsx
index 10d3e975..63fc2a8d 100644
--- a/client/src/components/ScriptGrading/ScriptGrading.tsx
+++ b/client/src/components/ScriptGrading/ScriptGrading.tsx
@@ -48,7 +48,7 @@ export default function ScriptGrading({ scriptAnswer, onClose }: Props) {
   };
 
   return (
-    <div>
+    <div data-testid={`script-grading`}>
       <button onClick={onClose} disabled={loading}>
         ← Back
       </button>
diff --git a/client/src/components/ScriptGrading/TaskAnswerEditor.tsx b/client/src/components/ScriptGrading/TaskAnswerEditor.tsx
index 3040176a..29711572 100644
--- a/client/src/components/ScriptGrading/TaskAnswerEditor.tsx
+++ b/client/src/components/ScriptGrading/TaskAnswerEditor.tsx
@@ -80,10 +80,10 @@ export default function TaskAnswerEditor({ taskAnswer, onChange, disabled = fals
         borderRadius: "6px",
         opacity: disabled ? 0.6 : 1,
         pointerEvents: disabled ? "none" : "auto"
-      }}
+      }} 
     >
       {/* Task statement */}
-      <strong>
+      <strong data-testid={`task-answer-${taskAnswer.id}`}>
         Task:{" "}
         {loading
           ? "Loading task..."
@@ -105,6 +105,7 @@ export default function TaskAnswerEditor({ taskAnswer, onChange, disabled = fals
             value={localGrade ?? ""}
             onChange={(e) => handleGradeChange(e.target.value as Grade | undefined)}
             disabled={saving}
+            data-testid={`task-grade-input-${taskAnswer.id}`}
           >
             <option value="">—</option>
             {gradeOptions.map((g) => (
@@ -126,6 +127,7 @@ export default function TaskAnswerEditor({ taskAnswer, onChange, disabled = fals
             rows={3}
             disabled={saving}
             style={{ width: "100%" }}
+            data-testid={`task-comment-input-${taskAnswer.id}`}
           />
         </label>
       </div>
@@ -144,6 +146,7 @@ export default function TaskAnswerEditor({ taskAnswer, onChange, disabled = fals
             cursor: hasChanges && !saving ? "pointer" : "not-allowed",
             opacity: hasChanges && !saving ? 1 : 0.6
           }}
+          data-testid={`task-save-button-${taskAnswer.id}`}
         >
           {saving ? "Saving..." : "Save Changes"}
         </button>

From b87b732dcc660f848fc269c36cd2340880280032 Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Tue, 9 Dec 2025 21:21:19 -0300
Subject: [PATCH 086/102] fix: uncommented deletion logic in Given('there are
 no script answers registered') step and fixed prepending of ta- in task
 addition

---
 client/src/step-definitions/server-scriptAnswer-steps.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/client/src/step-definitions/server-scriptAnswer-steps.ts b/client/src/step-definitions/server-scriptAnswer-steps.ts
index 1bd3955e..e3db95e0 100644
--- a/client/src/step-definitions/server-scriptAnswer-steps.ts
+++ b/client/src/step-definitions/server-scriptAnswer-steps.ts
@@ -150,7 +150,7 @@ Given('there are no script answers registered', async function () {
   if (res.status === 200) {
     const list = await res.json();
     for (const item of list) {
-      //await fetch(`${serverUrl}/api/scriptanswers/${item.id}`, { method: 'DELETE' });
+      await fetch(`${serverUrl}/api/scriptanswers/${item.id}`, { method: 'DELETE' });
     }
   }
 });

From 882d280c5a319707617c60c2f49ad8c43a70a0f0 Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Tue, 9 Dec 2025 21:22:00 -0300
Subject: [PATCH 087/102] testing: functional frontend testing for grade and
 comment scriptanswer feature

---
 .../features/scriptanswer-management.feature  |  25 +++
 .../scriptanswer-management-steps.ts          | 162 ++++++++++++++++++
 2 files changed, 187 insertions(+)
 create mode 100644 client/src/features/scriptanswer-management.feature
 create mode 100644 client/src/step-definitions/scriptanswer-management-steps.ts

diff --git a/client/src/features/scriptanswer-management.feature b/client/src/features/scriptanswer-management.feature
new file mode 100644
index 00000000..b93c3871
--- /dev/null
+++ b/client/src/features/scriptanswer-management.feature
@@ -0,0 +1,25 @@
+@gui
+Feature: Script Answer Management
+  As a professor
+  I want to grade and comment on student script answers
+  So that I can provide feedback on their submissions
+
+  Background:
+    Given the student management system is running
+    And the server is available
+
+  # ==========================================
+  # Editing both grade and comment
+  # ==========================================
+
+  Scenario: Edit both grade and comment of a task in a script answer
+    Given there is a script answer with ID "50" 
+    And this answer contains a task with ID "3"
+    And I am in the Script Grading area
+    And I select the script answer with ID "50"
+    And I see the task with ID "3"
+    When I change the grade to "MPA"
+    And I change the comment to "Great improvement!"
+    And I save all task updates
+    Then I should see the grade of task "3" updated to "MPA"
+    And I should see the comment of task "3" updated to "Great improvement!"
diff --git a/client/src/step-definitions/scriptanswer-management-steps.ts b/client/src/step-definitions/scriptanswer-management-steps.ts
new file mode 100644
index 00000000..89ad432a
--- /dev/null
+++ b/client/src/step-definitions/scriptanswer-management-steps.ts
@@ -0,0 +1,162 @@
+import { Given, When, Then, Before, After, setDefaultTimeout } from '@cucumber/cucumber';
+import { Browser, Page, launch } from 'puppeteer';
+import expect from 'expect';
+
+setDefaultTimeout(30 * 1000);
+
+let browser: Browser;
+let page: Page;
+const baseUrl = 'http://localhost:3004';
+const serverUrl = 'http://localhost:3005';
+let lastTaskId : string | null = null;
+
+// -----------------------------------------------------------
+// Setup and Teardown
+// -----------------------------------------------------------
+
+
+Before({ tags: '@gui' }, async () => {
+  browser = await launch({ headless: false, slowMo:  50});
+  page = await browser.newPage();
+  await page.setViewport({ width: 1280, height: 720 });
+});
+
+After({ tags: '@gui' }, async () => {
+  if (browser) await browser.close();
+
+});
+
+// -----------------------------------------------------------
+// Navigation
+// -----------------------------------------------------------
+
+
+Given(/^I am in the script grading area$/i, async () => {
+  await page.goto(baseUrl);
+  await page.waitForSelector('[data-testid="script-grading-tab"]', { timeout: 5000 });
+  
+  const tab = await page.$('[data-testid="script-grading-tab"]');
+  expect(tab).toBeTruthy();
+  
+  if (tab) {
+    // Log the button state before clicking
+    const isActive = await page.evaluate(el => el.classList.contains('active'), tab);
+    console.log('Tab is active before click:', isActive);
+    
+    if (!isActive) {
+      console.log('Clicking script grading tab...');
+      await tab.click();
+      
+      // Add a small delay to let the click register
+      await new Promise(r => setTimeout(r, 500));
+      
+      // Check if it's active now
+      const isActiveAfter = await page.evaluate(el => el.classList.contains('active'), tab);
+      console.log('Tab is active after click:', isActiveAfter);
+      
+      // Try to find the grading content
+      console.log('Waiting for grading page content...');
+      try {
+        await page.waitForSelector('[data-testid="grading-page-title"]', { timeout: 5000 });
+        console.log('Grading page title found!');
+      } catch (e) {
+        console.log('Grading page title NOT found. Available elements:');
+        const allTestIds = await page.$$eval('[data-testid]', els => els.map(el => el.getAttribute('data-testid')));
+        console.log('Data test IDs on page:', allTestIds);
+      }
+    }
+  }
+  
+  const grading = await page.$('[data-testid="grading-page-title"]');
+  expect(grading).toBeTruthy();
+});
+
+
+// -----------------------------------------------------------
+// GUI interactions
+// -----------------------------------------------------------
+When(/^I select the script answer with ID "([^"]+)"$/i, async (saId: string) => {
+  await page.waitForSelector(`[data-testid="script-answer-row-${saId}"]`, { timeout: 5000 });
+  await page.click(`[data-testid="script-answer-row-${saId}"]`);
+  await page.waitForSelector('[data-testid="script-grading"]', { timeout: 5000 });
+});
+
+Then(/^I should see the script answer details$/i, async () => {
+  const details = await page.$('[data-testid="script-grading"]');
+  expect(details).toBeTruthy();
+});
+
+Then(/^I should see all tasks associated with the script answer$/i, async () => {
+  await page.waitForSelector('[data-testid^="task-answer-"]', { timeout: 5000 });
+  const tasks = await page.$$('[data-testid^="task-answer-"]');
+  expect(tasks.length).toBeGreaterThan(0);
+});
+
+Given(/^I see the task with ID "([^"]+)"$/i, async (taskId: string) => {
+  expect(await page.$(`[data-testid="task-answer-${taskId}"]`)).toBeTruthy();
+  lastTaskId = taskId;
+});
+
+When(/^I change the grade to "([^"]+)"$/i, async (grade: string) => {
+  if (!lastTaskId) {
+    throw new Error('No task ID set. Use "When I select the task with ID" first.');
+  }
+
+  await page.waitForSelector(`[data-testid="task-grade-input-${lastTaskId}"]`, { timeout: 5000 });
+  
+  // Click the select element to open the dropdown
+  await page.click(`[data-testid="task-grade-input-${lastTaskId}"]`);
+  
+  // Wait a bit for the options to render
+  await new Promise(r => setTimeout(r, 300));
+  
+  // The component uses native <select> with <option> elements
+  // Select the option by its value attribute
+  await page.select(`[data-testid="task-grade-input-${lastTaskId}"]`, grade);
+  
+  console.log(`Grade changed to: ${grade}`);
+});
+
+
+Then(/^I should see the grade of task "([^"]+)" updated to "([^"]+)"$/i, async (taskId: string, grade: string) => {
+  const selectSelector = `[data-testid="task-grade-input-${taskId}"]`;
+  
+  await page.waitForSelector(selectSelector, { timeout: 5000 });
+  
+  // Check the selected option's text content
+  const selectedText = await page.$eval(
+    `${selectSelector} option:checked`,
+    el => el.textContent || ''
+  );
+  
+  expect(selectedText).toBe(grade);
+  console.log(`Grade verified as: ${grade}`);
+});
+
+When(/^I change the comment to "([^"]+)"$/i, async (comment: string) => {
+  await page.waitForSelector(`[data-testid="task-comment-input-${lastTaskId}"]`, { timeout: 5000 });
+  await page.click(`[data-testid="task-comment-input-${lastTaskId}"]`, { clickCount: 3 });
+  await page.type(`[data-testid="task-comment-input-${lastTaskId}"]`, comment);
+});
+
+
+Then(/^I should see the comment of task "([^"]+)" updated to "([^"]+)"$/i, async (taskId: string, comment: string) => {
+  const textareaSelector = `[data-testid="task-comment-input-${taskId}"]`;
+
+  await page.waitForSelector(textareaSelector, { timeout: 5000 });
+
+  const currentValue = await page.$eval(
+    textareaSelector,
+    el => (el as HTMLTextAreaElement).value
+  );
+
+  expect(currentValue).toBe(comment);
+  console.log(`Comment verified as: ${comment}`);
+});
+
+When(/^I save all task updates$/i, async () => {
+  const btn = await page.$('[data-testid="task-save-button-' + lastTaskId + '"]');
+  expect(btn).toBeTruthy();
+  await btn?.click();
+  await new Promise(r => setTimeout(r, 800));
+});
\ No newline at end of file

From ef86680a25dcba4ab4a6e759e0e68b216b6a2297 Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Tue, 9 Dec 2025 21:22:53 -0300
Subject: [PATCH 088/102] fix/testing: removed prepending of ta- in task
 creation of the server test suite

---
 client/src/step-definitions/server-scriptAnswer-steps.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/client/src/step-definitions/server-scriptAnswer-steps.ts b/client/src/step-definitions/server-scriptAnswer-steps.ts
index e3db95e0..55635021 100644
--- a/client/src/step-definitions/server-scriptAnswer-steps.ts
+++ b/client/src/step-definitions/server-scriptAnswer-steps.ts
@@ -179,7 +179,7 @@ Given(/^this answer contains a task with ID "([^"]+)"(?: and grade "([^"]+)")?$/
   if (!lastCreatedScriptAnswerId) throw new Error('No script answer created');
 
   const payload = {
-    id: `ta-${taskId}`,
+    id: `${taskId}`,
     task: taskId,
     answer: 'Test answer',
     grade: grade ?? null,

From efe097d8aa9cb08feee20ed769b0ecbbfa6bae73 Mon Sep 17 00:00:00 2001
From: Davi Guerreiro <daviguerreiro9a@gmail.com>
Date: Wed, 10 Dec 2025 07:24:28 -0300
Subject: [PATCH 089/102] feat(ScriptAnswerTest): Adding scriptAnswer test
 implementation

---
 client/cucumber.js                            |  16 +
 client/package-lock.json                      | 406 ++++++++--------
 .../server-newScriptAnswer-management.feature |  88 ++++
 .../server-scriptAnswer-management.feature    |  86 +---
 .../server-newScriptAnswer-steps.ts           | 442 ++++++++++++++++++
 package-lock.json                             | 351 --------------
 server/package-lock.json                      |   6 -
 server/src/mock_scripts.ts                    | 249 ++++++----
 server/src/models/ScriptAnswer.ts             |   2 +-
 server/src/server_routes/scriptanswer.ts      |  47 +-
 10 files changed, 932 insertions(+), 761 deletions(-)
 create mode 100644 client/src/features/server-newScriptAnswer-management.feature
 create mode 100644 client/src/step-definitions/server-newScriptAnswer-steps.ts

diff --git a/client/cucumber.js b/client/cucumber.js
index d4ecbe35..8135ed7a 100644
--- a/client/cucumber.js
+++ b/client/cucumber.js
@@ -14,5 +14,21 @@ module.exports = {
     },
     paths: ['src/features/**/*.feature'],
     requireModule: ['ts-node/register']
+  },
+  server: {
+    require: [
+      'ts-node/register',
+      'src/step-definitions/server-newScriptAnswer-steps.ts'
+    ],
+    format: [
+      'progress-bar',
+      'json:reports/cucumber_report.json'
+    ],
+    formatOptions: {
+      snippetInterface: 'async-await'
+    },
+    paths: ['src/features/server-newScriptAnswer-management.feature'],
+    requireModule: ['ts-node/register'],
+    timeout: 30000
   }
 };
\ No newline at end of file
diff --git a/client/package-lock.json b/client/package-lock.json
index 7089679f..d23d11a9 100644
--- a/client/package-lock.json
+++ b/client/package-lock.json
@@ -13,7 +13,7 @@
         "react-scripts": "5.0.1"
       },
       "devDependencies": {
-        "@cucumber/cucumber": "^12.2.0",
+        "@cucumber/cucumber": "^12.3.0",
         "@testing-library/jest-dom": "^6.9.1",
         "@testing-library/react": "^16.3.0",
         "@testing-library/user-event": "^14.6.1",
@@ -23,7 +23,7 @@
         "@types/react-dom": "^18.2.7",
         "expect": "^27.5.1",
         "jest-cucumber": "^4.5.0",
-        "puppeteer": "^24.30.0",
+        "puppeteer": "^24.32.0",
         "ts-node": "^10.9.2",
         "typescript": "^4.9.5"
       }
@@ -2416,31 +2416,30 @@
       }
     },
     "node_modules/@cucumber/ci-environment": {
-      "version": "10.0.1",
-      "resolved": "https://registry.npmjs.org/@cucumber/ci-environment/-/ci-environment-10.0.1.tgz",
-      "integrity": "sha512-/+ooDMPtKSmvcPMDYnMZt4LuoipfFfHaYspStI4shqw8FyKcfQAmekz6G+QKWjQQrvM+7Hkljwx58MEwPCwwzg==",
+      "version": "12.0.0",
+      "resolved": "https://registry.npmjs.org/@cucumber/ci-environment/-/ci-environment-12.0.0.tgz",
+      "integrity": "sha512-SqCEnbCNl3zCXCFpqGUuoaSNhLC0jLw4tKeFcAxTw9MD/QRlJjeAC/fyvVLFuXuSq0OunJlFfxLu+Z3HE+oLPg==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/@cucumber/cucumber": {
-      "version": "12.2.0",
-      "resolved": "https://registry.npmjs.org/@cucumber/cucumber/-/cucumber-12.2.0.tgz",
-      "integrity": "sha512-b7W4snvXYi1T2puUjxamASCCNhNzVSzb/fQUuGSkdjm/AFfJ24jo8kOHQyOcaoArCG71sVQci4vkZaITzl/V1w==",
+      "version": "12.3.0",
+      "resolved": "https://registry.npmjs.org/@cucumber/cucumber/-/cucumber-12.3.0.tgz",
+      "integrity": "sha512-36cIyplE1iDl12s4k6lBVpceua8tKLklFTf7CUITPrNHTLlQ/KBr7NYUUHviPzCbj2Ox3BPTZ6qkSLd6WMvVQg==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
-        "@cucumber/ci-environment": "10.0.1",
+        "@cucumber/ci-environment": "12.0.0",
         "@cucumber/cucumber-expressions": "18.0.1",
-        "@cucumber/gherkin": "34.0.0",
-        "@cucumber/gherkin-streams": "5.0.1",
-        "@cucumber/gherkin-utils": "9.2.0",
-        "@cucumber/html-formatter": "21.14.0",
-        "@cucumber/junit-xml-formatter": "0.8.1",
+        "@cucumber/gherkin": "37.0.0",
+        "@cucumber/gherkin-streams": "6.0.0",
+        "@cucumber/gherkin-utils": "10.0.0",
+        "@cucumber/html-formatter": "22.2.0",
+        "@cucumber/junit-xml-formatter": "0.9.0",
         "@cucumber/message-streams": "4.0.1",
-        "@cucumber/messages": "28.1.0",
+        "@cucumber/messages": "31.0.0",
         "@cucumber/pretty-formatter": "1.0.1",
-        "@cucumber/tag-expressions": "6.2.0",
+        "@cucumber/tag-expressions": "8.1.0",
         "assertion-error-formatter": "^3.0.0",
         "capital-case": "^1.0.4",
         "chalk": "^4.1.2",
@@ -2449,7 +2448,7 @@
         "debug": "^4.3.4",
         "error-stack-parser": "^2.1.4",
         "figures": "^3.2.0",
-        "glob": "^11.0.0",
+        "glob": "^13.0.0",
         "has-ansi": "^4.0.1",
         "indent-string": "^4.0.0",
         "is-installed-globally": "^0.4.0",
@@ -2457,19 +2456,19 @@
         "knuth-shuffle-seeded": "^1.0.6",
         "lodash.merge": "^4.6.2",
         "lodash.mergewith": "^4.6.2",
-        "luxon": "3.7.1",
+        "luxon": "3.7.2",
         "mime": "^3.0.0",
         "mkdirp": "^3.0.0",
         "mz": "^2.7.0",
         "progress": "^2.0.3",
-        "read-package-up": "^11.0.0",
-        "semver": "7.7.2",
+        "read-package-up": "^12.0.0",
+        "semver": "7.7.3",
         "string-argv": "0.3.1",
         "supports-color": "^8.1.1",
         "type-fest": "^4.41.0",
         "util-arity": "^1.1.0",
         "yaml": "^2.2.2",
-        "yup": "1.7.0"
+        "yup": "1.7.1"
       },
       "bin": {
         "cucumber-js": "bin/cucumber.js"
@@ -2491,6 +2490,17 @@
         "regexp-match-indices": "1.0.2"
       }
     },
+    "node_modules/@cucumber/cucumber/node_modules/@cucumber/messages": {
+      "version": "31.0.0",
+      "resolved": "https://registry.npmjs.org/@cucumber/messages/-/messages-31.0.0.tgz",
+      "integrity": "sha512-Dqhatp4AjMsH9SREfWz3Q8nlGuwJMTW7YAW5L3OzRId86ZUEu/a8vIL1RO2c0agQefuBS2SVH9fEZ66ovrMYRA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "class-transformer": "0.5.1",
+        "reflect-metadata": "0.2.2"
+      }
+    },
     "node_modules/@cucumber/cucumber/node_modules/commander": {
       "version": "14.0.2",
       "resolved": "https://registry.npmjs.org/commander/-/commander-14.0.2.tgz",
@@ -2502,38 +2512,16 @@
       }
     },
     "node_modules/@cucumber/cucumber/node_modules/glob": {
-      "version": "11.0.3",
-      "resolved": "https://registry.npmjs.org/glob/-/glob-11.0.3.tgz",
-      "integrity": "sha512-2Nim7dha1KVkaiF4q6Dj+ngPPMdfvLJEOpZk/jKiUAkqKebpGAWQXAq9z1xu9HKu5lWfqw/FASuccEjyznjPaA==",
+      "version": "13.0.0",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-13.0.0.tgz",
+      "integrity": "sha512-tvZgpqk6fz4BaNZ66ZsRaZnbHvP/jG3uKJvAZOwEVUL4RTA5nJeeLYfyN9/VA8NX/V3IBG+hkeuGpKjvELkVhA==",
       "dev": true,
-      "license": "ISC",
+      "license": "BlueOak-1.0.0",
       "dependencies": {
-        "foreground-child": "^3.3.1",
-        "jackspeak": "^4.1.1",
-        "minimatch": "^10.0.3",
+        "minimatch": "^10.1.1",
         "minipass": "^7.1.2",
-        "package-json-from-dist": "^1.0.0",
         "path-scurry": "^2.0.0"
       },
-      "bin": {
-        "glob": "dist/esm/bin.mjs"
-      },
-      "engines": {
-        "node": "20 || >=22"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
-    "node_modules/@cucumber/cucumber/node_modules/jackspeak": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-4.1.1.tgz",
-      "integrity": "sha512-zptv57P3GpL+O0I7VdMJNBZCu+BPHVQUk55Ft8/QCJjTVxrnJHuVuX/0Bl2A6/+2oyR/ZMEuFKwmzqqZ/U5nPQ==",
-      "dev": true,
-      "license": "BlueOak-1.0.0",
-      "dependencies": {
-        "@isaacs/cliui": "^8.0.2"
-      },
       "engines": {
         "node": "20 || >=22"
       },
@@ -2542,11 +2530,11 @@
       }
     },
     "node_modules/@cucumber/cucumber/node_modules/lru-cache": {
-      "version": "11.2.2",
-      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.2.2.tgz",
-      "integrity": "sha512-F9ODfyqML2coTIsQpSkRHnLSZMtkU8Q+mSfcaIyKwy58u+8k5nvAYeiNhsyMARvzNcXJ9QfWVrcPsC9e9rAxtg==",
+      "version": "11.2.4",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.2.4.tgz",
+      "integrity": "sha512-B5Y16Jr9LB9dHVkh6ZevG+vAbOsNOYCX+sXvFWFu7B3Iz5mijW3zdbMyhsh8ANd2mSWBYdJgnqi+mL7/LrOPYg==",
       "dev": true,
-      "license": "ISC",
+      "license": "BlueOak-1.0.0",
       "engines": {
         "node": "20 || >=22"
       }
@@ -2613,19 +2601,6 @@
         "url": "https://github.com/sponsors/isaacs"
       }
     },
-    "node_modules/@cucumber/cucumber/node_modules/semver": {
-      "version": "7.7.2",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.2.tgz",
-      "integrity": "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==",
-      "dev": true,
-      "license": "ISC",
-      "bin": {
-        "semver": "bin/semver.js"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
     "node_modules/@cucumber/cucumber/node_modules/supports-color": {
       "version": "8.1.1",
       "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz",
@@ -2669,24 +2644,23 @@
       }
     },
     "node_modules/@cucumber/gherkin": {
-      "version": "34.0.0",
-      "resolved": "https://registry.npmjs.org/@cucumber/gherkin/-/gherkin-34.0.0.tgz",
-      "integrity": "sha512-659CCFsrsyvuBi/Eix1fnhSheMnojSfnBcqJ3IMPNawx7JlrNJDcXYSSdxcUw3n/nG05P+ptCjmiZY3i14p+tA==",
+      "version": "37.0.0",
+      "resolved": "https://registry.npmjs.org/@cucumber/gherkin/-/gherkin-37.0.0.tgz",
+      "integrity": "sha512-vKJVJ6h4HCktG870wgYUUskNpFxbFI0WmAkVLPTz1LlLwJX7/KOBqFcr2/L3u0pPoHjbLRW+IpbiXLT2T13/wg==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
-        "@cucumber/messages": ">=19.1.4 <29"
+        "@cucumber/messages": ">=31.0.0 <32"
       }
     },
     "node_modules/@cucumber/gherkin-streams": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/@cucumber/gherkin-streams/-/gherkin-streams-5.0.1.tgz",
-      "integrity": "sha512-/7VkIE/ASxIP/jd4Crlp4JHXqdNFxPGQokqWqsaCCiqBiu5qHoKMxcWNlp9njVL/n9yN4S08OmY3ZR8uC5x74Q==",
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/@cucumber/gherkin-streams/-/gherkin-streams-6.0.0.tgz",
+      "integrity": "sha512-HLSHMmdDH0vCr7vsVEURcDA4WwnRLdjkhqr6a4HQ3i4RFK1wiDGPjBGVdGJLyuXuRdJpJbFc6QxHvT8pU4t6jw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "commander": "9.1.0",
+        "commander": "14.0.0",
         "source-map-support": "0.5.21"
       },
       "bin": {
@@ -2699,26 +2673,26 @@
       }
     },
     "node_modules/@cucumber/gherkin-streams/node_modules/commander": {
-      "version": "9.1.0",
-      "resolved": "https://registry.npmjs.org/commander/-/commander-9.1.0.tgz",
-      "integrity": "sha512-i0/MaqBtdbnJ4XQs4Pmyb+oFQl+q0lsAmokVUH92SlSw4fkeAcG3bVon+Qt7hmtF+u3Het6o4VgrcY3qAoEB6w==",
+      "version": "14.0.0",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-14.0.0.tgz",
+      "integrity": "sha512-2uM9rYjPvyq39NwLRqaiLtWHyDC1FvryJDa2ATTVims5YAS4PupsEQsDvP14FqhFr0P49CYDugi59xaxJlTXRA==",
       "dev": true,
       "license": "MIT",
       "engines": {
-        "node": "^12.20.0 || >=14"
+        "node": ">=20"
       }
     },
     "node_modules/@cucumber/gherkin-utils": {
-      "version": "9.2.0",
-      "resolved": "https://registry.npmjs.org/@cucumber/gherkin-utils/-/gherkin-utils-9.2.0.tgz",
-      "integrity": "sha512-3nmRbG1bUAZP3fAaUBNmqWO0z0OSkykZZotfLjyhc8KWwDSOrOmMJlBTd474lpA8EWh4JFLAX3iXgynBqBvKzw==",
+      "version": "10.0.0",
+      "resolved": "https://registry.npmjs.org/@cucumber/gherkin-utils/-/gherkin-utils-10.0.0.tgz",
+      "integrity": "sha512-BcujlDT343GXXNrMPl3ws6Il3zs8dQw3Yp/d3HnOJF8i2snGGgiapoTbko7MdvAt7ivDL7SDo+e1d5Cnpl3llA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@cucumber/gherkin": "^31.0.0",
-        "@cucumber/messages": "^27.0.0",
+        "@cucumber/gherkin": "^34.0.0",
+        "@cucumber/messages": "^29.0.0",
         "@teppeis/multimaps": "3.0.0",
-        "commander": "13.1.0",
+        "commander": "14.0.0",
         "source-map-support": "^0.5.21"
       },
       "bin": {
@@ -2726,69 +2700,53 @@
       }
     },
     "node_modules/@cucumber/gherkin-utils/node_modules/@cucumber/gherkin": {
-      "version": "31.0.0",
-      "resolved": "https://registry.npmjs.org/@cucumber/gherkin/-/gherkin-31.0.0.tgz",
-      "integrity": "sha512-wlZfdPif7JpBWJdqvHk1Mkr21L5vl4EfxVUOS4JinWGf3FLRV6IKUekBv5bb5VX79fkDcfDvESzcQ8WQc07Wgw==",
+      "version": "34.0.0",
+      "resolved": "https://registry.npmjs.org/@cucumber/gherkin/-/gherkin-34.0.0.tgz",
+      "integrity": "sha512-659CCFsrsyvuBi/Eix1fnhSheMnojSfnBcqJ3IMPNawx7JlrNJDcXYSSdxcUw3n/nG05P+ptCjmiZY3i14p+tA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@cucumber/messages": ">=19.1.4 <=26"
+        "@cucumber/messages": ">=19.1.4 <29"
       }
     },
     "node_modules/@cucumber/gherkin-utils/node_modules/@cucumber/gherkin/node_modules/@cucumber/messages": {
-      "version": "26.0.1",
-      "resolved": "https://registry.npmjs.org/@cucumber/messages/-/messages-26.0.1.tgz",
-      "integrity": "sha512-DIxSg+ZGariumO+Lq6bn4kOUIUET83A4umrnWmidjGFl8XxkBieUZtsmNbLYgH/gnsmP07EfxxdTr0hOchV1Sg==",
+      "version": "28.1.0",
+      "resolved": "https://registry.npmjs.org/@cucumber/messages/-/messages-28.1.0.tgz",
+      "integrity": "sha512-2LzZtOwYKNlCuNf31ajkrekoy2M4z0Z1QGiPH40n4gf5t8VOUFb7m1ojtR4LmGvZxBGvJZP8voOmRqDWzBzYKA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@types/uuid": "10.0.0",
         "class-transformer": "0.5.1",
         "reflect-metadata": "0.2.2",
-        "uuid": "10.0.0"
-      }
-    },
-    "node_modules/@cucumber/gherkin-utils/node_modules/@cucumber/gherkin/node_modules/uuid": {
-      "version": "10.0.0",
-      "resolved": "https://registry.npmjs.org/uuid/-/uuid-10.0.0.tgz",
-      "integrity": "sha512-8XkAphELsDnEGrDxUOHB3RGvXz6TeuYSGEZBOjtTtPm2lwhGBjLgOzLHB63IUWfBpNucQjND6d3AOudO+H3RWQ==",
-      "dev": true,
-      "funding": [
-        "https://github.com/sponsors/broofa",
-        "https://github.com/sponsors/ctavan"
-      ],
-      "license": "MIT",
-      "bin": {
-        "uuid": "dist/bin/uuid"
+        "uuid": "11.1.0"
       }
     },
     "node_modules/@cucumber/gherkin-utils/node_modules/@cucumber/messages": {
-      "version": "27.2.0",
-      "resolved": "https://registry.npmjs.org/@cucumber/messages/-/messages-27.2.0.tgz",
-      "integrity": "sha512-f2o/HqKHgsqzFLdq6fAhfG1FNOQPdBdyMGpKwhb7hZqg0yZtx9BVqkTyuoNk83Fcvk3wjMVfouFXXHNEk4nddA==",
+      "version": "29.0.1",
+      "resolved": "https://registry.npmjs.org/@cucumber/messages/-/messages-29.0.1.tgz",
+      "integrity": "sha512-aAvIYfQD6/aBdF8KFQChC3CQ1Q+GX9orlR6GurGiX6oqaCnBkxA4WU3OQUVepDynEFrPayerqKRFcAMhdcXReQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@types/uuid": "10.0.0",
         "class-transformer": "0.5.1",
-        "reflect-metadata": "0.2.2",
-        "uuid": "11.0.5"
+        "reflect-metadata": "0.2.2"
       }
     },
     "node_modules/@cucumber/gherkin-utils/node_modules/commander": {
-      "version": "13.1.0",
-      "resolved": "https://registry.npmjs.org/commander/-/commander-13.1.0.tgz",
-      "integrity": "sha512-/rFeCpNJQbhSZjGVwO9RFV3xPqbnERS8MmIQzCtD/zl6gpJuV/bMLuN92oG3F7d8oDEHHRrujSXNUr8fpjntKw==",
+      "version": "14.0.0",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-14.0.0.tgz",
+      "integrity": "sha512-2uM9rYjPvyq39NwLRqaiLtWHyDC1FvryJDa2ATTVims5YAS4PupsEQsDvP14FqhFr0P49CYDugi59xaxJlTXRA==",
       "dev": true,
       "license": "MIT",
       "engines": {
-        "node": ">=18"
+        "node": ">=20"
       }
     },
     "node_modules/@cucumber/gherkin-utils/node_modules/uuid": {
-      "version": "11.0.5",
-      "resolved": "https://registry.npmjs.org/uuid/-/uuid-11.0.5.tgz",
-      "integrity": "sha512-508e6IcKLrhxKdBbcA2b4KQZlLVp2+J5UwQ6F7Drckkc5N9ZJwFa4TgWtsww9UG8fGHbm6gbV19TdM5pQ4GaIA==",
+      "version": "11.1.0",
+      "resolved": "https://registry.npmjs.org/uuid/-/uuid-11.1.0.tgz",
+      "integrity": "sha512-0/A9rDy9P7cJ+8w1c9WD9V//9Wj15Ce2MPz8Ri6032usz+NfePxx5AcN3bN+r6ZL6jEo066/yNYB3tn4pQEx+A==",
       "dev": true,
       "funding": [
         "https://github.com/sponsors/broofa",
@@ -2799,10 +2757,21 @@
         "uuid": "dist/esm/bin/uuid"
       }
     },
+    "node_modules/@cucumber/gherkin/node_modules/@cucumber/messages": {
+      "version": "31.0.0",
+      "resolved": "https://registry.npmjs.org/@cucumber/messages/-/messages-31.0.0.tgz",
+      "integrity": "sha512-Dqhatp4AjMsH9SREfWz3Q8nlGuwJMTW7YAW5L3OzRId86ZUEu/a8vIL1RO2c0agQefuBS2SVH9fEZ66ovrMYRA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "class-transformer": "0.5.1",
+        "reflect-metadata": "0.2.2"
+      }
+    },
     "node_modules/@cucumber/html-formatter": {
-      "version": "21.14.0",
-      "resolved": "https://registry.npmjs.org/@cucumber/html-formatter/-/html-formatter-21.14.0.tgz",
-      "integrity": "sha512-vQqbmQZc0QiN4c+cMCffCItpODJlOlYtPG7pH6We096dBOa7u0ttDMjT6KrMAnQlcln54rHL46r408IFpuznAw==",
+      "version": "22.2.0",
+      "resolved": "https://registry.npmjs.org/@cucumber/html-formatter/-/html-formatter-22.2.0.tgz",
+      "integrity": "sha512-fUNC/KngTIz+hAQ2Yr4XjdYq+MO60PwK9SidxBQ54jNI1Vw7erlgsPq0TOWneCIvdjU3qp+YDqYG1hw3zuUuDA==",
       "dev": true,
       "license": "MIT",
       "peerDependencies": {
@@ -2810,13 +2779,13 @@
       }
     },
     "node_modules/@cucumber/junit-xml-formatter": {
-      "version": "0.8.1",
-      "resolved": "https://registry.npmjs.org/@cucumber/junit-xml-formatter/-/junit-xml-formatter-0.8.1.tgz",
-      "integrity": "sha512-FT1Y96pyd9/ifbE9I7dbkTCjkwEdW9C0MBobUZoKD13c8EnWAt0xl1Yy/v/WZLTk4XfCLte1DATtLx01jt+YiA==",
+      "version": "0.9.0",
+      "resolved": "https://registry.npmjs.org/@cucumber/junit-xml-formatter/-/junit-xml-formatter-0.9.0.tgz",
+      "integrity": "sha512-WF+A7pBaXpKMD1i7K59Nk5519zj4extxY4+4nSgv5XLsGXHDf1gJnb84BkLUzevNtp2o2QzMG0vWLwSm8V5blw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@cucumber/query": "^13.0.2",
+        "@cucumber/query": "^14.0.1",
         "@teppeis/multimaps": "^3.0.0",
         "luxon": "^3.5.0",
         "xmlbuilder": "^15.1.1"
@@ -2895,9 +2864,9 @@
       }
     },
     "node_modules/@cucumber/query": {
-      "version": "13.6.0",
-      "resolved": "https://registry.npmjs.org/@cucumber/query/-/query-13.6.0.tgz",
-      "integrity": "sha512-tiDneuD5MoWsJ9VKPBmQok31mSX9Ybl+U4wqDoXeZgsXHDURqzM3rnpWVV3bC34y9W6vuFxrlwF/m7HdOxwqRw==",
+      "version": "14.7.0",
+      "resolved": "https://registry.npmjs.org/@cucumber/query/-/query-14.7.0.tgz",
+      "integrity": "sha512-fiqZ4gMEgYjmbuWproF/YeCdD5y+gD2BqgBIGbpihOsx6UlNsyzoDSfO+Tny0q65DxfK+pHo2UkPyEl7dO7wmQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -2909,9 +2878,9 @@
       }
     },
     "node_modules/@cucumber/tag-expressions": {
-      "version": "6.2.0",
-      "resolved": "https://registry.npmjs.org/@cucumber/tag-expressions/-/tag-expressions-6.2.0.tgz",
-      "integrity": "sha512-KIF0eLcafHbWOuSDWFw0lMmgJOLdDRWjEL1kfXEWrqHmx2119HxVAr35WuEd9z542d3Yyg+XNqSr+81rIKqEdg==",
+      "version": "8.1.0",
+      "resolved": "https://registry.npmjs.org/@cucumber/tag-expressions/-/tag-expressions-8.1.0.tgz",
+      "integrity": "sha512-UFeOVUyc711/E7VHjThxMwg3jbGod9TlbM1gxNixX/AGDKg82Eha4cE0tKki3GGUs7uB2NyI+hQAuhB8rL2h5A==",
       "dev": true,
       "license": "MIT"
     },
@@ -3487,9 +3456,9 @@
       }
     },
     "node_modules/@puppeteer/browsers": {
-      "version": "2.10.13",
-      "resolved": "https://registry.npmjs.org/@puppeteer/browsers/-/browsers-2.10.13.tgz",
-      "integrity": "sha512-a9Ruw3j3qlnB5a/zHRTkruppynxqaeE4H9WNj5eYGRWqw0ZauZ23f4W2ARf3hghF5doozyD+CRtt7XSYuYRI/Q==",
+      "version": "2.11.0",
+      "resolved": "https://registry.npmjs.org/@puppeteer/browsers/-/browsers-2.11.0.tgz",
+      "integrity": "sha512-n6oQX6mYkG8TRPuPXmbPidkUbsSRalhmaaVAQxvH1IkQy63cwsH+kOjB3e4cpCDHg0aSvsiX9bQ4s2VB6mGWUQ==",
       "dev": true,
       "license": "Apache-2.0",
       "dependencies": {
@@ -5953,9 +5922,9 @@
       }
     },
     "node_modules/bare-fs": {
-      "version": "4.5.1",
-      "resolved": "https://registry.npmjs.org/bare-fs/-/bare-fs-4.5.1.tgz",
-      "integrity": "sha512-zGUCsm3yv/ePt2PHNbVxjjn0nNB1MkIaR4wOCxJ2ig5pCf5cCVAYJXVhQg/3OhhJV6DB1ts7Hv0oUaElc2TPQg==",
+      "version": "4.5.2",
+      "resolved": "https://registry.npmjs.org/bare-fs/-/bare-fs-4.5.2.tgz",
+      "integrity": "sha512-veTnRzkb6aPHOvSKIOy60KzURfBdUflr5VReI+NSaPL6xf+XLdONQgZgpYvUuZLVQ8dCqxpBAudaOM1+KpAUxw==",
       "dev": true,
       "license": "Apache-2.0",
       "optional": true,
@@ -7601,9 +7570,9 @@
       "license": "MIT"
     },
     "node_modules/devtools-protocol": {
-      "version": "0.0.1521046",
-      "resolved": "https://registry.npmjs.org/devtools-protocol/-/devtools-protocol-0.0.1521046.tgz",
-      "integrity": "sha512-vhE6eymDQSKWUXwwA37NtTTVEzjtGVfDr3pRbsWEQ5onH/Snp2c+2xZHWJJawG/0hCCJLRGt4xVtEVUVILol4w==",
+      "version": "0.0.1534754",
+      "resolved": "https://registry.npmjs.org/devtools-protocol/-/devtools-protocol-0.0.1534754.tgz",
+      "integrity": "sha512-26T91cV5dbOYnXdJi5qQHoTtUoNEqwkHcAyu/IKtjIAxiEqPMrDiRkDOPWVsGfNZGmlQVHQbZRSjD8sxagWVsQ==",
       "dev": true,
       "license": "BSD-3-Clause",
       "peer": true
@@ -10022,24 +9991,27 @@
       }
     },
     "node_modules/hosted-git-info": {
-      "version": "7.0.2",
-      "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-7.0.2.tgz",
-      "integrity": "sha512-puUZAUKT5m8Zzvs72XWy3HtvVbTWljRE66cP60bxJzAqf2DgICo7lYTY2IHUmLnNpjYvw5bvmoHvPc0QO2a62w==",
+      "version": "9.0.2",
+      "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-9.0.2.tgz",
+      "integrity": "sha512-M422h7o/BR3rmCQ8UHi7cyyMqKltdP9Uo+J2fXK+RSAY+wTcKOIRyhTuKv4qn+DJf3g+PL890AzId5KZpX+CBg==",
       "dev": true,
       "license": "ISC",
       "dependencies": {
-        "lru-cache": "^10.0.1"
+        "lru-cache": "^11.1.0"
       },
       "engines": {
-        "node": "^16.14.0 || >=18.0.0"
+        "node": "^20.17.0 || >=22.9.0"
       }
     },
     "node_modules/hosted-git-info/node_modules/lru-cache": {
-      "version": "10.4.3",
-      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz",
-      "integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==",
+      "version": "11.2.4",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.2.4.tgz",
+      "integrity": "sha512-B5Y16Jr9LB9dHVkh6ZevG+vAbOsNOYCX+sXvFWFu7B3Iz5mijW3zdbMyhsh8ANd2mSWBYdJgnqi+mL7/LrOPYg==",
       "dev": true,
-      "license": "ISC"
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": "20 || >=22"
+      }
     },
     "node_modules/hpack.js": {
       "version": "2.1.6",
@@ -12395,9 +12367,9 @@
       }
     },
     "node_modules/luxon": {
-      "version": "3.7.1",
-      "resolved": "https://registry.npmjs.org/luxon/-/luxon-3.7.1.tgz",
-      "integrity": "sha512-RkRWjA926cTvz5rAb1BqyWkKbbjzCGchDUIKMCUvNi17j6f6j8uHGDV82Aqcqtzd+icoYpELmG3ksgGiFNNcNg==",
+      "version": "3.7.2",
+      "resolved": "https://registry.npmjs.org/luxon/-/luxon-3.7.2.tgz",
+      "integrity": "sha512-vtEhXh/gNjI9Yg1u4jX/0YVPMvxzHuGgCm6tC5kZyb08yjGWGnqAjGJvcXbqQR2P3MyMEFnRbpcdFS6PBcLqew==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -12789,18 +12761,18 @@
       "license": "MIT"
     },
     "node_modules/normalize-package-data": {
-      "version": "6.0.2",
-      "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-6.0.2.tgz",
-      "integrity": "sha512-V6gygoYb/5EmNI+MEGrWkC+e6+Rr7mTmfHrxDbLzxQogBkgzo76rkok0Am6thgSF7Mv2nLOajAJj5vDJZEFn7g==",
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-8.0.0.tgz",
+      "integrity": "sha512-RWk+PI433eESQ7ounYxIp67CYuVsS1uYSonX3kA6ps/3LWfjVQa/ptEg6Y3T6uAMq1mWpX9PQ+qx+QaHpsc7gQ==",
       "dev": true,
       "license": "BSD-2-Clause",
       "dependencies": {
-        "hosted-git-info": "^7.0.0",
+        "hosted-git-info": "^9.0.0",
         "semver": "^7.3.5",
         "validate-npm-package-license": "^3.0.4"
       },
       "engines": {
-        "node": "^16.14.0 || >=18.0.0"
+        "node": "^20.17.0 || >=22.9.0"
       }
     },
     "node_modules/normalize-path": {
@@ -14944,18 +14916,18 @@
       }
     },
     "node_modules/puppeteer": {
-      "version": "24.30.0",
-      "resolved": "https://registry.npmjs.org/puppeteer/-/puppeteer-24.30.0.tgz",
-      "integrity": "sha512-A5OtCi9WpiXBQgJ2vQiZHSyrAzQmO/WDsvghqlN4kgw21PhxA5knHUaUQq/N3EMt8CcvSS0RM+kmYLJmedR3TQ==",
+      "version": "24.32.1",
+      "resolved": "https://registry.npmjs.org/puppeteer/-/puppeteer-24.32.1.tgz",
+      "integrity": "sha512-wa8vGswFjH1iCyG6bGGydIYssEBluXixbMibK4x2x6/lIAuR87gF+c+Jjzom2Wiw/dDOtuki89VBurRWrgYaUA==",
       "dev": true,
       "hasInstallScript": true,
       "license": "Apache-2.0",
       "dependencies": {
-        "@puppeteer/browsers": "2.10.13",
+        "@puppeteer/browsers": "2.11.0",
         "chromium-bidi": "11.0.0",
         "cosmiconfig": "^9.0.0",
-        "devtools-protocol": "0.0.1521046",
-        "puppeteer-core": "24.30.0",
+        "devtools-protocol": "0.0.1534754",
+        "puppeteer-core": "24.32.1",
         "typed-query-selector": "^2.12.0"
       },
       "bin": {
@@ -14966,18 +14938,18 @@
       }
     },
     "node_modules/puppeteer-core": {
-      "version": "24.30.0",
-      "resolved": "https://registry.npmjs.org/puppeteer-core/-/puppeteer-core-24.30.0.tgz",
-      "integrity": "sha512-2S3Smy0t0W4wJnNvDe7W0bE7wDmZjfZ3ljfMgJd6hn2Hq/f0jgN+x9PULZo2U3fu5UUIJ+JP8cNUGllu8P91Pg==",
+      "version": "24.32.1",
+      "resolved": "https://registry.npmjs.org/puppeteer-core/-/puppeteer-core-24.32.1.tgz",
+      "integrity": "sha512-GdWTOgy3RqaW6Etgx93ydlVJ4FBJ6TmhMksG5W7v4uawKAzLHNj33k4kBQ1SFZ9NvoXNjhdQuIQ+uik2kWnarA==",
       "dev": true,
       "license": "Apache-2.0",
       "dependencies": {
-        "@puppeteer/browsers": "2.10.13",
+        "@puppeteer/browsers": "2.11.0",
         "chromium-bidi": "11.0.0",
         "debug": "^4.4.3",
-        "devtools-protocol": "0.0.1521046",
+        "devtools-protocol": "0.0.1534754",
         "typed-query-selector": "^2.12.0",
-        "webdriver-bidi-protocol": "0.3.8",
+        "webdriver-bidi-protocol": "0.3.9",
         "ws": "^8.18.3"
       },
       "engines": {
@@ -16383,51 +16355,54 @@
       }
     },
     "node_modules/read-package-up": {
-      "version": "11.0.0",
-      "resolved": "https://registry.npmjs.org/read-package-up/-/read-package-up-11.0.0.tgz",
-      "integrity": "sha512-MbgfoNPANMdb4oRBNg5eqLbB2t2r+o5Ua1pNt8BqGp4I0FJZhuVSOj3PaBPni4azWuSzEdNn2evevzVmEk1ohQ==",
+      "version": "12.0.0",
+      "resolved": "https://registry.npmjs.org/read-package-up/-/read-package-up-12.0.0.tgz",
+      "integrity": "sha512-Q5hMVBYur/eQNWDdbF4/Wqqr9Bjvtrw2kjGxxBbKLbx8bVCL8gcArjTy8zDUuLGQicftpMuU0riQNcAsbtOVsw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "find-up-simple": "^1.0.0",
-        "read-pkg": "^9.0.0",
-        "type-fest": "^4.6.0"
+        "find-up-simple": "^1.0.1",
+        "read-pkg": "^10.0.0",
+        "type-fest": "^5.2.0"
       },
       "engines": {
-        "node": ">=18"
+        "node": ">=20"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
     "node_modules/read-package-up/node_modules/type-fest": {
-      "version": "4.41.0",
-      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-4.41.0.tgz",
-      "integrity": "sha512-TeTSQ6H5YHvpqVwBRcnLDCBnDOHWYu7IvGbHT6N8AOymcr9PJGjc1GTtiWZTYg0NCgYwvnYWEkVChQAr9bjfwA==",
+      "version": "5.3.1",
+      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-5.3.1.tgz",
+      "integrity": "sha512-VCn+LMHbd4t6sF3wfU/+HKT63C9OoyrSIf4b+vtWHpt2U7/4InZG467YDNMFMR70DdHjAdpPWmw2lzRdg0Xqqg==",
       "dev": true,
       "license": "(MIT OR CC0-1.0)",
+      "dependencies": {
+        "tagged-tag": "^1.0.0"
+      },
       "engines": {
-        "node": ">=16"
+        "node": ">=20"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
     "node_modules/read-pkg": {
-      "version": "9.0.1",
-      "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-9.0.1.tgz",
-      "integrity": "sha512-9viLL4/n1BJUCT1NXVTdS1jtm80yDEgR5T4yCelII49Mbj0v1rZdKqj7zCiYdbB0CuCgdrvHcNogAKTFPBocFA==",
+      "version": "10.0.0",
+      "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-10.0.0.tgz",
+      "integrity": "sha512-A70UlgfNdKI5NSvTTfHzLQj7NJRpJ4mT5tGafkllJ4wh71oYuGm/pzphHcmW4s35iox56KSK721AihodoXSc/A==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@types/normalize-package-data": "^2.4.3",
-        "normalize-package-data": "^6.0.0",
-        "parse-json": "^8.0.0",
-        "type-fest": "^4.6.0",
-        "unicorn-magic": "^0.1.0"
+        "@types/normalize-package-data": "^2.4.4",
+        "normalize-package-data": "^8.0.0",
+        "parse-json": "^8.3.0",
+        "type-fest": "^5.2.0",
+        "unicorn-magic": "^0.3.0"
       },
       "engines": {
-        "node": ">=18"
+        "node": ">=20"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
@@ -16451,7 +16426,7 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/read-pkg/node_modules/type-fest": {
+    "node_modules/read-pkg/node_modules/parse-json/node_modules/type-fest": {
       "version": "4.41.0",
       "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-4.41.0.tgz",
       "integrity": "sha512-TeTSQ6H5YHvpqVwBRcnLDCBnDOHWYu7IvGbHT6N8AOymcr9PJGjc1GTtiWZTYg0NCgYwvnYWEkVChQAr9bjfwA==",
@@ -16464,6 +16439,22 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/read-pkg/node_modules/type-fest": {
+      "version": "5.3.1",
+      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-5.3.1.tgz",
+      "integrity": "sha512-VCn+LMHbd4t6sF3wfU/+HKT63C9OoyrSIf4b+vtWHpt2U7/4InZG467YDNMFMR70DdHjAdpPWmw2lzRdg0Xqqg==",
+      "dev": true,
+      "license": "(MIT OR CC0-1.0)",
+      "dependencies": {
+        "tagged-tag": "^1.0.0"
+      },
+      "engines": {
+        "node": ">=20"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/readable-stream": {
       "version": "3.6.2",
       "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz",
@@ -18458,6 +18449,19 @@
       "integrity": "sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==",
       "license": "MIT"
     },
+    "node_modules/tagged-tag": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/tagged-tag/-/tagged-tag-1.0.0.tgz",
+      "integrity": "sha512-yEFYrVhod+hdNyx7g5Bnkkb0G6si8HJurOoOEgC8B/O0uXLHlaey/65KRv6cuWBNhBgHKAROVpc7QyYqE5gFng==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=20"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/tailwindcss": {
       "version": "3.4.18",
       "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-3.4.18.tgz",
@@ -19228,9 +19232,9 @@
       }
     },
     "node_modules/unicorn-magic": {
-      "version": "0.1.0",
-      "resolved": "https://registry.npmjs.org/unicorn-magic/-/unicorn-magic-0.1.0.tgz",
-      "integrity": "sha512-lRfVq8fE8gz6QMBuDM6a+LO3IAzTi05H6gCVaUpir2E1Rwpo4ZUog45KpNXKC/Mn3Yb9UDuHumeFTo9iV/D9FQ==",
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/unicorn-magic/-/unicorn-magic-0.3.0.tgz",
+      "integrity": "sha512-+QBBXBCvifc56fsbuxZQ6Sic3wqqc3WWaqxs58gvJrcOuN83HGTCwz3oS5phzU9LthRNE9VrJCFCLUgHeeFnfA==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -19478,9 +19482,9 @@
       }
     },
     "node_modules/webdriver-bidi-protocol": {
-      "version": "0.3.8",
-      "resolved": "https://registry.npmjs.org/webdriver-bidi-protocol/-/webdriver-bidi-protocol-0.3.8.tgz",
-      "integrity": "sha512-21Yi2GhGntMc671vNBCjiAeEVknXjVRoyu+k+9xOMShu+ZQfpGQwnBqbNz/Sv4GXZ6JmutlPAi2nIJcrymAWuQ==",
+      "version": "0.3.9",
+      "resolved": "https://registry.npmjs.org/webdriver-bidi-protocol/-/webdriver-bidi-protocol-0.3.9.tgz",
+      "integrity": "sha512-uIYvlRQ0PwtZR1EzHlTMol1G0lAlmOe6wPykF9a77AK3bkpvZHzIVxRE2ThOx5vjy2zISe0zhwf5rzuUfbo1PQ==",
       "dev": true,
       "license": "Apache-2.0"
     },
@@ -20381,9 +20385,9 @@
       }
     },
     "node_modules/yup": {
-      "version": "1.7.0",
-      "resolved": "https://registry.npmjs.org/yup/-/yup-1.7.0.tgz",
-      "integrity": "sha512-VJce62dBd+JQvoc+fCVq+KZfPHr+hXaxCcVgotfwWvlR0Ja3ffYKaJBT8rptPOSKOGJDCUnW2C2JWpud7aRP6Q==",
+      "version": "1.7.1",
+      "resolved": "https://registry.npmjs.org/yup/-/yup-1.7.1.tgz",
+      "integrity": "sha512-GKHFX2nXul2/4Dtfxhozv701jLQHdf6J34YDh2cEkpqoo8le5Mg6/LrdseVLrFarmFygZTlfIhHx/QKfb/QWXw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
diff --git a/client/src/features/server-newScriptAnswer-management.feature b/client/src/features/server-newScriptAnswer-management.feature
new file mode 100644
index 00000000..845964af
--- /dev/null
+++ b/client/src/features/server-newScriptAnswer-management.feature
@@ -0,0 +1,88 @@
+@server
+Feature: Server Script Answers Management
+    As a system
+    I want to manage script answers through the API
+    So that student submissions are properly retrieved and updated
+
+    Background:
+        Given the server API is available
+
+    Scenario: Criar um ScriptAnswer quando aluno inicia roteiro
+        Given O estudante de CPF "11111111111" está cadastrado no sistema
+        And O aluno está matriculado na turma "Math101-2024-2024"
+        And Existe um roteiro de ID "script-001" na turma
+        When O aluno cria um ScriptAnswer para o roteiro
+        Then O servidor retorna status "201"
+        And O ScriptAnswer tem status "in_progress"
+        And O campo "started_at" contém um timestamp válido
+        And O campo "answers" está vazio
+
+    Scenario: Iniciar resposta de uma questão
+        Given O estudante de CPF "11111111111" tem um ScriptAnswer ativo de ID "scriptanswer-start"
+        And A tarefa "task-001" existe no roteiro
+        And A tarefa ainda não foi iniciada
+        When O aluno inicia a resposta da tarefa "task-001"
+        Then O servidor retorna status "201"
+        And A TaskAnswer tem status "started"
+        And O campo "started_at" contém timestamp válido
+        And O campo "submitted_at" está vazio
+
+    Scenario: Enviar resposta de uma questão que não é a última
+        Given O estudante de CPF "11111111111" tem um ScriptAnswer ativo de ID "scriptanswer-submit-nonfinal"
+        And A tarefa "task-001" foi iniciada
+        And A tarefa não é a última do roteiro
+        When O aluno submete a resposta "Minha resposta aqui" para a tarefa
+        Then O servidor retorna status "200"
+        And A TaskAnswer tem status "submitted"
+        And O campo "submitted_at" contém timestamp válido
+        And O campo "time_taken_seconds" é calculado corretamente
+        And O ScriptAnswer continua com status "in_progress"
+
+    Scenario: Enviar resposta da última questão e finalizar roteiro
+        Given O estudante de CPF "11111111111" tem um ScriptAnswer ativo de ID "scriptanswer-submit-final"
+        And A tarefa "task-003" foi iniciada
+        And A tarefa é a última do roteiro
+        When O aluno submete a resposta "Resposta final" para a tarefa
+        Then O servidor retorna status "200"
+        And A TaskAnswer tem status "submitted"
+        And O ScriptAnswer tem status "finished"
+        And O campo "finished_at" do ScriptAnswer contém timestamp válido
+
+    Scenario: Marcar roteiro como expirado por timeout
+        Given O estudante de CPF "11111111111" tem um ScriptAnswer ativo de ID "scriptanswer-timeout"
+        And Passaram-se do tempo limite para realizar o roteiro
+        When O sistema verifica timeout do ScriptAnswer
+        Then O servidor retorna status "200"
+        And O ScriptAnswer tem status "finished"
+        And As tarefas "started" foram marcadas como "submitted"
+        And As tarefas "pending" foram marcadas como "timed_out"
+
+    Scenario: Falha ao criar ScriptAnswer para aluno não matriculado
+        Given O estudante de CPF "99999999999" está cadastrado no sistema
+        And O aluno NÃO está matriculado na turma "Math101-2024-2024"
+        And Existe um roteiro de ID "script-001" na turma
+        When O aluno tenta criar um ScriptAnswer para o roteiro
+        Then O servidor retorna status "403"
+        And A mensagem de erro indica "Student is not enrolled in this class"
+    
+    Scenario: Falha ao submeter tarefa já submetida
+        Given O estudante de CPF "11111111111" tem um ScriptAnswer ativo de ID "scriptanswer-resubmit-fail"
+        And A tarefa "task-001" já foi submetida
+        When O aluno tenta submeter novamente a tarefa "task-001" com resposta "Resposta duplicada"
+        Then O servidor retorna status "409"
+        And A mensagem de erro indica "Task answer already submitted and cannot be changed"
+
+    Scenario: Buscar ScriptAnswers de uma turma
+        Given A turma "Math101-2024-2024" tem "5" alunos com ScriptAnswers
+        When O sistema busca todos os ScriptAnswers da turma
+        Then O servidor retorna status "200"
+        And A resposta contém pelo menos "5" ScriptAnswers
+        And Todos os ScriptAnswers pertencem à turma correta
+
+    Scenario: Buscar ScriptAnswers de um aluno matriculado em uma turma
+        Given Existe uma turma com ID "Math101-2024-2024"
+        And Existe um estudante com CPF "12345678901" matriculado na turma "Math101-2024-2024"
+        And Este estudante possui ScriptAnswers de IDs "enrollment-001, enrollment-002" na turma "Math101-2024-2024"
+        When Eu envio uma requisição GET para "/scriptanswers/enrollment?classId=Math101-2024-2024&studentId=12345678901"
+        Then O servidor retorna status "200"
+        And O servidor deve retornar uma lista contendo as respostas "enrollment-001, enrollment-002"
diff --git a/client/src/features/server-scriptAnswer-management.feature b/client/src/features/server-scriptAnswer-management.feature
index 83156c78..4486e9ac 100644
--- a/client/src/features/server-scriptAnswer-management.feature
+++ b/client/src/features/server-scriptAnswer-management.feature
@@ -147,88 +147,4 @@ Feature: Server Script Answers Management
       | field   | value                    |
       | comment | Precisa revisar este ponto |
     Then the server should return 404 Not Found
-    And the server should return an error message stating the script answer was not found
-
-    #############
-    #############
-    #############
-
-  Scenario: Criar um ScriptAnswer quando aluno inicia roteiro
-    Given O estudante de CPF "11111111111" está cadastrado no sistema
-    And O aluno está matriculado na turma "Math 101-2024-2024"
-    And Existe um roteiro de ID "script-001" na turma
-    When O aluno cria um ScriptAnswer para o roteiro
-    Then O servidor retorna status "201"
-    And O ScriptAnswer tem status "in_progress"
-    And O campo "started_at" contém um timestamp válido
-    And O campo "answers" está vazio
-
-  Scenario: Iniciar resposta de uma questão
-    Given O estudante de CPF "11111111111" tem um ScriptAnswer ativo de ID "script-002"
-    And A tarefa "task-001" existe no roteiro
-    And A tarefa ainda não foi iniciada
-    When O aluno inicia a resposta da tarefa "task-001"
-    Then O servidor retorna status "201"
-    And A TaskAnswer tem status "started"
-    And O campo "started_at" contém timestamp válido
-    And O campo "submitted_at" está vazio
-
-  Scenario: Enviar resposta de uma questão que não é a última
-    Given O estudante de CPF "11111111111" tem um ScriptAnswer ativo
-    And A tarefa "task-001" foi iniciada
-    And A tarefa não é a última do roteiro
-    When O aluno submete a resposta "Minha resposta aqui" para a tarefa
-    Then O servidor retorna status "200"
-    And A TaskAnswer tem status "submitted"
-    And O campo "submitted_at" contém timestamp válido
-    And O campo "time_taken_seconds" é calculado corretamente
-    And O ScriptAnswer continua com status "in_progress"
-
-  Scenario: Enviar resposta da última questão e finalizar roteiro
-    Given O estudante de CPF "11111111111" tem um ScriptAnswer ativo
-    And A tarefa "task-003" foi iniciada
-    And A tarefa é a última do roteiro
-    When O aluno submete a resposta "Resposta final" para a tarefa
-    Then O servidor retorna status "200"
-    And A TaskAnswer tem status "submitted"
-    And O ScriptAnswer tem status "finished"
-    And O campo "finished_at" do ScriptAnswer contém timestamp válido
-
-  Scenario: Marcar roteiro como expirado por timeout
-    Given O estudante de CPF "11111111111" tem um ScriptAnswer ativo
-    And Passaram-se 3601 segundos desde o início
-    When O sistema verifica timeout do ScriptAnswer
-    Then O servidor retorna status "200"
-    And O ScriptAnswer tem status "finished"
-    And Todas as tarefas "started" foram marcadas como "submitted"
-    And Todas as tarefas "pending" foram marcadas como "timed_out"
-
-  Scenario: Falha ao criar ScriptAnswer para aluno não matriculado
-    Given O estudante de CPF "99999999999" está cadastrado no sistema
-    And O aluno NÃO está matriculado na turma "Math 101-2024-2024"
-    And Existe um roteiro de ID "script-001" na turma
-    When O aluno tenta criar um ScriptAnswer para o roteiro
-    Then O servidor retorna status "403"
-    And A mensagem de erro indica "Student is not enrolled in this class"
-    
-    Scenario: Falha ao submeter tarefa já submetida
-    Given O estudante de CPF "11111111111" tem um ScriptAnswer ativo
-    And A tarefa "task-001" já foi submetida
-    When O aluno tenta submeter novamente a tarefa "task-001" com resposta "Resposta duplicada"
-    Then O servidor retorna status "409"
-    And A mensagem de erro indica "Task answer already submitted and cannot be changed"
-
-    Scenario: Buscar ScriptAnswers de uma turma
-    Given A turma "Math 101-2024-2024" tem "5" alunos com ScriptAnswers
-    When O sistema busca todos os ScriptAnswers da turma
-    Then O servidor retorna status "200"
-    And A resposta contém pelo menos "5" ScriptAnswers
-    And Todos os ScriptAnswers pertencem à turma correta
-
-    Scenario: Buscar ScriptAnswers de um aluno matriculado em uma turma
-    Given Existe uma turma com ID "Math-101-2024"
-    And Existe um estudante com CPF "12345678901" matriculado na turma "Math-101-2024"
-    And Este estudante possui ScriptAnswers de IDs "201", "202" na turma "Math-101-2024"
-    When Eu envio uma requisição GET para "/api/scriptanswers/enrollment?classId=Math-101-2024&studentId=12345678901"
-    Then O servidor retorna status "200"
-    And O servidor deve retornar uma lista contendo as respostas "201", "202"
+    And the server should return an error message stating the script answer was not found
\ No newline at end of file
diff --git a/client/src/step-definitions/server-newScriptAnswer-steps.ts b/client/src/step-definitions/server-newScriptAnswer-steps.ts
new file mode 100644
index 00000000..5c2cce2e
--- /dev/null
+++ b/client/src/step-definitions/server-newScriptAnswer-steps.ts
@@ -0,0 +1,442 @@
+import { Given, When, Then } from '@cucumber/cucumber';
+import expect from 'expect';
+
+const API_URL = 'http://localhost:3005/api';
+
+// Test data storage
+interface TestContext {
+  lastResponse?: any;
+  lastError?: any;
+  lastStatusCode?: number;
+  scriptAnswers?: any[];
+  scriptAnswer?: any;
+  taskAnswer?: any;
+  student?: any;
+  class?: any;
+  script?: any;
+  classesByName: Map<string, any>;
+  studentsByCPF: Map<string, any>;
+  currentTaskId?: string;
+  elapsedSeconds?: number;
+  expectedScriptAnswerIds?: string[];
+}
+
+const context: TestContext = {
+  classesByName: new Map(),
+  studentsByCPF: new Map(),
+};
+
+// ============================================================
+// Helper Functions
+// ============================================================
+
+async function fetchAPI(method: string, endpoint: string, body?: any): Promise<any> {
+  const url = `${API_URL}${endpoint}`;
+  const options: RequestInit = {
+    method,
+    headers: { 'Content-Type': 'application/json' }
+  };
+  
+  if (body) {
+    options.body = JSON.stringify(body);
+  }
+  
+  try {
+    const response = await fetch(url, options);
+    context.lastStatusCode = response.status;
+    
+    const text = await response.text();
+    if (text) {
+      try {
+        context.lastResponse = JSON.parse(text);
+      } catch {
+        context.lastResponse = text;
+      }
+    }
+    
+    if (!response.ok) {
+      context.lastError = context.lastResponse;
+    }
+    
+    return context.lastResponse;
+  } catch (error: any) {
+    context.lastError = error;
+    throw error;
+  }
+}
+
+// ============================================================
+// Background
+// ============================================================
+
+Given('the server API is available', async function () {
+  try {
+    const response = await fetch('http://localhost:3005/api/students');
+    expect(response.status).toBe(200);
+  } catch (error) {
+    throw new Error('Server API is not available on port 3005');
+  }
+});
+
+// ============================================================
+// Portuguese Scenarios: Create ScriptAnswer
+// ============================================================
+
+Given('O estudante de CPF {string} está cadastrado no sistema', async function (cpf: string) {
+  // Simply store the student data - backend will verify on endpoint call
+  context.student = { cpf };
+  context.studentsByCPF.set(cpf, context.student);
+});
+
+Given('O aluno está matriculado na turma {string}', async function (className: string) {
+  try {
+    const classes = await fetchAPI('GET', '/classes');
+    context.class = classes.find((c: any) => c.id === className);
+    expect(context.class).toBeDefined();
+    context.classesByName.set(className, context.class);
+  } catch (error: any) {
+    throw new Error(`Class ${className} not found: ${error.message}`);
+  }
+});
+
+Given('Existe um roteiro de ID {string} na turma', async function (scriptId: string) {
+  try {
+    context.script = await fetchAPI('GET', `/scripts/${scriptId}`);
+    expect(context.script).toBeDefined();
+  } catch (error: any) {
+    throw new Error(`Script with ID ${scriptId} not found: ${error.message}`);
+  }
+});
+
+When('O aluno cria um ScriptAnswer para o roteiro', async function () {
+  try {
+    const answer = await fetchAPI('POST', '/scriptanswers', {
+      scriptId: context.script!.id,
+      classId: context.class!.id,
+      studentId: context.student!.cpf
+    });
+    context.scriptAnswer = answer;
+  } catch (error: any) {
+    context.lastError = error;
+  }
+});
+
+Then('O servidor retorna status {string}', async function (statusStr: string) {
+  const status = parseInt(statusStr);
+  expect(context.lastStatusCode).toBe(status);
+});
+
+Then('O ScriptAnswer tem status {string}', async function (expectedStatus: string) {
+  expect(context.lastResponse?.status).toBe(expectedStatus);
+});
+
+Then('O campo {string} contém um timestamp válido', async function (fieldName: string) {
+  const value = context.lastResponse?.[fieldName];
+  expect(typeof value).toBe('number');
+  expect(value).toBeGreaterThan(0);
+});
+
+Then('O campo {string} está vazio', async function (fieldName: string) {
+  const value = context.lastResponse?.[fieldName];
+  // If it's an array, check if empty
+  if (Array.isArray(value)) {
+    expect(value.length).toBe(0);
+  } else {
+    // Otherwise, should be null or undefined
+    expect(value == null).toBe(true);
+  }
+});
+
+// ============================================================
+// Portuguese Scenarios: Start Task Answer
+// ============================================================
+
+Given('O estudante de CPF {string} tem um ScriptAnswer ativo de ID {string}', async function (cpf: string, scriptAnswerId: string) {
+  context.student = context.studentsByCPF.get(cpf) || { cpf };
+  try {
+    context.scriptAnswer = await fetchAPI('GET', `/scriptanswers/${scriptAnswerId}`);
+    expect(context.scriptAnswer.status).toBe('in_progress');
+  } catch (error: any) {
+    throw new Error(`ScriptAnswer ${scriptAnswerId} not found or not in_progress: ${error.message}`);
+  }
+});
+
+Given('A tarefa {string} existe no roteiro', async function (taskId: string) {
+  context.currentTaskId = taskId;
+  // Task existence is verified implicitly when we try to start it
+});
+
+Given('A tarefa ainda não foi iniciada', async function () {
+  // No explicit setup needed
+});
+
+When('O aluno inicia a resposta da tarefa {string}', async function (taskId: string) {
+  context.currentTaskId = taskId;
+  try {
+    const taskAnswer = await fetchAPI('POST', `/scriptanswers/${context.scriptAnswer!.id}/tasks/${taskId}/start`);
+    context.taskAnswer = taskAnswer;
+  } catch (error: any) {
+    context.lastError = error;
+  }
+});
+
+Then('A TaskAnswer tem status {string}', async function (expectedStatus: string) {
+  expect(context.taskAnswer?.status).toBe(expectedStatus);
+});
+
+Then('O campo {string} contém timestamp válido', async function (fieldName: string) {
+  // Try taskAnswer first (for TaskAnswer fields like submitted_at), then lastResponse (for ScriptAnswer fields)
+  const value = context.taskAnswer?.[fieldName] ?? context.lastResponse?.[fieldName];
+  expect(typeof value).toBe('number');
+  expect(value).toBeGreaterThan(0);
+});
+
+// ============================================================
+// Portuguese Scenarios: Submit Task Answer
+// ============================================================
+
+Given('A tarefa {string} foi iniciada', async function (taskId: string) {
+  context.currentTaskId = taskId;
+  try {
+    const updated = await fetchAPI('GET', `/scriptanswers/${context.scriptAnswer!.id}`);
+    context.scriptAnswer = updated;
+    const task = updated.answers.find((a: any) => a.task === taskId);
+    expect(task?.status).toBe('started');
+  } catch (error: any) {
+    throw new Error(`Task ${taskId} not found or not started: ${error.message}`);
+  }
+});
+
+Given('A tarefa não é a última do roteiro', async function () {
+  // Verification happens after submit
+});
+
+Given('A tarefa é a última do roteiro', async function () {
+  // Verification happens after submit
+});
+
+When('O aluno submete a resposta {string} para a tarefa', async function (answer: string) {
+  try {
+    const taskId = context.currentTaskId || 'task-001';
+    const submitted = await fetchAPI('POST', `/scriptanswers/${context.scriptAnswer!.id}/tasks/${taskId}/submit`, { answer });
+    context.taskAnswer = submitted;
+    // Fetch updated ScriptAnswer to check if it's finished
+    context.lastResponse = await fetchAPI('GET', `/scriptanswers/${context.scriptAnswer!.id}`);
+    context.scriptAnswer = context.lastResponse;
+  } catch (error: any) {
+    context.lastError = error;
+  }
+});
+
+Then('O campo {string} é calculado corretamente', async function (fieldName: string) {
+  if (fieldName === 'time_taken_seconds') {
+    // time_taken_seconds is in taskAnswer, not lastResponse
+    expect(typeof context.taskAnswer?.time_taken_seconds).toBe('number');
+    expect(context.taskAnswer?.time_taken_seconds).toBeGreaterThanOrEqual(0);
+  }
+});
+
+Then('O ScriptAnswer continua com status {string}', async function (expectedStatus: string) {
+  const updated = await fetchAPI('GET', `/scriptanswers/${context.scriptAnswer!.id}`);
+  expect(updated.status).toBe(expectedStatus);
+});
+
+Then('O campo {string} do ScriptAnswer contém timestamp válido', async function (fieldName: string) {
+  const updated = await fetchAPI('GET', `/scriptanswers/${context.scriptAnswer!.id}`);
+  const value = updated[fieldName];
+  expect(typeof value).toBe('number');
+  expect(value).toBeGreaterThan(0);
+});
+
+// ============================================================
+// Portuguese Scenarios: Timeout
+// ============================================================
+
+Given('Passaram-se do tempo limite para realizar o roteiro', async function () {
+  // Set a negative timeout so any elapsed time will be greater
+  // This guarantees timeout will trigger regardless of actual elapsed time
+  context.elapsedSeconds = -1;
+});
+
+When('O sistema verifica timeout do ScriptAnswer', async function () {
+  try {
+    const maxTime = context.elapsedSeconds || 3600; //simulando um timeout ultrapassado.
+    const result = await fetchAPI('POST', `/scriptanswers/${context.scriptAnswer!.id}/timeout`, { timeoutSeconds: maxTime });
+    // Extract scriptAnswer from response (endpoint returns { message, scriptAnswer })
+    context.lastResponse = result.scriptAnswer || result;
+    context.scriptAnswer = context.lastResponse;
+  } catch (error: any) {
+    context.lastError = error;
+  }
+});
+
+Then('As tarefas {string} foram marcadas como {string}', async function (originalStatus: string, newStatus: string) {
+  const updated = await fetchAPI('GET', `/scriptanswers/${context.scriptAnswer!.id}`);
+  
+  if (originalStatus === 'started' && newStatus === 'submitted') {
+    // All previously started tasks should now be submitted
+    const stillStarted = updated.answers.filter((a: any) => a.status === 'started');
+    expect(stillStarted.length).toBe(0);
+    
+    const nowSubmitted = updated.answers.filter((a: any) => a.status === 'submitted');
+    expect(nowSubmitted.length).toBeGreaterThan(0);
+  }
+  
+  if (originalStatus === 'pending' && newStatus === 'timed_out') {
+    // All previously pending tasks should now be timed_out
+    const stillPending = updated.answers.filter((a: any) => a.status === 'pending');
+    expect(stillPending.length).toBe(0);
+    
+    const nowTimedOut = updated.answers.filter((a: any) => a.status === 'timed_out');
+    expect(nowTimedOut.length).toBeGreaterThan(0);
+  }
+});
+
+// ============================================================
+// Portuguese Scenarios: Enrollment Failure
+// ============================================================
+
+Given('O aluno NÃO está matriculado na turma {string}', async function (className: string) {
+  // Already handled by not setting the enrollment
+});
+
+When('O aluno tenta criar um ScriptAnswer para o roteiro', async function () {
+  try {
+    await fetchAPI('POST', '/scriptanswers', {
+      scriptId: context.script?.id || 'script-001',
+      classId: context.class?.id || 'Math101-2024-2024',
+      studentId: context.student?.cpf || '99999999999'
+    });
+  } catch (error: any) {
+    context.lastError = error;
+  }
+});
+
+Then('A mensagem de erro indica {string}', async function (expectedMessage: string) {
+  const errorMsg = context.lastError?.message || context.lastResponse?.error || '';
+  expect(errorMsg).toContain(expectedMessage);
+});
+
+// ============================================================
+// Portuguese Scenarios: Duplicate Task Start
+// ============================================================
+
+Given('A tarefa {string} já foi iniciada anteriormente', async function (taskId: string) {
+  context.currentTaskId = taskId;
+  const updated = await fetchAPI('GET', `/scriptanswers/${context.scriptAnswer!.id}`);
+  const task = updated.answers.find((a: any) => a.task === taskId);
+  expect(task?.status).toBe('started');
+});
+
+When('O aluno tenta iniciar novamente a tarefa {string}', async function (taskId: string) {
+  try {
+    await fetchAPI('POST', `/scriptanswers/${context.scriptAnswer!.id}/tasks/${taskId}/start`);
+  } catch (error: any) {
+    context.lastError = error;
+  }
+});
+
+// ============================================================
+// Portuguese Scenarios: Class Script Answers
+// ============================================================
+
+Given('A turma {string} tem {string} alunos com ScriptAnswers', async function (className: string, countStr: string) {
+  const count = parseInt(countStr);
+  try {
+    const classes = await fetchAPI('GET', '/classes');
+    context.class = classes.find((c: any) => c.id === className);
+    expect(context.class).toBeDefined();
+    
+    const answers = await fetchAPI('GET', `/scriptanswers/class/${context.class!.id}`);
+    context.scriptAnswers = answers;
+    expect(answers.length).toBeGreaterThanOrEqual(count);
+  } catch (error: any) {
+    throw new Error(`Failed to fetch class answers: ${error.message}`);
+  }
+});
+
+When('O sistema busca todos os ScriptAnswers da turma', async function () {
+  try {
+    await fetchAPI('GET', `/scriptanswers/class/${context.class!.id}`);
+  } catch (error: any) {
+    context.lastError = error;
+  }
+});
+
+Then('A resposta contém pelo menos {string} ScriptAnswers', async function (countStr: string) {
+  const expectedCount = parseInt(countStr);
+  expect(context.lastResponse).toBeDefined();
+  expect(Array.isArray(context.lastResponse)).toBe(true);
+  expect(context.lastResponse.length).toBeGreaterThanOrEqual(expectedCount);
+});
+
+Then('Todos os ScriptAnswers pertencem à turma correta', async function () {
+  const classId = context.class!.id;
+  for (const answer of context.lastResponse) {
+    expect(answer.classId).toBe(classId);
+  }
+});
+
+// ============================================================
+// Portuguese Scenarios: Enrollment Query
+// ============================================================
+
+Given('Existe uma turma com ID {string}', async function (classId: string) {
+  try {
+    const classes = await fetchAPI('GET', '/classes');
+    context.class = classes.find((c: any) => c.id === classId);
+    expect(context.class).toBeDefined();
+    context.classesByName.set(classId, context.class);
+  } catch (error: any) {
+    throw new Error(`Class ${classId} not found: ${error.message}`);
+  }
+});
+
+Given('Existe um estudante com CPF {string} matriculado na turma {string}', async function (cpf: string, className: string) {
+  // Simply store the student data - backend will verify on endpoint call
+  context.student = { cpf };
+  context.studentsByCPF.set(cpf, context.student);
+});
+
+Given('Este estudante possui ScriptAnswers de IDs {string} na turma {string}', async function (idsString: string, className: string) {
+  const ids = idsString.split(', ').map(id => id.trim());
+  // Store expected IDs for later validation
+  context.expectedScriptAnswerIds = ids;
+});
+
+When('Eu envio uma requisição GET para {string}', async function (endpoint: string) {
+  try {
+    await fetchAPI('GET', endpoint);
+  } catch (error: any) {
+    context.lastError = error;
+  }
+});
+
+Then('O servidor deve retornar uma lista contendo as respostas {string}', async function (idsString: string) {
+  const expectedIds = idsString.split(', ').map(id => id.trim());
+  expect(Array.isArray(context.lastResponse)).toBe(true);
+  
+  const returnedIds = context.lastResponse.map((a: any) => a.id);
+  for (const id of expectedIds) {
+    expect(returnedIds).toContain(id);
+  }
+});
+
+// ============================================================
+// Portuguese Scenarios: Re-submit Failed
+// ============================================================
+
+Given('A tarefa {string} já foi submetida', async function (taskId: string) {
+  context.currentTaskId = taskId;
+  const updated = await fetchAPI('GET', `/scriptanswers/${context.scriptAnswer!.id}`);
+  const task = updated.answers.find((a: any) => a.task === taskId);
+  expect(task?.status).toBe('submitted');
+});
+
+When('O aluno tenta submeter novamente a tarefa {string} com resposta {string}', async function (taskId: string, answer: string) {
+  try {
+    await fetchAPI('POST', `/scriptanswers/${context.scriptAnswer!.id}/tasks/${taskId}/submit`, { answer });
+  } catch (error: any) {
+    context.lastError = error;
+  }
+});
diff --git a/package-lock.json b/package-lock.json
index 81203a01..ec485b75 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -13147,43 +13147,6 @@
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/@emnapi/core": {
-      "version": "1.7.1",
-      "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.7.1.tgz",
-      "integrity": "sha512-o1uhUASyo921r2XtHYOHy7gdkGLge8ghBEQHMWmyJFoXlpU58kIrhhN3w26lpQb6dspetweapMn2CSNwQ8I4wg==",
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "peer": true,
-      "dependencies": {
-        "@emnapi/wasi-threads": "1.1.0",
-        "tslib": "^2.4.0"
-      }
-    },
-    "node_modules/@emnapi/runtime": {
-      "version": "1.7.1",
-      "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.7.1.tgz",
-      "integrity": "sha512-PVtJr5CmLwYAU9PZDMITZoR5iAOShYREoR45EyyLrbntV50mdePTgUn4AmOw90Ifcj+x2kRjdzr1HP3RrNiHGA==",
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "peer": true,
-      "dependencies": {
-        "tslib": "^2.4.0"
-      }
-    },
-    "node_modules/@emnapi/wasi-threads": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@emnapi/wasi-threads/-/wasi-threads-1.1.0.tgz",
-      "integrity": "sha512-WI0DdZ8xFSbgMjR1sFsKABJ/C5OnRrjT06JXbZKexJGrDuPTzZdDYfFlsgcCXCyf+suG5QU2e/y1Wo2V/OapLQ==",
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "peer": true,
-      "dependencies": {
-        "tslib": "^2.4.0"
-      }
-    },
     "node_modules/@isaacs/balanced-match": {
       "version": "4.0.1",
       "resolved": "https://registry.npmjs.org/@isaacs/balanced-match/-/balanced-match-4.0.1.tgz",
@@ -13912,20 +13875,6 @@
         "@jridgewell/sourcemap-codec": "^1.4.10"
       }
     },
-    "node_modules/@napi-rs/wasm-runtime": {
-      "version": "0.2.12",
-      "resolved": "https://registry.npmjs.org/@napi-rs/wasm-runtime/-/wasm-runtime-0.2.12.tgz",
-      "integrity": "sha512-ZVWUcfwY4E/yPitQJl481FjFo3K22D6qF0DuFH6Y/nbnE11GY5uguDxZMGXPQ8WQ0128MXQD7TnfHyK4oWoIJQ==",
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "peer": true,
-      "dependencies": {
-        "@emnapi/core": "^1.4.3",
-        "@emnapi/runtime": "^1.4.3",
-        "@tybys/wasm-util": "^0.10.0"
-      }
-    },
     "node_modules/@noble/hashes": {
       "version": "1.8.0",
       "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.8.0.tgz",
@@ -14156,18 +14105,6 @@
       "devOptional": true,
       "license": "MIT"
     },
-    "node_modules/@tybys/wasm-util": {
-      "version": "0.10.1",
-      "resolved": "https://registry.npmjs.org/@tybys/wasm-util/-/wasm-util-0.10.1.tgz",
-      "integrity": "sha512-9tTaPJLSiejZKx+Bmog4uSubteqTvFrVrURwkmHixBo0G4seD0zUxp98E1DzUBJxLQ3NPwXrGKDiVjwx/DpPsg==",
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "peer": true,
-      "dependencies": {
-        "tslib": "^2.4.0"
-      }
-    },
     "node_modules/@types/aria-query": {
       "version": "5.0.4",
       "resolved": "https://registry.npmjs.org/@types/aria-query/-/aria-query-5.0.4.tgz",
@@ -14504,294 +14441,6 @@
       "integrity": "sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g==",
       "license": "ISC"
     },
-    "node_modules/@unrs/resolver-binding-android-arm-eabi": {
-      "version": "1.11.1",
-      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-android-arm-eabi/-/resolver-binding-android-arm-eabi-1.11.1.tgz",
-      "integrity": "sha512-ppLRUgHVaGRWUx0R0Ut06Mjo9gBaBkg3v/8AxusGLhsIotbBLuRk51rAzqLC8gq6NyyAojEXglNjzf6R948DNw==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "peer": true
-    },
-    "node_modules/@unrs/resolver-binding-android-arm64": {
-      "version": "1.11.1",
-      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-android-arm64/-/resolver-binding-android-arm64-1.11.1.tgz",
-      "integrity": "sha512-lCxkVtb4wp1v+EoN+HjIG9cIIzPkX5OtM03pQYkG+U5O/wL53LC4QbIeazgiKqluGeVEeBlZahHalCaBvU1a2g==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "peer": true
-    },
-    "node_modules/@unrs/resolver-binding-darwin-arm64": {
-      "version": "1.11.1",
-      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-darwin-arm64/-/resolver-binding-darwin-arm64-1.11.1.tgz",
-      "integrity": "sha512-gPVA1UjRu1Y/IsB/dQEsp2V1pm44Of6+LWvbLc9SDk1c2KhhDRDBUkQCYVWe6f26uJb3fOK8saWMgtX8IrMk3g==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "peer": true
-    },
-    "node_modules/@unrs/resolver-binding-darwin-x64": {
-      "version": "1.11.1",
-      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-darwin-x64/-/resolver-binding-darwin-x64-1.11.1.tgz",
-      "integrity": "sha512-cFzP7rWKd3lZaCsDze07QX1SC24lO8mPty9vdP+YVa3MGdVgPmFc59317b2ioXtgCMKGiCLxJ4HQs62oz6GfRQ==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "peer": true
-    },
-    "node_modules/@unrs/resolver-binding-freebsd-x64": {
-      "version": "1.11.1",
-      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-freebsd-x64/-/resolver-binding-freebsd-x64-1.11.1.tgz",
-      "integrity": "sha512-fqtGgak3zX4DCB6PFpsH5+Kmt/8CIi4Bry4rb1ho6Av2QHTREM+47y282Uqiu3ZRF5IQioJQ5qWRV6jduA+iGw==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
-      "peer": true
-    },
-    "node_modules/@unrs/resolver-binding-linux-arm-gnueabihf": {
-      "version": "1.11.1",
-      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-linux-arm-gnueabihf/-/resolver-binding-linux-arm-gnueabihf-1.11.1.tgz",
-      "integrity": "sha512-u92mvlcYtp9MRKmP+ZvMmtPN34+/3lMHlyMj7wXJDeXxuM0Vgzz0+PPJNsro1m3IZPYChIkn944wW8TYgGKFHw==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "peer": true
-    },
-    "node_modules/@unrs/resolver-binding-linux-arm-musleabihf": {
-      "version": "1.11.1",
-      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-linux-arm-musleabihf/-/resolver-binding-linux-arm-musleabihf-1.11.1.tgz",
-      "integrity": "sha512-cINaoY2z7LVCrfHkIcmvj7osTOtm6VVT16b5oQdS4beibX2SYBwgYLmqhBjA1t51CarSaBuX5YNsWLjsqfW5Cw==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "peer": true
-    },
-    "node_modules/@unrs/resolver-binding-linux-arm64-gnu": {
-      "version": "1.11.1",
-      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-linux-arm64-gnu/-/resolver-binding-linux-arm64-gnu-1.11.1.tgz",
-      "integrity": "sha512-34gw7PjDGB9JgePJEmhEqBhWvCiiWCuXsL9hYphDF7crW7UgI05gyBAi6MF58uGcMOiOqSJ2ybEeCvHcq0BCmQ==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "peer": true
-    },
-    "node_modules/@unrs/resolver-binding-linux-arm64-musl": {
-      "version": "1.11.1",
-      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-linux-arm64-musl/-/resolver-binding-linux-arm64-musl-1.11.1.tgz",
-      "integrity": "sha512-RyMIx6Uf53hhOtJDIamSbTskA99sPHS96wxVE/bJtePJJtpdKGXO1wY90oRdXuYOGOTuqjT8ACccMc4K6QmT3w==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "peer": true
-    },
-    "node_modules/@unrs/resolver-binding-linux-ppc64-gnu": {
-      "version": "1.11.1",
-      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-linux-ppc64-gnu/-/resolver-binding-linux-ppc64-gnu-1.11.1.tgz",
-      "integrity": "sha512-D8Vae74A4/a+mZH0FbOkFJL9DSK2R6TFPC9M+jCWYia/q2einCubX10pecpDiTmkJVUH+y8K3BZClycD8nCShA==",
-      "cpu": [
-        "ppc64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "peer": true
-    },
-    "node_modules/@unrs/resolver-binding-linux-riscv64-gnu": {
-      "version": "1.11.1",
-      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-linux-riscv64-gnu/-/resolver-binding-linux-riscv64-gnu-1.11.1.tgz",
-      "integrity": "sha512-frxL4OrzOWVVsOc96+V3aqTIQl1O2TjgExV4EKgRY09AJ9leZpEg8Ak9phadbuX0BA4k8U5qtvMSQQGGmaJqcQ==",
-      "cpu": [
-        "riscv64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "peer": true
-    },
-    "node_modules/@unrs/resolver-binding-linux-riscv64-musl": {
-      "version": "1.11.1",
-      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-linux-riscv64-musl/-/resolver-binding-linux-riscv64-musl-1.11.1.tgz",
-      "integrity": "sha512-mJ5vuDaIZ+l/acv01sHoXfpnyrNKOk/3aDoEdLO/Xtn9HuZlDD6jKxHlkN8ZhWyLJsRBxfv9GYM2utQ1SChKew==",
-      "cpu": [
-        "riscv64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "peer": true
-    },
-    "node_modules/@unrs/resolver-binding-linux-s390x-gnu": {
-      "version": "1.11.1",
-      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-linux-s390x-gnu/-/resolver-binding-linux-s390x-gnu-1.11.1.tgz",
-      "integrity": "sha512-kELo8ebBVtb9sA7rMe1Cph4QHreByhaZ2QEADd9NzIQsYNQpt9UkM9iqr2lhGr5afh885d/cB5QeTXSbZHTYPg==",
-      "cpu": [
-        "s390x"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "peer": true
-    },
-    "node_modules/@unrs/resolver-binding-linux-x64-gnu": {
-      "version": "1.11.1",
-      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-linux-x64-gnu/-/resolver-binding-linux-x64-gnu-1.11.1.tgz",
-      "integrity": "sha512-C3ZAHugKgovV5YvAMsxhq0gtXuwESUKc5MhEtjBpLoHPLYM+iuwSj3lflFwK3DPm68660rZ7G8BMcwSro7hD5w==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "peer": true
-    },
-    "node_modules/@unrs/resolver-binding-linux-x64-musl": {
-      "version": "1.11.1",
-      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-linux-x64-musl/-/resolver-binding-linux-x64-musl-1.11.1.tgz",
-      "integrity": "sha512-rV0YSoyhK2nZ4vEswT/QwqzqQXw5I6CjoaYMOX0TqBlWhojUf8P94mvI7nuJTeaCkkds3QE4+zS8Ko+GdXuZtA==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "peer": true
-    },
-    "node_modules/@unrs/resolver-binding-wasm32-wasi": {
-      "version": "1.11.1",
-      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-wasm32-wasi/-/resolver-binding-wasm32-wasi-1.11.1.tgz",
-      "integrity": "sha512-5u4RkfxJm+Ng7IWgkzi3qrFOvLvQYnPBmjmZQ8+szTK/b31fQCnleNl1GgEt7nIsZRIf5PLhPwT0WM+q45x/UQ==",
-      "cpu": [
-        "wasm32"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "peer": true,
-      "dependencies": {
-        "@napi-rs/wasm-runtime": "^0.2.11"
-      },
-      "engines": {
-        "node": ">=14.0.0"
-      }
-    },
-    "node_modules/@unrs/resolver-binding-win32-arm64-msvc": {
-      "version": "1.11.1",
-      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-win32-arm64-msvc/-/resolver-binding-win32-arm64-msvc-1.11.1.tgz",
-      "integrity": "sha512-nRcz5Il4ln0kMhfL8S3hLkxI85BXs3o8EYoattsJNdsX4YUU89iOkVn7g0VHSRxFuVMdM4Q1jEpIId1Ihim/Uw==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "peer": true
-    },
-    "node_modules/@unrs/resolver-binding-win32-ia32-msvc": {
-      "version": "1.11.1",
-      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-win32-ia32-msvc/-/resolver-binding-win32-ia32-msvc-1.11.1.tgz",
-      "integrity": "sha512-DCEI6t5i1NmAZp6pFonpD5m7i6aFrpofcp4LA2i8IIq60Jyo28hamKBxNrZcyOwVOZkgsRp9O2sXWBWP8MnvIQ==",
-      "cpu": [
-        "ia32"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "peer": true
-    },
-    "node_modules/@unrs/resolver-binding-win32-x64-msvc": {
-      "version": "1.11.1",
-      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-win32-x64-msvc/-/resolver-binding-win32-x64-msvc-1.11.1.tgz",
-      "integrity": "sha512-lrW200hZdbfRtztbygyaq/6jP6AKE8qQN2KvPcJ+x7wiD038YtnYtZ82IMNJ69GJibV7bwL3y9FgK+5w/pYt6g==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "peer": true
-    },
     "node_modules/acorn": {
       "version": "8.15.0",
       "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz",
diff --git a/server/package-lock.json b/server/package-lock.json
index 0bb93186..f63df85d 100644
--- a/server/package-lock.json
+++ b/server/package-lock.json
@@ -58,7 +58,6 @@
       "integrity": "sha512-e7jT4DxYvIDLk1ZHmU/m/mB19rex9sv0c2ftBtjSBv+kVM/902eh0fINUzD7UwLLNR+jU585GxUJ8/EBfAM5fw==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@babel/code-frame": "^7.27.1",
         "@babel/generator": "^7.28.5",
@@ -1566,7 +1565,6 @@
       "integrity": "sha512-FE5u0ezmi6y9OZEzlJfg37mqqf6ZDSF2V/NLjUyGrR9uTZ7Sb9F7bLNZ03S4XVUNRWGA7Ck4c1kK+YnuWjl+DA==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "undici-types": "~6.21.0"
       }
@@ -2291,7 +2289,6 @@
         }
       ],
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "baseline-browser-mapping": "^2.8.25",
         "caniuse-lite": "^1.0.30001754",
@@ -3795,7 +3792,6 @@
       "integrity": "sha512-F26gjC0yWN8uAA5m5Ss8ZQf5nDHWGlN/xWZIh8S5SRbsEKBovwZhxGd6LJlbZYxBgCYOtreSUyb8hpXyGC5O4A==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@jest/core": "30.2.0",
         "@jest/types": "30.2.0",
@@ -6017,7 +6013,6 @@
       "integrity": "sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@cspotcode/source-map-support": "^0.8.0",
         "@tsconfig/node10": "^1.0.7",
@@ -6160,7 +6155,6 @@
       "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
       "dev": true,
       "license": "Apache-2.0",
-      "peer": true,
       "bin": {
         "tsc": "bin/tsc",
         "tsserver": "bin/tsserver"
diff --git a/server/src/mock_scripts.ts b/server/src/mock_scripts.ts
index 84e7c5be..c623b664 100644
--- a/server/src/mock_scripts.ts
+++ b/server/src/mock_scripts.ts
@@ -8,6 +8,7 @@ import { Classes } from './models/Classes';
 import { Class } from './models/Class';
 import { StudentSet } from './models/StudentSet';
 import { Student } from './models/Student';
+import { ScriptAnswer } from './models/ScriptAnswer';
 import { DEFAULT_ESPECIFICACAO_DO_CALCULO_DA_MEDIA } from './models/EspecificacaoDoCalculoDaMedia';
 
 export function loadMockScriptsAndAnswers(
@@ -20,21 +21,55 @@ export function loadMockScriptsAndAnswers(
 ): void {
   
   try {
+    console.log('=== Starting Mock Data Load ===');
+    
     // Create mock student if not exists
     let student = studentSet.findStudentByCPF(studentCPF);
     if (!student) {
       student = new Student('João Silva', studentCPF, 'joao@example.com');
       studentSet.addStudent(student);
-      console.log('Mock student created:', studentCPF);
+      console.log('✓ Mock student created:', studentCPF);
+    } else {
+      console.log('✓ Mock student already exists:', studentCPF);
     }
+    
+    // Create second mock student (not enrolled in class)
+    let student2 = studentSet.findStudentByCPF('99999999999');
+    if (!student2) {
+      student2 = new Student('Maria Santos', '99999999999', 'maria@example.com');
+      studentSet.addStudent(student2);
+      console.log('Mock student 2 created:', '99999999999');
+    }
+
+    // Create third mock student for enrollment query test
+    let student3 = studentSet.findStudentByCPF('12345678901');
+    if (!student3) {
+      student3 = new Student('Pedro Oliveira', '12345678901', 'pedro@example.com');
+      studentSet.addStudent(student3);
+      console.log('Mock student 3 created:', '12345678901');
+    }
+    
     // Create mock class if not exists
-    let classe = classes.findClassById('Math 101-2024-2024');
+    let classe = classes.findClassById('Math101-2024-2024');
     if (!classe) {
-      classe = new Class('Math 101', 2024, 2024, DEFAULT_ESPECIFICACAO_DO_CALCULO_DA_MEDIA);
+      classe = new Class('Math101', 2024, 2024, DEFAULT_ESPECIFICACAO_DO_CALCULO_DA_MEDIA);
       classes.addClass(classe);
-      // Enroll student in class
+      console.log('✓ Mock class created:', classe.getClassId());
+    } else {
+      console.log('✓ Mock class already exists:', classe.getClassId());
+    }
+    
+    // Always ensure both students are enrolled
+    const isStudent1Enrolled = classe.getEnrollments().some(e => e.getStudent().getCPF() === student.getCPF());
+    if (!isStudent1Enrolled) {
       classe.addEnrollment(student);
-      console.log('Mock class created:', classe.getClassId());
+      console.log('✓ Student 1 enrolled:', student.getCPF());
+    }
+    
+    const isStudent3Enrolled = classe.getEnrollments().some(e => e.getStudent().getCPF() === student3.getCPF());
+    if (!isStudent3Enrolled) {
+      classe.addEnrollment(student3);
+      console.log('✓ Student 3 enrolled:', student3.getCPF());
     }
     // Create mock tasks if none exist
     if (taskset.getAllTasks().length === 0) {
@@ -80,110 +115,140 @@ export function loadMockScriptsAndAnswers(
       console.log('Mock scripts created:', [script1.getId(), script2.getId(), script3.getId(), script4.getId()]);
     }
 
-    // Create mock script answers if none exist
-    if (scriptAnswerSet.getAll().length === 0) {
-      const answer1 = scriptAnswerSet.addScriptAnswer({
-        id: 'answer-001',
-        scriptId: 'script-001',
-        classId: 'Math 101-2024-2024',
+    // === Test data for individual scenarios ===
+    // These are ALWAYS verified/created to ensure test isolation works properly
+    console.log('📝 Creating scenario-specific test data...');
+
+    // In-progress script answer for "Start task" scenario (scriptanswer-start) - NO tasks yet
+    const existingStart = scriptAnswerSet.findById('scriptanswer-start');
+    if (!existingStart) {
+      scriptAnswerSet.addScriptAnswer({
+        id: 'scriptanswer-start',
+        scriptId: 'script-002',
+        classId: 'Math101-2024-2024',
+        studentId: studentCPF,
+        taskAnswers: [],
+        status: 'in_progress',
+        started_at: Date.now()
+      }, classes, studentSet, scripts);
+      console.log('✓ scriptanswer-start created');
+    }
+
+    // In-progress script answer for "Submit non-final task" scenario (scriptanswer-submit-nonfinal)
+    const existingSubmitNonFinal = scriptAnswerSet.findById('scriptanswer-submit-nonfinal');
+    if (!existingSubmitNonFinal) {
+      scriptAnswerSet.addScriptAnswer({
+        id: 'scriptanswer-submit-nonfinal',
+        scriptId: 'script-002',
+        classId: 'Math101-2024-2024',
         studentId: studentCPF,
         taskAnswers: [
-          new TaskAnswer(
-            'ta-001',
-            'task-001',
-            'The basic concepts are fundamental to understanding the subject matter.',
-            'MA',
-            'Excellent explanation with clear examples'
-          ),
-          new TaskAnswer(
-            'ta-002',
-            'task-002',
-            'Here is my implementation of the algorithm using a recursive approach...',
-            'MPA',
-            'Good attempt, but missing edge cases'
-          ),
-          new TaskAnswer(
-            'ta-003',
-            'task-003',
-            'My analysis shows that the time complexity is O(n log n).',
-            'MA',
-            'Well-reasoned analysis with proper mathematical justification'
-          )
+          new TaskAnswer('ta-nf-001', 'task-001', '', undefined, '', Date.now(), undefined, undefined, 'started')
         ],
-        grade: 'MA'
-      },classes, studentSet, scripts);
+        status: 'in_progress',
+        started_at: Date.now()
+      }, classes, studentSet, scripts);
+      console.log('✓ scriptanswer-submit-nonfinal created');
+    }
 
-      const answer2 = scriptAnswerSet.addScriptAnswer({
-        id: 'answer-002',
+    // In-progress script answer for "Submit final task" scenario (scriptanswer-submit-final)
+    const existingSubmitFinal = scriptAnswerSet.findById('scriptanswer-submit-final');
+    if (!existingSubmitFinal) {
+      scriptAnswerSet.addScriptAnswer({
+        id: 'scriptanswer-submit-final',
         scriptId: 'script-002',
-        classId: 'Math 101-2024-2024',
+        classId: 'Math101-2024-2024',
         studentId: studentCPF,
         taskAnswers: [
-          new TaskAnswer(
-            'ta-004',
-            'task-001',
-            'Building on previous knowledge, the concepts form the foundation...',
-            'MA',
-            'Excellent continuation of understanding'
-          ),
-          new TaskAnswer(
-            'ta-005',
-            'task-002',
-            'The implementation demonstrates proper use of design patterns.',
-            'MA',
-            'Clean code with good structure'
-          ),
-          new TaskAnswer(
-            'ta-006',
-            'task-003',
-            'Critical analysis reveals that the solution handles all edge cases effectively.',
-            'MA',
-            'Thorough and insightful analysis'
-          )
+          new TaskAnswer('ta-f-001', 'task-001', 'Already submitted', 'MA', '', Date.now() - 10000, Date.now() - 9000, 1, 'submitted'),
+          new TaskAnswer('ta-f-002', 'task-002', 'Already submitted', 'MA', '', Date.now() - 8000, Date.now() - 7000, 1, 'submitted'),
+          new TaskAnswer('ta-f-003', 'task-003', '', undefined, '', Date.now(), undefined, undefined, 'started')
         ],
-        grade: 'MA'
-      },classes, studentSet, scripts);
-      const answer3 = scriptAnswerSet.addScriptAnswer({
-        id: 'answer-003',
+        status: 'in_progress',
+        started_at: Date.now()
+      }, classes, studentSet, scripts);
+      console.log('✓ scriptanswer-submit-final created');
+    }
+
+    // In-progress script answer for timeout test (scriptanswer-timeout)
+    // Started 2 hours ago so timeout of 3700 seconds (1h+ 2min) would trigger
+    const existingTimeout = scriptAnswerSet.findById('scriptanswer-timeout');
+    if (!existingTimeout) {
+      const twoHoursAgo = Date.now() - 7200000;
+      scriptAnswerSet.addScriptAnswer({
+        id: 'scriptanswer-timeout',
         scriptId: 'script-003',
-        classId: 'Math 101-2024-2024',
+        classId: 'Math101-2024-2024',
         studentId: studentCPF,
         taskAnswers: [
-          new TaskAnswer(
-            'ta-007',
-            'task-002',
-            'My implementation uses a basic loop structure.',
-            'MPA',
-            'Works correctly but could be optimized'
-          ),
-          new TaskAnswer(
-            'ta-008',
-            'task-003',
-            'The solution works but could be optimized.',
-            'MPA',
-            'Shows understanding but optimization potential missed'
-          )
-        ]
-      },classes, studentSet, scripts);
-      const answer4 = scriptAnswerSet.addScriptAnswer({
-        id: 'answer-004',
+          new TaskAnswer('ta-t-001', 'task-001', '', undefined, '', twoHoursAgo, undefined, undefined, 'started'),
+          new TaskAnswer('ta-t-002', 'task-002', '', undefined, '', twoHoursAgo, undefined, undefined, 'started'),
+          new TaskAnswer('ta-t-003', 'task-003', '', undefined, '', undefined, undefined, undefined, 'pending')
+        ],
+        status: 'in_progress',
+        started_at: twoHoursAgo
+      }, classes, studentSet, scripts);
+      console.log('✓ scriptanswer-timeout created');
+    }
+
+    // In-progress script answer for "Re-submit failure" scenario (script-002)
+    const existingResubmitFail = scriptAnswerSet.findById('scriptanswer-resubmit-fail');
+    if (!existingResubmitFail) {
+      scriptAnswerSet.addScriptAnswer({
+        id: 'scriptanswer-resubmit-fail',
         scriptId: 'script-004',
-        classId: 'Math 101-2024-2024',
+        classId: 'Math101-2024-2024',
         studentId: studentCPF,
         taskAnswers: [
-          new TaskAnswer(
-            'ta-009',
-            'task-002',
-            'My implementation uses a basic loop structure.',
-            'MPA',
-            'Works correctly but could be optimized'
-          )
+          new TaskAnswer('ta-rsf-001', 'task-001', 'Already submitted', 'MA', '', Date.now(), Date.now(), 0, 'submitted')
+        ],
+        status: 'in_progress',
+        started_at: Date.now()
+      }, classes, studentSet, scripts);
+      console.log('✓ scriptanswer-resubmit-fail created');
+    }
+
+    console.log('Mock script answers created: [scenario-specific test data]');
+
+    // === ALWAYS CREATE/CHECK ENROLLMENT ANSWERS (outside the if block) ===
+    // These are checked independently to ensure they exist regardless of other ScriptAnswers
+    console.log('📝 Creating enrollment answers for student 12345678901...');
+    
+    // Check if enrollment-001 exists, if not create it
+    const existingEnrollment1 = scriptAnswerSet.findById('enrollment-001');
+    if (!existingEnrollment1) {
+      scriptAnswerSet.addScriptAnswer({
+        id: 'enrollment-001',
+        scriptId: 'script-001',
+        classId: 'Math101-2024-2024',
+        studentId: '12345678901',
+        taskAnswers: [
+          new TaskAnswer('ta-enroll-001', 'task-001', 'Test response for enrollment query', 'MA', '')
         ]
-      },classes, studentSet, scripts);
+      }, classes, studentSet, scripts);
+      console.log('✓ enrollment-001 created');
+    } else {
+      console.log('✓ enrollment-001 already exists');
+    }
 
-      console.log('Mock script answers created:', [answer1.getId(), answer2.getId(), answer3.getId(), answer4.getId()]);
+    // Check if enrollment-002 exists, if not create it
+    const existingEnrollment2 = scriptAnswerSet.findById('enrollment-002');
+    if (!existingEnrollment2) {
+      scriptAnswerSet.addScriptAnswer({
+        id: 'enrollment-002',
+        scriptId: 'script-002',
+        classId: 'Math101-2024-2024',
+        studentId: '12345678901',
+        taskAnswers: [
+          new TaskAnswer('ta-enroll-002', 'task-001', 'Another test response', 'MPA', '')
+        ]
+      }, classes, studentSet, scripts);
+      console.log('✓ enrollment-002 created');
+    } else {
+      console.log('✓ enrollment-002 already exists');
     }
   } catch (error) {
-    console.error('Error loading mock scripts and answers:', error);
+    console.error('❌ Error loading mock scripts and answers:', error);
   }
+  console.log('=== Mock Data Load Complete ===');
 }
\ No newline at end of file
diff --git a/server/src/models/ScriptAnswer.ts b/server/src/models/ScriptAnswer.ts
index 7bb9b028..dffb3f2a 100644
--- a/server/src/models/ScriptAnswer.ts
+++ b/server/src/models/ScriptAnswer.ts
@@ -129,7 +129,7 @@ export class ScriptAnswer {
     this.status = 'finished';
   }
 
-  checkAndMarkIfTimedOut(timeoutSeconds: number = 3600) {
+  checkAndMarkIfTimedOut(timeoutSeconds: number) {
     if (this.status === 'finished') return; // já finalizou
     const elapsed = (Date.now() - (this.started_at || 0)) / 1000;
     if (elapsed > timeoutSeconds) {
diff --git a/server/src/server_routes/scriptanswer.ts b/server/src/server_routes/scriptanswer.ts
index c48281e6..46f871b0 100644
--- a/server/src/server_routes/scriptanswer.ts
+++ b/server/src/server_routes/scriptanswer.ts
@@ -47,21 +47,28 @@ export function setupScriptAnswerRoutes(app: Express, scriptAnswerSet: any, stud
   });
 
   // GET /api/scriptanswers/enrollment?classId=X&studentId=Y  → Answers for a enrollment (student in class)
-  app.get(scriptAnswerurl+'enrollment', (req: Request, res: Response) => {
-    const { classId, studentId } = req.query; //retorna tipo generico (especificar tipo depois)
+  app.get('/api/scriptanswers/enrollment', (req: Request, res: Response) => {
+    const { classId, studentId } = req.query;
+    
     if (!classId || !studentId) {
       return res.status(400).json({ error: 'classId and studentId are required' });
     }
-    const classe = classes.findClassById(classId as string);
+    
+    const classIdStr = classId as string;
+    const studentIdStr = studentId as string;
+    
+    const classe = classes.findClassById(classIdStr);
     if (!classe) {
       return res.status(404).json({ error: 'Class not found' });
     }
-    const student = studentSet.findStudentByCPF(studentId as string);
+    
+    const cleanedStudentId = studentIdStr.replace(/[.-]/g, '');
+    const student = studentSet.findStudentByCPF(cleanedStudentId);
     if (!student) {
       return res.status(404).json({ error: 'Student not found' });
     }
 
-    const answers = scriptAnswerSet.findByClassAndStudent(classId as string, studentId as string);
+    const answers = scriptAnswerSet.findByClassAndStudent(classIdStr, cleanedStudentId);
     return res.status(200).json(answers.map((a: any) => a.toJSON()));
   });
 
@@ -94,20 +101,8 @@ export function setupScriptAnswerRoutes(app: Express, scriptAnswerSet: any, stud
     return res.status(200).json({ taskId, grade: task.getGrade() });
   });
 
-  // POST /api/scriptanswers → create a scriptanswer (obsoleto)
-
-  // app.post(scriptAnswerurl+'', (req: Request, res: Response) => {
-  //   try {
-  //     const newAnswer = scriptAnswerSet.addScriptAnswer(req.body);
-  //     res.status(201).json(newAnswer.toJSON());
-  //   } catch (error) {
-  //     res.status(400).json({ error: (error as Error).message });
-  //   }
-  // });
-
   // POST /api/scriptanswers → create a script answer
-
-app.post(scriptAnswerurl+'', (req: Request, res: Response) => {
+  app.post(scriptAnswerurl+'', (req: Request, res: Response) => {
   try {
     const { id, scriptId, classId, studentId } = req.body;
     if (!scriptId || !classId || !studentId) {
@@ -115,21 +110,23 @@ app.post(scriptAnswerurl+'', (req: Request, res: Response) => {
     }
     const script = scripts.findById(scriptId);
     if (!script) {
-      return res.status(404).json({ error: 'Script not found' });
+      return res.status(401).json({ error: 'Script not found' });
     }
     const classe = classes.findClassById(classId);
     if (!classe) {
-      return res.status(404).json({ error: 'Class not found' });
+      return res.status(401).json({ error: 'Class not found' });
     }
-    const student = studentSet.findStudentByCPF(studentId);
+    // Clean CPF before searching
+    const cleanedStudentId = studentId.replace(/[.-]/g, '');
+    const student = studentSet.findStudentByCPF(cleanedStudentId);
     if (!student) {
-      return res.status(404).json({ error: 'Student not found' });
+      return res.status(401).json({ error: 'Student not found' });
     }
-    const enrollment = classe.findEnrollmentByStudentCPF(studentId);
+    const enrollment = classe.findEnrollmentByStudentCPF(cleanedStudentId);
     if (!enrollment) {
       return res.status(403).json({ error: 'Student is not enrolled in this class' });
     }
-    const existing = scriptAnswerSet.findByClassAndStudent(classId, studentId).find((sa: any) => sa.getScriptId() === scriptId);
+    const existing = scriptAnswerSet.findByClassAndStudent(classId, cleanedStudentId).find((sa: any) => sa.getScriptId() === scriptId);
     if (existing) {
       return res.status(409).json({ 
         error: 'ScriptAnswer already exists',
@@ -140,7 +137,7 @@ app.post(scriptAnswerurl+'', (req: Request, res: Response) => {
       id,
       scriptId,
       classId,
-      studentId,
+      studentId: cleanedStudentId,
       classes, studentSet, scripts
     });
     saveCallback?.();

From 47917e51ac70d05ac5c470a75afbe8c27c3e5d4c Mon Sep 17 00:00:00 2001
From: Davi Guerreiro <daviguerreiro9a@gmail.com>
Date: Wed, 10 Dec 2025 07:43:09 -0300
Subject: [PATCH 090/102] feat(scripAnswer): Adding fornt-end implementation

---
 client/src/App.tsx                            | 107 +++++++-
 .../ActiveScriptAnswer.tsx                    | 222 ++++++++++++++++
 .../AvailableScriptsList.tsx                  | 101 +++++++
 .../StudentScriptAnswerPage.tsx               | 109 ++++++++
 .../StudentScriptAnswer/TaskAnswerForm.tsx    | 251 ++++++++++++++++++
 client/src/services/ScriptAnswerService.ts    |  10 +-
 6 files changed, 797 insertions(+), 3 deletions(-)
 create mode 100644 client/src/components/StudentScriptAnswer/ActiveScriptAnswer.tsx
 create mode 100644 client/src/components/StudentScriptAnswer/AvailableScriptsList.tsx
 create mode 100644 client/src/components/StudentScriptAnswer/StudentScriptAnswerPage.tsx
 create mode 100644 client/src/components/StudentScriptAnswer/TaskAnswerForm.tsx

diff --git a/client/src/App.tsx b/client/src/App.tsx
index 8f252d6f..433d815e 100644
--- a/client/src/App.tsx
+++ b/client/src/App.tsx
@@ -6,17 +6,19 @@ import ScriptsPage from './components/scripts/ScriptsPage';
 import GradingPage from './components/ScriptGrading/GradingPage'
 import StudentForm from './components/StudentForm';
 import StudentList from './components/StudentList';
+import StudentScriptAnswerPage from './components/StudentScriptAnswer/StudentScriptAnswerPage';
 import ClassService from './services/ClassService';
 import { studentService } from './services/StudentService';
 import { Class } from './types/Class';
 import { Student } from './types/Student';
 
-type TabType = 'students' | 'evaluations' | 'classes' | 'scripts' | 'Script Grading';
+type TabType = 'students' | 'evaluations' | 'classes' | 'scripts' | 'Script Grading' | 'answer-scripts';
 
 const App: React.FC = () => {
   const [students, setStudents] = useState<Student[]>([]);
   const [classes, setClasses] = useState<Class[]>([]);
   const [selectedClass, setSelectedClass] = useState<Class | null>(null);
+  const [selectedStudent, setSelectedStudent] = useState<Student | null>(null);
   const [loading, setLoading] = useState<boolean>(true);
   const [error, setError] = useState<string>('');
   const [editingStudent, setEditingStudent] = useState<Student | null>(null);
@@ -160,6 +162,12 @@ const App: React.FC = () => {
           >
             Script Grading
           </button>
+          <button
+            className={`tab-button ${activeTab === 'answer-scripts' ? 'active' : ''}`}
+            onClick={() => setActiveTab('answer-scripts')}
+          >
+            Answer Scripts
+          </button>
         </div>
 
         {/* Tab Content */}
@@ -237,6 +245,103 @@ const App: React.FC = () => {
           {activeTab == 'Script Grading' && (
             <GradingPage onError={handleError} />
           )}
+
+          {activeTab === 'answer-scripts' && (
+            <>
+              {/* Student and Class Selection */}
+              <div style={{ 
+                display: 'flex', 
+                gap: '20px', 
+                marginBottom: '20px',
+                padding: '20px',
+                background: 'linear-gradient(135deg, #667eea 0%, #764ba2 100%)',
+                borderRadius: '10px',
+                color: 'white'
+              }}>
+                <div style={{ flex: 1 }}>
+                  <label htmlFor="student-select" style={{ display: 'block', marginBottom: '8px', fontWeight: 'bold' }}>
+                    Select Student:
+                  </label>
+                  <select
+                    id="student-select"
+                    value={selectedStudent?.cpf || ''}
+                    onChange={(e) => {
+                      const student = students.find(s => s.cpf === e.target.value);
+                      setSelectedStudent(student || null);
+                    }}
+                    style={{
+                      width: '100%',
+                      padding: '10px',
+                      borderRadius: '5px',
+                      border: 'none',
+                      fontSize: '16px'
+                    }}
+                  >
+                    <option value="">-- Choose a student --</option>
+                    {students.map((student) => (
+                      <option key={student.cpf} value={student.cpf}>
+                        {student.name} ({student.cpf})
+                      </option>
+                    ))}
+                  </select>
+                </div>
+
+                <div style={{ flex: 1 }}>
+                  <label htmlFor="class-select-answer" style={{ display: 'block', marginBottom: '8px', fontWeight: 'bold' }}>
+                    Select Class:
+                  </label>
+                  <select
+                    id="class-select-answer"
+                    value={selectedClass ? `${selectedClass.topic}-${selectedClass.year}-${selectedClass.semester}` : ''}
+                    onChange={(e) => {
+                      const classId = e.target.value;
+                      if (classId) {
+                        const classObj = classes.find(c => `${c.topic}-${c.year}-${c.semester}` === classId);
+                        setSelectedClass(classObj || null);
+                      } else {
+                        setSelectedClass(null);
+                      }
+                    }}
+                    style={{
+                      width: '100%',
+                      padding: '10px',
+                      borderRadius: '5px',
+                      border: 'none',
+                      fontSize: '16px'
+                    }}
+                  >
+                    <option value="">-- Choose a class --</option>
+                    {classes.map((classObj) => (
+                      <option 
+                        key={`${classObj.topic}-${classObj.year}-${classObj.semester}`}
+                        value={`${classObj.topic}-${classObj.year}-${classObj.semester}`}
+                      >
+                        {classObj.topic} ({classObj.year}/{classObj.semester})
+                      </option>
+                    ))}
+                  </select>
+                </div>
+              </div>
+
+              {/* Answer Scripts Interface */}
+              {selectedStudent && selectedClass ? (
+                <StudentScriptAnswerPage
+                  studentCPF={selectedStudent.cpf}
+                  classId={`${selectedClass.topic}-${selectedClass.year}-${selectedClass.semester}`}
+                  onError={handleError}
+                />
+              ) : (
+                <div style={{
+                  padding: '40px',
+                  textAlign: 'center',
+                  fontSize: '18px',
+                  color: '#666'
+                }}>
+                  Please select both a student and a class to begin answering scripts.
+                </div>
+              )}
+            </>
+          )}
         </div>
       </main>
     </div>
diff --git a/client/src/components/StudentScriptAnswer/ActiveScriptAnswer.tsx b/client/src/components/StudentScriptAnswer/ActiveScriptAnswer.tsx
new file mode 100644
index 00000000..9cb51783
--- /dev/null
+++ b/client/src/components/StudentScriptAnswer/ActiveScriptAnswer.tsx
@@ -0,0 +1,222 @@
+// ActiveScriptAnswer.tsx
+import React, { useState, useEffect } from 'react';
+import { ScriptAnswer, TaskAnswer } from '../../types/ScriptAnswer';
+import { Script } from '../../types/Script';
+import { Task } from '../../types/Task';
+import ScriptService from '../../services/ScriptService';
+import { ScriptAnswerService } from '../../services/ScriptAnswerService';
+import TaskAnswerForm from './TaskAnswerForm';
+
+interface Props {
+  scriptAnswer: ScriptAnswer;
+  onFinish: () => void;
+  onError: (message: string) => void;
+}
+
+export default function ActiveScriptAnswer({ scriptAnswer, onFinish, onError }: Props) {
+  const [script, setScript] = useState<Script | null>(null);
+  const [current, setCurrent] = useState<ScriptAnswer>(scriptAnswer);
+  const [currentTaskIndex, setCurrentTaskIndex] = useState(0);
+  const [loading, setLoading] = useState(false);
+
+  useEffect(() => {
+    loadScript();
+  }, [scriptAnswer.scriptId]);
+
+  useEffect(() => {
+    // Auto-refresh script answer every 5 seconds to check for updates
+    const interval = setInterval(async () => {
+      try {
+        const updated = await ScriptAnswerService.getScriptAnswerById(scriptAnswer.id);
+        setCurrent(updated);
+        
+        // If finished, redirect
+        if (updated.status === 'finished') {
+          clearInterval(interval);
+          setTimeout(onFinish, 1000);
+        }
+      } catch (error) {
+        console.error('Failed to refresh script answer:', error);
+      }
+    }, 5000);
+
+    return () => clearInterval(interval);
+  }, [scriptAnswer.id]);
+
+  const loadScript = async () => {
+    try {
+      const scriptData = await ScriptService.getScriptById(scriptAnswer.scriptId);
+      setScript(scriptData);
+    } catch (error) {
+      onError('Failed to load script details');
+    }
+  };
+
+  const handleStartTask = async (taskId: string) => {
+    try {
+      setLoading(true);
+      await ScriptAnswerService.startTask(current.id, taskId);
+      const updated = await ScriptAnswerService.getScriptAnswerById(current.id);
+      setCurrent(updated);
+    } catch (error: any) {
+      onError(error.message || 'Failed to start task');
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  const handleSubmitTask = async (taskId: string, answer: string) => {
+    try {
+      setLoading(true);
+      await ScriptAnswerService.submitTask(current.id, taskId, answer);
+      const updated = await ScriptAnswerService.getScriptAnswerById(current.id);
+      setCurrent(updated);
+      
+      // Move to next task if not the last one
+      if (script && currentTaskIndex < script.tasks!.length - 1) {
+        setCurrentTaskIndex(currentTaskIndex + 1);
+      }
+      
+      // If this was the last task and script is finished, show completion
+      if (updated.status === 'finished') {
+        setTimeout(onFinish, 2000);
+      }
+    } catch (error: any) {
+      onError(error.message || 'Failed to submit task');
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  if (!script || !script.tasks || script.tasks.length === 0) {
+    return <div style={{ padding: '2rem' }}>Loading script...</div>;
+  }
+
+  const currentTask = script.tasks[currentTaskIndex];
+  const taskAnswer = current.answers.find(ta => ta.task === currentTask.id);
+
+  const getTaskStatus = (task: Task): 'pending' | 'started' | 'submitted' | 'timed_out' => {
+    const answer = current.answers.find(ta => ta.task === task.id);
+    return answer?.status || 'pending';
+  };
+
+  const formatTime = (seconds: number): string => {
+    const mins = Math.floor(seconds / 60);
+    const secs = seconds % 60;
+    return `${mins}:${secs.toString().padStart(2, '0')}`;
+  };
+
+  const getElapsedTime = (): string => {
+    if (!current.started_at) return '0:00';
+    const elapsed = Math.floor((Date.now() - current.started_at) / 1000);
+    return formatTime(elapsed);
+  };
+
+  return (
+    <div style={{ padding: '2rem', maxWidth: '1200px', margin: '0 auto' }}>
+      {/* Header */}
+      <div style={{
+        background: 'linear-gradient(135deg, #667eea 0%, #764ba2 100%)',
+        color: 'white',
+        padding: '2rem',
+        borderRadius: '12px',
+        marginBottom: '2rem',
+        boxShadow: '0 4px 6px rgba(0,0,0,0.1)'
+      }}>
+        <h1 style={{ margin: 0, marginBottom: '0.5rem' }}>
+          {script.title || 'Script'}
+        </h1>
+        <div style={{ display: 'flex', gap: '2rem', fontSize: '0.9rem', opacity: 0.95 }}>
+          <span>⏱️ Time Elapsed: {getElapsedTime()}</span>
+          <span>📝 Task {currentTaskIndex + 1} of {script.tasks.length}</span>
+          <span>Status: {current.status === 'finished' ? '✅ Finished' : '🔄 In Progress'}</span>
+        </div>
+      </div>
+
+      <div style={{ display: 'grid', gridTemplateColumns: '250px 1fr', gap: '2rem' }}>
+        {/* Task Navigation Sidebar */}
+        <div>
+          <h3 style={{ marginTop: 0 }}>Tasks</h3>
+          <div style={{ display: 'flex', flexDirection: 'column', gap: '0.5rem' }}>
+            {script.tasks.map((task, index) => {
+              const status = getTaskStatus(task);
+              const isActive = index === currentTaskIndex;
+              
+              return (
+                <button
+                  key={task.id}
+                  onClick={() => setCurrentTaskIndex(index)}
+                  disabled={current.status === 'finished'}
+                  style={{
+                    padding: '0.75rem',
+                    textAlign: 'left',
+                    border: isActive ? '2px solid #667eea' : '1px solid #ddd',
+                    borderRadius: '6px',
+                    background: isActive ? '#f0f4ff' : 'white',
+                    cursor: current.status === 'finished' ? 'not-allowed' : 'pointer',
+                    transition: 'all 0.2s',
+                    opacity: current.status === 'finished' ? 0.6 : 1
+                  }}
+                >
+                  <div style={{ fontWeight: isActive ? '600' : '400', marginBottom: '0.25rem' }}>
+                    Task {index + 1}
+                  </div>
+                  <div style={{ fontSize: '0.85rem', color: '#666' }}>
+                    {status === 'pending' && '⚪ Not Started'}
+                    {status === 'started' && '🟡 In Progress'}
+                    {status === 'submitted' && '✅ Submitted'}
+                    {status === 'timed_out' && '⏰ Timed Out'}
+                  </div>
+                </button>
+              );
+            })}
+          </div>
+        </div>
+
+        {/* Main Task Area */}
+        <div>
+          {current.status === 'finished' ? (
+            <div style={{
+              padding: '3rem',
+              textAlign: 'center',
+              background: '#f0fdf4',
+              border: '2px solid #86efac',
+              borderRadius: '12px'
+            }}>
+              <h2 style={{ color: '#16a34a', marginBottom: '1rem' }}>
+                🎉 Script Completed!
+              </h2>
+              <p style={{ color: '#666', marginBottom: '2rem' }}>
+                You have successfully completed all tasks in this script.
+              </p>
+              <button
+                onClick={onFinish}
+                style={{
+                  padding: '0.75rem 2rem',
+                  background: '#16a34a',
+                  color: 'white',
+                  border: 'none',
+                  borderRadius: '6px',
+                  fontSize: '1rem',
+                  cursor: 'pointer',
+                  fontWeight: '500'
+                }}
+              >
+                Back to Scripts
+              </button>
+            </div>
+          ) : (
+            <TaskAnswerForm
+              task={currentTask}
+              taskAnswer={taskAnswer}
+              onStart={handleStartTask}
+              onSubmit={handleSubmitTask}
+              loading={loading}
+              isLastTask={currentTaskIndex === script.tasks.length - 1}
+            />
+          )}
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/client/src/components/StudentScriptAnswer/AvailableScriptsList.tsx b/client/src/components/StudentScriptAnswer/AvailableScriptsList.tsx
new file mode 100644
index 00000000..be50affb
--- /dev/null
+++ b/client/src/components/StudentScriptAnswer/AvailableScriptsList.tsx
@@ -0,0 +1,101 @@
+// AvailableScriptsList.tsx
+import React from 'react';
+import { Script } from '../../types/Script';
+
+interface Props {
+  scripts: Script[];
+  onStartScript: (scriptId: string) => void;
+}
+
+export default function AvailableScriptsList({ scripts, onStartScript }: Props) {
+  return (
+    <div style={{ padding: '2rem' }}>
+      <h2>Available Scripts</h2>
+      <p style={{ color: '#666', marginBottom: '1.5rem' }}>
+        Select a script to begin answering
+      </p>
+
+      {scripts.length === 0 ? (
+        <div style={{
+          padding: '2rem',
+          textAlign: 'center',
+          background: '#f5f5f5',
+          borderRadius: '8px',
+          color: '#666'
+        }}>
+          No scripts available at the moment
+        </div>
+      ) : (
+        <div style={{
+          display: 'grid',
+          gap: '1rem',
+          gridTemplateColumns: 'repeat(auto-fill, minmax(300px, 1fr))'
+        }}>
+          {scripts.map(script => (
+            <div
+              key={script.id}
+              style={{
+                border: '1px solid #ddd',
+                borderRadius: '8px',
+                padding: '1.5rem',
+                background: 'white',
+                boxShadow: '0 2px 4px rgba(0,0,0,0.1)',
+                transition: 'transform 0.2s, box-shadow 0.2s',
+                cursor: 'pointer'
+              }}
+              onMouseEnter={(e) => {
+                e.currentTarget.style.transform = 'translateY(-2px)';
+                e.currentTarget.style.boxShadow = '0 4px 8px rgba(0,0,0,0.15)';
+              }}
+              onMouseLeave={(e) => {
+                e.currentTarget.style.transform = 'translateY(0)';
+                e.currentTarget.style.boxShadow = '0 2px 4px rgba(0,0,0,0.1)';
+              }}
+            >
+              <h3 style={{ marginTop: 0, marginBottom: '0.5rem' }}>
+                {script.title || script.id}
+              </h3>
+              
+              <div style={{ marginBottom: '1rem', color: '#666', fontSize: '0.9rem' }}>
+                {script.tasks && script.tasks.length > 0 ? (
+                  <span>{script.tasks.length} task{script.tasks.length !== 1 ? 's' : ''}</span>
+                ) : (
+                  <span>No tasks</span>
+                )}
+              </div>
+
+              <button
+                onClick={() => onStartScript(script.id)}
+                disabled={!script.tasks || script.tasks.length === 0}
+                style={{
+                  width: '100%',
+                  padding: '0.75rem',
+                  background: script.tasks && script.tasks.length > 0 
+                    ? 'linear-gradient(135deg, #667eea 0%, #764ba2 100%)'
+                    : '#ccc',
+                  color: 'white',
+                  border: 'none',
+                  borderRadius: '6px',
+                  cursor: script.tasks && script.tasks.length > 0 ? 'pointer' : 'not-allowed',
+                  fontSize: '1rem',
+                  fontWeight: '500',
+                  transition: 'opacity 0.2s'
+                }}
+                onMouseEnter={(e) => {
+                  if (script.tasks && script.tasks.length > 0) {
+                    e.currentTarget.style.opacity = '0.9';
+                  }
+                }}
+                onMouseLeave={(e) => {
+                  e.currentTarget.style.opacity = '1';
+                }}
+              >
+                Start Script
+              </button>
+            </div>
+          ))}
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/client/src/components/StudentScriptAnswer/StudentScriptAnswerPage.tsx b/client/src/components/StudentScriptAnswer/StudentScriptAnswerPage.tsx
new file mode 100644
index 00000000..470dcd6f
--- /dev/null
+++ b/client/src/components/StudentScriptAnswer/StudentScriptAnswerPage.tsx
@@ -0,0 +1,109 @@
+// StudentScriptAnswerPage.tsx
+import React, { useState, useEffect, useCallback } from 'react';
+import { Script } from '../../types/Script';
+import { ScriptAnswer } from '../../types/ScriptAnswer';
+import ScriptService from '../../services/ScriptService';
+import { ScriptAnswerService } from '../../services/ScriptAnswerService';
+import AvailableScriptsList from './AvailableScriptsList';
+import ActiveScriptAnswer from './ActiveScriptAnswer';
+
+interface Props {
+  studentCPF: string;
+  classId: string;
+  onError: (message: string) => void;
+}
+
+export default function StudentScriptAnswerPage({ studentCPF, classId, onError }: Props) {
+  const [availableScripts, setAvailableScripts] = useState<Script[]>([]);
+  const [activeScriptAnswer, setActiveScriptAnswer] = useState<ScriptAnswer | null>(null);
+  const [loading, setLoading] = useState(false);
+
+  // Shared loader: parallel fetch + unmount safety via optional cancelled ref
+  const loadData = useCallback(async (cancelled?: { current: boolean }) => {
+    setLoading(true);
+    try {
+      const [scripts, studentAnswers] = await Promise.all([
+        ScriptService.getAllScripts(),
+        ScriptAnswerService.getScriptAnswersByEnrollment(classId, studentCPF)
+      ]);
+
+      if (cancelled?.current) return;
+
+      const active = studentAnswers.find(sa => sa.status === 'in_progress') || null;
+      setActiveScriptAnswer(active);
+
+      // Avoid 409 from API: hide scripts already answered (any status) for this student/class
+      const alreadyAnswered = new Set(studentAnswers.map(sa => sa.scriptId));
+      const notAnswered = scripts.filter(s => !alreadyAnswered.has(s.id));
+      setAvailableScripts(notAnswered);
+    } catch (error) {
+      if (!cancelled?.current) {
+        const message = error instanceof Error ? error.message : 'Failed to load scripts';
+        onError(message);
+        console.error(error);
+        setAvailableScripts([]);
+        setActiveScriptAnswer(null);
+      }
+    } finally {
+      if (!cancelled?.current) {
+        setLoading(false);
+      }
+    }
+  }, [classId, studentCPF, onError]);
+
+  // Load available scripts and active script answers
+  useEffect(() => {
+    const cancelled = { current: false };
+    loadData(cancelled);
+    return () => { cancelled.current = true; };
+  }, [loadData]);
+
+  const handleStartScript = async (scriptId: string) => {
+    try {
+      setLoading(true);
+      const newAnswer = await ScriptAnswerService.createScriptAnswer({
+        scriptId,
+        classId,
+        studentId: studentCPF
+      });
+      setActiveScriptAnswer(newAnswer);
+    } catch (error: any) {
+      if (error.message.includes('already exists')) {
+        onError('You already have an active script answer. Please complete it first.');
+      } else if (error.message.includes('not enrolled')) {
+        onError('You are not enrolled in this class.');
+      } else {
+        onError('Failed to start script');
+      }
+      console.error(error);
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  const handleFinishScript = () => {
+    setActiveScriptAnswer(null);
+    loadData();
+  };
+
+  if (loading) {
+    return <div style={{ padding: '2rem' }}>Loading...</div>;
+  }
+
+  if (activeScriptAnswer) {
+    return (
+      <ActiveScriptAnswer
+        scriptAnswer={activeScriptAnswer}
+        onFinish={handleFinishScript}
+        onError={onError}
+      />
+    );
+  }
+
+  return (
+    <AvailableScriptsList
+      scripts={availableScripts}
+      onStartScript={handleStartScript}
+    />
+  );
+}
diff --git a/client/src/components/StudentScriptAnswer/TaskAnswerForm.tsx b/client/src/components/StudentScriptAnswer/TaskAnswerForm.tsx
new file mode 100644
index 00000000..375d971f
--- /dev/null
+++ b/client/src/components/StudentScriptAnswer/TaskAnswerForm.tsx
@@ -0,0 +1,251 @@
+// TaskAnswerForm.tsx
+import React, { useState, useEffect } from 'react';
+import { Task } from '../../types/Task';
+import { TaskAnswer } from '../../types/ScriptAnswer';
+
+interface Props {
+  task: Task;
+  taskAnswer?: TaskAnswer;
+  onStart: (taskId: string) => void;
+  onSubmit: (taskId: string, answer: string) => void;
+  loading: boolean;
+  isLastTask: boolean;
+}
+
+export default function TaskAnswerForm({ task, taskAnswer, onStart, onSubmit, loading, isLastTask }: Props) {
+  const [answer, setAnswer] = useState('');
+  const [elapsedTime, setElapsedTime] = useState(0);
+
+  useEffect(() => {
+    // Load existing answer if available
+    if (taskAnswer?.answer) {
+      setAnswer(taskAnswer.answer);
+    }
+  }, [taskAnswer]);
+
+  useEffect(() => {
+    // Update elapsed time if task is started
+    if (taskAnswer?.status === 'started' && taskAnswer.started_at) {
+      const interval = setInterval(() => {
+        const elapsed = Math.floor((Date.now() - taskAnswer.started_at!) / 1000);
+        setElapsedTime(elapsed);
+      }, 1000);
+
+      return () => clearInterval(interval);
+    }
+  }, [taskAnswer]);
+
+  const formatTime = (seconds: number): string => {
+    const mins = Math.floor(seconds / 60);
+    const secs = seconds % 60;
+    return `${mins}:${secs.toString().padStart(2, '0')}`;
+  };
+
+  const handleStartClick = () => {
+    onStart(task.id);
+  };
+
+  const handleSubmitClick = () => {
+    if (answer.trim()) {
+      onSubmit(task.id, answer.trim());
+    }
+  };
+
+  const getTaskStatus = () => {
+    if (!taskAnswer) return 'pending';
+    return taskAnswer.status || 'pending';
+  };
+
+  const status = getTaskStatus();
+
+  return (
+    <div style={{
+      border: '1px solid #ddd',
+      borderRadius: '12px',
+      padding: '2rem',
+      background: 'white',
+      boxShadow: '0 2px 4px rgba(0,0,0,0.1)'
+    }}>
+      {/* Task Description */}
+      <div style={{ marginBottom: '2rem' }}>
+        <h2 style={{ marginTop: 0, marginBottom: '1rem', color: '#333' }}>
+          {task.statement || 'Task'}
+        </h2>
+        
+        {status === 'started' && (
+          <div style={{
+            display: 'inline-block',
+            padding: '0.5rem 1rem',
+            background: '#fef3c7',
+            border: '1px solid #fbbf24',
+            borderRadius: '6px',
+            color: '#92400e',
+            fontSize: '0.9rem',
+            fontWeight: '500'
+          }}>
+            ⏱️ Time: {formatTime(elapsedTime)}
+          </div>
+        )}
+
+        {status === 'submitted' && (
+          <div style={{
+            display: 'inline-block',
+            padding: '0.5rem 1rem',
+            background: '#d1fae5',
+            border: '1px solid #6ee7b7',
+            borderRadius: '6px',
+            color: '#065f46',
+            fontSize: '0.9rem',
+            fontWeight: '500'
+          }}>
+            ✅ Submitted
+            {taskAnswer?.submitted_at && taskAnswer.started_at && (
+              <span style={{ marginLeft: '0.5rem' }}>
+                (Time taken: {formatTime(Math.floor((taskAnswer.submitted_at - taskAnswer.started_at) / 1000))})
+              </span>
+            )}
+          </div>
+        )}
+      </div>
+
+      {/* Answer Area */}
+      {status === 'pending' ? (
+        <div style={{ textAlign: 'center', padding: '3rem' }}>
+          <p style={{ color: '#666', marginBottom: '2rem', fontSize: '1.1rem' }}>
+            Click the button below to start this task and begin the timer.
+          </p>
+          <button
+            onClick={handleStartClick}
+            disabled={loading}
+            style={{
+              padding: '1rem 3rem',
+              background: 'linear-gradient(135deg, #667eea 0%, #764ba2 100%)',
+              color: 'white',
+              border: 'none',
+              borderRadius: '8px',
+              fontSize: '1.1rem',
+              fontWeight: '600',
+              cursor: loading ? 'not-allowed' : 'pointer',
+              opacity: loading ? 0.6 : 1,
+              transition: 'opacity 0.2s'
+            }}
+          >
+            {loading ? 'Starting...' : 'Start Task'}
+          </button>
+        </div>
+      ) : status === 'submitted' ? (
+        <div style={{
+          background: '#f9fafb',
+          border: '1px solid #e5e7eb',
+          borderRadius: '8px',
+          padding: '1.5rem'
+        }}>
+          <h4 style={{ marginTop: 0, marginBottom: '1rem', color: '#666' }}>Your Answer:</h4>
+          <div style={{
+            whiteSpace: 'pre-wrap',
+            wordBreak: 'break-word',
+            lineHeight: '1.6',
+            color: '#333'
+          }}>
+            {taskAnswer?.answer || 'No answer provided'}
+          </div>
+          
+          {taskAnswer?.comments && (
+            <div style={{ marginTop: '1.5rem' }}>
+              <h4 style={{ marginTop: 0, marginBottom: '0.5rem', color: '#666' }}>
+                Teacher Comments:
+              </h4>
+              <div style={{
+                background: '#fef3c7',
+                padding: '1rem',
+                borderRadius: '6px',
+                borderLeft: '4px solid #fbbf24',
+                color: '#78350f'
+              }}>
+                {taskAnswer.comments}
+              </div>
+            </div>
+          )}
+
+          {taskAnswer?.grade && (
+            <div style={{ marginTop: '1.5rem' }}>
+              <h4 style={{ marginTop: 0, marginBottom: '0.5rem', color: '#666' }}>
+                Grade:
+              </h4>
+              <div style={{
+                display: 'inline-block',
+                padding: '0.5rem 1rem',
+                background: '#dbeafe',
+                borderRadius: '6px',
+                fontWeight: '600',
+                fontSize: '1.1rem',
+                color: '#1e40af'
+              }}>
+                {taskAnswer.grade}
+              </div>
+            </div>
+          )}
+        </div>
+      ) : (
+        <div>
+          <textarea
+            value={answer}
+            onChange={(e) => setAnswer(e.target.value)}
+            placeholder="Type your answer here..."
+            disabled={loading}
+            style={{
+              width: '100%',
+              minHeight: '250px',
+              padding: '1rem',
+              border: '1px solid #ddd',
+              borderRadius: '8px',
+              fontSize: '1rem',
+              fontFamily: 'inherit',
+              resize: 'vertical',
+              marginBottom: '1.5rem',
+              boxSizing: 'border-box'
+            }}
+          />
+
+          <div style={{ display: 'flex', gap: '1rem', justifyContent: 'flex-end' }}>
+            <button
+              onClick={handleSubmitClick}
+              disabled={loading || !answer.trim()}
+              style={{
+                padding: '0.75rem 2rem',
+                background: answer.trim() 
+                  ? (isLastTask 
+                    ? 'linear-gradient(135deg, #10b981 0%, #059669 100%)' 
+                    : 'linear-gradient(135deg, #667eea 0%, #764ba2 100%)')
+                  : '#ccc',
+                color: 'white',
+                border: 'none',
+                borderRadius: '6px',
+                fontSize: '1rem',
+                fontWeight: '500',
+                cursor: (loading || !answer.trim()) ? 'not-allowed' : 'pointer',
+                opacity: (loading || !answer.trim()) ? 0.6 : 1,
+                transition: 'opacity 0.2s'
+              }}
+            >
+              {loading ? 'Submitting...' : (isLastTask ? '✓ Submit & Finish' : '→ Submit & Next')}
+            </button>
+          </div>
+
+          <div style={{
+            marginTop: '1rem',
+            padding: '0.75rem',
+            background: '#f0f9ff',
+            border: '1px solid #bae6fd',
+            borderRadius: '6px',
+            fontSize: '0.9rem',
+            color: '#0c4a6e'
+          }}>
+            💡 <strong>Tip:</strong> Once you submit this answer, you won't be able to change it.
+            {isLastTask && ' This is the last task - submitting will complete the entire script!'}
+          </div>
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/client/src/services/ScriptAnswerService.ts b/client/src/services/ScriptAnswerService.ts
index e0812222..e2bb0021 100644
--- a/client/src/services/ScriptAnswerService.ts
+++ b/client/src/services/ScriptAnswerService.ts
@@ -46,7 +46,10 @@ export const ScriptAnswerService = {
       body: JSON.stringify(data)
     });
 
-    if (!res.ok) throw new Error("Failed to create ScriptAnswer");
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      throw new Error(err.error || `Failed to create ScriptAnswer (status ${res.status})`);
+    }
     return res.json();
   },
 
@@ -95,7 +98,10 @@ export const ScriptAnswerService = {
   /** Get ScriptAnswers by class and student (enrollment) */
   async getScriptAnswersByEnrollment(classId: string, studentId: string): Promise<ScriptAnswer[]> {
     const res = await fetch(`${API_URL}/scriptanswers/enrollment?classId=${classId}&studentId=${studentId}`);
-    if (!res.ok) throw new Error("Failed to fetch scriptAnswers by enrollment");
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      throw new Error(err.error || `Failed to fetch scriptAnswers by enrollment (status ${res.status})`);
+    }
     return res.json();
   },
 

From 49a79c89f4dba1d6262030ffd915b58607b320b3 Mon Sep 17 00:00:00 2001
From: Davi Guerreiro <daviguerreiro9a@gmail.com>
Date: Wed, 10 Dec 2025 08:40:23 -0300
Subject: [PATCH 091/102] fix(mock): mock difference

---
 server/src/mock_scripts.ts | 32 ++++++++++++++++++++------------
 1 file changed, 20 insertions(+), 12 deletions(-)

diff --git a/server/src/mock_scripts.ts b/server/src/mock_scripts.ts
index 0c904aae..fa6ef1a4 100644
--- a/server/src/mock_scripts.ts
+++ b/server/src/mock_scripts.ts
@@ -100,18 +100,26 @@ export function loadMockScriptsAndAnswers(
         tasks: [foundTask1, foundTask2, foundTask3].filter(Boolean)
       });
 
-      const script2 = scripts.addScript(new (require('./models/Script').Script)('script-002', 'Final Exam - Math 101'));
-      if (foundTask1) script2.addTask(foundTask1);
-      if (foundTask2) script2.addTask(foundTask2);
-      if (foundTask3) script2.addTask(foundTask3);
-
-      const script3 = scripts.addScript(new (require('./models/Script').Script)('script-003', 'Quiz - Programming 201'));
-      if (foundTask2) script3.addTask(foundTask2);
-      if (foundTask3) script3.addTask(foundTask3);
-
-      const script4 = scripts.addScript(new (require('./models/Script').Script)('script-004', 'Quiz - Programming 202'));
-      if (foundTask2) script4.addTask(foundTask2);
-      if (foundTask3) script4.addTask(foundTask3);
+      const script2 = scripts.addScript({
+        id: 'script-002',
+        title: 'Final Exam - Math 101',
+        description: 'Final comprehensive exam',
+        tasks: [foundTask1, foundTask2, foundTask3].filter(Boolean)
+      });
+
+      const script3 = scripts.addScript({
+        id: 'script-003',
+        title: 'Quiz - Programming 201',
+        description: 'Programming fundamentals quiz',
+        tasks: [foundTask2, foundTask3].filter(Boolean)
+      });
+
+      const script4 = scripts.addScript({
+        id: 'script-004',
+        title: 'Quiz - Programming 202',
+        description: 'Advanced programming quiz',
+        tasks: [foundTask2, foundTask3].filter(Boolean)
+      });
 
       console.log('Mock scripts created:', [script1.getId(), script2.getId(), script3.getId(), script4.getId()]);
     }

From 107300f1949cdd7b1f0afb7629dc8daf86b01f88 Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Wed, 10 Dec 2025 08:44:16 -0300
Subject: [PATCH 092/102] HOTFIX: fixed error in which invalid scripts where
 created by the testhelper createscript. New helperfunction: createtask

---
 .../server-scriptAnswer-steps.ts              | 24 ++++++++++++++++++-
 1 file changed, 23 insertions(+), 1 deletion(-)

diff --git a/client/src/step-definitions/server-scriptAnswer-steps.ts b/client/src/step-definitions/server-scriptAnswer-steps.ts
index 55635021..8931f504 100644
--- a/client/src/step-definitions/server-scriptAnswer-steps.ts
+++ b/client/src/step-definitions/server-scriptAnswer-steps.ts
@@ -22,7 +22,29 @@ let mostRecentTaskId: string | null = null;
 // Helper functions
 // ============================================================
 
+async function createTask(statement : string, id: string) {
+  const check = await fetch(`${serverUrl}/api/tasks/${id}`);
+  if (check.status === 200) {
+    mostRecentTaskId = id;
+    return check;
+  }
+
+  const response = await fetch(`${serverUrl}/api/tasks/`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ id: id, statement: statement, type: 'text', answerKey: '' })
+  });
+
+  mostRecentTaskId = id;
+  lastResponse = response;
+  expect(response.status).toBe(201);
+
+  return response;
+}
+
 async function createScript(title : string, id: string) {
+  await createTask(`Task for ${id}`, `task-${id}`);
+
   const check = await fetch(`${serverUrl}/api/scripts/${id}`);
   if (check.status === 200) {
     createdScriptsIds.push(id);
@@ -32,7 +54,7 @@ async function createScript(title : string, id: string) {
   const response = await fetch(`${serverUrl}/api/scripts/`, {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ id: id, title: title, tasks: [] })
+    body: JSON.stringify({ id: id, title: title, tasks: [{id: `task-${id}`, statement: `Task for ${id}`}], description: 'testdesciption' })
   });
 
   lastResponse = response;

From 74a57cfd4844fc1fdabe6c6f8c3a79a420964739 Mon Sep 17 00:00:00 2001
From: tomclima <tomecostalima1228@gmail.com>
Date: Wed, 10 Dec 2025 09:15:32 -0300
Subject: [PATCH 093/102] HOSTFIX: fixed probelm in which scriptgrading unit
 tests generated invalid mock scripts

---
 server/src/__tests__/scriptgrading.test.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/server/src/__tests__/scriptgrading.test.ts b/server/src/__tests__/scriptgrading.test.ts
index d2bb6d3b..4ec8a837 100644
--- a/server/src/__tests__/scriptgrading.test.ts
+++ b/server/src/__tests__/scriptgrading.test.ts
@@ -157,7 +157,7 @@ describe('Server API – Script Answers Endpoints', () => {
   // ----------------------------------------------------------
 
   test('POST /api/scriptanswers → creates a new script answer', async () => {
-    scripts.addScript({ id: '1', title: 'Test Script' });
+    scripts.addScript({ id: '1', title: 'Test Script', tasks: [{id: 't1'}], description: 'desc' });
     const res = await request(app)
       .post('/api/scriptanswers/')
       .send({

From 6c5ae979d12ef5ed0f16f3095bcc7ef9daf4ced1 Mon Sep 17 00:00:00 2001
From: Davi Guerreiro <daviguerreiro9a@gmail.com>
Date: Wed, 10 Dec 2025 09:53:13 -0300
Subject: [PATCH 094/102] fix(AnswerScript): Adding Functions to taskAnswer

---
 client/src/App.tsx          | 2 +-
 server/src/models/Script.ts | 4 ++++
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/client/src/App.tsx b/client/src/App.tsx
index b7f748d8..6671c6b1 100644
--- a/client/src/App.tsx
+++ b/client/src/App.tsx
@@ -243,7 +243,7 @@ const App: React.FC = () => {
             <ScriptsPage onError={handleError} />
           )}
 
-          {activeTab == 'Script Grading' && (
+          {activeTab === 'Script Grading' && (
             <GradingPage onError={handleError} />
           )}
 
diff --git a/server/src/models/Script.ts b/server/src/models/Script.ts
index 4ba95999..bef1c5ce 100644
--- a/server/src/models/Script.ts
+++ b/server/src/models/Script.ts
@@ -13,6 +13,10 @@ export class Script {
     this.tasks = tasks || [];
   }
 
+  getTasks(): Task[] {
+    return this.tasks;
+  }
+
   getId(): string {
     return this.id;
   }

From 7f2a75f59d941a4e7587f076e95d517ca2518ede Mon Sep 17 00:00:00 2001
From: hlpaa <hlpaa@cin.ufpe.br>
Date: Wed, 10 Dec 2025 05:20:57 -0300
Subject: [PATCH 095/102] uinit test: script and tasks

---
 server/src/__tests__/Script.test.ts  | 226 +++++++++++++++++
 server/src/__tests__/Scripts.test.ts | 349 +++++++++++++++++++++++++++
 server/src/__tests__/Task.test.ts    |  87 +++++++
 3 files changed, 662 insertions(+)
 create mode 100644 server/src/__tests__/Script.test.ts
 create mode 100644 server/src/__tests__/Scripts.test.ts
 create mode 100644 server/src/__tests__/Task.test.ts

diff --git a/server/src/__tests__/Script.test.ts b/server/src/__tests__/Script.test.ts
new file mode 100644
index 00000000..547469a1
--- /dev/null
+++ b/server/src/__tests__/Script.test.ts
@@ -0,0 +1,226 @@
+import { Script } from "../models/Script";
+import { Task } from "../models/Task";
+
+describe("Script", () => {
+  // ---------------------------------------------------------------
+  test("constructor initializes fields correctly", () => {
+    const script = new Script("s1", "Test Script", "A test description");
+
+    expect(script.getId()).toBe("s1");
+    expect(script.getTitle()).toBe("Test Script");
+    expect(script.getDescription()).toBe("A test description");
+    expect(script.tasks).toEqual([]);
+  });
+
+  test("constructor with tasks initializes correctly", () => {
+    const task1 = new Task("t1", "Task 1");
+    const task2 = new Task("t2", "Task 2");
+    const script = new Script("s1", "Test", "Desc", [task1, task2]);
+
+    expect(script.tasks.length).toBe(2);
+    expect(script.tasks[0]).toBe(task1);
+    expect(script.tasks[1]).toBe(task2);
+  });
+
+  test("constructor without title and description works", () => {
+    const script = new Script("s1");
+
+    expect(script.getId()).toBe("s1");
+    expect(script.getTitle()).toBeUndefined();
+    expect(script.getDescription()).toBeUndefined();
+  });
+
+  // ---------------------------------------------------------------
+  test("toJSON() returns correct structure", () => {
+    const task1 = new Task("t1", "Task 1");
+    const script = new Script("s1", "My Script", "Description");
+    script.addTask(task1);
+
+    const json = script.toJSON();
+
+    expect(json).toEqual({
+      id: "s1",
+      title: "My Script",
+      description: "Description",
+      tasks: [
+        {
+          id: "t1",
+          statement: "Task 1"
+        }
+      ]
+    });
+  });
+
+  test("toJSON() filters out invalid tasks", () => {
+    const script = new Script("s1", "Test");
+    const task1 = new Task("t1", "Valid task");
+    script.addTask(task1);
+    
+    // Simulate invalid task
+    (script.tasks as any).push(null);
+    
+    const json = script.toJSON();
+    expect(json.tasks.length).toBe(1);
+  });
+
+  // ---------------------------------------------------------------
+  describe("addTask()", () => {
+    test("adds new task successfully", () => {
+      const script = new Script("s1");
+      const task = new Task("t1", "Task 1");
+
+      const result = script.addTask(task);
+
+      expect(result).toBe(task);
+      expect(script.tasks.length).toBe(1);
+      expect(script.tasks[0]).toBe(task);
+    });
+
+    test("throws error when adding duplicate task", () => {
+      const script = new Script("s1");
+      const task = new Task("t1", "Task 1");
+
+      script.addTask(task);
+
+      expect(() => {
+        script.addTask(task);
+      }).toThrow("Task already in script");
+    });
+
+    test("throws error when adding task with duplicate ID", () => {
+      const script = new Script("s1");
+      const task1 = new Task("t1", "Task 1");
+      const task2 = new Task("t1", "Task 2");
+
+      script.addTask(task1);
+
+      expect(() => {
+        script.addTask(task2);
+      }).toThrow("Task already in script");
+    });
+  });
+
+  // ---------------------------------------------------------------
+  describe("findTaskById()", () => {
+    test("finds existing task", () => {
+      const script = new Script("s1");
+      const task1 = new Task("t1", "Task 1");
+      const task2 = new Task("t2", "Task 2");
+
+      script.addTask(task1);
+      script.addTask(task2);
+
+      const found = script.findTaskById("t1");
+      expect(found).toBe(task1);
+    });
+
+    test("returns undefined for non-existent task", () => {
+      const script = new Script("s1");
+      const task1 = new Task("t1", "Task 1");
+
+      script.addTask(task1);
+
+      const found = script.findTaskById("t999");
+      expect(found).toBeUndefined();
+    });
+  });
+
+  // ---------------------------------------------------------------
+  describe("removeTask()", () => {
+    test("removes existing task and returns true", () => {
+      const script = new Script("s1");
+      const task1 = new Task("t1", "Task 1");
+      const task2 = new Task("t2", "Task 2");
+
+      script.addTask(task1);
+      script.addTask(task2);
+
+      const result = script.removeTask("t1");
+
+      expect(result).toBe(true);
+      expect(script.tasks.length).toBe(1);
+      expect(script.tasks[0]).toBe(task2);
+    });
+
+    test("returns false when task does not exist", () => {
+      const script = new Script("s1");
+      const task1 = new Task("t1", "Task 1");
+
+      script.addTask(task1);
+
+      const result = script.removeTask("t999");
+
+      expect(result).toBe(false);
+      expect(script.tasks.length).toBe(1);
+    });
+
+    test("works with empty task list", () => {
+      const script = new Script("s1");
+
+      const result = script.removeTask("t1");
+
+      expect(result).toBe(false);
+    });
+  });
+
+  // ---------------------------------------------------------------
+  describe("update()", () => {
+    test("updates title", () => {
+      const script = new Script("s1", "Old Title");
+
+      script.update({ title: "New Title" });
+
+      expect(script.getTitle()).toBe("New Title");
+    });
+
+    test("updates description", () => {
+      const script = new Script("s1", "Title", "Old Desc");
+
+      script.update({ description: "New Description" });
+
+      expect(script.getDescription()).toBe("New Description");
+    });
+
+    test("updates tasks from JSON", () => {
+      const script = new Script("s1");
+      const task1 = new Task("t1", "Old Task");
+      script.addTask(task1);
+
+      script.update({
+        tasks: [
+          { id: "t2", statement: "New Task 1" },
+          { id: "t3", statement: "New Task 2" }
+        ]
+      });
+
+      expect(script.tasks.length).toBe(2);
+      expect(script.tasks[0].getId()).toBe("t2");
+      expect(script.tasks[0].statement).toBe("New Task 1");
+      expect(script.tasks[1].getId()).toBe("t3");
+      expect(script.tasks[1].statement).toBe("New Task 2");
+    });
+
+    test("updates multiple fields at once", () => {
+      const script = new Script("s1", "Old", "Old Desc");
+
+      script.update({
+        title: "New Title",
+        description: "New Description",
+        tasks: [{ id: "t1", statement: "Task 1" }]
+      });
+
+      expect(script.getTitle()).toBe("New Title");
+      expect(script.getDescription()).toBe("New Description");
+      expect(script.tasks.length).toBe(1);
+    });
+
+    test("does not update fields when undefined", () => {
+      const script = new Script("s1", "Title", "Desc");
+
+      script.update({});
+
+      expect(script.getTitle()).toBe("Title");
+      expect(script.getDescription()).toBe("Desc");
+    });
+  });
+});
diff --git a/server/src/__tests__/Scripts.test.ts b/server/src/__tests__/Scripts.test.ts
new file mode 100644
index 00000000..0d11d9ff
--- /dev/null
+++ b/server/src/__tests__/Scripts.test.ts
@@ -0,0 +1,349 @@
+import { Script } from "../models/Script";
+import { Scripts } from "../models/Scripts";
+import { Task } from "../models/Task";
+
+describe("Scripts", () => {
+  let scripts: Scripts;
+
+  beforeEach(() => {
+    scripts = new Scripts();
+  });
+
+  // ---------------------------------------------------------------
+  describe("addScript()", () => {
+    test("adds new script successfully", () => {
+      const data = {
+        title: "Test Script",
+        description: "A test description",
+        tasks: [
+          { id: "t1", statement: "Task 1" },
+          { id: "t2", statement: "Task 2" }
+        ]
+      };
+
+      const script = scripts.addScript(data);
+
+      expect(script).toBeInstanceOf(Script);
+      expect(script.getTitle()).toBe("Test Script");
+      expect(script.getDescription()).toBe("A test description");
+      expect(script.tasks.length).toBe(2);
+      expect(script.getId()).toBeDefined();
+    });
+
+    test("generates ID when not provided", () => {
+      const data = {
+        title: "Script",
+        description: "Description",
+        tasks: [{ id: "t1", statement: "Task" }]
+      };
+
+      const script = scripts.addScript(data);
+
+      expect(script.getId()).toBeDefined();
+      expect(script.getId().length).toBeGreaterThan(0);
+    });
+
+    test("uses provided ID when given", () => {
+      const data = {
+        id: "custom-id",
+        title: "Script",
+        description: "Description",
+        tasks: [{ id: "t1", statement: "Task" }]
+      };
+
+      const script = scripts.addScript(data);
+
+      expect(script.getId()).toBe("custom-id");
+    });
+
+    test("throws error when title is missing", () => {
+      const data = {
+        description: "Description",
+        tasks: [{ id: "t1", statement: "Task" }]
+      };
+
+      expect(() => {
+        scripts.addScript(data);
+      }).toThrow("Script title is required");
+    });
+
+    test("throws error when title is empty string", () => {
+      const data = {
+        title: "   ",
+        description: "Description",
+        tasks: [{ id: "t1", statement: "Task" }]
+      };
+
+      expect(() => {
+        scripts.addScript(data);
+      }).toThrow("Script title is required");
+    });
+
+    test("throws error when description is missing", () => {
+      const data = {
+        title: "Title",
+        tasks: [{ id: "t1", statement: "Task" }]
+      };
+
+      expect(() => {
+        scripts.addScript(data);
+      }).toThrow("Script description is required");
+    });
+
+    test("throws error when description is empty string", () => {
+      const data = {
+        title: "Title",
+        description: "  ",
+        tasks: [{ id: "t1", statement: "Task" }]
+      };
+
+      expect(() => {
+        scripts.addScript(data);
+      }).toThrow("Script description is required");
+    });
+
+    test("throws error when tasks array is missing", () => {
+      const data = {
+        title: "Title",
+        description: "Description"
+      };
+
+      expect(() => {
+        scripts.addScript(data);
+      }).toThrow("Script must have at least one task");
+    });
+
+    test("throws error when tasks array is empty", () => {
+      const data = {
+        title: "Title",
+        description: "Description",
+        tasks: []
+      };
+
+      expect(() => {
+        scripts.addScript(data);
+      }).toThrow("Script must have at least one task");
+    });
+
+    test("throws error when script with same title already exists", () => {
+      const data1 = {
+        title: "Duplicate Title",
+        description: "Description",
+        tasks: [{ id: "t1", statement: "Task" }]
+      };
+
+      const data2 = {
+        title: "Duplicate Title",
+        description: "Different Description",
+        tasks: [{ id: "t2", statement: "Task 2" }]
+      };
+
+      scripts.addScript(data1);
+
+      expect(() => {
+        scripts.addScript(data2);
+      }).toThrow("Script with this title already exists");
+    });
+
+    test("converts tasks from JSON to Task instances", () => {
+      const data = {
+        title: "Script",
+        description: "Description",
+        tasks: [
+          { id: "t1", statement: "Task 1" },
+          { id: "t2", statement: "Task 2" }
+        ]
+      };
+
+      const script = scripts.addScript(data);
+
+      expect(script.tasks[0]).toBeInstanceOf(Task);
+      expect(script.tasks[1]).toBeInstanceOf(Task);
+      expect(script.tasks[0].getId()).toBe("t1");
+      expect(script.tasks[1].statement).toBe("Task 2");
+    });
+  });
+
+  // ---------------------------------------------------------------
+  describe("getAllScripts()", () => {
+    test("returns empty array when no scripts", () => {
+      const result = scripts.getAllScripts();
+
+      expect(result).toEqual([]);
+    });
+
+    test("returns all added scripts", () => {
+      const data1 = {
+        title: "Script 1",
+        description: "Desc 1",
+        tasks: [{ id: "t1", statement: "Task" }]
+      };
+
+      const data2 = {
+        title: "Script 2",
+        description: "Desc 2",
+        tasks: [{ id: "t2", statement: "Task" }]
+      };
+
+      scripts.addScript(data1);
+      scripts.addScript(data2);
+
+      const result = scripts.getAllScripts();
+
+      expect(result.length).toBe(2);
+      expect(result[0].getTitle()).toBe("Script 1");
+      expect(result[1].getTitle()).toBe("Script 2");
+    });
+  });
+
+  // ---------------------------------------------------------------
+  describe("findById()", () => {
+    test("finds existing script by ID", () => {
+      const data = {
+        id: "s123",
+        title: "Script",
+        description: "Description",
+        tasks: [{ id: "t1", statement: "Task" }]
+      };
+
+      scripts.addScript(data);
+
+      const found = scripts.findById("s123");
+
+      expect(found).toBeInstanceOf(Script);
+      expect(found?.getId()).toBe("s123");
+    });
+
+    test("returns undefined for non-existent ID", () => {
+      const data = {
+        title: "Script",
+        description: "Description",
+        tasks: [{ id: "t1", statement: "Task" }]
+      };
+
+      scripts.addScript(data);
+
+      const found = scripts.findById("non-existent");
+
+      expect(found).toBeUndefined();
+    });
+  });
+
+  // ---------------------------------------------------------------
+  describe("findByName()", () => {
+    test("finds existing script by title", () => {
+      const data = {
+        title: "Unique Script",
+        description: "Description",
+        tasks: [{ id: "t1", statement: "Task" }]
+      };
+
+      scripts.addScript(data);
+
+      const found = scripts.findByName("Unique Script");
+
+      expect(found).toBeInstanceOf(Script);
+      expect(found?.getTitle()).toBe("Unique Script");
+    });
+
+    test("returns undefined for non-existent title", () => {
+      const data = {
+        title: "Script",
+        description: "Description",
+        tasks: [{ id: "t1", statement: "Task" }]
+      };
+
+      scripts.addScript(data);
+
+      const found = scripts.findByName("Non-existent Script");
+
+      expect(found).toBeUndefined();
+    });
+
+    test("is case-sensitive", () => {
+      const data = {
+        title: "Script",
+        description: "Description",
+        tasks: [{ id: "t1", statement: "Task" }]
+      };
+
+      scripts.addScript(data);
+
+      const found = scripts.findByName("script");
+
+      expect(found).toBeUndefined();
+    });
+  });
+
+  // ---------------------------------------------------------------
+  describe("updateScript()", () => {
+    test("updates existing script and returns it", () => {
+      const data = {
+        id: "s1",
+        title: "Original Title",
+        description: "Original Description",
+        tasks: [{ id: "t1", statement: "Task 1" }]
+      };
+
+      scripts.addScript(data);
+
+      const updated = scripts.updateScript("s1", {
+        title: "Updated Title",
+        description: "Updated Description"
+      });
+
+      expect(updated).toBeInstanceOf(Script);
+      expect(updated?.getTitle()).toBe("Updated Title");
+      expect(updated?.getDescription()).toBe("Updated Description");
+    });
+
+    test("updates tasks", () => {
+      const data = {
+        id: "s1",
+        title: "Script",
+        description: "Description",
+        tasks: [{ id: "t1", statement: "Task 1" }]
+      };
+
+      scripts.addScript(data);
+
+      const updated = scripts.updateScript("s1", {
+        tasks: [
+          { id: "t2", statement: "New Task 1" },
+          { id: "t3", statement: "New Task 2" }
+        ]
+      });
+
+      expect(updated?.tasks.length).toBe(2);
+      expect(updated?.tasks[0].getId()).toBe("t2");
+      expect(updated?.tasks[1].statement).toBe("New Task 2");
+    });
+
+    test("returns undefined for non-existent ID", () => {
+      const updated = scripts.updateScript("non-existent", {
+        title: "New Title"
+      });
+
+      expect(updated).toBeUndefined();
+    });
+
+    test("partially updates script", () => {
+      const data = {
+        id: "s1",
+        title: "Original",
+        description: "Description",
+        tasks: [{ id: "t1", statement: "Task" }]
+      };
+
+      scripts.addScript(data);
+
+      const updated = scripts.updateScript("s1", {
+        title: "Updated"
+      });
+
+      expect(updated?.getTitle()).toBe("Updated");
+      expect(updated?.getDescription()).toBe("Description");
+      expect(updated?.tasks.length).toBe(1);
+    });
+  });
+});
diff --git a/server/src/__tests__/Task.test.ts b/server/src/__tests__/Task.test.ts
new file mode 100644
index 00000000..97dff19b
--- /dev/null
+++ b/server/src/__tests__/Task.test.ts
@@ -0,0 +1,87 @@
+import { Task } from "../models/Task";
+
+describe("Task", () => {
+  // ---------------------------------------------------------------
+  test("constructor initializes fields correctly", () => {
+    const task = new Task("t1", "Write an essay");
+
+    expect(task.getId()).toBe("t1");
+    expect(task.statement).toBe("Write an essay");
+  });
+
+  // ---------------------------------------------------------------
+  test("getId() returns task id", () => {
+    const task = new Task("t123", "Statement");
+
+    expect(task.getId()).toBe("t123");
+  });
+
+  // ---------------------------------------------------------------
+  test("toJSON() returns correct structure", () => {
+    const task = new Task("t1", "Complete the assignment");
+
+    const json = task.toJSON();
+
+    expect(json).toEqual({
+      id: "t1",
+      statement: "Complete the assignment"
+    });
+  });
+
+  // ---------------------------------------------------------------
+  describe("update()", () => {
+    test("updates statement", () => {
+      const task = new Task("t1", "Old statement");
+
+      task.update({ statement: "New statement" });
+
+      expect(task.statement).toBe("New statement");
+    });
+
+    test("does not update when statement is undefined", () => {
+      const task = new Task("t1", "Original");
+
+      task.update({});
+
+      expect(task.statement).toBe("Original");
+    });
+
+    test("updates with attachment parameter (ignored)", () => {
+      const task = new Task("t1", "Statement");
+
+      // attachment is in the signature but not implemented
+      task.update({ attachment: "file.pdf" });
+
+      expect(task.statement).toBe("Statement");
+    });
+  });
+
+  // ---------------------------------------------------------------
+  describe("fromJSON()", () => {
+    test("creates Task instance from JSON", () => {
+      const json = {
+        id: "t1",
+        statement: "Do something"
+      };
+
+      const task = Task.fromJSON(json);
+
+      expect(task).toBeInstanceOf(Task);
+      expect(task.getId()).toBe("t1");
+      expect(task.statement).toBe("Do something");
+    });
+
+    test("creates Task from object with extra properties", () => {
+      const json = {
+        id: "t2",
+        statement: "Task statement",
+        extraProp: "ignored"
+      };
+
+      const task = Task.fromJSON(json);
+
+      expect(task.getId()).toBe("t2");
+      expect(task.statement).toBe("Task statement");
+    });
+  });
+});

From a5cfd60db73aa878f00d207af049e7454c9cb654 Mon Sep 17 00:00:00 2001
From: hlpaa <hlpaa@cin.ufpe.br>
Date: Wed, 10 Dec 2025 05:29:42 -0300
Subject: [PATCH 096/102] integration test scritps  routes

---
 server/src/__tests__/scriptRoutes.test.ts | 99 +++++++++++++++++++++++
 1 file changed, 99 insertions(+)
 create mode 100644 server/src/__tests__/scriptRoutes.test.ts

diff --git a/server/src/__tests__/scriptRoutes.test.ts b/server/src/__tests__/scriptRoutes.test.ts
new file mode 100644
index 00000000..405cd5a9
--- /dev/null
+++ b/server/src/__tests__/scriptRoutes.test.ts
@@ -0,0 +1,99 @@
+import request from 'supertest';
+import { app, scripts } from '../server';
+
+describe('Server API - Scripts (create/edit)', () => {
+  beforeEach(() => {
+    // reset in-memory scripts between tests
+    scripts.getAllScripts().length = 0;
+  });
+
+  test('POST /api/scripts creates a script with tasks', async () => {
+    const payload = {
+      title: 'Script A',
+      description: 'Desc A',
+      tasks: [
+        { id: 't1', statement: 'Task 1' },
+        { id: 't2', statement: 'Task 2' }
+      ]
+    };
+
+    const res = await request(app).post('/api/scripts/').send(payload);
+
+    expect(res.status).toBe(201);
+    expect(res.body.title).toBe('Script A');
+    expect(res.body.description).toBe('Desc A');
+    expect(Array.isArray(res.body.tasks)).toBe(true);
+    expect(res.body.tasks).toHaveLength(2);
+    expect(res.body.tasks[0]).toEqual({ id: 't1', statement: 'Task 1' });
+    expect(res.body.tasks[1]).toEqual({ id: 't2', statement: 'Task 2' });
+  });
+
+  test('POST /api/scripts rejects missing or empty tasks', async () => {
+    const resMissing = await request(app).post('/api/scripts/').send({
+      title: 'No Tasks',
+      description: 'Desc',
+      tasks: []
+    });
+    expect(resMissing.status).toBe(400);
+    expect(resMissing.body.error).toBe('Script must have at least one task');
+
+    const resUndefined = await request(app).post('/api/scripts/').send({
+      title: 'No Tasks 2',
+      description: 'Desc'
+    });
+    expect(resUndefined.status).toBe(400);
+    expect(resUndefined.body.error).toBe('Script must have at least one task');
+  });
+
+  test('POST /api/scripts rejects duplicate title', async () => {
+    const payload = {
+      title: 'Duplicate',
+      description: 'First',
+      tasks: [{ id: 't1', statement: 'Task 1' }]
+    };
+
+    const first = await request(app).post('/api/scripts/').send(payload);
+    expect(first.status).toBe(201);
+
+    const second = await request(app).post('/api/scripts/').send({
+      title: 'Duplicate',
+      description: 'Second',
+      tasks: [{ id: 't2', statement: 'Task 2' }]
+    });
+
+    expect(second.status).toBe(400);
+    expect(second.body.error).toBe('Script with this title already exists');
+  });
+
+  test('PUT /api/scripts/:id updates title, description and tasks', async () => {
+    const createRes = await request(app).post('/api/scripts/').send({
+      title: 'Initial',
+      description: 'Old',
+      tasks: [{ id: 't1', statement: 'Old Task' }]
+    });
+
+    const id = createRes.body.id;
+    expect(id).toBeDefined();
+
+    const updateRes = await request(app).put(`/api/scripts/${id}`).send({
+      title: 'Updated',
+      description: 'New Desc',
+      tasks: [{ id: 't2', statement: 'New Task' }]
+    });
+
+    expect(updateRes.status).toBe(200);
+    expect(updateRes.body.title).toBe('Updated');
+    expect(updateRes.body.description).toBe('New Desc');
+    expect(updateRes.body.tasks).toHaveLength(1);
+    expect(updateRes.body.tasks[0]).toEqual({ id: 't2', statement: 'New Task' });
+  });
+
+  test('PUT /api/scripts/:id returns 404 when script not found', async () => {
+    const res = await request(app).put('/api/scripts/non-existent').send({
+      title: 'X'
+    });
+
+    expect(res.status).toBe(404);
+    expect(res.body.error).toBe('Script not found');
+  });
+});

From b8c82bab6be9acdc573101b85add2bcb2ab65480 Mon Sep 17 00:00:00 2001
From: hlpaa <hlpaa@cin.ufpe.br>
Date: Wed, 10 Dec 2025 08:19:00 -0300
Subject: [PATCH 097/102] end to end tests scripts

---
 client/src/step-definitions/script-steps.ts   | 181 ++++++++++++++++++
 .../step-definitions/server-script-steps.ts   |  83 ++++++++
 2 files changed, 264 insertions(+)
 create mode 100644 client/src/step-definitions/script-steps.ts
 create mode 100644 client/src/step-definitions/server-script-steps.ts

diff --git a/client/src/step-definitions/script-steps.ts b/client/src/step-definitions/script-steps.ts
new file mode 100644
index 00000000..2e40a56d
--- /dev/null
+++ b/client/src/step-definitions/script-steps.ts
@@ -0,0 +1,181 @@
+import { After, Before, DataTable, Given, setDefaultTimeout, Then, When } from '@cucumber/cucumber';
+import expect from 'expect';
+import { Browser, launch, Page } from 'puppeteer';
+
+setDefaultTimeout(30 * 1000);
+
+let browser: Browser;
+let page: Page;
+const baseUrl = 'http://localhost:3004';
+let testScriptTitle: string;
+
+Before({ tags: '@gui' }, async function () {
+  browser = await launch({ headless: false, slowMo: 50 });
+  page = await browser.newPage();
+  await page.setViewport({ width: 1280, height: 720 });
+});
+
+After({ tags: '@gui' }, async function () {
+  if (testScriptTitle) {
+    try {
+      await page.goto(baseUrl);
+      await page.waitForSelector('.scripts-list table', { timeout: 5000 });
+      const scriptRows = await page.$$('[data-testid^="script-row-"]');
+      for (const row of scriptRows) {
+        const titleCell = await row.$('[data-testid="script-title"]');
+        if (titleCell) {
+          const title = await page.evaluate(el => el.textContent, titleCell);
+          if (title === testScriptTitle) {
+            page.once('dialog', async (dialog) => { await dialog.accept(); });
+            const deleteButton = await row.$(`[data-testid="delete-script-${title}"]`);
+            if (deleteButton) {
+              await deleteButton.click();
+              await new Promise(resolve => setTimeout(resolve, 1000));
+              break;
+            }
+          }
+        }
+      }
+    } catch (error) {}
+  }
+  if (browser) await browser.close();
+});
+
+Given('the script management system is running', async function () {
+  await page.goto(baseUrl);
+  await page.waitForSelector('h1', { timeout: 10000 });
+  const title = await page.$eval('h1', el => el.textContent);
+  expect(title || '').toContain('Teaching Assistant React');
+});
+
+Given('there is no script with title {string} in the system', async function (title: string) {
+  testScriptTitle = title;
+  await page.goto(baseUrl);
+  await page.waitForSelector('.scripts-list', { timeout: 10000 });
+  const scriptRows = await page.$$('[data-testid^="script-row-"]');
+  for (const row of scriptRows) {
+    const titleCell = await row.$('[data-testid="script-title"]');
+    if (titleCell) {
+      const displayedTitle = await page.evaluate(el => el.textContent, titleCell);
+      if (displayedTitle === title) {
+        page.once('dialog', async (dialog) => { await dialog.accept(); });
+        const deleteButton = await row.$(`[data-testid="delete-script-${displayedTitle}"]`);
+        if (deleteButton) {
+          await deleteButton.click();
+          await new Promise(resolve => setTimeout(resolve, 1000));
+          break;
+        }
+      }
+    }
+  }
+  await page.reload();
+  await page.waitForSelector('.scripts-list', { timeout: 5000 });
+  const updatedRows = await page.$$('[data-testid^="script-row-"]');
+  for (const row of updatedRows) {
+    const titleCell = await row.$('[data-testid="script-title"]');
+    if (titleCell) {
+      const displayedTitle = await page.evaluate(el => el.textContent, titleCell);
+      if (displayedTitle === title) {
+        throw new Error(`Script with title ${displayedTitle} still exists in the system after cleanup`);
+      }
+    }
+  }
+});
+
+When('I navigate to the Scripts area', async function () {
+  const scriptsTab = await page.$('[data-testid="scripts-tab"]');
+  if (scriptsTab) {
+    const isActive = await page.evaluate(el => el?.classList.contains('active'), scriptsTab);
+    if (!isActive) await scriptsTab.click();
+  }
+  await page.waitForSelector('[data-testid="script-form"]', { timeout: 5000 });
+});
+
+When('I provide the script information:', async function (dataTable: DataTable) {
+  const data = dataTable.rowsHash();
+  await page.waitForSelector('#title');
+  await page.click('#title');
+  await page.type('#title', data.title);
+  await page.click('#description');
+  await page.type('#description', data.description);
+  await page.click('#tasks');
+  await page.type('#tasks', data.tasks);
+});
+
+When('I send the script information', async function () {
+  const submitButton = await page.$('[data-testid="submit-script-button"]');
+  expect(submitButton).toBeTruthy();
+  await submitButton?.click();
+  await new Promise(resolve => setTimeout(resolve, 2000));
+});
+
+When('I edit the script information:', async function (dataTable: DataTable) {
+  const data = dataTable.rowsHash();
+  await page.goto(baseUrl);
+  await page.waitForSelector('.scripts-list table', { timeout: 10000 });
+  const scriptRows = await page.$$('[data-testid^="script-row-"]');
+  let foundScript = null;
+  for (const row of scriptRows) {
+    const titleCell = await row.$('[data-testid="script-title"]');
+    if (titleCell) {
+      const title = await page.evaluate(el => el.textContent, titleCell);
+      if (title === testScriptTitle) {
+        foundScript = row;
+        break;
+      }
+    }
+  }
+  expect(foundScript).toBeTruthy();
+  const editButton = await foundScript!.$('[data-testid="edit-script-button"]');
+  expect(editButton).toBeTruthy();
+  await editButton?.click();
+  await page.waitForSelector('[data-testid="script-form"]', { timeout: 5000 });
+  await page.click('#title', { clickCount: 3 });
+  await page.type('#title', data.title);
+  await page.click('#description', { clickCount: 3 });
+  await page.type('#description', data.description);
+  await page.click('#tasks', { clickCount: 3 });
+  await page.type('#tasks', data.tasks);
+  const submitButton = await page.$('[data-testid="submit-script-button"]');
+  expect(submitButton).toBeTruthy();
+  await submitButton?.click();
+  await new Promise(resolve => setTimeout(resolve, 2000));
+  testScriptTitle = data.title;
+});
+
+Then('I should see {string} in the script list', async function (scriptTitle: string) {
+  await page.waitForSelector('.scripts-list table', { timeout: 10000 });
+  const scriptRows = await page.$$('[data-testid^="script-row-"]');
+  let foundScript = null;
+  for (const row of scriptRows) {
+    const titleCell = await row.$('[data-testid="script-title"]');
+    if (titleCell) {
+      const title = await page.evaluate(el => el.textContent, titleCell);
+      if (title === scriptTitle) {
+        foundScript = row;
+        break;
+      }
+    }
+  }
+  expect(foundScript).toBeTruthy();
+});
+
+Then('the script should have description {string}', async function (expectedDescription: string) {
+  await page.waitForSelector('.scripts-list table', { timeout: 10000 });
+  const scriptRows = await page.$$('[data-testid^="script-row-"]');
+  let foundScript = null;
+  for (const row of scriptRows) {
+    const titleCell = await row.$('[data-testid="script-title"]');
+    if (titleCell) {
+      const title = await page.evaluate(el => el.textContent, titleCell);
+      if (title === testScriptTitle) {
+        foundScript = row;
+        break;
+      }
+    }
+  }
+  expect(foundScript).toBeTruthy();
+  const descCell = await foundScript!.$('[data-testid="script-description"]');
+  const actualDesc = await page.evaluate(el => el.textContent, descCell!);
+  expect(actualDesc).toBe(expectedDescription);
+});
diff --git a/client/src/step-definitions/server-script-steps.ts b/client/src/step-definitions/server-script-steps.ts
new file mode 100644
index 00000000..b936a3b4
--- /dev/null
+++ b/client/src/step-definitions/server-script-steps.ts
@@ -0,0 +1,83 @@
+import { After, DataTable, Given, setDefaultTimeout, Then, When } from '@cucumber/cucumber';
+import expect from 'expect';
+
+setDefaultTimeout(30 * 1000);
+
+const serverUrl = 'http://localhost:3005';
+let testScriptId: string;
+let lastResponse: Response;
+
+After({ tags: '@server' }, async function () {
+  if (testScriptId) {
+    try {
+      await fetch(`${serverUrl}/api/scripts/${testScriptId}`, { method: 'DELETE' });
+      console.log(`Server cleanup: Removed test script with id: ${testScriptId}`);
+    } catch (error) {
+      console.log('Server cleanup: Script may not exist or server unavailable');
+    }
+    testScriptId = '';
+  }
+});
+
+Given('the scripts API is available', async function () {
+  const response = await fetch(`${serverUrl}/api/scripts`);
+  expect(response.status).toBe(200);
+});
+
+Given('there is no script with title {string} in the server', async function (title: string) {
+  // Remove all scripts with this title
+  const response = await fetch(`${serverUrl}/api/scripts`);
+  const scripts = await response.json();
+  for (const script of scripts) {
+    if (script.title === title) {
+      await fetch(`${serverUrl}/api/scripts/${script.id}`, { method: 'DELETE' });
+      console.log(`Server setup: Removed script with title: ${title}`);
+    }
+  }
+});
+
+When('I submit a request to create script with:', async function (dataTable: DataTable) {
+  const data = dataTable.rowsHash();
+  const requestBody = {
+    title: data.title,
+    description: data.description,
+    tasks: JSON.parse(data.tasks)
+  };
+  lastResponse = await fetch(`${serverUrl}/api/scripts`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(requestBody)
+  });
+  if (lastResponse.status === 201) {
+    const created = await lastResponse.json();
+    testScriptId = created.id;
+  }
+});
+
+When('I submit a request to edit script with:', async function (dataTable: DataTable) {
+  const data = dataTable.rowsHash();
+  const requestBody = {
+    title: data.title,
+    description: data.description,
+    tasks: JSON.parse(data.tasks)
+  };
+  lastResponse = await fetch(`${serverUrl}/api/scripts/${testScriptId}`, {
+    method: 'PUT',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(requestBody)
+  });
+});
+
+Then('the script request should be accepted successfully', async function () {
+  expect([200, 201]).toContain(lastResponse.status);
+});
+
+Then('the server should have stored the script with:', async function (dataTable: DataTable) {
+  const expected = dataTable.rowsHash();
+  const response = await fetch(`${serverUrl}/api/scripts/${testScriptId}`);
+  expect(response.status).toBe(200);
+  const stored = await response.json();
+  expect(stored.title).toBe(expected.title);
+  expect(stored.description).toBe(expected.description);
+  expect(JSON.stringify(stored.tasks)).toBe(expected.tasks);
+});

From c3f912c0af746362229a19a62f19306f3fd4c12c Mon Sep 17 00:00:00 2001
From: hlpaa <hlpaa@cin.ufpe.br>
Date: Wed, 10 Dec 2025 08:29:19 -0300
Subject: [PATCH 098/102] gherkin scenarios script management

---
 .../features/script-management-gui.feature    | 20 +++++++++
 client/src/features/script-management.feature | 33 +++++++++++++++
 .../features/server-script-management.feature | 41 +++++++++++++++++++
 3 files changed, 94 insertions(+)
 create mode 100644 client/src/features/script-management-gui.feature
 create mode 100644 client/src/features/script-management.feature
 create mode 100644 client/src/features/server-script-management.feature

diff --git a/client/src/features/script-management-gui.feature b/client/src/features/script-management-gui.feature
new file mode 100644
index 00000000..c1915cc7
--- /dev/null
+++ b/client/src/features/script-management-gui.feature
@@ -0,0 +1,20 @@
+@gui
+Feature: Script Management
+  As a professor
+  I want to create and edit scripts
+  So that I can manage script information
+
+  Background:
+    Given the script management system is running
+
+  Scenario: Create a new script successfully
+    Given there is no script with title "Roteiro 1" in the system
+    When I navigate to the Scripts area
+    And I provide the script information:
+      | field       | value                                                    |
+      | title       | Roteiro 1                                               |
+      | description | Descrição do Roteiro 1                                  |
+      | tasks       | [{"id":"t1","statement":"Task 1"}]                      |
+    And I send the script information
+    Then I should see "Roteiro 1" in the script list
+    And the script should have description "Descrição do Roteiro 1"
diff --git a/client/src/features/script-management.feature b/client/src/features/script-management.feature
new file mode 100644
index 00000000..ea3aa263
--- /dev/null
+++ b/client/src/features/script-management.feature
@@ -0,0 +1,33 @@
+Feature: Cadastro e Edição de Roteiros
+
+  Scenario: Cadastro de roteiro com sucesso
+    Given estou na tela de “Cadastro de Roteiros”
+    And não existe roteiro cadastrado com o título “Roteiro 1”
+    When eu preencho os campos obrigatórios do roteiro e clico em “Salvar”
+    Then o sistema exibe mensagem de sucesso
+    And permaneço na tela de “Cadastro de Roteiros”
+    And consigo visualizar o roteiro “Roteiro 1” na lista de roteiros cadastrados
+
+  Scenario: Cadastro de roteiro com campos obrigatórios ausentes
+    Given estou na tela de “Cadastro de Roteiros”
+    And não preenchi os campos obrigatórios
+    When clico em “Salvar”
+    Then o sistema exibe mensagem de erro indicando os campos obrigatórios ausentes
+    And continuo na tela de “Cadastro de Roteiros” com os dados parciais preenchidos
+
+  Scenario: Edição de roteiro com sucesso
+    Given estou na tela de “Listagem de Roteiros”
+    And existe um roteiro cadastrado chamado “Roteiro 1”
+    When clico em “Editar” no roteiro “Roteiro 1”
+    And altero o título para “Roteiro 1 - Atualizado” e clico em “Salvar”
+    Then o sistema exibe mensagem de sucesso
+    And continuo na tela de “Listagem de Roteiros”
+    And visualizo o roteiro com o título atualizado
+
+  Scenario: Edição de roteiro com título duplicado
+    Given estou na tela de “Listagem de Roteiros”
+    And existe um roteiro chamado “Roteiro 1” e outro chamado “Roteiro 2”
+    When clico em “Editar” no roteiro “Roteiro 2”
+    And altero o título para “Roteiro 1” e clico em “Salvar”
+    Then o sistema exibe mensagem de erro indicando que já existe um roteiro com esse título
+    And continuo na tela de “Edição de Roteiros” com os dados preenchidos
\ No newline at end of file
diff --git a/client/src/features/server-script-management.feature b/client/src/features/server-script-management.feature
new file mode 100644
index 00000000..ada02db3
--- /dev/null
+++ b/client/src/features/server-script-management.feature
@@ -0,0 +1,41 @@
+@server
+Feature: Server Script Management
+  As a system
+  I want to manage scripts through the API
+  So that script data is properly stored and retrieved
+
+  Background:
+    Given the scripts API is available
+
+  Scenario: Create a new script via API
+    Given there is no script with title "Roteiro API 1" in the server
+    When I submit a request to create script with:
+      | field       | value                                                    |
+      | title       | Roteiro API 1                                           |
+      | description | Descrição do Roteiro API 1                              |
+      | tasks       | [{"id":"t1","statement":"Task 1"}]                      |
+    Then the script request should be accepted successfully
+    And the server should have stored the script with:
+      | field       | value                                                    |
+      | title       | Roteiro API 1                                           |
+      | description | Descrição do Roteiro API 1                              |
+      | tasks       | [{"id":"t1","statement":"Task 1"}]                      |
+
+  Scenario: Edit an existing script via API
+    Given there is no script with title "Roteiro API Edit" in the server
+    When I submit a request to create script with:
+      | field       | value                                                    |
+      | title       | Roteiro API Edit                                        |
+      | description | Descrição Original                                       |
+      | tasks       | [{"id":"t1","statement":"Task Original"}]               |
+    And I submit a request to edit script with:
+      | field       | value                                                    |
+      | title       | Roteiro API Edit Atualizado                             |
+      | description | Descrição Atualizada                                     |
+      | tasks       | [{"id":"t2","statement":"Task Atualizada"}]             |
+    Then the script request should be accepted successfully
+    And the server should have stored the script with:
+      | field       | value                                                    |
+      | title       | Roteiro API Edit Atualizado                             |
+      | description | Descrição Atualizada                                     |
+      | tasks       | [{"id":"t2","statement":"Task Atualizada"}]             |

From 3c1763504dad56ff56f7a0889ea5f6b218b0ff06 Mon Sep 17 00:00:00 2001
From: hlpaa <hlpaa@cin.ufpe.br>
Date: Wed, 10 Dec 2025 08:47:19 -0300
Subject: [PATCH 099/102] end to endt tests fix server

---
 .../features/server-script-management.feature | 23 +++++++++++++++++++
 .../step-definitions/server-script-steps.ts   |  4 ++++
 2 files changed, 27 insertions(+)

diff --git a/client/src/features/server-script-management.feature b/client/src/features/server-script-management.feature
index ada02db3..3ae72f9c 100644
--- a/client/src/features/server-script-management.feature
+++ b/client/src/features/server-script-management.feature
@@ -39,3 +39,26 @@ Feature: Server Script Management
       | title       | Roteiro API Edit Atualizado                             |
       | description | Descrição Atualizada                                     |
       | tasks       | [{"id":"t2","statement":"Task Atualizada"}]             |
+
+  Scenario: Attempt to create script with missing required fields
+    Given there is no script with title "Roteiro Incompleto" in the server
+    When I submit a request to create script with:
+      | field       | value                                                    |
+      | title       |                                                          |
+      | description | Descrição sem título                                     |
+      | tasks       | [{"id":"t1","statement":"Task 1"}]                      |
+    Then the script request should be rejected with error
+
+  Scenario: Attempt to create script with duplicate title
+    Given there is no script with title "Roteiro Duplicado" in the server
+    When I submit a request to create script with:
+      | field       | value                                                    |
+      | title       | Roteiro Duplicado                                        |
+      | description | Primeira tentativa                                       |
+      | tasks       | [{"id":"t1","statement":"Task 1"}]                      |
+    And I submit a request to create script with:
+      | field       | value                                                    |
+      | title       | Roteiro Duplicado                                        |
+      | description | Segunda tentativa                                        |
+      | tasks       | [{"id":"t2","statement":"Task 2"}]                      |
+    Then the script request should be rejected with error
diff --git a/client/src/step-definitions/server-script-steps.ts b/client/src/step-definitions/server-script-steps.ts
index b936a3b4..212ec8b2 100644
--- a/client/src/step-definitions/server-script-steps.ts
+++ b/client/src/step-definitions/server-script-steps.ts
@@ -72,6 +72,10 @@ Then('the script request should be accepted successfully', async function () {
   expect([200, 201]).toContain(lastResponse.status);
 });
 
+Then('the script request should be rejected with error', async function () {
+  expect([400, 409]).toContain(lastResponse.status);
+});
+
 Then('the server should have stored the script with:', async function (dataTable: DataTable) {
   const expected = dataTable.rowsHash();
   const response = await fetch(`${serverUrl}/api/scripts/${testScriptId}`);

From 4bf1301973db73dce7d7cd5b0ce500949b7ca296 Mon Sep 17 00:00:00 2001
From: hlpaa <hlpaa@cin.ufpe.br>
Date: Wed, 10 Dec 2025 20:06:22 -0300
Subject: [PATCH 100/102] adjusting gui end to end test create script

---
 client/src/step-definitions/script-steps.ts | 362 ++++++++++++++------
 1 file changed, 253 insertions(+), 109 deletions(-)

diff --git a/client/src/step-definitions/script-steps.ts b/client/src/step-definitions/script-steps.ts
index 2e40a56d..08288428 100644
--- a/client/src/step-definitions/script-steps.ts
+++ b/client/src/step-definitions/script-steps.ts
@@ -2,43 +2,69 @@ import { After, Before, DataTable, Given, setDefaultTimeout, Then, When } from '
 import expect from 'expect';
 import { Browser, launch, Page } from 'puppeteer';
 
-setDefaultTimeout(30 * 1000);
+// Set default timeout for all steps
+setDefaultTimeout(30 * 1000); // 30 seconds
 
 let browser: Browser;
 let page: Page;
 const baseUrl = 'http://localhost:3004';
+const serverUrl = 'http://localhost:3005';
+
+// Test data to clean up
 let testScriptTitle: string;
 
 Before({ tags: '@gui' }, async function () {
-  browser = await launch({ headless: false, slowMo: 50 });
+  browser = await launch({ 
+    headless: false, // Set to true for CI/CD
+    slowMo: 50 // Slow down actions for visibility
+  });
   page = await browser.newPage();
   await page.setViewport({ width: 1280, height: 720 });
 });
 
 After({ tags: '@gui' }, async function () {
+  // Clean up test script if it exists
   if (testScriptTitle) {
     try {
+      // Navigate to Scripts area
       await page.goto(baseUrl);
-      await page.waitForSelector('.scripts-list table', { timeout: 5000 });
-      const scriptRows = await page.$$('[data-testid^="script-row-"]');
-      for (const row of scriptRows) {
-        const titleCell = await row.$('[data-testid="script-title"]');
-        if (titleCell) {
-          const title = await page.evaluate(el => el.textContent, titleCell);
+      
+      // Click on Scripts tab
+      await page.waitForSelector('button', { timeout: 5000 });
+      await page.evaluate(() => {
+        const buttons = Array.from(document.querySelectorAll('button'));
+        const scriptsButton = buttons.find(btn => btn.textContent?.includes('Scripts'));
+        if (scriptsButton) scriptsButton.click();
+      });
+      await new Promise(resolve => setTimeout(resolve, 1000));
+      
+      // Look for our test script and delete it if found
+      const scriptItems = await page.$$('[data-testid^="script-item-"]');
+      for (const item of scriptItems) {
+        const titleElement = await item.$('[data-testid="script-title"]');
+        if (titleElement) {
+          const title = await page.evaluate(el => el.textContent, titleElement);
           if (title === testScriptTitle) {
-            page.once('dialog', async (dialog) => { await dialog.accept(); });
-            const deleteButton = await row.$(`[data-testid="delete-script-${title}"]`);
+            // Click the delete button for this script
+            const deleteButton = await item.$(`[data-testid="delete-script-${title}"]`);
             if (deleteButton) {
               await deleteButton.click();
+              // Wait for deletion to complete
               await new Promise(resolve => setTimeout(resolve, 1000));
+              console.log(`GUI cleanup: Removed test script with title: ${title}`);
               break;
             }
           }
         }
       }
-    } catch (error) {}
+    } catch (error) {
+      console.log('GUI cleanup: Script may not exist or GUI unavailable');
+    }
+  }
+  
+  if (browser) {
+    await browser.close();
   }
-  if (browser) await browser.close();
 });
 
 Given('the script management system is running', async function () {
@@ -50,132 +76,250 @@ Given('the script management system is running', async function () {
 
 Given('there is no script with title {string} in the system', async function (title: string) {
   testScriptTitle = title;
+  
+  // Navigate to the application and check if script exists through GUI
   await page.goto(baseUrl);
-  await page.waitForSelector('.scripts-list', { timeout: 10000 });
-  const scriptRows = await page.$$('[data-testid^="script-row-"]');
-  for (const row of scriptRows) {
-    const titleCell = await row.$('[data-testid="script-title"]');
-    if (titleCell) {
-      const displayedTitle = await page.evaluate(el => el.textContent, titleCell);
-      if (displayedTitle === title) {
-        page.once('dialog', async (dialog) => { await dialog.accept(); });
-        const deleteButton = await row.$(`[data-testid="delete-script-${displayedTitle}"]`);
-        if (deleteButton) {
-          await deleteButton.click();
-          await new Promise(resolve => setTimeout(resolve, 1000));
-          break;
-        }
-      }
+  
+  // Click on Scripts tab
+  await page.waitForSelector('button', { timeout: 10000 });
+  const buttonClicked = await page.evaluate(() => {
+    const buttons = Array.from(document.querySelectorAll('button'));
+    const scriptsButton = buttons.find(btn => btn.textContent?.includes('Scripts'));
+    if (scriptsButton) {
+      scriptsButton.click();
+      return true;
     }
+    return false;
+  });
+  
+  if (!buttonClicked) {
+    throw new Error('Scripts tab button not found');
   }
-  await page.reload();
-  await page.waitForSelector('.scripts-list', { timeout: 5000 });
-  const updatedRows = await page.$$('[data-testid^="script-row-"]');
-  for (const row of updatedRows) {
-    const titleCell = await row.$('[data-testid="script-title"]');
-    if (titleCell) {
-      const displayedTitle = await page.evaluate(el => el.textContent, titleCell);
-      if (displayedTitle === title) {
-        throw new Error(`Script with title ${displayedTitle} still exists in the system after cleanup`);
+  
+  await new Promise(resolve => setTimeout(resolve, 1000));
+  
+  // Try to find the script with the given title
+  try {
+    const scriptItems = await page.$$('[data-testid^="script-item-"]');
+    for (const item of scriptItems) {
+      const titleElement = await item.$('[data-testid="script-title"]');
+      if (titleElement) {
+        const scriptTitle = await page.evaluate(el => el.textContent, titleElement);
+        if (scriptTitle === title) {
+          throw new Error(`Script with title "${title}" already exists in the system. Please clean up before running the test.`);
+        }
       }
     }
+  } catch (error) {
+    // If we can't find script elements, that's fine - it means no scripts exist
+    if (error instanceof Error && error.message.includes('already exists')) {
+      throw error;
+    }
   }
 });
 
 When('I navigate to the Scripts area', async function () {
-  const scriptsTab = await page.$('[data-testid="scripts-tab"]');
-  if (scriptsTab) {
-    const isActive = await page.evaluate(el => el?.classList.contains('active'), scriptsTab);
-    if (!isActive) await scriptsTab.click();
+  // Click on Scripts tab
+  await page.waitForSelector('button', { timeout: 10000 });
+  const buttonClicked = await page.evaluate(() => {
+    const buttons = Array.from(document.querySelectorAll('button'));
+    const scriptsButton = buttons.find(btn => btn.textContent?.includes('Scripts'));
+    if (scriptsButton) {
+      scriptsButton.click();
+      return true;
+    }
+    return false;
+  });
+  
+  if (!buttonClicked) {
+    throw new Error('Scripts tab button not found');
   }
-  await page.waitForSelector('[data-testid="script-form"]', { timeout: 5000 });
+  
+  // Wait for the Scripts page to load
+  await new Promise(resolve => setTimeout(resolve, 1000));
+  await page.waitForFunction(
+    () => document.querySelector('h2')?.textContent?.includes('Scripts'),
+    { timeout: 5000 }
+  );
 });
 
 When('I provide the script information:', async function (dataTable: DataTable) {
   const data = dataTable.rowsHash();
-  await page.waitForSelector('#title');
-  await page.click('#title');
-  await page.type('#title', data.title);
-  await page.click('#description');
-  await page.type('#description', data.description);
-  await page.click('#tasks');
-  await page.type('#tasks', data.tasks);
+  
+  // Wait for the script editor form to be visible
+  await page.waitForSelector('h3', { timeout: 5000 });
+  
+  // Fill in title
+  if (data.title) {
+    const titleInput = await page.waitForSelector('input[value=""]', { timeout: 5000 });
+    await titleInput.click({ clickCount: 3 }); // Select all
+    await titleInput.type(data.title);
+  }
+  
+  // Fill in description
+  if (data.description) {
+    const inputs = await page.$$('input');
+    if (inputs.length >= 2) {
+      await inputs[1].click({ clickCount: 3 }); // Select all
+      await inputs[1].type(data.description);
+    }
+  }
+  
+  // Handle tasks
+  if (data.tasks) {
+    let tasksArray;
+    try {
+      tasksArray = JSON.parse(data.tasks);
+      console.log('Parsed tasks:', tasksArray);
+    } catch (parseError) {
+      console.error('JSON parse error:', parseError);
+      throw new Error(`Failed to parse tasks JSON: ${data.tasks}`);
+    }
+    
+    try {
+      for (const task of tasksArray) {
+        console.log('Adding task:', task);
+        
+        // Fill in the task input field (placeholder="New task...")
+        const taskInput = await page.waitForSelector('input[placeholder="New task..."]', { timeout: 5000 });
+        await taskInput.click({ clickCount: 3 }); // Select all
+        await taskInput.type(task.statement);
+        
+        // Click "Add" button to add the task
+        await new Promise(resolve => setTimeout(resolve, 200));
+        const clicked = await page.evaluate(() => {
+          const buttons = Array.from(document.querySelectorAll('button'));
+          const addButton = buttons.find(btn => {
+            const text = btn.textContent?.trim();
+            return text === 'Add';
+          });
+          if (addButton) {
+            addButton.click();
+            return true;
+          }
+          return false;
+        });
+        
+        if (!clicked) {
+          throw new Error('Add button not found');
+        }
+        
+        // Wait a bit for the task to be added
+        await new Promise(resolve => setTimeout(resolve, 300));
+      }
+    } catch (error) {
+      console.error('Error adding tasks:', error);
+      throw error;
+    }
+  }
 });
 
 When('I send the script information', async function () {
-  const submitButton = await page.$('[data-testid="submit-script-button"]');
-  expect(submitButton).toBeTruthy();
-  await submitButton?.click();
-  await new Promise(resolve => setTimeout(resolve, 2000));
-});
-
-When('I edit the script information:', async function (dataTable: DataTable) {
-  const data = dataTable.rowsHash();
-  await page.goto(baseUrl);
-  await page.waitForSelector('.scripts-list table', { timeout: 10000 });
-  const scriptRows = await page.$$('[data-testid^="script-row-"]');
-  let foundScript = null;
-  for (const row of scriptRows) {
-    const titleCell = await row.$('[data-testid="script-title"]');
-    if (titleCell) {
-      const title = await page.evaluate(el => el.textContent, titleCell);
-      if (title === testScriptTitle) {
-        foundScript = row;
-        break;
-      }
+  // Click the Save button
+  const clicked = await page.evaluate(() => {
+    const buttons = Array.from(document.querySelectorAll('button'));
+    const saveButton = buttons.find(btn => btn.textContent?.includes('Save'));
+    if (saveButton) {
+      saveButton.click();
+      return true;
     }
+    return false;
+  });
+  
+  if (!clicked) {
+    throw new Error('Save button not found');
   }
-  expect(foundScript).toBeTruthy();
-  const editButton = await foundScript!.$('[data-testid="edit-script-button"]');
-  expect(editButton).toBeTruthy();
-  await editButton?.click();
-  await page.waitForSelector('[data-testid="script-form"]', { timeout: 5000 });
-  await page.click('#title', { clickCount: 3 });
-  await page.type('#title', data.title);
-  await page.click('#description', { clickCount: 3 });
-  await page.type('#description', data.description);
-  await page.click('#tasks', { clickCount: 3 });
-  await page.type('#tasks', data.tasks);
-  const submitButton = await page.$('[data-testid="submit-script-button"]');
-  expect(submitButton).toBeTruthy();
-  await submitButton?.click();
-  await new Promise(resolve => setTimeout(resolve, 2000));
-  testScriptTitle = data.title;
+  
+  // Wait for the script to be saved (wait for page to update)
+  await new Promise(resolve => setTimeout(resolve, 1500));
 });
 
 Then('I should see {string} in the script list', async function (scriptTitle: string) {
-  await page.waitForSelector('.scripts-list table', { timeout: 10000 });
-  const scriptRows = await page.$$('[data-testid^="script-row-"]');
-  let foundScript = null;
-  for (const row of scriptRows) {
-    const titleCell = await row.$('[data-testid="script-title"]');
-    if (titleCell) {
-      const title = await page.evaluate(el => el.textContent, titleCell);
+  // Wait for the script list to update
+  await new Promise(resolve => setTimeout(resolve, 1000));
+  
+  try {
+    await page.waitForFunction(
+      () => document.querySelector('h3')?.textContent?.includes('Existing Scripts'),
+      { timeout: 5000 }
+    );
+  } catch {
+    // If the header doesn't exist, that's ok - just continue
+  }
+  
+  // Check if the script appears in the list
+  const pageContent = await page.content();
+  expect(pageContent).toContain(scriptTitle);
+  
+  // Alternatively, look for the script item with the specific title
+  const scriptItems = await page.$$('[data-testid^="script-item-"]');
+  let found = false;
+  
+  for (const item of scriptItems) {
+    const titleElement = await item.$('[data-testid="script-title"]');
+    if (titleElement) {
+      const title = await page.evaluate(el => el.textContent, titleElement);
       if (title === scriptTitle) {
-        foundScript = row;
+        found = true;
         break;
       }
     }
   }
-  expect(foundScript).toBeTruthy();
+  
+  // If data-testid approach doesn't work, try a more general approach
+  if (!found) {
+    const scriptListText = await page.$eval('body', el => el.textContent || '');
+    expect(scriptListText).toContain(scriptTitle);
+  }
 });
 
-Then('the script should have description {string}', async function (expectedDescription: string) {
-  await page.waitForSelector('.scripts-list table', { timeout: 10000 });
-  const scriptRows = await page.$$('[data-testid^="script-row-"]');
-  let foundScript = null;
-  for (const row of scriptRows) {
-    const titleCell = await row.$('[data-testid="script-title"]');
-    if (titleCell) {
-      const title = await page.evaluate(el => el.textContent, titleCell);
-      if (title === testScriptTitle) {
-        foundScript = row;
-        break;
-      }
+Then('the script should have description {string}', async function (description: string) {
+  // Since the description is not shown in the list, we need to click Edit to verify it
+  // First, find and click the Edit button for the last script in the list
+  const editClicked = await page.evaluate(() => {
+    const buttons = Array.from(document.querySelectorAll('button'));
+    const editButtons = buttons.filter(btn => btn.textContent?.trim() === 'Edit');
+    if (editButtons.length > 0) {
+      // Click the last Edit button (most recently added script)
+      editButtons[editButtons.length - 1].click();
+      return true;
+    }
+    return false;
+  });
+  
+  if (!editClicked) {
+    throw new Error('Edit button not found');
+  }
+  
+  // Wait for the edit form to appear
+  await new Promise(resolve => setTimeout(resolve, 500));
+  
+  // Check if the description input has the correct value
+  const inputs = await page.$$('input');
+  let foundDescription = false;
+  
+  for (const input of inputs) {
+    const value = await page.evaluate(el => (el as HTMLInputElement).value, input);
+    if (value === description) {
+      foundDescription = true;
+      break;
+    }
+  }
+  
+  expect(foundDescription).toBe(true);
+  
+  // Click Cancel to return to the list view
+  const cancelClicked = await page.evaluate(() => {
+    const buttons = Array.from(document.querySelectorAll('button'));
+    const cancelButton = buttons.find(btn => btn.textContent?.trim() === 'Cancel');
+    if (cancelButton) {
+      cancelButton.click();
+      return true;
     }
+    return false;
+  });
+  
+  if (cancelClicked) {
+    await new Promise(resolve => setTimeout(resolve, 300));
   }
-  expect(foundScript).toBeTruthy();
-  const descCell = await foundScript!.$('[data-testid="script-description"]');
-  const actualDesc = await page.evaluate(el => el.textContent, descCell!);
-  expect(actualDesc).toBe(expectedDescription);
 });

From 4fdce1dc27cc59b3f63b1c9118c8cb1066dc3c0b Mon Sep 17 00:00:00 2001
From: Davi Guerreiro <daviguerreiro9a@gmail.com>
Date: Wed, 10 Dec 2025 23:15:57 -0300
Subject: [PATCH 101/102] fix(scriptAnswerGrid):to contain class id

---
 client/src/components/ScriptGrading/ScriptAnswerGrid.tsx | 1 +
 1 file changed, 1 insertion(+)

diff --git a/client/src/components/ScriptGrading/ScriptAnswerGrid.tsx b/client/src/components/ScriptGrading/ScriptAnswerGrid.tsx
index 4ec88f7a..41ce79ca 100644
--- a/client/src/components/ScriptGrading/ScriptAnswerGrid.tsx
+++ b/client/src/components/ScriptGrading/ScriptAnswerGrid.tsx
@@ -57,6 +57,7 @@ export default function ScriptAnswerGrid({ scriptAnswers, onSelect }: Props) {
         >
           <strong>Script: {loading ? "Loading..." : scriptTitles[sa.scriptId] || sa.scriptId}</strong><br />
           Student: {sa.student}<br />
+          Class: {sa.classId}<br />
           Grade: {sa.grade ?? "—"}
         </div>
       ))}

From 5d872369b576be915291d00214fe4679cd13b546 Mon Sep 17 00:00:00 2001
From: Davi Guerreiro <daviguerreiro9a@gmail.com>
Date: Thu, 11 Dec 2025 10:53:36 -0300
Subject: [PATCH 102/102] fix(): Integrando testes

---
 .../server-newScriptAnswer-steps.ts           |  19 +-
 .../server-scriptAnswer-steps.ts              |  36 +++-
 .../step-definitions/server-student-steps.ts  |   9 -
 server/data/app-data.json                     | 199 ++++++++++++++++++
 server/src/__tests__/ScriptAnswerSet.test.ts  |   8 +-
 server/src/__tests__/scriptgrading.test.ts    |  31 ++-
 server/src/mock_scripts.ts                    | 104 +++++----
 server/src/server_routes/scriptanswer.ts      |  10 +
 8 files changed, 356 insertions(+), 60 deletions(-)

diff --git a/client/src/step-definitions/server-newScriptAnswer-steps.ts b/client/src/step-definitions/server-newScriptAnswer-steps.ts
index 5c2cce2e..4332f51a 100644
--- a/client/src/step-definitions/server-newScriptAnswer-steps.ts
+++ b/client/src/step-definitions/server-newScriptAnswer-steps.ts
@@ -1,4 +1,4 @@
-import { Given, When, Then } from '@cucumber/cucumber';
+import { Given, When, Then, Before, After } from '@cucumber/cucumber';
 import expect from 'expect';
 
 const API_URL = 'http://localhost:3005/api';
@@ -26,6 +26,23 @@ const context: TestContext = {
   studentsByCPF: new Map(),
 };
 
+Before({ tags: '@server' }, async function () {
+  try {
+    await fetchAPI('POST', '/reset-mock-data');
+  } catch (error) {
+    console.warn('⚠ Could not reset mock data:', error);
+  }
+});
+
+After({ tags: '@server' }, async function () {
+  try {
+    await fetchAPI('DELETE', '/scriptanswers');
+    console.log('✓ Cleanup: Deleted all scriptanswers');
+  } catch (error) {
+    console.warn('⚠ Cleanup failed:', error);
+  }
+});
+
 // ============================================================
 // Helper Functions
 // ============================================================
diff --git a/client/src/step-definitions/server-scriptAnswer-steps.ts b/client/src/step-definitions/server-scriptAnswer-steps.ts
index 8931f504..8fa4fbd6 100644
--- a/client/src/step-definitions/server-scriptAnswer-steps.ts
+++ b/client/src/step-definitions/server-scriptAnswer-steps.ts
@@ -7,6 +7,7 @@ import expect from 'expect';
 setDefaultTimeout(30 * 10000);
 
 const serverUrl = 'http://localhost:3005';
+const CLASS_ID = 'Math101-2024-2024';
 
 // ============================================================
 // Shared test state
@@ -64,11 +65,42 @@ async function createScript(title : string, id: string) {
   return response;
 }
 
+async function ensureClassExists(classId: string = CLASS_ID) {
+  const res = await fetch(`${serverUrl}/api/classes`);
+  const classes = await res.json();
+  const found = classes.find((c: any) => c.id === classId);
+  if (found) return found;
+
+  const [topic, year, semester] = classId.split('-');
+  const response = await fetch(`${serverUrl}/api/classes`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ topic, year: Number(year) || 2024, semester: Number(semester) || 1 })
+  });
+  return response.json();
+}
+
+async function ensureEnrollmentExists(cpf: string, classId: string = CLASS_ID) {
+  const res = await fetch(`${serverUrl}/api/classes`);
+  const classes = await res.json();
+  const found = classes.find((c: any) => c.id === classId);
+  if (!found) return;
+  const enrolled = found.enrollments?.some((e: any) => e.studentCPF === cpf);
+  if (enrolled) return;
+  await fetch(`${serverUrl}/api/classes/${classId}/enroll`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ studentCPF: cpf })
+  });
+}
+
 
 
 
-async function createScriptAnswer(id: string, studentId: string) {
+async function createScriptAnswer(id: string, studentId: string, classId: string = CLASS_ID) {
   await createScript(`Script for ${id}`, `script-${id}`);
+  await ensureClassExists(classId);
+  await ensureEnrollmentExists(studentId, classId);
 
   const check = await fetch(`${serverUrl}/api/scriptanswers/${id}`);
   if (check.status === 200) {
@@ -80,7 +112,7 @@ async function createScriptAnswer(id: string, studentId: string) {
   const response = await fetch(`${serverUrl}/api/scriptanswers/`, {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ id, scriptId: `script-${id}`, studentId, answers: [] })
+    body: JSON.stringify({ id, scriptId: `script-${id}`, classId, studentId, answers: [] })
   });
 
   if (response.status === 201) {
diff --git a/client/src/step-definitions/server-student-steps.ts b/client/src/step-definitions/server-student-steps.ts
index bd994ca6..808c9ed8 100644
--- a/client/src/step-definitions/server-student-steps.ts
+++ b/client/src/step-definitions/server-student-steps.ts
@@ -27,15 +27,6 @@ After({ tags: '@server' }, async function () {
   }
 });
 
-Given('the server API is available', async function () {
-  try {
-    const response = await fetch(`${serverUrl}/api/students`);
-    expect(response.status).toBe(200);
-  } catch (error) {
-    throw new Error('Server is not available. Make sure the backend server is running on port 3005');
-  }
-});
-
 Given('there is no student with CPF {string} in the server', async function (cpf: string) {
   testStudentCPF = cpf;
   
diff --git a/server/data/app-data.json b/server/data/app-data.json
index fbadf223..38a5b5fd 100644
--- a/server/data/app-data.json
+++ b/server/data/app-data.json
@@ -19,6 +19,16 @@
       "name": "Joana Refatoração",
       "cpf": "55555555555",
       "email": "jr@gmail.com"
+    },
+    {
+      "name": "Pedro Oliveira",
+      "cpf": "12345678901",
+      "email": "pedro@example.com"
+    },
+    {
+      "name": "Maria Santos",
+      "cpf": "99999999999",
+      "email": "maria@example.com"
     }
   ],
   "classes": [
@@ -192,6 +202,195 @@
           ]
         }
       ]
+    },
+    {
+      "topic": "Math101",
+      "semester": 2024,
+      "year": 2024,
+      "especificacaoDoCalculoDaMedia": {
+        "pesosDosConceitos": {
+          "MA": 10,
+          "MPA": 7,
+          "MANA": 0
+        },
+        "pesosDasMetas": {
+          "Gerência de Configuração": 1,
+          "Gerência de Projeto": 1,
+          "Qualidade de Software": 1
+        }
+      },
+      "enrollments": [
+        {
+          "studentCPF": "11111111111",
+          "evaluations": []
+        },
+        {
+          "studentCPF": "12345678901",
+          "evaluations": []
+        }
+      ]
+    }
+  ],
+  "scriptAnswers": [
+    {
+      "id": "scriptanswer-start",
+      "scriptId": "script-002",
+      "classId": "Math101-2024-2024",
+      "student": "11111111111",
+      "answers": [],
+      "started_at": 1765460950458,
+      "status": "in_progress"
+    },
+    {
+      "id": "scriptanswer-submit-nonfinal",
+      "scriptId": "script-002",
+      "classId": "Math101-2024-2024",
+      "student": "11111111111",
+      "answers": [
+        {
+          "id": "ta-nf-001",
+          "task": "task-001",
+          "answer": "",
+          "started_at": 1765460950458,
+          "comments": "",
+          "status": "started"
+        }
+      ],
+      "started_at": 1765460950458,
+      "status": "in_progress"
+    },
+    {
+      "id": "scriptanswer-submit-final",
+      "scriptId": "script-002",
+      "classId": "Math101-2024-2024",
+      "student": "11111111111",
+      "answers": [
+        {
+          "id": "ta-f-001",
+          "task": "task-001",
+          "answer": "Already submitted",
+          "started_at": 1765460940458,
+          "submitted_at": 1765460941458,
+          "time_taken_seconds": 1,
+          "grade": "MA",
+          "comments": "",
+          "status": "submitted"
+        },
+        {
+          "id": "ta-f-002",
+          "task": "task-002",
+          "answer": "Already submitted",
+          "started_at": 1765460942458,
+          "submitted_at": 1765460943458,
+          "time_taken_seconds": 1,
+          "grade": "MA",
+          "comments": "",
+          "status": "submitted"
+        },
+        {
+          "id": "ta-f-003",
+          "task": "task-003",
+          "answer": "",
+          "started_at": 1765460950458,
+          "comments": "",
+          "status": "started"
+        }
+      ],
+      "started_at": 1765460950458,
+      "status": "in_progress"
+    },
+    {
+      "id": "scriptanswer-timeout",
+      "scriptId": "script-003",
+      "classId": "Math101-2024-2024",
+      "student": "11111111111",
+      "answers": [
+        {
+          "id": "ta-t-001",
+          "task": "task-001",
+          "answer": "",
+          "started_at": 1765453750458,
+          "comments": "",
+          "status": "started"
+        },
+        {
+          "id": "ta-t-002",
+          "task": "task-002",
+          "answer": "",
+          "started_at": 1765453750458,
+          "comments": "",
+          "status": "started"
+        },
+        {
+          "id": "ta-t-003",
+          "task": "task-003",
+          "answer": "",
+          "started_at": 1765460950458,
+          "comments": "",
+          "status": "pending"
+        }
+      ],
+      "started_at": 1765453750458,
+      "status": "in_progress"
+    },
+    {
+      "id": "scriptanswer-resubmit-fail",
+      "scriptId": "script-004",
+      "classId": "Math101-2024-2024",
+      "student": "11111111111",
+      "answers": [
+        {
+          "id": "ta-rsf-001",
+          "task": "task-001",
+          "answer": "Already submitted",
+          "started_at": 1765460950458,
+          "submitted_at": 1765460950458,
+          "time_taken_seconds": 0,
+          "grade": "MA",
+          "comments": "",
+          "status": "submitted"
+        }
+      ],
+      "started_at": 1765460950458,
+      "status": "in_progress"
+    },
+    {
+      "id": "enrollment-001",
+      "scriptId": "script-001",
+      "classId": "Math101-2024-2024",
+      "student": "12345678901",
+      "answers": [
+        {
+          "id": "ta-enroll-001",
+          "task": "task-001",
+          "answer": "Test response for enrollment query",
+          "started_at": 1765460950458,
+          "grade": "MA",
+          "comments": "",
+          "status": "started"
+        }
+      ],
+      "started_at": 1765460950458,
+      "status": "in_progress"
+    },
+    {
+      "id": "enrollment-002",
+      "scriptId": "script-002",
+      "classId": "Math101-2024-2024",
+      "student": "12345678901",
+      "answers": [
+        {
+          "id": "ta-enroll-002",
+          "task": "task-001",
+          "answer": "Another test response",
+          "started_at": 1765460950459,
+          "grade": "MPA",
+          "comments": "",
+          "status": "started"
+        }
+      ],
+      "started_at": 1765460950459,
+      "status": "in_progress"
     }
   ]
 }
\ No newline at end of file
diff --git a/server/src/__tests__/ScriptAnswerSet.test.ts b/server/src/__tests__/ScriptAnswerSet.test.ts
index 8c9b0e3a..70a3278d 100644
--- a/server/src/__tests__/ScriptAnswerSet.test.ts
+++ b/server/src/__tests__/ScriptAnswerSet.test.ts
@@ -74,9 +74,9 @@ describe('ScriptAnswerSet', () => {
   // -----------------------------------------
   describe('removeAllScriptAnswers', () => {
     test('should remove all script answers and return the count', () => {
-      set.addScriptAnswer({ id: 'A1', scriptId: 'S1', studentId: 'ST1' });
-      set.addScriptAnswer({ id: 'A2', scriptId: 'S2', studentId: 'ST2' });
-      set.addScriptAnswer({ id: 'A3', scriptId: 'S3', studentId: 'ST3' });
+      set.addScriptAnswer({ id: 'A1', scriptId: 'S1', classId: 'C1', studentId: 'ST1' });
+      set.addScriptAnswer({ id: 'A2', scriptId: 'S2', classId: 'C2', studentId: 'ST2' });
+      set.addScriptAnswer({ id: 'A3', scriptId: 'S3', classId: 'C3', studentId: 'ST3' });
       expect(set.getAll().length).toBe(3);
 
       const count = set.removeAllScriptAnswers();
@@ -98,6 +98,7 @@ describe('ScriptAnswerSet', () => {
       set.addScriptAnswer({ 
         id: 'A1', 
         scriptId: 'S1', 
+        classId: 'C1',
         studentId: 'ST1', 
         grade: 'MA',
         taskAnswers: [
@@ -107,6 +108,7 @@ describe('ScriptAnswerSet', () => {
       set.addScriptAnswer({ 
         id: 'A2', 
         scriptId: 'S2', 
+        classId: 'C2',
         studentId: 'ST2', 
         grade: 'MANA'
       });
diff --git a/server/src/__tests__/scriptgrading.test.ts b/server/src/__tests__/scriptgrading.test.ts
index 14e09121..09e93273 100644
--- a/server/src/__tests__/scriptgrading.test.ts
+++ b/server/src/__tests__/scriptgrading.test.ts
@@ -3,7 +3,6 @@ import { app, scriptAnswerSet, studentSet, classes, scripts } from '../server';
 import { Student } from '../models/Student';
 import { TaskAnswer } from '../models/TaskAnswer';
 import { Class } from '../models/Class';
-import { Script } from '../models/Script';
 import { Task } from '../models/Task';
 import { EspecificacaoDoCalculoDaMedia } from '../models/EspecificacaoDoCalculoDaMedia';
 
@@ -24,6 +23,9 @@ describe('Server API – Script Answers Endpoints', () => {
     const allClasses = classes.getAllClasses();
     allClasses.forEach(c => classes.removeClass(c.getClassId()));
 
+    // Clear scripts
+    scripts.getAllScripts().length = 0;
+
     // Create test student with valid 11-digit CPF
     const testStudent = new Student('Test Student', '12345678901', 'test@test.com');
     studentSet.addStudent(testStudent);
@@ -37,9 +39,16 @@ describe('Server API – Script Answers Endpoints', () => {
     // Enroll student in class
     testClass.addEnrollment(testStudent);
 
-    // Create test script
-    const testScript = new Script('1', 'Test Script');
-    scripts.addScript({ id: '1', title: 'Test Script' });
+    // Create test script with tasks (required by Scripts.addScript)
+    scripts.addScript({
+      id: '1',
+      title: 'Test Script',
+      description: 'Test Script Description',
+      tasks: [
+        { id: 't1', statement: 'Task 1' },
+        { id: 't2', statement: 'Task 2' }
+      ]
+    });
   });
 
   // ----------------------------------------------------------
@@ -185,7 +194,6 @@ describe('Server API – Script Answers Endpoints', () => {
   // ----------------------------------------------------------
 
   test('POST /api/scriptanswers → creates a new script answer', async () => {
-    scripts.addScript({ id: '1', title: 'Test Script', tasks: [{id: 't1'}], description: 'desc' });
     const res = await request(app)
       .post('/api/scriptanswers/')
       .send({
@@ -271,7 +279,12 @@ describe('Server API – Script Answers Endpoints', () => {
   // ----------------------------------------------------------
 
   test('DELETE /api/scriptanswers/:id → deletes existing script answer', async () => {
-    scriptAnswerSet.addScriptAnswer({ id: '130', scriptId: '1', studentId: 'S1' });
+    scriptAnswerSet.addScriptAnswer({
+      id: '130',
+      scriptId: '1',
+      classId: 'Test Class-2024-1',
+      studentId: '12345678901'
+    });
     expect(scriptAnswerSet.getAll().length).toBe(1);
 
     const res = await request(app).delete('/api/scriptanswers/130');
@@ -298,9 +311,9 @@ describe('Server API – Script Answers Endpoints', () => {
   // ----------------------------------------------------------
 
   test('DELETE /api/scriptanswers → deletes all script answers', async () => {
-    scriptAnswerSet.addScriptAnswer({ id: '140', scriptId: '1', studentId: 'S1' });
-    scriptAnswerSet.addScriptAnswer({ id: '141', scriptId: '2', studentId: 'S2' });
-    scriptAnswerSet.addScriptAnswer({ id: '142', scriptId: '3', studentId: 'S3' });
+    scriptAnswerSet.addScriptAnswer({ id: '140', scriptId: '1', classId: 'Test Class-2024-1', studentId: '12345678901' });
+    scriptAnswerSet.addScriptAnswer({ id: '141', scriptId: '1', classId: 'Test Class-2024-1', studentId: '12345678901' });
+    scriptAnswerSet.addScriptAnswer({ id: '142', scriptId: '1', classId: 'Test Class-2024-1', studentId: '12345678901' });
     expect(scriptAnswerSet.getAll().length).toBe(3);
 
     const res = await request(app).delete('/api/scriptanswers/');
diff --git a/server/src/mock_scripts.ts b/server/src/mock_scripts.ts
index fa6ef1a4..0bb3e2b3 100644
--- a/server/src/mock_scripts.ts
+++ b/server/src/mock_scripts.ts
@@ -71,58 +71,90 @@ export function loadMockScriptsAndAnswers(
       console.log('✓ Student 3 enrolled:', student3.getCPF());
     }
     // Create mock tasks if none exist
-    if (taskset.getAllTasks().length === 0) {
-      const task1 = taskset.addTask(
+    let task1 = taskset.findById('task-001');
+    if (!task1) {
+      task1 = taskset.addTask(
         new Task('task-001', 'Explain the basic concepts covered in class')
       );
+      console.log('✓ Task created: task-001');
+    } else {
+      console.log('✓ Task already exists: task-001');
+    }
 
-      const task2 = taskset.addTask(
+    let task2 = taskset.findById('task-002');
+    if (!task2) {
+      task2 = taskset.addTask(
         new Task('task-002', 'Implement the algorithm discussed')
       );
+      console.log('✓ Task created: task-002');
+    } else {
+      console.log('✓ Task already exists: task-002');
+    }
 
-      const task3 = taskset.addTask(
+    let task3 = taskset.findById('task-003');
+    if (!task3) {
+      task3 = taskset.addTask(
         new Task('task-003', 'Analyze the problem and propose a solution')
       );
-
-      console.log('Mock tasks created:', [task1.getId(), task2.getId(), task3.getId()]);
+      console.log('✓ Task created: task-003');
+    } else {
+      console.log('✓ Task already exists: task-003');
     }
 
     // Create mock scripts if none exist
-    if (scripts.getAllScripts().length === 0) {
       const foundTask1 = taskset.findById('task-001');
       const foundTask2 = taskset.findById('task-002');
       const foundTask3 = taskset.findById('task-003');
+      let script1 = scripts.findById('script-001');
+      if (!script1) {
+        script1 = scripts.addScript({
+          id: 'script-001',
+          title: 'Midterm Exam - Math 101',
+          description: 'Comprehensive midterm assessment',
+          tasks: [foundTask1, foundTask2, foundTask3].filter(Boolean)
+        });
+        console.log('✓ Script created: script-001');
+      } else {
+        console.log('✓ Script already exists: script-001');
+      }
 
-      const script1 = scripts.addScript({
-        id: 'script-001',
-        title: 'Midterm Exam - Math 101',
-        description: 'Comprehensive midterm assessment',
-        tasks: [foundTask1, foundTask2, foundTask3].filter(Boolean)
-      });
-
-      const script2 = scripts.addScript({
-        id: 'script-002',
-        title: 'Final Exam - Math 101',
-        description: 'Final comprehensive exam',
-        tasks: [foundTask1, foundTask2, foundTask3].filter(Boolean)
-      });
-
-      const script3 = scripts.addScript({
-        id: 'script-003',
-        title: 'Quiz - Programming 201',
-        description: 'Programming fundamentals quiz',
-        tasks: [foundTask2, foundTask3].filter(Boolean)
-      });
+      let script2 = scripts.findById('script-002');
+      if (!script2) {
+        script2 = scripts.addScript({
+          id: 'script-002',
+          title: 'Final Exam - Math 101',
+          description: 'Final comprehensive exam',
+          tasks: [foundTask1, foundTask2, foundTask3].filter(Boolean)
+        });
+        console.log('✓ Script created: script-002');
+      } else {
+        console.log('✓ Script already exists: script-002');
+      }
 
-      const script4 = scripts.addScript({
-        id: 'script-004',
-        title: 'Quiz - Programming 202',
-        description: 'Advanced programming quiz',
-        tasks: [foundTask2, foundTask3].filter(Boolean)
-      });
-
-      console.log('Mock scripts created:', [script1.getId(), script2.getId(), script3.getId(), script4.getId()]);
-    }
+      let script3 = scripts.findById('script-003');
+      if (!script3) {
+        script3 = scripts.addScript({
+          id: 'script-003',
+          title: 'Quiz - Programming 201',
+          description: 'Programming fundamentals quiz',
+          tasks: [foundTask2, foundTask3].filter(Boolean)
+        });
+        console.log('✓ Script created: script-003');
+      } else {
+        console.log('✓ Script already exists: script-003');
+      }
+      let script4 = scripts.findById('script-004');
+      if (!script4) {
+        script4 = scripts.addScript({
+          id: 'script-004',
+          title: 'Quiz - Programming 202',
+          description: 'Advanced programming quiz',
+          tasks: [foundTask2, foundTask3].filter(Boolean)
+        });
+        console.log('✓ Script created: script-004');
+      } else {
+        console.log('✓ Script already exists: script-004');
+      }
 
     // === Test data for individual scenarios ===
     // These are ALWAYS verified/created to ensure test isolation works properly
diff --git a/server/src/server_routes/scriptanswer.ts b/server/src/server_routes/scriptanswer.ts
index ac380836..1f6fad0b 100644
--- a/server/src/server_routes/scriptanswer.ts
+++ b/server/src/server_routes/scriptanswer.ts
@@ -366,4 +366,14 @@ app.post(scriptAnswerurl+':id/timeout', (req: Request, res: Response) => {
       return res.status(500).json({ error: 'Failed to delete all script answers' });
     }
   });
+
+  app.post('/api/reset-mock-data', (req: Request, res: Response) => {
+    try {
+      const { loadMockScriptsAndAnswers } = require('../mock_scripts');
+      loadMockScriptsAndAnswers(TaskSet, scripts, scriptAnswerSet, classes, studentSet, '11111111111');
+      return res.status(200).json({ message: 'Mock data reset successfully' });
+    } catch (error) {
+      return res.status(500).json({ error: (error as Error).message });
+    }
+  });
 }
\ No newline at end of file