Send Sms with Twilio on golang

menarayanzshrestha — Tue, 08 Mar 2022 16:09:43 +0000

Twilio is an American cloud communications platform. Working with golang is easier with twilio.

Lets signup for twilio account: Twilio | Try Twilio Free

Enter the details and get the account. Please verify your email and your mobile number with the flow of the link. We need three things to work with twilio on golang from Project Info.

AUTH SID
AUTH TOKEN
PHONE NUMBER( Sender phone number)

Generate all these variable which are required for twilio api.

Let code some golang for integration with twilio:

First run this command to create go.mod

go mod init github.com/menarayanzshrestha/workwithtwilio

and create a file main.go

package main

import (
    "fmt"
    "net/http"
)

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("Hello, Golang Dev"))
    })

    PORT := "5000"

    fmt.Println("Serverr running on port:", PORT)

    http.ListenAndServe(":"+PORT, nil)

}

Run this code and make sure the server is running. If you wake to work with hot reload follow the article on

Since we have to save the auth variables on code which is not a good practice. So let us integrate to pull the variables from .env file

Run this command to get the package.

go get -u github.com/joho/godotenv

And create the folder on root file named utils and under it create a file named “env.go”

package utils

import (
    "log"
    "os"

    "github.com/joho/godotenv"
)

//GetEnvWithKey : get env value of provided key
func GetEnvWithKey(key string) string {
    return os.Getenv(key)
}

//LoadEnv loads environment variables from .env file
func LoadEnv() {
    err := godotenv.Load(".env")
    if err != nil {
        log.Fatalf("Error loading .env file")
        os.Exit(1)
    }

}

Now add this code on the main.go on the top of main function

utils.LoadEnv()
This will load the .env file

Lets make .env file in root

#twilio
SID=AC0e05cb5549fbc7ebbebf577*****
AUTH_TOKEN=aeb3c88f1306799550af2c*****
TWILIO_NO=+170888*****

Note: This is just a sample value. You need to get them from twilio dashboard.

Now create a file “twilio.go” under utils folder

package utils

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "net/url"
    "strings"
)

func SendSms(to string, message string) {

    getEnv := GetEnvWithKey

    // Set account keys & information
    accountSid := getEnv("SID")
    authToken := getEnv("AUTH_TOKEN")
    from := getEnv("TWILIO_NO")

    urlStr := "https://api.twilio.com/2010-04-01/Accounts/" + accountSid + "/Messages.json"

    msgData := url.Values{}
    msgData.Set("To", to)
    msgData.Set("From", from)
    msgData.Set("Body", message)
    msgDataReader := *strings.NewReader(msgData.Encode())

    client := &http.Client{}
    req, _ := http.NewRequest("POST", urlStr, &msgDataReader)
    req.SetBasicAuth(accountSid, authToken)
    req.Header.Add("Accept", "application/json")
    req.Header.Add("Content-Type", "application/x-www-form-urlencoded")

    resp, _ := client.Do(req)
    if resp.StatusCode >= 200 && resp.StatusCode < 300 {
        var data map[string]interface{}
        decoder := json.NewDecoder(resp.Body)
        err := decoder.Decode(&data)
        if err == nil {
            fmt.Println(data["sid"])
        }
        log.Print("------------Sent sms successfully------------")
    } else {
        fmt.Println(resp.Status)
    }
}

Now we need to run the SendSms function in main.go. So add this inside “/ “ HandleFunc.

utils.SendSms("+9779800000000", "Test Message from twilio")

Note: “9800000000”is just the sample phone number . You need to verify the number first before able to send sms in trial version.

So lets start the server and hit http://localhost:5000

Hope it works.

Happy coding.

Hot Reload using Air in golang

menarayanzshrestha — Tue, 08 Mar 2022 16:05:16 +0000

Hot reloading is the important and most frequently used feature. We play and change different messages, logic inside our code. There is an easy way to implement it.

At first let us create a http server on golang:

Create a file named “server.go” inside which copy the below code:

package main

import (
    "fmt"
    "net/http"
)

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("Hello, Golang Dev"))
    })

    PORT := "5000"

    fmt.Println("Serverr running on port:", PORT)

    http.ListenAndServe(":" + PORT, nil)

}

This will create a http-server hosted on port “5000”. To run server

go run server.go

You can see the message : “Server running on port: 5000”. To verify it go to the browser and hit the url : http://localhost:5000/ . You can see “Hello, Golang Dev” as response. Its working right ??

Now if you want to change that message to “Hello World” . You need to restart server which is time consuming. There are many ways to hot reload. Here will talk about the “Air”.

Air is a command-line utility that provides live reloading for Go applications. To install it

go get -u github.com/cosmtrek/air

Next create .air.conf on the root directory

# .air.conf
# Config file for [Air](https://github.com/cosmtrek/air) in TOML format

# Working directory
# . or absolute path, please note that the directories following must be under root.
root = "." 
tmp_dir = "tmp"

[build]
# Just plain old shell command. You could use `make` as well.
cmd = "go build -o ./tmp/main ."
# Binary file yields from `cmd`.
bin = "tmp/main"
# Customize binary.
full_bin = "APP_ENV=dev APP_USER=air ./tmp/main"
# Watch these filename extensions.
include_ext = ["go", "tpl", "tmpl", "html"]
# Ignore these filename extensions or directories.
exclude_dir = ["assets", "tmp", "vendor", "frontend/node_modules"]
# Watch these directories if you specified.
include_dir = []
# Exclude files.
exclude_file = []
# It's not necessary to trigger build each time file changes if it's too frequent.
delay = 1000 # ms
# Stop to run old binary when build errors occur.
stop_on_error = true
# This log file places in your tmp_dir.
log = "air_errors.log"

[log]
# Show log time
time = false

[color]
# Customize each part's color. If no color found, use the raw app log.
main = "magenta"
watcher = "cyan"
build = "yellow"
runner = "green"

[misc]
# Delete tmp directory on exit
clean_on_exit = true

First check air is install properly or not.

air -v

If it works yo are ready to go. Else you need to setup for path for “air”

sudo mv ~/go/bin/air /usr/local/bin
Recheck

air -v
Finally, instead of running our Go application with the usual “go run server.go” command, use the “air” command.

air
Hope it works.

Happy Coding

DEV Community: menarayanzshrestha

Send Sms with Twilio on golang

Hot Reload using Air in golang