Gravar dados em um Realm sincronizado - Kotlin SDK

Configuração do App Services

Com base no modelo de objeto de exemplo acima, o Device Sync é configurado com os seguintes campos de query:

• _id (Sempre incluído)

• complexity

• ownerId

O App Services App tem permissões configuradas para permitir que os usuários leiam e escrevam somente seus próprios dados:

{
   "roles": [
      {
         "name": "readOwnWriteOwn",
         "apply_when": {},
         "document_filters": {
            "write": {
               "ownerId": "%%user.id"
            },
            "read": {
               "ownerId": "%%user.id"
            }
         },
         "read": true,
         "write": true,
         "insert": true,
         "delete": true,
         "search": true
      }
   ]
}

Qualquer objeto na collection Atlas em que o ownerId não corresponda ao user.id do usuário conectado não pode ser sincronizado com esse Realm.

Modelo de dados Realm e configuração do cliente

Usando o modelo de objetos, os exemplos configuram o Realm sincronizado para sincronizar objetos correspondentes a esta query de assinatura :

val app = App.create(FLEXIBLE_APP_ID)
val user = app.login(credentials)
val flexSyncConfig = SyncConfiguration.Builder(user, setOf(Item::class))
    // Add subscription
    .initialSubscriptions { realm ->
        add(
            // Get Items from Atlas that match the Realm Query Language query.
            // Uses the queryable field `complexity`.
            // Query matches objects with complexity less than or equal to 4.
            realm.query<Item>("complexity <= 4"),
            "simple-items"
        )
    }
    .build()
val syncRealm = Realm.open(flexSyncConfig)
syncRealm.subscriptions.waitForSynchronization()
Log.v("Successfully opened realm: ${syncRealm.configuration}")

Qualquer objeto na coleção Atlas em que o valor da propriedade complexity for maior que 4 não poderá ser sincronizado com esse domínio.

Gravações bem-sucedidas

Quando a gravação corresponde às permissões do usuário e à assinatura da query no cliente, o Realm Kotlin SDK pode gravar com êxito o objeto no domínio sincronizado. Este objeto é sincronizado com o backend do App Services quando o dispositivo tem uma conexão de rede.

// Per the Device Sync permissions, users can only read and write data
// where the `Item.ownerId` property matches their own user ID.
val userId = user.id
val newItem = Item().apply {
    ownerId = userId
    itemName = "This item meets sync criteria"
    complexity = 3
}
syncRealm.write {
    // `newItem` is successfully written to the realm and synced to Atlas
    // because its data matches the subscription query (complexity <= 4)
    // and its `ownerId` field matches the user ID.
    copyToRealm(newItem)
}

Compensação de escritas

Quando a gravação não corresponde à assinatura da query ou às permissões do usuário, o Realm reverte a gravação e lança uma CompensatingWriteException.

Em mais detalhes, quando você grava dados que estão fora dos limites de uma assinatura de query ou não correspondem às permissões do usuário, ocorre o seguinte:

1. Como o domínio do cliente não tem nenhum conceito de escrita "ilegal", a escrita inicialmente é bem-sucedida até que o Realm resolva o changeset com o backend do App Services.

2. Após a sincronização, o servidor aplica as regras e permissões. O servidor determina que o usuário não tem autorização para realizar a gravação.

3. O servidor envia uma operação de reversão, chamada de "escrita compensatória", de volta ao cliente.

4. O Realm do cliente reverte a operação de escrita ilegal.

Qualquer escrita do lado do cliente em um determinado objeto entre uma escrita ilegal nesse objeto e a escrita compensatória correspondente será perdida. Na prática, isso pode parecer que a gravação foi bem-sucedida, mas o objeto "desaparece" quando o Realm sincroniza com o backend do App Services e executa a gravação compensatória.

Quando isso ocorre, você pode consultar os registros doAtlas App Services ou usar o objeto CompensatingWriteInfo no cliente para obter informações adicionais sobre o erro.

// The complexity of this item is `7`. This is outside the bounds
// of the subscription query, which triggers a compensating write.
val itemTooComplex = Item().apply {
    ownerId = user.id
    itemName = "This item is too complex"
    complexity = 7
}
syncRealm.write {
    copyToRealm(itemTooComplex)
}

[Session][CompensatingWrite(231)] Client attempted a write that is disallowed by permissions, or modifies an object outside the current query, and the server undid the change.

Error:
Client attempted a write that is outside of permissions or query filters; it has been reverted (ProtocolErrorCode=231)
Details:
{
   "Item": {
      "63bdfc40f16be7b1e8c7e4b7": "write to \"63bdfc40f16be7b1e8c7e4b7\"
      in table \"Item\" not allowed; object is outside of
      the current query view"
   }
}

// The `ownerId` of this item does not match the `user.id` of the logged-in
// user. The user does not have permissions to make this write, which
// triggers a compensating write.
val itemWithWrongOwner = Item().apply {
    ownerId = "not the current user"
    itemName = "A simple item"
    complexity = 1
}
syncRealm.write {
    copyToRealm(itemWithWrongOwner)
}

[Session][CompensatingWrite(231)] Client attempted a write that is disallowed by permissions, or modifies an object outside the current query, and the server undid the change.

Error:
Client attempted a write that is outside of permissions or query filters; it has been reverted (ProtocolErrorCode=231)
Details:
{
   "Item": {
      "63bdfc40f16be7b1e8c7e4b7": "write to \"63bdfc40f16be7b1e8c7e4b7\"
      in table \"Item\" was denied by write filter in role \"readOwnWriteOwn\""
   }
}

val syncErrorHandler = SyncSession.ErrorHandler { session, error ->
    runBlocking {
        if (error is CompensatingWriteException) {
            error.writes.forEach { writeInfo ->
                val errorMessage = """
                    A write was rejected with a compensating write error
                    The write to object type: ${writeInfo.objectType}
                    With primary key of: ${writeInfo.primaryKey}
                    Was rejected because: ${writeInfo.reason}
                    """.trimIndent()
                Log.e(errorMessage)
            }
        }
    }
}

A write was rejected with a compensating write error
The write to object type: Item
With primary key of: RealmAny{type=OBJECT_ID, value=BsonObjectId(649f2c38835cc0346b861b74)}
Was rejected because: write to "649f2c38835cc0346b861b74" in table "Item" not allowed; object is outside of the current query view