texted 1.2.1

A markdown blog platform that lets you in control of your data
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

use crate::metrics::metric_aggregator::Event;
use crate::metrics::metric_types::EventApi;
use chrono::{DateTime, Duration, Utc};
use serde::Serialize;
use std::collections::HashSet;

#[derive(Debug, Default, PartialEq, Serialize)]
pub struct EventSlot {
    pub key: String,
    pub value: String,
    pub unique_total: u64,
    pub total: u64,
    pub origins: HashSet<String>,
    pub stats_date_start: DateTime<Utc>,
    pub stats_date_end: DateTime<Utc>,
}

impl EventSlot {
    pub fn from_event(event: Event, slot_size: &Duration) -> Self {
        let (stats_date_start, stats_date_end) = get_slot(&event.date_time, slot_size);
        let mut origins = HashSet::<String>::new();
        origins.insert(event.metric_event.origin.clone());

        let (key, value) = Self::get_key_val(&event);

        EventSlot {
            key,
            value,
            unique_total: event.total,
            total: event.total,
            origins,
            stats_date_start,
            stats_date_end,
        }
    }

    pub fn key_from(event: &Event) -> String {
        let (key, value) = Self::get_key_val(&event);
        format!("{}={}", key, value)
    }

    fn get_key_val(event: &Event) -> (String, String) {
        let (key, value) = match &event.metric_event.api {
            EventApi::View(detail) => ("view", detail.post_name.as_str()),
            EventApi::Page(detail) => ("page", detail.page_name.as_str()),
            EventApi::List(detail) => match &detail.tag {
                None => ("list", ""),
                Some(tag) => ("list", tag.as_str()),
            },
            EventApi::Index => ("index", ""),
            EventApi::Rss => ("rss", ""),
        };

        (key.to_string(), value.to_string())
    }
}

/// Return start + end date/time
fn get_slot(date_time: &DateTime<Utc>, slot_size: &Duration) -> (DateTime<Utc>, DateTime<Utc>) {
    // Calculate the start of the time slot
    let slot_size_secs = slot_size.num_seconds();
    let timestamp_seconds = date_time.timestamp();
    let start_timestamp = timestamp_seconds - (timestamp_seconds % slot_size_secs);
    let start = DateTime::<Utc>::from_timestamp(start_timestamp, 0).unwrap();

    // Calculate the end of the time slot
    let end = start + *slot_size;

    (start, end)
}

#[cfg(test)]
mod tests {
    use super::*;
    use chrono::TimeZone;

    #[test]
    fn test_5_second_slot() {
        let timestamp = Utc.with_ymd_and_hms(2024, 11, 4, 9, 12, 2).unwrap();
        let slot_size = Duration::seconds(5);
        let (start, end) = get_slot(&timestamp, &slot_size);
        assert_eq!(start, Utc.with_ymd_and_hms(2024, 11, 4, 9, 12, 0).unwrap());
        assert_eq!(end, Utc.with_ymd_and_hms(2024, 11, 4, 9, 12, 5).unwrap());
    }

    #[test]
    fn test_10_second_slot() {
        let timestamp = Utc.with_ymd_and_hms(2024, 11, 4, 9, 12, 7).unwrap();
        let slot_size = Duration::seconds(10);
        let (start, end) = get_slot(&timestamp, &slot_size);
        assert_eq!(start, Utc.with_ymd_and_hms(2024, 11, 4, 9, 12, 0).unwrap());
        assert_eq!(end, Utc.with_ymd_and_hms(2024, 11, 4, 9, 12, 10).unwrap());
    }

    #[test]
    fn test_15_second_slot() {
        let timestamp = Utc.with_ymd_and_hms(2024, 11, 4, 9, 12, 14).unwrap();
        let slot_size = Duration::seconds(15);
        let (start, end) = get_slot(&timestamp, &slot_size);
        assert_eq!(start, Utc.with_ymd_and_hms(2024, 11, 4, 9, 12, 0).unwrap());
        assert_eq!(end, Utc.with_ymd_and_hms(2024, 11, 4, 9, 12, 15).unwrap());
    }

    #[test]
    fn test_30_second_slot() {
        let timestamp = Utc.with_ymd_and_hms(2024, 11, 4, 9, 12, 25).unwrap();
        let slot_size = Duration::seconds(30);
        let (start, end) = get_slot(&timestamp, &slot_size);
        assert_eq!(start, Utc.with_ymd_and_hms(2024, 11, 4, 9, 12, 0).unwrap());
        assert_eq!(end, Utc.with_ymd_and_hms(2024, 11, 4, 9, 12, 30).unwrap());
    }

    #[test]
    fn test_60_second_slot() {
        let timestamp = Utc.with_ymd_and_hms(2024, 11, 4, 9, 12, 50).unwrap();
        let slot_size = Duration::seconds(60);
        let (start, end) = get_slot(&timestamp, &slot_size);
        assert_eq!(start, Utc.with_ymd_and_hms(2024, 11, 4, 9, 12, 0).unwrap());
        assert_eq!(end, Utc.with_ymd_and_hms(2024, 11, 4, 9, 13, 0).unwrap());
    }
}