appPlatform/api/version1/publicapi/api.go

package publicapi

import (
	"appPlatform/middleware/grocerystore"
	"appPlatform/models/modelshr"
	"appPlatform/models/modelsschool"
	"appPlatform/overall"
	"appPlatform/overall/publicmethod"
	"encoding/json"
	"fmt"
	"net/http"
	"strconv"
	"strings"
	"time"
	"unicode"

	"github.com/gin-gonic/gin"
	"github.com/mitchellh/mapstructure"
	"github.com/mozillazg/go-pinyin"
)

/*
*
@ 作者: 秦东
@ 时间: 2023-07-05 11:41:12
@ 功能:获取汉字首字母
@ 参数

	#

@ 返回值

	#

@ 方法原型

	#
*/
func (a *ApiMethod) ChineseInitial(c *gin.Context) {
	var requestData publicmethod.PublicName
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		publicmethod.Result(100, err, c)
		return
	}
	if requestData.Name == "" {
		publicmethod.Result(1, requestData.Name, c, "请输入关键字！")
		return
	}
	var wordStr string
	for _, v := range requestData.Name {
		if unicode.Is(unicode.Han, v) {
			firstWord := publicmethod.ChineseFirstWordCapitalize(fmt.Sprintf("%c", v))
			smallWord := strings.ToLower(firstWord)
			// fmt.Printf("sddff--->%v----------->%v\n", firstWord, smallWord)
			wordStr = fmt.Sprintf("%v%v", wordStr, smallWord)
		} else {
			wordStr = fmt.Sprintf("%v%c", wordStr, v)
		}

	}
	// fmt.Printf("请输入关键字！----->%v\n", wordStr)
	// firstWord := publicmethod.ChineseFirstWordCapitalize(requestData.Name)
	// smallWord := strings.ToLower(firstWord)
	var keyField string
	jbq := 0
	for _, kj := range wordStr {
		if jbq < 1 {
			if !unicode.IsNumber(kj) {
				jbq++
			}
		}
		if jbq > 0 {
			keyField = fmt.Sprintf("%v%c", keyField, kj)
		}

	}
	publicmethod.Result(0, keyField, c)
}

/*
*
@ 作者: 秦东
@ 时间: 2023-07-07 09:27:19
@ 功能: 输出编号
@ 参数

	#

@ 返回值

	#

@ 方法原型

	#
*/
func (a *ApiMethod) SendNumber(c *gin.Context) {
	var requestData publicmethod.CommonId[int64]
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		requestData.Id = 9
	}
	if requestData.Id == 0 {
		requestData.Id = 9
	}
	uuid := publicmethod.GetUUid(requestData.Id)
	var sendCont SendUUID
	sendCont.UuId = uuid
	sendCont.UuIdString = strconv.FormatInt(uuid, 10)
	publicmethod.Result(0, sendCont, c)
}

/*
*
@ 作者: 秦东
@ 时间: 2023-07-20 11:41:00
@ 功能: 生成身份验证唯一识别符
@ 参数

	#

@ 返回值

	#

@ 方法原型

	#
*/
func (a *ApiMethod) GenerateSignCode(c *gin.Context) {
	userKey := c.Request.Header.Get("user-key")
	userToken := c.Request.Header.Get("user-token")
	if userKey == "" || userToken == "" {
		publicmethod.Result(1, userKey, c, "验证失败！未知识别符！")
		return
	}
	uuid := publicmethod.GetUUid(6)
	uuidStr := strconv.FormatInt(uuid, 10)
	signCode := publicmethod.Sha1Encryption(uuidStr)

	var singCodeMd5 publicmethod.Md5Encryption
	singCodeMd5.Md5EncryptionInit(signCode)
	signCodeRedisKey := singCodeMd5.Md5EncryptionAlgorithm()
	redisFileKey := fmt.Sprintf("ScanCode:Aut:IdentRec_%v_%v", overall.CONSTANT_CONFIG.RedisPrefixStr.Alias, signCodeRedisKey)
	redisClient := grocerystore.RunRedis(overall.CONSTANT_REDIS4)
	redisClient.SetRedisTime(180)
	writeRedisData := map[string]interface{}{
		"userkey":   userKey,
		"usertoken": userToken,
	}
	redisClient.HashMsetAdd(redisFileKey, writeRedisData)
	sendCode := publicmethod.MapOut[string]()
	sendCode["code"] = signCode
	publicmethod.Result(0, sendCode, c)
}

/*
*
@ 作者: 秦东
@ 时间: 2023-09-26 11:51:43
@ 功能: 中文转拼音
@ 参数

	#

@ 返回值

	#

@ 方法原型

	#
*/
func (a *ApiMethod) ChineseToPinyin(c *gin.Context) {
	var requestData HanziToPinyin
	c.ShouldBindJSON(&requestData)
	if requestData.Title == "" {
		publicmethod.Result(1, requestData, c, "未知中文语句！")
		return
	}
	pyObject := pinyin.NewArgs()
	switch requestData.Types {
	case 1:
		pyObject.Style = pinyin.Tone
	case 2:
		pyObject.Style = pinyin.Tone2
	case 3:
		pyObject.Style = pinyin.Initials
	case 4:
		pyObject.Style = pinyin.FirstLetter
	case 5:
		pyObject.Style = pinyin.Finals
	case 6:
		pyObject.Style = pinyin.FinalsTone
	case 7:
		pyObject.Style = pinyin.FinalsTone2
	case 8:
		pyObject.Style = pinyin.Tone3
	case 9:
		pyObject.Style = pinyin.FinalsTone3
	default:
		pyObject.Style = pinyin.Normal
	}
	pyObject.Separator = requestData.Connector
	str := pinyin.Slug(requestData.Title, pyObject)
	publicmethod.Result(0, str, c)
}

/*
*
@ 作者: 秦东
@ 时间: 2023-11-02 10:35:14
@ 功能: 生成一键登录地址
@ 参数

	#

@ 返回值

	#

@ 方法原型

	#
*/
func (a *ApiMethod) CreateOneClickLogin(c *gin.Context) {
	userKey := c.Request.Header.Get("user-key")
	userToken := c.Request.Header.Get("user-token")
	if userKey == "" || userToken == "" {
		publicmethod.Result(1, userKey, c, "验证失败！未知识别符！")
		return
	}
	sendMap := publicmethod.MapOut[string]()
	var requestData SendUrl
	err := c.ShouldBindJSON(&requestData)
	if err != nil || requestData.UrlStr == "" {
		publicmethod.Result(100, err, c)
		return
	}
	timeVal := time.Now().UnixNano() / 1e6
	urlStr := fmt.Sprintf("/insensibleLogin?userkey=%v&usertoken=%v&time=%v", userKey, userToken, timeVal)
	if !strings.HasPrefix(requestData.UrlStr, "https://") && !strings.HasPrefix(requestData.UrlStr, "http://") {
		urlStr = fmt.Sprintf("http://%v%v", requestData.UrlStr, urlStr)
	} else {
		urlStr = fmt.Sprintf("%v%v", requestData.UrlStr, urlStr)
	}
	singStr := fmt.Sprintf("%v%v%v", userKey, userToken, timeVal)
	var singCodeMd5 publicmethod.Md5Encryption
	singCodeMd5.Md5EncryptionInit(singStr)
	signCodeRedisKey := singCodeMd5.Md5EncryptionAlgorithm()
	urlStr = fmt.Sprintf("%v&sing=%v", urlStr, signCodeRedisKey)

	sendMap["http"] = strings.HasPrefix(requestData.UrlStr, "http://")
	sendMap["https"] = strings.HasPrefix(requestData.UrlStr, "https://")
	sendMap["userKey"] = userKey
	sendMap["userToken"] = userToken
	sendMap["urlStr"] = urlStr

	publicmethod.Result(0, urlStr, c)
}

/*
*
@ 作者: 秦东
@ 时间: 2023-12-05 15:34:23
@ 功能: 获取带规则编号
@ 参数

	#

@ 返回值

	#

@ 方法原型

	#
*/
func (a *ApiMethod) GainNumber(c *gin.Context) {
	var requestData GainRulsNumner
	c.ShouldBindJSON(&requestData)
	uuid := strconv.FormatInt(publicmethod.GetUUid(1), 10)
	// fmt.Printf("uuidAry---->%v\n", uuid)
	if requestData.Automatic {
		uuid = requestData.GainUniqueNumber(uuid)
	}

	publicmethod.Result(0, uuid, c)
}

/*
*
@ 作者: 秦东
@ 时间: 2023-12-06 10:39:13
@ 功能: 获取唯一编号
@ 参数

	#

@ 返回值

	#

@ 方法原型

	#
*/
func (g *GainRulsNumner) GainUniqueNumber(uuid string) string {
	var uuidAry []string
	if len(g.CustomRules) > 0 {
		for _, v := range g.CustomRules {
			switch v.Types {
			case "text":
				uuidAry = append(uuidAry, v.Rule)
			case "randomnumber":
				maxNum, maxerr := strconv.Atoi(v.Rule)
				// fmt.Printf("maxNum---->%v---->%v\n", maxNum, maxerr)
				if maxerr != nil {
					randNum := publicmethod.GetRandNumber(6)
					uuidAry = append(uuidAry, strconv.FormatInt(randNum, 10))
				} else {
					randNum := publicmethod.GetRandNumber(maxNum)
					uuidAry = append(uuidAry, strconv.FormatInt(randNum, 10))
				}
			case "time":
				uuidAry = append(uuidAry, JudgeYearType(v.Rule))
			case "serialnumber":
				redisClient := grocerystore.RunRedis(overall.CONSTANT_Cluster)
				if g.TableKey == "" {
					redisKey := fmt.Sprintf("GetEncoding:AppPlatform:Key_Currency_%v", overall.CONSTANT_CONFIG.RedisPrefixStr.Alias)
					numAry, numErr := redisClient.Lrange(redisKey, 0, -1)
					if numErr != nil {
						redisClient.Rpush(redisKey, v.Rule)
						uuidAry = append(uuidAry, v.Rule)
					} else {
						if len(numAry) < 1 {
							redisClient.Rpush(redisKey, v.Rule)
							uuidAry = append(uuidAry, v.Rule)
						} else {
							var numFlow JudgeInStringAry
							numFlow.Str = v.Rule
							numFlow.StrAry = numAry
							jieguo := numFlow.GainNotInStr()
							redisClient.Rpush(redisKey, jieguo)
							uuidAry = append(uuidAry, jieguo)
						}
					}

				} else {
					redisKey := fmt.Sprintf("GetEncoding:AppPlatform:Key_Currency_%v_%v", g.TableKey, overall.CONSTANT_CONFIG.RedisPrefixStr.Alias)
					numAry, _ := redisClient.Lrange(redisKey, 0, -1)
					var count int64
					err := overall.CONSTANT_DB_CustomerForm.Table(g.TableKey).Count(&count).Error
					if err != nil {
						var numFlow JudgeInStringAry
						numFlow.Str = v.Rule
						numFlow.StrAry = numAry
						jieguo := numFlow.GainNotInStr()
						redisClient.Rpush(redisKey, jieguo)
						uuidAry = append(uuidAry, jieguo)
					} else {
						count = count + 1
						var numFlow JudgeInStringAry
						numFlow.Str = strconv.FormatInt(count, 10)
						numFlow.StrAry = numAry
						jieguo := numFlow.GainNotInStr()
						redisClient.Rpush(redisKey, jieguo)
						uuidAry = append(uuidAry, jieguo)
					}
				}
			default:
			}
		}
		// fmt.Printf("uuidAry-->%v\n", uuidAry)
		if len(uuidAry) > 0 {
			uuid = strings.Join(uuidAry, "-")
			redisClient := grocerystore.RunRedis(overall.CONSTANT_Cluster)
			redisKey := fmt.Sprintf("GetEncoding:AppPlatform:NumKey_Currency_%v", overall.CONSTANT_CONFIG.RedisPrefixStr.Alias)
			if g.TableKey != "" {
				redisKey = fmt.Sprintf("GetEncoding:AppPlatform:NumKey_Currency_%v_%v", g.TableKey, overall.CONSTANT_CONFIG.RedisPrefixStr.Alias)
			}
			numAry, _ := redisClient.Lrange(redisKey, 0, -1)
			if len(numAry) > 0 {
				if !publicmethod.IsInTrue[string](uuid, numAry) {
					redisClient.Rpush(redisKey, uuid)
					return uuid
				}
			} else {
				redisClient.Rpush(redisKey, uuid)
				return uuid
			}
		}
		g.GainUniqueNumber(uuid)
	}
	return uuid
}

/*
*
@ 作者: 秦东
@ 时间: 2023-12-06 10:28:01
@ 功能: 获取一个不存在的字符串
@ 参数

	#

@ 返回值

	#

@ 方法原型

	#
*/
func (j *JudgeInStringAry) GainNotInStr() string {
	zhi, _ := strconv.ParseInt(j.Str, 10, 64)
	if !publicmethod.IsInTrue[string](j.Str, j.StrAry) {
		return j.Str
	}
	zhi++
	j.Str = strconv.FormatInt(zhi, 10)
	return j.GainNotInStr()
}

/*
*
@ 作者: 秦东
@ 时间: 2023-12-05 16:27:20
@ 功能: 判定随机字符串年格式
@ 参数

	#

@ 返回值

	#

@ 方法原型

	#
*/
func JudgeYearType(yearClass string) (timeStr string) {
	yearClassBig := strings.ToUpper(yearClass)
	curraytime := time.Now().Unix()
	switch yearClassBig {
	case "YYYYMMDD":
		timeStr = publicmethod.UnixTimeToDay(curraytime, 20)
	case "YYYYMMD":
		timeStr = publicmethod.UnixTimeToDay(curraytime, 28)
	case "YYYYMD":
		timeStr = publicmethod.UnixTimeToDay(curraytime, 29)
	case "YYMD":
		timeStr = publicmethod.UnixTimeToDay(curraytime, 30)
	case "YYYYMM":
		timeStr = publicmethod.UnixTimeToDay(curraytime, 21)
	case "YYYYM":
		timeStr = publicmethod.UnixTimeToDay(curraytime, 31)
	case "YYYY":
		timeStr = publicmethod.UnixTimeToDay(curraytime, 16)
	case "YY":
		timeStr = publicmethod.UnixTimeToDay(curraytime, 32)
	case "YMD":
		timeStr = publicmethod.UnixTimeToDay(curraytime, 33)
	case "YM":
		timeStr = publicmethod.UnixTimeToDay(curraytime, 34)
	case "Y":
		timeStr = publicmethod.UnixTimeToDay(curraytime, 16)
	case "MMDD":
		timeStr = publicmethod.UnixTimeToDay(curraytime, 35)
	case "MMD":
		timeStr = publicmethod.UnixTimeToDay(curraytime, 36)
	case "MD":
		timeStr = publicmethod.UnixTimeToDay(curraytime, 37)
	case "M":
		timeStr = publicmethod.UnixTimeToDay(curraytime, 38)
	case "MM":
		timeStr = publicmethod.UnixTimeToDay(curraytime, 17)
	case "DD":
		timeStr = publicmethod.UnixTimeToDay(curraytime, 18)
	case "D":
		timeStr = publicmethod.UnixTimeToDay(curraytime, 39)
	default:
		timeStr = publicmethod.UnixTimeToDay(curraytime, 20)
	}
	return
}

/*
*
@ 作者: 秦东
@ 时间: 2023-12-13 07:57:27
@ 功能: 一键登录授权
@ 参数

	#

@ 返回值

	#

@ 方法原型

	#
*/
func (a *ApiMethod) ObtainToken(c *gin.Context) {
	ContentType := c.Request.Header.Get("Content-Type")
	Origin := c.Request.Header.Get("Origin")
	userAgent := c.Request.Header.Get("User-Agent")
	var requestData gainAuthorize
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		publicmethod.Result(100, err, c)
		return
	}
	if requestData.UserNumber == "" || requestData.Password == "" {
		publicmethod.Result(101, err, c)
		return
	}

	// if ContentType == "" || userAgent == "" || Origin == "" {
	// 	publicmethod.Result(100, err, c)
	// 	return
	// }
	var pwdMd5Cont publicmethod.Md5Encryption
	pwdMd5Cont.Md5EncryptionInit(requestData.Password)
	pwdStr := pwdMd5Cont.Md5EncryptionAlgorithm()
	//验证账号
	var empCont modelshr.EmpowerUser
	err = empCont.GetCont(map[string]interface{}{"userkey": requestData.UserNumber, "password": pwdStr}, "verification_code")
	if err != nil {
		publicmethod.Result(2000, err, c)
		return
	}
	ContentType = requestData.UserNumber
	Origin = pwdStr
	userAgent = empCont.VerificationCode

	//获取雪花随机数
	uuid := publicmethod.GetUUid(6)
	uuidStr := strconv.FormatInt(uuid, 10)
	var uuidMd5 publicmethod.Md5Encryption
	uuidMd5.Md5EncryptionInit(uuidStr)
	if empCont.VerificationCode != "" {
		uuidMd5.AppKey = empCont.VerificationCode
	}
	uuidMd5Str := uuidMd5.Md5EncryptionAlgorithm()
	//头文件加密
	//Content-Type
	var ContentTypeMd5 publicmethod.Md5Encryption
	ContentTypeMd5.Md5EncryptionInit(ContentType)
	if empCont.VerificationCode != "" {
		ContentTypeMd5.AppKey = empCont.VerificationCode
	}
	ContentTypeMd5Str := ContentTypeMd5.Md5EncryptionAlgorithm()
	//Origin
	var OriginMd5 publicmethod.Md5Encryption
	OriginMd5.Md5EncryptionInit(Origin)
	if empCont.VerificationCode != "" {
		OriginMd5.AppKey = empCont.VerificationCode
	}
	OriginMd5Str := OriginMd5.Md5EncryptionAlgorithm()
	//User-Agent
	var userAgentMd5 publicmethod.Md5Encryption
	userAgentMd5.Md5EncryptionInit(userAgent)
	if empCont.VerificationCode != "" {
		userAgentMd5.AppKey = empCont.VerificationCode
	}
	userAgentMd5Str := userAgentMd5.Md5EncryptionAlgorithm()

	tokenRedisKey := fmt.Sprintf("%v-%v-%v-%v-%v-%v", ContentTypeMd5Str, OriginMd5Str, userAgentMd5Str, uuidMd5Str, requestData.UserNumber, pwdStr)

	var tokenMd5 publicmethod.Md5Encryption
	tokenMd5.Md5EncryptionInit(tokenRedisKey)
	if empCont.VerificationCode != "" {
		tokenMd5.AppKey = empCont.VerificationCode
	}
	tokenMd5Str := tokenMd5.Md5EncryptionAlgorithm()

	//redis键
	redisKey := fmt.Sprintf("Authentication:PasswordFreeLogin:key_%v", tokenMd5Str)
	//哈希值
	redisCont := publicmethod.MapOut[string]()
	redisCont["number"] = uuidStr
	redisCont["userkey"] = requestData.UserNumber
	redisCont["password"] = pwdStr
	//将信息写入哈希
	// redisClient := grocerystore.RunRedisClan(overall.CONSTANT_ClusterClient)
	// redisClient.SetRedisTime(10800)
	// isTrue := redisClient.HashMsetAddClan(redisKey, redisCont)
	// grocerystore.RunRedis(overall.CONSTANT_Cluster)
	redisClient := grocerystore.RunRedis(overall.CONSTANT_Cluster)
	redisClient.SetRedisTime(10800)
	isTrue := redisClient.HashMsetAdd(redisKey, redisCont)
	if !isTrue {
		publicmethod.Result(1, overall.CONSTANT_Cluster, c, "授权失败！")
		return
	}

	//输出内容
	sendCont := publicmethod.MapOut[string]()
	sendCont["number"] = uuidStr
	sendCont["token"] = tokenMd5Str
	sendCont["isTrue"] = isTrue
	sendCont["tokenRedisKey"] = tokenRedisKey
	fmt.Printf("contentType:%v\n", ContentType)
	publicmethod.Result(0, sendCont, c)
}

/*
*
@ 作者: 秦东
@ 时间: 2023-12-13 09:00:45
@ 功能: 验证一键登录者身份
@ 参数

	#

@ 返回值

	#

@ 方法原型

	#
*/
func (a *ApiMethod) VerifyIdentity(c *gin.Context) {
	ContentType := c.Request.Header.Get("Content-Type")
	origin := c.Request.Header.Get("Origin")
	userAgent := c.Request.Header.Get("User-Agent")
	token := c.Query("token")
	number := c.Query("number")
	codeStr := c.Query("code")
	timeStr := c.Query("time")
	openId := c.Query("openid")
	if token == "" || number == "" || timeStr == "" || codeStr == "" {
		publicmethod.Result(100, ContentType, c)
		return
	}
	// currTime := time.Now().Unix()
	// queryTimeInt, _ := strconv.ParseInt(timeStr, 10, 64)
	// if (currTime - queryTimeInt) > 30 {
	// 	publicmethod.Result(1, timeStr, c, "授权超时")
	// 	return
	// }
	//redis键
	redisKey := fmt.Sprintf("Authentication:PasswordFreeLogin:key_%v", token)
	// redisClient := grocerystore.RunRedisClan(overall.CONSTANT_ClusterClient)
	// tokenInfo, isTrue := redisClient.HashGetAllClan(redisKey)

	redisClient := grocerystore.RunRedis(overall.CONSTANT_Cluster)
	tokenInfo, isTrue := redisClient.HashGetAll(redisKey)
	if isTrue != true {
		publicmethod.Result(1, redisKey, c, "token错误")
		return
	}
	var validator ValidatorType
	err := mapstructure.Decode(tokenInfo, &validator)
	if err != nil {
		publicmethod.Result(1, err, c, "对不起！身份验证失败！")
		return
	}
	//验证账号
	var empCont modelshr.EmpowerUser
	err = empCont.GetCont(map[string]interface{}{"userkey": validator.UserKey, "password": validator.PassWord}, "verification_code")
	if err != nil {
		publicmethod.Result(1, err, c, "对不起！身份验证失败！")
		return
	}
	ContentType = validator.UserKey
	origin = validator.PassWord
	userAgent = empCont.VerificationCode
	//头文件加密
	//Content-Type
	var contentTypeMd5 publicmethod.Md5Encryption
	contentTypeMd5.Md5EncryptionInit(ContentType)
	if empCont.VerificationCode != "" {
		contentTypeMd5.AppKey = empCont.VerificationCode
	}
	contentTypeMd5Str := contentTypeMd5.Md5EncryptionAlgorithm()

	fmt.Printf("contentType:%v\n", ContentType)
	//Origin
	var originMd5 publicmethod.Md5Encryption
	originMd5.Md5EncryptionInit(origin)
	if empCont.VerificationCode != "" {
		originMd5.AppKey = empCont.VerificationCode
	}
	originMd5Str := originMd5.Md5EncryptionAlgorithm()
	//User-Agent
	var userAgentMd5 publicmethod.Md5Encryption
	userAgentMd5.Md5EncryptionInit(userAgent)
	if empCont.VerificationCode != "" {
		userAgentMd5.AppKey = empCont.VerificationCode
	}
	userAgentMd5Str := userAgentMd5.Md5EncryptionAlgorithm()

	var uuidMd5 publicmethod.Md5Encryption
	uuidMd5.Md5EncryptionInit(validator.Number)
	if empCont.VerificationCode != "" {
		uuidMd5.AppKey = empCont.VerificationCode
	}
	uuidMd5Str := uuidMd5.Md5EncryptionAlgorithm()

	tokenRedisKey := fmt.Sprintf("%v-%v-%v-%v-%v-%v", contentTypeMd5Str, originMd5Str, userAgentMd5Str, uuidMd5Str, validator.UserKey, validator.PassWord)
	var tokenMd5 publicmethod.Md5Encryption
	tokenMd5.Md5EncryptionInit(tokenRedisKey)
	if empCont.VerificationCode != "" {
		tokenMd5.AppKey = empCont.VerificationCode
	}
	tokenMd5Str := tokenMd5.Md5EncryptionAlgorithm()
	//系统验证系数
	systemKey := fmt.Sprintf("%v-%v", tokenMd5Str, uuidMd5Str)
	var systemKeyMd5 publicmethod.Md5Encryption
	systemKeyMd5.Md5EncryptionInit(systemKey)
	if empCont.VerificationCode != "" {
		systemKeyMd5.AppKey = empCont.VerificationCode
	}
	systemKeyMd5Str := systemKeyMd5.Md5EncryptionAlgorithm()
	//接收系数
	receiveKey := fmt.Sprintf("%v-%v", token, number)
	var receiveKeyMd5 publicmethod.Md5Encryption
	receiveKeyMd5.Md5EncryptionInit(receiveKey)
	if empCont.VerificationCode != "" {
		receiveKeyMd5.AppKey = empCont.VerificationCode
	}
	receiveKeyMd5Str := receiveKeyMd5.Md5EncryptionAlgorithm()

	sendData := publicmethod.MapOut[string]()
	sendData["systemKeyMd5Str"] = systemKeyMd5Str
	sendData["receiveKeyMd5Str"] = receiveKeyMd5Str
	sendData["uuidMd5Str"] = uuidMd5Str
	sendData["number"] = number
	sendData["tokenMd5Str"] = tokenMd5Str
	sendData["token"] = token
	sendData["tokenRedisKey"] = tokenRedisKey

	if systemKeyMd5Str != receiveKeyMd5Str {
		publicmethod.Result(1, sendData, c, "对不起！身份验证失败！")
		return
	}
	var userCont modelshr.ManCont
	err = overall.CONSTANT_DB_HR.Where("`number` = ?  AND `emp_type` BETWEEN ? AND ?", codeStr, 1, 10).Find(&userCont).Error
	if err != nil {
		publicmethod.Result(1, sendData, c, "此账号禁止访问！")
		return
	}
	var md5JiaMi publicmethod.Md5Encryption
	md5JiaMi.Md5EncryptionInit(userAgent)
	md5Token := md5JiaMi.Md5EncryptionAlgorithm()

	var md5JiaMiNumber publicmethod.Md5Encryption
	md5JiaMiNumber.Md5EncryptionInit(userCont.Number)
	userKeyCode := md5JiaMiNumber.Md5EncryptionAlgorithm()
	sha1Str := userKeyCode + userCont.Number + userCont.Password + md5Token
	sha1Token := publicmethod.Sha1Encryption(sha1Str)

	//返回值
	saveData := publicmethod.MapOut[string]()
	saveData["key"] = userKeyCode
	saveData["token"] = sha1Token
	saveData["userinfo"] = userCont

	menuoper, jurisdiction := getRoleSeat(userCont.Role)
	writeRedisData := map[string]interface{}{
		"userkey":      userKeyCode,
		"key":          userCont.Key,
		"usernumber":   userCont.Number,
		"userpwd":      userCont.Password,
		"usertoken":    sha1Token,
		"jurisdiction": jurisdiction,
		"menuOper":     menuoper,
		"wand":         118,
	}
	//API Token数据
	redisFileKey := fmt.Sprintf("ScanCode:Authentication:LoginApi_%v_%v", overall.CONSTANT_CONFIG.RedisPrefixStr.Alias, userKeyCode)
	redisClients := grocerystore.RunRedis(overall.CONSTANT_REDIS5)
	redisClients.SetRedisTime(10800)
	redisClients.HashMsetAdd(redisFileKey, writeRedisData)

	_, companyId, _, sunDepartId, _ := publicmethod.GetOrgStructurees(userCont.AdminOrg)
	var sunmaindeparment int64
	if companyId != sunDepartId {
		sunmaindeparment = sunDepartId
	}

	//缓存写入个人信息
	redisMyContKey := fmt.Sprintf("ScanCode:Authentication:UserCont_%v_%v", overall.CONSTANT_CONFIG.RedisPrefixStr.Alias, userCont.Number)
	myCont := publicmethod.MapOut[string]()
	myCont["id"] = userCont.Id
	myCont["number"] = userCont.Number       //员工工号
	myCont["name"] = userCont.Name           //姓名
	myCont["icon"] = userCont.Icon           //头像
	myCont["hireclass"] = userCont.HireClass //雇佣类型（1：雇佣入职；2：再入职；）
	myCont["emptype"] = userCont.EmpType     //用工关系（1:临时工 , 2:编外人员 ;3:实习&实习生;4：试用员工；5：待分配；6：待岗；7：临时调入；8：正式员工；9：长期病假；10：停薪留职；11：退休；12：辞职；13：辞退；14：离职）
	myCont["company"] = userCont.Company     //入职公司
	// myCont["maindeparment"] = userCont.MainDeparment         //主部门
	// myCont["sunmaindeparment"] = userCont.SunMainDeparment   //二级主部门
	myCont["maindeparment"] = companyId           //主部门
	myCont["sunmaindeparment"] = sunmaindeparment //二级主部门

	myCont["deparment"] = userCont.Deparment                 //部门
	myCont["adminorg"] = userCont.AdminOrg                   //所属行政组织
	myCont["teamid"] = userCont.TeamId                       //班组
	myCont["position"] = userCont.Position                   //职位
	myCont["jobclass"] = userCont.JobClass                   //职务分类
	myCont["jobid"] = userCont.JobId                         //职务
	myCont["jobleve"] = userCont.JobLeve                     //职务等级
	myCont["wechat"] = userCont.Wechat                       //微信UserId
	myCont["workwechat"] = userCont.WorkWechat               //企业微信UserId
	myCont["state"] = userCont.State                         //状态（1：启用；2：禁用；3：删除）
	myCont["key"] = userCont.Key                             //key
	myCont["isadmin"] = userCont.IsAdmin                     //是否为管理员（1：不是；2：分公司；3：集团管理员；4：超级管
	myCont["password"] = userCont.Password                   //密码
	myCont["role"] = userCont.Role                           //角色
	myCont["idcardno"] = userCont.Idcardno                   //身份证号
	myCont["passportno"] = userCont.Passportno               //护照号码
	myCont["globalroaming"] = userCont.Globalroaming         //国际区号
	myCont["mobilephone"] = userCont.Mobilephone             //手机号码
	myCont["email"] = userCont.Email                         //电子邮件
	myCont["gender"] = userCont.Gender                       //性别（1：男性；2：女性；3：中性）
	myCont["birthday"] = userCont.Birthday                   //birthday
	myCont["myfolk"] = userCont.Myfolk                       //民族
	myCont["nativeplace"] = userCont.Nativeplace             //籍贯
	myCont["idcardstartdate"] = userCont.Idcardstartdate     //身份证有效期开始
	myCont["idcardenddate"] = userCont.Idcardenddate         //身份证有效期结束
	myCont["idcardaddress"] = userCont.Idcardaddress         //身份证地址
	myCont["idcardIssued"] = userCont.IdcardIssued           //身份证签发机关
	myCont["health"] = userCont.Health                       //健康状况（1：良好；2：一般；3：较弱，4：有生理缺陷；5：残废）
	myCont["maritalstatus"] = userCont.Maritalstatus         //婚姻状况（1：未婚；2：已婚；3：丧偶；4：离异）
	myCont["internaltelephone"] = userCont.Internaltelephone //内线电话
	myCont["currentresidence"] = userCont.Currentresidence   //现居住地址
	myCont["constellationing"] = userCont.Constellation      //星座（1：白羊座；2：金牛座；3：双子座；4：巨蟹座；5：狮子座；6：处女座；7：天枰座；8：天蝎座；9：射手座；10：摩羯座；11：水瓶座；12：双鱼座）
	myCont["isdoubleworker"] = userCont.Isdoubleworker       //是否双职工（1：是；2：否）
	myCont["isveterans"] = userCont.Isveterans               //是否为退役军人（1：是；2：否）
	myCont["veteransnumber"] = userCont.Veteransnumber       //退役证编号
	myCont["jobstartdate"] = userCont.Jobstartdate           //参加工作日期
	myCont["entrydate"] = userCont.Entrydate                 //入职日期
	myCont["probationperiod"] = userCont.Probationperiod     //试用期
	myCont["planformaldate"] = userCont.Planformaldate       //预计转正日期
	myCont["political_outlook"] = userCont.PoliticalOutlook  //政治面貌(1：群众；2：无党派；3：台盟会员；4：九三社员；5：致公党员；6：农工党员；7：民进会员；8：民建会员；9：民盟盟员；10：民革会员，11：共青团员；12：预备党员；13：中共党员)
	var companyCont modelshr.AdministrativeOrganization
	companyCont.GetCont(map[string]interface{}{"`id`": userCont.Company}, "`name`")
	myCont["companyname"] = companyCont.Name
	var departmentCont modelshr.AdministrativeOrganization
	departmentCont.GetCont(map[string]interface{}{"`id`": userCont.MainDeparment}, "`name`")
	myCont["maindeparmentname"] = departmentCont.Name
	var postInfo modelshr.Position
	postInfo.GetCont(map[string]interface{}{"`id`": userCont.Position}, "`name`")
	myCont["positionname"] = postInfo.Name
	redisClients.HashMsetAdd(redisMyContKey, myCont)
	redisClient.HashMsetAdd(redisMyContKey, myCont)
	saveData["usercont"] = myCont

	if openId != "" {
		var userInfo modelshr.PersonArchives
		userInfo.EiteCont(map[string]interface{}{"id": userCont.Id}, map[string]interface{}{"work_wechat": openId})
	}

	var sendKpiCont WriteIderCont
	sendKpiCont.Openid = openId
	sendKpiCont.Key = userKeyCode
	sendKpiCont.Token = sha1Token
	sendKpiCont.UserInfo.Key = strconv.FormatInt(userCont.Key, 10)
	sendKpiCont.UserInfo.Number = userCont.Number
	sendKpiCont.UserInfo.Password = userCont.Password
	sendDate, _ := json.Marshal(sendKpiCont)
	publicmethod.CurlPostJosn("http://120.224.6.6:39168/shiyan/write_token", sendDate)
	c.Redirect(http.StatusMovedPermanently, "/")
	publicmethod.Result(0, saveData, c)
}

// 获取权限点位
func getRoleSeat(roleId string) (menuStr, buttonStr string) {
	var roleInfo modelsschool.SystemRole
	err := roleInfo.GetCont(map[string]interface{}{"r_id": roleId}, "r_menu_oper", "r_jurisdiction")
	if err != nil {
		return
	}
	menuStr = roleInfo.MenuOper
	buttonStr = roleInfo.Jurisdiction
	return
}

/*
*
@ 作者: 秦东
@ 时间: 2023-12-13 16:09:59
@ 功能: 验证无感登录
@ 参数

	#

@ 返回值

	#

@ 方法原型

	#
*/
func (a *ApiMethod) SilentLogin(c *gin.Context) {
	ContentType := c.Request.Header.Get("Content-Type")
	origin := c.Request.Header.Get("Origin")
	userAgent := c.Request.Header.Get("User-Agent")
	var requestData SilentLoginInfo
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		publicmethod.Result(100, err, c)
		return
	}
	if requestData.Token == "" || requestData.Number == "" || requestData.Time == "" || requestData.Code == "" {
		publicmethod.Result(10001, ContentType, c, "token错误")
		return
	}
	// currTime := time.Now().Unix()
	// queryTimeInt, _ := strconv.ParseInt(requestData.Time, 10, 64)
	// if (currTime-queryTimeInt) > 30 || (currTime-queryTimeInt) < 0 {
	// 	publicmethod.Result(1, currTime-queryTimeInt, c, "授权超时")
	// 	return
	// }
	//redis键
	redisKey := fmt.Sprintf("Authentication:PasswordFreeLogin:key_%v", requestData.Token)
	// redisClient := grocerystore.RunRedisClan(overall.CONSTANT_ClusterClient)
	// tokenInfo, isTrue := redisClient.HashGetAllClan(redisKey)
	redisClient := grocerystore.RunRedis(overall.CONSTANT_Cluster)
	tokenInfo, isTrue := redisClient.HashGetAll(redisKey)
	if isTrue != true {
		publicmethod.Result(10001, redisKey, c, "token错误")
		return
	}
	var validator ValidatorType
	err = mapstructure.Decode(tokenInfo, &validator)
	if err != nil {
		publicmethod.Result(10001, err, c, "对不起！身份验证失败！")
		return
	}
	//验证账号
	var empCont modelshr.EmpowerUser
	err = empCont.GetCont(map[string]interface{}{"userkey": validator.UserKey, "password": validator.PassWord}, "verification_code")
	if err != nil {
		publicmethod.Result(10001, err, c, "对不起！身份验证失败！")
		return
	}
	ContentType = validator.UserKey
	origin = validator.PassWord
	userAgent = empCont.VerificationCode
	//头文件加密
	//Content-Type
	var contentTypeMd5 publicmethod.Md5Encryption
	contentTypeMd5.Md5EncryptionInit(ContentType)
	if empCont.VerificationCode != "" {
		contentTypeMd5.AppKey = empCont.VerificationCode
	}
	contentTypeMd5Str := contentTypeMd5.Md5EncryptionAlgorithm()

	fmt.Printf("contentType:%v\n", ContentType)
	//Origin
	var originMd5 publicmethod.Md5Encryption
	originMd5.Md5EncryptionInit(origin)
	if empCont.VerificationCode != "" {
		originMd5.AppKey = empCont.VerificationCode
	}
	originMd5Str := originMd5.Md5EncryptionAlgorithm()
	//User-Agent
	var userAgentMd5 publicmethod.Md5Encryption
	userAgentMd5.Md5EncryptionInit(userAgent)
	if empCont.VerificationCode != "" {
		userAgentMd5.AppKey = empCont.VerificationCode
	}
	userAgentMd5Str := userAgentMd5.Md5EncryptionAlgorithm()

	var uuidMd5 publicmethod.Md5Encryption
	uuidMd5.Md5EncryptionInit(validator.Number)
	if empCont.VerificationCode != "" {
		uuidMd5.AppKey = empCont.VerificationCode
	}
	uuidMd5Str := uuidMd5.Md5EncryptionAlgorithm()

	tokenRedisKey := fmt.Sprintf("%v-%v-%v-%v-%v-%v", contentTypeMd5Str, originMd5Str, userAgentMd5Str, uuidMd5Str, validator.UserKey, validator.PassWord)
	var tokenMd5 publicmethod.Md5Encryption
	tokenMd5.Md5EncryptionInit(tokenRedisKey)
	if empCont.VerificationCode != "" {
		tokenMd5.AppKey = empCont.VerificationCode
	}
	tokenMd5Str := tokenMd5.Md5EncryptionAlgorithm()
	//系统验证系数
	systemKey := fmt.Sprintf("%v-%v", tokenMd5Str, uuidMd5Str)
	var systemKeyMd5 publicmethod.Md5Encryption
	systemKeyMd5.Md5EncryptionInit(systemKey)
	if empCont.VerificationCode != "" {
		systemKeyMd5.AppKey = empCont.VerificationCode
	}
	systemKeyMd5Str := systemKeyMd5.Md5EncryptionAlgorithm()
	//接收系数
	receiveKey := fmt.Sprintf("%v-%v", requestData.Token, requestData.Number)
	var receiveKeyMd5 publicmethod.Md5Encryption
	receiveKeyMd5.Md5EncryptionInit(receiveKey)
	if empCont.VerificationCode != "" {
		receiveKeyMd5.AppKey = empCont.VerificationCode
	}
	receiveKeyMd5Str := receiveKeyMd5.Md5EncryptionAlgorithm()

	sendData := publicmethod.MapOut[string]()
	sendData["systemKeyMd5Str"] = systemKeyMd5Str
	sendData["receiveKeyMd5Str"] = receiveKeyMd5Str
	sendData["uuidMd5Str"] = uuidMd5Str
	sendData["number"] = requestData.Number
	sendData["tokenMd5Str"] = tokenMd5Str
	sendData["token"] = requestData.Token
	sendData["tokenRedisKey"] = tokenRedisKey

	if systemKeyMd5Str != receiveKeyMd5Str {
		publicmethod.Result(10001, sendData, c, "对不起！身份验证失败！")
		return
	}
	var userCont modelshr.ManCont
	err = overall.CONSTANT_DB_HR.Where("`number` = ?  AND `emp_type` BETWEEN ? AND ?", requestData.Code, 1, 10).Find(&userCont).Error
	if err != nil {
		publicmethod.Result(10001, sendData, c, "此账号禁止访问！")
		return
	}
	var md5JiaMi publicmethod.Md5Encryption
	md5JiaMi.Md5EncryptionInit(userAgent)
	md5Token := md5JiaMi.Md5EncryptionAlgorithm()

	var md5JiaMiNumber publicmethod.Md5Encryption
	md5JiaMiNumber.Md5EncryptionInit(userCont.Number)
	userKeyCode := md5JiaMiNumber.Md5EncryptionAlgorithm()
	sha1Str := userKeyCode + userCont.Number + userCont.Password + md5Token
	sha1Token := publicmethod.Sha1Encryption(sha1Str)

	//返回值
	saveData := publicmethod.MapOut[string]()
	saveData["key"] = userKeyCode
	saveData["token"] = sha1Token
	saveData["userinfo"] = userCont

	menuoper, jurisdiction := getRoleSeat(userCont.Role)
	writeRedisData := map[string]interface{}{
		"userkey":      userKeyCode,
		"key":          userCont.Key,
		"usernumber":   userCont.Number,
		"userpwd":      userCont.Password,
		"usertoken":    sha1Token,
		"jurisdiction": jurisdiction,
		"menuOper":     menuoper,
		"wand":         118,
	}
	//API Token数据
	redisFileKey := fmt.Sprintf("ScanCode:Authentication:LoginApi_%v_%v", overall.CONSTANT_CONFIG.RedisPrefixStr.Alias, userKeyCode)
	redisClients := grocerystore.RunRedis(overall.CONSTANT_REDIS5)
	redisClients.SetRedisTime(10800)
	redisClients.HashMsetAdd(redisFileKey, writeRedisData)

	_, companyId, _, sunDepartId, _ := publicmethod.GetOrgStructurees(userCont.AdminOrg)
	var sunmaindeparment int64
	if companyId != sunDepartId {
		sunmaindeparment = sunDepartId
	}

	//缓存写入个人信息
	redisMyContKey := fmt.Sprintf("ScanCode:Authentication:UserCont_%v_%v", overall.CONSTANT_CONFIG.RedisPrefixStr.Alias, userCont.Number)
	myCont := publicmethod.MapOut[string]()
	myCont["id"] = userCont.Id
	myCont["number"] = userCont.Number       //员工工号
	myCont["name"] = userCont.Name           //姓名
	myCont["icon"] = userCont.Icon           //头像
	myCont["hireclass"] = userCont.HireClass //雇佣类型（1：雇佣入职；2：再入职；）
	myCont["emptype"] = userCont.EmpType     //用工关系（1:临时工 , 2:编外人员 ;3:实习&实习生;4：试用员工；5：待分配；6：待岗；7：临时调入；8：正式员工；9：长期病假；10：停薪留职；11：退休；12：辞职；13：辞退；14：离职）
	myCont["company"] = userCont.Company     //入职公司
	// myCont["maindeparment"] = userCont.MainDeparment         //主部门
	// myCont["sunmaindeparment"] = userCont.SunMainDeparment   //二级主部门
	myCont["maindeparment"] = companyId           //主部门
	myCont["sunmaindeparment"] = sunmaindeparment //二级主部门

	myCont["deparment"] = userCont.Deparment                 //部门
	myCont["adminorg"] = userCont.AdminOrg                   //所属行政组织
	myCont["teamid"] = userCont.TeamId                       //班组
	myCont["position"] = userCont.Position                   //职位
	myCont["jobclass"] = userCont.JobClass                   //职务分类
	myCont["jobid"] = userCont.JobId                         //职务
	myCont["jobleve"] = userCont.JobLeve                     //职务等级
	myCont["wechat"] = userCont.Wechat                       //微信UserId
	myCont["workwechat"] = userCont.WorkWechat               //企业微信UserId
	myCont["state"] = userCont.State                         //状态（1：启用；2：禁用；3：删除）
	myCont["key"] = userCont.Key                             //key
	myCont["isadmin"] = userCont.IsAdmin                     //是否为管理员（1：不是；2：分公司；3：集团管理员；4：超级管
	myCont["password"] = userCont.Password                   //密码
	myCont["role"] = userCont.Role                           //角色
	myCont["idcardno"] = userCont.Idcardno                   //身份证号
	myCont["passportno"] = userCont.Passportno               //护照号码
	myCont["globalroaming"] = userCont.Globalroaming         //国际区号
	myCont["mobilephone"] = userCont.Mobilephone             //手机号码
	myCont["email"] = userCont.Email                         //电子邮件
	myCont["gender"] = userCont.Gender                       //性别（1：男性；2：女性；3：中性）
	myCont["birthday"] = userCont.Birthday                   //birthday
	myCont["myfolk"] = userCont.Myfolk                       //民族
	myCont["nativeplace"] = userCont.Nativeplace             //籍贯
	myCont["idcardstartdate"] = userCont.Idcardstartdate     //身份证有效期开始
	myCont["idcardenddate"] = userCont.Idcardenddate         //身份证有效期结束
	myCont["idcardaddress"] = userCont.Idcardaddress         //身份证地址
	myCont["idcardIssued"] = userCont.IdcardIssued           //身份证签发机关
	myCont["health"] = userCont.Health                       //健康状况（1：良好；2：一般；3：较弱，4：有生理缺陷；5：残废）
	myCont["maritalstatus"] = userCont.Maritalstatus         //婚姻状况（1：未婚；2：已婚；3：丧偶；4：离异）
	myCont["internaltelephone"] = userCont.Internaltelephone //内线电话
	myCont["currentresidence"] = userCont.Currentresidence   //现居住地址
	myCont["constellationing"] = userCont.Constellation      //星座（1：白羊座；2：金牛座；3：双子座；4：巨蟹座；5：狮子座；6：处女座；7：天枰座；8：天蝎座；9：射手座；10：摩羯座；11：水瓶座；12：双鱼座）
	myCont["isdoubleworker"] = userCont.Isdoubleworker       //是否双职工（1：是；2：否）
	myCont["isveterans"] = userCont.Isveterans               //是否为退役军人（1：是；2：否）
	myCont["veteransnumber"] = userCont.Veteransnumber       //退役证编号
	myCont["jobstartdate"] = userCont.Jobstartdate           //参加工作日期
	myCont["entrydate"] = userCont.Entrydate                 //入职日期
	myCont["probationperiod"] = userCont.Probationperiod     //试用期
	myCont["planformaldate"] = userCont.Planformaldate       //预计转正日期
	myCont["political_outlook"] = userCont.PoliticalOutlook  //政治面貌(1：群众；2：无党派；3：台盟会员；4：九三社员；5：致公党员；6：农工党员；7：民进会员；8：民建会员；9：民盟盟员；10：民革会员，11：共青团员；12：预备党员；13：中共党员)
	var companyCont modelshr.AdministrativeOrganization
	companyCont.GetCont(map[string]interface{}{"`id`": userCont.Company}, "`name`")
	myCont["companyname"] = companyCont.Name
	var departmentCont modelshr.AdministrativeOrganization
	departmentCont.GetCont(map[string]interface{}{"`id`": userCont.MainDeparment}, "`name`")
	myCont["maindeparmentname"] = departmentCont.Name
	var postInfo modelshr.Position
	postInfo.GetCont(map[string]interface{}{"`id`": userCont.Position}, "`name`")
	myCont["positionname"] = postInfo.Name
	redisClients.HashMsetAdd(redisMyContKey, myCont)
	redisClient.HashMsetAdd(redisMyContKey, myCont)
	saveData["usercont"] = myCont

	if requestData.Openid != "" {
		var userInfo modelshr.PersonArchives
		userInfo.EiteCont(map[string]interface{}{"id": userCont.Id}, map[string]interface{}{"work_wechat": requestData.Openid})
	}

	var sendKpiCont WriteIderCont
	sendKpiCont.Openid = requestData.Openid
	sendKpiCont.Key = userKeyCode
	sendKpiCont.Token = sha1Token
	sendKpiCont.UserInfo.Key = strconv.FormatInt(userCont.Key, 10)
	sendKpiCont.UserInfo.Number = userCont.Number
	sendKpiCont.UserInfo.Password = userCont.Password
	sendDate, _ := json.Marshal(sendKpiCont)
	publicmethod.CurlPostJosn("http://120.224.6.6:39168/shiyan/write_token", sendDate)
	publicmethod.Result(0, saveData, c)
}