510 lines
23 KiB
Rust
510 lines
23 KiB
Rust
#[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();
|
|
// tauri-plugin-sql stores DB in different locations depending on platform.
|
|
// Android: often in app root (/data/user/0/pkg/baldav.db), not in files/ subdir.
|
|
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");
|
|
// Android app root: THREE levels up from app_data_dir (files/dev.baldav.app/ → files/ → root/)
|
|
let p_root = data_dir.join("..").join("..").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 if p_root.exists() { p_root }
|
|
else { p_data }
|
|
};
|
|
let main_db = rusqlite::Connection::open(&main_path).map_err(|e| e.to_string())?;
|
|
|
|
// Ensure all columns exist in main DB
|
|
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), []);
|
|
}
|
|
|
|
// Dedup ALWAYS runs (even if seed version matches) — fixes legacy duplicates.
|
|
// Fast: <0.2s with index. No-op if no dupes exist.
|
|
let _ = main_db.execute(
|
|
"CREATE INDEX IF NOT EXISTS idx_products_name_lower ON products(name_lower)", []);
|
|
|
|
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))?;
|
|
|
|
let _ = 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", []);
|
|
|
|
// Check seed version — skip import if already up to date
|
|
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));
|
|
}
|
|
|
|
// ATTACH seed DB for import
|
|
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())?;
|
|
|
|
let total: usize = seed_db.query_row("SELECT COUNT(*) FROM products", [], |r| r.get(0))
|
|
.map_err(|e| e.to_string())?;
|
|
|
|
main_db.execute("BEGIN", []).map_err(|e| e.to_string())?;
|
|
|
|
// 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");
|
|
}
|