import Foundation
|
|
public enum ProFeature: String, CaseIterable, Codable, Equatable, Sendable {
|
case windowShortcutActivation
|
}
|
|
public enum TrialInvalidReason: String, Codable, Equatable, Sendable {
|
case corruptedRecord
|
case expiresBeforeStart
|
case startedInFuture
|
case timeRollback
|
}
|
|
public enum TrialState: Codable, Equatable, Sendable {
|
case notInitialized
|
case active(startedAt: Date, expiresAt: Date)
|
case expired(startedAt: Date, expiredAt: Date)
|
case invalidLocalRecord(reason: TrialInvalidReason)
|
}
|
|
public enum LicenseActivationStatus: String, Codable, Equatable, Sendable {
|
case active
|
case disabled
|
case expired
|
}
|
|
public enum LicenseRemoteFailureReason: String, Codable, Equatable, Sendable {
|
case invalid
|
case revoked
|
case disabled
|
case expired
|
case unknown
|
}
|
|
public enum LicenseMismatchReason: String, Codable, Equatable, Sendable {
|
case store
|
case product
|
case variant
|
}
|
|
public enum LicenseState: Codable, Equatable, Sendable {
|
case none
|
case activated(fingerprint: String, instanceID: String, status: LicenseActivationStatus)
|
case deactivatedLocal
|
case revokedOrExpiredRemote(reason: LicenseRemoteFailureReason)
|
case mismatch(reason: LicenseMismatchReason)
|
}
|
|
public enum ValidationHardFailureReason: String, Codable, Equatable, Sendable {
|
case invalid
|
case revoked
|
case disabled
|
case expired
|
case productMismatch
|
case storeMismatch
|
case variantMismatch
|
case serverRejected
|
case unknown
|
}
|
|
public enum ValidationFreshness: Codable, Equatable, Sendable {
|
case neverChecked
|
case valid(lastValidAt: Date, nextCheckAt: Date)
|
case temporaryFailure(lastAttemptAt: Date, graceUntil: Date)
|
case hardFailure(reason: ValidationHardFailureReason)
|
}
|
|
public enum EntitlementAllowedReason: String, Codable, Equatable, Sendable {
|
case trialActive
|
case licenseValid
|
case offlineGrace
|
}
|
|
public enum EntitlementDeniedReason: String, Codable, Equatable, Sendable {
|
case trialNotInitialized
|
case trialExpired
|
case noLicense
|
case licenseDeactivated
|
case licenseRevokedOrExpired
|
case licenseMismatch
|
case licenseDisabled
|
case licenseExpired
|
case verificationRequired
|
case graceExpired
|
case hardFailure
|
case invalidLocalRecord
|
case unsupportedFeature
|
}
|
|
public enum EffectiveEntitlement: Codable, Equatable, Sendable {
|
case proAllowed(reason: EntitlementAllowedReason)
|
case proDenied(reason: EntitlementDeniedReason)
|
|
public var isProAllowed: Bool {
|
switch self {
|
case .proAllowed:
|
return true
|
case .proDenied:
|
return false
|
}
|
}
|
}
|
|
public struct EntitlementSnapshot: Codable, Equatable, Sendable {
|
public var trialState: TrialState
|
public var licenseState: LicenseState
|
public var validationFreshness: ValidationFreshness
|
|
public init(
|
trialState: TrialState,
|
licenseState: LicenseState,
|
validationFreshness: ValidationFreshness
|
) {
|
self.trialState = trialState
|
self.licenseState = licenseState
|
self.validationFreshness = validationFreshness
|
}
|
}
|
|
public protocol ClockProtocol: Sendable {
|
var now: Date { get }
|
}
|
|
public struct SystemClock: ClockProtocol {
|
public init() {}
|
|
public var now: Date {
|
Date()
|
}
|
}
|
|
public protocol LicenseStoreProtocol: Sendable {
|
func loadEntitlementSnapshot() throws -> EntitlementSnapshot
|
func saveEntitlementSnapshot(_ snapshot: EntitlementSnapshot) throws
|
}
|
|
public enum LicenseValidationResult: Equatable, Sendable {
|
case success(lastValidAt: Date, nextCheckAt: Date)
|
case temporaryFailure(lastAttemptAt: Date, graceUntil: Date)
|
case hardFailure(reason: ValidationHardFailureReason)
|
}
|
|
public protocol LicenseValidationClientProtocol: Sendable {
|
func validateLicense(fingerprint: String, instanceID: String) async throws -> LicenseValidationResult
|
}
|
|
public protocol EntitlementProviderProtocol: Sendable {
|
func entitlement(for feature: ProFeature, at now: Date) -> EffectiveEntitlement
|
}
|
|
public enum EntitlementPolicy {
|
public static let defaultTrialDuration: TimeInterval = 30 * 24 * 60 * 60
|
public static let defaultOfflineGraceDuration: TimeInterval = 14 * 24 * 60 * 60
|
|
public static func trialStarted(at startedAt: Date, duration: TimeInterval = defaultTrialDuration) -> TrialState {
|
.active(startedAt: startedAt, expiresAt: startedAt.addingTimeInterval(duration))
|
}
|
|
public static func offlineGrace(
|
lastAttemptAt: Date,
|
duration: TimeInterval = defaultOfflineGraceDuration
|
) -> ValidationFreshness {
|
.temporaryFailure(lastAttemptAt: lastAttemptAt, graceUntil: lastAttemptAt.addingTimeInterval(duration))
|
}
|
|
public static func evaluate(
|
snapshot: EntitlementSnapshot,
|
feature: ProFeature,
|
now: Date
|
) -> EffectiveEntitlement {
|
switch feature {
|
case .windowShortcutActivation:
|
break
|
}
|
|
let licenseDecision = decisionForLicense(
|
state: snapshot.licenseState,
|
freshness: snapshot.validationFreshness,
|
now: now
|
)
|
if case .proAllowed = licenseDecision {
|
return licenseDecision
|
}
|
|
let trialDecision = decisionForTrial(state: snapshot.trialState, now: now)
|
if case .proAllowed = trialDecision {
|
return trialDecision
|
}
|
|
if case .none = snapshot.licenseState {
|
if case .notInitialized = snapshot.trialState {
|
return .proDenied(reason: .noLicense)
|
}
|
return trialDecision
|
}
|
|
return licenseDecision
|
}
|
|
private static func decisionForTrial(state: TrialState, now: Date) -> EffectiveEntitlement {
|
switch state {
|
case .notInitialized:
|
return .proDenied(reason: .trialNotInitialized)
|
case let .active(startedAt, expiresAt):
|
guard expiresAt > startedAt else {
|
return .proDenied(reason: .invalidLocalRecord)
|
}
|
guard now >= startedAt else {
|
return .proDenied(reason: .invalidLocalRecord)
|
}
|
guard now < expiresAt else {
|
return .proDenied(reason: .trialExpired)
|
}
|
return .proAllowed(reason: .trialActive)
|
case .expired:
|
return .proDenied(reason: .trialExpired)
|
case .invalidLocalRecord:
|
return .proDenied(reason: .invalidLocalRecord)
|
}
|
}
|
|
private static func decisionForLicense(
|
state: LicenseState,
|
freshness: ValidationFreshness,
|
now: Date
|
) -> EffectiveEntitlement {
|
switch state {
|
case .none:
|
return .proDenied(reason: .noLicense)
|
case .deactivatedLocal:
|
return .proDenied(reason: .licenseDeactivated)
|
case .revokedOrExpiredRemote:
|
return .proDenied(reason: .licenseRevokedOrExpired)
|
case .mismatch:
|
return .proDenied(reason: .licenseMismatch)
|
case let .activated(_, _, status):
|
switch status {
|
case .active:
|
return decisionForValidationFreshness(freshness, now: now)
|
case .disabled:
|
return .proDenied(reason: .licenseDisabled)
|
case .expired:
|
return .proDenied(reason: .licenseExpired)
|
}
|
}
|
}
|
|
private static func decisionForValidationFreshness(
|
_ freshness: ValidationFreshness,
|
now: Date
|
) -> EffectiveEntitlement {
|
switch freshness {
|
case .neverChecked:
|
return .proDenied(reason: .verificationRequired)
|
case let .valid(_, nextCheckAt):
|
return now <= nextCheckAt
|
? .proAllowed(reason: .licenseValid)
|
: .proDenied(reason: .verificationRequired)
|
case let .temporaryFailure(_, graceUntil):
|
return now < graceUntil
|
? .proAllowed(reason: .offlineGrace)
|
: .proDenied(reason: .graceExpired)
|
case .hardFailure:
|
return .proDenied(reason: .hardFailure)
|
}
|
}
|
}
|
|
public enum EntitlementFixtureState: String, CaseIterable, Codable, Equatable, Sendable {
|
case trialActive
|
case trialExpired
|
case proUnlocked
|
case offlineGrace
|
case verifyFailed
|
}
|
|
public struct FixtureEntitlementProvider: EntitlementProviderProtocol {
|
public let snapshot: EntitlementSnapshot
|
|
public init(fixtureState: EntitlementFixtureState, now: Date) {
|
let startedAt = now.addingTimeInterval(-24 * 60 * 60)
|
let expiredAt = now.addingTimeInterval(-24 * 60 * 60)
|
let expiredTrial = TrialState.expired(
|
startedAt: now.addingTimeInterval(-31 * 24 * 60 * 60),
|
expiredAt: expiredAt
|
)
|
let activeLicense = LicenseState.activated(
|
fingerprint: "fixture-fingerprint",
|
instanceID: "fixture-instance",
|
status: .active
|
)
|
|
switch fixtureState {
|
case .trialActive:
|
snapshot = EntitlementSnapshot(
|
trialState: .active(
|
startedAt: startedAt,
|
expiresAt: now.addingTimeInterval(29 * 24 * 60 * 60)
|
),
|
licenseState: .none,
|
validationFreshness: .neverChecked
|
)
|
case .trialExpired:
|
snapshot = EntitlementSnapshot(
|
trialState: expiredTrial,
|
licenseState: .none,
|
validationFreshness: .neverChecked
|
)
|
case .proUnlocked:
|
snapshot = EntitlementSnapshot(
|
trialState: expiredTrial,
|
licenseState: activeLicense,
|
validationFreshness: .valid(
|
lastValidAt: now,
|
nextCheckAt: now.addingTimeInterval(24 * 60 * 60)
|
)
|
)
|
case .offlineGrace:
|
snapshot = EntitlementSnapshot(
|
trialState: expiredTrial,
|
licenseState: activeLicense,
|
validationFreshness: EntitlementPolicy.offlineGrace(lastAttemptAt: now)
|
)
|
case .verifyFailed:
|
snapshot = EntitlementSnapshot(
|
trialState: expiredTrial,
|
licenseState: activeLicense,
|
validationFreshness: .hardFailure(reason: .serverRejected)
|
)
|
}
|
}
|
|
public func entitlement(for feature: ProFeature, at now: Date) -> EffectiveEntitlement {
|
EntitlementPolicy.evaluate(snapshot: snapshot, feature: feature, now: now)
|
}
|
}
|
