Rework recurrence to work with calendar months/years

Tackx · Tackx · commit 45d20bf51845 · 2025-07-27T23:12:57.000+02:00
diff --git a/README.md b/README.md
@@ -1,6 +1,6 @@
 # Todolator
 
-Todolator is a simple desktop task reminder designed to ensure it is hard to ignore the reminder (unlike other apps using push or in-browser notifications).
+Todolator is a simple desktop task reminder designed to ensure it is hard(er) to ignore the reminder (unlike other apps using push or in-browser notifications).
 
 ## Why
 
diff --git a/src-tauri/src/datetime.rs b/src-tauri/src/datetime.rs
@@ -0,0 +1,25 @@
+use chrono::{DateTime, Datelike, TimeZone, Timelike, Utc};
+
+pub fn add_months(dt: DateTime<Utc>, months: u32) -> DateTime<Utc> {
+    let mut year = dt.year();
+    let mut month = dt.month() + months;
+
+    while month > 12 {
+        month -= 12;
+        year += 1;
+    }
+
+    let day = std::cmp::min(dt.day(), days_in_month(year, month));
+    Utc.with_ymd_and_hms(year, month, day, dt.hour(), dt.minute(), dt.second())
+        .unwrap()
+}
+
+pub fn days_in_month(year: i32, month: u32) -> u32 {
+    let next_month = if month == 12 { 1 } else { month + 1 };
+    let next_year = if month == 12 { year + 1 } else { year };
+    let first_day = Utc.with_ymd_and_hms(year, month, 1, 0, 0, 0).unwrap();
+    let next_first_day = Utc
+        .with_ymd_and_hms(next_year, next_month, 1, 0, 0, 0)
+        .unwrap();
+    (next_first_day - first_day).num_days() as u32
+}
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
@@ -1,5 +1,6 @@
 mod commands;
 mod config;
+mod datetime;
 mod tasks;
 
 use std::{
diff --git a/src-tauri/src/tasks.rs b/src-tauri/src/tasks.rs
@@ -8,14 +8,25 @@ use std::fs;
 use uuid::Uuid;
 
 use crate::config;
+use crate::datetime::add_months;
+
+#[derive(Serialize, Deserialize, Clone, Debug)]
+pub enum RecurrenceInterval {
+    Minutes(i64),
+    Hourly(i64),
+    Daily(i64),
+    Weekly(i64),
+    Monthly(i64),
+    Yearly(i64),
+}
 
 #[derive(Serialize, Deserialize, Clone, Debug)]
 #[serde(untagged)]
 pub enum Recurrence {
     None,
     Recurring {
         last_recurrence: Option<DateTime<Utc>>,
-        minutes: i64,
+        interval: RecurrenceInterval,
         exceptions: Option<Vec<DateTime<Utc>>>,
     },
 }
@@ -149,11 +160,11 @@ impl TaskReminder {
             for i in 0..instances_required {
                 let recurrence_info = if let Some(Recurrence::Recurring {
                     last_recurrence,
-                    minutes,
+                    interval,
                     exceptions,
                 }) = &d.recurrence
                 {
-                    Some((last_recurrence, minutes, exceptions))
+                    Some((last_recurrence, interval, exceptions))
                 } else {
                     None
                 };
@@ -164,12 +175,51 @@ impl TaskReminder {
                 }
 
                 let timestamp = match recurrence_info {
-                    Some((last_recurrence, minutes, _exceptions)) => match *last_recurrence {
-                        Some(last) => last + Duration::minutes((i + 1) * minutes),
-
-                        None => d.start + Duration::minutes(i * minutes),
+                    Some((last_recurrence, interval, _)) => match interval {
+                        RecurrenceInterval::Minutes(number) => {
+                            if let Some(last) = last_recurrence {
+                                *last + Duration::minutes((i + 1) * number)
+                            } else {
+                                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
+                        }
                     },
-                    _ => d.start,
+                    None => d.start,
                 };
 
                 let exceptions = if let Some(recurrence) = recurrence_info {
@@ -251,7 +301,7 @@ impl TaskReminder {
         if let Some(definition) = self.get_task_definition_mut(task.definition_id) {
             if let Some(Recurrence::Recurring {
                 last_recurrence,
-                minutes: _,
+                interval: _,
                 exceptions: _,
             }) = &mut definition.recurrence
             {
@@ -316,7 +366,7 @@ mod tests {
             start: Utc.with_ymd_and_hms(2025, 1, 1, 12, 0, 0).unwrap(),
             recurrence: Some(Recurrence::Recurring {
                 last_recurrence: None,
-                minutes: 60,
+                interval: RecurrenceInterval::Minutes(60),
                 exceptions: None,
             }),
         }
@@ -436,7 +486,7 @@ mod tests {
                 start,
                 recurrence: Some(Recurrence::Recurring {
                     last_recurrence: None,
-                    minutes: 60,
+                    interval: RecurrenceInterval::Minutes(60),
                     exceptions: Some(vec![exception_time]),
                 }),
             }],
@@ -462,7 +512,7 @@ mod tests {
             start: Utc.with_ymd_and_hms(2025, 1, 1, 8, 0, 0).unwrap(),
             recurrence: Some(Recurrence::Recurring {
                 last_recurrence: None,
-                minutes: 5, // small interval to fill multiple pages quickly
+                interval: RecurrenceInterval::Minutes(60),
                 exceptions: None,
             }),
         };
diff --git a/src/components/TaskForm.vue b/src/components/TaskForm.vue
@@ -130,7 +130,7 @@
             tabindex="6"
           >
             <option
-              v-for="[unit] of Object.entries(timeUnitToMinutesMap)"
+              v-for="[unit] of Object.entries(intervalMap)"
               :key="unit"
               :value="unit"
               class="hover:bg-secondary hover:text-primary hover:font-bold hover:cursor-pointer"
@@ -168,12 +168,8 @@
             <br />
             <span
               >repeats every
-              <span class="text-warning font-bold">{{ recurrence![Recurrence.AMOUNT] }}</span>
-              {{
-                (recurrence![Recurrence.AMOUNT] as number) > 1
-                  ? pluralizeUnit(recurrence![Recurrence.UNIT] as string)
-                  : recurrence![Recurrence.UNIT]
-              }}</span
+              <span class="text-warning font-bold">{{ displayUnitNumber }}</span>
+              {{ displayUnitNumber > 1 ? pluralizeUnit(displayUnitName) : displayUnitName }}</span
             >
           </div>
         </div>
@@ -203,20 +199,27 @@
 import { computed, nextTick, ref, watch } from 'vue'
 
 import PHotkeys from './PHotkeys.vue'
-import { CreatedTaskDefinition, TaskDefinition } from '../composables/useTasks'
+import { CreatedTaskDefinition, Interval, TaskDefinition } from '../composables/useTasks'
 import {
   getDefaultRecurrence,
   getDefaultTaskDefinition,
   isExistingDefinition,
   isRecurringDefinition
 } from '../helpers/task'
-import {
-  convertMinutesToHighestUnit,
-  pluralizeUnit,
-  timeUnitToMinutesMap
-} from '../helpers/datetime'
+import { pluralizeUnit, timeUnitToMinutesMap } from '../helpers/datetime'
 import PIcon from './PIcon.vue'
 
+type IntervalKey = 'Minutes' | 'Hourly' | 'Daily' | 'Weekly' | 'Monthly' | 'Yearly'
+
+const intervalMap = {
+  minute: 'Minutes',
+  hour: 'Hourly',
+  day: 'Daily',
+  week: 'Weekly',
+  month: 'Monthly',
+  year: 'Yearly'
+} as const satisfies Record<string, IntervalKey>
+
 const props = withDefaults(
   defineProps<{
     // Provided if updating an existing definition
@@ -235,6 +238,30 @@ const props = withDefaults(
 
 const localTask = ref(props.currentTask)
 
+const displayUnitName = computed(() => {
+  if (localTask.value.recurrence) {
+    const [unit] = Object.entries(localTask.value.recurrence.interval)[0]
+
+    // [["minute", "Minutes"], ...]
+    const unitName = Object.entries(intervalMap).find((i) => i[1] === unit)
+
+    return unitName ? unitName[0] : ''
+  }
+
+  return ''
+})
+
+const displayUnitNumber = computed(() => {
+  if (localTask.value.recurrence) {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const [_unit, amount] = Object.entries(localTask.value.recurrence.interval)[0]
+
+    return amount
+  }
+
+  return 1
+})
+
 enum Mode {
   CREATE,
   UPDATE
@@ -244,22 +271,17 @@ const highlightClass = computed(() => (mode.value === Mode.CREATE ? 'secondary'
 
 const isRecurring = computed(() => isRecurringDefinition(localTask.value))
 
-enum Recurrence {
-  AMOUNT,
-  UNIT
-}
-
-// Used for determining recurrence unit and amount when editing a task (read-only)
-const recurrence = computed(() => convertMinutesToHighestUnit(localTask.value.recurrence?.minutes))
-
 // Used for specifying recurrence when creating a new task
 const unitAmount = ref<number>(1)
-const unitName = ref<keyof typeof timeUnitToMinutesMap>('minute')
+const unitName = ref<keyof typeof timeUnitToMinutesMap>('day')
 
 // If the selected time unit or amount changes, recalculate the resulting amount of minutes
 watch([unitName, unitAmount], () => {
   if (localTask.value.recurrence) {
-    localTask.value.recurrence.minutes = unitAmount.value * timeUnitToMinutesMap[unitName.value]
+    const key = intervalMap[unitName.value]
+    localTask.value.recurrence.interval = {
+      [key]: unitAmount.value
+    } as Interval
   }
 })
 
@@ -284,7 +306,7 @@ watch(
       // Reset the input values
       localTask.value = getDefaultTaskDefinition()
       unitAmount.value = 1
-      unitName.value = 'minute'
+      unitName.value = 'day'
     }
   }
 )
diff --git a/src/composables/useTasks.ts b/src/composables/useTasks.ts
@@ -4,13 +4,21 @@ import { Ref, ref } from 'vue'
 export type UuidString = Branded<string, 'Uuidstring'>
 export type DateTimeString = Branded<string, 'DateTimeString'>
 
+export type Interval =
+  | { Minutes: number }
+  | { Hourly: number }
+  | { Daily: number }
+  | { Weekly: number }
+  | { Monthly: number }
+  | { Yearly: number }
+
 export interface CreatedTaskDefinition {
   name: string
   desc: string | null
   start: DateTimeString
   recurrence: {
     last_recurrence: DateTimeString | null
-    minutes: number
+    interval: Interval
     exceptions: Array<DateTimeString> | null
   } | null
 }
@@ -45,7 +53,7 @@ export const useTasks = () => {
     if (
       !taskDefinition.name ||
       !taskDefinition.start ||
-      (taskDefinition.recurrence && !taskDefinition.recurrence.minutes)
+      (taskDefinition.recurrence && !taskDefinition.recurrence.interval)
     ) {
       taskCreationError.value = 'Missing required attributes!'
       throw new Error('Missing required attributes')
@@ -57,7 +65,7 @@ export const useTasks = () => {
       start: new Date(taskDefinition.start).toISOString() as DateTimeString,
       recurrence: taskDefinition.recurrence
         ? {
-            minutes: taskDefinition.recurrence.minutes,
+            interval: taskDefinition.recurrence.interval,
             exceptions: taskDefinition.recurrence.exceptions,
             last_recurrence: taskDefinition.recurrence.last_recurrence
           }
@@ -84,7 +92,7 @@ export const useTasks = () => {
       start: new Date(taskDefinition.start).toISOString() as DateTimeString,
       recurrence: taskDefinition.recurrence
         ? {
-            minutes: taskDefinition.recurrence.minutes,
+            interval: taskDefinition.recurrence.interval,
             exceptions: taskDefinition.recurrence.exceptions,
             last_recurrence: taskDefinition.recurrence.last_recurrence
           }
diff --git a/src/helpers/datetime.ts b/src/helpers/datetime.ts
@@ -14,10 +14,6 @@ const week = day * 7
 const month = week * 4
 const year = month * 12
 
-export const enum TimeUnitEnum {
-  NAME,
-  MINUTES
-}
 export const timeUnitToMinutesMap = {
   minute,
   hour,
@@ -27,35 +23,4 @@ export const timeUnitToMinutesMap = {
   year
 } as const
 
-export const timeUnits = [year, month, week, day, hour, minute] as const
-export const convertMinutesToHighestUnit = (minutes: number | undefined) => {
-  if (!minutes) return
-
-  let foundUnit: keyof typeof timeUnitToMinutesMap | undefined
-  let foundAmount
-  for (const unitAmount of timeUnits) {
-    if (minutes % unitAmount === 0) {
-      const foundUnitObj = Object.entries(timeUnitToMinutesMap).find(
-        ({ 1: minutes }) => minutes === unitAmount
-      )
-
-      if (foundUnitObj) {
-        foundUnit = foundUnitObj[TimeUnitEnum.NAME] as keyof typeof timeUnitToMinutesMap
-      }
-
-      foundAmount = minutes / unitAmount
-
-      break
-    }
-  }
-
-  if (foundUnit && foundAmount && foundAmount > 1) {
-    pluralizeUnit(foundUnit)
-  }
-
-  console.log('Found unit: ', foundUnit)
-
-  return [foundAmount, foundUnit?.toLowerCase()]
-}
-
 export const pluralizeUnit = (unit: string) => unit + 's'
diff --git a/src/helpers/task.ts b/src/helpers/task.ts
