795 lines
28 KiB
Rust
795 lines
28 KiB
Rust
use crate::config::Config;
|
|
use crate::state::{AppState, TimeItem};
|
|
use chrono::Utc;
|
|
use crossterm::event::{Event, KeyCode, KeyEvent, KeyModifiers};
|
|
use serde::Deserialize;
|
|
use std::process::Command;
|
|
|
|
#[derive(Debug, Deserialize, Clone)]
|
|
pub(crate) struct WatsonFrame {
|
|
id: String,
|
|
project: String,
|
|
start: String,
|
|
stop: String,
|
|
tags: Vec<String>,
|
|
}
|
|
|
|
pub enum Screen {
|
|
Main,
|
|
Help,
|
|
ConfigHelp,
|
|
NewEntry,
|
|
ReassignProject,
|
|
LogView,
|
|
}
|
|
|
|
pub enum LogViewPeriod {
|
|
Day,
|
|
Week,
|
|
Month,
|
|
}
|
|
|
|
pub struct App {
|
|
pub state: AppState,
|
|
pub config: Config,
|
|
pub current_screen: Screen,
|
|
pub needs_clear: bool,
|
|
pub new_entry_buffer: String,
|
|
pub new_entry_project: String,
|
|
pub new_entry_cursor: usize,
|
|
pub new_entry_mode: NewEntryMode, // Task or Project
|
|
pub reassign_project_buffer: String,
|
|
pub reassign_project_cursor: usize,
|
|
pub log_view_period: LogViewPeriod,
|
|
pub log_view_frames: Vec<WatsonFrame>,
|
|
pub log_view_content: Vec<String>,
|
|
pub log_view_scroll: usize,
|
|
pub log_view_selected: usize,
|
|
pub clipboard: Option<arboard::Clipboard>,
|
|
pub status_message: Option<(String, std::time::Instant)>,
|
|
}
|
|
|
|
pub enum NewEntryMode {
|
|
Task,
|
|
Project,
|
|
}
|
|
|
|
impl App {
|
|
pub fn new() -> anyhow::Result<Self> {
|
|
Ok(Self {
|
|
state: AppState::load()?,
|
|
config: Config::load()?,
|
|
current_screen: Screen::Main,
|
|
needs_clear: false,
|
|
new_entry_buffer: String::new(),
|
|
new_entry_project: String::new(),
|
|
new_entry_cursor: 0,
|
|
new_entry_mode: NewEntryMode::Task,
|
|
reassign_project_buffer: String::new(),
|
|
reassign_project_cursor: 0,
|
|
log_view_period: LogViewPeriod::Day,
|
|
log_view_frames: Vec::new(),
|
|
log_view_content: Vec::new(),
|
|
log_view_scroll: 0,
|
|
log_view_selected: 0,
|
|
clipboard: arboard::Clipboard::new().ok(),
|
|
status_message: None,
|
|
})
|
|
}
|
|
|
|
pub fn handle_event(&mut self, event: Event) -> anyhow::Result<bool> {
|
|
// Update status message
|
|
self.update_status_message();
|
|
|
|
let previous_screen = std::mem::discriminant(&self.current_screen);
|
|
|
|
let result = match self.current_screen {
|
|
Screen::Main => self.handle_main_event(event),
|
|
Screen::Help => self.handle_help_event(event),
|
|
Screen::ConfigHelp => self.handle_config_help_event(event),
|
|
Screen::NewEntry => self.handle_new_entry_event(event),
|
|
Screen::ReassignProject => self.handle_reassign_project_event(event),
|
|
Screen::LogView => self.handle_log_view_event(event),
|
|
};
|
|
|
|
// If we switched screens, signal that we need to clear
|
|
let current_screen = std::mem::discriminant(&self.current_screen);
|
|
if previous_screen != current_screen {
|
|
self.needs_clear = true;
|
|
}
|
|
|
|
result
|
|
}
|
|
|
|
fn handle_main_event(&mut self, event: Event) -> anyhow::Result<bool> {
|
|
match event {
|
|
Event::Key(KeyEvent {
|
|
code, modifiers, ..
|
|
}) => match (code, modifiers) {
|
|
(KeyCode::Char('q'), _) => return Ok(true),
|
|
(KeyCode::Char('j'), _) | (KeyCode::Down, _) => self.move_selection(1),
|
|
(KeyCode::Char('k'), _) | (KeyCode::Up, _) => self.move_selection(-1),
|
|
(KeyCode::Char('h'), _) | (KeyCode::Left, _) => self.change_pane(-1),
|
|
(KeyCode::Char('l'), _) | (KeyCode::Right, _) => self.change_pane(1),
|
|
(KeyCode::Char('n'), KeyModifiers::CONTROL) => self.change_pane(1),
|
|
(KeyCode::Char('p'), KeyModifiers::CONTROL) => self.change_pane(-1),
|
|
(KeyCode::Enter, _) => self.toggle_current_item()?,
|
|
(KeyCode::Char('e'), KeyModifiers::CONTROL) => self.edit_config()?,
|
|
(KeyCode::Char('?'), _) => self.current_screen = Screen::Help,
|
|
(KeyCode::Char('c'), _) => self.edit_app_config()?,
|
|
(KeyCode::Char('n'), _) => self.start_new_entry(),
|
|
(KeyCode::Char('p'), _) => self.start_reassign_project(),
|
|
(KeyCode::Char('v'), _) => self.start_log_view()?,
|
|
(KeyCode::Char('d'), _) => self.delete_current_item()?,
|
|
_ => {}
|
|
},
|
|
_ => {}
|
|
}
|
|
Ok(false)
|
|
}
|
|
|
|
fn handle_new_entry_event(&mut self, event: Event) -> anyhow::Result<bool> {
|
|
match event {
|
|
Event::Key(KeyEvent {
|
|
code, modifiers, ..
|
|
}) => {
|
|
match (code, modifiers) {
|
|
(KeyCode::Esc, _) => {
|
|
self.current_screen = Screen::Main;
|
|
self.new_entry_buffer.clear();
|
|
self.new_entry_project.clear();
|
|
self.new_entry_mode = NewEntryMode::Task;
|
|
self.new_entry_cursor = 0;
|
|
}
|
|
(KeyCode::Enter, _) => {
|
|
match self.new_entry_mode {
|
|
NewEntryMode::Task => {
|
|
if !self.new_entry_buffer.is_empty() {
|
|
self.new_entry_mode = NewEntryMode::Project;
|
|
self.new_entry_cursor = self.new_entry_project.len();
|
|
}
|
|
}
|
|
NewEntryMode::Project => {
|
|
if self.new_entry_project.is_empty()
|
|
|| self.config.is_valid_project(&self.new_entry_project)
|
|
{
|
|
// Create new time item
|
|
let item = TimeItem {
|
|
name: self.new_entry_buffer.clone(),
|
|
tags: if self.new_entry_project.is_empty() {
|
|
vec![]
|
|
} else {
|
|
vec![self.new_entry_project.clone()]
|
|
},
|
|
last_used: Some(Utc::now()),
|
|
};
|
|
// Add to current pane (or recurring if in recent)
|
|
match self.state.current_pane {
|
|
0 => self.state.permanent_items.push(item), // Permanent Items
|
|
1 => self.state.recurring_items.push(item), // Recurring Items
|
|
2 => self.state.recent_items.push(item), // Ad-Hoc Items
|
|
_ => unreachable!(),
|
|
}
|
|
self.state.save()?;
|
|
|
|
// Clear and return to main screen
|
|
self.current_screen = Screen::Main;
|
|
self.new_entry_buffer.clear();
|
|
self.new_entry_project.clear();
|
|
self.new_entry_mode = NewEntryMode::Task;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
(KeyCode::Backspace, _) => match self.new_entry_mode {
|
|
NewEntryMode::Task => {
|
|
if self.new_entry_cursor > 0 {
|
|
self.new_entry_buffer.remove(self.new_entry_cursor - 1);
|
|
self.new_entry_cursor -= 1;
|
|
}
|
|
}
|
|
NewEntryMode::Project => {
|
|
if self.new_entry_cursor > 0 {
|
|
let idx = self.new_entry_cursor - 1;
|
|
if idx < self.new_entry_project.len() {
|
|
self.new_entry_project.remove(idx);
|
|
self.new_entry_cursor -= 1;
|
|
}
|
|
}
|
|
}
|
|
},
|
|
(KeyCode::Char(c), m) if m.is_empty() => match self.new_entry_mode {
|
|
NewEntryMode::Task => {
|
|
self.new_entry_buffer.insert(self.new_entry_cursor, c);
|
|
self.new_entry_cursor += 1;
|
|
}
|
|
NewEntryMode::Project => {
|
|
if self.new_entry_cursor <= self.new_entry_project.len() {
|
|
self.new_entry_project.insert(self.new_entry_cursor, c);
|
|
self.new_entry_cursor += 1;
|
|
}
|
|
}
|
|
},
|
|
_ => {}
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
Ok(false)
|
|
}
|
|
|
|
fn handle_help_event(&mut self, event: Event) -> anyhow::Result<bool> {
|
|
match event {
|
|
Event::Key(KeyEvent { code, .. }) => match code {
|
|
KeyCode::Char('c') => self.current_screen = Screen::ConfigHelp,
|
|
KeyCode::Esc | KeyCode::Char('q') => self.current_screen = Screen::Main,
|
|
_ => {}
|
|
},
|
|
_ => {}
|
|
}
|
|
Ok(false)
|
|
}
|
|
|
|
fn handle_config_help_event(&mut self, event: Event) -> anyhow::Result<bool> {
|
|
match event {
|
|
Event::Key(KeyEvent { code, .. }) => match code {
|
|
KeyCode::Esc | KeyCode::Char('q') => self.current_screen = Screen::Help,
|
|
_ => {}
|
|
},
|
|
_ => {}
|
|
}
|
|
Ok(false)
|
|
}
|
|
|
|
fn handle_reassign_project_event(&mut self, event: Event) -> anyhow::Result<bool> {
|
|
match event {
|
|
Event::Key(KeyEvent {
|
|
code, modifiers, ..
|
|
}) => {
|
|
match (code, modifiers) {
|
|
(KeyCode::Esc, _) => {
|
|
self.current_screen = Screen::Main;
|
|
self.reassign_project_buffer.clear();
|
|
self.reassign_project_cursor = 0;
|
|
}
|
|
(KeyCode::Enter, _) => {
|
|
if self.reassign_project_buffer.is_empty()
|
|
|| self.config.is_valid_project(&self.reassign_project_buffer)
|
|
{
|
|
self.reassign_project_for_current_item()?;
|
|
self.current_screen = Screen::Main;
|
|
self.reassign_project_buffer.clear();
|
|
self.reassign_project_cursor = 0;
|
|
}
|
|
}
|
|
(KeyCode::Backspace, _) => {
|
|
if self.reassign_project_cursor > 0 {
|
|
let idx = self.reassign_project_cursor - 1;
|
|
if idx < self.reassign_project_buffer.len() {
|
|
self.reassign_project_buffer.remove(idx);
|
|
self.reassign_project_cursor -= 1;
|
|
}
|
|
}
|
|
}
|
|
(KeyCode::Char(c), m) if m.is_empty() => {
|
|
if self.reassign_project_cursor <= self.reassign_project_buffer.len() {
|
|
self.reassign_project_buffer.insert(self.reassign_project_cursor, c);
|
|
self.reassign_project_cursor += 1;
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
Ok(false)
|
|
}
|
|
|
|
fn handle_log_view_event(&mut self, event: Event) -> anyhow::Result<bool> {
|
|
match event {
|
|
Event::Key(KeyEvent { code, .. }) => match code {
|
|
KeyCode::Esc | KeyCode::Char('q') => {
|
|
self.current_screen = Screen::Main;
|
|
self.log_view_scroll = 0;
|
|
self.log_view_selected = 0;
|
|
self.needs_clear = true;
|
|
}
|
|
KeyCode::Char('d') => {
|
|
self.log_view_period = LogViewPeriod::Day;
|
|
self.log_view_scroll = 0;
|
|
self.log_view_selected = 0;
|
|
self.load_log_content()?;
|
|
self.needs_clear = true;
|
|
}
|
|
KeyCode::Char('w') => {
|
|
self.log_view_period = LogViewPeriod::Week;
|
|
self.log_view_scroll = 0;
|
|
self.log_view_selected = 0;
|
|
self.load_log_content()?;
|
|
self.needs_clear = true;
|
|
}
|
|
KeyCode::Char('m') => {
|
|
self.log_view_period = LogViewPeriod::Month;
|
|
self.log_view_scroll = 0;
|
|
self.log_view_selected = 0;
|
|
self.load_log_content()?;
|
|
self.needs_clear = true;
|
|
}
|
|
KeyCode::Char('j') | KeyCode::Down => {
|
|
if self.log_view_selected < self.log_view_frames.len().saturating_sub(1) {
|
|
self.log_view_selected += 1;
|
|
}
|
|
}
|
|
KeyCode::Char('k') | KeyCode::Up => {
|
|
if self.log_view_selected > 0 {
|
|
self.log_view_selected -= 1;
|
|
}
|
|
}
|
|
KeyCode::Char('e') => {
|
|
self.edit_selected_frame()?;
|
|
}
|
|
KeyCode::Char('x') => {
|
|
self.delete_selected_frame()?;
|
|
}
|
|
KeyCode::Char('c') => {
|
|
self.copy_log_to_clipboard()?;
|
|
}
|
|
KeyCode::PageDown => {
|
|
self.log_view_selected = (self.log_view_selected + 10)
|
|
.min(self.log_view_frames.len().saturating_sub(1));
|
|
}
|
|
KeyCode::PageUp => {
|
|
self.log_view_selected = self.log_view_selected.saturating_sub(10);
|
|
}
|
|
_ => {}
|
|
},
|
|
_ => {}
|
|
}
|
|
Ok(false)
|
|
}
|
|
|
|
fn format_log_entries(&mut self) {
|
|
use chrono::{DateTime, Local, Timelike};
|
|
use std::collections::BTreeMap;
|
|
|
|
if self.log_view_frames.is_empty() {
|
|
self.log_view_content = vec!["No log entries for this period.".to_string()];
|
|
return;
|
|
}
|
|
|
|
// Group frames by date
|
|
let mut by_date: BTreeMap<String, Vec<&WatsonFrame>> = BTreeMap::new();
|
|
|
|
for frame in &self.log_view_frames {
|
|
if let Ok(start_dt) = DateTime::parse_from_rfc3339(&frame.start) {
|
|
let local_dt: DateTime<Local> = start_dt.into();
|
|
let date_key = local_dt.format("%A %d %B %Y").to_string();
|
|
by_date.entry(date_key).or_insert_with(Vec::new).push(frame);
|
|
}
|
|
}
|
|
|
|
let mut lines = Vec::new();
|
|
|
|
for (date, frames) in by_date.iter().rev() {
|
|
lines.push(date.clone());
|
|
|
|
for frame in frames {
|
|
if let (Ok(start_dt), Ok(stop_dt)) = (
|
|
DateTime::parse_from_rfc3339(&frame.start),
|
|
DateTime::parse_from_rfc3339(&frame.stop),
|
|
) {
|
|
let start_local: DateTime<Local> = start_dt.into();
|
|
let stop_local: DateTime<Local> = stop_dt.into();
|
|
|
|
let start_time = format!("{:02}:{:02}", start_local.hour(), start_local.minute());
|
|
let stop_time = format!("{:02}:{:02}", stop_local.hour(), stop_local.minute());
|
|
|
|
let tags_str = if frame.tags.is_empty() {
|
|
String::new()
|
|
} else {
|
|
format!(" [{}]", frame.tags.join(", "))
|
|
};
|
|
|
|
lines.push(format!(
|
|
"\t{} to {} {}{}",
|
|
start_time, stop_time, frame.project, tags_str
|
|
));
|
|
}
|
|
}
|
|
lines.push(String::new()); // Empty line between dates
|
|
}
|
|
|
|
self.log_view_content = lines;
|
|
}
|
|
|
|
fn edit_selected_frame(&mut self) -> anyhow::Result<()> {
|
|
if self.log_view_frames.is_empty() || self.log_view_selected >= self.log_view_frames.len() {
|
|
return Ok(());
|
|
}
|
|
|
|
let frame_id = &self.log_view_frames[self.log_view_selected].id;
|
|
|
|
use crossterm::{
|
|
execute,
|
|
terminal::{disable_raw_mode, enable_raw_mode},
|
|
terminal::{EnterAlternateScreen, LeaveAlternateScreen},
|
|
};
|
|
use std::io::stdout;
|
|
|
|
// Leave TUI mode
|
|
disable_raw_mode()?;
|
|
execute!(stdout(), LeaveAlternateScreen)?;
|
|
|
|
// Run watson edit
|
|
let status = Command::new("watson").arg("edit").arg(frame_id).status()?;
|
|
|
|
// Return to TUI mode
|
|
execute!(stdout(), EnterAlternateScreen)?;
|
|
enable_raw_mode()?;
|
|
|
|
if status.success() {
|
|
// Reload log content
|
|
self.load_log_content()?;
|
|
}
|
|
|
|
self.needs_clear = true;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn delete_selected_frame(&mut self) -> anyhow::Result<()> {
|
|
if self.log_view_frames.is_empty() || self.log_view_selected >= self.log_view_frames.len() {
|
|
return Ok(());
|
|
}
|
|
|
|
let frame_id = self.log_view_frames[self.log_view_selected].id.clone();
|
|
|
|
// Run watson remove with --force flag (no confirmation)
|
|
let output = Command::new("watson")
|
|
.arg("remove")
|
|
.arg("--force")
|
|
.arg(&frame_id)
|
|
.output()?;
|
|
|
|
if output.status.success() {
|
|
// Reload log content
|
|
self.load_log_content()?;
|
|
|
|
// Adjust selection if we deleted the last item
|
|
if self.log_view_selected >= self.log_view_frames.len() && !self.log_view_frames.is_empty() {
|
|
self.log_view_selected = self.log_view_frames.len() - 1;
|
|
}
|
|
}
|
|
|
|
self.needs_clear = true;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn copy_log_to_clipboard(&mut self) -> anyhow::Result<()> {
|
|
if self.log_view_content.is_empty() {
|
|
return Ok(());
|
|
}
|
|
|
|
// Join all the formatted log content
|
|
let text = self.log_view_content.join("\n");
|
|
|
|
// Copy to clipboard using the persistent clipboard instance
|
|
if let Some(ref mut clipboard) = self.clipboard {
|
|
if let Err(e) = clipboard.set_text(&text) {
|
|
self.set_status_message(format!("Failed to copy: {}", e));
|
|
}
|
|
// Success - clipboard instance stays alive in App struct
|
|
} else {
|
|
// Try to create a new clipboard if we don't have one
|
|
match arboard::Clipboard::new() {
|
|
Ok(mut clipboard) => {
|
|
if let Err(e) = clipboard.set_text(&text) {
|
|
self.set_status_message(format!("Failed to copy: {}", e));
|
|
}
|
|
// Store it for future use
|
|
self.clipboard = Some(clipboard);
|
|
}
|
|
Err(e) => {
|
|
self.set_status_message(format!("Failed to access clipboard: {}", e));
|
|
}
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn move_selection(&mut self, delta: i32) {
|
|
let items_len = match self.state.current_pane {
|
|
0 => self.state.permanent_items.len(),
|
|
1 => self.state.recurring_items.len(),
|
|
2 => self.state.recent_items.len(),
|
|
_ => return,
|
|
};
|
|
|
|
if items_len == 0 {
|
|
return;
|
|
}
|
|
|
|
let current = self.state.selected_indices[self.state.current_pane] as i32;
|
|
let new_index = (current + delta).rem_euclid(items_len as i32) as usize;
|
|
self.state.selected_indices[self.state.current_pane] = new_index;
|
|
}
|
|
|
|
fn change_pane(&mut self, delta: i32) {
|
|
self.state.current_pane = ((self.state.current_pane as i32 + delta).rem_euclid(3)) as usize;
|
|
}
|
|
|
|
fn get_current_item(&self) -> Option<TimeItem> {
|
|
let items = match self.state.current_pane {
|
|
0 => &self.state.permanent_items,
|
|
1 => &self.state.recurring_items,
|
|
2 => &self.state.recent_items,
|
|
_ => return None,
|
|
};
|
|
|
|
let index = self.state.selected_indices[self.state.current_pane];
|
|
items.get(index).cloned()
|
|
}
|
|
|
|
fn toggle_current_item(&mut self) -> anyhow::Result<()> {
|
|
if let Some(item) = self.get_current_item() {
|
|
if self
|
|
.state
|
|
.active_timer
|
|
.as_ref()
|
|
.map(|(active, _)| active.name == item.name)
|
|
.unwrap_or(false)
|
|
{
|
|
self.state.stop_timer()?;
|
|
} else {
|
|
self.state.start_timer(item)?;
|
|
}
|
|
self.state.save()?;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn delete_current_item(&mut self) -> anyhow::Result<()> {
|
|
// Check if this is the active timer
|
|
let should_stop = {
|
|
let items = match self.state.current_pane {
|
|
0 => &self.state.permanent_items,
|
|
1 => &self.state.recurring_items,
|
|
2 => &self.state.recent_items,
|
|
_ => return Ok(()),
|
|
};
|
|
|
|
let index = self.state.selected_indices[self.state.current_pane];
|
|
|
|
if !items.is_empty() && index < items.len() {
|
|
if let Some((ref active, _)) = self.state.active_timer {
|
|
items[index].name == active.name
|
|
} else {
|
|
false
|
|
}
|
|
} else {
|
|
return Ok(());
|
|
}
|
|
};
|
|
|
|
// Stop timer if needed
|
|
if should_stop {
|
|
self.state.stop_timer()?;
|
|
}
|
|
|
|
// Now delete the item
|
|
let items = match self.state.current_pane {
|
|
0 => &mut self.state.permanent_items,
|
|
1 => &mut self.state.recurring_items,
|
|
2 => &mut self.state.recent_items,
|
|
_ => return Ok(()),
|
|
};
|
|
|
|
let index = self.state.selected_indices[self.state.current_pane];
|
|
|
|
if !items.is_empty() && index < items.len() {
|
|
// Remove the item
|
|
items.remove(index);
|
|
|
|
// Adjust index if we're at the end
|
|
if !items.is_empty() && index == items.len() {
|
|
self.state.selected_indices[self.state.current_pane] = items.len() - 1;
|
|
}
|
|
|
|
// Save changes
|
|
self.state.save()?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn set_status_message<S: Into<String>>(&mut self, message: S) {
|
|
self.status_message = Some((message.into(), std::time::Instant::now()));
|
|
}
|
|
|
|
fn update_status_message(&mut self) {
|
|
// Clear status message after 3 seconds
|
|
if let Some((_, instant)) = self.status_message {
|
|
if instant.elapsed().as_secs() >= 3 {
|
|
self.status_message = None;
|
|
}
|
|
}
|
|
}
|
|
|
|
fn start_new_entry(&mut self) {
|
|
self.current_screen = Screen::NewEntry;
|
|
self.new_entry_buffer.clear();
|
|
self.new_entry_project.clear();
|
|
self.new_entry_cursor = 0;
|
|
self.new_entry_mode = NewEntryMode::Task;
|
|
}
|
|
|
|
fn start_reassign_project(&mut self) {
|
|
if let Some(item) = self.get_current_item() {
|
|
self.current_screen = Screen::ReassignProject;
|
|
// Pre-fill with current project if it exists
|
|
self.reassign_project_buffer = item.tags.first().cloned().unwrap_or_default();
|
|
self.reassign_project_cursor = self.reassign_project_buffer.len();
|
|
}
|
|
}
|
|
|
|
fn start_log_view(&mut self) -> anyhow::Result<()> {
|
|
self.current_screen = Screen::LogView;
|
|
self.log_view_period = LogViewPeriod::Day;
|
|
self.log_view_scroll = 0;
|
|
self.load_log_content()?;
|
|
Ok(())
|
|
}
|
|
|
|
fn load_log_content(&mut self) -> anyhow::Result<()> {
|
|
let flag = match self.log_view_period {
|
|
LogViewPeriod::Day => "--day",
|
|
LogViewPeriod::Week => "--week",
|
|
LogViewPeriod::Month => "--month",
|
|
};
|
|
|
|
let output = Command::new("watson")
|
|
.arg("log")
|
|
.arg(flag)
|
|
.arg("--json")
|
|
.output()?;
|
|
|
|
if output.status.success() {
|
|
let json_str = String::from_utf8_lossy(&output.stdout);
|
|
|
|
// Parse JSON frames
|
|
match serde_json::from_str::<Vec<WatsonFrame>>(&json_str) {
|
|
Ok(frames) => {
|
|
self.log_view_frames = frames;
|
|
self.format_log_entries();
|
|
}
|
|
Err(e) => {
|
|
self.log_view_frames.clear();
|
|
self.log_view_content = vec![
|
|
"Failed to parse Watson log JSON:".to_string(),
|
|
e.to_string(),
|
|
];
|
|
}
|
|
}
|
|
} else {
|
|
let error = String::from_utf8_lossy(&output.stderr);
|
|
self.log_view_frames.clear();
|
|
self.log_view_content = vec![
|
|
"Failed to load Watson log:".to_string(),
|
|
error.to_string(),
|
|
];
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn reassign_project_for_current_item(&mut self) -> anyhow::Result<()> {
|
|
let items = match self.state.current_pane {
|
|
0 => &mut self.state.permanent_items,
|
|
1 => &mut self.state.recurring_items,
|
|
2 => &mut self.state.recent_items,
|
|
_ => return Ok(()),
|
|
};
|
|
|
|
let index = self.state.selected_indices[self.state.current_pane];
|
|
|
|
let needs_restart = if let Some(item) = items.get_mut(index) {
|
|
// Update the tags
|
|
if self.reassign_project_buffer.is_empty() {
|
|
item.tags.clear();
|
|
} else {
|
|
item.tags = vec![self.reassign_project_buffer.clone()];
|
|
}
|
|
|
|
// Check if this is the active timer
|
|
self.state
|
|
.active_timer
|
|
.as_ref()
|
|
.map(|(active, _)| active.name == item.name)
|
|
.unwrap_or(false)
|
|
} else {
|
|
false
|
|
};
|
|
|
|
// If this was the active timer, restart it with new tags
|
|
if needs_restart {
|
|
let item = items[index].clone();
|
|
self.state.stop_timer()?;
|
|
self.state.start_timer(item)?;
|
|
}
|
|
|
|
self.state.save()?;
|
|
Ok(())
|
|
}
|
|
|
|
fn edit_app_config(&mut self) -> anyhow::Result<()> {
|
|
use crossterm::{
|
|
execute,
|
|
terminal::{disable_raw_mode, enable_raw_mode},
|
|
terminal::{EnterAlternateScreen, LeaveAlternateScreen},
|
|
};
|
|
use std::io::stdout;
|
|
|
|
let editor = std::env::var("EDITOR").unwrap_or_else(|_| "vi".to_string());
|
|
let config_path = Config::config_path()?;
|
|
|
|
// Leave TUI mode
|
|
disable_raw_mode()?;
|
|
execute!(stdout(), LeaveAlternateScreen)?;
|
|
|
|
// Run editor
|
|
let status = Command::new(editor).arg(&config_path).status()?;
|
|
|
|
if status.success() {
|
|
// Reload entire application state
|
|
self.config = Config::load()?;
|
|
self.current_screen = Screen::Main;
|
|
}
|
|
|
|
// Return to TUI mode
|
|
execute!(stdout(), EnterAlternateScreen)?;
|
|
enable_raw_mode()?;
|
|
|
|
self.needs_clear = true;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn edit_config(&mut self) -> anyhow::Result<()> {
|
|
use crossterm::{
|
|
execute,
|
|
terminal::{disable_raw_mode, enable_raw_mode},
|
|
terminal::{EnterAlternateScreen, LeaveAlternateScreen},
|
|
};
|
|
use std::io::stdout;
|
|
|
|
let editor = std::env::var("EDITOR").unwrap_or_else(|_| "vi".to_string());
|
|
let config_path = AppState::config_file()?;
|
|
|
|
if !config_path.exists() {
|
|
std::fs::write(&config_path, "# WAT Configuration\n# Add your permanent items here\n\npermanent_items:\n - name: Daily Standup\n tags: [daily, meeting]\n")?;
|
|
}
|
|
|
|
// Leave TUI mode
|
|
disable_raw_mode()?;
|
|
execute!(stdout(), LeaveAlternateScreen)?;
|
|
|
|
// Run editor
|
|
let status = Command::new(editor).arg(&config_path).status()?;
|
|
|
|
if status.success() {
|
|
// Reload entire application state
|
|
self.state = AppState::load()?;
|
|
self.current_screen = Screen::Main;
|
|
}
|
|
|
|
// Return to TUI mode
|
|
execute!(stdout(), EnterAlternateScreen)?;
|
|
enable_raw_mode()?;
|
|
|
|
self.needs_clear = true;
|
|
|
|
Ok(())
|
|
}
|
|
}
|