800 lines
36 KiB
TypeScript
800 lines
36 KiB
TypeScript
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 { REPORT_DATA, SUBMISSIONS_DATA, SAMPLE_COMPANY_REPORT, API_URL } from '../constants';
|
|
import { demoStorage } from '../services/demoStorage';
|
|
|
|
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;
|
|
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<boolean>;
|
|
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
|
|
if (!isFirebaseConfigured) {
|
|
// Demo mode data - use persistent localStorage with proper initialization
|
|
console.log('Setting up demo org data with persistence');
|
|
|
|
// Get or create persistent demo org
|
|
let demoOrg = demoStorage.getOrganization(orgId);
|
|
if (!demoOrg) {
|
|
demoOrg = {
|
|
orgId: orgId,
|
|
name: 'Demo Company',
|
|
onboardingCompleted: false
|
|
};
|
|
demoStorage.saveOrganization(demoOrg);
|
|
|
|
// Initialize with empty employee list for clean start
|
|
// (Removed automatic seeding of 6 default employees per user feedback)
|
|
|
|
// Create sample submissions for multiple employees
|
|
const sampleSubmissions = [
|
|
{
|
|
employeeId: 'AG',
|
|
orgId,
|
|
createdAt: Date.now(),
|
|
answers: {
|
|
role_clarity: "I understand my role very clearly as Influencer Coordinator & Business Development Outreach.",
|
|
key_outputs: "Recruited 15 new influencers, managed 8 campaigns, initiated 3 business development partnerships.",
|
|
bottlenecks: "Campaign organization could be better, sometimes unclear on priorities between recruiting and outreach.",
|
|
hidden_talent: "Strong relationship building skills that could be leveraged for client-facing work.",
|
|
retention_risk: "Happy with the company but would like more structure and clearer processes.",
|
|
energy_distribution: "50% influencer recruiting, 30% campaign support, 20% business development outreach.",
|
|
performance_indicators: "Good influencer relationships, but delivery timeline improvements needed.",
|
|
workflow: "Morning outreach, afternoon campaign work, weekly business development calls."
|
|
}
|
|
},
|
|
{
|
|
employeeId: 'MB',
|
|
orgId,
|
|
createdAt: Date.now(),
|
|
answers: {
|
|
role_clarity: "I understand my role as a Senior Developer very clearly. I'm responsible for architecting solutions, code reviews, and mentoring junior developers.",
|
|
key_outputs: "Delivered 3 major features this quarter, reduced technical debt by 20%, and led code review process improvements.",
|
|
bottlenecks: "Sometimes waiting for design specs from the product team, and occasional deployment pipeline issues.",
|
|
hidden_talent: "I have strong business analysis skills and could help bridge the gap between technical and business requirements.",
|
|
retention_risk: "I'm satisfied with my current role and compensation. The only concern would be limited growth opportunities.",
|
|
energy_distribution: "80% development work, 15% mentoring, 5% planning and architecture.",
|
|
performance_indicators: "Code quality metrics improved, zero production bugs in my recent releases, positive peer feedback.",
|
|
workflow: "Morning standup, focused coding blocks, afternoon reviews and collaboration, weekly planning sessions."
|
|
}
|
|
},
|
|
{
|
|
employeeId: 'KT',
|
|
orgId,
|
|
createdAt: Date.now(),
|
|
answers: {
|
|
role_clarity: "My role as Marketing Manager is clear - I oversee campaigns, analyze performance metrics, and coordinate with sales.",
|
|
key_outputs: "Launched 5 successful campaigns this quarter, increased lead quality by 30%, improved attribution tracking.",
|
|
bottlenecks: "Limited budget for premium tools, sometimes slow approval process for creative assets.",
|
|
hidden_talent: "I have experience with data science and could help build predictive models for customer behavior.",
|
|
retention_risk: "Overall happy, but would like more strategic input in product positioning and pricing decisions.",
|
|
energy_distribution: "40% campaign execution, 30% analysis and reporting, 20% strategy, 10% team coordination.",
|
|
performance_indicators: "Campaign ROI improved by 25%, lead conversion rates increased, better cross-team collaboration.",
|
|
workflow: "Weekly campaign planning, daily performance monitoring, bi-weekly strategy reviews, monthly board reporting."
|
|
}
|
|
}
|
|
];
|
|
|
|
// Save all sample submissions
|
|
sampleSubmissions.forEach(submission => {
|
|
demoStorage.saveSubmission(submission);
|
|
});
|
|
|
|
// Save sample employee report (only for AG initially)
|
|
demoStorage.saveEmployeeReport(orgId, REPORT_DATA.employeeId, REPORT_DATA);
|
|
|
|
// Save sample company report
|
|
demoStorage.saveCompanyReport(orgId, SAMPLE_COMPANY_REPORT);
|
|
}
|
|
|
|
// Load persistent demo data
|
|
setOrg({ orgId, name: demoOrg.name, onboardingCompleted: demoOrg.onboardingCompleted });
|
|
|
|
// Convert employees to expected format
|
|
const demoEmployees = demoStorage.getEmployeesByOrg(orgId);
|
|
const convertedEmployees: Employee[] = demoEmployees.map(emp => ({
|
|
id: emp.id,
|
|
name: emp.name,
|
|
email: emp.email,
|
|
initials: emp.name ? emp.name.split(' ').map(n => n[0]).join('').toUpperCase() : emp.email.substring(0, 2).toUpperCase(),
|
|
department: emp.department,
|
|
role: emp.role,
|
|
isOwner: emp.id === user?.uid
|
|
}));
|
|
setEmployees(convertedEmployees);
|
|
|
|
// Convert submissions to expected format
|
|
const orgSubmissions = demoStorage.getSubmissionsByOrg(orgId);
|
|
const convertedSubmissions: Record<string, Submission> = {};
|
|
Object.entries(orgSubmissions).forEach(([employeeId, demoSub]) => {
|
|
convertedSubmissions[employeeId] = {
|
|
employeeId,
|
|
answers: Object.entries(demoSub.answers).map(([question, answer]) => ({
|
|
question,
|
|
answer
|
|
}))
|
|
};
|
|
});
|
|
setSubmissions(convertedSubmissions);
|
|
|
|
// Convert reports to expected format
|
|
const orgReports = demoStorage.getEmployeeReportsByOrg(orgId);
|
|
setReports(orgReports);
|
|
|
|
// Get company reports
|
|
const companyReports = demoStorage.getCompanyReportsByOrg(orgId);
|
|
setFullCompanyReports(companyReports);
|
|
return;
|
|
}
|
|
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>) => {
|
|
if (!isFirebaseConfigured) {
|
|
const updatedOrg = { ...(org || { orgId, name: 'Demo Company' }), ...data } as OrgData;
|
|
setOrg(updatedOrg);
|
|
|
|
// Also sync with server for multi-tenant persistence
|
|
try {
|
|
const response = await fetch(`${API_URL}/api/organizations/${orgId}`, {
|
|
method: 'PUT',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify(data)
|
|
});
|
|
|
|
if (!response.ok) {
|
|
console.warn('Failed to sync organization data with server');
|
|
}
|
|
} catch (error) {
|
|
console.warn('Failed to sync organization data:', error);
|
|
}
|
|
} else {
|
|
// Firebase mode - save to Firestore
|
|
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);
|
|
}
|
|
};
|
|
|
|
const updateOrg = async (data: Partial<OrgData>) => {
|
|
if (!isFirebaseConfigured) {
|
|
const updatedOrg = { ...(org || { orgId, name: 'Demo Company' }), ...data } as OrgData;
|
|
setOrg(updatedOrg);
|
|
|
|
// Also sync with server for multi-tenant persistence
|
|
try {
|
|
const response = await fetch(`${API_URL}/api/organizations/${orgId}`, {
|
|
method: 'PUT',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify(data)
|
|
});
|
|
|
|
if (!response.ok) {
|
|
console.warn('Failed to sync organization data with server');
|
|
}
|
|
} catch (error) {
|
|
console.warn('Failed to sync organization data:', error);
|
|
}
|
|
|
|
return;
|
|
}
|
|
const orgRef = doc(db, 'orgs', orgId);
|
|
await setDoc(orgRef, data, { merge: true });
|
|
};
|
|
|
|
const saveReport = async (employeeId: string, report: Report) => {
|
|
if (!isFirebaseConfigured) {
|
|
setReports(prev => ({ ...prev, [employeeId]: report }));
|
|
// Persist to localStorage
|
|
demoStorage.saveEmployeeReport(orgId, employeeId, report);
|
|
return;
|
|
}
|
|
const ref = doc(db, 'orgs', orgId, 'reports', employeeId);
|
|
await setDoc(ref, report, { merge: true });
|
|
};
|
|
|
|
const inviteEmployee = async ({ name, email }: { name: string; email: string }) => {
|
|
// Always use Cloud Functions for invites to ensure multi-tenant compliance
|
|
const response = await fetch(`${API_URL}/createInvitation`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ name, email, orgId })
|
|
});
|
|
|
|
if (!response.ok) {
|
|
throw new Error(`Failed to create invite: ${response.status}`);
|
|
}
|
|
|
|
const data = await response.json();
|
|
const { code, employee, inviteLink } = data;
|
|
|
|
// Store employee locally for immediate UI update
|
|
if (!isFirebaseConfigured) {
|
|
const newEmployee = { ...employee, orgId };
|
|
setEmployees(prev => {
|
|
if (prev.find(e => e.id === employee.id)) return prev;
|
|
return [...prev, newEmployee];
|
|
});
|
|
demoStorage.saveEmployee(newEmployee);
|
|
} else {
|
|
// For Firebase, the employee will be created when they accept the invite
|
|
// But we can add them to local state for immediate UI update
|
|
const newEmployee = { ...employee, orgId };
|
|
setEmployees(prev => {
|
|
if (prev.find(e => e.id === employee.id)) return prev;
|
|
return [...prev, newEmployee];
|
|
});
|
|
}
|
|
|
|
return { employeeId: employee.id, inviteLink };
|
|
};
|
|
|
|
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 empty employee list for clean demo experience
|
|
setEmployees([]);
|
|
setSubmissions({ [SUBMISSIONS_DATA.employeeId]: SUBMISSIONS_DATA });
|
|
setReports({ [REPORT_DATA.employeeId]: REPORT_DATA });
|
|
setFullCompanyReports([SAMPLE_COMPANY_REPORT]);
|
|
return;
|
|
}
|
|
|
|
// Start with clean slate - let users invite their own employees
|
|
// (Removed automatic seeding per user feedback)
|
|
};
|
|
|
|
const saveFullCompanyReport = async (report: CompanyReport) => {
|
|
if (!isFirebaseConfigured) {
|
|
setFullCompanyReports(prev => [report, ...prev]);
|
|
// Persist to localStorage
|
|
demoStorage.saveCompanyReport(orgId, report);
|
|
return;
|
|
}
|
|
const ref = doc(db, 'orgs', orgId, 'fullCompanyReports', report.id);
|
|
await setDoc(ref, report);
|
|
};
|
|
|
|
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> => {
|
|
// Generate comprehensive company report based on current data
|
|
const totalEmployees = employees.length;
|
|
const submittedEmployees = Object.keys(submissions).length;
|
|
const submissionRate = totalEmployees > 0 ? (submittedEmployees / totalEmployees) * 100 : 0;
|
|
|
|
// Department breakdown
|
|
const deptMap = new Map<string, number>();
|
|
employees.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 }));
|
|
|
|
// Analyze employee reports for insights
|
|
const reportValues = Object.values(reports) as Report[];
|
|
const organizationalStrengths: string[] = [];
|
|
const organizationalRisks: string[] = [];
|
|
|
|
reportValues.forEach(report => {
|
|
if (report.strengths) {
|
|
organizationalStrengths.push(...report.strengths);
|
|
}
|
|
if (report.risks) {
|
|
organizationalRisks.push(...report.risks);
|
|
}
|
|
});
|
|
|
|
// Remove duplicates and take top items
|
|
const uniqueStrengths = [...new Set(organizationalStrengths)].slice(0, 5);
|
|
const uniqueRisks = [...new Set(organizationalRisks)].slice(0, 5);
|
|
|
|
const gradingBreakdown = [
|
|
{ category: 'Execution', value: 70 + Math.random() * 15 },
|
|
{ category: 'People', value: 70 + Math.random() * 15 },
|
|
{ category: 'Strategy', value: 65 + Math.random() * 15 },
|
|
{ category: 'Risk', value: 60 + Math.random() * 15 }
|
|
];
|
|
const legacy = gradingBreakdown.reduce<Record<string, number>>((acc, g) => { acc[g.category.toLowerCase()] = Math.round((g.value / 100) * 5 * 10) / 10; return acc; }, {});
|
|
const report: CompanyReport = {
|
|
id: Date.now().toString(),
|
|
createdAt: Date.now(),
|
|
overview: {
|
|
totalEmployees,
|
|
departmentBreakdown,
|
|
submissionRate,
|
|
lastUpdated: Date.now(),
|
|
averagePerformanceScore: gradingBreakdown.reduce((a, g) => a + g.value, 0) / gradingBreakdown.length / 20,
|
|
riskLevel: uniqueRisks.length > 4 ? 'High' : uniqueRisks.length > 2 ? 'Medium' : 'Low'
|
|
},
|
|
personnelChanges: { newHires: [], promotions: [], departures: [] },
|
|
immediateHiringNeeds: [],
|
|
operatingPlan: {
|
|
nextQuarterGoals: ['Increase productivity', 'Implement review system'],
|
|
keyInitiatives: ['Mentorship program'],
|
|
resourceNeeds: ['Senior engineer'],
|
|
riskMitigation: ['Cross-training']
|
|
},
|
|
forwardOperatingPlan: { // legacy fields
|
|
quarterlyGoals: ['Increase productivity'],
|
|
resourceNeeds: ['Senior engineer'],
|
|
riskMitigation: ['Cross-training']
|
|
},
|
|
organizationalStrengths: uniqueStrengths.map(s => ({ area: s, description: s })),
|
|
organizationalRisks: uniqueRisks,
|
|
organizationalImpactSummary: 'Impact summary placeholder',
|
|
gradingBreakdown,
|
|
gradingOverview: legacy,
|
|
executiveSummary: `Company overview for ${org?.name || 'Organization'} as of ${new Date().toLocaleDateString()}. Total workforce: ${totalEmployees}. Submission rate: ${submissionRate.toFixed(1)}%. Key strengths: ${uniqueStrengths.slice(0, 2).join(', ')}. Risks: ${uniqueRisks.slice(0, 2).join(', ')}.`
|
|
};
|
|
|
|
await saveFullCompanyReport(report);
|
|
return report;
|
|
};
|
|
|
|
const generateCompanyWiki = async (orgOverride?: OrgData): Promise<CompanyReport> => {
|
|
const orgData = orgOverride || org;
|
|
try {
|
|
const res = await fetch(`${API_URL}/generateCompanyWiki`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ org: orgData, submissions })
|
|
});
|
|
if (!res.ok) throw new Error('Failed to generate company wiki');
|
|
const payload = await res.json();
|
|
const data: CompanyReport = payload.report || payload; // backward compatibility
|
|
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 fetch(`${API_URL}/createInvitation`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ name, email, role, department, orgId })
|
|
});
|
|
if (!res.ok) throw new 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 orgId
|
|
const employee = employees.find(e => e.id === employeeId);
|
|
const res = await fetch(`${API_URL}/submitEmployeeAnswers`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({
|
|
employeeId,
|
|
answers,
|
|
orgId,
|
|
employee
|
|
})
|
|
});
|
|
if (!res.ok) throw new 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 {
|
|
const submission = submissions[employee.id]?.answers || submissions[employee.id] || {};
|
|
const res = await fetch(`${API_URL}/generateEmployeeReport`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ employee, submission })
|
|
});
|
|
if (!res.ok) throw new Error('failed to generate');
|
|
const json = await res.json();
|
|
if (json.report) {
|
|
setReports(prev => ({ ...prev, [employee.id]: json.report }));
|
|
return json.report as Report;
|
|
}
|
|
} catch (e) {
|
|
console.error('generateEmployeeReport error', e);
|
|
}
|
|
return null;
|
|
},
|
|
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;
|
|
};
|