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        #[serde(transparent)]
 23        pub struct $name(pub i32);
 24
 25        impl $name {
 26            #[allow(unused)]
 27            pub const MAX: Self = Self(i32::MAX);
 28
 29            #[allow(unused)]
 30            pub fn from_proto(value: u64) -> Self {
 31                Self(value as i32)
 32            }
 33
 34            #[allow(unused)]
 35            pub fn to_proto(self) -> u64 {
 36                self.0 as u64
 37            }
 38        }
 39
 40        impl std::fmt::Display for $name {
 41            fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
 42                self.0.fmt(f)
 43            }
 44        }
 45
 46        impl sea_orm::TryFromU64 for $name {
 47            fn try_from_u64(n: u64) -> Result<Self, DbErr> {
 48                Ok(Self(n.try_into().map_err(|_| {
 49                    DbErr::ConvertFromU64(concat!(
 50                        "error converting ",
 51                        stringify!($name),
 52                        " to u64"
 53                    ))
 54                })?))
 55            }
 56        }
 57
 58        impl sea_orm::sea_query::Nullable for $name {
 59            fn null() -> Value {
 60                Value::Int(None)
 61            }
 62        }
 63    };
 64}
 65
 66id_type!(BufferId);
 67id_type!(AccessTokenId);
 68id_type!(ChannelChatParticipantId);
 69id_type!(ChannelId);
 70id_type!(ChannelMemberId);
 71id_type!(MessageId);
 72id_type!(ContactId);
 73id_type!(FollowerId);
 74id_type!(RoomId);
 75id_type!(RoomParticipantId);
 76id_type!(ProjectId);
 77id_type!(ProjectCollaboratorId);
 78id_type!(ReplicaId);
 79id_type!(ServerId);
 80id_type!(SignupId);
 81id_type!(UserId);
 82id_type!(ChannelBufferCollaboratorId);
 83id_type!(FlagId);
 84id_type!(NotificationId);
 85id_type!(NotificationKindId);
 86
 87#[derive(Eq, PartialEq, Copy, Clone, Debug, EnumIter, DeriveActiveEnum, Default)]
 88#[sea_orm(rs_type = "String", db_type = "String(None)")]
 89pub enum ChannelRole {
 90    #[sea_orm(string_value = "admin")]
 91    Admin,
 92    #[sea_orm(string_value = "member")]
 93    #[default]
 94    Member,
 95    #[sea_orm(string_value = "guest")]
 96    Guest,
 97    #[sea_orm(string_value = "banned")]
 98    Banned,
 99}
100
101impl ChannelRole {
102    pub fn should_override(&self, other: Self) -> bool {
103        use ChannelRole::*;
104        match self {
105            Admin => matches!(other, Member | Banned | Guest),
106            Member => matches!(other, Banned | Guest),
107            Banned => matches!(other, Guest),
108            Guest => false,
109        }
110    }
111
112    pub fn max(&self, other: Self) -> Self {
113        if self.should_override(other) {
114            *self
115        } else {
116            other
117        }
118    }
119}
120
121impl From<proto::ChannelRole> for ChannelRole {
122    fn from(value: proto::ChannelRole) -> Self {
123        match value {
124            proto::ChannelRole::Admin => ChannelRole::Admin,
125            proto::ChannelRole::Member => ChannelRole::Member,
126            proto::ChannelRole::Guest => ChannelRole::Guest,
127            proto::ChannelRole::Banned => ChannelRole::Banned,
128        }
129    }
130}
131
132impl Into<proto::ChannelRole> for ChannelRole {
133    fn into(self) -> proto::ChannelRole {
134        match self {
135            ChannelRole::Admin => proto::ChannelRole::Admin,
136            ChannelRole::Member => proto::ChannelRole::Member,
137            ChannelRole::Guest => proto::ChannelRole::Guest,
138            ChannelRole::Banned => proto::ChannelRole::Banned,
139        }
140    }
141}
142
143impl Into<i32> for ChannelRole {
144    fn into(self) -> i32 {
145        let proto: proto::ChannelRole = self.into();
146        proto.into()
147    }
148}
149
150#[derive(Eq, PartialEq, Copy, Clone, Debug, EnumIter, DeriveActiveEnum, Default, Hash)]
151#[sea_orm(rs_type = "String", db_type = "String(None)")]
152pub enum ChannelVisibility {
153    #[sea_orm(string_value = "public")]
154    Public,
155    #[sea_orm(string_value = "members")]
156    #[default]
157    Members,
158}
159
160impl From<proto::ChannelVisibility> for ChannelVisibility {
161    fn from(value: proto::ChannelVisibility) -> Self {
162        match value {
163            proto::ChannelVisibility::Public => ChannelVisibility::Public,
164            proto::ChannelVisibility::Members => ChannelVisibility::Members,
165        }
166    }
167}
168
169impl Into<proto::ChannelVisibility> for ChannelVisibility {
170    fn into(self) -> proto::ChannelVisibility {
171        match self {
172            ChannelVisibility::Public => proto::ChannelVisibility::Public,
173            ChannelVisibility::Members => proto::ChannelVisibility::Members,
174        }
175    }
176}
177
178impl Into<i32> for ChannelVisibility {
179    fn into(self) -> i32 {
180        let proto: proto::ChannelVisibility = self.into();
181        proto.into()
182    }
183}