add parser for URL that returns image

cmd/testserver/main.go

@@ -0,0 +1,46 @@
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"image"
+	"image/color"
+	"image/draw"
+	"image/jpeg"
+	"net/http"
+	"strconv"
+)
+
+var (
+	testTextURL1  = "/text/1"
+	testTextURL2  = "/text/2"
+	testTextURL3  = "/text/3"
+	testImageURL1 = "/image/1"
+)
+
+// sets up required value here
+func main() {
+	http.HandleFunc(testTextURL1, func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		w.Write(json.RawMessage(`{"message": "1"}`))
+	})
+	http.HandleFunc(testTextURL2, func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		w.Write(json.RawMessage(`{"massage": "2"}`))
+	})
+	http.HandleFunc(testImageURL1, func(w http.ResponseWriter, r *http.Request) {
+		m := image.NewRGBA(image.Rect(0, 0, 240, 240))
+		blue := color.RGBA{0, 0, 255, 255}
+		draw.Draw(m, m.Bounds(), &image.Uniform{blue}, image.ZP, draw.Src)
+		buffer := new(bytes.Buffer)
+		err := jpeg.Encode(buffer, m, nil)
+		if err != nil {
+			return
+		}
+		w.Header().Set("Content-Type", "image/jpeg")
+		w.Header().Set("Content-Length", strconv.Itoa(len(buffer.Bytes())))
+		w.Write(buffer.Bytes())
+	})
+
+	http.ListenAndServe(":6969", nil)
+}

go.mod

@@ -6,6 +6,7 @@ require (
 	github.com/Rhymen/go-whatsapp v0.1.0
 	github.com/aws/aws-sdk-go v1.34.25
 	github.com/goccy/go-yaml v1.8.2
+	github.com/gorilla/mux v1.8.0
 	github.com/imroc/req v0.3.0
 	github.com/joho/godotenv v1.3.0
 	github.com/robfig/cron/v3 v3.0.1

go.sum

@@ -22,6 +22,8 @@ github.com/goccy/go-yaml v1.8.2/go.mod h1:wS4gNoLalDSJxo/SpngzPQ2BN4uuZVLCmbM4S3
 github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.3.0 h1:kbxbvI4Un1LUWKxufD+BiE6AEExYYgkQLQmLFqA1LFk=
 github.com/golang/protobuf v1.3.0/go.mod h1:Qd/q+1AKNOZr9uGQzbzCmRO6sUih6GTPZv6a1/R87v0=
+github.com/gorilla/mux v1.8.0 h1:i40aqfkR1h2SlN9hojwV5ZA91wcXFOvkdNIeFDP5koI=
+github.com/gorilla/mux v1.8.0/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So=
 github.com/gorilla/websocket v1.4.0 h1:WDFjx/TMzVgy9VdMMQi2K2Emtwi2QcUQsztZ/zLaH/Q=
 github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
 github.com/imroc/req v0.3.0 h1:3EioagmlSG+z+KySToa+Ylo3pTFZs+jh3Brl7ngU12U=

main.go

@@ -1,28 +1,27 @@
 package main
 
 import (
+	"bytes"
 	"encoding/gob"
-	"math/rand"
-	"os/signal"
-
 	"fmt"
 	"log"
+	"math/rand"
 	"os"
-	"time"
+	"os/signal"
 	"strings"
 	"syscall"
+	"time"
 
 	whatsapp "github.com/Rhymen/go-whatsapp"
-	cron "github.com/robfig/cron/v3"
 	godotenv "github.com/joho/godotenv"
+	cron "github.com/robfig/cron/v3"
 	// "github.com/davecgh/go-spew/spew"
 )
 
 type waHandler struct {
 	c         *whatsapp.Conn
 	startTime uint64
-	chats map[string]struct{}
-
+	chats     map[string]struct{}
 }
 
 var Schedules []Schedule
@@ -34,9 +33,9 @@ var BuildCommands []BuildCommand
 var BuildGreetings []BuildGreeting
 
 func init() {
-    if err := godotenv.Load(); err != nil {
-        log.Print("No .env file found")
-    }
+	if err := godotenv.Load(); err != nil {
+		log.Print("No .env file found")
+	}
 }
 
 func main() {
@@ -79,20 +78,20 @@ func main() {
 	if !pong || err != nil {
 		log.Fatalf("error pinging in: %v\n", err)
 	}
-	
+
 	schedule := readScheduleFiles()
 	if !schedule {
 		log.Println("Can't read Schedule Files")
 		return
 	}
 
-	for index := range(Schedules) {
+	for index := range Schedules {
 		phone_numbers := Schedules[index].ExpectedUsers
 		process_name := Schedules[index].ProcessName
 		log.Println("Read the schedule to run with cron formula " + Schedules[index].Rule)
-		jadwal.AddFunc(Schedules[index].Rule, func(){
+		jadwal.AddFunc(Schedules[index].Rule, func() {
 			log.Println("Run Schedule " + process_name)
-			for pIndex := range(phone_numbers) {
+			for pIndex := range phone_numbers {
 				go sendMessage(wac, Schedules[index].Message, phone_numbers[pIndex])
 			}
 		})
@@ -118,7 +117,6 @@ func main() {
 }
 
 func sendMessage(wac *whatsapp.Conn, message string, RJID string) {
-
 	msg := whatsapp.TextMessage{
 		Info: whatsapp.MessageInfo{
 			RemoteJid: RJID,
@@ -135,13 +133,13 @@ func sendMessage(wac *whatsapp.Conn, message string, RJID string) {
 	// if min is 2 then 2 + (50/2) = 27
 	// if max is 4 then 4 + (50/2) = 29
 	// if 29 > 5 then max is 5
-	min = min + (len(kata)/2)
-	max = max + (len(kata)/2)
+	min = min + (len(kata) / 2)
+	max = max + (len(kata) / 2)
 	if max > limit_max {
 		min = limit_max - 2
 		max = limit_max
 	}
-	waitSec := rand.Intn(max-min)+min
+	waitSec := rand.Intn(max-min) + min
 	log.Printf("Randomly paused %d for throtling", waitSec)
 	wac.Presence(RJID, whatsapp.PresenceComposing)
 	time.Sleep(time.Duration(waitSec) * time.Second)
@@ -154,6 +152,26 @@ func sendMessage(wac *whatsapp.Conn, message string, RJID string) {
 	}
 }
 
+func sendImageMessage(wac *whatsapp.Conn, img ImageMessage, RJID string) {
+	msg := whatsapp.ImageMessage{
+		Info: whatsapp.MessageInfo{
+			RemoteJid: RJID,
+		},
+		Caption:   img.Caption,
+		Thumbnail: img.Thumbnail,
+		Type:      img.Type,
+		Content:   bytes.NewReader(img.Content),
+	}
+
+	wac.Presence(RJID, whatsapp.PresenceComposing)
+	msgId, err := wac.Send(msg)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "error sending message: %v", err)
+	} else {
+		fmt.Println("Message Sent -> ID : " + msgId)
+	}
+}
+
 func login(wac *whatsapp.Conn, phone_number string) error {
 	session, err := readSession(phone_number)
 	if err == nil {
@@ -236,4 +254,4 @@ func (h *waHandler) HandleError(err error) {
 	} else {
 		log.Printf("error occoured: %v\n", err)
 	}
-}
+}

parser.go

@@ -3,10 +3,12 @@ package main
 import (
 	"encoding/json"
 	"fmt"
-	req "github.com/imroc/req"
 	"io/ioutil"
 	"os"
 	"strings"
+
+	wa "github.com/Rhymen/go-whatsapp"
+	"github.com/imroc/req"
 )
 
 var (
@@ -23,38 +25,85 @@ var (
 	errRespNotSupported = func(dst string) string { return fmt.Sprintf("[resp not supported error: %s]", dst) }
 )
 
+type ImageMessage struct {
+	Caption   string
+	Thumbnail []byte // set to nil, add on your own as I have no way to test this
+	Type      string
+	Content   []byte
+}
+
 // nemoParser parses pesan for URL in {{url}} format
 // if no URL is found in pesan, pesan is returned as is
 // if URL is found, try POST request to url
+// if response contains supported JSON, pesan will be replaced with response
 // currently only supports JSON response with message key
-func nemoParser(pesan string, Sessions Session) (string, error) {
+// if response contains image(s), image with caption will be sent instead of text
+// if there are multiple URL that return images, it will send all images, only captioning the last image
+// currently if duplicate URLs exist, the request will be repeated
+func nemoParser(pesan string, Sessions Session) (*wa.TextMessage, map[int]ImageMessage, error) {
+	var countImg int
+	txt := &wa.TextMessage{}
+	mapImgs := make(map[int]ImageMessage)
 	urlCount := strings.Count(pesan, "{{")
 	if urlCount == 0 {
-		return pesan, nil
+		txt.Text = pesan
+		return txt, nil, nil
 	}
 	for i := 0; i < urlCount; i++ {
 		url := between(pesan, "{{", "}}")
-		r, err := req.Post(url, req.BodyJSON(Sessions))
+		resp, err := req.Post(url, req.BodyJSON(Sessions))
 		if err != nil {
-			pesan = strings.Replace(pesan, fmt.Sprintf("{{%s}}", url), errReqErr(url), -1)
+			pesan = strings.Replace(pesan, fmt.Sprintf("{{%s}}", url), errReqErr(url), 1)
 		}
 
-		var m map[string]interface{}
-		r.ToJSON(&m)
+		// check if json/image/else
+		switch ct := resp.Response().Header.Get("Content-Type"); ct {
+		case "application/json":
+			var m map[string]interface{}
+			resp.ToJSON(&m)
 
-		// TODO maybe calls this in main to setup
-		sk := supportKey(os.Getenv(defSupportedRespKeysConfig))
-		k := lookupKey(m, sk)
-		if k == "" {
-			pesan = strings.Replace(pesan, fmt.Sprintf("{{%s}}", url), errRespNotSupported(url), -1)
-			continue
-		}
-		if m[k] != "" {
-			pesan = strings.Replace(pesan, fmt.Sprintf("{{%s}}", url), fmt.Sprintf("%v", m[k]), -1)
+			// TODO maybe calls this in main to setup
+			sk := supportKey(os.Getenv(defSupportedRespKeysConfig))
+			k := lookupKey(m, sk)
+			if k == "" {
+				pesan = strings.Replace(pesan, fmt.Sprintf("{{%s}}", url), errRespNotSupported(url), 1)
+				txt.Text = pesan
+				continue
+			}
+			if m[k] != "" {
+				pesan = strings.Replace(pesan, fmt.Sprintf("{{%s}}", url), fmt.Sprintf("%v", m[k]), 1)
+			}
+			// if there is image, simply remove URL
+			if len(mapImgs) > 0 {
+				continue
+			}
+			txt.Text = pesan
+		default:
+			if strings.Contains(ct, "image") {
+				b, err := resp.ToBytes()
+				if err != nil {
+					pesan = strings.Replace(pesan, fmt.Sprintf("{{%s}}", url), errReqErr(url), 1)
+					continue
+				}
+				pesan = strings.Replace(pesan, fmt.Sprintf("{{%s}}", url), "", 1)
+				mapImgs[countImg] = ImageMessage{
+					Content: b,
+					Type:    ct,
+				}
+				countImg++
+				continue
+			}
+			pesan = strings.Replace(pesan, fmt.Sprintf("{{%s}}", url), errRespNotSupported(url), 1)
 		}
 	}
+	if len(mapImgs) > 0 {
+		lastImg := mapImgs[countImg-1]
+		lastImg.Caption = pesan
+		mapImgs[countImg-1] = lastImg
+		return nil, mapImgs, nil
+	}
 
-	return pesan, nil
+	return txt, nil, nil
 }
 
 // lookupKey looks up if key exists in a map based on priority
@@ -68,7 +117,7 @@ func nemoParser(pesan string, Sessions Session) (string, error) {
 func lookupKey(m map[string]interface{}, sup map[string]int) string {
 	var key string
 	var prio int
-	for k, _ := range m {
+	for k := range m {
 		for v, p := range sup {
 			if k != v {
 				continue