1
0
mirror of https://github.com/mastodon/mastodon-ios.git synced 2024-12-08 22:56:41 +01:00
mastodon-app-ufficiale-ipho.../MastodonSDK/Sources/MastodonCore/Service/AuthenticationService.swift

163 lines
5.7 KiB
Swift
Raw Normal View History

2021-02-03 09:01:08 +01:00
//
// AuthenticationService.swift
// Mastodon
//
// Created by MainasuK Cirno on 2021/2/3.
//
import Foundation
import Combine
import CoreData
import CoreDataStack
import MastodonSDK
private typealias IterativeResponse = (ids: [String], maxID: String?)
public final class AuthenticationService: NSObject {
2021-02-03 09:01:08 +01:00
var disposeBag = Set<AnyCancellable>()
2021-02-03 09:01:08 +01:00
// input
weak var apiService: APIService?
let managedObjectContext: NSManagedObjectContext // read-only
let backgroundManagedObjectContext: NSManagedObjectContext
let authenticationServiceProvider = AuthenticationServiceProvider.shared
2021-02-03 09:01:08 +01:00
// output
@Published public var mastodonAuthenticationBoxes: [MastodonAuthenticationBox] = []
private func fetchFollowedBlockedUserIds(
_ authBox: MastodonAuthenticationBox,
_ previousFollowingIDs: [String]? = nil,
_ maxID: String? = nil
) async throws {
guard let apiService else { return }
let followingResponse = try await fetchFollowing(maxID, apiService, authBox)
let followingIds = (previousFollowingIDs ?? []) + followingResponse.ids
if let nextMaxID = followingResponse.maxID {
return try await fetchFollowedBlockedUserIds(authBox, followingIds, nextMaxID)
}
let blockedIds = try await apiService.getBlocked(
authenticationBox: authBox
).value.map { $0.id }
let followRequestIds = try await apiService.pendingFollowRequest(userID: authBox.userID,
authenticationBox: authBox)
.value.map { $0.id }
authBox.inMemoryCache.followRequestedUserIDs = followRequestIds
authBox.inMemoryCache.followingUserIds = followingIds
authBox.inMemoryCache.blockedUserIds = blockedIds
}
private func fetchFollowing(
_ maxID: String?,
_ apiService: APIService,
_ mastodonAuthenticationBox: MastodonAuthenticationBox
) async throws -> IterativeResponse {
let response = try await apiService.following(
userID: mastodonAuthenticationBox.userID,
maxID: maxID,
authenticationBox: mastodonAuthenticationBox
)
let ids: [String] = response.value.map { $0.id }
let maxID: String? = response.link?.maxID
return (ids, maxID)
}
public func fetchFollowingAndBlockedAsync() {
/// We're dispatching this as a separate async call to not block the caller
/// Also we'll only be updating the current active user as the state will be reflesh upon user-change anyways
Task {
if let authBox = mastodonAuthenticationBoxes.first {
2023-05-09 16:16:31 +02:00
do { try await fetchFollowedBlockedUserIds(authBox) }
catch {}
}
}
}
public let updateActiveUserAccountPublisher = PassthroughSubject<Void, Never>()
2021-02-03 09:01:08 +01:00
init(
managedObjectContext: NSManagedObjectContext,
backgroundManagedObjectContext: NSManagedObjectContext,
apiService: APIService
) {
self.managedObjectContext = managedObjectContext
self.backgroundManagedObjectContext = backgroundManagedObjectContext
self.apiService = apiService
super.init()
$mastodonAuthenticationBoxes
.throttle(for: 3, scheduler: DispatchQueue.main, latest: true)
.sink { [weak self] boxes in
Task { [weak self] in
for authBox in boxes {
do { try await self?.fetchFollowedBlockedUserIds(authBox) }
catch {}
}
}
}
.store(in: &disposeBag)
2021-02-03 09:01:08 +01:00
// TODO: verify credentials for active authentication
authenticationServiceProvider.$authentications
.map { authentications -> [MastodonAuthenticationBox] in
return authentications
.sorted(by: { $0.activedAt > $1.activedAt })
.compactMap { authentication -> MastodonAuthenticationBox? in
return MastodonAuthenticationBox(authentication: authentication)
}
2021-02-03 09:01:08 +01:00
}
.assign(to: &$mastodonAuthenticationBoxes)
2023-06-02 11:10:29 +02:00
AuthenticationServiceProvider.shared.authentications = AuthenticationServiceProvider.shared.authenticationSortedByActivation()
2021-02-03 09:01:08 +01:00
}
}
extension AuthenticationService {
public func activeMastodonUser(domain: String, userID: String) async throws -> Bool {
var isActive = false
2021-02-03 09:01:08 +01:00
AuthenticationServiceProvider.shared.activateAuthentication(in: domain, for: userID)
isActive = true
return isActive
2021-02-03 09:01:08 +01:00
}
public func signOutMastodonUser(authentication: MastodonAuthentication) async throws {
try AuthenticationServiceProvider.shared.delete(authentication: authentication)
_ = try await apiService?.cancelSubscription(domain: authentication.domain, authorization: authentication.authorization)
}
public func signOutMastodonUser(authenticationBox: MastodonAuthenticationBox) async throws {
do {
try AuthenticationServiceProvider.shared.delete(authentication: authenticationBox.authentication)
} catch {
assertionFailure("Failed to delete Authentication: \(error)")
}
// cancel push notification subscription
do {
_ = try await apiService?.cancelSubscription(
domain: authenticationBox.domain,
authorization: authenticationBox.userAuthorization
)
} catch {
// do nothing
2021-02-03 09:01:08 +01:00
}
}
}