fonchain-fiee/pkg/service/account/turnstile.go

package account

import (
	"errors"
	"fmt"
	"github.com/fonchain_enterprise/fonchain-main/api/account"
	"github.com/fonchain_enterprise/fonchain-main/pkg/cache"
	"github.com/fonchain_enterprise/fonchain-main/pkg/config"
	"github.com/fonchain_enterprise/fonchain-main/pkg/e"
	"github.com/fonchain_enterprise/fonchain-main/pkg/model/request"
	"github.com/fonchain_enterprise/fonchain-main/pkg/model/vo/turnstile"
	"github.com/fonchain_enterprise/fonchain-main/pkg/service"
	"github.com/fonchain_enterprise/fonchain-main/pkg/utils"
	"github.com/gin-gonic/gin"
	"github.com/go-redis/redis"
	"github.com/google/uuid"
	"strconv"
	"strings"
	"sync"
)

func DeviceNumToJobNums(data []*account.ClockUserDeviceBatch) map[string][]uint64 {
	deviceNumToJobNums := make(map[string][]uint64)
	for _, batch := range data {
		if _, exists := deviceNumToJobNums[batch.DeviceNum]; exists {
			deviceNumToJobNums[batch.DeviceNum] = append(deviceNumToJobNums[batch.DeviceNum], batch.UserId)
		} else {
			deviceNumToJobNums[batch.DeviceNum] = []uint64{batch.UserId}
		}
	}
	return deviceNumToJobNums
}
func getUserInfo(c *gin.Context, userIDs []uint64) (*account.ListResponse, error) {
	idsRequest := account.ListByIDsRequest{IDs: userIDs}
	userInfo, err := service.AccountProvider.ListByIDs(c, &idsRequest)
	if err != nil {
		return nil, err
	}

	for _, i := range userInfo.Data {
		if i.NickName == "" || i.RecentImg == "" {
			return nil, errors.New("请完善员工信息")
		}
	}

	return userInfo, nil
}

func SelectTheUserToBeDelivered(device *account.ClockDeviceListResponse, userInfo *account.ListResponse) (*account.ClockBatchListResponse, []turnstile.DeviceUserData) {
	nonMatchingData := account.ClockBatchListResponse{Data: []*account.ClockUserDeviceBatch{}}
	dataSet := make([]turnstile.DeviceUserData, 0, len(device.Data))
	deviceInfoMap := make(map[uint64]*account.ClockDeviceInfo)

	// 创建设备信息的映射
	for _, info := range device.Data {
		deviceInfoMap[info.Id] = info
	}

	// 遍历用户信息
	for _, user := range userInfo.Data {
		// 创建一个 map 以存储用户已匹配的设备
		userMatchedDevices := make(map[uint64]bool)

		// 遍历用户已经匹配的设备并记录在 userMatchedDevices 中
		for _, clock := range user.Clocks {
			if deviceInfo, exists := deviceInfoMap[clock.DeviceID]; exists {
				userMatchedDevices[deviceInfo.Id] = true
			}
		}

		// 遍历所有设备，查找未匹配的设备并添加到结果中
		for _, deviceInfo := range deviceInfoMap {
			if !userMatchedDevices[deviceInfo.Id] {
				data := &account.ClockUserDeviceBatch{
					UserId:     user.ID,
					DeviceId:   deviceInfo.Id,
					DeviceNum:  deviceInfo.DeviceNum,
					DeviceName: deviceInfo.DeviceName,
				}
				nonMatchingData.Data = append(nonMatchingData.Data, data)

				// 构造 DeviceUserData 并添加到 dataSet 中
				userData := turnstile.DeviceUserData{
					JobNum:     user.ID,
					RecentImg:  user.RecentImg,
					DeviceNum:  deviceInfo.DeviceNum,
					NickName:   user.NickName,
					Phone:      user.TelNum,
					DeviceName: deviceInfo.DeviceName,
					IcNum:      user.ICNum,
				}
				dataSet = append(dataSet, userData)
			}
		}
	}
	return &nonMatchingData, dataSet
}
func CheckDeviceIsOnline(dataSet map[string]string) string {
	offlineMap := make(map[string]bool)
	var redisClient *redis.Client
	if config.IsOut == true && config.Env == "prod" {
		redisClient = utils.GetNewRedisClient()
	} else {
		redisClient = cache.RedisClient
	}
	for deviceNum, deviceName := range dataSet {
		deviceRes, _ := redisClient.Get(cache.GetPushDeviceSnInfo(deviceNum)).Result()
		if deviceRes == "" {
			offlineMap[deviceName] = true
		}
	}
	// 如果有离线设备，返回错误消息
	if len(offlineMap) != 0 {
		offlineDevices := make([]string, 0, len(offlineMap))
		for deviceName := range offlineMap {
			offlineDevices = append(offlineDevices, deviceName)
		}
		errorMessage := fmt.Sprintf("以下设备已离线: %v", strings.Join(offlineDevices, ", "))
		return errorMessage
	}
	return ""
}

func ConcurrentUpdateDeviceUser(ctx *gin.Context, dataSet []turnstile.DeviceUserData, concurrency int) error {
	var wg sync.WaitGroup

	errCh := make(chan error, len(dataSet))

	// 创建一个带有缓冲的通道，以控制并发度
	semaphore := make(chan struct{}, concurrency)

	for _, data := range dataSet {
		wg.Add(1)
		semaphore <- struct{}{} // 获取信号量，限制并发度
		go func(data turnstile.DeviceUserData) {
			defer wg.Done()
			err := UpdateDeviceUser(ctx, data)
			if err != nil {
				errCh <- err
			}
			<-semaphore // 释放信号量
		}(data)
	}

	go func() {
		wg.Wait()
		close(errCh)
	}()

	var errors []error
	for err := range errCh {
		errors = append(errors, err)
	}

	if len(errors) > 0 {
		return fmt.Errorf("更新设备用户时发生错误: %v", errors)
	}

	return nil
}

// UpdateDeviceUser 绑定打卡机
func UpdateDeviceUser(_ *gin.Context, data turnstile.DeviceUserData) (err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		Extra: uuidObj.String(),
		To:    data.DeviceNum,
		Data: turnstile.TurnData{
			Cmd:            e.AddUser,
			UserId:         strconv.FormatUint(data.JobNum, 10),
			Name:           data.NickName,
			FaceTemplate:   data.RecentImg,
			TtsName:        data.NickName,
			Phone:          data.Phone,
			VlfaceTemplate: "",
			IdValid:        "",
			Ic:             data.IcNum,
		},
	}
	err, _ = utils.IssueTheCardPunchData(synReq, data.DeviceNum, uuidObj)
	if err != nil {
		return errors.New("下发数据失败")
	}
	return err
}

// DelSingleDeviceAccount 单人解绑打卡机
func DelSingleDeviceAccount(_ *gin.Context, deviceNum string, jobNum uint64) (err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    deviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:    e.DelUser,
			UserId: strconv.FormatUint(jobNum, 10),
		},
	}
	err, _ = utils.IssueTheCardPunchData(synReq, deviceNum, uuidObj)
	if err != nil {
		return errors.New("下发数据失败")
	}
	return err
}

// DelBatchDeviceAccount 批量解绑打卡机
func DelBatchDeviceAccount(req map[string][]uint64) (err error) {
	for deviceNum, jobNums := range req {
		uuidObj := uuid.New()
		stringSlice := make([]string, len(jobNums))
		for i, num := range jobNums {
			stringSlice[i] = strconv.FormatUint(num, 10)
		}
		synReq := turnstile.TurnStile{
			Cmd:   "to_device",
			From:  "Message1",
			To:    deviceNum,
			Extra: uuidObj.String(),
			Data: turnstile.TurnData{
				Cmd:      e.DelMultiUser,
				UserIds:  stringSlice,
				UserType: 0,
			},
		}
		err, _ = utils.IssueTheCardPunchData(synReq, deviceNum, uuidObj)
		if err != nil {
			return errors.New("下发数据失败")
		}
	}
	return err
}

// SnapPhotosOfTheScene 抓拍现场照片
func SnapPhotosOfTheScene(_ *gin.Context, deviceNum string) (image string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    deviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd: e.OnlineAuthorization,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, deviceNum, uuidObj)
	if err != nil {
		return "", errors.New("下发数据失败")
	}
	return s.Data.VlFaceTemplate, err
}

// CheckPictureQuality 检测图片质量
func CheckPictureQuality(_ *gin.Context, deviceNum string, faceImage string) (data turnstile.WebsocketDeviceData, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    deviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:          e.VerifyPhoto,
			FaceTemplate: faceImage,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, deviceNum, uuidObj)
	if err != nil {
		return data, errors.New("下发数据失败")
	}
	return s.Data, err
}

// GeneralRuleIssuance 通行规则下发
func GeneralRuleIssuance(_ *gin.Context, req turnstile.RuleIssuance) (err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:  e.AddPassRule,
			Rule: req.Data.Rule,
		},
	}
	err, _ = utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return errors.New("下发数据失败")
	}
	return err
}

// AccessRule 获取通行规则
func AccessRule(_ *gin.Context, req turnstile.RuleIssuance) (image []turnstile.Rule, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd: e.GetPassRule,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return nil, errors.New("下发数据失败")
	}
	return s.Data.Rule, err
}

// DeleteRule 删除通行规则
func DeleteRule(_ *gin.Context, req request.DeleteRule) (err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:         e.DelPassRule,
			RuleIds:     req.RuleIds,
			IsDeleteAll: req.IsDeleteAll,
		},
	}
	err, _ = utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return errors.New("下发数据失败")
	}
	return err
}

// PasswordSwitch 设置密码开门开关
func PasswordSwitch(_ *gin.Context, req request.DeviceReq) (err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetPasswordVerify,
			Value: req.Switch,
		},
	}
	err, _ = utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return errors.New("下发数据失败")
	}
	return err
}

// PasswordSet 设置设备开门密码
func PasswordSet(_ *gin.Context, req request.DeviceReq) (err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetOpenDoorPassword,
			Value: req.Value,
		},
	}
	err, _ = utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return errors.New("下发数据失败")
	}
	return err
}

// PersonSync 通知设备同步人员数据
func PersonSync(_ *gin.Context, req request.DeviceReq) (err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd: e.UploadFaceInfo,
		},
	}
	err, _ = utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return errors.New("下发数据失败")
	}
	return err
}

// PersonTotal 查询设备人员数量和id
func PersonTotal(_ *gin.Context, req request.DeviceReq) (res turnstile.WebsocketDeviceRes, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.GetUserInfo,
			Value: req.Value,
		},
	}
	err, res = utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return res, errors.New("下发数据失败")
	}
	return res, err
}

// PersonInfo 根据userid读取用户数据
func PersonInfo(_ *gin.Context, req request.DeviceReq) (res turnstile.UserDetails, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:    e.GetUserDetails,
			UserId: req.UserId,
			Value:  req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Details, errors.New("下发数据失败")
	}
	return s.Data.Details, err
}

// SetAcquire 获取设备设置
func SetAcquire(_ *gin.Context, req request.DeviceReq) (res turnstile.Settings, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:      e.GetDeviceSettings,
			Settings: req.Settings,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Settings, errors.New("下发数据失败")
	}
	return s.Data.Settings, err
}

// SetLogo 设置设备logo
func SetLogo(_ *gin.Context, req request.DeviceReq) (res turnstile.Settings, err error) {
	uuidObj := uuid.New()
	turnData := turnstile.TurnData{}
	if req.Type == 0 {
		turnData = turnstile.TurnData{
			Cmd:  e.CustomHomeLogo,
			Type: req.Type,
		}
	} else {
		turnData = turnstile.TurnData{
			Cmd:   e.CustomHomeLogo,
			Type:  req.Type,
			Text:  req.Text,
			Image: req.Image,
		}
	}
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data:  turnData,
	}

	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Settings, errors.New("下发数据失败")
	}
	return s.Data.Settings, err
}

// SetSlogan 设置广告语
func SetSlogan(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:         e.AetAd,
			Advertising: req.Advertising,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, err
}
func SetTime(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetTime,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}
func SetDoor(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:    e.SetDoor,
			Value:  req.Value,
			UserId: req.UserId,
			Type:   req.Type,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}
func SetInterval(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetRecognitionInterval,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}
func SetDistance(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetRecognitionDistance,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}
func SetMask(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetMaskDetection,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}
func SetLiving(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetLivenessDetection,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}
func SetLivingClass(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetLivenessLevel,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}
func SetStranger(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetStrangerRecognition,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}
func SetVolume(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetVolume,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}
func SetUsername(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetPlayUserName,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

func SetHint(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:       e.SetVoice,
			Type:      req.Type,
			VoiceCode: req.VoiceCode,
			VoiceText: req.VoiceText,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}
func SetPassword(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:         e.SetPassword,
			OldPassword: req.OldPassword,
			NewPassword: req.NewPassword,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}
func SetRestart(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd: e.Reboot,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

func SetRelay(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetRelayState,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

func SetCapture(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetRecordPictureQuality,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

func SetCallout(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetVisitorCallStatus,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

func SetPrinter(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetPrinterStatus,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

func SetVisitor(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetVisitorApplyValue,
			Value: req.Value,
			Url:   req.Url,
			Photo: req.Photo,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

func SetToken(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:        e.SetHttpToken,
			TokenKey:   req.TokenKey,
			TokenValue: req.TokenValue,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

func SetVerify(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetVerifyTimeout,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

func SetDelay(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetOpenDoorDelay,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

func SetPressTime(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetAdminLongPressTime,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

func SetDesensitization(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetDesensitizationName,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

func SetSection(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:      e.SetReadCardInfo,
			Value:    req.Value,
			Sector:   req.Sector,
			Block:    req.Block,
			Password: req.Password,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

func SetRail(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:       e.SetGeofence,
			Latitude:  req.Latitude,
			Longitude: req.Longitude,
			Radius:    req.Radius,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

// ScreensaverState 设备节能屏保开关
func ScreensaverState(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetScreensaverState,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

// Screensaver 设置设备屏保
func Screensaver(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:      e.AddCarousePicture,
			ID:       req.ID,
			Value:    req.Value,
			Duration: req.Duration,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

// DelScreensaver 删除屏保
func DelScreensaver(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:         e.DelCarouselPic,
			IsDeleteAll: req.IsDeleteAll,
			ID:          req.ID,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

// ScreensaverInterval 设置屏保显示时长
func ScreensaverInterval(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetScreensaverInterval,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

// TemperatureDetection 体温检测开关
func TemperatureDetection(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetTemperatureDetection,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

// TemperatureMode 体温检测模式
func TemperatureMode(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetTemperatureMode,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

// TemperatureStandard 初筛模式标准
func TemperatureStandard(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetPreliminaryScreeningStandard,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

// TemperatureCalibration 设置体温校准模式
func TemperatureCalibration(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetTemperatureCalibrationMode,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

// TemperatureLowPass 低温可通行开关
func TemperatureLowPass(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetLowTemperaturePass,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

// TemperaturePlay 播报体温开关
func TemperaturePlay(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetPlayTemperature,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

// TemperatureReflectivity 设置体温反射率
func TemperatureReflectivity(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetReflectivity,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

// TemperatureCorrection 设置体温校准值
func TemperatureCorrection(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetTemperatureCorrection,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

// TemperatureDistance 设置设备体温检测距离
func TemperatureDistance(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetTemperatureDetectDistance,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

// TemperatureMeasure 设置测温时间段
func TemperatureMeasure(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetMeasureTemperatureTime,
			Value: req.Value,
			Time:  req.Time,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

// VersionAuto 开机自动更新
func VersionAuto(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetAutoUpdate,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

// VersionInfo 获取设备版本信息
func VersionInfo(_ *gin.Context, req request.DeviceReq) (res turnstile.WebsocketDeviceData, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.GetVersionInfo,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data, errors.New("下发数据失败")
	}
	return s.Data, nil
}

// VersionPush 发送设备版本信息给服务端
func VersionPush(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.PushVersionInfo,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

// VersionCheck 通知设备在线检查更新
func VersionCheck(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.CheckForUpdates,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

// ApplyValue 设置设备首页二维码
func ApplyValue(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetVisitorApplyValue,
			Value: req.Value,
			Url:   req.Url,
			Photo: req.Photo,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

// ApplyPrefix 设置访客二维码前缀
func ApplyPrefix(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetVisitorQRCodePrefix,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

// CameraPanoramic 全景相机开关
func CameraPanoramic(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetPanoramicCamera,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

// CameraParams 设置全景相机的参数
func CameraParams(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:      e.SetPanoramicCameraParams,
			IP:       req.IP,
			Port:     req.Port,
			Username: req.Username,
			Password: req.Password,
			Channel:  req.Channel,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

// RecognitionStyle 识别结果样式
func RecognitionStyle(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetRecognitionResultStyle,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

// OnlineVerify 识别后在线验证
func OnlineVerify(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetOnlineVerifyAfterRecognition,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

// OnlineCard 在线验证卡号
func OnlineCard(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetOnlineVerifyCard,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

// OnlineIdCard 在线验证身份证号
func OnlineIdCard(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetOnlineVerifyIdCard,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

// Online 设置在线识别间隔
func Online(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetOnlineRecognitionInterval,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

// OnlineState 在线识别开关
func OnlineState(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetOnlineRecognitionState,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

// OnlineTemporary 临时启用在线识别
func OnlineTemporary(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetOnlineRecognition,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

// DiscernSettings 设置可通行人员类型
func DiscernSettings(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetPassType,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

// DiscernClass 设置设备识别置信度
func DiscernClass(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:         e.SetRecognitionLevel,
			Value:       req.Value,
			IrisValue:   req.IrisValue,
			FusionValue: req.FusionValue,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

// ForbiddenSwitch 开启/关闭设备识别
func ForbiddenSwitch(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:     e.SetSwitch,
			Value:   req.Value,
			OffTime: req.OffTime,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

// ForbiddenNumber 停用状态通行人数
func ForbiddenNumber(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:      e.SetDisablePass,
			Value:    req.Value,
			Duration: req.Duration,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

// AdvertisingAdd 下发广告 - 图片
func AdvertisingAdd(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:      e.AddImageAd,
			Value:    req.Value,
			ID:       req.ID,
			Duration: req.Duration,
			Priority: req.Priority,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

// AdvertisingDel 删除广告
func AdvertisingDel(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:      e.DelAd,
			IsDelAll: req.IsDeleteAll,
			ID:       req.ID,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

// AdvertisingChange 启用停用广告
func AdvertisingChange(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.ChangeADStatus,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}

// DoorLock 获取(上报)门锁状态
func DoorLock(_ *gin.Context, req request.DeviceReq) (res int, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd: e.GetDoorLockState,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Value, errors.New("下发数据失败")
	}
	return s.Data.Value, nil
}

// DoorListener 设置门锁实时监听开关
func DoorListener(_ *gin.Context, req request.DeviceReq) (res string, err error) {
	uuidObj := uuid.New()
	fmt.Println(uuidObj.String())
	synReq := turnstile.TurnStile{
		Cmd:   "to_device",
		From:  "Message1",
		To:    req.DeviceNum,
		Extra: uuidObj.String(),
		Data: turnstile.TurnData{
			Cmd:   e.SetDoorLockListener,
			Value: req.Value,
		},
	}
	err, s := utils.IssueTheCardPunchData(synReq, req.DeviceNum, uuidObj)
	if err != nil {
		return s.Data.Msg, errors.New("下发数据失败")
	}
	return s.Data.Msg, nil
}