fix: store DateTime in utc

it works better

src/date_time.rs

@@ -3,24 +3,28 @@ use gettextrs::gettext;
 use gtk::glib;
 use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
 
-/// A local [`glib::DateTime`] that implements [`Serialize`] and [`Deserialize`]
+/// A [`glib::DateTime`] that implements [`Serialize`] and [`Deserialize`]
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, glib::ValueDelegate)]
 #[value_delegate(nullable)]
 pub struct DateTime(glib::DateTime);
 
 impl DateTime {
-    pub fn now_local() -> Self {
-        Self(glib::DateTime::now_local().unwrap())
+    pub fn now_utc() -> Self {
+        Self(glib::DateTime::now_utc().unwrap())
+    }
+
+    pub fn to_local(&self) -> Self {
+        Self(self.0.to_local().unwrap())
     }
 
     pub fn from_iso8601(string: &str) -> Result<Self> {
-        glib::DateTime::from_iso8601(string, Some(&glib::TimeZone::local()))
+        glib::DateTime::from_iso8601(string, None)
             .map(Self)
             .with_context(|| format!("Invalid iso8601 datetime `{}`", string))
     }
 
     pub fn fuzzy_display(&self) -> glib::GString {
-        let now = Self::now_local();
+        let now = Self::now_utc();
 
         if self.0.ymd() == now.0.ymd() {
             // Translators: `%R` will be replaced with 24-hour formatted datetime (e.g., `13:21`)
@@ -75,7 +79,7 @@ mod tests {
         let de_val = bincode::deserialize(&bytes).unwrap();
         assert_eq!(val, de_val);
 
-        let val = DateTime::now_local();
+        let val = DateTime::now_utc();
         let bytes = bincode::serialize(&val).unwrap();
         let de_val = bincode::deserialize(&bytes).unwrap();
         assert_eq!(val, de_val);

src/recognizer/mod.rs

@@ -273,7 +273,7 @@ impl Recognizer {
                 }),
             )
             .context("Failed to start recording")?;
-        let recorded_time = DateTime::now_local();
+        let recorded_time = DateTime::now_utc();
 
         cancellable.connect_cancelled_local(clone!(@weak _finally => move |_| {
             let _ = _finally.take();

src/recognizer/recording.rs

@@ -119,37 +119,37 @@ mod tests {
 
     #[test]
     fn serde_bincode() {
-        let val = Recording::new(&glib::Bytes::from_static(b""), &DateTime::now_local());
+        let val = Recording::new(&glib::Bytes::from_static(b""), &DateTime::now_utc());
         let bytes = bincode::serialize(&val).unwrap();
         let de_val = bincode::deserialize::<Recording>(&bytes).unwrap();
         assert_recording_eq(&val, &de_val);
         assert_eq!(val.recognize_retries(), de_val.recognize_retries());
 
-        let val = Recording::new(&glib::Bytes::from_static(b"a"), &DateTime::now_local());
+        let val = Recording::new(&glib::Bytes::from_static(b"a"), &DateTime::now_utc());
         let bytes = bincode::serialize(&val).unwrap();
         let de_val = bincode::deserialize::<Recording>(&bytes).unwrap();
         assert_recording_eq(&val, &de_val);
         assert_eq!(val.recognize_retries(), de_val.recognize_retries());
 
-        let val = Recording::new(&glib::Bytes::from_owned(vec![]), &DateTime::now_local());
+        let val = Recording::new(&glib::Bytes::from_owned(vec![]), &DateTime::now_utc());
         let bytes = bincode::serialize(&val).unwrap();
         let de_val = bincode::deserialize::<Recording>(&bytes).unwrap();
         assert_recording_eq(&val, &de_val);
         assert_eq!(val.recognize_retries(), de_val.recognize_retries());
 
-        let val = Recording::new(&glib::Bytes::from_owned(vec![1]), &DateTime::now_local());
+        let val = Recording::new(&glib::Bytes::from_owned(vec![1]), &DateTime::now_utc());
         let bytes = bincode::serialize(&val).unwrap();
         let de_val = bincode::deserialize::<Recording>(&bytes).unwrap();
         assert_recording_eq(&val, &de_val);
         assert_eq!(val.recognize_retries(), de_val.recognize_retries());
 
-        let val = Recording::new(&glib::Bytes::from_owned(vec![1, 2]), &DateTime::now_local());
+        let val = Recording::new(&glib::Bytes::from_owned(vec![1, 2]), &DateTime::now_utc());
         let bytes = bincode::serialize(&val).unwrap();
         let de_val = bincode::deserialize::<Recording>(&bytes).unwrap();
         assert_recording_eq(&val, &de_val);
         assert_eq!(val.recognize_retries(), de_val.recognize_retries());
 
-        let val = Recording::new(&glib::Bytes::from_owned(vec![1, 2]), &DateTime::now_local());
+        let val = Recording::new(&glib::Bytes::from_owned(vec![1, 2]), &DateTime::now_utc());
         val.set_recognize_result(Some(BoxedRecognizeResult(Err(RecognizeError::new(
             RecognizeErrorKind::Connection,
             "Some message".to_string(),
@@ -159,7 +159,7 @@ mod tests {
         assert_recording_eq(&val, &de_val);
         assert_eq!(val.recognize_retries(), de_val.recognize_retries());
 
-        let val = Recording::new(&glib::Bytes::from_owned(vec![1, 2]), &DateTime::now_local());
+        let val = Recording::new(&glib::Bytes::from_owned(vec![1, 2]), &DateTime::now_utc());
         val.increment_recognize_retries();
         let bytes = bincode::serialize(&val).unwrap();
         let de_val = bincode::deserialize::<Recording>(&bytes).unwrap();

src/recognizer/recordings.rs

@@ -253,7 +253,7 @@ mod tests {
     };
 
     fn new_test_recording(bytes: &'static [u8]) -> Recording {
-        Recording::new(&glib::Bytes::from_static(bytes), &DateTime::now_local())
+        Recording::new(&glib::Bytes::from_static(bytes), &DateTime::now_utc())
     }
 
     fn new_test_song(id: &str) -> Song {

src/song.rs

@@ -335,7 +335,7 @@ mod test {
         assert_song_eq(&val, &de_val);
 
         let val = SongBuilder::new(&Uid::from("d"), "D Title", "D Artist", "D Album").build();
-        val.set_last_heard(DateTime::now_local());
+        val.set_last_heard(DateTime::now_utc());
         let bytes = bincode::serialize(&val).unwrap();
         let de_val = bincode::deserialize::<Song>(&bytes).unwrap();
         assert_song_eq(&val, &de_val);

src/song_sorter.rs

@@ -103,8 +103,8 @@ mod tests {
     fn compare() {
         let sorter = SongSorter::new();
 
-        let old = new_test_song(DateTime::now_local(), "old");
-        let new = new_test_song(DateTime::now_local(), "new");
+        let old = new_test_song(DateTime::now_utc(), "old");
+        let new = new_test_song(DateTime::now_utc(), "new");
         assert!(old.last_heard() < new.last_heard());
 
         // Match search term, closer (old) song is sorted first (smaller)

src/window/recognized_page_tile.rs

@@ -101,7 +101,7 @@ mod imp {
                 .transform_to(|_, last_heard: Option<DateTime>| {
                     Some(
                         last_heard.map_or_else(glib::GString::default, |last_heard| {
-                            last_heard.fuzzy_display()
+                            last_heard.to_local().fuzzy_display()
                         }),
                     )
                 })

src/window/song_page.rs

@@ -347,7 +347,7 @@ impl SongPage {
             song.map(|song| {
                 song.last_heard().map_or_else(
                     || gettext("Unknown").into(),
-                    |last_heard| last_heard.fuzzy_display(),
+                    |last_heard| last_heard.to_local().fuzzy_display(),
                 )
             })
             .unwrap_or_default(),