Merge pull request #24 from fill9120/master

Add Actix-web support

Author: nanato12

Cargo.toml

@@ -14,17 +14,19 @@ categories = ["api-bindings"]
 [features]
 default = []
 rocket_support = ["rocket"]
+actix_support = ["actix-web"]
 
 [dependencies]
-rocket = { version = "0.4", optional = true }
+actix-web = { version = "3", optional = true, default-features = false }
+base64 = "0.9.2"
+bytes = "0.4"
+chrono = "0.4"
+hmac = "0.6.2"
 reqwest = { version = "0.11.0", features = ["blocking", "json"] }
+rocket = { version = "0.4", optional = true }
 serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
 serde_derive = "1.0.97"
-chrono = "0.4"
-bytes = "0.4"
-base64 = "0.9.2"
-hmac = "0.6.2"
+serde_json = "1.0"
 sha2 = "0.7.1"
 
 [dev-dependencies]

examples/echobot_actix_web.rs

@@ -4,59 +4,49 @@ use dotenv::dotenv;
 use std::env;
 
 use line::bot::LineBot;
-use line::events::messages::MessageType as EventMessageType;
+use line::events::messages::MessageType;
 use line::events::{EventType, Events};
 use line::messages::{SendMessageType, TextMessage};
+use line::support::actix_support::Signature;
+use line::webhook::validate_signature;
 
-use actix_web::web::Bytes;
-use actix_web::{post, App, HttpRequest, HttpResponse, HttpServer, Responder};
+use actix_web::{post, web, App, HttpServer, Responder};
 
 #[post("/callback")]
-async fn callback(req: HttpRequest, bytes: Bytes) -> impl Responder {
-    let body: &str = &String::from_utf8(bytes.to_vec()).unwrap();
-    let signature: &str = req
-        .headers()
-        .get("x-line-signature")
-        .unwrap()
-        .to_str()
-        .unwrap();
-
+async fn callback(
+    signature: Signature,
+    data: web::Json<Events>,
+    bytes: web::Bytes,
+) -> impl Responder {
     // Get channel secret and access token by environment variable
     let channel_secret: &str =
-        &env::var("LINE_CHANNEL_RECRET").expect("Failed getting LINE_CHANNEL_RECRET");
+        &env::var("LINE_CHANNEL_SECRET").expect("Failed getting LINE_CHANNEL_SECRET");
     let access_token: &str =
         &env::var("LINE_CHANNEL_ACCESS_TOKEN").expect("Failed getting LINE_CHANNEL_ACCESS_TOKEN");
 
     // LineBot
     let bot = LineBot::new(channel_secret, access_token);
 
-    // Request body parse
-    let result: Result<Events, &'static str> = bot.parse_event_request(signature, body);
-
-    // Success parsing
-    if let Ok(res) = result {
-        for event in res.events {
-            // MessageEvent only
-            if let EventType::MessageEvent(message_event) = event.r#type {
-                // TextMessageEvent only
-                if let EventMessageType::TextMessage(text_message) = message_event.message.r#type {
-                    // Create TextMessage
-                    let message = SendMessageType::TextMessage(TextMessage {
-                        text: text_message.text,
-                        emojis: None,
-                    });
-                    // Reply message with reply_token
-                    let _res = bot.reply_message(&message_event.reply_token, vec![message]);
-                }
+    let body: &str = &String::from_utf8(bytes.to_vec()).unwrap();
+    validate_signature(&bot.channel_secret, &signature.key, &body);
+
+    for event in &data.events {
+        // MessageEvent only
+        if let EventType::MessageEvent(message_event) = &event.r#type {
+            // TextMessageEvent only
+            if let MessageType::TextMessage(text_message) = &message_event.message.r#type {
+                // Create TextMessage
+                let message = SendMessageType::TextMessage(TextMessage {
+                    text: text_message.text.to_string(),
+                    emojis: None,
+                });
+                // Reply message with reply_token
+                let _res = bot.reply_message(&message_event.reply_token, vec![message]);
             }
         }
-        return HttpResponse::Ok().body("OK");
-    }
-    // Failed parsing
-    else if let Err(msg) = result {
-        return HttpResponse::BadRequest().body(msg);
     }
-    HttpResponse::BadRequest().body("Internal Server Error")
+
+    "OK"
 }
 
 #[actix_rt::main]

src/support/actix_support.rs

@@ -0,0 +1,29 @@
+use actix_web::dev::Payload;
+use actix_web::{error::ErrorBadRequest, Error, FromRequest, HttpRequest};
+use std::{future::Future, pin::Pin};
+
+#[derive(Debug)]
+pub struct Signature {
+    pub key: String,
+}
+
+impl FromRequest for Signature {
+    type Error = Error;
+    type Future = Pin<Box<dyn Future<Output = Result<Self, Self::Error>>>>;
+    type Config = ();
+
+    fn from_request(req: &HttpRequest, _payload: &mut Payload) -> Self::Future {
+        let res = if let Some(x_line_signature) = req.headers().get("x-line-signature") {
+            if let Ok(key) = x_line_signature.to_str() {
+                Ok(Signature {
+                    key: key.to_string(),
+                })
+            } else {
+                Err(ErrorBadRequest("x-line-signature is missing"))
+            }
+        } else {
+            Err(ErrorBadRequest("x-line-signature is missing"))
+        };
+        Box::pin(async move { res })
+    }
+}

src/support/mod.rs

@@ -2,3 +2,6 @@
 
 #[cfg(feature = "rocket_support")]
 pub mod rocket_support;
+
+#[cfg(feature = "actix_support")]
+pub mod actix_support;