From 6a9c013799b4f7de4864cab612a5206debc59c9d Mon Sep 17 00:00:00 2001 From: Asai Neko Date: Tue, 6 Jan 2026 12:49:55 +0800 Subject: [PATCH] Use utils.HttpResponse/Abort to replace c.JSON/Abort Signed-off-by: Asai Neko --- data/user.go | 34 ++++++++++++++++-------------- middleware/jwt.go | 5 +++-- middleware/permission.go | 9 ++++---- service/auth/magic.go | 21 ++++++++++++------- service/auth/redirect.go | 32 ++++++++++++++-------------- service/auth/refresh.go | 21 +++++++++++-------- service/auth/token.go | 19 ++++++++++------- service/event/checkin.go | 45 ++++++++++++++++++++++++---------------- service/event/info.go | 20 +++++++++++------- service/user/full.go | 16 ++++++++------ service/user/info.go | 28 ++++++++++++++----------- service/user/list.go | 15 +++++++++----- service/user/update.go | 24 +++++++++++++++------ utils/response.go | 30 +++++++++++++++++++++++++++ 14 files changed, 203 insertions(+), 116 deletions(-) create mode 100644 utils/response.go diff --git a/data/user.go b/data/user.go index 5bcfab1..887ee93 100644 --- a/data/user.go +++ b/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"` - Subtitle string `json:"subtitle"` - Avatar string `json:"avatar"` + Username string `json:"username" gorm:"type:varchar(255);uniqueindex;not null"` + Nickname string `json:"nickname" gorm:"type:text"` + 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"` - Email string `json:"email"` - Type string `json:"type"` - Nickname string `json:"nickname"` - Subtitle string `json:"subtitle"` - Avatar string `json:"avatar"` - PermissionLevel uint `json:"permission_level"` + UserId string `json:"user_id"` + Email string `json:"email"` + Username string `json:"username"` + Type string `json:"type"` + Nickname string `json:"nickname"` + Subtitle string `json:"subtitle"` + 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(), - Email: self.Email, - Nickname: self.Nickname, - Subtitle: self.Subtitle, - Avatar: self.Avatar, - PermissionLevel: self.PermissionLevel, + UserId: self.UserId.String(), + Email: self.Email, + Username: self.Username, + Nickname: self.Nickname, + Subtitle: self.Subtitle, + Avatar: self.Avatar, } index := MeiliSearch.Index("user") diff --git a/middleware/jwt.go b/middleware/jwt.go index 6ef188b..ace983c 100644 --- a/middleware/jwt.go +++ b/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 } diff --git a/middleware/permission.go b/middleware/permission.go index 74b0c0f..c010197 100644 --- a/middleware/permission.go +++ b/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 } diff --git a/service/auth/magic.go b/service/auth/magic.go index 634d74a..e3291fd 100644 --- a/service/auth/magic.go +++ b/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") } diff --git a/service/auth/redirect.go b/service/auth/redirect.go index 3161835..dce3d7f 100644 --- a/service/auth/redirect.go +++ b/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() diff --git a/service/auth/refresh.go b/service/auth/refresh.go index fc441b1..6851a5b 100644 --- a/service/auth/refresh.go +++ b/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{ - "access_token": access, - "refresh_token": refresh, - }) + tokenResp := struct { + AccessToken string `json:"access_token"` + RefreshToken string `json:"refresh_token"` + }{accessToken, refreshToken} + + utils.HttpResponse(c, 200, "", "success", tokenResp) } diff --git a/service/auth/token.go b/service/auth/token.go index 2af75ac..c2d574a 100644 --- a/service/auth/token.go +++ b/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{ - "access_token": accessToken, - "refresh_token": refreshToken, - }) + tokenResp := struct { + AccessToken string `json:"access_token"` + RefreshToken string `json:"refresh_token"` + }{accessToken, refreshToken} + + utils.HttpResponse(c, 200, "", "success", tokenResp) } diff --git a/service/event/checkin.go b/service/event/checkin.go index 7a573b4..9adbd01 100644 --- a/service/event/checkin.go +++ b/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{ - "status": "failed to parse uuid", - }) + utils.HttpResponse(c, 500, "", "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) } diff --git a/service/event/info.go b/service/event/info.go index b9ede68..747ce1e 100644 --- a/service/event/info.go +++ b/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{ - "name": event.Name, - "start_time": event.StartTime, - "end_time": event.EndTime, - }) + eventInfoResp := struct { + Name string `json:"name"` + StartTime time.Time `json:"start_time"` + EndTime time.Time `json:"end_time"` + }{event.Name, event.StartTime, event.EndTime} + + utils.HttpResponse(c, 200, "", "success", eventInfoResp) } diff --git a/service/user/full.go b/service/user/full.go index 3fd2216..edd2106 100644 --- a/service/user/full.go +++ b/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) } diff --git a/service/user/info.go b/service/user/info.go index 5e50450..17b88eb 100644 --- a/service/user/info.go +++ b/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{ - "user_id": user.UserId, - "email": user.Email, - "nickname": user.Nickname, - "subtitle": user.Subtitle, - "avatar": user.Avatar, - "bio": user.Bio, - "permission_level": user.PermissionLevel, - }) + userInfoResp := struct { + UserId uuid.UUID `json:"user_id"` + Email string `json:"email"` + Username string `json:"username"` + Nickname string `json:"nickname"` + Subtitle string `json:"subtitle"` + Avatar string `json:"avatar"` + 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) } diff --git a/service/user/list.go b/service/user/list.go index 1564aa5..eb9b717 100644 --- a/service/user/list.go +++ b/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) } diff --git a/service/user/update.go b/service/user/update.go index ea19b61..0043b53 100644 --- a/service/user/update.go +++ b/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") } diff --git a/utils/response.go b/utils/response.go new file mode 100644 index 0000000..6f239b7 --- /dev/null +++ b/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) +}