Merge pull request #1 from CompuIves/2020

Update bot naar 2020

Author: Victor

Cargo.toml

@@ -9,7 +9,15 @@ edition = "2018"
 [dependencies]
 serde_json = "1.0"
 serde = { version = "1.0", features = ["derive"] }
-serenity = {version = "0.7", features = ["cache", "framework", "standard_framework", "voice", "http", "rustls_backend"] }
+serenity = { version = "0.9", features = [
+  "cache",
+  "framework",
+  "standard_framework",
+  "voice",
+  "http",
+  "rustls_backend",
+] }
 dotenv = "0.15.0"
-reqwest = { version = "0.10.0-alpha.2", features = ["blocking"] }
+reqwest = { version = "0.10" }
 chrono = "0.4"
+tokio = { version = "0.2", features = ["time", "macros"] }

rustfmt.toml

@@ -0,0 +1,5 @@
+unstable_features = true
+merge_imports = true
+use_field_init_shorthand = true
+reorder_impl_items = true
+newline_style = "Unix"

src/2019.json

@@ -1,8 +1,6 @@
-use serde::{Deserialize, Deserializer, de};
 use crate::error::ErrorKind;
+use serde::{de, Deserialize, Deserializer};
 use serde_json::Value;
-use chrono::{DateTime, Utc};
-use std::str::FromStr;
 
 #[derive(Debug, Deserialize, Clone)]
 pub struct Song {
@@ -18,98 +16,95 @@ pub struct Song {
     #[serde(rename = "pos")]
     pub position: Option<u64>,
 
+    #[serde(rename = "prv")]
+    pub prev_position: Option<u64>,
+
     #[serde(rename = "url")]
-    pub url: String
+    pub url: String,
 
+    #[serde(rename = "img")]
+    pub image: Option<String>,
 }
 
 #[derive(Debug, Clone)]
 pub struct SongList {
-    songs: Vec<Song>
+    songs: Vec<Song>,
 }
 
 #[derive(Debug, Clone)]
 pub struct NowOnAir {
     pub song: Song,
     pub img_url: Option<String>,
-    pub end_time: DateTime<Utc>
 }
 
-fn to_u64<'de, D>(deserializer: D) -> Result<u64, D::Error> where D: Deserializer<'de> {
+fn to_u64<'de, D>(deserializer: D) -> Result<u64, D::Error>
+where
+    D: Deserializer<'de>,
+{
     let s: String = Deserialize::deserialize(deserializer)?;
     s.parse().map_err(de::Error::custom)
 }
 
 impl Song {
-    pub fn get_description(&self) -> Result<String, ErrorKind> {
-        let url = format!("https://www.nporadio2.nl/?option=com_ajax&plugin=Trackdata&format=json&songid={}", self.id);
-        let body = reqwest::blocking::get(&url)
+    pub async fn get_description(&self) -> Result<String, ErrorKind> {
+        let url = format!(
+            "https://www.nporadio2.nl/?option=com_ajax&plugin=Trackdata&format=json&songid={}",
+            self.id
+        );
+        let body = reqwest::get(&url)
+            .await
             .map_err(ErrorKind::RequestError)?
             .text()
+            .await
             .map_err(ErrorKind::RequestError)?;
 
-        let desc_unparsed = &serde_json::from_str::<Value>(&body).map_err(ErrorKind::JsonError)?["data"][0]["description"];
+        let desc_unparsed = &serde_json::from_str::<Value>(&body).map_err(ErrorKind::JsonError)?
+            ["data"][0]["description"];
         if let Value::String(desc) = desc_unparsed {
             Ok(desc.to_owned())
         } else {
             Err(ErrorKind::GenericError)
         }
     }
 
-    pub fn get_last_year_position(&self) -> Result<u64, ErrorKind> {
-        let url = format!("https://www.nporadio2.nl/?option=com_ajax&plugin=Trackdata&format=json&songid={}", self.id);
-        let body = reqwest::blocking::get(&url)
-            .map_err(ErrorKind::RequestError)?
-            .text()
-            .map_err(ErrorKind::RequestError)?;
-
-        let positions_unparsed = &serde_json::from_str::<Value>(&body).map_err(ErrorKind::JsonError)?["data"][0]["positions"];
-        if let Value::Array(positions) = positions_unparsed {
-            let year = positions.iter().find(|v| v["year"] == "2018").ok_or(ErrorKind::GenericError)?;
-            let position = year["position"].as_str().ok_or(ErrorKind::GenericError)?.parse().map_err(|_| ErrorKind::GenericError)?;
-            Ok(position)
-        } else {
-            Err(ErrorKind::GenericError)
-        }
+    pub fn get_last_year_position(&self) -> Option<u64> {
+        self.prev_position
     }
 }
 
 impl SongList {
     pub fn new() -> Result<SongList, ErrorKind> {
-        let body = include_str!("2019.json");
+        let body = include_str!("2020.json");
 
-        let unparsed_songs = &serde_json::from_str::<Value>(&body).map_err(ErrorKind::JsonError)?["data"][0];
-        let songs: Vec<_> = serde_json::from_value(unparsed_songs.to_owned()).map_err(ErrorKind::JsonError)?;
+        let unparsed_songs =
+            &serde_json::from_str::<Value>(&body).map_err(ErrorKind::JsonError)?["data"][0];
+        let songs: Vec<_> =
+            serde_json::from_value(unparsed_songs.to_owned()).map_err(ErrorKind::JsonError)?;
 
         println!("Successfully parsed {} songs!", &songs.len());
 
-        Ok(SongList {
-            songs
-        })
+        Ok(SongList { songs })
     }
 
-    pub fn get_now_on_air(&self) -> Result<NowOnAir, ErrorKind> {
-
-        let body = reqwest::blocking::get("https://radiobox2.omroep.nl/data/radiobox2/nowonair/2.json")
-            .map_err(ErrorKind::RequestError)?
-            .text()
-            .map_err(ErrorKind::RequestError)?;
+    pub fn get_song(&self, position: usize) -> Option<&Song> {
+        self.songs.get(position)
+    }
 
-        let parsed_json = serde_json::from_str::<Value>(&body).map_err( ErrorKind::JsonError)?;
+    pub async fn get_now_on_air(&self) -> Result<NowOnAir, ErrorKind> {
+        let body =
+            reqwest::get("https://www.nporadio2.nl/?option=com_ajax&plugin=nowplaying&format=json&channel=nporadio2").await
+                .map_err(ErrorKind::RequestError)?
+                .text().await
+                .map_err(ErrorKind::RequestError)?;
 
-        let end_time_unparsed = &parsed_json["results"][0]["stopdatetime"];
-        let end_time = if let Value::String(end_time_str) = end_time_unparsed {
-            DateTime::from_str(end_time_str).map_err(|_e| ErrorKind::GenericError)?
-        } else {
-            return Err(ErrorKind::GenericError);
-        };
+        let parsed_json = serde_json::from_str::<Value>(&body).map_err(ErrorKind::JsonError)?;
 
-        let id_unparsed = &parsed_json["results"][0]["songfile"]["songversion"]["id"];
-        if let Value::Number(id) = id_unparsed {
-            if let Some(id_unwrapped) = id.as_u64() {
+        let id_unparsed = &parsed_json["data"][0]["id"];
+        if let Value::String(id) = id_unparsed {
+            if let Ok(id_unwrapped) = id.parse::<u64>() {
                 let song_option = self.songs.iter().find(|s| s.id == id_unwrapped);
                 if let Some(song) = song_option {
-                    let img_url_unparsed = &parsed_json["results"][0]["songfile"]["songversion"]["image"][0]["url_ssl"];
+                    let img_url_unparsed = &parsed_json["data"][0]["image"];
                     let img_url = if let Value::String(img) = img_url_unparsed {
                         Some(img.to_string())
                     } else {
@@ -119,42 +114,42 @@ impl SongList {
                     return Ok(NowOnAir {
                         song: song.clone(),
                         img_url,
-                        end_time
-                    })
+                    });
                 }
             }
         }
 
-        let artist_val = &parsed_json["results"][0]["songfile"]["artist"];
-        let title_val = &parsed_json["results"][0]["songfile"]["title"];
+        let artist_val = &parsed_json["data"][0]["artist"];
+        let title_val = &parsed_json["data"][0]["title"];
 
         if let Value::String(artist) = artist_val {
             if let Value::String(title) = title_val {
-                let song = self.songs.iter().find(|s| {
-                    s.artist == *artist && s.title == *title
-                });
+                let song = self
+                    .songs
+                    .iter()
+                    .find(|s| s.artist == *artist && s.title == *title);
 
                 return match song {
                     Some(song_some) => Ok(NowOnAir {
                         song: song_some.to_owned(),
-                        img_url: None,
-                        end_time
+                        img_url: song_some.image.clone(),
                     }),
                     None => Ok(NowOnAir {
                         song: Song {
                             id: 0,
                             title: title.to_string(),
                             artist: artist.to_string(),
                             position: None,
-                            url: "".to_string()
+                            url: "".to_string(),
+                            image: None,
+                            prev_position: None,
                         },
                         img_url: None,
-                        end_time
-                    })
-                }
+                    }),
+                };
             }
         }
 
         Err(ErrorKind::GenericError)
     }
-}
+}