Let user touch to directly go to the current pay period

TimeKeen/Views/ContentView.swift

@@ -1,18 +1,20 @@
 import SwiftUI
+import SwiftData
 
 struct ContentView: View {
   var quickActionProvider: QuickActionProvider
   @State private var path: NavigationPath = .init()
   @State private var selectedTab = 0
   @AppStorage(SharedData.Keys.minuteInterval.rawValue, store: SharedData.userDefaults) var minuteInterval = 15
+  @Environment(\.modelContext) private var context
 
   init(quickActionProvider: QuickActionProvider) {
     self.quickActionProvider = quickActionProvider
   }
 
   var body: some View {
     TabView(selection: $selectedTab) {
-      CurrentTimeEntryView(quickActionProvider: quickActionProvider)
+      CurrentTimeEntryView(quickActionProvider: quickActionProvider, navigate: navigate)
         .tabItem {
           Label("Time Clock", systemImage: "stopwatch")
         }
@@ -35,4 +37,21 @@ struct ContentView: View {
       UIDatePicker.appearance().minuteInterval = minuteInterval
     }
   }
+
+  func navigate(to range: ClosedRange<Date>) {
+    let fetchDescriptor = FetchDescriptor<TimeEntry>(predicate: #Predicate { [range = range] timeEntry in
+      return timeEntry.start >= range.lowerBound && timeEntry.start <= range.upperBound
+    })
+
+    do {
+      let timeEntries = try context.fetch(fetchDescriptor)
+      let payPeriod = PayPeriod(range: range, timeEntries: timeEntries)
+      selectedTab = 1
+      path = .init()
+      path.append(payPeriod)
+    } catch {
+      selectedTab = 0
+      path = .init()
+    }
+  }
 }

TimeKeen/Views/CurrentTimeEntry/CurrentTimeEntryView.swift

@@ -32,11 +32,13 @@ struct CurrentTimeEntryView: View {
   @AppStorage(SharedData.Keys.endOfLastPayPeriod.rawValue, store: SharedData.userDefaults) var endOfLastPayPeriod = Calendar.current.date(from: DateComponents(year: 2024, month: 07, day: 21))!
   @FocusState private var isEditingNotes: Bool
   @State private var isOntheClockTimeVisible = true
+  private let navigate: (ClosedRange<Date>) -> Void
 
   let timer = Timer.publish(every: 1, on: .main, in: .common).autoconnect()
 
-  init(quickActionProvider: QuickActionProvider) {
+  init(quickActionProvider: QuickActionProvider, navigate: @escaping (ClosedRange<Date>) -> Void) {
     self.quickActionProvider = quickActionProvider
+    self.navigate = navigate
   }
 
   var body: some View {
@@ -114,6 +116,9 @@ struct CurrentTimeEntryView: View {
       if isOntheClockTimeVisible {
         TimeSheetOnTheClockView(payPeriod: $payPeriod, clockInDuration: $clockInDuration)
           .padding()
+          .onTapGesture {
+            navigate(payPeriod)
+          }
       }
     }
     .onChange(of: quickActionProvider.quickAction) { _, _ in

TimeKeen/Views/PayPeriods/PayPeriodDetails.swift

@@ -1,17 +1,22 @@
 import SwiftUI
+import SwiftData
 
 struct PayPeriodDetails: View {
-  @State var payPeriod: PayPeriod
   @Environment(\.modelContext) private var context
   @Environment(\.dismiss) private var dismiss
+  @Query var timeEntries: [TimeEntry]
+  private let payPeriod: ClosedRange<Date>
 
-  init(payPeriod: PayPeriod) {
+  init(for payPeriod: ClosedRange<Date>) {
     self.payPeriod = payPeriod
+    _timeEntries = Query(filter: #Predicate<TimeEntry> { [payPeriod = self.payPeriod] timeEntry in
+      return timeEntry.start >= payPeriod.lowerBound && timeEntry.start <= payPeriod.upperBound
+    }, sort: \TimeEntry.start, order: .reverse)
   }
 
   var body: some View {
     List {
-      ForEach(payPeriod.timeEntries.filter { payPeriod.range.contains( $0.start ) }.groupByDay()) { timeEntries in
+      ForEach(timeEntries.filter { payPeriod.contains( $0.start ) }.groupByDay()) { timeEntries in
         Section {
           ForEach(timeEntries) { timeEntry in
             NavigationLink(value: timeEntry) {
@@ -24,24 +29,16 @@ struct PayPeriodDetails: View {
       }
       .onDelete { offsets in
         for index in offsets {
-          context.delete(payPeriod.timeEntries[index])
+          context.delete(timeEntries[index])
         }
-        payPeriod.timeEntries.remove(atOffsets: offsets)
+
+        _timeEntries.update()
 
-        if payPeriod.timeEntries.isEmpty {
+        if timeEntries.isEmpty {
           dismiss()
         }
       }
     }
-    .navigationDestination(for: TimeEntry.self) { timeEntry in
-      TimeEntryDetails(timeEntry: timeEntry) { timeEntry in
-        payPeriod = PayPeriod(range: payPeriod.range, timeEntries: payPeriod.timeEntries.filter { [timeEntry] in $0 != timeEntry })
-      }
-    }
-    .navigationTitle("\(Formatting.yearlessDateformatter.string(from: payPeriod.range.lowerBound)) - \(Formatting.yearlessDateformatter.string(from: payPeriod.range.upperBound))")
-  }
-
-  private func onDelete() {
-    print("huh")
+    .navigationTitle("\(Formatting.yearlessDateformatter.string(from: payPeriod.lowerBound)) - \(Formatting.yearlessDateformatter.string(from: payPeriod.upperBound))")
   }
 }

TimeKeen/Views/PayPeriods/PayPeriodList.swift

@@ -16,7 +16,10 @@ struct PayPeriodList: View {
       }
     }
     .navigationDestination(for: PayPeriod.self) { payPeriod in
-      PayPeriodDetails(payPeriod: payPeriod)
+      PayPeriodDetails(for: payPeriod.range)
+    }
+    .navigationDestination(for: TimeEntry.self) { timeEntry in
+      TimeEntryDetails(for: timeEntry)
     }
     .toolbar {
       ToolbarItem(placement: .topBarTrailing) {

TimeKeen/Views/PayPeriods/TimeEntryDetails.swift

@@ -11,11 +11,9 @@ struct TimeEntryDetails: View {
   @State var breakStart = Date()
   @State var breakEnd = Date()
   @State var breakEntry: BreakEntry?
-  private let onDelete: (TimeEntry) -> Void
 
-  init(timeEntry: TimeEntry, _ onDelete: @escaping (TimeEntry) -> Void) {
+  init(for timeEntry: TimeEntry) {
     self.timeEntry = timeEntry
-    self.onDelete = onDelete
   }
 
   var body: some View {
@@ -72,7 +70,6 @@ struct TimeEntryDetails: View {
         Button("Delete Time Entry", role: .destructive) {
           context.delete(timeEntry)
           dismiss()
-          onDelete(timeEntry)
         }
       }
     }