create interface/controllers

README.md

@@ -5,7 +5,9 @@
 │   │   ├── handler
 │   │   │   └── userHandler.go (UPDATED!)
 │   │   └── router
-│   │       └── router.go (UPDATED!)
 │   └── datastore
+├── interface
+│   └── controllers
+│       └── userController.go (NEW!)
 └── main.go (UPDATED!)
 ```

infrastructure/api/handler/userHandler.go

@@ -6,10 +6,10 @@ import (
     "net/http"
     "strconv"
 
-    "github.com/jinzhu/gorm"
     "github.com/julienschmidt/httprouter"
 
     "api/domain/model"
+    "api/interface/controllers"
 )
 
 type UserHandler interface {
@@ -19,35 +19,32 @@ type UserHandler interface {
 }
 
 type userHandler struct {
-    db *gorm.DB
+    userController controllers.UserController
 }
 
-func NewUserHandler(db *gorm.DB) UserHandler {
-    return &userHandler{db: db}
+func NewUserHandler(uc controllers.UserController) UserHandler {
+    return &userHandler{userController: uc}
 }
 
 func (uh *userHandler) CreateUser(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
-    data := model.User{}
+    data := &model.User{}
     if err := json.NewDecoder(r.Body).Decode(&data); err != nil {
         fmt.Fprintln(w, "Bad request: "+err.Error())
         return
     }
-    uh.db.NewRecord(data)
-    uh.db.Create(&data)
-    if uh.db.NewRecord(data) == false {
+    err := uh.userController.CreateUser(data)
+    if err == false {
         fmt.Fprintln(w, "registerd")
     }
 }
 
 func (uh *userHandler) GetAllUsers(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
-    users := model.Users{}
-    uh.db.Find(&users)
-    json.NewEncoder(w).Encode(users)
+    u, _ := uh.userController.GetAllUsers()
+    json.NewEncoder(w).Encode(u)
 }
 
 func (uh *userHandler) GetUser(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
     id, _ := strconv.Atoi(ps.ByName("id"))
-    user := model.User{}
-    uh.db.Where("Id = ?", id).First(&user)
-    json.NewEncoder(w).Encode(user)
+    u, _ := uh.userController.GetUser(id)
+    json.NewEncoder(w).Encode(u)
 }

interface/controllers/userController.go

@@ -0,0 +1,42 @@
+package controllers
+
+import (
+    "github.com/jinzhu/gorm"
+
+    "api/domain/model"
+)
+
+type UserController interface {
+    CreateUser(data *model.User) bool
+    GetAllUsers() (model.Users, error)
+    GetUser(id int) (model.User, error)
+}
+
+type userController struct {
+    db *gorm.DB
+}
+
+func NewUserController(db *gorm.DB) UserController {
+    return &userController{db: db}
+}
+
+func (uc *userController) CreateUser(data *model.User) bool {
+    uc.db.NewRecord(data)
+    uc.db.Create(&data)
+    return uc.db.NewRecord(data)
+}
+
+func (uc *userController) GetAllUsers() (model.Users, error) {
+    users := model.Users{}
+    err := uc.db.Find(&users).Error
+    if err != nil {
+        return nil, err
+    }
+    return users, nil
+}
+
+func (uc *userController) GetUser(id int) (model.User, error) {
+    user := model.User{}
+    err := uc.db.Where("Id = ?", id).First(&user).Error
+    return user, err
+}

main.go

@@ -8,12 +8,14 @@ import (
     "api/infrastructure/api/handler"
     "api/infrastructure/api/router"
     "api/infrastructure/datastore"
+    "api/interface/controllers"
 )
 
 func main() {
     db := datastore.NewMySQL()
     r := httprouter.New()
-    h := handler.NewUserHandler(db)
+    c := controllers.NewUserController(db)
+    h := handler.NewUserHandler(c)
     router.NewRouter(r, h)
 
     defer db.Close()