concord 2.5.10

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
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
133
134

mod state;

use std::collections::BTreeMap;

use serde_json::Value;

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

use super::{ChannelInfo, MemberInfo, MessageInfo, PresenceEventFields};

pub(in crate::discord) use state::ThreadCache;
pub use state::ThreadCreatorState;

/// Cursor used by Discord's public archived-thread endpoint. The first page
/// omits `before`; later pages use the oldest `archive_timestamp` returned by
/// the previous response.
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub(crate) enum ArchivedThreadPageCursor {
    Initial,
    Before(String),
}

impl ArchivedThreadPageCursor {
    pub(crate) fn from_before(before: Option<String>) -> Self {
        before.map_or(Self::Initial, Self::Before)
    }

    pub(crate) fn into_before(self) -> Option<String> {
        match self {
            Self::Initial => None,
            Self::Before(before) => Some(before),
        }
    }
}

/// One page from `GET /channels/{channel.id}/threads/archived/public`.
///
/// `members` contains current-account thread memberships for returned rows. It
/// is not the participant list used by the member pane.
#[derive(Clone, Debug, PartialEq)]
pub struct ArchivedThreadsPage {
    pub threads: Vec<ChannelInfo>,
    pub members: Vec<ThreadMemberInfo>,
    pub has_more: bool,
    pub next_before: Option<String>,
    pub extra_fields: BTreeMap<String, Value>,
}

/// Active thread metadata and the optional current-account membership carried
/// beside a `THREAD_CREATE` or `THREAD_UPDATE` dispatch.
#[derive(Clone, Debug, PartialEq)]
pub struct ThreadGatewayInfo {
    pub channel: ChannelInfo,
    pub current_user_member: Option<ThreadMemberInfo>,
}

/// A replacement snapshot of active threads for a guild or selected parents.
/// The optional parallel member array contains current-account settings only.
/// Discord user-account syncs can omit this field, which means existing
/// membership state must be preserved. It is not the participant list shown in
/// the member pane.
#[derive(Clone, Debug, PartialEq)]
pub struct ThreadListSyncInfo {
    pub guild_id: Id<GuildMarker>,
    pub channel_ids: Option<Vec<Id<ChannelMarker>>>,
    pub threads: Vec<ChannelInfo>,
    pub current_user_members: Option<Vec<ThreadMemberInfo>>,
    pub extra_fields: BTreeMap<String, Value>,
}

#[derive(Clone, Debug, PartialEq)]
pub struct ThreadMemberInfo {
    pub thread_id: Option<Id<ChannelMarker>>,
    pub user_id: Option<Id<UserMarker>>,
    pub join_timestamp: Option<String>,
    pub flags: Option<u64>,
    pub muted: Option<bool>,
    pub mute_end_time: Option<String>,
    pub selected_time_window: Option<i64>,
    pub member: Option<MemberInfo>,
    pub presence: Option<PresenceEventFields>,
    pub extra_fields: BTreeMap<String, Value>,
}

impl ThreadMemberInfo {
    /// User-account guild snapshots only contain threads the current account
    /// has joined. Those channel objects can omit the redundant `member`
    /// object, so preserve the membership fact without inventing settings.
    pub(in crate::discord) fn joined_snapshot(thread_id: Id<ChannelMarker>) -> Self {
        Self {
            thread_id: Some(thread_id),
            user_id: None,
            join_timestamp: None,
            flags: None,
            muted: None,
            mute_end_time: None,
            selected_time_window: None,
            member: None,
            presence: None,
            extra_fields: BTreeMap::new(),
        }
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct ThreadMembersUpdateInfo {
    pub guild_id: Option<Id<GuildMarker>>,
    pub channel_id: Id<ChannelMarker>,
    pub member_count: Option<u64>,
    pub added_members: Vec<ThreadMemberInfo>,
    pub removed_user_ids: Vec<Id<UserMarker>>,
    pub extra_fields: BTreeMap<String, Value>,
}

#[derive(Clone, Debug, PartialEq)]
pub struct ThreadMemberListUpdateInfo {
    pub guild_id: Id<GuildMarker>,
    pub channel_id: Id<ChannelMarker>,
    pub members: Vec<ThreadMemberInfo>,
    pub extra_fields: BTreeMap<String, Value>,
}

/// Owner and starter-message data returned by the forum `post-data` endpoint
/// for a thread ID that was already discovered through Gateway state.
#[derive(Clone, Debug, PartialEq)]
pub struct ForumPostDataInfo {
    pub thread_id: Id<ChannelMarker>,
    pub owner: Option<MemberInfo>,
    pub first_message: Option<MessageInfo>,
    pub extra_fields: BTreeMap<String, Value>,
}