Temp target alarm migration

LoopFollow/Storage/Storage+Migrate.swift

@@ -296,6 +296,8 @@ extension Storage {
         migratePumpChangeAlarm()
         migrateOverrideStartAlarm()
         migrateOverrideEndAlarm()
+        migrateTempTargetStartAlarm()
+        migrateTempTargetEndAlarm()
     }
 
     // MARK: - One-off alarm migrations
@@ -1017,7 +1019,6 @@ extension Storage {
 
         var alarm = Alarm(type: .overrideStart)
         alarm.name = "Override Started"
-        alarm.disableAfterFiring = true // fire once, then stay off
 
         alarm.isEnabled = take("alertOverrideStart", false)
         alarm.snoozeDuration = 5 // legacy UI had no stepper
@@ -1091,7 +1092,6 @@ extension Storage {
 
         var alarm = Alarm(type: .overrideEnd)
         alarm.name = "Override Ended"
-        alarm.disableAfterFiring = true
 
         alarm.isEnabled = take("alertOverrideEnd", false)
         alarm.snoozeDuration = 5
@@ -1147,4 +1147,128 @@ extension Storage {
         list.append(alarm)
         Storage.shared.alarms.value = list
     }
+
+    // MARK: ––––– Temp-Target START  →  .tempTargetStart –––––
+
+    private func migrateTempTargetStartAlarm() {
+        let touched = UserDefaultsValue<Bool>(key: "alertTempTargetStart", default: false)
+        guard touched.exists else { return }
+
+        func take<V: AnyConvertible & Equatable>(_ k: String, _ def: V) -> V {
+            let box = UserDefaultsValue<V>(key: k, default: def)
+            defer { box.setNil(key: k) } // scrub after read
+            return box.value
+        }
+
+        var alarm = Alarm(type: .tempTargetStart)
+        alarm.name = "Temp Target Started"
+
+        alarm.isEnabled = take("alertTempTargetStart", false)
+        alarm.snoozeDuration = 5
+        if take("alertTempTargetStartIsSnoozed", false) {
+            alarm.snoozedUntil = take("alertTempTargetStartSnoozedTime", nil as Date?)
+        }
+
+        alarm.soundFile = SoundFile(
+            rawValue: take("alertTempTargetStartSound", "Ending_Reached")
+        ) ?? .endingReached
+
+        // ACTIVE  ← legacy Pre-Snooze day/night flags
+        alarm.activeOption = {
+            let d = take("alertTempTargetStartAutosnoozeDay", false)
+            let n = take("alertTempTargetStartAutosnoozeNight", false)
+            switch (d, n) { case (true, true): return .always
+            case (true, false): return .day
+            case (false, true): return .night
+            default: return .always }
+        }()
+
+        // PLAY
+        alarm.playSoundOption = {
+            let d = take("alertTempTargetStartDayTimeAudible", true)
+            let n = take("alertTempTargetStartNightTimeAudible", true)
+            switch (d, n) { case (true, true): return .always
+            case (true, false): return .day
+            case (false, true): return .night
+            default: return .never }
+        }()
+
+        // REPEAT
+        alarm.repeatSoundOption = {
+            let d = take("alertTempTargetStartDayTime", false)
+            let n = take("alertTempTargetStartNightTime", false)
+            switch (d, n) { case (true, true): return .always
+            case (true, false): return .day
+            case (false, true): return .night
+            default: return .never }
+        }()
+
+        // wipe “quiet / RepeatAudible” extras
+        _ = take("alertTempTargetStartQuiet", false as Bool)
+        _ = take("alertTempTargetStartRepeatAudible", "Always" as String)
+
+        var list = Storage.shared.alarms.value
+        list.append(alarm)
+        Storage.shared.alarms.value = list
+    }
+
+    // MARK: ––––– Temp-Target END  →  .tempTargetEnd –––––
+
+    private func migrateTempTargetEndAlarm() {
+        let touched = UserDefaultsValue<Bool>(key: "alertTempTargetEnd", default: false)
+        guard touched.exists else { return }
+
+        func take<V: AnyConvertible & Equatable>(_ k: String, _ def: V) -> V {
+            let box = UserDefaultsValue<V>(key: k, default: def)
+            defer { box.setNil(key: k) }
+            return box.value
+        }
+
+        var alarm = Alarm(type: .tempTargetEnd)
+        alarm.name = "Temp Target Ended"
+
+        alarm.isEnabled = take("alertTempTargetEnd", false)
+        alarm.snoozeDuration = 5
+        if take("alertTempTargetEndIsSnoozed", false) {
+            alarm.snoozedUntil = take("alertTempTargetEndSnoozedTime", nil as Date?)
+        }
+
+        alarm.soundFile = SoundFile(
+            rawValue: take("alertTempTargetEndSound", "Alert_Tone_Busy")
+        ) ?? .alertToneBusy
+
+        alarm.activeOption = {
+            let d = take("alertTempTargetEndAutosnoozeDay", false)
+            let n = take("alertTempTargetEndAutosnoozeNight", false)
+            switch (d, n) { case (true, true): return .always
+            case (true, false): return .day
+            case (false, true): return .night
+            default: return .always }
+        }()
+
+        alarm.playSoundOption = {
+            let d = take("alertTempTargetEndDayTimeAudible", true)
+            let n = take("alertTempTargetEndNightTimeAudible", true)
+            switch (d, n) { case (true, true): return .always
+            case (true, false): return .day
+            case (false, true): return .night
+            default: return .never }
+        }()
+
+        alarm.repeatSoundOption = {
+            let d = take("alertTempTargetEndDayTime", false)
+            let n = take("alertTempTargetEndNightTime", false)
+            switch (d, n) { case (true, true): return .always
+            case (true, false): return .day
+            case (false, true): return .night
+            default: return .never }
+        }()
+
+        _ = take("alertTempTargetEndQuiet", false as Bool)
+        _ = take("alertTempTargetEndRepeatAudible", "Always" as String)
+
+        var list = Storage.shared.alarms.value
+        list.append(alarm)
+        Storage.shared.alarms.value = list
+    }
 }

LoopFollow/Storage/UserDefaults.swift

@@ -106,36 +106,6 @@ class UserDefaultsRepository {
     static let alertTemporaryBGAudible = UserDefaultsValue<Bool>(key: "alertTemporaryBGRepeatAudible", default: true)
     static let alertTemporarySound = UserDefaultsValue<String>(key: "alertTemporarySound", default: "Indeed")
 
-    static let alertTempTargetStart = UserDefaultsValue<Bool>(key: "alertTempTargetStart", default: false)
-    static let alertTempTargetStartQuiet = UserDefaultsValue<Bool>(key: "alertTempTargetStartQuiet", default: false)
-    static let alertTempTargetStartRepeat = UserDefaultsValue<String>(key: "alertTempTargetStartRepeat", default: "Never")
-    static let alertTempTargetStartDayTime = UserDefaultsValue<Bool>(key: "alertTempTargetStartDayTime", default: false)
-    static let alertTempTargetStartNightTime = UserDefaultsValue<Bool>(key: "alertTempTargetStartNightTime", default: false)
-    static let alertTempTargetStartAudible = UserDefaultsValue<String>(key: "alertTempTargetStartRepeatAudible", default: "Always")
-    static let alertTempTargetStartDayTimeAudible = UserDefaultsValue<Bool>(key: "alertTempTargetStartDayTimeAudible", default: true)
-    static let alertTempTargetStartNightTimeAudible = UserDefaultsValue<Bool>(key: "alertTempTargetStartNightTimeAudible", default: true)
-    static let alertTempTargetStartSound = UserDefaultsValue<String>(key: "alertTempTargetStartSound", default: "Ending_Reached")
-    static let alertTempTargetStartSnoozedTime = UserDefaultsValue<Date?>(key: "alertTempTargetStartSnoozedTime", default: nil)
-    static let alertTempTargetStartIsSnoozed = UserDefaultsValue<Bool>(key: "alertTempTargetStartIsSnoozed", default: false)
-    static let alertTempTargetStartAutosnooze = UserDefaultsValue<String>(key: "alertTempTargetStartAutosnooze", default: "Never")
-    static let alertTempTargetStartAutosnoozeDay = UserDefaultsValue<Bool>(key: "alertTempTargetStartAutosnoozeDay", default: false)
-    static let alertTempTargetStartAutosnoozeNight = UserDefaultsValue<Bool>(key: "alertTempTargetStartAutosnoozeNight", default: false)
-
-    static let alertTempTargetEnd = UserDefaultsValue<Bool>(key: "alertTempTargetEnd", default: false)
-    static let alertTempTargetEndQuiet = UserDefaultsValue<Bool>(key: "alertTempTargetEndQuiet", default: false)
-    static let alertTempTargetEndRepeat = UserDefaultsValue<String>(key: "alertTempTargetEndRepeat", default: "Never")
-    static let alertTempTargetEndDayTime = UserDefaultsValue<Bool>(key: "alertTempTargetEndDayTime", default: false)
-    static let alertTempTargetEndNightTime = UserDefaultsValue<Bool>(key: "alertTempTargetEndNightTime", default: false)
-    static let alertTempTargetEndAudible = UserDefaultsValue<String>(key: "alertTempTargetEndRepeatAudible", default: "Always")
-    static let alertTempTargetEndDayTimeAudible = UserDefaultsValue<Bool>(key: "alertTempTargetEndDayTimeAudible", default: true)
-    static let alertTempTargetEndNightTimeAudible = UserDefaultsValue<Bool>(key: "alertTempTargetEndNightTimeAudible", default: true)
-    static let alertTempTargetEndSound = UserDefaultsValue<String>(key: "alertTempTargetEndSound", default: "Alert_Tone_Busy")
-    static let alertTempTargetEndSnoozedTime = UserDefaultsValue<Date?>(key: "alertTempTargetEndSnoozedTime", default: nil)
-    static let alertTempTargetEndIsSnoozed = UserDefaultsValue<Bool>(key: "alertTempTargetEndIsSnoozed", default: false)
-    static let alertTempTargetEndAutosnooze = UserDefaultsValue<String>(key: "alertTempTargetEndAutosnooze", default: "Never")
-    static let alertTempTargetEndAutosnoozeDay = UserDefaultsValue<Bool>(key: "alertTempTargetEndAutosnoozeDay", default: false)
-    static let alertTempTargetEndAutosnoozeNight = UserDefaultsValue<Bool>(key: "alertTempTargetEndAutosnoozeNight", default: false)
-
     static let alertPump = UserDefaultsValue<Bool>(key: "alertPump", default: false)
     static let alertPumpAt = UserDefaultsValue<Int>(key: "alertPumpAt", default: 10) // Units
     static let alertPumpQuiet = UserDefaultsValue<Bool>(key: "alertPumpQuiet", default: false)