Fix manual activity scoring and preserve activity type config

Author: prazgaitis

apps/web/components/admin/admin-activity-types-table.tsx

@@ -60,6 +60,7 @@ export function AdminActivityTypesTable({
   const [editContributes, setEditContributes] = useState(true);
   const [editNegative, setEditNegative] = useState(false);
   const [editThresholds, setEditThresholds] = useState<BonusThreshold[]>([]);
+  const [editScoringConfig, setEditScoringConfig] = useState<Record<string, unknown> | null>(null);
 
   const [statusMessage, setStatusMessage] = useState<{ type: "success" | "error"; text: string } | null>(null);
   const [isPending, setIsPending] = useState(false);
@@ -92,35 +93,74 @@ export function AdminActivityTypesTable({
   };
 
   const startEditing = (item: ActivityType) => {
+    const scoringConfig = (item.scoringConfig as Record<string, unknown>) ?? {};
     const basePoints = getBasePoints(item);
     setEditingId(item._id);
     setEditName(item.name);
     setEditPoints(String(basePoints));
     setEditContributes(item.contributesToStreak);
     setEditNegative(item.isNegative);
     setEditThresholds((item.bonusThresholds as BonusThreshold[]) || []);
+    setEditScoringConfig(scoringConfig);
   };
 
   const cancelEditing = () => {
     setEditingId(null);
     setEditThresholds([]);
+    setEditScoringConfig(null);
+  };
+
+  const withUpdatedPoints = (
+    currentConfig: Record<string, unknown>,
+    points: number
+  ): Record<string, unknown> => {
+    const nextConfig = { ...currentConfig };
+    const scoringType = typeof nextConfig.type === "string" ? nextConfig.type : undefined;
+
+    if (scoringType === "completion") {
+      if ("fixedPoints" in nextConfig) {
+        nextConfig.fixedPoints = points;
+      } else {
+        nextConfig.points = points;
+      }
+      return nextConfig;
+    }
+
+    if (
+      scoringType === "unit_based" ||
+      scoringType === "distance" ||
+      scoringType === "duration" ||
+      scoringType === "count" ||
+      typeof nextConfig.unit === "string"
+    ) {
+      nextConfig.pointsPerUnit = points;
+      return nextConfig;
+    }
+
+    nextConfig.basePoints = points;
+    return nextConfig;
   };
 
   const handleUpdate = async (e: React.FormEvent) => {
     e.preventDefault();
     if (!editingId) return;
     setIsPending(true);
     try {
+      const parsedPoints = Number(editPoints);
+      const safePoints = Number.isFinite(parsedPoints) ? parsedPoints : 1;
+      const nextScoringConfig = withUpdatedPoints(editScoringConfig ?? {}, safePoints);
+
       await updateActivityType({
         activityTypeId: editingId as Id<"activityTypes">,
         name: editName,
-        scoringConfig: { basePoints: Number(editPoints) || 1 },
+        scoringConfig: nextScoringConfig,
         contributesToStreak: editContributes,
         isNegative: editNegative,
         bonusThresholds: editThresholds,
       });
       setEditingId(null);
       setEditThresholds([]);
+      setEditScoringConfig(null);
       setStatusMessage({ type: "success", text: "Saved" });
       clearStatus();
     } catch {
@@ -149,7 +189,7 @@ export function AdminActivityTypesTable({
 
   const getBasePoints = (item: ActivityType) => {
     const config = item.scoringConfig as Record<string, unknown>;
-    return Number(config?.basePoints ?? config?.points ?? config?.pointsPerUnit ?? 1) || 1;
+    return Number(config?.pointsPerUnit ?? config?.fixedPoints ?? config?.points ?? config?.basePoints ?? 1) || 1;
   };
 
   return (

apps/web/components/dashboard/activity-log-dialog.tsx

@@ -88,6 +88,11 @@ function parseNumber(value: unknown): number | null {
   return Number.isFinite(numberValue) ? numberValue : null;
 }
 
+function formatPoints(value: number): string {
+  const normalized = Math.round((value + Number.EPSILON) * 100) / 100;
+  return normalized.toString();
+}
+
 interface MediaPreview {
   file: File;
   url: string;
@@ -677,12 +682,12 @@ export function ActivityLogDialog({ challengeId, challengeStartDate, trigger }:
               {successState.activityName}
             </p>
             <p className="mt-1 text-2xl font-bold text-green-500">
-              +{successState.pointsEarned.toFixed(0)} pts
+              +{formatPoints(successState.pointsEarned)} pts
             </p>
             {successState.triggeredBonuses.length > 0 && (
               <div className="mt-3 space-y-1">
                 <p className="text-xs text-muted-foreground">
-                  {successState.basePoints.toFixed(0)} base + {successState.bonusPoints.toFixed(0)} bonus
+                  {formatPoints(successState.basePoints)} base + {formatPoints(successState.bonusPoints)} bonus
                 </p>
                 {successState.triggeredBonuses.map((bonus, i) => (
                   <Badge key={i} variant="secondary" className="bg-amber-500/10 text-amber-500">

packages/backend/lib/scoring.ts

@@ -22,6 +22,60 @@ function toNumber(value: unknown): number {
   return Number.isFinite(numberValue) ? numberValue : 0;
 }
 
+function normalizeMetricKey(key: string): string {
+  return key
+    .trim()
+    .toLowerCase()
+    .replace(/[\s-]+/g, "_");
+}
+
+function getMetricValueForUnit(
+  unit: string | undefined,
+  metrics: Record<string, unknown>
+): number | undefined {
+  if (!unit) {
+    return undefined;
+  }
+
+  // Fast path: exact key as configured.
+  if (metrics[unit] !== undefined) {
+    return toNumber(metrics[unit]);
+  }
+
+  const normalizedUnit = normalizeMetricKey(unit);
+
+  // Common canonical aliases used across ingestion paths.
+  const canonicalAliases: Record<string, string[]> = {
+    miles: ["distance_miles", "mile", "distance_mile"],
+    kilometers: ["distance_km", "distance_kilometers", "km", "kilometres", "kilometer", "kilometre"],
+    minutes: ["duration_minutes", "moving_minutes", "minute"],
+    count: ["counts", "instances", "instance"],
+    completion: ["completed", "is_completed"],
+    full_days: ["full_day"],
+    half_days: ["half_day"],
+  };
+
+  const candidates = new Set<string>([normalizedUnit]);
+  const singular = normalizedUnit.endsWith("s") ? normalizedUnit.slice(0, -1) : normalizedUnit;
+  const plural = normalizedUnit.endsWith("s") ? normalizedUnit : `${normalizedUnit}s`;
+  candidates.add(singular);
+  candidates.add(plural);
+
+  const aliasKeys = canonicalAliases[normalizedUnit] ?? canonicalAliases[singular] ?? [];
+  for (const alias of aliasKeys) {
+    candidates.add(alias);
+  }
+
+  for (const [key, value] of Object.entries(metrics)) {
+    const normalizedKey = normalizeMetricKey(key);
+    if (candidates.has(normalizedKey) && value !== undefined) {
+      return toNumber(value);
+    }
+  }
+
+  return undefined;
+}
+
 function getScoringConfig(activityType: Doc<"activityTypes">): Record<string, unknown> {
   return (activityType.scoringConfig as Record<string, unknown>) ?? {};
 }
@@ -36,11 +90,11 @@ async function calculateDefaultPoints(
   const config = getScoringConfig(activityType);
   const { unit, pointsPerUnit = 1, basePoints = 0 } = config;
 
-  if (!unit || !context.metrics[unit as string]) {
+  const unitValue = getMetricValueForUnit(unit as string | undefined, context.metrics);
+  if (unitValue === undefined) {
     return toNumber(basePoints);
   }
 
-  const unitValue = toNumber(context.metrics[unit as string]);
   return toNumber(basePoints) + unitValue * toNumber(pointsPerUnit);
 }
 
@@ -210,11 +264,11 @@ function calculateVariantPoints(
   const { unit, pointsPerUnit = 1, basePoints = 0 } = variantConfig;
   const scoringUnit = unit || mainConfig["unit"];
 
-  if (!scoringUnit || !metrics[scoringUnit as string]) {
+  const unitValue = getMetricValueForUnit(scoringUnit as string | undefined, metrics);
+  if (unitValue === undefined) {
     return toNumber(basePoints);
   }
 
-  const unitValue = toNumber(metrics[scoringUnit as string]);
   return toNumber(basePoints) + unitValue * toNumber(pointsPerUnit);
 }
 
@@ -312,18 +366,19 @@ function calculateUnitBasedPoints(
   const maxUnits = config["maxUnits"] as number | undefined;
   const basePoints = toNumber(config["basePoints"] ?? 0);
 
-  if (!unit || !context.metrics[unit]) {
+  const unitValue = getMetricValueForUnit(unit, context.metrics);
+  if (unitValue === undefined) {
     return basePoints;
   }
 
-  let unitValue = toNumber(context.metrics[unit]);
+  let boundedUnitValue = unitValue;
 
   // Apply cap if maxUnits is defined
-  if (maxUnits !== undefined && unitValue > maxUnits) {
-    unitValue = maxUnits;
+  if (maxUnits !== undefined && boundedUnitValue > maxUnits) {
+    boundedUnitValue = maxUnits;
   }
 
-  return basePoints + unitValue * pointsPerUnit;
+  return basePoints + boundedUnitValue * pointsPerUnit;
 }
 
 /**