whatawhat 0.1.1

Application for monitoring user activity
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

use std::{collections::HashMap, sync::Arc};

use chrono::Duration;

use crate::{
    daemon::storage::entities::UsageIntervalEntity,
    utils::percentage::Percentage,
};

#[derive(Debug)]
pub struct ProcessUsage {
    pub process_name: Arc<str>,
    pub duration: Duration,
}

impl ProcessUsage {
    fn new(process_name: Arc<str>) -> Self {
        Self {
            process_name,
            duration: Duration::zero(),
        }
    }
}

#[derive(Debug)]
pub struct WindowUsage {
    pub process_name: Arc<str>,
    pub window_name: Arc<str>,
    pub duration: Duration,
}

impl WindowUsage {
    pub fn new(process_name: Arc<str>, window_name: Arc<str>) -> Self {
        Self {
            process_name,
            window_name,
            duration: Duration::zero(),
        }
    }
}

/// Returns vector of unique processes with their statistics + computer usage duration
pub fn analyze_processes(
    intervals: Vec<UsageIntervalEntity>,
    min_percentage: Percentage,
    include_afk: bool,
) -> (Vec<ProcessUsage>, Duration) {
    let mut map = HashMap::<Arc<str>, ProcessUsage>::new();

    let mut inactive = ProcessUsage::new("Inactive".into());

    let mut interval_sum = Duration::zero();

    for v in intervals {
        interval_sum += v.duration;
        if v.afk && !include_afk {
            inactive.duration += v.duration
        } else {
            let analysis = map
                .entry(v.process_name.clone())
                .or_insert_with(|| ProcessUsage::new(v.process_name));
            analysis.duration += v.duration;
        }
    }

    let threshold = interval_sum * (*min_percentage as i32) / 100;

    if !inactive.duration.is_zero() {
        map.insert(inactive.process_name.clone(), inactive);
    }

    let mut usages = map
        .into_iter()
        .map(|v| v.1)
        .filter(|v| v.duration > threshold)
        .collect::<Vec<_>>();
    usages.sort_by(|a, b| a.duration.cmp(&b.duration));
    usages.reverse();
    (usages, interval_sum)
}

/// Returns vector of unique windows with their statistics + computer usage duration
pub fn analyze_windows(
    intervals: Vec<UsageIntervalEntity>,
    min_percentage: Percentage,
    include_afk: bool,
) -> (Vec<WindowUsage>, Duration) {
    let mut map = HashMap::<(Arc<str>, Arc<str>), WindowUsage>::new();

    let mut inactive = WindowUsage::new("Inactive".into(), "".into());

    let mut interval_sum = Duration::zero();

    for v in intervals {
        interval_sum += v.duration;
        if v.afk && !include_afk {
            inactive.duration += v.duration
        } else {
            let analysis = map
                .entry((v.process_name.clone(), v.window_name.clone()))
                .or_insert_with(|| WindowUsage::new(v.process_name, v.window_name));
            analysis.duration += v.duration;
        }
    }

    let threshold = interval_sum * (*min_percentage as i32) / 100;

    if !inactive.duration.is_zero() {
        map.insert((inactive.process_name.clone(), inactive.window_name.clone()), inactive);
    }

    let mut usages = map
        .into_iter()
        .map(|v| v.1)
        .filter(|v| v.duration > threshold)
        .collect::<Vec<_>>();
    usages.sort_by(|a, b| a.duration.cmp(&b.duration));
    usages.reverse();
    (usages, interval_sum)
}