{
padding: "6px 0",
}}
onClick={() => {
- setActiveSignatureTarget("coordinator");
- setShowModal(true);
+ if (!formData.locked) {
+ setActiveSignatureTarget("coordinator");
+ setShowModal(true);
+ }
}}
>
{renderSignaturePreview("coordinatorSignature")}
@@ -376,21 +405,29 @@ const A3JobEvaluationForm = () => {
handleChange("coordinatorAgreement", e.target.checked)
}
required
+ disabled={formData.locked}
/>
{/* Submit button */}
-
-
-
+
+ {formData.locked ? (
+
+ This form has been finalized and is locked for editing.
+
+ ) : (
+
+ )}
+
diff --git a/client/src/pages/CoordinatorDashboard.js b/client/src/pages/CoordinatorDashboard.js
index ed712155..afbd122f 100644
--- a/client/src/pages/CoordinatorDashboard.js
+++ b/client/src/pages/CoordinatorDashboard.js
@@ -25,10 +25,19 @@ const CoordinatorDashboard = () => {
setLoadingRequests(false);
}
};
- // Group D's Weekly Report Review Logic
- const [reportGroups, setReportGroups] = useState([]);
- const [loadingReports, setLoadingReports] = useState(true);
+ const approveForm = async (formId) => {
+ try {
+ await axios.post(
+ `${process.env.REACT_APP_API_URL}/api/approval/form/${formId}/approve`
+ );
+ alert("Form approved successfully!");
+ fetchRequests(); // refresh the list after approving
+ } catch (err) {
+ console.error("Failed to approve form:", err);
+ alert("Failed to approve form!");
+ }
+ };
useEffect(() => {
if (activeTab === "reports") {
@@ -69,53 +78,28 @@ const CoordinatorDashboard = () => {
Loading...
: (
- Loading reports...
: (
- reportGroups.length === 0
- ?
+
Company: {req.workplace.name}
+
+
+
+
+
This is a reminder to review the submission by ${submission.student_name}.
`,
+ text: `Reminder to review submission "${submission.name}".`,
+ });
+
+ // Update the document
+ submission.supervisor_reminder_count = reminderCount + 1;
+ submission.last_supervisor_reminder_at = new Date();
+ await submission.save();
+
+ console.log(`Reminder sent to supervisor for "${submission.name}"`);
+ }
+ }
+ } catch (err) {
+ console.error("Error in supervisorReminder:", err);
+ }
+};
+
+const Evaluation = require("../models/Evaluation");
+
+const evaluationReminder = async () => {
+ try {
+ const pendingEvals = await Evaluation.find({
+ evaluations: { $exists: false },
+ advisorAgreement: true,
+ });
+
+ for (const evalDoc of pendingEvals) {
+ const emailHtml = `
+ The deadline is approaching. Please use the link below to complete the evaluation:
+ This is a reminder to review the submission by ${student.email}.
`,
- text: `Reminder to review submission "${submission._id}".`,
- });
- }
-
- submission.supervisor_reminder_count = reminderCount + 1;
- submission.last_supervisor_reminder_at = new Date();
-
- try {
- await submission.save();
- } catch (err) {
- logger.error(`Failed to save submission: ${err.message}`);
- }
-
- logger.info(
- `[Reminder Sent] Supervisor: "${supervisor.email}" for "${submission.name}"`
- );
- }
+ console.log(`✅ Reminder sent for: ${evalDoc.interneeName}`);
}
- } catch (err) {
- logger.error("[SupervisorReminder Error]:", err.message || err);
+ } catch (error) {
+ console.error("❌ Error sending A.3 reminders:", error);
}
};
module.exports = {
- coordinatorReminder,
- supervisorReminder,
+ coordinatorReminder,
+ supervisorReminder,
+ evaluationReminder,
};
diff --git a/server/jobs/reminderEmail.test.js b/server/jobs/reminderEmail.test.js
new file mode 100644
index 00000000..28f71cc1
--- /dev/null
+++ b/server/jobs/reminderEmail.test.js
@@ -0,0 +1,180 @@
+const emailService = require("../services/emailService");
+const { coordinatorReminder, supervisorReminder } = require('./reminderEmail');
+const mockingoose = require("mockingoose");
+const Submission = require("../models/Submission");
+const NotificationLog = require("../models/NotifLog");
+const User = require("../models/User");
+const mongoose = require("mongoose");
+
+jest.mock("../services/emailService");
+
+describe("reminderEmail", () => {
+ beforeEach( () => {
+ emailService.sendEmail.mockClear();
+ });
+
+ it("coordinatorReminder sends email", async () => {
+ await coordinatorReminder();
+ // Check sendEmail was called
+ expect(emailService.sendEmail).toHaveBeenCalledTimes(1);
+ expect(emailService.sendEmail).toHaveBeenCalledWith({to: process.env.EMAIL_DEFAULT_SENDER,
+ subject: "Reminder: Coordinator Approval Pending",
+ html: "This is a cron-based reminder email from IPMS.
",
+ text: "Reminder: Coordinator Approval Pending",})
+ });
+})
+
+// Supervisor reminder test
+
+describe("supervisorReminder", () => {
+ beforeEach(() => {
+ mockingoose.resetAll();
+ jest.clearAllMocks();
+ });
+
+ it("should send a reminder to the supervisor", async () => {
+
+ const submissionId = new mongoose.Types.ObjectId();
+ const studentId = new mongoose.Types.ObjectId();
+ const studentMail = "student@example.com"
+ const supervisorId = new mongoose.Types.ObjectId();
+ const supervisorMail = "supervisor@example.com"
+
+ const fakeSubmission = {
+ _id: submissionId,
+ name: "Test Submission",
+ student_id: studentId,
+ supervisor_id: supervisorId,
+ createdAt: new Date(Date.now() - 8 * 24 * 60 * 60 * 1000),
+ supervisor_status: "pending",
+ supervisor_reminder_count: 0,
+ last_supervisor_reminder_at: new Date(Date.now() - 6 * 24 * 60 * 60 * 1000),
+ save: jest.fn(),
+ };
+
+ // Mocking the Submission model
+ mockingoose(Submission).toReturn([fakeSubmission], "find");
+ jest.spyOn(User, "findById").mockImplementation((id) => {
+ if (id.equals(studentId)) {
+ return Promise.resolve({ _id: studentId, email: studentMail });
+ }
+ if (id.equals(supervisorId)) {
+ return Promise.resolve({ _id: supervisorId, email: supervisorMail });
+ }
+ return Promise.resolve(null);
+ });
+ mockingoose(NotificationLog).toReturn({}, "save");
+ jest.spyOn(Submission.prototype, "save").mockResolvedValue(true);
+
+ // Function to be tested
+ await supervisorReminder();
+
+ // Expectations
+ expect(emailService.sendEmail).toHaveBeenCalledWith(
+ expect.objectContaining({
+ to: expect.any(String),
+ subject: expect.stringContaining("Reminder")
+ })
+ );
+
+ expect(Submission.prototype.save).toHaveBeenCalled();
+ });
+});
+
+describe("supervisorReminder escalation", () => {
+ beforeEach(() => {
+ mockingoose.resetAll();
+ jest.clearAllMocks();
+ jest.restoreAllMocks();
+ });
+
+ it("should return to the student after multiple reminders", async () => {
+ const submissionId = new mongoose.Types.ObjectId();
+ const studentId = new mongoose.Types.ObjectId();
+ const studentMail = "student@example.com"
+ const supervisorId = new mongoose.Types.ObjectId();
+ const supervisorMail = "supervisor@example.com"
+
+ const fakeSubmissionData = {
+ _id: submissionId,
+ name: "Escalation Case",
+ student_id: studentId,
+ supervisor_id: supervisorId,
+ createdAt: new Date(Date.now() - 12 * 24 * 60 * 60 * 1000), // 12 days ago
+ supervisor_status: "pending",
+ supervisor_reminder_count: 2, // trigger escalation
+ last_supervisor_reminder_at: new Date(Date.now() - 6 * 24 * 60 * 60 * 1000), // older than 5 days
+ };
+
+ mockingoose(Submission).toReturn([fakeSubmissionData], "find");
+
+ jest.spyOn(User, "findById").mockImplementation((id) => {
+ if (id.equals(studentId)) {
+ return Promise.resolve({ _id: studentId, email: studentMail });
+ }
+ if (id.equals(supervisorId)) {
+ return Promise.resolve({ _id: supervisorId, email: supervisorMail });
+ }
+ return Promise.resolve(null);
+ });
+
+ const saveSpy = jest.spyOn(Submission.prototype, "save").mockResolvedValue(true);
+ const notifLogSpy = jest.spyOn(NotificationLog, "create").mockResolvedValue(true);
+ mockingoose(NotificationLog).toReturn({}, "save");
+
+ await supervisorReminder();
+
+ // Confirm student escalation email was sent
+ expect(emailService.sendEmail).toHaveBeenCalledWith(
+ expect.objectContaining({
+ to: studentMail,
+ subject: expect.stringContaining("Supervisor Not Responding"),
+ })
+ );
+
+ // Confirm student escalation notification was logged
+ expect(notifLogSpy).toHaveBeenCalledWith(
+ expect.objectContaining({
+ submissionId: submissionId,
+ type: "studentEscalation",
+ recipientEmail: studentMail,
+ })
+ );
+
+ // Should NOT save the submission (unless you track escalations)
+ expect(saveSpy).not.toHaveBeenCalled();
+ });
+});
+
+const Evaluation = require("../models/Evaluation");
+
+describe("evaluationReminder", () => {
+ beforeEach(() => {
+ mockingoose.resetAll();
+ emailService.sendEmail.mockClear();
+ });
+
+ it("should send evaluation reminder emails to pending A.3 entries", async () => {
+ const fakeEval = {
+ _id: new mongoose.Types.ObjectId(),
+ interneeName: "Test Student",
+ interneeID: "113689712",
+ interneeEmail: "student@example.com",
+ advisorAgreement: true,
+ };
+
+ // Mock Evaluation.find to return one pending evaluation
+ mockingoose(Evaluation).toReturn([fakeEval], "find");
+
+ const { evaluationReminder } = require("./reminderEmail");
+ await evaluationReminder();
+
+ expect(emailService.sendEmail).toHaveBeenCalledTimes(1);
+ expect(emailService.sendEmail).toHaveBeenCalledWith(
+ expect.objectContaining({
+ to: "student@example.com",
+ subject: expect.stringContaining("Reminder: Pending A.3 Evaluation"),
+ })
+ );
+ });
+});
diff --git a/server/models/Evaluation.js b/server/models/Evaluation.js
index 4f838107..cbf5692e 100644
--- a/server/models/Evaluation.js
+++ b/server/models/Evaluation.js
@@ -1,29 +1,46 @@
const mongoose = require('mongoose');
const formMetadata = require('./FormMetadata');
+// Signature schema for both supervisor and coordinator
const signatureSchema = new mongoose.Schema({
- type: { type: String, enum: ['text', 'draw'], required: true },
- value: { type: String, required: true },
- font: { type: String }
+ type: {
+ type: String,
+ enum: ['text', 'draw'],
+ required: true
+ },
+ value: {
+ type: String,
+ required: true
+ },
+ font: {
+ type: String // used only if type is 'text'
+ }
}, { _id: false });
+// Individual evaluation item schema
const evaluationItemSchema = new mongoose.Schema({
category: {
type: String,
- required: true,
+ required: true
},
rating: {
type: String,
enum: ['Satisfactory', 'Unsatisfactory'],
required: true
},
- comment: { type: String, maxlength: 500 }
+ comment: {
+ type: String,
+ maxlength: 500
+ }
}, { _id: false });
+// Main evaluation schema
const evaluationSchema = new mongoose.Schema({
- ...formMetadata,
- interneeId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: false },
- internshipId: { type: mongoose.Schema.Types.ObjectId, ref: 'Internship', required: false },
+ internshipId: {
+ type: mongoose.Schema.Types.ObjectId,
+ ref: 'Internship',
+ required: false
+ },
interneeName: {
type: String,
@@ -36,29 +53,60 @@ const evaluationSchema = new mongoose.Schema({
interneeID: {
type: String,
required: true,
- match: [/^\d{9}$/, 'Sooner ID must be a 9-digit number'] // Sooner ID validation
+ match: [/^\d{9}$/, 'Sooner ID must be a 9-digit number']
},
interneeEmail: {
type: String,
required: true,
- match: [/\S+@\S+\.\S+/, 'Invalid email format'], // Email format validation
+ match: [/\S+@\S+\.\S+/, 'Invalid email format'],
lowercase: true,
trim: true
},
evaluations: {
type: [evaluationItemSchema],
- validate: [arr => arr.length > 0, 'At least one evaluation item is required']
+ validate: [arr => arr.length === 3, 'Exactly 3 evaluation items are required']
+ },
+
+ supervisorSignature: {
+ type: signatureSchema,
+ required: true
+ },
+
+ supervisorAgreement: {
+ type: Boolean,
+ required: true
+ },
+
+ coordinatorSignature: {
+ type: signatureSchema,
+ required: true
+ },
+
+ coordinatorAgreement: {
+ type: Boolean,
+ required: true
+ },
+
+ status: {
+ type: String,
+ enum: ['draft', 'submitted', 'approved'],
+ default: 'draft'
+ },
+
+ submittedAt: {
+ type: Date
},
- advisorSignature: { type: signatureSchema, required: true },
- advisorAgreement: { type: Boolean, required: true },
- coordinatorSignature: { type: signatureSchema, required: true },
- coordinatorAgreement: { type: Boolean, required: true }
+ locked: {
+ type: Boolean,
+ default: false
+ }
}, { timestamps: true });
+// Unique index to prevent duplicate submissions
evaluationSchema.index({ interneeID: 1, internshipId: 1 });
module.exports = mongoose.model('Evaluation', evaluationSchema);
\ No newline at end of file
diff --git a/server/models/InternshipRequest.js b/server/models/InternshipRequest.js
index 68dced0e..c823337c 100644
--- a/server/models/InternshipRequest.js
+++ b/server/models/InternshipRequest.js
@@ -22,12 +22,28 @@ const Task = new mongoose.Schema({
});
const formA1 = new mongoose.Schema({
- ...formMetadata,
- student: {
- type: ObjectId,
- required: true,
- ref: 'UserTokenRequest'
+ // student: {
+ // type: ObjectId,
+ // required: true,
+ // ref: 'UserTokenRequest'
+ // },
+ student:{
+ name:{
+ type: String,
+ required: true,
+ },
+ email:{
+ unique: true,
+ type: String,
+ required:true,
+ },
},
+ ...formMetadata,
+ // student: {
+ // type: ObjectId,
+ // required: true,
+ // ref: 'UserTokenRequest'
+ // },
workplace: {
name: {
type: String,
diff --git a/server/models/Submission.js b/server/models/Submission.js
new file mode 100644
index 00000000..c75c9d0a
--- /dev/null
+++ b/server/models/Submission.js
@@ -0,0 +1,10 @@
+const mongoose = require('mongoose');
+
+const SubmissionSchema = new mongoose.Schema({
+ student: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },
+ internshipRequest: { type: mongoose.Schema.Types.ObjectId, ref: 'InternshipRequest' },
+ status: { type: String, default: 'pending' },
+ submittedAt: { type: Date, default: Date.now },
+});
+
+module.exports = mongoose.model('Submission', SubmissionSchema);
diff --git a/server/routes/approvalRoutes.js b/server/routes/approvalRoutes.js
index 0913ac09..1a2a7bb0 100644
--- a/server/routes/approvalRoutes.js
+++ b/server/routes/approvalRoutes.js
@@ -8,22 +8,21 @@ const {
getCoordinatorRequestDetails,
coordinatorApproveRequest,
coordinatorRejectRequest,
+ approveFormA3,
} = require("../controllers/approvalController");
const { isSupervisor, isCoordinator } = require("../middleware/authMiddleware");
-// =========================================== //
-// Supervisor Approval Routes //
-// =========================================== //
+// Import InternshipRequest model to manually handle basic form approval
+const InternshipRequest = require("../models/InternshipRequest");
// Supervisor APIs
router.get("/supervisor/forms", isSupervisor, (req, res) => {
- // const supervisorId = req.user._id,
return getSupervisorForms(req, res, {
- // supervisor_id: supervisorId,
supervisor_status: { $in: ["pending"] },
- })
+ });
});
+
// Approve route
router.post("/supervisor/form/:type/:id/approve", isSupervisor, (req, res) =>
handleSupervisorFormAction(req, res, "approve")
@@ -40,20 +39,33 @@ router.post("/supervisor/form/:type/:id/reject", isSupervisor, (req, res) =>
// Coordinator APIs
router.get("/coordinator/requests", isCoordinator, getCoordinatorRequests);
-router.get(
- "/coordinator/request/:id",
- isCoordinator,
- getCoordinatorRequestDetails
-);
-router.post(
- "/coordinator/request/:id/approve",
- isCoordinator,
- coordinatorApproveRequest
-);
-router.post(
- "/coordinator/request/:id/reject",
- isCoordinator,
- coordinatorRejectRequest
-);
+router.get("/coordinator/request/:id", isCoordinator, getCoordinatorRequestDetails);
+router.post("/coordinator/request/:id/approve", isCoordinator, coordinatorApproveRequest);
+router.post("/coordinator/request/:id/reject", isCoordinator, coordinatorRejectRequest);
+
+// NEW Coordinator API: Approve Form A.3
+router.post("/coordinator/form-a3/:formId/approve", isCoordinator, approveFormA3);
+
+// NEW SIMPLE Approve Form API (ONLY status update: submitted -> approved)
+router.post("/form/:formId/approve", async (req, res) => {
+ const { formId } = req.params;
+
+ try {
+ const form = await InternshipRequest.findById(formId);
+
+ if (!form) {
+ return res.status(404).json({ message: 'Form not found' });
+ }
+
+ form.status = 'approved';
+ form.approvedAt = new Date();
+ await form.save();
+
+ res.status(200).json({ message: 'Form approved successfully!' });
+ } catch (error) {
+ console.error('Error approving form:', error);
+ res.status(500).json({ message: 'Something went wrong' });
+ }
+});
-module.exports = router;
\ No newline at end of file
+module.exports = router;
diff --git a/server/routes/evaluationRoutes.js b/server/routes/evaluationRoutes.js
new file mode 100644
index 00000000..aaae5463
--- /dev/null
+++ b/server/routes/evaluationRoutes.js
@@ -0,0 +1,43 @@
+const express = require('express');
+const router = express.Router();
+const Evaluation = require('../models/Evaluation');
+
+// POST: Submit Evaluation Form A.3
+router.post('/submit', async (req, res) => {
+ try {
+ const data = req.body;
+
+ // Basic validation: required fields check
+ if (
+ !data.interneeName ||
+ !data.interneeID ||
+ !data.interneeEmail ||
+ !data.evaluations ||
+ data.evaluations.length !== 3
+ ) {
+ return res.status(400).json({ message: 'Missing required fields or invalid number of evaluations' });
+ }
+
+ const evaluation = new Evaluation({
+ interneeName: data.interneeName,
+ interneeID: data.interneeID,
+ interneeEmail: data.interneeEmail,
+ evaluations: data.evaluations,
+ advisorSignature: data.advisorSignature,
+ advisorAgreement: data.advisorAgreement,
+ coordinatorSignature: data.coordinatorSignature,
+ coordinatorAgreement: data.coordinatorAgreement,
+ status: 'submitted',
+ submittedAt: new Date()
+ });
+
+ await evaluation.save();
+ res.status(201).json({ message: 'Evaluation submitted successfully' });
+
+ } catch (err) {
+ console.error('Error submitting evaluation:', err);
+ res.status(500).json({ error: 'Internal server error' });
+ }
+});
+
+module.exports = router;
diff --git a/server/routes/formRoutes.js b/server/routes/formRoutes.js
index 8fe44896..c80f3ebe 100644
--- a/server/routes/formRoutes.js
+++ b/server/routes/formRoutes.js
@@ -1,31 +1,12 @@
-const express = require("express");
+const express = require('express');
const router = express.Router();
-const InternshipRequest = require("../models/InternshipRequest");
-const { insertFormData } = require("../services/insertData");
+const { insertFormData } = require('../services/insertData');
-// router.post("/internshiprequests/:id/approve", approveSubmission);
-// router.post("/internshiprequests/:id/reject", rejectSubmission);
-
-// UPDATED: GET route to fetch internship requests pending supervisor action
-router.get("/internshiprequests", async (req, res) => {
- try {
- const requests = await InternshipRequest.find({
- supervisor_status: "pending",
- // approvals: "advisor", // advisor has approved
- supervisor_status: { $in: [null, "pending"] } // not yet reviewed by supervisor
- }).sort({ createdAt: 1 }) .populate("student", "userName") // oldest first
-
- res.status(200).json(requests);
- } catch (err) {
- console.error("Error fetching internship requests:", err);
- res.status(500).json({ message: "Server error while fetching internship requests" });
- }
-});
+let status = '';
// Validate required fields
function validateFormData(formData) {
const requiredFields = [
- 'soonerId',
'workplaceName',
'website',
'phone',
@@ -44,9 +25,6 @@ function validateFormData(formData) {
}
}
- if (!/^[0-9]{9}$/.test(formData.soonerId))
- return `Sooner ID must be a 9-digit number, not ${formData.soonerId}`;
-
if (!Array.isArray(formData.tasks) || formData.tasks.length === 0) {
return 'Tasks must be a non-empty array';
}
@@ -63,7 +41,7 @@ function validateFormData(formData) {
const tasks = formData.tasks;
console.log(tasks);
- if (tasks.filter((task) => task.description && task.description.trim() !== '').length < 3)
+ if (tasks.filter((task) => task.description).length < 3)
return 'At least 3 tasks must be provided';
const uniqueOutcomes = new Set();
tasks.forEach((task) => {
@@ -75,7 +53,6 @@ function validateFormData(formData) {
return null;
}
-
router.post('/submit', async (req, res) => {
const formData = req.body;
const validationError = validateFormData(formData);
@@ -85,7 +62,7 @@ router.post('/submit', async (req, res) => {
try {
await insertFormData(formData);
- res.status(200).json({ message: 'Form received and handled!', manual: formData.status !== 'submitted'});
+ res.status(200).json({ message: 'Form received and handled!', status, manual: formData.status !== 'submitted'});
} catch (error) {
console.error('Error handling form data:', error);
res.status(500).json({ message: 'Something went wrong' });
diff --git a/server/services/insertData.js b/server/services/insertData.js
index 8d0e9541..3059a332 100644
--- a/server/services/insertData.js
+++ b/server/services/insertData.js
@@ -1,25 +1,20 @@
const mongoose = require("mongoose");
const InternshipRequest = require("../models/InternshipRequest");
+const User = require("../models/User"); // Make sure User model is imported properly
+const Submission = require("../models/Submission");
async function insertFormData(formData) {
try {
console.log("Received Form Data:\n", JSON.stringify(formData, null, 2));
- // Assumes global mongoose connection is already established elsewhere in app
- if (formData.status === "submitted") {
- // if tasks are aligned , form will be sent to the supervisor.
- formData.supervisor_status="pending"
- formData.coordinator_status="not submitted" //TBD
- console.log("Submission sent to Supervisor Dashboard.");
- } else if (formData.status === "pending manual review") {
- //if tasks are not aligned, form will be sent to coordinator. coordinator approves -> coordinator should forward to supervisor for further approval
- formData.coordinator_status="pending"
- formData.supervisor_status="not submitted"
- console.log("Task not aligned with CS Outcomes. Sent to coordinator for manual review.");
+ const student = await User.findOne({ email: formData.email });
+
+ if (!student) {
+ throw new Error("Student not found in users collection");
}
const formattedData = {
- student: new mongoose.Types.ObjectId(), // TODO: Replace with actual signed-in student ID
+ student: student._id,
workplace: {
name: formData.workplaceName,
website: formData.website,
@@ -33,32 +28,33 @@ async function insertFormData(formData) {
creditHours: parseInt(formData.creditHours),
startDate: new Date(formData.startDate),
endDate: new Date(formData.endDate),
- tasks: formData.tasks
- .map(task => ({
+ tasks: formData.tasks.map(task => ({
description: task.description,
outcomes: task.outcomes,
- })).filter(task => task.description.trim() !== ''), // remove empty tasks
- // status: "submitted", // Default status — adjust as needed
- // status: formData.status, // Default status — adjust as needed
-
- supervisor_status: formData.supervisor_status ,//function based on if tasks are aligned/not aligned with outcomes
- coordinator_status: formData.coordinator_status,
- approvals: ["advisor", "coordinator"], // TODO: Might be dynamic later
- reminders: [], // Placeholder for future reminder logic
- completedHours: parseInt(formData.creditHours) * 60, // Assuming 1 credit = 60 hours
+ })).filter(task => task.description.trim() !== ''),
+ status: formData.status,
+ approvals: ["advisor", "coordinator"],
+ reminders: [],
+ completedHours: parseInt(formData.creditHours) * 60
};
const savedForm = await InternshipRequest.create(formattedData);
console.log("Form saved successfully with ID:", savedForm._id);
- console.log("saved form",savedForm)
+
+ if (formData.status === "submitted") {
+ console.log("Submission sent to Supervisor Dashboard.");
+ } else if (formData.status === "pending manual review") {
+ console.log("Task not aligned with CS Outcomes. Sent to coordinator for manual review.");
+ }
+
return savedForm;
} catch (error) {
- console.error("Error saving form:", error.message);
+ console.error("Full Error Stack:", error);
throw error;
}
}
module.exports = {
insertFormData,
-};
\ No newline at end of file
+};