discord
/
manifold
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: discord:main
Branches Tags
discord:main
discord:3.3.1
discord:3.1.1
discord:3.1.0
discord:3.0.0
discord:2.0.0
..
compare: discord:2.0.0
Branches Tags
discord:main
discord:3.3.1
discord:3.1.1
discord:3.1.0
discord:3.0.0
discord:2.0.0

No commits in common. "main" and "2.0.0" have entirely different histories.
main ... 2.0.0

26 changed files with 402 additions and 1007 deletions
Show Stats Expand all files Collapse all files

1
.envrc
View File

@ -1 +0,0 @@
use nix

23
Cargo.toml
View File

@ -1,45 +1,32 @@
[package]
name = "manifold"
version = "8.0.0"
version = "2.0.0"
authors = ["Lucy Bladen <admin@lbladen.uk>"]
edition = "2021"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[build-dependencies]
built = { version = "0.8.0", features = ["git2", "chrono"] }
built = { version = "0.6.0", features = ["git2", "chrono"] }
[dependencies]
built = { version = "0.8.0", features = ["git2", "chrono"] }
built = { version = "0.6.0", features = ["git2", "chrono"] }
chrono = "0.4.26"
chrono-tz = "0.8.3"
clap = "4.3.4"
config = { version = "0.13.1", features = [ "yaml" ] }
d20 = "0.1.0"
diesel = { version = "2.1.0", features = ["postgres", "r2d2", "chrono"] }
diesel = { version = "2.1.0", features = ["sqlite", "r2d2", "chrono"] }
diesel_migrations = "2.1.0"
dirs = "5.0.1"
env_logger = "0.10.0"
log = "0.4.14"
num = "0.4.1"
poise = { version = "0.5.*", features = [ "cache" ] }
poise = "0.5.5"
r2d2 = "0.8.9"
rand = "0.8.5"
regex = "1.5.4"
reqwest = "0.11.9"
rust-i18n = "3.1.2"
serde = "1.0.171"
serde_json = "1.0.105"
tokio = { version = "1.16.1", features = ["sync", "macros", "rt-multi-thread"] }
[package.metadata.i18n]
# The available locales for your application, default: ["en"].
available-locales = ["en", "de"]
# The default locale, default: "en".
default-locale = "en"
# Path for your translations YAML file, default: "locales".
# This config for let `cargo i18n` command line tool know where to find your translations.
# You must keep this path same as the one you pass to method `rust_i18n::i18n!`.
load-path = "config/locales"

201
config/locales/manifold.yml
View File

@ -1,201 +0,0 @@
_version: 2
global:
not_available:
de: Nicht verfügbar
en: Not Available
not_available_with_id:
de: "Nicht verfügbar (%{id})"
en: "Not Available (%{id})"
logging:
bot_start:
de: Bot hat sich mit Discord verbunden und ist bereit für Befehlseingabe.
en: Manifold bot connected to discord and ready to begin broadcast operations.
logged_command:
de: "Befehl %{command} von %{name} erhalten"
en: "Received command %{command} from %{name}"
user_banned:
de: "%{user} wurde gesperrt"
en: "%{user} was banned"
user_unbanned:
de: "Die Sperre wurde für %{user} aufgehoben"
en: "Ban was lifted for %{user}"
user_joined:
de: "%{name} ist dem Server mit dem Spitznamen %{nickname} beigetreten (%{uid})"
en: "%{name} joined the server with nickname %{nickname} (%{uid})"
user_left:
de: "%{name} hat den Server verlassen"
en: "%{name} left the server"
role_created:
de: "Neue Rolle %{name} (%{role_id}) wurde erstellt"
en: "New role %{name} (%{role_id}) was created"
permissions:
de: Berechtigungen für Rollen
en: Role Permissions
hoist:
de: Hochziehen
en: Hoist
icon:
de: Ikone
en: Icon
mentionable:
de: Erwähnenswert
en: Mentionable
role_deleted:
de: "Rolle %{name} (%{role_id}) wurde gelöscht"
en: "Role %{name} (%{role_id}) was deleted"
permissions:
de: Berechtigungen für Rollen
en: Role Permissions
hoist:
de: Hochziehen
en: Hoist
icon:
de: Symbol
en: Icon
mentionable:
de: Erwähnenswert
en: Mentionable
not_cached:
de: "Rolle %{role_id} wurde gelöscht (Rolle nicht zwischengespeichert, keine Rolleninformationen verfügbar)"
en: "Role %{role_id} was deleted (Role not cached, no role info available)"
message_deleted:
de: "Nachricht in #%{channel} (%{channel_id}) entfernt"
en: "Message removed in #%{channel} (%{channel_id})"
content:
de: Inhalt der Nachricht
en: Message Content
attachments:
de: Nachrichten-Anhänge
en: Message Attachments
not_cached:
de: "Nachricht entfernt in #%{channel_name} (%{channel_id}) (Nicht zwischengespeichert)"
en: "Message removed in #%{channel_name} (%{channel_id}) (Not cached)"
channel_not_cached:
de: "Nicht verfügbar / Nicht zwischengespeichert (%{channel_id})"
en: "Not Available / Not Cached (%{channel_id})"
message_edited:
de: "Nachricht aktualisiert in #%{channel_name} (%{channel_id})"
en: "Message updated in #%{channel_name} (%{channel_id})"
original_content:
de: Ursprünglicher Inhalt
en: Original Content
new_content:
de: Neue Inhalte
en: New Content
created_at:
de: Nachricht erstellt am
en: Message created at
author:
de: Verfasser der Nachricht
en: Message author
commands:
admin:
config_dump:
de: "Konfigurations-Deponie; %{Dump}"
en: "Config dump; %{dump}"
start_watching:
de: "Okay, ich beobachte nun, %{target}."
en: "Okay, I'll start watching %{target}"
saving_the_world:
de: Speicher-Befehl erhalten, speichere Welt...
en: Save call received, saving the world...
save_complete:
de: Speichern abgeschlossen; Speicherte %{user_count} Benutzer.
en: "Save call complete; Saved %{user_count} users."
animal:
no_frog_tips:
de: Es konnten keine Hinweise gefunden werden.
en: No tips could be located. Try rubbing it.
no_animal_pic:
de: Die Suche schien kein Erfolg zu haben. Vielleicht hilft etwas Speck?
en: No frens here at the moment. Perhaps some bacon would help?
convert:
specify:
de: Geben Sie eine Konvertierung an. Weitere Informationen finden Sie in der Hilfe.
en: Specify a conversion. See help for more info.
converted:
de: "%{input_value}%{input_unit} ist %{output_value}%{output_unit}"
en: "%{input_value}%{input_unit} is %{output_value}%{output_unit}"
core:
set_timezone:
reject_invalid_timezone:
de: Ungültige Zeitzone
en: Are you having a laugh? What kind of timezone is that?
accept_timezone:
de: "Ich habe Ihre Zeitzone auf %{timezone} eingestellt, aber wir alle wissen, dass UTC die einzig wahre Zeitzone ist"
en: "I have set your timezone to %{timezone}, but we all know that UTC is the One True Timezone"
time:
unknown_timezone:
de: Ve vill tell ze Zeit!
en: This user hasn't given me their timezone yet. Shame on them!
unknown_user:
de: Wer ist das? Ich kenne sie nicht.
en: Who's that? I don't know them.
time_output:
de: "Die Zeit in %{name}'s Zeitzone von %{timezone} ist %{time}"
en: "Time in %{name}'s current timezone of %{timezone} is %{time}"
dad_joke:
no_jokes:
de: Ich kann keine Dad-Jokes finden. Vielleicht ist dein Vater nicht lustig.
en: Can't find any dad jokes. Maybe your dad isn't funny.
nasa_apod:
no_picture:
de: Das NASA Astronomy Photo of the Day fehlte. Versuchen Sie stattdessen, nach oben zu schauen.
en: The NASA Astronomy Photo of the Day was missing. Try looking up instead.
weather:
no_location:
de: Ich weiß nicht, wo du wohnst, und du hast es mir nicht gesagt, also kann ich nicht helfen. Schauen Sie aus dem Fenster.
en: I don't know where you live, and you didn't tell me, so I can't help. Look out of the window.
no_weather:
de: "Irgendetwas ist schief gelaufen. Vielleicht gibt es dort kein Wetter. %{error_output}"
en: "Something went wrong. Maybe there is no weather there. %{error_output}"
retrieve_wait:
de: Wetter abrufen, Geduld haben
en: Retrieving weather, be patient
current_weather:
de: "Aktuelles Wetter bei %{location_name}, %{location_region}, %{location_country}"
en: "Current weather at %{location_name}, %{location_region}, %{location_country}"
forecast_time:
de: "Prognose für %{forecast_time} erstellt um %{forecast_updated}"
en: "Forecast for %{forecast_time} made at %{forecast_updated}"
temperature_dewpoint:
de: Temperatur (Taupunkt)
en: Temperature (Dewpoint)
feels_like:
de: Fühlt sich wie
en: Feels like
condition:
de: Zustand
en: Condition
pressure:
de: Druck
en: Pressure
precipitation:
de: Niederschlag
en: Precipitation
humidity:
de: Feuchtigkeit
en: Humidity
cloud_coverage:
de: Wolkenbedeckung
en: Cloud coverage
coordinates:
de: Koordinaten
en: Coordinates
wind:
de: Wind
en: Wind
wind_value:
de: "%{wind_mph}mph/%{wind_kph}km/h von den %{wind_dir} (%{wind_degree} Grad), Böen auf %{gust_mph}mph/%{gust_kph}km/h"
en: "%{wind_mph}mph/%{wind_kph}kph from the %{wind_dir} (%{wind_degree} degrees), gusting to %{gust_mph}mph/%{gust_kph}kph"
weather_location:
location_save_confirm:
de: "Okay. Jetzt weiß ich, dass du in %{location} lebst. Ob das so weise war?"
en: "Okay. Now I know that you live in %{location}. Are you sure that was wise?"
misc:
version_string:
de: "%{caller} (Mannigfaltigkeits-Framework-Version %{mfold_ver}, erstellt um %{mfold_time} aus der Revision %{mfold_rev})"
en: "%{caller} (Manifold framework version %{mfold_ver} built at %{mfold_time} from revision %{mfold_rev})"

8
shell.nix
View File

@ -1,8 +0,0 @@
{ pkgs ? import <nixpkgs> {}}:
pkgs.mkShell {
buildInputs = with pkgs; [
openssl
postgresql
pkg-config
];
}

0
src/autocomplete_helpers/mod.rs Normal file
View File

42
src/commands/admin.rs
View File

@ -1,11 +1,35 @@
use poise::serenity_prelude::Activity;
use crate::{ManifoldContext, ManifoldData, ManifoldResult};
use crate::error::ManifoldError;
#[poise::command(slash_command, prefix_command, owners_only)]
async fn dump_config(ctx: ManifoldContext<'_>) -> ManifoldResult<()> {
ctx.say(t!("commands.admin.config_dump", dump = format!("{:?}", &ctx.data().bot_config))).await?;
let config = &ctx.data().bot_config;
ctx.say(format!("Config dump; {:?}", config.config)).await?;
Ok(())
}
#[poise::command(slash_command, prefix_command, owners_only)]
async fn get_environment(ctx: ManifoldContext<'_>) -> ManifoldResult<()> {
let environment = ctx.data().bot_config.get_environment();
ctx.say(format!("Currently running under the {} environment", environment)).await?;
Ok(())
}
#[poise::command(slash_command, prefix_command, owners_only)]
async fn get_config(ctx: ManifoldContext<'_>, #[description="Config key"] key: String) -> ManifoldResult<()> {
let config = &ctx.data().bot_config;
let value = match config.get_value(&key) {
Ok(v) => v.clone(),
Err(_) => "not found, sorry!".to_string()
};
ctx.say(format!("Value for key {} was {}", &key, &value)).await?;
Ok(())
}
@ -17,17 +41,17 @@ async fn register_commands(ctx: ManifoldContext<'_>) -> ManifoldResult<()> {
Ok(())
}
#[poise::command(slash_command, prefix_command, track_edits, aliases("watch"), required_permissions = "MODERATE_MEMBERS")]
#[poise::command(slash_command, prefix_command, track_edits, aliases("sa"), required_permissions = "MODERATE_MEMBERS")]
async fn set_activity(ctx: ManifoldContext<'_>, #[rest] #[description="Who to watch"] target: String) -> ManifoldResult<()> {
ctx.serenity_context().set_activity(Activity::watching(&target)).await;
ctx.say(t!("commands.admin.start_watching", target = target)).await?;
ctx.say(format!("Okay, I'll start watching {}", target)).await?;
Ok(())
}
#[poise::command(slash_command, prefix_command, owners_only)]
async fn save_world(ctx: ManifoldContext<'_>) -> ManifoldResult<()> {
let my_message = ctx.send(|f| f.content(t!("commands.admin.saving_the_world")).reply(true)).await?;
let my_message = ctx.send(|f| f.content("Save call received, saving the world...").reply(true)).await?;
let mut user_count = 0;
@ -39,7 +63,7 @@ async fn save_world(ctx: ManifoldContext<'_>) -> ManifoldResult<()> {
Ok(_) => debug!("User {:?} inserted successfully", user.0),
Err(e) => {
debug!("User {:?} was not inserted: {:?}, attempting to save instead", user.1, e);
match user.1.insert(db) {
match user.1.save(db) {
Ok(_) => debug!("User {:?} saved successfully, user is saved in database.", user.0),
Err(e) => debug!("User {:?} could not be saved: {:?}", user.1, e),
};
@ -48,11 +72,11 @@ async fn save_world(ctx: ManifoldContext<'_>) -> ManifoldResult<()> {
user_count = userinfo.len();
}
my_message.edit(ctx, |f| f.content(t!("commands.admin.save_complete", user_count = user_count))).await?;
my_message.edit(ctx, |f| f.content(format!("Save call complete; Saved {} users.", user_count))).await?;
Ok(())
}
pub fn commands() -> [poise::Command<ManifoldData, ManifoldError>; 4] {
[dump_config(), register_commands(), set_activity(), save_world()]
pub fn commands() -> [poise::Command<ManifoldData, ManifoldError>; 6] {
[dump_config(), get_environment(), get_config(), register_commands(), set_activity(), save_world()]
}

50
src/commands/animal.rs
View File

@ -1,50 +0,0 @@
use crate::models::frogtip::{Croak, Tip};
use crate::error::{ManifoldError, ManifoldResult};
use crate::{ManifoldContext, ManifoldData};
use crate::models::animalpics::{AnimalPic, AnimalPicWrapper};
#[poise::command(slash_command, prefix_command, aliases("ft"))]
async fn frog_tip(ctx: ManifoldContext<'_>) -> ManifoldResult<()> {
debug!("Processing tip");
if let Some(tank) = ctx.data().bot_config.services.get("frog_tips") {
let tip: &Tip = &tank.next_or_fill::<Tip, Croak>().await?;
debug!("Tip: {:?}", tip);
ctx.send(|f| f.content(format!("{}", tip)).reply(true)).await?;
} else {
error!("No such fuel tank frog_tips");
ctx.send(|f| f.content(t!("commands.animal.no_frog_tips").to_string()).reply(true)).await?;
}
Ok(())
}
#[poise::command(slash_command, prefix_command, aliases("dog"))]
async fn dog_pic(ctx: ManifoldContext<'_>) -> ManifoldResult<()> {
animal_pic(ctx, "dog_pics").await
}
#[poise::command(slash_command, prefix_command, aliases("cat"))]
async fn cat_pic(ctx: ManifoldContext<'_>) -> ManifoldResult<()> {
animal_pic(ctx, "cat_pics").await
}
async fn animal_pic(ctx: ManifoldContext<'_>, tank_name: &str) -> ManifoldResult<()> {
if let Some(tank) = ctx.data().bot_config.services.get(tank_name) {
let pic: &AnimalPic = &tank.next_or_fill::<AnimalPic, AnimalPicWrapper>().await?;
ctx.send(|f| f.content(format!("{}", pic)).reply(true)).await?;
} else {
error!("No such fuel tank {}", tank_name);
ctx.send(|f| f.content(t!("commands.animal.no_animal_pic").to_string()).reply(true)).await?;
}
Ok(())
}
pub fn commands() -> [poise::Command<ManifoldData, ManifoldError>; 3] {
[frog_tip(), dog_pic(), cat_pic()]
}

24
src/commands/convert.rs
View File

@ -4,35 +4,35 @@ use crate::{ManifoldContext, ManifoldData};
#[poise::command(slash_command, prefix_command, aliases("c"), subcommands("ftoc", "ftok", "ftor", "ctof", "ctok", "ctor", "rtof", "rtoc", "rtok", "ktoc", "ktof", "ktor"))]
pub async fn convert(ctx: ManifoldContext<'_>) -> ManifoldResult<()> {
ctx.send(|f| f.content(t!("commands.convert.specify")).reply(true)).await?;
ctx.send(|f| f.content("Specify a conversion. See help for more info").reply(true)).await?;
Ok(())
}
#[poise::command(slash_command, prefix_command)]
pub async fn ftoc(ctx: ManifoldContext<'_>, value: f32) -> ManifoldResult<()> {
ctx.send(|f| f.content(t!("commands.convert.converted", input_value = value, input_unit = "°F", output_value = ((value - 32.0)/1.8), output_unit = "°C")).reply(true)).await?;
ctx.send(|f| f.content(format!("{}°F is {}°C", value, ((value - 32.0)/1.8))).reply(true)).await?;
Ok(())
}
#[poise::command(slash_command, prefix_command)]
pub async fn ftok(ctx: ManifoldContext<'_>, value: f32) -> ManifoldResult<()> {
ctx.send(|f| f.content(t!("commands.convert.converted", input_unit = "°F", input_value = value, output_unit = "K", output_value = (((value - 32.0)/1.8) + 273.0))).reply(true)).await?;
ctx.send(|f| f.content(format!("{}°F is {}°K", value, (((value - 32.0)/1.8) + 273.0))).reply(true)).await?;
Ok(())
}
#[poise::command(slash_command, prefix_command)]
pub async fn ftor(ctx: ManifoldContext<'_>, value: f32) -> ManifoldResult<()> {
ctx.send(|f| f.content(t!("commands.convert.converted", input_unit = "°F", input_value = value, output_unit = "°Ra", output_value = (value + 459.67))).reply(true)).await?;
ctx.send(|f| f.content(format!("{}°F is {}°R", value, (value + 459.67))).reply(true)).await?;
Ok(())
}
#[poise::command(slash_command, prefix_command)]
pub async fn ctof(ctx: ManifoldContext<'_>, value: f32) -> ManifoldResult<()> {
ctx.send(|f| f.content(t!("commands.convert.converted", input_unit = "°C", input_value = value, output_unit = "°F", output_value = ((value * 1.8)+32.0))).reply(true)).await?;
ctx.send(|f| f.content(format!("{}°C is {}°F", value, ((value * 1.8)+32.0))).reply(true)).await?;
Ok(())
}
@ -46,49 +46,49 @@ pub async fn ctok(ctx: ManifoldContext<'_>, value: f32) -> ManifoldResult<()> {
#[poise::command(slash_command, prefix_command)]
pub async fn ctor(ctx: ManifoldContext<'_>, value: f32) -> ManifoldResult<()> {
ctx.send(|f| f.content(t!("commands.convert.converted", input_unit = "°C", input_value = value, output_unit = "°Ra", output_value = ((value + 273.15) * (9.0/5.0)))).reply(true)).await?;
ctx.send(|f| f.content(format!("{}°C is {}°R", value, ((value + 273.15) * (9.0/5.0)))).reply(true)).await?;
Ok(())
}
#[poise::command(slash_command, prefix_command)]
pub async fn ktoc(ctx: ManifoldContext<'_>, value: f32) -> ManifoldResult<()> {
ctx.send(|f| f.content(t!("commands.convert.converted", input_unit = "K", input_value = value, output_unit = "°C", output_value = (value - 273.15))).reply(true)).await?;
ctx.send(|f| f.content(format!("{}°K is {}°C", value, (value - 273.15))).reply(true)).await?;
Ok(())
}
#[poise::command(slash_command, prefix_command)]
pub async fn ktof(ctx: ManifoldContext<'_>, value: f32) -> ManifoldResult<()> {
ctx.send(|f| f.content(t!("commands.convert.converted", input_unit = "K", input_value = value, output_unit = "°F", output_value = ((value * (9.0/5.0)) - 459.67))).reply(true)).await?;
ctx.send(|f| f.content(format!("{}°K is {}°F", value, ((value * (9.0/5.0)) - 459.67))).reply(true)).await?;
Ok(())
}
#[poise::command(slash_command, prefix_command)]
pub async fn ktor(ctx: ManifoldContext<'_>, value: f32) -> ManifoldResult<()> {
ctx.send(|f| f.content(t!("commands.convert.converted", input_unit = "K", input_value = value, output_unit = "°Ra", output_value = (value * (9.0/5.0)))).reply(true)).await?;
ctx.send(|f| f.content(format!("{}°K is {}°R", value, (value * (9.0/5.0)))).reply(true)).await?;
Ok(())
}
#[poise::command(slash_command, prefix_command)]
pub async fn rtok(ctx: ManifoldContext<'_>, value: f32) -> ManifoldResult<()> {
ctx.send(|f| f.content(t!("commands.convert.converted", input_unit = "°Ra", input_value = value, output_unit = "K", output_value = (value * (5.0/9.0)))).reply(true)).await?;
ctx.send(|f| f.content(format!("{}°R is {}°K", value, (value * (5.0/9.0)))).reply(true)).await?;
Ok(())
}
#[poise::command(slash_command, prefix_command)]
pub async fn rtoc(ctx: ManifoldContext<'_>, value: f32) -> ManifoldResult<()> {
ctx.send(|f| f.content(t!("commands.convert.converted", input_unit = "°Ra", input_value = value, output_unit = "°C", output_value = ((value - 491.67) * (5.0/9.0)))).reply(true)).await?;
ctx.send(|f| f.content(format!("{}°R is {}°C", value, ((value - 491.67) * (5.0/9.0)))).reply(true)).await?;
Ok(())
}
#[poise::command(slash_command, prefix_command)]
pub async fn rtof(ctx: ManifoldContext<'_>, value: f32) -> ManifoldResult<()> {
ctx.send(|f| f.content(t!("commands.convert.converted", input_unit = "°Ra", input_value = value, output_unit = "°F", output_value = (value - 459.67))).reply(true)).await?;
ctx.send(|f| f.content(format!("{}°R is {}°F", value, (value - 459.67))).reply(true)).await?;
Ok(())
}

12
src/commands/core.rs
View File

@ -55,14 +55,14 @@ async fn set_timezone(ctx: ManifoldContext<'_>, input_timezone: String) -> Manif
Ok(r) => r,
Err(e) => {
error!("Problem parsing timezone input: {:?}", e);
ctx.send(|f| f.content(t!("commands.core.set_timezone.reject_invalid_timezone")).reply(true)).await?;
ctx.send(|f| f.content(format!("Are you having a laugh? What kind of timezone is that? {:?}", e)).reply(true)).await?;
Err(e)?
}
};
if let Some(user) = userinfo.get_mut(ctx.author().id.as_u64()) {
user.timezone = Some(validated_timezone.to_string());
ctx.send(|f| f.content(t!("commands.core.set_timezone.accept_timezone", timezone = validated_timezone.to_string())).reply(true)).await?;
ctx.send(|f| f.content(format!("I have set your timezone to {}, but we all know that UTC is the One True Timezone.", validated_timezone.to_string())).reply(true)).await?;
} else {
let new_user = UserInfo {
user_id: ctx.author().id.as_u64().to_owned() as i64,
@ -73,7 +73,7 @@ async fn set_timezone(ctx: ManifoldContext<'_>, input_timezone: String) -> Manif
last_seen: Some(chrono::Utc::now().timestamp())
};
userinfo.insert(ctx.author().id.as_u64().clone(), new_user);
ctx.send(|f| f.content(t!("commands.core.set_timezone.accept_timezone", timezone = validated_timezone.to_string())).reply(true)).await?;
ctx.send(|f| f.content(format!("I have set your timezone to {}, but we all know that UTC is the One True Timezone.", validated_timezone.to_string())).reply(true)).await?;
}
Ok(())
@ -86,16 +86,16 @@ pub async fn time(ctx: ManifoldContext<'_>, target: u64) -> ManifoldResult<()> {
let user = match userinfo.get(&target) {
Some(u) => match u.timezone.to_owned() {
Some(_) => u,
None => {ctx.send(|f| f.content(t!("commands.core.time.unknown_timezone")).reply(true)).await?; Err("NoTZ")?}
None => {ctx.send(|f| f.content(format!("This user hasn't given me their timezone yet. Shame on them!")).reply(true)).await?; Err("NoTZ")?}
},
None => { ctx.send(|f| f.content(t!("commands.core.time.unknown_user")).reply(true)).await?; Err("User not found")?}
None => { ctx.send(|f| f.content(format!("Who's that? I don't know them.")).reply(true)).await?; Err("User not found")?}
};
let current_time_utc = chrono::Utc::now();
let user_timezone: Tz = user.timezone.as_ref().unwrap().parse::<Tz>().unwrap();
let adjusted_time = user_timezone.from_utc_datetime(&current_time_utc.naive_utc());
ctx.send(|f| f.content(t!("commands.core.time.time_output", name = user.username, timezone = user_timezone.name().to_string(), time = adjusted_time.time().to_string())).reply(true)).await?;
ctx.send(|f| f.content(format!("Time in {}'s current timezone of {} is {}", user.username, user_timezone.name().to_string(), adjusted_time.time().to_string())).reply(true)).await?;
Ok(())
}

23
src/commands/frog.rs Normal file
View File

@ -0,0 +1,23 @@
use crate::models::fueltank::Tip;
use crate::error::{ManifoldError, ManifoldResult};
use crate::{ManifoldContext, ManifoldData};
#[poise::command(slash_command, prefix_command, aliases("ft"))]
async fn frogtip(ctx: ManifoldContext<'_>) -> ManifoldResult<()> {
debug!("Processing tip");
let tank = ctx.data().frogtip_fueltank.lock().await;
let tip: &Tip = &tank.next_or_fill().await?;
debug!("Tip: {:?}", tip);
ctx.send(|f| f.content(format!("{}", tip)).reply(true)).await?;
Ok(())
}
pub fn commands() -> [poise::Command<ManifoldData, ManifoldError>; 1] {
[frogtip()]
}

26
src/commands/joke.rs
View File

@ -1,26 +0,0 @@
use crate::error::{ManifoldError, ManifoldResult};
use crate::{ManifoldContext, ManifoldData};
use crate::models::dadjoke::{DadJoke, DadJokeWrapper};
#[poise::command(slash_command, prefix_command, aliases("dad"))]
async fn dad_joke(ctx: ManifoldContext<'_>) -> ManifoldResult<()> {
debug!("Processing tip");
if let Some(tank) = ctx.data().bot_config.services.get("dad_jokes") {
let tip: &DadJoke = &tank.next_or_fill::<DadJoke, DadJokeWrapper>().await?;
debug!("Tip: {:?}", tip);
ctx.send(|f| f.content(format!("{}", tip)).reply(true)).await?;
} else {
error!("No such fuel tank dad_jokes");
ctx.send(|f| f.content(t!("commands.dad_joke.no_jokes")).reply(true)).await?;
}
Ok(())
}
pub fn commands() -> [poise::Command<ManifoldData, ManifoldError>; 1] {
[dad_joke()]
}

8
src/commands/mod.rs
View File

@ -1,9 +1,7 @@
mod admin;
mod animal;
mod frog;
mod convert;
mod core;
mod joke;
mod nasa;
mod weather;
use crate::ManifoldCommand;
@ -11,10 +9,8 @@ use crate::ManifoldCommand;
pub fn collect_commands(injected: Vec<ManifoldCommand>) -> Vec<ManifoldCommand> {
core::commands().into_iter()
.chain(admin::commands())
.chain(animal::commands())
.chain(frog::commands())
.chain(convert::commands())
.chain(joke::commands())
.chain(nasa::commands())
.chain(weather::commands())
.chain(injected)
.collect()

35
src/commands/nasa.rs
View File

@ -1,35 +0,0 @@
use crate::error::{ManifoldError, ManifoldResult};
use crate::{ManifoldContext, ManifoldData};
use crate::models::nasa::*;
#[poise::command(slash_command, prefix_command, aliases("apod"))]
async fn nasa_apod(ctx: ManifoldContext<'_>) -> ManifoldResult<()> {
debug!("Processing tip");
if let Some(tank) = ctx.data().bot_config.services.get("nasa_apod") {
let photo: &NasaAstroPhoto = &tank.next_or_fill::<NasaAstroPhoto, NasaAstroPhoto>().await?;
debug!("Tip: {:?}", photo);
ctx.send(|f| {
f.content(format!("{}", photo))
.reply(true)
.embed(|e| {
e.title(&photo.title);
e.description(&photo.explanation);
e.image(&photo.hdurl);
e
})
}).await?;
} else {
error!("No such fuel tank nasa_apod");
ctx.send(|f| f.content(t!("commands.nasa_apod.no_picture")).reply(true)).await?;
}
Ok(())
}
pub fn commands() -> [poise::Command<ManifoldData, ManifoldError>; 1] {
[nasa_apod()]
}

131
src/commands/weather.rs
View File

@ -1,59 +1,99 @@
use chrono::{NaiveDateTime, Timelike};
use poise::serenity_prelude::utils::Colour;
use d20::roll_range;
use poise::ReplyHandle;
use poise::serenity_prelude::CreateEmbed;
use crate::{ManifoldCommand, ManifoldContext};
use crate::models::weather::WeatherForecastRequestResponse;
use crate::models::weather::{Weather, WeatherForecastRequestResponse};
use crate::models::user::UserInfo;
use crate::error::{ManifoldError, ManifoldResult};
use crate::helpers::paginate;
use crate::error::ManifoldResult;
#[poise::command(slash_command, prefix_command, aliases("w"))]
async fn weather(ctx: ManifoldContext<'_>, #[rest] #[description="Location to look up weather for"] location: Option<String>) -> ManifoldResult<()> {
let my_message = ctx.say(t!("commands.weather.retrieve_wait")).await?;
let my_message = ctx.say("Retrieving weather, be patient").await?;
let weather_forecast = _get_weather(ctx, &my_message, location).await?;
let weather_forecast = _get_weather(ctx, &my_message, location, Some(1)).await?;
let responses = &ctx.data().responses;
let mut pages = Vec::<CreateEmbed>::new();
my_message.edit(ctx, |m| {
m.content("");
m.embed(|e| {
let card_colour = Colour::from_rgb(roll_range(0, 255).unwrap_or(0) as u8, roll_range(0, 255).unwrap_or(0) as u8, roll_range(0, 255).unwrap_or(0) as u8);
let card_colour = Colour::from_rgb(roll_range(0, 255).unwrap_or(0) as u8, roll_range(0, 255).unwrap_or(0) as u8, roll_range(0, 255).unwrap_or(0) as u8);
weather_forecast.forecast.forecastday.iter().for_each(|d| {
d.hour.iter().for_each(|f| {
pages.push(CreateEmbed::default()
.colour(card_colour)
.title(t!("commands.weather.current_weather", location_name = weather_forecast.location.name, location_region = weather_forecast.location.region, location_country = weather_forecast.location.country))
.description(t!("commands.weather.forecast_time", forecast_time = f.time, forecast_updated = weather_forecast.current.last_updated))
.image(format!("https:{}", f.condition.icon))
.fields(vec![
(t!("commands.weather.temperature_dewpoint"), format!("{}°C/{}°F ({:.1}°C/{:.1}°F)", f.temp_c, f.temp_f, f.dewpoint_c, f.dewpoint_f), true),
(t!("commands.weather.feels_like"), format!("{}°C/{}°F", f.feelslike_c, f.feelslike_f), true),
(t!("commands.weather.condition"), format!("{}", f.condition.text), true),
(t!("commands.weather.pressure"), format!("{}mb/{}in", f.pressure_mb, f.pressure_in), true),
(t!("commands.weather.precipitation"), format!("{}mm/{}in", f.precip_mm, f.precip_in), true),
(t!("commands.weather.humidity"), format!("{}%", f.humidity), true),
(t!("commands.weather.cloud_coverage"), format!("{}%", f.cloud), true),
(t!("commands.weather.coordinates"), format!("Lat: {} Lon: {}", weather_forecast.location.lat, weather_forecast.location.lon), true),
])
.field(t!("commands.weather.wind"), t!("commands.weather.wind_value", wind_mph = f.wind_mph, wind_kph = f.wind_kph, wind_dir = f.wind_dir, wind_degree = f.wind_degree, gust_mph = f.gust_mph, gust_kph = f.gust_kph), false)
.footer(|f| {
f.text(format!("{}", responses.get_response(&"weather card footer".to_string()).unwrap_or(&"Weather Powered By Deez Nutz".to_string())));
f
}).to_owned());
})
});
let now = NaiveDateTime::parse_from_str(weather_forecast.current.last_updated.as_str(), "%Y-%m-%d %H:%M").unwrap_or(NaiveDateTime::default());
paginate(ctx, my_message, pages, (now.hour() + 1) as usize).await?;
e.colour(card_colour);
e.title(format!("Current weather at {}, {}, {}", weather_forecast.location.name, weather_forecast.location.region, weather_forecast.location.country));
e.description(format!("Observations recorded at {}.", weather_forecast.current.last_updated));
e.image(format!("https:{}", weather_forecast.current.condition.icon));
e.fields(vec![
("Temperature (Dewpoint)", format!("{}°C/{}°F ({:.1}°C/{:.1}°F)", weather_forecast.current.temp_c, weather_forecast.current.temp_f, weather_forecast.current.dewpoint_c.unwrap_or(0.0), weather_forecast.current.dewpoint_f.unwrap_or(0.0)), true),
("Feels like", format!("{}°C/{}°F", weather_forecast.current.feelslike_c, weather_forecast.current.feelslike_f), true),
("Condition", format!("{}", weather_forecast.current.condition.text), true),
("Pressure", format!("{}mb/{}in", weather_forecast.current.pressure_mb, weather_forecast.current.pressure_in), true),
("Precipitation", format!("{}mm/{}in", weather_forecast.current.precip_mm, weather_forecast.current.precip_in), true),
("Humidity", format!("{}%", weather_forecast.current.humidity), true),
("Cloud coverage", format!("{}%", weather_forecast.current.cloud), true),
("UV index", format!("{}", weather_forecast.current.uv), true),
("Coordinates", format!("Lat: {} Lon: {}", weather_forecast.location.lat, weather_forecast.location.lon), true),
]);
e.field("Wind", format!("{}mph/{}kph from the {} ({} degrees), gusting to {}mph/{}kph", weather_forecast.current.wind_mph, weather_forecast.current.wind_kph, weather_forecast.current.wind_dir, weather_forecast.current.wind_degree, weather_forecast.current.gust_mph, weather_forecast.current.gust_kph), false);
e.footer(|f| {
f.text(format!("{}", responses.get_response(&"weather card footer".to_string()).unwrap_or(&"Weather Powered By Deez Nutz".to_string())));
f
});
e
});
m
}).await?;
Ok(())
}
/*
#[command]
#[aliases("wf")]
pub async fn weather_forecast(ctx: &Context, msg: &Message, args: Args) -> CommandResult {
let mut my_message = msg.reply_ping(&ctx, "Retrieving weather, be patient").await?;
let weather_forecast = _get_weather(ctx, msg, args, Some(3)).await?;
let forecast_index: usize = (chrono::NaiveDateTime::parse_from_str(&*weather_forecast.location.localtime, "%Y-%m-%d %H:%M").unwrap().hour() as usize) + 1;
debug!("{:?}", weather_forecast);
my_message.edit(&ctx, |m| {
m.content("");
for day in &weather_forecast.forecast.forecastday {
m.add_embed(|e| {
let this_forecast = &day.hour[forecast_index];
let card_colour = Colour::from_rgb(roll_range(0, 255).unwrap_or(0) as u8, roll_range(0, 255).unwrap_or(0) as u8, roll_range(0, 255).unwrap_or(0) as u8);
e.colour(card_colour);
e.title(format!("Weather for {} at {}, {}, {}", this_forecast.time, weather_forecast.location.name, weather_forecast.location.region, weather_forecast.location.country));
e.description(format!("Observations recorded at {}.", weather_forecast.current.last_updated));
e.fields(vec![
("Temperature (Dewpoint)", format!("{}°C/{}°F ({:.1}°C/{:.1}°F)", this_forecast.temp_c, this_forecast.temp_f, this_forecast.dewpoint_c, this_forecast.dewpoint_f), true),
("Feels like", format!("{}°C/{}°F", this_forecast.feelslike_c, this_forecast.feelslike_f), true),
("Condition", format!("{}", this_forecast.condition.text), true),
("Pressure", format!("{}mb/{}in", this_forecast.pressure_mb, this_forecast.pressure_in), true),
("Precipitation", format!("{}mm/{}in", this_forecast.precip_mm, this_forecast.precip_in), true),
("Humidity", format!("{}%", this_forecast.humidity), true),
]);
e.field("Wind", format!("{}mph/{}kph from the {} ({} degrees), gusting to {}mph/{}kph", this_forecast.wind_mph, this_forecast.wind_kph, this_forecast.wind_dir, this_forecast.wind_degree, this_forecast.gust_mph, this_forecast.gust_kph), false);
e
});
}
m
}).await?;
Ok(())
}
*/
#[poise::command(slash_command, prefix_command, aliases("wl"))]
pub async fn save_weather_location(ctx: ManifoldContext<'_>, #[rest] #[description="Your default weather location"] location: String) -> ManifoldResult<()> {
@ -62,7 +102,7 @@ pub async fn save_weather_location(ctx: ManifoldContext<'_>, #[rest] #[descripti
if let Some(existing_user) = userinfo.get_mut(&ctx.author().id.as_u64()) {
existing_user.weather_location = Some(location.clone());
existing_user.insert(db)?;
existing_user.save(db)?;
} else {
let new_user = UserInfo {
user_id: ctx.author().id.as_u64().clone() as i64,
@ -76,20 +116,21 @@ pub async fn save_weather_location(ctx: ManifoldContext<'_>, #[rest] #[descripti
userinfo.insert(ctx.author().id.as_u64().clone(), new_user);
}
ctx.say(t!("commands.weather_location.location_save_confirm", location = &location)).await?;
ctx.say(format!("Okay. Now I know that you live in {}. Are you sure that was wise?", &location)).await?;
Ok(())
}
pub async fn _get_weather(ctx: ManifoldContext<'_>, message_handle: &ReplyHandle<'_>, location: Option<String>) -> ManifoldResult<WeatherForecastRequestResponse> {
pub async fn _get_weather(ctx: ManifoldContext<'_>, message_handle: &ReplyHandle<'_>, location: Option<String>, days: Option<i32>) -> ManifoldResult<WeatherForecastRequestResponse> {
let mut weather_location: String = String::default();
let responses = &ctx.data().responses;
let config = &ctx.data().bot_config;
let userinfo = &mut ctx.data().user_info.lock().await;
let weather_client = config.services.get("weather").ok_or_else(|| ManifoldError::from("No weather client available"))?;
let weather_client = Weather::new(config.get_value(&"WeatherApiKey".to_string()).unwrap().clone(), config.get_value(&"WeatherBaseUrl".to_string()).unwrap().clone());
if let Some(loc) = location {
weather_location = loc;
@ -104,23 +145,23 @@ pub async fn _get_weather(ctx: ManifoldContext<'_>, message_handle: &ReplyHandle
},
None => {
message_handle.edit(ctx, |m| {
m.content = Some(t!("commands.weather.no_location").to_string()); m
m.content = responses.get_response(&"weather noloc".to_string()).cloned(); m
}).await?;
Err("No location provided")?;
}
};
} else {
ctx.say(t!("commands.weather.no_location")).await?;
ctx.say(responses.get_response(&"weather noloc".to_string()).unwrap_or(&"B I don't know where you live, and you didn't tell me, so I can't help. Look out of the window.".to_string())).await?;
Err("No location provided")?;
}
}
debug!("Making weather request!");
let weather_forecast: WeatherForecastRequestResponse = match weather_client.get_weather_forecast(weather_location).await {
let weather_forecast: WeatherForecastRequestResponse = match weather_client.get_weather_forecast(weather_location, days).await {
Ok(w) => w,
Err(e) => {
ctx.say(t!("commands.weather.no_weather", error_output = format!("{:?}", e))).await?;
ctx.say(format!("Something went wrong. Maybe there is no weather there. {:?}", e)).await?;
Err("unknown")?
}
};

81
src/config.rs
View File

@ -1,41 +1,66 @@
use std::collections::HashMap;
use std::path::PathBuf;
use config::Config;
use poise::serenity_prelude::ChannelId;
use poise::serenity_prelude::model::prelude::{ChannelId, MessageId, RoleId};
use crate::ManifoldResult;
use crate::models::fueltank::FuelTank;
#[derive(Debug, Deserialize, Serialize)]
pub struct Channels {
pub log: ChannelId,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct DatabaseConfig {
pub host: String,
pub user: String,
pub pass: String,
pub database_name: String,
pub port: i32,
}
#[derive(Debug, Deserialize, Serialize)]
#[derive(Debug)]
pub struct ManifoldConfig {
pub prefix: String,
pub channels: Channels,
pub nickname: String,
pub services: HashMap<String, FuelTank>,
pub database: DatabaseConfig,
pub responses_file_path: String,
pub environment: String,
pub path: PathBuf,
pub config: Config,
}
impl ManifoldConfig {
pub fn new(config_file: &String, bot_environment: &String) -> ManifoldResult<Self> {
pub fn load_config(config_file: &String, bot_environment: &String) -> ManifoldResult<Self> {
let settings = Config::builder()
.add_source(config::File::with_name(&*format!("config/{}.{}", bot_environment.to_lowercase(), config_file)))
.add_source(config::Environment::with_prefix("manifold"))
.set_override("BotEnvironment", bot_environment.clone())?
.add_source(config::File::with_name(config_file))
.add_source(config::Environment::with_prefix("MANIFOLD"))
.build()?;
Ok(settings.try_deserialize()?)
Ok(Self {
environment: bot_environment.clone(),
path: PathBuf::from(config_file),
config: settings
})
}
pub fn get_environment(&self) -> &String {
&self.environment
}
pub fn get_path(&self) -> &PathBuf {
&self.path
}
pub fn get_environment_mut(&mut self) -> &mut String {
&mut self.environment
}
pub fn get_path_mut(&mut self) -> &mut PathBuf {
&mut self.path
}
pub fn get_value(&self, key: &String) -> ManifoldResult<String> {
Ok(self.config.get_string(&format!("{}{}", &self.environment, key))?)
}
pub fn get_role(&self, role_name: &String) -> ManifoldResult<RoleId> {
let key = format!("{}Role", role_name);
Ok(RoleId(self.get_value(&key)?.parse::<u64>()?))
}
pub fn get_channel(&self, channel_name: &String) -> ManifoldResult<ChannelId> {
let key = format!("{}Channel", channel_name);
Ok(ChannelId(self.get_value(&key)?.parse::<u64>()?))
}
pub fn get_message(&self, message_id: &String) -> ManifoldResult<MessageId> {
let key = format!("{}Message", message_id);
Ok(MessageId(self.get_value(&key)?.parse::<u64>()?))
}
}

267
src/events.rs
View File

@ -1,64 +1,49 @@
use std::sync::atomic::AtomicBool;
use poise::{async_trait, Event, FrameworkContext};
use poise::{Event, FrameworkContext};
use poise::serenity_prelude::model::{
gateway::Ready,
id::ChannelId,
};
use poise::serenity_prelude::{ChannelId, Colour, Context, GuildId, Member, Message, MessageId, Role, RoleId, Timestamp, User};
use poise::serenity_prelude::{Context, Message};
use crate::ManifoldData;
use crate::error::{ManifoldError, ManifoldResult};
use crate::models::user::UserInfo;
#[async_trait]
pub trait EventHandler {
async fn listen(ctx: Context, framework_ctx: FrameworkContext<'_, ManifoldData, ManifoldError>, event: &Event<'_>) -> ManifoldResult<bool>;
}
pub struct Handler {
pub timer_running: AtomicBool,
}
#[async_trait]
impl EventHandler for Handler {
async fn listen(ctx: Context, framework_ctx: FrameworkContext<'_, ManifoldData, ManifoldError>, event: &Event<'_>) -> ManifoldResult<bool> {
match event {
Event::Ready { data_about_bot } => Handler::standard_startup(&ctx, &framework_ctx, data_about_bot).await,
Event::GuildBanAddition { guild_id, banned_user } => Handler::ban_add(&ctx, &framework_ctx, guild_id, banned_user).await,
Event::GuildBanRemoval { guild_id, unbanned_user } => Handler::ban_remove(&ctx, &framework_ctx, guild_id, unbanned_user).await,
Event::GuildMemberAddition { new_member } => Handler::new_member(&ctx, &framework_ctx, &new_member).await,
Event::GuildMemberRemoval { guild_id, user, member_data_if_available } => Handler::member_leave(&ctx, &framework_ctx, guild_id, user, member_data_if_available).await,
Event::GuildMemberUpdate { old_if_available, new } => Handler::member_update(&ctx, &framework_ctx, old_if_available, new).await,
Event::GuildRoleCreate { new } => Handler::new_role(&ctx, &framework_ctx, new).await,
Event::GuildRoleDelete { guild_id, removed_role_id, removed_role_data_if_available } => Handler::delete_role(&ctx, &framework_ctx, guild_id, removed_role_id, removed_role_data_if_available).await,
Event::GuildRoleUpdate { old_data_if_available, new } => Handler::update_role(&ctx, &framework_ctx, old_data_if_available, new).await,
Event::Message { new_message } => Handler::message(&ctx, &framework_ctx, &new_message).await,
Event::MessageDelete { channel_id, deleted_message_id, guild_id } => Handler::message_deleted(&ctx, &framework_ctx, channel_id, deleted_message_id, guild_id).await,
Event::MessageUpdate { old_if_available, new, event: _event } => Handler::message_edited(&ctx, &framework_ctx, old_if_available, new).await,
_ => Ok(false)
}
}
}
impl Handler {
pub fn new() -> Self {
Handler {
timer_running: AtomicBool::from(false)
}
}
pub async fn standard_startup(ctx: &Context, framework_ctx: &FrameworkContext<'_, ManifoldData, ManifoldError>, data_about_bot: &Ready) -> ManifoldResult<bool> {
pub async fn listen(ctx: &Context, framework_ctx: FrameworkContext<'_, ManifoldData, ManifoldError>, event: &Event<'_>) -> ManifoldResult<()> {
match event {
Event::Ready { data_about_bot} => Handler::standard_startup(&ctx, &framework_ctx, data_about_bot).await,
Event::Message { new_message } => Handler::message(&ctx, &framework_ctx, &new_message).await,
Event::MessageUpdate { old_if_available, new, event: _event } => Handler::message_edited(&ctx, &framework_ctx, old_if_available, new).await,
_ => Ok(())
}
}
pub async fn standard_startup(ctx: &Context, framework_ctx: &FrameworkContext<'_, ManifoldData, ManifoldError>, data_about_bot: &Ready) -> ManifoldResult<()> {
let config = &framework_ctx.user_data().await.bot_config;
let responses = &framework_ctx.user_data().await.responses;
let greeting = match responses.get_response(&"bot startup".to_string()) {
Some(g) => g.to_owned(),
None => t!("logging.bot_start").to_string(),
None => "Manifold bot connected to discord and ready to begin broadcast operations.".to_string(),
};
let bot_nickname = config.get_value(&"BotNickname".to_string()).unwrap_or("BrokenManifoldBot".to_string());
let channel: ChannelId = config.get_channel(&"Log".to_string()).expect("Specified log channel invalid or unavailable");
for guild in &data_about_bot.guilds {
match guild.id.edit_nickname(&ctx, Some(&*config.nickname)).await {
match guild.id.edit_nickname(&ctx, Some(&*bot_nickname)).await {
Ok(()) => (),
Err(e) => {
error!("Error setting bot nickname (lack permission?): {:?}", e);
@ -66,153 +51,16 @@ impl Handler {
}
}
config.channels.log.say(&ctx, greeting).await.expect("Couldn't message log channel!");
channel.say(&ctx, greeting).await.expect("Couldn't message log channel!");
Ok(false)
Ok(())
}
async fn ban_add(ctx: &Context, fctx: &FrameworkContext<'_, ManifoldData, ManifoldError>, _guild_id: &GuildId, banned_user: &User) -> ManifoldResult<bool> {
let log_channel = fctx.user_data().await.bot_config.channels.log;
log_channel.send_message(ctx, |f| {
f
.content("")
.embed(|e| {
e
.title(t!("logging.user_banned", user = banned_user.name))
.colour(Colour::from_rgb(255, 0, 0))
.timestamp(Timestamp::now())
})
}).await?;
Ok(false)
}
async fn ban_remove(ctx: &Context, fctx: &FrameworkContext<'_, ManifoldData, ManifoldError>, _guild_id: &GuildId, unbanned_user: &User) -> ManifoldResult<bool> {
let log_channel = fctx.user_data().await.bot_config.channels.log;
log_channel.send_message(ctx, |f| {
f
.content("")
.embed(|e| {
e
.title(t!("logging.user_unbanned", user = unbanned_user.name))
.colour(Colour::from_rgb(0, 255, 0))
.timestamp(Timestamp::now())
})
}).await?;
Ok(false)
}
async fn new_member(ctx: &Context, fctx: &FrameworkContext<'_, ManifoldData, ManifoldError>, new_member: &Member) -> ManifoldResult<bool> {
let log_channel = fctx.user_data().await.bot_config.channels.log;
log_channel.send_message(ctx, |f| {
f
.content("")
.embed(|e| {
e
.title(t!("logging.user_joined", name = new_member.user.name, nickname = new_member.nick.as_ref().unwrap_or(&new_member.user.name), uid = new_member.user.id))
.colour(Colour::from_rgb(0, 255, 0))
.timestamp(new_member.joined_at.unwrap_or(Timestamp::now()))
.field("Account creation date", new_member.user.created_at(), false)
})
}).await?;
Ok(false)
}
async fn member_leave(ctx: &Context, fctx: &FrameworkContext<'_, ManifoldData, ManifoldError>, _guild_id: &GuildId, user: &User, _member_data_if_available: &Option<Member>) -> ManifoldResult<bool> {
let log_channel = fctx.user_data().await.bot_config.channels.log;
log_channel.send_message(ctx, |f| {
f
.content("")
.embed(|e| {
e
.title(t!("logging.user_left", name = user.name))
.colour(Colour::from_rgb(255, 0, 0))
.timestamp(Timestamp::now())
})
}).await?;
Ok(false)
}
async fn member_update(_ctx: &Context, _fctx: &FrameworkContext<'_, ManifoldData, ManifoldError>, _old_if_available: &Option<Member>, _new: &Member) -> ManifoldResult<bool> {
Ok(false)
}
async fn new_role(ctx: &Context, fctx: &FrameworkContext<'_, ManifoldData, ManifoldError>, new: &Role) -> ManifoldResult<bool> {
let log_channel = fctx.user_data().await.bot_config.channels.log;
log_channel.send_message(ctx, |f| {
f
.content("")
.embed(|e| {
e
.title(t!("logging.role_created", name = &new.name, role_id = &new.id))
.colour(Colour::from_rgb(0, 255, 0))
.timestamp(Timestamp::now())
.field(t!("logging.role_created.permissions"), &new.permissions, false)
.field(t!("logging.role_created.hoist"), &new.hoist, true)
.field(t!("logging.role_created.icon"), &new.icon.clone().unwrap_or("None set".to_string()), true)
.field(t!("logging.role_created.mentionable"), &new.mentionable, true)
})
}).await?;
Ok(false)
}
async fn delete_role(ctx: &Context, fctx: &FrameworkContext<'_, ManifoldData, ManifoldError>, _guild_id: &GuildId, removed_role_id: &RoleId, removed_role_data_if_available: &Option<Role>) -> ManifoldResult<bool> {
let log_channel = fctx.user_data().await.bot_config.channels.log;
log_channel.send_message(ctx, |f| {
f
.content("")
.embed(|e| {
match removed_role_data_if_available {
Some(role) => {
return e
.title(t!("logging.role_deleted", name = &role.name, role_id = &role.id))
.colour(Colour::from_rgb(255, 0, 0))
.timestamp(Timestamp::now())
.field(t!("logging.role_deleted.permissions"), &role.permissions, false)
.field(t!("logging.role_deleted.hoist"), &role.hoist, true)
.field(t!("logging.role_deleted.icon"), &role.icon.clone().unwrap_or("None set".to_string()), true)
.field(t!("logging.role_deleted.mentionable"), &role.mentionable, true)
},
None => {
return e
.title(t!("logging.role_deleted.not_cached", role_id = removed_role_id))
.colour(Colour::from_rgb(255, 0, 0))
.timestamp(Timestamp::now())
}
};
})
}).await?;
Ok(false)
}
async fn update_role(_ctx: &Context, _fctx: &FrameworkContext<'_, ManifoldData, ManifoldError>, _old_data_if_available: &Option<Role>, _new: &Role) -> ManifoldResult<bool> {
Ok(false)
}
async fn message(_ctx: &Context, fctx: &FrameworkContext<'_, ManifoldData, ManifoldError>, msg: &Message) -> ManifoldResult<bool> {
async fn message(_ctx: &Context, fctx: &FrameworkContext<'_, ManifoldData, ManifoldError>, msg: &Message) -> ManifoldResult<()> {
let userinfo = &mut fctx.user_data().await.user_info.lock().await;
let db = &fctx.user_data().await.database;
if let Some(u) = userinfo.get_mut(&msg.author.id.as_u64()) {
u.last_seen = Some(chrono::Utc::now().timestamp());
u.insert(db)?;
} else {
let new_user = UserInfo {
user_id: msg.author.id.as_u64().clone() as i64,
@ -223,90 +71,33 @@ impl Handler {
last_seen: Some(chrono::Utc::now().timestamp()),
};
new_user.insert(db)?;
userinfo.insert(msg.author.id.as_u64().clone(), new_user);
}
Ok(false)
Ok(())
}
async fn message_deleted(ctx: &Context, fctx: &FrameworkContext<'_, ManifoldData, ManifoldError>, channel_id: &ChannelId, deleted_message_id: &MessageId, _guild_id: &Option<GuildId>) -> ManifoldResult<bool> {
let log_channel = fctx.user_data().await.bot_config.channels.log;
let channel = match ctx.cache.guild_channel(channel_id) {
Some(c) => c.name,
None => t!("global.not_available_with_id", id = channel_id).to_string()
};
match ctx.cache.message(channel_id, deleted_message_id) {
Some(msg) => {
let mut attachment_urls: Vec<String> = Vec::new();
for attachment in &msg.attachments {
attachment_urls.push(attachment.url.clone());
}
log_channel.send_message(ctx, |f| {
f
.content("")
.embed(|e| {
e
.title(t!("logging.message_deleted", channel = channel, channel_id = channel_id))
.colour(Colour::from_rgb(255, 0, 0))
.author(|a| a.name(&msg.author.name))
.field(t!("logging.message_deleted.content"), msg.content_safe(&ctx.cache), false)
.field(t!("logging.message_deleted.attachments"), attachment_urls.join(", "), false)
.timestamp(Timestamp::now())
.footer(|f| f.text(&msg.author.id));
for attachment in &msg.attachments {
e.image(attachment.url.clone());
}
e
})
}).await?;
},
None => {
log_channel.send_message(ctx, |f| {
f
.content("")
.embed(|e| {
e
.title(t!("logging.message_deleted.not_cached", channel_name = channel, channel_id = channel_id))
.colour(Colour::from_rgb(255, 0, 0))
.timestamp(Timestamp::now())
})
}).await?;
}
}
Ok(false)
}
async fn message_edited(ctx: &Context, fctx: &FrameworkContext<'_, ManifoldData, ManifoldError>, original: &Option<Message>, new_message: &Option<Message>) -> ManifoldResult<bool> {
let log_channel = fctx.user_data().await.bot_config.channels.log;
async fn message_edited(ctx: &Context, fctx: &FrameworkContext<'_, ManifoldData, ManifoldError>, original: &Option<Message>, new_message: &Option<Message>) -> ManifoldResult<()> {
let log_channel = fctx.user_data().await.bot_config.get_channel(&"Log".to_string()).unwrap();
if let Some(new) = new_message.as_ref() {
let message_channel = new.channel_id.name(ctx).await.unwrap_or("Unknown Channel".to_string());
log_channel.send_message(ctx, |f| {
f
.content("")
.embed(|e| {
e
.title(t!("logging.message_edited", channel_name = message_channel, channel_id = new.channel_id))
.colour(Colour::from_rgb(255, 153, 0))
.title("Message updated")
.author(|a| a.name(new.author.name.clone()))
.timestamp(Timestamp::now())
.field(t!("logging.message_edited.original_content"), match original.as_ref() {
.timestamp(new.timestamp)
.field("Original Content", match original.as_ref() {
Some(m) => m.content.clone(),
None => t!("global.not_available").to_string(),
None => "Not available".to_string(),
}, false)
.field(t!("logging.message_edited.new_content"), new.content.clone(), false)
.field(t!("logging.message_edited.created_at"), new.timestamp, true)
.field(t!("logging.message_edited.author"), &new.author.id, true)
.field("New Content", new.content.clone(), false)
})
}).await?;
}
Ok(false)
Ok(())
}
}

55
src/helpers/mod.rs
View File

@ -1,55 +0,0 @@
use crate::error::ManifoldResult;
use crate::ManifoldContext;
use poise::{ReplyHandle, serenity_prelude};
use poise::serenity_prelude::CreateEmbed;
pub async fn paginate(ctx: ManifoldContext<'_>, message: ReplyHandle<'_>, pages: Vec<CreateEmbed>, mut current_page: usize) -> ManifoldResult<()> {
// Define some unique identifiers for the navigation buttons
let ctx_id = ctx.id();
let prev_button_id = format!("{}prev", ctx.id());
let next_button_id = format!("{}next", ctx.id());
// Send the embed with the first page as content
message.edit(ctx, |m| {
m.embeds = vec![pages[current_page].to_owned()];
m.components(|b| {
b.create_action_row(|b| {
b.create_button(|b| b.custom_id(&prev_button_id).emoji('◀'))
.create_button(|b| b.custom_id(&next_button_id).emoji('▶'))
})
})
}).await?;
// Loop through incoming interactions with the navigation buttons
while let Some(press) = serenity_prelude::CollectComponentInteraction::new(ctx)
// We defined our button IDs to start with `ctx_id`. If they don't, some other command's
// button was pressed
.filter(move |press| press.data.custom_id.starts_with(&ctx_id.to_string()))
// Timeout when no navigation button has been pressed for five minutes
.timeout(std::time::Duration::from_secs(300))
.await
{
// Depending on which button was pressed, go to next or previous page
if press.data.custom_id == next_button_id {
current_page += 1;
if current_page >= pages.len() {
current_page = 0;
}
} else if press.data.custom_id == prev_button_id {
current_page = current_page.checked_sub(1).unwrap_or(pages.len() - 1);
} else {
// This is an unrelated button interaction
continue;
}
// Update the message with the new page contents
press
.create_interaction_response(ctx, |b| {
b.kind(serenity_prelude::InteractionResponseType::UpdateMessage)
.interaction_response_data(|b| b.set_embeds(vec![pages[current_page.clone()].to_owned()]))
})
.await?;
}
Ok(())
}

65
src/lib.rs
View File

@ -1,5 +1,4 @@
#[macro_use] extern crate log;
#[macro_use] extern crate rust_i18n;
#[macro_use] extern crate serde;
use std::env;
@ -8,20 +7,21 @@ use std::path::PathBuf;
use std::sync::Arc;
use clap::ArgMatches;
use diesel::pg::Pg;
use diesel::r2d2::ConnectionManager;
use diesel::PgConnection;
use diesel::sqlite::Sqlite;
use diesel::SqliteConnection;
use diesel_migrations::{embed_migrations, EmbeddedMigrations, MigrationHarness};
use poise::framework::FrameworkBuilder;
use poise::serenity_prelude::*;
use crate::config::ManifoldConfig;
use crate::error::{ManifoldError, ManifoldResult};
use crate::events::{EventHandler, Handler};
use crate::events::Handler;
use crate::models::user::{ManifoldUserInfo, UserInfo};
use crate::models::fueltank::FuelTank;
use crate::responses::Responses;
pub mod helpers;
pub mod autocomplete_helpers;
pub mod config;
pub mod error;
pub mod events;
@ -37,7 +37,7 @@ pub mod built_info {
include!(concat!(env!("OUT_DIR"), "/built.rs"));
}
pub type ManifoldDatabasePool = r2d2::Pool<ConnectionManager<PgConnection>>;
pub type ManifoldDatabasePool = r2d2::Pool<ConnectionManager<SqliteConnection>>;
pub struct Db {
pub pool: ManifoldDatabasePool,
@ -62,37 +62,35 @@ impl Deref for ManifoldData {
}
pub struct ManifoldDataInner {
pub bot_config: ManifoldConfig,
pub database: Db,
pub responses: Responses,
pub user_info: Mutex<ManifoldUserInfo>,
pub version_string: String,
bot_config: ManifoldConfig,
database: Db,
responses: Responses,
user_info: Mutex<ManifoldUserInfo>,
version_string: String,
frogtip_fueltank: Mutex<FuelTank>,
}
pub type ManifoldContext<'a> = poise::Context<'a, ManifoldData, ManifoldError>;
pub type ManifoldCommand = poise::Command<ManifoldData, ManifoldError>;
i18n!("config/locales");
pub async fn prepare_client<T: EventHandler>(arguments: ArgMatches, intents: GatewayIntents, injected_commands: Vec<ManifoldCommand>, caller_version_string: String, caller_database_migrations: EmbeddedMigrations) -> ManifoldResult<FrameworkBuilder<ManifoldData, ManifoldError>> {
pub async fn prepare_client(arguments: ArgMatches, intents: GatewayIntents, injected_commands: Vec<ManifoldCommand>, caller_version_string: String) -> ManifoldResult<FrameworkBuilder<ManifoldData, ManifoldError>> {
let bot_environment = arguments.get_one("environment").unwrap();
let config_file = arguments.get_one::<String>("config-file").unwrap();
let config_file = format!("config/{}", arguments.get_one::<String>("config-file").unwrap());
info!("Reading configuration...");
debug!("Configuration file path: {}", &config_file);
let bot_config = ManifoldConfig::new(&config_file, bot_environment).expect(&*format!("Could not read configuration file {}", &config_file));
let bot_locale = arguments.get_one::<String>("locale").unwrap();
let config = ManifoldConfig::load_config(&config_file, bot_environment).expect(&*format!("Could not read configuration file {}", &config_file));
rust_i18n::set_locale(bot_locale);
let prefix = config.get_value(&"BotPrefix".to_string()).expect("Could not read bot_prefix from config.");
let manager = ConnectionManager::<PgConnection>::new(format!("postgresql://{user}:{pass}@{host}:{port}/{database}", user=&bot_config.database.user, pass=&bot_config.database.pass, host=&bot_config.database.host, port=&bot_config.database.port, database=&bot_config.database.database_name));
let manager = ConnectionManager::<SqliteConnection>::new("manifold.db");
let pool = r2d2::Pool::builder()
.max_size(1)
.build(manager)
.expect("Database setup error!");
let mut responses = Responses::new();
responses.reload(&PathBuf::from(&format!("{file}.{locale}.txt", file=bot_config.responses_file_path, locale=bot_locale))).expect("Could not load responses file!");
responses.reload(&PathBuf::from(config.get_value(&"ResponsesFilePath".to_string()).unwrap_or("txt/responses.txt".to_string()))).expect("Could not load responses file!");
let token = env::var("DISCORD_TOKEN").expect(
"Could not find an environment variable called DISCORD_TOKEN",
@ -101,19 +99,17 @@ pub async fn prepare_client<T: EventHandler>(arguments: ArgMatches, intents: Gat
let framework = poise::Framework::builder()
.options(poise::FrameworkOptions {
event_handler: |ctx, e, fctx, _| Box::pin(async move {
match T::listen(ctx.clone(), fctx, e).await {
Ok(b) => if b { return Ok(()) },
Err(e) => return Err(e),
};
_ = Handler::listen(ctx.clone(), fctx, e).await;
Ok(())
Handler::listen(ctx, fctx, e).await
}),
pre_command: |ctx: ManifoldContext<'_>| Box::pin(async move {
debug!("Received command {} from {}", ctx.command().name, ctx.author().name);
info!("Received command {} from {}", ctx.command().name, ctx.author().name);
let config = &ctx.data().bot_config;
let log_channel = config.get_channel(&"Log".to_string()).unwrap();
let _ = log_channel.say(ctx, format!("Received command {} from {}", ctx.command().name, ctx.author().name)).await;
}),
commands: commands::collect_commands(injected_commands),
prefix_options: poise::PrefixFrameworkOptions {
prefix: Some(bot_config.prefix.clone()),
prefix: Some(prefix),
..Default::default()
},
..Default::default()
@ -124,18 +120,17 @@ pub async fn prepare_client<T: EventHandler>(arguments: ArgMatches, intents: Gat
Box::pin(async move {
poise::builtins::register_globally(ctx, &framework.options().commands).await?;
ctx.set_activity(Activity::watching("you")).await;
ctx.cache.set_max_messages(350);
let db = Db { pool };
apply_migrations(&mut db.get()?, caller_database_migrations);
apply_migrations(&mut db.get()?);
let user_info = UserInfo::load(&db).expect("Could not load user info, rejecting");
let git_info: String = built_info::GIT_VERSION.unwrap_or("unknown").to_string();
Ok(ManifoldData(Arc::new(ManifoldDataInner {
bot_config,
bot_config: config,
database: db,
responses,
user_info: Mutex::new(user_info),
version_string: t!("misc.version_string", caller=caller_version_string, mfold_ver=built_info::PKG_VERSION, mfold_time=built_info::BUILT_TIME_UTC, mfold_rev=git_info).to_string(),
version_string: format!("{caller} (Manifold framework version {mfold_ver} built at {mfold_time} from revision {mfold_rev})", caller=caller_version_string, mfold_ver=built_info::PKG_VERSION, mfold_time=built_info::BUILT_TIME_UTC, mfold_rev=git_info),
frogtip_fueltank: Mutex::new(FuelTank::with_cache())
})))
})
});
@ -143,10 +138,8 @@ pub async fn prepare_client<T: EventHandler>(arguments: ArgMatches, intents: Gat
Ok(framework)
}
fn apply_migrations(conn: &mut impl MigrationHarness<Pg>, caller_migrations: EmbeddedMigrations) {
fn apply_migrations(conn: &mut impl MigrationHarness<Sqlite>) {
conn.run_pending_migrations(MIGRATIONS)
.expect("An error occurred applying migrations.");
conn.run_pending_migrations(caller_migrations)
.expect("An error occurred applying caller migrations");
}

26
src/models/animalpics.rs
View File

@ -1,26 +0,0 @@
use std::fmt::{Display, Formatter};
use crate::models::fueltank::Pump;
#[derive(Serialize, Deserialize, Debug)]
pub struct AnimalPic {
pub id: String,
pub url: String,
}
pub type AnimalPicWrapper = Vec<AnimalPic>;
impl Display for AnimalPic {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
write!(f, "{}", self.url)
}
}
impl Pump<AnimalPic> for AnimalPicWrapper {
fn pump(&mut self) -> Option<AnimalPic> {
self.pop()
}
fn len(&self) -> usize {
self.len()
}
}

29
src/models/dadjoke.rs
View File

@ -1,29 +0,0 @@
use std::fmt::{Display, Formatter};
use crate::models::fueltank::Pump;
#[derive(Serialize, Deserialize, Debug)]
pub struct DadJoke {
pub id: String,
pub joke: String,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DadJokeWrapper {
pub results: Vec<DadJoke>
}
impl Display for DadJoke {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
write!(f, "{}", self.joke)
}
}
impl Pump<DadJoke> for DadJokeWrapper {
fn pump(&mut self) -> Option<DadJoke> {
self.results.pop()
}
fn len(&self) -> usize {
self.results.len()
}
}

29
src/models/frogtip.rs
View File

@ -1,29 +0,0 @@
use std::fmt::{Display, Formatter};
use crate::models::fueltank::Pump;
#[derive(Clone, Serialize, Deserialize, Debug)]
pub struct Tip {
pub number: i32,
pub tip: String,
}
impl Display for Tip {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
write!(f, "#{}: {}", self.number, self.tip)
}
}
#[derive(Serialize, Deserialize, Debug)]
pub struct Croak {
pub tips: Vec<Tip>,
}
impl Pump<Tip> for Croak {
fn pump(&mut self) -> Option<Tip> {
self.tips.pop()
}
fn len(&self) -> usize {
self.tips.len()
}
}

199
src/models/fueltank.rs
View File

@ -1,128 +1,115 @@
use std::env::temp_dir;
use std::fmt::Debug;
use std::fmt::{Display, Formatter};
use std::fs;
use std::path::PathBuf;
use dirs::home_dir;
use std::io::{SeekFrom, Seek};
use reqwest::Client;
use reqwest::header::{ACCEPT, CONTENT_TYPE};
use serde::de::DeserializeOwned;
use serde::Serialize;
use reqwest::header::CONTENT_TYPE;
use crate::error::{ManifoldError, ManifoldResult};
const CACHE_VERSION: &'static str = "1";
pub trait Pump<V> {
fn pump(&mut self) -> Option<V>;
fn len(&self) -> usize;
fn pump<F>(self) -> Result<V, ManifoldError>;
}
#[derive(Clone, Debug, Serialize, Deserialize)]
#[derive(Copy, Clone, Debug)]
#[allow(dead_code)]
pub struct FuelTank {
pub source_uri: String,
cache_name: Option<String>,
pub api_key: Option<String>,
cache_mode: TankMode,
mode: TankMode,
}
#[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq)]
pub enum TankMode {
#[derive(Copy, Clone, Debug)]
enum TankMode {
Cache,
NoCache,
}
impl FuelTank {
pub async fn next_or_fill<T: Debug, U: Debug>(&self) -> ManifoldResult<T>
where T: DeserializeOwned,
U: Serialize,
U: DeserializeOwned, U: Pump<T>
{
let path = PathBuf::new()
.join(temp_dir())
.join(format!("manifold-{}-cache-{}.json", self.cache_name.clone().unwrap(), CACHE_VERSION));
let mut fuel = match self.cache_mode {
TankMode::Cache => {
// Read cache only if we have one
debug!("Filling tank!");
let mut cache = {
debug!("Cache path: {:?}", &path);
fs::OpenOptions::new()
.read(true)
.write(true)
.create(true)
.open(&path)
.map_err(|e| {
error!("Error creating cache file: {}", e);
ManifoldError::from("CACHE ERROR")
})?
};
debug!("Cache: {:?}", &cache);
let json: Result<U, serde_json::Error> = serde_json::from_reader(&mut cache);
debug!("Json: {:?}", &json);
match json {
Ok(contents) => {
match contents.len() {
0 => self.emit().await?,
_ => contents,
}
}
_ => self.emit().await?,
}
},
TankMode::NoCache => {
self.emit().await?
},
};
debug!("Got tips: {:?}", &fuel);
let single = fuel.pump().ok_or(ManifoldError::from("CACHE ERROR"))?;
debug!("Got single tip: {:?}", &single);
if self.cache_mode == TankMode::Cache {
// Write cache only if we have one
let mut cache = {
debug!("Cache path: {:?}", &path);
fs::OpenOptions::new()
.write(true)
.create(true)
.open(&path)
.map_err(|e| {
error!("Error creating cache file: {}", e);
ManifoldError::from("CACHE ERROR")
})?
};
cache
.set_len(0)
.and_then(|_| cache.seek(SeekFrom::Start(0)))?;
debug!("Writing cache");
serde_json::to_writer(cache, &fuel)?;
pub fn with_cache() -> Self {
Self {
mode: TankMode::Cache,
}
Ok(single)
}
pub async fn emit<U: Debug>(&self) -> ManifoldResult<U>
where U: DeserializeOwned
{
debug!("Getting new tips");
let result: U;
let mut client = Client::new().get(&self.source_uri)
.header(CONTENT_TYPE, "application/json")
.header(ACCEPT, "application/json");
if let Some(api_key) = &self.api_key {
client = client.header("X-API-KEY", api_key);
}
result = client.send().await?.json().await?;
debug!("Result: {:?}", &result);
Ok(result)
}
}
#[derive(Clone, Serialize, Deserialize, Debug)]
pub struct Tip {
pub number: i32,
pub tip: String,
}
impl Display for Tip {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
write!(f, "#{}: {}", self.number, self.tip)
}
}
#[derive(Serialize, Deserialize, Debug)]
pub struct Croak {
pub tips: Vec<Tip>,
}
pub async fn croak() -> ManifoldResult<Vec<Tip>> {
debug!("Getting new tips");
let result: Croak;
let client = Client::new();
result = client.get("https://frog.tips/api/1/tips/")
.header(CONTENT_TYPE, "application/json")
.send().await?.json().await?;
debug!("Result: {:?}", &result);
Ok(result.tips)
}
impl FuelTank {
pub async fn next_or_fill(self) -> Result<Tip, ManifoldError> {
debug!("Filling tank!");
let mut cache = {
let mut path = PathBuf::new();
path.push(home_dir().ok_or(ManifoldError::from("No home dir"))?);
path.push(".local");
path.push(format!("coffeebot-frog-cache-{}.json", CACHE_VERSION));
debug!("Cache path: {:?}", &path);
fs::OpenOptions::new()
.read(true)
.write(true)
.create(true)
.open(path)
.map_err(|e| {
error!("Error creating cache file: {}", e);
ManifoldError::from("CACHE ERROR")
})?
};
debug!("Cache: {:?}", &cache);
let json: Result<Vec<Tip>, serde_json::Error> = serde_json::from_reader(&mut cache);
debug!("Json: {:?}", &json);
let mut tips = match json {
Ok(contents) => {
match contents.len() {
0 => croak().await?,
_ => contents,
}
}
_ => croak().await?,
};
debug!("Got tips: {:?}", &tips);
let tip = tips.pop().ok_or(ManifoldError::from("FROG HAS NO TIPS FOR YOU. CROAK ERROR 12"))?;
debug!("Got single tip: {:?}", &tip);
cache
.set_len(0)
.and_then(|_| cache.seek(SeekFrom::Start(0)))?;
debug!("Writing cache");
serde_json::to_writer(cache, &tips)?;
Ok(tip)
}
}

4
src/models/mod.rs
View File

@ -1,7 +1,3 @@
pub mod animalpics;
pub mod dadjoke;
pub mod frogtip;
pub mod fueltank;
pub mod nasa;
pub mod user;
pub mod weather;

25
src/models/nasa.rs
View File

@ -1,25 +0,0 @@
use std::fmt::{Display, Formatter};
use crate::models::fueltank::Pump;
#[derive(Clone, Serialize, Deserialize, Debug)]
pub struct NasaAstroPhoto {
pub explanation: String,
pub hdurl: String,
pub title: String
}
impl Display for NasaAstroPhoto {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
write!(f, "{}", self.hdurl)
}
}
impl Pump<NasaAstroPhoto> for NasaAstroPhoto {
fn pump(&mut self) -> Option<NasaAstroPhoto> {
Some(self.clone())
}
fn len(&self) -> usize {
1
}
}

14
src/models/user.rs
View File

@ -1,13 +1,13 @@
use diesel::prelude::*;
use std::collections::HashMap;
use diesel::insert_into;
use diesel::{insert_into, update};
use crate::schema::*;
use crate::schema::userinfo::dsl as userinfo_dsl;
use crate::Db;
use crate::error::{ManifoldError, ManifoldResult};
#[derive(Identifiable, Insertable, AsChangeset, Selectable, Debug, Queryable, Serialize, Clone)]
#[derive(Identifiable, Insertable, AsChangeset, Debug, Queryable, Serialize, Clone)]
#[diesel(primary_key(user_id))]
#[diesel(table_name = userinfo)]
pub struct UserInfo {
@ -48,11 +48,15 @@ impl UserInfo {
pub fn insert(&self, conn: &Db) -> ManifoldResult<usize> {
insert_into(userinfo_dsl::userinfo)
.values(self)
.on_conflict(userinfo_dsl::user_id)
.do_update()
.set(self)
.execute(&mut conn.get()?)
.map_err(|e| ManifoldError::from(e))
}
pub fn save(&self, conn: &Db) -> ManifoldResult<usize> {
update(userinfo_dsl::userinfo)
.filter(userinfo::user_id.eq(self.user_id))
.set(self)
.execute(&mut conn.get()?)
.map_err(|e| ManifoldError::from(e))
}
}

29
src/models/weather.rs
View File

@ -1,7 +1,11 @@
use crate::error::{ManifoldError, ManifoldResult};
use crate::error::ManifoldResult;
use reqwest::Client;
use reqwest::header::CONTENT_TYPE;
use crate::models::fueltank::FuelTank;
pub struct Weather {
base_url: String,
api_key: String,
}
#[derive(Debug, Deserialize)]
pub struct CurrentConditionInformation {
@ -99,7 +103,7 @@ pub struct DayAstro {
pub moonrise: String,
pub moonset: String,
pub moon_phase: String,
pub moon_illumination: i64
pub moon_illumination: String
}
#[derive(Debug, Deserialize)]
@ -141,13 +145,22 @@ pub struct WeatherForecastRequestResponse {
pub forecast: ForecastDayWrapper,
}
pub type Weather = FuelTank;
impl Weather {
pub fn new(api_key:String, base_url: String) -> Self {
Weather {
base_url,
api_key,
}
}
pub async fn get_weather_forecast(&self, target: String) -> ManifoldResult<WeatherForecastRequestResponse> {
pub async fn get_weather_forecast(&self, target: String, days: Option<i32>) -> ManifoldResult<WeatherForecastRequestResponse> {
let target_url: String;
let target_url = format!("{}/forecast.json?key={}&q={}&days=2", self.source_uri, self.api_key.clone().ok_or_else(|| ManifoldError::from("No API key presented for Weather API"))?, &target);
if let Some(d) = days {
target_url = format!("{}/forecast.json?key={}&q={}&days={}", self.base_url, self.api_key, &target, d);
} else {
target_url = format!("{}/forecast.json?key={}&q={}&days=3", self.base_url, self.api_key, &target);
}
let client = Client::new();
let result = client.get(target_url)
@ -166,7 +179,7 @@ impl Weather {
decoded_result.current.dewpoint_f = Some((decoded_result.current.dewpoint_c.unwrap() * 1.8) + 32.0);
debug!("{:?}", &decoded_result);
debug!("{:?}", decoded_result);
Ok(decoded_result)
}