CRUD API Dengan Menggunakan

Go, Gin, Gorm & Mysql

GO sudah ada sejak lama, dianggap sebagai salah satu bahasa pemrograman tercepat dengan kinerja tinggi.

Gin adalah kerangka kerja web yang ditulis dalam Go (Golang). Ini fitur API mirip martini dengan kinerja yang
hingga 40 kali lebih cepat berkat httprouter .

GORM adalah library ORM (Object Relational Mapping) untuk Golang.

Mari kita mulai menulis CRUD API sekarang. Buat project GO baru dan install dependensi terkait. Kita
menginstal GORM, Gin dan Mysql dengan menjalankan perintah berikut, pada cmd atau terminal yang
sudah berjalan pada directory/folder project kita.

Versi Golang yang dipakai dalam artikel ini adalah go1.13.15

go get github.com/go-sql-driver/mysql
go get github.com/gin-gonic/gin
go get github.com/jinzhu/gorm

Untuk menyiapkan database Mysql. Kita dapat menambahkan kode berikut pada file setup.go yang terdapat
di dalam folder/directory models.

// models/setup.go
package models
import (
"fmt"
"github.com/go-sql-driver/mysql"
"github.com/jinzhu/gorm"
)
// SetupDB : initializing mysql database
func SetupDB() *gorm.DB {
USER := "root"
PASS := "password"
HOST := "localhost"
PORT := "3306"
 DBNAME := "NAMA_DATABASE_KITA"
URL := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8&parseTime=True&loc=Local", USER, PASS, HOST, PORT, DBNAME)
db, err := gorm.Open("mysql", URL)
if err != nil {
panic(err.Error())
}
return db
}

Demi kesederhanaan, Saya mengetikan User, Password, dan kredensial lainnya langsung pada kode diatas.
Anda juga dapat memuatnya dari file .env. Kita terhubung ke MySQL menggunakan gorm.Open.

Sekarang kita membuat model pertama. Kita dapat membuat model Anda dengan menggunakan kode
berikut.

// models/task.go

package models

import (
"time"
)

type Task struct {

ID uint `json:"id" gorm:"primary_key"`
AssingedTo string `json:"assignedTo"`
Task string `json:"task"`
Deadline time.Time `json:"deadline"`
CreatedAt time.Time `gorm:"default:CURRENT_TIMESTAMP" json:"created_at"`
UpdatedAt time.Time `gorm:"default:CURRENT_TIMESTAMP" json:"updated_at"`
}

Kita membuat struct Task, hanya memiliki Id, AssignedTo, Task, Deadline dan CreatedAt serta UpdateAt.
keterangan :
 Id bertipe int primary key untuk menyimpan id unik
 Deadline bertipe time untuk menyimpan waktu
 CreatedAt dan updateAt bertipe time untuk menyimpan waktu pembuatan task
 sedangkan yang AssignedTo dan Task adalah string untuk menyimpan tugas.

Sekarang, kita beralih ke konfigurasi routes untuk API. kita membuat file terpisah untuk routes di directory
routes, seperti kode file routes.go.

// routes/routes.go
package routes

import (
"golang_api/controllers"

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

func SetupRoutes(db *gorm.DB) *gin.Engine {

r := gin.Default()
r.Use(func(c *gin.Context) {
c.Set("db", db)
})
r.GET("/tasks", controllers.FindTasks)
r.POST("/tasks", controllers.CreateTask)
r.GET("/tasks/:id", controllers.FindTask)
r.PATCH("/tasks/:id", controllers.UpdateTask)
r.DELETE("tasks/:id", controllers.DeleteTask)
return r
}

Sekarang kita dapat membuat controllers yang menangani permintaan pada routes yang dikonfigurasi.Buat
file task.go pada folder atau directory controllers, kode di file controllers bisa seperti ini.

// controllers/task.go

package controllers

import (
"golang_api/models"
"net/http"
"time"

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

type CreateTaskInput struct {

AssingedTo string `json:"assignedTo"`
Task string `json:"task"`
Deadline string `json:"deadline`
}

type UpdateTaskInput struct {

AssingedTo string `json:"assignedTo"`
Task string `json:"task"`
Deadline string `json:"deadline`
}

// GET /tasks
// Get all tasks
func FindTasks(c *gin.Context) {
db := c.MustGet("db").(*gorm.DB)
var tasks []models.Task
db.Find(&tasks)

c.JSON(http.StatusOK, gin.H{"data": tasks})

}

// POST /tasks
// Create new task
func CreateTask(c *gin.Context) {
// Validate input
var input CreateTaskInput
if err := c.ShouldBindJSON(&input); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
date := "2022-01-08"
deadline, _ := time.Parse(date, input.Deadline)

// Create task
task := models.Task{AssingedTo: input.AssingedTo, Task: input.Task, Deadline: deadline}

db := c.MustGet("db").(*gorm.DB)
db.Create(&task)

c.JSON(http.StatusOK, gin.H{"data": task})

}

// GET /tasks/:id
// Find a task
func FindTask(c *gin.Context) { // Get model if exist
var task models.Task

db := c.MustGet("db").(*gorm.DB)
if err := db.Where("id = ?", c.Param("id")).First(&task).Error; err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": " Data tidak ditemukan!"})
return
}

c.JSON(http.StatusOK, gin.H{"data": task})

}

// PATCH /tasks/:id
// Update a task
func UpdateTask(c *gin.Context) {

db := c.MustGet("db").(*gorm.DB)
// Get model if exist
var task models.Task
if err := db.Where("id = ?", c.Param("id")).First(&task).Error; err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "Data tidak ditemukan!!"})
return
}

// Validate input
var input UpdateTaskInput
if err := c.ShouldBindJSON(&input); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}

date := "2022-01-08"
deadline, _ := time.Parse(date, input.Deadline)

var updatedInput models.Task

updatedInput.Deadline = deadline
updatedInput.AssingedTo = input.AssingedTo
 updatedInput.Task = input.Task

db.Model(&task).Updates(updatedInput)

c.JSON(http.StatusOK, gin.H{"data": task})

}

// DELETE /tasks/:id
// Delete a task
func DeleteTask(c *gin.Context) {
// Get model if exist
db := c.MustGet("db").(*gorm.DB)
var book models.Task
if err := db.Where("id = ?", c.Param("id")).First(&book).Error; err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "Data tidak ditemukan!!"})
return
}

db.Delete(&book)

c.JSON(http.StatusOK, gin.H{"data": true})

}

Yang terakhir kita membuat file main.go diluar folder models, routes, dan controllers. kode di file main
seperti berikut.

package main

import (
// golang_api adalah directory root project go yang kita buat
"golang_api/models" // memanggil package models pada directory models
"golang_api/routes"
)

func main() {

db := models.SetupDB()
db.AutoMigrate(&models.Task{})

r := routes.SetupRoutes(db)
r.Run()
}

Sekarang kita siap untuk menjalankan server yang telah kita buat sejauh ini. Dengan perintah dibawah ini. 
go run main.go

Update: Jika bermasalah silahkan lihat Github. Maaf baru push ke github dan ada perbedaan nama folder.