feat: implement training video backfill functionality

- Added scripts and server actions to trigger training video completion backfill for all organizations or specific organizations.
- Created jobs to handle backfilling of training video records for existing members in organizations.
- Enhanced employee onboarding processes by ensuring new members have training video completion entries created upon invitation or organization creation.
- Updated README with usage instructions and details on the backfill jobs.

This implementation improves the tracking of training video completions for all members, ensuring accurate data representation in the system.

Author: Marfuen

apps/app/scripts/backfill-training-videos.ts

@@ -0,0 +1,58 @@
+#!/usr/bin/env tsx
+
+/**
+ * Script to trigger the training video completion backfill job.
+ *
+ * Usage:
+ *   # Backfill all organizations
+ *   bun run scripts/backfill-training-videos.ts
+ *
+ *   # Backfill specific organization
+ *   bun run scripts/backfill-training-videos.ts --org <organizationId>
+ *
+ * This script is useful for:
+ * - Running the backfill manually
+ * - Testing the backfill process
+ * - Running on-demand backfills for specific organizations
+ */
+
+import { backfillTrainingVideosForAllOrgs } from '@/jobs/tasks/onboarding/backfill-training-videos-for-all-orgs';
+import { backfillTrainingVideosForOrg } from '@/jobs/tasks/onboarding/backfill-training-videos-for-org';
+
+async function main() {
+  const args = process.argv.slice(2);
+  const orgIndex = args.indexOf('--org');
+  const organizationId = orgIndex !== -1 ? args[orgIndex + 1] : null;
+
+  try {
+    if (organizationId) {
+      console.log(`🚀 Triggering training video backfill for organization: ${organizationId}`);
+
+      const handle = await backfillTrainingVideosForOrg.trigger({
+        organizationId: organizationId,
+      });
+
+      console.log(`✅ Successfully triggered job with ID: ${handle.id}`);
+      console.log(`📊 You can monitor the progress in the Trigger.dev dashboard`);
+    } else {
+      console.log('🚀 Triggering training video backfill for ALL organizations');
+
+      const handle = await backfillTrainingVideosForAllOrgs.trigger();
+
+      console.log(`✅ Successfully triggered batch job with ID: ${handle.id}`);
+      console.log(`📊 You can monitor the progress in the Trigger.dev dashboard`);
+      console.log(`⚠️  This will process ALL organizations and their members`);
+    }
+  } catch (error) {
+    console.error('❌ Error triggering backfill job:', error);
+    process.exit(1);
+  }
+}
+
+// Only run if this script is executed directly
+if (require.main === module) {
+  main().catch((error) => {
+    console.error('❌ Script failed:', error);
+    process.exit(1);
+  });
+}

apps/app/src/actions/admin/trigger-training-video-backfill.ts

@@ -0,0 +1,85 @@
+'use server';
+
+import { authActionClient } from '@/actions/safe-action';
+import { backfillTrainingVideosForAllOrgs } from '@/jobs/tasks/onboarding/backfill-training-videos-for-all-orgs';
+import { backfillTrainingVideosForOrg } from '@/jobs/tasks/onboarding/backfill-training-videos-for-org';
+import { z } from 'zod';
+import type { ActionResponse } from '../types';
+
+const triggerBackfillSchema = z.object({
+  organizationId: z.string().optional(),
+});
+
+export const triggerTrainingVideoBackfill = authActionClient
+  .metadata({
+    name: 'trigger-training-video-backfill',
+    track: {
+      event: 'trigger_training_video_backfill',
+      channel: 'admin',
+    },
+  })
+  .inputSchema(triggerBackfillSchema)
+  .action(
+    async ({
+      parsedInput,
+      ctx,
+    }): Promise<
+      ActionResponse<{
+        triggered: boolean;
+        jobType: 'single-org' | 'all-orgs';
+        organizationId?: string;
+      }>
+    > => {
+      try {
+        // Check if user has admin permissions (you may want to add additional checks)
+        const member = await ctx.db.member.findFirst({
+          where: {
+            userId: ctx.user.id,
+            organizationId: ctx.session.activeOrganizationId,
+          },
+        });
+
+        if (!member || (!member.role.includes('admin') && !member.role.includes('owner'))) {
+          return {
+            success: false,
+            error: 'Insufficient permissions. Admin or owner role required.',
+          };
+        }
+
+        if (parsedInput.organizationId) {
+          // Trigger backfill for a specific organization
+          await backfillTrainingVideosForOrg.trigger({
+            organizationId: parsedInput.organizationId,
+          });
+
+          return {
+            success: true,
+            data: {
+              triggered: true,
+              jobType: 'single-org',
+              organizationId: parsedInput.organizationId,
+            },
+          };
+        } else {
+          // Trigger backfill for all organizations
+          await backfillTrainingVideosForAllOrgs.trigger();
+
+          return {
+            success: true,
+            data: {
+              triggered: true,
+              jobType: 'all-orgs',
+            },
+          };
+        }
+      } catch (error) {
+        console.error('Error triggering training video backfill:', error);
+        const errorMessage =
+          error instanceof Error ? error.message : 'Failed to trigger backfill job';
+        return {
+          success: false,
+          error: errorMessage,
+        };
+      }
+    },
+  );

apps/app/src/actions/organization/accept-invitation.ts

@@ -1,5 +1,6 @@
 'use server';
 
+import { createTrainingVideoEntries } from '@/lib/db/employee';
 import { db } from '@db';
 import { revalidatePath, revalidateTag } from 'next/cache';
 import { redirect } from 'next/navigation';
@@ -96,7 +97,7 @@ export const completeInvitation = authActionClientWithoutOrg
           throw new Error('Invitation role is required');
         }
 
-        await db.member.create({
+        const newMember = await db.member.create({
           data: {
             userId: user.id,
             organizationId: invitation.organizationId,
@@ -105,6 +106,9 @@ export const completeInvitation = authActionClientWithoutOrg
           },
         });
 
+        // Create training video completion entries for the new member
+        await createTrainingVideoEntries(newMember.id);
+
         await db.invitation.update({
           where: {
             id: invitation.id,

apps/app/src/app/(app)/[orgId]/people/all/actions/addEmployeeWithoutInvite.ts

@@ -1,5 +1,6 @@
 'use server';
 
+import { createTrainingVideoEntries } from '@/lib/db/employee';
 import { auth } from '@/utils/auth';
 import type { Role } from '@db';
 import { db } from '@db';
@@ -61,6 +62,11 @@ export const addEmployeeWithoutInvite = async ({
       },
     });
 
+    // Create training video completion entries for the new member
+    if (member?.id) {
+      await createTrainingVideoEntries(member.id);
+    }
+
     return { success: true, data: member };
   } catch (error) {
     console.error('Error adding employee:', error);

apps/app/src/app/(app)/[orgId]/people/dashboard/components/EmployeeCompletionChart.tsx

@@ -228,10 +228,15 @@ export function EmployeeCompletionChart({
                       </div>
                       <p className="text-muted-foreground text-xs">{stat.email}</p>
                     </div>
-                    <span className="text-muted-foreground">
-                      {stat.policiesCompleted + stat.trainingsCompleted} / {stat.totalTasks}{' '}
-                      {'tasks'}
-                    </span>
+                    <div className="text-muted-foreground text-right text-xs">
+                      <div>
+                        {stat.policiesCompleted + stat.trainingsCompleted} / {stat.totalTasks} tasks
+                      </div>
+                      <div className="text-xs">
+                        {stat.policiesCompleted}/{stat.policiesTotal} policies •{' '}
+                        {stat.trainingsCompleted}/{stat.trainingsTotal} training
+                      </div>
+                    </div>
                   </div>
 
                   <TaskBarChart stat={stat} />

apps/app/src/app/(app)/setup/actions/create-organization-minimal.ts

@@ -2,6 +2,7 @@
 
 import { initializeOrganization } from '@/actions/organization/lib/initialize-organization';
 import { authActionClientWithoutOrg } from '@/actions/safe-action';
+import { createTrainingVideoEntries } from '@/lib/db/employee';
 import { auth } from '@/utils/auth';
 import { db } from '@db';
 import { revalidatePath } from 'next/cache';
@@ -64,6 +65,19 @@ export const createOrganizationMinimal = authActionClientWithoutOrg
 
       const orgId = newOrg.id;
 
+      // Get the member that was created with the organization (the owner)
+      const ownerMember = await db.member.findFirst({
+        where: {
+          userId: session.user.id,
+          organizationId: orgId,
+        },
+      });
+
+      // Create training video completion entries for the owner
+      if (ownerMember) {
+        await createTrainingVideoEntries(ownerMember.id);
+      }
+
       // Create onboarding record for new org
       await db.onboarding.create({
         data: {

apps/app/src/app/(app)/setup/actions/create-organization.ts

@@ -4,6 +4,7 @@ import { initializeOrganization } from '@/actions/organization/lib/initialize-or
 import { authActionClientWithoutOrg } from '@/actions/safe-action';
 import { createFleetLabelForOrg } from '@/jobs/tasks/device/create-fleet-label-for-org';
 import { onboardOrganization as onboardOrganizationTask } from '@/jobs/tasks/onboarding/onboard-organization';
+import { createTrainingVideoEntries } from '@/lib/db/employee';
 import { auth } from '@/utils/auth';
 import { db } from '@db';
 import { tasks } from '@trigger.dev/sdk';
@@ -63,6 +64,19 @@ export const createOrganization = authActionClientWithoutOrg
 
       const orgId = newOrg.id;
 
+      // Get the member that was created with the organization (the owner)
+      const ownerMember = await db.member.findFirst({
+        where: {
+          userId: session.user.id,
+          organizationId: orgId,
+        },
+      });
+
+      // Create training video completion entries for the owner
+      if (ownerMember) {
+        await createTrainingVideoEntries(ownerMember.id);
+      }
+
       // Create onboarding record for new org
       await db.onboarding.create({
         data: {

apps/app/src/jobs/tasks/onboarding/README-training-video-backfill.md

@@ -0,0 +1,114 @@
+# Training Video Completion Backfill Jobs
+
+This directory contains Trigger.dev jobs to backfill training video completion records for existing organizations and members.
+
+## Overview
+
+When the training video completion tracking feature was implemented, existing members in organizations did not have the required `EmployeeTrainingVideoCompletion` records. These jobs ensure all existing members have proper training video completion tracking.
+
+## Jobs
+
+### 1. `backfill-training-videos-for-all-orgs`
+
+- **Purpose**: Processes all organizations in the system
+- **Trigger ID**: `backfill-training-videos-for-all-orgs`
+- **Behavior**:
+  - Finds all organizations
+  - Creates batch jobs for each organization
+  - Uses `batchTrigger` to process organizations in parallel
+
+### 2. `backfill-training-videos-for-org`
+
+- **Purpose**: Processes a single organization
+- **Trigger ID**: `backfill-training-videos-for-org`
+- **Payload**: `{ organizationId: string }`
+- **Behavior**:
+  - Finds all members in the organization
+  - Creates `EmployeeTrainingVideoCompletion` records for each member
+  - Uses `skipDuplicates: true` to prevent duplicate records
+  - Processes each member individually with error handling
+
+## Duplicate Prevention
+
+Both jobs use `skipDuplicates: true` when creating records, which means:
+
+- ✅ Safe to run multiple times
+- ✅ Won't create duplicate records
+- ✅ Only creates missing records
+
+## Usage
+
+### Option 1: Via Script (Recommended for testing)
+
+```bash
+# Backfill all organizations
+bun run scripts/backfill-training-videos.ts
+
+# Backfill specific organization
+bun run scripts/backfill-training-videos.ts --org org_123456789
+```
+
+### Option 2: Via Server Action (For admin UI)
+
+```typescript
+import { triggerTrainingVideoBackfill } from '@/actions/admin/trigger-training-video-backfill';
+
+// Backfill all organizations
+await triggerTrainingVideoBackfill({ organizationId: undefined });
+
+// Backfill specific organization
+await triggerTrainingVideoBackfill({ organizationId: 'org_123456789' });
+```
+
+### Option 3: Direct Trigger.dev API
+
+```typescript
+import { backfillTrainingVideosForAllOrgs } from '@/jobs/tasks/onboarding/backfill-training-videos-for-all-orgs';
+
+await backfillTrainingVideosForAllOrgs.trigger();
+```
+
+## Monitoring
+
+- Monitor job progress in the Trigger.dev dashboard
+- Each job provides detailed logging including:
+  - Number of organizations processed
+  - Number of members processed per organization
+  - Number of records created
+  - Error details for any failures
+
+## Expected Results
+
+After running the backfill:
+
+- All existing members will have `EmployeeTrainingVideoCompletion` records
+- Records will have `completedAt: null` (indicating not yet completed)
+- Employee progress charts will show accurate data
+- Training video tracking will work correctly for all members
+
+## Safety Features
+
+- **Idempotent**: Safe to run multiple times
+- **Error Isolation**: Failure processing one member doesn't stop others
+- **Comprehensive Logging**: Full audit trail of what was processed
+- **Permission Checks**: Admin/owner permissions required for triggers
+- **Batch Processing**: Efficient processing of large datasets
+
+## Database Impact
+
+- Creates records in `EmployeeTrainingVideoCompletion` table
+- Number of records = (Number of members) × (Number of training videos)
+- Current training videos: 5 (sat-1 through sat-5)
+- Uses database transactions for consistency
+
+## Rollback
+
+If you need to remove the backfilled records:
+
+```sql
+-- Remove all training video completion records with null completedAt
+DELETE FROM "EmployeeTrainingVideoCompletion"
+WHERE "completedAt" IS NULL;
+```
+
+⚠️ **Warning**: Only run this if you're sure you want to remove ALL incomplete training records.