implement proxy settings dialog (rules tab)

src/profile/proxy.rs

@@ -4,7 +4,10 @@ mod rule;
 
 use anyhow::Result;
 use database::Database;
-use gtk::gio::{ProxyResolver, SimpleProxyResolver};
+use gtk::{
+    gio::{ProxyResolver, SimpleProxyResolver},
+    glib::DateTime,
+};
 use ignore::Ignore;
 use r2d2::Pool;
 use r2d2_sqlite::SqliteConnectionManager;
@@ -12,6 +15,7 @@ use rule::Rule;
 use std::cell::RefCell;
 
 pub struct Proxy {
+    database: Database,
     ignore: RefCell<Vec<Ignore>>,
     rule: RefCell<Vec<Rule>>,
 }
@@ -44,18 +48,73 @@ impl Proxy {
             let mut b = rule.borrow_mut();
             for r in rules {
                 b.push(Rule {
+                    id: Some(r.id),
+                    time: r.time,
                     is_enabled: r.is_enabled,
+                    priority: r.priority,
                     request: r.request,
                     url: r.url,
                 });
             }
         }
 
-        Ok(Self { ignore, rule })
+        Ok(Self {
+            database,
+            ignore,
+            rule,
+        })
     }
 
     // Actions
 
+    pub fn add_rule(
+        &self,
+        id: Option<i64>,
+        is_enabled: bool,
+        priority: i32,
+        request: String,
+        url: String,
+        time: DateTime,
+    ) {
+        let mut rules = self.rule.borrow_mut();
+        rules.push(Rule {
+            id,
+            time,
+            is_enabled,
+            priority,
+            request,
+            url,
+        }) // @TODO validate?
+    }
+
+    pub fn clear(&self) {
+        self.ignore.borrow_mut().clear();
+        self.rule.borrow_mut().clear();
+    }
+
+    pub fn save(&self) -> Result<()> {
+        let rules = self.rule.take();
+        let mut keep_id = Vec::with_capacity(rules.len());
+        for rule in rules {
+            keep_id.push(self.database.persist_rule(
+                rule.id,
+                rule.time,
+                rule.is_enabled,
+                rule.priority,
+                rule.request,
+                rule.url,
+            )?);
+        }
+        self.database.clean_rules(keep_id)?;
+        Ok(())
+    }
+
+    // Getters
+
+    pub fn rules(&self) -> Vec<Rule> {
+        self.rule.borrow().iter().cloned().collect()
+    }
+
     pub fn matches(&self, request: &str) -> Option<ProxyResolver> {
         for rule in self.rule.borrow().iter().filter(|r| r.is_enabled) {
             if gtk::glib::Regex::match_simple(