modzero/god-replacement-product-old
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Refactor things a bit to be less annoying

Browse Source
This commit is contained in:
Gender Shrapnel 2023-03-19 23:28:03 +01:00
parent 3f2f4fa733
commit 1170fa8c87
Signed by: modzero
GPG Key ID: 4E11A06C6D1E5213
2 changed files with 136 additions and 127 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

125
src/commands.rs Normal file
View File

@ -0,0 +1,125 @@
use axum::http::StatusCode;
use sqlx::PgPool;
use twilight_interactions::command::{CommandModel, CreateCommand};
use twilight_mention::{Mention, timestamp::{TimestampStyle, Timestamp}};
use twilight_model::{id::{Id, marker::{InteractionMarker, ChannelMarker, UserMarker}}, http::interaction::{InteractionResponse, InteractionResponseType, InteractionResponseData}, channel::message::MessageFlags};
#[derive(CommandModel, CreateCommand)]
#[command(name = "set_fact", desc = "Quietly save a fact")]
pub struct SetFactCommand {
#[command(rename = "name", desc = "Fact name")]
fact_name: String,
#[command(rename = "value", desc = "Fact value")]
fact_value: String,
}
#[derive(CommandModel, CreateCommand)]
#[command(name = "get_fact", desc = "Retrieve and display the value of a fact")]
pub struct GetFactCommand {
#[command(rename = "name", desc = "Fact name")]
fact_name: String,
#[command(desc = "Should it be displayed publically, by default it won't be")]
public: Option<bool>,
}
pub async fn set_fact(
interaction_id: Id<InteractionMarker>,
channel_id: Option<Id<ChannelMarker>>,
author_id: Id<UserMarker>,
command_data: SetFactCommand,
pg_pool: &PgPool,
) -> Result<InteractionResponse, (StatusCode, String)> {
let Ok(rows) = sqlx::query!("
INSERT INTO facts (\"last_interaction_id\", \"channel_id\", \"author_id\", \"name\", \"value\")
VALUES ($1, $2, $3, $4, $5)
ON CONFLICT ON CONSTRAINT facts_origin_key DO UPDATE SET value = $5, version = facts.version + 1
",
interaction_id.to_string(),
channel_id.map(|cid| cid.to_string()),
author_id.to_string(),
command_data.fact_name,
command_data.fact_value,
).execute(pg_pool).await.and_then(|rows| Ok(rows.rows_affected())) else {
return Err((StatusCode::INTERNAL_SERVER_ERROR, "Error saving fact.".to_string()));
};
if rows != 1 {
return Err((StatusCode::INTERNAL_SERVER_ERROR, "Error saving fact".to_string()));
}
Ok(InteractionResponse {
kind: InteractionResponseType::ChannelMessageWithSource,
data: Some(InteractionResponseData {
content: Some(format!(
"Set {0} to {1}",
command_data.fact_name, command_data.fact_value
)),
flags: Some(MessageFlags::EPHEMERAL),
..Default::default()
}),
})
}
struct FactResponse {
value: String,
version: i32,
created_at: time::OffsetDateTime,
updated_at: time::OffsetDateTime,
}
pub async fn get_fact(
channel_id: Option<Id<ChannelMarker>>,
author_id: Id<UserMarker>,
command_data: GetFactCommand,
pg_pool: &PgPool,
) -> Result<InteractionResponse, (StatusCode, String)> {
let Ok(facts) = sqlx::query_as!(FactResponse,
"
SELECT \"value\", \"version\", \"created_at\", \"updated_at\"
FROM facts
WHERE
channel_id IS NOT DISTINCT FROM $1 AND
author_id = $2 AND
name = $3
", channel_id.map(|cid| cid.to_string()), author_id.to_string(), command_data.fact_name).fetch_all(pg_pool).await else {
return Err((StatusCode::INTERNAL_SERVER_ERROR, "Querying facts failed".to_string()));
};
if facts.len() == 0 {
return Ok(InteractionResponse {
kind: InteractionResponseType::ChannelMessageWithSource,
data: Some(InteractionResponseData {
content: Some(format!("Fact {0} in channel {1} by you, {2}, was not found.",
command_data.fact_name,
channel_id.map_or("<none>".to_string(), |cid| cid.mention().to_string()),
author_id.mention().to_string(),
)),
flags: match command_data.public { Some(true) => None, _ => Some(MessageFlags::EPHEMERAL) },
..Default::default()
}),
});
}
if facts.len() > 1 {
return Err((StatusCode::INTERNAL_SERVER_ERROR, "Too many facts found, wtf, impossible".to_string()));
}
let fact = &facts[0];
Ok(InteractionResponse {
kind: InteractionResponseType::ChannelMessageWithSource,
data: Some(InteractionResponseData {
content: Some(format!(
"Fact **{0}** was set to **{1}** by {2} at {3}, and was reset {4} times in total since {5}.",
command_data.fact_name,
fact.value,
author_id.mention().to_string(),
Timestamp::new(fact.updated_at.unix_timestamp().try_into().unwrap(), Some(TimestampStyle::RelativeTime)).mention(),
fact.version,
Timestamp::new(fact.created_at.unix_timestamp().try_into().unwrap(), Some(TimestampStyle::ShortDateTime)).mention(),
)),
flags: match command_data.public { Some(true) => None, _ => Some(MessageFlags::EPHEMERAL) },
..Default::default()
}),
})
}

138
src/main.rs
View File

@ -7,35 +7,19 @@ use axum::{
Json, Router,
};
use base64::{alphabet, engine, Engine};
use commands::{SetFactCommand, GetFactCommand, set_fact, get_fact};
use ed25519_dalek::{Signature, VerifyingKey};
use serde::Deserialize;
use sqlx::{postgres::PgPoolOptions, PgPool};
use twilight_http::Client;
use twilight_interactions::command::{CommandInputData, CommandModel, CreateCommand};
use twilight_mention::{timestamp::{Timestamp, TimestampStyle}, Mention};
use twilight_model::{
application::interaction::{Interaction, InteractionData, InteractionType},
http::interaction::{InteractionResponse, InteractionResponseData, InteractionResponseType},
id::{Id, marker::{UserMarker, ChannelMarker, InteractionMarker}}, channel::message::MessageFlags,
http::interaction::{InteractionResponse, InteractionResponseType},
id::Id
};
#[derive(CommandModel, CreateCommand)]
#[command(name = "set_fact", desc = "Quietly save a fact")]
struct SetFactCommand {
#[command(rename = "name", desc = "Fact name")]
fact_name: String,
#[command(rename = "value", desc = "Fact value")]
fact_value: String,
}
#[derive(CommandModel, CreateCommand)]
#[command(name = "get_fact", desc = "Retrieve and display the value of a fact")]
struct GetFactCommand {
#[command(rename = "name", desc = "Fact name")]
fact_name: String,
#[command(desc = "Should it be displayed publically, by default it won't be")]
public: Option<bool>,
}
mod commands;
#[tokio::main]
async fn main() -> anyhow::Result<()> {
@ -93,106 +77,6 @@ fn validate_request(headers: HeaderMap, body: String) -> Result<Interaction, (St
return Ok(interaction);
}
async fn set_fact(
interaction_id: Id<InteractionMarker>,
channel_id: Option<Id<ChannelMarker>>,
author_id: Id<UserMarker>,
command_data: SetFactCommand,
pg_pool: &PgPool,
) -> Result<InteractionResponse, (StatusCode, String)> {
let Ok(rows) = sqlx::query!("
INSERT INTO facts (\"last_interaction_id\", \"channel_id\", \"author_id\", \"name\", \"value\")
VALUES ($1, $2, $3, $4, $5)
ON CONFLICT ON CONSTRAINT facts_origin_key DO UPDATE SET value = $5, version = facts.version + 1
",
interaction_id.to_string(),
channel_id.map(|cid| cid.to_string()),
author_id.to_string(),
command_data.fact_name,
command_data.fact_value,
).execute(pg_pool).await.and_then(|rows| Ok(rows.rows_affected())) else {
return Err((StatusCode::INTERNAL_SERVER_ERROR, "Error saving fact.".to_string()));
};
if rows != 1 {
return Err((StatusCode::INTERNAL_SERVER_ERROR, "Error saving fact".to_string()));
}
Ok(InteractionResponse {
kind: InteractionResponseType::ChannelMessageWithSource,
data: Some(InteractionResponseData {
content: Some(format!(
"Set {0} to {1}",
command_data.fact_name, command_data.fact_value
)),
flags: Some(MessageFlags::EPHEMERAL),
..Default::default()
}),
})
}
struct FactResponse {
value: String,
version: i32,
created_at: time::OffsetDateTime,
updated_at: time::OffsetDateTime,
}
async fn get_fact(
channel_id: Option<Id<ChannelMarker>>,
author_id: Id<UserMarker>,
command_data: GetFactCommand,
pg_pool: &PgPool,
) -> Result<InteractionResponse, (StatusCode, String)> {
let Ok(facts) = sqlx::query_as!(FactResponse,
"
SELECT \"value\", \"version\", \"created_at\", \"updated_at\"
FROM facts
WHERE
channel_id IS NOT DISTINCT FROM $1 AND
author_id = $2 AND
name = $3
", channel_id.map(|cid| cid.to_string()), author_id.to_string(), command_data.fact_name).fetch_all(pg_pool).await else {
return Err((StatusCode::INTERNAL_SERVER_ERROR, "Querying facts failed".to_string()));
};
if facts.len() == 0 {
return Ok(InteractionResponse {
kind: InteractionResponseType::ChannelMessageWithSource,
data: Some(InteractionResponseData {
content: Some(format!("Fact {0} in channel {1} by you, {2}, was not found.",
command_data.fact_name,
channel_id.map_or("<none>".to_string(), |cid| cid.mention().to_string()),
author_id.mention().to_string(),
)),
flags: match command_data.public { Some(true) => None, _ => Some(MessageFlags::EPHEMERAL) },
..Default::default()
}),
});
}
if facts.len() > 1 {
return Err((StatusCode::INTERNAL_SERVER_ERROR, "Too many facts found, wtf, impossible".to_string()));
}
let fact = &facts[0];
Ok(InteractionResponse {
kind: InteractionResponseType::ChannelMessageWithSource,
data: Some(InteractionResponseData {
content: Some(format!(
"Fact **{0}** was set to **{1}** by {2} at {3}, and was reset {4} times in total since {5}.",
command_data.fact_name,
fact.value,
author_id.mention().to_string(),
Timestamp::new(fact.updated_at.unix_timestamp().try_into().unwrap(), Some(TimestampStyle::RelativeTime)).mention(),
fact.version,
Timestamp::new(fact.created_at.unix_timestamp().try_into().unwrap(), Some(TimestampStyle::ShortDateTime)).mention(),
)),
flags: match command_data.public { Some(true) => None, _ => Some(MessageFlags::EPHEMERAL) },
..Default::default()
}),
})
}
async fn post_interaction(
headers: HeaderMap,
State(pg_pool): State<PgPool>,
@ -218,24 +102,24 @@ async fn post_interaction(
};
let command_input_data = CommandInputData::from(*data.clone());
match &*data.name {
"set_fact" => {
SetFactCommand::NAME => {
let Ok(command_data) = SetFactCommand::from_interaction(command_input_data) else {
return Err((StatusCode::BAD_REQUEST, "invalid set fact command".to_string()));
return Err((StatusCode::BAD_REQUEST, format!("invalid {0} command.", SetFactCommand::NAME)));
};
let Some(author_id) = author_id else {
return Err((StatusCode::BAD_REQUEST, "save_fact requires a user".to_string()));
return Err((StatusCode::BAD_REQUEST, format!("{0} requires a user.", SetFactCommand::NAME)));
};
match set_fact(interaction.id, interaction.channel_id, author_id, command_data, &pg_pool).await {
Ok(response) => Ok((StatusCode::OK, Json(response))),
Err(err) => Err(err),
}
},
"get_fact" => {
GetFactCommand::NAME => {
let Ok(command_data) = GetFactCommand::from_interaction(command_input_data) else {
return Err((StatusCode::BAD_REQUEST, "invalid get fact command".to_string()));
return Err((StatusCode::BAD_REQUEST, format!("invalid {0} command.", GetFactCommand::NAME)));
};
let Some(author_id) = author_id else {
return Err((StatusCode::BAD_REQUEST, "get_fact requires a user".to_string()));
return Err((StatusCode::BAD_REQUEST, format!("{0} requires a user.", GetFactCommand::NAME)));
};
match get_fact(interaction.channel_id, author_id, command_data, &pg_pool).await {