|
|
|
|
@ -2,7 +2,7 @@ extern crate dotenvy;
|
|
|
|
|
extern crate lastfm;
|
|
|
|
|
extern crate reqwest;
|
|
|
|
|
extern crate reqwest_middleware;
|
|
|
|
|
use http_cache_reqwest::{CACacheManager, Cache, CacheMode, HttpCache, HttpCacheOptions};
|
|
|
|
|
use http_cache_reqwest::{CACacheManager, Cache, CacheMode, HttpCache, HttpCacheOptions,};
|
|
|
|
|
|
|
|
|
|
use serenity::async_trait;
|
|
|
|
|
use serenity::builder::{CreateAttachment, CreateMessage};
|
|
|
|
|
@ -14,8 +14,10 @@ extern crate magick_rust;
|
|
|
|
|
use magick_rust::{
|
|
|
|
|
ColorspaceType, CompositeOperator, FilterType, MagickWand, PixelWand, magick_wand_genesis,
|
|
|
|
|
};
|
|
|
|
|
use magick_rust::bindings::MagickSetSeed;
|
|
|
|
|
|
|
|
|
|
use std::env;
|
|
|
|
|
use std::collections::HashMap;
|
|
|
|
|
use std::sync::{Arc, Once};
|
|
|
|
|
use tokio::sync::Mutex;
|
|
|
|
|
|
|
|
|
|
@ -32,6 +34,9 @@ use rspotify::{ClientCredsSpotify, Credentials, clients::BaseClient};
|
|
|
|
|
use imagetext::fontdb::FontDB;
|
|
|
|
|
use imagetext::superfont::SuperFont;
|
|
|
|
|
|
|
|
|
|
use std::time::SystemTime;
|
|
|
|
|
use std::io::Read;
|
|
|
|
|
|
|
|
|
|
mod text;
|
|
|
|
|
|
|
|
|
|
static START: Once = Once::new();
|
|
|
|
|
@ -69,8 +74,9 @@ macro_rules! log {
|
|
|
|
|
macro_rules! handle_magick_result {
|
|
|
|
|
($a: expr, $b: literal) => {
|
|
|
|
|
match $a {
|
|
|
|
|
Ok(_) => {
|
|
|
|
|
Ok(a) => {
|
|
|
|
|
log!("{} run successfully", stringify!($a));
|
|
|
|
|
a
|
|
|
|
|
}
|
|
|
|
|
Err(e) => return Reply::Text(format!("Error: {} {}", $b, e)),
|
|
|
|
|
}
|
|
|
|
|
@ -122,12 +128,12 @@ fn validate_color(col: &PixelWand) -> Option<Lab> {
|
|
|
|
|
|
|
|
|
|
async fn get_track(
|
|
|
|
|
ctx: &Context,
|
|
|
|
|
arg: &str,
|
|
|
|
|
arg: Option<&str>,
|
|
|
|
|
id: UserId,
|
|
|
|
|
) -> Result<lastfm::track::NowPlayingTrack, Reply> {
|
|
|
|
|
let lastfm_user = match arg {
|
|
|
|
|
"" => get_lastfm_username(ctx, id).await,
|
|
|
|
|
_ => Some(arg.to_owned()),
|
|
|
|
|
None => get_lastfm_username(ctx, id).await,
|
|
|
|
|
Some(user) => Some(user.to_owned()),
|
|
|
|
|
};
|
|
|
|
|
let lastfm_client = match lastfm_user {
|
|
|
|
|
Some(s) => lastfm::Client::<String, String>::from_env(s),
|
|
|
|
|
@ -148,7 +154,7 @@ async fn get_track(
|
|
|
|
|
Ok(track)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
async fn art(ctx: &Context, arg: &str, id: UserId) -> Reply {
|
|
|
|
|
async fn art(ctx: &Context, arg: Option<&str>, id: UserId) -> Reply {
|
|
|
|
|
let track = match get_track(ctx, arg, id).await {
|
|
|
|
|
Ok(track) => track,
|
|
|
|
|
Err(e) => return e,
|
|
|
|
|
@ -160,7 +166,7 @@ async fn art(ctx: &Context, arg: &str, id: UserId) -> Reply {
|
|
|
|
|
Reply::Text(track_art.to_owned())
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
async fn url(ctx: &Context, arg: &str, id: UserId) -> Reply {
|
|
|
|
|
async fn url(ctx: &Context, arg: Option<&str>, id: UserId) -> Reply {
|
|
|
|
|
let track = match get_track(ctx, arg, id).await {
|
|
|
|
|
Ok(track) => track,
|
|
|
|
|
Err(e) => return e,
|
|
|
|
|
@ -168,43 +174,77 @@ async fn url(ctx: &Context, arg: &str, id: UserId) -> Reply {
|
|
|
|
|
Reply::Text(track.url)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
async fn spot(ctx: &Context, arg: &str, id: UserId) -> Reply {
|
|
|
|
|
async fn spot(ctx: &Context, arg: Option<&str>, id: UserId) -> Reply {
|
|
|
|
|
let track = match get_track(ctx, arg, id).await {
|
|
|
|
|
Ok(track) => track,
|
|
|
|
|
Err(e) => return e,
|
|
|
|
|
};
|
|
|
|
|
let mut data = ctx.data.write().await;
|
|
|
|
|
let spotify_option = data
|
|
|
|
|
.get_mut::<SpotifyHaver>()
|
|
|
|
|
.expect("Failed to have spotify option");
|
|
|
|
|
let spotify_option = data.get_mut::<SpotifyHaver>().expect("Failed to have spotify option");
|
|
|
|
|
if spotify_option.is_none() {
|
|
|
|
|
return Reply::Text("Unable to use Spotify command: Contact bot Administrator.".to_owned());
|
|
|
|
|
return Reply::Text("Unable to use Spotify commands: Contact bot Administrator.".to_owned())
|
|
|
|
|
}
|
|
|
|
|
let spotify_arc_mutex = spotify_option.as_mut().unwrap();
|
|
|
|
|
//let spotify_arc_mutex_ref = Arc::clone(&spotify_arc_mutex);
|
|
|
|
|
let spotify_client = spotify_arc_mutex.lock().await;
|
|
|
|
|
let search = spotify_client
|
|
|
|
|
.search(
|
|
|
|
|
format!(r#"track:"{}" album:"{}" artist:"{}""#, track.name.replace("\"", ""), track.album.replace("\"", ""), track.artist.name.replace("\"", "")).as_str(),
|
|
|
|
|
SearchType::Track,
|
|
|
|
|
None,
|
|
|
|
|
None,
|
|
|
|
|
None,
|
|
|
|
|
None,
|
|
|
|
|
)
|
|
|
|
|
.await;
|
|
|
|
|
spotify_client.request_token().await.unwrap();
|
|
|
|
|
let search = spotify_client.search(format!("{} {}", track.name, track.artist.name).as_str(), SearchType::Track, None, None, None, None).await;
|
|
|
|
|
let tracks = match search {
|
|
|
|
|
Ok(SearchResult::Tracks(track_page)) => track_page,
|
|
|
|
|
Err(e) => return Reply::Text(format!("Failed to get track {e}")),
|
|
|
|
|
_ => return Reply::Text("Spotify search failed".to_owned()),
|
|
|
|
|
};
|
|
|
|
|
match &tracks.items[0].external_urls.get("spotify") {
|
|
|
|
|
Some(url) => Reply::Text(url.to_owned().to_owned()),
|
|
|
|
|
None => Reply::Text("Unable to get spotify url".to_owned()),
|
|
|
|
|
match &tracks.items.first().map(|x| x.external_urls.get("spotify")) {
|
|
|
|
|
Some(Some(url)) => Reply::Text(url.to_owned().to_owned()),
|
|
|
|
|
_ => Reply::Text("Unable to get spotify url".to_owned()),
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
async fn fmi(ctx: &Context, arg: &str, id: UserId, avatar: Option<String>) -> Reply {
|
|
|
|
|
async fn get_overrides_inner(last_modified: Option<SystemTime>) -> Option<HashMap<String, String>> {
|
|
|
|
|
let mut file = match std::fs::File::open("overrides.txt") {
|
|
|
|
|
Ok(a) => a,
|
|
|
|
|
Err(_) => return None,
|
|
|
|
|
};
|
|
|
|
|
let file_stats = match file.metadata() {
|
|
|
|
|
Ok(a) => a,
|
|
|
|
|
Err(_) => return None,
|
|
|
|
|
};
|
|
|
|
|
let file_modified_time = match file_stats.modified() {
|
|
|
|
|
Ok(a) => a,
|
|
|
|
|
Err(_) => return None,
|
|
|
|
|
};
|
|
|
|
|
let reload = match last_modified {
|
|
|
|
|
None => true,
|
|
|
|
|
Some(last_modified) => match file_modified_time.duration_since(last_modified) {
|
|
|
|
|
Err(_) => true,
|
|
|
|
|
Ok(a) => a != std::time::Duration::default()
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
if !reload { return None; }
|
|
|
|
|
let mut contents = "".to_owned();
|
|
|
|
|
match file.read_to_string(&mut contents) {
|
|
|
|
|
Ok(_) => (),
|
|
|
|
|
Err(_) => return None,
|
|
|
|
|
};
|
|
|
|
|
Some(contents.as_str().lines().map(|x| {
|
|
|
|
|
let mut split = x.split("@");
|
|
|
|
|
let a: &str = split.next().unwrap_or("").trim();
|
|
|
|
|
let b: &str = split.next().unwrap_or("").trim();
|
|
|
|
|
(a.to_owned(), b.to_owned())
|
|
|
|
|
}).collect())
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
async fn get_overrides(ctx: &Context) -> HashMap<String, String> {
|
|
|
|
|
let data = ctx.data.write().await;
|
|
|
|
|
let overrides = data.get::<OverridesHaver>().expect("Failed to have overrides");
|
|
|
|
|
let mut map = overrides.map.lock().await;
|
|
|
|
|
let new_map = get_overrides_inner(overrides.last_modified).await;
|
|
|
|
|
if let Some(new_map) = new_map {
|
|
|
|
|
*map = new_map;
|
|
|
|
|
}
|
|
|
|
|
map.clone()
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
async fn fmi(ctx: &Context, arg: Option<&str>, id: UserId, avatar: Option<String>) -> Reply {
|
|
|
|
|
let track = match get_track(ctx, arg, id).await {
|
|
|
|
|
Ok(track) => track,
|
|
|
|
|
Err(e) => return e,
|
|
|
|
|
@ -214,16 +254,22 @@ async fn fmi(ctx: &Context, arg: &str, id: UserId, avatar: Option<String>) -> Re
|
|
|
|
|
artist: track.artist.name,
|
|
|
|
|
album: track.album,
|
|
|
|
|
};
|
|
|
|
|
let image_uri = match track.image.extralarge {
|
|
|
|
|
let original_image_uri = match track.image.extralarge {
|
|
|
|
|
Some(iu) => iu,
|
|
|
|
|
None => return Reply::Text("Error: getting image uri failed".to_owned()),
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
let image = match get_image(ctx, image_uri.as_str()).await {
|
|
|
|
|
Ok(i) => i,
|
|
|
|
|
Err(e) => return Reply::Text(format!("{e}")),
|
|
|
|
|
};
|
|
|
|
|
let overrides = get_overrides(ctx).await;
|
|
|
|
|
let image_uri: String = match overrides.get(&format!("{} | {}", track_info.artist, track_info.album)) {
|
|
|
|
|
Some(s) => s,
|
|
|
|
|
None => match overrides.get(&track_info.album) {
|
|
|
|
|
Some(s) => s,
|
|
|
|
|
None => &original_image_uri,
|
|
|
|
|
},
|
|
|
|
|
}.to_owned();
|
|
|
|
|
|
|
|
|
|
let mut base_color = PixelWand::new();
|
|
|
|
|
let mut accent_color = PixelWand::new();
|
|
|
|
|
let mut white = PixelWand::new();
|
|
|
|
|
let main_wand = MagickWand::new();
|
|
|
|
|
let art_wand = MagickWand::new();
|
|
|
|
|
@ -231,10 +277,10 @@ async fn fmi(ctx: &Context, arg: &str, id: UserId, avatar: Option<String>) -> Re
|
|
|
|
|
let mask_wand = MagickWand::new();
|
|
|
|
|
let text_image_wand = MagickWand::new();
|
|
|
|
|
|
|
|
|
|
handle_magick_result!(
|
|
|
|
|
base_color.set_color("#7f7f7f"),
|
|
|
|
|
"Failed to set init base color"
|
|
|
|
|
);
|
|
|
|
|
let image = match get_image(ctx, image_uri.as_str()).await {
|
|
|
|
|
Ok(i) => i,
|
|
|
|
|
Err(e) => return Reply::Text(format!("{e}")),
|
|
|
|
|
};
|
|
|
|
|
handle_magick_result!(
|
|
|
|
|
art_wand.read_image_blob(image),
|
|
|
|
|
"Failed to read image from uri"
|
|
|
|
|
@ -244,6 +290,26 @@ async fn fmi(ctx: &Context, arg: &str, id: UserId, avatar: Option<String>) -> Re
|
|
|
|
|
"Failed to set art colorspace"
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
handle_magick_result!(
|
|
|
|
|
base_color.set_color("#7f7f7f"),
|
|
|
|
|
"Failed to set init base color"
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
let color_cache_entry = {
|
|
|
|
|
let data = ctx.data.write().await;
|
|
|
|
|
let color_cache = data.get::<ColorsHaver>().expect("Failed to have colors option");
|
|
|
|
|
if color_cache.max > 0 {
|
|
|
|
|
let color_cache_map = color_cache.map.lock().await;
|
|
|
|
|
color_cache_map.get(image_uri.as_str()).map(|s| s.to_owned())
|
|
|
|
|
} else {
|
|
|
|
|
None
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
let (base_lab, accent_lab) = match color_cache_entry {
|
|
|
|
|
Some(value) => value.to_owned(),
|
|
|
|
|
None => {
|
|
|
|
|
let (art_width, art_height) = (art_wand.get_image_width(), art_wand.get_image_height());
|
|
|
|
|
handle_magick_result!(
|
|
|
|
|
art_wand_cluster.new_image(art_width, art_height, &base_color),
|
|
|
|
|
@ -258,6 +324,7 @@ async fn fmi(ctx: &Context, arg: &str, id: UserId, avatar: Option<String>) -> Re
|
|
|
|
|
art_wand_cluster.set_image_colorspace(ColorspaceType::Lab),
|
|
|
|
|
"Failed to set cluster colorspace"
|
|
|
|
|
);
|
|
|
|
|
unsafe { MagickSetSeed(0x5F3759DF); }
|
|
|
|
|
handle_magick_result!(
|
|
|
|
|
art_wand_cluster.kmeans(10, 200, 0.001),
|
|
|
|
|
"Failed to run kmeans"
|
|
|
|
|
@ -278,20 +345,27 @@ async fn fmi(ctx: &Context, arg: &str, id: UserId, avatar: Option<String>) -> Re
|
|
|
|
|
}
|
|
|
|
|
})
|
|
|
|
|
.collect::<Vec<_>>();
|
|
|
|
|
let mut accent_color = PixelWand::new();
|
|
|
|
|
handle_magick_result!(
|
|
|
|
|
accent_color.set_color("cielab(0.0,0.0,0.0)"),
|
|
|
|
|
"Failed to init accent color"
|
|
|
|
|
);
|
|
|
|
|
let mut accent_lab = "cielab(0.0,0.0,0.0)".to_owned();
|
|
|
|
|
if let Some(color) = other_colors.first() {
|
|
|
|
|
let col = format!("cielab{:?}", color.into_components());
|
|
|
|
|
handle_magick_result!(
|
|
|
|
|
accent_color.set_color(col.as_str()),
|
|
|
|
|
"Failed to set accent color"
|
|
|
|
|
);
|
|
|
|
|
accent_lab = format!("cielab{:?}", color.into_components());
|
|
|
|
|
}
|
|
|
|
|
let base_lab = handle_magick_result!(colors[0].get_color_as_string(), "Failed to serialize base color");
|
|
|
|
|
let data = ctx.data.write().await;
|
|
|
|
|
let color_cache = data.get::<ColorsHaver>().expect("Failed to have colors option");
|
|
|
|
|
let mut color_cache_map = color_cache.map.lock().await;
|
|
|
|
|
if color_cache_map.keys().len() > color_cache.max {
|
|
|
|
|
let key: String = color_cache_map.iter().next().unwrap().0.to_owned();
|
|
|
|
|
color_cache_map.remove(&key);
|
|
|
|
|
}
|
|
|
|
|
color_cache_map.insert(image_uri, (base_lab.clone(), accent_lab.clone()));
|
|
|
|
|
(base_lab, accent_lab)
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
let use_dark_color = match validate_color(&colors[0]) {
|
|
|
|
|
handle_magick_result!(base_color.set_color(base_lab.as_str()), "Failed to deserialize base color");
|
|
|
|
|
handle_magick_result!(accent_color.set_color(accent_lab.as_str()), "Failed to deserialize accent color");
|
|
|
|
|
|
|
|
|
|
let use_dark_color = match validate_color(&base_color) {
|
|
|
|
|
Some(color) => {
|
|
|
|
|
let black_delta_e = Lab::<D65>::new(0.0, 0.0, 0.0).improved_difference(color);
|
|
|
|
|
let white_delta_e = Lab::<D65>::new(100.0, 0.0, 0.0).improved_difference(color);
|
|
|
|
|
@ -372,7 +446,7 @@ async fn fmi(ctx: &Context, arg: &str, id: UserId, avatar: Option<String>) -> Re
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
handle_magick_result!(
|
|
|
|
|
main_wand.new_image(image_width as usize, image_height as usize, &colors[0]),
|
|
|
|
|
main_wand.new_image(image_width as usize, image_height as usize, &base_color),
|
|
|
|
|
"Failed to create wand"
|
|
|
|
|
);
|
|
|
|
|
handle_magick_result!(
|
|
|
|
|
@ -380,13 +454,13 @@ async fn fmi(ctx: &Context, arg: &str, id: UserId, avatar: Option<String>) -> Re
|
|
|
|
|
"Failed to set main colorspace"
|
|
|
|
|
);
|
|
|
|
|
handle_magick_result!(
|
|
|
|
|
art_wand.adaptive_resize_image(124, 124),
|
|
|
|
|
art_wand.resize_image(124, 124, FilterType::RobidouxSharp),
|
|
|
|
|
"Failed to resize art"
|
|
|
|
|
);
|
|
|
|
|
handle_magick_result!(
|
|
|
|
|
/*handle_magick_result!(
|
|
|
|
|
art_wand_cluster.adaptive_resize_image(124, 124),
|
|
|
|
|
"Failed to resize art_cluster"
|
|
|
|
|
);
|
|
|
|
|
);*/
|
|
|
|
|
handle_magick_result!(
|
|
|
|
|
main_wand.compose_images(&art_wand, CompositeOperator::SrcOver, false, 12, 12),
|
|
|
|
|
"Failed to combine art image"
|
|
|
|
|
@ -419,29 +493,44 @@ async fn fmi(ctx: &Context, arg: &str, id: UserId, avatar: Option<String>) -> Re
|
|
|
|
|
Reply::Image(main_wand.write_image_blob("png").unwrap())
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn help(arg: &str) -> Reply {
|
|
|
|
|
async fn text(ctx: &Context, arg: Option<&str>, id: UserId) -> Reply {
|
|
|
|
|
let track = match get_track(ctx, arg, id).await {
|
|
|
|
|
Ok(track) => track,
|
|
|
|
|
Err(e) => return e,
|
|
|
|
|
};
|
|
|
|
|
Reply::Text(format!(
|
|
|
|
|
"{}\n{}\n{}",
|
|
|
|
|
track.name,
|
|
|
|
|
track.artist.name,
|
|
|
|
|
track.album,
|
|
|
|
|
))
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn help(arg: Option<&str>) -> Reply {
|
|
|
|
|
Reply::Text(format!(
|
|
|
|
|
"```{}```",
|
|
|
|
|
match arg {
|
|
|
|
|
"" =>
|
|
|
|
|
"usage: .k <img|set|art|url|spotify|help> [lastfm user]\n .k img [lastfm user]: get now playing\n .k set <lastfm user>: sets your username for the future\n .k art [lastfm user]: get now playing album art\n .k url [lastfm user]: get now playing lastfm url\n .k spot [lastfm user]: get now playing spotify link\n .k help [command]: displays a help message"
|
|
|
|
|
None =>
|
|
|
|
|
"usage: .k <img|set|art|url|spotify|help> [lastfm user]\n .k img [lastfm user]: get now playing\n .k set <lastfm user>: sets your username for the future\n .k art [lastfm user]: get now playing album art\n .k url [lastfm user]: get now playing lastfm url\n .k spot [lastfm user]: get now playing spotify link\n .k search <search query>: searches spotify\n .k help [command]: displays a help message"
|
|
|
|
|
.to_owned(),
|
|
|
|
|
"img" | "fmi" | "fm" | "get" =>
|
|
|
|
|
Some("img" | "fmi" | "fm" | "get") =>
|
|
|
|
|
"usage: .k img [lastfm user]\nreturns a pretty-printed image of the user's now playing track on last.fm, using the album art's colors to theme the image. see also: .k set\naliases: .kfmi, .k <fmi|get|img>, .kf, .ki, or even just .k"
|
|
|
|
|
.to_owned(),
|
|
|
|
|
"set" =>
|
|
|
|
|
Some("set") =>
|
|
|
|
|
"usage: .k set <lastfm user>\nties a lastfm username to your account. use this to not require your username for .k fmi every time, for example\naliases: .kset"
|
|
|
|
|
.to_owned(),
|
|
|
|
|
"art" =>
|
|
|
|
|
Some("art") =>
|
|
|
|
|
"usage: .k art [lastfm user]\nfetches user's now playing track's album art\naliases: .k art, .kart, .ka"
|
|
|
|
|
.to_owned(),
|
|
|
|
|
"url" | "link" =>
|
|
|
|
|
Some("url" | "link") =>
|
|
|
|
|
"usage: .k url [lastfm user]\nfetches a lastfm link to user's now playing track\naliases: .k url, .k link, .kl, .ku, .kurl"
|
|
|
|
|
.to_owned(),
|
|
|
|
|
"spot" | "spotify" =>
|
|
|
|
|
"usage: .k spotify [lastfm user]\nsearches spotify for the user's now playing track and returns a link to that track\naliases: .k <spot|spotify>, .ks, .kspot"
|
|
|
|
|
Some("spot" | "spotify") =>
|
|
|
|
|
"usage: .k spotify [lastfm user]\nsearches spotify for the user's now playing track and returns a link to that track\naliases: .k <spot|spotify>, .kx, .kspot"
|
|
|
|
|
.to_owned(),
|
|
|
|
|
_ => format!("unknown command: {arg}"),
|
|
|
|
|
Some("search") =>
|
|
|
|
|
"usage: .k search <search query>\nsearches spotify with an arbitrary query and returns the first result\naliases: .k search, .ks".to_owned(),
|
|
|
|
|
Some(cmd) => format!("unknown command: {cmd}"),
|
|
|
|
|
}
|
|
|
|
|
))
|
|
|
|
|
}
|
|
|
|
|
@ -451,48 +540,88 @@ async fn set(ctx: &Context, arg: &str, id: UserId) -> Reply {
|
|
|
|
|
Reply::Text(format!("set user {arg}"))
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//macro_rules! cmd {
|
|
|
|
|
// (c:lit, abbr:lit, a:ident) => {
|
|
|
|
|
// (".k", $c, $a) | (".k", $a, $c) | (concat!(".k", $abbr), $ident, "")
|
|
|
|
|
// }
|
|
|
|
|
//}
|
|
|
|
|
async fn search(ctx: &Context, arg: &str) -> Reply {
|
|
|
|
|
let mut data = ctx.data.write().await;
|
|
|
|
|
let spotify_option = data.get_mut::<SpotifyHaver>().expect("Failed to have spotify option");
|
|
|
|
|
if spotify_option.is_none() {
|
|
|
|
|
return Reply::Text("Unable to use Spotify commands: Contact bot Administrator.".to_owned())
|
|
|
|
|
}
|
|
|
|
|
let spotify_arc_mutex = spotify_option.as_mut().unwrap();
|
|
|
|
|
let spotify_client = spotify_arc_mutex.lock().await;
|
|
|
|
|
spotify_client.request_token().await.unwrap();
|
|
|
|
|
let search = spotify_client.search(arg, SearchType::Track, None, None, None, None).await;
|
|
|
|
|
let tracks = match search {
|
|
|
|
|
Ok(SearchResult::Tracks(track_page)) => track_page,
|
|
|
|
|
Err(e) => return Reply::Text(format!("Failed to get track {e}")),
|
|
|
|
|
_ => return Reply::Text("Spotify search failed".to_owned()),
|
|
|
|
|
};
|
|
|
|
|
match &tracks.items.first().map(|x| x.external_urls.get("spotify")) {
|
|
|
|
|
Some(Some(url)) => Reply::Text(url.to_owned().to_owned()),
|
|
|
|
|
_ => Reply::Text("Unable to get spotify url".to_owned()),
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
macro_rules! cmd_pattern {
|
|
|
|
|
($long_cmd:pat, $short_pattern:pat, $arg_name:pat) => {
|
|
|
|
|
(Some(".k"), Some($long_cmd), $arg_name) | (Some(".k"), $arg_name, Some($long_cmd)) | (Some($short_pattern), $arg_name, None)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[async_trait]
|
|
|
|
|
impl EventHandler for Handler {
|
|
|
|
|
async fn message(&self, ctx: Context, msg: Message) {
|
|
|
|
|
let mut cmd_iter = msg.content.split(" ");
|
|
|
|
|
let cmd = cmd_iter.next().unwrap_or("");
|
|
|
|
|
let arg1 = cmd_iter.next().unwrap_or("");
|
|
|
|
|
let arg2 = cmd_iter.next().unwrap_or("");
|
|
|
|
|
let cmd = cmd_iter.next();
|
|
|
|
|
let arg1 = cmd_iter.next();
|
|
|
|
|
let arg2 = cmd_iter.next();
|
|
|
|
|
let resp = match (cmd, arg1, arg2) {
|
|
|
|
|
(".set", arg, "") | (".k", "set", arg) | (".kset", arg, "") => {
|
|
|
|
|
log!("{} received", msg.content);
|
|
|
|
|
Some(set(&ctx, arg, msg.author.id).await)
|
|
|
|
|
}
|
|
|
|
|
(".k", "art", arg) | (".k", arg, "art") | (".ka" | ".kart", arg, "") => {
|
|
|
|
|
log!("{} received", msg.content);
|
|
|
|
|
Some(art(&ctx, arg, msg.author.id).await)
|
|
|
|
|
}
|
|
|
|
|
(".k", "url" | "uri" | "link", arg)
|
|
|
|
|
| (".k", arg, "url" | "uri" | "link")
|
|
|
|
|
| (".ku" | ".kl" | ".kurl", arg, "") => {
|
|
|
|
|
log!("{} received", msg.content);
|
|
|
|
|
Some(url(&ctx, arg, msg.author.id).await)
|
|
|
|
|
}
|
|
|
|
|
(".k", "spot" | "spotify", arg)
|
|
|
|
|
| (".k", arg, "spot" | "spotify")
|
|
|
|
|
| (".ks" | ".kspot", arg, "") => {
|
|
|
|
|
log!("{} received", msg.content);
|
|
|
|
|
Some(spot(&ctx, arg, msg.author.id).await)
|
|
|
|
|
}
|
|
|
|
|
(".k", "help" | "h" | "?", arg)
|
|
|
|
|
| (".k", arg, "help" | "h" | "?")
|
|
|
|
|
| (".kh" | ".k?", arg, "") => {
|
|
|
|
|
(Some(".k"), Some("help" | "h" | "?"), arg) // skip the ".k <command> help" syntax
|
|
|
|
|
| (Some(".kh") | Some(".k?"), arg, None) => {
|
|
|
|
|
log!("{} received", msg.content);
|
|
|
|
|
Some(help(arg))
|
|
|
|
|
}
|
|
|
|
|
(".fmi" | ".k" | ".kf" | ".ki" | ".kfmi", arg, "")
|
|
|
|
|
| (".k", "fm" | "fmi" | "get" | "img", arg) => {
|
|
|
|
|
cmd_pattern!("set", ".kset" | ".set", Some(arg)) =>
|
|
|
|
|
/*(".set", arg, "") | (".k", "set", arg) | (".kset", arg, "") =>*/ {
|
|
|
|
|
log!("{} received", msg.content);
|
|
|
|
|
Some(set(&ctx, arg, msg.author.id).await)
|
|
|
|
|
},
|
|
|
|
|
cmd_pattern!("art", ".ka" | ".kart", arg) =>
|
|
|
|
|
/*(".k", "art", arg) | (".k", arg, "art") | (".ka" | ".kart", arg, "") =>*/ {
|
|
|
|
|
log!("{} received", msg.content);
|
|
|
|
|
Some(art(&ctx, arg, msg.author.id).await)
|
|
|
|
|
},
|
|
|
|
|
cmd_pattern!("url" | "uri" | "link", ".ku" | ".kl", arg) =>
|
|
|
|
|
/*(".k", "url" | "uri" | "link", arg)
|
|
|
|
|
| (".k", arg, "url" | "uri" | "link")
|
|
|
|
|
| (".ku" | ".kl" | ".kurl", arg, "") =>*/ {
|
|
|
|
|
log!("{} received", msg.content);
|
|
|
|
|
Some(url(&ctx, arg, msg.author.id).await)
|
|
|
|
|
},
|
|
|
|
|
cmd_pattern!("text", ".kt", arg) =>
|
|
|
|
|
/*(".k", "url" | "uri" | "link", arg)
|
|
|
|
|
| (".k", arg, "url" | "uri" | "link")
|
|
|
|
|
| (".ku" | ".kl" | ".kurl", arg, "") =>*/ {
|
|
|
|
|
log!("{} received", msg.content);
|
|
|
|
|
Some(text(&ctx, arg, msg.author.id).await)
|
|
|
|
|
},
|
|
|
|
|
cmd_pattern!("spot" | "spotify", ".kx", arg) =>
|
|
|
|
|
/*(".k", "spot" | "spotify", arg)
|
|
|
|
|
| (".k", arg, "spot" | "spotify")
|
|
|
|
|
| (".ks" | ".kspot", arg, "") =>*/ {
|
|
|
|
|
log!("{} received", msg.content);
|
|
|
|
|
Some(spot(&ctx, arg, msg.author.id).await)
|
|
|
|
|
},
|
|
|
|
|
(Some(".ks"), Some(_), _) => {
|
|
|
|
|
log!("{} received", msg.content);
|
|
|
|
|
Some(search(&ctx, &msg.content[4..]).await)
|
|
|
|
|
},
|
|
|
|
|
(Some(".k"), Some("search"), Some(_)) => {
|
|
|
|
|
log!("{} received", msg.content);
|
|
|
|
|
Some(search(&ctx, &msg.content[10..]).await)
|
|
|
|
|
},
|
|
|
|
|
cmd_pattern!("fm" | "fmi" | "get" | "img", ".fmi" | ".k" | ".kf" | ".ki" | ".kfmi", arg) =>
|
|
|
|
|
/*(".fmi" | ".k" | ".kf" | ".ki" | ".kfmi", arg, "")
|
|
|
|
|
| (".k", "fm" | "fmi" | "get" | "img", arg) =>*/ {
|
|
|
|
|
log!("{} received", msg.content);
|
|
|
|
|
Some(fmi(&ctx, arg, msg.author.id, msg.author.avatar_url()).await)
|
|
|
|
|
}
|
|
|
|
|
@ -535,6 +664,24 @@ impl TypeMapKey for SpotifyHaver {
|
|
|
|
|
type Value = Option<Arc<Mutex<ClientCredsSpotify>>>;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
struct ColorCache {
|
|
|
|
|
map: Arc<Mutex<HashMap<String, (String, String)>>>,
|
|
|
|
|
max: usize,
|
|
|
|
|
}
|
|
|
|
|
struct ColorsHaver;
|
|
|
|
|
impl TypeMapKey for ColorsHaver {
|
|
|
|
|
type Value = ColorCache;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
struct Overrides {
|
|
|
|
|
map: Arc<Mutex<HashMap<String, String>>>,
|
|
|
|
|
last_modified: Option<SystemTime>,
|
|
|
|
|
}
|
|
|
|
|
struct OverridesHaver;
|
|
|
|
|
impl TypeMapKey for OverridesHaver {
|
|
|
|
|
type Value = Overrides;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
struct DBResponse {
|
|
|
|
|
lastfm_username: String,
|
|
|
|
|
}
|
|
|
|
|
@ -568,7 +715,7 @@ async fn get_lastfm_username(ctx: &Context, id: UserId) -> Option<String> {
|
|
|
|
|
|
|
|
|
|
async fn set_lastfm_username(ctx: &Context, id: UserId, user: String) {
|
|
|
|
|
log!("set db user {} {}", id, user);
|
|
|
|
|
let data = ctx.data.write().await;
|
|
|
|
|
let data = ctx.data.read().await;
|
|
|
|
|
let pool = data
|
|
|
|
|
.get::<PoolHaver>()
|
|
|
|
|
.expect("Failed to get pool container");
|
|
|
|
|
@ -588,7 +735,7 @@ async fn set_lastfm_username(ctx: &Context, id: UserId, user: String) {
|
|
|
|
|
|
|
|
|
|
async fn get_image(ctx: &Context, url: &str) -> Result<Vec<u8>, reqwest_middleware::Error> {
|
|
|
|
|
log!("get {}", url);
|
|
|
|
|
let data = ctx.data.write().await;
|
|
|
|
|
let data = ctx.data.read().await;
|
|
|
|
|
let http = data.get::<HttpHaver>().expect("Failed to get http client");
|
|
|
|
|
match http.get(url).send().await {
|
|
|
|
|
Ok(resp) => {
|
|
|
|
|
@ -668,6 +815,16 @@ async fn main() {
|
|
|
|
|
let _ = &spotify_client.request_token().await.unwrap();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
let colors_cache = ColorCache {
|
|
|
|
|
map: Arc::new(Mutex::new(HashMap::new())),
|
|
|
|
|
max: env::var("MAX_CACHE_SIZE").unwrap_or("".to_owned()).parse::<usize>().unwrap_or(1000000),
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
let overrides = Overrides {
|
|
|
|
|
map: Arc::new(Mutex::new(HashMap::new())),
|
|
|
|
|
last_modified: None,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
let mut discord_client = Client::builder(&token, intents)
|
|
|
|
|
.event_handler(Handler)
|
|
|
|
|
.await
|
|
|
|
|
@ -679,6 +836,8 @@ async fn main() {
|
|
|
|
|
data.insert::<HttpHaver>(http);
|
|
|
|
|
data.insert::<FontsHaver>((regular_fonts, bold_fonts));
|
|
|
|
|
data.insert::<SpotifyHaver>(spotify.map(Mutex::new).map(Arc::new));
|
|
|
|
|
data.insert::<ColorsHaver>(colors_cache);
|
|
|
|
|
data.insert::<OverridesHaver>(overrides);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if let Err(why) = discord_client.start().await {
|
|
|
|
|
|
