.idea/misc.xml

@@ -3,7 +3,4 @@
   <component name="ProjectRootManager">
     <output url="file://$PROJECT_DIR$/out" />
   </component>
-  <component name="ProjectType">
-    <option name="id" value="jpab" />
-  </component>
 </project>

Cargo.toml

@@ -1,14 +1,13 @@
 [package]
 name = "songlify"
-version = "0.3.3"
+version = "0.2.3"
 edition = "2018"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-teloxide = { version = "0.9.1", features = ["auto-send", "macros"] }
+teloxide = { version = "0.7.1", features = ["auto-send", "macros"] }
-log = "0.4.17"
+log = "0.4.14"
 pretty_env_logger = "0.4.0"
-tokio = { version =  "1.18.2", features = ["rt-multi-thread", "macros"] }
+tokio = { version =  "1.17.0", features = ["rt-multi-thread", "macros"] }
-rspotify = { version = "0.11.5", features = ["default"]}
+rspotify = { version = "0.11.4", features = ["default"]}
-sentry = "0.26.0"

src/main.rs

@@ -1,6 +1,3 @@
-use log::LevelFilter;
-use sentry::ClientInitGuard;
-use std::env;
 use teloxide::prelude::*;
 
 use crate::spotify::{PlayableKind, TrackInfo};
@@ -16,37 +13,12 @@ static MAX_ARTISTS_CHARS: usize = 140;
 
 #[tokio::main]
 async fn main() {
-    if env::var("RUST_LOG").is_err() {
+    teloxide::enable_logging!();
-        pretty_env_logger::formatted_builder()
-            .filter_module("songlify", LevelFilter::Info)
-            .filter_module("teloxide", LevelFilter::Info)
-            .init();
-    } else {
-        pretty_env_logger::init();
-    }
     log::info!("Starting Songlify...");
-    log::trace!("You're running in trace mode!");
-
-    let mut _guard: ClientInitGuard;
-    match env::var("SENTRY_DSN") {
-        Ok(sentry_dsn) => {
-            log::debug!("Sentry DSN found, enabling error reporting");
-            _guard = sentry::init((
-                sentry_dsn,
-                sentry::ClientOptions {
-                    release: sentry::release_name!(),
-                    ..Default::default()
-                },
-            ));
-        }
-        Err(_) => {
-            log::warn!("No sentry DSN set, errors will not be reported. Use SENTRY_DSN env variable if you want to set error reporting")
-        }
-    }
 
     let bot = Bot::from_env().auto_send();
-    teloxide::repl(bot, |message: Message, bot: AutoSend<Bot>| async move {
+    teloxide::repl(bot, |message| async move {
-        let text = message.text().and_then(spotify::get_entry_kind);
+        let text = message.update.text().and_then(spotify::get_entry_kind);
         match text {
             Some(spotify) => {
                 let spotify_client = spotify::get_client().await;
@@ -65,10 +37,7 @@ async fn main() {
                                     truncate_with_dots(info.artists.join(", "), MAX_ARTISTS_CHARS),
                                     human_readable_duration(info.duration)
                                 );
-                                bot.send_message(message.chat.id, reply)
+                                Some(message.reply_to(reply).await?)
-                                    .reply_to_message_id(message.id)
-                                    .await?;
-                                Some(respond(()))
                             }
                             None => None,
                         }
@@ -92,10 +61,11 @@ async fn main() {
                                             .as_str(),
                                     );
                                 }
-                                bot.send_message(message.chat.id, reply)
+                                Some(
-                                    .reply_to_message_id(message.id)
+                                    message
-                                    .await?;
+                                        .reply_to(add_track_section(info.tracks, reply))
-                                Some(respond(()))
+                                        .await?,
+                                )
                             }
                             None => None,
                         }
@@ -113,14 +83,15 @@ async fn main() {
                                     info.artists.len(),
                                     truncate_with_dots(info.artists.join(", "), MAX_ARTISTS_CHARS)
                                 );
-                                bot.send_message(message.chat.id, reply)
+                                Some(
-                                    .reply_to_message_id(message.id)
+                                    message
-                                    .await?;
+                                        .reply_to(add_track_section_for_playlist(info.tracks, reply))
-                                Some(respond(()))
+                                        .await?,
+                                )
                             }
                             None => None,
                         }
-                    }
+                    },
                     Episode(id) => {
                         log::warn!("Support for episodes ({}) has not be implemented yet!", id);
                         None

src/spotify/mod.rs

@@ -1,20 +1,20 @@
-use rspotify::model::PlayableItem::{Episode, Track};
-use rspotify::model::{AlbumId, FullTrack, PlaylistId, TrackId};
-use rspotify::prelude::*;
-use rspotify::{ClientCredsSpotify, Credentials};
 use std::time::Duration;
+use rspotify::{ClientCredsSpotify, Credentials};
+use rspotify::model::{AlbumId, FullTrack, PlaylistId, TrackId};
+use rspotify::model::PlayableItem::{Episode, Track};
+use rspotify::prelude::*;
 
 pub enum SpotifyKind {
     Track(String),
     Album(String),
     Playlist(String),
     Podcast(String),
-    Episode(String),
+    Episode(String)
 }
 
 pub enum PlayableKind {
     Track(TrackInfo),
-    Podcast(EpisodeInfo),
+    Podcast(EpisodeInfo)
 }
 
 pub struct TrackInfo {
@@ -29,7 +29,7 @@ pub struct EpisodeInfo {
     pub(crate) duration: Duration,
     pub(crate) description: String,
     pub(crate) languages: Vec<String>,
-    pub(crate) release_date: String,
+    pub(crate) release_date: String
 }
 
 pub struct AlbumInfo {
@@ -99,8 +99,7 @@ pub fn get_entry_kind(url: &str) -> Option<SpotifyKind> {
 }
 
 pub async fn get_client() -> Box<ClientCredsSpotify> {
-    let spotify_creds =
+    let spotify_creds = Credentials::from_env().expect("RSPOTIFY_CLIENT_ID and RSPOTIFY_CLIENT_SECRET not found.");
-        Credentials::from_env().expect("RSPOTIFY_CLIENT_ID and RSPOTIFY_CLIENT_SECRET not found.");
     let mut spotify = ClientCredsSpotify::new(spotify_creds);
     spotify.request_token().await.unwrap();
     Box::new(spotify)
@@ -109,23 +108,23 @@ pub async fn get_client() -> Box<ClientCredsSpotify> {
 pub async fn get_track(spotify: Box<ClientCredsSpotify>, id: &String) -> Option<TrackInfo> {
     let track_id = match TrackId::from_id(id.as_str()) {
         Ok(track) => track,
-        Err(_e) => return None,
+        Err(_e) => return None
     };
 
     match spotify.track(&track_id).await {
-        Ok(track) => Some(TrackInfo {
+        Ok(track) => Some(TrackInfo{
             name: track.name,
             artists: track.artists.iter().map(|x| x.name.clone()).collect(),
             duration: track.duration,
         }),
-        Err(_e) => None,
+        Err(_e) => None
     }
 }
 
 pub async fn get_album(spotify: Box<ClientCredsSpotify>, id: &String) -> Option<AlbumInfo> {
     let album_id = match AlbumId::from_id(id.as_str()) {
         Ok(album) => album,
-        Err(_e) => return None,
+        Err(_e) => return None
     };
 
     match spotify.album(&album_id).await {
@@ -151,7 +150,7 @@ pub async fn get_album(spotify: Box<ClientCredsSpotify>, id: &String) -> Option<
 pub async fn get_playlist(spotify: Box<ClientCredsSpotify>, id: &String) -> Option<PlaylistInfo> {
     let playlist_id = match PlaylistId::from_id(id.as_str()) {
         Ok(playlist) => playlist,
-        Err(_e) => return None,
+        Err(_e) => return None
     };
 
     match spotify.playlist(&playlist_id, None, None).await {
@@ -164,35 +163,37 @@ pub async fn get_playlist(spotify: Box<ClientCredsSpotify>, id: &String) -> Opti
                 .flat_map(|p| {
                     match &p.track {
                         Some(t) => match t {
-                            Track(t) => t.artists.iter().map(|a| a.name.clone()).collect(),
+                            Track(t) => t.artists.iter().map(|a| {
-                            Episode(e) => vec![e.show.publisher.clone()],
+                                a.name.clone()
-                        },
+                            }).collect(),
+                            Episode(e) => vec![e.show.publisher.clone()]
+                        }
                         None => Vec::new(),
-                    }
+                    }.into_iter()
-                    .into_iter()
+                }).collect(),
-                })
-                .collect(),
             tracks: playlist
                 .tracks
                 .items
                 .iter()
-                .map(|p| match &p.track {
+                .map(|p| {
-                    Some(t) => match t {
+                    match &p.track {
-                        Track(t) => Some(PlayableKind::Track(TrackInfo {
+                        Some(t) => match t {
-                            name: t.name.clone(),
+                            Track(t) => Some(PlayableKind::Track(TrackInfo{
-                            artists: t.artists.iter().map(|a| a.name.clone()).collect(),
+                                name: t.name.clone(),
-                            duration: t.duration,
+                                artists: t.artists.iter().map(|a| a.name.clone()).collect(),
-                        })),
+                                duration: t.duration
-                        Episode(e) => Some(PlayableKind::Podcast(EpisodeInfo {
+                            })),
-                            name: e.name.clone(),
+                            Episode(e) => Some(PlayableKind::Podcast(EpisodeInfo{
-                            show: e.show.name.clone(),
+                                name: e.name.clone(),
-                            duration: e.duration,
+                                show: e.show.name.clone(),
-                            description: e.description.clone(),
+                                duration: e.duration,
-                            languages: e.languages.clone(),
+                                description: e.description.clone(),
-                            release_date: e.release_date.clone(),
+                                languages: e.languages.clone(),
-                        })),
+                                release_date: e.release_date.clone()
-                    },
+                            }))
-                    None => None,
+                        },
+                        None => None
+                    }
                 })
                 .filter(|i| i.is_some())
                 .map(|i| i.unwrap())