micialware/jap_learn
1
0 Fork 0
Code Issues 6 Pull Requests Actions Packages Projects Releases Wiki Activity

Rewrite words and groups into result

Browse Source
This commit is contained in:
micialware committed 2026-08-24 18:46:54 +03:00
1 parent c56d135ce8
commit 5a6747030b
7 files changed
+99 -70
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

src/data_provider/words.rs
+53 -41
View File
@@ -1,8 +1,10 @@
use crate::data::entities::{WordData, WordGroup};
use crate::notification::NotificationData;
use crate::notification::NotificationData::{DbLoadError, DbSaveError};
use rusqlite::{Connection, params};
use std::collections::HashMap;
use crate::data::entities::{WordData, WordGroup};
pub fn add_word(word: &mut WordData, connection: &Connection) {
pub fn add_word(word: &mut WordData, connection: &Connection) -> Result<(), NotificationData> {
let index : u32 = connection
.query_row(
"INSERT INTO words (key, value, tags, more, group_id) VALUES (?1, ?2, ?3, ?4, ?5) RETURNING id",
@@ -10,17 +12,21 @@ pub fn add_word(word: &mut WordData, connection: &Connection) {
&word.key,
&word.value,
&word.tags,
serde_json::to_string(&word.additional).unwrap(),
serde_json::to_string(&word.additional).unwrap_or_default(),
&word.group_id,
),
|row| row.get(0),
).unwrap();
).map_err(|_| DbSaveError)?;
word.id = index.into();
Ok(())
}
pub fn add_words(words: &mut [WordData], connection: &mut Connection) {
let tx = connection.transaction().unwrap();
pub fn add_words(
words: &mut [WordData],
connection: &mut Connection,
) -> Result<(), NotificationData> {
let tx = connection.transaction().map_err(|_| DbLoadError)?;
let count = words.len();
{
@@ -28,33 +34,35 @@ pub fn add_words(words: &mut [WordData], connection: &mut Connection) {
.prepare(
"INSERT INTO words (key, value, tags, more, group_id) VALUES (?1, ?2, ?3, ?4, ?5)",
)
.unwrap();
.expect("Failed to prepare statement");
for word in words.iter() {
stmt.execute(params![
word.key,
word.value,
word.tags,
serde_json::to_string(&word.additional).unwrap(),
serde_json::to_string(&word.additional).unwrap_or_default(),
word.group_id
])
.unwrap();
.map_err(|_| DbSaveError)?;
}
}
let last_index: u32 = tx.last_insert_rowid() as u32;
tx.commit().unwrap();
tx.commit().map_err(|_| DbSaveError)?;
let start_index = last_index - (count as u32) + 1;
for (index, id) in (start_index..=last_index).enumerate() {
words[index].id = id.into();
}
Ok(())
}
pub fn update_word(word: &mut WordData, connection: &Connection) {
pub fn update_word(word: &mut WordData, connection: &Connection) -> Result<(), NotificationData> {
if !word.id.is_valid() {
add_word(word, connection);
Ok(add_word(word, connection)?)
} else {
connection
.execute(
@@ -67,23 +75,25 @@ pub fn update_word(word: &mut WordData, connection: &Connection) {
&word.id,
),
)
.unwrap();
.map_err(|_| DbSaveError)?;
Ok(())
}
}
pub fn delete_word(word: &WordData, connection: &Connection) {
pub fn delete_word(word: &WordData, connection: &Connection) -> Result<(), NotificationData> {
if !word.id.is_valid() {
return;
return Err(DbSaveError);
}
connection
.execute("DELETE FROM words WHERE id = ?1", (&word.id,))
.unwrap();
.map_err(|_| DbSaveError)?;
Ok(())
}
pub fn load_words(connection: &Connection) -> Vec<WordData> {
pub fn load_words(connection: &Connection) -> Result<Vec<WordData>, NotificationData> {
let mut stmt = connection
.prepare("SELECT id, key, value, tags, more, group_id FROM words")
.unwrap();
.expect("Failed to prepare statement");
let word_iter = stmt
.query_map([], |row| {
let additional: String = row.get(4)?;
@@ -92,24 +102,22 @@ pub fn load_words(connection: &Connection) -> Vec<WordData> {
key: row.get(1)?,
value: row.get(2)?,
tags: row.get(3)?,
additional: serde_json::from_str::<HashMap<String, String>>(&additional).unwrap(),
additional: serde_json::from_str::<HashMap<String, String>>(&additional).unwrap_or_default(),
group_id: row.get(5)?,
})
})
.unwrap();
.map_err(|_| DbLoadError)?;
let mut buffer = vec![];
for word in word_iter {
buffer.push(word.unwrap());
}
let mut buffer = Vec::with_capacity(1024);
word_iter.filter_map(|res| res.ok()).for_each(|i| buffer.push(i));
buffer
Ok(buffer)
}
pub fn load_word_groups(connection: &Connection) -> Vec<WordGroup> {
pub fn load_word_groups(connection: &Connection) -> Result<Vec<WordGroup>, NotificationData> {
let mut stmt = connection
.prepare("SELECT id, name FROM word_group")
.unwrap();
.expect("Failed to prepare statement");
let group_iter = stmt
.query_map([], |row| {
Ok(WordGroup {
@@ -117,46 +125,50 @@ pub fn load_word_groups(connection: &Connection) -> Vec<WordGroup> {
name: row.get(1)?,
})
})
.unwrap();
.map_err(|_| DbLoadError)?;
let mut buffer = vec![];
for group in group_iter {
buffer.push(group.unwrap());
}
let mut buffer = Vec::with_capacity(8);
group_iter.filter_map(|res| res.ok()).for_each(|i| buffer.push(i));
buffer
Ok(buffer)
}
pub fn add_group(group: &mut WordGroup, connection: &Connection) {
pub fn add_group(group: &mut WordGroup, connection: &Connection) -> Result<(), NotificationData> {
let index: u32 = connection
.query_row(
"INSERT INTO word_group (name) VALUES (?1) RETURNING id",
(&group.name,),
|row| row.get(0),
)
.unwrap();
.map_err(|_| DbSaveError)?;
group.id = index.into();
Ok(())
}
pub fn update_group(group: &mut WordGroup, connection: &Connection) {
pub fn update_group(
group: &mut WordGroup,
connection: &Connection,
) -> Result<(), NotificationData> {
if !group.id.is_valid() {
add_group(group, connection);
Ok(add_group(group, connection)?)
} else {
connection
.execute(
"UPDATE word_group SET name = ?1 WHERE id = ?2",
(&group.name, &group.id),
)
.unwrap();
.map_err(|_| DbSaveError)?;
Ok(())
}
}
pub fn delete_group(group: &WordGroup, connection: &Connection) {
pub fn delete_group(group: &WordGroup, connection: &Connection) -> Result<(), NotificationData> {
if !group.id.is_valid() {
return;
return Err(DbSaveError);
}
connection
.execute("DELETE FROM word_group WHERE id = ?1", (&group.id,))
.unwrap();
.map_err(|_| DbSaveError)?;
Ok(())
}