writing and reading notes

src/db.rs

@@ -31,8 +31,16 @@ pub struct DbNamespace {
     pub name: EncryptedValue,
 }
 
-#[derive(Debug)]
 pub struct DbNote {
+    pub id: i64,
+    pub namespace: DbNamespace,
+    pub category: String,
+    pub title: EncryptedValue,
+    pub value: EncryptedValue,
+}
+
+#[derive(Debug)]
+pub struct Note {
     pub id: i64,
     pub namespace: String,
     pub category: String,
@@ -91,6 +99,54 @@ impl DbHandle {
         Ok(rowid)
     }
 
+    pub fn write_note(&mut self, master_key: [u8; 32], note: Note) {
+        let namespace_id = self.get_namespace_id(&note.namespace, master_key).unwrap();
+        let encrypted_title = crypt::encrypt_value(&note.title, master_key);
+        let encrypted_value = crypt::encrypt_value(&note.value, master_key);
+        self.conn
+            .execute(
+                "INSERT INTO notes (namespace, category, title, value) VALUES ($1, $2, $3, $4);",
+                params![
+                    namespace_id,
+                    note.category,
+                    encrypted_title,
+                    encrypted_value
+                ],
+            )
+            .unwrap();
+    }
+
+    pub fn read_notes(&mut self, master_key: [u8; 32]) -> rusqlite::Result<Vec<Note>> {
+        let mut stmt = self.conn.prepare("SELECT notes.id, notes.category, notes.title, notes.value, namespaces.id, namespaces.name FROM notes JOIN namespaces ON notes.namespace=namespaces.id").unwrap();
+        let rows = stmt.query_map(params![], |row| {
+            Ok(DbNote {
+                id: row.get(0)?,
+                category: row.get(1)?,
+                title: row.get(2)?,
+                value: row.get(3)?,
+                namespace: DbNamespace {
+                    id: row.get(4)?,
+                    name: row.get(5)?,
+                },
+            })
+        })?;
+
+        let notes: Result<Vec<Note>, _> = rows
+            .map(|note_result| match note_result {
+                Ok(note) => Ok(Note {
+                    id: note.id,
+                    namespace: note.namespace.name.decrypt_to_string(master_key).unwrap(),
+                    category: note.category,
+                    title: note.title.decrypt_to_string(master_key).unwrap(),
+                    value: note.value.decrypt_to_string(master_key).unwrap(),
+                }),
+                Err(e) => return Err(e),
+            })
+            .collect();
+
+        notes
+    }
+
     pub fn get_db_property(&self, name: &str) -> Result<Option<String>, Box<dyn Error>> {
         let mut stmt = self
             .conn