property-system-gateway/controller/v1/gate.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"
	"sort"
)

//
// @Summary 门禁单元列表
// @Description 门禁单元列表
// @Tags 门禁
// @Accept  json
// @Produce  json
// @Param token header string true " "
// @Param device_id query int true "设备id"
// @Success 200 {object} v1.GateListResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/gate/unit [get]
func (c *Controller) GateUnitList(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.GateUnitListRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, &req.Header, nil, &req.GateUnitListQuery, 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
		}

		greq := &v1.UnitListRequest{GardenId: tokenInfo.GardenId, Page: -1, PageSize: -1}
		greply, err := pb.Garden.UnitList(ctx, greq)
		if err != nil {
			s, _ := json.MarshalToString(greq)
			logger.Error("func",
				zap.String("call", "Device.UnitList"),
				zap.String("params", s),
				zap.String("error", err.Error()))
			return errors.ErrorTransForm(err)
		}

		resp := param_v1.GateUnitListResponse{}
		rpcReq := &v1.GateUnitListRequest{
			GardenId: tokenInfo.GardenId,
			DeviceId: req.DeviceId,
		}

		rpcRsp, err := pb.Device.GateUnitList(ctx, rpcReq)
		if err != nil {
			s, _ := json.MarshalToString(req)
			logger.Error("func",
				zap.String("call", "Device.GateUnitList"),
				zap.String("params", s),
				zap.String("error", err.Error()))

			return errors.ErrorTransForm(err)
		}

		// 记录已添加的单元
		selected := map[int64]bool{}
		for _, v := range rpcRsp.UnitId {
			selected[v] = true
		}

		// 解析为返回的格式
		buildingM := map[int64][]param_v1.GateUnitBuildingUnitItem{}
		buildingInfoM := map[int64]param_v1.GateUnitBuildingItem{}
		for _, v := range greply.List {
			buildingInfoM[v.BuildingId] = param_v1.GateUnitBuildingItem{
				BuildingNumber: v.BuildingNumber,
				BuildingName:   v.BuildingName,
			}
			unitItem := param_v1.GateUnitBuildingUnitItem{
				UnitId:     v.Id,
				UnitNumber: v.UnitNumber,
				UnitName:   v.UnitName,
				Selected:   selected[v.Id],
			}
			buildingM[v.BuildingId] = append(buildingM[v.BuildingId], unitItem)
		}

		// 填充返回字段
		resp.Data.List = make([]param_v1.GateUnitBuildingItem, len(buildingInfoM))
		i := 0
		for buildingId, binfo := range buildingInfoM {
			resp.Data.List[i] = binfo
			resp.Data.List[i].Units = buildingM[buildingId]
			i++
		}

		// 按编号排序
		for k, _ := range resp.Data.List {
			sort.Slice(resp.Data.List[k].Units, func(i int, j int) bool {
				return resp.Data.List[k].Units[i].UnitNumber < resp.Data.List[k].Units[j].UnitNumber
			})
		}
		sort.Slice(resp.Data.List, func(i int, j int) bool { return resp.Data.List[i].BuildingNumber < resp.Data.List[j].BuildingNumber })

		ctx.JSON(http.StatusOK, resp)
		return nil
	}

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

//
// @Summary 门禁添加单元
// @Description 门禁添加单元
// @Tags 门禁
// @Accept  json
// @Produce  json
// @Param token header string true " "
// @Param body body v1.GateUnitAddBody true " "
// @Success 200 {object} v1.GateUnitAddResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/gate/unit [post]
func (c *Controller) GateUnitAdd(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.GateUnitAddRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, &req.Header, nil, nil, &req.GateUnitAddBody)
		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.GateUnitAddResponse{}
		rpcReq := &v1.GateUnitAddRequest{
			GardenId: tokenInfo.GardenId,
			DeviceId: req.DeviceId,
			UnitId:   req.UnitIds,
		}

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

			return errors.ErrorTransForm(err)
		}

		ctx.JSON(http.StatusOK, resp)
		return nil
	}

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

//
// @Summary 门禁卡号重新下发
// @Description 门禁卡号重新下发
// @Tags 门禁
// @Accept  json
// @Produce  json
// @Param token header string true " "
// @Param body body v1.GateCardSyncBody true " "
// @Success 200 {object} v1.GateCardSyncResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/gate/card [put]
func (c *Controller) GateCardSync(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.GateCardSyncRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, &req.Header, nil, nil, &req.GateCardSyncBody)
		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.GateCardSyncResponse{}
		rpcReq := &v1.GateCardSyncRequest{
			GardenId: tokenInfo.GardenId,
			Id:       req.Id,
		}

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

			return errors.ErrorTransForm(err)
		}

		ctx.JSON(http.StatusOK, resp)
		return nil
	}

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

//
// @Summary 删除卡
// @Description 删除卡
// @Tags 门禁
// @Accept  json
// @Produce  json
// @Param token header string true " "
// @Param id query int true "卡记录id"
// @Success 200 {object} v1.GateCardDelResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/gate/card [delete]
func (c *Controller) GateCardDel(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.GateCardDelRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, &req.Header, nil, &req.GateCardDelQuery, 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.GateCardDelResponse{}
		rpcReq := &v1.GateCardDelRequest{
			GardenId: tokenInfo.GardenId,
			Id:       req.Id,
		}

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

			return errors.ErrorTransForm(err)
		}

		ctx.JSON(http.StatusOK, resp)
		return nil
	}

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

//
// @Summary 添加卡
// @Description 添加卡
// @Tags 门禁
// @Accept  json
// @Produce  json
// @Param token header string true " "
// @Param body body v1.GateCardAddBody true " "
// @Success 200 {object} v1.GateCardAddResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/gate/card [post]
func (c *Controller) GateCardAdd(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.GateCardAddRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, &req.Header, nil, nil, &req.GateCardAddBody)
		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.GateCardAddResponse{}
		rpcReq := &v1.GateCardAddRequest{
			GardenId:   tokenInfo.GardenId,
			CardNumber: req.CardNumber,
			Name:       req.Name,
			DeviceIds:  req.DeviceIds,
		}

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

			return errors.ErrorTransForm(err)
		}

		ctx.JSON(http.StatusOK, resp)
		return nil
	}

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

//
// @Summary 卡列表
// @Description 卡列表
// @Tags 门禁
// @Accept  json
// @Produce  json
// @Param token header string true " "
// @Param page query int false " "
// @Param page_size query int false " "
// @Param name query string false "姓名"
// @Param down_status query int false "下发状态 0 不过滤 1 待下发 2 下发成功 3 下发失败"
// @Success 200 {object} v1.GateCardListResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/gate/card [get]
func (c *Controller) GateCardList(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.GateCardListRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, &req.Header, nil, &req.GateCardListQuery, 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.GateCardListResponse{}
		rpcReq := &v1.GateCardListRequest{
			Page:       req.Page,
			PageSize:   req.PageSize,
			GardenId:   tokenInfo.GardenId,
			Name:       req.Name,
			DownStatus: req.DownStatus,
		}

		rpcRsp, err := pb.Device.GateCardList(ctx, rpcReq)

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

			return errors.ErrorTransForm(err)
		}
		if rpcRsp.List == nil {
			rpcRsp.List = make([]*v1.GateCardItem, 0)
		}
		for i, v := range rpcRsp.List {
			if v.GatePermissions == nil {
				rpcRsp.List[i].GatePermissions = make([]*v1.GateCardDevice, 0)
			}
		}
		resp.Data = *rpcRsp

		ctx.JSON(http.StatusOK, resp)
		return nil
	}

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

//
// @Summary 卡还可以绑定的设备
// @Description 卡还可以绑定的设备
// @Tags 门禁
// @Accept  json
// @Produce  json
// @Param token header string true " "
// @Param card_number query string true "卡号"
// @Success 200 {object} v1.GateCardCanBindDevicesResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/gate/card/devices [get]
func (c *Controller) GateCardCanBindDevices(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.GateCardCanBindDevicesRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, &req.Header, nil, &req.GateCardCanBindDevicesQuery, 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.GateCardCanBindDevicesResponse{}
		rpcReq := &v1.GateCardCanBindDevicesRequest{

			GardenId:   tokenInfo.GardenId,
			CardNumber: req.CardNumber,
		}

		rpcRsp, err := pb.Device.GateCardCanBindDevices(ctx, rpcReq)

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

			return errors.ErrorTransForm(err)
		}
		if rpcRsp.List == nil {
			rpcRsp.List = make([]*v1.GateItem, 0)
		}
		resp.Data = *rpcRsp

		ctx.JSON(http.StatusOK, resp)
		return nil
	}

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

//
// @Summary 人脸重新下发
// @Description 人脸重新下发
// @Tags 门禁
// @Accept  json
// @Produce  json
// @Param token header string true " "
// @Param body body v1.GateUserPicSyncBody true " "
// @Success 200 {object} v1.GateUserPicSyncResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/gate/pic [put]
func (c *Controller) GateUserPicSync(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.GateUserPicSyncRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, &req.Header, nil, nil, &req.GateUserPicSyncBody)
		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.GateUserPicSyncResponse{}
		rpcReq := &v1.GateUserPicSyncRequest{
			GardenId: tokenInfo.GardenId,
			Id:       req.Id,
		}

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

			return errors.ErrorTransForm(err)
		}

		ctx.JSON(http.StatusOK, resp)
		return nil
	}

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

//
// @Summary 删除人脸
// @Description 删除人脸
// @Tags 门禁
// @Accept  json
// @Produce  json
// @Param token header string true " "
// @Param id query int true "人脸记录id"
// @Success 200 {object} v1.GateUserPicDelResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/gate/pic [delete]
func (c *Controller) GateUserPicDel(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.GateUserPicDelRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, &req.Header, nil, &req.GateUserPicDelQuery, 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.GateUserPicDelResponse{}
		rpcReq := &v1.GateUserPicDelRequest{
			GardenId: tokenInfo.GardenId,
			Id:       req.Id,
		}

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

			return errors.ErrorTransForm(err)
		}

		ctx.JSON(http.StatusOK, resp)
		return nil
	}

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

//
// @Summary 人脸审核
// @Description 人脸审核
// @Tags 门禁
// @Accept  json
// @Produce  json
// @Param token header string true " "
// @Param body body v1.GateUserPicApproveBody true " "
// @Success 200 {object} v1.GateUserPicApproveResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/gate/pic/approve [put]
func (c *Controller) GateUserPicApprove(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.GateUserPicApproveRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, &req.Header, nil, nil, &req.GateUserPicApproveBody)
		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.GateUserPicApproveResponse{}
		rpcReq := &v1.GateUserPicApproveRequest{
			GardenId: tokenInfo.GardenId,
			Id:       req.Id,
			Status:   req.Status,
		}

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

			return errors.ErrorTransForm(err)
		}

		ctx.JSON(http.StatusOK, resp)
		return nil
	}

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

//
// @Summary 人脸列表
// @Description 人脸列表
// @Tags 门禁
// @Accept  json
// @Produce  json
// @Param token header string true " "
// @Param page query int false " "
// @Param page_size query int false " "
// @Param name query string false "姓名"
// @Param down_status query int false "下发状态 0 不过滤 1 待下发 2 下发成功 3 下发失败"
// @Success 200 {object} v1.GateUserPicListResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/gate/pic [get]
func (c *Controller) GateUserPicList(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.GateUserPicListRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, &req.Header, nil, &req.GateUserPicListQuery, 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.GateUserPicListResponse{}
		rpcReq := &v1.GateUserPicListRequest{
			Page:       req.Page,
			PageSize:   req.PageSize,
			GardenId:   tokenInfo.GardenId,
			Name:       req.Name,
			DownStatus: req.DownStatus,
		}

		rpcRsp, err := pb.Device.GateUserPicList(ctx, rpcReq)

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

			return errors.ErrorTransForm(err)
		}
		if rpcRsp.List == nil {
			rpcRsp.List = make([]*v1.GateUserPicItem, 0)
		}
		for i, v := range rpcRsp.List {
			if v.GatePermissions == nil {
				rpcRsp.List[i].GatePermissions = make([]*v1.GateUserPicDevice, 0)
			}
		}
		resp.Data = *rpcRsp

		ctx.JSON(http.StatusOK, resp)
		return nil
	}

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

//
// @Summary 门禁列表
// @Description 门禁列表
// @Tags 门禁
// @Accept  json
// @Produce  json
// @Param token header string true " "
// @Param page query int false " "
// @Param page_size query int false " "
// @Param device_name query string false "设备名"
// @Param manufactor query string false "厂商"
// @Param sn query string false "序列号"
// @Success 200 {object} v1.GateListResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/gate [get]
func (c *Controller) GateList(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.GateListRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, &req.Header, nil, &req.GateListQuery, 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.GateListResponse{}
		rpcReq := &v1.GateListRequest{
			Page:       req.Page,
			PageSize:   req.PageSize,
			GardenId:   tokenInfo.GardenId,
			Sn:         req.Sn,
			DeviceName: req.DeviceName,
			Manufactor: req.Manufactor,
		}

		rpcRsp, err := pb.Device.GateList(ctx, rpcReq)

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

			return errors.ErrorTransForm(err)
		}
		if rpcRsp.List == nil {
			rpcRsp.List = make([]*v1.GateItem, 0)
		}
		resp.Data = *rpcRsp

		ctx.JSON(http.StatusOK, resp)
		return nil
	}

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

//
// @Summary 门禁起停用
// @Description 门禁起停用
// @Tags 门禁
// @Accept  json
// @Produce  json
// @Param token header string true " "
// @Param body body v1.GateEnableBody true " "
// @Success 200 {object} v1.GateEnableResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/gate/enable [put]
func (c *Controller) GateEnable(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.GateEnableRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, &req.Header, nil, nil, &req.GateEnableBody)
		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.GateEnableResponse{}
		rpcReq := &v1.GateEnableRequest{
			DeviceId: req.DeviceId,
			Enable:   req.Enable,
			GardenId: tokenInfo.GardenId,
		}

		_, err = pb.Device.GateEnable(ctx, rpcReq)

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

			return errors.ErrorTransForm(err)
		}

		ctx.JSON(http.StatusOK, resp)

		return nil
	}

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

//
// @Summary 门禁配置进场场和位置
// @Description 门禁配置进场场和位置
// @Tags 门禁
// @Accept  json
// @Produce  json
// @Param token header string true " "
// @Param body body v1.GateSetBody true " "
// @Success 200 {object} v1.GateSetResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/gate/set [put]
func (c *Controller) GateSet(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.GateSetRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, &req.Header, nil, nil, &req.GateSetBody)
		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.GateSetResponse{}
		rpcReq := &v1.GateSetRequest{
			DeviceId:  req.DeviceId,
			GardenId:  tokenInfo.GardenId,
			Location:  req.Location,
			Direction: req.Direction,
			GateName:  req.GateName,
			Ip:        req.Ip,
			Mac:       req.Mac,
			UserName:  req.User,
			Password:  req.Password,
		}

		_, err = pb.Device.GateSet(ctx, rpcReq)

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

			return errors.ErrorTransForm(err)
		}

		ctx.JSON(http.StatusOK, resp)

		return nil
	}

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

//
// @Summary 操作记录
// @Description 操作记录
// @Tags 门禁
// @Accept  json
// @Produce  json
// @Param token header string true " "
// @Param page query int false " "
// @Param page_size query int false " "
// @Param device_id query int true "设备id"
// @Success 200 {object} v1.GateCommandListResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/gate/command [get]
func (c *Controller) GateCommandList(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.GateCommandListRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, &req.Header, nil, &req.GateCommandListQuery, 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.GateCommandListResponse{}
		rpcReq := &v1.GateCommandListRequest{
			Page:     req.Page,
			PageSize: req.PageSize,
			DeviceId: req.DeviceId,
		}

		rpcRsp, err := pb.Device.GateCommandList(ctx, rpcReq)

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

			return errors.ErrorTransForm(err)
		}
		if rpcRsp.List == nil {
			rpcRsp.List = make([]*v1.GateCommandItem, 0)
		}
		resp.Data = *rpcRsp

		ctx.JSON(http.StatusOK, resp)
		return nil
	}

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

//
// @Summary 门禁远程开门
// @Description 门禁远程开门
// @Tags 门禁
// @Accept  json
// @Produce  json
// @Param token header string true " "
// @Param body body v1.GateOpenBody true " "
// @Success 200 {object} v1.GateOpenResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/gate/command/open [post]
func (c *Controller) GateOpen(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.GateOpenRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, &req.Header, nil, nil, &req.GateOpenBody)
		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.GateOpenResponse{}
		rpcReq := &v1.GateCommandAddRequest{
			DeviceId: req.DeviceId,
			CmdCode:  1,
		}

		_, err := pb.Device.GateCommandAdd(ctx, rpcReq)

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

			return errors.ErrorTransForm(err)
		}

		ctx.JSON(http.StatusOK, resp)

		return nil
	}

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

//
// @Summary 门禁重启设备
// @Description 门禁重启设备
// @Tags 门禁
// @Accept  json
// @Produce  json
// @Param token header string true " "
// @Param body body v1.GateRestartBody true " "
// @Success 200 {object} v1.GateRestartResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/gate/command/restart [post]
func (c *Controller) GateRestart(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.GateRestartRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, &req.Header, nil, nil, &req.GateRestartBody)
		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.GateRestartResponse{}
		rpcReq := &v1.GateCommandAddRequest{
			DeviceId: req.DeviceId,
			CmdCode:  2,
		}

		_, err := pb.Device.GateCommandAdd(ctx, rpcReq)

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

			return errors.ErrorTransForm(err)
		}

		ctx.JSON(http.StatusOK, resp)

		return nil
	}

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

//
// @Summary 开门记录
// @Description 开门记录
// @Tags 门禁
// @Accept  json
// @Produce  json
// @Param token header string true " "
// @Param page query int false " "
// @Param page_size query int false " "
// @Param device_id query string false "设备id必传"
// @Param start query int false "开始时间"
// @Param end query int false "结束时间"
// @Param is_visitor query int false "0不过滤 1 访客 2 非访客"
// @Success 200 {object} v1.GateRecordListResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/gate/record [get]
func (c *Controller) GateRecordList(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.GateRecordListRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, &req.Header, nil, &req.GateRecordListQuery, 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.GateRecordListResponse{}
		rpcReq := &v1.GateRecordListRequest{
			Page:      req.Page,
			PageSize:  req.PageSize,
			DeviceId:  req.DeviceId,
			Start:     req.Start,
			End:       req.End,
			IsVisitor: req.IsVisitor,
		}

		rpcRsp, err := pb.Device.GateRecordList(ctx, rpcReq)

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

			return errors.ErrorTransForm(err)
		}
		if rpcRsp.List == nil {
			rpcRsp.List = make([]*v1.GateRecordItem, 0)
		}
		resp.Data = *rpcRsp

		ctx.JSON(http.StatusOK, resp)
		return nil
	}

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

//
// @Summary 访客记录
// @Description 访客记录
// @Tags 门禁
// @Accept  json
// @Produce  json
// @Param token header string true " "
// @Param page query int false " "
// @Param page_size query int false " "
// @Param gate_id query int64 false "门禁id必传"
// @Param start query int false "开始时间"
// @Param end query int false "结束时间"
// @Param user query string false "邀请人"
// @Param visitor query string false "被邀请人"
// @Success 200 {object} v1.GateVisitorListResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/gate/visitor [get]
func (c *Controller) GateVisitorList(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.GateVisitorListRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, &req.Header, nil, &req.GateVisitorListQuery, 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.GateVisitorListResponse{}
		rpcReq := &v1.GateVisitorListRequest{
			Page:     req.Page,
			PageSize: req.PageSize,
			DeviceId: req.GateId,
			Start:    req.Start,
			End:      req.End,
			Name:     req.User,
			Visitor:  req.Visitor,
		}

		rpcRsp, err := pb.Device.GateVisitorList(ctx, rpcReq)

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

			return errors.ErrorTransForm(err)
		}
		if rpcRsp.List == nil {
			rpcRsp.List = make([]*v1.GateVisitorListItem, 0)
		}
		resp.Data = *rpcRsp

		ctx.JSON(http.StatusOK, resp)
		return nil
	}

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