init

go.mod

@@ -61,6 +61,7 @@ require (
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
 	github.com/schollz/closestmatch v2.1.0+incompatible // indirect
 	github.com/sirupsen/logrus v1.8.1 // indirect
+	github.com/stretchr/objx v0.5.0 // indirect
 	github.com/syndtr/goleveldb v1.0.0 // indirect
 	github.com/tdewolff/minify/v2 v2.12.4 // indirect
 	github.com/tdewolff/parse/v2 v2.6.4 // indirect

repositories/api_repo.go

@@ -86,6 +86,18 @@ func (d *ApiRepo) GetById(modId, apiId int64) (*viewmodels.ApiInfo, error) {
     }
 }
 
+func (d *ApiRepo) GetByCode(apiCode string) (*viewmodels.ApiInfo, error) {
+    data := &viewmodels.ApiInfo{}
+    ok, err := d.engine.
+        Where("api_code = ?", apiCode).
+        Get(data)
+    if !ok && err == nil {
+        return nil, err
+    } else {
+        return data, nil
+    }
+}
+
 func (d *ApiRepo) Create(data *datamodels.Api) error {
     data.CreatedAt = time.Now()
     _, err := d.engine.Insert(data)

repositories/api_trans_unit_repo.go

@@ -25,7 +25,7 @@ func (d *ApiTransUnitRepo) GetPage(m map[string]interface{}) (*viewmodels.PageRe
     sqlSelect := ` SELECT     A.*,
                               B.api_title `
     sqlFrom   := ` FROM       ps_api_trans_unit AS A
-                   LEFT  JOIN ps_api            AS B ON (A.api_id = C.api_id)`
+                   LEFT  JOIN ps_api            AS B ON (A.api_id = B.api_id)`
     sqlWhere  := ` WHERE 1 = 1  AND A.deleted_flag = 0 `
     
     if apiId, ok := m["apiId"]; ok {
@@ -64,7 +64,7 @@ func (d *ApiTransUnitRepo) GetList(m map[string]interface{}) ([]viewmodels.ApiTr
     sqlSelect := ` SELECT     A.*,
                               B.api_title `
     sqlFrom   := ` FROM       ps_api_trans_unit AS A
-                   LEFT  JOIN ps_api            AS B ON (A.api_id = C.api_id)`
+                   LEFT  JOIN ps_api            AS B ON (A.api_id = B.api_id)`
     sqlWhere  := ` WHERE 1 = 1  AND A.deleted_flag = 0 `
     
     
@@ -86,6 +86,24 @@ func (d *ApiTransUnitRepo) GetList(m map[string]interface{}) ([]viewmodels.ApiTr
     }
 }
 
+func (d *ApiTransUnitRepo) GetListById(apiId int64) ([]viewmodels.ApiTransUnitInfo, error) {
+    sqlSelect := ` SELECT     A.*,
+                              B.api_title `
+    sqlFrom   := ` FROM       ps_api_trans_unit AS A
+                   LEFT  JOIN ps_api            AS B ON (A.api_id = B.api_id)`
+    sqlWhere  := ` WHERE 1 = 1  AND A.deleted_flag = 0 `
+    sqlWhere += ` AND A.api_id = `+ fmt.Sprintf("%d", apiId)
+    sqlOrderBy := " ORDER BY A.atu_id ASC "
+    
+    datalist := make([]viewmodels.ApiTransUnitInfo, 0)
+    err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere + sqlOrderBy).Find(&datalist)
+    if err != nil {
+        return nil, err
+    } else {
+        return datalist, nil
+    }
+}
+
 func (d *ApiTransUnitRepo) GetById(apiId, atuId int64) (*viewmodels.ApiTransUnitInfo, error) {
     data := &viewmodels.ApiTransUnitInfo{}
     ok, err := d.engine.
@@ -104,7 +122,6 @@ func (d *ApiTransUnitRepo) Create(data *datamodels.ApiTransUnit) error {
     return err
 }
 
-
 func (d *ApiTransUnitRepo) Update(data *datamodels.ApiTransUnit) error {
     apiId := data.ApiId
     atuId := data.AtuId

repositories/data_bus_rebo.go

@@ -74,7 +74,7 @@ func (d *DataBusRepo) GetById(statement string, fields map[string]interface{})(m
     return results[0], nil
 }
 
-func (d *DataBusRepo) Create(object datamodels.Object, fields []datamodels.ObjectAttr, values map[string]interface{}) error {
+func (d *DataBusRepo) Create(object *viewmodels.ObjectInfo, fields []viewmodels.ObjectAttrInfo, values map[string]interface{}) error {
     tableName := object.ObjectCode
     
     sql := "INSERT INTO" + fmt.Sprintf(" %s ", tableName)
@@ -102,7 +102,7 @@ func (d *DataBusRepo) Create(object datamodels.Object, fields []datamodels.Objec
     return err
 }
 
-func (d *DataBusRepo) Update(object datamodels.Object, fields []datamodels.ObjectAttr, values map[string]interface{}) error {
+func (d *DataBusRepo) Update(object *viewmodels.ObjectInfo, fields []viewmodels.ObjectAttrInfo, values map[string]interface{}) error {
     tableName := object.ObjectCode
     
     sql := fmt.Sprintf("UPDATE table %s ", tableName)
@@ -131,7 +131,7 @@ func (d *DataBusRepo) Update(object datamodels.Object, fields []datamodels.Objec
     return err
 }
 
-func (d *DataBusRepo) Patch(object datamodels.Object, fields []datamodels.ObjectAttr, values map[string]interface{}) error {
+func (d *DataBusRepo) Patch(object *viewmodels.ObjectInfo, fields []viewmodels.ObjectAttrInfo, values map[string]interface{}) error {
     tableName := object.ObjectCode
     
     sql := fmt.Sprintf("UPDATE table %s ", tableName)
@@ -161,7 +161,7 @@ func (d *DataBusRepo) Patch(object datamodels.Object, fields []datamodels.Object
 }
 
 
-func (d *DataBusRepo) Delete(object datamodels.Object, fields []datamodels.ObjectAttr, values map[string]interface{}) error {
+func (d *DataBusRepo) Delete(object *viewmodels.ObjectInfo, fields []viewmodels.ObjectAttrInfo, values map[string]interface{}) error {
     tableName := object.ObjectCode
     deletedBy := values["deletedBy"].(int64)
     

repositories/object_attr_repo.go

@@ -71,6 +71,20 @@ func (d *ObjectAttrRepo) GetList(m map[string]interface{}) ([]viewmodels.ObjectA
 	}
 }
 
+func (d *ObjectAttrRepo) GetListById(modelId, objectId int64) ([]viewmodels.ObjectAttrInfo, error) {
+	data    := make([]viewmodels.ObjectAttrInfo, 0)
+	ok, err := d.engine.
+		Where("model_id = ?", modelId).
+		Where("object_id = ?", objectId).
+		Get(data)
+	if !ok && err == nil {
+		return nil, err
+	} else {
+		return data, nil
+	}
+}
+
+
 func (d *ObjectAttrRepo) GetById(modelId, objectId, attrId int64) (*viewmodels.ObjectAttrInfo, error) {
 	data    := &viewmodels.ObjectAttrInfo{}
 	ok, err := d.engine.

service/api_gateway_service.go

@@ -17,6 +17,9 @@ type ApiGatewayService interface {
 
 type apiGatewayService struct {
     apiRepo *repositories.ApiRepo
+    apiTransUnitRepo *repositories.ApiTransUnitRepo
+    objectRepo *repositories.ObjectRepo
+    objectAttrRepo *repositories.ObjectAttrRepo
     dataBus *repositories.DataBusRepo
 }
 
@@ -24,32 +27,87 @@ type apiGatewayService struct {
 func NewApiGatewayService() ApiGatewayService {
     return &apiGatewayService{
         apiRepo: repositories.NewApiRepo(datasource.InstanceMaster()),
+        objectRepo: repositories.NewObjectRepo(datasource.InstanceMaster()),
+        objectAttrRepo: repositories.NewObjectAttrRepo(datasource.InstanceMaster()),
         dataBus: repositories.NewDataBusRepo(datasource.InstanceMaster()),
     }
 }
 
 
 func (a apiGatewayService) Get(apiCode string, m map[string]interface{}) ([]map[string]interface{}, error) {
+    
+    
     return nil, errors.New("TEST")
 }
 
+func (a apiGatewayService) Handle(apiCode string, action int, m map[string]interface{}) error{
+   apiInfo, err1 := a.apiRepo.GetByCode(apiCode)
+   if err1 == nil{
+       return err1
+   }
+   
+   apiId := apiInfo.ApiId
+   atus, err2 := a.apiTransUnitRepo.GetListById(apiId)
+   if err2 == nil{
+       return err2
+   }
+   
+   for _, atu := range atus {
+       modelId  := atu.ModelId
+       objectId := atu.ObjectId
+       
+       objectInfo, err3 := a.objectRepo.GetById(modelId, objectId)
+       if err3 == nil {
+           return err3
+       }
+       
+       attrs , err4 := a.objectAttrRepo.GetListById(modelId, objectId)
+       if err4 == nil {
+           return err4
+       }
+    
+       if action == 1 {
+           err5 := a.dataBus.Create(objectInfo, attrs, m)
+           if err5 == nil {
+               return err5
+           }
+       }
+       if action == 2 {
+           err5 := a.dataBus.Update(objectInfo, attrs, m)
+           if err5 == nil {
+               return err5
+           }
+       }
+       if action == 3 {
+           err5 := a.dataBus.Patch(objectInfo, attrs, m)
+           if err5 == nil {
+               return err5
+           }
+       }
+    
+       if action == 4 {
+           err5 := a.dataBus.Delete(objectInfo, attrs, m)
+           if err5 == nil {
+               return err5
+           }
+       }
+   }
+   
+   return nil
+}
 
 func (a apiGatewayService) Create(apiCode string, m map[string]interface{}) error {
-    //TODO implement me
-    panic("implement me")
+    return a.Handle(apiCode, 1, m)
 }
 
 func (a apiGatewayService) Update(apiCode string, m map[string]interface{}) error {
-    //TODO implement me
-    panic("implement me")
+    return a.Handle(apiCode, 2, m)
 }
 
 func (a apiGatewayService) Patch(apiCode string, m map[string]interface{}) error {
-    //TODO implement me
-    panic("implement me")
+    return a.Handle(apiCode, 3, m)
 }
 
 func (a apiGatewayService) Delete(apiCode string, m map[string]interface{}) error {
-    //TODO implement me
-    panic("implement me")
+    return a.Handle(apiCode, 4, m)
 }

service/api_trans_unit_service.go

@@ -12,6 +12,8 @@ type ApiTransUnitService interface {
     GetPage(m map[string]interface{}) (*viewmodels.PageResult, error)
     GetById(apiId, atuId int64) (*viewmodels.ApiTransUnitInfo, error)
     Create(d *datamodels.ApiTransUnit) error
+    Update(d *datamodels.ApiTransUnit) error
+    Delete(m map[string]interface{}) error
 }
 
 type apiTransUnitService struct {
@@ -36,7 +38,17 @@ func (s *apiTransUnitService) GetById(apiId, atuId int64) (*viewmodels.ApiTransU
     return s.repo.GetById(apiId, atuId)
 }
 
-func (s *apiTransUnitService) Create(apiTransUnit *datamodels.ApiTransUnit) error {
-    apiTransUnit.ApiId = NewID()
-    return s.repo.Create(apiTransUnit)
+func (s *apiTransUnitService) Create(atu *datamodels.ApiTransUnit) error {
+    atu.AtuId = NewID()
+    return s.repo.Create(atu)
+}
+
+
+func (s *apiTransUnitService) Update(atu *datamodels.ApiTransUnit) error {
+    return s.repo.Update(atu)
+}
+
+
+func (s *apiTransUnitService) Delete(m map[string]interface{}) error {
+    return s.repo.Delete(m)
 }

web/controllers/api_gateway_controller.go

@@ -1,6 +1,7 @@
 package controllers
 
 import (
+    "fmt"
     "github.com/kataras/iris/v12/mvc"
     "xps/service"
 )
@@ -21,6 +22,10 @@ func (c *ApiGatewayController) BeforeActivation(b mvc.BeforeActivation) {
 func (c *ApiGatewayController) Get(apiCode string) *JsonResult {
     m := c.buildParams()
     data, err := c.Service.Get(apiCode, m)
+    
+    m2, _ := c.GetJsonData()
+    fmt.Sprintf("%v", m2)
+    
     if err != nil {
         return ResultErr(err.Error(), nil)
     } else {
@@ -29,8 +34,12 @@ func (c *ApiGatewayController) Get(apiCode string) *JsonResult {
 }
 
 func (c *ApiGatewayController) Create(apiCode string) *JsonResult {
-    m := c.buildParams()
-    err := c.Service.Create(apiCode, m)
+    m, err := c.GetJsonData()
+    if err != nil {
+        return ResultErr(err.Error(), nil)
+    }
+    
+    err = c.Service.Create(apiCode, m)
     if err != nil {
         return ResultErr(err.Error(), nil)
     } else {
@@ -39,8 +48,12 @@ func (c *ApiGatewayController) Create(apiCode string) *JsonResult {
 }
 
 func (c *ApiGatewayController) Update(apiCode string) *JsonResult {
-    m := c.buildParams()
-    err := c.Service.Update(apiCode, m)
+    m, err := c.GetJsonData()
+    if err != nil {
+        return ResultErr(err.Error(), nil)
+    }
+    
+    err = c.Service.Update(apiCode, m)
     if err != nil {
         return ResultErr(err.Error(), nil)
     } else {
@@ -49,8 +62,12 @@ func (c *ApiGatewayController) Update(apiCode string) *JsonResult {
 }
 
 func (c *ApiGatewayController) Patch(apiCode string)*JsonResult{
-    m := c.buildParams()
-    err := c.Service.Patch(apiCode, m)
+    m, err := c.GetJsonData()
+    if err != nil {
+        return ResultErr(err.Error(), nil)
+    }
+    
+    err = c.Service.Patch(apiCode, m)
     if err != nil {
         return ResultErr(err.Error(), nil)
     } else {
@@ -59,8 +76,12 @@ func (c *ApiGatewayController) Patch(apiCode string)*JsonResult{
 }
 
 func (c *ApiGatewayController) Delete(apiCode string) *JsonResult {
-    m := c.buildParams()
-    err := c.Service.Delete(apiCode, m)
+    m, err := c.GetJsonData()
+    if err != nil {
+        return ResultErr(err.Error(), nil)
+    }
+    
+    err = c.Service.Delete(apiCode, m)
     if err != nil {
         return ResultErr(err.Error(), nil)
     } else {

web/controllers/api_trans_unit_controller.go

@@ -0,0 +1,95 @@
+package controllers
+
+import (
+    "github.com/kataras/iris/v12/mvc"
+    "xps/datamodels"
+    "xps/service"
+)
+
+type ApiTransUnitController struct {
+    Base
+    Service service.ApiTransUnitService
+}
+
+func (c *ApiTransUnitController) BeforeActivation(b mvc.BeforeActivation) {
+    b.Handle("GET",         "/",                              "GetList"       )
+    b.Handle("GET",         "/page",                          "GetPage"       )
+    b.Handle("GET",         "/{apiId:int64}/{atuId:int64}",   "GetById"       )
+    b.Handle("POST",        "/add",                           "Create"        )
+}
+
+func (c *ApiTransUnitController) GetList() *JsonResult {
+    params  := c.buildParams()
+    data, err := c.Service.GetList(params)
+    if err != nil {
+        return ResultErr(err.Error(), nil)
+    } else {
+        return ResultOk("获取成功", data)
+    }
+}
+
+func (c *ApiTransUnitController) GetPage() *JsonResult {
+    params  := c.buildParams()
+    data, err := c.Service.GetPage(params)
+    if err != nil {
+        return ResultErr(err.Error(), nil)
+    } else {
+        return ResultOk("获取成功", data)
+    }
+}
+
+func (c *ApiTransUnitController) GetById(apiId, atuId int64) *JsonResult {
+    data, err := c.Service.GetById(apiId, atuId)
+    if err != nil {
+        return ResultErr(err.Error(), nil)
+    } else {
+        return ResultOk("获取成功", data)
+    }
+}
+
+func (c *ApiTransUnitController) Create() *JsonResult {
+    userId := c.GetCurUserId()
+    
+    atu    := datamodels.ApiTransUnit{}
+    if err := c.Ctx.ReadJSON(&atu); err != nil {
+        return ResultErr("读取数据失败", nil)
+    }
+    
+    atu.CreatedBy = userId
+    if err := c.Service.Create(&atu); err != nil {
+        return ResultErr(err.Error(), nil)
+    } else {
+        return ResultOk("新增成功", nil)
+    }
+}
+
+
+func (c *ApiTransUnitController) Update() *JsonResult {
+    userId := c.GetCurUserId()
+    
+    atu := datamodels.ApiTransUnit{}
+    if err := c.Ctx.ReadJSON(&atu); err != nil {
+        return ResultErr("读取数据失败", nil)
+    }
+    
+    atu.UpdatedBy = userId
+    if err := c.Service.Update(&atu); err != nil {
+        return ResultErr(err.Error(), nil)
+    } else {
+        return ResultOk("更新成功", nil)
+    }
+}
+
+func (c *ApiTransUnitController) DeleteByID(apiId, atuId int64) *JsonResult {
+    userId := c.GetCurUserId()
+    
+    m := make(map[string]interface{})
+    m["apiId"]     = apiId
+    m["atuId"]     = atuId
+    m["deletedBy"] = userId
+    if err := c.Service.Delete(m); err != nil {
+        return ResultErr(err.Error(), nil)
+    } else {
+        return ResultOk("删除成功", nil)
+    }
+}

web/controllers/base_controller.go

@@ -3,6 +3,8 @@ package controllers
 import (
 	"github.com/go-playground/validator/v10"
 	"github.com/kataras/iris/v12"
+	"github.com/stretchr/objx"
+	"io"
 	"log"
 	"xps/cache"
 	"xps/viewmodels"
@@ -54,6 +56,20 @@ func (b *Base) GetAppSecret() string {
 	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 {
@@ -65,6 +81,7 @@ func (b *Base) buildParams() map[string]interface{} {
 		_ = b.Ctx.JSON(ResultErr(err.Error(), nil))
 		b.Ctx.Next()
 	}
+	
 	params := make(map[string]interface{})
 	params["ocId"] = ocId
 	params["userId"] = userId
@@ -133,3 +150,4 @@ func GetCurUser(userId int64) *viewmodels.UserData {
 	}
 	return userData
 }
+

web/router/routes.go

@@ -29,116 +29,116 @@ func Configure(b *bootstrap.Bootstrapper) {
 	loginApp.Handle(new(controllers.LoginController))
 
 	// role
-	sys := b.Party("/sys", crs).AllowMethods(iris.MethodOptions)
+	sysParty := b.Party("/sys", crs).AllowMethods(iris.MethodOptions)
 	{
-		sys.Use(middleware.AuthToken)
+		sysParty.Use(middleware.AuthToken)
 
 		// Role
 		roleService := service.NewRoleService()
-		roleApp := mvc.New(sys.Party("/role"))
+		roleApp := mvc.New(sysParty.Party("/role"))
 		roleApp.Register(roleService)
 		roleApp.Handle(new(controllers.RoleController))
 
 	}
 
 	// Company Profile
-	company := b.Party("/company", crs).AllowMethods(iris.MethodOptions)
+	companyParty := b.Party("/company", crs).AllowMethods(iris.MethodOptions)
 	{
-		company.Use(middleware.AuthToken)
+		companyParty.Use(middleware.AuthToken)
 		companyProfileService := service.NewCompanyProfileService()
-		companyProfileApp := mvc.New(company.Party("/profile"))
+		companyProfileApp := mvc.New(companyParty.Party("/profile"))
 		companyProfileApp.Register(companyProfileService)
 		companyProfileApp.Handle(new(controllers.CompanyProfileController))
 	}
 
 	// Group
-	group := b.Party("/group", crs).AllowMethods(iris.MethodOptions)
+	groupParty := b.Party("/group", crs).AllowMethods(iris.MethodOptions)
 	{
-		group.Use(middleware.AuthToken)
+		groupParty.Use(middleware.AuthToken)
 		groupService := service.NewGroupService()
-		groupApp := mvc.New(group.Party(""))
+		groupApp := mvc.New(groupParty.Party(""))
 		groupApp.Register(groupService)
 		groupApp.Handle(new(controllers.GroupController))
 	}
 
 	// User
-	user := b.Party("/user", crs).AllowMethods(iris.MethodOptions)
+	userParty := b.Party("/user", crs).AllowMethods(iris.MethodOptions)
 	{
-		user.Use(middleware.AuthToken)
+		userParty.Use(middleware.AuthToken)
 
 		// user
 		userService := service.NewUserService()
-		userApp := mvc.New(user.Party(""))
+		userApp := mvc.New(userParty.Party(""))
 		userApp.Register(userService)
 		userApp.Handle(new(controllers.UserController))
 	}
 	
 	// Position
-	position := b.Party("/position", crs).AllowMethods(iris.MethodOptions)
+	positionParty := b.Party("/position", crs).AllowMethods(iris.MethodOptions)
 	{
-		position.Use(middleware.AuthToken)
+		positionParty.Use(middleware.AuthToken)
 		positionService := service.NewPositionService()
-		positionApp := mvc.New(position.Party(""))
+		positionApp := mvc.New(positionParty.Party(""))
 		positionApp.Register(positionService)
 		positionApp.Handle(new(controllers.PositionController))
 	}
 
-	// GroupCat
-	groupCat := b.Party("/group", crs).AllowMethods(iris.MethodOptions)
+	// GroupCatParty
+	GroupCatParty := b.Party("/group", crs).AllowMethods(iris.MethodOptions)
 	{
-		groupCat.Use(middleware.AuthToken)
+		GroupCatParty.Use(middleware.AuthToken)
 		groupCatService := service.NewGroupCatService()
-		groupCatApp := mvc.New(groupCat.Party("/cat"))
+		groupCatApp := mvc.New(GroupCatParty.Party("/cat"))
 		groupCatApp.Register(groupCatService)
 		groupCatApp.Handle(new(controllers.GroupCatController))
 	}
 
 	// App
-	app := b.Party("/app", crs).AllowMethods(iris.MethodOptions)
+	appParty := b.Party("/app", crs).AllowMethods(iris.MethodOptions)
 	{
-		app.Use(middleware.AuthToken)
+		appParty.Use(middleware.AuthToken)
 		appService := service.NewAppService()
-		appApp := mvc.New(app.Party(""))
+		appApp := mvc.New(appParty.Party(""))
 		appApp.Register(appService)
 		appApp.Handle(new(controllers.AppController))
 
 		appCatService := service.NewAppCatService()
-		appCatApp := mvc.New(app.Party("/cat"))
+		appCatApp := mvc.New(appParty.Party("/cat"))
 		appCatApp.Register(appCatService)
 		appCatApp.Handle(new(controllers.AppCatController))
 		
 		appPermitService := service.NewAppPermitService()
-		appPermitApp := mvc.New(app.Party("/permit"))
+		appPermitApp := mvc.New(appParty.Party("/permit"))
 		appPermitApp.Register(appPermitService)
 		appPermitApp.Handle(new(controllers.AppPermitController))
 	}
 
 	// TaskCat
-	taskCat := b.Party("/task", crs).AllowMethods(iris.MethodOptions)
+	taskCatParty := b.Party("/task", crs).AllowMethods(iris.MethodOptions)
 	{
-		taskCat.Use(middleware.AuthToken)
+		taskCatParty.Use(middleware.AuthToken)
 		taskCatService := service.NewTaskCatService()
-		taskCatApp := mvc.New(taskCat.Party("/cat"))
+		taskCatApp := mvc.New(taskCatParty.Party("/cat"))
 		taskCatApp.Register(taskCatService)
 		taskCatApp.Handle(new(controllers.TaskCatController))
 	}
 
 	// EntCat
-	entCat := b.Party("/ent", crs).AllowMethods(iris.MethodOptions)
+	entCatParty := b.Party("/ent", crs).AllowMethods(iris.MethodOptions)
 	{
-		entCat.Use(middleware.AuthToken)
+		entCatParty.Use(middleware.AuthToken)
 		entCatService := service.NewEntCatService()
-		entCatApp := mvc.New(entCat.Party("/cat"))
+		entCatApp := mvc.New(entCatParty.Party("/cat"))
 		entCatApp.Register(entCatService)
 		entCatApp.Handle(new(controllers.EntCatController))
 	}
 
 	// PartnerCat
-	partnerCat := b.Party("/partner", crs).AllowMethods(iris.MethodOptions)
+	partnerCatParty := b.Party("/partner", crs).AllowMethods(iris.MethodOptions)
 	{
-		partnerCat.Use(middleware.AuthToken)
+		partnerCatParty.Use(middleware.AuthToken)
 		partnerCatService := service.NewPartnerCatService()
-		partnerCatApp := mvc.New(partnerCat.Party("/cat"))
+		partnerCatApp := mvc.New(partnerCatParty.Party("/cat"))
 		partnerCatApp.Register(partnerCatService)
 		partnerCatApp.Handle(new(controllers.PartnerCatController))
 	}
@@ -191,5 +191,20 @@ func Configure(b *bootstrap.Bootstrapper) {
 		reqApp := mvc.New(paasParty.Party("/api/request"))
 		reqApp.Register(reqService)
 		reqApp.Handle(new(controllers.ApiReqController))
+		
+		atuService := service.NewApiTransUnitService()
+		apiAtuApp := mvc.New(paasParty.Party("/api/atu"))
+		apiAtuApp.Register(atuService)
+		apiAtuApp.Handle(new(controllers.ApiTransUnitController))
+	}
+	
+	// x
+	xParty := b.Party("/x", crs).AllowMethods(iris.MethodOptions)
+	{
+		xParty.Use(middleware.AuthToken)
+		apiGatewayService := service.NewApiGatewayService()
+		apiGatewayApp := mvc.New(xParty.Party(""))
+		apiGatewayApp.Register(apiGatewayService)
+		apiGatewayApp.Handle(new(controllers.ApiGatewayController))
 	}
 }