property-system-gateway/controller/v1/permission.go

package v1

import (
	"git.getensh.com/common/gopkgs/logger"
	"git.getensh.com/common/gopkgs/tasker/httptasker"
	"git.getensh.com/common/gopkgs/util"
	"github.com/gin-gonic/gin"
	"go.uber.org/zap"
	"net/http"
	"property-system-gateway/errors"
	param_v1 "property-system-gateway/param/v1"
	"property-system-gateway/pb"
	"property-system-gateway/pb/v1"
	"property-system-gateway/utils"
)

//
// @Summary 添加权限组
// @Description 添加权限组
// @Tags 权限管理
// @Accept  json
// @Produce  json
// @Param token header string true "token"
// @Param body body v1.GroupAddBody true "组信息"
// @Success 200 {object} v1.GroupAddResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/permission/group [post]
func (c *Controller) GroupAdd(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.GroupAddRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, &req.Header, nil, nil, &req.GroupAddBody)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}
		return nil
	}

	// 业务处理
	handleServiceTask := func() error {
		tokenInfo, err := utils.GetSubjectValue(ctx)
		if err != nil {
			return err
		}
		// 响应数据
		resp := param_v1.GroupAddResponse{}
		rpcReq := &v1.GroupAddRequest{
			GroupDesc:       req.GroupDesc,
			GroupName:       req.GroupName,
			PermissionCodes: req.PermissionCodes,
			Cid:             tokenInfo.Cid,
			GardenId:        tokenInfo.GardenId,
		}

		rpcRsp, err := pb.System.GroupAdd(ctx, rpcReq)

		if err != nil {
			s, _ := json.MarshalToString(req)
			logger.Error("func",
				zap.String("call", "pb.System.GroupAdd"),
				zap.String("params", s),
				zap.String("error", err.Error()))

			return errors.ErrorTransForm(err)
		}
		resp.Data = *rpcRsp
		ctx.JSON(http.StatusOK, resp)

		logReq := OperationLogRequest{
			Module:   ModulePermission,
			Action:   ActionGroupAdd,
			Origin:   nil,
			Target:   req.GroupAddBody,
			UserName: tokenInfo.UserName,
			Uid:      tokenInfo.Uid,
			Cid:      tokenInfo.Cid,
			GardenId: tokenInfo.GardenId,
		}
		go OperationLogAdd(&logReq)
		return nil
	}

	// 执行任务
	httptasker.Exec(ctx, parseParamTask, handleServiceTask)
}

//
// @Summary 更改权限组
// @Description 更改权限组
// @Tags 权限管理
// @Accept  json
// @Produce  json
// @Param token header string true "token"
// @Param body body v1.GroupUpdateBody true "组信息"
// @Success 200 {object} v1.GroupUpdateResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/permission/group [put]
func (c *Controller) GroupUpdate(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.GroupUpdateRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, &req.Header, nil, nil, &req.GroupUpdateBody)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}
		return nil
	}

	// 业务处理
	handleServiceTask := func() error {
		tokenInfo, err := utils.GetSubjectValue(ctx)
		if err != nil {
			return err
		}
		// 响应数据
		resp := param_v1.GroupUpdateResponse{}
		rpcReq := &v1.GroupUpdateRequest{
			GroupDesc:       req.GroupDesc,
			GroupName:       req.GroupName,
			PermissionCodes: req.PermissionCodes,
			Cid:             tokenInfo.Cid,
			GardenId:        tokenInfo.GardenId,
			Id:              req.Id,
		}

		rpcRsp, err := pb.System.GroupUpdate(ctx, rpcReq)

		if err != nil {
			s, _ := json.MarshalToString(req)
			logger.Error("func",
				zap.String("call", "pb.System.GroupUpdate"),
				zap.String("params", s),
				zap.String("error", err.Error()))

			return errors.ErrorTransForm(err)
		}
		ctx.JSON(http.StatusOK, resp)

		logReq := OperationLogRequest{
			Module:   ModulePermission,
			Action:   ActionGroupUpdate,
			Origin:   rpcRsp.Origin,
			Target:   req.GroupUpdateBody,
			UserName: tokenInfo.UserName,
			Uid:      tokenInfo.Uid,
			Cid:      tokenInfo.Cid,
			GardenId: tokenInfo.GardenId,
		}
		go OperationLogAdd(&logReq)
		return nil
	}

	// 执行任务
	httptasker.Exec(ctx, parseParamTask, handleServiceTask)
}

//
// @Summary 删除权限组
// @Description 删除权限组
// @Tags 权限管理
// @Accept  json
// @Produce  json
// @Param token header string true "token"
// @Param id query int true "组id"
// @Success 200 {object} v1.GroupDelResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/permission/group [delete]
func (c *Controller) GroupDel(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.GroupDelRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, &req.Header, nil, &req.GroupDelQuery, nil)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}
		return nil
	}

	// 业务处理
	handleServiceTask := func() error {
		tokenInfo, err := utils.GetSubjectValue(ctx)
		if err != nil {
			return err
		}

		// 响应数据
		resp := param_v1.GroupDelResponse{}
		rpcReq := &v1.GroupDelRequest{
			Id:       req.Id,
			Cid:      tokenInfo.Cid,
			GardenId: tokenInfo.GardenId,
		}

		rpcRsp, err := pb.System.GroupDel(ctx, rpcReq)

		if err != nil {
			s, _ := json.MarshalToString(req)
			logger.Error("func",
				zap.String("call", "pb.System.GroupDel"),
				zap.String("params", s),
				zap.String("error", err.Error()))

			return errors.ErrorTransForm(err)
		}
		ctx.JSON(http.StatusOK, resp)

		logReq := OperationLogRequest{
			Module:   ModulePermission,
			Action:   ActionGroupDel,
			Origin:   rpcRsp.Origin,
			Target:   nil,
			UserName: tokenInfo.UserName,
			Uid:      tokenInfo.Uid,
			Cid:      tokenInfo.Cid,
			GardenId: tokenInfo.GardenId,
		}
		go OperationLogAdd(&logReq)
		return nil
	}

	// 执行任务
	httptasker.Exec(ctx, parseParamTask, handleServiceTask)
}

//
// @Summary 权限组列表
// @Description 权限组列表
// @Tags 权限管理
// @Accept  json
// @Produce  json
// @Param token header string true "token"
// @Success 200 {object} v1.GroupListResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/permission/group_list [get]
func (c *Controller) GroupList(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.GroupListRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, &req.Header, nil, nil, nil)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}
		return nil
	}

	// 业务处理
	handleServiceTask := func() error {
		tokenInfo, err := utils.GetSubjectValue(ctx)
		if err != nil {
			return err
		}
		// 响应数据
		resp := param_v1.GroupListResponse{}
		rpcReq := &v1.GroupListRequest{
			Cid:      tokenInfo.Cid,
			GardenId: tokenInfo.GardenId,
		}

		rpcRsp, err := pb.System.GroupList(ctx, rpcReq)

		if err != nil {
			s, _ := json.MarshalToString(req)
			logger.Error("func",
				zap.String("call", "pb.System.GroupList"),
				zap.String("params", s),
				zap.String("error", err.Error()))

			return errors.ErrorTransForm(err)
		}
		if rpcRsp.List == nil {
			rpcRsp.List = make([]*v1.GroupItem, 0)
		}
		resp.Data = *rpcRsp
		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	httptasker.Exec(ctx, parseParamTask, handleServiceTask)
}

func handleGroupPermission(data []*v1.SystemGroupPermissionItem) []*v1.SystemGroupPermissionItem {
	if len(data) == 0 {
		return make([]*v1.SystemGroupPermissionItem, 0)
	}
	for i, _ := range data {
		data[i].Childs = handleGroupPermission(data[i].Childs)
	}
	return data
}

//
// @Summary 权限组信息
// @Description 权限组信息
// @Tags 权限管理
// @Accept  json
// @Produce  json
// @Param token header string true "token"
// @Param id query int true "组id"
// @Success 200 {object} v1.GroupInfoResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/permission/group_info [get]
func (c *Controller) GroupInfo(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.GroupInfoRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, &req.Header, nil, &req.GroupInfoQuery, nil)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}
		return nil
	}

	// 业务处理
	handleServiceTask := func() error {
		// 响应数据
		resp := param_v1.GroupInfoResponse{}
		rpcReq := &v1.GroupInfoRequest{
			Id: req.Id,
		}

		rpcRsp, err := pb.System.GroupInfo(ctx, rpcReq)

		if err != nil {
			s, _ := json.MarshalToString(req)
			logger.Error("func",
				zap.String("call", "pb.System.GroupInfo"),
				zap.String("params", s),
				zap.String("error", err.Error()))

			return errors.ErrorTransForm(err)
		}
		rpcRsp.List = handleGroupPermission(rpcRsp.List)
		resp.Data = *rpcRsp
		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	httptasker.Exec(ctx, parseParamTask, handleServiceTask)
}

func handleAllPermission(data []*v1.GardenPermissionItem) []*v1.GardenPermissionItem {
	if len(data) == 0 {
		return make([]*v1.GardenPermissionItem, 0)
	}
	for i, _ := range data {
		data[i].Childs = handleAllPermission(data[i].Childs)
	}
	return data
}

//
// @Summary 所有权限节点信息
// @Description 所有权限节点信息
// @Tags 权限管理
// @Accept  json
// @Produce  json
// @Param token header string true "token"
// @Success 200 {object} v1.AllPermissionResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/permission/all [get]
func (c *Controller) AllPermission(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.AllPermissionRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, &req.Header, nil, nil, nil)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}
		return nil
	}

	// 业务处理
	handleServiceTask := func() error {
		tokenInfo, err := utils.GetSubjectValue(ctx)
		if err != nil {
			return err
		}
		// 响应数据
		resp := param_v1.AllPermissionResponse{}
		rpcReq := &v1.GardenPermissionListRequest{
			GardenId: tokenInfo.GardenId,
		}

		rpcRsp, err := pb.System.GardenPermissionList(ctx, rpcReq)

		if err != nil {
			s, _ := json.MarshalToString(req)
			logger.Error("func",
				zap.String("call", "pb.System.GardenPermissionList"),
				zap.String("params", s),
				zap.String("error", err.Error()))

			return errors.ErrorTransForm(err)
		}
		rpcRsp.List = handleAllPermission(rpcRsp.List)
		resp.Data = *rpcRsp
		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	httptasker.Exec(ctx, parseParamTask, handleServiceTask)
}