1use crate::Result;
2use rpc::proto;
3use sea_orm::{entity::prelude::*, DbErr};
4use serde::{Deserialize, Serialize};
5
6macro_rules! id_type {
7 ($name:ident) => {
8 #[derive(
9 Clone,
10 Copy,
11 Debug,
12 Default,
13 PartialEq,
14 Eq,
15 PartialOrd,
16 Ord,
17 Hash,
18 Serialize,
19 Deserialize,
20 DeriveValueType,
21 )]
22 #[allow(missing_docs)]
23 #[serde(transparent)]
24 pub struct $name(pub i32);
25
26 impl $name {
27 #[allow(unused)]
28 #[allow(missing_docs)]
29 pub const MAX: Self = Self(i32::MAX);
30
31 #[allow(unused)]
32 #[allow(missing_docs)]
33 pub fn from_proto(value: u64) -> Self {
34 Self(value as i32)
35 }
36
37 #[allow(unused)]
38 #[allow(missing_docs)]
39 pub fn to_proto(self) -> u64 {
40 self.0 as u64
41 }
42 }
43
44 impl std::fmt::Display for $name {
45 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
46 self.0.fmt(f)
47 }
48 }
49
50 impl sea_orm::TryFromU64 for $name {
51 fn try_from_u64(n: u64) -> Result<Self, DbErr> {
52 Ok(Self(n.try_into().map_err(|_| {
53 DbErr::ConvertFromU64(concat!(
54 "error converting ",
55 stringify!($name),
56 " to u64"
57 ))
58 })?))
59 }
60 }
61
62 impl sea_orm::sea_query::Nullable for $name {
63 fn null() -> Value {
64 Value::Int(None)
65 }
66 }
67 };
68}
69
70id_type!(BufferId);
71id_type!(AccessTokenId);
72id_type!(ChannelChatParticipantId);
73id_type!(ChannelId);
74id_type!(ChannelMemberId);
75id_type!(MessageId);
76id_type!(ContactId);
77id_type!(FollowerId);
78id_type!(RoomId);
79id_type!(RoomParticipantId);
80id_type!(ProjectId);
81id_type!(ProjectCollaboratorId);
82id_type!(ReplicaId);
83id_type!(ServerId);
84id_type!(SignupId);
85id_type!(UserId);
86id_type!(ChannelBufferCollaboratorId);
87id_type!(FlagId);
88id_type!(NotificationId);
89id_type!(NotificationKindId);
90
91/// ChannelRole gives you permissions for both channels and calls.
92#[derive(Eq, PartialEq, Copy, Clone, Debug, EnumIter, DeriveActiveEnum, Default, Hash)]
93#[sea_orm(rs_type = "String", db_type = "String(None)")]
94pub enum ChannelRole {
95 /// Admin can read/write and change permissions.
96 #[sea_orm(string_value = "admin")]
97 Admin,
98 /// Member can read/write, but not change pemissions.
99 #[sea_orm(string_value = "member")]
100 #[default]
101 Member,
102 /// Guest can read, but not write.
103 /// (thought they can use the channel chat)
104 #[sea_orm(string_value = "guest")]
105 Guest,
106 /// Banned may not read.
107 #[sea_orm(string_value = "banned")]
108 Banned,
109}
110
111impl ChannelRole {
112 /// Returns true if this role is more powerful than the other role.
113 pub fn should_override(&self, other: Self) -> bool {
114 use ChannelRole::*;
115 match self {
116 Admin => matches!(other, Member | Banned | Guest),
117 Member => matches!(other, Banned | Guest),
118 Banned => matches!(other, Guest),
119 Guest => false,
120 }
121 }
122
123 /// Returns the maximal role between the two
124 pub fn max(&self, other: Self) -> Self {
125 if self.should_override(other) {
126 *self
127 } else {
128 other
129 }
130 }
131
132 /// True if the role allows access to all descendant channels
133 pub fn can_see_all_descendants(&self) -> bool {
134 use ChannelRole::*;
135 match self {
136 Admin | Member => true,
137 Guest | Banned => false,
138 }
139 }
140
141 /// True if the role only allows access to public descendant channels
142 pub fn can_only_see_public_descendants(&self) -> bool {
143 use ChannelRole::*;
144 match self {
145 Guest => true,
146 Admin | Member | Banned => false,
147 }
148 }
149
150 /// True if the role can share screen/microphone/projects into rooms.
151 pub fn can_publish_to_rooms(&self) -> bool {
152 use ChannelRole::*;
153 match self {
154 Admin | Member => true,
155 Guest | Banned => false,
156 }
157 }
158
159 /// True if the role can edit shared projects.
160 pub fn can_edit_projects(&self) -> bool {
161 use ChannelRole::*;
162 match self {
163 Admin | Member => true,
164 Guest | Banned => false,
165 }
166 }
167
168 /// True if the role can read shared projects.
169 pub fn can_read_projects(&self) -> bool {
170 use ChannelRole::*;
171 match self {
172 Admin | Member | Guest => true,
173 Banned => false,
174 }
175 }
176
177 pub fn requires_cla(&self) -> bool {
178 use ChannelRole::*;
179 match self {
180 Admin | Member => true,
181 Banned | Guest => false,
182 }
183 }
184}
185
186impl From<proto::ChannelRole> for ChannelRole {
187 fn from(value: proto::ChannelRole) -> Self {
188 match value {
189 proto::ChannelRole::Admin => ChannelRole::Admin,
190 proto::ChannelRole::Member => ChannelRole::Member,
191 proto::ChannelRole::Guest => ChannelRole::Guest,
192 proto::ChannelRole::Banned => ChannelRole::Banned,
193 }
194 }
195}
196
197impl Into<proto::ChannelRole> for ChannelRole {
198 fn into(self) -> proto::ChannelRole {
199 match self {
200 ChannelRole::Admin => proto::ChannelRole::Admin,
201 ChannelRole::Member => proto::ChannelRole::Member,
202 ChannelRole::Guest => proto::ChannelRole::Guest,
203 ChannelRole::Banned => proto::ChannelRole::Banned,
204 }
205 }
206}
207
208impl Into<i32> for ChannelRole {
209 fn into(self) -> i32 {
210 let proto: proto::ChannelRole = self.into();
211 proto.into()
212 }
213}
214
215/// ChannelVisibility controls whether channels are public or private.
216#[derive(Eq, PartialEq, Copy, Clone, Debug, EnumIter, DeriveActiveEnum, Default, Hash)]
217#[sea_orm(rs_type = "String", db_type = "String(None)")]
218pub enum ChannelVisibility {
219 /// Public channels are visible to anyone with the link. People join with the Guest role by default.
220 #[sea_orm(string_value = "public")]
221 Public,
222 /// Members channels are only visible to members of this channel or its parents.
223 #[sea_orm(string_value = "members")]
224 #[default]
225 Members,
226}
227
228impl From<proto::ChannelVisibility> for ChannelVisibility {
229 fn from(value: proto::ChannelVisibility) -> Self {
230 match value {
231 proto::ChannelVisibility::Public => ChannelVisibility::Public,
232 proto::ChannelVisibility::Members => ChannelVisibility::Members,
233 }
234 }
235}
236
237impl Into<proto::ChannelVisibility> for ChannelVisibility {
238 fn into(self) -> proto::ChannelVisibility {
239 match self {
240 ChannelVisibility::Public => proto::ChannelVisibility::Public,
241 ChannelVisibility::Members => proto::ChannelVisibility::Members,
242 }
243 }
244}
245
246impl Into<i32> for ChannelVisibility {
247 fn into(self) -> i32 {
248 let proto: proto::ChannelVisibility = self.into();
249 proto.into()
250 }
251}