2020-03-18 21:48:44 +01:00
|
|
|
//
|
|
|
|
// CloudKitAppDelegate.swift
|
|
|
|
// Account
|
|
|
|
//
|
|
|
|
// Created by Maurice Parker on 3/18/20.
|
|
|
|
// Copyright © 2020 Ranchero Software, LLC. All rights reserved.
|
|
|
|
//
|
|
|
|
|
|
|
|
import Foundation
|
2020-03-22 22:35:03 +01:00
|
|
|
import CloudKit
|
2020-04-11 23:45:31 +02:00
|
|
|
import SystemConfiguration
|
2020-03-22 22:35:03 +01:00
|
|
|
import os.log
|
|
|
|
import SyncDatabase
|
2024-04-03 06:43:06 +02:00
|
|
|
import Parser
|
2020-03-18 21:48:44 +01:00
|
|
|
import Articles
|
2020-04-11 00:23:39 +02:00
|
|
|
import ArticlesDatabase
|
2024-04-02 04:31:57 +02:00
|
|
|
import Web
|
2020-04-10 04:07:56 +02:00
|
|
|
import Secrets
|
2024-03-21 04:49:15 +01:00
|
|
|
import Core
|
|
|
|
import CloudKitExtras
|
2024-04-07 23:57:05 +02:00
|
|
|
import CommonErrors
|
|
|
|
import FeedFinder
|
2024-04-08 00:25:12 +02:00
|
|
|
import LocalAccount
|
2024-04-20 19:32:57 +02:00
|
|
|
import CloudKitSync
|
2020-03-18 21:48:44 +01:00
|
|
|
|
2020-05-02 17:02:58 +02:00
|
|
|
enum CloudKitAccountDelegateError: LocalizedError {
|
|
|
|
case invalidParameter
|
|
|
|
case unknown
|
|
|
|
|
|
|
|
var errorDescription: String? {
|
|
|
|
return NSLocalizedString("An unexpected CloudKit error occurred.", comment: "An unexpected CloudKit error occurred.")
|
|
|
|
}
|
2020-03-18 21:48:44 +01:00
|
|
|
}
|
|
|
|
|
2024-03-26 05:10:37 +01:00
|
|
|
@MainActor final class CloudKitAccountDelegate: AccountDelegate {
|
2020-03-18 21:48:44 +01:00
|
|
|
|
2020-03-22 22:35:03 +01:00
|
|
|
private var log = OSLog(subsystem: Bundle.main.bundleIdentifier!, category: "CloudKit")
|
|
|
|
|
|
|
|
private let database: SyncDatabase
|
|
|
|
|
|
|
|
private let container: CKContainer = {
|
|
|
|
let orgID = Bundle.main.object(forInfoDictionaryKey: "OrganizationIdentifier") as! String
|
|
|
|
return CKContainer(identifier: "iCloud.\(orgID).NetNewsWire")
|
|
|
|
}()
|
|
|
|
|
|
|
|
private let accountZone: CloudKitAccountZone
|
2020-04-01 18:46:37 +02:00
|
|
|
private let articlesZone: CloudKitArticlesZone
|
2020-03-22 22:35:03 +01:00
|
|
|
|
2024-03-25 06:42:48 +01:00
|
|
|
private let mainThreadOperationQueue = MainThreadOperationQueue()
|
2020-05-02 17:02:58 +02:00
|
|
|
|
2020-04-11 19:22:28 +02:00
|
|
|
private lazy var refresher: LocalAccountRefresher = {
|
2020-04-10 18:20:35 +02:00
|
|
|
let refresher = LocalAccountRefresher()
|
|
|
|
refresher.delegate = self
|
|
|
|
return refresher
|
|
|
|
}()
|
2020-03-22 22:35:03 +01:00
|
|
|
|
2020-04-25 22:09:03 +02:00
|
|
|
weak var account: Account?
|
|
|
|
|
2020-03-18 21:48:44 +01:00
|
|
|
let behaviors: AccountBehaviors = []
|
|
|
|
let isOPMLImportInProgress = false
|
|
|
|
|
|
|
|
let server: String? = nil
|
|
|
|
var credentials: Credentials?
|
|
|
|
var accountMetadata: AccountMetadata?
|
|
|
|
|
2020-04-02 19:00:10 +02:00
|
|
|
var refreshProgress = DownloadProgress(numberOfTasks: 0)
|
2020-04-28 19:31:53 +02:00
|
|
|
|
2020-03-22 22:35:03 +01:00
|
|
|
init(dataFolder: String) {
|
|
|
|
accountZone = CloudKitAccountZone(container: container)
|
2020-04-01 18:46:37 +02:00
|
|
|
articlesZone = CloudKitArticlesZone(container: container)
|
|
|
|
|
2024-03-14 05:50:22 +01:00
|
|
|
let databasePath = (dataFolder as NSString).appendingPathComponent("Sync.sqlite3")
|
|
|
|
database = SyncDatabase(databasePath: databasePath)
|
2020-03-22 22:35:03 +01:00
|
|
|
}
|
|
|
|
|
2024-03-27 04:49:47 +01:00
|
|
|
func receiveRemoteNotification(for account: Account, userInfo: [AnyHashable : Any]) async {
|
|
|
|
|
|
|
|
await withCheckedContinuation { continuation in
|
|
|
|
self.receiveRemoteNotification(for: account, userInfo: userInfo) {
|
|
|
|
continuation.resume()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private func receiveRemoteNotification(for account: Account, userInfo: [AnyHashable : Any], completion: @escaping () -> Void) {
|
2020-05-02 17:02:58 +02:00
|
|
|
let op = CloudKitRemoteNotificationOperation(accountZone: accountZone, articlesZone: articlesZone, userInfo: userInfo)
|
|
|
|
op.completionBlock = { mainThreadOperaion in
|
2020-03-30 09:48:25 +02:00
|
|
|
completion()
|
|
|
|
}
|
2024-03-21 17:46:40 +01:00
|
|
|
Task { @MainActor in
|
|
|
|
mainThreadOperationQueue.add(op)
|
|
|
|
}
|
2020-03-30 09:48:25 +02:00
|
|
|
}
|
|
|
|
|
2024-03-27 01:31:46 +01:00
|
|
|
func refreshAll(for account: Account) async throws {
|
|
|
|
|
2024-04-07 04:02:11 +02:00
|
|
|
guard refreshProgress.isComplete, Reachability.internetIsReachable else {
|
2020-04-11 23:45:31 +02:00
|
|
|
return
|
|
|
|
}
|
2024-04-16 06:02:35 +02:00
|
|
|
try await standardRefreshAll(for: account)
|
2020-03-18 21:48:44 +01:00
|
|
|
}
|
|
|
|
|
2024-03-27 00:50:11 +01:00
|
|
|
func syncArticleStatus(for account: Account) async throws {
|
|
|
|
|
|
|
|
try await withCheckedThrowingContinuation { continuation in
|
|
|
|
sendArticleStatus(for: account) { result in
|
|
|
|
switch result {
|
|
|
|
case .success:
|
|
|
|
self.refreshArticleStatus(for: account) { result in
|
|
|
|
switch result {
|
|
|
|
case .success:
|
|
|
|
continuation.resume()
|
|
|
|
case .failure(let error):
|
|
|
|
continuation.resume(throwing: error)
|
|
|
|
}
|
2021-04-15 21:13:15 +02:00
|
|
|
}
|
2024-03-27 00:50:11 +01:00
|
|
|
case .failure(let error):
|
|
|
|
continuation.resume(throwing: error)
|
2021-04-15 21:13:15 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2024-03-27 00:50:11 +01:00
|
|
|
|
2024-03-27 01:49:21 +01:00
|
|
|
func sendArticleStatus(for account: Account) async throws {
|
|
|
|
|
|
|
|
try await withCheckedThrowingContinuation { continuation in
|
|
|
|
self.sendArticleStatus(for: account) { result in
|
|
|
|
switch result {
|
|
|
|
case .success:
|
|
|
|
continuation.resume()
|
|
|
|
case .failure(let error):
|
|
|
|
continuation.resume(throwing: error)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private func sendArticleStatus(for account: Account, completion: @escaping ((Result<Void, Error>) -> Void)) {
|
2020-05-01 00:42:56 +02:00
|
|
|
sendArticleStatus(for: account, showProgress: false, completion: completion)
|
2020-03-18 21:48:44 +01:00
|
|
|
}
|
|
|
|
|
2024-03-27 02:00:23 +01:00
|
|
|
func refreshArticleStatus(for account: Account) async throws {
|
|
|
|
try await withCheckedThrowingContinuation { continuation in
|
|
|
|
self.refreshArticleStatus(for: account) { result in
|
|
|
|
switch result {
|
|
|
|
case .success:
|
|
|
|
continuation.resume()
|
|
|
|
case .failure(let error):
|
|
|
|
continuation.resume(throwing: error)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private func refreshArticleStatus(for account: Account, completion: @escaping ((Result<Void, Error>) -> Void)) {
|
2020-05-02 17:02:58 +02:00
|
|
|
let op = CloudKitReceiveStatusOperation(articlesZone: articlesZone)
|
2024-03-25 05:06:17 +01:00
|
|
|
op.completionBlock = { mainThreadOperation in
|
2024-03-25 05:52:30 +01:00
|
|
|
Task { @MainActor in
|
|
|
|
if mainThreadOperation.isCanceled {
|
|
|
|
completion(.failure(CloudKitAccountDelegateError.unknown))
|
|
|
|
} else {
|
|
|
|
completion(.success(()))
|
|
|
|
}
|
2020-04-01 18:46:37 +02:00
|
|
|
}
|
|
|
|
}
|
2024-03-21 17:46:40 +01:00
|
|
|
Task { @MainActor in
|
|
|
|
mainThreadOperationQueue.add(op)
|
|
|
|
}
|
2020-03-18 21:48:44 +01:00
|
|
|
}
|
|
|
|
|
2024-03-27 05:10:05 +01:00
|
|
|
func importOPML(for account: Account, opmlFile: URL) async throws {
|
|
|
|
|
2020-04-11 00:23:39 +02:00
|
|
|
guard refreshProgress.isComplete else {
|
2020-04-10 18:20:35 +02:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2024-04-15 06:36:50 +02:00
|
|
|
let opmlData = try Data(contentsOf: opmlFile)
|
2020-03-18 21:48:44 +01:00
|
|
|
let parserData = ParserData(url: opmlFile.absoluteString, data: opmlData)
|
2024-04-15 06:36:50 +02:00
|
|
|
let opmlDocument = try RSOPMLParser.parseOPML(with: parserData)
|
2020-03-18 21:48:44 +01:00
|
|
|
|
2024-04-15 06:36:50 +02:00
|
|
|
guard let opmlItems = opmlDocument.children, let rootExternalID = account.externalID else {
|
2020-03-18 21:48:44 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2020-04-01 01:10:35 +02:00
|
|
|
let normalizedItems = OPMLNormalizer.normalize(opmlItems)
|
2020-03-18 21:48:44 +01:00
|
|
|
|
2020-05-02 21:39:28 +02:00
|
|
|
refreshProgress.addToNumberOfTasksAndRemaining(1)
|
2024-04-15 06:36:50 +02:00
|
|
|
defer { refreshProgress.completeTask() }
|
|
|
|
|
|
|
|
try await accountZone.importOPML(rootExternalID: rootExternalID, items: normalizedItems)
|
|
|
|
try await standardRefreshAll(for: account)
|
2020-03-18 21:48:44 +01:00
|
|
|
}
|
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
@discardableResult
|
|
|
|
func createFeed(for account: Account, url urlString: String, name: String?, container: Container, validateFeed: Bool) async throws -> Feed {
|
2024-04-03 05:46:28 +02:00
|
|
|
|
2023-06-26 01:11:55 +02:00
|
|
|
guard let url = URL(string: urlString) else {
|
2024-04-16 06:02:35 +02:00
|
|
|
throw LocalAccountDelegateError.invalidParameter
|
2020-03-18 21:48:44 +01:00
|
|
|
}
|
|
|
|
|
2020-04-19 00:30:58 +02:00
|
|
|
let editedName = name == nil || name!.isEmpty ? nil : name
|
2020-03-29 10:43:20 +02:00
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
return try await createRSSFeed(for: account, url: url, editedName: editedName, container: container, validateFeed: validateFeed)
|
2020-03-18 21:48:44 +01:00
|
|
|
}
|
|
|
|
|
2024-03-28 01:49:09 +01:00
|
|
|
func renameFeed(for account: Account, with feed: Feed, to name: String) async throws {
|
|
|
|
|
2024-04-20 19:32:57 +02:00
|
|
|
guard let feedExternalID = feed.externalID else {
|
|
|
|
throw LocalAccountDelegateError.invalidParameter
|
|
|
|
}
|
|
|
|
|
|
|
|
refreshProgress.addTask()
|
2024-04-16 06:02:35 +02:00
|
|
|
defer { refreshProgress.completeTask() }
|
2024-03-28 01:49:09 +01:00
|
|
|
|
2020-03-30 00:53:11 +02:00
|
|
|
let editedName = name.isEmpty ? nil : name
|
2024-04-20 19:32:57 +02:00
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
do {
|
2024-04-20 19:32:57 +02:00
|
|
|
try await accountZone.renameFeed(externalID: feedExternalID, editedName: editedName)
|
2024-04-16 06:02:35 +02:00
|
|
|
feed.editedName = name
|
|
|
|
} catch {
|
|
|
|
processAccountError(account, error)
|
|
|
|
throw error
|
2020-03-30 00:53:11 +02:00
|
|
|
}
|
2020-03-18 21:48:44 +01:00
|
|
|
}
|
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
func removeFeed(for account: Account, with feed: Feed, from container: Container) async throws {
|
2024-03-28 17:28:16 +01:00
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
do {
|
|
|
|
try await removeFeedFromCloud(for: account, with: feed, from: container)
|
|
|
|
account.clearFeedMetadata(feed)
|
|
|
|
container.removeFeed(feed)
|
2024-03-28 17:28:16 +01:00
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
} catch {
|
2024-03-28 17:28:16 +01:00
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
switch error {
|
|
|
|
case CloudKitZoneError.corruptAccount:
|
|
|
|
// We got into a bad state and should remove the feed to clear up the bad data
|
2024-02-26 08:12:21 +01:00
|
|
|
account.clearFeedMetadata(feed)
|
|
|
|
container.removeFeed(feed)
|
2024-04-16 06:02:35 +02:00
|
|
|
default:
|
|
|
|
throw error
|
2020-03-29 15:52:59 +02:00
|
|
|
}
|
|
|
|
}
|
2020-03-18 21:48:44 +01:00
|
|
|
}
|
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
func moveFeed(for account: Account, with feed: Feed, from sourceContainer: Container, to destinationContainer: Container) async throws {
|
2024-04-03 05:17:03 +02:00
|
|
|
|
2024-04-20 19:32:57 +02:00
|
|
|
guard let feedExternalID = feed.externalID, let sourceContainerExternalID = sourceContainer.externalID, let destinationContainerExternalID = destinationContainer.externalID else {
|
|
|
|
throw LocalAccountDelegateError.invalidParameter
|
|
|
|
}
|
|
|
|
|
2020-04-02 19:00:10 +02:00
|
|
|
refreshProgress.addToNumberOfTasksAndRemaining(1)
|
2024-04-16 06:02:35 +02:00
|
|
|
defer { refreshProgress.completeTask() }
|
|
|
|
|
|
|
|
do {
|
2024-04-20 19:32:57 +02:00
|
|
|
try await accountZone.moveFeed(externalID: feedExternalID, from: sourceContainerExternalID, to: destinationContainerExternalID)
|
2024-04-16 06:02:35 +02:00
|
|
|
sourceContainer.removeFeed(feed)
|
|
|
|
destinationContainer.addFeed(feed)
|
|
|
|
} catch {
|
|
|
|
processAccountError(account, error)
|
|
|
|
throw error
|
2020-03-31 10:30:53 +02:00
|
|
|
}
|
2020-03-18 21:48:44 +01:00
|
|
|
}
|
|
|
|
|
2024-03-28 16:24:35 +01:00
|
|
|
func addFeed(for account: Account, with feed: Feed, to container: any Container) async throws {
|
|
|
|
|
2024-04-20 19:32:57 +02:00
|
|
|
guard let feedExternalID = feed.externalID, let containerExternalID = container.externalID else {
|
|
|
|
throw LocalAccountDelegateError.invalidParameter
|
|
|
|
}
|
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
refreshProgress.addToNumberOfTasksAndRemaining(1)
|
|
|
|
defer { refreshProgress.completeTask() }
|
2024-03-28 16:24:35 +01:00
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
do {
|
2024-04-20 19:32:57 +02:00
|
|
|
try await accountZone.addFeed(externalID: feedExternalID, to: containerExternalID)
|
2024-04-16 06:02:35 +02:00
|
|
|
container.addFeed(feed)
|
|
|
|
} catch {
|
|
|
|
processAccountError(account, error)
|
|
|
|
throw error
|
2024-03-28 16:24:35 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-03-28 01:18:17 +01:00
|
|
|
func restoreFeed(for account: Account, feed: Feed, container: any Container) async throws {
|
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
try await createFeed(for: account, url: feed.url, name: feed.editedName, container: container, validateFeed: true)
|
2020-03-18 21:48:44 +01:00
|
|
|
}
|
2024-03-28 01:18:17 +01:00
|
|
|
|
2024-03-27 06:18:48 +01:00
|
|
|
func createFolder(for account: Account, name: String) async throws -> Folder {
|
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
refreshProgress.addToNumberOfTasksAndRemaining(1)
|
|
|
|
defer { refreshProgress.completeTask() }
|
2024-03-27 06:18:48 +01:00
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
var externalID: String!
|
2024-03-27 06:18:48 +01:00
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
do {
|
|
|
|
externalID = try await accountZone.createFolder(name: name)
|
|
|
|
} catch {
|
|
|
|
processAccountError(account, error)
|
|
|
|
throw error
|
2020-03-18 21:48:44 +01:00
|
|
|
}
|
2024-03-28 01:49:09 +01:00
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
if let folder = account.ensureFolder(with: name) {
|
|
|
|
folder.externalID = externalID
|
|
|
|
return folder
|
|
|
|
} else {
|
|
|
|
throw CloudKitAccountDelegateError.invalidParameter
|
2024-03-28 01:49:09 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
func renameFolder(for account: Account, with folder: Folder, to name: String) async throws {
|
|
|
|
|
2024-04-20 19:32:57 +02:00
|
|
|
guard let folderExternalID = folder.externalID else {
|
|
|
|
throw CloudKitAccountDelegateError.invalidParameter
|
|
|
|
}
|
|
|
|
|
2020-04-02 19:00:10 +02:00
|
|
|
refreshProgress.addToNumberOfTasksAndRemaining(1)
|
2024-04-16 06:02:35 +02:00
|
|
|
defer { refreshProgress.completeTask() }
|
|
|
|
|
|
|
|
do {
|
2024-04-20 19:32:57 +02:00
|
|
|
try await accountZone.renameFolder(externalID: folderExternalID, to: name)
|
2024-04-16 06:02:35 +02:00
|
|
|
folder.name = name
|
|
|
|
} catch {
|
|
|
|
processAccountError(account, error)
|
|
|
|
throw error
|
2020-03-30 22:15:45 +02:00
|
|
|
}
|
2020-03-18 21:48:44 +01:00
|
|
|
}
|
|
|
|
|
2024-03-28 04:21:44 +01:00
|
|
|
func removeFolder(for account: Account, with folder: Folder) async throws {
|
|
|
|
|
2024-04-20 19:32:57 +02:00
|
|
|
guard let folderExternalID = folder.externalID else {
|
|
|
|
throw CloudKitAccountDelegateError.invalidParameter
|
|
|
|
}
|
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
refreshProgress.addToNumberOfTasksAndRemaining(1)
|
|
|
|
defer { refreshProgress.completeTask() }
|
2024-03-28 04:21:44 +01:00
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
do {
|
2024-04-20 19:32:57 +02:00
|
|
|
let feedExternalIDs = try await accountZone.findFeedExternalIDs(for: folderExternalID)
|
2024-04-16 06:02:35 +02:00
|
|
|
|
|
|
|
let feeds = feedExternalIDs.compactMap { account.existingFeed(withExternalID: $0) }
|
|
|
|
var errorOccurred = false
|
|
|
|
refreshProgress.addToNumberOfTasksAndRemaining(feeds.count)
|
|
|
|
|
|
|
|
for feed in feeds {
|
|
|
|
do {
|
|
|
|
try await removeFeedFromCloud(for: account, with: feed, from: folder)
|
|
|
|
} catch {
|
|
|
|
os_log(.error, log: self.log, "Remove folder, remove feed error: %@.", error.localizedDescription)
|
|
|
|
errorOccurred = true
|
2024-03-28 04:21:44 +01:00
|
|
|
}
|
2024-04-16 06:02:35 +02:00
|
|
|
refreshProgress.completeTask()
|
2024-03-28 04:21:44 +01:00
|
|
|
}
|
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
if errorOccurred {
|
|
|
|
throw CloudKitAccountDelegateError.unknown
|
|
|
|
}
|
2024-03-28 04:21:44 +01:00
|
|
|
|
2024-04-20 19:32:57 +02:00
|
|
|
try await accountZone.removeFolder(externalID: folderExternalID)
|
2024-04-16 06:02:35 +02:00
|
|
|
account.removeFolder(folder: folder)
|
2020-05-10 23:59:23 +02:00
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
} catch {
|
|
|
|
processAccountError(account, error)
|
|
|
|
throw error
|
2020-03-30 22:15:45 +02:00
|
|
|
}
|
2020-03-18 21:48:44 +01:00
|
|
|
}
|
2024-04-16 06:02:35 +02:00
|
|
|
|
2024-03-28 00:21:57 +01:00
|
|
|
func restoreFolder(for account: Account, folder: Folder) async throws {
|
|
|
|
|
2020-03-30 22:15:45 +02:00
|
|
|
guard let name = folder.name else {
|
2024-04-16 06:02:35 +02:00
|
|
|
throw CloudKitAccountDelegateError.invalidParameter
|
2020-03-30 22:15:45 +02:00
|
|
|
}
|
2024-04-16 06:02:35 +02:00
|
|
|
|
2024-02-26 08:12:21 +01:00
|
|
|
let feedsToRestore = folder.topLevelFeeds
|
2020-04-02 19:00:10 +02:00
|
|
|
refreshProgress.addToNumberOfTasksAndRemaining(1 + feedsToRestore.count)
|
2020-03-18 21:48:44 +01:00
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
do {
|
|
|
|
let externalID = try await accountZone.createFolder(name: name)
|
2024-03-27 02:48:44 +01:00
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
folder.externalID = externalID
|
|
|
|
account.addFolder(folder)
|
2024-03-27 02:48:44 +01:00
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
for feed in feedsToRestore {
|
2024-04-05 07:05:46 +02:00
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
folder.topLevelFeeds.remove(feed)
|
2024-04-05 07:05:46 +02:00
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
do {
|
|
|
|
try await self.restoreFeed(for: account, feed: feed, container: folder)
|
|
|
|
} catch {
|
|
|
|
os_log(.error, log: self.log, "Restore folder feed error: %@.", error.localizedDescription)
|
|
|
|
}
|
2024-04-05 07:05:46 +02:00
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
refreshProgress.completeTask()
|
|
|
|
}
|
2024-04-05 07:05:46 +02:00
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
account.addFolder(folder)
|
|
|
|
refreshProgress.completeTask()
|
2020-10-25 00:17:46 +02:00
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
} catch {
|
|
|
|
processAccountError(account, error)
|
|
|
|
throw error
|
|
|
|
}
|
|
|
|
}
|
2024-04-05 07:05:46 +02:00
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
func markArticles(for account: Account, articles: Set<Article>, statusKey: ArticleStatus.Key, flag: Bool) async throws {
|
2024-04-05 07:05:46 +02:00
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
let articles = try await account.update(articles: articles, statusKey: statusKey, flag: flag)
|
|
|
|
|
|
|
|
let syncStatuses = articles.map { article in
|
|
|
|
SyncStatus(articleID: article.articleID, key: SyncStatus.Key(statusKey), flag: flag)
|
|
|
|
}
|
|
|
|
|
|
|
|
try? await database.insertStatuses(syncStatuses)
|
|
|
|
if let count = try? await self.database.selectPendingCount(), count > 100 {
|
|
|
|
try await sendArticleStatus(for: account, showProgress: false)
|
2020-04-01 03:56:34 +02:00
|
|
|
}
|
2020-03-18 21:48:44 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
func accountDidInitialize(_ account: Account) {
|
2020-04-10 18:20:35 +02:00
|
|
|
self.account = account
|
|
|
|
|
2020-04-26 03:20:56 +02:00
|
|
|
accountZone.delegate = CloudKitAcountZoneDelegate(account: account, refreshProgress: refreshProgress, articlesZone: articlesZone)
|
|
|
|
articlesZone.delegate = CloudKitArticlesZoneDelegate(account: account, database: database, articlesZone: articlesZone)
|
2020-03-30 22:15:45 +02:00
|
|
|
|
2024-03-14 05:50:22 +01:00
|
|
|
Task {
|
|
|
|
try await database.resetAllSelectedForProcessing()
|
|
|
|
}
|
|
|
|
|
2020-04-04 20:33:49 +02:00
|
|
|
// Check to see if this is a new account and initialize anything we need
|
2020-03-30 22:15:45 +02:00
|
|
|
if account.externalID == nil {
|
2024-04-16 06:02:35 +02:00
|
|
|
|
|
|
|
Task {
|
|
|
|
|
|
|
|
do {
|
|
|
|
let externalID = try await accountZone.findOrCreateAccount()
|
2020-03-30 22:15:45 +02:00
|
|
|
account.externalID = externalID
|
2024-04-16 06:02:35 +02:00
|
|
|
try await self.initialRefreshAll(for: account)
|
|
|
|
} catch {
|
2020-03-30 22:15:45 +02:00
|
|
|
os_log(.error, log: self.log, "Error adding account container: %@", error.localizedDescription)
|
|
|
|
}
|
2024-04-16 06:02:35 +02:00
|
|
|
|
|
|
|
accountZone.subscribeToZoneChanges()
|
|
|
|
articlesZone.subscribeToZoneChanges()
|
2020-03-30 22:15:45 +02:00
|
|
|
}
|
|
|
|
}
|
2020-03-18 21:48:44 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
func accountWillBeDeleted(_ account: Account) {
|
2020-05-02 17:02:58 +02:00
|
|
|
accountZone.resetChangeToken()
|
|
|
|
articlesZone.resetChangeToken()
|
2020-03-18 21:48:44 +01:00
|
|
|
}
|
|
|
|
|
2024-03-27 06:34:16 +01:00
|
|
|
static func validateCredentials(transport: Transport, credentials: Credentials, endpoint: URL?, secretsProvider: SecretsProvider) async throws -> Credentials? {
|
|
|
|
|
|
|
|
return nil
|
2020-03-18 21:48:44 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// MARK: Suspend and Resume (for iOS)
|
|
|
|
|
|
|
|
func suspendNetwork() {
|
2024-03-14 05:50:22 +01:00
|
|
|
|
2020-03-18 21:48:44 +01:00
|
|
|
refresher.suspend()
|
|
|
|
}
|
|
|
|
|
|
|
|
func suspendDatabase() {
|
2024-03-14 05:50:22 +01:00
|
|
|
|
|
|
|
Task {
|
|
|
|
await database.suspend()
|
|
|
|
}
|
2020-03-18 21:48:44 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
func resume() {
|
2024-03-14 05:50:22 +01:00
|
|
|
|
2020-03-18 21:48:44 +01:00
|
|
|
refresher.resume()
|
2024-03-14 05:50:22 +01:00
|
|
|
|
|
|
|
Task {
|
|
|
|
await database.resume()
|
|
|
|
}
|
2020-03-18 21:48:44 +01:00
|
|
|
}
|
|
|
|
}
|
2020-04-02 19:00:10 +02:00
|
|
|
|
|
|
|
private extension CloudKitAccountDelegate {
|
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
func initialRefreshAll(for account: Account) async throws {
|
2020-04-26 18:26:41 +02:00
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
refreshProgress.addTask()
|
|
|
|
defer { refreshProgress.completeTask() }
|
2020-04-26 18:37:12 +02:00
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
do {
|
|
|
|
try await accountZone.fetchChangesInZone()
|
2020-04-13 11:59:41 +02:00
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
let feeds = account.flattenedFeeds()
|
|
|
|
refreshProgress.addToNumberOfTasksAndRemaining(feeds.count)
|
2020-04-13 11:59:41 +02:00
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
try await refreshArticleStatus(for: account)
|
2024-04-15 06:36:50 +02:00
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
try await combinedRefresh(account, feeds)
|
|
|
|
account.metadata.lastArticleFetchEndTime = Date()
|
|
|
|
} catch {
|
|
|
|
processAccountError(account, error)
|
|
|
|
refreshProgress.clear()
|
|
|
|
throw error
|
2024-04-15 06:36:50 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
func standardRefreshAll(for account: Account) async throws {
|
|
|
|
|
2024-02-26 08:12:21 +01:00
|
|
|
let intialFeedsCount = account.flattenedFeeds().count
|
|
|
|
refreshProgress.addToNumberOfTasksAndRemaining(3 + intialFeedsCount)
|
2020-04-02 19:00:10 +02:00
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
do {
|
2020-04-30 06:56:50 +02:00
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
try await accountZone.fetchChangesInZone()
|
|
|
|
refreshProgress.completeTask()
|
|
|
|
|
|
|
|
let feeds = account.flattenedFeeds()
|
|
|
|
refreshProgress.addToNumberOfTasksAndRemaining(feeds.count - intialFeedsCount)
|
|
|
|
|
|
|
|
try await refreshArticleStatus(for: account)
|
|
|
|
refreshProgress.completeTask()
|
|
|
|
|
|
|
|
try await combinedRefresh(account, feeds)
|
|
|
|
try await sendArticleStatus(for: account, showProgress: true)
|
|
|
|
|
|
|
|
account.metadata.lastArticleFetchEndTime = Date()
|
|
|
|
|
|
|
|
refreshProgress.clear()
|
|
|
|
|
|
|
|
} catch {
|
|
|
|
refreshProgress.completeTask()
|
|
|
|
processAccountError(account, error)
|
|
|
|
refreshProgress.clear()
|
|
|
|
throw error
|
2020-04-02 19:00:10 +02:00
|
|
|
}
|
2020-04-19 00:30:58 +02:00
|
|
|
}
|
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
func combinedRefresh(_ account: Account, _ feeds: Set<Feed>) async throws {
|
|
|
|
|
|
|
|
await refresher.refreshFeeds(feeds)
|
2020-04-19 00:30:58 +02:00
|
|
|
}
|
2021-03-19 17:13:26 +01:00
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
func createRSSFeed(for account: Account, url: URL, editedName: String?, container: Container, validateFeed: Bool) async throws -> Feed {
|
2021-03-19 17:13:26 +01:00
|
|
|
|
2024-04-20 19:32:57 +02:00
|
|
|
guard let containerExternalID = container.externalID else {
|
|
|
|
throw CloudKitAccountDelegateError.invalidParameter
|
|
|
|
}
|
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
func addDeadFeed() async throws -> Feed {
|
2021-03-19 17:13:26 +01:00
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
let feed = account.createFeed(with: editedName,
|
|
|
|
url: url.absoluteString,
|
|
|
|
feedID: url.absoluteString,
|
|
|
|
homePageURL: nil)
|
|
|
|
container.addFeed(feed)
|
|
|
|
|
|
|
|
do {
|
|
|
|
let externalID = try await accountZone.createFeed(url: url.absoluteString,
|
|
|
|
name: editedName,
|
|
|
|
editedName: nil, homePageURL: nil,
|
2024-04-20 19:32:57 +02:00
|
|
|
containerExternalID: containerExternalID)
|
2024-04-16 06:02:35 +02:00
|
|
|
feed.externalID = externalID
|
|
|
|
return feed
|
|
|
|
} catch {
|
|
|
|
container.removeFeed(feed)
|
|
|
|
throw error
|
2021-03-19 17:13:26 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
refreshProgress.addTask()
|
|
|
|
defer { refreshProgress.completeTask() }
|
2024-04-08 00:25:12 +02:00
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
var feedSpecifiers: Set<FeedSpecifier>?
|
2024-04-08 00:25:12 +02:00
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
do {
|
|
|
|
feedSpecifiers = try await FeedFinder.find(url: url)
|
|
|
|
} catch {
|
|
|
|
if validateFeed {
|
|
|
|
throw AccountError.createErrorNotFound
|
|
|
|
} else {
|
|
|
|
return try await addDeadFeed()
|
|
|
|
}
|
|
|
|
}
|
2024-04-08 00:25:12 +02:00
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
guard let feedSpecifiers, let bestFeedSpecifier = FeedSpecifier.bestFeed(in: feedSpecifiers), let url = URL(string: bestFeedSpecifier.urlString) else {
|
|
|
|
if validateFeed {
|
|
|
|
throw AccountError.createErrorNotFound
|
|
|
|
} else {
|
|
|
|
return try await addDeadFeed()
|
2020-04-19 00:30:58 +02:00
|
|
|
}
|
|
|
|
}
|
2024-04-16 06:02:35 +02:00
|
|
|
|
|
|
|
if account.hasFeed(withURL: bestFeedSpecifier.urlString) {
|
|
|
|
throw AccountError.createErrorAlreadySubscribed
|
|
|
|
}
|
|
|
|
|
|
|
|
let feed = account.createFeed(with: nil, url: url.absoluteString, feedID: url.absoluteString, homePageURL: nil)
|
|
|
|
feed.editedName = editedName
|
|
|
|
container.addFeed(feed)
|
|
|
|
|
|
|
|
guard let parsedFeed = await InitialFeedDownloader.download(url) else {
|
|
|
|
container.removeFeed(feed)
|
|
|
|
throw AccountError.createErrorNotFound
|
|
|
|
}
|
|
|
|
|
|
|
|
do {
|
|
|
|
try await account.update(feed: feed, with: parsedFeed)
|
|
|
|
|
2024-04-20 19:32:57 +02:00
|
|
|
let externalID = try await accountZone.createFeed(url: bestFeedSpecifier.urlString,
|
|
|
|
name: parsedFeed.title,
|
|
|
|
editedName: editedName,
|
|
|
|
homePageURL: parsedFeed.homePageURL,
|
|
|
|
containerExternalID: containerExternalID)
|
2024-04-16 06:02:35 +02:00
|
|
|
|
|
|
|
feed.externalID = externalID
|
|
|
|
sendNewArticlesToTheCloud(account, feed)
|
|
|
|
|
|
|
|
return feed
|
|
|
|
|
|
|
|
} catch {
|
|
|
|
container.removeFeed(feed)
|
|
|
|
throw error
|
|
|
|
}
|
2020-04-19 00:30:58 +02:00
|
|
|
}
|
|
|
|
|
2024-02-26 06:41:18 +01:00
|
|
|
func sendNewArticlesToTheCloud(_ account: Account, _ feed: Feed) {
|
2024-03-26 05:10:37 +01:00
|
|
|
|
2024-03-25 07:44:25 +01:00
|
|
|
Task { @MainActor in
|
2024-03-26 05:10:37 +01:00
|
|
|
|
2024-03-25 07:44:25 +01:00
|
|
|
do {
|
|
|
|
let articles = try await account.articles(for: .feed(feed))
|
2024-04-16 06:02:35 +02:00
|
|
|
|
|
|
|
await self.storeArticleChanges(new: articles, updated: Set<Article>(), deleted: Set<Article>())
|
|
|
|
self.refreshProgress.completeTask()
|
|
|
|
|
|
|
|
try await self.sendArticleStatus(for: account, showProgress: true)
|
|
|
|
try await self.articlesZone.fetchChangesInZone()
|
2024-03-26 05:10:37 +01:00
|
|
|
|
2024-03-25 07:44:25 +01:00
|
|
|
} catch {
|
2021-02-24 00:59:19 +01:00
|
|
|
os_log(.error, log: self.log, "CloudKit Feed send articles error: %@.", error.localizedDescription)
|
2020-04-27 23:41:45 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2024-03-25 07:44:25 +01:00
|
|
|
|
2020-04-06 09:15:28 +02:00
|
|
|
func processAccountError(_ account: Account, _ error: Error) {
|
|
|
|
if case CloudKitZoneError.userDeletedZone = error {
|
2024-02-26 08:12:21 +01:00
|
|
|
account.removeFeeds(account.topLevelFeeds)
|
2020-04-06 09:15:28 +02:00
|
|
|
for folder in account.folders ?? Set<Folder>() {
|
2024-03-28 04:21:44 +01:00
|
|
|
account.removeFolder(folder: folder)
|
2020-04-06 09:15:28 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
func storeArticleChanges(new: Set<Article>?, updated: Set<Article>?, deleted: Set<Article>?) async {
|
|
|
|
|
2020-04-30 23:58:41 +02:00
|
|
|
// New records with a read status aren't really new, they just didn't have the read article stored
|
2024-04-16 06:02:35 +02:00
|
|
|
if let new {
|
2020-04-30 23:58:41 +02:00
|
|
|
let filteredNew = new.filter { $0.status.read == false }
|
2024-04-16 06:02:35 +02:00
|
|
|
await insertSyncStatuses(articles: filteredNew, statusKey: .new, flag: true)
|
2020-05-28 23:24:10 +02:00
|
|
|
}
|
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
await insertSyncStatuses(articles: updated, statusKey: .new, flag: false)
|
|
|
|
await insertSyncStatuses(articles: deleted, statusKey: .deleted, flag: true)
|
2020-04-27 23:41:45 +02:00
|
|
|
}
|
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
func insertSyncStatuses(articles: Set<Article>?, statusKey: SyncStatus.Key, flag: Bool) async {
|
|
|
|
|
|
|
|
guard let articles, !articles.isEmpty else {
|
2020-04-27 23:41:45 +02:00
|
|
|
return
|
|
|
|
}
|
2024-04-16 06:02:35 +02:00
|
|
|
|
2020-04-27 23:41:45 +02:00
|
|
|
let syncStatuses = articles.map { article in
|
|
|
|
return SyncStatus(articleID: article.articleID, key: statusKey, flag: flag)
|
|
|
|
}
|
2024-03-26 06:14:40 +01:00
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
try? await database.insertStatuses(syncStatuses)
|
|
|
|
}
|
2024-03-26 06:14:40 +01:00
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
func sendArticleStatus(for account: Account, showProgress: Bool) async throws {
|
|
|
|
|
|
|
|
try await withCheckedThrowingContinuation { continuation in
|
|
|
|
|
|
|
|
self.sendArticleStatus(for: account, showProgress: showProgress) { result in
|
|
|
|
switch result {
|
|
|
|
case .success:
|
|
|
|
continuation.resume()
|
|
|
|
case .failure(let error):
|
|
|
|
continuation.resume(throwing: error)
|
|
|
|
}
|
|
|
|
}
|
2020-05-28 23:24:10 +02:00
|
|
|
}
|
2020-04-27 23:41:45 +02:00
|
|
|
}
|
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
private func sendArticleStatus(for account: Account, showProgress: Bool, completion: @escaping ((Result<Void, Error>) -> Void)) {
|
2020-05-02 17:02:58 +02:00
|
|
|
let op = CloudKitSendStatusOperation(account: account,
|
|
|
|
articlesZone: articlesZone,
|
|
|
|
refreshProgress: refreshProgress,
|
|
|
|
showProgress: showProgress,
|
|
|
|
database: database)
|
|
|
|
op.completionBlock = { mainThreadOperaion in
|
2024-03-25 05:52:30 +01:00
|
|
|
Task { @MainActor in
|
|
|
|
if mainThreadOperaion.isCanceled {
|
|
|
|
completion(.failure(CloudKitAccountDelegateError.unknown))
|
|
|
|
} else {
|
|
|
|
completion(.success(()))
|
|
|
|
}
|
2020-05-01 00:42:56 +02:00
|
|
|
}
|
|
|
|
}
|
2024-03-21 17:46:40 +01:00
|
|
|
Task { @MainActor in
|
|
|
|
mainThreadOperationQueue.add(op)
|
|
|
|
}
|
2020-05-01 00:42:56 +02:00
|
|
|
}
|
|
|
|
|
2020-05-11 00:10:44 +02:00
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
func removeFeedFromCloud(for account: Account, with feed: Feed, from container: Container) async throws {
|
|
|
|
|
2024-04-20 19:32:57 +02:00
|
|
|
guard let feedExternalID = feed.externalID, let containerExternalID = container.externalID else {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2024-04-16 06:02:35 +02:00
|
|
|
refreshProgress.addToNumberOfTasksAndRemaining(1)
|
|
|
|
defer { refreshProgress.completeTask() }
|
|
|
|
|
|
|
|
do {
|
2024-04-20 19:32:57 +02:00
|
|
|
try await accountZone.removeFeed(externalID: feedExternalID, from: containerExternalID)
|
2024-04-16 06:02:35 +02:00
|
|
|
|
|
|
|
try await articlesZone.deleteArticles(feedExternalID)
|
|
|
|
feed.dropConditionalGetInfo()
|
|
|
|
|
|
|
|
} catch {
|
|
|
|
self.processAccountError(account, error)
|
|
|
|
throw error
|
2020-05-11 00:10:44 +02:00
|
|
|
}
|
|
|
|
}
|
2020-04-02 19:00:10 +02:00
|
|
|
}
|
2020-04-10 18:20:35 +02:00
|
|
|
|
|
|
|
extension CloudKitAccountDelegate: LocalAccountRefresherDelegate {
|
2024-04-16 06:02:35 +02:00
|
|
|
|
2024-02-26 06:41:18 +01:00
|
|
|
func localAccountRefresher(_ refresher: LocalAccountRefresher, requestCompletedFor: Feed) {
|
2024-04-16 06:02:35 +02:00
|
|
|
|
2020-04-10 18:20:35 +02:00
|
|
|
refreshProgress.completeTask()
|
2020-05-28 23:24:10 +02:00
|
|
|
}
|
2024-04-16 06:02:35 +02:00
|
|
|
|
2020-05-28 23:24:10 +02:00
|
|
|
func localAccountRefresher(_ refresher: LocalAccountRefresher, articleChanges: ArticleChanges, completion: @escaping () -> Void) {
|
2024-04-16 06:02:35 +02:00
|
|
|
|
|
|
|
Task { @MainActor in
|
|
|
|
await storeArticleChanges(new: articleChanges.newArticles,
|
|
|
|
updated: articleChanges.updatedArticles,
|
|
|
|
deleted: articleChanges.deletedArticles)
|
|
|
|
}
|
2020-04-10 18:20:35 +02:00
|
|
|
}
|
|
|
|
}
|