facebook-webhook 0.1.2

Facebook - Webhook
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

//! [Official doc](https://developers.facebook.com/docs/graph-api/webhooks/getting-started#verification-requests)

use http::StatusCode;
use serde::Deserialize;

#[derive(Deserialize, Debug, Clone)]
pub struct Query {
    #[serde(rename = "hub.mode")]
    pub mode: String,
    #[serde(rename = "hub.challenge")]
    pub challenge: i64,
    #[serde(rename = "hub.verify_token")]
    pub verify_token: String,
}

pub fn verify(query_str: &str, verify_token: &str) -> Result<Query, VerifyError> {
    let query: Query = serde_qs::from_str(query_str)?;

    verify_with_query(query, verify_token)
}

pub fn verify_with_query(query: Query, verify_token: &str) -> Result<Query, VerifyError> {
    if query.mode != "subscribe" {
        return Err(VerifyError::ModeMismatch);
    }

    if query.verify_token != verify_token {
        return Err(VerifyError::VerifyTokenMismatch);
    }

    Ok(query)
}

#[derive(thiserror::Error, Debug)]
pub enum VerifyError {
    #[error("QueryInvalid {0}")]
    QueryInvalid(#[from] serde_qs::Error),
    #[error("ModeMismatch")]
    ModeMismatch,
    #[error("VerifyTokenMismatch")]
    VerifyTokenMismatch,
}

pub fn pass_back(query_str: &str, verify_token: &str) -> PassBackResponse {
    match serde_qs::from_str(query_str) {
        Ok(query) => pass_back_with_query(query, verify_token),
        Err(err) => PassBackResponse {
            status_code: StatusCode::BAD_REQUEST,
            body: err.to_string(),
        },
    }
}

pub fn pass_back_with_query(query: Query, verify_token: &str) -> PassBackResponse {
    match verify_with_query(query, verify_token) {
        Ok(query) => PassBackResponse {
            status_code: StatusCode::OK,
            body: format!("{}", query.challenge),
        },
        Err(err) => PassBackResponse {
            status_code: StatusCode::BAD_REQUEST,
            body: err.to_string(),
        },
    }
}

#[derive(Debug, Clone)]
pub struct PassBackResponse {
    pub status_code: StatusCode,
    pub body: String,
}

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

    const SAMPLE_QUERY_STR: &str =
        "hub.mode=subscribe&hub.challenge=1158201444&hub.verify_token=meatyhamhock";

    #[test]
    fn test_verify() {
        assert_eq!(
            verify(SAMPLE_QUERY_STR, "meatyhamhock").unwrap().challenge,
            1158201444
        );

        match verify(
            SAMPLE_QUERY_STR
                .replace("hub.mode=", "hub.modexx=")
                .as_str(),
            "meatyhamhock",
        ) {
            Ok(_) => panic!(""),
            Err(VerifyError::QueryInvalid(err)) => {
                assert!(err.to_string().contains("missing field `hub.mode`"))
            }
            Err(err) => panic!("{}", err),
        }

        match verify(
            SAMPLE_QUERY_STR
                .replace("=subscribe&", "=subscribexx&")
                .as_str(),
            "meatyhamhock",
        ) {
            Ok(_) => panic!(""),
            Err(VerifyError::ModeMismatch) => (),
            Err(err) => panic!("{}", err),
        }

        match verify(SAMPLE_QUERY_STR, "FOO") {
            Ok(_) => panic!(""),
            Err(VerifyError::VerifyTokenMismatch) => (),
            Err(err) => panic!("{}", err),
        }
    }

    #[test]
    fn test_pass_back() {
        let res = pass_back(SAMPLE_QUERY_STR, "meatyhamhock");
        assert_eq!(res.status_code, StatusCode::OK);
        assert_eq!(res.body, "1158201444");

        let res = pass_back(SAMPLE_QUERY_STR, "FOO");
        assert_eq!(res.status_code, StatusCode::BAD_REQUEST);
        assert_eq!(res.body, "VerifyTokenMismatch");
    }
}