Merge pull request #11 from nanato12/feature/sample

Add sample files

Author: nanato12

.gitignore

@@ -8,3 +8,6 @@ Cargo.lock
 
 # These are backup files generated by rustfmt
 **/*.rs.bk
+
+# enviroment value
+.env

Cargo.toml

@@ -17,3 +17,8 @@ bytes = "0.4"
 base64 = "0.9.2"
 hmac = "0.6.2"
 sha2 = "0.7.1"
+
+[dev-dependencies]
+dotenv = "0.15.0"
+actix-web = "3.3"
+actix-rt = "1.0"

examples/create_signature.rs

@@ -0,0 +1,67 @@
+extern crate line_bot_sdk_rust as line;
+
+use line::webhook::validate_signature;
+
+use base64::encode;
+use hmac::{Hmac, Mac};
+use sha2::Sha256;
+
+// Signature confirmation
+pub fn create_signature(channel_secret: &str, body: &str) -> String {
+    type HmacSha256 = Hmac<Sha256>;
+
+    let mut mac =
+        HmacSha256::new_varkey(channel_secret.as_bytes()).expect("HMAC can take key of any size");
+    mac.input(body.as_bytes());
+    return encode(&mac.result().code().to_vec());
+}
+
+fn main() {
+    let channel_secret: &str = "channel_secret";
+    let request_body: &str = r#"
+        {
+            "destination": "xxxxxxxxxx",
+            "events": [
+                {
+                    "replyToken": "nHuyWiB7yP5Zw52FIkcQobQuGDXCTA",
+                    "type": "message",
+                    "mode": "active",
+                    "timestamp": 1462629479859,
+                    "source": {
+                        "type": "user",
+                        "userId": "U4af4980629..."
+                    },
+                    "message": {
+                        "id": "325708",
+                        "type": "text",
+                        "text": "@example Hello, world! (love)",
+                        "emojis": [
+                                {
+                                    "index": 14,
+                                    "length": 6,
+                                    "productId": "5ac1bfd5040ab15980c9b435",
+                                    "emojiId": "001"
+                                }
+                            ],
+                        "mention": {
+                            "mentionees": [
+                                {
+                                    "index": 0,
+                                    "length": 8,
+                                    "userId": "U850014438e..."
+                                }
+                            ]
+                        }
+                    }
+                }
+            ]
+        }
+    "#;
+    let signature: String = create_signature(channel_secret, request_body);
+
+    if validate_signature(channel_secret, &signature, request_body) {
+        println!("Success: {}", signature);
+    } else {
+        println!("NG");
+    }
+}

examples/echobot_actix_web.rs

@@ -0,0 +1,69 @@
+extern crate line_bot_sdk_rust as line;
+
+use dotenv::dotenv;
+use std::env;
+
+use line::bot::LineBot;
+use line::events::messages::MessageType as EventMessageType;
+use line::events::{EventType, Events};
+use line::messages::{SendMessageType, TextMessage};
+
+use actix_web::web::Bytes;
+use actix_web::{post, App, HttpRequest, HttpResponse, 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();
+
+    // Get channel secret and access token by environment variable
+    let channel_secret: &str =
+        &env::var("LINE_CHANNEL_RECRET").expect("Failed getting LINE_CHANNEL_RECRET");
+    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]);
+                }
+            }
+        }
+        return HttpResponse::Ok().body("OK");
+    }
+    // Failed parsing
+    else if let Err(msg) = result {
+        return HttpResponse::BadRequest().body(msg);
+    }
+    HttpResponse::BadRequest().body("Internal Server Error")
+}
+
+#[actix_rt::main]
+async fn main() -> std::io::Result<()> {
+    dotenv().ok();
+    HttpServer::new(|| App::new().service(callback))
+        .bind("127.0.0.1:8000")?
+        .run()
+        .await
+}

examples/echobot_rocket.rs

@@ -0,0 +1,63 @@
+#![feature(proc_macro_hygiene, decl_macro)]
+
+#[macro_use]
+extern crate rocket;
+
+extern crate line_bot_sdk_rust as line;
+
+use dotenv::dotenv;
+use std::env;
+
+use rocket::http::Status;
+
+use line::bot::LineBot;
+use line::events::messages::MessageType as EventMessageType;
+use line::events::{EventType, Events};
+use line::messages::{SendMessageType, TextMessage};
+use line::support::rocket_support::{Body, Signature};
+
+#[post("/callback", data = "<body>")]
+fn callback(signature: Signature, body: Body) -> Status {
+    // Get channel secret and access token by environment variable
+    let channel_secret: &str =
+        &env::var("LINE_CHANNEL_RECRET").expect("Failed getting LINE_CHANNEL_RECRET");
+    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.key, &body.string);
+
+    // 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]);
+                }
+            }
+        }
+        return Status::new(200, "OK");
+    }
+    // Failed parsing
+    else if let Err(msg) = result {
+        return Status::new(500, msg);
+    }
+    Status::new(500, "Internal Server Error")
+}
+
+fn main() {
+    dotenv().ok();
+    rocket::ignite().mount("/", routes![callback]).launch();
+}

examples/source_rocket.rs

@@ -0,0 +1,84 @@
+#![feature(proc_macro_hygiene)]
+#![feature(decl_macro)]
+
+#[macro_use]
+extern crate rocket;
+
+extern crate line_bot_sdk_rust as line;
+
+use dotenv::dotenv;
+use std::env;
+
+use rocket::http::Status;
+
+use line::bot::LineBot;
+use line::events::source::SouceType;
+use line::events::{EventType, Events};
+use line::messages::{SendMessageType, TextMessage};
+use line::support::rocket_support::{Body, Signature};
+
+#[post("/callback", data = "<body>")]
+fn callback(signature: Signature, body: Body) -> Status {
+    // Get channel secret and access token by environment variable
+    let channel_secret: &str =
+        &env::var("LINE_CHANNEL_RECRET").expect("Failed getting LINE_CHANNEL_RECRET");
+    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.key, &body.string);
+
+    // Success parsing
+    if let Ok(res) = result {
+        for event in res.events {
+            // MessageEvent only
+            if let EventType::MessageEvent(message_event) = event.r#type {
+                // Reply message with reply_token
+                match message_event.source.r#type {
+                    // By Group
+                    SouceType::Group(source) => {
+                        // Create TextMessage
+                        let message = SendMessageType::TextMessage(TextMessage {
+                            text: format!("Group Id: {}", source.group_id),
+                            emojis: None,
+                        });
+                        let _res = bot.reply_message(&message_event.reply_token, vec![message]);
+                    }
+                    // By Room
+                    SouceType::Room(source) => {
+                        // Create TextMessage
+                        let message = SendMessageType::TextMessage(TextMessage {
+                            text: format!("Room Id: {}", source.room_id),
+                            emojis: None,
+                        });
+                        let _res = bot.reply_message(&message_event.reply_token, vec![message]);
+                    }
+                    // By User
+                    SouceType::User(source) => {
+                        // Create TextMessage
+                        let message = SendMessageType::TextMessage(TextMessage {
+                            text: format!("User Id: {}", source.user_id),
+                            emojis: None,
+                        });
+                        let _res = bot.reply_message(&message_event.reply_token, vec![message]);
+                    }
+                }
+            }
+        }
+        return Status::new(200, "OK");
+    }
+    // Failed parsing
+    else if let Err(msg) = result {
+        return Status::new(500, msg);
+    }
+    Status::new(500, "Internal Server Error")
+}
+
+fn main() {
+    dotenv().ok();
+    rocket::ignite().mount("/", routes![callback]).launch();
+}

examples/various_messages_rocket.rs

@@ -0,0 +1,77 @@
+#![feature(proc_macro_hygiene, decl_macro)]
+
+#[macro_use]
+extern crate rocket;
+
+extern crate line_bot_sdk_rust as line;
+
+use dotenv::dotenv;
+use std::env;
+
+use rocket::http::Status;
+
+use line::bot::LineBot;
+use line::events::{EventType, Events};
+use line::messages::Emoji;
+use line::messages::{SendMessageType, StickerMessage, TextMessage};
+use line::support::rocket_support::{Body, Signature};
+
+#[post("/callback", data = "<body>")]
+fn callback(signature: Signature, body: Body) -> Status {
+    // Get channel secret and access token by environment variable
+    let channel_secret: &str =
+        &env::var("LINE_CHANNEL_RECRET").expect("Failed getting LINE_CHANNEL_RECRET");
+    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.key, &body.string);
+
+    // Success parsing
+    if let Ok(res) = result {
+        for event in res.events {
+            // MessageEvent only
+            if let EventType::MessageEvent(message_event) = event.r#type {
+                // Create Vec of messages to be sent
+                let mut messages: Vec<SendMessageType> = Vec::new();
+                // Add TextMessage
+                messages.push(SendMessageType::TextMessage(TextMessage {
+                    text: String::from("text message"),
+                    emojis: None,
+                }));
+                // Add TextMessage with Emoji
+                messages.push(SendMessageType::TextMessage(TextMessage {
+                    text: String::from("$ EMOJI!"),
+                    emojis: Some(vec![Emoji {
+                        index: 0,
+                        product_id: String::from("5ac1bfd5040ab15980c9b435"),
+                        emoji_id: String::from("001"),
+                    }]),
+                }));
+                // Add StickerMessage
+                messages.push(SendMessageType::StickerMessage(StickerMessage {
+                    package_id: String::from("1"),
+                    sticker_id: String::from("1"),
+                }));
+                println!("{:?}", messages);
+                // Reply message with reply_token
+                let _res = bot.reply_message(&message_event.reply_token, messages);
+            }
+        }
+        return Status::new(200, "OK");
+    }
+    // Failed parsing
+    else if let Err(msg) = result {
+        return Status::new(500, msg);
+    }
+    Status::new(500, "Internal Server Error")
+}
+
+fn main() {
+    dotenv().ok();
+    rocket::ignite().mount("/", routes![callback]).launch();
+}