Remove ls from dockerfile (#2)

Fix issue with spotify history repeat inserting

Author: dustinrouillard

Dockerfile

@@ -10,8 +10,6 @@ WORKDIR /app
 COPY . .
 
 RUN cargo prisma generate
-
-RUN ls -lha src/connectivity/
 RUN cargo build --release
 
 FROM alpine

src/modules/spotify.rs

@@ -2,17 +2,14 @@ use std::sync::Arc;
 
 use actix_web::web::{self};
 use chrono::prelude::*;
-use serde_json::json;
+use prisma_client_rust::Direction;
 
 use crate::{
   connectivity::prisma::spotify_history,
-  services::spotify::helpers::{self, get_or_make_device},
+  services::spotify::helpers::{self, store_history},
   structs::{
     self,
-    spotify::{
-      ArtistName, CurrentPlaying, DeviceRewrite, PlayerState,
-      SpotifyArtist,
-    },
+    spotify::{ArtistName, CurrentPlaying, DeviceRewrite, PlayerState},
   },
   ServerState,
 };
@@ -111,6 +108,7 @@ pub(crate) async fn fetch_spotify_current(data: web::Data<ServerState>) {
             .find_first(vec![spotify_history::id::equals(
               current_playing.id.as_ref().unwrap().to_string(),
             )])
+            .order_by(spotify_history::listened_at::order(Direction::Desc))
             .exec()
             .await
           {
@@ -120,130 +118,28 @@ pub(crate) async fn fetch_spotify_current(data: web::Data<ServerState>) {
                 let date_minus_length =
                   (date.timestamp() * 1000) - latest.length as i64;
 
-                if date_minus_length >= listened_date
-                  && current_playing.progress.unwrap() >= 10000
-                {
-                  let dev = get_or_make_device(
-                    prisma,
-                    current_playing
-                      .device
-                      .as_ref()
-                      .unwrap()
-                      .name
-                      .to_string(),
-                    current_playing
-                      .device
-                      .as_ref()
-                      .unwrap()
-                      .device_type
-                      .to_string(),
-                  )
-                  .await;
-
-                  let mut artists = Vec::new();
-                  for artist in current_playing.artists.as_ref().unwrap() {
-                    artists.push(json!(SpotifyArtist {
-                      name: artist.name.clone(),
-                    }));
-                  }
+                if current_playing.progress.unwrap() < 10000 {
+                  return;
+                }
 
-                  let current_playing = current_playing.as_ref().clone();
-                  let _ = prisma.spotify_history().create(
-                    current_playing.id.unwrap(),
-                    current_playing.name.unwrap(),
-                    current_playing.length.unwrap() as i32,
-                    current_playing.image.unwrap(),
-                    crate::connectivity::prisma::spotify_devices::UniqueWhereParam::IdEquals(dev.id),
-                    vec![
-                      spotify_history::r#type::set(current_playing.current_playing_type.as_ref().unwrap().to_string()),
-                      spotify_history::artists::set(artists),
-                      spotify_history::listened_at::set(date),
-                    ]
-                  ).exec().await;
+                if date_minus_length >= listened_date {
+                  store_history(prisma, current_playing).await;
                 }
               }
               None => {
-                if current_playing.progress.unwrap() >= 10000 {
-                  let device = get_or_make_device(
-                    prisma,
-                    current_playing
-                      .device
-                      .as_ref()
-                      .unwrap()
-                      .name
-                      .to_string(),
-                    current_playing
-                      .device
-                      .as_ref()
-                      .unwrap()
-                      .device_type
-                      .to_string(),
-                  )
-                  .await;
-
-                  let mut artists = Vec::new();
-                  for artist in current_playing.artists.as_ref().unwrap() {
-                    artists.push(json!(SpotifyArtist {
-                      name: artist.name.clone(),
-                    }));
-                  }
-
-                  let current_playing = current_playing.as_ref().clone();
-                  let _ = prisma.spotify_history().create(
-                    current_playing.id.unwrap(),
-                    current_playing.name.unwrap(),
-                    current_playing.length.unwrap() as i32,
-                    current_playing.image.unwrap(),
-                    crate::connectivity::prisma::spotify_devices::UniqueWhereParam::IdEquals(device.id),
-                    vec![
-                      spotify_history::r#type::set(current_playing.current_playing_type.as_ref().unwrap().to_string()),
-                      spotify_history::artists::set(artists),
-                      spotify_history::listened_at::set(date),
-                    ]
-                  ).exec().await;
+                if current_playing.progress.unwrap() < 10000 {
+                  return;
                 }
+
+                store_history(prisma, current_playing).await;
               }
             },
             Err(_) => {
-              if current_playing.progress.unwrap() >= 10000 {
-                let device = get_or_make_device(
-                  prisma,
-                  current_playing
-                    .device
-                    .as_ref()
-                    .unwrap()
-                    .name
-                    .to_string(),
-                  current_playing
-                    .device
-                    .as_ref()
-                    .unwrap()
-                    .device_type
-                    .to_string(),
-                )
-                .await;
-
-                let mut artists = Vec::new();
-                for artist in current_playing.artists.as_ref().unwrap() {
-                  artists.push(json!(SpotifyArtist {
-                    name: artist.name.clone(),
-                  }));
-                }
-
-                let current_playing = current_playing.as_ref().clone();
-                let _ = prisma.spotify_history().create(
-                    current_playing.id.unwrap(),
-                    current_playing.name.unwrap(),
-                    current_playing.length.unwrap() as i32,
-                    current_playing.image.unwrap(),
-                    crate::connectivity::prisma::spotify_devices::UniqueWhereParam::IdEquals(device.id),
-                    vec![
-                      spotify_history::r#type::set(current_playing.current_playing_type.as_ref().unwrap().to_string()),
-                      spotify_history::artists::set(artists),
-                      spotify_history::listened_at::set(date),
-                    ]
-                  ).exec().await;
+              if current_playing.progress.unwrap() < 10000 {
+                return;
               }
+
+              store_history(prisma, current_playing).await;
             }
           }
         }

src/services/spotify/helpers.rs

@@ -1,17 +1,19 @@
-use std::io::Error;
+use std::{io::Error, sync::Arc};
 
+use chrono::{DateTime, FixedOffset, Utc};
 use envconfig::Envconfig;
 use redis::{aio::ConnectionManager, AsyncCommands};
 use serde_json::json;
 
 use crate::{
   config::Config,
   connectivity::{
-    prisma::{spotify_devices, PrismaClient},
+    prisma::{spotify_devices, spotify_history, PrismaClient},
     valkey::ValkeyManager,
   },
   structs::spotify::{
-    AuthorizationData, CurrentPlaying, SpotifyAccount, SpotifyTokens,
+    AuthorizationData, CurrentPlaying, SpotifyAccount, SpotifyArtist,
+    SpotifyTokens,
   },
 };
 
@@ -185,3 +187,44 @@ pub async fn get_or_make_device(
       .unwrap(),
   }
 }
+
+pub async fn store_history(
+  prisma: &mut &PrismaClient,
+  current_playing: Arc<CurrentPlaying>,
+) {
+  let date: DateTime<FixedOffset> =
+    Utc::now().with_timezone(&FixedOffset::east_opt(0).unwrap());
+
+  let dev = get_or_make_device(
+    prisma,
+    current_playing.device.as_ref().unwrap().name.to_string(),
+    current_playing
+      .device
+      .as_ref()
+      .unwrap()
+      .device_type
+      .to_string(),
+  )
+  .await;
+
+  let mut artists = Vec::new();
+  for artist in current_playing.artists.as_ref().unwrap() {
+    artists.push(json!(SpotifyArtist {
+      name: artist.name.clone(),
+    }));
+  }
+
+  let current_playing = current_playing.as_ref().clone();
+  let _ = prisma.spotify_history().create(
+      current_playing.id.unwrap(),
+      current_playing.name.unwrap(),
+      current_playing.length.unwrap() as i32,
+      current_playing.image.unwrap(),
+      crate::connectivity::prisma::spotify_devices::UniqueWhereParam::IdEquals(dev.id),
+      vec![
+        spotify_history::r#type::set(current_playing.current_playing_type.as_ref().unwrap().to_string()),
+        spotify_history::artists::set(artists),
+        spotify_history::listened_at::set(date),
+      ]
+    ).exec().await;
+}