Golang image search api

Building the REST API

I'll be using gin for this part of project.

Gin is a web framework written in Go (Golang). It features a martini-like API with performance that is up to 40 times faster thanks to httprouter. If you need performance and good productivity, you will love Gin.

TLDR

The colly code for scraping

First we create our go.mod file:

 go mod init Intersect_api

Then we'll create our main.go file and add the following code.

// main.go
package main
import (
    "Intersect/server"
    "log"
    "os"
    "time"

    "github.com/getsentry/sentry-go"
)

func main() {

    // Initialize Libraries

    // Initialize and defer Sentry
    if err := sentry.Init(sentry.ClientOptions{
        Dsn: os.Getenv("SENTRY_DSN"),
    }); err != nil {
        log.Fatalln("Sentry Init Error: ", err)
    }

    defer sentry.Flush(2 * time.Second)

    // Initialize Server
    server.Init()
}

Create a server module and initialize the server

/// server.go
package server

import "github.com/getsentry/sentry-go"

// Init : Initialize the routes and server
func Init() {
    r := NewRouter()
    err := r.Run()

    if err != nil {
        sentry.CaptureException(err)
    }
}

Good rule of thumb to add some middleware with a token required

// middleware.go
package server

import (
    "net/http"

    "github.com/gin-gonic/gin"
)

func AuthMiddleware() gin.HandlerFunc {
    authHeader := "let-me-in"
    // os.Getenv("AUTHORIZATION_STRING")
    return func(c *gin.Context) {
        requiredAuth := c.Request.Header.Get("Authorization")
        if requiredAuth != authHeader {
            c.AbortWithStatusJSON(http.StatusUnauthorized, map[string]string{"message": "unauthorized peasant 😃"})
        }
        c.Next()
        // middleware
    }
}

Then we'll create default cors, routes and also call our middleware inside the router.use() method

package server

import (
    "Intersect/scraper"

    "github.com/gin-contrib/cors"
    "github.com/gin-gonic/gin"
)

/// router.go
func NewRouter() *gin.Engine {
    // gin.SetMode(gin.ReleaseMode)
    router := gin.New()
    // Gin and CORS Middlewares
    router.Use(gin.Logger())
    router.Use(gin.Recovery())
    /// Cors
    router.Use(setCors())
    /// Declare Middleware
    authorized := router.Group("/")
    authorized.Use(AuthMiddleware())
    {
        authorized.GET("", scraper.Greet)
        searchRouter := authorized.Group("search")
        searchRouter.GET("", scraper.GetImgs)
    }
    return router
}

// Cors
func setCors() gin.HandlerFunc {
    return cors.New(cors.Config{
        AllowOrigins:     []string{"*"},
        AllowMethods:     []string{"GET", "OPTIONS", "PUT"},
        AllowHeaders:     []string{"Origin", "Authorization"},
        ExposeHeaders:    []string{"Content-Length"},
        AllowCredentials: true,
    })
}

Then we'll create a scraper directory/module and create two files

greeting.go for default route and
search.go for the request route. (Because the default route will be lonely).

package scraper

import (
    "net/http"

    "github.com/gin-gonic/gin"
)

func Greet(c *gin.Context) {
    c.JSON(http.StatusOK, map[string]string{"sup": "🤘🚀"})

}

And now the main component of the server, we'll scrape the images from various websites for free and non-stock images.
- https://unsplash.com
- https://burst.shopify.com
- https://www.pexels.com/
- https://www.flickr.com
- https://stocksnap.io
- https://google.com ... (because why not)

package scraper

import (
    "fmt"
    "net/http"
    "strings"

    "github.com/gin-gonic/gin"
    "github.com/gocolly/colly"
)

func GetImgs(c *gin.Context) {
    searchQuery := c.Query("q")
    res := getSearch(searchQuery)
    c.JSON(http.StatusOK, res)
}

func getSearch(searchQuery string) Images {
    searchString := strings.Replace(searchQuery, " ", "-", -1)
    c := colly.NewCollector()
    c.UserAgent = "Mozilla/5.0 (Macintosh; Intel Mac OS X x.y; rv:42.0) Gecko/20100101 Firefox/42.0"
    c.AllowURLRevisit = true
    c.DisableCookies()
    array := []string{}

    // Find and visit all links
    c.OnHTML("img[src]", func(e *colly.HTMLElement) {
        src := e.Attr("src")
        if src != "" {
            array = append(array, e.Attr("src"))
        }
    })
    // Requesting a url for html
    c.OnRequest(func(r *colly.Request) {
        fmt.Println("Visiting", r.URL)
    })
    // search query
    pexelsQuery := strings.Replace(searchString, "-", "%20", -1)
    stocSnapQuery := strings.Replace(searchString, "-", "+", -1)
    //
    c.Visit("https://unsplash.com/s/" + searchString)
    c.Visit("https://burst.shopify.com/photos/search?utf8=%E2%9C%93&q=" + searchString + "&button=")
    c.Visit("https://www.pexels.com/search/" + pexelsQuery + "/")
    c.Visit("https://www.flickr.com/search/?text=" + pexelsQuery)
    c.Visit("http://www.google.com/images?q=" + stocSnapQuery)
    c.Visit("https://stocksnap.io/search/" + stocSnapQuery)
    //
    return Images{
        Count: len(array),
        Data:  array}
}

type Images struct {
    Count int      `json:"counts"`
    Data  []string `json:"data"`
}

After that, we'll build a binary using

go build -o /bin/Intersect_api -v .

Blog

Golang image search api

Navin Kodag

Building the REST API

I'll be using gin for this part of project.

TLDR

Now that's almost all the code we'll need.

Join Our Newsletter. No Spam, Only the good stuff.

Related