1 files changed, 26 insertions, 23 deletions

diff --git a/server/src/import.rs b/server/src/import.rs
index d3919b5..ad1d5e9 100644
--- a/server/src/import.rs
+++ b/server/src/import.rs
@@ -27,7 +27,7 @@ pub async fn import(db: &Database, fed: &Federation) -> anyhow::Result<()> {
     let permit = IMPORT_SEM.try_acquire()?;
     db.node.clear()?;
     info!("importing...");
-    let (_, errs) = import_path(CONF.library_path.clone(), db, fed, None)
+    let (_, errs) = import_path(CONF.library_path.clone(), db, fed, vec![])
         .await
         .context("indexing")?;
     info!("import completed");
@@ -46,7 +46,7 @@ pub async fn import_path(
     path: PathBuf,
     db: &Database,
     fed: &Federation,
-    parent: Option<String>,
+    mut node_path: Vec<String>,
 ) -> anyhow::Result<(Vec<String>, usize)> {
     if path.is_dir() {
         let mpath = path.join("directory.json");
@@ -62,14 +62,16 @@ pub async fn import_path(
         let identifier = if mpath.exists() {
             path.file_name().unwrap().to_str().unwrap().to_string()
         } else {
-            parent
-                .clone()
+            node_path
+                .last()
+                .cloned()
                 .ok_or(anyhow!("non-root node requires parent"))?
         };
 
+        node_path.push(identifier.clone());
         let mut all: FuturesUnordered<_> = children_paths
             .into_iter()
-            .map(|p| import_path(p.clone(), db, fed, Some(identifier.clone())).map_err(|e| (p, e)))
+            .map(|p| import_path(p.clone(), db, fed, node_path.clone()).map_err(|e| (p, e)))
             .collect();
 
         let mut children_ids = Vec::new();
@@ -87,13 +89,14 @@ pub async fn import_path(
             }
         }
         if mpath.exists() {
-            let mut data: Node =
+            let mut node: Node =
                 serde_json::from_reader(File::open(mpath).context("metadata missing")?)?;
 
-            data.public.children = children_ids;
-            data.public.parent = parent;
+            node.public.children = children_ids;
+            node.public.path = node_path;
+            node.public.id = Some(identifier.to_owned());
             info!("adding {identifier}");
-            db.node.insert(&identifier, &data)?;
+            db.node.insert(&identifier, &node)?;
             Ok((vec![identifier], errs))
         } else {
             Ok((children_ids, errs))
@@ -101,8 +104,8 @@ pub async fn import_path(
     } else if path.is_file() {
         info!("loading {path:?}");
         let datafile = File::open(path.clone()).context("cant load metadata")?;
-        let mut data: Node = serde_json::from_reader(datafile).context("invalid metadata")?;
-        let identifier = data.private.id.clone().unwrap_or_else(|| {
+        let mut node: Node = serde_json::from_reader(datafile).context("invalid metadata")?;
+        let identifier = node.private.id.clone().unwrap_or_else(|| {
             path.file_name()
                 .unwrap()
                 .to_str()
@@ -112,19 +115,20 @@ pub async fn import_path(
                 .to_string()
         });
 
-        let idents = if let Some(io) = data.private.import.take() {
+        let idents = if let Some(io) = node.private.import.take() {
             let session = fed
                 .get_session(&io.host)
                 .await
                 .context("creating session")?;
 
-            import_remote(io, db, &session, identifier.clone(), parent)
+            import_remote(io, db, &session, identifier.clone(), node_path)
                 .await
                 .context("federated import")?
         } else {
             debug!("adding {identifier}");
-            data.public.parent = parent;
-            db.node.insert(&identifier, &data)?;
+            node.public.path = node_path;
+            node.public.id = Some(identifier.to_owned());
+            db.node.insert(&identifier, &node)?;
             vec![identifier]
         };
         Ok((idents, 0))
@@ -141,7 +145,7 @@ async fn import_remote(
     db: &Database,
     session: &Arc<Session>,
     identifier: String,
-    parent: Option<String>,
+    mut node_path: Vec<String>,
 ) -> anyhow::Result<Vec<String>> {
     let _permit = SEM_REMOTE_IMPORT.acquire().await.unwrap();
     info!("loading federated node {identifier:?}");
@@ -163,9 +167,7 @@ async fn import_remote(
 
     drop(_permit);
 
-    let child_parent = if flatten {
-        parent
-    } else {
+    if !flatten {
         let mut node = Node {
             public: node.clone(),
             private: NodePrivate {
@@ -179,7 +181,7 @@ async fn import_remote(
                 }),
             },
         };
-        node.public.parent = parent;
+        node.public.path = node_path.clone();
         node.public.federated = Some(opts.host.clone());
         node.public
             .children
@@ -187,9 +189,10 @@ async fn import_remote(
             .for_each(|c| *c = format!("{}{c}", opts.prefix.clone().unwrap_or(String::new())));
 
         debug!("adding {identifier}");
+        node.public.id = Some(identifier.to_owned());
         db.node.insert(&identifier, &node)?;
-        Some(opts.id.clone())
-    };
+        node_path.push(opts.id.clone());
+    }
 
     let mut children: FuturesUnordered<_> = node
         .children
@@ -204,7 +207,7 @@ async fn import_remote(
                 db,
                 session,
                 prefixed,
-                child_parent.clone(),
+                node_path.clone(),
             )
         })
         .collect();