kanban-tui 0.9.0

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
128
129
130
131
132

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

impl App {
    pub fn handle_open_filter_dialog(&mut self) {
        if self.focus.active != Focus::Cards || self.selection.active_board_id.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_id) = self.selection.active_board_id.and_then(|id| {
                            self.model
                                .board_by_id_state(id)
                                .loaded()
                                .copied()
                                .map(|b| b.id)
                        }) {
                            {
                                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;
                    }
                    _ => {
                        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) = self
                            .selection
                            .active_board_id
                            .and_then(|id| self.model.board_by_id_state(id).loaded().copied())
                        {
                            {
                                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, None)
                                    );
                                    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()
            );
        }
    }
}