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);
 84
 85#[derive(Eq, PartialEq, Copy, Clone, Debug, EnumIter, DeriveActiveEnum)]
 86#[sea_orm(rs_type = "String", db_type = "String(None)")]
 87pub enum ChannelRole {
 88    #[sea_orm(string_value = "admin")]
 89    Admin,
 90    #[sea_orm(string_value = "member")]
 91    Member,
 92    #[sea_orm(string_value = "guest")]
 93    Guest,
 94    #[sea_orm(string_value = "banned")]
 95    Banned,
 96}
 97
 98impl ChannelRole {
 99    pub fn should_override(&self, other: Self) -> bool {
100        use ChannelRole::*;
101        match self {
102            Admin => matches!(other, Member | Banned | Guest),
103            Member => matches!(other, Banned | Guest),
104            Banned => matches!(other, Guest),
105            Guest => false,
106        }
107    }
108}
109
110impl From<proto::ChannelRole> for ChannelRole {
111    fn from(value: proto::ChannelRole) -> Self {
112        match value {
113            proto::ChannelRole::Admin => ChannelRole::Admin,
114            proto::ChannelRole::Member => ChannelRole::Member,
115            proto::ChannelRole::Guest => ChannelRole::Guest,
116            proto::ChannelRole::Banned => ChannelRole::Banned,
117        }
118    }
119}
120
121impl Into<proto::ChannelRole> for ChannelRole {
122    fn into(self) -> proto::ChannelRole {
123        match self {
124            ChannelRole::Admin => proto::ChannelRole::Admin,
125            ChannelRole::Member => proto::ChannelRole::Member,
126            ChannelRole::Guest => proto::ChannelRole::Guest,
127            ChannelRole::Banned => proto::ChannelRole::Banned,
128        }
129    }
130}
131
132impl Into<i32> for ChannelRole {
133    fn into(self) -> i32 {
134        let proto: proto::ChannelRole = self.into();
135        proto.into()
136    }
137}
138
139#[derive(Eq, PartialEq, Copy, Clone, Debug, EnumIter, DeriveActiveEnum, Default)]
140#[sea_orm(rs_type = "String", db_type = "String(None)")]
141pub enum ChannelVisibility {
142    #[sea_orm(string_value = "public")]
143    Public,
144    #[sea_orm(string_value = "members")]
145    #[default]
146    Members,
147}
148
149impl From<proto::ChannelVisibility> for ChannelVisibility {
150    fn from(value: proto::ChannelVisibility) -> Self {
151        match value {
152            proto::ChannelVisibility::Public => ChannelVisibility::Public,
153            proto::ChannelVisibility::ChannelMembers => ChannelVisibility::Members,
154        }
155    }
156}
157
158impl Into<proto::ChannelVisibility> for ChannelVisibility {
159    fn into(self) -> proto::ChannelVisibility {
160        match self {
161            ChannelVisibility::Public => proto::ChannelVisibility::Public,
162            ChannelVisibility::Members => proto::ChannelVisibility::ChannelMembers,
163        }
164    }
165}
166
167impl Into<i32> for ChannelVisibility {
168    fn into(self) -> i32 {
169        let proto: proto::ChannelVisibility = self.into();
170        proto.into()
171    }
172}