GithubBackup/httprunner
1
0
Fork 0
mirror of https://github.com/httprunner/httprunner.git synced 2026-05-12 02:21:29 +08:00
Code Issues Packages Projects Releases Wiki Activity

refacotr: move pkg/server to root

Browse Source
This commit is contained in:
lilong.129
2025-02-06 11:28:34 +08:00
parent 1f063dd6f7
commit a578e92e00
10 changed files with 2 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

112
pkg/server/app.go
View File

@@ -1,112 +0,0 @@
package server
import (
"fmt"
"net/http"
"github.com/gin-gonic/gin"
"github.com/httprunner/httprunner/v5/code"
"github.com/rs/zerolog/log"
)
func foregroundAppHandler(c *gin.Context) {
dExt, err := getContextDriver(c)
if err != nil {
return
}
appInfo, err := dExt.Driver.GetForegroundApp()
if err != nil {
log.Err(err).Msg(fmt.Sprintf("[%s]: failed to unlick screen", c.HandlerName()))
c.JSON(http.StatusInternalServerError,
HttpResponse{
Code: code.GetErrorCode(err),
Message: err.Error(),
},
)
c.Abort()
return
}
c.JSON(http.StatusOK, HttpResponse{Result: appInfo})
}
func clearAppHandler(c *gin.Context) {
dExt, err := getContextDriver(c)
if err != nil {
return
}
var appClearReq AppClearRequest
if err := c.ShouldBindJSON(&appClearReq); err != nil {
handlerValidateRequestFailedContext(c, err)
return
}
err = dExt.Driver.Clear(appClearReq.PackageName)
if err != nil {
log.Err(err).Msg(fmt.Sprintf("[%s]: failed to unlick screen", c.HandlerName()))
c.JSON(http.StatusInternalServerError,
HttpResponse{
Code: code.GetErrorCode(err),
Message: err.Error(),
},
)
c.Abort()
return
}
c.JSON(http.StatusOK, HttpResponse{Code: 0, Message: "success"})
}
func launchAppHandler(c *gin.Context) {
dExt, err := getContextDriver(c)
if err != nil {
return
}
var appLaunchReq AppLaunchRequest
if err := c.ShouldBindJSON(&appLaunchReq); err != nil {
handlerValidateRequestFailedContext(c, err)
return
}
err = dExt.Driver.AppLaunch(appLaunchReq.PackageName)
if err != nil {
log.Err(err).Msg(fmt.Sprintf("[%s]: failed to launch app %s", c.HandlerName(), appLaunchReq.PackageName))
c.JSON(http.StatusInternalServerError,
HttpResponse{
Code: code.GetErrorCode(err),
Message: err.Error(),
},
)
c.Abort()
return
}
c.JSON(http.StatusOK, HttpResponse{Code: 0, Message: "success"})
}
func terminalAppHandler(c *gin.Context) {
dExt, err := getContextDriver(c)
if err != nil {
return
}
var appTerminalReq AppTerminalRequest
if err := c.ShouldBindJSON(&appTerminalReq); err != nil {
handlerValidateRequestFailedContext(c, err)
return
}
success, err := dExt.Driver.AppTerminate(appTerminalReq.PackageName)
if !success {
log.Err(err).Msg(fmt.Sprintf("[%s]: failed to launch app %s", c.HandlerName(), appTerminalReq.PackageName))
c.JSON(http.StatusInternalServerError,
HttpResponse{
Code: code.GetErrorCode(err),
Message: err.Error(),
},
)
c.Abort()
return
}
c.JSON(http.StatusOK, HttpResponse{Code: 0, Message: "success"})
}

109
pkg/server/context.go
View File

@@ -1,109 +0,0 @@
package server
import (
"fmt"
"net/http"
"strings"
"github.com/gin-gonic/gin"
"github.com/httprunner/httprunner/v5/code"
"github.com/httprunner/httprunner/v5/pkg/uixt"
"github.com/rs/zerolog/log"
)
var uiClients = make(map[string]*uixt.DriverExt) // UI automation clients for iOS and Android, key is udid/serial
func handleDeviceContext() gin.HandlerFunc {
return func(c *gin.Context) {
platform := c.Param("platform")
serial := c.Param("serial")
if serial == "" {
log.Error().Str("platform", platform).Msg(fmt.Sprintf("[%s]: serial is empty", c.HandlerName()))
c.JSON(http.StatusBadRequest, HttpResponse{
Code: code.GetErrorCode(code.InvalidParamError),
Message: "serial is empty",
})
c.Abort()
return
}
// get cached driver
if driver, ok := uiClients[serial]; ok {
c.Set("driver", driver)
c.Next()
return
}
switch strings.ToLower(platform) {
case "android":
device, err := uixt.NewAndroidDevice(uixt.WithSerialNumber(serial), uixt.WithStub(true))
if err != nil {
log.Error().Err(err).Str("platform", platform).Str("serial", serial).
Msg("device not found")
c.JSON(http.StatusBadRequest,
HttpResponse{
Code: code.GetErrorCode(err),
Message: err.Error(),
},
)
c.Abort()
return
}
device.Init()
driver, err := device.NewDriver(uixt.WithDriverImageService(true), uixt.WithDriverResultFolder(true))
if err != nil {
log.Error().Err(err).Str("platform", platform).Str("serial", serial).
Msg("failed to init driver")
c.JSON(http.StatusInternalServerError,
HttpResponse{
Code: code.GetErrorCode(err),
Message: err.Error(),
},
)
c.Abort()
return
}
c.Set("driver", driver)
// cache driver
uiClients[serial] = driver
default:
c.JSON(http.StatusBadRequest, HttpResponse{
Code: code.GetErrorCode(code.InvalidParamError),
Message: fmt.Sprintf("unsupported platform %s", platform),
})
c.Abort()
return
}
c.Next()
}
}
func getContextDriver(c *gin.Context) (*uixt.DriverExt, error) {
driverObj, exists := c.Get("driver")
if !exists {
handlerInitDeviceDriverFailedContext(c)
return nil, fmt.Errorf("driver not found")
}
dExt := driverObj.(*uixt.DriverExt)
return dExt, nil
}
func handlerInitDeviceDriverFailedContext(c *gin.Context) {
log.Error().Msg("init device driver failed")
c.JSON(http.StatusInternalServerError,
HttpResponse{
Code: code.GetErrorCode(code.MobileUIDriverError),
Message: "init driver failed",
},
)
c.Abort()
}
func handlerValidateRequestFailedContext(c *gin.Context, err error) {
log.Error().Err(err).Msg("validate request failed")
c.JSON(http.StatusBadRequest, HttpResponse{
Code: code.GetErrorCode(code.InvalidParamError),
Message: fmt.Sprintf("validate request param failed: %s", err.Error()),
})
c.Abort()
}

80
pkg/server/key.go
View File

@@ -1,80 +0,0 @@
package server
import (
"fmt"
"net/http"
"github.com/gin-gonic/gin"
"github.com/httprunner/httprunner/v5/code"
"github.com/httprunner/httprunner/v5/pkg/uixt"
"github.com/rs/zerolog/log"
)
func unlockHandler(c *gin.Context) {
dExt, err := getContextDriver(c)
if err != nil {
return
}
err = dExt.Driver.Unlock()
if err != nil {
log.Err(err).Msg(fmt.Sprintf("[%s]: failed to unlick screen", c.HandlerName()))
c.JSON(http.StatusInternalServerError,
HttpResponse{
Code: code.GetErrorCode(err),
Message: err.Error(),
},
)
c.Abort()
return
}
c.JSON(http.StatusOK, HttpResponse{Code: 0, Message: "success"})
}
func homeHandler(c *gin.Context) {
dExt, err := getContextDriver(c)
if err != nil {
return
}
err = dExt.Driver.Homescreen()
if err != nil {
log.Err(err).Msg(fmt.Sprintf("[%s]: failed to enter homescreen", c.HandlerName()))
c.JSON(http.StatusInternalServerError,
HttpResponse{
Code: code.GetErrorCode(err),
Message: err.Error(),
},
)
c.Abort()
return
}
c.JSON(http.StatusOK, HttpResponse{Code: 0, Message: "success"})
}
func keycodeHandler(c *gin.Context) {
dExt, err := getContextDriver(c)
if err != nil {
return
}
var keycodeReq KeycodeRequest
if err := c.ShouldBindJSON(&keycodeReq); err != nil {
handlerValidateRequestFailedContext(c, err)
return
}
err = dExt.Driver.PressKeyCode(uixt.KeyCode(keycodeReq.Keycode))
if err != nil {
log.Err(err).Msg(fmt.Sprintf("[%s]: failed to input keycode %d", c.HandlerName(), keycodeReq.Keycode))
c.JSON(http.StatusInternalServerError,
HttpResponse{
Code: code.GetErrorCode(err),
Message: err.Error(),
},
)
c.Abort()
return
}
c.JSON(http.StatusOK, HttpResponse{Code: 0, Message: "success"})
}

55
pkg/server/main.go
View File

@@ -1,55 +0,0 @@
package server
import (
"fmt"
"net/http"
"github.com/gin-gonic/gin"
"github.com/rs/zerolog/log"
)
func NewServer(port int) error {
router := gin.Default()
router.GET("/ping", pingHandler)
apiV1Platform := router.Group("/api/v1").Group("/:platform")
apiV1Platform.GET("/devices", listDeviceHandler)
apiV1PlatformSerial := apiV1Platform.Group("/:serial")
// UI operations
apiV1PlatformSerial.POST("/ui/tap", handleDeviceContext(), tapHandler)
apiV1PlatformSerial.POST("/ui/drag", handleDeviceContext(), dragHandler)
apiV1PlatformSerial.POST("/ui/input", handleDeviceContext(), inputHandler)
// Key operations
apiV1PlatformSerial.POST("/key/unlock", handleDeviceContext(), unlockHandler)
apiV1PlatformSerial.POST("/key/home", handleDeviceContext(), homeHandler)
apiV1PlatformSerial.POST("/key", handleDeviceContext(), keycodeHandler)
// App operations
apiV1PlatformSerial.GET("/app/foreground", handleDeviceContext(), foregroundAppHandler)
apiV1PlatformSerial.POST("/app/clear", handleDeviceContext(), clearAppHandler)
apiV1PlatformSerial.POST("/app/launch", handleDeviceContext(), launchAppHandler)
apiV1PlatformSerial.POST("/app/terminal", handleDeviceContext(), terminalAppHandler)
// get screen info
apiV1PlatformSerial.GET("/screenshot", handleDeviceContext(), screenshotHandler)
apiV1PlatformSerial.POST("/screenresult", handleDeviceContext(), screenResultHandler)
apiV1PlatformSerial.GET("/stub/source", handleDeviceContext(), sourceHandler)
apiV1PlatformSerial.GET("/adb/source", handleDeviceContext(), adbSourceHandler)
// Stub operations
apiV1PlatformSerial.POST("/stub/login", handleDeviceContext(), loginHandler)
apiV1PlatformSerial.POST("/stub/logout", handleDeviceContext(), logoutHandler)
// run uixt actions
apiV1PlatformSerial.POST("/uixt/action", handleDeviceContext(), uixtActionHandler)
apiV1PlatformSerial.POST("/uixt/actions", handleDeviceContext(), uixtActionsHandler)
err := router.Run(fmt.Sprintf("127.0.0.1:%d", port))
if err != nil {
log.Err(err).Msg("failed to start http server")
return err
}
return nil
}
func pingHandler(c *gin.Context) {
c.JSON(http.StatusOK, HttpResponse{Code: 0, Message: "success"})
}

62
pkg/server/model.go
View File

@@ -1,62 +0,0 @@
package server
import "github.com/httprunner/httprunner/v5/pkg/uixt"
type HttpResponse struct {
Code int `json:"code"`
Message string `json:"msg"`
Result interface{} `json:"result,omitempty"`
}
type TapRequest struct {
X float64 `json:"x"`
Y float64 `json:"y"`
Text string `json:"text"`
Options *uixt.ActionOptions `json:"options,omitempty"`
}
type DragRequest struct {
FromX float64 `json:"from_x"`
FromY float64 `json:"from_y"`
ToX float64 `json:"to_x"`
ToY float64 `json:"to_y"`
Options *uixt.ActionOptions `json:"options,omitempty"`
}
type InputRequest struct {
Text string `json:"text"`
Frequency int `json:"frequency"` // only iOS
}
type ScreenRequest struct {
Options *uixt.ActionOptions `json:"options,omitempty"`
}
type KeycodeRequest struct {
Keycode int `json:"keycode"`
}
type AppClearRequest struct {
PackageName string `json:"packageName"`
}
type AppLaunchRequest struct {
PackageName string `json:"packageName"`
}
type AppTerminalRequest struct {
PackageName string `json:"packageName"`
}
type LoginRequest struct {
PackageName string `json:"packageName"`
PhoneNumber string `json:"phoneNumber"`
Captcha string `json:"captcha"`
Password string `json:"password"`
}
type LogoutRequest struct {
PackageName string `json:"packageName"`
}

133
pkg/server/source.go
View File

@@ -1,133 +0,0 @@
package server
import (
"encoding/base64"
"fmt"
"net/http"
"github.com/gin-gonic/gin"
"github.com/httprunner/httprunner/v5/code"
"github.com/httprunner/httprunner/v5/pkg/uixt"
"github.com/rs/zerolog/log"
)
func screenshotHandler(c *gin.Context) {
dExt, err := getContextDriver(c)
if err != nil {
return
}
raw, err := dExt.Driver.Screenshot()
if err != nil {
log.Err(err).Msg(fmt.Sprintf("[%s]: failed to get screenshot", c.HandlerName()))
c.JSON(http.StatusInternalServerError,
HttpResponse{
Code: code.GetErrorCode(err),
Message: err.Error(),
},
)
c.Abort()
return
}
c.JSON(http.StatusOK,
HttpResponse{
Code: code.Success,
Message: "success",
Result: base64.StdEncoding.EncodeToString(raw.Bytes()),
},
)
}
func screenResultHandler(c *gin.Context) {
dExt, err := getContextDriver(c)
if err != nil {
return
}
var screenReq ScreenRequest
if err := c.ShouldBindJSON(&screenReq); err != nil {
handlerValidateRequestFailedContext(c, err)
return
}
var actionOptions []uixt.ActionOption
if screenReq.Options != nil {
actionOptions = screenReq.Options.Options()
}
screenResult, err := dExt.GetScreenResult(actionOptions...)
if err != nil {
log.Err(err).Msg("get screen result failed")
c.JSON(http.StatusInternalServerError,
HttpResponse{
Code: code.GetErrorCode(err),
Message: err.Error(),
},
)
c.Abort()
return
}
c.JSON(http.StatusOK,
HttpResponse{
Code: code.Success,
Message: "success",
Result: screenResult,
},
)
}
func sourceHandler(c *gin.Context) {
dExt, err := getContextDriver(c)
if err != nil {
return
}
app, err := dExt.Driver.GetForegroundApp()
if err != nil {
log.Err(err).Msg(fmt.Sprintf("[%s]: failed to get foreground app", c.HandlerName()))
c.JSON(http.StatusInternalServerError,
HttpResponse{
Code: code.GetErrorCode(err),
Message: err.Error(),
},
)
c.Abort()
return
}
source, err := dExt.Driver.Source(uixt.NewSourceOption().WithProcessName(app.PackageName))
if err != nil {
log.Err(err).Msg(fmt.Sprintf("[%s]: failed to get source %s", c.HandlerName(), app.PackageName))
c.JSON(http.StatusInternalServerError,
HttpResponse{
Code: code.GetErrorCode(err),
Message: err.Error(),
},
)
c.Abort()
return
}
c.JSON(http.StatusOK, HttpResponse{Result: source})
}
func adbSourceHandler(c *gin.Context) {
dExt, err := getContextDriver(c)
if err != nil {
return
}
source, err := dExt.Driver.Source()
if err != nil {
log.Err(err).Msg(fmt.Sprintf("[%s]: failed to get adb source", c.HandlerName()))
c.JSON(http.StatusInternalServerError,
HttpResponse{
Code: code.GetErrorCode(err),
Message: err.Error(),
},
)
c.Abort()
return
}
c.JSON(http.StatusOK, HttpResponse{Result: source})
}

148
pkg/server/stub.go
View File

@@ -1,148 +0,0 @@
package server
import (
"fmt"
"net/http"
"strings"
"github.com/gin-gonic/gin"
"github.com/rs/zerolog/log"
"github.com/httprunner/httprunner/v5/code"
"github.com/httprunner/httprunner/v5/pkg/gadb"
)
func listDeviceHandler(c *gin.Context) {
platform := c.Param("platform")
switch strings.ToLower(platform) {
case "android":
{
client, err := gadb.NewClient()
if err != nil {
log.Err(err).Msg("failed to init adb client")
c.JSON(http.StatusInternalServerError,
HttpResponse{
Code: code.GetErrorCode(err),
Message: err.Error(),
},
)
c.Abort()
return
}
devices, err := client.DeviceList()
if err != nil && strings.Contains(err.Error(), "no android device found") {
c.JSON(http.StatusOK, HttpResponse{Result: nil})
return
} else if err != nil {
log.Err(err).Msg("failed to list devices")
c.JSON(http.StatusInternalServerError,
HttpResponse{
Code: code.GetErrorCode(err),
Message: err.Error(),
},
)
c.Abort()
return
}
var deviceList []interface{}
for _, device := range devices {
brand, err := device.Brand()
if err != nil {
log.Err(err).Msg("failed to get device brand")
c.JSON(http.StatusInternalServerError,
HttpResponse{
Code: code.GetErrorCode(err),
Message: err.Error(),
},
)
c.Abort()
return
}
model, err := device.Model()
if err != nil {
log.Err(err).Msg("failed to get device model")
c.JSON(http.StatusInternalServerError,
HttpResponse{
Code: code.GetErrorCode(err),
Message: err.Error(),
},
)
c.Abort()
return
}
deviceInfo := map[string]interface{}{
"serial": device.Serial(),
"brand": brand,
"model": model,
"platform": "android",
}
deviceList = append(deviceList, deviceInfo)
}
c.JSON(http.StatusOK, HttpResponse{Result: deviceList})
return
}
default:
{
c.JSON(http.StatusBadRequest, HttpResponse{
Code: code.GetErrorCode(code.InvalidParamError),
Message: fmt.Sprintf("unsupported platform %s", platform),
})
c.Abort()
return
}
}
}
func loginHandler(c *gin.Context) {
dExt, err := getContextDriver(c)
if err != nil {
return
}
var loginReq LoginRequest
if err := c.ShouldBindJSON(&loginReq); err != nil {
handlerValidateRequestFailedContext(c, err)
return
}
info, err := dExt.Driver.LoginNoneUI(loginReq.PackageName, loginReq.PhoneNumber, loginReq.Captcha, loginReq.Password)
if err != nil {
log.Err(err).Msg(fmt.Sprintf("[%s]: failed to login", c.HandlerName()))
c.JSON(http.StatusInternalServerError,
HttpResponse{
Code: code.GetErrorCode(err),
Message: err.Error(),
},
)
c.Abort()
return
}
c.JSON(http.StatusOK, HttpResponse{Code: 0, Message: "success", Result: info})
}
func logoutHandler(c *gin.Context) {
dExt, err := getContextDriver(c)
if err != nil {
return
}
var logoutReq LogoutRequest
if err := c.ShouldBindJSON(&logoutReq); err != nil {
handlerValidateRequestFailedContext(c, err)
return
}
err = dExt.Driver.LogoutNoneUI(logoutReq.PackageName)
if err != nil {
log.Err(err).Msg(fmt.Sprintf("[%s]: failed to login", c.HandlerName()))
c.JSON(http.StatusInternalServerError,
HttpResponse{
Code: code.GetErrorCode(err),
Message: err.Error(),
},
)
c.Abort()
return
}
c.JSON(http.StatusOK, HttpResponse{Code: 0, Message: "success"})
}

155
pkg/server/ui.go
View File

@@ -1,155 +0,0 @@
package server
import (
"fmt"
"net/http"
"github.com/gin-gonic/gin"
"github.com/httprunner/httprunner/v5/code"
"github.com/httprunner/httprunner/v5/pkg/uixt"
"github.com/rs/zerolog/log"
)
func tapHandler(c *gin.Context) {
dExt, err := getContextDriver(c)
if err != nil {
return
}
var tapReq TapRequest
if err := c.ShouldBindJSON(&tapReq); err != nil {
handlerValidateRequestFailedContext(c, err)
return
}
var actionOptions []uixt.ActionOption
if tapReq.Options != nil {
actionOptions = tapReq.Options.Options()
}
if tapReq.Text != "" {
err := dExt.TapByOCR(tapReq.Text, actionOptions...)
if err != nil {
log.Err(err).Str("text", tapReq.Text).Msg("tap text failed")
c.JSON(http.StatusInternalServerError,
HttpResponse{
Code: code.GetErrorCode(err),
Message: err.Error(),
},
)
c.Abort()
return
}
} else if tapReq.X < 1 && tapReq.Y < 1 {
err := dExt.TapXY(tapReq.X, tapReq.Y, actionOptions...)
if err != nil {
log.Err(err).Float64("x", tapReq.X).Float64("y", tapReq.Y).Msg("tap relative xy failed")
c.JSON(http.StatusInternalServerError,
HttpResponse{
Code: code.GetErrorCode(err),
Message: err.Error(),
},
)
c.Abort()
return
}
} else {
err := dExt.TapAbsXY(tapReq.X, tapReq.Y, actionOptions...)
if err != nil {
log.Err(err).Float64("x", tapReq.X).Float64("y", tapReq.Y).Msg("tap abs xy failed")
c.JSON(http.StatusInternalServerError,
HttpResponse{
Code: code.GetErrorCode(err),
Message: err.Error(),
},
)
c.Abort()
return
}
}
c.JSON(http.StatusOK, HttpResponse{Code: 0, Message: "success"})
}
func dragHandler(c *gin.Context) {
dExt, err := getContextDriver(c)
if err != nil {
return
}
var dragReq DragRequest
if err := c.ShouldBindJSON(&dragReq); err != nil {
handlerValidateRequestFailedContext(c, err)
return
}
var actionOptions []uixt.ActionOption
if dragReq.Options != nil {
actionOptions = dragReq.Options.Options()
}
if dragReq.FromX < 1 && dragReq.FromY < 1 && dragReq.ToX < 1 && dragReq.ToY < 1 {
err := dExt.SwipeRelative(
dragReq.FromX, dragReq.FromY, dragReq.ToX, dragReq.ToY,
actionOptions...)
if err != nil {
log.Err(err).
Float64("from_x", dragReq.FromX).Float64("from_y", dragReq.FromY).
Float64("to_x", dragReq.ToX).Float64("to_y", dragReq.ToY).
Msg("swipe relative failed")
c.JSON(http.StatusInternalServerError,
HttpResponse{
Code: code.GetErrorCode(err),
Message: err.Error(),
},
)
c.Abort()
return
}
} else {
err := dExt.Driver.Swipe(
dragReq.FromX, dragReq.FromY, dragReq.ToX, dragReq.ToY,
actionOptions...)
if err != nil {
log.Err(err).
Float64("from_x", dragReq.FromX).Float64("from_y", dragReq.FromY).
Float64("to_x", dragReq.ToX).Float64("to_y", dragReq.ToY).
Msg("swipe absolute failed")
c.JSON(http.StatusInternalServerError,
HttpResponse{
Code: code.GetErrorCode(err),
Message: err.Error(),
},
)
c.Abort()
return
}
}
c.JSON(http.StatusOK, HttpResponse{Code: 0, Message: "success"})
}
func inputHandler(c *gin.Context) {
dExt, err := getContextDriver(c)
if err != nil {
return
}
var inputReq InputRequest
if err := c.ShouldBindJSON(&inputReq); err != nil {
handlerValidateRequestFailedContext(c, err)
return
}
err = dExt.Driver.SendKeys(inputReq.Text, uixt.WithFrequency(inputReq.Frequency))
if err != nil {
log.Err(err).Msg(fmt.Sprintf("[%s]: failed to input text %s", c.HandlerName(), inputReq.Text))
c.JSON(http.StatusInternalServerError,
HttpResponse{
Code: code.GetErrorCode(err),
Message: err.Error(),
},
)
c.Abort()
return
}
c.JSON(http.StatusOK, HttpResponse{Code: 0, Message: "success"})
}

70
pkg/server/uixt.go
View File

@@ -1,70 +0,0 @@
package server
import (
"net/http"
"github.com/gin-gonic/gin"
"github.com/httprunner/httprunner/v5/code"
"github.com/httprunner/httprunner/v5/pkg/uixt"
"github.com/rs/zerolog/log"
)
// exec a single uixt action
func uixtActionHandler(c *gin.Context) {
dExt, err := getContextDriver(c)
if err != nil {
return
}
var req uixt.MobileAction
if err := c.ShouldBindJSON(&req); err != nil {
handlerValidateRequestFailedContext(c, err)
return
}
if err = dExt.DoAction(req); err != nil {
log.Err(err).Interface("action", req).
Msg("exec uixt action failed")
c.JSON(http.StatusInternalServerError,
HttpResponse{
Code: code.GetErrorCode(err),
Message: err.Error(),
},
)
c.Abort()
return
}
c.JSON(http.StatusOK, HttpResponse{Code: 0, Message: "success"})
}
// exec multiple uixt actions
func uixtActionsHandler(c *gin.Context) {
dExt, err := getContextDriver(c)
if err != nil {
return
}
var actions []uixt.MobileAction
if err := c.ShouldBindJSON(&actions); err != nil {
handlerValidateRequestFailedContext(c, err)
return
}
for _, action := range actions {
if err = dExt.DoAction(action); err != nil {
log.Err(err).Interface("action", action).
Msg("exec uixt action failed")
c.JSON(http.StatusInternalServerError,
HttpResponse{
Code: code.GetErrorCode(err),
Message: err.Error(),
},
)
c.Abort()
return
}
}
c.JSON(http.StatusOK, HttpResponse{Code: 0, Message: "success"})
}