chore: update err handler (#12)

api/auth.go

@@ -2,7 +2,6 @@ package api
 
 import (
 	"bytes"
-	"database/sql"
 	"encoding/json"
 	"fmt"
 	"io/ioutil"
@@ -15,13 +14,13 @@ import (
 	"github.com/gorilla/mux"
 )
 
-type UserSignUp struct {
-	Username string `json:"username"`
-	Password string `json:"password"`
-}
-
 func handleUserSignUp(w http.ResponseWriter, r *http.Request) {
-	userSignup := UserSignUp{}
+	type UserSignUpDataBody struct {
+		Username string `json:"username"`
+		Password string `json:"password"`
+	}
+
+	userSignup := UserSignUpDataBody{}
 	err := json.NewDecoder(r.Body).Decode(&userSignup)
 
 	if err != nil {
@@ -58,13 +57,13 @@ func handleUserSignUp(w http.ResponseWriter, r *http.Request) {
 	})
 }
 
-type UserSignin struct {
-	Username string `json:"username"`
-	Password string `json:"password"`
-}
-
 func handleUserSignIn(w http.ResponseWriter, r *http.Request) {
-	userSignin := UserSignin{}
+	type UserSigninDataBody struct {
+		Username string `json:"username"`
+		Password string `json:"password"`
+	}
+
+	userSignin := UserSigninDataBody{}
 	err := json.NewDecoder(r.Body).Decode(&userSignin)
 
 	if err != nil {
@@ -75,16 +74,11 @@ func handleUserSignIn(w http.ResponseWriter, r *http.Request) {
 	user, err := store.GetUserByUsernameAndPassword(userSignin.Username, userSignin.Password)
 
 	if err != nil {
-		if err == sql.ErrNoRows {
+		json.NewEncoder(w).Encode(Response{
-			json.NewEncoder(w).Encode(Response{
+			Succeed: false,
-				Succeed: false,
+			Message: "Username and password not allowed",
-				Message: "Username and password not allowed",
+			Data:    nil,
-				Data:    nil,
+		})
-			})
-		} else {
-			e.ErrorHandler(w, "DATABASE_ERROR", err.Error())
-		}
-
 		return
 	}
 
@@ -218,7 +212,7 @@ func handleGithubAuthCallback(w http.ResponseWriter, r *http.Request) {
 
 	user, err := store.GetUserByGithubName(githubUser.Login)
 
-	if err == sql.ErrNoRows {
+	if err != nil {
 		username := githubUser.Name
 		usernameUsable, _ := store.CheckUsernameUsable(username)
 		for !usernameUsable {

api/e/codes.go

@@ -5,6 +5,9 @@ var Codes = map[string]int{
 
 	"REQUEST_BODY_ERROR": 40001,
 	"UPLOAD_FILE_ERROR":  40002,
+	"NOT_FOUND":          40400,
+	"USER_NOT_FOUND":     40401,
+	"RESOURCE_NOT_FOUND": 40402,
 
 	"DATABASE_ERROR": 50001,
 }

api/memo.go

@@ -29,14 +29,14 @@ func handleGetMyMemos(w http.ResponseWriter, r *http.Request) {
 	})
 }
 
-type CreateMemo struct {
-	Content string `json:"content"`
-}
-
 func handleCreateMemo(w http.ResponseWriter, r *http.Request) {
 	userId, _ := GetUserIdInSession(r)
 
-	createMemo := CreateMemo{}
+	type CreateMemoDataBody struct {
+		Content string `json:"content"`
+	}
+
+	createMemo := CreateMemoDataBody{}
 	err := json.NewDecoder(r.Body).Decode(&createMemo)
 
 	if err != nil {

api/query.go

@@ -26,23 +26,23 @@ func handleGetMyQueries(w http.ResponseWriter, r *http.Request) {
 	})
 }
 
-type QueryPut struct {
-	Title       string `json:"title"`
-	Querystring string `json:"querystring"`
-}
-
 func handleCreateQuery(w http.ResponseWriter, r *http.Request) {
 	userId, _ := GetUserIdInSession(r)
 
-	queryPut := QueryPut{}
+	type CreateQueryDataBody struct {
-	err := json.NewDecoder(r.Body).Decode(&queryPut)
+		Title       string `json:"title"`
+		Querystring string `json:"querystring"`
+	}
+
+	queryData := CreateQueryDataBody{}
+	err := json.NewDecoder(r.Body).Decode(&queryData)
 
 	if err != nil {
 		e.ErrorHandler(w, "REQUEST_BODY_ERROR", "Bad request")
 		return
 	}
 
-	query, err := store.CreateNewQuery(queryPut.Title, queryPut.Querystring, userId)
+	query, err := store.CreateNewQuery(queryData.Title, queryData.Querystring, userId)
 
 	if err != nil {
 		e.ErrorHandler(w, "DATABASE_ERROR", err.Error())

api/resource.go

@@ -93,7 +93,7 @@ func handleGetResource(w http.ResponseWriter, r *http.Request) {
 	resource, err := store.GetResourceByIdAndFilename(resourceId, filename)
 
 	if err != nil {
-		e.ErrorHandler(w, "DATABASE_ERROR", err.Error())
+		e.ErrorHandler(w, "RESOURCE_NOT_FOUND", err.Error())
 		return
 	}
 

api/user.go

@@ -15,7 +15,7 @@ func handleGetMyUserInfo(w http.ResponseWriter, r *http.Request) {
 	user, err := store.GetUserById(userId)
 
 	if err != nil {
-		e.ErrorHandler(w, "DATABASE_ERROR", err.Error())
+		e.ErrorHandler(w, "USER_NOT_FOUND", err.Error())
 		return
 	}
 
@@ -92,12 +92,12 @@ func handleRefreshUserOpenId(w http.ResponseWriter, r *http.Request) {
 	})
 }
 
-type CheckUsername struct {
-	Username string
-}
-
 func handleCheckUsername(w http.ResponseWriter, r *http.Request) {
-	checkUsername := CheckUsername{}
+	type CheckUsernameDataBody struct {
+		Username string
+	}
+
+	checkUsername := CheckUsernameDataBody{}
 	err := json.NewDecoder(r.Body).Decode(&checkUsername)
 
 	if err != nil {
@@ -119,13 +119,13 @@ func handleCheckUsername(w http.ResponseWriter, r *http.Request) {
 	})
 }
 
-type ValidPassword struct {
-	Password string
-}
-
 func handleValidPassword(w http.ResponseWriter, r *http.Request) {
+	type ValidPasswordDataBody struct {
+		Password string
+	}
+
 	userId, _ := GetUserIdInSession(r)
-	validPassword := ValidPassword{}
+	validPassword := ValidPasswordDataBody{}
 	err := json.NewDecoder(r.Body).Decode(&validPassword)
 
 	if err != nil {

store/db.go

@@ -2,6 +2,7 @@ package store
 
 import (
 	"database/sql"
+	"errors"
 	"io/ioutil"
 	"os"
 	"path/filepath"
@@ -45,7 +46,9 @@ func FormatDBError(err error) error {
 		return nil
 	}
 
-	switch err.Error() {
+	switch err {
+	case sql.ErrNoRows:
+		return errors.New("data not found")
 	default:
 		return err
 	}

store/memo.go

@@ -28,7 +28,7 @@ func CreateNewMemo(content string, userId string) (Memo, error) {
 	query := `INSERT INTO memos (id, content, user_id, deleted_at, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)`
 	_, err := DB.Exec(query, newMemo.Id, newMemo.Content, newMemo.UserId, newMemo.DeletedAt, newMemo.CreatedAt, newMemo.UpdatedAt)
 
-	return newMemo, err
+	return newMemo, FormatDBError(err)
 }
 
 type MemoPatch struct {
@@ -54,21 +54,20 @@ func UpdateMemo(id string, memoPatch *MemoPatch) (Memo, error) {
 	sqlQuery := `UPDATE memos SET ` + strings.Join(set, ",") + ` WHERE id=?`
 	_, err := DB.Exec(sqlQuery, args...)
 
-	return memo, err
+	return memo, FormatDBError(err)
 }
 
 func DeleteMemo(memoId string) error {
 	query := `DELETE FROM memos WHERE id=?`
 	_, err := DB.Exec(query, memoId)
-
+	return FormatDBError(err)
-	return err
 }
 
 func GetMemoById(id string) (Memo, error) {
 	query := `SELECT id, content, deleted_at, created_at, updated_at FROM memos WHERE id=?`
 	memo := Memo{}
 	err := DB.QueryRow(query, id).Scan(&memo.Id, &memo.Content, &memo.DeletedAt, &memo.CreatedAt, &memo.UpdatedAt)
-	return memo, err
+	return memo, FormatDBError(err)
 }
 
 func GetMemosByUserId(userId string, onlyDeleted bool) ([]Memo, error) {
@@ -93,7 +92,7 @@ func GetMemosByUserId(userId string, onlyDeleted bool) ([]Memo, error) {
 	}
 
 	if err := rows.Err(); err != nil {
-		return nil, err
+		return nil, FormatDBError(err)
 	}
 
 	return memos, nil

store/query.go

@@ -30,7 +30,7 @@ func CreateNewQuery(title string, querystring string, userId string) (Query, err
 	sqlQuery := `INSERT INTO queries (id, title, querystring, user_id, pinned_at, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)`
 	_, err := DB.Exec(sqlQuery, newQuery.Id, newQuery.Title, newQuery.Querystring, newQuery.UserId, newQuery.PinnedAt, newQuery.CreatedAt, newQuery.UpdatedAt)
 
-	return newQuery, err
+	return newQuery, FormatDBError(err)
 }
 
 type QueryPatch struct {
@@ -61,21 +61,20 @@ func UpdateQuery(id string, queryPatch *QueryPatch) (Query, error) {
 	sqlQuery := `UPDATE queries SET ` + strings.Join(set, ",") + ` WHERE id=?`
 	_, err := DB.Exec(sqlQuery, args...)
 
-	return query, err
+	return query, FormatDBError(err)
 }
 
 func DeleteQuery(queryId string) error {
 	query := `DELETE FROM queries WHERE id=?`
 	_, err := DB.Exec(query, queryId)
-
+	return FormatDBError(err)
-	return err
 }
 
 func GetQueryById(queryId string) (Query, error) {
 	sqlQuery := `SELECT id, title, querystring, pinned_at, created_at, updated_at FROM queries WHERE id=?`
 	query := Query{}
 	err := DB.QueryRow(sqlQuery, queryId).Scan(&query.Id, &query.Title, &query.Querystring, &query.PinnedAt, &query.CreatedAt, &query.UpdatedAt)
-	return query, err
+	return query, FormatDBError(err)
 }
 
 func GetQueriesByUserId(userId string) ([]Query, error) {
@@ -94,7 +93,7 @@ func GetQueriesByUserId(userId string) ([]Query, error) {
 	}
 
 	if err := rows.Err(); err != nil {
-		return nil, err
+		return nil, FormatDBError(err)
 	}
 
 	return queries, nil

store/resource.go

@@ -26,7 +26,7 @@ func CreateResource(userId string, filename string, blob []byte, filetype string
 	query := `INSERT INTO resources (id, user_id, filename, blob, type, size, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)`
 	_, err := DB.Exec(query, newResource.Id, newResource.UserId, newResource.Filename, newResource.Blob, newResource.Type, newResource.Size, newResource.CreatedAt)
 
-	return newResource, err
+	return newResource, FormatDBError(err)
 }
 
 func GetResourcesByUserId(userId string) ([]Resource, error) {
@@ -43,7 +43,7 @@ func GetResourcesByUserId(userId string) ([]Resource, error) {
 	}
 
 	if err := rows.Err(); err != nil {
-		return nil, err
+		return nil, FormatDBError(err)
 	}
 
 	return resources, nil
@@ -53,11 +53,11 @@ func GetResourceByIdAndFilename(id string, filename string) (Resource, error) {
 	query := `SELECT id, filename, blob, type, size FROM resources WHERE id=? AND filename=?`
 	resource := Resource{}
 	err := DB.QueryRow(query, id, filename).Scan(&resource.Id, &resource.Filename, &resource.Blob, &resource.Type, &resource.Size)
-	return resource, err
+	return resource, FormatDBError(err)
 }
 
 func DeleteResourceById(id string) error {
 	query := `DELETE FROM resources WHERE id=?`
 	_, err := DB.Exec(query, id)
-	return err
+	return FormatDBError(err)
 }

store/user.go

@@ -32,7 +32,7 @@ func CreateNewUser(username string, password string, githubName string) (User, e
 	query := `INSERT INTO users (id, username, password, open_id, github_name, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)`
 	_, err := DB.Exec(query, newUser.Id, newUser.Username, newUser.Password, newUser.OpenId, newUser.GithubName, newUser.CreatedAt, newUser.UpdatedAt)
 
-	return newUser, err
+	return newUser, FormatDBError(err)
 }
 
 type UserPatch struct {
@@ -42,7 +42,13 @@ type UserPatch struct {
 }
 
 func UpdateUser(id string, userPatch *UserPatch) (User, error) {
-	user, _ := GetUserById(id)
+	user := User{}
+	user, err := GetUserById(id)
+
+	if err != nil {
+		return user, FormatDBError(err)
+	}
+
 	set, args := []string{}, []interface{}{}
 
 	if v := userPatch.Username; v != nil {
@@ -61,39 +67,37 @@ func UpdateUser(id string, userPatch *UserPatch) (User, error) {
 	args = append(args, id)
 
 	sqlQuery := `UPDATE users SET ` + strings.Join(set, ",") + ` WHERE id=?`
-	_, err := DB.Exec(sqlQuery, args...)
+	_, err = DB.Exec(sqlQuery, args...)
 
-	return user, err
+	return user, FormatDBError(err)
 }
 
 func UpdateUserOpenId(userId string) (string, error) {
 	openId := utils.GenUUID()
-
 	query := `UPDATE users SET open_id=? WHERE id=?`
 	_, err := DB.Exec(query, openId, userId)
-
+	return openId, FormatDBError(err)
-	return openId, err
 }
 
 func GetUserById(id string) (User, error) {
 	query := `SELECT id, username, password, open_id, github_name, created_at, updated_at FROM users WHERE id=?`
 	user := User{}
 	err := DB.QueryRow(query, id).Scan(&user.Id, &user.Username, &user.Password, &user.OpenId, &user.GithubName, &user.CreatedAt, &user.UpdatedAt)
-	return user, err
+	return user, FormatDBError(err)
 }
 
 func GetUserByUsernameAndPassword(username string, password string) (User, error) {
 	query := `SELECT id, username, password, open_id, github_name, created_at, updated_at FROM users WHERE username=? AND password=?`
 	user := User{}
 	err := DB.QueryRow(query, username, password).Scan(&user.Id, &user.Username, &user.Password, &user.OpenId, &user.GithubName, &user.CreatedAt, &user.UpdatedAt)
-	return user, err
+	return user, FormatDBError(err)
 }
 
 func GetUserByGithubName(githubName string) (User, error) {
 	query := `SELECT id, username, password, open_id, github_name, created_at, updated_at FROM users WHERE github_name=?`
 	user := User{}
 	err := DB.QueryRow(query, githubName).Scan(&user.Id, &user.Username, &user.Password, &user.OpenId, &user.GithubName, &user.CreatedAt, &user.UpdatedAt)
-	return user, err
+	return user, FormatDBError(err)
 }
 
 func CheckUsernameUsable(username string) (bool, error) {
@@ -106,11 +110,12 @@ func CheckUsernameUsable(username string) (bool, error) {
 		return false, FormatDBError(err)
 	}
 
+	usable := true
 	if count > 0 {
-		return false, nil
+		usable = false
-	} else {
-		return true, nil
 	}
+
+	return usable, nil
 }
 
 func CheckGithubNameUsable(githubName string) (bool, error) {