feat: home page development started

Author: KrinjMaster

backend/src/scraper/build_dataset.rs

@@ -1,4 +1,4 @@
-use rusqlite::Connection;
+use rusqlite::{params, Connection};
 use std::fs::{self, create_dir_all, File};
 
 use crate::scraper::{
@@ -13,63 +13,198 @@ pub async fn fetch_all_products() -> Result<(), Box<dyn std::error::Error>> {
     // Metro supermarket
     let metro_products = fetch_metro_products().await;
     let metro_file = File::create("src/scraper/results/metro.json")?;
-    let Metro = Supermarket {
+
+    let metro = Supermarket {
         supermarket_name: "Metro".to_string(),
         products: metro_products,
     };
 
-    serde_json::to_writer_pretty(metro_file, &Metro)?;
-    println!("Saved {} products from metro", Metro.products.len());
+    serde_json::to_writer_pretty(metro_file, &metro)?;
+
+    println!("Saved {} products from metro", metro.products.len());
 
     Ok(())
 }
 
 pub fn build_database() -> Result<(), Box<dyn std::error::Error>> {
     let supermarkets = vec!["metro"];
-    let conn = Connection::open("main.db")?;
+
+    let mut conn = Connection::open("main.db")?;
+
+    conn.execute("PRAGMA foreign_keys = ON;", [])?;
+
+    //
+    // Static tables
+    //
 
     conn.execute(
         "
         CREATE TABLE IF NOT EXISTS supermarkets (
-        id TEXT PRIMARY KEY,
-        name TEXT NOT NULL
+            id TEXT PRIMARY KEY,
+            name TEXT NOT NULL
         )
-    ",
+        ",
         [],
     )?;
 
     conn.execute(
         "
         CREATE TABLE IF NOT EXISTS products (
-        id TEXT PRIMARY KEY,
-        name TEXT NOT NULL,
-        source INTEGER NOT NULL,
-        brand TEXT,
-        category TEXT,
-        weight REAL,
-        proteins REAL,
-        fats REAL,
-        carbs REAL,
-        calories REAL,
-        FOREIGN KEY (source) REFERENCES supermarkets (id)
+            id TEXT PRIMARY KEY,
+
+            name TEXT NOT NULL,
+
+            source TEXT NOT NULL,
+
+            brand TEXT,
+
+            source_category TEXT,
+
+            serving_size REAL,
+
+            proteins_per_100g REAL,
+
+            fats_per_100g REAL,
+
+            carbs_per_100g REAL,
+
+            calories_per_100g REAL,
+
+            version INTEGER NOT NULL DEFAULT 1,
+
+            updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+            FOREIGN KEY (source)
+                REFERENCES supermarkets(id)
         )
-    ",
+        ",
         [],
     )?;
 
-    let mut stmt_supermarket = conn.prepare(
+    //
+    // User tables
+    //
+
+    conn.execute(
         "
-        INSERT INTO supermarkets
-        (id, name)
+        CREATE TABLE IF NOT EXISTS food_entries (
+            id TEXT PRIMARY KEY,
+
+            logged_at TEXT NOT NULL,
+
+            logged_day TEXT NOT NULL,
+
+            meal_type TEXT NOT NULL,
+
+            product_id TEXT NOT NULL,
+
+            grams REAL NOT NULL,
+
+            FOREIGN KEY (product_id)
+                REFERENCES products(id)
+        )
+        ",
+        [],
+    )?;
+
+    conn.execute(
+        "
+        CREATE TABLE IF NOT EXISTS weight_entries (
+            id TEXT PRIMARY KEY,
+
+            logged_at TEXT NOT NULL,
+
+            weight REAL NOT NULL
+        )
+        ",
+        [],
+    )?;
+
+    conn.execute(
+        "
+        CREATE TABLE IF NOT EXISTS favorite_products (
+            product_id TEXT PRIMARY KEY,
+
+            FOREIGN KEY (product_id)
+                REFERENCES products(id)
+        )
+        ",
+        [],
+    )?;
+
+    conn.execute(
+        "
+        CREATE TABLE IF NOT EXISTS meal_templates (
+            id TEXT PRIMARY KEY,
+
+            name TEXT NOT NULL
+        )
+        ",
+        [],
+    )?;
+
+    conn.execute(
+        "
+        CREATE TABLE IF NOT EXISTS meal_template_items (
+            meal_template_id TEXT NOT NULL,
+
+            product_id TEXT NOT NULL,
+
+            grams REAL NOT NULL,
+
+            PRIMARY KEY (
+                meal_template_id,
+                product_id
+            ),
+
+            FOREIGN KEY (meal_template_id)
+                REFERENCES meal_templates(id),
+
+            FOREIGN KEY (product_id)
+                REFERENCES products(id)
+        )
+        ",
+        [],
+    )?;
+
+    let tx = conn.transaction()?;
+
+    let mut stmt_supermarket = tx.prepare(
+        "
+        INSERT OR IGNORE INTO supermarkets (
+            id,
+            name
+        )
         VALUES (?1, ?2)
         ",
     )?;
 
-    let mut stmt_product = conn.prepare(
+    let mut stmt_product = tx.prepare(
         "
-        INSERT OR IGNORE INTO products
-        (id, name, source, brand, category, weight, proteins, fats, carbs, calories)
-        VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10)
+        INSERT OR IGNORE INTO products (
+            id,
+            name,
+            source,
+            brand,
+            source_category,
+            serving_size,
+            proteins_per_100g,
+            fats_per_100g,
+            carbs_per_100g,
+            calories_per_100g
+        )
+        VALUES (
+            ?1,
+            ?2,
+            ?3,
+            ?4,
+            ?5,
+            ?6,
+            ?7,
+            ?8,
+            ?9,
+            ?10
+        )
         ",
     )?;
 
@@ -82,33 +217,36 @@ pub fn build_database() -> Result<(), Box<dyn std::error::Error>> {
 
         let supermarket_id = generate_supermarket_id(&supermarket_struct.supermarket_name);
 
-        // first insert supermarket into it's table
-        stmt_supermarket.execute([&supermarket_id, &supermarket_struct.supermarket_name])?;
+        stmt_supermarket.execute(params![supermarket_id, supermarket_struct.supermarket_name])?;
 
         for product in products {
-            // then product itself
             let product_id = generate_product_id(
                 &supermarket_id,
                 &product.name,
                 &product.brand.clone().unwrap_or_default(),
-                &product.weight.unwrap_or(0.0),
+                &product.serving_size.unwrap_or(0.0),
             );
 
-            stmt_product.execute([
-                &product_id,
-                &product.name,
-                &supermarket_id.to_string(),
-                &product.brand.unwrap_or_default(),
-                &product.category,
-                &product.weight.unwrap_or(0.0).to_string(),
-                &product.nutrients.proteins.unwrap_or(0.0).to_string(),
-                &product.nutrients.fats.unwrap_or(0.0).to_string(),
-                &product.nutrients.carbohydrates.unwrap_or(0.0).to_string(),
-                &product.nutrients.calories.unwrap_or(0.0).to_string(),
+            stmt_product.execute(params![
+                product_id,
+                product.name,
+                supermarket_id,
+                product.brand.unwrap_or_default(),
+                product.category,
+                product.serving_size.unwrap_or(0.0),
+                product.nutrients.proteins.unwrap_or(0.0),
+                product.nutrients.fats.unwrap_or(0.0),
+                product.nutrients.carbohydrates.unwrap_or(0.0),
+                product.nutrients.calories.unwrap_or(0.0),
             ])?;
         }
     }
 
+    drop(stmt_product);
+    drop(stmt_supermarket);
+
+    tx.commit()?;
+
     println!("Database initiated from json files!");
 
     Ok(())

backend/src/scraper/models.rs

@@ -30,17 +30,17 @@ pub struct Attribute {
 
 #[derive(Serialize, Deserialize)]
 pub struct Nutrients {
-    pub proteins: Option<f32>,
-    pub fats: Option<f32>,
-    pub carbohydrates: Option<f32>,
-    pub calories: Option<f32>,
+    pub proteins: Option<f64>,
+    pub fats: Option<f64>,
+    pub carbohydrates: Option<f64>,
+    pub calories: Option<f64>,
 }
 
 #[derive(Serialize, Deserialize)]
 pub struct ParsedProduct {
     pub name: String,
     pub brand: Option<String>,
-    pub weight: Option<f32>,
+    pub serving_size: Option<f64>,
     pub category: String,
     pub nutrients: Nutrients,
 }

backend/src/scraper/parser.rs

@@ -6,7 +6,7 @@ pub fn parse_product(
     category: &str,
 ) -> ParsedProduct {
     let mut brand = None;
-    let mut weight = None;
+    let mut serving_size = None;
 
     let mut nutrients = Nutrients {
         proteins: None,
@@ -28,7 +28,7 @@ pub fn parse_product(
 
         match name_attr.as_str() {
             "Бренд" => brand = Some(value),
-            "Вес, объем" => weight = value.parse().ok(),
+            "Вес, объем" => serving_size = value.parse().ok(),
             "Белки, г" => nutrients.proteins = value.parse().ok(),
             "Жиры, г" => nutrients.fats = value.parse().ok(),
             "Углеводы, г" => nutrients.carbohydrates = value.parse().ok(),
@@ -42,7 +42,7 @@ pub fn parse_product(
     ParsedProduct {
         name: name.unwrap_or_else(|| "unknown".to_string()),
         brand,
-        weight,
+        serving_size,
         category: category.to_string(),
         nutrients,
     }

backend/src/scraper/utils.rs

@@ -1,13 +1,12 @@
-use hex::encode;
 use sha2::{Digest, Sha256};
 
-pub fn generate_product_id(source: &str, name: &str, brand: &str, weight: &f32) -> String {
+pub fn generate_product_id(source: &str, name: &str, brand: &str, serving_size: &f64) -> String {
     let input = format!(
         "{}:{}:{}:{}",
         source.to_lowercase(),
         name.to_lowercase(),
         brand.to_lowercase(),
-        weight
+        serving_size
     );
 
     let mut hasher = Sha256::new();

mobile/.env

@@ -1 +0,0 @@
-EXPO_PUBLIC_RESET_STORAGE=True

mobile/app.json

@@ -41,21 +41,7 @@
           }
         }
       ],
-      "expo-sqlite",
-      [
-        "expo-font",
-        {
-          "fonts": ["./assets/fonts/Seenonim.otf"]
-        }
-      ],
-      [
-        "expo-localization",
-        {
-          "supportedLocales": {
-            "ios": ["ru"]
-          }
-        }
-      ]
+      "expo-sqlite"
     ],
     "experiments": {
       "typedRoutes": true,