move all direct database access to logic crate

1 files changed, 69 insertions, 16 deletions

diff --git a/logic/src/node.rs b/logic/src/node.rs
index c8ff820..820116f 100644
--- a/logic/src/node.rs
+++ b/logic/src/node.rs
@@ -3,30 +3,30 @@
     which is licensed under the GNU Affero General Public License (version 3); see /COPYING.
     Copyright (C) 2025 metamuffin <metamuffin.org>
 */
-use crate::{filter_sort::filter_and_sort_nodes, session::Session};
+use crate::{DATABASE, filter_sort::filter_and_sort_nodes, session::Session};
 use anyhow::{Result, anyhow};
 use jellycommon::{
     Node, NodeID, NodeKind, Visibility,
     api::{ApiNodeResponse, NodeFilterSort, SortOrder, SortProperty},
-    user::NodeUserData,
+    user::{NodeUserData, WatchedState},
 };
 use jellydb::Database;
 use std::{cmp::Reverse, collections::BTreeMap, sync::Arc};
 
 pub fn get_node(
-    db: &Database,
-    id: NodeID,
     session: &Session,
+    id: NodeID,
     children: bool,
     parents: bool,
     filter: NodeFilterSort,
 ) -> Result<ApiNodeResponse> {
-    let (node, udata) = db.get_node_with_userdata(id, &session)?;
+    let (node, udata) = DATABASE.get_node_with_userdata(id, &session)?;
 
     let mut children = if children {
-        db.get_node_children(id)?
+        DATABASE
+            .get_node_children(id)?
             .into_iter()
-            .map(|c| db.get_node_with_userdata(c, &session))
+            .map(|c| DATABASE.get_node_with_userdata(c, &session))
             .collect::<anyhow::Result<Vec<_>>>()?
     } else {
         Vec::new()
@@ -35,13 +35,13 @@ pub fn get_node(
     let mut parents = if parents {
         node.parents
             .iter()
-            .map(|pid| db.get_node_with_userdata(*pid, &session))
+            .map(|pid| DATABASE.get_node_with_userdata(*pid, &session))
             .collect::<anyhow::Result<Vec<_>>>()?
     } else {
         Vec::new()
     };
 
-    let mut similar = get_similar_media(&node, db, &session)?;
+    let mut similar = get_similar_media(&session, &node)?;
 
     similar.retain(|(n, _)| n.visibility >= Visibility::Reduced);
     children.retain(|(n, _)| n.visibility >= Visibility::Reduced);
@@ -65,15 +65,11 @@ pub fn get_node(
     })
 }
 
-pub fn get_similar_media(
-    node: &Node,
-    db: &Database,
-    session: &Session,
-) -> Result<Vec<(Arc<Node>, NodeUserData)>> {
+pub fn get_similar_media(session: &Session, node: &Node) -> Result<Vec<(Arc<Node>, NodeUserData)>> {
     let this_id = NodeID::from_slug(&node.slug);
     let mut ranking = BTreeMap::<NodeID, usize>::new();
     for tag in &node.tags {
-        let nodes = db.get_tag_nodes(tag)?;
+        let nodes = DATABASE.get_tag_nodes(tag)?;
         let weight = 1_000_000 / nodes.len();
         for n in nodes {
             if n != this_id {
@@ -86,7 +82,7 @@ pub fn get_similar_media(
     ranking
         .into_iter()
         .take(32)
-        .map(|(pid, _)| db.get_node_with_userdata(pid, session))
+        .map(|(pid, _)| DATABASE.get_node_with_userdata(pid, session))
         .collect::<anyhow::Result<Vec<_>>>()
 }
 
@@ -110,3 +106,60 @@ impl DatabaseNodeUserDataExt for Database {
         ))
     }
 }
+
+pub fn get_nodes_modified_since(_session: &Session, since: u64) -> Result<Vec<NodeID>> {
+    let mut nodes = DATABASE.get_nodes_modified_since(since)?;
+    nodes.retain(|id| {
+        DATABASE.get_node(*id).is_ok_and(|n| {
+            n.as_ref()
+                .is_some_and(|n| n.visibility >= Visibility::Reduced)
+        })
+    });
+    Ok(nodes)
+}
+
+pub fn get_node_by_eid(_session: &Session, platform: &str, eid: &str) -> Result<Option<NodeID>> {
+    DATABASE.get_node_external_id(platform, eid)
+}
+pub fn node_id_to_slug(_session: &Session, id: NodeID) -> Result<String> {
+    Ok(DATABASE
+        .get_node(id)?
+        .ok_or(anyhow!("node does not exist"))?
+        .slug
+        .to_owned())
+}
+
+pub fn update_node_userdata_watched(
+    session: &Session,
+    node: NodeID,
+    state: WatchedState,
+) -> Result<()> {
+    // TODO perm
+    DATABASE.update_node_udata(node, &session.user.name, |udata| {
+        udata.watched = state;
+        Ok(())
+    })
+}
+pub fn update_node_userdata_watched_progress(
+    session: &Session,
+    node: NodeID,
+    time: f64,
+) -> Result<()> {
+    // TODO perm
+    DATABASE.update_node_udata(node, &session.user.name, |udata| {
+        udata.watched = match udata.watched {
+            WatchedState::None | WatchedState::Pending | WatchedState::Progress(_) => {
+                WatchedState::Progress(time)
+            }
+            WatchedState::Watched => WatchedState::Watched,
+        };
+        Ok(())
+    })
+}
+pub fn update_node_userdata_rating(session: &Session, node: NodeID, rating: i32) -> Result<()> {
+    // TODO perm
+    DATABASE.update_node_udata(node, &session.user.name, |udata| {
+        udata.rating = rating;
+        Ok(())
+    })
+}