336 lines
14 KiB
Swift
336 lines
14 KiB
Swift
import Combine
|
|
import Foundation
|
|
import GRDB
|
|
|
|
final class DatabaseMiddleware {
|
|
static let shared = DatabaseMiddleware()
|
|
private let database = Database.shared
|
|
private var cancellables: Set<AnyCancellable> = []
|
|
private var conversationCancellables: Set<AnyCancellable> = []
|
|
|
|
private init() {
|
|
// Database changes
|
|
ValueObservation
|
|
.tracking(Roster.fetchAll)
|
|
.publisher(in: database._db, scheduling: .immediate)
|
|
.sink { _ in
|
|
// Handle completion
|
|
} receiveValue: { rosters in
|
|
DispatchQueue.main.async {
|
|
store.dispatch(.databaseAction(.storedRostersLoaded(rosters: rosters)))
|
|
}
|
|
}
|
|
.store(in: &cancellables)
|
|
ValueObservation
|
|
.tracking(Chat.fetchAll)
|
|
.publisher(in: database._db, scheduling: .immediate)
|
|
.sink { _ in
|
|
// Handle completion
|
|
} receiveValue: { chats in
|
|
DispatchQueue.main.async {
|
|
store.dispatch(.databaseAction(.storedChatsLoaded(chats: chats)))
|
|
}
|
|
}
|
|
.store(in: &cancellables)
|
|
}
|
|
|
|
// swiftlint:disable:next function_body_length
|
|
func middleware(state _: AppState, action: AppAction) -> AnyPublisher<AppAction, Never> {
|
|
switch action {
|
|
// MARK: Accounts
|
|
case .startAction(.loadStoredAccounts):
|
|
return Future<AppAction, Never> { promise in
|
|
Task(priority: .background) { [weak self] in
|
|
guard let database = self?.database else {
|
|
promise(.success(.databaseAction(.loadingStoredAccountsFailed)))
|
|
return
|
|
}
|
|
do {
|
|
try database._db.read { db in
|
|
let accounts = try Account.fetchAll(db)
|
|
promise(.success(.databaseAction(.storedAccountsLoaded(accounts: accounts))))
|
|
}
|
|
} catch {
|
|
promise(.success(.databaseAction(.loadingStoredAccountsFailed)))
|
|
}
|
|
}
|
|
}
|
|
.eraseToAnyPublisher()
|
|
|
|
case .accountsAction(.makeAccountPermanent(let account)):
|
|
return Future<AppAction, Never> { promise in
|
|
Task(priority: .background) { [weak self] in
|
|
guard let database = self?.database else {
|
|
promise(.success(.databaseAction(.updateAccountFailed)))
|
|
return
|
|
}
|
|
do {
|
|
try database._db.write { db in
|
|
// make permanent and store to database
|
|
var acc = account
|
|
acc.isTemp = false
|
|
try acc.insert(db)
|
|
|
|
// Re-Fetch all accounts
|
|
let accounts = try Account.fetchAll(db)
|
|
|
|
// Use the accounts
|
|
promise(.success(.databaseAction(.storedAccountsLoaded(accounts: accounts))))
|
|
}
|
|
} catch {
|
|
promise(.success(.databaseAction(.updateAccountFailed)))
|
|
}
|
|
}
|
|
}
|
|
.eraseToAnyPublisher()
|
|
|
|
// MARK: Rosters
|
|
case .rostersAction(.markRosterAsLocallyDeleted(let ownerJID, let contactJID)):
|
|
return Future<AppAction, Never> { promise in
|
|
Task(priority: .background) { [weak self] in
|
|
guard let database = self?.database else {
|
|
promise(.success(.rostersAction(.rosterDeletingFailed(reason: L10n.Global.Error.genericDbError))))
|
|
return
|
|
}
|
|
do {
|
|
_ = try database._db.write { db in
|
|
try Roster
|
|
.filter(Column("bareJid") == ownerJID)
|
|
.filter(Column("contactBareJid") == contactJID)
|
|
.updateAll(db, Column("locallyDeleted").set(to: true))
|
|
}
|
|
promise(.success(.empty))
|
|
} catch {
|
|
promise(.success(.rostersAction(.rosterDeletingFailed(reason: L10n.Global.Error.genericDbError))))
|
|
}
|
|
}
|
|
}
|
|
.eraseToAnyPublisher()
|
|
|
|
case .rostersAction(.unmarkRosterAsLocallyDeleted(let ownerJID, let contactJID)):
|
|
return Future<AppAction, Never> { promise in
|
|
Task(priority: .background) { [weak self] in
|
|
guard let database = self?.database else {
|
|
promise(.success(.rostersAction(.rosterDeletingFailed(reason: L10n.Global.Error.genericDbError))))
|
|
return
|
|
}
|
|
do {
|
|
_ = try database._db.write { db in
|
|
try Roster
|
|
.filter(Column("bareJid") == ownerJID)
|
|
.filter(Column("contactBareJid") == contactJID)
|
|
.updateAll(db, Column("locallyDeleted").set(to: false))
|
|
}
|
|
promise(.success(.empty))
|
|
} catch {
|
|
promise(.success(.rostersAction(.rosterDeletingFailed(reason: L10n.Global.Error.genericDbError))))
|
|
}
|
|
}
|
|
}
|
|
.eraseToAnyPublisher()
|
|
|
|
// MARK: Chats
|
|
case .chatsAction(.createNewChat(let accountJid, let participantJid)):
|
|
return Future<AppAction, Never> { promise in
|
|
Task(priority: .background) { [weak self] in
|
|
guard let database = self?.database else {
|
|
promise(.success(.chatsAction(.chatCreationFailed(reason: L10n.Global.Error.genericDbError))))
|
|
return
|
|
}
|
|
do {
|
|
try database._db.write { db in
|
|
let chat = Chat(
|
|
id: UUID().uuidString,
|
|
account: accountJid,
|
|
participant: participantJid,
|
|
type: .chat
|
|
)
|
|
try chat.insert(db)
|
|
promise(.success(.chatsAction(.chatCreated(chat: chat))))
|
|
}
|
|
} catch {
|
|
promise(.success(.chatsAction(.chatCreationFailed(reason: L10n.Global.Error.genericDbError))))
|
|
}
|
|
}
|
|
}
|
|
.eraseToAnyPublisher()
|
|
|
|
// MARK: Conversation and messages
|
|
case .conversationAction(.makeConversationActive(let chat, _)):
|
|
subscribeToMessages(chat: chat)
|
|
return Empty().eraseToAnyPublisher()
|
|
|
|
case .xmppAction(.xmppMessageReceived(let message)):
|
|
return Future<AppAction, Never> { promise in
|
|
Task(priority: .background) { [weak self] in
|
|
guard let database = self?.database else {
|
|
promise(.success(.databaseAction(.storeMessageFailed(reason: L10n.Global.Error.genericDbError))))
|
|
return
|
|
}
|
|
guard message.contentType != .typing, message.body != nil else {
|
|
promise(.success(.empty))
|
|
return
|
|
}
|
|
do {
|
|
try database._db.write { db in
|
|
try message.insert(db)
|
|
}
|
|
if let remoteUrl = message.oobUrl {
|
|
let attachment = Attachment(
|
|
id: UUID().uuidString,
|
|
type: remoteUrl.attachmentType,
|
|
localPath: nil,
|
|
remotePath: URL(string: remoteUrl),
|
|
localThumbnailPath: nil,
|
|
messageId: message.id
|
|
)
|
|
try database._db.write { db in
|
|
try attachment.insert(db)
|
|
try Message
|
|
.filter(Column("id") == message.id)
|
|
.updateAll(db, [Column("attachmentId").set(to: attachment.id)])
|
|
}
|
|
}
|
|
promise(.success(.empty))
|
|
} catch {
|
|
promise(.success(.databaseAction(.storeMessageFailed(reason: error.localizedDescription))))
|
|
}
|
|
}
|
|
}
|
|
.eraseToAnyPublisher()
|
|
|
|
case .conversationAction(.sendMessage(let from, let to, let body)):
|
|
return Future<AppAction, Never> { promise in
|
|
Task(priority: .background) { [weak self] in
|
|
guard let database = self?.database else {
|
|
promise(.success(.databaseAction(.storeMessageFailed(reason: L10n.Global.Error.genericDbError))))
|
|
return
|
|
}
|
|
do {
|
|
let message = Message(
|
|
id: UUID().uuidString,
|
|
type: .chat,
|
|
contentType: .text,
|
|
from: from,
|
|
to: to,
|
|
body: body,
|
|
subject: nil,
|
|
thread: nil,
|
|
oobUrl: nil,
|
|
date: Date(),
|
|
pending: true,
|
|
sentError: false
|
|
)
|
|
try database._db.write { db in
|
|
try message.insert(db)
|
|
}
|
|
promise(.success(.xmppAction(.xmppMessageSent(message))))
|
|
} catch {
|
|
promise(.success(.databaseAction(.storeMessageFailed(reason: error.localizedDescription))))
|
|
}
|
|
}
|
|
}
|
|
.eraseToAnyPublisher()
|
|
|
|
case .xmppAction(.xmppMessageSendSuccess(let msgId)):
|
|
// mark message as pending false and sentError false
|
|
return Future<AppAction, Never> { promise in
|
|
Task(priority: .background) { [weak self] in
|
|
guard let database = self?.database else {
|
|
promise(.success(.databaseAction(.storeMessageFailed(reason: L10n.Global.Error.genericDbError))))
|
|
return
|
|
}
|
|
do {
|
|
_ = try database._db.write { db in
|
|
try Message
|
|
.filter(Column("id") == msgId)
|
|
.updateAll(db, Column("pending").set(to: false), Column("sentError").set(to: false))
|
|
}
|
|
promise(.success(.empty))
|
|
} catch {
|
|
promise(.success(.databaseAction(.storeMessageFailed(reason: error.localizedDescription)))
|
|
)
|
|
}
|
|
}
|
|
}
|
|
.eraseToAnyPublisher()
|
|
|
|
case .xmppAction(.xmppMessageSendFailed(let msgId)):
|
|
// mark message as pending false and sentError true
|
|
return Future<AppAction, Never> { promise in
|
|
Task(priority: .background) { [weak self] in
|
|
guard let database = self?.database else {
|
|
promise(.success(.databaseAction(.storeMessageFailed(reason: L10n.Global.Error.genericDbError))))
|
|
return
|
|
}
|
|
do {
|
|
_ = try database._db.write { db in
|
|
try Message
|
|
.filter(Column("id") == msgId)
|
|
.updateAll(db, Column("pending").set(to: false), Column("sentError").set(to: true))
|
|
}
|
|
promise(.success(.empty))
|
|
} catch {
|
|
promise(.success(.databaseAction(.storeMessageFailed(reason: error.localizedDescription)))
|
|
)
|
|
}
|
|
}
|
|
}
|
|
.eraseToAnyPublisher()
|
|
|
|
default:
|
|
return Empty().eraseToAnyPublisher()
|
|
}
|
|
}
|
|
}
|
|
|
|
private extension DatabaseMiddleware {
|
|
func subscribeToMessages(chat: Chat) {
|
|
conversationCancellables = []
|
|
ValueObservation
|
|
.tracking(
|
|
Message
|
|
.filter(
|
|
(Column("to") == chat.account && Column("from") == chat.participant) ||
|
|
(Column("from") == chat.account && Column("to") == chat.participant)
|
|
)
|
|
.order(Column("date").desc)
|
|
.including(optional: Message.attachment)
|
|
.fetchAll
|
|
)
|
|
.publisher(in: database._db, scheduling: .immediate)
|
|
.sink { _ in
|
|
} receiveValue: { messages in
|
|
var attachments: [Attachment] = []
|
|
for message in messages {
|
|
do {
|
|
try self.database._db.read { db in
|
|
if let attachment = try message.attachment.fetchOne(db) {
|
|
attachments.append(attachment)
|
|
}
|
|
}
|
|
} catch {
|
|
print("Failed to fetch attachment for message \(message.id): \(error)")
|
|
}
|
|
}
|
|
DispatchQueue.main.async {
|
|
store.dispatch(.conversationAction(.messagesUpdated(messages: messages)))
|
|
store.dispatch(.conversationAction(.attachmentsUpdated(attachments: attachments)))
|
|
}
|
|
}
|
|
.store(in: &conversationCancellables)
|
|
}
|
|
}
|
|
|
|
// try db.write { db in
|
|
// // Update the attachment
|
|
// var attachment = try Attachment.fetchOne(db, key: attachmentId)!
|
|
// attachment.someField = newValue
|
|
// try attachment.update(db)
|
|
//
|
|
// // Update the message
|
|
// var message = try Message.fetchOne(db, key: messageId)!
|
|
// message.someField = newValue
|
|
// try message.update(db)
|
|
// }
|