mirror of
https://github.com/Ranchero-Software/NetNewsWire.git
synced 2024-12-12 09:26:26 +01:00
249 lines
8.0 KiB
Swift
249 lines
8.0 KiB
Swift
//
|
|
// FeedlyAccountDelegate.swift
|
|
// Account
|
|
//
|
|
// Created by Kiel Gillard on 3/9/19.
|
|
// Copyright © 2019 Ranchero Software, LLC. All rights reserved.
|
|
//
|
|
|
|
import Articles
|
|
import RSCore
|
|
import RSParser
|
|
import RSWeb
|
|
import SyncDatabase
|
|
import os.log
|
|
|
|
final class FeedlyAccountDelegate: AccountDelegate {
|
|
|
|
// TODO: Kiel, if you decide not to support OPML import you will have to disallow it in the behaviors
|
|
// See https://developer.feedly.com/v3/opml/
|
|
var behaviors: AccountBehaviors = [.disallowFeedInRootFolder]
|
|
|
|
let isOPMLImportSupported = false
|
|
|
|
var isOPMLImportInProgress = false
|
|
|
|
var server: String? {
|
|
return caller.server
|
|
}
|
|
|
|
var credentials: Credentials? {
|
|
didSet {
|
|
// https://developer.feedly.com/v3/developer/
|
|
if let devToken = ProcessInfo.processInfo.environment["FEEDLY_DEV_ACCESS_TOKEN"], !devToken.isEmpty {
|
|
caller.credentials = Credentials(type: .oauthAccessToken, username: "Developer", secret: devToken)
|
|
} else {
|
|
caller.credentials = credentials
|
|
}
|
|
}
|
|
}
|
|
|
|
var accountMetadata: AccountMetadata?
|
|
|
|
var refreshProgress = DownloadProgress(numberOfTasks: 0)
|
|
|
|
private let caller: FeedlyAPICaller
|
|
private let log = OSLog(subsystem: Bundle.main.bundleIdentifier!, category: "Feedly")
|
|
private let articleStatusCoodinator: FeedlyArticleStatusCoordinator
|
|
|
|
init(dataFolder: String, transport: Transport?, api: FeedlyAPICaller.API = .default) {
|
|
|
|
if let transport = transport {
|
|
caller = FeedlyAPICaller(transport: transport, api: api)
|
|
|
|
} else {
|
|
|
|
let sessionConfiguration = URLSessionConfiguration.default
|
|
sessionConfiguration.requestCachePolicy = .reloadIgnoringLocalCacheData
|
|
sessionConfiguration.timeoutIntervalForRequest = 60.0
|
|
sessionConfiguration.httpShouldSetCookies = false
|
|
sessionConfiguration.httpCookieAcceptPolicy = .never
|
|
sessionConfiguration.httpMaximumConnectionsPerHost = 1
|
|
sessionConfiguration.httpCookieStorage = nil
|
|
sessionConfiguration.urlCache = nil
|
|
|
|
if let userAgentHeaders = UserAgent.headers() {
|
|
sessionConfiguration.httpAdditionalHeaders = userAgentHeaders
|
|
}
|
|
|
|
let session = URLSession(configuration: sessionConfiguration)
|
|
caller = FeedlyAPICaller(transport: session, api: api)
|
|
}
|
|
|
|
articleStatusCoodinator = FeedlyArticleStatusCoordinator(dataFolderPath: dataFolder,
|
|
caller: caller,
|
|
log: log)
|
|
}
|
|
|
|
// MARK: Account API
|
|
|
|
private var syncStrategy: FeedlySyncStrategy?
|
|
|
|
func refreshAll(for account: Account, completion: @escaping (Result<Void, Error>) -> Void) {
|
|
let date = Date()
|
|
let log = self.log
|
|
let progress = refreshProgress
|
|
progress.addToNumberOfTasksAndRemaining(1)
|
|
syncStrategy?.startSync { result in
|
|
os_log(.debug, log: log, "Sync took %.3f seconds", -date.timeIntervalSinceNow)
|
|
progress.completeTask()
|
|
completion(result)
|
|
}
|
|
}
|
|
|
|
func sendArticleStatus(for account: Account, completion: @escaping (() -> Void)) {
|
|
// Ensure remote articles have the same status as they do locally.
|
|
articleStatusCoodinator.sendArticleStatus(for: account, completion: completion)
|
|
}
|
|
|
|
/// Attempts to ensure local articles have the same status as they do remotely.
|
|
/// So if the user is using another client roughly simultaneously with this app,
|
|
/// this app does its part to ensure the articles have a consistent status between both.
|
|
///
|
|
/// Feedly has no API that allows the app to fetch the identifiers of unread articles only.
|
|
/// The only way to identify unread articles is to pull all of the article data,
|
|
/// which is effectively equivalent of a full refresh.
|
|
///
|
|
/// - Parameter account: The account whose articles have a remote status.
|
|
/// - Parameter completion: Call on the main queue.
|
|
func refreshArticleStatus(for account: Account, completion: @escaping (() -> Void)) {
|
|
refreshAll(for: account) { _ in
|
|
completion()
|
|
}
|
|
}
|
|
|
|
func importOPML(for account: Account, opmlFile: URL, completion: @escaping (Result<Void, Error>) -> Void) {
|
|
let data: Data
|
|
|
|
do {
|
|
data = try Data(contentsOf: opmlFile)
|
|
} catch {
|
|
completion(.failure(error))
|
|
return
|
|
}
|
|
|
|
os_log(.debug, log: log, "Begin importing OPML...")
|
|
isOPMLImportInProgress = true
|
|
refreshProgress.addToNumberOfTasksAndRemaining(1)
|
|
|
|
caller.importOpml(data) { result in
|
|
switch result {
|
|
case .success:
|
|
os_log(.debug, log: self.log, "Import OPML done.")
|
|
self.refreshProgress.completeTask()
|
|
self.isOPMLImportInProgress = false
|
|
DispatchQueue.main.async {
|
|
completion(.success(()))
|
|
}
|
|
case .failure(let error):
|
|
os_log(.debug, log: self.log, "Import OPML failed.")
|
|
self.refreshProgress.completeTask()
|
|
self.isOPMLImportInProgress = false
|
|
DispatchQueue.main.async {
|
|
let wrappedError = AccountError.wrappedError(error: error, account: account)
|
|
completion(.failure(wrappedError))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func addFolder(for account: Account, name: String, completion: @escaping (Result<Folder, Error>) -> Void) {
|
|
caller.createCollection(named: name) { result in
|
|
switch result {
|
|
case .success(let collection):
|
|
if let folder = account.ensureFolder(with: collection.label) {
|
|
folder.externalID = collection.id
|
|
completion(.success(folder))
|
|
} else {
|
|
completion(.failure(FeedbinAccountDelegateError.invalidParameter))
|
|
}
|
|
case .failure(let error):
|
|
completion(.failure(error))
|
|
}
|
|
}
|
|
}
|
|
|
|
func renameFolder(for account: Account, with folder: Folder, to name: String, completion: @escaping (Result<Void, Error>) -> Void) {
|
|
guard let id = folder.externalID else {
|
|
completion(.failure(FeedbinAccountDelegateError.invalidParameter))
|
|
return
|
|
}
|
|
caller.renameCollection(with: id, to: name) { result in
|
|
switch result {
|
|
case .success(let collection):
|
|
folder.name = collection.label
|
|
completion(.success(()))
|
|
case .failure(let error):
|
|
completion(.failure(error))
|
|
}
|
|
}
|
|
}
|
|
|
|
func removeFolder(for account: Account, with folder: Folder, completion: @escaping (Result<Void, Error>) -> Void) {
|
|
guard let id = folder.externalID else {
|
|
completion(.failure(FeedbinAccountDelegateError.invalidParameter))
|
|
return
|
|
}
|
|
caller.deleteCollection(with: id) { result in
|
|
switch result {
|
|
case .success:
|
|
account.removeFolder(folder)
|
|
completion(.success(()))
|
|
case .failure(let error):
|
|
completion(.failure(error))
|
|
}
|
|
}
|
|
}
|
|
|
|
func createFeed(for account: Account, url: String, name: String?, container: Container, completion: @escaping (Result<Feed, Error>) -> Void) {
|
|
fatalError()
|
|
}
|
|
|
|
func renameFeed(for account: Account, with feed: Feed, to name: String, completion: @escaping (Result<Void, Error>) -> Void) {
|
|
fatalError()
|
|
}
|
|
|
|
func addFeed(for account: Account, with: Feed, to container: Container, completion: @escaping (Result<Void, Error>) -> Void) {
|
|
fatalError()
|
|
}
|
|
|
|
func removeFeed(for account: Account, with feed: Feed, from container: Container, completion: @escaping (Result<Void, Error>) -> Void) {
|
|
fatalError()
|
|
}
|
|
|
|
func moveFeed(for account: Account, with feed: Feed, from: Container, to: Container, completion: @escaping (Result<Void, Error>) -> Void) {
|
|
fatalError()
|
|
}
|
|
|
|
func restoreFeed(for account: Account, feed: Feed, container: Container, completion: @escaping (Result<Void, Error>) -> Void) {
|
|
fatalError()
|
|
}
|
|
|
|
func restoreFolder(for account: Account, folder: Folder, completion: @escaping (Result<Void, Error>) -> Void) {
|
|
fatalError()
|
|
}
|
|
|
|
func markArticles(for account: Account, articles: Set<Article>, statusKey: ArticleStatus.Key, flag: Bool) -> Set<Article>? {
|
|
|
|
let acceptedStatuses = articleStatusCoodinator.articles(articles,
|
|
for: account,
|
|
didChangeStatus: statusKey,
|
|
flag: flag)
|
|
|
|
return acceptedStatuses
|
|
}
|
|
|
|
func accountDidInitialize(_ account: Account) {
|
|
credentials = try? account.retrieveCredentials(type: .oauthAccessToken)
|
|
|
|
syncStrategy = FeedlySyncStrategy(account: account,
|
|
caller: caller,
|
|
articleStatusCoordinator: articleStatusCoodinator,
|
|
log: log)
|
|
}
|
|
|
|
static func validateCredentials(transport: Transport, credentials: Credentials, endpoint: URL?, completion: @escaping (Result<Credentials?, Error>) -> Void) {
|
|
fatalError()
|
|
}
|
|
}
|