审查视图

pkg/port/beego/controllers/web_client/roles_controller.go 5.0 KB
tangxuhui authored
1 2 3 4 5 6
package web_client

import (
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/application/web/roles/command"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/application/web/roles/query"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/application/web/roles/service"
7
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/log"
tangxuhui authored
8 9 10
)

type RolesController struct {
tangxuhui authored
11
	baseController
tangxuhui authored
12 13 14 15 16
}

func (controller *RolesController) RoleAdd() {
	rolesService := service.NewRolesService(nil)
	roleAddCommand := &command.RoleAddCommand{}
17 18 19 20
	err := controller.Unmarshal(roleAddCommand)
	if err != nil {
		log.Logger.Debug("json err:" + err.Error())
	}
tangxuhui authored
21
	roleAddCommand.Operator = controller.GetOperator()
tangxuhui authored
22 23 24 25 26 27 28
	data, err := rolesService.RoleAdd(roleAddCommand)
	controller.Response(data, err)
}

func (controller *RolesController) RoleUpdate() {
	rolesService := service.NewRolesService(nil)
	roleUpdateCommand := &command.RoleUpdateCommand{}
29 30 31 32
	err := controller.Unmarshal(roleUpdateCommand)
	if err != nil {
		log.Logger.Debug("json err:" + err.Error())
	}
tangxuhui authored
33 34
	roleId := controller.GetString(":roleId")
	roleUpdateCommand.RoleId = roleId
tangxuhui authored
35
	roleUpdateCommand.Operator = controller.GetOperator()
tangxuhui authored
36 37 38 39 40 41 42
	data, err := rolesService.RoleEdit(roleUpdateCommand)
	controller.Response(data, err)
}

func (controller *RolesController) RoleList() {
	rolesService := service.NewRolesService(nil)
	roleListQuery := &query.RoleListQuery{}
43 44 45 46
	err := controller.Unmarshal(roleListQuery)
	if err != nil {
		log.Logger.Debug("json err:" + err.Error())
	}
tangxuhui authored
47
	roleListQuery.Operator = controller.GetOperator()
tangxuhui authored
48
	cnt, data, err := rolesService.RoleList(roleListQuery)
yangfu authored
49
	controller.ReturnPageListData(cnt, data, err, roleListQuery.PageNumber)
tangxuhui authored
50 51 52 53 54 55 56
}

func (controller *RolesController) RoleGet() {
	rolesService := service.NewRolesService(nil)
	roleGetQuery := &query.RoleGetQuery{}
	roleId := controller.GetString(":roleId")
	roleGetQuery.RoleId = roleId
tangxuhui authored
57
	roleGetQuery.Operator = controller.GetOperator()
tangxuhui authored
58 59 60 61 62 63 64 65 66
	data, err := rolesService.RoleGet(roleGetQuery)
	controller.Response(data, err)
}

func (controller *RolesController) RoleUserInfo() {
	rolesService := service.NewRolesService(nil)
	roleUserInfoQuery := &query.RoleUserInfoQuery{}
	roleId, _ := controller.GetInt64(":roleId")
	roleUserInfoQuery.RoleId = roleId
tangxuhui authored
67
	roleUserInfoQuery.Operator = controller.GetOperator()
tangxuhui authored
68 69 70 71 72 73 74
	data, err := rolesService.RoleUserInfo(roleUserInfoQuery)
	controller.Response(data, err)
}

func (controller *RolesController) RoleUserAdd() {
	rolesService := service.NewRolesService(nil)
	roleUserAddQuery := &command.RoleUserAddCommand{}
75 76 77 78
	err := controller.Unmarshal(roleUserAddQuery)
	if err != nil {
		log.Logger.Debug("json err:" + err.Error())
	}
tangxuhui authored
79
	roleUserAddQuery.Operator = controller.GetOperator()
tangxuhui authored
80 81 82 83 84 85 86
	data, err := rolesService.RoleUserAdd(roleUserAddQuery)
	controller.Response(data, err)
}

func (controller *RolesController) RoleUserDelete() {
	rolesService := service.NewRolesService(nil)
	roleUserDeleteQuery := &command.RoleUserDeleteCommand{}
87 88 89 90
	err := controller.Unmarshal(roleUserDeleteQuery)
	if err != nil {
		log.Logger.Debug("json err:" + err.Error())
	}
tangxuhui authored
91
	roleUserDeleteQuery.Operator = controller.GetOperator()
tangxuhui authored
92 93 94 95 96 97 98
	data, err := rolesService.RoleUserDelete(roleUserDeleteQuery)
	controller.Response(data, err)
}

func (controller *RolesController) RoleUserBeforeEdit() {
	rolesService := service.NewRolesService(nil)
	roleUserBeforeEditQuery := &query.RoleUserBeforeEditQuery{}
yangfu authored
99
	roleUserBeforeEditQuery.Operator = controller.GetOperator()
yangfu authored
100 101
	roleId := controller.GetString("roleId")
	roleUserBeforeEditQuery.RoleId = roleId
tangxuhui authored
102 103 104 105 106 107 108
	data, err := rolesService.RoleUserBeforeEdit(roleUserBeforeEditQuery)
	controller.Response(data, err)
}

func (controller *RolesController) RoleMenuBeforeEdit() {
	rolesService := service.NewRolesService(nil)
	roleMenuBeforeEditQuery := &query.RoleMenuBeforeEditQuery{}
yangfu authored
109
	roleMenuBeforeEditQuery.Operator = controller.GetOperator()
110 111 112 113
	err := controller.Unmarshal(roleMenuBeforeEditQuery)
	if err != nil {
		log.Logger.Debug("json err:" + err.Error())
	}
yangfu authored
114 115
	roleId := controller.GetString(":roleId")
	roleMenuBeforeEditQuery.RoleId = roleId
tangxuhui authored
116 117 118 119 120 121 122
	data, err := rolesService.RoleMenuBeforeEdit(roleMenuBeforeEditQuery)
	controller.Response(data, err)
}

func (controller *RolesController) RoleMenuEdit() {
	rolesService := service.NewRolesService(nil)
	roleMenuEditQuery := &command.RoleMenuEditCommand{}
123 124 125 126
	err := controller.Unmarshal(roleMenuEditQuery)
	if err != nil {
		log.Logger.Debug("json err:" + err.Error())
	}
tangxuhui authored
127 128
	roleId := controller.GetString(":roleId")
	roleMenuEditQuery.RoleId = roleId
tangxuhui authored
129
	roleMenuEditQuery.Operator = controller.GetOperator()
tangxuhui authored
130 131 132
	data, err := rolesService.RoleMenuEdit(roleMenuEditQuery)
	controller.Response(data, err)
}
yangfu authored
133 134 135 136

func (controller *RolesController) RoleDelete() {
	rolesService := service.NewRolesService(nil)
	roleRemoveCommand := &command.RoleRemoveCommand{}
137 138 139 140
	err := controller.Unmarshal(roleRemoveCommand)
	if err != nil {
		log.Logger.Debug("json err:" + err.Error())
	}
yangfu authored
141 142 143 144
	roleRemoveCommand.Operator = controller.GetOperator()
	data, err := rolesService.RoleRemove(roleRemoveCommand)
	controller.Response(data, err)
}