kanban-tui 0.7.2

Terminal user interface for the kanban project management tool
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use crate::app::{App, DialogMode, Focus};
use crate::filters::{FilterDialogSection, FilterDialogState};
use crossterm::event::KeyCode;
use kanban_domain::CardFilters;

impl App {
    pub fn handle_open_filter_dialog(&mut self) {
        if self.focus.active != Focus::Cards || self.selection.active_board_index.is_none() {
            return;
        }

        let filters = CardFilters {
            show_unassigned_sprints: self.filter.hide_assigned_cards,
            selected_sprint_ids: self.filter.active_sprint_filters.clone(),
            date_from: None,
            date_to: None,
            selected_tags: Default::default(),
        };

        self.filter.dialog_state = Some(FilterDialogState::new(filters));
        self.open_dialog(DialogMode::FilterOptions);
    }

    pub fn handle_filter_options_popup(&mut self, key_code: KeyCode) {
        use crossterm::event::KeyCode;

        if let Some(ref mut dialog_state) = self.filter.dialog_state {
            match key_code {
                KeyCode::Esc => {
                    self.filter.dialog_state = None;
                    self.pop_mode();
                }
                KeyCode::Char('j') | KeyCode::Down => match dialog_state.current_section {
                    FilterDialogSection::Sprints => {
                        if let Some(board_idx) = self.selection.active_board_index {
                            if let Some(board) = self.model.boards().get(board_idx) {
                                let sprint_count = self
                                    .model
                                    .sprints()
                                    .iter()
                                    .filter(|s| s.board_id == board.id)
                                    .count();
                                let total_items = 1 + sprint_count;
                                if dialog_state.item_selection < total_items.saturating_sub(1) {
                                    dialog_state.item_selection += 1;
                                } else {
                                    dialog_state.next_section();
                                }
                            }
                        }
                    }
                    _ => {
                        dialog_state.next_section();
                    }
                },
                KeyCode::Char('k') | KeyCode::Up => match dialog_state.current_section {
                    FilterDialogSection::Sprints => {
                        if dialog_state.item_selection > 0 {
                            dialog_state.item_selection -= 1;
                        } else {
                            dialog_state.prev_section();
                        }
                    }
                    _ => {
                        dialog_state.prev_section();
                    }
                },
                KeyCode::Char(' ') => {
                    if dialog_state.current_section == FilterDialogSection::Sprints {
                        if dialog_state.item_selection == 0 {
                            dialog_state.filters.show_unassigned_sprints =
                                !dialog_state.filters.show_unassigned_sprints;
                            tracing::info!(
                                "Toggled unassigned sprints filter: {}",
                                dialog_state.filters.show_unassigned_sprints
                            );
                            self.apply_filters();
                        } else if let Some(board_idx) = self.selection.active_board_index {
                            let boards = self.model.boards();
                            if let Some(board) = boards.get(board_idx) {
                                let sprints = self.model.sprints();
                                let board_sprints: Vec<_> =
                                    sprints.iter().filter(|s| s.board_id == board.id).collect();

                                let sprint_idx = dialog_state.item_selection - 1;
                                if let Some(sprint) = board_sprints.get(sprint_idx) {
                                    if dialog_state
                                        .filters
                                        .selected_sprint_ids
                                        .contains(&sprint.id)
                                    {
                                        dialog_state.filters.selected_sprint_ids.remove(&sprint.id);
                                    } else {
                                        dialog_state.filters.selected_sprint_ids.insert(sprint.id);
                                    }
                                    tracing::info!(
                                        "Toggled sprint: {}",
                                        sprint.formatted_name(board, "sprint")
                                    );
                                    self.apply_filters();
                                }
                            }
                        }
                    }
                }
                KeyCode::Enter => {
                    self.apply_filters();
                    self.filter.dialog_state = None;
                    self.pop_mode();
                }
                _ => {}
            }
        }
    }

    fn apply_filters(&mut self) {
        if let Some(dialog_state) = &self.filter.dialog_state {
            self.filter.hide_assigned_cards = dialog_state.filters.show_unassigned_sprints;
            self.filter.active_sprint_filters = dialog_state.filters.selected_sprint_ids.clone();
            tracing::info!(
                "Applied filters: unassigned={}, sprints={}",
                self.filter.hide_assigned_cards,
                self.filter.active_sprint_filters.len()
            );
        }
    }
}