mirror of
https://github.com/Ranchero-Software/NetNewsWire.git
synced 2024-12-08 15:35:21 +01:00
248 lines
7.2 KiB
Swift
248 lines
7.2 KiB
Swift
//
|
|
// SyncStatusTable.swift
|
|
// NetNewsWire
|
|
//
|
|
// Created by Maurice Parker on 5/14/19.
|
|
// Copyright © 2019 Ranchero Software. All rights reserved.
|
|
//
|
|
|
|
import Foundation
|
|
import RSCore
|
|
import Articles
|
|
import RSDatabase
|
|
|
|
struct SyncStatusTable: DatabaseTable {
|
|
|
|
let name = DatabaseTableName.syncStatus
|
|
private let queue: DatabaseQueue
|
|
|
|
init(queue: DatabaseQueue) {
|
|
self.queue = queue
|
|
}
|
|
|
|
func selectForProcessing(limit: Int?, completion: @escaping SyncStatusesCompletionBlock) {
|
|
queue.runInTransaction { databaseResult in
|
|
var statuses = Set<SyncStatus>()
|
|
var error: DatabaseError?
|
|
|
|
func makeDatabaseCall(_ database: FMDatabase) {
|
|
let updateSQL = "update syncStatus set selected = true"
|
|
database.executeUpdate(updateSQL, withArgumentsIn: nil)
|
|
|
|
var selectSQL = "select * from syncStatus where selected == true"
|
|
if let limit = limit {
|
|
selectSQL = "\(selectSQL) limit \(limit)"
|
|
}
|
|
if let resultSet = database.executeQuery(selectSQL, withArgumentsIn: nil) {
|
|
statuses = resultSet.mapToSet(self.statusWithRow)
|
|
}
|
|
}
|
|
|
|
switch databaseResult {
|
|
case .success(let database):
|
|
makeDatabaseCall(database)
|
|
case .failure(let databaseError):
|
|
error = databaseError
|
|
}
|
|
|
|
DispatchQueue.main.async {
|
|
if let error = error {
|
|
completion(.failure(error))
|
|
}
|
|
else {
|
|
completion(.success(Array(statuses)))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func selectPendingCount(_ completion: @escaping DatabaseIntCompletionBlock) {
|
|
queue.runInDatabase { databaseResult in
|
|
var count: Int = 0
|
|
var error: DatabaseError?
|
|
|
|
func makeDatabaseCall(_ database: FMDatabase) {
|
|
let sql = "select count(*) from syncStatus"
|
|
if let resultSet = database.executeQuery(sql, withArgumentsIn: nil) {
|
|
count = self.numberWithCountResultSet(resultSet)
|
|
}
|
|
}
|
|
|
|
switch databaseResult {
|
|
case .success(let database):
|
|
makeDatabaseCall(database)
|
|
case .failure(let databaseError):
|
|
error = databaseError
|
|
}
|
|
|
|
DispatchQueue.main.async {
|
|
if let error = error {
|
|
completion(.failure(error))
|
|
}
|
|
else {
|
|
completion(.success(count))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func selectPendingReadStatusArticleIDs(completion: @escaping SyncStatusArticleIDsCompletionBlock) {
|
|
selectPendingArticleIDsAsync(.read, completion)
|
|
}
|
|
|
|
func selectPendingStarredStatusArticleIDs(completion: @escaping SyncStatusArticleIDsCompletionBlock) {
|
|
selectPendingArticleIDsAsync(.starred, completion)
|
|
}
|
|
|
|
func resetAllSelectedForProcessing(completion: DatabaseCompletionBlock? = nil) {
|
|
queue.runInTransaction { databaseResult in
|
|
|
|
func makeDatabaseCall(_ database: FMDatabase) {
|
|
let updateSQL = "update syncStatus set selected = false"
|
|
database.executeUpdate(updateSQL, withArgumentsIn: nil)
|
|
}
|
|
|
|
switch databaseResult {
|
|
case .success(let database):
|
|
makeDatabaseCall(database)
|
|
callCompletion(completion, nil)
|
|
case .failure(let databaseError):
|
|
callCompletion(completion, databaseError)
|
|
}
|
|
}
|
|
}
|
|
|
|
func resetSelectedForProcessing(_ articleIDs: [String], completion: DatabaseCompletionBlock? = nil) {
|
|
queue.runInTransaction { databaseResult in
|
|
|
|
func makeDatabaseCall(_ database: FMDatabase) {
|
|
let parameters = articleIDs.map { $0 as AnyObject }
|
|
let placeholders = NSString.rs_SQLValueList(withPlaceholders: UInt(articleIDs.count))!
|
|
let updateSQL = "update syncStatus set selected = false where articleID in \(placeholders)"
|
|
database.executeUpdate(updateSQL, withArgumentsIn: parameters)
|
|
}
|
|
|
|
switch databaseResult {
|
|
case .success(let database):
|
|
makeDatabaseCall(database)
|
|
callCompletion(completion, nil)
|
|
case .failure(let databaseError):
|
|
callCompletion(completion, databaseError)
|
|
}
|
|
}
|
|
}
|
|
|
|
func deleteSelectedForProcessing(_ articleIDs: [String], completion: DatabaseCompletionBlock? = nil) {
|
|
queue.runInTransaction { databaseResult in
|
|
|
|
func makeDatabaseCall(_ database: FMDatabase) {
|
|
let parameters = articleIDs.map { $0 as AnyObject }
|
|
let placeholders = NSString.rs_SQLValueList(withPlaceholders: UInt(articleIDs.count))!
|
|
let deleteSQL = "delete from syncStatus where selected = true and articleID in \(placeholders)"
|
|
database.executeUpdate(deleteSQL, withArgumentsIn: parameters)
|
|
}
|
|
|
|
switch databaseResult {
|
|
case .success(let database):
|
|
makeDatabaseCall(database)
|
|
callCompletion(completion, nil)
|
|
case .failure(let databaseError):
|
|
callCompletion(completion, databaseError)
|
|
}
|
|
}
|
|
}
|
|
|
|
func insertStatuses(_ statuses: [SyncStatus]) throws {
|
|
var error: DatabaseError?
|
|
queue.runInTransactionSync { databaseResult in
|
|
switch databaseResult {
|
|
case .success(let database):
|
|
let statusArray = statuses.map { $0.databaseDictionary() }
|
|
self.insertRows(statusArray, insertType: .orReplace, in: database)
|
|
case .failure(let databaseError):
|
|
error = databaseError
|
|
}
|
|
}
|
|
|
|
if let error = error {
|
|
throw error
|
|
}
|
|
}
|
|
|
|
func insertStatuses(_ statuses: [SyncStatus], completion: @escaping DatabaseCompletionBlock) {
|
|
queue.runInTransaction { databaseResult in
|
|
|
|
func makeDatabaseCall(_ database: FMDatabase) {
|
|
let statusArray = statuses.map { $0.databaseDictionary() }
|
|
self.insertRows(statusArray, insertType: .orReplace, in: database)
|
|
}
|
|
|
|
switch databaseResult {
|
|
case .success(let database):
|
|
makeDatabaseCall(database)
|
|
completion(nil)
|
|
case .failure(let databaseError):
|
|
completion(databaseError)
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
private extension SyncStatusTable {
|
|
|
|
func statusWithRow(_ row: FMResultSet) -> SyncStatus? {
|
|
guard let articleID = row.string(forColumn: DatabaseKey.articleID),
|
|
let rawKey = row.string(forColumn: DatabaseKey.key),
|
|
let key = SyncStatus.Key(rawValue: rawKey) else {
|
|
return nil
|
|
}
|
|
|
|
let flag = row.bool(forColumn: DatabaseKey.flag)
|
|
let selected = row.bool(forColumn: DatabaseKey.selected)
|
|
|
|
return SyncStatus(articleID: articleID, key: key, flag: flag, selected: selected)
|
|
}
|
|
|
|
func selectPendingArticleIDsAsync(_ statusKey: ArticleStatus.Key, _ completion: @escaping SyncStatusArticleIDsCompletionBlock) {
|
|
|
|
queue.runInDatabase { databaseResult in
|
|
|
|
func makeDatabaseCall(_ database: FMDatabase) {
|
|
let sql = "select articleID from syncStatus where selected == false and key = \"\(statusKey.rawValue)\";"
|
|
|
|
guard let resultSet = database.executeQuery(sql, withArgumentsIn: nil) else {
|
|
DispatchQueue.main.async {
|
|
completion(.success(Set<String>()))
|
|
}
|
|
return
|
|
}
|
|
|
|
let articleIDs = resultSet.mapToSet{ $0.string(forColumnIndex: 0) }
|
|
DispatchQueue.main.async {
|
|
completion(.success(articleIDs))
|
|
}
|
|
}
|
|
|
|
switch databaseResult {
|
|
case .success(let database):
|
|
makeDatabaseCall(database)
|
|
case .failure(let databaseError):
|
|
DispatchQueue.main.async {
|
|
completion(.failure(databaseError))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
private func callCompletion(_ completion: DatabaseCompletionBlock?, _ databaseError: DatabaseError?) {
|
|
guard let completion = completion else {
|
|
return
|
|
}
|
|
DispatchQueue.main.async {
|
|
completion(databaseError)
|
|
}
|
|
}
|