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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
use serde::de::Error as DeError;
use std::collections::HashMap;
use std::sync::{Arc, RwLock};
use super::*;
#[cfg(feature="cache")]
use ::internal::prelude::*;
#[cfg(feature="cache")]
use super::permissions::{self, Permissions};
#[cfg(feature="cache")]
use ::client::CACHE;
pub fn deserialize_emojis<'de, D: Deserializer<'de>>(deserializer: D)
-> StdResult<HashMap<EmojiId, Emoji>, D::Error> {
let vec: Vec<Emoji> = Deserialize::deserialize(deserializer)?;
let mut emojis = HashMap::new();
for emoji in vec {
emojis.insert(emoji.id, emoji);
}
Ok(emojis)
}
pub fn deserialize_guild_channels<'de, D: Deserializer<'de>>(deserializer: D)
-> StdResult<HashMap<ChannelId, Arc<RwLock<GuildChannel>>>, D::Error> {
let vec: Vec<GuildChannel> = Deserialize::deserialize(deserializer)?;
let mut map = HashMap::new();
for channel in vec {
map.insert(channel.id, Arc::new(RwLock::new(channel)));
}
Ok(map)
}
pub fn deserialize_members<'de, D: Deserializer<'de>>(deserializer: D)
-> StdResult<HashMap<UserId, Member>, D::Error> {
let vec: Vec<Member> = Deserialize::deserialize(deserializer)?;
let mut members = HashMap::new();
for member in vec {
let user_id = member.user.read().unwrap().id;
members.insert(user_id, member);
}
Ok(members)
}
pub fn deserialize_presences<'de, D: Deserializer<'de>>(deserializer: D)
-> StdResult<HashMap<UserId, Presence>, D::Error> {
let vec: Vec<Presence> = Deserialize::deserialize(deserializer)?;
let mut presences = HashMap::new();
for presence in vec {
presences.insert(presence.user_id, presence);
}
Ok(presences)
}
pub fn deserialize_private_channels<'de, D: Deserializer<'de>>(deserializer: D)
-> StdResult<HashMap<ChannelId, Channel>, D::Error> {
let vec: Vec<Channel> = Deserialize::deserialize(deserializer)?;
let mut private_channels = HashMap::new();
for private_channel in vec {
let id = match private_channel {
Channel::Group(ref group) => group.read().unwrap().channel_id,
Channel::Private(ref channel) => channel.read().unwrap().id,
Channel::Guild(_) => unreachable!("Guild private channel decode"),
};
private_channels.insert(id, private_channel);
}
Ok(private_channels)
}
pub fn deserialize_roles<'de, D: Deserializer<'de>>(deserializer: D)
-> StdResult<HashMap<RoleId, Role>, D::Error> {
let vec: Vec<Role> = Deserialize::deserialize(deserializer)?;
let mut roles = HashMap::new();
for role in vec {
roles.insert(role.id, role);
}
Ok(roles)
}
pub fn deserialize_single_recipient<'de, D: Deserializer<'de>>(deserializer: D)
-> StdResult<Arc<RwLock<User>>, D::Error> {
let mut users: Vec<User> = Deserialize::deserialize(deserializer)?;
let user = if users.is_empty() {
return Err(DeError::custom("Expected a single recipient"));
} else {
users.remove(0)
};
Ok(Arc::new(RwLock::new(user)))
}
pub fn deserialize_users<'de, D: Deserializer<'de>>(deserializer: D)
-> StdResult<HashMap<UserId, Arc<RwLock<User>>>, D::Error> {
let vec: Vec<User> = Deserialize::deserialize(deserializer)?;
let mut users = HashMap::new();
for user in vec {
users.insert(user.id, Arc::new(RwLock::new(user)));
}
Ok(users)
}
pub fn deserialize_voice_states<'de, D: Deserializer<'de>>(deserializer: D)
-> StdResult<HashMap<UserId, VoiceState>, D::Error> {
let vec: Vec<VoiceState> = Deserialize::deserialize(deserializer)?;
let mut voice_states = HashMap::new();
for voice_state in vec {
voice_states.insert(voice_state.user_id, voice_state);
}
Ok(voice_states)
}
#[cfg(feature="cache")]
pub fn user_has_perms(channel_id: ChannelId, mut permissions: Permissions) -> Result<bool> {
let cache = CACHE.read().unwrap();
let current_user = &cache.user;
let channel = match cache.channel(channel_id) {
Some(channel) => channel,
None => return Err(Error::Client(ClientError::ItemMissing)),
};
let guild_id = match channel {
Channel::Group(_) | Channel::Private(_) => {
return Ok(permissions == permissions::MANAGE_MESSAGES);
},
Channel::Guild(channel) => channel.read().unwrap().guild_id,
};
let guild = match cache.guild(guild_id) {
Some(guild) => guild,
None => return Err(Error::Client(ClientError::ItemMissing)),
};
let perms = guild.read().unwrap().permissions_for(channel_id, current_user.id);
permissions.remove(perms);
Ok(permissions.is_empty())
}
|