concord 2.5.0

A terminal user interface client for Discord
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

use std::collections::{HashMap, VecDeque};

use crate::discord::AppCommand;
use crate::discord::ids::{
    Id,
    marker::{ChannelMarker, GuildMarker, MessageMarker},
};

use super::DashboardState;

#[derive(Debug, Default)]
pub(super) struct ForumPostListState {
    pub(super) active_post_ids: Vec<Id<ChannelMarker>>,
    pub(super) archived_post_ids: Vec<Id<ChannelMarker>>,
    pub(super) has_more: bool,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(super) enum LatestMessageHistoryState {
    Loading,
    Loaded,
    Failed,
}

#[derive(Debug, Default)]
pub(super) struct RequestTrackingState {
    pub(super) forum_post_lists: HashMap<Id<ChannelMarker>, ForumPostListState>,
    latest_message_history: HashMap<Id<ChannelMarker>, LatestMessageHistoryState>,
    pub(super) pending_commands: VecDeque<AppCommand>,
}

impl DashboardState {
    pub(in crate::tui) fn drain_pending_commands(&mut self) -> Vec<AppCommand> {
        self.requests.pending_commands.drain(..).collect()
    }

    pub(in crate::tui) fn enqueue_pending_command(&mut self, command: AppCommand) {
        self.requests.pending_commands.push_back(command);
    }

    pub(super) fn queue_application_command_load(&mut self, guild_id: Option<Id<GuildMarker>>) {
        self.enqueue_pending_command(AppCommand::LoadApplicationCommands { guild_id });
    }

    pub(super) fn queue_ack_channel_command(
        &mut self,
        channel_id: Id<ChannelMarker>,
        message_id: Id<MessageMarker>,
    ) {
        self.enqueue_pending_command(AppCommand::AckChannel {
            channel_id,
            message_id,
        });
    }

    pub(super) fn queue_scheduled_ack_channel_command(
        &mut self,
        channel_id: Id<ChannelMarker>,
        message_id: Id<MessageMarker>,
    ) {
        self.enqueue_pending_command(AppCommand::ScheduleAckChannel {
            channel_id,
            message_id,
        });
    }

    pub(super) fn queue_ack_channels_command(
        &mut self,
        targets: Vec<(Id<ChannelMarker>, Id<MessageMarker>)>,
    ) {
        self.enqueue_pending_command(AppCommand::AckChannels { targets });
    }

    pub(super) fn record_latest_message_history_loaded(&mut self, channel_id: Id<ChannelMarker>) {
        self.requests
            .latest_message_history
            .insert(channel_id, LatestMessageHistoryState::Loaded);
    }

    pub(super) fn record_latest_message_history_loading(&mut self, channel_id: Id<ChannelMarker>) {
        self.requests
            .latest_message_history
            .insert(channel_id, LatestMessageHistoryState::Loading);
    }

    pub(super) fn record_latest_message_history_failed(&mut self, channel_id: Id<ChannelMarker>) {
        self.requests
            .latest_message_history
            .insert(channel_id, LatestMessageHistoryState::Failed);
    }

    pub(super) fn latest_message_history_state(
        &self,
        channel_id: Id<ChannelMarker>,
    ) -> LatestMessageHistoryState {
        self.requests
            .latest_message_history
            .get(&channel_id)
            .copied()
            .unwrap_or(LatestMessageHistoryState::Loading)
    }
}