ra/auditly
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: complete employee invite flow implementation

Browse Source 
- Fix submitEmployeeAnswers to use pending invites and consume during submission
- Add automatic employee report generation with company context
- Include company onboarding data in LLM prompts for alignment analysis
- Store reports in correct Firestore collection with submission linking
- Simplify frontend invite submission to single API call
- Add comprehensive error handling and employee creation
This commit is contained in:
Ra
2025-08-25 14:48:52 -07:00
parent 0d7b8d104b
commit cf670c84b3
2 changed files with 222 additions and 25 deletions
Download Patch File Download Diff File Expand all files Collapse all files

222
functions/index.js
View File

@@ -591,21 +591,56 @@ exports.submitEmployeeAnswers = onRequest({ cors: true }, async (req, res) => {
return res.status(400).json({ error: "Invite code and answers are required for invite submissions" });
}
// Look up the invite to get employee and org data
// Look up the invite to get employee and org data (should be pending, not consumed yet)
const inviteSnapshot = await db
.collectionGroup("invites")
.where("code", "==", inviteCode)
.where("status", "==", "consumed")
.where("status", "==", "pending")
.limit(1)
.get();
if (inviteSnapshot.empty) {
return res.status(404).json({ error: "Invitation not found or not consumed yet" });
return res.status(404).json({ error: "Invitation not found or already used" });
}
const inviteDoc = inviteSnapshot.docs[0];
const invite = inviteDoc.data();
// Check if expired
if (Date.now() > invite.expiresAt) {
return res.status(400).json({ error: "Invitation has expired" });
}
const invite = inviteSnapshot.docs[0].data();
finalOrgId = invite.orgId;
finalEmployeeId = invite.employee.id;
// Consume the invitation now
await inviteDoc.ref.update({
status: "consumed",
consumedBy: finalEmployeeId,
consumedAt: Date.now(),
});
// Add employee to organization if not already added
const employeeRef = db
.collection("orgs")
.doc(finalOrgId)
.collection("employees")
.doc(finalEmployeeId);
const employeeDoc = await employeeRef.get();
if (!employeeDoc.exists) {
await employeeRef.set({
id: invite.employee.id,
name: invite.employee.name || invite.employee.email.split("@")[0],
email: invite.employee.email,
role: invite.employee.role || "employee",
department: invite.employee.department || "General",
joinedAt: Date.now(),
status: "active",
inviteCode: inviteCode,
});
}
} else {
// Authenticated submission
const authContext = await validateAuthAndGetContext(req);
@@ -638,6 +673,185 @@ exports.submitEmployeeAnswers = onRequest({ cors: true }, async (req, res) => {
...(inviteCode && { inviteCode })
});
// Generate employee report automatically with company context
try {
// Get employee data
const employeeDoc = await db
.collection("orgs")
.doc(finalOrgId)
.collection("employees")
.doc(finalEmployeeId)
.get();
const employeeData = employeeDoc.exists ? employeeDoc.data() : null;
// Get company onboarding data for LLM context
const orgDoc = await db.collection("orgs").doc(finalOrgId).get();
const orgData = orgDoc.exists ? orgDoc.data() : {};
// Prepare company context (onboarding data)
const companyContext = {
name: orgData.name,
industry: orgData.industry,
mission: orgData.mission,
values: orgData.values,
culture: orgData.cultureDescription,
size: orgData.size,
onboardingData: orgData // Include all org data for comprehensive context
};
// Prepare submission data
const submissionData = {
employeeId: finalEmployeeId,
answers,
submittedAt: Date.now(),
status: "completed"
};
// Generate the report using the existing function logic
let report;
if (openai) {
// Use OpenAI to generate the report with company context
const prompt = `
You are an expert HR analyst. Generate a comprehensive employee performance report based on the following data:
Employee Information:
- Name: ${employeeData?.name || employeeData?.email || 'Unknown'}
- Role: ${employeeData?.role || "Team Member"}
- Department: ${employeeData?.department || "General"}
- Email: ${employeeData?.email || 'Unknown'}
Employee Questionnaire Responses:
${JSON.stringify(answers, null, 2)}
Company Context & Alignment Criteria:
${JSON.stringify(companyContext, null, 2)}
Generate a detailed report that:
1. Evaluates how well the employee aligns with company values and culture
2. Assesses their role performance and output
3. Identifies behavioral insights and work patterns
4. Highlights strengths and areas for improvement
5. Provides specific recommendations for growth
6. Suggests opportunities that align with company goals
7. Identifies any risks or concerns
8. Provides numerical grading across key performance areas
Return ONLY valid JSON that matches this structure:
{
"roleAndOutput": { "currentRole": string, "keyResponsibilities": string[], "performanceRating": number },
"behavioralInsights": { "workStyle": string, "communicationSkills": string, "teamDynamics": string },
"strengths": string[],
"weaknesses": string[],
"opportunities": string[],
"risks": string[],
"recommendations": string[],
"companyAlignment": { "valuesAlignment": number, "cultureAlignment": number, "missionAlignment": number },
"grading": { "overall": number, "technical": number, "communication": number, "teamwork": number, "leadership": number }
}
Be thorough, professional, and focus on actionable insights.
`.trim();
const completion = await openai.chat.completions.create({
model: "gpt-4o",
messages: [
{
role: "system",
content: "You are an expert HR analyst. Generate comprehensive employee performance reports in JSON format that evaluate company alignment and performance."
},
{
role: "user",
content: prompt
}
],
response_format: { type: "json_object" },
temperature: 0.7,
});
const aiResponse = completion.choices[0].message.content;
const parsedReport = JSON.parse(aiResponse);
report = {
employeeId: finalEmployeeId,
generatedAt: Date.now(),
summary: `AI-generated performance analysis for ${employeeData?.name || employeeData?.email || 'Employee'}`,
submissionId: finalEmployeeId,
companyContext: companyContext,
...parsedReport
};
} else {
// Fallback to mock report when OpenAI is not available
report = {
employeeId: finalEmployeeId,
generatedAt: Date.now(),
summary: `Performance analysis for ${employeeData?.name || employeeData?.email || 'Employee'}`,
submissionId: finalEmployeeId,
companyContext: companyContext,
roleAndOutput: {
currentRole: employeeData?.role || "Team Member",
keyResponsibilities: ["Task completion", "Team collaboration", "Quality delivery"],
performanceRating: 85,
},
behavioralInsights: {
workStyle: "Collaborative and detail-oriented",
communicationSkills: "Strong verbal and written communication",
teamDynamics: "Positive team player",
},
strengths: [
"Excellent problem-solving abilities",
"Strong attention to detail",
"Reliable and consistent performance",
],
weaknesses: [
"Could improve time management",
"Needs to be more proactive in meetings",
],
opportunities: [
"Leadership development opportunities",
"Cross-functional project involvement",
"Skill enhancement in emerging technologies",
],
risks: [
"Potential burnout from heavy workload",
"Limited growth opportunities in current role",
],
recommendations: [
"Provide leadership training",
"Assign mentorship role",
"Consider promotion to senior position",
],
companyAlignment: {
valuesAlignment: 88,
cultureAlignment: 82,
missionAlignment: 85
},
grading: {
overall: 85,
technical: 88,
communication: 82,
teamwork: 90,
leadership: 75,
},
};
}
// Store the report in Firestore
const reportRef = db
.collection("orgs")
.doc(finalOrgId)
.collection("reports")
.doc(finalEmployeeId);
await reportRef.set(report);
console.log(`Employee report generated and stored for ${finalEmployeeId} in org ${finalOrgId}`);
} catch (reportError) {
console.error("Failed to generate employee report:", reportError);
// Don't fail the submission if report generation fails
}
res.json({
success: true,
message: "Employee answers submitted successfully",

25
src/pages/EmployeeQuestionnaireNew.tsx
View File

@@ -81,31 +81,14 @@ const EmployeeQuestionnaire: React.FC = () => {
const submitViaInvite = async (answers: EmployeeSubmissionAnswers, inviteCode: string) => {
try {
// First, consume the invite to mark it as used
const consumeResponse = await fetch(`${API_URL}/consumeInvitation`, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ code: inviteCode })
});
if (!consumeResponse.ok) {
throw new Error('Failed to process invitation');
}
// Get orgId from the consume response
const consumeData = await consumeResponse.json();
const orgId = consumeData.orgId;
// Submit the questionnaire answers using Cloud Function
// This will include company onboarding questions and answers for LLM context
// Submit the questionnaire answers directly using Cloud Function
// The cloud function will handle invite consumption and report generation
const submitResponse = await fetch(`${API_URL}/submitEmployeeAnswers`, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
inviteCode: inviteCode,
answers: answers,
orgId: orgId,
includeCompanyContext: true // Flag to include company Q&A in LLM processing
answers: answers
})
});
@@ -115,7 +98,7 @@ const EmployeeQuestionnaire: React.FC = () => {
}
const result = await submitResponse.json();
return { success: true, reportGenerated: !!result.report };
return { success: true, reportGenerated: true };
} catch (error) {
console.error('Invite submission error:', error);
return { success: false, error: error.message };