up

pkg/gateway/api_gateway_controller.go

@@ -6,22 +6,21 @@ import (
     "time"
     "xps/cmd/cache"
     "xps/cmd/constant"
-    "xps/pkg/api/controller"
     "xps/pkg/common"
 )
 
 type ApiGatewayController struct {
-    controller.Base
+    Base
     Service HttpHandler
 }
 
 func (c *ApiGatewayController) BeforeActivation(b mvc.BeforeActivation) {
-    b.Handle("GET", "/{objectCode:string}/{oamCode:string}", "Get")
-    b.Handle("GET", "/GenerateParams/{objectCode:string}/{oamCode:string}", "GenerateParams")
-    b.Handle("POST", "/{objectCode:string}/{oamCode:string}", "Post")
-    b.Handle("PUT", "/{objectCode:string}/{oamCode:string}", "Put")
-    b.Handle("PATCH", "/{objectCode:string}/{oamCode:string}", "Patch")
-    b.Handle("DELETE", "/{objectCode:string}/{oamCode:string}", "Delete")
+    b.Handle("GET",     "/{objectCode:string}/{oamCode:string}",                "Get"           )
+    b.Handle("GET",     "/GenerateParams/{objectCode:string}/{oamCode:string}", "GenerateParams")
+    b.Handle("POST",    "/{objectCode:string}/{oamCode:string}",                "Post"          )
+    b.Handle("PUT",     "/{objectCode:string}/{oamCode:string}",                "Put"           )
+    b.Handle("PATCH",   "/{objectCode:string}/{oamCode:string}",                "Patch"         )
+    b.Handle("DELETE",  "/{objectCode:string}/{oamCode:string}",                "Delete"        )
 }
 
 func (c *ApiGatewayController) HandleParamRule(ruleId int64) interface{} {
@@ -54,7 +53,7 @@ func (c *ApiGatewayController) buildUrlParams(objectCode, oamCode string) ([]com
         return nil, err1
     }
 
-    urlParams := c.Ctx.URLParams()
+    urlParams   := c.Ctx.URLParams()
     queryParams := make([]common.QueryParam, 0)
     for _, oamParam := range oamParams {
         paramValueCode := oamParam.ParamValue
@@ -105,41 +104,41 @@ func (c *ApiGatewayController) buildUrlParams(objectCode, oamCode string) ([]com
     return queryParams, nil
 }
 
-func (c *ApiGatewayController) GenerateParams(objectCode, oamCode string) *controller.JsonResult {
+func (c *ApiGatewayController) GenerateParams(objectCode, oamCode string) *JsonResult {
     data, err := c.Service.GenerateParams(objectCode, oamCode)
     if err != nil {
-        return controller.ResultErr(err.Error(), nil)
+        return ResultErr(err.Error(), nil)
     } else {
-        return controller.ResultOk("获取成功", data)
+        return ResultOk("获取成功", data)
     }
 }
 
-func (c *ApiGatewayController) Get(objectCode, oamCode string) *controller.JsonResult {
+func (c *ApiGatewayController) Get(objectCode, oamCode string) *JsonResult {
     oamInfo, err1 := cache.GetApiData(objectCode, oamCode)
     if err1 != nil {
-        return controller.ResultErr(err1.Error(), nil)
+        return ResultErr(err1.Error(), nil)
     }
 
     params, err2 := c.buildUrlParams(objectCode, oamCode)
     if err2 != nil {
-        return controller.ResultErr(err2.Error(), nil)
+        return ResultErr(err2.Error(), nil)
     }
 
     oamType := oamInfo.OamType
     if oamType == constant.OAM_GET_ONE {
         data, err := c.Service.Get(objectCode, oamCode, params)
         if err != nil {
-            return controller.ResultErr(err.Error(), nil)
+            return ResultErr(err.Error(), nil)
         } else {
-            return controller.ResultOk("获取成功", data)
+            return ResultOk("获取成功", data)
         }
     }
     if oamType == constant.OAM_GET_LIST {
         data, err := c.Service.GetList(objectCode, oamCode, params)
         if err != nil {
-            return controller.ResultErr(err.Error(), nil)
+            return ResultErr(err.Error(), nil)
         } else {
-            return controller.ResultOk("获取成功", data)
+            return ResultOk("获取成功", data)
         }
     }
     if oamType == constant.OAM_GET_PAGE {
@@ -155,19 +154,19 @@ func (c *ApiGatewayController) Get(objectCode, oamCode string) *controller.JsonR
 
         data, err := c.Service.GetPage(objectCode, oamCode, params, page, limit)
         if err != nil {
-            return controller.ResultErr(err.Error(), nil)
+            return ResultErr(err.Error(), nil)
         } else {
-            return controller.ResultOk("获取成功", data)
+            return ResultOk("获取成功", data)
         }
     }
 
-    return controller.ResultErr("方法不存在", nil)
+    return ResultErr("方法不存在", nil)
 }
 
-func (c *ApiGatewayController) Post(objectCode, oamCode string) *controller.JsonResult {
+func (c *ApiGatewayController) Post(objectCode, oamCode string) *JsonResult {
     m, err := c.GetJsonData()
     if err != nil {
-        return controller.ResultErr(err.Error(), nil)
+        return ResultErr(err.Error(), nil)
     }
 
     userInfo := &common.CurUserInfo{
@@ -181,16 +180,16 @@ func (c *ApiGatewayController) Post(objectCode, oamCode string) *controller.Json
 
     err = c.Service.Create(objectCode, oamCode, m, userInfo)
     if err != nil {
-        return controller.ResultErr(err.Error(), nil)
+        return ResultErr(err.Error(), nil)
     } else {
-        return controller.ResultOk("创建成功", nil)
+        return ResultOk("创建成功", nil)
     }
 }
 
-func (c *ApiGatewayController) Put(objectCode, oamCode string) *controller.JsonResult {
+func (c *ApiGatewayController) Put(objectCode, oamCode string) *JsonResult {
     m, err := c.GetJsonData()
     if err != nil {
-        return controller.ResultErr(err.Error(), nil)
+        return ResultErr(err.Error(), nil)
     }
 
     userInfo := &common.CurUserInfo{
@@ -204,16 +203,16 @@ func (c *ApiGatewayController) Put(objectCode, oamCode string) *controller.JsonR
 
     err = c.Service.Update(objectCode, oamCode, m, userInfo)
     if err != nil {
-        return controller.ResultErr(err.Error(), nil)
+        return ResultErr(err.Error(), nil)
     } else {
-        return controller.ResultOk("更新成功", nil)
+        return ResultOk("更新成功", nil)
     }
 }
 
-func (c *ApiGatewayController) Patch(objectCode, oamCode string) *controller.JsonResult {
+func (c *ApiGatewayController) Patch(objectCode, oamCode string) *JsonResult {
     m, err := c.GetJsonData()
     if err != nil {
-        return controller.ResultErr(err.Error(), nil)
+        return ResultErr(err.Error(), nil)
     }
 
     userInfo := &common.CurUserInfo{
@@ -226,16 +225,16 @@ func (c *ApiGatewayController) Patch(objectCode, oamCode string) *controller.Jso
     }
     err = c.Service.Patch(objectCode, oamCode, m, userInfo)
     if err != nil {
-        return controller.ResultErr(err.Error(), nil)
+        return ResultErr(err.Error(), nil)
     } else {
-        return controller.ResultOk("更新成功", nil)
+        return ResultOk("更新成功", nil)
     }
 }
 
-func (c *ApiGatewayController) Delete(objectCode, oamCode string) *controller.JsonResult {
+func (c *ApiGatewayController) Delete(objectCode, oamCode string) *JsonResult {
     m, err := c.GetJsonData()
     if err != nil {
-        return controller.ResultErr(err.Error(), nil)
+        return ResultErr(err.Error(), nil)
     }
 
     userInfo := &common.CurUserInfo{
@@ -249,8 +248,8 @@ func (c *ApiGatewayController) Delete(objectCode, oamCode string) *controller.Js
 
     err = c.Service.Delete(objectCode, oamCode, m, userInfo)
     if err != nil {
-        return controller.ResultErr(err.Error(), nil)
+        return ResultErr(err.Error(), nil)
     } else {
-        return controller.ResultOk("删除成功", nil)
+        return ResultOk("删除成功", nil)
     }
 }

pkg/gateway/base.go

@@ -1,8 +1,14 @@
 package gateway
 
 import (
+    "github.com/go-playground/validator/v10"
+    "github.com/kataras/iris/v12"
+    "github.com/stretchr/objx"
+    "io"
     "log"
+    "xps/cmd/cache"
     "xps/cmd/datasource"
+    "xps/pkg/system/viewmodel"
 )
 
 func NewID() int64 {
@@ -17,3 +23,193 @@ func NewID() int64 {
     }
     return uid
 }
+
+
+var (
+    validate *validator.Validate
+)
+
+func init() {
+    validate = validator.New()
+}
+
+func errorData(errs ...error) {
+    var s string
+    for _, err := range errs {
+        if err != nil {
+            s += err.Error() + "<br/>"
+        }
+    }
+}
+
+type Base struct {
+    Ctx iris.Context
+}
+
+func (b *Base) GetCurOcId() int64 {
+
+    ocId, _ := b.Ctx.Values().GetInt64("ocId")
+    return ocId
+}
+
+func (b *Base) GetCurUserId() int64 {
+    userId, _ := b.Ctx.Values().GetInt64("userId")
+    return userId
+}
+
+func (b *Base) GetCurUserName() string {
+    userId, _ := b.Ctx.Values().GetInt64("userId")
+    userData := GetCurUser(userId)
+    if userData != nil {
+        return userData.UserName
+    }
+    return ""
+}
+
+func (b *Base) GetCurUserPositionId() int64 {
+    userId, _ := b.Ctx.Values().GetInt64("userId")
+    userData := GetCurUser(userId)
+    if userData != nil {
+        return userData.PositionId
+    }
+    return 0
+}
+
+func (b *Base) GetCurUserPositionName() string {
+    userId, _ := b.Ctx.Values().GetInt64("userId")
+    userData := GetCurUser(userId)
+    if userData != nil {
+        return userData.PositionName
+    }
+    return ""
+}
+
+func (b *Base) GetCurUserGroupId() int64 {
+    userId, _ := b.Ctx.Values().GetInt64("userId")
+    userData := GetCurUser(userId)
+    if userData != nil {
+        return userData.GroupId
+    }
+    return 0
+}
+
+func (b *Base) GetCurUserGroupName() string {
+    userId, _ := b.Ctx.Values().GetInt64("userId")
+    userData := GetCurUser(userId)
+    if userData != nil {
+        return userData.GroupName
+    }
+    return ""
+}
+
+func (b *Base) GetOcTypeId() int64 {
+    ocTypeId, _ := b.Ctx.Values().GetInt64("ocTypeId")
+    return ocTypeId
+}
+
+func (b *Base) GetAppKey() string {
+    appKey := b.Ctx.Values().GetString("appKey")
+    return appKey
+}
+
+func (b *Base) GetAppSecret() string {
+    appSecret := b.Ctx.Values().GetString("appSecret")
+    return appSecret
+}
+
+func (b *Base) GetJsonData() (map[string]interface{}, error) {
+    data, err := io.ReadAll(b.Ctx.Request().Body)
+    if err != nil {
+        return nil, err
+    }
+
+    m, err := objx.FromJSON(string(data))
+    if err != nil {
+        return nil, err
+    }
+
+    return m, nil
+}
+
+func (b *Base) buildParams() map[string]interface{} {
+    ocId, err := b.Ctx.Values().GetInt64("ocId")
+    if err != nil {
+        _ = b.Ctx.JSON(ResultErr(err.Error(), nil))
+        b.Ctx.Next()
+    }
+    userId, err := b.Ctx.Values().GetInt64("userId")
+    if err != nil {
+        _ = b.Ctx.JSON(ResultErr(err.Error(), nil))
+        b.Ctx.Next()
+    }
+
+    params := make(map[string]interface{})
+    params["ocId"] = ocId
+    params["userId"] = userId
+    groupId := b.Ctx.URLParamInt64Default("groupId", 0)
+    if groupId > 0 {
+        params["groupId"] = groupId
+    }
+
+    limit := b.Ctx.URLParamIntDefault("limit", 0)
+    if limit <= 0 {
+        limit = 10
+    }
+    params["limit"] = limit
+
+    page := b.Ctx.URLParamIntDefault("page", 0)
+    if page <= 0 {
+        page = 1
+    }
+    params["page"] = page
+    keywords := b.Ctx.URLParamDefault("keywords", "")
+    if keywords != "" {
+        params["keywords"] = keywords
+    }
+
+    b.Ctx.URLParams()
+
+    return params
+}
+
+// RetCode Result Code
+type RetCode int
+
+// Result Code List
+const (
+    RetOk  RetCode = 200
+    RetErr RetCode = 500
+)
+
+type QueryConditions struct {
+    OcId     int64  `url:"ocId"`
+    GroupId  int64  `url:"groupId"`
+    UserId   int64  `url:"userId"`
+    Page     int    `url:"page"`
+    Limit    int    `url:"limit"`
+    Keywords string `url:"keywords"`
+}
+
+type JsonResult struct {
+    Code RetCode     `json:"code"`
+    Msg  interface{} `json:"msg"`
+    Data interface{} `json:"data"`
+}
+
+func ResultOk(msg string, objects interface{}) (r *JsonResult) {
+    r = &JsonResult{Code: RetOk, Msg: msg, Data: objects}
+    return
+}
+
+func ResultErr(msg string, objects interface{}) (r *JsonResult) {
+    r = &JsonResult{Code: RetErr, Msg: msg, Data: objects}
+    return
+}
+
+func GetCurUser(userId int64) *viewmodel.UserData {
+    userData, err := cache.GetUserData(userId)
+    if err != nil {
+        log.Fatal(err.Error())
+    }
+    return userData
+}