target/

web: java $JVM_OPTS -cp target/facebook-example-standalone.jar clojure.main -m facebook-example.core

A Facebook Messenger Bot Example in Clojure

1. Setup a Facebook Page, Facebook app, create a Page Access Token and link the app to the page by following this [step-by-step guide](https://github.com/prometheus-ai/fb-messenger-clj/wiki/Facebook-Setup).

2. Download the repository: [lemmings-io/02-facebook-example](https://github.com/lemmings-io/02-facebook-example/archive/master.zip)

3. Extract it into the `/lemmings/clojure/projects` directory.

4. Start a new VM shell session via `vagrant ssh`

5. In the VM shell change into the facebook-example project directory

cd 02-facebook-example/

6. Run `ngrok http 3000` ([read more about ngrok](https://ngrok.com))


7. Start another new VM shell session via `vagrant ssh`

8. Add your Facebook Page Access Token to your environment

export FB_PAGE_ACCESS_TOKEN="<YOUR_FB_PAGE_ACCESS_TOKEN>"

9. Start the local server

lein ring server-headless


Via the [lein-ring doc](https://github.com/weavejester/lein-ring): by default, this command attempts to find a free port, starting at 3000.

10. Visit the https URL as shown in step 4.

E.g. `https://0db8caac.ngrok.io`

If everything went right, you'll see "Hello Lemming :)" in your Browser 🎈


11. In your Facebook Developer App go to "Webhooks" in the left sidebar and add `Callback URL` and `Verify Token` accordingly:


12. Click "Verify and Save" and your app is connected to Facebook's Messenger API 🎈


13. Go to your Facebook Page and send a message and your bot echo's your input. Congratulations!💧


Check out the code to find out more 🙂

Note: This clojure app is ready for deployment on Heroku and based on [Heroku's Clojure Getting Started Example](https://github.com/heroku/clojure-getting-started).

(defproject facebook-example "0.1.0-SNAPSHOT"

:description "Facebook Messenger Bot in Clojure"

:url "http://example.com/FIXME"

:license {:name "Eclipse Public License"

:url "http://www.eclipse.org/legal/epl-v10.html"}

:dependencies [[org.clojure/clojure "1.8.0"]

[org.clojure/data.json "0.2.1"]

[compojure "1.5.1"]

[http-kit "2.2.0"]

[ring/ring-defaults "0.2.1"]

[ring/ring-json "0.4.0"]

[ring/ring-jetty-adapter "1.5.0"]

[environ "1.0.0"]]

:min-lein-version "2.0.0"

:plugins [[lein-ring "0.9.7"]

[environ/environ.lein "0.3.1"]]

:hooks [environ.leiningen.hooks]

:ring {:handler facebook-example.core/app}

:uberjar-name "facebook-example-standalone.jar"

:profiles {:default [:base :dev :user]

#_:production #_{:env {:production false}}})

(ns facebook-example.core

(:require [compojure.core :refer :all]

[compojure.route :as route]

[ring.middleware.defaults :refer :all]

[ring.middleware.json :refer [wrap-json-params]]

[ring.middleware.keyword-params :refer [wrap-keyword-params]]

[facebook-example.facebook :as fb]

; Dependencies via Heroku Example

[compojure.handler :refer [site]]

[clojure.java.io :as io]

[ring.adapter.jetty :as jetty]

[environ.core :refer [env]]))

(defn splash []

{:status 200

:headers {"Content-Type" "text/plain"}

:body "Hello Lemming :)"})

(defroutes fb-routes

(GET "/" [] (splash))

(POST "/webhook" request (fb/route-request request) {:status 200})

(GET "/webhook" request (fb/webhook-is-valid? request)))

(def app

(-> (wrap-defaults fb-routes api-defaults)

(wrap-keyword-params)

(wrap-json-params)))

(defn -main [& args]

(println "Started up"))

(ns facebook-example.facebook

(:gen-class)

(:require [clojure.string :as s]

[facebook-example.messages :as msg]))

(defn webhook-is-valid? [request]

(let [params (:params request)]

(println "Incoming Webhook Request:")

(println request)

(if (= true (= (params "hub.mode") "subscribe")

(= (params "hub.verify_token") (System/getenv "FB_PAGE_ACCESS_TOKEN")))

{:status 200 :body (params "hub.challenge")}

{:status 403})))

(defn processText [senderID text]

(cond

(s/includes? (s/lower-case text) "help") (msg/sendTextMessage [senderID "Hi there, happy to help :)"])

(s/includes? (s/lower-case text) "image") (msg/sendImageMessage [senderID "https://upload.wikimedia.org/wikipedia/commons/thumb/c/c5/M101_hires_STScI-PRC2006-10a.jpg/1280px-M101_hires_STScI-PRC2006-10a.jpg"])

(s/includes? (s/lower-case text) "quick reply") (msg/sendQuickReply [senderID])

; If no rules apply echo the user's text input

:else (msg/sendTextMessage [senderID text])))

(defn receivedMessage [event]

(println "Messaging Event:")

(println event)

(let [senderID (get-in event [:sender :id]) recipientID (get-in event [:recipient :id]) timeOfMessage (get-in event [:timestamp]) message (get-in event [:message])]

(println (str "Received message for user " senderID " and page " recipientID " at " timeOfMessage " with message:"))

(println message)

; TODO: Check for text (onText ?), attachments (onAttachments ?)

; or quick_reply (onQuickReply) in :message tree here

; TODO: Simplify function to send a message vs.

; (msg/sendTextMessage (receivedMessage messagingEvent))

(let [messageText (message :text)]

(cond

; Check for :text

(contains? message :text) (processText senderID messageText)

; Check for :attachments

(contains? message :attachments) (msg/sendTextMessage [senderID "Message with attachment received"])))))

(defn route-request [request]

(let [data (get-in request [:params])]

(println "Incoming Request:")

(println request)

(when (= (:object data) "page")

(doseq [pageEntry (:entry data)]

(doseq [messagingEvent (:messaging pageEntry)]

; Check for message (onMessage) or postback (onPostback) here

(cond (contains? messagingEvent :message) (receivedMessage messagingEvent)

(contains? messagingEvent :postback) (msg/sendTextMessage (receivedMessage messagingEvent))

:else (println (str "Webhook received unknown messagingEvent: " messagingEvent))))))))

(ns facebook-example.messages

(:require [org.httpkit.client :as http]

[clojure.data.json :as json]))

(defn sendAPI [messageData]

(try

(let [response (http/post "https://graph.facebook.com/v2.6/me/messages"

{:query-params {"access_token" (System/getenv "FB_PAGE_ACCESS_TOKEN")}

:headers {"Content-Type" "application/json"}

:body (json/write-str messageData)

:insecure? true})]

(println "Response to FB:")

(println @response))

(catch Exception e (str "caught exception: " (.getMessage e)))))

(defn sendTextMessage [[recipientId messageText]]

(let [messageData {:recipient {:id recipientId} :message {:text messageText}}]

(println messageData)

(sendAPI messageData)))

(defn sendImageMessage [[recipientId imageUrl]]

(let [messageData {:recipient {:id recipientId}

:message {:attachment {:type "image"

:payload {:url imageUrl}}}}]

(println messageData)

(sendAPI messageData)))

(defn sendQuickReply [[recipientId]]

(let [messageData {:recipient {:id recipientId}

:message {:text "What's your favorite movie genre?"

:quick_replies [{:content_type "text"

:title "Action"

:payload "DEVELOPER_DEFINED_PAYLOAD_FOR_PICKING_ACTION"}

{:content_type "text"

:title "Comedy"

:payload "DEVELOPER_DEFINED_PAYLOAD_FOR_PICKING_COMEDY"}

{:content_type "text"

:title "Drama"

:payload "DEVELOPER_DEFINED_PAYLOAD_FOR_PICKING_DRAMA"}]}}]

(println messageData)

(sendAPI messageData)))

(ns compojure-bot.handler-test

(:require [clojure.test :refer :all]

[ring.mock.request :as mock]

[compojure-bot.handler :refer :all]))

(deftest test-app

(testing "main route"

(let [response (app (mock/request :get "/"))]

(is (= (:status response) 200))

(is (= (:body response) "Hello World"))))

(testing "not-found route"

(let [response (app (mock/request :get "/invalid"))]

(is (= (:status response) 404)))))