Reset daily functionality added

Author: Per-Gunnar Eriksson

src/commands/hello.rs

@@ -1,7 +1,8 @@
 use anyhow::Result;
+use chrono::{Local, NaiveTime, TimeZone};
 
 use crate::config::Config;
-use crate::entry::{Entry, HELLO_ENTRY_NAME};
+use crate::entry::{Entry, HELLO_ENTRY_NAME, MIDNIGHT_SEPARATOR_PREFIX};
 use crate::storage;
 use crate::util;
 
@@ -10,15 +11,48 @@ pub fn execute(cli: &crate::Cli, config: &Config) -> Result<()> {
     // Determine current time, either from command line or system
     let now = util::parse_now_arg(cli.now.as_deref())?;
 
-    // Create a hello entry
-    let entry = Entry::new(now, HELLO_ENTRY_NAME.to_string(), false, None);
-    
     // Get data file path
     let data_file = cli.data.as_ref().map(std::path::PathBuf::from).unwrap_or_else(|| config.data_file.clone());
 
     // Create directory structure if needed
     crate::config::ensure_data_dir(&data_file)?;
 
+    // Check if there are existing entries
+    let existing_entries = storage::read_entries(&data_file)?;
+    
+    // Check if we need to create a midnight separator
+    let create_midnight_separator = if !existing_entries.is_empty() {
+        let last_entry = existing_entries.last().unwrap();
+        let last_entry_date = last_entry.datetime.date_naive();
+        let current_date = now.date_naive();
+        
+        // If the last entry is from a previous day, we should add a midnight separator
+        last_entry_date < current_date
+    } else {
+        false
+    };
+    
+    // If needed, add a midnight separator entry
+    if create_midnight_separator {
+        // Create a midnight entry at 00:00 of the current day
+        let midnight_naive = now.date_naive().and_time(NaiveTime::from_hms_opt(0, 0, 0).unwrap());
+        let midnight = Local.from_local_datetime(&midnight_naive).single().unwrap();
+        
+        // Create a midnight separator entry
+        let midnight_entry = Entry::new(
+            midnight, 
+            format!("{}", MIDNIGHT_SEPARATOR_PREFIX), 
+            false, 
+            None
+        );
+        
+        // Write the midnight separator to the log file
+        storage::append_entry(&data_file, &midnight_entry)?;
+    }
+    
+    // Create a hello entry
+    let entry = Entry::new(now, HELLO_ENTRY_NAME.to_string(), false, None);
+    
     // Write the entry to the log file
     storage::append_entry(&data_file, &entry)?;
 

src/commands/report.rs

@@ -32,27 +32,39 @@ pub fn execute(
     // Get data file path
     let data_file = cli.data.as_ref().map(std::path::PathBuf::from).unwrap_or_else(|| config.data_file.clone());
 
-    // Read entries from the log file
-    let entries = storage::read_entries(&data_file)?;
+    // Read all entries from the log file
+    let all_entries = storage::read_entries(&data_file)?;
+    
+    // Filter entries by date range considering midnight separators
+    let filtered_entries = storage::filter_entries_by_date_range(
+        &all_entries, 
+        range.start_date, 
+        range.end_date
+    );
 
     // Convert entries to activities
-    let mut activities = storage::entries_to_activities(&entries);
+    let mut activities = storage::entries_to_activities(&filtered_entries);
 
     // Add current activity if requested
-    if !no_current_activity && !entries.is_empty() {
-        let current_activity_name = if current_activity.is_empty() {
-            "-- Current Activity --"
-        } else {
-            current_activity
-        };
-        
-        let current = storage::create_current_activity(
-            entries.last().unwrap(),
-            now,
-            current_activity_name
-        );
+    if !no_current_activity && !filtered_entries.is_empty() {
+        let last_entry = filtered_entries.last().unwrap();
 
-        activities.push(current);
+        // Only add current activity if the last entry is from today
+        if last_entry.datetime.date_naive() == now.date_naive() {
+            let current_activity_name = if current_activity.is_empty() {
+                "-- Current Activity --"
+            } else {
+                current_activity
+            };
+            
+            let current = storage::create_current_activity(
+                last_entry,
+                now,
+                current_activity_name
+            );
+            
+            activities.push(current);
+        }
     }
 
     // Create report options

src/entry.rs

@@ -5,8 +5,9 @@ use serde::{Deserialize, Serialize};
 use std::fmt;
 use std::hash::{Hash, Hasher};
 
-// Constants for activity types
+// Constants for entry types
 pub const HELLO_ENTRY_NAME: &str = "hello";
+pub const MIDNIGHT_SEPARATOR_PREFIX: &str = "--- Midnight: New Day ---";
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub enum ActivityType {
@@ -135,7 +136,10 @@ impl Activity {
         let duration = end.signed_duration_since(start);
         let project = Entry::new(start, name.clone(), false, None).project();
         let task = Entry::new(start, name.clone(), false, None).task();
-        let activity_type = if name.ends_with("***") {
+        
+        let activity_type = if name.starts_with(MIDNIGHT_SEPARATOR_PREFIX) {
+            ActivityType::Ignored
+        } else if name.ends_with("***") {
             ActivityType::Ignored
         } else if name.ends_with("**") {
             ActivityType::Break

src/storage.rs

@@ -1,10 +1,10 @@
 use anyhow::{Context, Result};
-use chrono::{DateTime, Local};
+use chrono::{DateTime, Local, NaiveDate};
 use std::fs::{self, File, OpenOptions};
 use std::io::{BufRead, BufReader, Read, Seek, SeekFrom, Write};
 use std::path::Path;
 
-use crate::entry::{Activity, Entry};
+use crate::entry::{Activity, Entry, HELLO_ENTRY_NAME, MIDNIGHT_SEPARATOR_PREFIX};
 
 pub fn read_entries(data_file: &Path) -> Result<Vec<Entry>> {
     if !data_file.exists() {
@@ -118,8 +118,18 @@ pub fn entries_to_activities(entries: &[Entry]) -> Vec<Activity> {
         return activities;
     }
 
-    // Create activities from consecutive entries
+    // Create activities from consecutive entries, skipping midnight separators
     for i in 0..entries.len() - 1 {
+        // Skip if this is a midnight separator entry
+        if entries[i+1].name.starts_with(MIDNIGHT_SEPARATOR_PREFIX) {
+            continue;
+        }
+        
+        // Skip if previous entry was a midnight separator
+        if entries[i].name.starts_with(MIDNIGHT_SEPARATOR_PREFIX) {
+            continue;
+        }
+        
         let activity = Activity::new(
             entries[i+1].name.clone(),
             entries[i].datetime,
@@ -134,6 +144,66 @@ pub fn entries_to_activities(entries: &[Entry]) -> Vec<Activity> {
     activities
 }
 
+pub fn filter_entries_by_date_range(entries: &[Entry], start_date: NaiveDate, end_date: NaiveDate) -> Vec<Entry> {
+    let mut filtered_entries = Vec::new();
+    let mut current_day_entries = Vec::new();
+    let mut current_date = None;
+    
+    for entry in entries {
+        let entry_date = entry.datetime.date_naive();
+        
+        // Check if this is a midnight separator
+        if entry.name.starts_with(MIDNIGHT_SEPARATOR_PREFIX) {
+            // Save current day entries if they are in range
+            if let Some(date) = current_date {
+                if date >= start_date && date <= end_date {
+                    filtered_entries.extend(current_day_entries.drain(..));
+                } else {
+                    current_day_entries.clear();
+                }
+            }
+            
+            // Start a new day
+            current_date = Some(entry_date);
+            current_day_entries.push(entry.clone());
+            continue;
+        }
+        
+        // If we've encountered a hello entry without a preceding midnight separator
+        if entry.name == HELLO_ENTRY_NAME && (current_date.is_none() || current_date.unwrap() != entry_date) {
+            // Save current day entries if they are in range
+            if let Some(date) = current_date {
+                if date >= start_date && date <= end_date {
+                    filtered_entries.extend(current_day_entries.drain(..));
+                } else {
+                    current_day_entries.clear();
+                }
+            }
+            
+            // Start a new day
+            current_date = Some(entry_date);
+            current_day_entries.push(entry.clone());
+            continue;
+        }
+        
+        // Regular entry, add to current day
+        if current_date.is_none() {
+            current_date = Some(entry_date);
+        }
+        
+        current_day_entries.push(entry.clone());
+    }
+    
+    // Don't forget to process the last day
+    if let Some(date) = current_date {
+        if date >= start_date && date <= end_date {
+            filtered_entries.extend(current_day_entries);
+        }
+    }
+    
+    filtered_entries
+}
+
 pub fn create_current_activity(
     last_entry: &Entry,
     now: DateTime<Local>,