1042 lines
31 KiB
Rust
1042 lines
31 KiB
Rust
use scylla::{
|
|
DeserializeValue, SerializeValue,
|
|
client::session::Session,
|
|
deserialize::row::DeserializeRow,
|
|
errors::{ExecutionError, SingleRowError},
|
|
statement::{
|
|
Statement,
|
|
batch::{Batch, BatchType},
|
|
},
|
|
};
|
|
use thiserror::Error;
|
|
use time::{OffsetDateTime, UtcDateTime};
|
|
use twilight_http::Client;
|
|
use twilight_model::{
|
|
guild::{Guild as TwilightGuild, GuildInfo as TwilightGuildInfo},
|
|
id::Id,
|
|
user::User as TwilightUser,
|
|
};
|
|
|
|
use crate::{constants::DEFAULT_PREFIX, utils::get_random_u64};
|
|
|
|
#[derive(Debug, Error)]
|
|
pub enum DatabaseOrDiscordError {
|
|
#[error("An error occurred when querying the database")]
|
|
Database(#[from] DatabaseError),
|
|
|
|
#[error("An error occurred when querying the Discord API")]
|
|
Discord(#[from] twilight_http::Error),
|
|
|
|
#[error("The Discord API returned a response that could not be deserialized")]
|
|
DiscordDeserializationFailed,
|
|
}
|
|
|
|
#[derive(Debug, Error)]
|
|
pub enum DatabaseError {
|
|
#[error("An error occurred when querying the database")]
|
|
QueryError(ExecutionError),
|
|
|
|
#[error("The database responded but the result of the query weren't rows")]
|
|
ResultNotRows,
|
|
|
|
#[error("The resulting row could not be deserialized into an object")]
|
|
DeserializationFailed,
|
|
}
|
|
|
|
/// Copies the bytes from [`i64`] to [`u64`].
|
|
///
|
|
/// WARNING: This does NOT keep the same "represented" value. This only keeps the bytes intact,
|
|
/// e.g. 0b0101 will still be 0b0101, but the value represented will change since the type changes.
|
|
///
|
|
/// Arguments:
|
|
/// * `i` - The [`i64`] to convert.
|
|
///
|
|
/// Returns:
|
|
/// [`u64`] - The resulting [`u64`].
|
|
fn i64_to_u64(i: i64) -> u64 {
|
|
u64::from_ne_bytes(i.to_ne_bytes())
|
|
}
|
|
|
|
/// Copies the bytes from [`u64`] to [`i64`].
|
|
///
|
|
/// WARNING: This does NOT keep the same "represented" value. This only keeps the bytes intact,
|
|
/// e.g. 0b0101 will still be 0b0101, but the value represented will change since the type changes.
|
|
///
|
|
/// Arguments:
|
|
/// * `u` - The [`u64`] to convert.
|
|
///
|
|
/// Returns:
|
|
/// [`i64`] - The resulting [`i64`].
|
|
fn u64_to_i64(u: u64) -> i64 {
|
|
i64::from_ne_bytes(u.to_ne_bytes())
|
|
}
|
|
|
|
trait Object<'a> {
|
|
type Row: DeserializeRow<'a, 'a>;
|
|
|
|
fn from_row(row: Self::Row) -> Self;
|
|
fn to_row(value: Self) -> Self::Row;
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct User {
|
|
pub id: u64,
|
|
pub name: String,
|
|
pub email: Option<String>,
|
|
pub is_masked: bool,
|
|
pub is_moderator: bool,
|
|
pub joined_at: UtcDateTime,
|
|
pub last_seen_at: UtcDateTime,
|
|
pub supporter_since: Option<UtcDateTime>,
|
|
pub supporter_until: Option<UtcDateTime>,
|
|
}
|
|
|
|
impl<'a> Object<'a> for User {
|
|
type Row = (
|
|
i64,
|
|
String,
|
|
Option<String>,
|
|
bool,
|
|
bool,
|
|
OffsetDateTime,
|
|
OffsetDateTime,
|
|
Option<OffsetDateTime>,
|
|
Option<OffsetDateTime>,
|
|
);
|
|
|
|
fn from_row(row: Self::Row) -> Self {
|
|
Self {
|
|
id: i64_to_u64(row.0),
|
|
name: row.1,
|
|
email: row.2,
|
|
is_masked: row.3,
|
|
is_moderator: row.4,
|
|
joined_at: row.5.into(),
|
|
last_seen_at: row.6.into(),
|
|
supporter_since: row.7.map(|i| i.into()),
|
|
supporter_until: row.8.map(|i| i.into()),
|
|
}
|
|
}
|
|
|
|
fn to_row(value: Self) -> Self::Row {
|
|
(
|
|
u64_to_i64(value.id),
|
|
value.name,
|
|
value.email,
|
|
value.is_masked,
|
|
value.is_moderator,
|
|
value.joined_at.into(),
|
|
value.last_seen_at.into(),
|
|
value.supporter_since.map(|i| i.into()),
|
|
value.supporter_until.map(|i| i.into()),
|
|
)
|
|
}
|
|
}
|
|
|
|
impl User {
|
|
pub async fn get_by_id(id: u64, session: &Session) -> Result<Option<Self>, DatabaseError> {
|
|
let id = u64_to_i64(id);
|
|
|
|
let result = session
|
|
.query_unpaged(
|
|
r#"
|
|
SELECT
|
|
user_id,
|
|
name,
|
|
email,
|
|
is_masked,
|
|
is_moderator,
|
|
joined_at,
|
|
last_seen_at,
|
|
supporter_since,
|
|
supporter_until
|
|
FROM
|
|
payphone.users
|
|
WHERE
|
|
user_id = ?
|
|
LIMIT 1;
|
|
"#,
|
|
(id,),
|
|
)
|
|
.await
|
|
.map_err(DatabaseError::QueryError)?
|
|
.into_rows_result()
|
|
.map_err(|_| DatabaseError::ResultNotRows)?;
|
|
|
|
match result.single_row::<<User as Object>::Row>() {
|
|
Ok(row) => Ok(Some(Self::from_row(row))),
|
|
Err(error) => match error {
|
|
SingleRowError::DeserializationFailed(_) | SingleRowError::TypeCheckFailed(_) => {
|
|
Err(DatabaseError::DeserializationFailed)
|
|
}
|
|
SingleRowError::UnexpectedRowCount(_) => Ok(None),
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<TwilightUser> for User {
|
|
fn from(value: TwilightUser) -> Self {
|
|
Self {
|
|
id: value.id.get(),
|
|
name: value.name,
|
|
email: value.email,
|
|
is_masked: false,
|
|
is_moderator: false,
|
|
joined_at: UtcDateTime::now(),
|
|
last_seen_at: UtcDateTime::now(),
|
|
supporter_since: None,
|
|
supporter_until: None,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, SerializeValue, DeserializeValue)]
|
|
pub struct Message {
|
|
pub id: i64,
|
|
pub author_id: i64,
|
|
pub author_name: String,
|
|
pub author_avatar_url: String,
|
|
pub author_mask: Option<String>,
|
|
pub content: String,
|
|
pub attachments: Option<Vec<String>>,
|
|
pub sticker: Option<i64>,
|
|
pub propagation_message_id: Option<i64>,
|
|
pub propagation_channel_id: Option<i64>,
|
|
pub replying_to_id: Option<i64>,
|
|
pub is_deleted: bool,
|
|
pub is_edited: bool,
|
|
pub is_censored: bool,
|
|
}
|
|
|
|
impl<'a> Object<'a> for Message {
|
|
type Row = (
|
|
i64,
|
|
i64,
|
|
String,
|
|
String,
|
|
Option<String>,
|
|
String,
|
|
Option<Vec<String>>,
|
|
Option<i64>,
|
|
Option<i64>,
|
|
Option<i64>,
|
|
Option<i64>,
|
|
bool,
|
|
bool,
|
|
bool,
|
|
);
|
|
fn from_row(row: Self::Row) -> Self {
|
|
Self {
|
|
id: row.0,
|
|
author_id: row.1,
|
|
author_name: row.2,
|
|
author_avatar_url: row.3,
|
|
author_mask: row.4,
|
|
content: row.5,
|
|
attachments: row.6,
|
|
sticker: row.7,
|
|
propagation_message_id: row.8,
|
|
propagation_channel_id: row.9,
|
|
replying_to_id: row.10,
|
|
is_deleted: row.11,
|
|
is_edited: row.12,
|
|
is_censored: row.13,
|
|
}
|
|
}
|
|
fn to_row(value: Self) -> Self::Row {
|
|
(
|
|
value.id,
|
|
value.author_id,
|
|
value.author_name,
|
|
value.author_avatar_url,
|
|
value.author_mask,
|
|
value.content,
|
|
value.attachments,
|
|
value.sticker,
|
|
value.propagation_message_id,
|
|
value.propagation_channel_id,
|
|
value.replying_to_id,
|
|
value.is_deleted,
|
|
value.is_edited,
|
|
value.is_censored,
|
|
)
|
|
}
|
|
}
|
|
|
|
pub struct MessageRow {
|
|
pub call_id: u64,
|
|
pub message_id: u64,
|
|
pub data: Message,
|
|
}
|
|
|
|
impl MessageRow {
|
|
pub async fn get_by_call_and_message_id(
|
|
call_id: u64,
|
|
message_id: u64,
|
|
session: &Session,
|
|
) -> Result<Option<Self>, DatabaseError> {
|
|
let call_id = u64_to_i64(call_id);
|
|
let message_id = u64_to_i64(message_id);
|
|
let result = session
|
|
.query_unpaged(
|
|
r#"
|
|
SELECT call_id, message_id, data
|
|
FROM payphone.messages
|
|
WHERE call_id = ? AND message_id = ?
|
|
LIMIT 1;
|
|
"#,
|
|
(call_id, message_id),
|
|
)
|
|
.await
|
|
.map_err(DatabaseError::QueryError)?
|
|
.into_rows_result()
|
|
.map_err(|_| DatabaseError::ResultNotRows)?;
|
|
match result.single_row::<<MessageRow as Object>::Row>() {
|
|
Ok(row) => Ok(Some(<MessageRow as Object>::from_row(row))),
|
|
Err(error) => match error {
|
|
SingleRowError::DeserializationFailed(_) | SingleRowError::TypeCheckFailed(_) => {
|
|
Err(DatabaseError::DeserializationFailed)
|
|
}
|
|
SingleRowError::UnexpectedRowCount(_) => Ok(None),
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'a> Object<'a> for Report {
|
|
type Row = (
|
|
i64, // report_id
|
|
Message,
|
|
Option<Message>,
|
|
OffsetDateTime,
|
|
Option<OffsetDateTime>,
|
|
Vec<i64>,
|
|
Option<i64>,
|
|
Option<String>,
|
|
);
|
|
fn from_row(row: Self::Row) -> Self {
|
|
Self {
|
|
report_id: i64_to_u64(row.0),
|
|
message: row.1,
|
|
replying_to: row.2,
|
|
created_at: row.3,
|
|
reviewed_at: row.4,
|
|
created_by_ids: row.5.iter().map(|&id| i64_to_u64(id)).collect(),
|
|
reviewed_by_id: row.6.map(i64_to_u64),
|
|
resolution: row.7,
|
|
}
|
|
}
|
|
fn to_row(value: Self) -> Self::Row {
|
|
(
|
|
u64_to_i64(value.report_id),
|
|
value.message,
|
|
value.replying_to,
|
|
value.created_at,
|
|
value.reviewed_at,
|
|
value
|
|
.created_by_ids
|
|
.iter()
|
|
.map(|&id| u64_to_i64(id))
|
|
.collect(),
|
|
value.reviewed_by_id.map(u64_to_i64),
|
|
value.resolution,
|
|
)
|
|
}
|
|
}
|
|
|
|
// --- BEGIN: Payphone Message and Report Models ---
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct Report {
|
|
pub report_id: u64,
|
|
pub message: Message,
|
|
pub replying_to: Option<Message>,
|
|
pub created_at: OffsetDateTime,
|
|
pub reviewed_at: Option<OffsetDateTime>,
|
|
pub created_by_ids: Vec<u64>,
|
|
pub reviewed_by_id: Option<u64>,
|
|
pub resolution: Option<String>,
|
|
}
|
|
|
|
impl<'a> Object<'a> for MessageRow {
|
|
type Row = (i64, i64, <Message as Object<'a>>::Row);
|
|
fn from_row(row: Self::Row) -> Self {
|
|
Self {
|
|
call_id: i64_to_u64(row.0),
|
|
message_id: i64_to_u64(row.1),
|
|
data: <Message as Object>::from_row(row.2),
|
|
}
|
|
}
|
|
fn to_row(value: Self) -> Self::Row {
|
|
(
|
|
u64_to_i64(value.call_id),
|
|
u64_to_i64(value.message_id),
|
|
<Message as Object>::to_row(value.data),
|
|
)
|
|
}
|
|
}
|
|
|
|
impl Report {
|
|
pub async fn insert(&self, session: &Session) -> Result<(), DatabaseError> {
|
|
let row = Self::to_row(self.clone());
|
|
session
|
|
.query_unpaged(
|
|
r#"
|
|
INSERT INTO payphone.reports (
|
|
report_id,
|
|
message,
|
|
replying_to,
|
|
created_at,
|
|
reviewed_at,
|
|
created_by_ids,
|
|
reviewed_by_id,
|
|
resolution
|
|
) VALUES (?, ?, ?, ?, ?, ?, ?, ?);
|
|
"#,
|
|
row,
|
|
)
|
|
.await
|
|
.map_err(DatabaseError::QueryError)?;
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct Server {
|
|
pub id: u64,
|
|
pub name: String,
|
|
pub prefix: String,
|
|
}
|
|
|
|
impl<'a> Object<'a> for Server {
|
|
type Row = (i64, String, String);
|
|
|
|
fn from_row(row: Self::Row) -> Self {
|
|
Self {
|
|
id: i64_to_u64(row.0),
|
|
name: row.1,
|
|
prefix: row.2,
|
|
}
|
|
}
|
|
|
|
fn to_row(value: Self) -> Self::Row {
|
|
(u64_to_i64(value.id), value.name, value.prefix)
|
|
}
|
|
}
|
|
|
|
impl Server {
|
|
pub async fn get_by_id(id: u64, session: &Session) -> Result<Option<Self>, DatabaseError> {
|
|
let id = u64_to_i64(id);
|
|
|
|
let result = session
|
|
.query_unpaged(
|
|
r#"
|
|
SELECT
|
|
server_id,
|
|
name,
|
|
prefix
|
|
FROM
|
|
payphone.servers
|
|
WHERE
|
|
server_id = ?
|
|
LIMIT 1;
|
|
"#,
|
|
(id,),
|
|
)
|
|
.await
|
|
.map_err(DatabaseError::QueryError)?
|
|
.into_rows_result()
|
|
.map_err(|_| DatabaseError::ResultNotRows)?;
|
|
|
|
match result.single_row::<<Server as Object>::Row>() {
|
|
Ok(row) => Ok(Some(Self::from_row(row))),
|
|
Err(error) => match error {
|
|
SingleRowError::DeserializationFailed(_) | SingleRowError::TypeCheckFailed(_) => {
|
|
Err(DatabaseError::DeserializationFailed)
|
|
}
|
|
SingleRowError::UnexpectedRowCount(_) => Ok(None),
|
|
},
|
|
}
|
|
}
|
|
|
|
pub async fn insert(&self, session: &Session) -> Result<(), DatabaseError> {
|
|
session
|
|
.query_unpaged(
|
|
r#"
|
|
INSERT INTO payphone.servers (
|
|
server_id,
|
|
name,
|
|
prefix
|
|
) VALUES (?, ?, ?) IF NOT EXISTS;
|
|
"#,
|
|
Self::to_row(self.clone()),
|
|
)
|
|
.await
|
|
.inspect_err(|e| log::error!("{e:?}"))
|
|
.map_err(DatabaseError::QueryError)?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn upsert(&self, session: &Session) -> Result<(), DatabaseError> {
|
|
session
|
|
.query_unpaged(
|
|
r#"
|
|
INSERT INTO payphone.servers (
|
|
server_id,
|
|
name,
|
|
prefix
|
|
) VALUES (
|
|
?,
|
|
?,
|
|
?
|
|
);
|
|
"#,
|
|
Self::to_row(self.clone()),
|
|
)
|
|
.await
|
|
.map_err(DatabaseError::QueryError)?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn delete_by_id(id: u64, session: &Session) -> Result<(), DatabaseError> {
|
|
session
|
|
.query_unpaged(
|
|
"DELETE FROM payphone.servers WHERE server_id = ?;",
|
|
(u64_to_i64(id),),
|
|
)
|
|
.await
|
|
.map_err(DatabaseError::QueryError)?;
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl From<TwilightGuild> for Server {
|
|
fn from(value: TwilightGuild) -> Self {
|
|
Self {
|
|
id: value.id.get(),
|
|
name: value.name,
|
|
prefix: DEFAULT_PREFIX.into(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<TwilightGuildInfo> for Server {
|
|
fn from(value: TwilightGuildInfo) -> Self {
|
|
Self {
|
|
id: value.id.get(),
|
|
name: value.name,
|
|
prefix: DEFAULT_PREFIX.into(),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct Channel {
|
|
pub id: u64,
|
|
pub server_id: u64,
|
|
pub call_id: Option<u64>,
|
|
pub is_searching: bool,
|
|
pub recently_called_server_ids: Vec<u64>,
|
|
pub webhook_id: Option<u64>,
|
|
pub webhook_token: Option<String>,
|
|
}
|
|
|
|
impl<'a> Object<'a> for Channel {
|
|
type Row = (
|
|
i64,
|
|
i64,
|
|
Option<i64>,
|
|
bool,
|
|
Vec<i64>,
|
|
Option<i64>,
|
|
Option<String>,
|
|
);
|
|
|
|
fn from_row(row: Self::Row) -> Self {
|
|
Self {
|
|
id: i64_to_u64(row.0),
|
|
server_id: i64_to_u64(row.1),
|
|
call_id: row.2.map(i64_to_u64),
|
|
is_searching: row.3,
|
|
recently_called_server_ids: row.4.iter().map(|&i| i64_to_u64(i)).collect(),
|
|
webhook_id: row.5.map(i64_to_u64),
|
|
webhook_token: row.6,
|
|
}
|
|
}
|
|
|
|
fn to_row(value: Self) -> Self::Row {
|
|
(
|
|
u64_to_i64(value.id),
|
|
u64_to_i64(value.server_id),
|
|
value.call_id.map(u64_to_i64),
|
|
value.is_searching,
|
|
value
|
|
.recently_called_server_ids
|
|
.iter()
|
|
.map(|&u| u64_to_i64(u))
|
|
.collect(),
|
|
value.webhook_id.map(u64_to_i64),
|
|
value.webhook_token,
|
|
)
|
|
}
|
|
}
|
|
|
|
impl Channel {
|
|
pub async fn get_by_id(id: u64, session: &Session) -> Result<Option<Self>, DatabaseError> {
|
|
let id = u64_to_i64(id);
|
|
|
|
let result = session
|
|
.query_unpaged(
|
|
r#"
|
|
SELECT
|
|
channel_id,
|
|
server_id,
|
|
call_id,
|
|
is_searching,
|
|
recently_called_server_ids,
|
|
webhook_id,
|
|
webhook_token
|
|
FROM
|
|
payphone.channels
|
|
WHERE
|
|
channel_id = ?
|
|
LIMIT 1;
|
|
"#,
|
|
(id,),
|
|
)
|
|
.await
|
|
.map_err(DatabaseError::QueryError)?
|
|
.into_rows_result()
|
|
.map_err(|_| DatabaseError::ResultNotRows)?;
|
|
|
|
match result.single_row::<<Channel as Object>::Row>() {
|
|
Ok(row) => Ok(Some(Self::from_row(row))),
|
|
Err(error) => match error {
|
|
SingleRowError::DeserializationFailed(_) | SingleRowError::TypeCheckFailed(_) => {
|
|
Err(DatabaseError::DeserializationFailed)
|
|
}
|
|
SingleRowError::UnexpectedRowCount(_) => Ok(None),
|
|
},
|
|
}
|
|
}
|
|
|
|
pub async fn get_or_create_by_id(
|
|
id: u64,
|
|
session: &Session,
|
|
http: &Client,
|
|
) -> Result<Self, DatabaseOrDiscordError> {
|
|
if let Some(channel) = Channel::get_by_id(id, session)
|
|
.await
|
|
.map_err(DatabaseOrDiscordError::Database)?
|
|
{
|
|
Ok(channel)
|
|
} else {
|
|
let webhook = http
|
|
.create_webhook(Id::new(id), "Payphone Messages")
|
|
.await
|
|
.inspect_err(|e| log::error!("Failed to create webhook for channel {id}: {e:?}"))
|
|
.map_err(DatabaseOrDiscordError::Discord)?
|
|
.model()
|
|
.await
|
|
.inspect_err(|e| log::error!("Failed to get model for webhook {id}: {e:?}"))
|
|
.map_err(|_| DatabaseOrDiscordError::DiscordDeserializationFailed)?;
|
|
|
|
let response = http
|
|
.channel(Id::new(id))
|
|
.await
|
|
.map_err(DatabaseOrDiscordError::Discord)?
|
|
.model()
|
|
.await
|
|
.inspect_err(|e| {
|
|
log::error!("The discord API didn't return a parseable channel! {e:?}")
|
|
})
|
|
.map_err(|_| DatabaseOrDiscordError::DiscordDeserializationFailed)?;
|
|
|
|
let channel = Channel {
|
|
id: response.id.get(),
|
|
server_id: response.guild_id.map(|i| i.get()).unwrap_or(0),
|
|
call_id: None,
|
|
is_searching: false,
|
|
recently_called_server_ids: vec![],
|
|
webhook_id: Some(webhook.id.get()),
|
|
webhook_token: webhook.token,
|
|
};
|
|
channel
|
|
.upsert(session)
|
|
.await
|
|
.inspect_err(|e| log::error!("Could not upsert channel in database! {e:?}"))
|
|
.map_err(DatabaseOrDiscordError::Database)?;
|
|
|
|
Ok(channel)
|
|
}
|
|
}
|
|
|
|
pub async fn upsert(&self, session: &Session) -> Result<(), DatabaseError> {
|
|
session
|
|
.query_unpaged(
|
|
r#"
|
|
INSERT INTO payphone.channels (
|
|
channel_id,
|
|
server_id,
|
|
call_id,
|
|
is_searching,
|
|
recently_called_server_ids,
|
|
webhook_id,
|
|
webhook_token
|
|
) VALUES (?, ?, ?, ?, ?, ?, ?);
|
|
"#,
|
|
Self::to_row(self.clone()),
|
|
)
|
|
.await
|
|
.map_err(DatabaseError::QueryError)?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn cancel_search(&self, session: &Session) -> Result<(), DatabaseError> {
|
|
session
|
|
.query_unpaged(
|
|
"UPDATE payphone.channels SET is_searching = false WHERE channel_id = ?;",
|
|
(u64_to_i64(self.id),),
|
|
)
|
|
.await
|
|
.map_err(DatabaseError::QueryError)?;
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct SearchingChannel {
|
|
pub id: u64,
|
|
pub server_id: u64,
|
|
pub recently_called_server_ids: Vec<u64>,
|
|
}
|
|
|
|
impl<'a> Object<'a> for SearchingChannel {
|
|
type Row = (i64, i64, Vec<i64>);
|
|
|
|
fn from_row(row: Self::Row) -> Self {
|
|
Self {
|
|
id: i64_to_u64(row.0),
|
|
server_id: i64_to_u64(row.1),
|
|
recently_called_server_ids: row.2.iter().map(|&i| i64_to_u64(i)).collect(),
|
|
}
|
|
}
|
|
|
|
fn to_row(value: Self) -> Self::Row {
|
|
(
|
|
u64_to_i64(value.id),
|
|
u64_to_i64(value.server_id),
|
|
value
|
|
.recently_called_server_ids
|
|
.iter()
|
|
.map(|&u| u64_to_i64(u))
|
|
.collect(),
|
|
)
|
|
}
|
|
}
|
|
|
|
impl SearchingChannel {
|
|
pub async fn get_all(session: &Session) -> Result<Vec<Self>, DatabaseError> {
|
|
let result = session
|
|
.query_unpaged(
|
|
r#"
|
|
SELECT
|
|
channel_id,
|
|
server_id,
|
|
recently_called_server_ids
|
|
FROM
|
|
payphone.searching_channels;
|
|
"#,
|
|
(),
|
|
)
|
|
.await
|
|
.map_err(DatabaseError::QueryError)?
|
|
.into_rows_result()
|
|
.map_err(|_| DatabaseError::ResultNotRows)?;
|
|
|
|
Ok(result
|
|
.rows::<<SearchingChannel as Object>::Row>()
|
|
.map_err(|_| DatabaseError::ResultNotRows)?
|
|
.collect::<Result<Vec<_>, _>>()
|
|
.map_err(|_| DatabaseError::DeserializationFailed)?
|
|
.into_iter()
|
|
.map(Self::from_row)
|
|
.collect::<Vec<_>>())
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct Call {
|
|
pub id: u64,
|
|
pub channel_ids: Vec<u64>,
|
|
pub started_at: UtcDateTime,
|
|
pub finished_at: Option<UtcDateTime>,
|
|
}
|
|
|
|
impl<'a> Object<'a> for Call {
|
|
type Row = (i64, Vec<i64>, OffsetDateTime, Option<OffsetDateTime>);
|
|
|
|
fn from_row(row: Self::Row) -> Self {
|
|
Self {
|
|
id: i64_to_u64(row.0),
|
|
channel_ids: row.1.iter().map(|&i| i64_to_u64(i)).collect(),
|
|
started_at: row.2.into(),
|
|
finished_at: row.3.map(|i| i.into()),
|
|
}
|
|
}
|
|
|
|
fn to_row(value: Self) -> Self::Row {
|
|
(
|
|
u64_to_i64(value.id),
|
|
value.channel_ids.iter().map(|&u| u64_to_i64(u)).collect(),
|
|
value.started_at.into(),
|
|
value.finished_at.map(|i| i.into()),
|
|
)
|
|
}
|
|
}
|
|
|
|
fn push_and_cap<T>(vec: &mut Vec<T>, value: T, max_size: usize) {
|
|
if vec.len() >= max_size {
|
|
vec.remove(0);
|
|
}
|
|
|
|
vec.push(value);
|
|
}
|
|
|
|
impl Call {
|
|
pub async fn get_by_id(id: u64, session: &Session) -> Result<Option<Self>, DatabaseError> {
|
|
let id = u64_to_i64(id);
|
|
|
|
let result = session
|
|
.query_unpaged(
|
|
r#"
|
|
SELECT
|
|
call_id,
|
|
channel_ids,
|
|
started_at,
|
|
finished_at
|
|
FROM
|
|
payphone.calls
|
|
WHERE
|
|
call_id = ?
|
|
LIMIT 1;
|
|
"#,
|
|
(id,),
|
|
)
|
|
.await
|
|
.map_err(DatabaseError::QueryError)?
|
|
.into_rows_result()
|
|
.map_err(|_| DatabaseError::ResultNotRows)?;
|
|
|
|
match result.single_row::<<Call as Object>::Row>() {
|
|
Ok(row) => Ok(Some(Self::from_row(row))),
|
|
Err(error) => match error {
|
|
SingleRowError::DeserializationFailed(_) | SingleRowError::TypeCheckFailed(_) => {
|
|
Err(DatabaseError::DeserializationFailed)
|
|
}
|
|
SingleRowError::UnexpectedRowCount(_) => Ok(None),
|
|
},
|
|
}
|
|
}
|
|
|
|
/// Returns the opposite party's channel ID.
|
|
pub fn other_party_channel_id(&self, channel_id: u64) -> u64 {
|
|
if self.channel_ids[0] == channel_id {
|
|
self.channel_ids[1]
|
|
} else {
|
|
self.channel_ids[0]
|
|
}
|
|
}
|
|
|
|
pub fn is_active(&self) -> bool {
|
|
self.finished_at.is_none()
|
|
}
|
|
|
|
/// Starts a call, or marks the channel as searching if the call is not started.
|
|
///
|
|
/// Arguments:
|
|
/// * `channel` - The channel to start the call in.
|
|
/// * `session` - The Scylla session to use for database operations.
|
|
///
|
|
/// Returns:
|
|
/// [`Result<Option<Self>, DatabaseError>`] - `Ok(Some(Call))` if the call was started
|
|
/// successfully, or `Ok(None)` if the channel was marked as searching. If an error occurs, it
|
|
/// returns `Err(DatabaseError)`.
|
|
pub async fn start(
|
|
channel: &Channel,
|
|
session: &Session,
|
|
) -> Result<Option<Self>, DatabaseError> {
|
|
let searching_channels = SearchingChannel::get_all(session).await?;
|
|
|
|
let call_id = get_random_u64();
|
|
|
|
log::trace!("Call ID is {call_id}");
|
|
|
|
for searching_channel in searching_channels
|
|
.iter()
|
|
.filter(|sc| !sc.recently_called_server_ids.contains(&channel.server_id))
|
|
{
|
|
if searching_channel.server_id == channel.server_id {
|
|
return Ok(None);
|
|
}
|
|
|
|
if channel
|
|
.recently_called_server_ids
|
|
.contains(&searching_channel.server_id)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
log::trace!("Found a searching channel: {searching_channel:?}");
|
|
|
|
let mut searching_channel_recently_called_server_ids = searching_channel
|
|
.recently_called_server_ids
|
|
.clone()
|
|
.into_iter()
|
|
.map(u64_to_i64)
|
|
.collect::<Vec<_>>();
|
|
push_and_cap(
|
|
&mut searching_channel_recently_called_server_ids,
|
|
u64_to_i64(channel.server_id),
|
|
5,
|
|
);
|
|
|
|
let (is_applied, ..) = session
|
|
.query_unpaged(
|
|
r#"
|
|
UPDATE payphone.channels
|
|
SET
|
|
is_searching = false,
|
|
call_id = ?,
|
|
recently_called_server_ids = ?
|
|
WHERE
|
|
channel_id = ?
|
|
IF call_id = NULL;
|
|
"#,
|
|
(
|
|
u64_to_i64(call_id),
|
|
searching_channel_recently_called_server_ids,
|
|
u64_to_i64(searching_channel.id),
|
|
),
|
|
)
|
|
.await
|
|
.inspect_err(|e| log::error!("Failed to add channel to the call! {e:?}"))
|
|
.map_err(DatabaseError::QueryError)?
|
|
.into_rows_result()
|
|
.inspect_err(|e| log::error!("Failed to get result of the query! {e:?}"))
|
|
.map_err(|_| DatabaseError::ResultNotRows)?
|
|
.first_row::<(bool, Option<i64>)>()
|
|
.inspect_err(|e| log::error!("Failed to get first row of the result! {e:?}"))
|
|
.map_err(|_| DatabaseError::DeserializationFailed)?;
|
|
|
|
log::trace!("Is applied: {is_applied:?}");
|
|
|
|
if is_applied {
|
|
let mut channel_recently_called_server_ids = channel
|
|
.recently_called_server_ids
|
|
.clone()
|
|
.into_iter()
|
|
.map(u64_to_i64)
|
|
.collect::<Vec<_>>();
|
|
push_and_cap(
|
|
&mut channel_recently_called_server_ids,
|
|
u64_to_i64(searching_channel.server_id),
|
|
5,
|
|
);
|
|
|
|
session
|
|
.query_unpaged(
|
|
"UPDATE payphone.channels SET call_id = ?, recently_called_server_ids = ? WHERE channel_id = ?",
|
|
(u64_to_i64(call_id), channel_recently_called_server_ids, u64_to_i64(channel.id)),
|
|
)
|
|
.await
|
|
.inspect_err(|e| log::error!("Failed to update channel {e:?}"))
|
|
.map_err(DatabaseError::QueryError)?;
|
|
|
|
let call = Call {
|
|
id: call_id,
|
|
channel_ids: vec![searching_channel.id, channel.id].into_iter().collect(),
|
|
started_at: UtcDateTime::now(),
|
|
finished_at: None,
|
|
};
|
|
call.insert(session)
|
|
.await
|
|
.inspect_err(|e| log::error!("Failed to insert call {e:?}"))?;
|
|
|
|
return Ok(Some(call));
|
|
} else {
|
|
// This channel already got a call, so we skip it, preventing race conditions.
|
|
continue;
|
|
}
|
|
}
|
|
|
|
session.query_unpaged(
|
|
"UPDATE payphone.channels SET is_searching = true WHERE channel_id = ? IF call_id = NULL;",
|
|
(u64_to_i64(channel.id),),
|
|
)
|
|
.await
|
|
.inspect_err(|e| log::error!("Failed to mark channel as searching! {e:?}"))
|
|
.map_err(DatabaseError::QueryError)?;
|
|
|
|
Ok(None)
|
|
}
|
|
|
|
pub async fn insert(&self, session: &Session) -> Result<(), DatabaseError> {
|
|
session
|
|
.query_unpaged(
|
|
r#"
|
|
INSERT INTO payphone.calls (
|
|
call_id,
|
|
channel_ids,
|
|
started_at,
|
|
finished_at
|
|
) VALUES (?, ?, ?, ?);
|
|
"#,
|
|
Self::to_row(self.clone()),
|
|
)
|
|
.await
|
|
.map_err(DatabaseError::QueryError)?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn hangup(&self, session: &Session) -> Result<(), DatabaseError> {
|
|
let mut batch = Batch::new(BatchType::Unlogged);
|
|
|
|
batch.append_statement(Statement::new(
|
|
"UPDATE payphone.calls SET finished_at = ? WHERE call_id = ?;",
|
|
));
|
|
batch.append_statement(Statement::new(
|
|
"UPDATE payphone.channels SET call_id = NULL WHERE channel_id = ?;",
|
|
));
|
|
batch.append_statement(Statement::new(
|
|
"UPDATE payphone.channels SET call_id = NULL WHERE channel_id = ?;",
|
|
));
|
|
|
|
let call_id = u64_to_i64(self.id);
|
|
|
|
session
|
|
.batch(
|
|
&batch,
|
|
(
|
|
(OffsetDateTime::now_utc(), call_id),
|
|
(u64_to_i64(self.channel_ids[0]),),
|
|
(u64_to_i64(self.channel_ids[1]),),
|
|
),
|
|
)
|
|
.await
|
|
.map_err(DatabaseError::QueryError)?;
|
|
|
|
log::trace!("Hung up call {call_id}");
|
|
|
|
Ok(())
|
|
}
|
|
}
|