Added fallback method for out-of-sync response

Author: amandli-ks

KeeperSdk/vault/KeeperNSFFunctions.cs

@@ -470,6 +470,18 @@ public static async Task UpdateKeeperNSFRecordInternal(this VaultOnline vault, s
             if (!vault.TryGetKeeperNSFRecord(recordUid, out var record))
                 throw new VaultException($"Keeper NSF record '{recordUid}' not found");
 
+            await vault.UpdateKeeperNSFRecordInternal(record, title, recordType, notes, fields).ConfigureAwait(false);
+        }
+
+        public static async Task UpdateKeeperNSFRecordInternal(this VaultOnline vault, KeeperNSFRecord record, string title, string recordType, string notes, IDictionary<string, object> fields)
+        {
+            if (record == null)
+                throw new ArgumentNullException(nameof(record));
+
+            var recordUid = record.RecordUid;
+            if (string.IsNullOrEmpty(recordUid))
+                throw new VaultException("Record UID cannot be empty");
+
             if (record.RecordKey == null)
                 throw new VaultException($"Record key not available for record '{recordUid}'");
 
@@ -529,7 +541,13 @@ public static async Task UpdateKeeperNSFRecordInternal(this VaultOnline vault, s
                 var result = rs.Records[0];
                 if (result.Status != RecordModifyResult.RsSuccess)
                 {
-                    throw new VaultException($"Failed to update record: {result.Message}");
+                    var status = Enum.GetName(typeof(RecordModifyResult), result.Status) ?? "";
+                    if (status.StartsWith("Rs", StringComparison.Ordinal))
+                    {
+                        status = status.Substring(2);
+                    }
+
+                    throw new KeeperApiException(status.ToSnakeCase(), result.Message ?? "Failed to update record");
                 }
             }
         }
@@ -1062,35 +1080,7 @@ private static string GetFolderName(VaultOnline vault, string folderUid)
         public static async Task<KeeperNSFRecordDetailsResult> GetKeeperNSFRecordDetailsInternal(
             this VaultOnline vault, IReadOnlyList<string> recordUids)
         {
-            if (recordUids == null || recordUids.Count == 0)
-            {
-                throw new KeeperInvalidParameter("GetKeeperNSFRecordDetails", nameof(recordUids), "", "at least one record UID required");
-            }
-
-            var request = new RecordDetailsProto.RecordDataRequest
-            {
-                ClientTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
-            };
-
-            foreach (var uid in recordUids.Where(u => !string.IsNullOrWhiteSpace(u)))
-            {
-                var uidBytes = uid.Trim().Base64UrlDecode();
-                if (uidBytes == null || uidBytes.Length == 0)
-                {
-                    Trace.TraceWarning($"KeeperNSF: Skipping record details request with malformed UID '{uid}'");
-                    continue;
-                }
-
-                request.RecordUids.Add(ByteString.CopyFrom(uidBytes));
-            }
-
-            if (request.RecordUids.Count == 0)
-            {
-                throw new KeeperInvalidParameter("GetKeeperNSFRecordDetails", nameof(recordUids), "", "no valid record UIDs");
-            }
-
-            var response = await vault.Auth.ExecuteAuthRest<RecordDetailsProto.RecordDataRequest, RecordDetailsProto.RecordDataResponse>(
-                "vault/records/v3/details/data", request).ConfigureAwait(false);
+            var response = await vault.FetchKeeperNSFRecordDetailsDataAsync(recordUids).ConfigureAwait(false);
 
             var result = new KeeperNSFRecordDetailsResult();
             foreach (var forbiddenUid in response.ForbiddenRecords)
@@ -1129,6 +1119,98 @@ public static async Task<KeeperNSFRecordDetailsResult> GetKeeperNSFRecordDetails
             return result;
         }
 
+        private static async Task<RecordDetailsProto.RecordDataResponse> FetchKeeperNSFRecordDetailsDataAsync(
+            this VaultOnline vault, IReadOnlyList<string> recordUids)
+        {
+            if (recordUids == null || recordUids.Count == 0)
+            {
+                throw new KeeperInvalidParameter("GetKeeperNSFRecordDetails", nameof(recordUids), "", "at least one record UID required");
+            }
+
+            var request = new RecordDetailsProto.RecordDataRequest
+            {
+                ClientTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
+            };
+
+            foreach (var uid in recordUids.Where(u => !string.IsNullOrWhiteSpace(u)))
+            {
+                var uidBytes = uid.Trim().Base64UrlDecode();
+                if (uidBytes == null || uidBytes.Length == 0)
+                {
+                    Trace.TraceWarning($"KeeperNSF: Skipping record details request with malformed UID '{uid}'");
+                    continue;
+                }
+
+                request.RecordUids.Add(ByteString.CopyFrom(uidBytes));
+            }
+
+            if (request.RecordUids.Count == 0)
+            {
+                throw new KeeperInvalidParameter("GetKeeperNSFRecordDetails", nameof(recordUids), "", "no valid record UIDs");
+            }
+
+            return await vault.Auth.ExecuteAuthRest<RecordDetailsProto.RecordDataRequest, RecordDetailsProto.RecordDataResponse>(
+                "vault/records/v3/details/data", request).ConfigureAwait(false);
+        }
+
+        internal static async Task<KeeperNSFRecord> GetRefreshedKeeperNSFRecordAsync(this VaultOnline vault, string recordUid)
+        {
+            if (string.IsNullOrWhiteSpace(recordUid))
+                return null;
+
+            var trimmedUid = recordUid.Trim();
+            var response = await vault.FetchKeeperNSFRecordDetailsDataAsync(new[] { trimmedUid }).ConfigureAwait(false);
+
+            var recordData = (response.Data ?? Enumerable.Empty<Records.RecordData>())
+                .FirstOrDefault(x =>
+                {
+                    if (x.RecordUid == null || x.RecordUid.IsEmpty)
+                        return false;
+                    var uid = CryptoUtils.Base64UrlEncode(x.RecordUid.ToByteArray());
+                    return string.Equals(uid, trimmedUid, StringComparison.OrdinalIgnoreCase);
+                });
+
+            return recordData != null && TryBuildKeeperNSFRecordFromDetailsData(vault, recordData, trimmedUid, out var record)
+                ? record
+                : null;
+        }
+
+        private static bool TryBuildKeeperNSFRecordFromDetailsData(
+            VaultOnline vault, Records.RecordData recordData, string recordUid, out KeeperNSFRecord record)
+        {
+            record = null;
+            if (recordData == null || string.IsNullOrWhiteSpace(recordUid))
+                return false;
+
+            if (!TryDecryptKeeperNSFRecordDetailsData(vault, recordData, recordUid, out var data))
+                return false;
+
+            var recordKey = TryDecryptKeeperNSFRecordKeyFromDetails(vault, recordData, recordUid);
+            if (recordKey == null || recordKey.Length == 0)
+                return false;
+
+            vault.TryGetKeeperNSFRecord(recordUid, out var cached);
+
+            record = new KeeperNSFRecord
+            {
+                RecordUid = recordUid,
+                Title = !string.IsNullOrEmpty(data?.Title) ? data.Title : data?.Name,
+                Type = data?.Type,
+                Notes = data?.Notes,
+                Revision = recordData.Revision,
+                Version = recordData.Version,
+                Shared = cached?.Shared ?? false,
+                ClientModifiedTime = cached?.ClientModifiedTime ?? 0,
+                FileSize = cached?.FileSize ?? 0,
+                ThumbnailSize = cached?.ThumbnailSize ?? 0,
+                FolderUid = cached?.FolderUid,
+                FolderName = cached?.FolderName,
+                RecordKey = recordKey,
+                Data = data,
+            };
+            return true;
+        }
+
         private static void ResolveKeeperNSFRecordTitleAndType(KeeperNSFRecord record, out string title, out string type)
         {
             if (!string.IsNullOrEmpty(record?.Type))

KeeperSdk/vault/VaultOnline.cs

@@ -186,10 +186,63 @@ public Task<KeeperRecord> CreateRecord(KeeperRecord record, string folderUid = n
             return this.AddRecordToFolder(record, folderUid);
         }
 
+        /// <inheritdoc/>
+        public async Task<TryUpdateRecordResult> TryUpdateRecord(KeeperRecord record, bool skipExtra = true)
+        {
+            try
+            {
+                var recordUpdated = await this.PutRecord(record, skipExtra).ConfigureAwait(false);
+                return new TryUpdateRecordResult(true, recordUpdated, null);
+            }
+            catch (Exception e)
+            {
+                return new TryUpdateRecordResult(false, null, FormatUpdateErrorReason(e));
+            }
+        }
+
         /// <inheritdoc/>
         public Task<KeeperRecord> UpdateRecord(KeeperRecord record, bool skipExtra = true)
         {
-            return this.PutRecord(record, skipExtra);
+            return UpdateRecordAsync(record, skipExtra);
+        }
+
+        private async Task<KeeperRecord> UpdateRecordAsync(KeeperRecord record, bool skipExtra)
+        {
+            try
+            {
+                return await this.PutRecord(record, skipExtra).ConfigureAwait(false);
+            }
+            catch (KeeperApiException e) when (IsRecordOutOfSync(e))
+            {
+                if (string.IsNullOrEmpty(record?.Uid))
+                {
+                    throw;
+                }
+
+                var refreshed = await RecordSkipSyncDown
+                    .GetOwnedRecordsAsync(Auth, new[] { record.Uid })
+                    .ConfigureAwait(false);
+                if (refreshed.Records.Count == 0)
+                {
+                    throw;
+                }
+
+                var refreshedRecord = refreshed.Records[0];
+                return await this.PutRecord(refreshedRecord, skipExtra).ConfigureAwait(false);
+            }
+        }
+
+        private static bool IsRecordOutOfSync(KeeperApiException e)
+        {
+            return string.Equals(e.Code, "out_of_sync", StringComparison.OrdinalIgnoreCase)
+                || string.Equals(e.Code, "RS_OUT_OF_SYNC", StringComparison.OrdinalIgnoreCase);
+        }
+
+        private static string FormatUpdateErrorReason(Exception e)
+        {
+            return e is KeeperApiException kae && !string.IsNullOrEmpty(kae.Code)
+                ? $"{kae.Code}: {kae.Message}"
+                : e.Message;
         }
 
         /// <inheritdoc/>
@@ -363,13 +416,50 @@ public async Task<string> CreateKeeperNSFRecord(string title, string recordType
             return recordUid;
         }
 
+        /// <inheritdoc/>
+        public async Task<TryUpdateKeeperNSFRecordResult> TryUpdateKeeperNSFRecord(string recordUid, string title = null, string recordType = null, string notes = null, IDictionary<string, object> fields = null)
+        {
+            try
+            {
+                await this.UpdateKeeperNSFRecordInternal(recordUid, title, recordType, notes, fields).ConfigureAwait(false);
+                return new TryUpdateKeeperNSFRecordResult(true, recordUid, null);
+            }
+            catch (Exception e)
+            {
+                return new TryUpdateKeeperNSFRecordResult(false, null, FormatUpdateErrorReason(e));
+            }
+        }
+
         /// <inheritdoc/>
         public async Task UpdateKeeperNSFRecord(string recordUid, string title = null, string recordType = null, string notes = null, IDictionary<string, object> fields = null)
         {
-            await this.UpdateKeeperNSFRecordInternal(recordUid, title, recordType, notes, fields);
+            await UpdateKeeperNSFRecordAsync(recordUid, title, recordType, notes, fields).ConfigureAwait(false);
             await ScheduleSyncDown(TimeSpan.FromMilliseconds(100));
         }
 
+        private async Task UpdateKeeperNSFRecordAsync(string recordUid, string title, string recordType, string notes, IDictionary<string, object> fields)
+        {
+            try
+            {
+                await this.UpdateKeeperNSFRecordInternal(recordUid, title, recordType, notes, fields).ConfigureAwait(false);
+            }
+            catch (KeeperApiException e) when (IsRecordOutOfSync(e))
+            {
+                if (string.IsNullOrEmpty(recordUid))
+                {
+                    throw;
+                }
+
+                var refreshedRecord = await this.GetRefreshedKeeperNSFRecordAsync(recordUid).ConfigureAwait(false);
+                if (refreshedRecord == null)
+                {
+                    throw;
+                }
+
+                await this.UpdateKeeperNSFRecordInternal(refreshedRecord, title, recordType, notes, fields).ConfigureAwait(false);
+            }
+        }
+
         /// <inheritdoc/>
         public async Task ShareKeeperNSFRecord(string recordUid, string userEmail, string role = "viewer")
         {

KeeperSdk/vault/VaultTypes.cs

@@ -384,6 +384,14 @@ public interface IVault : IVaultData
         /// <exception cref="Authentication.KeeperApiException"></exception>
         Task<KeeperRecord> UpdateRecord(KeeperRecord record, bool skipExtra = true);
 
+        /// <summary>
+        /// Attempts to modify a password record without throwing.
+        /// </summary>
+        /// <param name="record">Keeper Record.</param>
+        /// <param name="skipExtra">Do not update file attachment information on the record.</param>
+        /// <returns>A task returning success with the updated record, or failure with an error reason.</returns>
+        Task<TryUpdateRecordResult> TryUpdateRecord(KeeperRecord record, bool skipExtra = true);
+
         /// <summary>
         /// Modifies multiple password records.
         /// </summary>
@@ -519,6 +527,17 @@ Task<FolderNode> CreateFolder(string name, string parentFolderUid = null,
         /// <param name="fields">Fields to add or update. Values may be strings (plain scalars) or complex objects (e.g. host = { hostName, port } on a databaseCredentials record).</param>
         Task UpdateKeeperNSFRecord(string recordUid, string title = null, string recordType = null, string notes = null, IDictionary<string, object> fields = null);
 
+        /// <summary>
+        /// Attempts to update a Keeper NSF record without throwing.
+        /// </summary>
+        /// <param name="recordUid">Record UID to update.</param>
+        /// <param name="title">New title (null to keep existing).</param>
+        /// <param name="recordType">New record type (null to keep existing).</param>
+        /// <param name="notes">New notes (null to keep existing).</param>
+        /// <param name="fields">Fields to add or update.</param>
+        /// <returns>A task returning success with the record UID, or failure with an error reason.</returns>
+        Task<TryUpdateKeeperNSFRecordResult> TryUpdateKeeperNSFRecord(string recordUid, string title = null, string recordType = null, string notes = null, IDictionary<string, object> fields = null);
+
         /// <summary>
         /// Grants a user access to a Keeper NSF record by sharing the record key.
         /// </summary>
@@ -1148,6 +1167,52 @@ public VaultException(string message) : base(message)
         }
     }
 
+    /// <summary>
+    /// Result of <see cref="IVault.TryUpdateRecord"/>.
+    /// </summary>
+    public sealed class TryUpdateRecordResult
+    {
+        /// <exclude/>
+        public TryUpdateRecordResult(bool success, KeeperRecord record, string reason)
+        {
+            Success = success;
+            Record = record;
+            Reason = reason;
+        }
+
+        /// <summary><c>true</c> when the record was updated successfully.</summary>
+        public bool Success { get; }
+
+        /// <summary>Updated record when <see cref="Success"/> is <c>true</c>.</summary>
+        public KeeperRecord Record { get; }
+
+        /// <summary>Error reason when <see cref="Success"/> is <c>false</c>.</summary>
+        public string Reason { get; }
+    }
+
+    /// <summary>
+    /// Result of <see cref="IVault.TryUpdateKeeperNSFRecord"/>.
+    /// </summary>
+    public sealed class TryUpdateKeeperNSFRecordResult
+    {
+        /// <exclude/>
+        public TryUpdateKeeperNSFRecordResult(bool success, string recordUid, string reason)
+        {
+            Success = success;
+            RecordUid = recordUid;
+            Reason = reason;
+        }
+
+        /// <summary><c>true</c> when the record was updated successfully.</summary>
+        public bool Success { get; }
+
+        /// <summary>Updated record UID when <see cref="Success"/> is <c>true</c>.</summary>
+        public string RecordUid { get; }
+
+        /// <summary>Error reason when <see cref="Success"/> is <c>false</c>.</summary>
+        public string Reason { get; }
+    }
+
     /// <summary>
     /// Result of <see cref="RecordSkipSyncDown.GetOwnedRecordsAsync"/> or <see cref="RecordSkipSyncDown.GetSharedFolderRecordsAsync"/> (both call <c>vault/get_records_details</c>).
     /// </summary>