957 lines
32 KiB
JavaScript
957 lines
32 KiB
JavaScript
const express = require('express');
|
||
const fs = require('fs');
|
||
const path = require('path');
|
||
const app = express();
|
||
const PORT = 3000;
|
||
|
||
// Serve raw wordlists.json for admin UI (must come after app is defined)
|
||
app.get('/getWordlistsRaw', (req, res) => {
|
||
const wordlists = readJsonSafe(path.join(DATA_DIR, files.wordlists), {});
|
||
res.json(wordlists);
|
||
});
|
||
|
||
// 📁 Static assets
|
||
app.use(express.static('public'));
|
||
app.use(express.json());
|
||
|
||
// 🗂 Directories
|
||
const DATA_DIR = path.join(__dirname, 'data');
|
||
const SEED_DIR = path.join(__dirname, 'seed');
|
||
if (!fs.existsSync(DATA_DIR)) fs.mkdirSync(DATA_DIR);
|
||
|
||
// Date utility functions for gamification features
|
||
function getWeekNumber(date) {
|
||
const firstDayOfYear = new Date(date.getFullYear(), 0, 1);
|
||
const pastDaysOfYear = (date - firstDayOfYear) / 86400000;
|
||
return Math.ceil((pastDaysOfYear + firstDayOfYear.getDay() + 1) / 7);
|
||
}
|
||
|
||
function getWeekStartDate(date) {
|
||
const result = new Date(date);
|
||
result.setDate(result.getDate() - result.getDay());
|
||
return result;
|
||
}
|
||
|
||
function getWeekEndDate(date) {
|
||
const result = new Date(date);
|
||
result.setDate(result.getDate() + (6 - result.getDay()));
|
||
return result;
|
||
}
|
||
|
||
function isToday(dateString) {
|
||
if (!dateString) return false;
|
||
const today = new Date().toISOString().split('T')[0];
|
||
return dateString.split('T')[0] === today;
|
||
}
|
||
|
||
function isSameDay(date1, date2) {
|
||
return date1.toISOString().split('T')[0] === date2.toISOString().split('T')[0];
|
||
}
|
||
|
||
function daysInARow(dateStrings) {
|
||
if (!dateStrings || !dateStrings.length) return 0;
|
||
|
||
// Convert strings to Date objects
|
||
const dates = dateStrings.map(d => new Date(d)).sort((a, b) => a - b);
|
||
|
||
let currentStreak = 1;
|
||
for (let i = 1; i < dates.length; i++) {
|
||
const prevDate = new Date(dates[i-1]);
|
||
prevDate.setDate(prevDate.getDate() + 1);
|
||
|
||
// If consecutive days
|
||
if (isSameDay(prevDate, dates[i])) {
|
||
currentStreak++;
|
||
} else {
|
||
break;
|
||
}
|
||
}
|
||
|
||
return currentStreak;
|
||
}
|
||
|
||
// 🗃 File mapping
|
||
const files = {
|
||
users: 'users.json',
|
||
wordlists: 'wordlists.json',
|
||
results: 'results.json',
|
||
badges: 'badges.json',
|
||
leaderboards: 'leaderboards.json',
|
||
challenges: 'challenges.json',
|
||
progress: 'progress.json',
|
||
spacedRepetition: 'spacedRepetition.json'
|
||
};
|
||
|
||
// 🌱 Initialize data from seeds if missing/empty
|
||
function ensureFileWithSeed(name, fallback = '{}') {
|
||
const targetPath = path.join(DATA_DIR, name);
|
||
const seedPath = path.join(SEED_DIR, name);
|
||
|
||
if (!fs.existsSync(targetPath) || fs.readFileSync(targetPath, 'utf-8').trim() === '') {
|
||
if (fs.existsSync(seedPath)) {
|
||
fs.copyFileSync(seedPath, targetPath);
|
||
console.log(`🌱 Seeded ${name} from seed/${name}`);
|
||
} else {
|
||
// Create default data for each file type
|
||
if (name === 'users.json') {
|
||
const defaultUsers = [
|
||
{
|
||
"username": "admin1",
|
||
"hash": "5e884898da28047151d0e56f8dc6292773603d0d6aabbdd62a11ef721d1542d8", // password
|
||
"role": "admin"
|
||
},
|
||
{
|
||
"username": "nate",
|
||
"hash": "5a2a558c78d3717db731600c4f354fa1d9c84b556f108091a891f444f1bdec40", // nate123
|
||
"role": "student"
|
||
},
|
||
{
|
||
"username": "student1",
|
||
"hash": "8d969eef6ecad3c29a3a629280e686cf0c3f5d5a86aff3ca12020c923adc6c92", // 123456
|
||
"role": "student"
|
||
}
|
||
];
|
||
fs.writeFileSync(targetPath, JSON.stringify(defaultUsers, null, 2));
|
||
console.log(`👥 Created default users: admin1, nate, student1`);
|
||
} else if (name === 'wordlists.json') {
|
||
const defaultWordlists = {
|
||
"student1": [
|
||
"apple", "banana", "cherry", "date", "elderberry",
|
||
"grape", "honeydew", "kiwi", "lemon", "mango"
|
||
],
|
||
"admin1": [
|
||
"administration", "education", "technology", "development", "programming"
|
||
],
|
||
"nate": [
|
||
"computer", "keyboard", "mouse", "screen", "printer",
|
||
"software", "hardware", "network", "database", "security"
|
||
]
|
||
};
|
||
fs.writeFileSync(targetPath, JSON.stringify(defaultWordlists, null, 2));
|
||
console.log(`📝 Created default word lists for all users`);
|
||
} else if (name === 'badges.json') {
|
||
const defaultBadges = {
|
||
"student1": [],
|
||
"nate": [],
|
||
"admin1": []
|
||
};
|
||
fs.writeFileSync(targetPath, JSON.stringify(defaultBadges, null, 2));
|
||
console.log(`🏆 Created default badge structure`);
|
||
} else if (name === 'leaderboards.json') {
|
||
const defaultLeaderboards = {
|
||
"allTime": {
|
||
"accuracy": [],
|
||
"totalWords": [],
|
||
"sessionsCompleted": [],
|
||
"streakDays": []
|
||
},
|
||
"weekly": {
|
||
"accuracy": [],
|
||
"totalWords": [],
|
||
"sessionsCompleted": []
|
||
},
|
||
"lastUpdated": new Date().toISOString()
|
||
};
|
||
fs.writeFileSync(targetPath, JSON.stringify(defaultLeaderboards, null, 2));
|
||
console.log(`🏅 Created default leaderboards structure`);
|
||
} else if (name === 'challenges.json') {
|
||
const today = new Date();
|
||
const dayString = today.toISOString().split('T')[0];
|
||
const weekNum = getWeekNumber(today);
|
||
const yearNum = today.getFullYear();
|
||
|
||
const defaultChallenges = {
|
||
"daily": {
|
||
"current": {
|
||
"id": `daily-${dayString}`,
|
||
"title": `${new Date().toLocaleDateString('en-US', { month: 'long', day: 'numeric' })} Challenge`,
|
||
"description": "Complete a spelling session with at least 90% accuracy",
|
||
"type": "accuracy",
|
||
"target": 90,
|
||
"reward": {
|
||
"points": 50,
|
||
"badge": null
|
||
},
|
||
"date": dayString
|
||
},
|
||
"history": []
|
||
},
|
||
"weekly": {
|
||
"current": {
|
||
"id": `weekly-${yearNum}-${weekNum}`,
|
||
"title": `Week ${weekNum} Challenge`,
|
||
"description": "Practice spelling for 5 consecutive days",
|
||
"type": "streak",
|
||
"target": 5,
|
||
"reward": {
|
||
"points": 100,
|
||
"badge": "Weekly Warrior"
|
||
},
|
||
"startDate": getWeekStartDate(today).toISOString().split('T')[0],
|
||
"endDate": getWeekEndDate(today).toISOString().split('T')[0]
|
||
},
|
||
"history": []
|
||
},
|
||
"achievements": [
|
||
{
|
||
"id": "perfect-accuracy",
|
||
"title": "Perfect Accuracy",
|
||
"description": "Complete a session with 100% accuracy",
|
||
"type": "session",
|
||
"condition": "accuracy",
|
||
"target": 100,
|
||
"reward": {
|
||
"points": 75,
|
||
"badge": "Perfection"
|
||
}
|
||
},
|
||
{
|
||
"id": "persistent-learner",
|
||
"title": "Persistent Learner",
|
||
"description": "Practice for 7 days in a row",
|
||
"type": "streak",
|
||
"condition": "dailyLogin",
|
||
"target": 7,
|
||
"reward": {
|
||
"points": 200,
|
||
"badge": "Persistence"
|
||
}
|
||
},
|
||
{
|
||
"id": "spelling-veteran",
|
||
"title": "Spelling Veteran",
|
||
"description": "Complete 50 spelling sessions",
|
||
"type": "cumulative",
|
||
"condition": "sessions",
|
||
"target": 50,
|
||
"reward": {
|
||
"points": 300,
|
||
"badge": "Veteran"
|
||
}
|
||
}
|
||
],
|
||
"lastUpdated": new Date().toISOString()
|
||
};
|
||
fs.writeFileSync(targetPath, JSON.stringify(defaultChallenges, null, 2));
|
||
console.log(`🎯 Created default challenges structure`);
|
||
} else if (name === 'progress.json') {
|
||
// Create empty progress structure for each user
|
||
const users = readJsonSafe(path.join(DATA_DIR, files.users), []);
|
||
const defaultProgress = {};
|
||
|
||
users.forEach(user => {
|
||
defaultProgress[user.username] = {
|
||
"stats": {
|
||
"points": 0,
|
||
"totalSessions": 0,
|
||
"totalWords": 0,
|
||
"correctWords": 0,
|
||
"accuracy": 0
|
||
},
|
||
"streaks": {
|
||
"current": 0,
|
||
"longest": 0,
|
||
"lastActivity": null
|
||
},
|
||
"challengesCompleted": {
|
||
"daily": [],
|
||
"weekly": [],
|
||
"achievements": []
|
||
}
|
||
};
|
||
});
|
||
|
||
fs.writeFileSync(targetPath, JSON.stringify(defaultProgress, null, 2));
|
||
console.log(`📈 Created default progress structure for ${Object.keys(defaultProgress).length} users`);
|
||
} else if (name === 'spacedRepetition.json') {
|
||
// Create empty spaced repetition structure for each user
|
||
const users = readJsonSafe(path.join(DATA_DIR, files.users), []);
|
||
const defaultSRData = {};
|
||
|
||
users.forEach(user => {
|
||
defaultSRData[user.username] = {
|
||
"settings": {
|
||
"dailyLimit": 20,
|
||
"reviewThreshold": 3,
|
||
"newWordsPerDay": 5
|
||
},
|
||
"stats": {
|
||
"totalReviews": 0,
|
||
"correctReviews": 0,
|
||
"totalWords": 0,
|
||
"masteredWords": 0
|
||
},
|
||
"words": {}
|
||
};
|
||
});
|
||
|
||
fs.writeFileSync(targetPath, JSON.stringify(defaultSRData, null, 2));
|
||
console.log(`📚 Created default spaced repetition structure for ${Object.keys(defaultSRData).length} users`);
|
||
} else {
|
||
fs.writeFileSync(targetPath, fallback);
|
||
console.log(`📄 Initialized ${name} with default`);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
for (const [key, file] of Object.entries(files)) {
|
||
const defaultData = file === 'users.json' ? '[]' : '{}';
|
||
ensureFileWithSeed(file, defaultData);
|
||
}
|
||
|
||
// 🔄 Initialize existing users in all data files
|
||
function initializeAllExistingUsers() {
|
||
console.log('🔄 Checking all users are initialized...');
|
||
const users = readJsonSafe(path.join(DATA_DIR, files.users), []);
|
||
|
||
users.forEach(user => {
|
||
// Check if user exists in all data files
|
||
const wordlists = readJsonSafe(path.join(DATA_DIR, files.wordlists), {});
|
||
const results = readJsonSafe(path.join(DATA_DIR, files.results), {});
|
||
const badges = readJsonSafe(path.join(DATA_DIR, files.badges), {});
|
||
|
||
const needsInit = !wordlists[user.username] || !results[user.username] || !badges[user.username];
|
||
|
||
if (needsInit) {
|
||
console.log(`🔧 User "${user.username}" needs initialization`);
|
||
initializeUserInAllFiles(user.username);
|
||
}
|
||
});
|
||
console.log('✅ All users initialized');
|
||
}
|
||
|
||
// Initialize all existing users
|
||
initializeAllExistingUsers();
|
||
|
||
// 🔐 JSON utility
|
||
function readJsonSafe(filePath, fallback = {}) {
|
||
try {
|
||
return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
|
||
} catch {
|
||
return fallback;
|
||
}
|
||
}
|
||
|
||
// 🔧 Initialize user across all data files
|
||
function initializeUserInAllFiles(username) {
|
||
console.log(`🔧 Initializing user "${username}" across all data files`);
|
||
|
||
// Initialize in wordlists.json
|
||
const wordlistsPath = path.join(DATA_DIR, files.wordlists);
|
||
const wordlists = readJsonSafe(wordlistsPath, {});
|
||
if (!wordlists[username]) {
|
||
wordlists[username] = [
|
||
"hello", "world", "test", "sample", "basic",
|
||
"learn", "spell", "word", "study", "practice"
|
||
];
|
||
fs.writeFileSync(wordlistsPath, JSON.stringify(wordlists, null, 2));
|
||
console.log(`📝 Added default word list for "${username}"`);
|
||
}
|
||
|
||
// Initialize in results.json
|
||
const resultsPath = path.join(DATA_DIR, files.results);
|
||
const results = readJsonSafe(resultsPath, {});
|
||
if (!results[username]) {
|
||
results[username] = [];
|
||
fs.writeFileSync(resultsPath, JSON.stringify(results, null, 2));
|
||
console.log(`📊 Added results tracking for "${username}"`);
|
||
}
|
||
|
||
// Initialize in badges.json
|
||
const badgesPath = path.join(DATA_DIR, files.badges);
|
||
const badges = readJsonSafe(badgesPath, {});
|
||
if (!badges[username]) {
|
||
badges[username] = [];
|
||
fs.writeFileSync(badgesPath, JSON.stringify(badges, null, 2));
|
||
console.log(`🏆 Added badge tracking for "${username}"`);
|
||
}
|
||
|
||
// Initialize in progress.json
|
||
const progressPath = path.join(DATA_DIR, files.progress);
|
||
const progress = readJsonSafe(progressPath, {});
|
||
if (!progress[username]) {
|
||
progress[username] = {
|
||
stats: {
|
||
points: 0,
|
||
totalSessions: 0,
|
||
totalWords: 0,
|
||
correctWords: 0,
|
||
accuracy: 0
|
||
},
|
||
streaks: {
|
||
current: 0,
|
||
longest: 0,
|
||
lastActivity: null
|
||
},
|
||
challengesCompleted: {
|
||
daily: [],
|
||
weekly: [],
|
||
achievements: []
|
||
}
|
||
};
|
||
fs.writeFileSync(progressPath, JSON.stringify(progress, null, 2));
|
||
console.log(`📈 Added progress tracking for "${username}"`);
|
||
}
|
||
|
||
// Initialize in spacedRepetition.json
|
||
const srPath = path.join(DATA_DIR, files.spacedRepetition);
|
||
const srData = readJsonSafe(srPath, {});
|
||
if (!srData[username]) {
|
||
srData[username] = {
|
||
settings: {
|
||
dailyLimit: 20,
|
||
reviewThreshold: 3,
|
||
newWordsPerDay: 5
|
||
},
|
||
stats: {
|
||
totalReviews: 0,
|
||
correctReviews: 0,
|
||
totalWords: 0,
|
||
masteredWords: 0
|
||
},
|
||
words: {}
|
||
};
|
||
fs.writeFileSync(srPath, JSON.stringify(srData, null, 2));
|
||
console.log(`📚 Added spaced repetition data for "${username}"`);
|
||
}
|
||
}
|
||
|
||
// 🔐 Verify login
|
||
app.post('/verifyUser', (req, res) => {
|
||
const { username, hash } = req.body;
|
||
console.log('Login attempt - Username:', username, 'Hash:', hash);
|
||
|
||
if (typeof username !== 'string' || typeof hash !== 'string') {
|
||
console.log('Invalid credentials format');
|
||
return res.status(400).send("Invalid credentials format");
|
||
}
|
||
|
||
const users = readJsonSafe(path.join(DATA_DIR, files.users), []);
|
||
console.log('Available users:', users.map(u => u.username));
|
||
|
||
const user = users.find(u => u.username === username && u.hash === hash);
|
||
|
||
if (user) {
|
||
console.log('Login successful for:', username);
|
||
res.json(user);
|
||
} else {
|
||
console.log('Login failed for:', username);
|
||
res.status(401).send("Invalid login");
|
||
}
|
||
});
|
||
|
||
// ➕ Add user
|
||
app.post('/addUser', (req, res) => {
|
||
const { username, hash, role } = req.body;
|
||
if (
|
||
typeof username !== 'string' ||
|
||
typeof hash !== 'string' ||
|
||
typeof role !== 'string' ||
|
||
!['admin', 'student'].includes(role.trim().toLowerCase())
|
||
) return res.status(400).send("Invalid user data");
|
||
|
||
const users = readJsonSafe(path.join(DATA_DIR, files.users), []);
|
||
if (users.find(u => u.username === username)) {
|
||
return res.status(409).send("User already exists");
|
||
}
|
||
|
||
// Add user to users.json
|
||
users.push({ username: username.trim(), hash, role: role.trim() });
|
||
fs.writeFileSync(path.join(DATA_DIR, files.users), JSON.stringify(users, null, 2));
|
||
|
||
// Initialize user in all other data files
|
||
initializeUserInAllFiles(username.trim());
|
||
|
||
res.send(`✅ User "${username}" added and initialized`);
|
||
});
|
||
|
||
// ❌ Delete user
|
||
app.post('/deleteUser', (req, res) => {
|
||
const { username } = req.body;
|
||
if (typeof username !== 'string') return res.status(400).send("Invalid username");
|
||
|
||
const usersPath = path.join(DATA_DIR, files.users);
|
||
const users = readJsonSafe(usersPath, []);
|
||
const updated = users.filter(u => u.username !== username);
|
||
|
||
if (users.length === updated.length) {
|
||
return res.status(404).send("User not found");
|
||
}
|
||
|
||
// Remove from users.json
|
||
fs.writeFileSync(usersPath, JSON.stringify(updated, null, 2));
|
||
|
||
// Clean up from other data files
|
||
const wordlistsPath = path.join(DATA_DIR, files.wordlists);
|
||
const wordlists = readJsonSafe(wordlistsPath, {});
|
||
delete wordlists[username];
|
||
fs.writeFileSync(wordlistsPath, JSON.stringify(wordlists, null, 2));
|
||
|
||
const resultsPath = path.join(DATA_DIR, files.results);
|
||
const results = readJsonSafe(resultsPath, {});
|
||
delete results[username];
|
||
fs.writeFileSync(resultsPath, JSON.stringify(results, null, 2));
|
||
|
||
const badgesPath = path.join(DATA_DIR, files.badges);
|
||
const badges = readJsonSafe(badgesPath, {});
|
||
delete badges[username];
|
||
fs.writeFileSync(badgesPath, JSON.stringify(badges, null, 2));
|
||
|
||
console.log(`🗑️ Cleaned up all data for user "${username}"`);
|
||
res.send(`✅ User "${username}" deleted and cleaned up`);
|
||
});
|
||
|
||
// 🔐 Change user password
|
||
app.post('/changePassword', (req, res) => {
|
||
const { username, newPasswordHash } = req.body;
|
||
if (typeof username !== 'string' || typeof newPasswordHash !== 'string') {
|
||
return res.status(400).send("Invalid request data");
|
||
}
|
||
|
||
const usersPath = path.join(DATA_DIR, files.users);
|
||
const users = readJsonSafe(usersPath, []);
|
||
const userIndex = users.findIndex(u => u.username === username);
|
||
|
||
if (userIndex === -1) {
|
||
return res.status(404).send("User not found");
|
||
}
|
||
|
||
// Update the password hash
|
||
users[userIndex].hash = newPasswordHash;
|
||
|
||
// Save updated users
|
||
fs.writeFileSync(usersPath, JSON.stringify(users, null, 2));
|
||
|
||
console.log(`Password changed for user: ${username}`);
|
||
res.send(`✅ Password changed for user "${username}"`);
|
||
});
|
||
|
||
// 📚 Word list
|
||
app.get('/getWordList', (req, res) => {
|
||
try {
|
||
const { username } = req.query;
|
||
if (!username) {
|
||
return res.status(400).json({ error: 'Username is required' });
|
||
}
|
||
|
||
// Add debug logging
|
||
console.log('Requested username:', username);
|
||
|
||
const wordListPath = path.join(DATA_DIR, 'wordlists.json');
|
||
console.log('Reading from:', wordListPath);
|
||
|
||
const wordLists = readJsonSafe(wordListPath, {});
|
||
console.log('Available wordlists:', Object.keys(wordLists));
|
||
|
||
// Get words for specific user
|
||
let userWords = wordLists[username] || [];
|
||
// If the user's word list is an object (weeks/activeWeek)
|
||
if (userWords && typeof userWords === 'object' && !Array.isArray(userWords)) {
|
||
if (Array.isArray(userWords.weeks)) {
|
||
// If activeWeek is set, return only that week's words
|
||
if (userWords.activeWeek) {
|
||
const found = userWords.weeks.find(w => w.date === userWords.activeWeek);
|
||
userWords = found && Array.isArray(found.words) ? found.words : [];
|
||
} else {
|
||
// No activeWeek, flatten all words from all weeks
|
||
userWords = userWords.weeks.flatMap(w => Array.isArray(w.words) ? w.words : []);
|
||
}
|
||
} else {
|
||
userWords = [];
|
||
}
|
||
}
|
||
console.log(`Words found for ${username}:`, userWords);
|
||
res.json({ words: userWords });
|
||
} catch (error) {
|
||
console.error('Error in getWordList:', error);
|
||
res.status(500).json({ error: 'Failed to get word list' });
|
||
}
|
||
});
|
||
|
||
// Save a word list for a user
|
||
app.post('/saveWordList', (req, res) => {
|
||
const { username, words } = req.body;
|
||
if (
|
||
typeof username !== 'string' ||
|
||
!Array.isArray(words) ||
|
||
words.length > 100 ||
|
||
words.some(w => typeof w !== 'string')
|
||
) return res.status(400).send("Invalid word list");
|
||
|
||
const userList = readJsonSafe(path.join(DATA_DIR, files.users), []);
|
||
if (!userList.find(u => u.username === username)) {
|
||
return res.status(404).send("User not found");
|
||
}
|
||
|
||
const wordlistsPath = path.join(DATA_DIR, files.wordlists);
|
||
const wordlists = readJsonSafe(wordlistsPath);
|
||
wordlists[username] = words;
|
||
fs.writeFileSync(wordlistsPath, JSON.stringify(wordlists, null, 2));
|
||
res.send(`✅ Word list saved for ${username}`);
|
||
});
|
||
|
||
// Save multiple weeks with dates for a user
|
||
app.post('/saveWeeksWordList', (req, res) => {
|
||
const { username, weeks } = req.body;
|
||
if (
|
||
typeof username !== 'string' ||
|
||
!Array.isArray(weeks) ||
|
||
weeks.length > 100 ||
|
||
weeks.some(w => typeof w.date !== 'string' || !Array.isArray(w.words) || w.words.some(word => typeof word !== 'string'))
|
||
) return res.status(400).send('Invalid weeks data');
|
||
|
||
const userList = readJsonSafe(path.join(DATA_DIR, files.users), []);
|
||
if (!userList.find(u => u.username === username)) {
|
||
return res.status(404).send('User not found');
|
||
}
|
||
|
||
const wordlistsPath = path.join(DATA_DIR, files.wordlists);
|
||
const wordlists = readJsonSafe(wordlistsPath);
|
||
wordlists[username] = { weeks };
|
||
fs.writeFileSync(wordlistsPath, JSON.stringify(wordlists, null, 2));
|
||
res.send(`✅ Weeks word list saved for ${username}`);
|
||
});
|
||
|
||
// Set active week for a user
|
||
app.post('/setActiveWeek', (req, res) => {
|
||
const { username, activeWeek } = req.body;
|
||
if (typeof username !== 'string' || typeof activeWeek !== 'string') {
|
||
return res.status(400).send('Invalid data');
|
||
}
|
||
const wordlistsPath = path.join(DATA_DIR, files.wordlists);
|
||
const wordlists = readJsonSafe(wordlistsPath);
|
||
if (!wordlists[username] || typeof wordlists[username] !== 'object') {
|
||
return res.status(404).send('User not found or no weeks data');
|
||
}
|
||
wordlists[username].activeWeek = activeWeek;
|
||
fs.writeFileSync(wordlistsPath, JSON.stringify(wordlists, null, 2));
|
||
res.send(`✅ Active week set for ${username}: ${activeWeek}`);
|
||
});
|
||
|
||
// Set active week for a user
|
||
// ...existing code...
|
||
|
||
// 📊 Results
|
||
app.get('/getResults', (req, res) => {
|
||
const results = readJsonSafe(path.join(DATA_DIR, files.results));
|
||
res.json(results);
|
||
});
|
||
|
||
// Include gamification endpoints
|
||
const gamificationEndpoints = fs.readFileSync(path.join(__dirname, 'gamification-endpoints.js'), 'utf8');
|
||
eval(gamificationEndpoints);
|
||
|
||
// Include spaced repetition endpoints
|
||
const spacedRepetitionEndpoints = fs.readFileSync(path.join(__dirname, 'spaced-repetition-endpoints.js'), 'utf8');
|
||
eval(spacedRepetitionEndpoints);
|
||
|
||
// 📈 Enhanced Analytics API endpoint
|
||
app.get('/getAnalytics', (req, res) => {
|
||
try {
|
||
const results = readJsonSafe(path.join(DATA_DIR, files.results), {});
|
||
|
||
// Prepare analytics data structure
|
||
const analytics = {
|
||
summary: {
|
||
totalSessions: 0,
|
||
totalWords: 0,
|
||
correctWords: 0,
|
||
overallAccuracy: 0,
|
||
averageScore: 0,
|
||
mostMissedWords: [],
|
||
activityByDate: {}
|
||
},
|
||
userStats: {},
|
||
wordStats: {}
|
||
};
|
||
|
||
// Process all results data
|
||
Object.keys(results).forEach(username => {
|
||
// Skip if user has no results
|
||
if (!Array.isArray(results[username]) || results[username].length === 0) return;
|
||
|
||
// Initialize user stats if not already present
|
||
if (!analytics.userStats[username]) {
|
||
analytics.userStats[username] = {
|
||
totalSessions: 0,
|
||
totalWords: 0,
|
||
correctWords: 0,
|
||
accuracy: 0,
|
||
averageScore: 0,
|
||
trend: [], // For progress over time
|
||
recentResults: [],
|
||
problemWords: []
|
||
};
|
||
}
|
||
|
||
// Process each session for this user
|
||
results[username].forEach(session => {
|
||
// Skip invalid sessions
|
||
if (!session || !session.answers || !Array.isArray(session.answers)) return;
|
||
|
||
// Update summary counts
|
||
analytics.summary.totalSessions++;
|
||
analytics.userStats[username].totalSessions++;
|
||
|
||
// Process session date for activity tracking
|
||
const sessionDate = new Date(session.timestamp || Date.now()).toISOString().split('T')[0];
|
||
analytics.summary.activityByDate[sessionDate] = (analytics.summary.activityByDate[sessionDate] || 0) + 1;
|
||
|
||
// Collect score for trending data
|
||
if (typeof session.score === 'number' && session.answers.length > 0) {
|
||
const accuracy = session.score / session.answers.length;
|
||
analytics.userStats[username].trend.push({
|
||
date: sessionDate,
|
||
accuracy: accuracy * 100,
|
||
score: session.score,
|
||
total: session.answers.length
|
||
});
|
||
}
|
||
|
||
// Keep only most recent 10 sessions for the trend data
|
||
if (analytics.userStats[username].trend.length > 10) {
|
||
analytics.userStats[username].trend = analytics.userStats[username].trend.slice(-10);
|
||
}
|
||
|
||
// Get the 5 most recent results for display
|
||
if (analytics.userStats[username].recentResults.length < 5) {
|
||
analytics.userStats[username].recentResults.push({
|
||
date: new Date(session.timestamp || Date.now()).toLocaleString(),
|
||
score: session.score,
|
||
total: session.answers.length,
|
||
completed: session.completed
|
||
});
|
||
}
|
||
|
||
// Process individual words in the session
|
||
session.answers.forEach(answer => {
|
||
// Skip invalid answers
|
||
if (!answer || typeof answer.word !== 'string') return;
|
||
|
||
// Update word stats
|
||
const word = answer.word.toLowerCase();
|
||
|
||
if (!analytics.wordStats[word]) {
|
||
analytics.wordStats[word] = {
|
||
attempts: 0,
|
||
correct: 0,
|
||
incorrect: 0,
|
||
accuracy: 0
|
||
};
|
||
}
|
||
|
||
analytics.wordStats[word].attempts++;
|
||
analytics.summary.totalWords++;
|
||
analytics.userStats[username].totalWords++;
|
||
|
||
if (answer.correct) {
|
||
analytics.wordStats[word].correct++;
|
||
analytics.summary.correctWords++;
|
||
analytics.userStats[username].correctWords++;
|
||
} else {
|
||
analytics.wordStats[word].incorrect++;
|
||
|
||
// Track problem words for this user
|
||
const problemWordIndex = analytics.userStats[username].problemWords.findIndex(pw => pw.word === word);
|
||
|
||
if (problemWordIndex >= 0) {
|
||
analytics.userStats[username].problemWords[problemWordIndex].count++;
|
||
} else {
|
||
analytics.userStats[username].problemWords.push({
|
||
word,
|
||
count: 1
|
||
});
|
||
}
|
||
}
|
||
|
||
// Calculate accuracy for this word
|
||
analytics.wordStats[word].accuracy =
|
||
analytics.wordStats[word].correct / analytics.wordStats[word].attempts * 100;
|
||
});
|
||
|
||
// Calculate user accuracy and average score
|
||
analytics.userStats[username].accuracy =
|
||
analytics.userStats[username].correctWords / analytics.userStats[username].totalWords * 100 || 0;
|
||
analytics.userStats[username].averageScore =
|
||
analytics.userStats[username].correctWords / analytics.userStats[username].totalSessions || 0;
|
||
});
|
||
|
||
// Sort problem words by count (descending)
|
||
analytics.userStats[username].problemWords.sort((a, b) => b.count - a.count);
|
||
|
||
// Keep only top 5 problem words
|
||
analytics.userStats[username].problemWords = analytics.userStats[username].problemWords.slice(0, 5);
|
||
});
|
||
|
||
// Calculate overall metrics
|
||
analytics.summary.overallAccuracy =
|
||
analytics.summary.correctWords / analytics.summary.totalWords * 100 || 0;
|
||
analytics.summary.averageScore =
|
||
analytics.summary.correctWords / analytics.summary.totalSessions || 0;
|
||
|
||
// Find most missed words (top 5)
|
||
const missedWords = Object.keys(analytics.wordStats)
|
||
.map(word => ({
|
||
word,
|
||
missCount: analytics.wordStats[word].incorrect
|
||
}))
|
||
.filter(item => item.missCount > 0)
|
||
.sort((a, b) => b.missCount - a.missCount)
|
||
.slice(0, 5);
|
||
|
||
analytics.summary.mostMissedWords = missedWords;
|
||
|
||
res.json(analytics);
|
||
} catch (error) {
|
||
console.error('Error generating analytics:', error);
|
||
res.status(500).send('Error generating analytics data');
|
||
}
|
||
});
|
||
|
||
app.post('/saveResults', (req, res) => {
|
||
const { username, result } = req.body;
|
||
if (
|
||
typeof username !== 'string' ||
|
||
typeof result !== 'object' ||
|
||
typeof result.score !== 'number' ||
|
||
typeof result.completed !== 'boolean' ||
|
||
!Array.isArray(result.answers)
|
||
) return res.status(400).send("Invalid result format");
|
||
|
||
const resultsPath = path.join(DATA_DIR, files.results);
|
||
const allResults = readJsonSafe(resultsPath);
|
||
if (!allResults[username]) allResults[username] = [];
|
||
|
||
allResults[username].push({
|
||
...result,
|
||
timestamp: new Date().toISOString()
|
||
});
|
||
fs.writeFileSync(resultsPath, JSON.stringify(allResults, null, 2));
|
||
res.send(`✅ Results archived for ${username}`);
|
||
});
|
||
|
||
// 👥 Get users
|
||
// --- Typing Practice Results ---
|
||
// Save typing practice results for a user
|
||
app.post('/saveTypingResults', (req, res) => {
|
||
const { username, result } = req.body;
|
||
if (
|
||
typeof username !== 'string' ||
|
||
typeof result !== 'object' ||
|
||
typeof result.score !== 'number' ||
|
||
typeof result.completed !== 'boolean' ||
|
||
!Array.isArray(result.answers)
|
||
) return res.status(400).send("Invalid result format");
|
||
|
||
const resultsPath = path.join(DATA_DIR, files.results);
|
||
const allResults = readJsonSafe(resultsPath);
|
||
if (!allResults[username]) allResults[username] = [];
|
||
|
||
allResults[username].push({
|
||
...result,
|
||
timestamp: new Date().toISOString(),
|
||
type: 'typing' // Mark as typing practice result
|
||
});
|
||
fs.writeFileSync(resultsPath, JSON.stringify(allResults, null, 2));
|
||
res.send(`✅ Typing results archived for ${username}`);
|
||
});
|
||
app.get('/getUsers', (req, res) => {
|
||
const users = readJsonSafe(path.join(DATA_DIR, files.users), []);
|
||
res.json(users);
|
||
});
|
||
|
||
// 🎖 Badges
|
||
app.post('/awardBadges', (req, res) => {
|
||
const { username, badges } = req.body;
|
||
if (typeof username !== 'string' || !Array.isArray(badges)) {
|
||
return res.status(400).send("Invalid badge format");
|
||
}
|
||
|
||
const badgePath = path.join(DATA_DIR, files.badges);
|
||
const allBadges = readJsonSafe(badgePath);
|
||
if (!allBadges[username]) allBadges[username] = { earned: [], counts: {} };
|
||
|
||
// Initialize structure if old format
|
||
if (Array.isArray(allBadges[username])) {
|
||
// Convert from old format to new format
|
||
const oldBadges = [...allBadges[username]];
|
||
allBadges[username] = {
|
||
earned: oldBadges.map(name => ({
|
||
id: name.toLowerCase().replace(/\s/g, '_'),
|
||
name,
|
||
icon: "🏅",
|
||
earnedAt: new Date().toISOString()
|
||
})),
|
||
counts: {}
|
||
};
|
||
}
|
||
|
||
badges.forEach(badge => {
|
||
// Check if badge already exists by ID
|
||
const existingBadge = allBadges[username].earned.find(b => {
|
||
return (typeof b === 'object' && b.id === badge.id) ||
|
||
(typeof b === 'string' && b === badge.name);
|
||
});
|
||
|
||
if (!existingBadge) {
|
||
// Add new badge with timestamp
|
||
const badgeToAdd = {
|
||
...badge,
|
||
earnedAt: new Date().toISOString()
|
||
};
|
||
|
||
allBadges[username].earned.push(badgeToAdd);
|
||
|
||
// Track badge counts by category
|
||
if (badge.category) {
|
||
if (!allBadges[username].counts[badge.category]) {
|
||
allBadges[username].counts[badge.category] = 0;
|
||
}
|
||
allBadges[username].counts[badge.category]++;
|
||
}
|
||
}
|
||
});
|
||
|
||
fs.writeFileSync(badgePath, JSON.stringify(allBadges, null, 2));
|
||
res.send(`🎉 Badges updated for ${username}`);
|
||
});
|
||
|
||
app.get('/getBadges', (req, res) => {
|
||
const badgePath = path.join(DATA_DIR, files.badges);
|
||
const badges = readJsonSafe(badgePath);
|
||
res.json(badges);
|
||
});
|
||
|
||
// 🚀 Server start
|
||
app.listen(PORT, () => {
|
||
console.log(`✅ Server listening at http://localhost:${PORT}`);
|
||
|
||
// Display available users for easy login
|
||
try {
|
||
const usersPath = path.join(DATA_DIR, files.users);
|
||
const users = readJsonSafe(usersPath, []);
|
||
console.log('\n👥 Available Users:');
|
||
console.log('┌─────────────┬────────────┬──────────┐');
|
||
console.log('│ Username │ Password │ Role │');
|
||
console.log('├─────────────┼────────────┼──────────┤');
|
||
|
||
const userInfo = [
|
||
{ username: 'admin1', password: 'password', role: 'admin' },
|
||
{ username: 'nate', password: 'nate123', role: 'student' },
|
||
{ username: 'student1', password: '123456', role: 'student' }
|
||
];
|
||
|
||
userInfo.forEach(user => {
|
||
const exists = users.find(u => u.username === user.username);
|
||
const status = exists ? '✅' : '❌';
|
||
console.log(`│ ${user.username.padEnd(11)} │ ${user.password.padEnd(10)} │ ${user.role.padEnd(8)} │ ${status}`);
|
||
});
|
||
|
||
console.log('└─────────────┴────────────┴──────────┘');
|
||
console.log('\n🔐 Note: Change default passwords after first login!');
|
||
console.log(`🌐 Access the app at: http://localhost:${PORT}\n`);
|
||
} catch (error) {
|
||
console.log('⚠️ Could not display user information');
|
||
}
|
||
}); |