The adoption of chat-bots are at a peak now. Since facebook opened up its developer platform and opened the world of possibilities for chat-bots many platforms supported bots. Telegram is one of the leading platforms with bot functionality.
There is almost a bot for everything on telegram. For memes, searching movies, downloading youtube videos, dating and many more. Businesses engage with users through these bots. Crypto companies do airdrops, giveaways using these bots. Bots are literally everywhere.
Today we are going to checkout how to build a telegram bot using Golang. So if you don't know Go this article is not for you.
We are not using any telegram bot api wrapper libraries .We are using only the net/http
package to have a better understanding how things work under the hood. Let's dive right in.
Getting started
First thing you have to do is to get a bot token after creating a bot using botfather bot on telegram and declare a constant.
const botToken = "BOT_TOKEN"
Let's start by creating a main.go file.
The first thing we need is the net/http
package we also require the log
package for logging the errors so import them and code the main function which looks like this.
func main() {
err := http.ListenAndServe(":8080", http.HandlerFunc(webHookHandler))
if err != nil {
log.Fatal(err)
return
}
}
Yep that's it . That' how much it takes to make a simple http server in go.It listens at the port 8080 and invokes the function webHookHandler
on recieving a http Request the next line is just how we handle errors in go.
Now that we have setup a server we want to create the webHookHandler
function. You may think why the name webHookhandler
its because we are using the webHooks. You can find more details here on Telegram bot docs.
Now lets take a look at the webHookHandler
function.
The bot we are going to built reply's with a random joke when the user sends the command "/joke". For this we use a free API http://api.icndb.com/jokes/random.
Our WebHookHandler Function looks like this
func webHookHandler(rw http.ResponseWriter, req *http.Request) {
// Create our web hook request body type instance
body := &webHookReqBody{}
// Decodes the incoming request into our cutom webhookreqbody type
if err := json.NewDecoder(req.Body).Decode(body); err != nil {
log.Printf("An error occured (webHookHandler)")
log.Panic(err)
return
}
// If the command /joke is recieved call the sendReply function
if strings.ToLower(body.Message.Text) == "/joke" {
err := sendReply(body.Message.Chat.ID)
if err != nil {
log.Panic(err)
return
}
}
}
Whenever a message is received by the bot our http Server gets a request and we handle the request using this function.
You can see a webHookReqBody type which is a struct to which we decode the data received via http Request.
The webHookReqBody struct declaration :
We need to import the encoding/json package for this
type webHookReqBody struct {
Message struct {
Text string `json:"text"`
Chat struct {
ID int64 `json:"id"`
} `json:"chat"`
} `json:"message"`
}
Now whenever our bot recieves a message an http request is recieved by our server and that http request body is decoded into the webHookHandler struct. Then we check if the message is "/joke" if it is then we call the sendReply
Function :
func sendReply(chatID int64) error {
fmt.Println("sendReply called")
// calls the joke fetcher fucntion and gets a random joke from the API
text, err := jokeFetcher()
if err != nil {
return err
}
//Creates an instance of our custom sendMessageReqBody Type
reqBody := &sendMessageReqBody{
ChatID: chatID,
Text: text,
}
// Convert our custom type into json format
reqBytes, err := json.Marshal(reqBody)
if err != nil {
return err
}
// Make a request to send our message using the POST method to the telegram bot API
resp, err := http.Post(
"https://api.telegram.org/bot"+botToken+"/"+"sendMessage",
"application/json",
bytes.NewBuffer(reqBytes),
)
if err != nil {
return err
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
return errors.New("unexpected status" + resp.Status)
}
return err
}
sendReply
takes an argument the CHATID which is used to identify the telegram user inside the sendReply we first generate the text to be sent using the jokFetcher function which calls our API and gets a random joke for us.
func jokeFetcher() (string, error) {
resp, err := http.Get("http://api.icndb.com/jokes/random")
c := &joke{}
if err != nil {
return "", err
}
err = json.NewDecoder(resp.Body).Decode(c)
return c.Value.Joke, err
}
We have joke struct into which the joke gets decoded into
type joke struct {
Value struct {
Joke string `json:"joke"`
} `json:"value"`
}
In the senReply Function we have sendMessageReqBody struct whose declaration is as follows :
type sendMessageReqBody struct {
ChatID int64 `json:"chat_id"`
Text string `json:"text"`
}
Check out the full code here main.go
Now in order to test our bot you should first install ngrok on your system
then run
ngrok http 8080
Now you will get a screen containing an https url copy that url and run the command
curl -F "url=YOUR_NGROK_URL_HERE" https://api.telegram.org/botYOUR_BOT_TOKEN_HERE/setWebhook
Now run your main.go file then send your bot a message "/joke". Enjoy .!!!
Top comments (0)