Implement workday recurrence

Author: Tackx

README.md

@@ -77,13 +77,9 @@ npm run tauri build --release
 
 The built binary & installers will be created in `src-tauri/target/release`.
 
-## TODO
-
-- Calendar units for recurrence
-
 ## Future Releases
 
-- GUI paging
+- GUI paging to support displaying more than 30 upcoming reminders
 - Update paging so that all generated instances are not held in memory and do not grow with each new page
   - Only hold the current page and check if it's needed to regenerate upon every request for a page of tasks
 - MacOS release

src-tauri/src/datetime.rs

@@ -1,4 +1,4 @@
-use chrono::{DateTime, Datelike, TimeZone, Timelike, Utc};
+use chrono::{DateTime, Datelike, Duration, TimeZone, Timelike, Utc, Weekday};
 
 pub fn add_months(dt: DateTime<Utc>, months: u32) -> DateTime<Utc> {
     let mut year = dt.year();
@@ -23,3 +23,83 @@ pub fn days_in_month(year: i32, month: u32) -> u32 {
         .unwrap();
     (next_first_day - first_day).num_days() as u32
 }
+
+pub fn add_workdays(mut date: DateTime<Utc>, mut n: i64) -> DateTime<Utc> {
+    while n > 0 {
+        date = date + Duration::days(1);
+        match date.weekday() {
+            Weekday::Sat | Weekday::Sun => continue,
+            _ => n -= 1,
+        }
+    }
+    date
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use chrono::TimeZone;
+
+    #[test]
+    fn test_days_in_month() {
+        assert_eq!(days_in_month(2024, 2), 29); // Leap year
+        assert_eq!(days_in_month(2023, 2), 28);
+        assert_eq!(days_in_month(2023, 1), 31);
+        assert_eq!(days_in_month(2023, 4), 30);
+    }
+
+    #[test]
+    fn test_add_months_basic() {
+        let date = Utc.with_ymd_and_hms(2023, 1, 15, 12, 0, 0).unwrap();
+        let result = add_months(date, 1);
+        assert_eq!(result, Utc.with_ymd_and_hms(2023, 2, 15, 12, 0, 0).unwrap());
+    }
+
+    #[test]
+    fn test_add_months_wrap_year() {
+        let date = Utc.with_ymd_and_hms(2023, 11, 30, 9, 0, 0).unwrap();
+        let result = add_months(date, 2);
+        assert_eq!(result, Utc.with_ymd_and_hms(2024, 1, 30, 9, 0, 0).unwrap());
+    }
+
+    #[test]
+    fn test_add_months_day_adjustment() {
+        let date = Utc.with_ymd_and_hms(2023, 1, 31, 8, 0, 0).unwrap();
+        let result = add_months(date, 1);
+        // February 2023 only has 28 days
+        assert_eq!(result, Utc.with_ymd_and_hms(2023, 2, 28, 8, 0, 0).unwrap());
+    }
+
+    #[test]
+    fn test_add_workdays_simple() {
+        let monday = Utc.with_ymd_and_hms(2023, 7, 24, 10, 0, 0).unwrap(); // Monday
+        let result = add_workdays(monday, 5);
+        assert_eq!(result.weekday(), Weekday::Mon);
+        assert_eq!(
+            result.date_naive(),
+            monday.date_naive() + chrono::Days::new(7)
+        );
+    }
+
+    #[test]
+    fn test_add_workdays_over_weekend() {
+        let friday = Utc.with_ymd_and_hms(2023, 7, 21, 10, 0, 0).unwrap(); // Friday
+        let result = add_workdays(friday, 1);
+        assert_eq!(result.weekday(), Weekday::Mon);
+        assert_eq!(
+            result.date_naive(),
+            friday.date_naive() + chrono::Days::new(3)
+        );
+    }
+
+    #[test]
+    fn test_add_workdays_multiple_weeks() {
+        let tuesday = Utc.with_ymd_and_hms(2023, 7, 18, 10, 0, 0).unwrap(); // Tuesday
+        let result = add_workdays(tuesday, 10);
+        assert_eq!(result.weekday(), Weekday::Tue);
+        assert_eq!(
+            result.date_naive(),
+            tuesday.date_naive() + chrono::Days::new(14)
+        );
+    }
+}

src-tauri/src/tasks.rs

@@ -8,7 +8,7 @@ use std::fs;
 use uuid::Uuid;
 
 use crate::config;
-use crate::datetime::add_months;
+use crate::datetime::{add_months, add_workdays};
 
 #[derive(Serialize, Deserialize, Clone, Debug)]
 pub enum RecurrenceInterval {
@@ -18,6 +18,7 @@ pub enum RecurrenceInterval {
     Weekly(i64),
     Monthly(i64),
     Yearly(i64),
+    Workdays(i64),
 }
 
 #[derive(Serialize, Deserialize, Clone, Debug)]
@@ -183,41 +184,54 @@ impl TaskReminder {
                                 d.start + Duration::minutes(i * number)
                             }
                         }
+
                         RecurrenceInterval::Hourly(number) => {
                             if let Some(last) = last_recurrence {
                                 *last + Duration::hours((i + 1) * number)
                             } else {
                                 d.start + Duration::hours(i * number)
                             }
                         }
+
                         RecurrenceInterval::Daily(number) => {
                             if let Some(last) = last_recurrence {
                                 *last + Duration::days((i + 1) * number)
                             } else {
                                 d.start + Duration::days(i * number)
                             }
                         }
+
                         RecurrenceInterval::Weekly(number) => {
                             if let Some(last) = last_recurrence {
                                 *last + Duration::weeks((i + 1) * number)
                             } else {
                                 d.start + Duration::weeks(i * number)
                             }
                         }
+
                         RecurrenceInterval::Monthly(number) => {
                             let mut t = last_recurrence.unwrap_or(d.start);
                             for _ in 0..=(i as u32) {
                                 t = add_months(t, *number as u32);
                             }
                             t
                         }
+
                         RecurrenceInterval::Yearly(number) => {
                             let mut t = last_recurrence.unwrap_or(d.start);
                             for _ in 0..=(i as u32) {
                                 t = add_months(t, 12 * (*number as u32));
                             }
                             t
                         }
+
+                        RecurrenceInterval::Workdays(number) => {
+                            let mut t = last_recurrence.unwrap_or(d.start);
+                            for _ in 0..(i + 1) {
+                                t = add_workdays(t, *number);
+                            }
+                            t
+                        }
                     },
                     None => d.start,
                 };

src/components/TaskForm.vue

@@ -209,15 +209,16 @@ import {
 import { pluralizeUnit, timeUnitToMinutesMap } from '../helpers/datetime'
 import PIcon from './PIcon.vue'
 
-type IntervalKey = 'Minutes' | 'Hourly' | 'Daily' | 'Weekly' | 'Monthly' | 'Yearly'
+type IntervalKey = 'Minutes' | 'Hourly' | 'Daily' | 'Weekly' | 'Monthly' | 'Yearly' | 'Workdays'
 
 const intervalMap = {
   minute: 'Minutes',
   hour: 'Hourly',
   day: 'Daily',
   week: 'Weekly',
   month: 'Monthly',
-  year: 'Yearly'
+  year: 'Yearly',
+  workday: 'Workdays'
 } as const satisfies Record<string, IntervalKey>
 
 const props = withDefaults(

src/composables/useTasks.ts

@@ -8,6 +8,7 @@ export type Interval =
   | { Minutes: number }
   | { Hourly: number }
   | { Daily: number }
+  | { Workdays: number }
   | { Weekly: number }
   | { Monthly: number }
   | { Yearly: number }