Reports feature (Issue #32)

1 files changed, 470 insertions, 0 deletions

diff --git a/src/ui/report.rs b/src/ui/report.rs
new file mode 100644
index 0000000..215aea0
--- /dev/null
+++ b/src/ui/report.rs
@@ -0,0 +1,470 @@
+// Furtherance - Track your time without being tracked
+// Copyright (C) 2022  Ricky Kresslein <rk@lakoliu.com>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+use adw::subclass::prelude::*;
+use gettextrs::*;
+use glib::clone;
+use gtk::subclass::prelude::*;
+use gtk::{glib, prelude::*, CompositeTemplate};
+use chrono::{DateTime, NaiveDate, Local, Duration, Date, Datelike, offset::TimeZone};
+use itertools::Itertools;
+
+use crate::FurtheranceApplication;
+use crate::ui::FurtheranceWindow;
+use crate::database;
+
+mod imp {
+    use super::*;
+    use glib::subclass;
+
+    #[derive(Debug, Default, CompositeTemplate)]
+    #[template(resource = "/com/lakoliu/Furtherance/gtk/report.ui")]
+    pub struct FurReport {
+        #[template_child]
+        pub range_combo: TemplateChild<gtk::ComboBoxText>,
+        #[template_child]
+        pub date_range_box: TemplateChild<gtk::Box>,
+        #[template_child]
+        pub start_date_entry: TemplateChild<gtk::Entry>,
+        #[template_child]
+        pub end_date_entry: TemplateChild<gtk::Entry>,
+        #[template_child]
+        pub format_error: TemplateChild<gtk::Label>,
+        #[template_child]
+        pub start_end_error: TemplateChild<gtk::Label>,
+        #[template_child]
+        pub filter_check: TemplateChild<gtk::CheckButton>,
+        #[template_child]
+        pub filter_box: TemplateChild<gtk::Box>,
+        #[template_child]
+        pub filter_combo: TemplateChild<gtk::ComboBoxText>,
+        #[template_child]
+        pub filter_entry: TemplateChild<gtk::Entry>,
+        #[template_child]
+        pub results_tree: TemplateChild<gtk::TreeView>,
+        #[template_child]
+        pub sort_by_box: TemplateChild<gtk::Box>,
+        #[template_child]
+        pub sort_by_task: TemplateChild<gtk::CheckButton>,
+        #[template_child]
+        pub sort_by_tag: TemplateChild<gtk::CheckButton>,
+        #[template_child]
+        pub refresh_btn: TemplateChild<gtk::Button>,
+    }
+
+    #[glib::object_subclass]
+    impl ObjectSubclass for FurReport {
+        const NAME: &'static str = "FurReport";
+        type ParentType = adw::Window;
+        type Type = super::FurReport;
+
+        fn class_init(klass: &mut Self::Class) {
+            Self::bind_template(klass);
+        }
+
+        fn instance_init(obj: &subclass::InitializingObject<Self>) {
+            obj.init_template();
+        }
+    }
+
+    impl ObjectImpl for FurReport {
+
+        fn constructed(&self, obj: &Self::Type) {
+            obj.setup_widgets();
+            self.parent_constructed(obj);
+        }
+    }
+
+    impl WidgetImpl for FurReport {}
+
+    impl WindowImpl for FurReport {}
+
+    impl AdwWindowImpl for FurReport {}
+}
+
+glib::wrapper! {
+    pub struct FurReport(ObjectSubclass<imp::FurReport>)
+        @extends gtk::Widget, gtk::Window, adw::Window;
+}
+
+impl FurReport {
+    pub fn new() -> Self {
+        let dialog: Self = glib::Object::new(&[]).unwrap();
+
+        let window = FurtheranceWindow::default();
+        dialog.set_transient_for(Some(&window));
+
+        let app = FurtheranceApplication::default();
+        app.add_window(&window);
+
+        dialog
+    }
+
+    pub fn setup_widgets(&self) {
+        let imp = imp::FurReport::from_instance(self);
+
+        imp.range_combo.set_active_id(Some("week_item"));
+        imp.filter_combo.set_active_id(Some("tasks_item"));
+
+        imp.range_combo.connect_changed(clone!(@weak self as this => move |combo|{
+            let imp = imp::FurReport::from_instance(&this);
+            if combo.active_id().unwrap() != "date_range_item" {
+                imp.date_range_box.set_visible(false);
+                this.refresh_report();
+            } else {
+                imp.date_range_box.set_visible(true);
+            }
+        }));
+
+        imp.filter_check.connect_toggled(clone!(@weak self as this => move |_|{
+            let imp = imp::FurReport::from_instance(&this);
+            if imp.filter_box.get_visible() {
+                imp.filter_box.set_visible(false);
+            } else {
+                imp.filter_box.set_visible(true);
+            }
+        }));
+
+        imp.filter_combo.connect_changed(clone!(@weak self as this => move |combo|{
+            let imp = imp::FurReport::from_instance(&this);
+            if combo.active_id().unwrap() == "tasks_item" {
+                imp.filter_entry.set_placeholder_text(Some(&gettext("Task, Task 2")));
+            } else {
+                imp.filter_entry.set_placeholder_text(Some(&gettext("tag, tag 2")));
+            }
+        }));
+
+        imp.refresh_btn.connect_clicked(clone!(@weak self as this => move |_|{
+            this.refresh_report();
+        }));
+
+        let renderer = gtk::CellRendererText::new();
+        let task_column = gtk::TreeViewColumn::with_attributes(&gettext("Task"), &renderer, &[("text", 0)]);
+        task_column.set_expand(true);
+        task_column.set_resizable(true);
+        let duration_column = gtk::TreeViewColumn::with_attributes(&gettext("Duration"), &renderer, &[("text", 1)]);
+        duration_column.set_expand(false);
+        duration_column.set_resizable(true);
+        imp.results_tree.append_column(&task_column);
+        imp.results_tree.append_column(&duration_column);
+        imp.results_tree.set_enable_search(false);
+
+        self.refresh_report();
+    }
+
+    fn refresh_report(&self) {
+        let imp = imp::FurReport::from_instance(self);
+        imp.format_error.set_visible(false);
+        imp.start_end_error.set_visible(false);
+
+        let results_model = gtk::TreeStore::new(&[String::static_type(), String::static_type()]);
+
+        let mut task_list = database::retrieve().unwrap();
+        task_list.reverse();
+
+        // Get date range
+        let active_range = imp.range_combo.active_id().unwrap();
+        let today = Local::today();
+        let range_start_date: Date<Local>;
+        let mut range_end_date = today;
+        if active_range == "week_item" {
+            range_start_date = today - Duration::days(6);
+        } else if active_range == "month_item" {
+            let days_ago = today.day() - 1;
+            range_start_date = today - Duration::days(days_ago.into());
+        } else if active_range == "30_days_item" {
+            range_start_date = today - Duration::days(30);
+        } else if active_range == "six_months_item" {
+            range_start_date = today - Duration::days(180);
+        } else if active_range == "year_item" {
+            range_start_date = today - Duration::days(365);
+        } else {
+            let input_start_date = NaiveDate::parse_from_str(&imp.start_date_entry.text(), "%m/%d/%Y");
+            let input_end_date = NaiveDate::parse_from_str(&imp.end_date_entry.text(), "%m/%d/%Y");
+            // Check if user entered dates properly
+            if let Err(_) = input_start_date {
+                imp.format_error.set_visible(true);
+                results_model.clear();
+                imp.results_tree.set_model(Some(&results_model));
+                return
+            }
+            if let Err(_) = input_end_date {
+                imp.format_error.set_visible(true);
+                results_model.clear();
+                imp.results_tree.set_model(Some(&results_model));
+                return
+            }
+            // Start date cannot be after end date
+            if (input_end_date.unwrap() - input_start_date.unwrap()).num_days() < 0 {
+                imp.start_end_error.set_visible(true);
+                results_model.clear();
+                return
+            }
+            range_start_date = Local.from_local_date(&input_start_date.unwrap()).unwrap();
+            range_end_date = Local.from_local_date(&input_end_date.unwrap()).unwrap();
+        }
+
+        let mut total_time: i64 = 0;
+        let mut tasks_in_range: Vec<(database::Task, i64)> = Vec::new();
+        let mut user_chosen_tags: Vec<String> = Vec::new();
+        let mut only_this_tag = false;
+        for task in task_list {
+            let start = DateTime::parse_from_rfc3339(&task.start_time).unwrap().with_timezone(&Local);
+            let stop = DateTime::parse_from_rfc3339(&task.stop_time).unwrap().with_timezone(&Local);
+            // Check if start time is in date range and if not remove it from task_list
+            let start_date = start.date();
+            if start_date >= range_start_date && start_date <= range_end_date {
+                // Sort by only selected tasks or tags if filter is selected
+                if imp.filter_check.is_active() && !imp.filter_entry.text().trim().is_empty() {
+                    if imp.filter_combo.active_id().unwrap() == "tasks_item" {
+                        // Create a vec of tasks to match from written tasks
+                        let chosen_tasks = imp.filter_entry.text();
+                        let mut split_tasks: Vec<&str> = chosen_tasks.trim().split(",").collect();
+                        // Trim whitespace around each task
+                        split_tasks = split_tasks.iter().map(|x| x.trim()).collect();
+                        // Don't allow empty tasks
+                        split_tasks.retain(|&x| !x.trim().is_empty());
+                        // Handle duplicate tasks
+                        split_tasks = split_tasks.into_iter().unique().collect();
+                        // Lowercase tags
+                        let lower_tasks: Vec<String> = split_tasks.iter().map(|x| x.to_lowercase()).collect();
+
+                        if lower_tasks.contains(&task.task_name.to_lowercase()) {
+                            let duration = stop - start;
+                            let duration = duration.num_seconds();
+                            tasks_in_range.push((task, duration));
+                            total_time += duration;
+                        }
+
+                    } else if imp.filter_combo.active_id().unwrap() == "tags_item" {
+                        // Split user chosen tags
+                        let chosen_tasgs = imp.filter_entry.text();
+                        let mut split_tags: Vec<&str> = chosen_tasgs.trim().split(",").collect();
+                        // Trim whitespace around each tag
+                        split_tags = split_tags.iter().map(|x| x.trim()).collect();
+                        // Don't allow empty tags
+                        split_tags.retain(|&x| !x.trim().is_empty());
+                        // Handle duplicate tags
+                        split_tags = split_tags.into_iter().unique().collect();
+                        // Lowercase tags
+                        user_chosen_tags = split_tags.iter().map(|x| x.to_lowercase()).collect();
+
+                        // Split task's tags
+                        let mut split_tags: Vec<&str> = task.tags.trim().split("#").collect();
+                        // Trim whitespace around each tag
+                        split_tags = split_tags.iter().map(|x| x.trim()).collect();
+
+                        // Only keep tasks that contain the user's chosen tags
+                        split_tags.retain(|&x| user_chosen_tags.contains(&x.to_string()));
+                        if !split_tags.is_empty() {
+                            let duration = stop - start;
+                            let duration = duration.num_seconds();
+                            tasks_in_range.push((task, duration));
+                            total_time += duration;
+                        }
+
+                        only_this_tag = true;
+                    }
+                } else {
+                    let duration = stop - start;
+                    let duration = duration.num_seconds();
+                    tasks_in_range.push((task, duration));
+                    total_time += duration;
+                }
+            }
+        }
+
+        let all_tasks_iter:gtk::TreeIter;
+        if tasks_in_range.is_empty() {
+            all_tasks_iter = results_model.insert_with_values(None,
+                                                                None,
+                                                                &[
+                                                                    (0, &gettext("No Results")),
+                                                                    (1, &"")
+                                                                ]);
+        } else {
+            let total_time_str = FurReport::format_duration(total_time);
+            all_tasks_iter = results_model.insert_with_values(None,
+                                                                    None,
+                                                                    &[
+                                                                        (0, &gettext("All Results")),
+                                                                        (1, &total_time_str)
+                                                                    ]);
+        }
+        // TODO Bold "All Results"
+
+        if imp.sort_by_task.is_active() {
+            let mut tasks_by_name: Vec<Vec<(database::Task, i64)>> = Vec::new();
+            for (task, task_duration) in tasks_in_range {
+                let mut unique = true;
+                for i in 0..tasks_by_name.len() {
+                    let (tbn, _) = &tasks_by_name[i][0];
+                    if tbn.task_name == task.task_name {
+                        tasks_by_name[i].push((task.clone(), task_duration));
+                        unique = false;
+                    }
+                }
+                if unique {
+                    // Add unique task to list for group name
+                    let mut new_name_list: Vec<(database::Task, i64)> = Vec::new();
+                    new_name_list.push((task.clone(), task_duration));
+                    tasks_by_name.push(new_name_list);
+                }
+            }
+
+            let mut sorted_tasks_by_duration: Vec<(String, i64, Vec<(String, i64)>)> = Vec::new();
+            for tbn in tasks_by_name {
+                let mut total_duration: i64 = 0;
+                let mut tags_dur: Vec<(String, i64)> = Vec::new();
+                let task_name = tbn[0].0.task_name.to_string();
+                for tbn_tuple in tbn {
+                    let (task, task_duration) = tbn_tuple;
+                    total_duration += task_duration;
+
+                    let mut split_tags: Vec<&str> = task.tags.split("#").collect();
+                    split_tags = split_tags.iter().map(|x| x.trim()).collect();
+                    split_tags.retain(|&x| !x.trim().is_empty());
+                    if !split_tags.is_empty() {
+                        let mut formatted_tags = split_tags.join(" #");
+                        formatted_tags = format!("#{}", formatted_tags);
+                        let mut unique = true;
+                        for i in 0..tags_dur.len() {
+                            let (tags, dur) = &tags_dur[i];
+                            if tags == &formatted_tags {
+                                let new_dur = dur + task_duration;
+                                tags_dur[i] = (formatted_tags.clone(), new_dur);
+                                unique = false;
+                            }
+                        }
+                        if unique {
+                            tags_dur.push((formatted_tags, task_duration))
+                        }
+                    }
+                }
+
+                // Sort tasks and tags in descending order by duration
+                tags_dur.sort_by_key(|k| k.1);
+                tags_dur.reverse();
+                sorted_tasks_by_duration.push((task_name, total_duration, tags_dur));
+                sorted_tasks_by_duration.sort_by_key(|k| k.1);
+                sorted_tasks_by_duration.reverse();
+            }
+
+            for stbd in sorted_tasks_by_duration {
+                let header_iter = results_model.append(Some(&all_tasks_iter));
+                for (task, task_duration) in stbd.2 {
+                    let _child_iter = results_model.insert_with_values(
+                        Some(&header_iter),
+                        None,
+                        &[(0, &task), (1, &FurReport::format_duration(task_duration))]
+                    );
+                }
+                results_model.set(
+                    &header_iter,
+                    &[(0, &stbd.0), (1, &FurReport::format_duration(stbd.1))]
+                );
+            }
+        } else if imp.sort_by_tag.is_active() {
+            let mut tasks_by_tag: Vec<Vec<(String, database::Task, i64)>> = Vec::new();
+            for (task, task_duration) in tasks_in_range {
+                let mut split_tags: Vec<&str> = task.tags.split("#").collect();
+                // Trim whitespace around each tag
+                split_tags = split_tags.iter().map(|x| x.trim()).collect();
+                for tag in split_tags {
+                    let mut unique = true;
+                    for i in 0..tasks_by_tag.len() {
+                        let (tbt_tag, _, _) = &tasks_by_tag[i][0];
+                        if tbt_tag == tag {
+                            tasks_by_tag[i].push((tag.to_string(), task.clone(), task_duration));
+                            unique = false;
+                        }
+                    }
+                    if unique {
+                        // Add unique task to list for group name
+                        let mut new_name_list: Vec<(String, database::Task, i64)> = Vec::new();
+                        new_name_list.push((tag.to_string(), task.clone(), task_duration));
+                        tasks_by_tag.push(new_name_list);
+                    }
+                }
+            }
+
+            let mut sorted_tasks_by_duration: Vec<(String, i64, Vec<(String, i64)>)> = Vec::new();
+            for tbt in tasks_by_tag {
+                let mut total_duration: i64 = 0;
+                let mut tasks_dur: Vec<(String, i64)> = Vec::new();
+                let tag_name = format!("#{}", tbt[0].0);
+                for tbt_tuple in tbt {
+                    let (_, task, tag_duration) = tbt_tuple;
+                    total_duration += tag_duration;
+
+                    let mut unique = true;
+                    for i in 0..tasks_dur.len() {
+                        let (td_task, dur) = &tasks_dur[i];
+                        if td_task == &task.task_name {
+                            let new_dur = dur + tag_duration;
+                            tasks_dur[i] = (task.task_name.clone(), new_dur);
+                            unique = false;
+                        }
+                    }
+                    if unique {
+                        tasks_dur.push((task.task_name.clone(), tag_duration))
+                    }
+                }
+
+                // Sort tags and tasks in descending order by duration
+                tasks_dur.sort_by_key(|k| k.1);
+                tasks_dur.reverse();
+                sorted_tasks_by_duration.push((tag_name, total_duration, tasks_dur));
+                sorted_tasks_by_duration.sort_by_key(|k| k.1);
+                sorted_tasks_by_duration.reverse();
+            }
+
+            for mut stbd in sorted_tasks_by_duration {
+                if !only_this_tag || (only_this_tag && user_chosen_tags.contains(&stbd.0[1..].to_string())) {
+                    let header_iter = results_model.append(Some(&all_tasks_iter));
+                    for (task, task_duration) in stbd.2 {
+                        let _child_iter = results_model.insert_with_values(
+                            Some(&header_iter),
+                            None,
+                            &[(0, &task), (1, &FurReport::format_duration(task_duration))]
+                        );
+                    }
+                    if stbd.0 == "#" {
+                        stbd.0 = gettext("no tags").to_string();
+                    }
+                    results_model.set(
+                        &header_iter,
+                        &[(0, &stbd.0), (1, &FurReport::format_duration(stbd.1))]
+                    );
+                }
+            }
+        }
+
+        imp.results_tree.set_model(Some(&results_model));
+        // Automatically expand All Tasks row
+        let all_tasks_path = gtk::TreePath::new_first();
+        imp.results_tree.expand_row(&all_tasks_path, false);
+    }
+
+    fn format_duration(total_time: i64) -> String {
+         // Format total time to readable string
+        let h = total_time / 3600;
+        let m = total_time % 3600 / 60;
+        let s = total_time % 60;
+        format!("{:02}:{:02}:{:02}", h, m, s)
+    }
+}
+