caracal 0.3.8

Nostr client for Gemini
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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

use crate::storage::Storage;
use heed::types::{SerdeRmp, Str};
use heed::{Database, RoTxn};
use nostr::{Timestamp, Url};
use serde::{Deserialize, Serialize};
use std::error::Error;

use chrono::{DateTime, Utc};

#[derive(Debug, Serialize, Deserialize)]
pub struct LongFormNoteDraft<'a> {
    #[serde(borrow)]
    pub body: Vec<&'a str>,
    pub title: Option<&'a str>,
    pub summary: Option<&'a str>,
    pub image: Option<Url>,
    pub ts_created: u64,
    pub ts_first_published: Option<u64>,
    pub datetime_created: DateTime<Utc>,
    pub datetime_expires: Option<DateTime<Utc>>,
    pub datetime_autopublish: Option<DateTime<Utc>>,
    pub attachments: Vec<&'a str>,
}

type LongFormDraftsDatabase<'a> =
    Database<Str, SerdeRmp<LongFormNoteDraft<'a>>>;

const DB_NAME: &str = "lf_note_drafts";

impl Storage {
    fn lf_drafts_db(
        &self,
    ) -> Result<LongFormDraftsDatabase<'_>, Box<dyn Error + Send + Sync>> {
        let rtxn = self.get_read_txn()?;

        self.env
            .open_database(&rtxn, Some(DB_NAME))?
            .ok_or(Box::from("Failed to open long-form drafts db"))
    }

    pub fn create_lf_drafts_db(
        &self,
    ) -> Result<LongFormDraftsDatabase<'_>, Box<dyn Error + Send + Sync>> {
        let mut wtxn = self.env.write_txn()?;
        let db: LongFormDraftsDatabase =
            self.env.create_database(&mut wtxn, Some(DB_NAME))?;
        wtxn.commit()?;
        Ok(db)
    }

    pub fn lf_draft_new(
        &self,
        id: &str,
    ) -> Result<(), Box<dyn Error + Send + Sync>> {
        let db = self.lf_drafts_db()?;

        let mut wtxn = self.env.write_txn()?;

        let draft = LongFormNoteDraft {
            body: Vec::new(),
            title: None,
            summary: None,
            image: None,
            ts_created: Timestamp::now().as_secs(),
            ts_first_published: None,
            datetime_created: Utc::now(),
            datetime_expires: None,
            datetime_autopublish: None,
            attachments: Vec::new(),
        };

        db.put(&mut wtxn, id, &draft)?;
        wtxn.commit()?;

        Ok(())
    }

    pub fn lf_draft_store(
        &self,
        id: &str,
        draft: LongFormNoteDraft,
    ) -> Result<(), Box<dyn Error + Send + Sync>> {
        let db = self.lf_drafts_db()?;
        let mut wtxn = self.env.write_txn()?;
        db.put(&mut wtxn, id, &draft)?;
        wtxn.commit()?;
        Ok(())
    }

    pub fn lf_draft_append_gemtext(
        &self,
        id: &str,
        gemtext: &str,
    ) -> Result<(), Box<dyn Error + Send + Sync>> {
        let db = self.lf_drafts_db()?;
        let mut rtxn = self.env.read_txn()?;
        let mut draft = self.lf_draft_get(id, &mut rtxn)?;

        draft.body.extend(gemtext.lines());

        let mut wtxn = self.env.write_txn()?;
        db.put(&mut wtxn, id, &draft)?;
        wtxn.commit()?;

        Ok(())
    }

    pub fn lf_draft_delete_last(
        &self,
        id: &str,
    ) -> Result<(), Box<dyn Error + Send + Sync>> {
        let db = self.lf_drafts_db()?;
        let mut rtxn = self.env.read_txn()?;
        let mut draft = self.lf_draft_get(id, &mut rtxn)?;

        if !draft.body.is_empty() {
            let len = draft.body.len() - 1;
            draft.body.truncate(len);

            let mut wtxn = self.env.write_txn()?;
            db.put(&mut wtxn, id, &draft)?;
            wtxn.commit()?;
        }

        Ok(())
    }

    pub fn lf_draft_get_content(
        &self,
        id: &str,
    ) -> Result<String, Box<dyn Error + Send + Sync>> {
        let rtxn = self.env.read_txn()?;

        match self.lf_drafts_db()?.get(&rtxn, id)? {
            Some(draft) => {
                let content = draft.body.join("\n");
                Ok(content)
            }
            None => Err(Box::from("Cannot get draft")),
        }
    }

    pub fn lf_draft_get<'c>(
        &'c self,
        id: &str,
        rtxn: &'c mut RoTxn,
    ) -> Result<LongFormNoteDraft<'c>, Box<dyn Error + Send + Sync>> {
        self.lf_drafts_db()?
            .get(rtxn, id)?
            .ok_or(Box::from("Cannot find draft"))
    }
}