Merge pull request #800 from apedley/app-barcode-scan

App Barcode Scan and Dash Charts

Author: CodeWithCJ

SparkyFitnessMobile/App.tsx

@@ -24,6 +24,7 @@ import FoodSearchScreen from './src/screens/FoodSearchScreen';
 import FoodEntryAddScreen from './src/screens/FoodEntryAddScreen';
 import FoodEntryViewScreen from './src/screens/FoodEntryViewScreen';
 import ManualFoodEntryScreen from './src/screens/ManualFoodEntryScreen';
+import FoodScanScreen from './src/screens/FoodScanScreen';
 import { configureBackgroundSync } from './src/services/backgroundSyncService';
 import { initializeTheme } from './src/services/themeService';
 import { initLogService } from './src/services/LogService';
@@ -200,6 +201,8 @@ function AppContent() {
             options={{
               presentation: 'modal',
               headerShown: false,
+              gestureEnabled: true,
+              gestureDirection: 'horizontal',
             }}
           />
           <Stack.Screen
@@ -220,6 +223,15 @@ function AppContent() {
               gestureDirection: 'horizontal',
             }}
           />
+          <Stack.Screen
+            name="FoodScan"
+            component={FoodScanScreen}
+            options={{
+              headerShown: false,
+              gestureEnabled: true,
+              gestureDirection: 'horizontal',
+            }}
+          />
           <Stack.Screen
             name="FoodEntryView"
             component={FoodEntryViewScreen}

SparkyFitnessMobile/__tests__/hooks/useMeasurementsRange.test.ts

@@ -0,0 +1,270 @@
+import { renderHook, waitFor } from '@testing-library/react-native';
+import React from 'react';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { useMeasurementsRange } from '../../src/hooks/useMeasurementsRange';
+import { measurementsRangeQueryKey } from '../../src/hooks/queryKeys';
+import { fetchMeasurementsRange } from '../../src/services/api/measurementsApi';
+import { getTodayDate, addDays } from '../../src/utils/dateUtils';
+import type { CheckInMeasurementRange } from '../../src/types/measurements';
+
+jest.mock('../../src/services/api/measurementsApi', () => ({
+  fetchMeasurementsRange: jest.fn(),
+}));
+
+jest.mock('@react-navigation/native', () => ({
+  useFocusEffect: jest.fn((callback) => {
+    callback();
+  }),
+}));
+
+const mockFetchMeasurementsRange = fetchMeasurementsRange as jest.MockedFunction<typeof fetchMeasurementsRange>;
+
+const makeMeasurement = (entry_date: string, steps?: number): CheckInMeasurementRange => ({
+  id: `id-${entry_date}`,
+  user_id: 'user-1',
+  entry_date,
+  steps,
+  updated_at: `${entry_date}T12:00:00Z`,
+});
+
+describe('useMeasurementsRange', () => {
+  let queryClient: QueryClient;
+
+  const createWrapper = () => {
+    const Wrapper = ({ children }: { children: React.ReactNode }) =>
+      React.createElement(QueryClientProvider, { client: queryClient }, children);
+    Wrapper.displayName = 'QueryClientProviderWrapper';
+    return Wrapper;
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    queryClient = new QueryClient({
+      defaultOptions: {
+        queries: {
+          retry: false,
+          staleTime: 0,
+        },
+      },
+    });
+  });
+
+  afterEach(() => {
+    queryClient.clear();
+  });
+
+  describe('data transformation', () => {
+    test('returns correct number of data points for 7d range', async () => {
+      mockFetchMeasurementsRange.mockResolvedValue([]);
+
+      const { result } = renderHook(
+        () => useMeasurementsRange({ range: '7d' }),
+        { wrapper: createWrapper() },
+      );
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      expect(result.current.stepsData).toHaveLength(7);
+    });
+
+    test('returns correct number of data points for 30d range', async () => {
+      mockFetchMeasurementsRange.mockResolvedValue([]);
+
+      const { result } = renderHook(
+        () => useMeasurementsRange({ range: '30d' }),
+        { wrapper: createWrapper() },
+      );
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      expect(result.current.stepsData).toHaveLength(30);
+    });
+
+    test('returns correct number of data points for 90d range', async () => {
+      mockFetchMeasurementsRange.mockResolvedValue([]);
+
+      const { result } = renderHook(
+        () => useMeasurementsRange({ range: '90d' }),
+        { wrapper: createWrapper() },
+      );
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      expect(result.current.stepsData).toHaveLength(90);
+    });
+
+    test('fills missing days with 0 steps', async () => {
+      const today = getTodayDate();
+      mockFetchMeasurementsRange.mockResolvedValue([
+        makeMeasurement(today, 5000),
+      ]);
+
+      const { result } = renderHook(
+        () => useMeasurementsRange({ range: '7d' }),
+        { wrapper: createWrapper() },
+      );
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      // Only today should have steps, rest should be 0
+      const nonZero = result.current.stepsData.filter((d) => d.steps > 0);
+      expect(nonZero).toHaveLength(1);
+      expect(nonZero[0].day).toBe(today);
+      expect(nonZero[0].steps).toBe(5000);
+
+      const zeros = result.current.stepsData.filter((d) => d.steps === 0);
+      expect(zeros).toHaveLength(6);
+    });
+
+    test('deduplicates entries per date keeping the first (most recent)', async () => {
+      const today = getTodayDate();
+      mockFetchMeasurementsRange.mockResolvedValue([
+        { ...makeMeasurement(today, 8000), updated_at: `${today}T14:00:00Z` },
+        { ...makeMeasurement(today, 5000), updated_at: `${today}T10:00:00Z` },
+      ]);
+
+      const { result } = renderHook(
+        () => useMeasurementsRange({ range: '7d' }),
+        { wrapper: createWrapper() },
+      );
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      const todayPoint = result.current.stepsData.find((d) => d.day === today);
+      expect(todayPoint?.steps).toBe(8000);
+    });
+
+    test('returns data in chronological order (ascending)', async () => {
+      const today = getTodayDate();
+      const yesterday = addDays(today, -1);
+      mockFetchMeasurementsRange.mockResolvedValue([
+        makeMeasurement(today, 3000),
+        makeMeasurement(yesterday, 7000),
+      ]);
+
+      const { result } = renderHook(
+        () => useMeasurementsRange({ range: '7d' }),
+        { wrapper: createWrapper() },
+      );
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      const data = result.current.stepsData;
+      // Last item should be today
+      expect(data[data.length - 1].day).toBe(today);
+      expect(data[data.length - 2].day).toBe(yesterday);
+
+      // Verify ascending order
+      for (let i = 1; i < data.length; i++) {
+        expect(data[i].day > data[i - 1].day).toBe(true);
+      }
+    });
+
+    test('treats undefined steps as 0', async () => {
+      const today = getTodayDate();
+      mockFetchMeasurementsRange.mockResolvedValue([
+        makeMeasurement(today, undefined),
+      ]);
+
+      const { result } = renderHook(
+        () => useMeasurementsRange({ range: '7d' }),
+        { wrapper: createWrapper() },
+      );
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      const todayPoint = result.current.stepsData.find((d) => d.day === today);
+      expect(todayPoint?.steps).toBe(0);
+    });
+  });
+
+  describe('API calls', () => {
+    test('calls fetchMeasurementsRange with correct date range for 7d', async () => {
+      mockFetchMeasurementsRange.mockResolvedValue([]);
+      const today = getTodayDate();
+      const startDate = addDays(today, -6);
+
+      renderHook(
+        () => useMeasurementsRange({ range: '7d' }),
+        { wrapper: createWrapper() },
+      );
+
+      await waitFor(() => {
+        expect(mockFetchMeasurementsRange).toHaveBeenCalledWith(startDate, today);
+      });
+    });
+
+    test('calls fetchMeasurementsRange with correct date range for 30d', async () => {
+      mockFetchMeasurementsRange.mockResolvedValue([]);
+      const today = getTodayDate();
+      const startDate = addDays(today, -29);
+
+      renderHook(
+        () => useMeasurementsRange({ range: '30d' }),
+        { wrapper: createWrapper() },
+      );
+
+      await waitFor(() => {
+        expect(mockFetchMeasurementsRange).toHaveBeenCalledWith(startDate, today);
+      });
+    });
+  });
+
+  describe('options', () => {
+    test('respects enabled=false', async () => {
+      mockFetchMeasurementsRange.mockResolvedValue([]);
+
+      renderHook(
+        () => useMeasurementsRange({ range: '7d', enabled: false }),
+        { wrapper: createWrapper() },
+      );
+
+      await new Promise((resolve) => setTimeout(resolve, 50));
+
+      expect(mockFetchMeasurementsRange).not.toHaveBeenCalled();
+    });
+
+    test('enabled defaults to true', async () => {
+      mockFetchMeasurementsRange.mockResolvedValue([]);
+
+      renderHook(
+        () => useMeasurementsRange({ range: '7d' }),
+        { wrapper: createWrapper() },
+      );
+
+      await waitFor(() => {
+        expect(mockFetchMeasurementsRange).toHaveBeenCalled();
+      });
+    });
+  });
+
+  describe('query key', () => {
+    test('exports correct query key function', () => {
+      expect(measurementsRangeQueryKey('2024-06-01', '2024-06-07')).toEqual([
+        'measurementsRange',
+        '2024-06-01',
+        '2024-06-07',
+      ]);
+    });
+
+    test('query key changes with dates', () => {
+      expect(measurementsRangeQueryKey('2024-06-01', '2024-06-07')).not.toEqual(
+        measurementsRangeQueryKey('2024-06-01', '2024-06-08'),
+      );
+    });
+  });
+});

SparkyFitnessMobile/app.json

@@ -38,7 +38,14 @@
       "expo-font",
       "expo-asset",
       "expo-background-task",
-      "expo-secure-store"
+      "expo-secure-store",
+      [
+        "expo-camera",
+        {
+          "cameraPermission": "SparkyFitness needs access to your camera to scan food barcodes.",
+          "recordAudioAndroid": false
+        }
+      ]
     ],
     "experiments": {
       "reactCompiler": true

SparkyFitnessMobile/docs/external_providers.md

@@ -14,6 +14,8 @@ Most providers require an `x-provider-id` header — that's the ID of the user's
 
 
 ## Open Food Facts
+
+### Search
 ```
 curl -X GET 'http://10.0.0.75:8080/api/foods/openfoodfacts/search?query=pepper' \
   --header 'Accept: */*' \
@@ -39,6 +41,26 @@ interface OpenFoodFactsProduct {
 }
 ```
 
+### Barcode Search
+```
+curl -X GET 'http://10.0.0.75:8080/api/foods/openfoodfacts/barcode/0851953005136' \
+  --header 'Accept: */*' \
+  --header 'Authorization: Bearer {token}'
+```
+
+
+#### Response
+
+```json
+{
+  "code": "0851953005136",
+  "product": {
+    "_id": "0851953005136",
+    ...
+  }
+}
+```
+
 ## FatSecret
 
 ### Search

SparkyFitnessMobile/docs/food_api.md

@@ -104,4 +104,42 @@ Searches for foods based on searchTerm. foodFilter is unused.
   "custom_nutrients": {},
   "meal_type_id": "d7bbfb6c-a5fb-48e0-9444-718bd20e7885"
 }
+```
+
+
+## POST /api/foods
+
+```json
+{
+  "name": "Protein Shake",
+  "brand": "Homemade",
+  "user_id": "some-uuid-here",
+  "is_custom": true,
+  "is_quick_food": true,
+  "barcode": null,
+  "provider_external_id": null,
+  "provider_type": null,
+  "serving_size": 1,
+  "serving_unit": "serving",
+  "calories": 250,
+  "protein": 30,
+  "carbs": 15,
+  "fat": 8,
+  "saturated_fat": 2,
+  "polyunsaturated_fat": null,
+  "monounsaturated_fat": null,
+  "trans_fat": 0,
+  "cholesterol": null,
+  "sodium": null,
+  "potassium": null,
+  "dietary_fiber": null,
+  "sugars": 5,
+  "vitamin_a": null,
+  "vitamin_c": null,
+  "calcium": null,
+  "iron": null,
+  "is_default": true,
+  "glycemic_index": null,
+  "custom_nutrients": {}
+}
 ```