# Create data dengan Gorm Golang

<figure><img src="https://3397141630-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FVUQUm1GVUT3pDnRHmDRU%2Fuploads%2FPCdzmrHB1ns2oAO4cUpt%2FUntitled%20(6).png?alt=media&#x26;token=8405ac65-0ecb-46fa-9d2d-c0c028e00aa7" alt=""><figcaption></figcaption></figure>

Langsung aja ya..

Buat create data menggunakan bahasa golang dan gorm sebagai framework, saya kurang tau sih gorm itu bisa dikatakan sebagai framework atau engga, jadi gitu aja dulu ya.

Ini contoh structure project saya

<figure><img src="https://3397141630-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FVUQUm1GVUT3pDnRHmDRU%2Fuploads%2FNkwf7QQk38XIRev84BOI%2FUntitled%20(7).png?alt=media&#x26;token=87728397-341b-41d3-81c8-6844b48f7b7a" alt=""><figcaption></figcaption></figure>

## Configuration

```
package controllers

import (
	"fmt"
	"log"
	"net/http"

	"github.com/gorilla/mux"

	"github.com/jinzhu/gorm"

	_ "github.com/jinzhu/gorm/dialects/mysql"    //mysql database driver
	_ "github.com/jinzhu/gorm/dialects/postgres" //postgres database driver

	"backend/api/models"
)

//Server struct
type Server struct {
	DB     *gorm.DB
	Router *mux.Router
}

//Initialize function
func (server *Server) Initialize(Dbdriver, DbUser, DbPassword, DbPort, DbHost, DbName string) {

	var err error

	if Dbdriver == "mysql" {
		DBURL := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8&parseTime=True&loc=Local", DbUser, DbPassword, DbHost, DbPort, DbName)
		server.DB, err = gorm.Open(Dbdriver, DBURL)
		if err != nil {
			fmt.Printf("Cannot connect to %s database", Dbdriver)
			log.Fatal("This is the error:", err)
		} else {
			fmt.Printf("We are connected to the %s database", Dbdriver)
		}
	}
	if Dbdriver == "postgres" {
		DBURL := fmt.Sprintf("host=%s port=%s user=%s dbname=%s sslmode=disable password=%s", DbHost, DbPort, DbUser, DbName, DbPassword)
		server.DB, err = gorm.Open(Dbdriver, DBURL)
		if err != nil {
			fmt.Printf("Cannot connect to %s database", Dbdriver)
			log.Fatal("This is the error:", err)
		} else {
			fmt.Printf("We are connected to the %s database", Dbdriver)
		}
	}

	server.DB.Debug().AutoMigrate(&models.User{}) //database migration

	server.Router = mux.NewRouter()

	server.initializeRoutes()
}

//Run function
func (server *Server) Run(addr string) {

	fmt.Println("Listening to port 8080")
	log.Fatal(http.ListenAndServe(addr, server.Router))
}

```

## Controller

Nah di dalam controller saya buat seperti ini

```
package controllers

import (
	"backend/api/models"
	"backend/api/responses"
	"backend/api/utils/formaterror"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
)

// Create Customer function
func (server *Server) CreateCustomer(w http.ResponseWriter, r *http.Request) {
	body, err := ioutil.ReadAll(r.Body)
	if err != nil {
		responses.ERROR(w, http.StatusUnprocessableEntity, err)
	}

	customer := models.Customer{}
	err = json.Unmarshal(body, &customer)
	if err != nil {
		responses.ERROR(w, http.StatusUnprocessableEntity, err)
		return
	}

	err = customer.ValidateCustomer("")
	if err != nil {
		responses.ERROR(w, http.StatusUnprocessableEntity, err)
		return
	}
	customerCreated, err := customer.SaveCustomer(server.DB)

	if err != nil {

		formattedError := formaterror.FormatError(err.Error())

		responses.ERROR(w, http.StatusInternalServerError, formattedError)
		return
	}
	w.Header().Set("Location", fmt.Sprintf("%s%s/%d", r.Host, r.RequestURI, customerCreated.ID))
	responses.JSON(w, http.StatusCreated, customerCreated)
}

```

## Model

Sedangkan pada model saya buat seperti ini

```
package models

import (
	"errors"
	"strings"

	"github.com/jinzhu/gorm"
)

type Customer struct {
	gorm.Model
	GradeID uint32 `json:"gradeid"`
	Name    string `gorm:"size:100;not null;" json:"name"`
	Address string `gorm:"size:100;not null;" json:"address"`
	City    string `gorm:"size:100;not null;" json:"city"`
	Region  string `gorm:"size:100;not null;" json:"region"`
}

type Customers []Customer

func (r *Customer) ValidateCustomer(action string) error {
	switch strings.ToLower(action) {
	default:
		if r.Name == "" {
			return errors.New("Required Name")
		}
		if r.Address == "" {
			return errors.New("Required Address")
		}
		if r.City == "" {
			return errors.New("Required City")
		}
		if r.Region == "" {
			return errors.New("Required Region")
		}
		return nil

	}
}

//Save Customer function
func (r *Customer) SaveCustomer(db *gorm.DB) (*Customer, error) {
	var err error
	err = db.Debug().Create(&r).Error
	if err != nil {
		return &Customer{}, err
	}
	return r, nil
}

```

## Migration

Dan pada file api\seed\seeder.go saya buat seperti ini untuk menjalankan proses migration data

```
package seed

import (
	"backend/api/models"
	"log"

	"github.com/jinzhu/gorm"
)

var customers = []models.Customer{
	models.Customer{
		GradeID: 1,
		Name:    "Kim Yoohyeon",
		Address: "Nowongu",
		City:    "Namyangju",
		Region:  "Korea Selatan",
	},
	models.Customer{
		GradeID: 2,
		Name:    "Kang Daniel",
		Address: "Ansan",
		City:    "Busan",
		Region:  "Korea Selatan",
	},
}

//Load function
func Load(db *gorm.DB) {

	err := db.Debug().DropTableIfExists(&models.Customer{}).Error
	if err != nil {
		log.Fatalf("cannot drop table: %v", err)
	}

	err = db.Debug().AutoMigrate(&models.Customer{}).Error
	if err != nil {
		log.Fatalf("cannot migrate table: %v", err)
	}

	for h, _ := range customers {
		err = db.Debug().Model(&models.Customer{}).Create(&customers[h]).Error
		if err != nil {
			log.Fatalf("cannot seed customer table: %v", err)
		}
	}
}

```

Sekian, Gomawo^-^