slackrs 0.3.0

Provides a CLI and library functions to analyze Slack message data exports (zipped JSONs with a Slack-specific structure) and plot statistics.
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use csv::Writer;
use plot::{PlotTask, TimeResolution};
use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
use slack::MessageInChannel;
use std::{io::Error, result::Result};

/// Slack JSON data structures and parsing
pub mod slack;

/// Plotting utilities
pub mod plot;

pub fn process_tasks(tasks: &[PlotTask], messages: &[MessageInChannel]) -> Result<(), Error> {
    tasks.par_iter().for_each(|task| {
        println!("Task: {:?}", task);
        match task.metric {
            plot::Metric::MentionCount {
                ref channel_pattern,
                ref message_pattern,
            } => {
                let message_counts = filter_and_count_messages(
                    &messages,
                    channel_pattern,
                    message_pattern,
                    &task.resolution,
                    &task.msg_output_file_name,
                );
                plot::counter_plot(&task, &message_pattern, &message_counts)
                    .expect("Image generation failed.");
            }
            plot::Metric::StringMessageCountRatio {
                ref channel_pattern,
                ref message_pattern1,
                ref message_pattern2,
            } => {
                let message_counts1 = filter_and_count_messages(
                    &messages,
                    channel_pattern,
                    message_pattern1,
                    &task.resolution,
                    &task.msg_output_file_name,
                );
                let message_counts2 = filter_and_count_messages(
                    &messages,
                    channel_pattern,
                    message_pattern2,
                    &task.resolution,
                    &task.msg_output_file_name,
                );

                plot::ratio_plot(
                    &task,
                    &message_pattern1,
                    &message_counts1,
                    &message_pattern2,
                    &message_counts2,
                )
                .expect("Image generation failed.");
            }
        }
    });
    Ok(())
}

fn filter_and_count_messages(
    messages: &[MessageInChannel],
    channel_pattern: &str,
    message_pattern: &str,
    resolution: &TimeResolution,
    msg_output_file_name: &Option<String>,
) -> Vec<(String, usize)> {
    let messages_to_plot: Vec<&MessageInChannel> = messages
        .iter()
        .filter(|x| x.channel.contains(channel_pattern) && x.message.contains(message_pattern))
        .collect();
    println!(
        "Found {} messages matching '{}'.",
        messages_to_plot.len(),
        message_pattern
    );
    group_messages_by_time_and_write_to_csv(&messages_to_plot, resolution, msg_output_file_name)
}

/// Group messages by `TimeResolution`, count them, optionally export each counted message to a CSV file.
fn group_messages_by_time_and_write_to_csv(
    messages_to_plot: &Vec<&MessageInChannel>,
    resolution: &TimeResolution,
    msg_output_file_name: &Option<String>,
) -> Vec<(String, usize)> {
    let mut message_counts: Vec<(String, usize)> = Vec::new();
    let mut last_count: usize = 0;
    let mut last_label: String = "".to_string();
    let mut msg_writer_opt: Option<Writer<std::fs::File>> =
        if let Some(file_name) = msg_output_file_name {
            Some(Writer::from_path(file_name).unwrap())
        } else {
            None
        };
    #[cfg(debug_assertions)]
    dbg!(format!(
        "Writing messages to '{}'.",
        if let Some(file_name) = msg_output_file_name {
            file_name
        } else {
            "N/A"
        }
    ));
    for (index, message) in messages_to_plot.iter().enumerate() {
        let time_label = time_by_resolution(message, resolution);
        if index == 0 {
            last_count = 1;
            last_label = time_label.clone();
        } else if time_label == last_label {
            last_count += 1;
        }
        if time_label != last_label {
            message_counts.push((last_label.clone(), last_count));
            last_count = 1;
            last_label = time_label.clone();
        }
        if index == messages_to_plot.len() - 1 {
            message_counts.push((last_label.clone(), last_count));
        }

        if let Some(ref mut writer) = msg_writer_opt {
            writer
                .serialize((time_label.clone(), message.message.text.clone()))
                .unwrap();
        }
    }

    if let Some(ref mut writer) = msg_writer_opt {
        writer.flush().unwrap();
    }
    message_counts
}

/// Convert the message time to a string based on the `TimeResolution`.
fn time_by_resolution(msg: &MessageInChannel, resolution: &TimeResolution) -> String {
    return match resolution {
        TimeResolution::Daily => msg.message.time().format("%Y-%m-%d").to_string(),
        TimeResolution::Monthly => msg.message.time().format("%Y-%m").to_string(),
        TimeResolution::Yearly => msg.message.time().format("%Y").to_string(),
    };
}