sockudo-http 2.2.0

A Rust client for interacting with the Sockudo HTTP API
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

use serde::Deserialize;
use sonic_rs::Value;
use std::collections::BTreeMap;

#[derive(Debug, Clone, Default)]
pub struct PresenceHistoryParams {
    pub limit: Option<u32>,
    pub direction: Option<String>,
    pub cursor: Option<String>,
    pub start_serial: Option<u64>,
    pub end_serial: Option<u64>,
    pub start_time_ms: Option<i64>,
    pub end_time_ms: Option<i64>,
    /// Ably-compatible alias for `start_time_ms`
    pub start: Option<i64>,
    /// Ably-compatible alias for `end_time_ms`
    pub end: Option<i64>,
}

impl PresenceHistoryParams {
    pub fn to_map(&self) -> BTreeMap<String, String> {
        let mut params = BTreeMap::new();
        if let Some(limit) = self.limit {
            params.insert("limit".to_string(), limit.to_string());
        }
        if let Some(direction) = self.direction.as_ref() {
            params.insert("direction".to_string(), direction.clone());
        }
        if let Some(cursor) = self.cursor.as_ref() {
            params.insert("cursor".to_string(), cursor.clone());
        }
        if let Some(start_serial) = self.start_serial {
            params.insert("start_serial".to_string(), start_serial.to_string());
        }
        if let Some(end_serial) = self.end_serial {
            params.insert("end_serial".to_string(), end_serial.to_string());
        }
        let start_time = self.start_time_ms.or(self.start);
        if let Some(start_time_ms) = start_time {
            params.insert("start_time_ms".to_string(), start_time_ms.to_string());
        }
        let end_time = self.end_time_ms.or(self.end);
        if let Some(end_time_ms) = end_time {
            params.insert("end_time_ms".to_string(), end_time_ms.to_string());
        }
        params
    }
}

#[derive(Debug, Clone, Default)]
pub struct PresenceSnapshotParams {
    pub at_time_ms: Option<i64>,
    /// Ably-compatible alias for `at_time_ms`
    pub at: Option<i64>,
    pub at_serial: Option<u64>,
}

impl PresenceSnapshotParams {
    pub fn to_map(&self) -> BTreeMap<String, String> {
        let mut params = BTreeMap::new();
        let at_time = self.at_time_ms.or(self.at);
        if let Some(at_time_ms) = at_time {
            params.insert("at_time_ms".to_string(), at_time_ms.to_string());
        }
        if let Some(at_serial) = self.at_serial {
            params.insert("at_serial".to_string(), at_serial.to_string());
        }
        params
    }
}

pub type PresenceHistoryEventKind = String;
pub type PresenceHistoryEventCause = String;

#[derive(Debug, Clone, Deserialize)]
pub struct PresenceHistoryPage {
    pub items: Vec<PresenceHistoryItem>,
    pub direction: String,
    pub limit: usize,
    pub has_more: bool,
    pub next_cursor: Option<String>,
    pub bounds: PresenceHistoryBounds,
    pub continuity: PresenceHistoryContinuity,
}

#[derive(Debug, Clone, Deserialize)]
pub struct PresenceHistoryItem {
    pub stream_id: Option<String>,
    pub serial: Option<u64>,
    pub published_at_ms: Option<i64>,
    pub event: Option<PresenceHistoryEventKind>,
    pub cause: Option<PresenceHistoryEventCause>,
    pub user_id: Option<String>,
    pub connection_id: Option<String>,
    pub dead_node_id: Option<String>,
    pub payload_size_bytes: Option<usize>,
    pub presence_event: Option<Value>,
}

#[derive(Debug, Clone, Deserialize, Default)]
pub struct PresenceHistoryBounds {
    pub start_serial: Option<u64>,
    pub end_serial: Option<u64>,
    pub start_time_ms: Option<i64>,
    pub end_time_ms: Option<i64>,
}

#[derive(Debug, Clone, Deserialize, Default)]
pub struct PresenceHistoryContinuity {
    pub stream_id: Option<String>,
    pub oldest_available_serial: Option<u64>,
    pub newest_available_serial: Option<u64>,
    pub oldest_available_published_at_ms: Option<i64>,
    pub newest_available_published_at_ms: Option<i64>,
    pub retained_events: u64,
    pub retained_bytes: u64,
    pub degraded: bool,
    pub complete: bool,
    pub truncated_by_retention: bool,
}

#[derive(Debug, Clone, Deserialize)]
pub struct PresenceSnapshotMember {
    pub user_id: String,
    pub last_event: PresenceHistoryEventKind,
    pub last_event_serial: u64,
    pub last_event_at_ms: i64,
}

#[derive(Debug, Clone, Deserialize)]
pub struct PresenceSnapshot {
    pub channel: String,
    pub members: Vec<PresenceSnapshotMember>,
    pub member_count: usize,
    pub events_replayed: u64,
    pub snapshot_serial: Option<u64>,
    pub snapshot_time_ms: Option<i64>,
    pub continuity: PresenceHistoryContinuity,
}