Ninjas ECHO REST API

main.go

package main

import (
        "encoding/json"
        "net/http"
        "strconv"
        "time"

        "github.com/labstack/echo"
)

var ninjaNumber int64 = 1

var ninjas = map[int64]ninja{
        1: ninja{ID: 1, Name: "Ji", Age: 3, Date: time.Now()},
}

type ninjaQueue chan ninja

var addNinjaQueue = make(ninjaQueue)
var deleteNinjaQueue = make(ninjaQueue)
var updateNinjaQueue = make(ninjaQueue)
var newNinjaQueue = make(ninjaQueue)

type ninja struct {
        ID   int64     `json:"id"`
        Name string    `json:"name"`
        Age  int32     `json:"age"`
        Date time.Time `json:"date"`
}

func main() {
        defer close(addNinjaQueue)
        defer close(deleteNinjaQueue)
        defer close(updateNinjaQueue)
        go addNinjaHandler()
        go deleteNinjaHandler()
        go updateNinjaHandler()
        e := echo.New()
        e.GET("/", getNinja)
        e.GET("/:id",getNinjaByID)
        e.DELETE("/:id", deleteNinja)
        e.PUT("/:id", putNinja)
        e.POST("/", postNinja)
        e.Start(":80")
}

func addNinjaHandler() {
        for {
                n := <-addNinjaQueue
                ninjaNumber++
                n.ID = ninjaNumber
                n.Date = time.Now()
                ninjas[ninjaNumber] = n
                newNinjaQueue <- n
        }
}

func deleteNinjaHandler() {
        for {
                n := <-deleteNinjaQueue
                delete(ninjas, n.ID)
        }
}

func updateNinjaHandler() {
        for {
                n := <-updateNinjaQueue
                n.Date = time.Now()
                ninjas[n.ID] = n
        }
}

func makeErrorResponse(err error) map[string]interface{} {
        return map[string]interface{}{
                "error": err.Error(),
        }
}

func validateNinja(n ninja) (bool, map[string]string) {
        if n.Age == 0 || n.Name == "" {
                validation := make(map[string]string)

                if n.Age == 0 {
                        validation["age"] = "Ninja age required"
                }
                if n.Name == "" {
                        validation["name"] = "Ninja name required"
                }

                return false, validation
        }

        return true, nil
}

func getNinja(c echo.Context) error {
        ninjaSlice := []ninja{}
        for _,n := range ninjas {
                ninjaSlice = append(ninjaSlice,n)
        }
        return c.JSON(http.StatusOK, ninjaSlice)
}

func getNinjaByID(c echo.Context) error {
        parID := c.Param("id")
        id,err := strconv.Atoi(parID)
        if err != nil {
                return c.JSON(http.StatusInternalServerError, makeErrorResponse(err))
        }
        n := ninjas[int64(id)]
        return c.JSON(http.StatusOK, n)
}

func postNinja(c echo.Context) error {
        n := ninja{}
        err := json.NewDecoder(c.Request().Body).Decode(&n)

        if err != nil {
                return c.JSON(http.StatusInternalServerError, makeErrorResponse(err))
        }

        ok, validation := validateNinja(n)

        if !ok {
                response := map[string]interface{}{
                        "validation": validation,
                }
                return c.JSON(http.StatusBadRequest, response)
        }

        addNinjaQueue <- n

        newNinja := <-newNinjaQueue

        return c.JSON(http.StatusOK, newNinja)
}

func putNinja(c echo.Context) error {
        parID := c.Param("id")
        n := ninja{}
        err := json.NewDecoder(c.Request().Body).Decode(&n)

        if err != nil {
                return c.JSON(http.StatusInternalServerError, makeErrorResponse(err))
        }

        id, err := strconv.Atoi(parID)

        if err != nil {
                return c.JSON(http.StatusInternalServerError, makeErrorResponse(err))
        }

        ok, validation := validateNinja(n)

        if !ok {
                response := map[string]interface{}{
                        "validation": validation,
                }
                return c.JSON(http.StatusBadRequest, response)
        }

        n.ID = int64(id)

        updateNinjaQueue <- n

        return c.JSON(http.StatusOK, n)
}

func deleteNinja(c echo.Context) error {
        parID := c.Param("id")
        n := ninja{}
        err := json.NewDecoder(c.Request().Body).Decode(&n)

        if err != nil {
                return c.JSON(http.StatusInternalServerError, makeErrorResponse(err))
        }

        id, err := strconv.Atoi(parID)

        if err != nil {
                return c.JSON(http.StatusInternalServerError, makeErrorResponse(err))
        }
        n.ID = int64(id)

        deleteNinjaQueue <- n

        return c.JSON(http.StatusOK, n)
}