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