package account

import (
	"context"
	"dubbo.apache.org/dubbo-go/v3/common/logger"
	"encoding/base64"
	"errors"
	"fmt"
	"github.com/fonchain_enterprise/fonchain-main/api/account"
	"github.com/fonchain_enterprise/fonchain-main/api/department"
	"github.com/fonchain_enterprise/fonchain-main/api/e_card"
	"github.com/fonchain_enterprise/fonchain-main/api/employee"
	"github.com/fonchain_enterprise/fonchain-main/api/position"
	"github.com/fonchain_enterprise/fonchain-main/api/rule"
	"github.com/fonchain_enterprise/fonchain-main/pkg/config"
	"github.com/fonchain_enterprise/fonchain-main/pkg/e"
	"github.com/fonchain_enterprise/fonchain-main/pkg/model/dto"
	"github.com/fonchain_enterprise/fonchain-main/pkg/model/login"
	"github.com/fonchain_enterprise/fonchain-main/pkg/model/query"
	"github.com/fonchain_enterprise/fonchain-main/pkg/model/request"
	"github.com/fonchain_enterprise/fonchain-main/pkg/model/union"
	"github.com/fonchain_enterprise/fonchain-main/pkg/model/vo"
	"github.com/fonchain_enterprise/fonchain-main/pkg/model/vo/turnstile"
	"github.com/fonchain_enterprise/fonchain-main/pkg/serializer"
	"github.com/fonchain_enterprise/fonchain-main/pkg/service"
	"github.com/fonchain_enterprise/fonchain-main/pkg/utils/secret"
	"github.com/fonchain_enterprise/utils/objstorage"
	"github.com/fonchain_enterprise/utils/utils"
	"github.com/gin-gonic/gin"
	"github.com/gin-gonic/gin/binding"
	uuid "github.com/satori/go.uuid"
	"net/http"
	"net/url"
	"strconv"
	"time"
)

// UserRegister 用户注册操作
func UserRegister(c *gin.Context) {
	var req union.User
	var res *account.RequestStatus
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	err, res := UserRegisters(c, req)
	if err != nil && err.Error() == "账号已存在" && req.Source == "exam" {
		handleExistingAccountForExam(c, req)
		service.Success(c, &res)
		return
	}
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	service.Success(c, res)
	return
}

func handleExistingAccountForExam(c *gin.Context, req union.User) {
	var Tel account.UsersByTelRequest
	var res account.RequestStatus
	// 初始化 Tels 切片
	Tel.Tels = make([]string, 1)
	// 赋值
	Tel.Tels[0] = req.TelNum

	// 查询用户信息
	telRes, _ := service.AccountProvider.UsersByTel(c, &Tel)

	// 更新 res 对象
	res.ID = telRes.Data[0].ID
	res.Status = "success"

	// 返回成功响应
	service.Success(c, &res)
	return
}

func UserRegisters(c *gin.Context, req union.User) (err error, res *account.RequestStatus) {
	if req.Avatar == "" {
		req.Avatar = "https://dci-file-new.bj.bcebos.com/fonchain-main/test/runtime/image/avatar/40/b8ed6fea-6662-416d-8bb3-1fd8a8197061.jpg"
	}
	if req.Source == "exam" {
		req.PositionUsers = []*position.PositionUser{
			{
				DepartmentName: "考试管理",
				PositionName:   "学员",
			},
		}
		req.Password = e.DEFAULT_PWD
	}
	//账号服务
	registRequest := account.RegistRequest{
		Domain:    req.Domain,
		NickName:  req.NickName,
		TelNum:    req.TelNum,
		Password:  req.Password,
		JobNum:    req.JobNum,
		Status:    req.Status,
		Avatar:    req.Avatar,
		EnterDate: req.EnterDate,
		Extend:    &account.Extend{JumpTo: req.JumpTo},
		RecentImg: req.RecentImg,
		Source:    req.Source,
	}

	if req.Operator != nil {
		registRequest.Operator = req.Operator
	}

	res, err = service.AccountProvider.Register(c, &registRequest)
	if err != nil {
		return err, res
	}
	if len(req.PositionUsers) <= 0 {
		return nil, res
	}
	//岗位服务 绑定岗位
	positionReq := &position.BindUserRequest{
		Domain:        req.Domain,
		UserID:        res.ID,
		UserName:      req.NickName,
		Avatar:        req.Avatar,
		PositionUsers: req.PositionUsers,
	}
	var err1 error // 声明 err1 变量
	if len(req.PositionUsers) > 0 && req.PositionUsers[0].DepartmentName != "" && req.PositionUsers[0].PositionName != "" {
		_, err1 = service.PositionProvider.BindUserForName(c, positionReq)
	} else {
		_, err1 = service.PositionProvider.BindUser(c, positionReq)
	}

	if err1 != nil {
		return err1, res
	}
	return err, res
}

// RefreshToken token
func RefreshToken(c *gin.Context) {

	var jumpToWhere = "setting"
	var isDriverAuth = false
	var isDriverSupervisorAuth = false

	var req account.RefreshTokenRequest

	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}

	req.Ip = c.ClientIP()

	res, err := service.AccountProvider.RefreshToken(context.Background(), &req)

	if err != nil {
		c.JSON(e.Success, serializer.Response{
			Code:   201,
			Status: 1,
			Msg:    err.Error(),
			Data:   nil,
		})
		c.Abort()
		return
	}

	//获取用户的岗位信息
	uReq := rule.RulesRequest{
		AccountID: res.AccountInfo.ID,
	}

	qres, err1 := service.RuleProvider.UserInfo(c, &uReq)

	if err1 != nil {
		service.Error(c, e.Error, err1)
		return
	}

	if len(qres.PositionUsers) >= 1 {
		isDriverAuth = isHaveDriverAuth(c, res.AccountInfo.ID, qres.PositionUsers[0].DepartmentId)
		isDriverSupervisorAuth = isHaveDriverSupervisorAuth(c, res.AccountInfo.ID, qres.PositionUsers[0].DepartmentId)
	}

	accountInfo := &union.AccountInfo{
		ID:                   res.AccountInfo.ID,
		Account:              res.AccountInfo.Account,
		NickName:             res.AccountInfo.NickName,
		Domain:               res.AccountInfo.Domain,
		TelNum:               res.AccountInfo.TelNum,
		Status:               res.AccountInfo.Status,
		Avatar:               res.AccountInfo.Avatar,
		CreatedAt:            res.AccountInfo.CreateAt,
		IsNeedChange:         res.AccountInfo.IsNeedChange,
		EnterDate:            res.AccountInfo.EnterDate,
		WorkYear:             res.AccountInfo.WorkYear,
		IsAdmin:              qres.IsAdmin,
		PositionUsers:        qres.PositionUsers,
		JumpTo:               res.AccountInfo.Extend.JumpTo,
		DepartmentName:       "",
		JobNum:               res.AccountInfo.JobNum,
		BirthDate:            res.AccountInfo.BirthDate,
		Age:                  res.AccountInfo.Age,
		Sex:                  res.AccountInfo.Sex,
		Title:                res.AccountInfo.Title,
		IDNum:                res.AccountInfo.IDNum,
		DriverAuth:           isDriverAuth,
		DriverSupervisorAuth: isDriverSupervisorAuth,
	}

	code := "xxx"
	if len(qres.PositionUsers) >= 1 {
		accountInfo.DepartmentName = qres.PositionUsers[0].DepartmentName
		code = secret.GetPositionCode(qres.PositionUsers[0].PositionName)
	}

	token, err := secret.CombineSecret(code, accountInfo.DepartmentName, res.Token)

	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	ruleUrlReq := rule.FindRuleByUrlRequest{
		AccountID: accountInfo.ID,
		Type:      "menu",
		Domain:    accountInfo.Domain,
		Url:       "/home",
		Method:    "*",
	}

	ruleInfo, ruleErr := service.RuleProvider.FindUserRule(c, &ruleUrlReq)
	if ruleInfo.IsPass == true {
		jumpToWhere = "home"
	}

	if ruleErr != nil {
		service.Error(c, e.Error, ruleErr)
		return
	}

	resInfo := &union.Login{
		Token:        token,
		RefreshToken: res.RefreshToken,
		AccountInfo:  accountInfo,
		JumpToWhere:  jumpToWhere,
	}

	service.Success(c, resInfo)

	return
}

// Offline 下线
func Offline(c *gin.Context) {

	intStr := c.DefaultQuery("id", "0")

	intNum, err := strconv.Atoi(intStr)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	req := account.CommonRequest{
		ID: uint64(intNum),
	}

	res, err := service.AccountProvider.OffLine(context.Background(), &req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, res)
	return
}

// OnlineInfoById 获取登陆信息
func OnlineInfoById(c *gin.Context) {

	intStr := c.DefaultQuery("id", "0")

	id, err := strconv.Atoi(intStr)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	req := account.OnlineLogByIdRequest{
		ID: uint64(id),
	}

	res, err := service.AccountProvider.OnlineLogById(context.Background(), &req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, res)
	return
}

// OnlineInfos 用户登录操作
func OnlineInfos(c *gin.Context) {

	intStr := c.DefaultQuery("UserId", "0")

	id, err := strconv.Atoi(intStr)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	req := account.LoginInfosByUserIdRequest{
		UserId: uint64(id),
	}

	res, err := service.AccountProvider.OnlineLog(context.Background(), &req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, res)
	return
}

// SendMsg 用户登录操作
func SendMsg(c *gin.Context) {

	var req account.SendMsgRequest

	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}

	req.SignNo = uint32(config.DefaultSignNo)
	res, err := service.AccountProvider.SendMsg(context.Background(), &req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, res)
	return
}

// CheckMsg 验证码是否正确
func CheckMsg(c *gin.Context) {

	var req account.CheckMsgRequest

	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}

	res, err := service.AccountProvider.CheckMsg(context.Background(), &req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, res)
	return
}

func UserLogout(c *gin.Context) {
	req := account.DecryptJwtRequest{}

	//获取jwt
	authorization := c.GetHeader(e.Authorization)
	if authorization == "" {
		service.Error(c, e.Error, errors.New("请求数据为空，请直接重新登录"))
		return
	}

	jwt, err := secret.GetJwtFromStr(authorization)
	if err != nil {
		service.Error(c, e.Error, err, "解析秘钥失败")
		return
	}

	req.Token = jwt

	//退出登陆
	res, err := service.AccountProvider.Logout(context.Background(), &req)

	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, res)
	return
}

// UserLogin 用户登录操作
func UserLogin(c *gin.Context) {

	var jumpToWhere = "setting"
	var isDriverAuth = false
	var isDriverSupervisorAuth = false

	var req account.LoginRequest
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	req.Ip = c.ClientIP()

	res, err := service.AccountProvider.Login(c, &req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	//获取用户的岗位信息
	uReq := rule.RulesRequest{
		AccountID: res.AccountInfo.ID,
	}

	qres, err1 := service.RuleProvider.UserInfo(c, &uReq)

	if err1 != nil {
		service.Error(c, e.Error, err1)
		return
	}

	if len(qres.PositionUsers) >= 1 {
		isDriverAuth = isHaveDriverAuth(c, res.AccountInfo.ID, qres.PositionUsers[0].DepartmentId)
		isDriverSupervisorAuth = isHaveDriverSupervisorAuth(c, res.AccountInfo.ID, qres.PositionUsers[0].DepartmentId)
	}

	accountInfo := &union.AccountInfo{
		ID:                   res.AccountInfo.ID,
		Account:              res.AccountInfo.Account,
		NickName:             res.AccountInfo.NickName,
		Domain:               res.AccountInfo.Domain,
		TelNum:               res.AccountInfo.TelNum,
		Status:               res.AccountInfo.Status,
		Avatar:               res.AccountInfo.Avatar,
		CreatedAt:            res.AccountInfo.CreateAt,
		IsNeedChange:         res.AccountInfo.IsNeedChange,
		EnterDate:            res.AccountInfo.EnterDate,
		WorkYear:             res.AccountInfo.WorkYear,
		IsAdmin:              qres.IsAdmin,
		PositionUsers:        qres.PositionUsers,
		JumpTo:               res.AccountInfo.Extend.JumpTo,
		DepartmentName:       "",
		JobNum:               res.AccountInfo.JobNum,
		BirthDate:            res.AccountInfo.BirthDate,
		Age:                  res.AccountInfo.Age,
		Sex:                  res.AccountInfo.Sex,
		Title:                res.AccountInfo.Title,
		IDNum:                res.AccountInfo.IDNum,
		DriverAuth:           isDriverAuth,
		DriverSupervisorAuth: isDriverSupervisorAuth,
		MailAccount:          res.AccountInfo.MailAccount,
		Train:                res.AccountInfo.Train,
		Certificate:          res.AccountInfo.Certificate,
		TrainVideos:          res.AccountInfo.TrainVideos,
	}

	code := "xxx"
	if len(qres.PositionUsers) >= 1 {
		accountInfo.DepartmentName = qres.PositionUsers[0].DepartmentName
		code = secret.GetPositionCode(qres.PositionUsers[0].PositionName)
	}

	token, err := secret.CombineSecret(code, accountInfo.DepartmentName, res.Token)

	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	ruleUrlReq := rule.FindRuleByUrlRequest{
		AccountID: accountInfo.ID,
		Type:      "menu",
		Domain:    accountInfo.Domain,
		Url:       "/home",
		Method:    "*",
	}

	ruleInfo, ruleErr := service.RuleProvider.FindUserRule(c, &ruleUrlReq)
	if ruleInfo.IsPass == true {
		jumpToWhere = "home"
	}

	if ruleErr != nil {
		service.Error(c, e.Error, ruleErr)
		return
	}

	resInfo := &union.Login{
		Token:        token,
		RefreshToken: res.RefreshToken,
		AccountInfo:  accountInfo,
		JumpToWhere:  jumpToWhere,
	}

	fmt.Println("是否相同：", res.IsSampleAddress, res.AccountInfo.NowLogId)
	if res.IsSampleAddress == false && res.AccountInfo.NowLogId != 0 { //登陆地址异常

		url := fmt.Sprintf("https://erpapi.fontree.cn/off7524164487E?id=%d", res.AccountInfo.NowLogId)
		shortUrl, err := utils.CreateShortUrl(url)
		if err == nil {
			url = shortUrl
		}

		msgReq := account.SendCustomMsgRequest{
			ID:     res.AccountInfo.ID,
			TelNum: res.AccountInfo.TelNum,
			MId:    134802,
			SigNo:  uint32(config.DefaultSignNo),
		}

		msgReq.Url = res.NowAddress + "|" + url
		fmt.Println("发送短信", msgReq)
		service.AccountProvider.SendCustomMsg(c, &msgReq)

	}

	service.Success(c, resInfo)

	return
}

// Authentication 用户实名认证操作
func Authentication(c *gin.Context) {
	//创建一个UserLoginService对象
	var req account.AuthenticationRequest

	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}

	authorization := c.GetHeader(e.Authorization)
	jwt, err := secret.GetJwtFromStr(authorization)
	if err != nil {
		service.Error(c, e.Error, err, "解析秘钥失败")
		return
	}

	req.Token = jwt

	res, err := service.AccountProvider.Authentication(context.Background(), &req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, res)
	return
}

func List(c *gin.Context) {
	//创建一个UserLoginService对象
	var req account.ListRequest
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}

	res, err := service.AccountProvider.List(context.Background(), &req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	//查询部门
	puRequest := &rule.PositionUserListRequest{}
	puRes, err := service.RuleProvider.PositionUserList(c, puRequest)

	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	if len(puRes.Data) > 0 {
		for index, t := range res.Data {

			var departments []*account.Department
			var positions []*account.PositionUser
			md := make(map[uint64]bool)
			mp := make(map[uint64]bool)

			for _, tt := range puRes.Data {
				if tt.UserId == t.ID {
					if _, ok := md[tt.DepartmentId]; !ok {
						temp := &account.Department{
							ID:   tt.DepartmentId,
							Name: tt.DepartmentName,
						}
						departments = append(departments, temp)
						md[tt.DepartmentId] = true
					}
					if _, ok := mp[tt.PositionID]; !ok {
						temp := &account.PositionUser{
							PositionID:   tt.PositionID,
							PositionName: tt.PositionName,
						}
						positions = append(positions, temp)
						md[tt.PositionID] = true
					}
				}
			}

			res.Data[index].Departments = departments
			res.Data[index].Positions = positions
		}
	}

	/*             ES  操作                   */
	//go es.BulkIndexAccountInfo(es.OaIndex)
	/*             ES  操作                   */

	service.Success(c, res)
	return
}

// PrivacyInfo 获取私密信息
func PrivacyInfo(c *gin.Context) {
	//创建一个UserLoginService对象
	var req account.PrivacyInfoRequest
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}

	res, err := service.AccountProvider.PrivacyInfo(context.Background(), &req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, res)
	return
}

// Remove 用户删除
func Remove(c *gin.Context) {
	//创建一个UserLoginService对象
	var req account.RemoveRequest
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}

	res, err := service.AccountProvider.Remove(context.Background(), &req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	//岗位删除
	positionReq := &position.RemoveUserRequest{
		Domain: req.Domain,
		ID:     req.ID,
	}

	_, err1 := service.PositionProvider.RemoveUser(c, positionReq)
	if err1 != nil {
		service.Error(c, e.Error, err1)
		return
	}

	//部门删除
	DepartmentReq := &department.RemoveUserRequest{
		Domain:   req.Domain,
		LeaderID: req.ID,
	}

	_, err2 := service.DepartmentProvider.RemoveUser(c, DepartmentReq)
	if err2 != nil {
		service.Error(c, e.Error, err2)
		return
	}

	service.Success(c, res)
}

// BaseInfo 用户信息
func BaseInfo(c *gin.Context) {
	//创建一个UserLoginService对象
	var req account.InfoRequest
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}

	res, err := service.AccountProvider.Info(context.Background(), &req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, res)
	return
}

func NowInfo(c *gin.Context) {
	//创建一个UserLoginService对象
	userInfo := login.GetUserInfoFromC(c)

	user, err := GetUserInfoById(c, userInfo.ID, userInfo.Domain)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}

	service.Success(c, user)
	return
}

func Info(c *gin.Context) {
	//创建一个UserLoginService对象
	var req account.InfoRequest

	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}

	user, err := GetUserInfoById(c, req.ID, req.Domain)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}

	service.Success(c, user)
	return
}

// Update 用户更新信息
func Update(c *gin.Context) {
	//创建一个UserLoginService对象
	var req union.User

	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}

	//账号服务
	var updateReq = account.UpdateRequest{
		ID:          req.ID,
		Domain:      req.Domain,
		NickName:    req.NickName,
		Password:    req.Password,
		TelNum:      req.TelNum,
		Avatar:      req.Avatar,
		Status:      req.Status,
		EnterDate:   req.EnterDate,
		JobNum:      req.JobNum,
		BirthDate:   req.BirthDate,
		Sex:         req.Sex,
		Title:       req.Title,
		LeftDate:    req.LeftDate,
		Remark:      req.Remark,
		RecentImg:   req.RecentImg,
		ICNum:       req.ICNum,
		Extend:      req.Extend,
		Train:       req.Train,
		Certificate: req.Certificate,
		Operator: &account.Operator{
			ID:   0,
			Name: "人员管理",
		},
	}

	if req.JumpTo != "" {
		if updateReq.Extend == nil {
			updateReq.Extend = &account.Extend{}
		}
		updateReq.Extend.JumpTo = req.JumpTo
	}

	user, err := GetUserInfoById(c, req.ID, req.Domain)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	_, err = service.AccountProvider.Update(context.Background(), &updateReq)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	//必须替换岗位
	if req.PositionUsers != nil && len(req.PositionUsers) > 0 {
		positionReq := &position.BindUserRequest{
			Domain:        req.Domain,
			UserID:        req.ID,
			UserName:      req.NickName,
			Avatar:        req.Avatar,
			PositionUsers: req.PositionUsers,
		}

		_, err1 := service.PositionProvider.BindUser(c, positionReq)
		if err1 != nil {
			service.Error(c, e.Error, err1)
			return
		}
	}
	if req.RecentImg != "" && req.RecentImg != user.RecentImg {
		_, _ = service.GrpcEmployeeProvider.UpdateEmployeeFile(c, &employee.UpdateEmployeeFileRequest{
			UserId:    user.ID,
			RecentImg: req.RecentImg,
		})
	}
	if req.RecentImg != "" && len(user.Clocks) > 0 && (req.RecentImg != user.RecentImg || req.NickName !=
		user.NickName || req.TelNum != user.TelNum || req.ICNum != user.ICNum) {
		if req.ICNum == "" {
			req.ICNum = user.ICNum
		}
		if req.NickName == "" {
			req.NickName = user.NickName
		}
		if req.TelNum == "" {
			req.TelNum = user.TelNum
		}
		var dataSet []turnstile.DeviceUserData
		var userId account.ClockUserDeviceBatch
		deviceNums := make(map[string]string)
		for _, i := range user.Clocks {
			data := turnstile.DeviceUserData{
				JobNum:     user.ID,
				RecentImg:  req.RecentImg,
				DeviceNum:  i.Device.DeviceNum,
				NickName:   req.NickName,
				Phone:      req.TelNum,
				DeviceName: i.Device.DeviceName,
				IcNum:      req.ICNum,
			}
			dataSet = append(dataSet, data)
		}
		for _, i := range user.Clocks {
			deviceNums[i.Device.DeviceNum] = i.Device.DeviceName
		}
		//判断设备是否离线
		oline := CheckDeviceIsOnline(deviceNums)
		if oline != "" {
			//service.Error(c, e.Error, errors.New(oline))
			//return
		}
		//并发下发数据
		err = ConcurrentUpdateDeviceUser(c, dataSet, 10)
		if err != nil {
			//service.Error(c, e.Error, err)
			//return
		}
		//更新绑定关系
		userId.UserId = user.ID
		_, err = service.AccountProvider.UpdateDeviceRelevance(c, &userId)
		if err != nil {
			//service.Error(c, e.Error, err)
			//return
		}
	}
	service.Success(c, user)
	return
}

// MallRandList 获取商城随机用户
func MallRandList(c *gin.Context) {
	//创建一个UserLoginService对象
	var req query.UserNumSearchQuery
	res := vo.UserListResponse{}

	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}

	//账号服务
	var updateReq = account.ListRequest{
		Domain:   "mall",
		PageSize: req.Num,
	}

	if req.UserId != 0 {
		updateReq.PageSize = 1
		res.Count = 1
		res.UserIds = []uint64{req.UserId}
		ures, _ := service.AccountProvider.RandList(context.Background(), &updateReq)
		res.DomainCount = ures.AllCount

		service.Success(c, res)
		return
	}

	ures, err := service.AccountProvider.RandList(context.Background(), &updateReq)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	res.Count = ures.Count
	var tempIds []uint64
	for _, v := range ures.Data {
		tempIds = append(tempIds, v.ID)
	}
	res.UserIds = tempIds
	res.DomainCount = ures.AllCount

	service.Success(c, res)
	return
}

func GetUserInfoById(c *gin.Context, ID uint64, domain string) (union.UserResponse, error) {
	info := union.UserResponse{}
	var driverAuth = false
	var driverSupervisorAuth = false

	req := account.InfoRequest{
		ID: ID,
	}
	if domain != "" {
		req.Domain = domain
	}

	res, err := service.AccountProvider.Info(c, &req)
	if err != nil {
		return info, err
	}

	//获取用户的岗位信息
	uReq := rule.RulesRequest{
		AccountID: req.ID,
	}

	qres, err1 := service.RuleProvider.UserInfo(c, &uReq)

	if err1 != nil {
		return info, err1
	}

	if len(qres.PositionUsers) >= 1 {
		driverAuth = isHaveDriverAuth(c, ID, qres.PositionUsers[0].DepartmentId)
		driverSupervisorAuth = isHaveDriverSupervisorAuth(c, ID, qres.PositionUsers[0].DepartmentId)
	}

	fReq := position.FindRuleByUserIdRequest{
		UserId: ID,
		Urls:   []string{e.AuthFinanceKey, e.AuthTrainingKey, e.AuthPublicizeKey, e.AuthWarehouseKey},
	}

	fRes, err1 := service.PositionProvider.FindRuleByUserId(c, &fReq)

	info = union.UserResponse{
		ID:                   res.Info.ID,
		NickName:             res.Info.NickName,
		TelNum:               res.Info.TelNum,
		Avatar:               res.Info.Avatar,
		Status:               res.Info.Status,
		CreateAt:             res.Info.CreateAt,
		IsAdmin:              qres.IsAdmin,
		RealNameID:           res.Info.RealNameID,
		RealName:             res.Info.RealName,
		PositionUsers:        qres.PositionUsers,
		DepartmentLeaders:    qres.DepartmentLeaders,
		IsNeedChange:         res.Info.IsNeedChange,
		WorkYear:             res.Info.WorkYear,
		EnterDate:            res.Info.EnterDate,
		Extend:               res.Info.Extend,
		DepartmentName:       "",
		JumpTo:               "",
		JobNum:               res.Info.JobNum,
		BirthDate:            res.Info.BirthDate,
		Sex:                  res.Info.Sex,
		Title:                res.Info.Title,
		Age:                  res.Info.Age,
		IDNum:                res.Info.IDNum,
		LeftDate:             res.Info.LeftDate,
		DriverAuth:           driverAuth,
		DriverSupervisorAuth: driverSupervisorAuth,
		Remark:               res.Info.Remark,
		RecentImg:            res.Info.RecentImg,
		Clocks:               res.Info.Clocks,
		MailAccount:          res.Info.MailAccount,
		ICNum:                res.Info.ICNum,
		Train:                res.Info.Train,
		Certificate:          res.Info.Certificate,
		TrainVideos:          res.Info.TrainVideos,
	}

	if res.Info.Extend != nil {
		info.JumpTo = res.Info.Extend.JumpTo
	}

	if len(qres.PositionUsers) >= 1 {
		info.DepartmentName = qres.PositionUsers[0].DepartmentName
	}

	if len(fRes.Rules) >= 1 {
		info.IdentityKey = fRes.Rules[0].Url
	}

	return info, nil
}

func isHaveDriverAuth(c *gin.Context, ID uint64, DepartmentID uint64) bool {
	isLeader := false

	req := position.DoIHavaAuthRequest{
		UserId:       ID,
		Url:          e.AuthDriveKey,
		DepartmentID: DepartmentID,
	}

	res, err := service.PositionProvider.DoIHavaAuth(c, &req)

	if err == nil && res.Hava == true {
		isLeader = true
	}

	return isLeader
}

func isHaveDriverSupervisorAuth(c *gin.Context, ID uint64, DepartmentID uint64) bool {
	isLeader := false

	req := position.DoIHavaAuthRequest{
		UserId:       ID,
		Url:          e.AuthDriveSupervisorKey,
		DepartmentID: DepartmentID,
	}

	res, err := service.PositionProvider.DoIHavaAuth(c, &req)

	if err == nil && res.Hava == true {
		isLeader = true
	}

	return isLeader
}

func MailAccount(c *gin.Context) {
	var req query.UserRequest

	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	mailReq := &account.MailAccountByNickNameRequest{NickName: req.NickName, ID: req.ID}

	mailRes, err := service.AccountProvider.MailAccountByNickName(c, mailReq)

	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, mailRes)
	return
}

func DepartmentLeaderList(c *gin.Context) {
	var req dto.DepartmentListReq

	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	findByUrlRequest := rule.FindByUrlRequest{
		Url:           e.DepartmentKey,
		DepartmentIds: req.DepartmentIds,
	}

	fmt.Println("=============================== FindByUrlRequest ==================================")
	fmt.Printf("findByUrlRequest : %+v\n", findByUrlRequest)

	res, err := service.RuleProvider.FindUsersByUrl(c, &findByUrlRequest)

	DepartmentListRes := new(dto.DepartmentListRes)
	DepartmentListRes.DepartmentLeaders = make([]dto.DepartmentLeader, 0)

	if err == nil && len(res.List) > 0 {
		for _, tt := range res.List {
			leader := dto.DepartmentLeader{
				UserID:   tt.UserId,
				UserName: tt.UserName,
			}
			DepartmentListRes.DepartmentLeaders = append(DepartmentListRes.DepartmentLeaders, leader)
			fmt.Println("=============================== FindByUrlResponse ==================================")
			fmt.Printf("leader : %+v\n", leader)

		}
	}

	service.ResponseMsg(c, e.SUCCESS, serializer.Response{
		Data:   DepartmentListRes,
		Status: e.Ok,
	})
}

// CreateClockDevice 创建打卡机
func CreateClockDevice(c *gin.Context) {
	var req account.CreateClockDeviceRequest
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	var in = account.CreateClockDeviceRequest{
		DeviceNum:  req.DeviceNum,
		DeviceName: req.DeviceName,
		DeviceSite: req.DeviceSite,
	}
	res, err := service.AccountProvider.CreateClockDevice(c, &in)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	service.Success(c, res)
}

// UpdateClockDevice 更新打卡机
func UpdateClockDevice(c *gin.Context) {
	var req account.UpdateClockDeviceRequest
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	var in = account.UpdateClockDeviceRequest{
		Id:         req.Id,
		DeviceNum:  req.DeviceNum,
		DeviceName: req.DeviceName,
		DeviceSite: req.DeviceSite,
	}
	res, err := service.AccountProvider.UpdateClockDevice(c, &in)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	service.Success(c, res)
}

// RemoveClockDevice 删除打卡机
func RemoveClockDevice(c *gin.Context) {
	var req account.RemoveClockDeviceRequest
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	var in = account.RemoveClockDeviceRequest{
		Id: req.Id,
	}
	res, err := service.AccountProvider.RemoveClockDevice(c, &in)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	service.Success(c, res)
}

// ClockDeviceInfo 查看打卡机详情
func ClockDeviceInfo(c *gin.Context) {
	var req account.ClockDeviceInfoRequest
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	var in = account.ClockDeviceInfoRequest{
		Id:       req.Id,
		Page:     req.Page,
		PageSize: req.PageSize,
	}
	res, err := service.AccountProvider.ClockDeviceInfo(c, &in)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	service.Success(c, res)
}

// ClockDeviceList 查看打卡机列表
func ClockDeviceList(c *gin.Context) {
	var req account.ClockDeviceListRequest
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	var in = account.ClockDeviceListRequest{
		DeviceSite: req.DeviceSite,
		DeviceNum:  req.DeviceNum,
		DeviceName: req.DeviceName,
		Page:       req.Page,
		PageSize:   req.PageSize,
	}
	res, err := service.AccountProvider.ClockDeviceList(c, &in)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	service.Success(c, res)
}

// ClockDeviceSingleUntie 单人解绑打卡机设备
func ClockDeviceSingleUntie(c *gin.Context) {
	var req account.RemoveClockDeviceRequest
	deviceNums := make(map[string]string)
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	var batch account.ClockBatchBindRequest
	batch.Id = req.Id
	devRes, err := service.AccountProvider.ClockDeviceBatchList(c, &batch) //获取设备列表
	if err != nil {
		service.Error(c, e.InvalidParams, errors.New("未找到设备"))
		return
	}
	for _, i := range devRes.Data {
		deviceNums[i.DeviceNum] = i.DeviceName
	}
	oline := CheckDeviceIsOnline(deviceNums)
	if oline != "" {
		service.Error(c, e.Error, errors.New(oline))
		return
	}
	err = DelSingleDeviceAccount(c, devRes.Data[0].DeviceNum, devRes.Data[0].UserId)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	res, err := service.AccountProvider.ClockDeviceSingleUntie(c, &req) //删除绑定关联
	service.Success(c, res)
	return
}

// ClockDeviceBatchBind 批量绑定打卡机
func ClockDeviceBatchBind(c *gin.Context) {
	var req account.ClockBatchBindRequest
	deviceNums := make(map[string]string)
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	deviceIds := account.ClockDeviceListRequest{
		Ids: req.DeviceId,
	}
	DeviceList, err := service.AccountProvider.ClockDeviceList(c, &deviceIds)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	//判断设备是否在线
	for _, i := range DeviceList.Data {
		deviceNums[i.DeviceNum] = i.DeviceName
	}
	oline := CheckDeviceIsOnline(deviceNums)
	if oline != "" {
		service.Error(c, e.Error, errors.New(oline))
		return
	}
	//判断所选员工姓名和近照是否存在
	userInfo, err := getUserInfo(c, req.UserId)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	// 整合数据
	data, dataSet := SelectTheUserToBeDelivered(DeviceList, userInfo)
	//保存不匹配的数据到新切片
	if len(data.Data) == 0 {
		service.Error(c, e.Error, errors.New("所选用户已经下发过"))
		return
	}
	//并发下发用户数据
	err = ConcurrentUpdateDeviceUser(c, dataSet, 10)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	//添加绑定关系
	res, err := service.AccountProvider.ClockDeviceBatchBind(c, data)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, res)
}

// ClockDeviceBatchUntie 批量解绑打卡机
func ClockDeviceBatchUntie(c *gin.Context) {
	var req account.ClockBatchBindRequest
	deviceNums := make(map[string]string)
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res1, err := service.AccountProvider.ClockDeviceBatchList(c, &req)
	if len(res1.Data) == 0 {
		service.Error(c, e.InvalidParams, errors.New("没有需要解绑的人员"))
		return
	}
	//判断设备是否在线
	for _, i := range res1.Data {
		deviceNums[i.DeviceNum] = i.DeviceName
	}
	oline := CheckDeviceIsOnline(deviceNums)
	if oline != "" {
		service.Error(c, e.Error, errors.New(oline))
		return
	}
	//整合数据
	data := DeviceNumToJobNums(res1.Data)
	//下发数据
	err = DelBatchDeviceAccount(data)
	if err != nil {
		service.Error(c, e.InvalidParams, errors.New("下发命令失败"))
		return
	}
	//删除关联
	res, err := service.AccountProvider.ClockDeviceBatchUntie(c, &req)
	if err != nil {
		service.Error(c, e.InvalidParams, errors.New("解绑失败"))
		return
	}
	service.Success(c, res)
	return
}

// ClockDeviceCapturePhoto 抓拍现场照片
func ClockDeviceCapturePhoto(c *gin.Context) {
	var req request.NotificationDevice
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := SnapPhotosOfTheScene(c, req.DeviceNum)
	if err != nil {
		service.Error(c, e.Error, errors.New("获取失败"))
		return
	}
	decodedData, err := url.QueryUnescape(res)
	if err != nil {
		fmt.Println("URL 解码时出错:", err)
		return
	}
	imageBytes, err := base64.StdEncoding.DecodeString(decodedData)
	if err != nil {
		service.Error(c, e.Error, errors.New("解码Base64时出错"))
		return
	}
	c.Writer.Header().Set("Content-Type", "image/png")
	_, _ = c.Writer.WriteString(string(imageBytes))
	service.Success(c, res)
	return
}

// ClockDeviceDetectionPhoto 检测图片质量
func ClockDeviceDetectionPhoto(c *gin.Context) {
	file, err := c.FormFile("file")
	source := c.PostForm("deviceNum")
	// 检验文件
	if err != nil {
		logger.Errorf("Upload FormFile err", err)
		service.Error(c, e.Error, err)
		return
	}
	// 打开上传的文件
	src, err := file.Open()
	if err != nil {
		logger.Errorf("Open file err: %v", err)
		c.JSON(http.StatusInternalServerError, gin.H{
			"error": "Unable to open file",
		})
		return
	}
	defer src.Close()
	// 读取文件内容到字节切片
	fileBytes := make([]byte, file.Size)
	_, err = src.Read(fileBytes)
	if err != nil {
		logger.Errorf("Read file err: %v", err)
		c.JSON(http.StatusInternalServerError, gin.H{
			"error": "Unable to read file",
		})
		return
	}
	// 将字节切片编码为Base64字符串
	base64String := base64.StdEncoding.EncodeToString(fileBytes)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	encodedData := url.QueryEscape(base64String)
	res, err := CheckPictureQuality(c, source, encodedData)
	if err != nil {
		service.Error(c, e.Error, errors.New("获取失败"))
		return
	}
	service.Success(c, res)
}

// ClockDeviceRuleIssuance 人员通行规则下发
func ClockDeviceRuleIssuance(c *gin.Context) {
	var req turnstile.RuleIssuance
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	err := GeneralRuleIssuance(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New("下发失败"))
		return
	}
	service.Success(c, nil)
	return
}

// ClockDeviceRuleAcquire 获取人员通行规则
func ClockDeviceRuleAcquire(c *gin.Context) {
	var req turnstile.RuleIssuance
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := AccessRule(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New("下发失败"))
		return
	}
	service.Success(c, res)
	return
}

// ClockDeviceRuleDelete 删除人员通行规则
func ClockDeviceRuleDelete(c *gin.Context) {
	var req request.DeleteRule
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	err := DeleteRule(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New("下发失败"))
		return
	}
	service.Success(c, nil)
	return
}

// ClockDevicePasswordSwitch 设备密码开门开关
func ClockDevicePasswordSwitch(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	err := PasswordSwitch(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New("下发失败"))
		return
	}
	service.Success(c, nil)
	return
}

// ClockDevicePasswordSet 设置设备开门密码
func ClockDevicePasswordSet(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	err := PasswordSet(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New("下发失败"))
		return
	}
	service.Success(c, nil)
	return
}

// ClockDevicePersonSync 通知设备同步人员数据
func ClockDevicePersonSync(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	err := PersonSync(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New("下发失败"))
		return
	}
	service.Success(c, nil)
	return
}

// ClockDevicePersonTotal 查询设备人员数量和id
func ClockDevicePersonTotal(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := PersonTotal(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New("获取失败"))
		return
	}
	service.Success(c, res)
	return
}

// ClockDevicePersonInfo 根据userid读取用户数据
func ClockDevicePersonInfo(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := PersonInfo(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New("获取失败"))
		return
	}
	service.Success(c, res)
	return
}

// ClockDeviceSetAcquire 获取设备设置
func ClockDeviceSetAcquire(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	lockStatus := -1
	if req.Settings[0] == "all" {
		lockStatus, _ = DoorLock(c, req)
	}
	res, err := SetAcquire(c, req)
	res.LockState = lockStatus
	if err != nil {
		service.Error(c, e.Error, errors.New("获取失败"))
		return
	}
	service.Success(c, res)
	return
}

// ClockDeviceSetLogo 设置设备logo
func ClockDeviceSetLogo(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := SetLogo(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New("获取失败"))
		return
	}
	service.Success(c, res)
	return
}

// ClockDeviceSetSlogan 设置广告语
func ClockDeviceSetSlogan(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := SetSlogan(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockDeviceSetTime 设置设备时间
func ClockDeviceSetTime(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := SetTime(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockDeviceSetDoor 控制设备开门/关门
func ClockDeviceSetDoor(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := SetDoor(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockDeviceSetInterval 设置设备识别间隔
func ClockDeviceSetInterval(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := SetInterval(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockDeviceSetDistance 设置设备识别距离
func ClockDeviceSetDistance(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := SetDistance(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockDeviceSetMask 口罩检测开关
func ClockDeviceSetMask(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := SetMask(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockDeviceSetLiving 活体检测
func ClockDeviceSetLiving(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := SetLiving(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockDeviceSetLivingClass 活体检测等级
func ClockDeviceSetLivingClass(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := SetLivingClass(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockDeviceSetStranger 陌生人识别
func ClockDeviceSetStranger(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := SetStranger(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockDeviceSetVolume 设备音量
func ClockDeviceSetVolume(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := SetVolume(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockDeviceSetUsername 播放用户名
func ClockDeviceSetUsername(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := SetUsername(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockDeviceSetHint 设置设备提示语音
func ClockDeviceSetHint(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := SetHint(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockDeviceSetPassword 修改进入设置页面密码
func ClockDeviceSetPassword(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := SetPassword(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockDeviceSetRestart 重启设备
func ClockDeviceSetRestart(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := SetRestart(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockDeviceSetRelay 设置继电器状态-常开/正常
func ClockDeviceSetRelay(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := SetRelay(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockDeviceSetCapture 设置设备识别照片抓拍的质量
func ClockDeviceSetCapture(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := SetCapture(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockDeviceSetCallout 访问呼叫开关
func ClockDeviceSetCallout(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := SetCallout(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockDeviceSetPrinter 打印机开关
func ClockDeviceSetPrinter(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := SetPrinter(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockDeviceSetVisitor 首页访客申请入库内容
func ClockDeviceSetVisitor(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := SetVisitor(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockDeviceSetToken 设置http请求的token
func ClockDeviceSetToken(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := SetToken(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockDeviceSetVerify 设置验证接口超时时长
func ClockDeviceSetVerify(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := SetVerify(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockDeviceSetDelay 设置设备开门延迟
func ClockDeviceSetDelay(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := SetDelay(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockDeviceSetPressTime 进入设置页面长按时间
func ClockDeviceSetPressTime(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := SetPressTime(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockDeviceSetDesensitization 姓名脱敏显示
func ClockDeviceSetDesensitization(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := SetDesensitization(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockDeviceSetSection 设置读卡扇区
func ClockDeviceSetSection(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := SetSection(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockDeviceSetRail 设置设备位置围栏
func ClockDeviceSetRail(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := SetRail(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockScreensaverState 设备节能屏保开关
func ClockScreensaverState(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := ScreensaverState(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockScreensaver 设置设备屏保
func ClockScreensaver(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := Screensaver(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockDelScreensaver 删除屏保
func ClockDelScreensaver(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := DelScreensaver(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockScreensaverInterval 设置屏保显示时长
func ClockScreensaverInterval(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := ScreensaverInterval(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockTemperatureDetection 体温检测开关
func ClockTemperatureDetection(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := TemperatureDetection(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockTemperatureMode 体温检测模式
func ClockTemperatureMode(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := TemperatureMode(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockTemperatureStandard 初筛模式标准
func ClockTemperatureStandard(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := TemperatureStandard(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockTemperatureCalibration 设置体温校准模式
func ClockTemperatureCalibration(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := TemperatureCalibration(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockTemperatureLowPass 低温可通行开关
func ClockTemperatureLowPass(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := TemperatureLowPass(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockTemperaturePlay 播报体温开关
func ClockTemperaturePlay(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := TemperaturePlay(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockTemperatureReflectivity 设置体温反射率
func ClockTemperatureReflectivity(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := TemperatureReflectivity(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockTemperatureCorrection 设置体温校准值
func ClockTemperatureCorrection(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := TemperatureCorrection(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockTemperatureDistance 设置设备体温检测距离
func ClockTemperatureDistance(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := TemperatureDistance(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockTemperatureMeasure 设置测温时间段
func ClockTemperatureMeasure(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := TemperatureMeasure(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockVersionAuto 开机自动更新
func ClockVersionAuto(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := VersionAuto(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockVersionInfo 获取设备版本信息
func ClockVersionInfo(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := VersionInfo(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res.Msg))
		return
	}
	service.Success(c, res)
	return
}

// ClockVersionPush 发送设备版本信息给服务端
func ClockVersionPush(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := VersionPush(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New("获取失败"))
		return
	}
	service.Success(c, res)
	return
}

// ClockVersionCheck 通知设备在线检查更新
func ClockVersionCheck(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := VersionCheck(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockApplyValue 设置设备首页二维码
func ClockApplyValue(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := ApplyValue(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockApplyPrefix 设置访客二维码前缀
func ClockApplyPrefix(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := ApplyPrefix(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockCameraPanoramic 全景相机开关
func ClockCameraPanoramic(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := CameraPanoramic(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockCameraParams 设置全景相机的参数
func ClockCameraParams(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := CameraParams(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockRecognitionStyle 识别结果样式
func ClockRecognitionStyle(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := RecognitionStyle(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockOnlineVerify 识别后在线验证
func ClockOnlineVerify(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := OnlineVerify(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockOnlineCard 在线验证卡号
func ClockOnlineCard(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := OnlineCard(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockOnlineIdCard 在线验证身份证号
func ClockOnlineIdCard(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := OnlineIdCard(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockOnline 设置在线识别间隔
func ClockOnline(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := Online(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockOnlineState 在线识别开关
func ClockOnlineState(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := OnlineState(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockOnlineTemporary 临时启用在线识别
func ClockOnlineTemporary(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := OnlineTemporary(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockDiscernSettings 设置可通行人员类型
func ClockDiscernSettings(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := DiscernSettings(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockDiscernClass 设置设备识别置信度
func ClockDiscernClass(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := DiscernClass(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockForbiddenSwitch 开启/关闭设备识别
func ClockForbiddenSwitch(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := ForbiddenSwitch(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockForbiddenNumber 停用状态通行人数
func ClockForbiddenNumber(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := ForbiddenNumber(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockAdvertisingAdd 下发广告 - 图片
func ClockAdvertisingAdd(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := AdvertisingAdd(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockAdvertisingDel 删除广告
func ClockAdvertisingDel(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := AdvertisingDel(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockAdvertisingChange 启用停用广告
func ClockAdvertisingChange(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := AdvertisingChange(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockDoorLock 获取(上报)门锁状态
func ClockDoorLock(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := DoorLock(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(strconv.Itoa(res)))
		return
	}
	service.Success(c, res)
	return
}

// ClockDoorListener 设置门锁实时监听开关
func ClockDoorListener(c *gin.Context) {
	var req request.DeviceReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := DoorListener(c, req)
	if err != nil {
		service.Error(c, e.Error, errors.New(res))
		return
	}
	service.Success(c, res)
	return
}

// ClockLogList 打卡记录列表
func ClockLogList(c *gin.Context) {
	req := &account.ClockLogReq{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := service.AccountProvider.FindClockLogList(c, req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	service.Success(c, res)
	return
}

// ClockLogInfo 打卡记录详情
func ClockLogInfo(c *gin.Context) {
	req := &account.ClockLogReq{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := service.AccountProvider.FindClockLogList(c, req)

	res.Count = uint64(len(res.Data))
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	service.Success(c, res)
	return
}

// ClockVisitor 访客申请
func ClockVisitor(c *gin.Context) {
	req := &account.ClockLogInfo{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	face, _ := SnapPhotosOfTheScene(c, req.Sn)
	decodedData, err := url.QueryUnescape(face)
	if err != nil {
		fmt.Println("URL 解码时出错:", err)
		return
	}
	uuids, _ := uuid.NewV4()
	var objectName = fmt.Sprintf("%s/%s/%s.jpeg", config.ConfigData.Oss.BaseDir, config.Env, uuids)
	BOSClient, _ := objstorage.NewOSS(config.ConfigData.Oss.AccessKeyId, config.ConfigData.Oss.AccessKeySecret, config.ConfigData.Oss.Endpoint)
	imageBytes, err := base64.StdEncoding.DecodeString(decodedData)
	_, err = BOSClient.PutObjectFromBytes(config.ConfigData.Oss.BucketName, objectName, imageBytes)
	Url := fmt.Sprintf("%s/%s", config.ConfigData.Oss.CdnHost, objectName)

	if err != nil {
		service.Error(c, e.Error, errors.New("解码Base64时出错"))
		return
	}
	userReq := &account.UserByTelRequest{
		Tel: req.ReceiverTel,
	}
	userRes, err := service.AccountProvider.UserByTel(c, userReq)
	if userRes.Info.ID == 0 || err != nil {
		service.Error(c, e.Error, errors.New("接待人不存在"))
		return
	}
	req = &account.ClockLogInfo{
		Sn:          req.Sn,
		UserId:      "F1000001",
		RecogType:   "manual_visitor",
		RecogTime:   time.Now().Format("2006-01-02 15:04:05"),
		Gender:      req.Gender,
		Photo:       Url,
		PassStatus:  1,
		UserName:    req.UserName,
		UserType:    2,
		Tel:         req.Tel,
		ReasonVisit: req.ReasonVisit,
		ReceiverTel: req.ReceiverTel,
		NumOfPeople: req.NumOfPeople,
	}
	res, err := service.AccountProvider.CreateClockLog(c, req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	strangerReq := account.SendClockInWechatRequest{
		GhId:    "gh_d838598b1a23",
		Address: req.Sn,
		UserId:  uint32(userRes.Info.ID),
		LogId:   res.Id,
	}
	_, err = service.AccountProvider.SendStrangerClockInWechat(c, &strangerReq)
	if err != nil {
		service.Error(c, e.Error, errors.New("接待人未注册"))
		return
	}
	service.Success(c, res)
	return
}

// ExamineList 审核列表
func ExamineList(c *gin.Context) {
	var req account.WriteOffListRequest
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := service.AccountProvider.FindWriteOffList(c, &req)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	service.Success(c, res)
}

// ExamineApprove 审批
func ExamineApprove(c *gin.Context) {
	var req account.WriteOffApproveRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := service.AccountProvider.WriteOffInfo(c, &req)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	if res.Status != 1 {
		service.Error(c, e.InvalidParams, errors.New("审批结束,不可重复提交"))
		return
	}
	_, err = service.AccountProvider.WriteOffUpdate(c, &req)
	if err != nil {
		service.Error(c, e.InvalidParams, errors.New("审批错误"))
		return
	}
	// 拒绝审批
	if req.Status == 3 {
		service.Success(c, res)
		return
	}
	// 通过审批
	if req.Status == 2 {
		err := handleApprovalSuccess(c, res)
		if err != nil {
			service.Error(c, e.Error, err)
			return
		}
		service.Success(c, res)
		return
	}

	service.Error(c, e.InvalidParams, errors.New("参数错误"))
	return
}

// ArtworkUserLogin 用户登录操作
func ArtworkUserLogin(c *gin.Context) {

	var jumpToWhere = "setting"

	var req account.LoginRequest
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	req.Ip = c.ClientIP()

	res, err := service.AccountProvider.Login(c, &req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	//获取用户的岗位信息
	uReq := rule.RulesRequest{
		AccountID: res.AccountInfo.ID,
	}

	qres, err1 := service.RuleProvider.UserInfo(c, &uReq)

	if err1 != nil {
		service.Error(c, e.Error, err1)
		return
	}

	if isHaveAuth(c, res.AccountInfo.ID, e.AuthArtworkFix, "button") == false {
		service.Error(c, e.Error, errors.New("您暂时没有登陆的权限"))
		return
	}

	accountInfo := &union.AccountInfo{
		ID:             res.AccountInfo.ID,
		Account:        res.AccountInfo.Account,
		NickName:       res.AccountInfo.NickName,
		Domain:         res.AccountInfo.Domain,
		TelNum:         res.AccountInfo.TelNum,
		Status:         res.AccountInfo.Status,
		Avatar:         res.AccountInfo.Avatar,
		CreatedAt:      res.AccountInfo.CreateAt,
		IsNeedChange:   res.AccountInfo.IsNeedChange,
		EnterDate:      res.AccountInfo.EnterDate,
		WorkYear:       res.AccountInfo.WorkYear,
		IsAdmin:        qres.IsAdmin,
		PositionUsers:  qres.PositionUsers,
		JumpTo:         res.AccountInfo.Extend.JumpTo,
		DepartmentName: "",
		JobNum:         res.AccountInfo.JobNum,
		BirthDate:      res.AccountInfo.BirthDate,
		Age:            res.AccountInfo.Age,
		Sex:            res.AccountInfo.Sex,
		Title:          res.AccountInfo.Title,
		IDNum:          res.AccountInfo.IDNum,
		MailAccount:    res.AccountInfo.MailAccount,
		Train:          res.AccountInfo.Train,
		Certificate:    res.AccountInfo.Certificate,
		TrainVideos:    res.AccountInfo.TrainVideos,
	}

	code := "xxx"
	if len(qres.PositionUsers) >= 1 {
		accountInfo.DepartmentName = qres.PositionUsers[0].DepartmentName
		code = secret.GetPositionCode(qres.PositionUsers[0].PositionName)
	}

	token, err := secret.CombineSecret(code, accountInfo.DepartmentName, res.Token)

	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	resInfo := &union.Login{
		Token:        token,
		RefreshToken: res.RefreshToken,
		AccountInfo:  accountInfo,
		JumpToWhere:  jumpToWhere,
	}

	fmt.Println("是否相同：", res.IsSampleAddress, res.AccountInfo.NowLogId)
	if res.IsSampleAddress == false && res.AccountInfo.NowLogId != 0 { //登陆地址异常

		url := fmt.Sprintf("https://erpapi.fontree.cn/off7524164487E?id=%d", res.AccountInfo.NowLogId)
		shortUrl, err := utils.CreateShortUrl(url)
		if err == nil {
			url = shortUrl
		}

		msgReq := account.SendCustomMsgRequest{
			ID:     res.AccountInfo.ID,
			TelNum: res.AccountInfo.TelNum,
			MId:    134802,
			SigNo:  uint32(config.DefaultSignNo),
		}

		msgReq.Url = res.NowAddress + "|" + url
		fmt.Println("发送短信", msgReq)
		service.AccountProvider.SendCustomMsg(c, &msgReq)

	}

	service.Success(c, resInfo)

	return
}

func isHaveAuth(c *gin.Context, ID uint64, url, ruleType string) bool {
	isLeader := false

	req := position.DoIHavaAuthRequest{
		UserId: ID,
		Url:    url,
		Type:   ruleType,
	}

	res, err := service.PositionProvider.DoIHavaAuth(c, &req)

	if err == nil && res.Hava == true {
		isLeader = true
	}

	return isLeader
}

// handleApprovalSuccess 处理通过审批的逻辑
func handleApprovalSuccess(c *gin.Context, req *account.WriteOffRequest) error {
	// 获取用户信息
	user, err := GetUserInfoById(c, req.UserId, req.Domain)
	if err != nil {
		return err
	}
	// 构建新的岗位用户列表，排除当前岗位
	newPositionUsers := filterPositionUsers(user.PositionUsers, req.SiteId)
	// 替换岗位
	positionReq := &position.BindUserRequest{
		Domain:        user.Domain,
		UserID:        user.ID,
		UserName:      user.NickName,
		Avatar:        user.Avatar,
		PositionUsers: newPositionUsers,
	}
	_, err = service.PositionProvider.BindUser(c, positionReq)
	if err != nil {
		return err
	}
	// 如果用户不属于其他部门，则将其状态设置为"left"
	if len(newPositionUsers) == 0 {
		removeReq := account.UpdateRequest{
			Domain: "fontree",
			ID:     req.UserId,
			Status: "left",
			Operator: &account.Operator{
				ID:   0,
				Name: "销售宝",
			},
		}
		_, err = service.AccountProvider.Update(c, &removeReq)
		if err != nil {
			return err
		}
	}

	return nil
}

// filterPositionUsers 过滤掉指定岗位的用户
func filterPositionUsers(users []*rule.PositionUser, siteID uint64) []*position.PositionUser {
	var newPositionUsers []*position.PositionUser
	for _, u := range users {
		if u.DepartmentId != siteID {
			p := &position.PositionUser{
				PositionID:     u.PositionID,
				DepartmentID:   u.DepartmentId,
				DepartmentCode: u.DepartmentCode,
				UserId:         u.UserId,
				UserName:       u.UserName,
				DepartmentName: u.DepartmentName,
				PositionName:   u.PositionName,
			}
			newPositionUsers = append(newPositionUsers, p)
		}
	}
	return newPositionUsers
}

func GetECardInfo(userID uint64, changedPlace string) (addChainRequest *e_card.AddChainRequest, err error) {
	// 生成电子名片
	// 获取用户信息，如果是非erp用户则不需要生成电子名片
	infoRequest := &account.InfoRequest{
		Domain: "fontree",
		ID:     userID,
	}
	var userInfo *account.InfoResponse
	userInfo, err = service.AccountProvider.Info(context.Background(), infoRequest)
	if err != nil {
		return
	}
	// 重新获取用户的部门、岗位
	rulesReq := &rule.RulesRequest{
		AccountID: userID,
	}

	qres, err := service.RuleProvider.UserInfo(context.Background(), rulesReq)
	if err != nil {
		return
	}

	var departments []string
	var posts []string

	for _, positionUser := range qres.PositionUsers {
		departments = append(departments, positionUser.DepartmentName)
		posts = append(posts, positionUser.PositionName)
	}

	addChainRequest = &e_card.AddChainRequest{
		Name:         userInfo.Info.NickName,
		Phone:        userInfo.Info.TelNum,
		Company:      "泰丰文化集团",
		Department:   departments,
		Post:         posts,
		DateOnBoard:  userInfo.Info.EnterDate,
		UserID:       int32(userID),
		Addr:         userInfo.Info.Account,
		ChangedPlace: changedPlace,
	}

	return
}