// server/config/config.

js
module.exports = {
db: {
uri: 'mongodb://your_db_username:your_db_password@your_db_host:your_db_port/
your_db_name', // Replace with your MongoDB connection URI
},
jwt: {
secret: 'your_very_secret_key', // Replace with a strong secret key
},
};

// server/db/connect.js
const mongoose = require('mongoose');
const config = require('../config/config');

module.exports = async () => {

try {
await mongoose.connect(config.db.uri); // Removed deprecated options
console.log('Connected to MongoDB!');
} catch (error) {
console.error('Error connecting to MongoDB:', error);
}
};

// server/models/course.js
const mongoose = require('mongoose');

const Schema = mongoose.Schema;

const courseSchema = new Schema({

courseName: { type: String, required: true },
courseDescription: { type: String, required: true },
timestamps: { type: Date, default: Date.now }
});

module.exports = mongoose.model('Courses', courseSchema);

// server/models/member.js
const mongoose = require('mongoose');

const Schema = mongoose.Schema;

const memberSchema = new Schema({

username: { type: String, required: true, unique: true },
password: { type: String, required: true },
timestamps: { type: Date, default: Date.now }
});

module.exports = mongoose.model('Members', memberSchema);

// server/models/section.js
const mongoose = require('mongoose');

const Schema = mongoose.Schema;

const sectionSchema = new Schema({

sectionName: { type: String, required: true },
sectionDescription: { type: String, required: true },
duration: { type: Number, required: true },
 isMainTask: { type: Boolean, default: false },
course: { type: Schema.Types.ObjectId, ref: 'Courses', required: true },
timestamps: { type: Date, default: Date.now }
});

module.exports = mongoose.model('Sections', sectionSchema);

// server/controllers/members.js
const bcrypt = require('bcryptjs');
const jwt = require('jsonwebtoken');
const Member = require('../models/member');

// Register a new member

exports.register = async (req, res) => {
try {
const { username, password } = req.body;

// Check if username exists

const existingUser = await Member.findOne({ username });
if (existingUser) {
return res.status(400).json({ message: 'Username already exists!' });
}

// Hash password
const hashedPassword = await bcrypt.hash(password, 10); // Adjust salt rounds
as needed

const newMember = new Member({

username,
password: hashedPassword,
});

await newMember.save();
res.status(201).json({ message: 'Member registered successfully!' });
} catch (error) {
console.error('Error during registration:', error);
res.status(500).json({ message: 'Server error during registration.' });
}
};

// Login a member
exports.login = async (req, res) => {
try {
const { username, password } = req.body;

console.log("Username entered:", username); // Check if username is being

received
const member = await Member.findOne({ username });
console.log("Member found:", member); // Check if member is found in the
database
if (!member) {
return res.status(401).json({ message: 'Invalid credentials!' });
}

console.log("Password entered:", password); // Check if password is being

received
console.log("Password stored:", member.password); // Check if password is being
retrieved from the database
const isValidPassword = await bcrypt.compare(password, member.password);
 if (!isValidPassword) {
return res.status(401).json({ message: 'Invalid credentials!' });
}

// Generate JWT token

const token = jwt.sign({ memberId: member._id }, process.env.JWT_SECRET, {
expiresIn: '1h', // Set token expiration time
});

res.status(200).json({
token: token,
memberId: member._id,
username: member.username
});

} catch (error) {
console.error('Error during login:', error);
res.status(500).json({ message: 'Server error during login.' });
}
};

// server/controllers/courses.js
const Course = require('../models/course');

// Get all courses

exports.getAllCourses = async (req, res) => {
try {
const courses = await Course.find();
res.status(200).json(courses);
} catch (error) {
console.error('Error fetching courses:', error);
res.status(500).json({ message: 'Server error while retrieving courses.' });
}
};

// Get a course by ID
exports.getCourseById = async (req, res) => {
try {
const courseId = req.params.courseId;
const course = await Course.findById(courseId);
if (!course) {
return res.status(404).json({ message: 'Course not found!' });
}
res.status(200).json(course);
} catch (error) {
console.error('Error fetching course by ID:', error);
res.status(500).json({ message: 'Server error while retrieving course.' });
}
};

// Create a new course

exports.createCourse = async (req, res) => {
try {
const { courseName, courseDescription } = req.body;
const newCourse = new Course({
courseName,
courseDescription,
});
 await newCourse.save();
res.status(201).json({ message: 'Course created successfully!', courseId:
newCourse._id });
} catch (error) {
console.error('Error creating course:', error);
res.status(500).json({ message: 'Server error while creating course.' });
}
};

// Update a course by ID
exports.updateCourse = async (req, res) => {
try {
const courseId = req.params.courseId;
const { courseName, courseDescription } = req.body;
const updatedCourse = await Course.findByIdAndUpdate(
courseId,
{ courseName, courseDescription },
{ new: true } // Return the updated document
);
if (!updatedCourse) {
return res.status(404).json({ message: 'Course not found!' });
}
res.status(200).json({ message: 'Course updated successfully!', course:
updatedCourse });
} catch (error) {
console.error('Error updating course:', error);
res.status(500).json({ message: 'Server error while updating course.' });
}
};

// Delete a course by ID
exports.deleteCourse = async (req, res) => {
try {
const courseId = req.params.courseId;
const deletedCourse = await Course.findByIdAndDelete(courseId);
if (!deletedCourse) {
return res.status(404).json({ message: 'Course not found!' });
}
res.status(200).json({ message: 'Course deleted successfully!' });
} catch (error) {
console.error('Error deleting course:', error);
res.status(500).json({ message: 'Server error while deleting course.' });
}
};

// server/controllers/sections.js
const Section = require('../models/section');

// Get all sections for a course

exports.getSectionsForCourse = async (req, res) => {
try {
const courseId = req.params.courseId;
const sections = await Section.find({ course: courseId });
res.status(200).json(sections);
} catch (error) {
console.error('Error fetching sections for course:', error);
res.status(500).json({ message: 'Server error while retrieving sections.' });
}
};
// Create a new section
exports.createSection = async (req, res) => {
try {
const { sectionName, sectionDescription, duration, isMainTask, courseId } =
req.body;

const newSection = new Section({

sectionName,
sectionDescription,
duration,
isMainTask,
course: courseId
});
await newSection.save();
res.status(201).json({ message: 'Section created successfully!', sectionId:
newSection._id });
} catch (error) {
console.error('Error creating section:', error);
res.status(500).json({ message: 'Server error while creating section.' });
}
};

// Update a section
exports.updateSection = async (req, res) => {
try {
const sectionId = req.params.sectionId;
const { sectionName, sectionDescription, duration, isMainTask, courseId } =
req.body;

const updatedSection = await Section.findByIdAndUpdate(

sectionId,
{ sectionName, sectionDescription, duration, isMainTask, course: courseId },
{ new: true } // Return the updated document
);
if (!updatedSection) {
return res.status(404).json({ message: 'Section not found!' });
}
res.status(200).json({ message: 'Section updated successfully!', section:
updatedSection });
} catch (error) {
console.error('Error updating section:', error);
res.status(500).json({ message: 'Server error while updating section.' });
}
};

// Delete a section
exports.deleteSection = async (req, res) => {
try {
const sectionId = req.params.sectionId;
const deletedSection = await Section.findByIdAndDelete(sectionId);
if (!deletedSection) {
return res.status(404).json({ message: 'Section not found!' });
}
res.status(200).json({ message: 'Section deleted successfully!' });
} catch (error) {
console.error('Error deleting section:', error);
res.status(500).json({ message: 'Server error while deleting section.' });
}
};

// server/routes/courses.js
const express = require('express');
const router = express.Router();
const courseController = require('../controllers/courses');
const sectionController = require('../controllers/sections'); // Import
sectionController
const authMiddleware = require('../middleware/auth'); // Import auth middleware

// Define routes
router.get('/', authMiddleware, courseController.getAllCourses);
router.get('/:courseId', authMiddleware, courseController.getCourseById);
router.post('/', authMiddleware, courseController.createCourse);
router.put('/:courseId', authMiddleware, courseController.updateCourse);
router.delete('/:courseId', authMiddleware, courseController.deleteCourse);

router.get('/:courseId/sections', authMiddleware,
sectionController.getSectionsForCourse); // Add sections route for a course

module.exports = router;

// server/routes/members.js
const express = require('express');
const router = express.Router();
const memberController = require('../controllers/members');

// Define routes
router.post('/register', memberController.register);
router.post('/login', memberController.login);

module.exports = router;

// server/routes/sections.js
const express = require('express');
const router = express.Router();
const sectionController = require('../controllers/sections');
const authMiddleware = require('../middleware/auth'); // Import auth middleware

// Define routes
router.get('/:courseId', authMiddleware, sectionController.getSectionsForCourse);
router.post('/', authMiddleware, sectionController.createSection);
router.put('/:sectionId', authMiddleware, sectionController.updateSection);
router.delete('/:sectionId', authMiddleware, sectionController.deleteSection);

module.exports = router;

// server/middleware/auth.js
const jwt = require('jsonwebtoken');
const config = require('../config/config');

module.exports = (req, res, next) => {

const token = req.header('Authorization');

if (!token) {
return res.status(401).json({ message: 'No token provided.' });
}

try {
 const decoded = jwt.verify(token, config.jwt.secret);
req.memberId = decoded.memberId; // Attach the memberId to the request object
next(); // If the token is valid, proceed to the next middleware or route
handler
} catch (error) {
return res.status(401).json({ message: 'Invalid token.' });
}
};

// server/app.js
const express = require('express');
const cors = require('cors');
const dotenv = require('dotenv');
const dbConnect = require('./db/connect');
const courseRoutes = require('./routes/courses');
const memberRoutes = require('./routes/members');
const sectionRoutes = require('./routes/sections');

dotenv.config(); // Load environment variables from .env

const app = express();

const port = process.env.PORT || 5000;

// Middleware
app.use(cors()); // Enable CORS
app.use(express.json()); // Parse JSON request bodies

// Set up EJS view engine

app.set('view engine', 'ejs');
app.set('views', __dirname + '/views'); // Tell Express where to find EJS views

// Connect to MongoDB
console.log('Connecting to MongoDB...');
dbConnect();

// Handle login
app.post('/login', memberController.login);

// Handle registration
app.post('/register', memberController.register);

// Handle routes
app.get('/', async (req, res) => {
try {
let user = null;
if (req.memberId) { // Check if user is logged in
user = await Member.findById(req.memberId);
}
const courses = await Course.find();
res.render('index', { user, courses }); // Pass user data to the view
} catch (error) {
console.error('Error fetching courses:', error);
res.status(500).json({ message: 'Server error while retrieving courses.' });
}
});

// Mount routes
app.use('/api/courses/:courseId/sections', sectionRoutes);
app.use('/api/courses', courseRoutes);
app.use('/api/members', memberRoutes);

// Start the server

app.listen(port, () => {
console.log(`Server is listening on port ${port}`);
});

env
# MongoDB connection string
MONGO_URI=mongodb://localhost:27017/PE_SDN301m_TrialTest

# JWT secret key

JWT_SECRET=your_very_secret_key

# Port for the server

PORT=5000