Indicate which films have been watched, log unknown database errors

Also use "is" instead of "=" in SQL statements where sensible.

src/persist/sqlite_manager.rs

@@ -3,7 +3,7 @@ use std::fmt;
 use std::fmt::{Debug, Formatter};
 
 use async_sqlite::rusqlite::fallible_iterator::FallibleIterator;
-use async_sqlite::rusqlite::{OpenFlags, Row};
+use async_sqlite::rusqlite::{OpenFlags, Row, named_params};
 use async_sqlite::{Client, ClientBuilder, rusqlite};
 
 use crate::persist::common::{ResultExt, concat_os_str};
@@ -30,8 +30,10 @@ impl SqliteManager {
         connection
           .prepare(
             "
-              select uuid, name, original_name, release_date, runtime_minutes
-                from films
+              select films.uuid, films.name, films.original_name, films.release_date, films.runtime_minutes,
+                coalesce(watched_status.watched, 0) as watched
+              from films left join watched_status
+                on films.uuid is watched_status.media_uuid
             ",
           )?
           .query(())?
@@ -53,7 +55,7 @@ impl SqliteManager {
               select series.uuid, series.name, series.original_name,
                 min(episodes.release_date) as first_release_date
               from series, seasons, episodes
-              where series.uuid = seasons.series and seasons.uuid = episodes.season
+              where series.uuid is seasons.series and seasons.uuid is episodes.season
               group by series.uuid
             ",
           )?
@@ -64,6 +66,31 @@ impl SqliteManager {
       .await
       .map_err(convert_error)
   }
+
+  pub async fn set_film_watched_status(
+    &self,
+    uuid: &str,
+    watched: bool,
+  ) -> Result<(), DataManagerError> {
+    self
+      .client
+      .conn({
+        let uuid = uuid.to_string();
+        move |connection| {
+          connection.execute(
+            "
+              update watched_status
+              set watched = :watched
+              where watched_status.media_uuid is :uuid
+            ",
+            named_params! { ":uuid": uuid, ":watched": watched },
+          )?;
+          Ok(())
+        }
+      })
+      .await
+      .map_err(convert_error)
+  }
 }
 
 impl Debug for SqliteManager {
@@ -112,6 +139,7 @@ fn row_to_film_overview(row: &Row) -> rusqlite::Result<FilmOverview> {
   let original_name = row.get("original_name")?;
   let release_date = row.get("release_date")?;
   let runtime = row.get("runtime_minutes")?;
+  let watched = row.get("watched")?;
 
   Ok(FilmOverview {
     uuid,
@@ -119,6 +147,7 @@ fn row_to_film_overview(row: &Row) -> rusqlite::Result<FilmOverview> {
     original_name,
     release_date,
     runtime,
+    watched,
   })
 }
 
@@ -144,7 +173,10 @@ fn convert_error(async_sqlite_error: async_sqlite::Error) -> DataManagerError {
     async_sqlite::Error::Rusqlite(rusqlite_error) => match rusqlite_error {
       rusqlite::Error::SqliteFailure(sqlite_error, _) => match sqlite_error.code {
         rusqlite::ffi::ErrorCode::CannotOpen => DataManagerError::CannotOpenDB,
-        _ => DataManagerError::UnknownDBError,
+        _ => {
+          println!("{sqlite_error:?}");
+          DataManagerError::UnknownDBError
+        }
       },
       rusqlite::Error::InvalidColumnIndex(_) => {
         panic!("column indices obtained from query should exist")
@@ -164,8 +196,14 @@ fn convert_error(async_sqlite_error: async_sqlite::Error) -> DataManagerError {
       rusqlite::Error::MultipleStatement => {
         panic!("multiple statements present when there should be one")
       }
-      _ => DataManagerError::UnknownDBError,
+      _ => {
+        println!("{rusqlite_error:?}");
+        DataManagerError::UnknownDBError
+      }
     },
-    _ => DataManagerError::UnknownDBError,
+    _ => {
+      println!("{async_sqlite_error:?}");
+      DataManagerError::UnknownDBError
+    }
   }
 }