diff --git a/openflare_server/controller/acme_account.go b/openflare_server/controller/acme_account.go index 33903151..000b4084 100644 --- a/openflare_server/controller/acme_account.go +++ b/openflare_server/controller/acme_account.go @@ -2,7 +2,6 @@ package controller import ( "github.com/gin-gonic/gin" - "net/http" "openflare/model" ) @@ -16,15 +15,8 @@ import ( func GetDefaultAcmeAccount(c *gin.Context) { account, err := model.GetDefaultAcmeAccount() if err != nil { - c.JSON(http.StatusOK, gin.H{ - "success": false, - "message": err.Error(), - }) + respondFailure(c, err.Error()) return } - c.JSON(http.StatusOK, gin.H{ - "success": true, - "message": "", - "data": account, - }) + respondSuccess(c, account) } diff --git a/openflare_server/controller/database.go b/openflare_server/controller/database.go index 29a4989b..a1ef3f51 100644 --- a/openflare_server/controller/database.go +++ b/openflare_server/controller/database.go @@ -1,7 +1,6 @@ package controller import ( - "net/http" "openflare/service" "github.com/gin-gonic/gin" @@ -18,11 +17,7 @@ import ( func CleanupDatabaseObservability(c *gin.Context) { var input service.DatabaseCleanupInput if err := decodeOptionalJSONBody(c.Request.Body, &input); err != nil { - c.JSON(http.StatusBadRequest, gin.H{ - "success": false, - "message": "参数错误", - "error": err.Error(), - }) + respondBadRequest(c, "") return } result, err := service.CleanupDatabaseObservability(input) diff --git a/openflare_server/controller/dns_account.go b/openflare_server/controller/dns_account.go index 050ce3bb..4b4e2ef6 100644 --- a/openflare_server/controller/dns_account.go +++ b/openflare_server/controller/dns_account.go @@ -1,11 +1,8 @@ package controller import ( - "encoding/json" "github.com/gin-gonic/gin" - "net/http" "openflare/model" - "strconv" ) type DnsAccountInput struct { @@ -24,17 +21,10 @@ type DnsAccountInput struct { func GetDnsAccounts(c *gin.Context) { accounts, err := model.ListDnsAccounts() if err != nil { - c.JSON(http.StatusOK, gin.H{ - "success": false, - "message": err.Error(), - }) + respondFailure(c, err.Error()) return } - c.JSON(http.StatusOK, gin.H{ - "success": true, - "message": "", - "data": accounts, - }) + respondSuccess(c, accounts) } // CreateDnsAccount godoc @@ -48,11 +38,7 @@ func GetDnsAccounts(c *gin.Context) { // @Router /api/dns-accounts/ [post] func CreateDnsAccount(c *gin.Context) { var input DnsAccountInput - if err := json.NewDecoder(c.Request.Body).Decode(&input); err != nil { - c.JSON(http.StatusBadRequest, gin.H{ - "success": false, - "message": "无效的参数", - }) + if !bindJSON(c, &input) { return } @@ -63,18 +49,11 @@ func CreateDnsAccount(c *gin.Context) { } if err := account.Insert(); err != nil { - c.JSON(http.StatusOK, gin.H{ - "success": false, - "message": err.Error(), - }) + respondFailure(c, err.Error()) return } - c.JSON(http.StatusOK, gin.H{ - "success": true, - "message": "", - "data": account, - }) + respondSuccess(c, account) } // UpdateDnsAccount godoc @@ -88,30 +67,19 @@ func CreateDnsAccount(c *gin.Context) { // @Success 200 {object} map[string]interface{} // @Router /api/dns-accounts/{id}/update [post] func UpdateDnsAccount(c *gin.Context) { - id, err := strconv.ParseUint(c.Param("id"), 10, 64) - if err != nil || id == 0 { - c.JSON(http.StatusBadRequest, gin.H{ - "success": false, - "message": "无效的参数", - }) + id, ok := parseIDParam(c) + if !ok { return } var input DnsAccountInput - if err := json.NewDecoder(c.Request.Body).Decode(&input); err != nil { - c.JSON(http.StatusBadRequest, gin.H{ - "success": false, - "message": "无效的参数", - }) + if !bindJSON(c, &input) { return } - account, err := model.GetDnsAccountByID(uint(id)) + account, err := model.GetDnsAccountByID(id) if err != nil { - c.JSON(http.StatusOK, gin.H{ - "success": false, - "message": err.Error(), - }) + respondFailure(c, err.Error()) return } @@ -120,18 +88,11 @@ func UpdateDnsAccount(c *gin.Context) { account.Authorization = input.Authorization if err := account.Update(); err != nil { - c.JSON(http.StatusOK, gin.H{ - "success": false, - "message": err.Error(), - }) + respondFailure(c, err.Error()) return } - c.JSON(http.StatusOK, gin.H{ - "success": true, - "message": "", - "data": account, - }) + respondSuccess(c, account) } // DeleteDnsAccount godoc @@ -143,21 +104,14 @@ func UpdateDnsAccount(c *gin.Context) { // @Success 200 {object} map[string]interface{} // @Router /api/dns-accounts/{id}/delete [post] func DeleteDnsAccount(c *gin.Context) { - id, err := strconv.ParseUint(c.Param("id"), 10, 64) - if err != nil || id == 0 { - c.JSON(http.StatusBadRequest, gin.H{ - "success": false, - "message": "无效的参数", - }) + id, ok := parseIDParam(c) + if !ok { return } - account, err := model.GetDnsAccountByID(uint(id)) + account, err := model.GetDnsAccountByID(id) if err != nil { - c.JSON(http.StatusOK, gin.H{ - "success": false, - "message": err.Error(), - }) + respondFailure(c, err.Error()) return } @@ -165,23 +119,14 @@ func DeleteDnsAccount(c *gin.Context) { var count int64 model.DB.Model(&model.TLSCertificate{}).Where("dns_account_id = ?", id).Count(&count) if count > 0 { - c.JSON(http.StatusOK, gin.H{ - "success": false, - "message": "该 DNS 账号已被证书使用，无法删除", - }) + respondFailure(c, "该 DNS 账号已被证书使用，无法删除") return } if err := account.Delete(); err != nil { - c.JSON(http.StatusOK, gin.H{ - "success": false, - "message": err.Error(), - }) + respondFailure(c, err.Error()) return } - c.JSON(http.StatusOK, gin.H{ - "success": true, - "message": "", - }) + respondSuccess(c, nil) } diff --git a/openflare_server/controller/geoip.go b/openflare_server/controller/geoip.go index 3d803ca2..6e7c65ec 100644 --- a/openflare_server/controller/geoip.go +++ b/openflare_server/controller/geoip.go @@ -22,8 +22,7 @@ type geoIPLookupRequest struct { // @Router /api/option/geoip/lookup [post] func LookupGeoIP(c *gin.Context) { var request geoIPLookupRequest - if err := decodeJSONBody(c.Request.Body, &request); err != nil { - respondBadRequest(c, "") + if !bindJSON(c, &request) { return } diff --git a/openflare_server/controller/managed_domain.go b/openflare_server/controller/managed_domain.go index 2279ec90..4f163f5f 100644 --- a/openflare_server/controller/managed_domain.go +++ b/openflare_server/controller/managed_domain.go @@ -1,11 +1,8 @@ package controller import ( - "encoding/json" "github.com/gin-gonic/gin" - "net/http" "openflare/service" - "strconv" "strings" ) @@ -19,17 +16,10 @@ import ( func GetManagedDomains(c *gin.Context) { domains, err := service.ListManagedDomains() if err != nil { - c.JSON(http.StatusOK, gin.H{ - "success": false, - "message": err.Error(), - }) + respondFailure(c, err.Error()) return } - c.JSON(http.StatusOK, gin.H{ - "success": true, - "message": "", - "data": domains, - }) + respondSuccess(c, domains) } // CreateManagedDomain godoc @@ -44,26 +34,15 @@ func GetManagedDomains(c *gin.Context) { // @Router /api/managed-domains/ [post] func CreateManagedDomain(c *gin.Context) { var input service.ManagedDomainInput - if err := json.NewDecoder(c.Request.Body).Decode(&input); err != nil { - c.JSON(http.StatusBadRequest, gin.H{ - "success": false, - "message": "无效的参数", - }) + if !bindJSON(c, &input) { return } domain, err := service.CreateManagedDomain(input) if err != nil { - c.JSON(http.StatusOK, gin.H{ - "success": false, - "message": err.Error(), - }) + respondFailure(c, err.Error()) return } - c.JSON(http.StatusOK, gin.H{ - "success": true, - "message": "", - "data": domain, - }) + respondSuccess(c, domain) } // UpdateManagedDomain godoc @@ -78,35 +57,20 @@ func CreateManagedDomain(c *gin.Context) { // @Failure 400 {object} map[string]interface{} // @Router /api/managed-domains/{id}/update [post] func UpdateManagedDomain(c *gin.Context) { - id, err := strconv.ParseUint(c.Param("id"), 10, 64) - if err != nil || id == 0 { - c.JSON(http.StatusBadRequest, gin.H{ - "success": false, - "message": "无效的参数", - }) + id, ok := parseIDParam(c) + if !ok { return } var input service.ManagedDomainInput - if err = json.NewDecoder(c.Request.Body).Decode(&input); err != nil { - c.JSON(http.StatusBadRequest, gin.H{ - "success": false, - "message": "无效的参数", - }) + if !bindJSON(c, &input) { return } - domain, err := service.UpdateManagedDomain(uint(id), input) + domain, err := service.UpdateManagedDomain(id, input) if err != nil { - c.JSON(http.StatusOK, gin.H{ - "success": false, - "message": err.Error(), - }) + respondFailure(c, err.Error()) return } - c.JSON(http.StatusOK, gin.H{ - "success": true, - "message": "", - "data": domain, - }) + respondSuccess(c, domain) } // DeleteManagedDomain godoc @@ -119,25 +83,15 @@ func UpdateManagedDomain(c *gin.Context) { // @Failure 400 {object} map[string]interface{} // @Router /api/managed-domains/{id}/delete [post] func DeleteManagedDomain(c *gin.Context) { - id, err := strconv.ParseUint(c.Param("id"), 10, 64) - if err != nil || id == 0 { - c.JSON(http.StatusBadRequest, gin.H{ - "success": false, - "message": "无效的参数", - }) + id, ok := parseIDParam(c) + if !ok { return } - if err = service.DeleteManagedDomain(uint(id)); err != nil { - c.JSON(http.StatusOK, gin.H{ - "success": false, - "message": err.Error(), - }) + if err := service.DeleteManagedDomain(id); err != nil { + respondFailure(c, err.Error()) return } - c.JSON(http.StatusOK, gin.H{ - "success": true, - "message": "", - }) + respondSuccess(c, nil) } // MatchManagedDomainCertificate godoc @@ -152,15 +106,8 @@ func MatchManagedDomainCertificate(c *gin.Context) { domain := strings.TrimSpace(c.Query("domain")) result, err := service.MatchManagedDomainCertificate(domain) if err != nil { - c.JSON(http.StatusOK, gin.H{ - "success": false, - "message": err.Error(), - }) + respondFailure(c, err.Error()) return } - c.JSON(http.StatusOK, gin.H{ - "success": true, - "message": "", - "data": result, - }) + respondSuccess(c, result) } diff --git a/openflare_server/controller/node.go b/openflare_server/controller/node.go index b8254e32..ff88fa21 100644 --- a/openflare_server/controller/node.go +++ b/openflare_server/controller/node.go @@ -2,7 +2,6 @@ package controller import ( "openflare/service" - "strconv" "github.com/gin-gonic/gin" ) @@ -29,8 +28,7 @@ type nodeObservabilityQuery struct { // @Router /api/nodes/ [post] func CreateNode(c *gin.Context) { var input service.NodeInput - if err := decodeJSONBody(c.Request.Body, &input); err != nil { - respondBadRequest(c, "") + if !bindJSON(c, &input) { return } @@ -86,19 +84,17 @@ func RotateNodeBootstrapToken(c *gin.Context) { // @Failure 400 {object} map[string]interface{} // @Router /api/nodes/{id}/update [post] func UpdateNode(c *gin.Context) { - id, err := strconv.ParseUint(c.Param("id"), 10, 64) - if err != nil || id == 0 { - respondBadRequest(c, "") + id, ok := parseIDParam(c) + if !ok { return } var input service.NodeInput - if err = decodeJSONBody(c.Request.Body, &input); err != nil { - respondBadRequest(c, "") + if !bindJSON(c, &input) { return } - node, err := service.UpdateNode(uint(id), input) + node, err := service.UpdateNode(id, input) if err != nil { respondFailure(c, err.Error()) return @@ -116,13 +112,12 @@ func UpdateNode(c *gin.Context) { // @Failure 400 {object} map[string]interface{} // @Router /api/nodes/{id}/delete [post] func DeleteNode(c *gin.Context) { - id, err := strconv.ParseUint(c.Param("id"), 10, 64) - if err != nil || id == 0 { - respondBadRequest(c, "") + id, ok := parseIDParam(c) + if !ok { return } - if err = service.DeleteNode(uint(id)); err != nil { + if err := service.DeleteNode(id); err != nil { respondFailure(c, err.Error()) return } @@ -139,21 +134,20 @@ func DeleteNode(c *gin.Context) { // @Failure 400 {object} map[string]interface{} // @Router /api/nodes/{id}/agent-update [post] func RequestNodeAgentUpdate(c *gin.Context) { - id, err := strconv.ParseUint(c.Param("id"), 10, 64) - if err != nil || id == 0 { - respondBadRequest(c, "") + id, ok := parseIDParam(c) + if !ok { return } var request nodeAgentUpdateRequest if c.Request.ContentLength > 0 { - if err = decodeOptionalJSONBody(c.Request.Body, &request); err != nil { + if err := decodeOptionalJSONBody(c.Request.Body, &request); err != nil { respondBadRequest(c, "") return } } - node, err := service.RequestNodeAgentUpdate(uint(id), service.NodeAgentUpdateInput{ + node, err := service.RequestNodeAgentUpdate(id, service.NodeAgentUpdateInput{ Channel: request.Channel, TagName: request.TagName, }) @@ -174,13 +168,12 @@ func RequestNodeAgentUpdate(c *gin.Context) { // @Failure 400 {object} map[string]interface{} // @Router /api/nodes/{id}/openresty-restart [post] func RequestNodeOpenrestyRestart(c *gin.Context) { - id, err := strconv.ParseUint(c.Param("id"), 10, 64) - if err != nil || id == 0 { - respondBadRequest(c, "") + id, ok := parseIDParam(c) + if !ok { return } - node, err := service.RequestNodeOpenrestyRestart(uint(id)) + node, err := service.RequestNodeOpenrestyRestart(id) if err != nil { respondFailure(c, err.Error()) return @@ -198,13 +191,12 @@ func RequestNodeOpenrestyRestart(c *gin.Context) { // @Failure 400 {object} map[string]interface{} // @Router /api/nodes/{id}/force-sync [post] func RequestNodeForceSync(c *gin.Context) { - id, err := strconv.ParseUint(c.Param("id"), 10, 64) - if err != nil || id == 0 { - respondBadRequest(c, "") + id, ok := parseIDParam(c) + if !ok { return } - node, err := service.RequestNodeForceSync(uint(id)) + node, err := service.RequestNodeForceSync(id) if err != nil { respondFailure(c, err.Error()) return @@ -223,13 +215,12 @@ func RequestNodeForceSync(c *gin.Context) { // @Failure 400 {object} map[string]interface{} // @Router /api/nodes/{id}/agent-release [get] func GetNodeAgentRelease(c *gin.Context) { - id, err := strconv.ParseUint(c.Param("id"), 10, 64) - if err != nil || id == 0 { - respondBadRequest(c, "") + id, ok := parseIDParam(c) + if !ok { return } - release, err := service.GetNodeAgentRelease(c.Request.Context(), uint(id), c.Query("channel")) + release, err := service.GetNodeAgentRelease(c.Request.Context(), id, c.Query("channel")) if err != nil { respondFailure(c, err.Error()) return @@ -249,19 +240,18 @@ func GetNodeAgentRelease(c *gin.Context) { // @Failure 400 {object} map[string]interface{} // @Router /api/nodes/{id}/observability [get] func GetNodeObservability(c *gin.Context) { - id, err := strconv.ParseUint(c.Param("id"), 10, 64) - if err != nil || id == 0 { - respondBadRequest(c, "") + id, ok := parseIDParam(c) + if !ok { return } var query nodeObservabilityQuery - if err = c.ShouldBindQuery(&query); err != nil { + if err := c.ShouldBindQuery(&query); err != nil { respondBadRequest(c, "") return } - view, err := service.GetNodeObservability(uint(id), service.NodeObservabilityQuery{ + view, err := service.GetNodeObservability(id, service.NodeObservabilityQuery{ Hours: query.Hours, Limit: query.Limit, }) @@ -282,13 +272,12 @@ func GetNodeObservability(c *gin.Context) { // @Failure 400 {object} map[string]interface{} // @Router /api/nodes/{id}/observability/cleanup [post] func CleanupNodeHealthEvents(c *gin.Context) { - id, err := strconv.ParseUint(c.Param("id"), 10, 64) - if err != nil || id == 0 { - respondBadRequest(c, "") + id, ok := parseIDParam(c) + if !ok { return } - result, err := service.CleanupNodeHealthEvents(uint(id)) + result, err := service.CleanupNodeHealthEvents(id) if err != nil { respondFailure(c, err.Error()) return diff --git a/openflare_server/controller/origin.go b/openflare_server/controller/origin.go index 16b57a93..c8d0b9f1 100644 --- a/openflare_server/controller/origin.go +++ b/openflare_server/controller/origin.go @@ -1,128 +1,70 @@ package controller import ( - "encoding/json" - "net/http" - "openflare/service" - "strconv" - "github.com/gin-gonic/gin" + "openflare/service" ) func GetOrigins(c *gin.Context) { origins, err := service.ListOrigins() if err != nil { - c.JSON(http.StatusOK, gin.H{ - "success": false, - "message": err.Error(), - }) + respondFailure(c, err.Error()) return } - c.JSON(http.StatusOK, gin.H{ - "success": true, - "message": "", - "data": origins, - }) + respondSuccess(c, origins) } func GetOrigin(c *gin.Context) { - id, err := strconv.ParseUint(c.Param("id"), 10, 64) - if err != nil || id == 0 { - c.JSON(http.StatusBadRequest, gin.H{ - "success": false, - "message": "无效的参数", - }) + id, ok := parseIDParam(c) + if !ok { return } - origin, err := service.GetOriginDetail(uint(id)) + origin, err := service.GetOriginDetail(id) if err != nil { - c.JSON(http.StatusOK, gin.H{ - "success": false, - "message": err.Error(), - }) + respondFailure(c, err.Error()) return } - c.JSON(http.StatusOK, gin.H{ - "success": true, - "message": "", - "data": origin, - }) + respondSuccess(c, origin) } func CreateOrigin(c *gin.Context) { var input service.OriginInput - if err := json.NewDecoder(c.Request.Body).Decode(&input); err != nil { - c.JSON(http.StatusBadRequest, gin.H{ - "success": false, - "message": "无效的参数", - }) + if !bindJSON(c, &input) { return } origin, err := service.CreateOrigin(input) if err != nil { - c.JSON(http.StatusOK, gin.H{ - "success": false, - "message": err.Error(), - }) + respondFailure(c, err.Error()) return } - c.JSON(http.StatusOK, gin.H{ - "success": true, - "message": "", - "data": origin, - }) + respondSuccess(c, origin) } func UpdateOrigin(c *gin.Context) { - id, err := strconv.ParseUint(c.Param("id"), 10, 64) - if err != nil || id == 0 { - c.JSON(http.StatusBadRequest, gin.H{ - "success": false, - "message": "无效的参数", - }) + id, ok := parseIDParam(c) + if !ok { return } var input service.OriginInput - if err = json.NewDecoder(c.Request.Body).Decode(&input); err != nil { - c.JSON(http.StatusBadRequest, gin.H{ - "success": false, - "message": "无效的参数", - }) + if !bindJSON(c, &input) { return } - origin, err := service.UpdateOrigin(uint(id), input) + origin, err := service.UpdateOrigin(id, input) if err != nil { - c.JSON(http.StatusOK, gin.H{ - "success": false, - "message": err.Error(), - }) + respondFailure(c, err.Error()) return } - c.JSON(http.StatusOK, gin.H{ - "success": true, - "message": "", - "data": origin, - }) + respondSuccess(c, origin) } func DeleteOrigin(c *gin.Context) { - id, err := strconv.ParseUint(c.Param("id"), 10, 64) - if err != nil || id == 0 { - c.JSON(http.StatusBadRequest, gin.H{ - "success": false, - "message": "无效的参数", - }) + id, ok := parseIDParam(c) + if !ok { return } - if err = service.DeleteOrigin(uint(id)); err != nil { - c.JSON(http.StatusOK, gin.H{ - "success": false, - "message": err.Error(), - }) + if err := service.DeleteOrigin(id); err != nil { + respondFailure(c, err.Error()) return } - c.JSON(http.StatusOK, gin.H{ - "success": true, - "message": "", - }) + respondSuccess(c, nil) } diff --git a/openflare_server/controller/proxy_route.go b/openflare_server/controller/proxy_route.go index 556d83ce..280241ce 100644 --- a/openflare_server/controller/proxy_route.go +++ b/openflare_server/controller/proxy_route.go @@ -1,12 +1,8 @@ package controller import ( - "encoding/json" - "net/http" - "openflare/service" - "strconv" - "github.com/gin-gonic/gin" + "openflare/service" ) // GetProxyRoutes godoc @@ -19,17 +15,10 @@ import ( func GetProxyRoutes(c *gin.Context) { routes, err := service.ListProxyRoutes() if err != nil { - c.JSON(http.StatusOK, gin.H{ - "success": false, - "message": err.Error(), - }) + respondFailure(c, err.Error()) return } - c.JSON(http.StatusOK, gin.H{ - "success": true, - "message": "", - "data": routes, - }) + respondSuccess(c, routes) } // GetProxyRoute godoc @@ -42,27 +31,16 @@ func GetProxyRoutes(c *gin.Context) { // @Failure 400 {object} map[string]interface{} // @Router /api/proxy-routes/{id} [get] func GetProxyRoute(c *gin.Context) { - id, err := strconv.ParseUint(c.Param("id"), 10, 64) - if err != nil || id == 0 { - c.JSON(http.StatusBadRequest, gin.H{ - "success": false, - "message": "invalid id", - }) + id, ok := parseIDParam(c) + if !ok { return } - route, err := service.GetProxyRoute(uint(id)) + route, err := service.GetProxyRoute(id) if err != nil { - c.JSON(http.StatusOK, gin.H{ - "success": false, - "message": err.Error(), - }) + respondFailure(c, err.Error()) return } - c.JSON(http.StatusOK, gin.H{ - "success": true, - "message": "", - "data": route, - }) + respondSuccess(c, route) } // CreateProxyRoute godoc @@ -77,26 +55,15 @@ func GetProxyRoute(c *gin.Context) { // @Router /api/proxy-routes/ [post] func CreateProxyRoute(c *gin.Context) { var input service.ProxyRouteInput - if err := json.NewDecoder(c.Request.Body).Decode(&input); err != nil { - c.JSON(http.StatusBadRequest, gin.H{ - "success": false, - "message": "invalid payload", - }) + if !bindJSON(c, &input) { return } route, err := service.CreateProxyRoute(input) if err != nil { - c.JSON(http.StatusOK, gin.H{ - "success": false, - "message": err.Error(), - }) + respondFailure(c, err.Error()) return } - c.JSON(http.StatusOK, gin.H{ - "success": true, - "message": "", - "data": route, - }) + respondSuccess(c, route) } // UpdateProxyRoute godoc @@ -111,35 +78,20 @@ func CreateProxyRoute(c *gin.Context) { // @Failure 400 {object} map[string]interface{} // @Router /api/proxy-routes/{id}/update [post] func UpdateProxyRoute(c *gin.Context) { - id, err := strconv.ParseUint(c.Param("id"), 10, 64) - if err != nil || id == 0 { - c.JSON(http.StatusBadRequest, gin.H{ - "success": false, - "message": "invalid id", - }) + id, ok := parseIDParam(c) + if !ok { return } var input service.ProxyRouteInput - if err = json.NewDecoder(c.Request.Body).Decode(&input); err != nil { - c.JSON(http.StatusBadRequest, gin.H{ - "success": false, - "message": "invalid payload", - }) + if !bindJSON(c, &input) { return } - route, err := service.UpdateProxyRoute(uint(id), input) + route, err := service.UpdateProxyRoute(id, input) if err != nil { - c.JSON(http.StatusOK, gin.H{ - "success": false, - "message": err.Error(), - }) + respondFailure(c, err.Error()) return } - c.JSON(http.StatusOK, gin.H{ - "success": true, - "message": "", - "data": route, - }) + respondSuccess(c, route) } // DeleteProxyRoute godoc @@ -152,23 +104,13 @@ func UpdateProxyRoute(c *gin.Context) { // @Failure 400 {object} map[string]interface{} // @Router /api/proxy-routes/{id}/delete [post] func DeleteProxyRoute(c *gin.Context) { - id, err := strconv.ParseUint(c.Param("id"), 10, 64) - if err != nil || id == 0 { - c.JSON(http.StatusBadRequest, gin.H{ - "success": false, - "message": "invalid id", - }) + id, ok := parseIDParam(c) + if !ok { return } - if err = service.DeleteProxyRoute(uint(id)); err != nil { - c.JSON(http.StatusOK, gin.H{ - "success": false, - "message": err.Error(), - }) + if err := service.DeleteProxyRoute(id); err != nil { + respondFailure(c, err.Error()) return } - c.JSON(http.StatusOK, gin.H{ - "success": true, - "message": "", - }) + respondSuccess(c, nil) } diff --git a/openflare_server/controller/response.go b/openflare_server/controller/response.go index 713dc548..34a4888a 100644 --- a/openflare_server/controller/response.go +++ b/openflare_server/controller/response.go @@ -5,11 +5,12 @@ import ( "errors" "io" "net/http" + "strconv" "github.com/gin-gonic/gin" ) -const invalidParamsMessage = "鏃犳晥鐨勫弬鏁?" +const invalidParamsMessage = "参数错误" func respondSuccess(c *gin.Context, data any) { c.JSON(http.StatusOK, gin.H{ @@ -72,3 +73,20 @@ func decodeOptionalJSONBody(body io.Reader, target any) error { } return nil } + +func parseIDParam(c *gin.Context) (uint, bool) { + id, err := strconv.ParseUint(c.Param("id"), 10, 64) + if err != nil || id == 0 { + respondBadRequest(c, "") + return 0, false + } + return uint(id), true +} + +func bindJSON(c *gin.Context, target any) bool { + if err := decodeJSONBody(c.Request.Body, target); err != nil { + respondBadRequest(c, "") + return false + } + return true +} diff --git a/openflare_server/controller/tls_certificate.go b/openflare_server/controller/tls_certificate.go index 79b02b35..2ce5c5d0 100644 --- a/openflare_server/controller/tls_certificate.go +++ b/openflare_server/controller/tls_certificate.go @@ -1,11 +1,8 @@ package controller import ( - "encoding/json" "github.com/gin-gonic/gin" - "net/http" "openflare/service" - "strconv" ) // GetTLSCertificates godoc @@ -18,17 +15,10 @@ import ( func GetTLSCertificates(c *gin.Context) { certificates, err := service.ListTLSCertificates() if err != nil { - c.JSON(http.StatusOK, gin.H{ - "success": false, - "message": err.Error(), - }) + respondFailure(c, err.Error()) return } - c.JSON(http.StatusOK, gin.H{ - "success": true, - "message": "", - "data": certificates, - }) + respondSuccess(c, certificates) } // GetTLSCertificate godoc @@ -41,28 +31,17 @@ func GetTLSCertificates(c *gin.Context) { // @Failure 400 {object} map[string]interface{} // @Router /api/tls-certificates/{id} [get] func GetTLSCertificate(c *gin.Context) { - id, err := strconv.ParseUint(c.Param("id"), 10, 64) - if err != nil || id == 0 { - c.JSON(http.StatusBadRequest, gin.H{ - "success": false, - "message": "invalid request", - }) + id, ok := parseIDParam(c) + if !ok { return } - certificate, err := service.GetTLSCertificate(uint(id)) + certificate, err := service.GetTLSCertificate(id) if err != nil { - c.JSON(http.StatusOK, gin.H{ - "success": false, - "message": err.Error(), - }) + respondFailure(c, err.Error()) return } - c.JSON(http.StatusOK, gin.H{ - "success": true, - "message": "", - "data": certificate, - }) + respondSuccess(c, certificate) } // GetTLSCertificateContent godoc @@ -75,28 +54,17 @@ func GetTLSCertificate(c *gin.Context) { // @Failure 400 {object} map[string]interface{} // @Router /api/tls-certificates/{id}/content [get] func GetTLSCertificateContent(c *gin.Context) { - id, err := strconv.ParseUint(c.Param("id"), 10, 64) - if err != nil || id == 0 { - c.JSON(http.StatusBadRequest, gin.H{ - "success": false, - "message": "invalid request", - }) + id, ok := parseIDParam(c) + if !ok { return } - content, err := service.GetTLSCertificateContent(uint(id)) + content, err := service.GetTLSCertificateContent(id) if err != nil { - c.JSON(http.StatusOK, gin.H{ - "success": false, - "message": err.Error(), - }) + respondFailure(c, err.Error()) return } - c.JSON(http.StatusOK, gin.H{ - "success": true, - "message": "", - "data": content, - }) + respondSuccess(c, content) } // CreateTLSCertificate godoc @@ -111,26 +79,15 @@ func GetTLSCertificateContent(c *gin.Context) { // @Router /api/tls-certificates/ [post] func CreateTLSCertificate(c *gin.Context) { var input service.TLSCertificateInput - if err := json.NewDecoder(c.Request.Body).Decode(&input); err != nil { - c.JSON(http.StatusBadRequest, gin.H{ - "success": false, - "message": "无效的参数", - }) + if !bindJSON(c, &input) { return } certificate, err := service.CreateTLSCertificate(input) if err != nil { - c.JSON(http.StatusOK, gin.H{ - "success": false, - "message": err.Error(), - }) + respondFailure(c, err.Error()) return } - c.JSON(http.StatusOK, gin.H{ - "success": true, - "message": "", - "data": certificate, - }) + respondSuccess(c, certificate) } // UpdateTLSCertificate godoc @@ -145,37 +102,22 @@ func CreateTLSCertificate(c *gin.Context) { // @Failure 400 {object} map[string]interface{} // @Router /api/tls-certificates/{id}/update [post] func UpdateTLSCertificate(c *gin.Context) { - id, err := strconv.ParseUint(c.Param("id"), 10, 64) - if err != nil || id == 0 { - c.JSON(http.StatusBadRequest, gin.H{ - "success": false, - "message": "invalid request", - }) + id, ok := parseIDParam(c) + if !ok { return } var input service.TLSCertificateInput - if err = json.NewDecoder(c.Request.Body).Decode(&input); err != nil { - c.JSON(http.StatusBadRequest, gin.H{ - "success": false, - "message": "invalid request", - }) + if !bindJSON(c, &input) { return } - certificate, err := service.UpdateTLSCertificate(uint(id), input) + certificate, err := service.UpdateTLSCertificate(id, input) if err != nil { - c.JSON(http.StatusOK, gin.H{ - "success": false, - "message": err.Error(), - }) + respondFailure(c, err.Error()) return } - c.JSON(http.StatusOK, gin.H{ - "success": true, - "message": "", - "data": certificate, - }) + respondSuccess(c, certificate) } // ImportTLSCertificateFile godoc @@ -196,33 +138,20 @@ func ImportTLSCertificateFile(c *gin.Context) { remark := c.PostForm("remark") certFile, err := c.FormFile("cert_file") if err != nil { - c.JSON(http.StatusBadRequest, gin.H{ - "success": false, - "message": "缺少证书文件", - }) + respondBadRequest(c, "缺少证书文件") return } keyFile, err := c.FormFile("key_file") if err != nil { - c.JSON(http.StatusBadRequest, gin.H{ - "success": false, - "message": "缺少私钥文件", - }) + respondBadRequest(c, "缺少私钥文件") return } certificate, err := service.CreateTLSCertificateFromFiles(name, certFile, keyFile, remark) if err != nil { - c.JSON(http.StatusOK, gin.H{ - "success": false, - "message": err.Error(), - }) + respondFailure(c, err.Error()) return } - c.JSON(http.StatusOK, gin.H{ - "success": true, - "message": "", - "data": certificate, - }) + respondSuccess(c, certificate) } // DeleteTLSCertificate godoc @@ -235,25 +164,15 @@ func ImportTLSCertificateFile(c *gin.Context) { // @Failure 400 {object} map[string]interface{} // @Router /api/tls-certificates/{id}/delete [post] func DeleteTLSCertificate(c *gin.Context) { - id, err := strconv.ParseUint(c.Param("id"), 10, 64) - if err != nil || id == 0 { - c.JSON(http.StatusBadRequest, gin.H{ - "success": false, - "message": "无效的参数", - }) + id, ok := parseIDParam(c) + if !ok { return } - if err = service.DeleteTLSCertificate(uint(id)); err != nil { - c.JSON(http.StatusOK, gin.H{ - "success": false, - "message": err.Error(), - }) + if err := service.DeleteTLSCertificate(id); err != nil { + respondFailure(c, err.Error()) return } - c.JSON(http.StatusOK, gin.H{ - "success": true, - "message": "", - }) + respondSuccess(c, nil) } // ApplyTLSCertificate godoc @@ -268,26 +187,15 @@ func DeleteTLSCertificate(c *gin.Context) { // @Router /api/tls-certificates/apply [post] func ApplyTLSCertificate(c *gin.Context) { var input service.TLSApplyInput - if err := json.NewDecoder(c.Request.Body).Decode(&input); err != nil { - c.JSON(http.StatusBadRequest, gin.H{ - "success": false, - "message": "无效的参数", - }) + if !bindJSON(c, &input) { return } certificate, err := service.ApplyTLSCertificate(input) if err != nil { - c.JSON(http.StatusOK, gin.H{ - "success": false, - "message": err.Error(), - }) + respondFailure(c, err.Error()) return } - c.JSON(http.StatusOK, gin.H{ - "success": true, - "message": "", - "data": certificate, - }) + respondSuccess(c, certificate) } // UpdateAcmeCertificate godoc @@ -302,36 +210,21 @@ func ApplyTLSCertificate(c *gin.Context) { // @Failure 400 {object} map[string]interface{} // @Router /api/tls-certificates/{id}/update-acme [post] func UpdateAcmeCertificate(c *gin.Context) { - id, err := strconv.ParseUint(c.Param("id"), 10, 64) - if err != nil || id == 0 { - c.JSON(http.StatusBadRequest, gin.H{ - "success": false, - "message": "invalid request", - }) + id, ok := parseIDParam(c) + if !ok { return } var input service.TLSApplyInput - if err := json.NewDecoder(c.Request.Body).Decode(&input); err != nil { - c.JSON(http.StatusBadRequest, gin.H{ - "success": false, - "message": "无效的参数", - }) + if !bindJSON(c, &input) { return } - certificate, err := service.UpdateAcmeCertificate(uint(id), input) + certificate, err := service.UpdateAcmeCertificate(id, input) if err != nil { - c.JSON(http.StatusOK, gin.H{ - "success": false, - "message": err.Error(), - }) + respondFailure(c, err.Error()) return } - c.JSON(http.StatusOK, gin.H{ - "success": true, - "message": "", - "data": certificate, - }) + respondSuccess(c, certificate) } // ConvertTLSCertificateToAcme godoc @@ -346,36 +239,21 @@ func UpdateAcmeCertificate(c *gin.Context) { // @Failure 400 {object} map[string]interface{} // @Router /api/tls-certificates/{id}/convert-acme [post] func ConvertTLSCertificateToAcme(c *gin.Context) { - id, err := strconv.ParseUint(c.Param("id"), 10, 64) - if err != nil || id == 0 { - c.JSON(http.StatusBadRequest, gin.H{ - "success": false, - "message": "invalid request", - }) + id, ok := parseIDParam(c) + if !ok { return } var input service.TLSApplyInput - if err := json.NewDecoder(c.Request.Body).Decode(&input); err != nil { - c.JSON(http.StatusBadRequest, gin.H{ - "success": false, - "message": "无效的参数", - }) + if !bindJSON(c, &input) { return } - certificate, err := service.ConvertTLSCertificateToAcme(uint(id), input) + certificate, err := service.ConvertTLSCertificateToAcme(id, input) if err != nil { - c.JSON(http.StatusOK, gin.H{ - "success": false, - "message": err.Error(), - }) + respondFailure(c, err.Error()) return } - c.JSON(http.StatusOK, gin.H{ - "success": true, - "message": "", - "data": certificate, - }) + respondSuccess(c, certificate) } // RenewTLSCertificate godoc @@ -388,25 +266,14 @@ func ConvertTLSCertificateToAcme(c *gin.Context) { // @Failure 400 {object} map[string]interface{} // @Router /api/tls-certificates/{id}/renew [post] func RenewTLSCertificate(c *gin.Context) { - id, err := strconv.ParseUint(c.Param("id"), 10, 64) - if err != nil || id == 0 { - c.JSON(http.StatusBadRequest, gin.H{ - "success": false, - "message": "无效的参数", - }) + id, ok := parseIDParam(c) + if !ok { return } - certificate, err := service.RenewTLSCertificate(uint(id)) + certificate, err := service.RenewTLSCertificate(id) if err != nil { - c.JSON(http.StatusOK, gin.H{ - "success": false, - "message": err.Error(), - }) + respondFailure(c, err.Error()) return } - c.JSON(http.StatusOK, gin.H{ - "success": true, - "message": "", - "data": certificate, - }) + respondSuccess(c, certificate) } diff --git a/openflare_server/router/api_phase1_test.go b/openflare_server/router/api_phase1_test.go index c3457bac..0ed9a0e1 100644 --- a/openflare_server/router/api_phase1_test.go +++ b/openflare_server/router/api_phase1_test.go @@ -452,7 +452,7 @@ func TestTLSCertificateConvertAcmeAPI(t *testing.T) { } invalidResp := performJSONRequestNoFatal(t, engine, token, http.MethodPost, "/api/tls-certificates/not-a-number/convert-acme", map[string]any{}) - if invalidResp.Success || !strings.Contains(invalidResp.Message, "invalid request") { + if invalidResp.Success || !strings.Contains(invalidResp.Message, "参数错误") { t.Fatalf("expected invalid id to fail, got %+v", invalidResp) }