release: v0.18.0 — multiple availability windows per event type

Add support for multiple time windows per day (e.g. 09:00-12:00 +
13:00-17:00) to create lunch breaks or custom schedules. Dynamic UI
with add/remove buttons, backward-compatible with existing single-window
event types. Also fixes post-action redirects across all dashboard pages.

Closes #5

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: olivierlambert

CHANGELOG.md

@@ -67,9 +67,20 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/), and this
 | Host identity on bookings | 0.17.1 | Avatar, name, and title shown on slot picker for individual bookings |
 | Team link search UX | 0.17.1 | Search + pill selection for team members with avatar previews |
 | Matrix-style initials | 0.17.1 | Two-letter avatar fallback (first+last name initials) across all pages |
+| Multiple availability windows | 0.18.0 | Define morning + afternoon slots with lunch breaks (multiple time windows per event type) |
 
 ## [Unreleased]
 
+## [0.18.0] - 2026-03-11
+
+### Added
+
+- **Multiple availability windows per event type** — define separate time blocks (e.g. 09:00–12:00 + 13:00–17:00) to create lunch breaks or custom schedules. Dynamic "Add time window" UI with add/remove buttons. Backward-compatible with existing single-window event types. Closes #5.
+
+### Fixed
+
+- **Post-action redirects go to correct dashboard page** — creating/deleting team links, event types, bookings, and sources now redirect to their respective page instead of the overview
+
 ## [0.17.6] - 2026-03-11
 
 ### Fixed

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "calrs"
-version = "0.17.6"
+version = "0.18.0"
 edition = "2021"
 description = "A fast, self-hostable scheduling platform. Like Cal.com, but written in Rust."
 license = "AGPL-3.0"

Cargo.toml

@@ -239,6 +239,40 @@ fn format_time_from_dt(dt_str: &str) -> String {
     }
 }
 
+/// Parse availability windows from the form.
+/// Supports new `avail_windows` format ("09:00-12:00,13:00-17:00") with fallback to
+/// legacy single `avail_start`/`avail_end` pair. Returns at least one window.
+fn parse_avail_windows(
+    windows_str: Option<&str>,
+    legacy_start: Option<&str>,
+    legacy_end: Option<&str>,
+) -> Vec<(String, String)> {
+    if let Some(ws) = windows_str.filter(|s| !s.trim().is_empty()) {
+        let parsed: Vec<(String, String)> = ws
+            .split(',')
+            .filter_map(|w| {
+                let parts: Vec<&str> = w.trim().splitn(2, '-').collect();
+                if parts.len() == 2
+                    && NaiveTime::parse_from_str(parts[0], "%H:%M").is_ok()
+                    && NaiveTime::parse_from_str(parts[1], "%H:%M").is_ok()
+                {
+                    Some((parts[0].to_string(), parts[1].to_string()))
+                } else {
+                    None
+                }
+            })
+            .collect();
+        if !parsed.is_empty() {
+            return parsed;
+        }
+    }
+    // Fallback to legacy single window
+    vec![(
+        legacy_start.unwrap_or("09:00").to_string(),
+        legacy_end.unwrap_or("17:00").to_string(),
+    )]
+}
+
 pub fn create_router(pool: SqlitePool, data_dir: PathBuf, secret_key: [u8; 32]) -> Router {
     let mut env = Environment::new();
     env.set_undefined_behavior(minijinja::UndefinedBehavior::Lenient);
@@ -1263,9 +1297,10 @@ struct EventTypeForm {
     location_type: Option<String>,         // "link", "phone", "in_person", "custom"
     location_value: Option<String>,
     // Availability schedule
-    avail_days: Option<String>,  // comma-separated: "1,2,3,4,5"
-    avail_start: Option<String>, // "09:00"
-    avail_end: Option<String>,   // "17:00"
+    avail_days: Option<String>,    // comma-separated: "1,2,3,4,5"
+    avail_start: Option<String>,   // legacy: "09:00"
+    avail_end: Option<String>,     // legacy: "17:00"
+    avail_windows: Option<String>, // "09:00-12:00,13:00-17:00"
     // Group (optional)
     group_id: Option<String>,
     // Calendar selection (comma-separated IDs)
@@ -1435,23 +1470,28 @@ async fn create_event_type(
 
     // Create availability rules
     let avail_days = form.avail_days.as_deref().unwrap_or("1,2,3,4,5");
-    let avail_start = form.avail_start.as_deref().unwrap_or("09:00");
-    let avail_end = form.avail_end.as_deref().unwrap_or("17:00");
+    let windows = parse_avail_windows(
+        form.avail_windows.as_deref(),
+        form.avail_start.as_deref(),
+        form.avail_end.as_deref(),
+    );
 
     for day_str in avail_days.split(',') {
         if let Ok(day) = day_str.trim().parse::<i32>() {
             if (0..=6).contains(&day) {
-                let rule_id = uuid::Uuid::new_v4().to_string();
-                let _ = sqlx::query(
-                    "INSERT INTO availability_rules (id, event_type_id, day_of_week, start_time, end_time) VALUES (?, ?, ?, ?, ?)",
-                )
-                .bind(&rule_id)
-                .bind(&et_id)
-                .bind(day)
-                .bind(avail_start)
-                .bind(avail_end)
-                .execute(&state.pool)
-                .await;
+                for (ws, we) in &windows {
+                    let rule_id = uuid::Uuid::new_v4().to_string();
+                    let _ = sqlx::query(
+                        "INSERT INTO availability_rules (id, event_type_id, day_of_week, start_time, end_time) VALUES (?, ?, ?, ?, ?)",
+                    )
+                    .bind(&rule_id)
+                    .bind(&et_id)
+                    .bind(day)
+                    .bind(ws)
+                    .bind(we)
+                    .execute(&state.pool)
+                    .await;
+                }
             }
         }
     }
@@ -1513,30 +1553,41 @@ async fn edit_event_type_form(
     };
 
     // Get current availability rules
-    let rules: Vec<(i32, String, String)> = sqlx::query_as(
-        "SELECT day_of_week, start_time, end_time FROM availability_rules WHERE event_type_id = ? ORDER BY day_of_week LIMIT 1",
+    let all_rules: Vec<(i32, String, String)> = sqlx::query_as(
+        "SELECT day_of_week, start_time, end_time FROM availability_rules WHERE event_type_id = ? ORDER BY day_of_week, start_time",
     )
     .bind(&et_id)
     .fetch_all(&state.pool)
     .await
     .unwrap_or_default();
 
-    let all_rules: Vec<(i32,)> = sqlx::query_as(
-        "SELECT DISTINCT day_of_week FROM availability_rules WHERE event_type_id = ? ORDER BY day_of_week",
-    )
-    .bind(&et_id)
-    .fetch_all(&state.pool)
-    .await
-    .unwrap_or_default();
+    let avail_days: String = {
+        let mut days: Vec<i32> = all_rules.iter().map(|(d, _, _)| *d).collect();
+        days.sort();
+        days.dedup();
+        days.iter()
+            .map(|d| d.to_string())
+            .collect::<Vec<_>>()
+            .join(",")
+    };
 
-    let avail_days: String = all_rules
+    // Collect distinct time windows (preserving order)
+    let mut windows: Vec<(String, String)> = Vec::new();
+    for (_, s, e) in &all_rules {
+        let pair = (s.clone(), e.clone());
+        if !windows.contains(&pair) {
+            windows.push(pair);
+        }
+    }
+    let avail_windows: String = windows
         .iter()
-        .map(|(d,)| d.to_string())
+        .map(|(s, e)| format!("{}-{}", s, e))
         .collect::<Vec<_>>()
         .join(",");
-    let (avail_start, avail_end) = rules
+    // Legacy fields for backward compat
+    let (avail_start, avail_end) = windows
         .first()
-        .map(|(_, s, e)| (s.clone(), e.clone()))
+        .cloned()
         .unwrap_or_else(|| ("09:00".to_string(), "17:00".to_string()));
 
     // Get user's calendars (is_busy=1) for calendar selection
@@ -1599,6 +1650,7 @@ async fn edit_event_type_form(
             form_avail_days => avail_days,
             form_avail_start => avail_start,
             form_avail_end => avail_end,
+            form_avail_windows => avail_windows,
             form_reminder_minutes => reminder_min.unwrap_or(0),
             error => "",
             sidebar => sidebar_context(&auth_user, "event-types"),
@@ -1692,23 +1744,28 @@ async fn update_event_type(
         .await;
 
     let avail_days = form.avail_days.as_deref().unwrap_or("1,2,3,4,5");
-    let avail_start = form.avail_start.as_deref().unwrap_or("09:00");
-    let avail_end = form.avail_end.as_deref().unwrap_or("17:00");
+    let windows = parse_avail_windows(
+        form.avail_windows.as_deref(),
+        form.avail_start.as_deref(),
+        form.avail_end.as_deref(),
+    );
 
     for day_str in avail_days.split(',') {
         if let Ok(day) = day_str.trim().parse::<i32>() {
             if (0..=6).contains(&day) {
-                let rule_id = uuid::Uuid::new_v4().to_string();
-                let _ = sqlx::query(
-                    "INSERT INTO availability_rules (id, event_type_id, day_of_week, start_time, end_time) VALUES (?, ?, ?, ?, ?)",
-                )
-                .bind(&rule_id)
-                .bind(&et_id)
-                .bind(day)
-                .bind(avail_start)
-                .bind(avail_end)
-                .execute(&state.pool)
-                .await;
+                for (ws, we) in &windows {
+                    let rule_id = uuid::Uuid::new_v4().to_string();
+                    let _ = sqlx::query(
+                        "INSERT INTO availability_rules (id, event_type_id, day_of_week, start_time, end_time) VALUES (?, ?, ?, ?, ?)",
+                    )
+                    .bind(&rule_id)
+                    .bind(&et_id)
+                    .bind(day)
+                    .bind(ws)
+                    .bind(we)
+                    .execute(&state.pool)
+                    .await;
+                }
             }
         }
     }
@@ -3110,6 +3167,7 @@ fn render_event_type_form_error(
             form_avail_days => form.avail_days.as_deref().unwrap_or("1,2,3,4,5"),
             form_avail_start => form.avail_start.as_deref().unwrap_or("09:00"),
             form_avail_end => form.avail_end.as_deref().unwrap_or("17:00"),
+            form_avail_windows => form.avail_windows.as_deref().unwrap_or(""),
             error => error,
             sidebar => sidebar_context(auth_user, "event-types"),
             impersonating => impersonating,
@@ -7590,4 +7648,54 @@ mod tests {
         let tz = parse_guest_tz(None);
         let _ = tz;
     }
+
+    // --- parse_avail_windows tests ---
+
+    #[test]
+    fn parse_avail_windows_single_window() {
+        let w = parse_avail_windows(Some("09:00-17:00"), None, None);
+        assert_eq!(w, vec![("09:00".to_string(), "17:00".to_string())]);
+    }
+
+    #[test]
+    fn parse_avail_windows_multiple_windows() {
+        let w = parse_avail_windows(Some("09:00-12:00,13:00-17:00"), None, None);
+        assert_eq!(
+            w,
+            vec![
+                ("09:00".to_string(), "12:00".to_string()),
+                ("13:00".to_string(), "17:00".to_string()),
+            ]
+        );
+    }
+
+    #[test]
+    fn parse_avail_windows_legacy_fallback() {
+        let w = parse_avail_windows(None, Some("08:00"), Some("16:00"));
+        assert_eq!(w, vec![("08:00".to_string(), "16:00".to_string())]);
+    }
+
+    #[test]
+    fn parse_avail_windows_empty_string_uses_legacy() {
+        let w = parse_avail_windows(Some(""), Some("10:00"), Some("18:00"));
+        assert_eq!(w, vec![("10:00".to_string(), "18:00".to_string())]);
+    }
+
+    #[test]
+    fn parse_avail_windows_invalid_times_ignored() {
+        let w = parse_avail_windows(Some("09:00-12:00,bad-data,13:00-17:00"), None, None);
+        assert_eq!(
+            w,
+            vec![
+                ("09:00".to_string(), "12:00".to_string()),
+                ("13:00".to_string(), "17:00".to_string()),
+            ]
+        );
+    }
+
+    #[test]
+    fn parse_avail_windows_defaults_when_none() {
+        let w = parse_avail_windows(None, None, None);
+        assert_eq!(w, vec![("09:00".to_string(), "17:00".to_string())]);
+    }
 }

src/web/mod.rs

@@ -80,15 +80,12 @@ <h2>Availability</h2>
         <input type="hidden" name="avail_days" id="avail_days" value="{{ form_avail_days }}">
       </div>
 
-      <div style="display: grid; grid-template-columns: 1fr 1fr; gap: 1rem;" class="form-grid-2">
-        <div class="form-group">
-          <label for="avail_start">Start time</label>
-          <input type="time" id="avail_start" name="avail_start" value="{{ form_avail_start }}">
-        </div>
-        <div class="form-group">
-          <label for="avail_end">End time</label>
-          <input type="time" id="avail_end" name="avail_end" value="{{ form_avail_end }}">
-        </div>
+      <div class="form-group">
+        <label>Time windows</label>
+        <div id="time-windows" style="display: flex; flex-direction: column; gap: 0.5rem;"></div>
+        <button type="button" id="add-window-btn" style="margin-top: 0.5rem; padding: 0.375rem 0.75rem; border: 1px dashed var(--border); border-radius: var(--radius); background: transparent; color: var(--text-muted); cursor: pointer; font-size: 0.85rem; transition: all 0.15s ease;">+ Add time window</button>
+        <input type="hidden" name="avail_windows" id="avail_windows" value="{{ form_avail_windows }}">
+        <span class="hint" style="font-size: 0.8rem; color: var(--text-muted); display: block; margin-top: 0.25rem;">Add multiple windows to create breaks (e.g. morning + afternoon with lunch break).</span>
       </div>
     </div>
 
@@ -172,6 +169,56 @@ <h2>Notifications</h2>
     });
   });
 
+  // --- Time windows ---
+  const windowsContainer = document.getElementById('time-windows');
+  const windowsHidden = document.getElementById('avail_windows');
+  const addBtn = document.getElementById('add-window-btn');
+
+  function syncWindows() {
+    const rows = windowsContainer.querySelectorAll('.time-window-row');
+    const vals = [];
+    rows.forEach(row => {
+      const s = row.querySelector('.tw-start').value;
+      const e = row.querySelector('.tw-end').value;
+      if (s && e) vals.push(s + '-' + e);
+    });
+    windowsHidden.value = vals.join(',');
+  }
+
+  function addWindow(start, end) {
+    const row = document.createElement('div');
+    row.className = 'time-window-row';
+    row.style.cssText = 'display:flex;align-items:center;gap:0.5rem;';
+    row.innerHTML =
+      '<input type="time" class="tw-start" value="' + start + '" style="flex:1;padding:0.5rem 0.625rem;border:1px solid var(--border);border-radius:var(--radius);background:var(--surface);color:var(--text);font-family:inherit;font-size:0.925rem;">' +
+      '<span style="color:var(--text-muted);">to</span>' +
+      '<input type="time" class="tw-end" value="' + end + '" style="flex:1;padding:0.5rem 0.625rem;border:1px solid var(--border);border-radius:var(--radius);background:var(--surface);color:var(--text);font-family:inherit;font-size:0.925rem;">' +
+      '<button type="button" class="tw-remove" style="padding:0.25rem 0.5rem;border:none;background:transparent;color:var(--text-muted);cursor:pointer;font-size:1.1rem;line-height:1;" title="Remove">&times;</button>';
+    row.querySelector('.tw-start').addEventListener('change', syncWindows);
+    row.querySelector('.tw-end').addEventListener('change', syncWindows);
+    row.querySelector('.tw-remove').addEventListener('click', () => {
+      row.remove();
+      // Keep at least one window
+      if (!windowsContainer.querySelector('.time-window-row')) addWindow('09:00', '17:00');
+      syncWindows();
+    });
+    windowsContainer.appendChild(row);
+    syncWindows();
+  }
+
+  addBtn.addEventListener('click', () => addWindow('', ''));
+
+  // Initialize from saved value or legacy fields
+  const saved = windowsHidden.value.trim();
+  if (saved) {
+    saved.split(',').forEach(w => {
+      const [s, e] = w.split('-');
+      if (s && e) addWindow(s, e);
+    });
+  } else {
+    addWindow('{{ form_avail_start }}', '{{ form_avail_end }}');
+  }
+
   // Auto-generate slug from title
   {% if not editing %}
   const titleEl = document.getElementById('title');