REPO: Make a kara unavailable when we download it

src/rust/lektor_db/src/connexion.rs

@@ -212,8 +212,30 @@ impl LktDatabaseConnection {
         })
     }
 
-    pub fn make_kara_available<'a>(&mut self, remote_id: RemoteKaraId) -> LktDatabaseResult<()> {
-        todo!()
+    /// Makes a kara avilable, set the avail flag to `true` or `false` depending on the passed
+    /// flag. If the operation changed nothing, don't raise an error.
+    pub fn make_kara_available<'a>(
+        &mut self,
+        remote_id: RemoteKaraId,
+        flag: bool,
+    ) -> LktDatabaseResult<()> {
+        let RemoteKaraId {
+            repo_id: rid,
+            repo_kara_id: rkid,
+        } = remote_id;
+        self.sqlite.exclusive_transaction(|c| {
+            let local_kara_id: i64 = with_dsl!(repo_kara => repo_kara
+                .select(local_kara_id)
+                .filter(repo_id.eq(rid).and(repo_kara_id.eq(rkid)))
+                .first(c)?
+            );
+            with_dsl!(kara => diesel::update(kara)
+                .filter(id.eq(local_kara_id))
+                .set(is_dl.eq(flag))
+                .execute(c)?
+            );
+            Ok(())
+        })
     }
 
     /// Create a series of models from a kara signature from Kurisu's V1 API.

src/rust/lektor_db/src/models.rs

@@ -18,7 +18,7 @@ pub struct KaraId {
     pub local_kara_id: i64,
 }
 
-#[derive(Debug, Queryable, Selectable)]
+#[derive(Debug, Queryable, Selectable, Clone, Copy)]
 #[diesel(table_name = repo_kara)]
 pub struct RemoteKaraId {
     pub repo_id: i64,

src/rust/lektor_repo/src/download.rs

@@ -225,24 +225,42 @@ impl Download {
         search_urls: &[&str],
         dest: impl AsRef<Path>,
     ) {
-        let (dest, name, db) = (dest.as_ref(), name.as_ref(), self.db.clone());
-        if let Err(err) =
-            Download::download_kara(db.clone(), api, search_urls, repo_id, repo_kara_id, dest).await
-        {
-            log::error!(target: "REPO", "failed to download file `{}` for kara {repo_kara_id}: {err}", dest.to_string_lossy());
+        macro_rules! make_kara_available {
+            ($db: expr, $id: expr, $flag: expr) => {{
+                let mut db = $db.lock().expect("failed to lock the database...");
+                if let Err(err) = db.make_kara_available($id, $flag) {
+                    log::error!(
+                        target: "REPO",
+                        "failed to make kara `{repo_kara_id}` from {} {}: {err}",
+                        name.as_ref(),
+                        either!($flag => "available"; "unavailable")
+                    );
                     return;
                 }
-        let mut db = db.lock().expect("failed to lock the database...");
-        let remote_id = RemoteKaraId {
+            }};
+        }
+
+        let (remote_id, db, dest) = (
+            RemoteKaraId {
                 repo_id,
                 repo_kara_id,
-        };
-        if let Err(err) = db.make_kara_available(remote_id) {
-            log::error!(target: "REPO", "failed to make kara `{repo_kara_id}` from {name} available: {err}");
+            },
+            self.db.clone(),
+            dest.as_ref(),
+        );
+
+        make_kara_available!(db, remote_id, false);
+        if let Err(err) =
+            Download::download_kara(db.clone(), api, search_urls, repo_id, repo_kara_id, dest).await
+        {
+            log::error!(target: "REPO", "failed to download file `{}` for kara {repo_kara_id}: {err}", dest.to_string_lossy());
             return;
         }
+        make_kara_available!(db, remote_id, true);
+
         log::info!(
-            "downloaded kara {repo_kara_id} from {name} at location {}",
+            "downloaded kara {repo_kara_id} from {} at location {}",
+            name.as_ref(),
             dest.to_string_lossy()
         );
     }