4aiman/baldav
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
baldav/src-tauri/src/lib.rs
4aiman 01427941d4 Fix dedup: use execute() not execute_batch(), propagate errors 
execute_batch() silently failed on multi-statement dedup SQL.
Split into 4 separate execute() calls with map_err — errors
now propagate to JS and show to user instead of being swallowed.
2026-06-01 14:58:15 +03:00

509 lines
23 KiB
Rust
Raw Blame History

#[allow(unused_imports)]
use tauri_plugin_sql::{Migration, MigrationKind};
#[allow(unused_imports)]
use tauri::Manager;
use serde::Serialize;
#[derive(Serialize)]
struct AppInfo {
version: String,
git_hash: String,
build_date: String,
}
#[tauri::command]
fn get_app_info() -> AppInfo {
AppInfo {
version: env!("CARGO_PKG_VERSION").to_string(),
git_hash: env!("GIT_HASH").to_string(),
build_date: env!("BUILD_DATE").to_string(),
}
}
// GPS service control — writes command file, Kotlin reads and starts/stops service
#[tauri::command]
fn gps_service_command(app: tauri::AppHandle, cmd: String) -> Result<String, String> {
let data_dir = app.path().app_data_dir().map_err(|e| e.to_string())?;
std::fs::create_dir_all(&data_dir).ok();
// Write to app_data_dir
let cmd_path = data_dir.join("gps_command.txt");
std::fs::write(&cmd_path, &cmd).map_err(|e| e.to_string())?;
// Also write to app root dir (Android: Kotlin watches there)
if let Some(root) = data_dir.parent().and_then(|p| p.parent()) {
let alt = root.join("gps_command.txt");
let _ = std::fs::write(&alt, &cmd);
}
Ok(format!("sent:{}", cmd))
}
// Read GPS points from service's JSONL file
#[tauri::command]
fn gps_service_read_points(app: tauri::AppHandle) -> Result<String, String> {
let data_dir = app.path().app_data_dir().map_err(|e| e.to_string())?;
// Also check parent dir (Android: app_data_dir may be files/dev.baldav.app but service writes to app root)
let pts_path = data_dir.join("gps_live_points.jsonl");
let alt_path = data_dir.parent().and_then(|p| p.parent()).map(|p| p.join("gps_live_points.jsonl"));
if pts_path.exists() {
std::fs::read_to_string(&pts_path).map_err(|e| e.to_string())
} else if let Some(ref alt) = alt_path {
if alt.exists() {
std::fs::read_to_string(alt).map_err(|e| e.to_string())
} else {
Ok(String::new())
}
} else {
Ok(String::new())
}
}
#[tauri::command]
fn save_file(app: tauri::AppHandle, filename: String, content: String) -> Result<String, String> {
let data_dir = app.path().app_data_dir().map_err(|e| e.to_string())?;
std::fs::create_dir_all(&data_dir).ok();
// Write content to temp file for Kotlin to read
let content_path = data_dir.join("save_content.txt");
std::fs::write(&content_path, &content).map_err(|e| e.to_string())?;
// Send save command to Kotlin (triggers SAF file picker on Android)
let cmd_path = data_dir.join("gps_command.txt");
std::fs::write(&cmd_path, format!("save:{}", filename)).map_err(|e| e.to_string())?;
// Also write to app root for Kotlin FileObserver
if let Some(root) = data_dir.parent().and_then(|p| p.parent()) {
let _ = std::fs::write(root.join("save_content.txt"), &content);
let _ = std::fs::write(root.join("gps_command.txt"), format!("save:{}", filename));
}
Ok("save_requested".to_string())
}
#[tauri::command]
fn import_seed_products(app: tauri::AppHandle) -> Result<String, String> {
// Find seed DB — try multiple locations
let data_dir = app.path().app_data_dir().map_err(|e| e.to_string())?;
let seed_in_data = data_dir.join("products_seed.db");
let seed_in_files = data_dir.join("files").join("products_seed.db");
// Always try to refresh seed DB from bundled assets (resource_dir).
// This ensures app updates deliver new seed data even if an old copy exists.
let resource_dir = app.path().resource_dir().unwrap_or_default();
let seed_resource = resource_dir.join("data").join("products_seed.db");
if seed_resource.exists() {
// Overwrite the local copy with the bundled one (may be newer)
let _ = std::fs::copy(&seed_resource, &seed_in_data);
}
let seed_path = if seed_in_data.exists() {
seed_in_data
} else if seed_in_files.exists() {
seed_in_files
} else {
return Err(format!("Seed DB not found. Checked: {:?}, {:?}", seed_in_data, seed_in_files));
};
let seed_db = rusqlite::Connection::open(&seed_path).map_err(|e| e.to_string())?;
let seed_version: i64 = seed_db.query_row("SELECT version FROM seed_meta LIMIT 1", [], |r| r.get(0)).map_err(|e| e.to_string())?;
// tauri-plugin-sql may store DB in app_config_dir (desktop: ~/.config/...)
// or app_data_dir (desktop: ~/.local/share/...). Check both.
let config_dir = app.path().app_config_dir().unwrap_or_default();
let main_path = {
let p_config = config_dir.join("baldav.db");
let p_data = data_dir.join("baldav.db");
let p_parent = data_dir.join("..").join("baldav.db");
if p_config.exists() { p_config }
else if p_data.exists() { p_data }
else if p_parent.exists() { p_parent }
else { p_data }
};
let main_db = rusqlite::Connection::open(&main_path).map_err(|e| e.to_string())?;
let current_version: i64 = main_db.query_row("SELECT COALESCE((SELECT value FROM profile WHERE key='seed_version'), '0')", [], |r| {
let s: String = r.get(0)?;
Ok(s.parse::<i64>().unwrap_or(0))
}
).unwrap_or(0);
if current_version >= seed_version {return Ok(format!("up-to-date:v{}", current_version));}
let total: usize = seed_db.query_row("SELECT COUNT(*) FROM products", [], |r| r.get(0))
.map_err(|e| e.to_string())?;
// Emit initial progress
// Bulk import — no per-row progress needed (takes <5 seconds)
// Ensure all columns exist in main DB (including micronutrients from ION import)
let extra_cols = [
"composition TEXT", "name_lower TEXT", "category TEXT",
"sodium_mg REAL", "potassium_mg REAL", "calcium_mg REAL",
"magnesium_mg REAL", "phosphorus_mg REAL", "iron_mg REAL",
"vit_a_mcg REAL", "vit_b1_mg REAL", "vit_b2_mg REAL",
"vit_b3_mg REAL", "vit_c_mg REAL", "vit_e_mg REAL", "carotene_mcg REAL",
"nutrients_guessed INTEGER DEFAULT 0",
"user_edited INTEGER DEFAULT 0",
];
for col in &extra_cols {
let _ = main_db.execute(&format!("ALTER TABLE products ADD COLUMN {}", col), []);
}
// ATTACH seed DB to main DB and do bulk INSERT + UPDATE in SQL (no per-row loop)
let seed_str = seed_path.to_str().unwrap_or_default().to_string();
main_db.execute("ATTACH DATABASE ?1 AS seed", rusqlite::params![seed_str]).map_err(|e| e.to_string())?;
main_db.execute("BEGIN", []).map_err(|e| e.to_string())?;
// Create index for fast lookups during dedup and insert
let _ = main_db.execute_batch(
"CREATE INDEX IF NOT EXISTS idx_products_name_lower ON main.products(name_lower);"
);
// Dedup existing products by (name_lower, source, store_id).
// Each statement separate — execute_batch can fail silently on multi-statement strings.
main_db.execute(
"UPDATE food_log SET product_id = (
SELECT MIN(p2.id) FROM products p2
WHERE p2.name_lower = (SELECT p3.name_lower FROM products p3 WHERE p3.id = food_log.product_id)
AND p2.source = (SELECT p3.source FROM products p3 WHERE p3.id = food_log.product_id)
AND COALESCE(p2.store_id,'') = COALESCE((SELECT p3.store_id FROM products p3 WHERE p3.id = food_log.product_id),'')
) WHERE product_id NOT IN (
SELECT MIN(id) FROM products WHERE name_lower IS NOT NULL
GROUP BY name_lower, source, COALESCE(store_id,'')
)", []).map_err(|e| format!("dedup food_log: {}", e))?;
main_db.execute(
"UPDATE recipe_ingredients SET product_id = (
SELECT MIN(p2.id) FROM products p2
WHERE p2.name_lower = (SELECT p3.name_lower FROM products p3 WHERE p3.id = recipe_ingredients.product_id)
AND p2.source = (SELECT p3.source FROM products p3 WHERE p3.id = recipe_ingredients.product_id)
AND COALESCE(p2.store_id,'') = COALESCE((SELECT p3.store_id FROM products p3 WHERE p3.id = recipe_ingredients.product_id),'')
) WHERE product_id NOT IN (
SELECT MIN(id) FROM products WHERE name_lower IS NOT NULL
GROUP BY name_lower, source, COALESCE(store_id,'')
)", []).map_err(|e| format!("dedup recipe_ingredients: {}", e))?;
main_db.execute(
"DELETE FROM products WHERE name_lower IS NOT NULL
AND id NOT IN (
SELECT MIN(id) FROM products WHERE name_lower IS NOT NULL
GROUP BY name_lower, source, COALESCE(store_id,'')
)", []).map_err(|e| format!("dedup delete: {}", e))?;
// UNIQUE index to prevent future duplicates
main_db.execute(
"CREATE UNIQUE INDEX IF NOT EXISTS idx_products_dedup
ON products(name_lower, source, COALESCE(store_id, ''))
WHERE name_lower IS NOT NULL", [])
.map_err(|e| format!("unique index: {}", e))?;
// Bulk INSERT new products from seed (INSERT OR IGNORE now works with unique index)
let inserted = main_db.execute(
"INSERT OR IGNORE INTO main.products (
name, brand, kcal_per_100g, protein_per_100g, fat_per_100g,
carbs_per_100g, fiber_per_100g, composition, source, store_id,
name_lower, weight_g, category,
sodium_mg, potassium_mg, calcium_mg, magnesium_mg, phosphorus_mg,
iron_mg, vit_a_mcg, vit_b1_mg, vit_b2_mg, vit_b3_mg, vit_c_mg,
vit_e_mg, carotene_mcg, nutrients_guessed
)
SELECT name, brand, kcal_per_100g, protein_per_100g, fat_per_100g,
carbs_per_100g, fiber_per_100g, composition, source, store_id,
name_lower, weight_g, category,
sodium_mg, potassium_mg, calcium_mg, magnesium_mg, phosphorus_mg,
iron_mg, vit_a_mcg, vit_b1_mg, vit_b2_mg, vit_b3_mg, vit_c_mg,
vit_e_mg, carotene_mcg, COALESCE(nutrients_guessed, 0)
FROM seed.products",
[]
).map_err(|e| e.to_string())?;
// Seed index for fast UPDATE lookups
let _ = main_db.execute_batch(
"CREATE INDEX IF NOT EXISTS idx_seed_name_lower ON seed.products(name_lower);"
);
// Update KBJU + micronutrients for existing store products (seed already attached above)
// Sync nutrients_guessed flag
let _ = main_db.execute_batch(
"UPDATE main.products SET nutrients_guessed = 1
WHERE (nutrients_guessed IS NULL OR nutrients_guessed = 0)
AND name_lower IN (SELECT s.name_lower FROM seed.products s WHERE s.nutrients_guessed = 1)"
);
// Update KBJU + micronutrients for store products that user hasn't manually edited.
// This ensures seed corrections (e.g. bread 268→243) flow through to app DB.
let _ = main_db.execute_batch(
"UPDATE main.products SET
kcal_per_100g = (SELECT s.kcal_per_100g FROM seed.products s WHERE s.name_lower = main.products.name_lower LIMIT 1),
protein_per_100g = (SELECT s.protein_per_100g FROM seed.products s WHERE s.name_lower = main.products.name_lower LIMIT 1),
fat_per_100g = (SELECT s.fat_per_100g FROM seed.products s WHERE s.name_lower = main.products.name_lower LIMIT 1),
carbs_per_100g = (SELECT s.carbs_per_100g FROM seed.products s WHERE s.name_lower = main.products.name_lower LIMIT 1),
fiber_per_100g = (SELECT s.fiber_per_100g FROM seed.products s WHERE s.name_lower = main.products.name_lower LIMIT 1),
nutrients_guessed= COALESCE((SELECT s.nutrients_guessed FROM seed.products s WHERE s.name_lower = main.products.name_lower LIMIT 1), nutrients_guessed),
sodium_mg = COALESCE((SELECT s.sodium_mg FROM seed.products s WHERE s.name_lower = main.products.name_lower LIMIT 1), sodium_mg),
potassium_mg = COALESCE((SELECT s.potassium_mg FROM seed.products s WHERE s.name_lower = main.products.name_lower LIMIT 1), potassium_mg),
calcium_mg = COALESCE((SELECT s.calcium_mg FROM seed.products s WHERE s.name_lower = main.products.name_lower LIMIT 1), calcium_mg),
magnesium_mg = COALESCE((SELECT s.magnesium_mg FROM seed.products s WHERE s.name_lower = main.products.name_lower LIMIT 1), magnesium_mg),
phosphorus_mg = COALESCE((SELECT s.phosphorus_mg FROM seed.products s WHERE s.name_lower = main.products.name_lower LIMIT 1), phosphorus_mg),
iron_mg = COALESCE((SELECT s.iron_mg FROM seed.products s WHERE s.name_lower = main.products.name_lower LIMIT 1), iron_mg),
vit_a_mcg = COALESCE((SELECT s.vit_a_mcg FROM seed.products s WHERE s.name_lower = main.products.name_lower LIMIT 1), vit_a_mcg),
vit_b1_mg = COALESCE((SELECT s.vit_b1_mg FROM seed.products s WHERE s.name_lower = main.products.name_lower LIMIT 1), vit_b1_mg),
vit_b2_mg = COALESCE((SELECT s.vit_b2_mg FROM seed.products s WHERE s.name_lower = main.products.name_lower LIMIT 1), vit_b2_mg),
vit_b3_mg = COALESCE((SELECT s.vit_b3_mg FROM seed.products s WHERE s.name_lower = main.products.name_lower LIMIT 1), vit_b3_mg),
vit_c_mg = COALESCE((SELECT s.vit_c_mg FROM seed.products s WHERE s.name_lower = main.products.name_lower LIMIT 1), vit_c_mg),
vit_e_mg = COALESCE((SELECT s.vit_e_mg FROM seed.products s WHERE s.name_lower = main.products.name_lower LIMIT 1), vit_e_mg),
carotene_mcg = COALESCE((SELECT s.carotene_mcg FROM seed.products s WHERE s.name_lower = main.products.name_lower LIMIT 1), carotene_mcg)
WHERE (main.products.user_edited IS NULL OR main.products.user_edited = 0)
AND main.products.source IN ('magnit', '5ka', 'kdv', 'ion')
AND main.products.name_lower IN (SELECT s2.name_lower FROM seed.products s2)"
);
// Update seed version AFTER all inserts+updates succeed
main_db.execute(
"INSERT OR REPLACE INTO profile (key, value) VALUES ('seed_version', ?1)",
[seed_version.to_string()],
).map_err(|e| e.to_string())?;
main_db.execute("COMMIT", []).map_err(|e| e.to_string())?;
let _ = main_db.execute("DETACH DATABASE seed", []);
Ok(format!("imported:{}:{}", inserted, total))
}
#[derive(Serialize)]
struct SafeInsets {
top: i32,
bottom: i32,
left: i32,
right: i32,
}
#[cfg(target_os = "android")]
#[tauri::command]
fn get_safe_insets(app: tauri::AppHandle) -> SafeInsets {
let data_dir = app.path().app_data_dir().unwrap_or_default();
let insets_file = data_dir.join("safe_insets.json");
for _ in 0..10 {
if let Ok(content) = std::fs::read_to_string(&insets_file) {
if let Ok(insets) = serde_json::from_str::<serde_json::Value>(&content) {
return SafeInsets {
top: insets["top"].as_i64().unwrap_or(0) as i32,
bottom: insets["bottom"].as_i64().unwrap_or(0) as i32,
left: insets["left"].as_i64().unwrap_or(0) as i32,
right: insets["right"].as_i64().unwrap_or(0) as i32,
};
}
}
std::thread::sleep(std::time::Duration::from_millis(50));
}
SafeInsets { top: 0, bottom: 0, left: 0, right: 0 }
}
#[cfg(not(target_os = "android"))]
#[tauri::command]
fn get_safe_insets() -> SafeInsets {
SafeInsets { top: 0, bottom: 0, left: 0, right: 0 }
}
#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
let migrations: Vec<Migration> = vec![
Migration {
version: 1,
description: "full schema v1",
sql: r#"
PRAGMA foreign_keys = ON;
CREATE TABLE IF NOT EXISTS profile (
key TEXT PRIMARY KEY,
value TEXT
);
CREATE TABLE IF NOT EXISTS products (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
brand TEXT,
category TEXT,
weight_g REAL,
kcal_per_100g REAL,
protein_per_100g REAL,
fat_per_100g REAL,
carbs_per_100g REAL,
fiber_per_100g REAL,
vit_a_mcg REAL,
vit_c_mg REAL,
vit_d_mcg REAL,
vit_e_mg REAL,
vit_k_mcg REAL,
vit_b1_mg REAL,
vit_b2_mg REAL,
vit_b3_mg REAL,
vit_b6_mg REAL,
vit_b12_mcg REAL,
folate_mcg REAL,
calcium_mg REAL,
iron_mg REAL,
magnesium_mg REAL,
zinc_mg REAL,
copper_mg REAL,
selenium_mcg REAL,
potassium_mg REAL,
sodium_mg REAL,
source TEXT,
store_id TEXT,
image_path TEXT,
created_at TEXT DEFAULT (datetime('now','localtime'))
);
CREATE TABLE IF NOT EXISTS supplements (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
daily_dose_g REAL,
vit_a_mcg REAL,
vit_c_mg REAL,
vit_d_mcg REAL,
vit_e_mg REAL,
vit_k_mcg REAL,
vit_b1_mg REAL,
vit_b2_mg REAL,
vit_b3_mg REAL,
vit_b6_mg REAL,
vit_b12_mcg REAL,
folate_mcg REAL,
calcium_mg REAL,
iron_mg REAL,
magnesium_mg REAL,
zinc_mg REAL,
copper_mg REAL,
selenium_mcg REAL,
potassium_mg REAL,
sodium_mg REAL
);
CREATE TABLE IF NOT EXISTS recipes (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
cooking_method TEXT,
cooking_temp_c INTEGER,
servings INTEGER DEFAULT 1,
notes TEXT
);
CREATE TABLE IF NOT EXISTS recipe_ingredients (
id INTEGER PRIMARY KEY,
recipe_id INTEGER NOT NULL REFERENCES recipes(id) ON DELETE CASCADE,
product_id INTEGER NOT NULL REFERENCES products(id),
amount_g REAL NOT NULL
);
CREATE TABLE IF NOT EXISTS weight_log (
id INTEGER PRIMARY KEY,
date TEXT NOT NULL,
time TEXT,
weight_kg REAL NOT NULL
);
CREATE TABLE IF NOT EXISTS sleep_log (
id INTEGER PRIMARY KEY,
date TEXT NOT NULL,
bed_time TEXT,
asleep_time TEXT,
wake_time TEXT,
nap_minutes INTEGER DEFAULT 0,
notes TEXT
);
CREATE TABLE IF NOT EXISTS food_log (
id INTEGER PRIMARY KEY,
date TEXT NOT NULL,
time TEXT,
product_id INTEGER REFERENCES products(id),
recipe_id INTEGER REFERENCES recipes(id),
amount_g REAL NOT NULL,
kcal REAL,
protein_g REAL,
fat_g REAL,
carbs_g REAL,
fiber_g REAL,
note TEXT
);
CREATE TABLE IF NOT EXISTS supplement_log (
id INTEGER PRIMARY KEY,
date TEXT NOT NULL,
time TEXT,
supplement_id INTEGER NOT NULL REFERENCES supplements(id),
dose_g REAL
);
CREATE TABLE IF NOT EXISTS gps_sessions (
id INTEGER PRIMARY KEY,
date TEXT NOT NULL,
start_time TEXT,
end_time TEXT,
activity_type TEXT,
total_distance_m REAL,
total_kcal REAL,
avg_speed_kmh REAL,
max_speed_kmh REAL,
elevation_gain_m REAL,
elevation_loss_m REAL,
source TEXT
);
CREATE TABLE IF NOT EXISTS gps_points (
id INTEGER PRIMARY KEY,
session_id INTEGER NOT NULL REFERENCES gps_sessions(id) ON DELETE CASCADE,
ts TEXT NOT NULL,
lat REAL NOT NULL,
lon REAL NOT NULL,
altitude_gps_m REAL,
altitude_srtm_m REAL,
speed_ms REAL,
heart_rate INTEGER
);
CREATE TABLE IF NOT EXISTS activity_log (
id INTEGER PRIMARY KEY,
date TEXT NOT NULL,
time TEXT,
type TEXT,
desc TEXT,
minutes INTEGER,
kcal REAL,
gps_session_id INTEGER REFERENCES gps_sessions(id)
);
CREATE INDEX IF NOT EXISTS idx_food_log_date ON food_log(date);
CREATE INDEX IF NOT EXISTS idx_activity_log_date ON activity_log(date);
CREATE INDEX IF NOT EXISTS idx_weight_log_date ON weight_log(date);
CREATE INDEX IF NOT EXISTS idx_sleep_log_date ON sleep_log(date);
CREATE INDEX IF NOT EXISTS idx_gps_points_sess ON gps_points(session_id);
CREATE INDEX IF NOT EXISTS idx_products_name ON products(name COLLATE NOCASE);
"#,
kind: MigrationKind::Up,
},
Migration {
version: 2,
description: "add composition column to products",
sql: "ALTER TABLE products ADD COLUMN composition TEXT;",
kind: MigrationKind::Up,
},
Migration {
version: 3,
description: "reserved",
sql: "SELECT 1;",
kind: MigrationKind::Up,
},
];
tauri::Builder::default()
.plugin(
tauri_plugin_sql::Builder::default()
.add_migrations("sqlite:baldav.db", migrations)
.build(),
)
.invoke_handler(tauri::generate_handler![get_safe_insets, import_seed_products, get_app_info, gps_service_command, gps_service_read_points, save_file])
.run(tauri::generate_context!())
.expect("error while running tauri application");
}
Reference in a new issue View git blame Copy permalink