chore(release): 0.0.1

CHANGELOG.md

@@ -6,11 +6,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-## [0.0.2] - 2025-03-26
-
-### Added
-- add current hours
-
 ## [0.0.1] - 2025-03-25
 
 ### Added

Cargo.toml

@@ -3,7 +3,7 @@ members = ["crates/*"]
 resolver = "2"
 
 [workspace.package]
-version = "0.0.2"
+version = "0.0.1"
 
 [workspace.dependencies]
 clock = { path = "crates/clock" }

crates/clock/src/main.rs

@@ -61,31 +61,28 @@ async fn main() -> anyhow::Result<()> {
 
     match cli.command.expect("to have a command available") {
         Commands::List { limit, project } => {
-            let mut timetable = timetable.clone();
             let days = &timetable
                 .days
-                .iter_mut()
-                .map(|d| {
-                    if let Some(project) = &project {
-                        d.entry = d
-                            .entry
                 .iter()
-                            .filter(|d| d.project.as_ref() == Some(project))
+                .filter(|d| {
-                            .cloned()
+                    if let Some(project) = &project {
-                            .collect::<Vec<_>>();
+                        Some(project) == d.project.as_ref()
-                        d
                     } else {
-                        d
+                        true
                     }
                 })
-                .filter(|d| !d.entry.is_empty())
                 .collect::<Vec<_>>();
             let days = days.iter().rev().take(limit).collect::<Vec<_>>();
 
             for day in days {
                 println!(
-                    "{}{}\n{}\n",
+                    "{}{}{}\n  {}{}\n",
-                    day.date.format("%Y-%m-%d"),
+                    day.clock_in.with_timezone(&Local {}).format("%Y-%m-%d"),
+                    if let Some(project) = &day.project {
+                        format!(" project: {}", project)
+                    } else {
+                        "".into()
+                    },
                     if day.breaks.is_empty() {
                         "".into()
                     } else {
@@ -94,64 +91,28 @@ async fn main() -> anyhow::Result<()> {
                             day.breaks.iter().fold(0, |acc, _| acc + 30)
                         )
                     },
-                    day.entry
+                    day.clock_in.with_timezone(&Local {}).format("%H:%M"),
-                        .iter()
+                    if let Some(clockout) = &day.clock_out {
-                        .map(|e| {
+                        format!(" - {}", clockout.with_timezone(&Local {}).format("%H:%M"))
-                            format!(
-                                " - {} - {}{}",
-                                e.clock_in.with_timezone(&Local {}).format("%H:%M"),
-                                if let Some(clockout) = &e.clock_out {
-                                    clockout
-                                        .with_timezone(&Local {})
-                                        .format("%H:%M")
-                                        .to_string()
-                                } else if day.date == now.date_naive() {
-                                    let working_hours = e.clock_in - now;
-                                    format!(
-                                        "unclosed, current hours: {}h{}m",
-                                        working_hours.num_hours().abs(),
-                                        working_hours.num_minutes().abs() % 60
-                                    )
                     } else {
-                                    "unclosed".into()
+                        " - unclosed".into()
                     },
-                                if let Some(project) = &e.project {
-                                    format!(": project: {}", project)
-                                } else {
-                                    "".into()
-                                }
-                            )
-                        })
-                        .collect::<Vec<_>>()
-                        .join("\n"),
                 )
             }
         }
         Commands::In { project } => {
-            match timetable.get_day(now) {
+            timetable.days.push(Day {
-                Some(d) => {
-                    d.entry.push(ClockIn {
                 clock_in: now,
                 clock_out: None,
+                breaks: Vec::default(),
                 project,
             });
         }
-                None => timetable.days.push(Day {
+        Commands::Out { project } => match timetable.get_day(project, now) {
-                    entry: vec![ClockIn {
-                        clock_in: now,
-                        clock_out: None,
-                        project,
-                    }],
-                    breaks: Vec::default(),
-                    date: now.date_naive(),
-                }),
-            };
-        }
-        Commands::Out { project } => match timetable.get_day_entry(project, now) {
             Some(day) => day.clock_out = Some(now),
             None => todo!(),
         },
-        Commands::Break { project } => match timetable.get_day(now) {
+        Commands::Break { project } => match timetable.get_day(project, now) {
             Some(day) => day.breaks.push(Break {}),
             None => todo!(),
         },
@@ -159,7 +120,6 @@ async fn main() -> anyhow::Result<()> {
             let to_resolve = timetable
                 .days
                 .iter_mut()
-                .flat_map(|d| &mut d.entry)
                 .filter(|d| d.clock_out.is_none())
                 .collect::<Vec<_>>();
 
@@ -244,18 +204,15 @@ fn parse_string_to_time(v: &str) -> anyhow::Result<chrono::NaiveTime> {
         })
         .context("failed to parse int to hour")
 }
-#[derive(Clone, Debug, Serialize, Deserialize)]
-struct ClockIn {
-    clock_in: chrono::DateTime<chrono::Utc>,
-    clock_out: Option<chrono::DateTime<chrono::Utc>>,
-    project: Option<String>,
-}
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
 struct Day {
-    date: chrono::NaiveDate,
+    clock_in: chrono::DateTime<chrono::Utc>,
-    entry: Vec<ClockIn>,
+    clock_out: Option<chrono::DateTime<chrono::Utc>>,
+
     breaks: Vec<Break>,
+
+    project: Option<String>,
 }
 
 #[derive(Default, Clone, Debug, Serialize, Deserialize)]
@@ -267,21 +224,12 @@ struct TimeTable {
 }
 
 impl TimeTable {
-    pub fn get_day(&mut self, now: chrono::DateTime<chrono::Utc>) -> Option<&mut Day> {
+    pub fn get_day(
-        let item = self
-            .days
-            .iter_mut()
-            .find(|d| d.date.format("%Y-%m-%d").to_string() == now.format("%Y-%m-%d").to_string());
-
-        item
-    }
-
-    pub fn get_day_entry(
         &mut self,
         project: Option<String>,
         now: chrono::DateTime<chrono::Utc>,
-    ) -> Option<&mut ClockIn> {
+    ) -> Option<&mut Day> {
-        let item = self.days.iter_mut().flat_map(|d| &mut d.entry).find(|d| {
+        let item = self.days.iter_mut().find(|d| {
             if d.project != project {
                 return false;
             }