123 lines
3.9 KiB
Swift
123 lines
3.9 KiB
Swift
import Foundation
|
|
|
|
@MainActor
|
|
final class LicenseStore: ObservableObject {
|
|
@Published private(set) var status: LicenseStatus?
|
|
@Published private(set) var isWorking = false
|
|
@Published private(set) var hasChecked = false
|
|
@Published var errorMessage: String?
|
|
|
|
var hasStoredLicense: Bool { KeychainService.licenseToken() != nil }
|
|
var isLicensed: Bool { status?.valid == true }
|
|
|
|
func activate(_ key: String) async {
|
|
let clean = key.trimmingCharacters(in: .whitespacesAndNewlines).uppercased()
|
|
guard !clean.isEmpty else {
|
|
errorMessage = "Enter your SonarDesk licence key."
|
|
return
|
|
}
|
|
|
|
isWorking = true
|
|
errorMessage = nil
|
|
defer {
|
|
isWorking = false
|
|
hasChecked = true
|
|
}
|
|
|
|
do {
|
|
let (result, token) = try await LicenseService.shared.activate(key: clean)
|
|
try KeychainService.saveLicenseToken(token)
|
|
status = result
|
|
} catch {
|
|
errorMessage = error.localizedDescription
|
|
}
|
|
}
|
|
|
|
func replaceLicense(with key: String) async -> Bool {
|
|
let clean = key.trimmingCharacters(in: .whitespacesAndNewlines).uppercased()
|
|
guard !clean.isEmpty else {
|
|
errorMessage = "Enter your new SonarDesk licence key."
|
|
return false
|
|
}
|
|
|
|
let previousToken = KeychainService.licenseToken()
|
|
|
|
isWorking = true
|
|
errorMessage = nil
|
|
defer {
|
|
isWorking = false
|
|
hasChecked = true
|
|
}
|
|
|
|
do {
|
|
// Validate the replacement before touching the currently working licence.
|
|
let (result, newToken) = try await LicenseService.shared.activate(key: clean)
|
|
try KeychainService.saveLicenseToken(newToken)
|
|
status = result
|
|
|
|
// Once the replacement is safely stored, release the old activation.
|
|
// Failure here must not undo a successfully installed replacement licence.
|
|
if let previousToken, previousToken != newToken {
|
|
try? await LicenseService.shared.deactivate(token: previousToken)
|
|
}
|
|
|
|
return true
|
|
} catch {
|
|
errorMessage = error.localizedDescription
|
|
return false
|
|
}
|
|
}
|
|
|
|
func refresh() async {
|
|
guard let token = KeychainService.licenseToken() else {
|
|
status = nil
|
|
hasChecked = true
|
|
return
|
|
}
|
|
|
|
// Always restore the locally signed status before attempting the network.
|
|
// This keeps the application licensed while the validation request is in flight.
|
|
if let cached = try? await LicenseService.shared.cachedStatus(token: token) {
|
|
status = cached
|
|
}
|
|
|
|
isWorking = true
|
|
errorMessage = nil
|
|
defer {
|
|
isWorking = false
|
|
hasChecked = true
|
|
}
|
|
|
|
do {
|
|
let (result, refreshedToken) = try await LicenseService.shared.refresh(token: token)
|
|
try KeychainService.saveLicenseToken(refreshedToken)
|
|
status = result
|
|
} catch {
|
|
// Do NOT clear status or delete the token here. A failed Check Licence can
|
|
// be caused by networking, DNS, TLS, the licensing server, or a transient
|
|
// server error. Explicit deactivation is the only path that removes the
|
|
// persisted activation.
|
|
errorMessage = error.localizedDescription
|
|
}
|
|
}
|
|
|
|
func deactivate() async {
|
|
guard let token = KeychainService.licenseToken() else { return }
|
|
|
|
isWorking = true
|
|
errorMessage = nil
|
|
defer {
|
|
isWorking = false
|
|
hasChecked = true
|
|
}
|
|
|
|
do {
|
|
try await LicenseService.shared.deactivate(token: token)
|
|
KeychainService.deleteLicenseToken()
|
|
status = nil
|
|
} catch {
|
|
errorMessage = error.localizedDescription
|
|
}
|
|
}
|
|
}
|