Invalidate a Note after un-approving a notification

Networking/Networking/Mapper/NoteListMapper.swift

@@ -8,6 +8,10 @@ struct NoteListMapper: Mapper {
     /// (Attempts) to convert an instance of Data into an array of Note Entities.
     ///
     func map(response: Data) throws -> [Note] {
+        let jsonString = String(data: response, encoding: .utf8)
+        print("==== raw json =====")
+        print(jsonString)
+        print("//// raw json /////")
         let decoder = JSONDecoder()
         decoder.dateDecodingStrategy = .formatted(DateFormatter.Defaults.dateTimeFormatter)
 

Networking/Networking/Model/NoteBlock.swift

@@ -50,7 +50,7 @@ extension NoteBlock: Decodable {
 
     /// Decodable Initializer.
     ///
-    public init(from decoder: Decoder) throws {
+    public init(from decoder: Decoder) throws {        
         let container = try decoder.container(keyedBy: CodingKeys.self)
 
         let media = container.failsafeDecodeIfPresent([NoteMedia].self, forKey: .media) ?? []

Networking/Networking/Remote/NotificationsRemote.swift

@@ -14,6 +14,9 @@ public class NotificationsRemote: Remote {
     ///     - completion: callback to be executed on completion.
     ///
     public func loadNotes(noteIds: [Int64]? = nil, pageSize: Int? = nil, completion: @escaping ([Note]?, Error?) -> Void) {
+        print("==== loading note with id====" )
+        print(noteIds)
+        print("//// loading note with id====" )
         let request = requestForNotifications(fields: .all, noteIds: noteIds, pageSize: pageSize)
         let mapper = NoteListMapper()
 

WooCommerce/Classes/ViewRelated/Notifications/NotificationDetailsViewController.swift

@@ -377,8 +377,9 @@ private extension NotificationDetailsViewController {
     /// Dispatches the moderation command (Approve/Unapprove, Spam, Trash) to the backend
     ///
     func moderateComment(siteID: Int, commentID: Int, doneStatus: CommentStatus, undoStatus: CommentStatus) {
-        guard let undo = moderateCommentAction(siteID: siteID, commentID: commentID, status: undoStatus, onCompletion: { (error) in
+        guard let undo = moderateCommentAction(siteID: siteID, commentID: commentID, status: undoStatus, onCompletion: { [weak self] error in
             guard let error = error else {
+                self?.invalidateNotificationCache()
                 WooAnalytics.shared.track(.notificationReviewActionSuccess)
                 return
             }
@@ -390,8 +391,9 @@ private extension NotificationDetailsViewController {
             return
         }
 
-        guard let done = moderateCommentAction(siteID: siteID, commentID: commentID, status: doneStatus, onCompletion: { (error) in
+        guard let done = moderateCommentAction(siteID: siteID, commentID: commentID, status: doneStatus, onCompletion: { [weak self] error in
             guard let error = error else {
+                self?.invalidateNotificationCache()
                 WooAnalytics.shared.track(.notificationReviewActionSuccess)
                 NotificationDetailsViewController.displayModerationCompleteNotice(newStatus: doneStatus, onUndoAction: {
                     WooAnalytics.shared.track(.notificationReviewActionUndo)
@@ -467,6 +469,32 @@ private extension NotificationDetailsViewController {
         }
         return action
     }
+
+    func invalidateNotificationCache() {
+        let noteID = note.noteId
+        print("==== starting invalidation sequence for note ", noteID)
+        print("==== body ", note.body)
+
+        let group = DispatchGroup()
+
+        group.enter()
+        let action = NotificationAction.invalidateCache(noteId: noteID) {
+            group.leave()
+        }
+        StoresManager.shared.dispatch(action)
+
+        group.enter()
+        let syncNoteAction = NotificationAction.synchronizeNotification(noteId: noteID) { error in
+            group.leave()
+        }
+
+        StoresManager.shared.dispatch(syncNoteAction)
+
+        group.notify(queue: .main) {
+            print("===== clear and update completed ")
+            //onCompletion()
+        }
+    }
 }
 
 

Yosemite/Yosemite/Actions/NotificationAction.swift

@@ -39,4 +39,8 @@ public enum NotificationAction: Action {
     ///
     case updateMultipleReadStatus(noteIds: [Int64], read: Bool, onCompletion: (Error?) -> Void)
     case updateLocalDeletedStatus(noteId: Int64, deleteInProgress: Bool, onCompletion: (Error?) -> Void)
+
+    /// Invalidates the cache for a given Notification.
+    ///
+    case invalidateCache(noteId: Int64, onCompletion: () -> Void)
 }

Yosemite/Yosemite/Stores/NotificationStore.swift

@@ -50,6 +50,8 @@ public class NotificationStore: Store {
             updateReadStatus(for: noteIds, read: read, onCompletion: onCompletion)
         case .updateLocalDeletedStatus(let noteId, let deleteInProgress, let onCompletion):
             updateDeletedStatus(noteId: noteId, deleteInProgress: deleteInProgress, onCompletion: onCompletion)
+        case .invalidateCache(let noteId, let onCompletion):
+            invalidateCache(noteId: noteId, onCompletion: onCompletion)
         }
     }
 }
@@ -127,6 +129,9 @@ private extension NotificationStore {
     ///     - onCompletion: Closure to be executed on completion.
     ///
     func synchronizeNotification(with noteId: Int64, onCompletion: @escaping (Error?) -> Void) {
+        print("==== synchronize notification ===")
+        print("starting sync with id ", noteId)
+        print("//// synchronize notification ===")
         let remote = NotificationsRemote(network: network)
 
         remote.loadNotes(noteIds: [noteId]) { notes, error in
@@ -135,6 +140,7 @@ private extension NotificationStore {
                 return
             }
 
+            print("ready to update local notes ", notes)
             self.updateLocalNotes(with: notes) {
                 onCompletion(nil)
             }
@@ -192,6 +198,12 @@ private extension NotificationStore {
             onCompletion(nil)
         }
     }
+
+    func invalidateCache(noteId: Int64, onCompletion: @escaping () -> Void) {
+        invalidateCache(for: [noteId]) {
+            onCompletion()
+        }
+    }
 }
 
 
@@ -304,7 +316,13 @@ extension NotificationStore {
         let derivedStorage = type(of: self).sharedDerivedStorage(with: storageManager)
 
         derivedStorage.perform {
+            print("===== notifications to invalidate ids =====")
+            print(noteIds)
+            print("///// notifications to invalidate ids ====")
             let notifications = noteIds.compactMap { derivedStorage.loadNotification(noteID: $0) }
+            print("===== notifications to invalidate =====")
+            print(notifications)
+            print("///// notifications to invalidate ====")
             for note in notifications {
                 note.noteHash = Int64.min
             }
@@ -314,7 +332,7 @@ extension NotificationStore {
             guard let onCompletion = onCompletion else {
                 return
             }
-
+            print("***** invalidation completed ====")
             DispatchQueue.main.async(execute: onCompletion)
         }
     }