Allow ActivityWatch to Ignoring / Filtering

aw-client-rust/src/blocking.rs

@@ -1,5 +1,4 @@
 use std::future::Future;
-use std::vec::Vec;
 use std::{collections::HashMap, error::Error};
 
 use chrono::{DateTime, Utc};
@@ -62,6 +61,12 @@ impl AwClient {
         stop: Option<DateTime<Utc>>,
         limit: Option<u64>
     );
+    proxy_method!(
+        query,
+        Vec<serde_json::Value>,
+        query: &str,
+        timeperiods: Vec<(DateTime<Utc>, DateTime<Utc>)>
+    );
     proxy_method!(insert_event, (), bucketname: &str, event: &Event);
     proxy_method!(insert_events, (), bucketname: &str, events: Vec<Event>);
     proxy_method!(

aw-client-rust/src/lib.rs

@@ -7,11 +7,10 @@ extern crate tokio;
 
 pub mod blocking;
 
-use std::vec::Vec;
 use std::{collections::HashMap, error::Error};
 
 use chrono::{DateTime, Utc};
-use serde_json::Map;
+use serde_json::{json, Map};
 
 pub use aw_models::{Bucket, BucketMetadata, Event};
 
@@ -98,6 +97,33 @@ impl AwClient {
         Ok(())
     }
 
+    pub async fn query(
+        &self,
+        query: &str,
+        timeperiods: Vec<(DateTime<Utc>, DateTime<Utc>)>,
+    ) -> Result<Vec<serde_json::Value>, reqwest::Error> {
+        let url = reqwest::Url::parse(format!("{}/api/0/query", self.baseurl).as_str()).unwrap();
+
+        // Format timeperiods as ISO8601 strings, separated by /
+        let timeperiods_str: Vec<String> = timeperiods
+            .iter()
+            .map(|(start, stop)| (start.to_rfc3339(), stop.to_rfc3339()))
+            .map(|(start, stop)| format!("{}/{}", start, stop))
+            .collect();
+
+        // Result is a sequence, one element per timeperiod
+        self.client
+            .post(url)
+            .json(&json!({
+                "query": query.split('\n').collect::<Vec<&str>>(),
+                "timeperiods": timeperiods_str,
+            }))
+            .send()
+            .await?
+            .json()
+            .await
+    }
+
     pub async fn get_events(
         &self,
         bucketname: &str,

aw-client-rust/tests/test.rs

@@ -110,6 +110,22 @@ mod test {
         println!("Events: {events:?}");
         assert!(events[0].duration == Duration::seconds(1));
 
+        // Query
+        let query = format!(
+            "events = query_bucket(\"{}\");
+RETURN = events;",
+            bucket.id
+        );
+        let start: DateTime<Utc> = DateTime::parse_from_rfc3339("1996-12-19T00:00:00-08:00")
+            .unwrap()
+            .into();
+        let end: DateTime<Utc> = DateTime::parse_from_rfc3339("2020-12-19T00:00:00-08:00")
+            .unwrap()
+            .into();
+        let timeperiods = (start, end);
+        let query_result = client.query(&query, vec![timeperiods]).unwrap();
+        println!("Query result: {query_result:?}");
+
         client
             .delete_event(&bucketname, events[0].id.unwrap())
             .unwrap();

aw-datastore/Cargo.toml

@@ -13,7 +13,7 @@ appdirs = "0.2"
 serde = "1.0"
 serde_json = "1.0"
 chrono = { version = "0.4", features = ["serde"] }
-rusqlite = { version = "0.28", features = ["chrono", "serde_json", "bundled"]  }
+rusqlite = { version = "0.30", features = ["chrono", "serde_json", "bundled"]  }
 mpsc_requests = "0.3"
 log = "0.4"
 

aw-datastore/src/datastore.rs

@@ -2,8 +2,6 @@ use std::collections::HashMap;
 
 use chrono::DateTime;
 use chrono::Duration;
-use chrono::NaiveDateTime;
-use chrono::TimeZone;
 use chrono::Utc;
 
 use rusqlite::Connection;
@@ -173,6 +171,8 @@ fn _migrate_v3_to_v4(conn: &Connection) {
 
 pub struct DatastoreInstance {
     buckets_cache: HashMap<String, Bucket>,
+    ignored_apps: Vec<String>,
+    ignored_titles: Vec<String>,
     first_init: bool,
     pub db_version: i32,
 }
@@ -201,13 +201,57 @@ impl DatastoreInstance {
 
         let mut ds = DatastoreInstance {
             buckets_cache: HashMap::new(),
+            ignored_apps: vec![],
+            ignored_titles: vec![],
             first_init,
             db_version,
         };
         ds.get_stored_buckets(conn)?;
+        ds.get_stored_ignores(conn)?;
         Ok(ds)
     }
 
+    fn get_stored_ignores(&mut self, conn: &Connection) -> Result<(), DatastoreError> {
+        let result = self.get_key_value(conn, "IGNORE_FILTERS_APPS");
+        if result.is_ok() {
+            let unwrapped_key_value = &result.unwrap();
+	    let parts = unwrapped_key_value.split(",");
+	    for part in parts {
+                    self.ignored_apps.push(part.to_uppercase());
+	    }
+
+            /*let apps_exist = unwrapped_key_value.value.get("APPS");
+            if apps_exist.is_some() {
+                let apps = apps_exist.unwrap().as_array().unwrap();
+                for key in apps {
+                    let value = key.as_str().unwrap().to_string();
+                    self.ignored_apps.push(value.to_uppercase());
+                }
+            }*/
+	}
+
+        let result = self.get_key_value(conn, "IGNORE_FILTERS_TITLES");
+        if result.is_ok() {
+            let unwrapped_key_value = &result.unwrap();
+	    let parts = unwrapped_key_value.split(",");
+	    for part in parts {
+                    self.ignored_titles.push(part.to_uppercase());
+	    }
+
+            /* let titles_exist = unwrapped_key_value.value.get("TITLES");
+            if titles_exist.is_some() {
+                let titles = titles_exist.unwrap().as_array().unwrap();
+                for key in titles {
+                    let value = key.as_str().unwrap().to_string();
+                    self.ignored_titles.push(value.to_uppercase());
+                }
+            } */
+
+            info!("Ignoring {} titles & {} apps.", self.ignored_titles.len(), self.ignored_apps.len());
+        }
+        Ok(())
+    }
+
     fn get_stored_buckets(&mut self, conn: &Connection) -> Result<(), DatastoreError> {
         let mut stmt = match conn.prepare(
             "
@@ -233,10 +277,7 @@ impl DatastoreInstance {
                 Some(starttime_ns) => {
                     let seconds: i64 = starttime_ns / 1_000_000_000;
                     let subnanos: u32 = (starttime_ns % 1_000_000_000) as u32;
-                    Some(TimeZone::from_utc_datetime(
-                        &Utc,
-                        &NaiveDateTime::from_timestamp_opt(seconds, subnanos).unwrap(),
-                    ))
+                    Some(DateTime::from_timestamp(seconds, subnanos).unwrap())
                 }
                 None => None,
             };
@@ -246,10 +287,7 @@ impl DatastoreInstance {
                 Some(endtime_ns) => {
                     let seconds: i64 = endtime_ns / 1_000_000_000;
                     let subnanos: u32 = (endtime_ns % 1_000_000_000) as u32;
-                    Some(TimeZone::from_utc_datetime(
-                        &Utc,
-                        &NaiveDateTime::from_timestamp_opt(seconds, subnanos).unwrap(),
-                    ))
+                    Some(DateTime::from_timestamp(seconds, subnanos).unwrap())
                 }
                 None => None,
             };
@@ -450,8 +488,34 @@ impl DatastoreInstance {
                 )))
             }
         };
-        for event in &mut events {
+
+        'event: for event in &mut events {
+            let app = match event.data.get("app") {
+                Some(data) => data.as_str().unwrap().to_string().to_uppercase(),
+                None => String::new()
+            };
+            let title = match event.data.get("title") {
+                Some(data) => data.as_str().unwrap().to_string().to_uppercase(),
+                None => String::new()
+            };
+
+            if !app.is_empty() {
+                for key in self.ignored_apps.iter().cloned() {
+                    if app.contains(&key) {
+                        continue 'event;
+                    }
+                }
+            }
+            if !title.is_empty() {
+                for key in self.ignored_titles.iter().cloned() {
+                    if title.contains(&key) {
+                        continue 'event;
+                    }
+                }
+            }
+
             let starttime_nanos = event.timestamp.timestamp_nanos_opt().unwrap();
+
             let duration_nanos = match event.duration.num_nanoseconds() {
                 Some(nanos) => nanos,
                 None => {
@@ -561,6 +625,26 @@ impl DatastoreInstance {
         bucket_id: &str,
         event: &Event,
     ) -> Result<(), DatastoreError> {
+
+        let app_exists = event.data.get("app");
+        if app_exists.is_some() {
+            let app = app_exists.unwrap().as_str().unwrap().to_string().to_uppercase();
+            for key in self.ignored_apps.iter().cloned() {
+                if app.contains(&key) {
+                    return Ok(());
+                }
+            }
+        }
+        let title_exists = event.data.get("title");
+        if title_exists.is_some() {
+            let title = title_exists.unwrap().as_str().unwrap().to_string().to_uppercase();
+            for key in self.ignored_titles.iter().cloned() {
+                if title.contains(&key) {
+                    return Ok(());
+                }
+            }
+        }
+
         let mut bucket = self.get_bucket(bucket_id)?;
 
         let mut stmt = match conn.prepare(
@@ -689,10 +773,7 @@ impl DatastoreInstance {
 
             Ok(Event {
                 id: Some(id),
-                timestamp: TimeZone::from_utc_datetime(
-                    &Utc,
-                    &NaiveDateTime::from_timestamp_opt(time_seconds, time_subnanos).unwrap(),
-                ),
+                timestamp: DateTime::from_timestamp(time_seconds, time_subnanos).unwrap(),
                 duration: Duration::nanoseconds(duration_ns),
                 data,
             })
@@ -784,10 +865,7 @@ impl DatastoreInstance {
 
                 Ok(Event {
                     id: Some(id),
-                    timestamp: TimeZone::from_utc_datetime(
-                        &Utc,
-                        &NaiveDateTime::from_timestamp_opt(time_seconds, time_subnanos).unwrap(),
-                    ),
+                    timestamp: DateTime::from_timestamp(time_seconds, time_subnanos).unwrap(),
                     duration: Duration::nanoseconds(duration_ns),
                     data,
                 })

aw-query/Cargo.toml

@@ -12,7 +12,7 @@ serde_json = "1.0"
 chrono = { version = "0.4", features = ["serde"] }
 plex = "0.3.0"
 log = "0.4"
-fancy-regex = "0.11.0"
+fancy-regex = "0.12.0"
 aw-datastore = { path = "../aw-datastore" }
 aw-models = { path = "../aw-models" }
 aw-transform = { path = "../aw-transform" }

aw-query/src/datatype.rs

@@ -1,5 +1,4 @@
 use std::collections::HashMap;
-use std::convert::{TryFrom, TryInto};
 use std::fmt;
 
 use super::functions;

aw-query/src/functions.rs

@@ -116,9 +116,6 @@ pub fn fill_env(env: &mut VarEnv) {
 }
 
 mod qfunctions {
-    use std::convert::TryFrom;
-    use std::convert::TryInto;
-
     use aw_datastore::Datastore;
     use aw_models::Event;
     use aw_transform::classify::Rule;

aw-server.service

@@ -14,12 +14,12 @@
 #
 
 [Service]
-Type=simple
+Type=notify
 ExecStart=aw-server
 
 [Unit]
 Description=ActivityWatch Server (Rust implementation)
-Wants=network.target
+After=network.target
 
 [Install]
 WantedBy=default.target

aw-server/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "aw-server"
-version = "0.12.1"
+version = "0.13.1"
 authors = ["Johan Bjäreholt <[email protected]>", "Erik Bjäreholt <[email protected]>"]
 edition = "2021"
 
@@ -14,9 +14,8 @@ name = "aw-server"
 path = "src/main.rs"
 
 [dependencies]
-rocket = { version = "0.5.0-rc.3", features = ["json"] }
-rocket_cors = { version = "0.6.0-alpha2" }
-multipart = { version = "0.18", default-features = false, features = ["server"] }
+rocket = { version = "0.5.0", features = ["json"] }
+rocket_cors = { version = "0.6.0" }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 chrono = { version = "0.4", features = ["serde"] }
@@ -36,6 +35,9 @@ aw-models = { path = "../aw-models" }
 aw-transform = { path = "../aw-transform" }
 aw-query = { path = "../aw-query" }
 
+[target.'cfg(target_os="linux")'.dependencies]
+sd-notify = "0.4.2"
+
 [target.'cfg(all(target_os="linux", target_arch="x86"))'.dependencies]
 jemallocator = "0.5.0"
 

aw-server/build.rs

@@ -20,5 +20,11 @@ fn main() -> Result<(), Box<dyn Error>> {
         );
     }
 
+    // Rebuild if the webui directory changes
+    println!("cargo:rerun-if-env-changed=AW_WEBUI_DIR");
+    if webui_var.is_ok() {
+        println!("cargo:rerun-if-changed={}", webui_var.unwrap());
+    }
+
     Ok(())
 }