feat: Implement system activity log (Phases 1-3)

src/lib/systemActivityService.ts

@@ -0,0 +1,333 @@
+import { supabase } from '@/integrations/supabase/client';
+
+export type ActivityType = 
+  | 'entity_change' 
+  | 'admin_action' 
+  | 'submission_review' 
+  | 'report_resolution' 
+  | 'review_moderation' 
+  | 'photo_approval';
+
+export interface ActivityActor {
+  id: string;
+  username: string;
+  display_name?: string;
+  avatar_url?: string;
+}
+
+export interface EntityChangeDetails {
+  entity_type: string;
+  entity_id: string;
+  entity_name?: string;
+  change_type: string;
+  change_reason?: string;
+  version_number?: number;
+}
+
+export interface AdminActionDetails {
+  action: string;
+  target_user_id?: string;
+  target_username?: string;
+  details?: Record<string, any>;
+}
+
+export interface SubmissionReviewDetails {
+  submission_id: string;
+  submission_type: string;
+  status: string;
+  entity_name?: string;
+}
+
+export interface ReportResolutionDetails {
+  report_id: string;
+  reported_entity_type: string;
+  reported_entity_id: string;
+  status: string;
+  resolution_notes?: string;
+}
+
+export interface ReviewModerationDetails {
+  review_id: string;
+  entity_type: string;
+  entity_id: string;
+  moderation_status: string;
+  entity_name?: string;
+}
+
+export interface PhotoApprovalDetails {
+  photo_id: string;
+  entity_type: string;
+  entity_id: string;
+  entity_name?: string;
+}
+
+export type ActivityDetails = 
+  | EntityChangeDetails 
+  | AdminActionDetails 
+  | SubmissionReviewDetails 
+  | ReportResolutionDetails 
+  | ReviewModerationDetails 
+  | PhotoApprovalDetails;
+
+export interface SystemActivity {
+  id: string;
+  type: ActivityType;
+  timestamp: string;
+  actor_id: string | null;
+  actor?: ActivityActor;
+  action: string;
+  details: ActivityDetails;
+}
+
+export interface ActivityFilters {
+  type?: ActivityType;
+  userId?: string;
+  entityType?: string;
+  dateFrom?: string;
+  dateTo?: string;
+}
+
+/**
+ * Fetch unified system activity log from multiple sources
+ */
+export async function fetchSystemActivities(
+  limit: number = 50,
+  filters?: ActivityFilters
+): Promise<SystemActivity[]> {
+  const activities: SystemActivity[] = [];
+
+  // Fetch entity versions (entity changes)
+  const { data: versions, error: versionsError } = await supabase
+    .from('entity_versions')
+    .select('id, entity_type, entity_id, version_number, version_data, changed_by, changed_at, change_type, change_reason')
+    .order('changed_at', { ascending: false })
+    .limit(limit * 2); // Fetch more to account for filtering
+
+  if (!versionsError && versions) {
+    for (const version of versions) {
+      const versionData = version.version_data as any;
+      activities.push({
+        id: version.id,
+        type: 'entity_change',
+        timestamp: version.changed_at,
+        actor_id: version.changed_by,
+        action: `${version.change_type} ${version.entity_type}`,
+        details: {
+          entity_type: version.entity_type,
+          entity_id: version.entity_id,
+          entity_name: versionData?.name || versionData?.title,
+          change_type: version.change_type,
+          change_reason: version.change_reason,
+          version_number: version.version_number,
+        } as EntityChangeDetails,
+      });
+    }
+  }
+
+  // Fetch admin audit log (admin actions)
+  const { data: auditLogs, error: auditError } = await supabase
+    .from('admin_audit_log')
+    .select('id, admin_user_id, target_user_id, action, details, created_at')
+    .order('created_at', { ascending: false })
+    .limit(limit);
+
+  if (!auditError && auditLogs) {
+    for (const log of auditLogs) {
+      activities.push({
+        id: log.id,
+        type: 'admin_action',
+        timestamp: log.created_at,
+        actor_id: log.admin_user_id,
+        action: log.action,
+        details: {
+          action: log.action,
+          target_user_id: log.target_user_id,
+          details: log.details,
+        } as AdminActionDetails,
+      });
+    }
+  }
+
+  // Fetch submission reviews (approved/rejected submissions)
+  const { data: submissions, error: submissionsError } = await supabase
+    .from('content_submissions')
+    .select('id, submission_type, status, reviewer_id, reviewed_at, content')
+    .not('reviewed_at', 'is', null)
+    .in('status', ['approved', 'rejected', 'partially_approved'])
+    .order('reviewed_at', { ascending: false })
+    .limit(limit);
+
+  if (!submissionsError && submissions) {
+    for (const submission of submissions) {
+      const contentData = submission.content as any;
+      activities.push({
+        id: submission.id,
+        type: 'submission_review',
+        timestamp: submission.reviewed_at!,
+        actor_id: submission.reviewer_id,
+        action: `${submission.status} ${submission.submission_type} submission`,
+        details: {
+          submission_id: submission.id,
+          submission_type: submission.submission_type,
+          status: submission.status,
+          entity_name: contentData?.name,
+        } as SubmissionReviewDetails,
+      });
+    }
+  }
+
+  // Fetch report resolutions
+  const { data: reports, error: reportsError } = await supabase
+    .from('reports')
+    .select('id, reported_entity_type, reported_entity_id, status, reviewed_by, reviewed_at')
+    .not('reviewed_at', 'is', null)
+    .order('reviewed_at', { ascending: false })
+    .limit(limit);
+
+  if (!reportsError && reports) {
+    for (const report of reports) {
+      activities.push({
+        id: report.id,
+        type: 'report_resolution',
+        timestamp: report.reviewed_at!,
+        actor_id: report.reviewed_by,
+        action: `${report.status} report`,
+        details: {
+          report_id: report.id,
+          reported_entity_type: report.reported_entity_type,
+          reported_entity_id: report.reported_entity_id,
+          status: report.status,
+        } as ReportResolutionDetails,
+      });
+    }
+  }
+
+  // Fetch review moderation
+  const { data: reviews, error: reviewsError } = await supabase
+    .from('reviews')
+    .select('id, park_id, ride_id, moderation_status, moderated_by, moderated_at')
+    .not('moderated_at', 'is', null)
+    .neq('moderation_status', 'pending')
+    .order('moderated_at', { ascending: false })
+    .limit(limit);
+
+  if (!reviewsError && reviews) {
+    for (const review of reviews) {
+      const entityType = review.park_id ? 'park' : 'ride';
+      const entityId = review.park_id || review.ride_id;
+      
+      activities.push({
+        id: review.id,
+        type: 'review_moderation',
+        timestamp: review.moderated_at!,
+        actor_id: review.moderated_by,
+        action: `${review.moderation_status} review`,
+        details: {
+          review_id: review.id,
+          entity_type: entityType,
+          entity_id: entityId!,
+          moderation_status: review.moderation_status,
+        } as ReviewModerationDetails,
+      });
+    }
+  }
+
+  // Fetch photo approvals
+  const { data: photos, error: photosError } = await supabase
+    .from('photos')
+    .select('id, entity_type, entity_id, approved_by, approved_at')
+    .not('approved_at', 'is', null)
+    .order('approved_at', { ascending: false })
+    .limit(limit);
+
+  if (!photosError && photos) {
+    for (const photo of photos) {
+      activities.push({
+        id: photo.id,
+        type: 'photo_approval',
+        timestamp: photo.approved_at!,
+        actor_id: photo.approved_by,
+        action: `approved ${photo.entity_type} photo`,
+        details: {
+          photo_id: photo.id,
+          entity_type: photo.entity_type,
+          entity_id: photo.entity_id,
+        } as PhotoApprovalDetails,
+      });
+    }
+  }
+
+  // Sort all activities by timestamp (newest first)
+  activities.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+
+  // Apply filters
+  let filteredActivities = activities;
+  if (filters?.type) {
+    filteredActivities = filteredActivities.filter(a => a.type === filters.type);
+  }
+  if (filters?.userId) {
+    filteredActivities = filteredActivities.filter(a => a.actor_id === filters.userId);
+  }
+
+  // Limit to requested amount
+  filteredActivities = filteredActivities.slice(0, limit);
+
+  // Enrich with user profile data
+  const uniqueUserIds = [...new Set(filteredActivities.map(a => a.actor_id).filter(Boolean))] as string[];
+  
+  if (uniqueUserIds.length > 0) {
+    const { data: profiles } = await supabase
+      .from('profiles')
+      .select('user_id, username, display_name, avatar_url')
+      .in('user_id', uniqueUserIds);
+
+    if (profiles) {
+      const profileMap = new Map(profiles.map(p => [p.user_id, p]));
+      
+      for (const activity of filteredActivities) {
+        if (activity.actor_id) {
+          const profile = profileMap.get(activity.actor_id);
+          if (profile) {
+            activity.actor = {
+              id: profile.user_id,
+              username: profile.username,
+              display_name: profile.display_name || undefined,
+              avatar_url: profile.avatar_url || undefined,
+            };
+          }
+        }
+      }
+
+      // Also enrich admin action target users
+      const targetUserIds = filteredActivities
+        .filter(a => a.type === 'admin_action')
+        .map(a => (a.details as AdminActionDetails).target_user_id)
+        .filter(Boolean) as string[];
+
+      if (targetUserIds.length > 0) {
+        const { data: targetProfiles } = await supabase
+          .from('profiles')
+          .select('user_id, username')
+          .in('user_id', targetUserIds);
+
+        if (targetProfiles) {
+          const targetProfileMap = new Map(targetProfiles.map(p => [p.user_id, p]));
+          
+          for (const activity of filteredActivities) {
+            if (activity.type === 'admin_action') {
+              const details = activity.details as AdminActionDetails;
+              if (details.target_user_id) {
+                const targetProfile = targetProfileMap.get(details.target_user_id);
+                if (targetProfile) {
+                  details.target_username = targetProfile.username;
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  return filteredActivities;
+}