Add basic rate conversion

src-tauri/src/lib.rs

@@ -1,15 +1,62 @@
+use std::collections::HashMap as Map;
 // Learn more about Tauri commands at https://tauri.app/v1/guides/features/command
+#[derive(Debug, serde::Deserialize)]
+struct Currency {
+    conversionRate: f32,
+    existingAmount: f32,
+}
+
+#[tauri::command]
+fn calculate_currency_total(selected_currencies: Map<String, Currency>) -> Map<String, f32> {
+    let currencies: Vec<(String, Currency)> = selected_currencies.into_iter().collect();
+    let mut total: Map<String, f32> = Map::new();
+
+    for (key, currency) in &currencies {
+        total.insert(key.clone(), currency.existingAmount);
+    }
+
+    for (key1, currency) in &currencies {
+        for (key2, other_currency) in &currencies {
+            if key1 != key2 {
+                let total_value = (total[key1])
+                    + (other_currency.existingAmount
+                        * (currency.conversionRate / other_currency.conversionRate));
+                total.insert(key1.clone(), total_value);
+            }
+        }
+    }
+
+    return total;
+}
+
 #[tauri::command]
-fn greet(name: &str) -> String {
-    format!("Hello, {}! You've been greeted from Rust!", name)
+fn calculate_exchange_rates(selected_currencies: Map<String, Currency>) -> Map<String, f32> {
+    let currencies: Vec<(String, Currency)> = selected_currencies.into_iter().collect();
+    let mut exchange: Map<String, f32> = Map::new();
+
+    for (key1, currency) in &currencies {
+        for (key2, other_currency) in &currencies {
+            if key1 != key2 {
+                exchange.insert(
+                    format!("{key1}/{key2}"),
+                    other_currency.conversionRate / currency.conversionRate,
+                );
+            }
+        }
+    }
+
+    return exchange;
 }
 
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
     tauri::Builder::default()
         .plugin(tauri_plugin_window::init())
         .plugin(tauri_plugin_shell::init())
-        .invoke_handler(tauri::generate_handler![greet])
+        .invoke_handler(tauri::generate_handler![
+            calculate_currency_total,
+            calculate_exchange_rates
+        ])
         .run(tauri::generate_context!())
         .expect("error while running tauri application");
 }

src/context/CurrencyContext.tsx

@@ -13,7 +13,7 @@ export interface ICurrencyList {
   dict: ICurrency;
 }
 
-interface ICurrency {
+export interface ICurrency {
   [symbol: string]: {
     conversionRate: number;
     existingAmount?: number;

src/pages/Summary.tsx

@@ -1,7 +1,8 @@
 import { useEffect, useState } from "react";
-import { useCurrencyContext } from "../context/CurrencyContext";
+import { ICurrency, useCurrencyContext } from "../context/CurrencyContext";
 import styled from "styled-components";
 import Tabs from "../components/Tabs";
+import { invoke } from "@tauri-apps/api/tauri";
 
 const Wrapper = styled.div(() => ({
   marginLeft: "50px",
@@ -50,36 +51,22 @@ const Summary = () => {
   const { currencies } = useCurrencyContext();
 
   useEffect(() => {
-    const selectedCurrencies = Object.keys(currencies.dict).filter(
-      (currencyCode) => currencies.dict[currencyCode].isSelected
-    );
-
-    const total: { [name: string]: number } = {};
-    const exchange: { [name: string]: number } = {};
-    for (let currency of selectedCurrencies) {
-      total[currency] = currencies.dict[currency].existingAmount || 0;
-    }
-    for (let currency of selectedCurrencies) {
-      for (let otherCurrency of selectedCurrencies) {
-        if (currency !== otherCurrency) {
-          total[currency] =
-            (total[currency] || 0) +
-            (currencies.dict[otherCurrency].existingAmount || 0) *
-              (currencies.dict[currency].conversionRate /
-                currencies.dict[otherCurrency].conversionRate);
-
-          exchange[`${currency}/${otherCurrency}`] =
-            currencies.dict[otherCurrency].conversionRate /
-            currencies.dict[currency].conversionRate;
-          exchange[`${otherCurrency}/${currency}`] =
-            currencies.dict[currency].conversionRate /
-            currencies.dict[otherCurrency].conversionRate;
+    const selectedCurrencies: ICurrency = {};
+    Object.keys(currencies.dict).map(
+      (currencyCode) => {
+        if (currencies.dict[currencyCode].isSelected) {
+          selectedCurrencies[currencyCode] = currencies.dict[currencyCode];
+          selectedCurrencies[currencyCode].existingAmount = selectedCurrencies[currencyCode].existingAmount || 0;
         }
-      }
-    }
-
-    setTotalList({ ...total });
-    setExchangeList({ ...exchange });
+    });
+
+    invoke<{[key: string]: number}>("calculate_currency_total", { selectedCurrencies }).then(total => {
+      setTotalList({...total});
+    }).catch(err => console.error("Problem with calculating total: ", err));
+
+    invoke<{[key: string]: number}>("calculate_exchange_rates", { selectedCurrencies }).then(exchange => {
+      setExchangeList({ ...exchange });
+    }).catch(err => console.error("Problem with calculating exchange rates: ", err));
   }, []);
 
   return (