Add MoM and YoY on summary page

src/activity_page/activity_ui.rs

@@ -180,10 +180,10 @@ pub fn activity_ui(
         }
     }
 
-    if let Some(index) = table_data.state.selected() {
-        if index > 10 {
-            *table_data.state.offset_mut() = index - 10;
-        }
+    if let Some(index) = table_data.state.selected()
+        && index > 10
+    {
+        *table_data.state.offset_mut() = index - 10;
     }
 
     f.render_widget(year_tab, chunks[0]);

src/home_page/home_ui.rs

@@ -223,10 +223,10 @@ pub fn home_ui(
     }
 
     // Always keep some items rendered on the upper side of the table
-    if let Some(index) = table.state.selected() {
-        if index > 10 {
-            *table.state.offset_mut() = index - 10;
-        }
+    if let Some(index) = table.state.selected()
+        && index > 10
+    {
+        *table.state.offset_mut() = index - 10;
     }
 
     // After all data is in place, render the widgets one by one

src/key_checker/key_handler.rs

@@ -4,6 +4,7 @@ use std::collections::HashMap;
 
 use crate::activity_page::ActivityData;
 use crate::chart_page::ChartData;
+use crate::db::MONTHS;
 use crate::home_page::TransactionData;
 use crate::outputs::TxType;
 use crate::outputs::{HandlingOutput, TxUpdateError, VerifyingOutput};
@@ -65,6 +66,7 @@ pub struct InputKeyHandler<'a> {
     popup_scroll_position: &'a mut usize,
     max_popup_scroll: &'a mut usize,
     lerp_state: &'a mut LerpState,
+    last_summary_data: &'a mut Option<Vec<Vec<String>>>,
     conn: &'a mut Connection,
 }
 
@@ -113,6 +115,7 @@ impl<'a> InputKeyHandler<'a> {
         popup_scroll_position: &'a mut usize,
         max_popup_scroll: &'a mut usize,
         lerp_state: &'a mut LerpState,
+        last_summary_data: &'a mut Option<Vec<Vec<String>>>,
         conn: &'a mut Connection,
     ) -> InputKeyHandler<'a> {
         let total_tags = summary_data
@@ -162,6 +165,7 @@ impl<'a> InputKeyHandler<'a> {
             popup_scroll_position,
             max_popup_scroll,
             lerp_state,
+            last_summary_data,
             conn,
         }
     }
@@ -798,24 +802,103 @@ impl<'a> InputKeyHandler<'a> {
     pub fn change_summary_sort(&mut self) {
         *self.summary_sort = self.summary_sort.next_type();
         let summary_data = self.summary_table.items.clone();
-        let sorted_data = sort_table_data(summary_data, self.summary_sort);
+        let mut sorted_data = sort_table_data(summary_data, self.summary_sort);
         let selection_status = self.summary_table.state.selected();
-        *self.summary_table = TableData::new(sorted_data);
         self.summary_table.state.select(selection_status);
+
+        let mut summary_tags_map = HashMap::new();
+
+        let previous_indexes = match self.summary_modes.index {
+            0 => {
+                if self.summary_months.index > 0 {
+                    Some((self.summary_months.index - 1, self.summary_years.index))
+                } else if self.summary_months.index == 0 && self.summary_years.index > 0 {
+                    Some((self.summary_years.index - 1, MONTHS.len() - 1))
+                } else {
+                    None
+                }
+            }
+            1 => {
+                if self.summary_years.index > 0 {
+                    Some((self.summary_months.index, self.summary_years.index - 1))
+                } else {
+                    None
+                }
+            }
+            _ => None,
+        };
+
+        if let Some((month, year)) = previous_indexes {
+            let (_, _, _, method_data) =
+                self.summary_data
+                    .get_tx_data(self.summary_modes, month, year, &None, self.conn);
+
+            *self.last_summary_data = Some(method_data);
+
+            let tag_data = self
+                .summary_data
+                .get_table_data(self.summary_modes, month, year);
+
+            for tag in tag_data {
+                let tag_name = tag[0].clone();
+                let tag_income = tag[1].parse::<f64>().unwrap();
+                let tag_expense = tag[2].parse::<f64>().unwrap();
+
+                summary_tags_map.insert(tag_name, (tag_income, tag_expense));
+            }
+        }
+
+        for data in &mut sorted_data {
+            let tag_name = &data[0];
+            let mut to_push = Vec::new();
+
+            if let Some((last_earning, last_expense)) = summary_tags_map.get(tag_name) {
+                let current_earning = data[1].parse::<f64>().unwrap();
+                let current_expense = data[2].parse::<f64>().unwrap();
+
+                let earning_increased_percentage =
+                    ((current_earning - last_earning) / last_earning) * 100.0;
+
+                if last_earning == &0.0 {
+                    to_push.push("∞".to_string());
+                } else if earning_increased_percentage < 0.0 {
+                    to_push.push(format!("↓{:.2}", earning_increased_percentage.abs()));
+                } else {
+                    to_push.push(format!("↑{earning_increased_percentage:.2}"));
+                }
+
+                let expense_increased_percentage =
+                    ((current_expense - last_expense) / last_expense) * 100.0;
+
+                if last_expense == &0.0 {
+                    to_push.push("∞".to_string());
+                } else if expense_increased_percentage < 0.0 {
+                    to_push.push(format!("↓{:.2}", expense_increased_percentage.abs()));
+                } else {
+                    to_push.push(format!("↑{expense_increased_percentage:.2}"));
+                }
+            } else {
+                to_push.push("∞".to_string());
+                to_push.push("∞".to_string());
+            }
+            data.extend(to_push);
+        }
+
+        *self.summary_table = TableData::new(sorted_data);
     }
 
     /// If Enter is pressed on Summary page while a tag is selected
     /// go to search page and search for it
     #[cfg(not(tarpaulin_include))]
     pub fn search_tag(&mut self) {
-        if let SummaryTab::Table = self.summary_tab {
-            if let Some(index) = self.summary_table.state.selected() {
-                let tag_name = &self.summary_table.items[index][0];
-                let search_param = TxData::custom("", "", "", "", "", "", tag_name, 0);
-                *self.search_data = search_param;
-                self.go_search();
-                self.search_tx();
-            }
+        if let SummaryTab::Table = self.summary_tab
+            && let Some(index) = self.summary_table.state.selected()
+        {
+            let tag_name = &self.summary_table.items[index][0];
+            let search_param = TxData::custom("", "", "", "", "", "", tag_name, 0);
+            *self.search_data = search_param;
+            self.go_search();
+            self.search_tx();
         }
     }
 
@@ -1012,19 +1095,19 @@ impl<'a> InputKeyHandler<'a> {
 
     #[cfg(not(tarpaulin_include))]
     pub fn switch_chart_tx_method_activation(&mut self) {
-        if !*self.chart_hidden_mode {
-            if let ChartTab::TxMethods = self.chart_tab {
-                let selected_index = self.chart_tx_methods.index;
-                let all_tx_methods = get_all_tx_methods_cumulative(self.conn);
-
-                let selected_method = &all_tx_methods[selected_index];
-                let activation_status = self
-                    .chart_activated_methods
-                    .get_mut(selected_method)
-                    .unwrap();
-                *activation_status = !*activation_status;
-                self.lerp_state.clear();
-            }
+        if !*self.chart_hidden_mode
+            && let ChartTab::TxMethods = self.chart_tab
+        {
+            let selected_index = self.chart_tx_methods.index;
+            let all_tx_methods = get_all_tx_methods_cumulative(self.conn);
+
+            let selected_method = &all_tx_methods[selected_index];
+            let activation_status = self
+                .chart_activated_methods
+                .get_mut(selected_method)
+                .unwrap();
+            *activation_status = !*activation_status;
+            self.lerp_state.clear();
         }
     }
 
@@ -1692,14 +1775,92 @@ impl InputKeyHandler<'_> {
     /// Reset summary table data by recreating it from gathered Summary Data
     #[cfg(not(tarpaulin_include))]
     fn reload_summary(&mut self) {
-        let summary_table = self.summary_data.get_table_data(
+        let mut summary_table = self.summary_data.get_table_data(
             self.summary_modes,
             self.summary_months.index,
             self.summary_years.index,
         );
         self.total_tags = summary_table.len();
-        *self.summary_table = TableData::new(summary_table);
         *self.summary_sort = SortingType::ByTags;
+        let mut summary_tags_map = HashMap::new();
+
+        let previous_indexes = match self.summary_modes.index {
+            0 => {
+                if self.summary_months.index > 0 {
+                    Some((self.summary_months.index - 1, self.summary_years.index))
+                } else if self.summary_months.index == 0 && self.summary_years.index > 0 {
+                    Some((self.summary_years.index - 1, MONTHS.len() - 1))
+                } else {
+                    None
+                }
+            }
+            1 => {
+                if self.summary_years.index > 0 {
+                    Some((self.summary_months.index, self.summary_years.index - 1))
+                } else {
+                    None
+                }
+            }
+            _ => None,
+        };
+
+        if let Some((month, year)) = previous_indexes {
+            let (_, _, _, method_data) =
+                self.summary_data
+                    .get_tx_data(self.summary_modes, month, year, &None, self.conn);
+
+            *self.last_summary_data = Some(method_data);
+
+            let tag_data = self
+                .summary_data
+                .get_table_data(self.summary_modes, month, year);
+
+            for tag in tag_data {
+                let tag_name = tag[0].clone();
+                let tag_income = tag[1].parse::<f64>().unwrap();
+                let tag_expense = tag[2].parse::<f64>().unwrap();
+
+                summary_tags_map.insert(tag_name, (tag_income, tag_expense));
+            }
+        }
+
+        for data in &mut summary_table {
+            let tag_name = &data[0];
+            let mut to_push = Vec::new();
+
+            if let Some((last_earning, last_expense)) = summary_tags_map.get(tag_name) {
+                let current_earning = data[1].parse::<f64>().unwrap();
+                let current_expense = data[2].parse::<f64>().unwrap();
+
+                let earning_increased_percentage =
+                    ((current_earning - last_earning) / last_earning) * 100.0;
+
+                if last_earning == &0.0 {
+                    to_push.push("∞".to_string());
+                } else if earning_increased_percentage < 0.0 {
+                    to_push.push(format!("↓{:.2}", earning_increased_percentage.abs()));
+                } else {
+                    to_push.push(format!("↑{earning_increased_percentage:.2}"));
+                }
+
+                let expense_increased_percentage =
+                    ((current_expense - last_expense) / last_expense) * 100.0;
+
+                if last_expense == &0.0 {
+                    to_push.push("∞".to_string());
+                } else if expense_increased_percentage < 0.0 {
+                    to_push.push(format!("↓{:.2}", expense_increased_percentage.abs()));
+                } else {
+                    to_push.push(format!("↑{expense_increased_percentage:.2}"));
+                }
+            } else {
+                to_push.push("∞".to_string());
+                to_push.push("∞".to_string());
+            }
+            data.extend(to_push);
+        }
+
+        *self.summary_table = TableData::new(summary_table);
     }
 
     /// Reload summary data by fetching from the DB

src/page_handler/initializer.rs

@@ -27,16 +27,16 @@ pub fn initialize_app(
 
     let new_version_available = new_version.unwrap_or_default();
     // If is not terminal, try to start a terminal otherwise create an error.txt file with the error message
-    if !atty::is(Stream::Stdout) {
-        if let Err(err) = start_terminal(original_dir.to_str().unwrap()) {
-            let mut error_location = PathBuf::from(&original_dir);
-            error_location.push("Error.txt");
-
-            let mut open = File::create(error_location)?;
-            let to_write = format!("{}\n{}", original_dir.to_str().unwrap(), err);
-            open.write_all(to_write.as_bytes())?;
-            process::exit(1);
-        }
+    if !atty::is(Stream::Stdout)
+        && let Err(err) = start_terminal(original_dir.to_str().unwrap())
+    {
+        let mut error_location = PathBuf::from(&original_dir);
+        error_location.push("Error.txt");
+
+        let mut open = File::create(error_location)?;
+        let to_write = format!("{}\n{}", original_dir.to_str().unwrap(), err);
+        open.write_all(to_write.as_bytes())?;
+        process::exit(1);
     }
 
     // If the location was changed/json file found, change the db directory.

src/page_handler/ui_handler.rs

@@ -131,6 +131,8 @@ pub fn start_app<B: Backend>(
         summary_years.index,
     ));
 
+    let mut last_summary_data = None;
+
     // Data for the Search Page's table
     let mut search_table = TableData::new(Vec::new());
 
@@ -239,6 +241,7 @@ pub fn start_app<B: Backend>(
                         summary_hidden_mode,
                         &summary_sort,
                         &mut lerp_state,
+                        &last_summary_data,
                         conn,
                     ),
                     CurrentUi::Search => search_ui(
@@ -342,6 +345,7 @@ pub fn start_app<B: Backend>(
                 &mut popup_scroll_position,
                 &mut max_popup_scroll,
                 &mut lerp_state,
+                &mut last_summary_data,
                 conn,
             );
 

src/search_page/search_ui.rs

@@ -318,10 +318,10 @@ pub fn search_ui(
         }
     }
 
-    if let Some(index) = search_table.state.selected() {
-        if index > 10 {
-            *search_table.state.offset_mut() = index - 10;
-        }
+    if let Some(index) = search_table.state.selected()
+        && index > 10
+    {
+        *search_table.state.offset_mut() = index - 10;
     }
 
     // Render the previously generated data into an interface