Offline Data Sync in OutSystems Mobile Apps

In Service Studio, go to **Data tab** in the left panel. Expand the **Local Storage** section (this section only appears in Mobile app modules — not Reactive Web). Right-click **Local Storage** → **Add Local Entity**. Name it to match your server entity (e.g., `LocalProduct`). Add the same attributes as your server entity (Name, Price, Category, etc.) plus two additional sync-tracking attributes: - `IsNew` (Boolean, default: False) — marks locally created records - `IsModified` (Boolean, default: False) — marks locally updated records - `IsDeleted` (Boolean, default: False) — marks locally deleted records (soft delete) - `LastSynced` (DateTime, default: #1900-01-01 00:00:00#) — timestamp of last server sync Local entities have auto-generated CRUD actions: `CreateLocalProduct`, `UpdateLocalProduct`, `DeleteLocalProduct`, `GetLocalProduct`.

Create a Server Action named `SyncDownload_Products`. This runs on the server and returns all products: **Server Action: SyncDownload_Products** - Output: `Products` (List of Product record) - Action flow: Start → GetAllProducts (Aggregate, no filters, no Max Records) → Assign Products = GetAllProducts.List → End Create a **Client Action** named `SyncProducts_Full`: Action flow: ``` Start → SyncDownload_Products (Server call) → For Each Product in SyncDownload_Products.Products → GetLocalProduct (find existing by server Id) → If GetLocalProduct.Success (local record exists) [True] → UpdateLocalProduct with new server values [False] → CreateLocalProduct from server data → [After loop] DeleteOldLocalRecords /* Aggregate: filter LocalProduct.Id NOT IN received server Ids */ /* Delete each record not in the server response */ → End ``` Call `SyncProducts_Full` from the App → OnApplicationReady lifecycle event.

1/* Client Action: SyncProducts_Full */
2/* Runs on device, calls server, populates LocalStorage */
3
4Start
5→ SyncDownload_Products
6     /* Server Action: returns all Product records */
7→ For Each CurrentProduct in SyncDownload_Products.Products
8   /* CurrentProduct is a Product record */
9   → GetLocalProductById
10        /* Aggregate: LocalProduct.ServerId = CurrentProduct.Id */
11   → If GetLocalProductById.List.Empty
12        [True]  (new record)
13          → CreateLocalProduct
14               LocalProduct.ServerId    = CurrentProduct.Id
15               LocalProduct.Name        = CurrentProduct.Name
16               LocalProduct.Price       = CurrentProduct.Price
17               LocalProduct.LastSynced  = CurrDateTime()
18               LocalProduct.IsNew       = False
19        [False] (existing record — update)
20          → UpdateLocalProduct
21               LocalProduct.Id          = GetLocalProductById.List.Current.LocalProduct.Id
22               LocalProduct.Name        = CurrentProduct.Name
23               LocalProduct.Price       = CurrentProduct.Price
24               LocalProduct.LastSynced  = CurrDateTime()
25               LocalProduct.IsModified  = False
26→ End

For tables with many records that change frequently, only download records modified since the last sync. **Add a `ModifiedOn` attribute** to your server-side Product entity (DateTime, auto-set on every update via entity auto-timestamp or a Before Create/Update handler). **Create Client Variable**: Data tab → Client Variables → Add → name it `LastProductSync` (DateTime, default: NullDate()). **Modify SyncDownload_Products Server Action** to accept `SinceDateTime` (DateTime) input: - Add filter to Aggregate: `Product.ModifiedOn >= SinceDateTime` - If SinceDateTime = NullDate(), fetch all records (first sync) **Incremental Client Action: SyncProducts_Incremental**: ``` Start → SyncDownload_Products SinceDateTime = LastProductSync → [Process each returned record — upsert into LocalStorage] → Assign LastProductSync = CurrDateTime() → End ```

1/* Server Action: SyncDownload_Products (incremental version) */
2/* Input: SinceDateTime (DateTime) */
3/* Output: Products (List of Product) */
4
5Start
6→ GetModifiedProducts
7     /* Aggregate filter: */
8     /* Product.ModifiedOn >= SinceDateTime */
9     /* OR SinceDateTime = NullDate()  ← first sync, get everything */
10     /* Filter expression: */
11     /* Product.ModifiedOn >= SinceDateTime Or SinceDateTime = NullDate() */
12→ Assign Products = GetModifiedProducts.List
13→ End
14
15
16/* Client Variable tracking last sync time */
17/* Data tab → Client Variables → LastProductSync (DateTime) */
18/* Default: NullDate() */
19
20/* In SyncProducts_Incremental Client Action */
21Start
22→ SyncDownload_Products
23     SinceDateTime = LastProductSync
24→ For Each in SyncDownload_Products.Products
25     → [upsert into LocalProduct as in full sync]
26→ Assign: LastProductSync = CurrDateTime()
27→ End

When users create or modify records offline, sync those changes back to the server when connectivity is restored. **Create Server Action: SyncUpload_Products** - Input: `ModifiedProducts` (List of LocalProduct) - For each record: create or update the server entity based on `IsNew`/`IsModified` flags - Output: `Success` (Boolean), `FailedIds` (List of Integer) **Client Action: SyncUp_Products**: ``` Start → GetModifiedLocalProducts /* Aggregate: LocalProduct.IsNew = True OR LocalProduct.IsModified = True */ /* Exclude IsDeleted records — handle separately */ → If NOT GetModifiedLocalProducts.List.Empty [True] → SyncUpload_Products (Server Action) ModifiedProducts = GetModifiedLocalProducts.List → [On success] Reset IsNew = False, IsModified = False for each uploaded record → GetDeletedLocalProducts /* Aggregate: LocalProduct.IsDeleted = True AND LocalProduct.ServerId > 0 */ → [Call Server Action to delete on server] → DeleteFromLocal (remove soft-deleted local records) → End ```

1/* Aggregate: GetModifiedLocalProducts */
2/* Filter: LocalProduct.IsNew = True Or LocalProduct.IsModified = True */
3
4/* Server Action: SyncUpload_Products */
5/* Input: ModifiedProducts (List of LocalProduct) */
6/* Output: Success (Boolean) */
7
8Start
9→ For Each CurrentRecord in ModifiedProducts
10   → If CurrentRecord.IsNew
11        [True]
12          → CreateProduct
13               Product.Name  = CurrentRecord.Name
14               Product.Price = CurrentRecord.Price
15               /* ... other attributes ... */
16          → Assign CurrentRecord.ServerId = CreateProduct.Id
17        [False] (IsModified)
18          → UpdateProduct
19               Product.Id    = CurrentRecord.ServerId
20               Product.Name  = CurrentRecord.Name
21               Product.Price = CurrentRecord.Price
22→ Assign Success = True
23→ End
24
25/* After successful upload — reset flags in Client Action */
26UpdateLocalProduct
27    LocalProduct.Id         = UploadedRecord.Id
28    LocalProduct.IsNew      = False
29    LocalProduct.IsModified = False
30    LocalProduct.ServerId   = ServerIdFromUpload

A conflict occurs when the same record is modified both locally and on the server since the last sync. **Last Write Wins** (simplest strategy): Compare `ModifiedOn` timestamps — the more recent change wins. In `SyncUpload_Products`, before updating a server record: ``` → GetServerProduct (Get server entity by ServerId) → If GetServerProduct.ModifiedOn > CurrentRecord.LastSynced [True — server modified after our last sync — CONFLICT] → Apply conflict policy: Option A: Server wins → discard local change, refresh local from server Option B: Client wins → proceed with update, overwrite server Option C: Merge → merge specific fields (complex, app-specific) [False — no conflict, safe to update] → UpdateProduct ``` For most enterprise apps, server wins is safest and prevents data loss.

1/* Conflict detection in SyncUpload_Products Server Action */
2
3For Each LocalRecord in ModifiedProducts
4→ GetProductFromServer  /* Get<Entity> by ServerId */
5→ If GetProductFromServer.Success
6   → If GetProductFromServer.Product.ModifiedOn > LocalRecord.LastSynced
7      [True — CONFLICT: server changed after our last sync]
8        /* Option A: Server wins — return conflict info to client */
9        → Append to ConflictsList: LocalRecord.Id
10      [False — no conflict, safe to proceed]
11        → UpdateProduct (server entity)
12   [False — record doesn't exist on server anymore]
13     → If LocalRecord.IsNew
14        [True] → CreateProduct (was new local record, never existed on server)
15        [False] → Skip update (deleted on server — log and discard)
16
17/* On client: refresh conflicted records from server */
18For Each ConflictedId in SyncUploadResult.ConflictsList
19→ GetServerRecord (Server Action)
20→ UpdateLocalProduct with server data
21→ Assign IsModified = False, LastSynced = CurrDateTime()

OutSystems mobile apps expose lifecycle and connectivity events. Wire your sync logic to these: **On app resume** (user reopens app): - Interface tab → UI Flows → Common → **OnApplicationReady** → add call to `SyncProducts_Full` (or incremental if LastSync is recent) **On connectivity restore**: - Interface tab → UI Flows → Common → **OnNetworkStatusChanged** event → check if status = Online → trigger `SyncProducts_Incremental` followed by `SyncUp_Products` **Manual sync button**: - Add a Sync button on relevant screens → OnClick Client Action calls the sync sequence with a loading spinner **Offline indicator**: - Use `IsNetworkConnected()` built-in Client function in a Container's Visible expression or a status bar widget. Action flow for OnNetworkStatusChanged: ``` Start → If IsNetworkConnected() → [True] SyncProducts_Incremental → SyncUp_Products → End ```

1/* OnNetworkStatusChanged Client Action */
2/* Available at: Interface tab → UI Flows → Common → OnNetworkStatusChanged */
3
4Start
5→ If IsNetworkConnected()
6   [True — device just came online]
7   → SyncProducts_Incremental
8        SinceDateTime = LastProductSync
9   → SyncUp_Products  /* upload local changes */
10   → FeedbackMessage("Sync complete", Success)
11   [False — device went offline]
12   → FeedbackMessage("You are offline. Changes saved locally.", Info)
13→ End
14
15
16/* Offline indicator — Container Visible property */
17Not IsNetworkConnected()
18
19/* Online indicator */
20IsNetworkConnected()
21
22/* OnApplicationReady — initial sync on app start */
23Start
24→ If IsNetworkConnected()
25   [True]
26   → If LastProductSync = NullDate()
27        [True]  → SyncProducts_Full    /* First time */
28        [False] → SyncProducts_Incremental  /* Subsequent */
29→ End