lb_rs/service/
share.rs

1use crate::LocalLb;
2use crate::model::api::GetPublicKeyRequest;
3use crate::model::errors::{LbErr, LbResult};
4use crate::model::file::{File, ShareMode};
5use crate::model::file_metadata::Owner;
6use crate::model::tree_like::TreeLike;
7use crate::service::events::Actor;
8use libsecp256k1::PublicKey;
9use uuid::Uuid;
10
11impl LocalLb {
12    // todo: this can check whether the username is known already
13    #[instrument(level = "debug", skip(self))]
14    pub async fn share_file(&self, id: Uuid, username: &str, mode: ShareMode) -> LbResult<()> {
15        let account = self.get_account()?;
16        let username = username.to_lowercase();
17
18        let sharee = Owner(
19            self.client
20                .request(account, GetPublicKeyRequest { username: username.clone() })
21                .await
22                .map_err(LbErr::from)?
23                .key,
24        );
25
26        let mut tx = self.begin_tx().await;
27        let db = tx.db();
28
29        let mut tree = (&db.base_metadata)
30            .to_staged(&mut db.local_metadata)
31            .to_lazy();
32        db.pub_key_lookup.insert(sharee, username)?;
33
34        tree.add_share(id, sharee, mode, &self.keychain)?;
35
36        tx.end();
37
38        self.events.meta_changed(Actor::User(None));
39
40        Ok(())
41    }
42
43    /// returns pending shares -- files shared with us that we haven't accepted or rejected
44    /// this function just returns the actual files that were shared -- or the roots of shared
45    /// trees. For the full set of shares see [Self::get_pending_share_files]
46    #[instrument(level = "debug", skip(self))]
47    pub async fn get_pending_shares(&self) -> LbResult<Vec<File>> {
48        let tx = self.ro_tx().await;
49        let db = tx.db();
50
51        let mut tree = (&db.base_metadata).to_staged(&db.local_metadata).to_lazy();
52        let pending_roots = tree.pending_roots(&self.keychain)?.into_iter();
53
54        tree.decrypt_all(&self.keychain, pending_roots, &db.pub_key_lookup, false)
55    }
56
57    /// returns *all* the files associated with any pending shares (the share as well as it's
58    /// descendants).
59    #[instrument(level = "debug", skip(self))]
60    pub async fn get_pending_share_files(&self) -> LbResult<Vec<File>> {
61        let tx = self.ro_tx().await;
62        let db = tx.db();
63
64        let mut tree = (&db.base_metadata).to_staged(&db.local_metadata).to_lazy();
65        let pending_files = tree.non_deleted_pending_files(&self.keychain)?.into_iter();
66
67        tree.decrypt_all(&self.keychain, pending_files, &db.pub_key_lookup, false)
68    }
69
70    #[instrument(level = "debug", skip(self))]
71    async fn delete_share(
72        &self, id: &Uuid, maybe_encrypted_for: Option<PublicKey>,
73    ) -> LbResult<()> {
74        let mut tx = self.begin_tx().await;
75        let db = tx.db();
76
77        let mut tree = (&db.base_metadata)
78            .to_staged(&mut db.local_metadata)
79            .to_lazy();
80
81        tree.delete_share(id, maybe_encrypted_for, &self.keychain)?;
82
83        tx.end();
84        self.events.meta_changed(Actor::User(None));
85
86        Ok(())
87    }
88
89    #[instrument(level = "debug", skip(self))]
90    pub async fn known_usernames(&self) -> LbResult<Vec<String>> {
91        let db = self.ro_tx().await;
92        let db = db.db();
93
94        Ok(db.pub_key_lookup.get().values().cloned().collect())
95    }
96
97    /// Whether `username` is a known Lockbook account (local cache, then server).
98    ///
99    /// Server lookup uses [`GetPublicKeyRequest`]. Auth is only a signed envelope —
100    /// when signed out we probe with an ephemeral key so onboard can check
101    /// availability without an account. `UserNotFound` maps to `false`.
102    #[instrument(level = "debug", skip(self))]
103    pub async fn username_exists(&self, username: &str) -> LbResult<bool> {
104        use crate::DEFAULT_API_LOCATION;
105        use crate::model::account::Account;
106        use crate::model::errors::LbErrKind;
107
108        let username = username.trim().to_lowercase();
109        if username.is_empty() {
110            return Ok(false);
111        }
112        // Signed-in only: local roster can short-circuit a hit. Empty when signed out.
113        if let Ok(known) = self.known_usernames().await {
114            if known.iter().any(|u| u.eq_ignore_ascii_case(&username)) {
115                return Ok(true);
116            }
117        }
118
119        // Prefer real account for api_url; else ephemeral signer + API_URL / default.
120        let owned;
121        let account = match self.get_account() {
122            Ok(a) => a,
123            Err(_) => {
124                let api =
125                    std::env::var("API_URL").unwrap_or_else(|_| DEFAULT_API_LOCATION.to_string());
126                owned = Account::new(String::new(), api);
127                &owned
128            }
129        };
130
131        match self
132            .client
133            .request(account, GetPublicKeyRequest { username })
134            .await
135        {
136            Ok(_) => Ok(true),
137            Err(e) => {
138                let err = LbErr::from(e);
139                match err.kind {
140                    // GetPublicKey UserNotFound → AccountNonexistent in LbErr map.
141                    LbErrKind::AccountNonexistent | LbErrKind::UsernameNotFound => Ok(false),
142                    _ => Err(err),
143                }
144            }
145        }
146    }
147
148    #[instrument(level = "debug", skip(self))]
149    pub async fn reject_share(&self, id: &Uuid) -> Result<(), LbErr> {
150        let pk = self.keychain.get_pk()?;
151        self.delete_share(id, Some(pk)).await
152    }
153}
lb_rs/service/share.rs

lb_rs/service/
share.rs
