feat: local vs server sync (M2-10227)

assets/translations/en.json

@@ -18,6 +18,8 @@
     "please_wait": "Please wait",
     "activity_all_items_hidden": "\"{{entityName}}\" cannot be started because all items inside the activity are hidden",
     "flow_all_items_hidden": "\"{{entityName}}\" cannot be started because it contains an activity in which all items are hidden",
+    "flow_completed": "Flow Completed",
+    "flow_completed_elsewhere_message": "This flow was completed on another device. Refreshing to sync the latest data.",
     "progress": {
       "upload_files": "Uploading your files...",
       "encrypt_answers": "Encrypting your answers...",

src/app/ui/AppProvider/ReduxProvider.tsx

@@ -31,7 +31,7 @@
   blacklist: ['banners'],
 };
 
 const rootReducer = (state: any, action: AnyAction) => {
   if (migrateReduxStore.match(action)) {
     state = action.payload;
   }
@@ -44,7 +44,7 @@
     defaultBanners: defaultBannersReducer,
   });
 
   return reducer(state, action);
 };
 
 const persistedReducer = persistReducer(
@@ -54,6 +54,14 @@
 
 export const reduxStore = configureStore({
   reducer: persistedReducer,
+  middleware: getDefaultMiddleware =>
+    getDefaultMiddleware({
+      serializableCheck: {
+        // Ignore redux-persist actions (they contain non-serializable functions)
+        ignoredActions: ['persist/PERSIST', 'persist/REHYDRATE'],
+        ignoredPaths: ['register'],
+      },
+    }),
   enhancers: getDefaultEnhancers => {
     const enhancers = getDefaultEnhancers();
 

src/entities/activity/lib/services/tests/AnswersUploadService.test.ts

@@ -349,6 +349,13 @@ describe('AnswersUploadService', () => {
       activityId: 'activity123',
       appletId: 'applet123',
       flowId: 'flow123',
+      answer: {
+        startTime: 1000,
+        endTime: 2000,
+        localEndDate: '2023-01-01',
+        localEndTime: '12:00:00',
+        tzOffset: -300,
+      },
     } as ActivityAnswersRequest;
 
     const mockCheckIfAnswersUploaded = jest.fn().mockResolvedValueOnce(false);
@@ -380,6 +387,13 @@ describe('AnswersUploadService', () => {
       activityId: 'activity123',
       appletId: 'applet123',
       flowId: 'flow123',
+      answer: {
+        startTime: 1000,
+        endTime: 2000,
+        localEndDate: '2023-01-01',
+        localEndTime: '12:00:00',
+        tzOffset: -300,
+      },
     } as ActivityAnswersRequest;
 
     const mockCheckIfAnswersUploaded = jest.fn().mockResolvedValueOnce(false);

src/entities/applet/lib/alerts.ts

@@ -67,3 +67,17 @@ export function onFlowActivityContainsAllItemsHidden(entityName: string) {
 export function onDataSharingConsentDetails() {
   Alert.alert('', i18n.t('data_sharing:dialog:body'));
 }
+
+export function onFlowCompletedElsewhere(onOk: () => void) {
+  Alert.alert(
+    i18n.t('activity:flow_completed'),
+    i18n.t('activity:flow_completed_elsewhere_message'),
+    [
+      {
+        text: i18n.t('additional:ok'),
+        onPress: onOk,
+      },
+    ],
+    { cancelable: false },
+  );
+}

src/entities/applet/model/hooks/useRefreshMutation.ts

@@ -18,8 +18,9 @@ export const useRefreshMutation = (onSuccess?: () => void | Promise<void>) => {
   const queryClient = useQueryClient();
 
   const progressSyncService = useMemo(
-    () => new ProgressSyncService(state, dispatch, getDefaultLogger()),
-    [dispatch, state],
+    () =>
+      new ProgressSyncService(state, dispatch, getDefaultLogger(), queryClient),
+    [dispatch, state, queryClient],
   );
 
   const refreshService = useMemo(

src/entities/applet/model/hooks/useStartEntity.ts

@@ -8,8 +8,13 @@ import {
   EvaluateAvailableTo,
   LookupEntityInput,
 } from '@app/abstract/lib/types/entity';
-import { EntityProgressionInProgress } from '@app/abstract/lib/types/entityProgress';
+import {
+  EntityProgression,
+  EntityProgressionInProgress,
+} from '@app/abstract/lib/types/entityProgress';
 import { ActivityRecordKeyParams } from '@app/abstract/lib/types/storage';
+import { reduxStore } from '@app/app/ui/AppProvider/ReduxProvider';
+import { useRefreshMutation } from '@app/entities/applet/model/hooks/useRefreshMutation';
 import { ResponseType } from '@app/shared/api/services/ActivityItemDto';
 import {
   ActivityFlowRecordDto,
@@ -63,7 +68,8 @@ type FailReason =
   | 'all-items-hidden'
   | 'not-available'
   | 'mutex-busy'
-  | 'expired-while-alert-opened';
+  | 'expired-while-alert-opened'
+  | 'completed-elsewhere';
 
 type StartResult = {
   fromScratch?: boolean;
@@ -111,6 +117,8 @@ export function useStartEntity({
 
   const { getName: getAppletDisplayName } = useAppletInfo();
 
+  const { mutateAsync: refresh } = useRefreshMutation();
+
   const logger: ILogger = getDefaultLogger();
 
   function activityStart(
@@ -201,12 +209,15 @@ export function useStartEntity({
     entityType: EntityType,
     targetSubjectId: string | null,
   ): Promise<{ isEntityInProgress: boolean; availableTo: number | null }> {
+    const freshProgressions: EntityProgression[] =
+      selectAppletsEntityProgressions(reduxStore.getState());
+
     const progression = getEntityProgression(
       appletId,
       entityId,
       eventId,
       targetSubjectId,
-      entityProgressions,
+      freshProgressions,
     );
 
     let evaluatedIsInProgress = isEntityProgressionInProgress(progression);
@@ -221,7 +232,7 @@ export function useStartEntity({
 
     const readyForAutocompletion = isProgressionReadyForAutocompletion(
       entityPath,
-      entityProgressions,
+      freshProgressions,
     );
 
     if (readyForAutocompletion) {
@@ -346,6 +357,8 @@ export function useStartEntity({
     try {
       mutex.setBusy();
 
+      await refresh();
+
       if (
         !(await checkAvailability(entityName, {
           appletId,
@@ -471,6 +484,19 @@ export function useStartEntity({
               return resolve({ failReason: 'expired-while-alert-opened' });
             }
 
+            // Clear FlowState to ensure clean restart
+            const flowStateKey = getFlowRecordKey(
+              flowId,
+              appletId,
+              eventId,
+              targetSubjectId,
+            );
+            const flowStorage =
+              getDefaultStorageInstanceManager().getFlowProgressStorage();
+            flowStorage.delete(flowStateKey);
+
+            logger.log(`[useStartEntity.onRestart] Cleared FlowState`);
+
             for (let i = 0; i < flowActivities.length; i++) {
               // TODO: it should be based on progress record
               cleanUpMediaFiles({
@@ -514,8 +540,28 @@ export function useStartEntity({
             const storage =
               getDefaultStorageInstanceManager().getFlowProgressStorage();
 
-            const flowState =
-              (JSON.parse(storage.getString(key) || '') as FlowState) || {};
+            let flowState: FlowState | undefined;
+            try {
+              const storedValue = storage.getString(key);
+              if (storedValue) {
+                flowState = JSON.parse(storedValue) as FlowState;
+              }
+            } catch (error) {
+              logger.error(
+                `[useStartEntity.onResume] Failed to parse flow state: ${error}`,
+              );
+            }
+
+            if (
+              !flowState ||
+              !flowState.pipeline ||
+              flowState.pipeline.length === 0
+            ) {
+              logger.warn(
+                '[useStartEntity.onResume] No valid flow state found, starting from scratch',
+              );
+              return resolve({ fromScratch: true });
+            }
 
             trackResumeFlow({
               ...logParams,
@@ -566,6 +612,47 @@ export function useStartEntity({
     try {
       mutex.setBusy();
 
+      // Capture pre-refresh state to detect cross-device completion
+      const preRefreshProgressions: EntityProgression[] =
+        selectAppletsEntityProgressions(reduxStore.getState());
+      const preRefreshProgression = getEntityProgression(
+        appletId,
+        flowId,
+        eventId,
+        targetSubjectId,
+        preRefreshProgressions,
+      );
+      const wasInProgress = isEntityProgressionInProgress(
+        preRefreshProgression,
+      );
+      const preRefreshSubmitId = wasInProgress
+        ? (preRefreshProgression as EntityProgressionInProgress).submitId
+        : null;
+
+      await refresh();
+
+      // Check if the flow we started was completed on another device
+      if (wasInProgress && preRefreshSubmitId) {
+        const postRefreshProgressions: EntityProgression[] =
+          selectAppletsEntityProgressions(reduxStore.getState());
+        const postRefreshProgression = getEntityProgression(
+          appletId,
+          flowId,
+          eventId,
+          targetSubjectId,
+          postRefreshProgressions,
+        );
+
+        const isNowCompleted = postRefreshProgression?.status === 'completed';
+        const submitIdsMatch =
+          postRefreshProgression?.submitId === preRefreshSubmitId;
+
+        // SAME submitId completed elsewhere - show alert and block
+        if (isNowCompleted && submitIdsMatch) {
+          return { failed: true, failReason: 'completed-elsewhere' };
+        }
+      }
+
       if (
         !(await checkAvailability(entityName, {
           appletId,

src/entities/applet/model/hooks/useTargetedSync.ts

@@ -0,0 +1,49 @@
+import { useCallback, useMemo, useRef, useState } from 'react';
+
+import { useQueryClient } from '@tanstack/react-query';
+
+import { useAppDispatch, useAppSelector } from '@app/shared/lib/hooks/redux';
+import { getDefaultLogger } from '@app/shared/lib/services/loggerInstance';
+
+import { selectGlobalState } from '../selectors';
+import { TargetedProgressSyncService } from '../services/TargetedProgressSyncService';
+
+// Hook for syncing single applet's progress without full refresh
+export const useTargetedSync = () => {
+  const dispatch = useAppDispatch();
+  const state = useAppSelector(selectGlobalState);
+  const queryClient = useQueryClient();
+  const logger = getDefaultLogger();
+
+  const syncService = useMemo(
+    () => new TargetedProgressSyncService(state, dispatch, logger, queryClient),
+    [state, dispatch, logger, queryClient],
+  );
+
+  const isSyncing = useRef(false);
+  const [isRefreshing, setIsRefreshing] = useState(false);
+
+  const syncApplet = useCallback(
+    async (appletId: string): Promise<void> => {
+      if (isSyncing.current) {
+        logger.log('[useTargetedSync]: Sync already in progress, skipping');
+        return;
+      }
+
+      try {
+        isSyncing.current = true;
+        setIsRefreshing(true);
+        await syncService.syncAppletProgress(appletId);
+      } finally {
+        isSyncing.current = false;
+        setIsRefreshing(false);
+      }
+    },
+    [syncService, logger],
+  );
+
+  return {
+    syncApplet,
+    isRefreshing,
+  };
+};

src/entities/applet/model/services/ITargetedProgressSyncService.ts

@@ -0,0 +1,4 @@
+export interface ITargetedProgressSyncService {
+  // Syncs in-progress flows and completions for a single applet
+  syncAppletProgress(appletId: string): Promise<void>;
+}

src/entities/applet/model/services/ProgressDataCollector.ts

@@ -19,6 +19,7 @@ export class ProgressDataCollector implements IProgressDataCollector {
 
     return await getDefaultEventsService().getAllCompletedEntities({
       fromDate,
+      includeInProgress: true,
     });
   }