Offline Mode: Sync Publishing

WordPress/Classes/Models/BasePost.h

@@ -35,6 +35,8 @@ NS_ASSUME_NONNULL_BEGIN
 
 /**
  BOOL flag set to true if the post is first time published.
+
+ - note: Deprecated (kahu-offline-mode)
  */
 @property (nonatomic, assign) BOOL isFirstTimePublish;
 

WordPress/Classes/Services/PostCoordinator+Notices.swift

@@ -0,0 +1,111 @@
+import UIKit
+
+extension PostCoordinator {
+    static func makePublishSuccessNotice(for post: AbstractPost) -> Notice {
+        var message: String {
+            let title = post.titleForDisplay() ?? ""
+            if !title.isEmpty {
+                return title
+            }
+            return post.blog.displayURL as String? ?? ""
+        }
+        return Notice(title: Strings.publishSuccessTitle(for: post),
+                      message: message,
+                      feedbackType: .success,
+                      notificationInfo: makePublishSuccessNotificationInfo(for: post),
+                      actionTitle: Strings.view,
+                      actionHandler: { _ in
+            PostNoticeNavigationCoordinator.presentPostEpilogue(for: post)
+        })
+    }
+
+    private static func makePublishSuccessNotificationInfo(for post: AbstractPost) -> NoticeNotificationInfo {
+        var title: String {
+            let title = post.titleForDisplay() ?? ""
+            guard !title.isEmpty else {
+                return Strings.publishSuccessTitle(for: post)
+            }
+            return "“\(title)” \(Strings.publishSuccessTitle(for: post))"
+        }
+        var body: String {
+            post.blog.displayURL as String? ?? ""
+        }
+        return NoticeNotificationInfo(
+            identifier: UUID().uuidString,
+            categoryIdentifier: InteractiveNotificationsManager.NoteCategoryDefinition.postUploadSuccess.rawValue,
+            title: title,
+            body: body,
+            userInfo: [
+                PostNoticeUserInfoKey.postID: post.objectID.uriRepresentation().absoluteString
+            ])
+    }
+
+    static func makePublishFailureNotice(for post: AbstractPost, error: Error) -> Notice {
+        return Notice(
+            title: Strings.uploadFailed,
+            message: error.localizedDescription,
+            feedbackType: .error,
+            notificationInfo: makePublishFailureNotificationInfo(for: post, error: error)
+        )
+    }
+
+    private static func makePublishFailureNotificationInfo(for post: AbstractPost, error: Error) -> NoticeNotificationInfo {
+        var title: String {
+            let title = post.titleForDisplay() ?? ""
+            guard !title.isEmpty else {
+                return Strings.uploadFailed
+            }
+            return "“\(title)” \(Strings.uploadFailed)"
+        }
+        return NoticeNotificationInfo(
+            identifier: UUID().uuidString,
+            categoryIdentifier: nil,
+            title: title,
+            body: error.localizedDescription
+        )
+    }
+}
+
+private enum Strings {
+    static let view = NSLocalizedString("postNotice.view", value: "View", comment: "Button title. Displays a summary / sharing screen for a specific post.")
+
+    static let uploadFailed = NSLocalizedString("postNotice.uploadFailed", value: "Upload failed", comment: "A post upload failed notification.")
+
+    static func publishSuccessTitle(for post: AbstractPost, isFirstTimePublish: Bool = true) -> String {
+        switch post {
+        case let post as Post:
+            switch post.status {
+            case .draft:
+                return NSLocalizedString("postNotice.postDraftCreated", value: "Post draft uploaded", comment: "Title of notification displayed when a post has been successfully saved as a draft.")
+            case .scheduled:
+                return NSLocalizedString("postNotice.postScheduled", value: "Post scheduled", comment: "Title of notification displayed when a post has been successfully scheduled.")
+            case .pending:
+                return NSLocalizedString("postNotice.postPendingReview", value: "Post pending review", comment: "Title of notification displayed when a post has been successfully saved as a draft.")
+            default:
+                if isFirstTimePublish {
+                    return NSLocalizedString("postNotice.postPublished", value: "Post published", comment: "Title of notification displayed when a post has been successfully published.")
+                } else {
+                    return NSLocalizedString("postNotice.postUpdated", value: "Post updated", comment: "Title of notification displayed when a post has been successfully updated.")
+                }
+            }
+        case let page as Page:
+            switch page.status {
+            case .draft:
+                return NSLocalizedString("postNotice.pageDraftCreated", value: "Page draft uploaded", comment: "Title of notification displayed when a page has been successfully saved as a draft.")
+            case .scheduled:
+                return NSLocalizedString("postNotice.pageScheduled", value: "Page scheduled", comment: "Title of notification displayed when a page has been successfully scheduled.")
+            case .pending:
+                return NSLocalizedString("postNotice.pagePending", value: "Page pending review", comment: "Title of notification displayed when a page has been successfully saved as a draft.")
+            default:
+                if isFirstTimePublish {
+                    return NSLocalizedString("postNotice.pagePublished", value: "Page published", comment: "Title of notification displayed when a page has been successfully published.")
+                } else {
+                    return NSLocalizedString("postNotice.pageUpdated", value: "Page updated", comment: "Title of notification displayed when a page has been successfully updated.")
+                }
+            }
+        default:
+            assertionFailure("Unexpected post type: \(post)")
+            return ""
+        }
+    }
+}

WordPress/Classes/Services/PostCoordinator.swift

@@ -1,5 +1,6 @@
 import Aztec
 import Foundation
+import WordPressKit
 import WordPressFlux
 
 protocol PostCoordinatorDelegate: AnyObject {
@@ -15,7 +16,7 @@ class PostCoordinator: NSObject {
 
     @objc static let shared = PostCoordinator()
 
-    private let coreDataStack: CoreDataStack
+    private let coreDataStack: CoreDataStackSwift
 
     private var mainContext: NSManagedObjectContext {
         coreDataStack.mainContext
@@ -41,7 +42,7 @@ class PostCoordinator: NSObject {
          mediaCoordinator: MediaCoordinator? = nil,
          failedPostsFetcher: FailedPostsFetcher? = nil,
          actionDispatcherFacade: ActionDispatcherFacade = ActionDispatcherFacade(),
-         coreDataStack: CoreDataStack = ContextManager.sharedInstance()) {
+         coreDataStack: CoreDataStackSwift = ContextManager.sharedInstance()) {
         self.coreDataStack = coreDataStack
 
         let mainContext = self.coreDataStack.mainContext
@@ -94,6 +95,7 @@ class PostCoordinator: NSObject {
         }
     }
 
+    /// - note: Deprecated (kahu-offline-mode) (See PostCoordinator.publish)
     func publish(_ post: AbstractPost) {
         if post.status == .draft {
             post.status = .publish
@@ -109,6 +111,50 @@ class PostCoordinator: NSObject {
         save(post)
     }
 
+    /// Publishes the post according to the current settings and user capabilities.
+    ///
+    /// - warning: Before publishing, ensure that the media for the post got
+    /// uploaded. Managing media is not the responsibility of `PostRepository.`
+    ///
+    /// - warning: Work-in-progress (kahu-offline-mode)
+    @MainActor
+    func _publish(_ post: AbstractPost) async throws {
+        let parameters = PostHelper.remotePost(with: post)
+        if post.status == .draft {
+            parameters.status = PostStatusPublish
+            parameters.date = Date()
+        } else {
+            // Publish according to the currrent post settings: private, scheduled, etc.
+        }
+        do {
+            let repository = PostRepository(coreDataStack: coreDataStack)
+            let post = try await repository._upload(parameters, for: post)
+            didPublish(post)
+            show(PostCoordinator.makePublishSuccessNotice(for: post))
+        } catch {
+            show(PostCoordinator.makePublishFailureNotice(for: post, error: error))
+            throw error
+        }
+    }
+
+    @MainActor
+    private func didPublish(_ post: AbstractPost) {
+        if post.status == .publish {
+            QuickStartTourGuide.shared.complete(tour: QuickStartPublishTour(), silentlyForBlog: post.blog)
+        }
+        if post.status == .scheduled {
+            notifyNewPostScheduled()
+        } else if post.status == .publish {
+            notifyNewPostPublished()
+        }
+        SearchManager.shared.indexItem(post)
+        AppRatingUtility.shared.incrementSignificantEvent()
+    }
+
+    private func show(_ notice: Notice) {
+        actionDispatcherFacade.dispatch(NoticeAction.post(notice))
+    }
+
     func moveToDraft(_ post: AbstractPost) {
         post.status = .draft
         save(post)
@@ -233,6 +279,7 @@ class PostCoordinator: NSObject {
         Post.refreshStatus(with: coreDataStack)
     }
 
+    /// - note: Deprecated (kahu-offline-mode)
     private func upload(post: AbstractPost, forceDraftIfCreating: Bool, completion: ((Result<AbstractPost, Error>) -> ())? = nil) {
         mainService.uploadPost(post, forceDraftIfCreating: forceDraftIfCreating, success: { [weak self] uploadedPost in
             guard let uploadedPost = uploadedPost else {

WordPress/Classes/Services/PostRepository.swift

@@ -1,4 +1,5 @@
 import Foundation
+import WordPressKit
 
 final class PostRepository {
 
@@ -10,7 +11,8 @@ final class PostRepository {
     private let coreDataStack: CoreDataStackSwift
     private let remoteFactory: PostServiceRemoteFactory
 
-    init(coreDataStack: CoreDataStackSwift, remoteFactory: PostServiceRemoteFactory = PostServiceRemoteFactory()) {
+    init(coreDataStack: CoreDataStackSwift = ContextManager.shared,
+         remoteFactory: PostServiceRemoteFactory = PostServiceRemoteFactory()) {
         self.coreDataStack = coreDataStack
         self.remoteFactory = remoteFactory
     }
@@ -22,14 +24,7 @@ final class PostRepository {
     ///   - blogID: The blog that has the post.
     /// - Returns: The stored post object id.
     func getPost(withID postID: NSNumber, from blogID: TaggedManagedObjectID<Blog>) async throws -> TaggedManagedObjectID<AbstractPost> {
-        let remote = try await coreDataStack.performQuery { [remoteFactory] context in
-            let blog = try context.existingObject(with: blogID)
-            return remoteFactory.forBlog(blog)
-        }
-
-        guard let remote else {
-            throw PostRepository.Error.remoteAPIUnavailable
-        }
+        let remote = try await getRemoteService(forblogID: blogID)
 
         let remotePost: RemotePost? = try await withCheckedThrowingContinuation { continuation in
             remote.getPostWithID(
@@ -63,6 +58,65 @@ final class PostRepository {
         }
     }
 
+    /// Uploads the changes to the given post to the server and deletes the
+    /// uploaded local revision afterward. If the post doesn't have an associated
+    /// remote ID, creates a new post.
+    ///
+    /// - note: This method is a low-level primitive for syncing the latest
+    /// post date to the server.
+    ///
+    /// - warning: Before publishing, ensure that the media for the post got
+    /// uploaded. Managing media is not the responsibility of `PostRepository.`
+    ///
+    /// - warning: Work-in-progress (kahu-offline-mode)
+    ///
+    /// - parameter post: The revision of the post.
+    @MainActor
+    func _upload(_ post: AbstractPost) async throws {
+        let remotePost = PostHelper.remotePost(with: post)
+        try await _upload(remotePost, for: post)
+    }
+
+    /// Uploads the changes to the given post to the server and deletes the
+    /// uploaded local revision afterward. If the post doesn't have an associated
+    /// remote ID, creates a new post.
+    ///
+    /// - note: This method is a low-level primitive for syncing the latest
+    /// post date to the server.
+    ///
+    /// - warning: Before publishing, ensure that the media for the post got
+    /// uploaded. Managing media is not the responsibility of `PostRepository.`
+    ///
+    /// - warning: Work-in-progress (kahu-offline-mode)
+    ///
+    /// - parameter post: The revision of the post.
+    @discardableResult @MainActor
+    func _upload(_ parameters: RemotePost, for post: AbstractPost) async throws -> AbstractPost {
+        let service = try getRemoteService(for: post.blog)
+        let uploadedPost: RemotePost
+        if let postID = post.postID, postID.intValue > 0 {
+            uploadedPost = try await service.update(parameters)
+        } else {
+            uploadedPost = try await service.create(parameters)
+        }
+
+        let post = deleteRevision(for: post)
+        let context = coreDataStack.mainContext
+        PostHelper.update(post, with: uploadedPost, in: context)
+        PostService(managedObjectContext: context)
+            .updateMediaFor(post: post, success: {}, failure: { _ in })
+        ContextManager.shared.save(context)
+        return post
+    }
+
+    private func deleteRevision(for post: AbstractPost) -> AbstractPost {
+        if post.isRevision(), let original = post.original {
+            original.deleteRevision()
+            return original
+        }
+        return post
+    }
+
     /// Permanently delete the given post from local database and the post's WordPress site.
     ///
     /// - Parameter postID: Object ID of the post
@@ -229,7 +283,26 @@ final class PostRepository {
             PostHelper.update(post, with: updatedRemotePost, in: context)
         }
     }
+}
 
+private extension PostRepository {
+    func getRemoteService(forblogID blogID: TaggedManagedObjectID<Blog>) async throws -> PostServiceRemote {
+        let remote = try await coreDataStack.performQuery { [remoteFactory] context in
+            let blog = try context.existingObject(with: blogID)
+            return remoteFactory.forBlog(blog)
+        }
+        guard let remote else {
+            throw PostRepository.Error.remoteAPIUnavailable
+        }
+        return remote
+    }
+
+    func getRemoteService(for blog: Blog) throws -> PostServiceRemote {
+        guard let remote = remoteFactory.forBlog(blog) else {
+            throw PostRepository.Error.remoteAPIUnavailable
+        }
+        return remote
+    }
 }
 
 // MARK: - Posts/Pages List

WordPress/Classes/Services/PostService+UnattachedMedia.swift

@@ -1,6 +1,7 @@
 import Foundation
 
 extension PostService {
+    /// - note: Deprecated (kahu-offline-mode)
     @objc func updateMediaFor(post: AbstractPost,
                               success: @escaping () -> Void,
                               failure: @escaping (Error?) -> Void) {

WordPress/Classes/Services/PostService.h

@@ -90,6 +90,8 @@ extern const NSUInteger PostServiceDefaultNumberToSync;
         parameter, since if the input post was a revision, it will no longer exist once the upload
         succeeds.
  @param failure A failure block
+
+ - note: Deprecated (kahu-offline-mode) (see PostRepository.upload)
  */
 - (void)uploadPost:(AbstractPost *)post
            success:(nullable void (^)(AbstractPost *post))success
@@ -105,6 +107,8 @@ extern const NSUInteger PostServiceDefaultNumberToSync;
 
  Another use case of `forceDraftIfCreating` is to create the post in the background so we can
  periodically auto-save it. Again, we'd still want to create it as a `.draft` status.
+
+ - note: Deprecated (kahu-offline-mode) (see PostRepository.upload)
  */
 - (void)uploadPost:(AbstractPost *)post
 forceDraftIfCreating:(BOOL)forceDraftIfCreating

WordPress/Classes/Services/PostServiceRemote+Concurrency.swift

@@ -0,0 +1,26 @@
+import Foundation
+import WordPressKit
+
+extension PostServiceRemote {
+    func update(_ post: RemotePost) async throws -> RemotePost {
+        try await withUnsafeThrowingContinuation { continuation in
+            update(post, success: {
+                assert($0 != nil)
+                continuation.resume(returning: $0 ?? post)
+            }, failure: { error in
+                continuation.resume(throwing: error ?? URLError(.unknown))
+            })
+        }
+    }
+
+    func create(_ post: RemotePost) async throws -> RemotePost {
+        try await withUnsafeThrowingContinuation { continuation in
+            createPost(post, success: {
+                assert($0 != nil)
+                continuation.resume(returning: $0 ?? post)
+            }, failure: { error in
+                continuation.resume(throwing: error ?? URLError(.unknown))
+            })
+        }
+    }
+}