feat: handle if last.fm response is offline or malformed

server/src/index.rs

···
-use crate::scrobble_monitor::ScrobbleMonitor;
+use crate::{scrobble::ScrobblesTemplate, scrobble_monitor::ScrobbleMonitor};
 
 use askama::Template;
 
 #[derive(Template, Debug, Clone)]
 #[template(path = "index.html")]
 pub struct RootTemplate {
-    intro: String,
-    now_playing: String,
-    image: String,
-    srcset: String,
+    scrobble: Option<ScrobblesTemplate>
 }
 
-pub async fn get_index(monitor: &mut ScrobbleMonitor) -> anyhow::Result<RootTemplate> {
-    let scrobbles_template = monitor.get_scrobble().await?;
+pub async fn get_index(monitor: &mut ScrobbleMonitor) -> RootTemplate {
+    let scrobbles_template = monitor.get_scrobble().await;
+    if let Err(err) = scrobbles_template.as_ref() {
+        tracing::warn!(?err, "Failed to get scrobble");
+    }
 
-    Ok(RootTemplate {
-        intro: scrobbles_template.intro,
-        now_playing: scrobbles_template.now_playing,
-        image: scrobbles_template.image,
-        srcset: scrobbles_template.srcset,
-    })
+    RootTemplate {
+        scrobble: scrobbles_template.ok()
+    }
 }

server/src/main.rs

···
 async fn render_index_handler(
     Extension(mut monitor): Extension<ScrobbleMonitor>,
 ) -> impl IntoResponse {
-    let template = get_index(&mut monitor).await.map_err(|err| {
-        tracing::error!("failed to get data from last.fm: {err:?}");
-        StatusCode::BAD_GATEWAY
-    })?;
+    let template = get_index(&mut monitor).await;
     template.render().map(Html).map_err(|err| {
         tracing::error!("failed to render index: {err:?}");
         StatusCode::INTERNAL_SERVER_ERROR

server/src/scrobble.rs

···
 
 #[derive(Debug, Clone, Deserialize)]
 pub struct ScrobbleRecentTracks {
-    pub track: Vec<ScrobbleTrack>,
+    pub track: (ScrobbleTrack,),
 }
 
 #[derive(Debug, Clone, Deserialize)]
···
 #[derive(Template, Debug, Clone)]
 #[template(path = "index.html", block = "scrobbles")]
 pub struct ScrobblesTemplate {
-    pub intro: String,
+    pub intro: &'static str,
     pub now_playing: String,
-    pub image: String,
-    pub srcset: String,
+    pub image: Option<String>,
+    pub srcset: Option<String>,
 }
 
-pub fn scrobble_partial(scrobble: &Scrobble) -> ScrobblesTemplate {
-    let latest_track = &scrobble.recent_tracks.track[0];
-    let srcset = format!(
-        "{}, {} 2x, {} 3x",
-        latest_track.image[0].text, latest_track.image[1].text, latest_track.image[2].text
-    );
+pub fn scrobble_partial(scrobble: Scrobble) -> ScrobblesTemplate {
+    let (latest_track,) = scrobble.recent_tracks.track;
+    let srcset = latest_track.image.get(0..3).map(|images| {
+        format!(
+            "{}, {} 2x, {} 3x",
+            images[0].text, images[1].text, images[2].text
+        )
+    });
     let text_intro = if latest_track
         .attributes
-        .as_ref()
         .map_or(false, |attr| attr.now_playing)
     {
         "Now playing: "
···
     let now_playing = format!("{} - {}", latest_track.name, latest_track.artist.text);
 
     ScrobblesTemplate {
-        intro: text_intro.to_owned(),
+        intro: text_intro,
         now_playing,
-        image: latest_track.image[0].text.clone(),
+        image: latest_track
+            .image
+            .into_iter()
+            .next()
+            .map(|image| image.text),
         srcset,
     }
 }

server/src/scrobble_monitor.rs

···
             _ => {
                 tracing::debug!("fetching new scrobble data");
                 let scrobble = self.fetch_scrobble().await?;
-                let scrobble_partial = scrobble_partial(&scrobble);
+                let scrobble_partial = scrobble_partial(scrobble);
                 *last_scrobble = Some(CachedScrobble {
                     data: scrobble_partial.clone(),
                     fetch_time: Instant::now(),

server/templates/index.html

···
       </div>
     </div>
     <div class="scrobble-bar" hx-get="/scrobbles" hx-trigger="every 30s">
+      {% match scrobble %} {% when Some with (ScrobblesTemplate {intro, now_playing, image, srcset}) %}
       {% block scrobbles %}
       <div class="bar-container">
+        {% match image %} {% when Some with (image) %}
         <img
           class="bar-cover"
           src="{{ image }}"
           alt="Cover art"
-          srcset="{{ srcset }}"
+          {% match srcset %} {% when Some with (srcset) %}
+            srcset="{{ srcset }}"
+          {% else %}
+          {% endmatch %}
         />
+        {% else %}
+        {% endmatch %}
         <p class="bar-text-intro">{{ intro }}</p>
         <p class="bar-text-music">{{ now_playing }}</p>
       </div>
       {% endblock scrobbles %}
+      {% else %}
+      {% endmatch %}
     </div>
   </body>
 </html>