You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
434 lines
10 KiB
434 lines
10 KiB
package overallhandle
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto/md5"
|
|
"crypto/rand"
|
|
"crypto/sha1"
|
|
"encoding/hex"
|
|
"fmt"
|
|
"hr_server/models"
|
|
"hr_server/overall"
|
|
"math"
|
|
"math/big"
|
|
"strconv"
|
|
"time"
|
|
|
|
"github.com/mozillazg/go-pinyin"
|
|
)
|
|
|
|
//全局函数处理
|
|
//编号，纯数字
|
|
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
|
|
}
|
|
|
|
//初始化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"
|
|
default:
|
|
timeTemplate = "2006-01-02 15:04:05" //常规类型
|
|
}
|
|
dateStr = time.Unix(timeStamp, 0).Format(timeTemplate)
|
|
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 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 int = 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
|
|
}
|
|
|
|
//
|
|
// 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
|
|
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))
|
|
|
|
codeNewMd1 := md5.New()
|
|
codeNewMd1.Write([]byte(m.Code))
|
|
codeMd1 := fmt.Sprintf("%x", codeNewMd1.Sum(nil))
|
|
|
|
yiCeng := codeMd1 + keyMd5
|
|
|
|
yiCengNew := md5.New()
|
|
yiCengNew.Write([]byte(yiCeng))
|
|
yiCengMd5 := fmt.Sprintf("%x", yiCengNew.Sum(nil))
|
|
|
|
erCeng := yiCengMd5 + m.AppKey
|
|
|
|
erCengNew := md5.New()
|
|
erCengNew.Write([]byte(erCeng))
|
|
md5Val = fmt.Sprintf("%x", erCengNew.Sum(nil))
|
|
|
|
// 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 {
|
|
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
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|