update the chat to use the new chat, fix file uploads, mentions, and message area scaling
This commit is contained in:
772
src/contexts/OrgContext.tsx
Normal file
772
src/contexts/OrgContext.tsx
Normal file
@@ -0,0 +1,772 @@
|
||||
import React, { createContext, useContext, useEffect, useState } from 'react';
|
||||
import { collection, doc, getDoc, getDocs, onSnapshot, setDoc } from 'firebase/firestore';
|
||||
import { db, isFirebaseConfigured } from '../services/firebase';
|
||||
import { useAuth } from './AuthContext';
|
||||
import { Employee, Report, Submission, CompanyReport } from '../types';
|
||||
import { SAMPLE_COMPANY_REPORT, API_URL } from '../constants';
|
||||
import { demoStorage } from '../services/demoStorage';
|
||||
import { apiPost, apiPut } from '../services/api';
|
||||
import { User } from 'firebase/auth';
|
||||
import { EmployeeSubmissionAnswers } from '../employeeQuestions';
|
||||
|
||||
interface OrgData {
|
||||
orgId: string;
|
||||
name: string;
|
||||
industry?: string;
|
||||
size?: string;
|
||||
description?: string;
|
||||
mission?: string;
|
||||
vision?: string;
|
||||
values?: string;
|
||||
foundingYear?: string;
|
||||
evolution?: string;
|
||||
majorMilestones?: string;
|
||||
advantages?: string;
|
||||
vulnerabilities?: string;
|
||||
competitors?: string;
|
||||
marketPosition?: string;
|
||||
currentChallenges?: string;
|
||||
shortTermGoals?: string;
|
||||
longTermGoals?: string;
|
||||
keyMetrics?: string;
|
||||
cultureDescription?: string;
|
||||
workEnvironment?: string;
|
||||
leadershipStyle?: string;
|
||||
communicationStyle?: string;
|
||||
additionalContext?: string;
|
||||
onboardingCompleted?: boolean;
|
||||
}
|
||||
|
||||
interface OrgContextType {
|
||||
org: OrgData | null;
|
||||
user?: User;
|
||||
orgId: string;
|
||||
employees: Employee[];
|
||||
submissions: Record<string, Submission>;
|
||||
reports: Record<string, Report>;
|
||||
upsertOrg: (data: Partial<OrgData>) => Promise<void>;
|
||||
saveReport: (employeeId: string, report: Report) => Promise<void>;
|
||||
inviteEmployee: (args: { name: string; email: string }) => Promise<{ employeeId: string; inviteLink: string }>;
|
||||
issueInviteViaApi: (args: { name: string; email: string; role?: string; department?: string }) => Promise<{ code: string; inviteLink: string; emailLink: string; employee: any }>;
|
||||
getInviteStatus: (code: string) => Promise<{ used: boolean; employee: any } | null>;
|
||||
consumeInvite: (code: string) => Promise<{ employee: any } | null>;
|
||||
getReportVersions: (employeeId: string) => Promise<Array<{ id: string; createdAt: number; report: Report }>>;
|
||||
saveReportVersion: (employeeId: string, report: Report) => Promise<void>;
|
||||
acceptInvite: (code: string) => Promise<void>;
|
||||
saveCompanyReport: (summary: string) => Promise<void>;
|
||||
getCompanyReportHistory: () => Promise<Array<{ id: string; createdAt: number; summary: string }>>;
|
||||
saveFullCompanyReport: (report: CompanyReport) => Promise<void>;
|
||||
getFullCompanyReportHistory: () => Promise<CompanyReport[]>;
|
||||
generateCompanyReport: () => Promise<CompanyReport>;
|
||||
generateCompanyWiki: (orgOverride?: OrgData) => Promise<CompanyReport>;
|
||||
seedInitialData: () => Promise<void>;
|
||||
isOwner: (employeeId?: string) => boolean;
|
||||
submitEmployeeAnswers: (employeeId: string, answers: Record<string, string>) => Promise<any>;
|
||||
generateEmployeeReport: (employee: Employee) => Promise<Report | null>;
|
||||
getEmployeeReport: (employeeId: string) => Promise<{ success: boolean; report?: Report; error?: string }>;
|
||||
getEmployeeReports: () => Promise<{ success: boolean; reports?: Report[]; error?: string }>;
|
||||
}
|
||||
|
||||
const OrgContext = createContext<OrgContextType | undefined>(undefined);
|
||||
|
||||
export const OrgProvider: React.FC<{ children: React.ReactNode; selectedOrgId: string }> = ({ children, selectedOrgId }) => {
|
||||
const { user } = useAuth();
|
||||
const [org, setOrg] = useState<OrgData | null>(null);
|
||||
const [employees, setEmployees] = useState<Employee[]>([]);
|
||||
const [submissions, setSubmissions] = useState<Record<string, Submission>>({});
|
||||
const [reports, setReports] = useState<Record<string, Report>>({});
|
||||
const [reportVersions, setReportVersions] = useState<Record<string, Array<{ id: string; createdAt: number; report: Report }>>>({});
|
||||
const [companyReports, setCompanyReports] = useState<Array<{ id: string; createdAt: number; summary: string }>>([]);
|
||||
const [fullCompanyReports, setFullCompanyReports] = useState<CompanyReport[]>([]);
|
||||
|
||||
// Use the provided selectedOrgId instead of deriving from user
|
||||
const orgId = selectedOrgId;
|
||||
|
||||
useEffect(() => {
|
||||
console.log('OrgContext effect running, orgId:', orgId, 'isFirebaseConfigured:', isFirebaseConfigured);
|
||||
if (!orgId) return; // Wait for orgId to be available
|
||||
console.log('Setting up Firebase org data');
|
||||
const orgRef = doc(db, 'orgs', orgId);
|
||||
getDoc(orgRef).then(async (snap) => {
|
||||
if (snap.exists()) {
|
||||
setOrg({ orgId, ...(snap.data() as any) });
|
||||
} else {
|
||||
const seed = { name: 'Your Company', onboardingCompleted: false };
|
||||
await setDoc(orgRef, seed);
|
||||
setOrg({ orgId, ...(seed as any) });
|
||||
}
|
||||
});
|
||||
|
||||
const employeesCol = collection(db, 'orgs', orgId, 'employees');
|
||||
const unsubEmp = onSnapshot(employeesCol, (snap) => {
|
||||
const arr: Employee[] = [];
|
||||
snap.forEach((d) => arr.push({ id: d.id, ...(d.data() as any) }));
|
||||
setEmployees(arr);
|
||||
});
|
||||
|
||||
const submissionsCol = collection(db, 'orgs', orgId, 'submissions');
|
||||
const unsubSub = onSnapshot(submissionsCol, (snap) => {
|
||||
const map: Record<string, Submission> = {};
|
||||
snap.forEach((d) => (map[d.id] = { employeeId: d.id, ...(d.data() as any) }));
|
||||
setSubmissions(map);
|
||||
});
|
||||
|
||||
const reportsCol = collection(db, 'orgs', orgId, 'reports');
|
||||
const unsubRep = onSnapshot(reportsCol, (snap) => {
|
||||
const map: Record<string, Report> = {};
|
||||
snap.forEach((d) => (map[d.id] = { employeeId: d.id, ...(d.data() as any) } as Report));
|
||||
setReports(map);
|
||||
});
|
||||
|
||||
return () => { unsubEmp(); unsubSub(); unsubRep(); };
|
||||
}, [orgId]);
|
||||
|
||||
const upsertOrg = async (data: Partial<OrgData>) => {
|
||||
const orgRef = doc(db, 'orgs', orgId);
|
||||
await setDoc(orgRef, data, { merge: true });
|
||||
|
||||
// Update local state
|
||||
const updatedOrg = { ...(org || { orgId, name: 'Your Company' }), ...data } as OrgData;
|
||||
setOrg(updatedOrg);
|
||||
|
||||
// If onboarding was completed, notify other contexts
|
||||
if (data.onboardingCompleted) {
|
||||
console.log('OrgContext (Firebase): Onboarding completed, dispatching update event', {
|
||||
orgId: updatedOrg.orgId,
|
||||
onboardingCompleted: true
|
||||
});
|
||||
|
||||
window.dispatchEvent(new CustomEvent('organizationUpdated', {
|
||||
detail: { orgId: updatedOrg.orgId, onboardingCompleted: true }
|
||||
}));
|
||||
}
|
||||
};
|
||||
|
||||
const saveReport = async (employeeId: string, report: Report) => {
|
||||
const ref = doc(db, 'orgs', orgId, 'reports', employeeId);
|
||||
await setDoc(ref, report, { merge: true });
|
||||
};
|
||||
|
||||
const inviteEmployee = async ({ name, email }: { name: string; email: string }) => {
|
||||
console.log('inviteEmployee called:', { name, email, orgId });
|
||||
|
||||
try {
|
||||
// Always use Cloud Functions for invites to ensure multi-tenant compliance
|
||||
const res = await apiPost('/createInvitation', {
|
||||
name,
|
||||
email
|
||||
}, orgId);
|
||||
|
||||
if (!res.ok) {
|
||||
const errorData = await res.json();
|
||||
console.error('Invite creation failed:', errorData);
|
||||
throw new Error(errorData.error || `Failed to create invite: ${res.status}`);
|
||||
}
|
||||
|
||||
const data = await res.json();
|
||||
const { code, employee, inviteLink } = data;
|
||||
|
||||
console.log('Invite created successfully:', { code, employee: employee.name, inviteLink });
|
||||
|
||||
// Store employee locally for immediate UI update with proper typing
|
||||
const newEmployee: Employee = {
|
||||
id: employee.id,
|
||||
name: employee.name,
|
||||
email: employee.email,
|
||||
initials: employee.name ? employee.name.split(' ').map(n => n[0]).join('').toUpperCase() : employee.email.substring(0, 2).toUpperCase(),
|
||||
department: employee.department,
|
||||
role: employee.role,
|
||||
isOwner: false
|
||||
};
|
||||
|
||||
if (!isFirebaseConfigured) {
|
||||
const employeeWithOrg = { ...newEmployee, orgId };
|
||||
setEmployees(prev => {
|
||||
if (prev.find(e => e.id === employee.id)) return prev;
|
||||
return [...prev, newEmployee];
|
||||
});
|
||||
demoStorage.saveEmployee(employeeWithOrg);
|
||||
} else {
|
||||
// For Firebase, add to local state for immediate UI update
|
||||
setEmployees(prev => {
|
||||
if (prev.find(e => e.id === employee.id)) return prev;
|
||||
return [...prev, newEmployee];
|
||||
});
|
||||
}
|
||||
|
||||
return { employeeId: employee.id, inviteLink };
|
||||
} catch (error) {
|
||||
console.error('inviteEmployee error:', error);
|
||||
throw error;
|
||||
}
|
||||
};
|
||||
|
||||
const getReportVersions = async (employeeId: string) => {
|
||||
if (!isFirebaseConfigured) {
|
||||
return reportVersions[employeeId] || [];
|
||||
}
|
||||
const col = collection(db, 'orgs', orgId, 'reports', employeeId, 'versions');
|
||||
const snap = await getDocs(col);
|
||||
const arr: Array<{ id: string; createdAt: number; report: Report }> = [];
|
||||
snap.forEach(d => {
|
||||
const data = d.data() as any;
|
||||
arr.push({ id: d.id, createdAt: data.createdAt ?? 0, report: data.report as Report });
|
||||
});
|
||||
return arr.sort((a, b) => b.createdAt - a.createdAt);
|
||||
};
|
||||
|
||||
const saveReportVersion = async (employeeId: string, report: Report) => {
|
||||
const version = { id: Date.now().toString(), createdAt: Date.now(), report };
|
||||
if (!isFirebaseConfigured) {
|
||||
setReportVersions(prev => ({ ...prev, [employeeId]: [version, ...(prev[employeeId] || [])] }));
|
||||
return;
|
||||
}
|
||||
const ref = doc(db, 'orgs', orgId, 'reports', employeeId, 'versions', version.id);
|
||||
await setDoc(ref, { createdAt: version.createdAt, report });
|
||||
};
|
||||
|
||||
const acceptInvite = async (code: string) => {
|
||||
if (!code) return;
|
||||
|
||||
if (!isFirebaseConfigured) {
|
||||
// Demo mode: mark invite as used
|
||||
demoStorage.markInviteUsed(code);
|
||||
return;
|
||||
}
|
||||
|
||||
const inviteRef = doc(db, 'orgs', orgId, 'invites', code);
|
||||
const snap = await getDoc(inviteRef);
|
||||
if (!snap.exists()) return;
|
||||
const data = snap.data() as any;
|
||||
// Minimal: mark accepted
|
||||
await setDoc(inviteRef, { ...data, acceptedAt: Date.now() }, { merge: true });
|
||||
};
|
||||
|
||||
const saveCompanyReport = async (summary: string) => {
|
||||
const id = Date.now().toString();
|
||||
const createdAt = Date.now();
|
||||
if (!isFirebaseConfigured) {
|
||||
const reportData = { id, createdAt, summary };
|
||||
setCompanyReports(prev => [reportData, ...prev]);
|
||||
// Persist to localStorage (note: this method stores simple reports)
|
||||
return;
|
||||
}
|
||||
const ref = doc(db, 'orgs', orgId, 'companyReports', id);
|
||||
await setDoc(ref, { createdAt, summary });
|
||||
};
|
||||
|
||||
const getCompanyReportHistory = async () => {
|
||||
if (!isFirebaseConfigured) {
|
||||
return companyReports;
|
||||
}
|
||||
const col = collection(db, 'orgs', orgId, 'companyReports');
|
||||
const snap = await getDocs(col);
|
||||
const arr: Array<{ id: string; createdAt: number; summary: string }> = [];
|
||||
snap.forEach(d => {
|
||||
const data = d.data() as any;
|
||||
arr.push({ id: d.id, createdAt: data.createdAt ?? 0, summary: data.summary ?? '' });
|
||||
});
|
||||
return arr.sort((a, b) => b.createdAt - a.createdAt);
|
||||
};
|
||||
|
||||
const seedInitialData = async () => {
|
||||
if (!isFirebaseConfigured) {
|
||||
// Start with completely clean slate - no sample data
|
||||
setEmployees([]);
|
||||
setSubmissions({});
|
||||
setReports({});
|
||||
setFullCompanyReports([]);
|
||||
return;
|
||||
}
|
||||
|
||||
// Start with clean slate - let users invite their own employees and generate real data
|
||||
};
|
||||
|
||||
const saveFullCompanyReport = async (report: CompanyReport) => {
|
||||
if (!orgId) {
|
||||
console.error('Cannot save company report: orgId is undefined');
|
||||
throw new Error('Organization ID is required to save company report');
|
||||
}
|
||||
|
||||
if (!isFirebaseConfigured || !db) {
|
||||
// Fallback to local storage in demo mode
|
||||
setFullCompanyReports(prev => [report, ...prev]);
|
||||
demoStorage.saveCompanyReport(orgId, report);
|
||||
return;
|
||||
}
|
||||
|
||||
// Use direct Firestore operations - much more efficient
|
||||
const ref = doc(db, 'orgs', orgId, 'fullCompanyReports', report.id);
|
||||
await setDoc(ref, report);
|
||||
|
||||
// Update local state after successful save
|
||||
setFullCompanyReports(prev => [report, ...prev]);
|
||||
};
|
||||
|
||||
const getFullCompanyReportHistory = async (): Promise<CompanyReport[]> => {
|
||||
if (!isFirebaseConfigured) {
|
||||
return fullCompanyReports;
|
||||
}
|
||||
const col = collection(db, 'orgs', orgId, 'fullCompanyReports');
|
||||
const snap = await getDocs(col);
|
||||
const arr: CompanyReport[] = [];
|
||||
snap.forEach(d => {
|
||||
arr.push({ id: d.id, ...d.data() } as CompanyReport);
|
||||
});
|
||||
return arr.sort((a, b) => b.createdAt - a.createdAt);
|
||||
};
|
||||
|
||||
const generateCompanyReport = async (): Promise<CompanyReport> => {
|
||||
console.log('generateCompanyReport called for org:', orgId);
|
||||
|
||||
// Calculate concrete metrics from actual data (no AI needed)
|
||||
// Exclude owners from employee counts - they are company wiki contributors, not employees
|
||||
const actualEmployees = employees.filter(emp => !emp.isOwner);
|
||||
const totalEmployees = actualEmployees.length;
|
||||
|
||||
// Only count submissions from non-owner employees
|
||||
const employeeSubmissions = Object.fromEntries(
|
||||
Object.entries(submissions).filter(([employeeId]) => {
|
||||
const employee = employees.find(emp => emp.id === employeeId);
|
||||
return employee && !employee.isOwner;
|
||||
})
|
||||
);
|
||||
const submittedEmployees = Object.keys(employeeSubmissions).length;
|
||||
const submissionRate = totalEmployees > 0 ? (submittedEmployees / totalEmployees) * 100 : 0;
|
||||
|
||||
// Department breakdown (concrete data) - exclude owners
|
||||
const deptMap = new Map<string, number>();
|
||||
actualEmployees.forEach(emp => {
|
||||
const dept = emp.department || 'Unassigned';
|
||||
deptMap.set(dept, (deptMap.get(dept) || 0) + 1);
|
||||
});
|
||||
const departmentBreakdown = Array.from(deptMap.entries()).map(([department, count]) => ({ department, count }));
|
||||
|
||||
try {
|
||||
// Use AI only for analysis and insights that require reasoning
|
||||
const res = await apiPost('/generateCompanyWiki', {
|
||||
org: org,
|
||||
submissions: employeeSubmissions, // Only employee submissions, not owner data
|
||||
metrics: {
|
||||
totalEmployees,
|
||||
submissionRate,
|
||||
departmentBreakdown
|
||||
}
|
||||
}, orgId);
|
||||
|
||||
if (!res.ok) {
|
||||
const errorData = await res.json();
|
||||
console.error('Company report generation failed:', errorData);
|
||||
throw new Error(errorData.error || 'Failed to generate company report');
|
||||
}
|
||||
|
||||
const data = await res.json();
|
||||
console.log('Company insights generated via AI successfully');
|
||||
console.log('AI response data:', data);
|
||||
|
||||
// Combine concrete metrics with AI insights
|
||||
const report: CompanyReport = {
|
||||
id: Date.now().toString(),
|
||||
createdAt: Date.now(),
|
||||
// Use AI-generated insights for subjective analysis
|
||||
...data.report,
|
||||
// Override with our concrete metrics
|
||||
overview: {
|
||||
totalEmployees,
|
||||
departmentBreakdown,
|
||||
submissionRate,
|
||||
lastUpdated: Date.now(),
|
||||
averagePerformanceScore: data.report?.overview?.averagePerformanceScore || 0,
|
||||
riskLevel: data.report?.overview?.riskLevel || 'Unknown'
|
||||
}
|
||||
};
|
||||
|
||||
console.log('Final company report object:', report);
|
||||
await saveFullCompanyReport(report);
|
||||
return report;
|
||||
} catch (error) {
|
||||
console.error('generateCompanyReport error:', error);
|
||||
throw error;
|
||||
}
|
||||
};
|
||||
|
||||
const generateCompanyWiki = async (orgOverride?: OrgData): Promise<CompanyReport> => {
|
||||
const orgData = orgOverride || org;
|
||||
console.log('generateCompanyWiki called with:', { orgData, orgId, submissionsCount: Object.keys(submissions || {}).length, isFirebaseConfigured });
|
||||
|
||||
if (!orgId) {
|
||||
throw new Error('Organization ID is required to generate company wiki');
|
||||
}
|
||||
|
||||
// ALWAYS use API call for wiki generation, with local fallback
|
||||
try {
|
||||
console.log('Making API call to generateCompanyWiki...');
|
||||
const res = await apiPost('/generateCompanyWiki', {
|
||||
org: orgData,
|
||||
submissions: submissions || []
|
||||
}, orgId);
|
||||
|
||||
console.log('API response status:', res.status);
|
||||
|
||||
if (!res.ok) {
|
||||
const errorData = await res.json();
|
||||
console.error('API error response:', errorData);
|
||||
throw new Error(errorData.error || 'Failed to generate company wiki');
|
||||
}
|
||||
|
||||
const payload = await res.json();
|
||||
console.log('API success response:', payload);
|
||||
|
||||
// Ensure the report has all required fields to prevent undefined errors
|
||||
const data: CompanyReport = {
|
||||
id: Date.now().toString(),
|
||||
createdAt: Date.now(),
|
||||
overview: {
|
||||
totalEmployees: employees.length,
|
||||
departmentBreakdown: [],
|
||||
submissionRate: 0,
|
||||
lastUpdated: Date.now(),
|
||||
averagePerformanceScore: 0,
|
||||
riskLevel: 'Unknown'
|
||||
},
|
||||
gradingBreakdown: [],
|
||||
operatingPlan: { nextQuarterGoals: [], keyInitiatives: [], resourceNeeds: [], riskMitigation: [] },
|
||||
personnelChanges: { newHires: [], promotions: [], departures: [] },
|
||||
keyPersonnelChanges: [],
|
||||
immediateHiringNeeds: [],
|
||||
forwardOperatingPlan: { quarterlyGoals: [], resourceNeeds: [], riskMitigation: [] },
|
||||
organizationalStrengths: [],
|
||||
organizationalRisks: [],
|
||||
gradingOverview: {},
|
||||
executiveSummary: 'Company report generated successfully.',
|
||||
// Override with API data if available
|
||||
...(payload.report || payload)
|
||||
};
|
||||
|
||||
await saveFullCompanyReport(data);
|
||||
return data;
|
||||
} catch (e) {
|
||||
console.error('generateCompanyWiki error, falling back to local synthetic:', e);
|
||||
return generateCompanyReport();
|
||||
}
|
||||
};
|
||||
|
||||
const isOwner = (employeeId?: string): boolean => {
|
||||
const currentEmployee = employeeId ? employees.find(e => e.id === employeeId) :
|
||||
employees.find(e => e.email === user?.email);
|
||||
return currentEmployee?.isOwner === true;
|
||||
};
|
||||
|
||||
const getEmployeeReport = async (employeeId: string) => {
|
||||
try {
|
||||
if (isFirebaseConfigured && user) {
|
||||
// Firebase implementation
|
||||
const reportDoc = await getDoc(doc(db, 'organizations', orgId, 'employeeReports', employeeId));
|
||||
if (reportDoc.exists()) {
|
||||
return { success: true, report: reportDoc.data() };
|
||||
}
|
||||
return { success: false, error: 'Report not found' };
|
||||
} else {
|
||||
// Demo mode - call API
|
||||
const response = await fetch(`${API_URL}/api/employee-report/${employeeId}`);
|
||||
const result = await response.json();
|
||||
return result;
|
||||
}
|
||||
} catch (error) {
|
||||
console.error('Error fetching employee report:', error);
|
||||
return { success: false, error: error.message };
|
||||
}
|
||||
};
|
||||
|
||||
const getEmployeeReports = async () => {
|
||||
try {
|
||||
if (isFirebaseConfigured && user) {
|
||||
// Firebase implementation
|
||||
const reportsSnapshot = await getDocs(collection(db, 'organizations', orgId, 'employeeReports'));
|
||||
const reports = reportsSnapshot.docs.map(doc => ({ id: doc.id, ...doc.data() }));
|
||||
return { success: true, reports };
|
||||
} else {
|
||||
// Demo mode - call API
|
||||
const response = await fetch(`${API_URL}/api/employee-reports`);
|
||||
const result = await response.json();
|
||||
return result;
|
||||
}
|
||||
} catch (error) {
|
||||
console.error('Error fetching employee reports:', error);
|
||||
return { success: false, error: error.message };
|
||||
}
|
||||
};
|
||||
|
||||
const value = {
|
||||
org,
|
||||
orgId,
|
||||
employees,
|
||||
submissions,
|
||||
reports,
|
||||
upsertOrg,
|
||||
saveReport,
|
||||
inviteEmployee,
|
||||
getReportVersions,
|
||||
saveReportVersion,
|
||||
acceptInvite,
|
||||
saveCompanyReport,
|
||||
getCompanyReportHistory,
|
||||
saveFullCompanyReport,
|
||||
getFullCompanyReportHistory,
|
||||
generateCompanyReport,
|
||||
generateCompanyWiki,
|
||||
seedInitialData,
|
||||
isOwner,
|
||||
issueInviteViaApi: async ({ name, email, role, department }) => {
|
||||
try {
|
||||
const res = await apiPost('/createInvitation', {
|
||||
name,
|
||||
email,
|
||||
role,
|
||||
department
|
||||
}, orgId);
|
||||
|
||||
if (!res.ok) {
|
||||
const errorData = await res.json();
|
||||
throw new Error(errorData.error || 'Invite creation failed');
|
||||
}
|
||||
|
||||
const json = await res.json();
|
||||
// Optimistically add employee shell (not yet active until consume)
|
||||
setEmployees(prev => prev.find(e => e.id === json.employee.id) ? prev : [...prev, { ...json.employee }]);
|
||||
return json;
|
||||
} catch (e) {
|
||||
console.error('issueInviteViaApi error', e);
|
||||
throw e;
|
||||
}
|
||||
},
|
||||
getInviteStatus: async (code: string) => {
|
||||
if (!isFirebaseConfigured) {
|
||||
// Demo mode: check localStorage first, then server
|
||||
const invite = demoStorage.getInvite(code);
|
||||
if (invite) {
|
||||
return { used: invite.used, employee: invite.employee };
|
||||
}
|
||||
}
|
||||
|
||||
try {
|
||||
const res = await fetch(`${API_URL}/getInvitationStatus?code=${code}`);
|
||||
if (!res.ok) return null;
|
||||
return await res.json();
|
||||
} catch (e) {
|
||||
console.error('getInviteStatus error', e);
|
||||
return null;
|
||||
}
|
||||
},
|
||||
consumeInvite: async (code: string) => {
|
||||
if (!isFirebaseConfigured) {
|
||||
// Demo mode: mark invite as used in localStorage and update state
|
||||
const invite = demoStorage.getInvite(code);
|
||||
if (invite && !invite.used) {
|
||||
demoStorage.markInviteUsed(code);
|
||||
// Ensure employee is in the list with proper typing
|
||||
const convertedEmployee: Employee = {
|
||||
id: invite.employee.id,
|
||||
name: invite.employee.name,
|
||||
email: invite.employee.email,
|
||||
initials: invite.employee.name ? invite.employee.name.split(' ').map(n => n[0]).join('').toUpperCase() : invite.employee.email.substring(0, 2).toUpperCase(),
|
||||
department: invite.employee.department,
|
||||
role: invite.employee.role
|
||||
};
|
||||
setEmployees(prev => prev.find(e => e.id === invite.employee.id) ? prev : [...prev, convertedEmployee]);
|
||||
return { employee: convertedEmployee };
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
try {
|
||||
const res = await fetch(`${API_URL}/consumeInvitation?code=${code}`, { method: 'POST' });
|
||||
if (!res.ok) return null;
|
||||
const json = await res.json();
|
||||
// Mark employee as active (could set a flag later)
|
||||
setEmployees(prev => prev.find(e => e.id === json.employee.id) ? prev : [...prev, json.employee]);
|
||||
return json;
|
||||
} catch (e) {
|
||||
console.error('consumeInvite error', e);
|
||||
return null;
|
||||
}
|
||||
},
|
||||
submitEmployeeAnswers: async (employeeId: string, answers: Record<string, string>) => {
|
||||
if (!isFirebaseConfigured) {
|
||||
// Demo mode: save to localStorage and call server endpoint
|
||||
try {
|
||||
const submission = {
|
||||
employeeId,
|
||||
orgId,
|
||||
answers,
|
||||
createdAt: Date.now()
|
||||
};
|
||||
|
||||
// Save to localStorage for persistence
|
||||
demoStorage.saveSubmission(submission);
|
||||
|
||||
// Also call Cloud Function for processing with authentication and orgId
|
||||
const employee = employees.find(e => e.id === employeeId);
|
||||
const res = await apiPost('/submitEmployeeAnswers', {
|
||||
employeeId,
|
||||
answers,
|
||||
employee
|
||||
}, orgId);
|
||||
|
||||
if (!res.ok) {
|
||||
const errorData = await res.json();
|
||||
throw new Error(errorData.error || 'Failed to submit to server');
|
||||
}
|
||||
|
||||
// Update local state for UI with proper typing
|
||||
const convertedSubmission: Submission = {
|
||||
employeeId,
|
||||
answers: Object.entries(answers).map(([question, answer]) => ({
|
||||
question,
|
||||
answer
|
||||
}))
|
||||
};
|
||||
setSubmissions(prev => ({ ...prev, [employeeId]: convertedSubmission }));
|
||||
return true;
|
||||
} catch (e) {
|
||||
console.error('submitEmployeeAnswers error', e);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Firebase mode: save to Firestore
|
||||
try {
|
||||
const ref = doc(db, 'orgs', orgId, 'submissions', employeeId);
|
||||
await setDoc(ref, { ...answers, createdAt: Date.now() }, { merge: true });
|
||||
return true;
|
||||
} catch (e) {
|
||||
console.error('submitEmployeeAnswers error', e);
|
||||
return false;
|
||||
}
|
||||
},
|
||||
generateEmployeeReport: async (employee: Employee) => {
|
||||
try {
|
||||
console.log('generateEmployeeReport called for:', employee.name, 'in org:', orgId);
|
||||
|
||||
// Get submission data for this employee
|
||||
const submission = submissions[employee.id];
|
||||
if (!submission) {
|
||||
throw new Error(`No questionnaire submission found for ${employee.name}. Please ensure they have completed the employee questionnaire first.`);
|
||||
}
|
||||
|
||||
// Convert submission format for API
|
||||
let submissionAnswers: Record<string, string> = {};
|
||||
if (submission.answers) {
|
||||
if (Array.isArray(submission.answers)) {
|
||||
// If answers is an array of {question, answer} objects
|
||||
submissionAnswers = submission.answers.reduce((acc, item) => {
|
||||
acc[item.question] = item.answer;
|
||||
return acc;
|
||||
}, {} as Record<string, string>);
|
||||
} else {
|
||||
// If answers is already a key-value object
|
||||
submissionAnswers = submission.answers as Record<string, string>;
|
||||
}
|
||||
}
|
||||
|
||||
console.log('Submission data found:', Object.keys(submissionAnswers).length, 'answers');
|
||||
|
||||
// Get company report and wiki data for context
|
||||
let companyWiki = null;
|
||||
try {
|
||||
const companyReports = await getFullCompanyReportHistory();
|
||||
if (companyReports.length > 0) {
|
||||
companyWiki = {
|
||||
org: org,
|
||||
companyReport: companyReports[0]
|
||||
};
|
||||
console.log('Including company context in employee report generation');
|
||||
}
|
||||
} catch (error) {
|
||||
console.warn('Could not fetch company report for context:', error);
|
||||
}
|
||||
|
||||
const res = await apiPost('/generateEmployeeReport', {
|
||||
employee,
|
||||
submission: submissionAnswers,
|
||||
companyWiki
|
||||
}, orgId);
|
||||
|
||||
if (!res.ok) {
|
||||
const errorData = await res.json();
|
||||
console.error('API error response:', errorData);
|
||||
throw new Error(errorData.error || 'Failed to generate employee report');
|
||||
}
|
||||
|
||||
const json = await res.json();
|
||||
if (json.report) {
|
||||
console.log('Employee report generated successfully');
|
||||
setReports(prev => ({ ...prev, [employee.id]: json.report }));
|
||||
|
||||
// Also save to persistent storage in demo mode
|
||||
if (!isFirebaseConfigured) {
|
||||
demoStorage.saveEmployeeReport(orgId, employee.id, json.report);
|
||||
}
|
||||
|
||||
return json.report as Report;
|
||||
} else {
|
||||
throw new Error('No report data received from API');
|
||||
}
|
||||
} catch (e) {
|
||||
console.error('generateEmployeeReport error', e);
|
||||
throw e; // Re-throw to allow caller to handle
|
||||
}
|
||||
},
|
||||
getEmployeeReport: async (employeeId: string) => {
|
||||
try {
|
||||
if (isFirebaseConfigured && user) {
|
||||
// Firebase implementation
|
||||
const reportDoc = await getDoc(doc(db, 'organizations', orgId, 'employeeReports', employeeId));
|
||||
if (reportDoc.exists()) {
|
||||
return { success: true, report: reportDoc.data() };
|
||||
}
|
||||
return { success: false, error: 'Report not found' };
|
||||
} else {
|
||||
// Demo mode - call Cloud Function
|
||||
const response = await fetch(`${API_URL}/generateEmployeeReport?employeeId=${employeeId}`);
|
||||
const result = await response.json();
|
||||
return result;
|
||||
}
|
||||
} catch (error) {
|
||||
console.error('Error fetching employee report:', error);
|
||||
return { success: false, error: error.message };
|
||||
}
|
||||
},
|
||||
|
||||
getEmployeeReports: async () => {
|
||||
try {
|
||||
if (isFirebaseConfigured && user) {
|
||||
// Firebase implementation
|
||||
const reportsSnapshot = await getDocs(collection(db, 'organizations', orgId, 'employeeReports'));
|
||||
const reports = reportsSnapshot.docs.map(doc => ({ id: doc.id, ...doc.data() }));
|
||||
return { success: true, reports };
|
||||
} else {
|
||||
// Demo mode - call Cloud Function
|
||||
const response = await fetch(`${API_URL}/generateEmployeeReport`);
|
||||
const result = await response.json();
|
||||
return result;
|
||||
}
|
||||
} catch (error) {
|
||||
console.error('Error fetching employee reports:', error);
|
||||
return { success: false, error: error.message };
|
||||
}
|
||||
},
|
||||
};
|
||||
|
||||
return (
|
||||
<OrgContext.Provider value={value}>
|
||||
{children}
|
||||
</OrgContext.Provider>
|
||||
);
|
||||
};
|
||||
|
||||
export const useOrg = () => {
|
||||
const ctx = useContext(OrgContext);
|
||||
if (!ctx) throw new Error('useOrg must be used within OrgProvider');
|
||||
return ctx;
|
||||
};
|
||||
Reference in New Issue
Block a user