Use utils.HttpResponse/Abort to replace c.JSON/Abort

Signed-off-by: Asai Neko <sugar@sne.moe>

data/user.go

@@ -18,21 +18,23 @@ type User struct {
 	UUID            uuid.UUID `json:"uuid" gorm:"type:uuid;uniqueindex;not null"`
 	UserId          uuid.UUID `json:"user_id" gorm:"type:uuid;uniqueindex;not null"`
 	Email           string    `json:"email" gorm:"type:varchar(255);uniqueindex;not null"`
-	Nickname        string    `json:"nickname"`
+	Username        string    `json:"username" gorm:"type:varchar(255);uniqueindex;not null"`
-	Subtitle        string    `json:"subtitle"`
+	Nickname        string    `json:"nickname" gorm:"type:text"`
-	Avatar          string    `json:"avatar"`
+	Subtitle        string    `json:"subtitle" gorm:"type:text"`
+	Avatar          string    `json:"avatar" gorm:"type:text"`
 	Bio             string    `json:"bio" gorm:"type:text"`
 	PermissionLevel uint      `json:"permission_level" gorm:"default:10;not null"`
+	AllowPublic     bool      `json:"allow_public" gorm:"default:false;not null"`
 }
 
 type UserSearchDoc struct {
-	UserId          string `json:"user_id"`
+	UserId   string `json:"user_id"`
-	Email           string `json:"email"`
+	Email    string `json:"email"`
-	Type            string `json:"type"`
+	Username string `json:"username"`
-	Nickname        string `json:"nickname"`
+	Type     string `json:"type"`
-	Subtitle        string `json:"subtitle"`
+	Nickname string `json:"nickname"`
-	Avatar          string `json:"avatar"`
+	Subtitle string `json:"subtitle"`
-	PermissionLevel uint   `json:"permission_level"`
+	Avatar   string `json:"avatar"`
 }
 
 func (self *User) GetByEmail(email string) (*User, error) {
@@ -132,12 +134,12 @@ func (self *User) FastListUsers(limit, offset int64) (*[]UserSearchDoc, error) {
 
 func (self *User) UpdateSearchIndex() error {
 	doc := UserSearchDoc{
-		UserId:          self.UserId.String(),
+		UserId:   self.UserId.String(),
-		Email:           self.Email,
+		Email:    self.Email,
-		Nickname:        self.Nickname,
+		Username: self.Username,
-		Subtitle:        self.Subtitle,
+		Nickname: self.Nickname,
-		Avatar:          self.Avatar,
+		Subtitle: self.Subtitle,
-		PermissionLevel: self.PermissionLevel,
+		Avatar:   self.Avatar,
 	}
 	index := MeiliSearch.Index("user")
 

middleware/jwt.go

@@ -2,6 +2,7 @@ package middleware
 
 import (
 	"nixcn-cms/pkgs/authtoken"
+	"nixcn-cms/utils"
 
 	"github.com/gin-gonic/gin"
 )
@@ -14,12 +15,12 @@ func JWTAuth(required bool) gin.HandlerFunc {
 		authtoken := new(authtoken.Token)
 		uid, err := authtoken.HeaderVerify(auth)
 		if err != nil {
-			c.AbortWithStatusJSON(401, gin.H{"status": err.Error()})
+			utils.HttpAbort(c, 401, "", "unauthorized")
 			return
 		}
 
 		if required == true && uid == "" {
-			c.AbortWithStatusJSON(401, gin.H{"status": "unauthorized"})
+			utils.HttpAbort(c, 401, "", "unauthorized")
 			return
 		}
 

middleware/permission.go

@@ -2,6 +2,7 @@ package middleware
 
 import (
 	"nixcn-cms/data"
+	"nixcn-cms/utils"
 
 	"github.com/gin-gonic/gin"
 	"github.com/google/uuid"
@@ -14,19 +15,19 @@ func Permission(requiredLevel uint) gin.HandlerFunc {
 		if !ok {
 			userIdOrig, ok := c.Get("user_id")
 			if !ok || userIdOrig.(string) == "" {
-				c.AbortWithStatusJSON(401, gin.H{"status": "missing user id"})
+				utils.HttpAbort(c, 401, "", "missing user id")
 				return
 			}
 
 			userId, err := uuid.Parse(userIdOrig.(string))
 			if err != nil {
-				c.AbortWithStatusJSON(500, gin.H{"status": "error parsing user id"})
+				utils.HttpAbort(c, 500, "", "error parsing user id")
 				return
 			}
 
 			userData, err := new(data.User).GetByUserId(userId)
 			if err != nil {
-				c.AbortWithStatusJSON(404, gin.H{"status": "user not found"})
+				utils.HttpAbort(c, 404, "", "user not found")
 				return
 			}
 
@@ -37,7 +38,7 @@ func Permission(requiredLevel uint) gin.HandlerFunc {
 		}
 
 		if permissionLevel < requiredLevel {
-			c.AbortWithStatusJSON(403, gin.H{"status": "permission denied"})
+			utils.HttpAbort(c, 403, "", "permission denied")
 			return
 		}
 

service/auth/magic.go

@@ -5,6 +5,7 @@ import (
 	"nixcn-cms/pkgs/authcode"
 	"nixcn-cms/pkgs/email"
 	"nixcn-cms/pkgs/turnstile"
+	"nixcn-cms/utils"
 
 	"github.com/gin-gonic/gin"
 	"github.com/spf13/viper"
@@ -22,26 +23,28 @@ func Magic(c *gin.Context) {
 	// Parse request
 	var req MagicRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
-		c.JSON(400, gin.H{"error": "invalid request"})
+		utils.HttpResponse(c, 400, "", "invalid request")
 		return
 	}
 
 	// Cloudflare turnstile
 	ok, err := turnstile.VerifyTurnstile(req.TurnstileToken, c.ClientIP())
 	if err != nil || !ok {
-		c.JSON(403, gin.H{"error": "turnstile failed"})
+		utils.HttpResponse(c, 403, "", "turnstile failed")
 		return
 	}
 
 	code, err := authcode.NewAuthCode(req.ClientId, req.Email)
 	if err != nil {
-		c.JSON(500, gin.H{"status": "code gen failed"})
+		utils.HttpResponse(c, 500, "", "code gen failed")
+		return
 	}
 
 	externalUrl := viper.GetString("server.external_url")
 	url, err := url.Parse(externalUrl)
 	if err != nil {
-		c.JSON(500, gin.H{"status": "invalid external url"})
+		utils.HttpResponse(c, 500, "", "invalid external url")
+		return
 	}
 
 	url.Path = "/api/v1/auth/redirect"
@@ -54,13 +57,17 @@ func Magic(c *gin.Context) {
 
 	debugMode := viper.GetBool("server.debug_mode")
 	if debugMode {
-		c.JSON(200, gin.H{"status": "magiclink sent", "uri": url.String()})
+		uriData := struct {
+			Uri string `json:"uri"`
+		}{url.String()}
+
+		utils.HttpResponse(c, 200, "", "magiclink sent", uriData)
 		return
 	} else {
 		// Send email using resend
 		emailClient, err := email.NewSMTPClient()
 		if err != nil {
-			c.JSON(500, gin.H{"status": "invalid email config"})
+			utils.HttpResponse(c, 500, "", "invalid email config")
 			return
 		}
 		emailClient.Send(
@@ -70,5 +77,5 @@ func Magic(c *gin.Context) {
 		)
 	}
 
-	c.JSON(200, gin.H{"status": "magic link sent"})
+	utils.HttpResponse(c, 200, "", "magic link sent")
 }

service/auth/redirect.go

@@ -4,6 +4,7 @@ import (
 	"net/url"
 	"nixcn-cms/data"
 	"nixcn-cms/pkgs/authcode"
+	"nixcn-cms/utils"
 
 	"github.com/gin-gonic/gin"
 	"github.com/google/uuid"
@@ -13,19 +14,19 @@ import (
 func Redirect(c *gin.Context) {
 	clientId := c.Query("client_id")
 	if clientId == "" {
-		c.JSON(400, gin.H{"status": "invalid request"})
+		utils.HttpResponse(c, 400, "", "invalid request")
 		return
 	}
 
 	redirectUri := c.Query("redirect_uri")
 	if redirectUri == "" {
-		c.JSON(400, gin.H{"status": "invalid request"})
+		utils.HttpResponse(c, 400, "", "invalid request")
 		return
 	}
 
 	state := c.Query("state")
 	if state == "" {
-		c.JSON(400, gin.H{"status": "invalid request"})
+		utils.HttpResponse(c, 400, "", "invalid request")
 		return
 	}
 
@@ -33,32 +34,32 @@ func Redirect(c *gin.Context) {
 	if code == "" {
 		userIdOrig, ok := c.Get("user_id")
 		if !ok || userIdOrig == "" {
-			c.JSON(401, gin.H{"status": "unauthorized"})
+			utils.HttpResponse(c, 401, "", "unauthorized")
 			return
 		}
 
 		userId, err := uuid.Parse(userIdOrig.(string))
 		if err != nil {
-			c.JSON(500, gin.H{"status": "failed to parse uuid"})
+			utils.HttpResponse(c, 500, "", "failed to parse uuid")
 			return
 		}
 
 		userData := new(data.User)
 		user, err := userData.GetByUserId(userId)
 		if err != nil {
-			c.JSON(500, gin.H{"status": "failed to get user id"})
+			utils.HttpResponse(c, 500, "", "failed to get user id")
 			return
 		}
 
 		code, err := authcode.NewAuthCode(clientId, user.Email)
 		if err != nil {
-			c.JSON(500, gin.H{"status": "code gen failed"})
+			utils.HttpResponse(c, 500, "", "code gen failed")
 			return
 		}
 
 		url, err := url.Parse(redirectUri)
 		if err != nil {
-			c.JSON(400, gin.H{"status": "invalid redirect uri"})
+			utils.HttpResponse(c, 400, "", "invalid redirect uri")
 			return
 		}
 		query := url.Query()
@@ -71,7 +72,7 @@ func Redirect(c *gin.Context) {
 	// Verify email token
 	authCode, ok := authcode.VerifyAuthCode(code)
 	if !ok {
-		c.JSON(403, gin.H{"status": "invalid or expired token"})
+		utils.HttpResponse(c, 403, "", "invalid or expired token")
 		return
 	}
 
@@ -85,13 +86,14 @@ func Redirect(c *gin.Context) {
 			user.UUID = uuid.New()
 			user.UserId = uuid.New()
 			user.Email = authCode.Email
+			user.Username = user.UserId.String()
 			user.PermissionLevel = 10
 			if err := user.Create(); err != nil {
-				c.JSON(500, gin.H{"status": "internal server error"})
+				utils.HttpResponse(c, 500, "", "internal server error")
 				return
 			}
 		} else {
-			c.JSON(500, gin.H{"status": "internal server error"})
+			utils.HttpResponse(c, 500, "", "internal server error")
 			return
 		}
 	}
@@ -99,25 +101,25 @@ func Redirect(c *gin.Context) {
 	clientData := new(data.Client)
 	client, err := clientData.GetClientByClientId(clientId)
 	if err != nil {
-		c.JSON(400, gin.H{"status": "client not found"})
+		utils.HttpResponse(c, 400, "", "client not found")
 		return
 	}
 
 	err = client.ValidateRedirectURI(redirectUri)
 	if err != nil {
-		c.JSON(400, gin.H{"status": "redirect uri not match"})
+		utils.HttpResponse(c, 400, "", "redirect uri not match")
 		return
 	}
 
 	newCode, err := authcode.NewAuthCode(clientId, authCode.Email)
 	if err != nil {
-		c.JSON(500, gin.H{"status": "internal server error"})
+		utils.HttpResponse(c, 500, "", "internal server error")
 		return
 	}
 
 	url, err := url.Parse(redirectUri)
 	if err != nil {
-		c.JSON(400, gin.H{"status": "invalid redirect uri"})
+		utils.HttpResponse(c, 400, "", "invalid redirect uri")
 		return
 	}
 	query := url.Query()

service/auth/refresh.go

@@ -2,6 +2,7 @@ package auth
 
 import (
 	"nixcn-cms/pkgs/authtoken"
+	"nixcn-cms/utils"
 
 	"github.com/gin-gonic/gin"
 	"github.com/spf13/viper"
@@ -13,7 +14,7 @@ func Refresh(c *gin.Context) {
 	}
 
 	if err := c.ShouldBindJSON(&req); err != nil {
-		c.JSON(400, gin.H{"status": "invalid request"})
+		utils.HttpResponse(c, 400, "", "invalid request")
 		return
 	}
 
@@ -21,20 +22,22 @@ func Refresh(c *gin.Context) {
 		Application: viper.GetString("server.application"),
 	}
 
-	access, err := JwtTool.RefreshAccessToken(req.RefreshToken)
+	accessToken, err := JwtTool.RefreshAccessToken(req.RefreshToken)
 	if err != nil {
-		c.JSON(401, gin.H{"status": "invalid refresh token"})
+		utils.HttpResponse(c, 401, "", "invalid refresh token")
 		return
 	}
 
-	refresh, err := JwtTool.RenewRefreshToken(req.RefreshToken)
+	refreshToken, err := JwtTool.RenewRefreshToken(req.RefreshToken)
 	if err != nil {
-		c.JSON(500, gin.H{"statis": "error renew refresh token"})
+		utils.HttpResponse(c, 500, "", "error renew refresh token")
 		return
 	}
 
-	c.JSON(200, gin.H{
+	tokenResp := struct {
-		"access_token":  access,
+		AccessToken  string `json:"access_token"`
-		"refresh_token": refresh,
+		RefreshToken string `json:"refresh_token"`
-	})
+	}{accessToken, refreshToken}
+
+	utils.HttpResponse(c, 200, "", "success", tokenResp)
 }

service/auth/token.go

@@ -4,6 +4,7 @@ import (
 	"nixcn-cms/data"
 	"nixcn-cms/pkgs/authcode"
 	"nixcn-cms/pkgs/authtoken"
+	"nixcn-cms/utils"
 
 	"github.com/gin-gonic/gin"
 	"github.com/spf13/viper"
@@ -18,20 +19,20 @@ func Token(c *gin.Context) {
 
 	err := c.ShouldBindJSON(&req)
 	if err != nil {
-		c.JSON(400, gin.H{"status": "invalid request"})
+		utils.HttpResponse(c, 400, "", "invalid request")
 		return
 	}
 
 	authCode, ok := authcode.VerifyAuthCode(req.Code)
 	if !ok {
-		c.JSON(403, gin.H{"status": "invalid or expired token"})
+		utils.HttpResponse(c, 403, "", "invalid or expired token")
 		return
 	}
 
 	userData := new(data.User)
 	user, err := userData.GetByEmail(authCode.Email)
 	if err != nil {
-		c.JSON(500, gin.H{"status": "internal server error"})
+		utils.HttpResponse(c, 500, "", "internal server error")
 		return
 	}
 
@@ -41,12 +42,14 @@ func Token(c *gin.Context) {
 	}
 	accessToken, refreshToken, err := JwtTool.IssueTokens(authCode.ClientId, user.UserId)
 	if err != nil {
-		c.JSON(500, gin.H{"status": "error generating tokens"})
+		utils.HttpResponse(c, 500, "", "error generating tokens")
 		return
 	}
 
-	c.JSON(200, gin.H{
+	tokenResp := struct {
-		"access_token":  accessToken,
+		AccessToken  string `json:"access_token"`
-		"refresh_token": refreshToken,
+		RefreshToken string `json:"refresh_token"`
-	})
+	}{accessToken, refreshToken}
+
+	utils.HttpResponse(c, 200, "", "success", tokenResp)
 }

service/event/checkin.go

@@ -2,6 +2,8 @@ package event
 
 import (
 	"nixcn-cms/data"
+	"nixcn-cms/utils"
+	"time"
 
 	"github.com/gin-gonic/gin"
 	"github.com/google/uuid"
@@ -11,35 +13,38 @@ func Checkin(c *gin.Context) {
 	data := new(data.Attendance)
 	userIdOrig, ok := c.Get("user_id")
 	if !ok {
-		c.JSON(403, gin.H{"status": "userid error"})
+		utils.HttpResponse(c, 403, "", "userid error")
 		return
 	}
 	userId, err := uuid.Parse(userIdOrig.(string))
 	if err != nil {
-		c.JSON(500, gin.H{"status": "failed to parse uuid"})
+		utils.HttpResponse(c, 500, "", "failed to parse uuid")
 	}
 
 	// Get event id from query
 	eventIdOrig, ok := c.GetQuery("event_id")
 	if !ok {
-		c.JSON(400, gin.H{"status": "undefinded event id"})
+		utils.HttpResponse(c, 400, "", "undefinded event id")
 		return
 	}
 
 	// Parse event id to uuid
 	eventId, err := uuid.Parse(eventIdOrig)
 	if err != nil {
-		c.JSON(500, gin.H{"status": "error parsing string to uuid"})
+		utils.HttpResponse(c, 500, "", "error parsing string to uuid")
 		return
 	}
 	data.UserId = userId
 	code, err := data.GenCheckinCode(eventId)
 	if err != nil {
-		c.JSON(500, gin.H{"status": "error generating code"})
+		utils.HttpResponse(c, 500, "", "error generating code")
 		return
 	}
 
-	c.JSON(200, gin.H{"checkin_code": code})
+	checkinCodeResp := struct {
+		CheckinCode *string `json:"checkin_code"`
+	}{code}
+	utils.HttpResponse(c, 200, "", "success", checkinCodeResp)
 }
 
 func CheckinSubmit(c *gin.Context) {
@@ -51,49 +56,53 @@ func CheckinSubmit(c *gin.Context) {
 	attendanceData := new(data.Attendance)
 	err := attendanceData.VerifyCheckinCode(req.ChekinCode)
 	if err != nil {
-		c.JSON(400, gin.H{"status": "error verify checkin code"})
+		utils.HttpResponse(c, 400, "", "error verify checkin code")
 		return
 	}
 
-	c.JSON(200, gin.H{"status": "success"})
+	utils.HttpResponse(c, 200, "", "success")
 }
 
 func CheckinQuery(c *gin.Context) {
 	userIdOrig, ok := c.Get("user_id")
 	if !ok {
-		c.JSON(403, gin.H{"status": "userid error"})
+		utils.HttpResponse(c, 400, "", "userid error")
 		return
 	}
 	userId, err := uuid.Parse(userIdOrig.(string))
 	if err != nil {
-		c.JSON(500, gin.H{
+		utils.HttpResponse(c, 500, "", "failed to parse uuid")
-			"status": "failed to parse uuid",
+		return
-		})
 	}
 
 	eventIdOrig, ok := c.GetQuery("event_id")
 	if !ok {
-		c.JSON(400, gin.H{"status": "could not found event_id"})
+		utils.HttpResponse(c, 400, "", "could not found event_id")
 		return
 	}
 	eventId, err := uuid.Parse(eventIdOrig)
 	if err != nil {
-		c.JSON(400, gin.H{"status": "event_id is not valid"})
+		utils.HttpResponse(c, 400, "", "event_id is not valid")
 		return
 	}
 
 	attendanceData := new(data.Attendance)
 	attendance, err := attendanceData.GetAttendance(userId, eventId)
+
 	if err != nil {
-		c.JSON(500, gin.H{"status": "database error"})
+		utils.HttpResponse(c, 500, "", "database error")
 		return
 	} else if attendance == nil {
-		c.JSON(404, gin.H{"status": "event checkin record not found"})
+		utils.HttpResponse(c, 404, "", "event checkin record not found")
 		return
 	} else if attendance.CheckinAt.IsZero() {
-		c.JSON(200, gin.H{"checkin_at": nil})
+		utils.HttpResponse(c, 200, "", "success", gin.H{"checkin_at": nil})
 		return
 	}
 
-	c.JSON(200, gin.H{"checkin_at": attendance.CheckinAt})
+	checkInAtResp := struct {
+		CheckinAt time.Time `json:"checkin_at"`
+	}{attendance.CheckinAt}
+
+	utils.HttpResponse(c, 200, "", "success", checkInAtResp)
 }

service/event/info.go

@@ -2,6 +2,8 @@ package event
 
 import (
 	"nixcn-cms/data"
+	"nixcn-cms/utils"
+	"time"
 
 	"github.com/gin-gonic/gin"
 	"github.com/google/uuid"
@@ -11,26 +13,28 @@ func Info(c *gin.Context) {
 	eventData := new(data.Event)
 	eventIdOrig, ok := c.GetQuery("event_id")
 	if !ok {
-		c.JSON(400, gin.H{"status": "undefinded event id"})
+		utils.HttpResponse(c, 400, "", "undefinded event id")
 		return
 	}
 
 	// Parse event id
 	eventId, err := uuid.Parse(eventIdOrig)
 	if err != nil {
-		c.JSON(500, gin.H{"status": "error parsing string to uuid"})
+		utils.HttpResponse(c, 500, "", "error parsing string to uuid")
 		return
 	}
 
 	event, err := eventData.GetEventById(eventId)
 	if err != nil {
-		c.JSON(404, gin.H{"status": "event id not found"})
+		utils.HttpResponse(c, 404, "", "event id not found")
 		return
 	}
 
-	c.JSON(200, gin.H{
+	eventInfoResp := struct {
-		"name":       event.Name,
+		Name      string    `json:"name"`
-		"start_time": event.StartTime,
+		StartTime time.Time `json:"start_time"`
-		"end_time":   event.EndTime,
+		EndTime   time.Time `json:"end_time"`
-	})
+	}{event.Name, event.StartTime, event.EndTime}
+
+	utils.HttpResponse(c, 200, "", "success", eventInfoResp)
 }

service/user/full.go

@@ -2,6 +2,7 @@ package user
 
 import (
 	"nixcn-cms/data"
+	"nixcn-cms/utils"
 
 	"github.com/gin-gonic/gin"
 	"github.com/google/uuid"
@@ -10,26 +11,29 @@ import (
 func Full(c *gin.Context) {
 	userIdOrig, ok := c.Get("user_id")
 	if !ok {
-		c.JSON(403, gin.H{"status": "userid error"})
+		utils.HttpResponse(c, 403, "", "userid error")
 		return
 	}
 	userId, err := uuid.Parse(userIdOrig.(string))
 	if err != nil {
-		c.JSON(500, gin.H{"status": "failed to parse uuid"})
+		utils.HttpResponse(c, 500, "", "failed to parse uuid")
 		return
 	}
 
 	userData, err := new(data.User).GetByUserId(userId)
 	if err != nil {
-		c.JSON(404, gin.H{"status": "user not found"})
+		utils.HttpResponse(c, 404, "", "user not found")
 		return
 	}
 
-	data, err := userData.GetFullTable()
+	users, err := userData.GetFullTable()
 	if err != nil {
-		c.JSON(500, gin.H{"status": "database error"})
+		utils.HttpResponse(c, 500, "", "database error")
 		return
 	}
 
-	c.JSON(200, gin.H{"user_table": data})
+	userFullResp := struct {
+		UserTable *[]data.User `json:"user_table"`
+	}{users}
+	utils.HttpResponse(c, 200, "", "success", userFullResp)
 }

service/user/info.go

@@ -2,6 +2,7 @@ package user
 
 import (
 	"nixcn-cms/data"
+	"nixcn-cms/utils"
 
 	"github.com/gin-gonic/gin"
 	"github.com/google/uuid"
@@ -11,29 +12,32 @@ func Info(c *gin.Context) {
 	userData := new(data.User)
 	userIdOrig, ok := c.Get("user_id")
 	if !ok {
-		c.JSON(403, gin.H{"status": "userid error"})
+		utils.HttpResponse(c, 403, "", "userid error")
 		return
 	}
 	userId, err := uuid.Parse(userIdOrig.(string))
 	if err != nil {
-		c.JSON(500, gin.H{"status": "failed to parse uuid"})
+		utils.HttpResponse(c, 500, "", "failed to parse uuid")
 		return
 	}
 
 	// Get user from database
 	user, err := userData.GetByUserId(userId)
 	if err != nil {
-		c.JSON(404, gin.H{"status": "user not found"})
+		utils.HttpResponse(c, 404, "", "user not found")
 		return
 	}
 
-	c.JSON(200, gin.H{
+	userInfoResp := struct {
-		"user_id":          user.UserId,
+		UserId          uuid.UUID `json:"user_id"`
-		"email":            user.Email,
+		Email           string    `json:"email"`
-		"nickname":         user.Nickname,
+		Username        string    `json:"username"`
-		"subtitle":         user.Subtitle,
+		Nickname        string    `json:"nickname"`
-		"avatar":           user.Avatar,
+		Subtitle        string    `json:"subtitle"`
-		"bio":              user.Bio,
+		Avatar          string    `json:"avatar"`
-		"permission_level": user.PermissionLevel,
+		Bio             string    `json:"bio"`
-	})
+		PermissionLevel uint      `json:"permission_level"`
+	}{user.UserId, user.Email, user.Username, user.Nickname, user.Subtitle, user.Avatar, user.Bio, user.PermissionLevel}
+
+	utils.HttpResponse(c, 200, "", "success", userInfoResp)
 }

service/user/list.go

@@ -2,6 +2,7 @@ package user
 
 import (
 	"nixcn-cms/data"
+	"nixcn-cms/utils"
 	"strconv"
 
 	"github.com/gin-gonic/gin"
@@ -15,26 +16,30 @@ func List(c *gin.Context) {
 	}
 	offset, ok := c.GetQuery("offset")
 	if !ok {
-		c.JSON(400, gin.H{"status": "offset not found"})
+		utils.HttpResponse(c, 400, "", "offset not found")
 		return
 	}
 
 	// Parse string to int64
 	limitNum, err := strconv.ParseInt(limit, 10, 64)
 	if err != nil {
-		c.JSON(400, gin.H{"status": "parse string to int error"})
+		utils.HttpResponse(c, 400, "", "parse string to int error")
 		return
 	}
 	offsetNum, err := strconv.ParseInt(offset, 10, 64)
 	if err != nil {
-		c.JSON(400, gin.H{"status": "parse string to int error"})
+		utils.HttpResponse(c, 400, "", "parse string to int error")
 		return
 	}
 
 	// Get user list from search engine
 	list, err := new(data.User).FastListUsers(limitNum, offsetNum)
 	if err != nil {
-		c.JSON(500, gin.H{"status": "failed list users from meilisearch"})
+		utils.HttpResponse(c, 500, "", "failed list users from meilisearch")
 	}
-	c.JSON(200, list)
+
+	userListResp := struct {
+		List *[]data.UserSearchDoc `json:"list"`
+	}{list}
+	utils.HttpResponse(c, 200, "", "success", userListResp)
 }

service/user/update.go

@@ -3,6 +3,7 @@ package user
 import (
 	"nixcn-cms/data"
 	"nixcn-cms/internal/cryptography"
+	"nixcn-cms/utils"
 
 	"github.com/gin-gonic/gin"
 	"github.com/google/uuid"
@@ -12,12 +13,12 @@ func Update(c *gin.Context) {
 	// New user model
 	userIdOrig, ok := c.Get("user_id")
 	if !ok {
-		c.JSON(403, gin.H{"status": "userid error"})
+		utils.HttpResponse(c, 403, "", "userid error")
 		return
 	}
 	userId, err := uuid.Parse(userIdOrig.(string))
 	if err != nil {
-		c.JSON(500, gin.H{"status": "failed to parse uuid"})
+		utils.HttpResponse(c, 500, "", "failed to parse uuid")
 		return
 	}
 
@@ -27,18 +28,29 @@ func Update(c *gin.Context) {
 	// Get user info
 	userData, err := new(data.User).GetByUserId(userId)
 	if err != nil {
-		c.JSON(500, gin.H{"status": "failed to find user"})
+		utils.HttpResponse(c, 500, "", "failed to find user")
 		return
 	}
 
-	userData.Avatar = ReqInfo.Avatar
+	if len(ReqInfo.Email) < 5 || len(ReqInfo.Email) >= 255 {
+		utils.HttpResponse(c, 400, "", "invilad email")
+		return
+	}
 	userData.Email = ReqInfo.Email
+
+	if len(ReqInfo.Username) < 5 || len(ReqInfo.Username) >= 255 {
+		utils.HttpResponse(c, 400, "", "invilad user name")
+		return
+	}
+	userData.Username = ReqInfo.Username
+
 	userData.Nickname = ReqInfo.Nickname
 	userData.Subtitle = ReqInfo.Subtitle
+	userData.Avatar = ReqInfo.Avatar
 
 	if ReqInfo.Bio != "" {
 		if !cryptography.IsBase64Std(ReqInfo.Bio) {
-			c.JSON(400, gin.H{"status": "invalid base64"})
+			utils.HttpResponse(c, 400, "", "invalid base64")
 		}
 	}
 	userData.Bio = ReqInfo.Bio
@@ -46,5 +58,5 @@ func Update(c *gin.Context) {
 	// Update user info
 	userData.UpdateByUserID(userId)
 
-	c.JSON(200, gin.H{"status": "success"})
+	utils.HttpResponse(c, 200, "", "success")
 }

utils/response.go

@@ -0,0 +1,30 @@
+package utils
+
+import "github.com/gin-gonic/gin"
+
+type RespStatus struct {
+	Code    int    `json:"code"`
+	ErrorId string `json:"error_id"`
+	Status  string `json:"status"`
+	Data    any    `json:"data"`
+}
+
+func HttpResponse(c *gin.Context, code int, errorId string, status string, data ...any) {
+	var resp = RespStatus{
+		Code:    code,
+		ErrorId: errorId,
+		Status:  status,
+		Data:    data,
+	}
+	c.JSON(code, resp)
+}
+
+func HttpAbort(c *gin.Context, code int, errorId string, status string, data ...any) {
+	var resp = RespStatus{
+		Code:    code,
+		ErrorId: errorId,
+		Status:  status,
+		Data:    data,
+	}
+	c.AbortWithStatusJSON(code, resp)
+}