@tuturuuu/utils 0.0.2 → 0.6.0

package/src/nova/scores/calculate.ts

@@ -0,0 +1,132 @@
+/**
+ * Score calculation utility functions for Nova
+ *
+ * This module provides standardized functions for calculating scores
+ * across the Nova platform to ensure consistency.
+ */
+
+export interface ScoreInput {
+  total_tests?: number | null;
+  passed_tests?: number | null;
+  total_criteria?: number | null;
+  sum_criterion_score?: number | null;
+}
+
+/**
+ * Calculates a standardized score based on test cases and criteria evaluation
+ *
+ * The score is calculated as follows:
+ * 1. If both tests and criteria exist:
+ *    - Test Score = (passed_tests/total_tests) * 10 * 0.5
+ *    - Criteria Score = (sum_criterion_score/(total_criteria*10)) * 10 * 0.5
+ * 2. If only criteria exist:
+ *    - Criteria Score = (sum_criterion_score/(total_criteria*10)) * 10 * 1.0
+ * 3. If only tests exist:
+ *    - Test Score = (passed_tests/total_tests) * 10 * 1.0
+ *
+ * Each problem has a maximum score of 10 points
+ *
+ * @param submission Object containing test and criteria data
+ * @returns Calculated score (0-10)
+ */
+export function calculateScore(submission: ScoreInput): number {
+  const totalTests = submission.total_tests || 0;
+  const passedTests = submission.passed_tests || 0;
+  const totalCriteria = submission.total_criteria || 0;
+  const sumCriterionScore = submission.sum_criterion_score || 0;
+
+  const hasCriteria = totalCriteria > 0;
+  const hasTests = totalTests > 0;
+
+  let criteriaScore = 0;
+  let testScore = 0;
+
+  // Calculate criteria score
+  if (hasCriteria) {
+    // Criteria weight is 0.5 if tests exist, 1.0 otherwise
+    const criteriaWeight = hasTests ? 0.5 : 1.0;
+    criteriaScore =
+      (sumCriterionScore / (totalCriteria * 10)) * 10 * criteriaWeight;
+  }
+
+  // Calculate test score
+  if (hasTests) {
+    // Test weight is 0.5 when both tests and criteria exist, 1.0 when only tests exist
+    const testWeight = hasCriteria ? 0.5 : 1.0;
+    testScore = (passedTests / totalTests) * 10 * testWeight;
+  }
+
+  return criteriaScore + testScore;
+}
+
+/**
+ * Calculates scores for multiple problems and returns the best score for each
+ *
+ * @param submissions Array of submission objects with problem IDs
+ * @returns Map of problem ID to best score
+ */
+export function calculateBestScores(
+  submissions: Array<ScoreInput & { problem_id: string }>
+): Map<string, number> {
+  const bestScores = new Map<string, number>();
+
+  submissions.forEach((submission) => {
+    if (!submission.problem_id) return;
+
+    const score = calculateScore(submission);
+    const currentBest = bestScores.get(submission.problem_id) || 0;
+
+    if (score > currentBest) {
+      bestScores.set(submission.problem_id, score);
+    }
+  });
+
+  return bestScores;
+}
+
+/**
+ * Aggregates scores by challenge
+ *
+ * @param problemScores Map of problem ID to score
+ * @param problemChallengeMap Map of problem ID to challenge ID
+ * @returns Object mapping challenge IDs to their total scores
+ */
+export function aggregateByChallenge(
+  problemScores: Map<string, number>,
+  problemChallengeMap: Map<string, string>
+): Record<string, number> {
+  const challengeScores: Record<string, number> = {};
+
+  problemScores.forEach((score, problemId) => {
+    const challengeId = problemChallengeMap.get(problemId);
+    if (challengeId) {
+      challengeScores[challengeId] =
+        (challengeScores[challengeId] || 0) + score;
+    }
+  });
+
+  return challengeScores;
+}
+
+/**
+ * Formats a score for display
+ *
+ * @param score Raw score number
+ * @param decimals Number of decimal places (default: 1)
+ * @returns Formatted score string
+ */
+export function formatScore(score: number, decimals: number = 1): string {
+  return score.toFixed(decimals);
+}
+
+/**
+ * Calculates percentage based on score and maximum possible score
+ *
+ * @param score Current score
+ * @param maxScore Maximum possible score
+ * @returns Percentage (0-100)
+ */
+export function calculatePercentage(score: number, maxScore: number): number {
+  if (maxScore <= 0) return 0;
+  return (score / maxScore) * 100;
+}

package/src/nova/submissions/check-permission.ts

@@ -0,0 +1,132 @@
+import { createAdminClient } from '@tuturuuu/supabase/next/server';
+
+export async function checkPermission({
+  problemId,
+  sessionId,
+  userId,
+}: {
+  problemId: string;
+  sessionId: string | null;
+  userId: string;
+}) {
+  const sbAdmin = await createAdminClient({ noCookie: true });
+
+  // Check if the user is an admin
+  const { data: roleData, error: roleError } = await sbAdmin
+    .from('platform_user_roles')
+    .select('*')
+    .eq('user_id', userId)
+    .eq('allow_challenge_management', true)
+    .single();
+
+  if (roleError && roleError.code !== 'PGRST116') {
+    console.error('Database Error when checking role:', roleError);
+    return {
+      canSubmit: false,
+      remainingAttempts: 0,
+      message: 'Error checking user permissions',
+    };
+  }
+
+  const isAdmin = roleData?.allow_challenge_management;
+
+  // Admin users can always submit without restrictions
+  if (isAdmin) {
+    return { canSubmit: true, remainingAttempts: -1, message: null };
+  }
+
+  // For non-admin users, validate session and submission count
+  if (!sessionId) {
+    return {
+      canSubmit: false,
+      remainingAttempts: 0,
+      message: 'sessionId is required for non-admin users',
+    };
+  }
+
+  // Check if the session is in progress
+  const { data: sessionData, error: sessionError } = await sbAdmin
+    .schema('private')
+    .from('nova_sessions')
+    .select('*')
+    .eq('id', sessionId)
+    .single();
+
+  if (sessionError) {
+    console.error('Database Error when checking session:', sessionError);
+    return {
+      canSubmit: false,
+      remainingAttempts: 0,
+      message: 'Error fetching session data',
+    };
+  }
+
+  const { data: challengeData, error: challengeError } = await sbAdmin
+    .schema('private')
+    .from('nova_challenges')
+    .select('duration, close_at')
+    .eq('id', sessionData.challenge_id)
+    .single();
+
+  if (challengeError || !challengeData) {
+    console.error('Database Error when checking challenge:', challengeError);
+    return {
+      canSubmit: false,
+      remainingAttempts: 0,
+      message: 'Error fetching challenge data',
+    };
+  }
+
+  const sessionEndTime = Math.min(
+    challengeData.close_at
+      ? new Date(challengeData.close_at).getTime()
+      : Infinity,
+    new Date(sessionData.start_time).getTime() + challengeData.duration * 1000
+  );
+
+  const currentTime = Date.now();
+
+  if (currentTime > sessionEndTime) {
+    return {
+      canSubmit: false,
+      remainingAttempts: 0,
+      message: 'Session has ended',
+    };
+  }
+
+  // Check submission count
+  const { error: countError, count } = await sbAdmin
+    .schema('private')
+    .from('nova_submissions')
+    .select('*', { count: 'exact', head: true })
+    .eq('problem_id', problemId)
+    .eq('session_id', sessionId)
+    .eq('user_id', userId);
+
+  if (countError) {
+    console.error('Database Error when counting submissions:', countError);
+    return {
+      canSubmit: false,
+      remainingAttempts: 0,
+      message: 'Error checking submission count',
+    };
+  }
+
+  const maxAttempts = 3;
+  const submissionCount = count || 0;
+  const remainingAttempts = maxAttempts - submissionCount;
+
+  if (submissionCount >= maxAttempts) {
+    return {
+      canSubmit: false,
+      remainingAttempts: 0,
+      message: 'You have reached the maximum of 3 submissions.',
+    };
+  }
+
+  return {
+    canSubmit: true,
+    remainingAttempts,
+    message: null,
+  };
+}

package/src/onboarding-helper.ts

@@ -0,0 +1,213 @@
+import { createClient } from '@tuturuuu/supabase/next/client';
+
+export interface OnboardingProgress {
+  user_id: string;
+  completed_steps: string[];
+  current_step: string;
+  workspace_name?: string | null;
+  workspace_description?: string | null;
+  workspace_avatar_url?: string | null;
+  profile_completed: boolean;
+  tour_completed: boolean;
+  completed_at?: string | null;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface WhitelistStatus {
+  is_whitelisted: boolean;
+  enabled: boolean;
+  allow_challenge_management: boolean;
+  allow_manage_all_challenges: boolean;
+  allow_role_management: boolean;
+}
+
+export interface WorkspaceTemplate {
+  id: string;
+  name: string;
+  description?: string | null;
+  avatar_url?: string | null;
+  is_default: boolean;
+  created_at: string;
+}
+
+export const ONBOARDING_STEPS = {
+  WELCOME: 'welcome',
+  WORKSPACE_SETUP: 'workspace_setup',
+  PROFILE_COMPLETION: 'profile_completion',
+  FEATURE_TOUR: 'feature_tour',
+  DASHBOARD_REDIRECT: 'dashboard_redirect',
+} as const;
+
+export type OnboardingStep =
+  (typeof ONBOARDING_STEPS)[keyof typeof ONBOARDING_STEPS];
+
+/**
+ * Check if a user is whitelisted to access the platform
+ */
+export async function checkUserWhitelistStatus(
+  userId: string
+): Promise<WhitelistStatus> {
+  const supabase = createClient();
+
+  const { data, error } = await supabase
+    .rpc('get_user_whitelist_status', { user_id_param: userId })
+    .single();
+
+  if (error) {
+    console.error('Error checking whitelist status:', error);
+    return {
+      is_whitelisted: false,
+      enabled: false,
+      allow_challenge_management: false,
+      allow_manage_all_challenges: false,
+      allow_role_management: false,
+    };
+  }
+
+  return data;
+}
+
+/**
+ * Get user's onboarding progress
+ */
+export async function getUserOnboardingProgress(
+  userId: string
+): Promise<OnboardingProgress | null> {
+  const supabase = createClient();
+
+  const { data, error } = await supabase
+    .from('onboarding_progress')
+    .select('*')
+    .eq('user_id', userId)
+    .single();
+
+  if (error) {
+    if (error.code === 'PGRST116') {
+      // No record found, return null
+      return null;
+    }
+    console.error('Error fetching onboarding progress:', error);
+    return null;
+  }
+
+  return data;
+}
+
+/**
+ * Create or update user's onboarding progress
+ */
+export async function updateOnboardingProgress(
+  userId: string,
+  updates: Partial<
+    Omit<OnboardingProgress, 'user_id' | 'created_at' | 'updated_at'>
+  >
+): Promise<OnboardingProgress | null> {
+  const supabase = createClient();
+
+  const { data, error } = await supabase
+    .from('onboarding_progress')
+    .upsert(
+      {
+        user_id: userId,
+        ...updates,
+      },
+      {
+        onConflict: 'user_id',
+      }
+    )
+    .select()
+    .single();
+
+  if (error) {
+    console.error('Error updating onboarding progress:', error);
+    return null;
+  }
+
+  return data;
+}
+
+/**
+ * Mark an onboarding step as completed
+ */
+export async function completeOnboardingStep(
+  userId: string,
+  step: OnboardingStep,
+  nextStep?: OnboardingStep
+): Promise<boolean> {
+  const progress = await getUserOnboardingProgress(userId);
+  const completedSteps = progress?.completed_steps || [];
+
+  if (!completedSteps.includes(step)) {
+    completedSteps.push(step);
+  }
+
+  const updates: Partial<OnboardingProgress> = {
+    completed_steps: completedSteps,
+    current_step: nextStep || step,
+  };
+
+  // Check if all steps are completed
+  const allSteps = Object.values(ONBOARDING_STEPS);
+  const isCompleted = allSteps.every((s) => completedSteps.includes(s));
+
+  if (isCompleted) {
+    updates.completed_at = new Date().toISOString();
+  }
+
+  const result = await updateOnboardingProgress(userId, updates);
+  return !!result;
+}
+
+/**
+ * Check if user has completed onboarding
+ */
+export async function hasCompletedOnboarding(userId: string): Promise<boolean> {
+  const progress = await getUserOnboardingProgress(userId);
+  return !!progress?.completed_at;
+}
+
+/**
+ * Create workspace from onboarding data
+ */
+export async function createWorkspaceFromOnboarding(
+  userId: string,
+  workspaceName: string,
+  avatarUrl?: string
+): Promise<{ success: boolean; workspaceId?: string; error?: string }> {
+  const supabase = createClient();
+
+  try {
+    // Create the workspace
+    const { data: workspace, error: workspaceError } = await supabase
+      .from('workspaces')
+      .insert({
+        name: workspaceName,
+        avatar_url: avatarUrl,
+        creator_id: userId,
+      })
+      .select('id')
+      .single();
+
+    if (workspaceError) {
+      return { success: false, error: workspaceError.message };
+    }
+
+    // Set as user's default workspace
+    const { error: updateError } = await supabase
+      .from('user_private_details')
+      .update({ default_workspace_id: workspace.id })
+      .eq('user_id', userId);
+
+    if (updateError) {
+      console.warn('Could not set default workspace:', updateError);
+    }
+
+    return { success: true, workspaceId: workspace.id };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown error',
+    };
+  }
+}

package/src/path-helper.ts

@@ -0,0 +1,93 @@
+export function joinPath(...paths: string[]) {
+  if (paths.length === 0) return '/';
+
+  // Clean up paths and filter empty ones
+  const validPaths = paths.filter(Boolean).map((p) => p.trim());
+  if (validPaths.length === 0) return '/';
+
+  // Track path properties
+  const firstPath = validPaths[0];
+  const shouldBeRelative =
+    firstPath?.startsWith('./') || firstPath?.startsWith('../');
+  const shouldStartWithSlash =
+    firstPath?.startsWith('/') || firstPath?.startsWith('//');
+  const shouldHaveTrailingSlash = paths[paths.length - 1]?.endsWith('/');
+
+  // Process each path segment
+  const segments: string[] = [];
+  for (const path of validPaths) {
+    const parts = path.split('/');
+    for (const part of parts) {
+      if (part === '.') {
+        continue; // Skip "." segments
+      }
+      if (part) {
+        segments.push(part);
+      }
+    }
+  }
+
+  let result = segments.join('/');
+
+  // Handle special cases
+  if (!result || result === '/') return '/';
+
+  // Add leading slash for absolute paths
+  if (!shouldBeRelative && shouldStartWithSlash) {
+    result = `/${result.replace(/^\//, '')}`;
+  }
+
+  // Add leading './' if the first path started with './'
+  if (shouldBeRelative && firstPath?.startsWith('./')) {
+    result = `./${result}`;
+  }
+
+  // Add trailing slash if original had one
+  if (shouldHaveTrailingSlash && !result.endsWith('/')) {
+    result += '/';
+  }
+
+  return result;
+}
+
+export function popPath(path: string) {
+  if (!path) return '/';
+
+  // Clean and normalize the path
+  let cleanPath = path.trim().replace(/\/+/g, '/');
+  const isRelative = cleanPath.startsWith('./') || cleanPath.startsWith('../');
+  const isAbsolute = cleanPath.startsWith('/');
+
+  // Handle root and empty cases
+  if (!cleanPath || cleanPath === '/' || cleanPath === '.') return '/';
+
+  // Remove trailing slashes for processing
+  cleanPath = cleanPath.replace(/\/*$/, '');
+
+  // Find last slash
+  const lastSlash = cleanPath.lastIndexOf('/');
+
+  // No slash found
+  if (lastSlash === -1) {
+    if (isRelative) return '.';
+    return isAbsolute ? '/' : '/base';
+  }
+
+  // Get parent path
+  let result = cleanPath.slice(0, lastSlash);
+  if (!result) return '/';
+
+  // Handle relative paths
+  if (isRelative) {
+    if (!result.startsWith('./') && !result.startsWith('../')) {
+      result = `./${result.replace(/^\/+/, '')}`;
+    }
+  } else {
+    // Ensure leading slash for absolute paths and paths without protocol
+    if (!result.includes('://') && !result.startsWith('/')) {
+      result = `/${result}`;
+    }
+  }
+
+  return result;
+}