pokemon-data-displayer/src-tauri/src/main.rs

#![cfg_attr(
  all(not(debug_assertions), target_os = "windows"),
  windows_subsystem = "windows"
)]
use std::collections::HashMap;
use std::fs;

use serde_json::json;
use wana_kana::to_hiragana::*;
use wana_kana::to_katakana::*;
mod model;
use model::*;
use wfd::DialogParams;

#[tauri::command]
fn autosearch_move(keyword: &str) -> serde_json::Value {
  let connection = sqlite::open("./pokemon.db").unwrap();
  let query = "SELECT * FROM learnset WHERE name like ? or name like ? or name like ? LIMIT 5";
  let mut result: Vec<Autosearch> = vec![];
  let aste_keyword = format!("%{}%", keyword.to_lowercase());
  let katakana = format!("%{}%", to_katakana(keyword));
  let hiragana = format!("%{}%", to_hiragana(keyword));
  println!("{} - {}", katakana, hiragana);
  for row in connection
    .prepare(query)
    .unwrap()
    .into_iter()
    .bind((1, aste_keyword.as_str()))
    .unwrap()
    .bind((2, katakana.as_str()))
    .unwrap()
    .bind((3, hiragana.as_str()))
    .unwrap()
    .map(|row| row.unwrap())
  {
    let row_result = Autosearch {
      id: row.read::<i64, _>("id"),
      name: format!("{}", row.read::<&str, _>("name").to_string()),
    };
    result.push(row_result);
  }
  println!("{:?}", result);
  serde_json::to_value(result).unwrap_or(serde_json::json!("[]"))
}

#[tauri::command]
fn save_json(json_content: Vec<Option<PokemonDataToSave>>) -> Result<(), String> {
  let params = DialogParams {
    title: "Select a file to save",
    file_types: vec![("JSON File", "*.json")],
    file_name: "team.json",
    default_extension: "json",
    ..Default::default()
  };
  match wfd::save_dialog(params) {
    Ok(r) => {
      let result = fs::write(r.selected_file_path, serde_json::to_string_pretty(&json_content).unwrap());
      if let Err(e) = result {
        Err(format!("Error: {e:?}"))
      } else {
        Ok(())
      }
    }
    Err(e) => {
      Err(format!("Error: {e:?}"))
    }
  }
}
#[tauri::command]
fn load_json() -> Result<serde_json::Value, String> {
  let params = DialogParams {
    title: "Select a file to load",
    file_types: vec![("JSON File", "*.json")],
    default_extension: "json",
    ..Default::default()
  };
  match wfd::open_dialog(params) {
    Ok(r) => {
      let file_content_string = fs::read_to_string(r.selected_file_path);
      if let Err(e) = file_content_string {
        return Err(format!("Error: {e:?}"))
      }
      match serde_json::from_str::<Vec<PokemonDataToSave>>(&file_content_string.unwrap()) {
        Ok(c) => {
          let mut result: Vec<PokemonDataToLoad> = vec![];
          for d in c {
            let pokemon_data = search(d.id);
            let pokemon_data_to_load = PokemonDataToLoad::from((d, pokemon_data));
            result.push(pokemon_data_to_load);
          }
          if result.len() > 0 {
            Ok(serde_json::to_value(result).unwrap())
          } else {
            Err("Unable to load pokemon data.".to_string())
          }
        },
        Err(e) => Err(format!("Error: {e:?}")),
      }
    }
    Err(e) => {
      Err(format!("Error: {e:?}"))
    }
  }
}
#[tauri::command]
fn autosearch(keyword: &str) -> serde_json::Value {
  let connection = sqlite::open("./pokemon.db").unwrap();
  let query = "SELECT * FROM pokemon WHERE name like ? or name like ? LIMIT 5";
  let mut result: Vec<Autosearch> = vec![];
  let aste_keyword = format!("%{}%", keyword.to_lowercase());
  let katakana = format!("%{}%", to_katakana(keyword));
  println!("{}", katakana);
  for row in connection
    .prepare(query)
    .unwrap()
    .into_iter()
    .bind((1, aste_keyword.as_str()))
    .unwrap()
    .bind((2, katakana.as_str()))
    .unwrap()
    .map(|row| row.unwrap())
  {
    let row_result = Autosearch {
      id: row.read::<i64, _>("id"),
      name: format!("{}", row.read::<&str, _>("name").to_string()),
    };
    result.push(row_result);
  }
  println!("{:?}", result);
  serde_json::to_value(result).unwrap_or(serde_json::json!("[]"))
}
#[tauri::command]
fn search_move(index: i64) -> MoveSearchResult {
  let connection = sqlite::open("./pokemon.db").unwrap();
  let query = "SELECT * FROM learnset WHERE id = ?";
  for row in connection
    .prepare(query)
    .unwrap()
    .into_iter()
    .bind((1, index))
    .unwrap()
    .map(|row| row.unwrap())
  {
    let row_result = MoveSearchResult {
      id: row.read::<i64, _>("id"),
      name: row.read::<&str, _>("name").to_string(),
      types: serde_json::from_str(row.read::<&str, _>("types")).unwrap_or(vec![0]),
      power: row.read::<i64, _>("power"),
      category: row.read::<i64, _>("category"),
      priority: row.read::<i64, _>("priority"),
      condition: match row.read::<Option<&str>, _>("condition") {
        Some(t) => Some(t.to_string()),
        _ => None,
      },
    };
    return row_result;
  }
  return MoveSearchResult {
    id: 0,
    name: "Wrong".to_string(),
    types: vec![0],
    power: 0,
    category: 0,
    priority: 0,
    condition: None,
  };
}
#[tauri::command]
fn get_items() -> Vec<ItemSearchResult> {
  let connection = sqlite::open("./pokemon.db").unwrap();
  let query = "SELECT * FROM item WHERE 1";
  let mut items: Vec<ItemSearchResult> = vec![];
  for row in connection
    .prepare(query)
    .unwrap()
    .into_iter()
    .map(|row| row.unwrap())
  {
    let row_result = ItemSearchResult {
      id: row.read::<i64, _>("id"),
      name: row.read::<&str, _>("name").to_string(),
      image: row.read::<&str, _>("image").to_string(),
      effect: match row.read::<Option<&str>, _>("effect") {
        Some(t) => Some(serde_json::from_str(t).unwrap_or(json!({}))),
        _ => None,
      },
    };
    items.push(row_result);
  }
  return items;
}

#[tauri::command]
fn increase_attack_usage(index: i64) {
  println!("update index: {index}");
  let connection = sqlite::open("./pokemon.db").unwrap();
  let query = format!("UPDATE pokemon__learnset SET usage = usage + 1 WHERE id = {index}");
  connection.execute(query).unwrap();
}

#[tauri::command]
fn search_learnset(index: i64) -> Vec<PokemonDataLearnset> {
  let connection = sqlite::open("./pokemon.db").unwrap();
  let mut learnset: Vec<PokemonDataLearnset> = vec![];
  let move_query = "SELECT pl.id, pl.learnset_id, l.name, l.types, l.power, l.category FROM pokemon__learnset pl JOIN learnset l on pl.learnset_id = l.id WHERE pl.pokemon_id = ? ORDER BY usage DESC";
  for row in connection
    .prepare(move_query)
    .unwrap()
    .into_iter()
    .bind((1, index))
    .unwrap()
    .map(|row| row.unwrap())
  {
    let row_result = PokemonDataLearnset {
      id: row.read::<i64, _>("id"),
      learnset_id: row.read::<i64, _>("learnset_id"),
      name: row.read::<&str, _>("name").to_string(),
      types: serde_json::from_str(row.read::<&str, _>("types")).unwrap_or(vec![0]),
      power: row.read::<i64, _>("power"),
      category: row.read::<i64, _>("category"),
    };
    learnset.push(row_result)
  }
  return learnset;
}
#[tauri::command]
fn search(index: i64) -> SearchResult {
  let connection = sqlite::open("./pokemon.db").unwrap();
  let learnset = search_learnset(index.clone());

  let query = "SELECT * FROM pokemon WHERE id = ?";
  for row in connection
    .prepare(query)
    .unwrap()
    .into_iter()
    .bind((1, index))
    .unwrap()
    .map(|row| row.unwrap())
  {
    let row_result = SearchResult {
      id: row.read::<i64, _>("id"),
      name: row.read::<&str, _>("name").to_string(),
      types: serde_json::from_str(row.read::<&str, _>("types")).unwrap_or(vec![0]),
      thumbnail: row.read::<&str, _>("thumbnail").to_string(),
      abilities: serde_json::from_str(row.read::<&str, _>("abilities")).unwrap_or(HashMap::new()),
      hp: row.read::<i64, _>("hp"),
      attack: row.read::<i64, _>("attack"),
      defense: row.read::<i64, _>("defense"),
      special_attack: row.read::<i64, _>("special_attack"),
      special_defense: row.read::<i64, _>("special_defense"),
      speed: row.read::<i64, _>("speed"),
      learnset: learnset,
    };
    return row_result;
  }
  return SearchResult {
    id: 0,
    name: "Missigno".to_string(),
    types: vec![],
    thumbnail: "".to_string(),
    abilities: HashMap::new(),
    hp: 0,
    attack: 0,
    defense: 0,
    special_attack: 0,
    special_defense: 0,
    speed: 0,
    learnset: vec![],
  };
}
fn main() {
  tauri::Builder::default()
    .invoke_handler(tauri::generate_handler![
      autosearch_move,
      search_move,
      autosearch,
      search,
      get_items,
      increase_attack_usage,
      search_learnset,
      save_json,
      load_json,
    ])
    .run(tauri::generate_context!())
    .expect("error while running tauri application");
}