feat(sickleave): introduce Sick Leave marker day with optional --to range

- Add --pos s (Sick Leave)
- Implement marker-day storage (00:00 sentinel event)
- Add optional --to range (DATE is implicit start)
- Skip weekends, national holidays and existing event dates
- Update list rendering to hide times and exclude ΔWORK
- Refactor add/apply logic and improve CLI validation

Author: umpire274

CHANGELOG.md

@@ -4,25 +4,33 @@
 
 ### Added
 
-- New position: `Sick Leave` (`--pos s`)
-- Optional Sick Leave range support via `--to` (start date is the command `DATE`)
+- New `Sick Leave` position (`--pos s`)
+- Optional range support via `--to` (start date is the command `DATE`)
+- Automatic skipping of:
+    - Weekends (Saturday/Sunday)
+    - National holidays
+    - Dates already containing events
 
 ### Changed
 
-- Sick Leave is stored as a non-working marker day (sentinel event at `00:00`, similar to Holiday)
-- `list` rendering updated for Sick Leave marker days:
-    - IN/OUT/TGT shown as `--:--`
-    - ΔWORK does not contribute to daily/monthly totals
-- CLI validation updated:
+- Sick Leave is now stored as a non-working marker day (sentinel event at `00:00`, similar to Holiday)
+- `list` rendering updated:
+    - IN/OUT/TGT displayed as `--:--`
+    - Sick Leave days do not contribute to ΔWORK totals
+- CLI validation improved:
     - `--to` is only allowed with `--pos s`
-    - If `--to` is omitted, Sick Leave applies to the single `DATE`
-- Migration updated to support `S` position in `events.position` CHECK constraint
-- Improved `add` handler flow to support Sick Leave marker insertion and range insertion
+    - If `--to` is omitted, Sick Leave applies only to the specified `DATE`
+- `recalc_pairs_for_date` updated to accept `&Connection`
+- Refactored `add` flow to cleanly separate:
+    - marker days
+    - working days
+    - range handling
 
 ### Fixed
 
-- Prevented incorrect `00:00` IN time display for Sick Leave in `list`
-- Prevented Sick Leave days from producing surplus/deficit calculations
+- Prevented `00:00` IN time from being displayed for Sick Leave
+- Prevented incorrect surplus/deficit calculations for Sick Leave days
+- Improved argument validation consistency in `add`
 
 ---
 

src/cli/commands/add.rs

@@ -107,11 +107,11 @@ pub fn handle(cmd: &Commands, cfg: &crate::config::Config) -> AppResult<()> {
         let sick_range = validate_sickleave_args(pos_final, Some(d), *to)?;
 
         match sick_range {
-            Some((from_date, to_date)) => {
+            Some((_from_date, to_date)) => {
                 // (opzionale ma consigliato) vieta start/end nel range malattia
                 if start_parsed.is_some() || end_parsed.is_some() {
                     return Err(AppError::InvalidArgs(
-                        "--start/--end cannot be used with --pos s (use only --to)".into(),
+                        "--in/--out cannot be used with --pos s (use only --to)".into(),
                     ));
                 }
 
@@ -126,7 +126,6 @@ pub fn handle(cmd: &Commands, cfg: &crate::config::Config) -> AppResult<()> {
                     None,
                     *edit,
                     *edit_pair,
-                    Some(from_date),
                     Some(to_date),
                     pos.clone(),
                 )?;
@@ -144,7 +143,6 @@ pub fn handle(cmd: &Commands, cfg: &crate::config::Config) -> AppResult<()> {
                     *edit,
                     *edit_pair,
                     None,
-                    None,
                     pos.clone(),
                 )?;
             }

src/core/add.rs

@@ -9,6 +9,7 @@ use crate::models::event::{Event, EventExtras};
 use crate::models::event_type::EventType;
 use crate::models::location::Location;
 use crate::ui::messages::success;
+use crate::utils::date::{is_national_holiday, is_weekend};
 use chrono::{NaiveDate, NaiveTime, Timelike};
 use rusqlite::params;
 
@@ -69,7 +70,6 @@ impl AddLogic {
         end: Option<NaiveTime>,
         edit_mode: bool,
         edit_pair: Option<usize>,
-        from: Option<NaiveDate>,
         to: Option<NaiveDate>,
         pos: Option<String>,
     ) -> AppResult<()> {
@@ -89,8 +89,8 @@ impl AddLogic {
         // ------------------------------------------------
         // Sanity: range args only allowed for SickLeave
         // ------------------------------------------------
-        let range = match (from, to) {
-            (Some(f), Some(t)) => {
+        let range = match (date, to) {
+            (f, Some(t)) => {
                 if pos_final != Location::SickLeave {
                     return Err(AppError::InvalidArgs(
                         "--from/--to can only be used with --pos Malattia".into(),
@@ -102,12 +102,7 @@ impl AddLogic {
                 }
                 Some((f, t))
             }
-            (None, None) => None,
-            _ => {
-                return Err(AppError::InvalidArgs(
-                    "Both --from and --to must be provided together.".into(),
-                ));
-            }
+            (_null, None) => None,
         };
 
         // ------------------------------------------------
@@ -223,19 +218,14 @@ impl AddLogic {
             }
 
             // Range: if omitted -> single-day (date,date)
-            let (from_date, to_date) = match (from, to) {
-                (Some(f), Some(t)) => {
+            let (date, to_date) = match (date, to) {
+                (f, Some(t)) => {
                     if f > t {
                         return Err(AppError::InvalidDateRange { from: f, to: t });
                     }
                     (f, t)
                 }
-                (None, None) => (date, date),
-                _ => {
-                    return Err(AppError::InvalidArgs(
-                        "Both --from and --to must be provided together.".into(),
-                    ));
-                }
+                (_null, None) => (date, date),
             };
 
             // Sentinel time (00:00) like holiday
@@ -244,32 +234,58 @@ impl AddLogic {
 
             let tx = pool.conn.transaction()?;
 
-            let mut day = from_date;
+            let mut inserted = 0usize;
+            let mut skipped_weekend = 0usize;
+            let mut skipped_national = 0usize;
+            let mut skipped_existing = 0usize;
+
+            let mut day = date;
             while day <= to_date {
-                // Check existing events on that day (fail fast)
+                // 1) weekend -> skip
+                if is_weekend(day) {
+                    skipped_weekend += 1;
+                    day = day
+                        .succ_opt()
+                        .ok_or_else(|| AppError::Other("Invalid date increment.".into()))?;
+                    continue;
+                }
+
+                // 2) national holiday -> skip
+                if is_national_holiday(&tx, day)? {
+                    skipped_national += 1;
+                    day = day
+                        .succ_opt()
+                        .ok_or_else(|| AppError::Other("Invalid date increment.".into()))?;
+                    continue;
+                }
+
+                // 3) already has events -> skip
                 let day_str = day.to_string();
                 let exists: i64 = tx.query_row(
                     "SELECT EXISTS(SELECT 1 FROM events WHERE date = ?1 LIMIT 1)",
                     rusqlite::params![day_str],
                     |r| r.get(0),
                 )?;
                 if exists == 1 {
-                    return Err(AppError::InvalidArgs(format!(
-                        "Cannot set Sick Leave on {}: the date already has events.",
-                        day
-                    )));
+                    skipped_existing += 1;
+                    day = day
+                        .succ_opt()
+                        .ok_or_else(|| AppError::Other("Invalid date increment.".into()))?;
+                    continue;
                 }
 
+                // 4) insert marker
                 let ev = build_event_cli(
                     day,
-                    marker_time,
+                    marker_time, // 00:00
                     EventType::In,
                     Location::SickLeave,
                     extras_cli(Some(0), false),
                 );
 
                 insert_event(&tx, &ev)?;
                 recalc_pairs_for_date(&tx, &day)?;
+                inserted += 1;
 
                 day = day
                     .succ_opt()
@@ -278,17 +294,22 @@ impl AddLogic {
 
             tx.commit()?;
 
-            if from_date == to_date {
-                success(format!("Added SICK LEAVE on {}.\n", from_date));
+            // output summary
+            if to_date == date {
+                if inserted == 1 {
+                    success(format!("Added SICK LEAVE on {}.\n", date));
+                } else {
+                    success(format!(
+                        "No Sick Leave inserted on {} (skipped: weekend={}, national_holiday={}, existing_events={}).\n",
+                        date, skipped_weekend, skipped_national, skipped_existing
+                    ));
+                }
             } else {
                 success(format!(
-                    "Added SICK LEAVE from {} to {} ({} days).\n",
-                    from_date,
-                    to_date,
-                    (to_date - from_date).num_days() + 1
+                    "SICK LEAVE range {} → {}: inserted={}, skipped (weekend={}, national_holiday={}, existing_events={}).\n",
+                    date, to_date, inserted, skipped_weekend, skipped_national, skipped_existing
                 ));
             }
-
             return Ok(());
         }
 

src/utils/date.rs

@@ -1,4 +1,5 @@
 use crate::core::calculator::timeline::Timeline;
+use crate::errors::AppResult;
 use crate::models::location::Location;
 use chrono::{Datelike, NaiveDate, Weekday};
 
@@ -159,3 +160,19 @@ pub fn get_day_position(timeline: &Timeline) -> Location {
         Location::Mixed
     }
 }
+
+// helper weekend
+pub fn is_weekend(d: NaiveDate) -> bool {
+    matches!(d.weekday(), Weekday::Sat | Weekday::Sun)
+}
+
+// helper national holiday in DB (position = 'N')
+pub fn is_national_holiday(conn: &rusqlite::Connection, d: NaiveDate) -> AppResult<bool> {
+    let date_str = d.to_string();
+    let exists: i64 = conn.query_row(
+        "SELECT EXISTS(SELECT 1 FROM events WHERE date = ?1 AND position = 'N' LIMIT 1)",
+        rusqlite::params![date_str],
+        |r| r.get(0),
+    )?;
+    Ok(exists == 1)
+}