hr_server/overall/overallhandle/overall_handle.go

package overallhandle

import (
	"bytes"
	"crypto/md5"
	"crypto/rand"
	"crypto/sha1"
	"encoding/hex"
	"errors"
	"fmt"
	"hr_server/grocerystore"
	"hr_server/middleware/snowflake"
	"hr_server/models"
	"hr_server/overall"
	"io/ioutil"
	"math"
	"math/big"
	"net/http"
	"reflect"
	"strconv"
	"strings"
	"time"

	"github.com/mozillazg/go-pinyin"
)

// 全局函数处理
var (
	timeLayoutMap = map[string]string{
		"y": "2006",
		"m": "2006-01",
		"d": "2006-01-02",
		"h": "2006-01-02 15",
		"i": "2006-01-02 15:04",
		"s": "2006-01-02 15:04:05",
	}

	weekDay = map[string]int{
		"Monday":    1,
		"Tuesday":   2,
		"Wednesday": 3,
		"Thursday":  4,
		"Friday":    5,
		"Saturday":  6,
		"Sunday":    7,
	}
)

// 编号，纯数字
func TableNumber(class ...string) (number int64) {
	result, _ := rand.Int(rand.Reader, big.NewInt(8999))
	numberTeam := result.Int64() + 1000
	numberStr := fmt.Sprintf("%v%v", time.Now().Unix(), numberTeam)
	if len(class) > 0 {
		resultLong, _ := rand.Int(rand.Reader, big.NewInt(8999999))
		numberTeamLong := resultLong.Int64() + 1000000
		numberStr = fmt.Sprintf("%v%v", time.Now().Unix(), numberTeamLong)
	}
	number, _ = strconv.ParseInt(numberStr, 10, 64)
	return
}

// 获取唯一编号
func OnlyOneNumber(id int64) (manKeyNum int64) {
	node, nodeErr := snowflake.NewWorker(id)
	if nodeErr == nil {
		manKeyNum = node.GetId()
	} else {
		idStr := strconv.FormatInt(id, 10)
		manKeyNum = TableNumber(idStr)
	}
	return
}

// 初始化map
func MapOut() (data map[string]interface{}) {
	data = make(map[string]interface{}) //必可不少，分配内存
	return data
}

func MapOutint() (data map[int]interface{}) {
	data = make(map[int]interface{}) //必可不少，分配内存
	return data
}
func MapOutint64() (data map[int64]interface{}) {
	data = make(map[int64]interface{}) //必可不少，分配内存
	return data
}
func MapOutFloat64() (data map[float64]interface{}) {
	data = make(map[float64]interface{}) //必可不少，分配内存
	return data
}
func MapOutString() (data map[string]string) {
	data = make(map[string]string) //必可不少，分配内存
	return data
}

//时间搓转换成日期
/*
@timestamp  待转换的时间戳
@timeType	转换类型
*/
func UnixTimeToDay(timeStamp int64, timeType int) (dateStr string) {
	timeTemplate := "2006-01-02 15:04:05" //常规类型
	switch timeType {
	case 1:
		timeTemplate = "2006/01/02 15:04:05"
	case 2:
		timeTemplate = "2006/01/02 15:04"
	case 3:
		timeTemplate = "2006/01/02 15"
	case 4:
		timeTemplate = "2006/01/02"
	case 5:
		timeTemplate = "15:04:05"
	case 6:
		timeTemplate = "15:04"
	case 7:
		timeTemplate = "15"
	case 8:
		timeTemplate = "04:05"
	case 9:
		timeTemplate = "04"
	case 10:
		timeTemplate = "05"
	case 11:
		timeTemplate = "2006-01-02 15:04:05"
	case 12:
		timeTemplate = "2006-01-02 15:04"
	case 13:
		timeTemplate = "2006-01-02 15"
	case 14:
		timeTemplate = "2006-01-02"
	case 15:
		timeTemplate = "2006-01" //年月
	case 16:
		timeTemplate = "2006" //年
	case 17:
		timeTemplate = "01" //月
	case 18:
		timeTemplate = "02" //日
	case 19: //季度
		dayMonth := time.Unix(timeStamp, 0).Format("01")
		datMonthFloat, datMonthFloatErr := strconv.ParseFloat(dayMonth, 10)
		if datMonthFloatErr == nil {
			dateStr = strconv.FormatFloat(math.Ceil(datMonthFloat/3), 'f', -1, 64)
		}
		dateStr = "1"
	case 20:
		timeTemplate = "20060102"
	case 21:
		timeTemplate = "200601"
	default:
		timeTemplate = "2006-01-02 15:04:05" //常规类型
	}
	dateStr = time.Unix(timeStamp, 0).Format(timeTemplate)
	return
}

// 获取整型年月日
func GetIntTime(timeStamp int64, timeType int) (timeInt int) {
	dayMonth := time.Unix(timeStamp, 0)
	switch timeType {
	case 1:
		timeInt = dayMonth.Year()
	case 2:
		fmt.Printf("%v\n", dayMonth.Format("01"))
		timeInt, _ = strconv.Atoi(dayMonth.Format("01"))
	default:
		timeInt = dayMonth.Day()
	}
	return
}

/*
日期转时间戳
*/
func DateToTimeStamp(dataStr string) (timeStamp int64, isTrue bool) {
	isTrue = false
	tmp := "2006-01-02 15:04:05"
	res, err := time.ParseInLocation(tmp, dataStr, time.Local)
	timeStamp = res.Unix()
	if err == nil {
		isTrue = true
	}
	return
}
func DateToTimeStampDay(dataStr string) (timeStamp int64, isTrue bool, err error) {
	// fmt.Printf("记不清威威--->%v\n", dataStr)
	isTrue = false
	tmp := "2006-01-02"
	res, err := time.ParseInLocation(tmp, dataStr, time.Local)
	timeStamp = res.Unix()
	if err == nil {
		isTrue = true
	}
	// fmt.Printf("记不清威威--2->%v\n", dataStr)
	if !isTrue {
		tmp := "2006/01/02"
		res, err := time.ParseInLocation(tmp, dataStr, time.Local)
		// fmt.Printf("记不清威威--3->%v\n", err)
		timeStamp = res.Unix()
		if err == nil {
			isTrue = true
		}
	}
	return
}

// 数据库查询翻页
func LimitPage(page, pageSize int) (offSet int) {
	if page < 1 {
		page = 1
	}
	offSet = pageSize * (page - 1)
	if offSet < 0 {
		offSet = 0
	}
	return
}

// 中文首字母大写
func ChineseFirstWordCapitalize(wordStr string) (firstWord string) {
	pinYinSub := pinyin.NewArgs()
	rows := pinyin.Pinyin(wordStr, pinYinSub)
	for i := 0; i < len(rows); i++ {
		if len(rows[i]) != 0 {
			str := rows[i][0]
			pi := str[0:1]
			firstWord += string(bytes.ToUpper([]byte(pi)))
		}
	}
	return
}

//获取行政组织首字母
/*
@govName				全称
@abbreviation			简称
@govClass				部门类型
@parentId				上级
*/
func GetGovFirstWords(govName, abbreviation, govClass, parentId string) (firstWord string) {
	var lev = 0
	overall.CONSTANT_DB_HR.Model(&models.AdministrativeOrganizationType{}).Select("`level`").Where("`id` = ?", govClass).First(&lev)
	if lev <= 2 {
		if abbreviation != "" {
			firstWord = ChineseFirstWordCapitalize(abbreviation)
		} else {
			firstWord = ChineseFirstWordCapitalize(govName)
		}
	} else {
		var idAry []int64
		firstWord = GetCompany(GetGroupFramework(parentId, idAry))
	}
	return
}

// 获取行政级别公司
func GetCompany(id []int64) (firstWord string) {
	var govClass []outGovToClass
	err := overall.CONSTANT_DB_HR.Model(&models.AdministrativeOrganization{}).Select("administrative_organization.name,administrative_organization.abbreviation,aot.level").Joins("left join administrative_organization_type as aot on aot.id = administrative_organization.organization_type").Where("administrative_organization.state IN ? AND administrative_organization.id IN ?", []int{1, 2}, id).Find(&govClass).Error
	if err != nil {
		return
	}
	levelOne := ""
	levelTwo := ""
	for _, v := range govClass {
		if v.Level == 2 {
			if v.Abbreviation != "" {
				levelTwo = ChineseFirstWordCapitalize(v.Abbreviation)
			} else {
				levelTwo = ChineseFirstWordCapitalize(v.Name)
			}
			firstWord = levelTwo
			return
		}
		if v.Level == 1 {
			if v.Abbreviation != "" {
				levelOne = ChineseFirstWordCapitalize(v.Abbreviation)
			} else {
				levelOne = ChineseFirstWordCapitalize(v.Name)
			}
		}
	}
	if levelTwo != "" {
		firstWord = levelTwo
	} else {
		firstWord = levelOne
	}
	return
}

// 获取架构
func GetGroupFramework(parentId string, father []int64) []int64 {
	var id int64
	err := overall.CONSTANT_DB_HR.Model(&models.AdministrativeOrganization{}).Select("`id`").Where("`superior` = ?", parentId).First(&id)
	if err != nil {
		return father
	}
	father = append(father, id)
	GetGroupFramework(strconv.FormatInt(id, 10), father)
	return father
}

// 获取集团或第一实权部门
func GetGroupOrDepartPower(parentId int64, departId ...int64) int64 {
	var orgCont models.AdministrativeOrganization
	err := orgCont.GetCont(map[string]interface{}{"id": parentId}, "id", "organization_type", "superior", "ispower")
	if err != nil {
		return parentId
	}
	// jsonCCC, _ := json.Marshal(orgCont)
	// fmt.Printf("orgCont------->%v\n", string(jsonCCC))
	if len(departId) > 0 {
		if orgCont.IsPower == 1 {
			// fmt.Printf("orgCont---1---->%v---->%v\n", string(jsonCCC), orgCont.Id)
			return orgCont.Id
		}
		return GetGroupOrDepartPower(orgCont.Superior, 1)
	} else {
		if orgCont.OrganizationType <= 2 {
			// fmt.Printf("orgCont---2---->%v\n", string(jsonCCC))
			return orgCont.Id
		}
		return GetGroupOrDepartPower(orgCont.Superior)
	}
	// if len(departId) > 0 {
	// 	fmt.Printf("orgCont----4--->%v\n", orgCont.Superior)
	// 	GetGroupOrDepartPower(orgCont.Superior, 1)
	// } else {
	// 	fmt.Printf("orgCont----5--->%v\n", orgCont.Superior)
	// 	GetGroupOrDepartPower(orgCont.Superior)
	// }
	// fmt.Printf("orgCont----3--->%v\n", string(jsonCCC))
	return orgCont.Id
}

// 获取集团或第一实权部门
func GetGroupOrDepartPoweres(parentId int64, departId ...int64) int64 {
	var orgCont models.AdministrativeOrganization
	err := orgCont.GetCont(map[string]interface{}{"id": parentId}, "id", "organization_type", "superior", "ispower")
	if err != nil {
		return parentId
	}
	// jsonCCC, _ := json.Marshal(orgCont)
	// fmt.Printf("orgCont------->%v\n", string(jsonCCC))
	if len(departId) > 0 {
		if orgCont.IsPower == 1 {
			// fmt.Printf("orgCont---1---->%v---->%v\n", string(jsonCCC), orgCont.Id)
			return orgCont.Id
		}
		return GetGroupOrDepartPoweres(orgCont.Superior, 1)
	} else {
		if orgCont.OrganizationType <= 3 {
			// fmt.Printf("orgCont---2---->%v\n", string(jsonCCC))
			return orgCont.Id
		}
		return GetGroupOrDepartPoweres(orgCont.Superior)
	}
	// if len(departId) > 0 {
	// 	fmt.Printf("orgCont----4--->%v\n", orgCont.Superior)
	// 	GetGroupOrDepartPower(orgCont.Superior, 1)
	// } else {
	// 	fmt.Printf("orgCont----5--->%v\n", orgCont.Superior)
	// 	GetGroupOrDepartPower(orgCont.Superior)
	// }
	// fmt.Printf("orgCont----3--->%v\n", string(jsonCCC))
	return orgCont.Id
}

// ZeroFillByStr
// @Description: 字符串补零
// @param str :需要操作的字符串
// @param resultLen 结果字符串的长度
// @param reverse true 为前置补零，false 为后置补零
// @return string
func ZeroFillByStr(str string, resultLen int, reverse bool) string {
	if len(str) > resultLen || resultLen <= 0 {
		return str
	}
	if reverse {
		return fmt.Sprintf("%0*s", resultLen, str) //不足前置补零
	}
	result := str
	for i := 0; i < resultLen-len(str); i++ {
		result += "0"
	}
	return result
}

// 生成编号
func CreateNumber(firstWords, govClass string) (numberStr string) {
	var orgCont models.AdministrativeOrganization
	var orgClass models.AdministrativeOrganizationType

	whereAry := MapOut()
	whereAry["superior"] = govClass
	countId := orgCont.CountCont(whereAry)

	whereOrgAry := MapOut()
	whereOrgAry["id"] = govClass
	orgCont.GetCont(whereOrgAry)

	orgWhere := MapOut()
	orgWhere["id"] = orgCont.OrganizationType
	orgClass.GetCont(orgWhere)

	// fmt.Printf("---11---------->%v------>%v\n", orgWhere, orgClass)

	if orgClass.Level < 2 {
		numberVal := ZeroFillByStr(strconv.FormatInt(countId, 10), 2, true)
		numberStr = fmt.Sprintf("%v%v", firstWords, numberVal)
	} else {
		countId++
		numberVal := ZeroFillByStr(strconv.FormatInt(countId, 10), 2, true)

		// fmt.Printf("------------->%v------>%v\n", whereOrgAry, orgCont)
		numberStr = fmt.Sprintf("%v%v", orgCont.Number, numberVal)
	}
	return
}

type MenuList []OutGovCont

// 行政组织递归
func (g *MenuList) GovRecursion(parentId, level int64) []govThree {
	var govMap []govThree

	list := g.findChildren(parentId)
	if len(list) == 0 {
		return govMap
	}
	for _, v := range list {
		// child := g.GovRecursion(v.Superior, level+1)
		g.GovRecursion(v.Superior, level+1)
		// 	govMap = append(govMap, govThree{v, child})
	}
	return govMap
}

// 获取子集
func (g *MenuList) findChildren(parentId int64) []OutGovCont {
	child := []OutGovCont{}

	for _, v := range *g {
		if v.Superior == parentId {
			child = append(child, v)
		}
	}
	return child
}

func GovThreeList(parentId int64, govAry []OutGovCont) []govThree {
	var govMap []govThree
	// fmt.Printf("govAry---------------->%v\n", govAry)
	for _, v := range govAry {
		// var zhucont govThree

		if v.Superior == parentId {

			child := GovThreeList(v.Id, govAry)
			govMap = append(govMap, govThree{v, child})
		}

	}
	return govMap
}

// 菜单权限递归
func MenuThreePermit(parentId int64, menuAry []models.SystemMenuOperation) []MenuPermitThree {
	var menuThree []MenuPermitThree
	for _, v := range menuAry {
		if v.ParentId == parentId {
			child := MenuThreePermit(v.Id, menuAry)
			menuThree = append(menuThree, MenuPermitThree{v, child})
		}
	}
	return menuThree
}

/*
*加密算法
 */
type Md5Encryption struct {
	Code   string `json:"code"`
	AppKey string `json:"appKey"`
}

func (m *Md5Encryption) Md5EncryptionAlgorithm() (md5Val string) {
	if m.AppKey == "" {
		m.Md5EncryptionInit(m.Code)
	}
	// fmt.Printf("Code ====> %v\n", m.Code)
	// fmt.Printf("AppKey ====> %v\n", m.AppKey)

	mdNew := md5.New()
	mdNew.Write([]byte(m.AppKey))
	keyMd5 := fmt.Sprintf("%x", mdNew.Sum(nil))

	// fmt.Printf("Step1:--AppKey-加密->%v\n", keyMd5)

	codeNewMd1 := md5.New()
	codeNewMd1.Write([]byte(m.Code))
	codeMd1 := fmt.Sprintf("%x", codeNewMd1.Sum(nil))

	// fmt.Printf("Step2:--CodeString-加密->%v\n", codeMd1)

	yiCeng := codeMd1 + keyMd5

	// fmt.Printf("Step3:--CodeString+AppKey-->%v\n", yiCeng)

	yiCengNew := md5.New()
	yiCengNew.Write([]byte(yiCeng))
	yiCengMd5 := fmt.Sprintf("%x", yiCengNew.Sum(nil))

	// fmt.Printf("Step4:--one-加密->%v\n", yiCengMd5)

	erCeng := yiCengMd5 + m.AppKey

	// fmt.Printf("Step5:--one + AppKey->%v\n", erCeng)

	// fmt.Printf("AppKey ===2=> %v\n", m.AppKey)

	erCengNew := md5.New()
	erCengNew.Write([]byte(erCeng))
	md5Val = fmt.Sprintf("%x", erCengNew.Sum(nil))

	// fmt.Printf("Step6:--therr--加密-->%v\n", md5Val)

	// md5Val = codeMd1
	return
}

func (m *Md5Encryption) Md5EncryptionAlgorithmFj() (md5Val string, outlog []string) {
	if m.AppKey == "" {
		m.Md5EncryptionInit(m.Code)
	}
	// fmt.Printf("Code ====> %v\n", m.Code)
	// fmt.Printf("AppKey ====> %v\n", m.AppKey)

	outlog = append(outlog, fmt.Sprintf("Code ====> %v", m.Code))
	outlog = append(outlog, fmt.Sprintf("AppKey ====> %v", m.AppKey))

	mdNew := md5.New()
	mdNew.Write([]byte(m.AppKey))
	keyMd5 := fmt.Sprintf("%x", mdNew.Sum(nil))

	// fmt.Printf("Step1:--AppKey-加密->%v\n", keyMd5)
	outlog = append(outlog, fmt.Sprintf("Step1:--AppKey-加密->%v", keyMd5))

	codeNewMd1 := md5.New()
	codeNewMd1.Write([]byte(m.Code))
	codeMd1 := fmt.Sprintf("%x", codeNewMd1.Sum(nil))

	// fmt.Printf("Step2:--CodeString-加密->%v\n", codeMd1)
	outlog = append(outlog, fmt.Sprintf("Step2:--CodeString-加密->%v", codeMd1))

	yiCeng := codeMd1 + keyMd5

	// fmt.Printf("Step3:--CodeString+AppKey-->%v\n", yiCeng)
	outlog = append(outlog, fmt.Sprintf("Step3:--CodeString+AppKey-->%v", yiCeng))

	yiCengNew := md5.New()
	yiCengNew.Write([]byte(yiCeng))
	yiCengMd5 := fmt.Sprintf("%x", yiCengNew.Sum(nil))

	// fmt.Printf("Step4:--one-加密->%v\n", yiCengMd5)
	outlog = append(outlog, fmt.Sprintf("Step4:--one-加密->%v", yiCengMd5))

	erCeng := yiCengMd5 + m.AppKey

	// fmt.Printf("Step5:--one + AppKey->%v\n", erCeng)
	outlog = append(outlog, fmt.Sprintf("Step5:--one + AppKey->%v", erCeng))

	// fmt.Printf("AppKey ===2=> %v\n", m.AppKey)

	erCengNew := md5.New()
	erCengNew.Write([]byte(erCeng))
	md5Val = fmt.Sprintf("%x", erCengNew.Sum(nil))

	fmt.Printf("Step6:--therr--加密-->%v\n", md5Val)
	outlog = append(outlog, fmt.Sprintf("Step6:--therr--加密-->%v", md5Val))

	// md5Val = codeMd1
	return
}

// 初始化程序
func (m *Md5Encryption) Md5EncryptionInit(code string) {
	m.AppKey = overall.CONSTANT_CONFIG.Appsetup.AppKey
	m.Code = code
}

// sha1算法
func Sha1Encryption(str string) string {
	sha1 := sha1.New()
	sha1.Write([]byte(str))
	return hex.EncodeToString(sha1.Sum(nil))
}

//计算当前时间N个月后的时间
/*
@timeStamp				当前时间戳
@futureTime				正数多少时间后，负数多少时间前
*/
func GetFutureMonthTime(timeStamp int64, futureTime, class int) (dateStr int64) {
	timeUnix := time.Unix(timeStamp, 0)
	addDate := timeUnix.AddDate(0, 0, futureTime)
	switch class {
	case 2:
		addDate = timeUnix.AddDate(0, futureTime, 0)
	case 3:
		addDate = timeUnix.AddDate(futureTime, 0, 0)
	default:
		addDate = timeUnix.AddDate(0, 0, futureTime)
	}

	dateStr = addDate.Unix()
	return
}

// 判断字符串是否在切片中
func StringIsInMap(str string, strAry []string) bool {
	if len(strAry) > 0 {
		for _, v := range strAry {
			// fmt.Printf("id------>%v----->%v\n", str, strAry)
			if v == str {
				return true
			}
		}
	}
	return false
}

// 判断值是否在数组中
func JudeInArray(id int64, ary []string) (isTrue bool) {
	// isTrue = false
	// for _, val := range ary {
	// 	valint64, err := strconv.ParseInt(val, 10, 64)
	// 	if err == nil {
	// 		if id == valint64 {
	// 			isTrue = true
	// 		}
	// 	}
	// }
	idStr := strconv.FormatInt(id, 10)
	isTrue = StringIsInMap(idStr, ary)
	return
}

func JudgeInMap(id int64, ary []int64) bool {
	if len(ary) > 0 {
		for _, v := range ary {
			if v == id {
				return true
			}
		}
	}
	return false
}

// 判断元素是否在切片中
func IsInTrue[T GenericityVariable](key T, keyAry []T) (isTrue bool) {
	isTrue = false
	for _, v := range keyAry {
		if v == key {
			return true
		}
	}
	return
}

// 获取两个切片得差集
func DifferenceSet[T GenericityVariable](one, two []T) []T {
	var three []T
	temp := map[T]struct{}{}
	for _, val := range two {
		if _, ok := temp[val]; !ok {
			temp[val] = struct{}{}
		}
	}
	for _, val := range one {
		if _, ok := temp[val]; !ok {
			three = append(three, val)
		}
	}
	return three
}

// 合并两个数组
func HeBingArray[T GenericityVariable](one, two []T) (three []T) {
	three = one
	for _, val := range two {
		if IsInTrue[T](val, three) == false {
			three = append(three, val)
		}
	}
	return
}

//判断类型转换成
/*
字符转int
*/
func StringToInt(val interface{}) (int, error) {
	switch val.(type) {
	case string:
		return strconv.Atoi(val.(string))
	case int:
		return val.(int), nil
	default:
		return 0, nil
	}
	return 0, nil
}

/*
字符转int64
*/
func StringToInt64(val interface{}) (int64, error) {
	switch val.(type) {
	case string:
		return strconv.ParseInt(val.(string), 10, 64)
	case int:
		return int64(val.(int)), nil
	case int64:
		return val.(int64), nil
	default:
		return 0, nil
	}
	return 0, nil
}

/*
政治面貌
(1：群众； 2：无党派；3：台盟会员；4：九三社员；5：致公党员；6：农工党员；7：民进会员；8：民建会员；9：民盟盟员；10：民革会员，11：共青团员；12：预备党员；13：中共党员)
*/
func PolitiToString(emp int) string {
	switch emp {
	case 1:
		return "群众"
	case 2:
		return "无党派"
	case 3:
		return "台盟会员"
	case 4:
		return "九三社员"
	case 5:
		return "致公党员"
	case 6:
		return "农工党员"
	case 7:
		return "民进会员"
	case 8:
		return "民建会员"
	case 9:
		return "民盟盟员"
	case 10:
		return "民革会员"
	case 11:
		return "共青团员"
	case 12:
		return "预备党员"
	case 13:
		return "中共党员"
	default:
		return "群众"
	}
}
func RecursionOrgLevees(oldId, superior int64, leve int64) (groupId int64) {
	if leve == 0 {
		leve = 1
	}
	if superior == 0 {
		return
	}
	var orgMap models.OrgContType
	err := orgMap.GetCont(map[string]interface{}{"`id`": superior, "`state`": 1}, "`id`", "`superior`", "`level`")
	if err != nil {
		return
	}
	if orgMap.Level <= leve {
		if orgMap.Level == leve {
			groupId = oldId
		} else {
			groupId = orgMap.Id
		}

		return
	} else {
		groupId = RecursionOrgLevees(orgMap.Superior, orgMap.Superior, leve)
	}
	return
}

// 递归查找
func RecursionOrgLeve(superior int64, leve int64) (groupId int64) {
	if leve == 0 {
		leve = 1
	}
	if superior == 0 {
		return
	}
	var orgMap models.OrgContType
	err := orgMap.GetCont(map[string]interface{}{"`id`": superior, "`state`": 1}, "`id`", "`superior`", "`level`")
	if err != nil {
		return
	}
	if orgMap.Level <= leve || (orgMap.Level == 5 && leve == 4 && (orgMap.Id == 282 || orgMap.Id == 115)) {
		if orgMap.Level == leve {
			groupId = superior
		} else {
			groupId = orgMap.Id
		}

		return
	} else {
		groupId = RecursionOrgLeve(orgMap.Superior, leve)
	}
	return
}

func RecursionOrgLeveEs(oldId, superior, leve int64) (groupId int64) {
	if leve == 0 {
		leve = 1
	}
	if superior == 0 {
		return
	}
	var orgMap models.OrgContType
	err := orgMap.GetCont(map[string]interface{}{"`id`": superior, "`state`": 1}, "`id`", "`superior`", "`level`")
	if err != nil {
		return
	}
	if orgMap.Level <= leve {
		if orgMap.Level == leve {
			groupId = oldId
		} else {
			groupId = orgMap.Id
		}

		return
	} else {
		groupId = RecursionOrgLeveEs(orgMap.Id, orgMap.Superior, leve)
	}
	return
}

// 获取集团、公司、部门、二级部门、工段
func GetOrgStructure(orgId int64) (groupId, companyId, departmentId, sunDepartId, workShopId int64) {
	if orgId == 0 {
		return
	}
	var orgContTypeInfo models.OrgContType
	err := orgContTypeInfo.GetCont(map[string]interface{}{"`id`": orgId})
	if err != nil {
		return
	}
	// fmt.Printf("获取集团属性--->%v\n", orgContTypeInfo.Level)
	switch orgContTypeInfo.Level {
	case 1:
		groupId = orgContTypeInfo.Id
	case 2:
		groupId = RecursionOrgLevees(orgContTypeInfo.Superior, orgContTypeInfo.Superior, 1)
		workShopId = orgContTypeInfo.Id
	case 3:
		groupId = RecursionOrgLevees(orgContTypeInfo.Superior, orgContTypeInfo.Superior, 2)
		companyId = orgContTypeInfo.Id
	case 4:
		groupId = RecursionOrgLevees(orgContTypeInfo.Superior, orgContTypeInfo.Superior, 2)
		companyId = RecursionOrgLevees(orgContTypeInfo.Superior, orgContTypeInfo.Superior, 3)
		departmentId = orgContTypeInfo.Id
	case 5:
		groupId = RecursionOrgLevees(orgContTypeInfo.Superior, orgContTypeInfo.Superior, 2)
		companyId = RecursionOrgLevees(orgContTypeInfo.Superior, orgContTypeInfo.Superior, 3)
		departmentId = RecursionOrgLevees(orgContTypeInfo.Superior, orgContTypeInfo.Superior, 4)
		fmt.Printf("departmentId--->%v\norgId--->%v\n", departmentId, orgId)
		sunDepartId = orgContTypeInfo.Id
	case 6:
		groupId = RecursionOrgLevees(orgContTypeInfo.Superior, orgContTypeInfo.Superior, 2)
		companyId = RecursionOrgLevees(orgContTypeInfo.Superior, orgContTypeInfo.Superior, 3)
		departmentId = RecursionOrgLevees(orgContTypeInfo.Superior, orgContTypeInfo.Superior, 4)
		sunDepartId = RecursionOrgLevees(orgContTypeInfo.Superior, orgContTypeInfo.Superior, 5)
		workShopId = orgContTypeInfo.Id
	default:
		groupId = orgContTypeInfo.Id
		companyId = orgContTypeInfo.Id
		workShopId = orgContTypeInfo.Id
	}
	return
}

// 获取指定行政组织id，所有子类
func GetDepartmentSun(superior int64, idary []int64) (orgIdAry []int64) {
	// if superior != 0 && IsInTrue[int64](superior, orgIdAry) == false {
	// 	orgIdAry = append(orgIdAry, superior)
	// }
	var orgAry []models.AdministrativeOrganization
	err := overall.CONSTANT_DB_HR.Model(&models.AdministrativeOrganization{}).Select("`id`").Where("`state` = 1 AND `superior` = ?", superior).Find(&orgAry).Error
	if err != nil {
		return
	}
	for _, v := range orgAry {
		if superior != 0 && IsInTrue[int64](v.Id, orgIdAry) == false {
			orgIdAry = append(orgIdAry, v.Id)
			GetDepartmentSun(v.Id, orgIdAry)
		} else {
			GetDepartmentSun(v.Id, orgIdAry)
		}
	}
	return
}

// 获取所有子集
func (a *AllSunList[int64]) GetAllSunOrg(superior int64) (err error) {
	var orgAry []models.AdministrativeOrganization
	err = overall.CONSTANT_DB_HR.Model(&models.AdministrativeOrganization{}).Select("`id`").Where("`state` = 1 AND `superior` = ?", superior).Find(&orgAry).Error
	if err != nil {
		return
	}
	for _, v := range orgAry {
		// var idInt int64
		idInt := int64(v.Id)
		if IsInTrue[int64](idInt, a.SunList) == false {
			a.SunList = append(a.SunList, idInt)
		}
		a.GetAllSunOrg(idInt)
	}
	return
}

// 获取行政组织所有上级
func (a *AllSunList[int64]) GetAllFatherOrg(superior int64) (err error) {
	var orgAry []models.AdministrativeOrganization
	err = overall.CONSTANT_DB_HR.Model(&models.AdministrativeOrganization{}).Select("`id`,`superior`").Where("`id` = ?", superior).Find(&orgAry).Error
	if err != nil {
		if IsInTrue[int64](superior, a.SunList) == false {
			a.SunList = append(a.SunList, superior)
		}
		return
	}
	for _, v := range orgAry {
		// var idInt int64
		idInt := int64(v.Id)
		if IsInTrue[int64](idInt, a.SunList) == false {
			a.SunList = append(a.SunList, idInt)
		}
		supId := int64(v.Superior)
		a.GetAllSunOrg(supId)
	}
	return
}

//浮点数保留小数
/*
@value				浮点数值
@weishu				要保留的小数位数
*/
func DecimalEs(value float64, weishu int) float64 {
	switch weishu {
	case 3:
		value, _ = strconv.ParseFloat(fmt.Sprintf("%.3f", value), 64)
	case 4:
		value, _ = strconv.ParseFloat(fmt.Sprintf("%.4f", value), 64)
	case 5:
		value, _ = strconv.ParseFloat(fmt.Sprintf("%.5f", value), 64)
	case 6:
		value, _ = strconv.ParseFloat(fmt.Sprintf("%.6f", value), 64)
	default:
		value, _ = strconv.ParseFloat(fmt.Sprintf("%.2f", value), 64)
	}

	return value
}

/*
*
获取月份有多少天
@year 年
@month 月
*/
func GetYearOfMonthHaveDay(year, month int) (day int) {
	//有31天的月份
	day31 := map[int]bool{
		1:  true,
		3:  true,
		5:  true,
		7:  true,
		8:  true,
		10: true,
		12: true,
	}
	if day31[month] == true {
		return 31
	}
	//有30天的月份
	day30 := map[int]bool{
		4:  true,
		6:  true,
		9:  true,
		11: true,
	}
	if day30[month] == true {
		return 30
	}
	if (year%4 == 0 && year%100 != 0) || (year%400 == 0) {
		return 29
	}
	return 28
}

/*
*
@ 作者: 秦东
@ 时间: 2023-01-29 11:37:59
@ 功能: 获取行政组织父级列表
@ 参数

	#

@ 返回值

	#

@ 方法原型

	#
*/
func (a *AllSunList[int64]) GetAllParentOrg(superior int64, level int) (err error) {
	var orgAry models.OrgContType
	gormDb := overall.CONSTANT_DB_HR.Model(&models.OrgContType{}).Select("`id`,`superior`,`level`").Where("`state` = 1 AND `id` = ?", superior)
	if level != 0 {
		gormDb = gormDb.Where("`level` > ?", level)
	}
	err = gormDb.First(&orgAry).Error
	if err != nil {
		return
	}
	idInt := int64(orgAry.Superior)
	var fatherCont models.OrgContType
	fatherCont.GetCont(map[string]interface{}{"`id`": idInt}, "`level`")
	if orgAry.Superior != 0 && int64(fatherCont.Level) > int64(level) {
		if IsInTrue[int64](idInt, a.SunList) == false {
			a.SunList = append(a.SunList, idInt)
		}
	}
	a.GetAllParentOrg(idInt, level)
	return
}

// Get请求
func CurlGet(getUrl string) []byte {
	client := &http.Client{}
	reqest, err := http.NewRequest("GET", getUrl, nil)
	if err != nil {
		panic(err)
	}
	response, _ := client.Do(reqest)
	defer response.Body.Close()
	body, err := ioutil.ReadAll(response.Body)
	return body
}

// Post请求 json
func CurlPostJosn(postUrl string, jsonData []byte) []byte {
	req, err := http.NewRequest("POST", postUrl, bytes.NewBuffer(jsonData))
	if err != nil {
		var kkl []byte
		return kkl
	}
	req.Header.Set("Content-Type", "application/json;charset=utf-8")
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	body, _ := ioutil.ReadAll(resp.Body)
	return body
}

func NewGovThreeList(parentId int64, govAry []OutGovCont) []govThree {
	var govMap []govThree
	// fmt.Printf("govAry---------------->%v\n", govAry)
	for _, v := range govAry {
		// var zhucont govThree

		if v.Superior == parentId {

			child := GovThreeList(v.Id, govAry)
			govMap = append(govMap, govThree{v, child})
		}

	}
	return govMap
}
func DucationToInt(emp int) string {
	switch emp {
	case 1:
		return "初中及以下"
	case 2:
		return "中专"
	case 3:
		return "高中"
	case 4:
		return "中技"
	case 5:
		return "高技"
	case 6:
		return "函授专科"
	case 7:
		return "专科"
	case 8:
		return "函授本科"
	case 9:
		return "本科"
	case 10:
		return "硕士"
	case 11:
		return "博士"
	case 12:
		return "专家、教授"
	default:
		return "初中及以下"
	}
}

// 学位(0：无；1：学士；2：硕士；3：博士；4：工学学士；5：教育学学位)int
func HestacademicdegreeToInt(hir string) int {
	switch hir {
	case "学士":
		return 1
	case "硕士":
		return 2
	case "博士":
		return 3
	case "学士学位":
		return 1
	case "工学学士":
		return 4
	case "教育学学位":
		return 5
	default:
		return 0
	}
}

// 根据字符串组合时间
//补全时间
/*
#dateTime			日期
*/
func (d *DateTimeTotimes) BaisStrToTime(dateTime string) {
	timeStrAry := strings.Split(dateTime, "-")
	switch len(timeStrAry) {
	case 1:
		dateTime = fmt.Sprintf("%v-01-01 12:00:00", dateTime)
	case 2:
		if len(timeStrAry[1]) < 2 {
			dateTime = fmt.Sprintf("%v-0%v-01 12:00:00", timeStrAry[0], timeStrAry[1])
		}
	case 3:
		monthStr := timeStrAry[1]
		if len(timeStrAry[1]) < 2 {
			monthStr = fmt.Sprintf("0%v", timeStrAry[1])
		}
		dayAry := strings.Split(timeStrAry[2], " ")
		// fmt.Printf("dayAry:%v------>%v\n", dayAry, len(dayAry))
		dayStr := dayAry[0]
		if len(dayAry[0]) < 2 {
			dayStr = fmt.Sprintf("0%v", dayAry[0])
		}
		if len(dayAry) > 1 {
			// fmt.Printf("dayAry[1]:%v------>%v\n", dayAry[1], len(dayAry[1]))
			if len(dayAry[1]) > 0 {
				Hours := "00"
				minutes := "00"
				seconds := "00"
				hisAry := strings.Split(dayAry[1], ":")
				switch len(hisAry) {
				case 1:
					if len(hisAry[0]) < 2 {
						Hours = fmt.Sprintf("0%v", hisAry[0])
					} else {
						Hours = hisAry[0]
					}
				case 2:
					if len(hisAry[0]) < 2 {
						Hours = fmt.Sprintf("0%v", hisAry[0])
					} else {
						Hours = hisAry[0]
					}
					if len(hisAry[1]) < 2 {
						minutes = fmt.Sprintf("0%v", hisAry[1])
					} else {
						minutes = hisAry[1]
					}
				case 3:
					if len(hisAry[0]) < 2 {
						Hours = fmt.Sprintf("0%v", hisAry[0])
					} else {
						Hours = hisAry[0]
					}
					if len(hisAry[1]) < 2 {
						minutes = fmt.Sprintf("0%v", hisAry[1])
					} else {
						minutes = hisAry[1]
					}
					if len(hisAry[2]) < 2 {
						seconds = fmt.Sprintf("0%v", hisAry[2])
					} else {
						seconds = hisAry[2]
					}
				default:
				}
				dayStr = fmt.Sprintf("%v %v:%v:%v", dayStr, Hours, minutes, seconds)
			}
		}
		// dayStr := timeStrAry[2]
		// if len(timeStrAry[2]) < 2 {
		// 	dayStr = fmt.Sprintf("0%v", timeStrAry[2])
		// }
		dateTime = fmt.Sprintf("%v-%v-%v", timeStrAry[0], monthStr, dayStr)

	default:
	}
	// fmt.Printf("dateTime:%v---1--->%v\n", dateTime, len(dateTime))
	orgTime, orgTimeErr := DateToTimeStamp(fmt.Sprintf("%v-01-01 12:00:00", dateTime))
	d.Time = dateTime
	if orgTimeErr {
		d.AllTime = orgTime
		d.Years = strconv.FormatInt(ComputingTime(orgTime, 1), 10)
		d.Quarter = strconv.FormatInt(ComputingTime(orgTime, 2), 10)
		d.Months = strconv.FormatInt(ComputingTime(orgTime, 3), 10)
		d.Week = strconv.FormatInt(ComputingTime(orgTime, 4), 10)
		d.Days = strconv.FormatInt(ComputingTime(orgTime, 5), 10)
		d.Hours = strconv.FormatInt(ComputingTime(orgTime, 7), 10)
		d.Minutes = strconv.FormatInt(ComputingTime(orgTime, 8), 10)
		d.Second = strconv.FormatInt(ComputingTime(orgTime, 9), 10)
	} else {

		orgTime, orgTimeErr = DateToTimeStamp(fmt.Sprintf("%v-01 12:00:00", dateTime))
		if orgTimeErr {
			d.AllTime = orgTime
			d.Years = strconv.FormatInt(ComputingTime(orgTime, 1), 10)
			d.Quarter = strconv.FormatInt(ComputingTime(orgTime, 2), 10)
			d.Months = strconv.FormatInt(ComputingTime(orgTime, 3), 10)
			d.Week = strconv.FormatInt(ComputingTime(orgTime, 4), 10)
			d.Days = strconv.FormatInt(ComputingTime(orgTime, 5), 10)
			d.Hours = strconv.FormatInt(ComputingTime(orgTime, 7), 10)
			d.Minutes = strconv.FormatInt(ComputingTime(orgTime, 8), 10)
			d.Second = strconv.FormatInt(ComputingTime(orgTime, 9), 10)

			fmt.Printf("dateTime:%v---2--->%v--->%v\n", orgTime, d.AllTime, d.Quarter)
		} else {
			orgTime, orgTimeErr = DateToTimeStamp(fmt.Sprintf("%v 12:00:00", dateTime))
			if orgTimeErr {
				d.AllTime = orgTime
				d.Years = strconv.FormatInt(ComputingTime(orgTime, 1), 10)
				d.Quarter = strconv.FormatInt(ComputingTime(orgTime, 2), 10)
				d.Months = strconv.FormatInt(ComputingTime(orgTime, 3), 10)
				d.Week = strconv.FormatInt(ComputingTime(orgTime, 4), 10)
				d.Days = strconv.FormatInt(ComputingTime(orgTime, 5), 10)
				d.Hours = strconv.FormatInt(ComputingTime(orgTime, 7), 10)
				d.Minutes = strconv.FormatInt(ComputingTime(orgTime, 8), 10)
				d.Second = strconv.FormatInt(ComputingTime(orgTime, 9), 10)
			} else {
				orgTime, orgTimeErr = DateToTimeStamp(fmt.Sprintf("%v:00:00", dateTime))
				if orgTimeErr {
					d.AllTime = orgTime
					d.Years = strconv.FormatInt(ComputingTime(orgTime, 1), 10)
					d.Quarter = strconv.FormatInt(ComputingTime(orgTime, 2), 10)
					d.Months = strconv.FormatInt(ComputingTime(orgTime, 3), 10)
					d.Week = strconv.FormatInt(ComputingTime(orgTime, 4), 10)
					d.Days = strconv.FormatInt(ComputingTime(orgTime, 5), 10)
					d.Hours = strconv.FormatInt(ComputingTime(orgTime, 7), 10)
					d.Minutes = strconv.FormatInt(ComputingTime(orgTime, 8), 10)
					d.Second = strconv.FormatInt(ComputingTime(orgTime, 9), 10)
				} else {
					orgTime, orgTimeErr = DateToTimeStamp(fmt.Sprintf("%v:00", dateTime))
					if orgTimeErr {
						d.AllTime = orgTime
						d.Years = strconv.FormatInt(ComputingTime(orgTime, 1), 10)
						d.Quarter = strconv.FormatInt(ComputingTime(orgTime, 2), 10)
						d.Months = strconv.FormatInt(ComputingTime(orgTime, 3), 10)
						d.Week = strconv.FormatInt(ComputingTime(orgTime, 4), 10)
						d.Days = strconv.FormatInt(ComputingTime(orgTime, 5), 10)
						d.Hours = strconv.FormatInt(ComputingTime(orgTime, 7), 10)
						d.Minutes = strconv.FormatInt(ComputingTime(orgTime, 8), 10)
						d.Second = strconv.FormatInt(ComputingTime(orgTime, 9), 10)
					} else {
						orgTime, orgTimeErr = DateToTimeStamp(dateTime)
						if orgTimeErr {
							d.AllTime = orgTime
							d.Years = strconv.FormatInt(ComputingTime(orgTime, 1), 10)
							d.Quarter = strconv.FormatInt(ComputingTime(orgTime, 2), 10)
							d.Months = strconv.FormatInt(ComputingTime(orgTime, 3), 10)
							d.Week = strconv.FormatInt(ComputingTime(orgTime, 4), 10)
							d.Days = strconv.FormatInt(ComputingTime(orgTime, 5), 10)
							d.Hours = strconv.FormatInt(ComputingTime(orgTime, 7), 10)
							d.Minutes = strconv.FormatInt(ComputingTime(orgTime, 8), 10)
							d.Second = strconv.FormatInt(ComputingTime(orgTime, 9), 10)
						}
					}
				}
			}
		}
	}
}
func DateToTimeStampOld(dataStr string) (timeStamp int64) {
	tmp := "2006-01-02 15:04:05"
	res, _ := time.ParseInLocation(tmp, dataStr, time.Local)
	timeStamp = res.Unix()
	return
}

// 时间计算(年、季、月、周、日、时、分、秒)
func ComputingTime(timeStamp int64, timeType int) (timeDataInt int64) {
	var timeData = "1"
	switch timeType {
	case 1:
		timeData = time.Unix(timeStamp, 0).Format("2006") //年
	case 2:
		dayMonth := time.Unix(timeStamp, 0).Format("01") //季度
		datMonthFloat, datMonthFloatErr := strconv.ParseFloat(dayMonth, 10)
		if datMonthFloatErr == nil {
			timeData = strconv.FormatFloat(math.Ceil(datMonthFloat/3), 'f', -1, 64)
		} else {
			timeData = "1"
		}
	case 3:
		timeData = time.Unix(timeStamp, 0).Format("01") //月份
	case 4: //当前日期为本月第几周
		monthFirstDayStr := DateToTimeStampOld(UnixTimeToDay(timeStamp, 15) + "-01 00:00:00") //获取指定月第一天时间戳
		dayTime := time.Unix(monthFirstDayStr, 0)
		dayOfWeek := int(dayTime.Weekday()) //获取本月第一天是周几
		if dayOfWeek == 0 {
			dayOfWeek = 7
		}

		dayNumber, dayNumberErr := strconv.ParseInt(UnixTimeToDay(timeStamp, 18), 10, 64) //获取今天是几号
		if dayNumberErr != nil {
			dayNumber = 1
		}
		daysAndWeeksDiff := dayNumber - (8 - int64(dayOfWeek))
		if daysAndWeeksDiff <= 0 {
			timeData = "1"
		} else {
			daysAndWeeksDiffFlot, daysAndWeeksDiffFloatErr := strconv.ParseFloat(strconv.FormatInt(daysAndWeeksDiff, 10), 10)
			if daysAndWeeksDiffFloatErr == nil {
				daysWeeksDiffVal := math.Ceil(daysAndWeeksDiffFlot/7) + 1
				timeData = strconv.FormatFloat(daysWeeksDiffVal, 'f', -1, 64)
			} else {
				timeData = "1"
			}
		}
	case 5:
		timeData = time.Unix(timeStamp, 0).Format("02") //天
	case 7:
		timeData = time.Unix(timeStamp, 0).Format("15") //时
	case 8:
		timeData = time.Unix(timeStamp, 0).Format("04") //分
	case 9:
		timeData = time.Unix(timeStamp, 0).Format("05") //秒
	default:
		timeData = "0"
	}
	timeDataInt, timeDataIntErr := strconv.ParseInt(timeData, 10, 64)
	if timeDataIntErr != nil {
		timeDataInt = 0
		return
	}
	return
}

// 获取指定月的起止时间副本
func GetAppointMonthStarAndEndTimeEs(dayTime string) (startTime, endTime int64) {
	dataTypeAll := "2006-01-02"
	firstToTime := StringToTimeIng("d", dayTime)
	startTimeStr := fmt.Sprintf("%v 00:00:00", firstToTime.AddDate(0, 0, 0).Format(dataTypeAll))
	endTimeStr := fmt.Sprintf("%v 23:59:59", firstToTime.AddDate(0, 1, -1).Format(dataTypeAll))
	// startTime = dayTime
	// fmt.Printf("获取指定月的起止时间副本--->%v--->%v\n", startTimeStr, endTimeStr)
	startTime, _ = DateToTimeStamp(startTimeStr)
	endTime, _ = DateToTimeStamp(endTimeStr)
	return
}

// 日期字符串转换成time格式
func StringToTimeIng(unit, str string) (res time.Time) {
	loc, _ := time.LoadLocation("Local")
	// str := t.ToString()
	layout, ok := timeLayoutMap[unit]
	if !ok {
		layout = timeLayoutMap["s"]
	}
	res, _ = time.ParseInLocation(layout, str, loc)
	return
}

/*
*
@ 作者: 秦东
@ 时间: 2023-07-01 13:04:00
@ 功能: 获取当前登陆人信息
@ 参数

	#

@ 返回值

	#

@ 方法原型

	#
*/
func GetCreetUserCont(userKey string) (manCont models.ManCont, err error) {
	redisFileKey := fmt.Sprintf("ScanCode:Authentication:LoginApi_%v_%v", overall.CONSTANT_CONFIG.RedisPrefixStr.Alias, userKey)
	redisClient := grocerystore.RunRedis(overall.CONSTANT_REDIS5)
	userRedisToken, isTrue := redisClient.HashGetAll(redisFileKey)
	if !isTrue {
		return
	}
	manCont, err = GetUserRedisCont(userRedisToken["usernumber"])
	return
}

// 获取人员Redis信息
func GetUserRedisCont(number string) (manCont models.ManCont, err error) {
	redisMyContKey := fmt.Sprintf("ScanCode:Authentication:UserCont_%v_%v", overall.CONSTANT_CONFIG.RedisPrefixStr.Alias, number)
	redisClient := grocerystore.RunRedis(overall.CONSTANT_REDIS5)
	useMap, isTrue := redisClient.HashGetAll(redisMyContKey)
	if !isTrue {
		errors.New("没有相关信息")
		return
	}
	err = MapToStruct(useMap, &manCont, "json")
	return
}

/*
map[string]string  转 struct
*/
func MapToStruct(mapString map[string]string, structInterface interface{}, tag string) (err error) {
	strType := reflect.TypeOf(structInterface)
	strValue := reflect.ValueOf(structInterface)
	switch strType.Kind() {
	case reflect.Ptr:
		if strType.Elem().Kind() != reflect.Struct {
			// fmt.Printf("1-->%v\n", strType.Elem().Kind().String())
			return errors.New("需要*struct类型，却传入*" + strType.Elem().Kind().String() + "类型")
		}
	default:
		// fmt.Printf("2-->%v\n", strType.Kind().String())
		return errors.New("需要*struct类型，却传入" + strType.Kind().String() + "类型")
	}
	// fmt.Printf("strType--->%v---strValue---->%v\n", strType, strValue)
	strTypeElem := strType.Elem()
	strValueElem := strValue.Elem()
	strTypeNum := strTypeElem.NumField()
	// fmt.Printf("strTypeElem--->%v---strValueElem---->%v---------strTypeNum--------->%v\n", strTypeElem, strValueElem, strTypeNum)
	for i := 0; i < strTypeNum; i++ {
		fieldName := strTypeElem.Field(i).Name
		if tag != "" {
			fieldName = strTypeElem.Field(i).Tag.Get(tag)
		}
		value, ok := mapString[fieldName]
		if !ok {
			continue
		}
		// fmt.Printf("name--->%v---tag---->%v----value---->%v----ok---->%v\n", fieldName, tag, value, ok)
		if strValueElem.Field(i).CanSet() {
			// fmt.Printf("Type--->%v---value---->%v\n", strValueElem.Field(i).Type(), reflect.TypeOf(value))
			valType := fmt.Sprintf("%v", strValueElem.Field(i).Type())
			switch valType {
			case "int":
				valueInt, _ := strconv.Atoi(value)
				strValueElem.Field(i).Set(reflect.ValueOf(valueInt))
			case "int32":
				valueInt32, _ := strconv.ParseInt(value, 10, 32)
				strValueElem.Field(i).Set(reflect.ValueOf(int32(valueInt32)))
			case "int64":
				valueInt64, _ := strconv.ParseInt(value, 10, 64)
				strValueElem.Field(i).Set(reflect.ValueOf(valueInt64))
			case "float32":
				valuefloat32, _ := strconv.ParseFloat(value, 32)
				strValueElem.Field(i).Set(reflect.ValueOf(float32(valuefloat32)))
			case "float64":
				valuefloat64, _ := strconv.ParseFloat(value, 64)
				strValueElem.Field(i).Set(reflect.ValueOf(valuefloat64))
			case "string":
				strValueElem.Field(i).Set(reflect.ValueOf(value))
			default:

			}
		} else {
			continue
		}
	}
	return
}

/**
@ 作者: 秦东
@ 时间: 2024-01-23 10:02:14
@ 功能: 教育等级
@ 参数
		#level   等级
@ 返回值
		#
@ 方法原型
		#
*/
//'学历(1：初中及以下；2：中专；3：高中；4：中技；5：高技；6：函数专科；7：大学专科；8：函数本科；9：大学本科；10：硕士研究生；11：博士研究生；12：专家、教授)'
func EducationLevel(level int64) string {
	switch level {
	case 2:
		return "中专"
	case 3:
		return "高中"
	case 4:
		return "中技"
	case 5:
		return "高技"
	case 6:
		return "函授专科"
	case 7:
		return "大学专科"
	case 8:
		return "函数本科"
	case 9:
		return "大学本科"
	case 10:
		return "硕士研究生"
	case 11:
		return "博士研究生"
	case 12:
		return "专家、教授"
	default:
		return "初中及以下"
	}
}

/*
*
@ 作者: 秦东
@ 时间: 2024-01-23 10:06:12
@ 功能: 学位
@ 参数

	#

@ 返回值

	#

@ 方法原型

	#
*/
func AcademicDegree(level int64) string {
	switch level {
	case 2:
		return "学士"
	case 3:
		return "硕士"
	case 4:
		return "博士"
	default:
		return "无"
	}
}

// 学历类型
func GetXueWeiClass(level int64) string {
	switch level {
	case 2:
		return "第一学历"
	case 3:
		return "最高学历"
	default:
		return "其他学历"
	}
}

// 政治身份
// 政治面貌(1：群众；2：无党派；3：台盟会员；4：九三社员；5：致公党员；6：农工党员；7：民进会员；8：民建会员；9：民盟盟员；10：民革会员，11：共青团员；12：预备党员；13：中共党员)
func PoliticalIdentity(level int64) string {
	switch level {
	case 2:
		return "无党派"
	case 3:
		return "台盟会员"
	case 4:
		return "九三社员"
	case 5:
		return "致公党员"
	case 6:
		return "农工党员"
	case 7:
		return "民进会员"
	case 8:
		return "民建会员"
	case 9:
		return "民盟盟员"
	case 10:
		return "民革会员"
	case 11:
		return "共青团员"
	case 12:
		return "预备党员"
	case 13:
		return "中共党员"
	default:
		return "群众"
	}
}

// 星座
// 星座（1：白羊座；2：金牛座；3：双子座；4：巨蟹座；5：狮子座；6：处女座；7：天枰座；8：天蝎座；9：射手座；10：摩羯座；11：水瓶座；12：双鱼座）
func StarSign(level int64) string {
	switch level {
	case 2:
		return "金牛座"
	case 3:
		return "双子座"
	case 4:
		return "巨蟹座"
	case 5:
		return "狮子座"
	case 6:
		return "处女座"
	case 7:
		return "天枰座"
	case 8:
		return "天蝎座"
	case 9:
		return "射手座"
	case 10:
		return "摩羯座"
	case 11:
		return "水瓶座"
	case 12:
		return "双鱼座"
	default:
		return "白羊座"
	}
}

// 健康状况
func HealthState(level int64) string {
	switch level {
	case 1:
		return "良好"
	case 3:
		return "较弱"
	case 4:
		return "有生理缺陷"
	case 5:
		return "残废"
	default:
		return "一般"
	}
}

// 婚姻状况
func MaritalStatus(level int64) string {
	switch level {
	case 2:
		return "已婚"
	case 3:
		return "丧偶"
	case 4:
		return "离异"
	default:
		return "未婚"
	}
}

// 性别
func GenderStatus(level int64) string {
	switch level {
	case 1:
		return "男"
	case 2:
		return "女"
	case 3:
		return "第三性别"
	default:
		return "未知"
	}
}

// 员工状态
// 用工关系（1:临时工 , 2:编外人员 ;3:实习&实习生;4：试用员工；5：待分配；6：待岗；7：临时调入；8：正式员工；9：长期病假；10：停薪留职；11：退休；12：辞职；13：辞退；14：离职）
func EmpTypeStatus(level int64) string {
	switch level {
	case 2:
		return "编外人员"
	case 3:
		return "实习&实习生"
	case 4:
		return "试用员工"
	case 5:
		return "待分配"
	case 6:
		return "待岗"
	case 7:
		return "临时调入"
	case 8:
		return "正式员工"
	case 9:
		return "长期病假"
	case 10:
		return "停薪留职"
	case 11:
		return "退休"
	case 12:
		return "辞职"
	case 13:
		return "辞退"
	case 14:
		return "离职"
	default:
		return "临时工"
	}
}

// 学历类型
func EducationType(level int64) string {
	switch level {
	case 1:
		return "全日制统招"
	case 2:
		return "成人高考"
	case 3:
		return "自学考试"
	case 4:
		return "开放大学"
	case 5:
		return "网络教育"
	case 6:
		return "函授"
	default:
		return ""
	}
}

// 学历类型
func EducationTypeAll(level int64) string {
	switch level {
	case 1:
		return "全日制统招学历"
	case 2:
		return "成人高考学历"
	case 3:
		return "自学考试学历"
	case 4:
		return "开放大学学历"
	case 5:
		return "网络教育学历"
	case 6:
		return "函授学历"
	default:
		return ""
	}
}

//取最大值

func GetMaxNum[T GenericityVariableInt](ary []T) T {
	if len(ary) == 0 {
		return 0
	}

	maxVal := ary[0]
	for i := 1; i < len(ary); i++ {
		if maxVal < ary[i] {
			maxVal = ary[i]
		}
	}

	return maxVal
}

// 判断文件上传的TYPE
func JudgeUpFileType(extTage string) int {
	images := []string{".jpg", ".jpeg", ".png", ".gif", ".bmp", ".avif", ".webp", ".tif", ".pcx", ".tga", ".exif", ".fpx", ".svg", ".psd", ".cdr", ".pcd", ".dxf", ".ufo", ".hdri", ".eps", ".flic", ".ai", ".ico", ".emf", ".raw", ".WMF", ".avif", ".apng", ".Webp", ".BMP", ".PCX", ".TIF", ".GIF", ".JPEG", ".JPG", ".TGA", ".EXIF", ".FPX", ".SVG", ".PSD", ".CDR", ".PCD", ".DXF", ".UFO", ".EPS", ".AI", ".PNG", ".HDRI", ".RAW", ".WMF", ".FLIC", ".EMF", ".APNG", ".ICO"}
	videoExt := []string{".mp4", ".avi", ".3gp", ".flv", ".rm", ".rmvb", ".wmv", ".mpeg", ".mpeg1", ".mpeg2", ".divx", ".xvid", ".dv", ".mkv", ".asf", ".asx", ".mov", ".m4v", ".dat", ".mkv", ".vob", ".ogg", ".mod", ".MP4", ".3GP", ".AVI", ".RM", ".RMVB", ".WMV", ".MPEG", ".MPEG1", ".MPEG2", ".DivX", ".XVID", ".DV", ".MKV", ".MOV", ".OGG", ".MOD", ".M4V", ".DAT", ".VOB"}
	officeExt := []string{".doc", ".docx", ".xml", ".ppt", ".pptx", ".pot", ".PPS", ".dot", ".mht", ".xlt"}
	zipExt := []string{".rar", ".zip", ".7z", ".ar", ".bz", ".car", ".dar", ".cpgz", ".f", ".ha"}
	excel := []string{".xls", ".xlsx", "csv"}
	if IsInTrue[string](extTage, images) {
		return 1
	}
	if IsInTrue[string](extTage, videoExt) {
		return 2
	}
	if IsInTrue[string](extTage, officeExt) {
		return 3
	}
	if IsInTrue[string](extTage, zipExt) {
		return 4
	}
	if IsInTrue[string](extTage, excel) {
		return 5
	}
	return 6
}

/*
*
@ 作者: 秦东
@ 时间: 2024-01-29 13:12:16
@ 功能: 院校类型
@ 参数

	#

@ 返回值

	#

@ 方法原型

	#
*/
func SchoolType(level int) string {
	var typeName string
	switch level {
	case 1:
		typeName = "私立中学"
	case 2:
		typeName = "公立中学"
	case 3:
		typeName = "高职院校"
	case 4:
		typeName = "民办专科院校"
	case 5:
		typeName = "公办专科院校"
	case 6:
		typeName = "民办本科院校"
	case 7:
		typeName = "公办本科院校"
	case 8:
		typeName = "”211“工程院校"
	case 9:
		typeName = "”985“工程院校"
	case 10:
		typeName = "：双一流院校"
	default:
		typeName = ""
	}
	return typeName
}

// 职位变动类型
func PositionChangeType(level int64) string {
	switch level {
	case 2:
		return "平调"
	case 3:
		return "降职"
	case 4:
		return "升职"
	default:
		return "新入职"
	}
}

// 雇佣类型（1：社会招聘；2：校园招聘；3：内部推荐）
func JoinJobChanelStr(hir int) string {
	switch hir {
	case 2:
		return "校园招聘"
	case 3:
		return "内部推荐"
	default:
		return "社会招聘"
	}
}

// 获取所有下级
func (g *GetOrgAllParent) GetOrgSonAllId(orgId int64) {
	var orgAry []int64
	if orgId != 0 {
		err := overall.CONSTANT_DB_HR.Model(&models.AdministrativeOrganization{}).Select("`id`").Where("`state` = 1 AND `superior` = ?", orgId).Find(&orgAry).Error
		if err != nil {
			return
		}
		for _, v := range orgAry {
			if !IsInTrue[int64](v, g.Id) {
				g.Id = append(g.Id, v)
				g.GetOrgSonAllId(v)
			} else {
				g.GetOrgSonAllId(v)
			}
		}
	}

}

/*
*
@ 作者: 秦东
@ 时间: 2024-01-30 16:23:36
@ 功能: Excel 5位时间转换
@ 参数

	#

@ 返回值

	#

@ 方法原型

	#
*/
func ExcelDateToDate(excelDate string) time.Time {
	timeInt, isTrue, _ := DateToTimeStampDay(excelDate)
	// fmt.Printf("事件处理-222-->%v\n", err)
	if isTrue {
		// fmt.Printf("事件处理-222-3->%v\n", timeInt)
		excelDateStrs := UnixTimeToDay(timeInt, 14)
		// fmt.Printf("事件处理-222-4->%v\n", excelDateStrs)
		return StringToTimeIng("d", excelDateStrs)
	} else {
		// fmt.Printf("事件处理--->%v\n", excelDate)
		excelTime := time.Date(1899, time.December, 30, 0, 0, 0, 0, time.UTC)
		var days, _ = strconv.ParseFloat(excelDate, 64)
		// fmt.Printf("事件处理--1->%v\n", days)
		return excelTime.Add(time.Second * time.Duration(days*86400))
	}

}

/*
*
@ 作者: 秦东
@ 时间: 2024-02-01 13:17:23
@ 功能: 职务变动对照
*/
func changeTypeToStr(emp int) string {
	switch emp {
	case 1:
		return "预入职"
	case 2:
		return "雇佣入职"
	case 3:
		return "转正"
	case 4:
		return "升职"
	case 5:
		return "降职"
	case 6:
		return "职等调整"
	case 7:
		return "调动调入"
	case 8:
		return "跨公司调动调入"
	case 9:
		return "借调"
	case 10:
		return "平调"
	case 11:
		return "兼职"
	case 12:
		return "预离职"
	case 13:
		return "离职"
	case 14:
		return "退休"
	case 15:
		return "返聘"
	case 16:
		return "员工初始化"
	case 17:
		return "擅自离职"
	case 18:
		return "即辞即走"
	case 19:
		return "组织调整"
	case 20:
		return "辞退"
	case 21:
		return "跨公司借调调出"
	case 22:
		return "跨公司借调调入"
	case 23:
		return "培训期间离职"
	case 24:
		return "合同到期"
	case 25:
		return "实习结束"
	case 26:
		return "新入职"
	default:
		return "预入职"
	}
}

// 奖惩级别
func RewPunLevel(level int) string {
	switch level {
	case 1:
		return "部门级"
	case 2:
		return "公司级"
	case 3:
		return "县级"
	case 4:
		return "市级"
	case 5:
		return "省级"
	case 6:
		return "国家级"
	default:
		return ""
	}
}
func RewPunLevelClass(emp int) string {
	switch emp {
	case 1:
		return "年终评优"
	case 2:
		return "表扬"
	case 3:
		return "嘉奖"
	case 4:
		return "记功"
	case 5:
		return "记大功"
	case 6:
		return "特别奖励"
	case 7:
		return "批评"
	case 8:
		return "警告"
	case 9:
		return "记过"
	case 10:
		return "记大过"
	case 11:
		return "降级"
	case 12:
		return "留用察看"
	case 13:
		return "开除"
	default:
		return ""
	}
}