lb-rs 26.4.13

The rust library for interacting with your lockbook.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

use crate::Lb;
use crate::model::errors::{LbErrKind, LbResult};
use crate::model::file::File;
use crate::model::path_ops::Filter;
use crate::model::tree_like::TreeLike;
use crate::service::events::Actor;
use uuid::Uuid;

impl Lb {
    #[instrument(level = "debug", skip(self), err(Debug))]
    pub async fn create_link_at_path(&self, path: &str, target_id: Uuid) -> LbResult<File> {
        let mut tx = self.begin_tx().await;
        let db = tx.db();

        let mut tree = (&db.base_metadata)
            .to_staged(&mut db.local_metadata)
            .to_lazy();

        let root = db.root.get().ok_or(LbErrKind::RootNonexistent)?;

        let id = tree.create_link_at_path(path, target_id, root, &self.keychain)?;

        let ui_file = tree.decrypt(&self.keychain, &id, &db.pub_key_lookup)?;

        self.events.meta_changed(Actor::User);

        Ok(ui_file)
    }

    #[instrument(level = "debug", skip(self), err(Debug))]
    pub async fn create_at_path(&self, path: &str) -> LbResult<File> {
        let mut tx = self.begin_tx().await;
        let db = tx.db();

        let mut tree = (&db.base_metadata)
            .to_staged(&mut db.local_metadata)
            .to_lazy();

        let root = db.root.get().ok_or(LbErrKind::RootNonexistent)?;

        let id = tree.create_at_path(path, root, &self.keychain)?;

        let ui_file = tree.decrypt(&self.keychain, &id, &db.pub_key_lookup)?;

        self.events.meta_changed(Actor::User);

        Ok(ui_file)
    }

    #[instrument(level = "debug", skip(self), err(Debug))]
    pub async fn get_by_path(&self, path: &str) -> LbResult<File> {
        let tx = self.ro_tx().await;
        let db = tx.db();

        let mut tree = (&db.base_metadata).to_staged(&db.local_metadata).to_lazy();

        let root = db.root.get().ok_or(LbErrKind::RootNonexistent)?;

        let id = tree.path_to_id(path, root, &self.keychain)?;

        let ui_file = tree.decrypt(&self.keychain, &id, &db.pub_key_lookup)?;

        Ok(ui_file)
    }

    #[instrument(level = "debug", skip(self), err(Debug))]
    pub async fn get_path_by_id(&self, id: Uuid) -> LbResult<String> {
        let tx = self.ro_tx().await;
        let db = tx.db();

        let mut tree = (&db.base_metadata).to_staged(&db.local_metadata).to_lazy();
        let path = tree.id_to_path(&id, &self.keychain)?;

        Ok(path)
    }

    #[instrument(level = "debug", skip(self), err(Debug))]
    pub async fn list_paths(&self, filter: Option<Filter>) -> LbResult<Vec<String>> {
        Ok(self
            .list_paths_with_ids(filter)
            .await?
            .into_iter()
            .map(|(_, path)| path)
            .collect())
    }

    #[instrument(level = "debug", skip(self), err(Debug))]
    pub async fn list_paths_with_ids(
        &self, filter: Option<Filter>,
    ) -> LbResult<Vec<(Uuid, String)>> {
        let tx = self.ro_tx().await;
        let db = tx.db();

        let mut tree = (&db.base_metadata).to_staged(&db.local_metadata).to_lazy();
        let paths = tree.list_paths(filter, &self.keychain)?;

        Ok(paths)
    }
}