Spaces:
Sleeping
Sleeping
| /** | |
| * User Data Service - SINGLE SOURCE OF TRUTH | |
| * | |
| * Provides unified data access for Dashboard, Profile, and Analytics pages. | |
| * Uses backend API as primary source with localStorage fallback. | |
| * | |
| * CRITICAL: Both Dashboard and Profile MUST use this service. | |
| * DO NOT fetch data separately in components. | |
| */ | |
| import { analyticsApi, profileApi, resumeApi, userApi } from './api'; | |
| import { | |
| getCachedAnalytics, | |
| getStoredInterviews, | |
| getInterviewHistory, | |
| syncWithBackend, | |
| } from './interviewStorage'; | |
| // =========================================== | |
| // DATA SHAPE DEFINITIONS | |
| // =========================================== | |
| /** | |
| * @typedef {Object} UserAnalytics | |
| * @property {number} total_interviews | |
| * @property {number} completed_interviews | |
| * @property {number|null} average_score | |
| * @property {number|null} best_score | |
| * @property {string|null} last_interview_at | |
| * @property {string} trend - 'improving' | 'declining' | 'stable' | |
| * @property {number} completion_rate | |
| * @property {number} total_questions_answered | |
| * @property {Object} skill_summary | |
| */ | |
| /** | |
| * @typedef {Object} InterviewRecord | |
| * @property {string} id | |
| * @property {string} target_role | |
| * @property {number|null} score | |
| * @property {string} status | |
| * @property {string} created_at | |
| * @property {string} session_type | |
| * @property {string} difficulty | |
| * @property {number} duration | |
| * @property {Array} strengths | |
| * @property {Array} weaknesses | |
| * @property {boolean} has_recording | |
| */ | |
| // =========================================== | |
| // ANALYTICS COMPUTATION (Used by Dashboard & Profile) | |
| // =========================================== | |
| /** | |
| * Compute analytics from interview array | |
| * SINGLE function used by both Dashboard and Profile | |
| * | |
| * @param {Array} interviews - Array of interview records | |
| * @returns {UserAnalytics} | |
| */ | |
| export function computeAnalytics(interviews = []) { | |
| const completed = interviews.filter(i => | |
| i.status === 'completed' || i.status === 'completing' | |
| ); | |
| const scores = completed | |
| .filter(i => i.score != null && i.score > 0) | |
| .map(i => Number(i.score)); | |
| // Calculate trend (compare last 3 vs previous 3) | |
| let trend = 'stable'; | |
| if (scores.length >= 6) { | |
| const recent = scores.slice(0, 3).reduce((a, b) => a + b, 0) / 3; | |
| const older = scores.slice(3, 6).reduce((a, b) => a + b, 0) / 3; | |
| if (recent > older + 5) trend = 'improving'; | |
| else if (recent < older - 5) trend = 'declining'; | |
| } | |
| // Calculate completion rate | |
| const completionRate = interviews.length > 0 | |
| ? Math.round((completed.length / interviews.length) * 100) | |
| : 0; | |
| // Calculate total questions | |
| const totalQuestions = completed.reduce((sum, i) => { | |
| return sum + (i.total_questions || i.questions_answered || 0); | |
| }, 0); | |
| return { | |
| total_interviews: interviews.length, | |
| completed_interviews: completed.length, | |
| average_score: scores.length > 0 | |
| ? Math.round(scores.reduce((a, b) => a + b, 0) / scores.length) | |
| : null, | |
| best_score: scores.length > 0 ? Math.max(...scores) : null, | |
| last_interview_at: interviews.length > 0 ? interviews[0].created_at : null, | |
| trend, | |
| completion_rate: completionRate, | |
| total_questions_answered: totalQuestions, | |
| }; | |
| } | |
| // =========================================== | |
| // UNIFIED DATA LOADERS | |
| // =========================================== | |
| /** | |
| * Load all user data for Dashboard/Profile | |
| * Uses backend API with localStorage fallback | |
| * | |
| * @returns {Promise<{analytics: UserAnalytics, interviews: Array, resumes: Array}>} | |
| */ | |
| export async function loadUserData() { | |
| let analytics = getCachedAnalytics(); // Start with cache | |
| let interviews = []; | |
| let resumes = []; | |
| // Try backend first | |
| try { | |
| // Load all data in parallel | |
| const [analyticsRes, historyRes, resumesRes] = await Promise.allSettled([ | |
| userApi.getAnalytics(), | |
| profileApi.getInterviewHistory(50, 0), | |
| resumeApi.getAll(), | |
| ]); | |
| // Process analytics | |
| if (analyticsRes.status === 'fulfilled' && analyticsRes.value.success) { | |
| analytics = analyticsRes.value.analytics || analytics; | |
| } | |
| // Process interview history | |
| if (historyRes.status === 'fulfilled' && historyRes.value.success) { | |
| interviews = historyRes.value.interviews || []; | |
| // Sync to localStorage for future fallback | |
| syncWithBackend(interviews); | |
| } else { | |
| // Fallback to localStorage | |
| interviews = getStoredInterviews().map(normalizeInterviewRecord); | |
| } | |
| // Process resumes | |
| if (resumesRes.status === 'fulfilled' && resumesRes.value.success) { | |
| resumes = resumesRes.value.resumes || []; | |
| } | |
| // If backend analytics failed but we have interviews, compute locally | |
| if (!analytics.total_interviews && interviews.length > 0) { | |
| analytics = computeAnalytics(interviews); | |
| } | |
| } catch (error) { | |
| console.error('[UserDataService] Failed to load data:', error); | |
| // Full fallback to localStorage | |
| interviews = getStoredInterviews().map(normalizeInterviewRecord); | |
| analytics = computeAnalytics(interviews); | |
| } | |
| return { analytics, interviews, resumes }; | |
| } | |
| /** | |
| * Load dashboard-specific data (quick stats + recent interviews) | |
| * Optimized for dashboard which needs less data | |
| * | |
| * @returns {Promise<{analytics: UserAnalytics, recentInterviews: Array}>} | |
| */ | |
| export async function loadDashboardData() { | |
| let analytics = getCachedAnalytics(); | |
| let recentInterviews = getInterviewHistory(5); // Start with cache | |
| try { | |
| // Load analytics from backend | |
| const analyticsRes = await userApi.getAnalytics(); | |
| if (analyticsRes.success && analyticsRes.analytics) { | |
| analytics = analyticsRes.analytics; | |
| } | |
| // Load recent history | |
| const historyRes = await userApi.getHistory(5, 0); | |
| if (historyRes.success && historyRes.interviews?.length > 0) { | |
| recentInterviews = historyRes.interviews; | |
| syncWithBackend(historyRes.interviews); | |
| } | |
| } catch (error) { | |
| console.warn('[UserDataService] Dashboard API failed, using cache'); | |
| // Fallback already set | |
| } | |
| return { analytics, recentInterviews }; | |
| } | |
| /** | |
| * Load profile page data (full history + resumes) | |
| * | |
| * @returns {Promise<{analytics: UserAnalytics, interviews: Array, resumes: Array, user: Object}>} | |
| */ | |
| export async function loadProfileData() { | |
| return loadUserData(); | |
| } | |
| // =========================================== | |
| // HELPERS | |
| // =========================================== | |
| /** | |
| * Normalize interview record to consistent shape | |
| * Handles variations between backend and localStorage formats | |
| */ | |
| function normalizeInterviewRecord(record) { | |
| return { | |
| id: record.id || record.interviewId || record.session_id, | |
| target_role: record.target_role || record.targetRole || record.job_role || 'Interview', | |
| score: record.score ?? null, | |
| status: record.status || 'completed', | |
| created_at: record.created_at || record.date || record.createdAt, | |
| session_type: record.session_type || 'mixed', | |
| difficulty: record.difficulty || record.difficulty_level || 'medium', | |
| duration: record.duration || record.duration_minutes || 0, | |
| strengths: record.strengths || [], | |
| weaknesses: record.weaknesses || [], | |
| has_recording: record.has_recording || false, | |
| total_questions: record.total_questions || record.statistics?.total_questions || 0, | |
| questions_answered: record.questions_answered || record.statistics?.answered || 0, | |
| }; | |
| } | |
| /** | |
| * Get formatted analytics for Profile stats display | |
| */ | |
| export function getFormattedStats(analytics, resumeCount = 0) { | |
| return { | |
| total_interviews: analytics?.total_interviews || 0, | |
| completed_interviews: analytics?.completed_interviews || 0, | |
| average_score: analytics?.average_score || 0, | |
| total_resumes: resumeCount, | |
| best_score: analytics?.best_score || 0, | |
| completion_rate: analytics?.completion_rate || 0, | |
| trend: analytics?.trend || 'stable', | |
| }; | |
| } | |
| export default { | |
| computeAnalytics, | |
| loadUserData, | |
| loadDashboardData, | |
| loadProfileData, | |
| getFormattedStats, | |
| }; | |