sergeant 0.8.1

Sergeant is a terminal based Twitch chat widget and bot in one. It will display the Twitch chat from your channel in terminal while also allowing you to add chat bot commands.
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

use std::{str::FromStr, sync::Arc};

use crate::{
    eventsub::structs::{Subscription, Transport},
    twitch::{api::get_user, pubsub::send_to_error_log},
};

use super::{structs::Condition, Message, Session};

const SUBSCRIPTIONS: &str = "https://api.twitch.tv/helix/eventsub/subscriptions";

pub const CHAT_CLEAR_USER_MESSAGES: &str = "channel.chat.clear_user_messages";
pub const CHANNEL_AD_BREAK_BEGIN: &str = "channel.ad_break.begin";
pub const CHANNEL_CHAT_NOTIFICATION: &str = "channel.chat.notification";

fn request_subscription(
    r#type: String,
    condition: Condition,
    message: &Message,
    oauth_token: Arc<String>,
    client_id: Arc<String>,
) {
    if let Some(Session { id: session_id, .. }) = &message.payload.session {
        let subscription = Subscription {
            r#type,
            condition,
            version: "1".to_string(),
            transport: Transport {
                method: "websocket".to_string(),
                session_id: session_id.to_string(),
            },
            status: None,
            created_at: None,
        };

        let subscription_result = ureq::post(SUBSCRIPTIONS)
            .set(
                "Authorization",
                format!("Bearer {}", &oauth_token.replace("oauth:", "")).as_str(),
            )
            .set("Client-Id", &client_id)
            .set("Content-Type", "application/json")
            .send_json(subscription);

        dbg!(&subscription_result);

        if let Err(error) = subscription_result {
            send_to_error_log("Subscription Error:".to_string(), error.to_string());
        }
    }
}

pub fn channel_ad_break_begin(message: &Message, oauth_token: Arc<String>, client_id: Arc<String>) {
    if let Ok(user) = get_user(&oauth_token, &client_id) {
        let condition = Condition {
            broadcaster_user_id: Some(user.id),
            moderator_user_id: None,
            user_id: None,
        };

        request_subscription(
            String::from_str(CHANNEL_AD_BREAK_BEGIN).unwrap(),
            condition,
            message,
            oauth_token,
            client_id,
        );
    }
}

pub fn channel_chat_clear_user_messages(message: &Message, oauth_token: Arc<String>, client_id: Arc<String>) {
    if let Ok(user) = get_user(&oauth_token, &client_id) {
        let condition = Condition {
            broadcaster_user_id: Some(user.id.clone()),
            moderator_user_id: None,
            user_id: Some(user.id),
        };

        request_subscription(
            String::from_str(CHAT_CLEAR_USER_MESSAGES).unwrap(),
            condition,
            message,
            oauth_token,
            client_id,
        );
    }
}

pub fn channel_chat_notification(message: &Message, oauth_token: Arc<String>, client_id: Arc<String>) {
    if let Ok(user) = get_user(&oauth_token, &client_id) {
        let condition = Condition {
            broadcaster_user_id: Some(user.id.clone()),
            moderator_user_id: None,
            user_id: Some(user.id),
        };

        request_subscription(
            String::from_str(CHANNEL_CHAT_NOTIFICATION).unwrap(),
            condition,
            message,
            oauth_token,
            client_id,
        );
    }
}