hr_server/api/jindie_docking/dockingorganization/controller.go

package dockingorganization

import (
	"encoding/json"
	"fmt"
	"hr_server/models"
	"hr_server/overall"
	"hr_server/overall/overallhandle"
	"strconv"
	"strings"
	"time"

	"github.com/gin-gonic/gin"
)

// 接口实验
func (d *DockingJinDieApi) DockKingdeeApi(c *gin.Context) {
	// GetOrgType()
	// JobClass()
	// DutiesContrast()
	OrgAdmin()
	// Position()
	// xingzheng()
	outMap := overallhandle.MapOut()
	overallhandle.Result(0, outMap, c)
}

func xingzheng() {
	var orgList []models.AdministrativeOrganization
	// orgList.GetCont(map[string]interface{}{"ispower": 1})
	overall.CONSTANT_DB_HR.Where("ispower = 1").Find(&orgList)
	var id []string
	var num []string
	for _, v := range orgList {

		id = append(id, strconv.FormatInt(v.Id, 10))
		num = append(num, v.Number)
	}
	fmt.Println(strings.Join(id, ","))
	fmt.Println(strings.Join(num, ","))
}

// 行政组织类型
func GetOrgType() {
	var orgContAry []orgClass
	sendUrl := fmt.Sprintf("%v/person/adminUnitType", overall.DockingKingdeeUrl)
	respBody, err := GetUrl(sendUrl)
	if err != nil {
		overallhandle.WriteLog("e", "未能获取到行政组织类型！", err)
		return
	}
	err = json.Unmarshal(respBody, &orgContAry)
	if err != nil {
		overallhandle.WriteLog("e", "行政组织类型映射错误！", err)
		return
	}
	overallhandle.WriteLog("i", "行政组织类型映射成功！", orgContAry)
	if len(orgContAry) < 0 {
		overallhandle.WriteLog("e", "未能获取到行政组织类型！", orgContAry)
		return
	}

	fmt.Printf("err---------------------->%v\n", err)
	var kingDeeIdAry []string
	//进行行政组织类别对照
	for _, v := range orgContAry {
		if overallhandle.StringIsInMap(v.Id, kingDeeIdAry) == false {
			kingDeeIdAry = append(kingDeeIdAry, v.Id)
		}
		//判断该项是否存在
		var orgCont models.AdministrativeOrganizationType
		orgErr := orgCont.GetCont(map[string]interface{}{"kingdeeid": v.Id}, "id", "name", "state")
		if orgErr == nil {
			//判断是否编辑
			if v.Name != orgCont.Name {
				editOrgErr := orgCont.EiteCont(map[string]interface{}{"id": orgCont.Id}, map[string]interface{}{"name": v.Name, "state": 1})
				if editOrgErr == nil {
					overallhandle.WriteLog("edit", "行政组织类型更新成功！", editOrgErr, v)
				} else {
					overallhandle.WriteLog("edit", "行政组织类型更新失败！", editOrgErr, v)
				}
			} else {
				if orgCont.State != 1 {
					editOrgErr := orgCont.EiteCont(map[string]interface{}{"id": orgCont.Id}, map[string]interface{}{"state": 1})
					if editOrgErr == nil {
						overallhandle.WriteLog("edit", "行政组织类型更新成功！state", editOrgErr, v)
					} else {
						overallhandle.WriteLog("edit", "行政组织类型更新失败！state", editOrgErr, v)
					}
				}
			}
		} else {
			orgCont.Name = v.Name
			orgCont.State = 1
			orgCont.Time = time.Now().Unix()
			orgCont.KingdeeId = v.Id
			addOrgErr := overall.CONSTANT_DB_HR.Create(&orgCont).Error
			if addOrgErr == nil {
				overallhandle.WriteLog("add", "行政组织类型写入成功！", addOrgErr, orgCont)
			} else {
				overallhandle.WriteLog("add", "行政组织类型写入失败！", addOrgErr, orgCont)
			}
		}
	}
	var orgAll []models.AdministrativeOrganizationType
	allErr := overall.CONSTANT_DB_HR.Where("`state` = 1").Find(&orgAll).Error
	if allErr == nil {
		var eidtId []string
		for _, av := range orgAll {
			if overallhandle.StringIsInMap(av.KingdeeId, kingDeeIdAry) == false {
				if overallhandle.StringIsInMap(av.KingdeeId, eidtId) == false {
					eidtId = append(eidtId, av.KingdeeId)
				}
			}
		}
		if len(eidtId) > 0 {
			orgContEditErr := overall.CONSTANT_DB_HR.Model(&models.AdministrativeOrganizationType{}).Where("`kingdeeid` IN ?", eidtId).Updates(map[string]interface{}{"state": 2}).Error
			if orgContEditErr == nil {
				overallhandle.WriteLog("edit", "禁用已不使用得行政组织类型成功！", orgContEditErr, eidtId)
			} else {
				overallhandle.WriteLog("edit", "禁用已不使用得行政组织类型失败！", orgContEditErr, eidtId)
			}
		}
	}
}

// 职务类型
func JobClass() {
	// fmt.Printf("1")
	var jobClassInfo []jobClassType
	sendUrl := fmt.Sprintf("%v/person/ptype", overall.DockingKingdeeUrl)
	respBody, err := GetUrl(sendUrl)
	if err != nil {
		overallhandle.WriteLog("e", "未能获取到职务类型！", err)
		return
	}
	err = json.Unmarshal(respBody, &jobClassInfo)
	if err != nil {
		overallhandle.WriteLog("e", "职务类型映射错误！", err)
		return
	}
	overallhandle.WriteLog("i", "职务类型映射成功！", jobClassInfo)
	if len(jobClassInfo) < 0 {
		overallhandle.WriteLog("e", "未能获取到职务类型！", jobClassInfo)
		return
	}
	var kingDeeIdAry []string
	//进行职务类型对照
	for _, v := range jobClassInfo {
		if overallhandle.StringIsInMap(v.Id, kingDeeIdAry) == false {
			kingDeeIdAry = append(kingDeeIdAry, v.Id)
		}
		//判断该项是否存在
		var jobClassCont models.JobClass
		jobClassErr := jobClassCont.GetCont(map[string]interface{}{"kingdeeid": v.Id})
		if jobClassErr == nil {
			//存在判断是否要进行更新
			if v.Name != jobClassCont.Name {
				editOrgErr := jobClassCont.EiteJobClassCont(map[string]interface{}{"id": jobClassCont.Id}, map[string]interface{}{"name": v.Name, "state": 1})
				if editOrgErr == nil {
					overallhandle.WriteLog("edit", "职务类型更新成功！", editOrgErr, v)
				} else {
					overallhandle.WriteLog("edit", "职务类型更新失败！", editOrgErr, v)
				}
			} else {
				if jobClassCont.State != 1 {
					editOrgErr := jobClassCont.EiteJobClassCont(map[string]interface{}{"id": jobClassCont.Id}, map[string]interface{}{"state": 1})
					if editOrgErr == nil {
						overallhandle.WriteLog("edit", "职务类型更新成功！state", editOrgErr, v)
					} else {
						overallhandle.WriteLog("edit", "职务类型更新失败！state", editOrgErr, v)
					}
				}
			}
		} else {
			//不存在，进行新增
			jobClassCont.Name = v.Name
			jobClassCont.KingdeeNum = v.Fnumber
			jobClassCont.KingdeeId = v.Id
			jobClassCont.State = 1
			jobClassCont.Time = time.Now().Unix()
			addErr := overall.CONSTANT_DB_HR.Create(&jobClassCont).Error
			if addErr == nil {
				overallhandle.WriteLog("add", "职务类型写入成功！", addErr, jobClassCont)
			} else {
				overallhandle.WriteLog("add", "职务类型写入失败！", addErr, jobClassCont)
			}
		}
	}

	var jobClassAll []models.JobClass
	allErr := overall.CONSTANT_DB_HR.Where("`state` = 1").Find(&jobClassAll).Error
	if allErr == nil {
		var eidtId []string
		for _, av := range jobClassAll {
			if overallhandle.StringIsInMap(av.KingdeeId, kingDeeIdAry) == false {
				if overallhandle.StringIsInMap(av.KingdeeId, eidtId) == false {
					eidtId = append(eidtId, av.KingdeeId)
				}
			}
		}
		if len(eidtId) > 0 {
			jobClassContEditErr := overall.CONSTANT_DB_HR.Model(&models.JobClass{}).Where("`kingdeeid` IN ?", eidtId).Updates(map[string]interface{}{"state": 2}).Error
			if jobClassContEditErr == nil {
				overallhandle.WriteLog("edit", "禁用已不使用得职务类型成功！", jobClassContEditErr, eidtId)
			} else {
				overallhandle.WriteLog("edit", "禁用已不使用得职务类型失败！", jobClassContEditErr, eidtId)
			}
		}
	}
}

// 职务
func DutiesContrast() {
	var jobInfo []jobContDuck
	sendUrl := fmt.Sprintf("%v/person/job", overall.DockingKingdeeUrl)
	respBody, err := GetUrl(sendUrl)
	if err != nil {
		overallhandle.WriteLog("e", "未能获取到职务！", err)
		return
	}
	err = json.Unmarshal(respBody, &jobInfo)
	if err != nil {
		overallhandle.WriteLog("e", "职务映射错误！", err)
		return
	}
	overallhandle.WriteLog("i", "职务映射成功！", jobInfo)
	if len(jobInfo) < 0 {
		overallhandle.WriteLog("e", "未能获取到职务！", jobInfo)
		return
	}
	var kingDeeIdAry []string
	//进行职务对照
	for _, v := range jobInfo {
		if overallhandle.StringIsInMap(v.Id, kingDeeIdAry) == false {
			kingDeeIdAry = append(kingDeeIdAry, v.Id)
		}
		//判断该项是否存在
		var dutiesCont models.Duties
		dutiesErr := dutiesCont.GetCont(map[string]interface{}{"kingdeeid": v.Id}, "`id`", "`name`", `state`, `job_type`)
		if dutiesErr == nil {
			//存在，进行更新
			//获取职务Id
			var jobClassInfo models.JobClass
			jobClassInfo.GetCont(map[string]interface{}{"kingdeeid": v.Fjobtype}, "`id`")
			var editOrgErr error
			isCaoZuo := false
			if v.Name != dutiesCont.Name {
				if dutiesCont.JobType != jobClassInfo.Id {
					editOrgErr = dutiesCont.EiteCont(map[string]interface{}{"id": dutiesCont.Id}, map[string]interface{}{"name": v.Name, "state": 1, "job_type": jobClassInfo.Id})
					isCaoZuo = true
				} else {
					editOrgErr = dutiesCont.EiteCont(map[string]interface{}{"id": dutiesCont.Id}, map[string]interface{}{"name": v.Name, "state": 1})
					isCaoZuo = true
				}
			} else {
				if dutiesCont.State != 1 {
					if dutiesCont.JobType != jobClassInfo.Id {
						editOrgErr = dutiesCont.EiteCont(map[string]interface{}{"id": dutiesCont.Id}, map[string]interface{}{"state": 1, "job_type": jobClassInfo.Id})
						isCaoZuo = true
					} else {
						editOrgErr = dutiesCont.EiteCont(map[string]interface{}{"id": dutiesCont.Id}, map[string]interface{}{"state": 1})
						isCaoZuo = true
					}
				}
			}
			if isCaoZuo == true {
				if editOrgErr == nil {
					overallhandle.WriteLog("edit", "职务更新成功！", editOrgErr, v)
				} else {
					overallhandle.WriteLog("edit", "职务更新失败！", editOrgErr, v)
				}
			}
		} else {
			//不存在，进行新增
			//获取旧对照表数据
			var oldDutiesInfo models.Duties
			oldDutErr := overall.CONSTANT_DB_HR_Jin.Model(&models.Duties{}).Select("weight,number").Where("`name` = ?", v.Name).First(&oldDutiesInfo).Error
			//获取职务Id
			var jobClassInfo models.JobClass
			jobClassErr := jobClassInfo.GetCont(map[string]interface{}{"kingdeeid": v.Fjobtype}, "`id`")
			var dutiesInfo models.Duties
			dutiesInfo.Name = v.Name
			if jobClassErr == nil {
				dutiesInfo.JobType = jobClassInfo.Id
			}
			if oldDutErr == nil {
				dutiesInfo.Weight = oldDutiesInfo.Weight
				dutiesInfo.Number = oldDutiesInfo.Number
			}
			dutiesInfo.Time = time.Now().Unix()
			dutiesInfo.State = 1
			dutiesInfo.KingdeeId = v.Id
			dutiesInfo.KingdeeNum = v.Fnumber
			addErr := overall.CONSTANT_DB_HR.Create(&dutiesInfo).Error
			if addErr == nil {
				overallhandle.WriteLog("add", "职务写入成功！", addErr, dutiesInfo)
			} else {
				overallhandle.WriteLog("add", "职务写入失败！", addErr, dutiesInfo)
			}
		}
	}

	var dutiesAll []models.Duties
	allErr := overall.CONSTANT_DB_HR.Where("`state` = 1").Find(&dutiesAll).Error
	if allErr == nil {
		var eidtId []string
		for _, av := range dutiesAll {
			if overallhandle.StringIsInMap(av.KingdeeId, kingDeeIdAry) == false {
				if overallhandle.StringIsInMap(av.KingdeeId, eidtId) == false {
					eidtId = append(eidtId, av.KingdeeId)
				}
			}
		}
		if len(eidtId) > 0 {
			dutiesContEditErr := overall.CONSTANT_DB_HR.Model(&models.Duties{}).Where("`kingdeeid` IN ?", eidtId).Updates(map[string]interface{}{"state": 2}).Error
			if dutiesContEditErr == nil {
				overallhandle.WriteLog("edit", "禁用已不使用得职务成功！", dutiesContEditErr, eidtId)
			} else {
				overallhandle.WriteLog("edit", "禁用已不使用得职务失败！", dutiesContEditErr, eidtId)
			}
		}
	}
}

// 行政组织
func OrgAdmin() {
	var orgInfo []orgAdminType
	sendUrl := fmt.Sprintf("%v/person/adminunit", overall.DockingKingdeeUrl)
	respBody, err := GetUrl(sendUrl)
	if err != nil {
		overallhandle.WriteLog("e", "未能获取到行政组织！", err)
		return
	}
	err = json.Unmarshal(respBody, &orgInfo)
	if err != nil {
		overallhandle.WriteLog("e", "行政组织映射错误！", err)
		return
	}
	overallhandle.WriteLog("i", "行政组织映射完成！", orgInfo)
	if len(orgInfo) < 0 {
		overallhandle.WriteLog("e", "未能获取到行政组织！", orgInfo)
		return
	}
	var kingDeeIdAry []string

	//进行职务对照
	for _, v := range orgInfo {
		if overallhandle.StringIsInMap(v.Id, kingDeeIdAry) == false {
			kingDeeIdAry = append(kingDeeIdAry, v.Id)
		}
		//判断该项是否存在
		var orgInfoContCont models.AdministrativeOrganization
		orgInfoContErr := orgInfoContCont.GetCont(map[string]interface{}{"kingdeeid": v.Id})
		if orgInfoContErr == nil {
			//存在，进行更新
			isEdit := false
			saveData := overallhandle.MapOut()
			if v.Name != orgInfoContCont.Name {
				saveData["name"] = v.Name
				isEdit = true
			}
			if v.Abbreviation != orgInfoContCont.Abbreviation {
				saveData["abbreviation"] = v.Abbreviation
				isEdit = true
			}
			if v.Number != orgInfoContCont.Number {
				saveData["number"] = v.Number
				isEdit = true
			}
			if orgInfoContCont.State != 1 {
				saveData["state"] = 1
				isEdit = true
			}
			//判断行政组织类型是否需要改变
			var judgeOrgType models.AdministrativeOrganizationType
			judgeOrgTypeErr := judgeOrgType.GetCont(map[string]interface{}{"id": orgInfoContCont.OrganizationType}, "`id`", "`kingdeeid`")
			if judgeOrgTypeErr == nil {
				if v.GovClass != judgeOrgType.KingdeeId {
					var orgTypeNewType models.AdministrativeOrganizationType
					orgTypeNewTypeErr := orgTypeNewType.GetCont(map[string]interface{}{"kingdeeid": v.Superior}, "id")
					if orgTypeNewTypeErr == nil {
						saveData["organization_type"] = orgTypeNewType.Id
						isEdit = true
					}
				}
			}
			if isEdit == true {
				saveData["time"] = time.Now().Unix()
				editErr := orgInfoContCont.EiteCont(map[string]interface{}{"id": orgInfoContCont.Id}, saveData)
				if editErr == nil {
					overallhandle.WriteLog("edit", "行政组织更新成功！", editErr, v, saveData)
				} else {
					overallhandle.WriteLog("edit", "行政组织更新失败！", editErr, v, saveData)
				}
			}
		} else {
			//不存在进行添加
			var orgCont models.AdministrativeOrganization
			orgCont.KingdeeId = v.Id
			orgCont.Number = v.Number
			orgCont.Name = v.Name
			orgCont.Abbreviation = v.Abbreviation
			orgCont.State = 1
			orgCont.Time = time.Now().Unix()
			//获取行政组织类型
			var orgType models.AdministrativeOrganizationType
			orgTypeErr := orgType.GetCont(map[string]interface{}{"kingdeeid": v.GovClass}, "id")
			if orgTypeErr == nil {
				orgCont.OrganizationType = orgType.Id
			}
			//获取知行学院及企业微信对照码
			var orgOldCont models.AdministrativeOrganization
			orgOldErr := overall.CONSTANT_DB_HR_Jin.Model(&models.AdministrativeOrganization{}).Select("wechat_organization_id,schoole").Where("`number` = ?", v.Number).First(&orgOldCont).Error
			if orgOldErr == nil {
				orgCont.WechatOrganizationId = orgOldCont.WechatOrganizationId
				orgCont.Schoole = orgOldCont.Schoole
			}
			if overallhandle.StringIsInMap(v.Number, OrgNumberDuiZhao) {
				orgCont.IsPower = 1
			}
			// orgCont.IsPower
			addErr := overall.CONSTANT_DB_HR.Create(&orgCont).Error
			if addErr == nil {
				overallhandle.WriteLog("add", "行政组织写入成功！", addErr, orgCont)
			} else {
				overallhandle.WriteLog("add", "行政组织写入失败！", addErr, orgCont)
			}
		}

	}
	//职务上级校正
	for _, cv := range orgInfo {
		var parentContCorre models.AdministrativeOrganization
		parentErr := parentContCorre.GetCont(map[string]interface{}{"kingdeeid": cv.Id}, "`id`", "`superior`")
		if parentErr == nil {
			if cv.Superior != "" {
				var orgCorrePrent models.AdministrativeOrganization
				orgCorrePrentErr := orgCorrePrent.GetCont(map[string]interface{}{"kingdeeid": cv.Superior}, "id")
				if orgCorrePrentErr == nil {
					if parentContCorre.Superior != orgCorrePrent.Id {
						saveData := overallhandle.MapOut()
						saveData["superior"] = orgCorrePrent.Id
						saveData["time"] = time.Now().Unix()
						parentIngErr := parentContCorre.EiteCont(map[string]interface{}{"id": parentContCorre.Id}, saveData)
						overallhandle.WriteLog("add", "行政组织写入成功！", parentIngErr, saveData)
					}
				}
			}

		}
	}
	//关闭已经弃用得行政组织
	var orgAdminAll []models.AdministrativeOrganization
	allErr := overall.CONSTANT_DB_HR.Where("`state` = 1").Find(&orgAdminAll).Error
	if allErr == nil {
		var eidtId []string
		for _, av := range orgAdminAll {
			if overallhandle.StringIsInMap(av.KingdeeId, kingDeeIdAry) == false {
				if overallhandle.StringIsInMap(av.KingdeeId, eidtId) == false {
					eidtId = append(eidtId, av.KingdeeId)
				}
			}
		}
		if len(eidtId) > 0 {
			orgAdminEditErr := overall.CONSTANT_DB_HR.Model(&models.AdministrativeOrganization{}).Where("`kingdeeid` IN ?", eidtId).Updates(map[string]interface{}{"state": 2}).Error
			if orgAdminEditErr == nil {
				overallhandle.WriteLog("edit", "禁用已不使用得行政组织成功！", orgAdminEditErr, eidtId)
			} else {
				overallhandle.WriteLog("edit", "禁用已不使用得行政组织失败！", orgAdminEditErr, eidtId)
			}
		}
	}
}

// 职位
func Position() {
	var orgInfo []positionType
	sendUrl := fmt.Sprintf("%v/person/position", overall.DockingKingdeeUrl)
	respBody, err := GetUrl(sendUrl)
	if err != nil {
		overallhandle.WriteLog("e", "未能获取到职位！", err)
		return
	}
	err = json.Unmarshal(respBody, &orgInfo)
	if err != nil {
		overallhandle.WriteLog("e", "职位映射错误！", err)
		return
	}
	overallhandle.WriteLog("i", "职位映射完成！", orgInfo)
	if len(orgInfo) < 0 {
		overallhandle.WriteLog("e", "金蝶对照数据！", orgInfo)
		return
	}

	var kingDeeIdAry []string
	//批量写入
	var batchPosition []models.Position
	//进行职位对照
	for _, v := range orgInfo {
		if overallhandle.StringIsInMap(v.Id, kingDeeIdAry) == false {
			kingDeeIdAry = append(kingDeeIdAry, v.Id)
		}
		// strconv.Atoi(v.FIsRespPosition)
		personInt64, _ := strconv.Atoi(v.FIsRespPosition)

		//获取职务信息
		var zhiwuCont models.Duties
		zhiwuCont.GetCont(map[string]interface{}{"kingdeeid": v.FJobID}, "id")

		//判断该项是否存在
		var positCont models.Position
		positContErr := positCont.GetCont(map[string]interface{}{"kingdeeid": v.Id})
		if positContErr == nil {
			//存在，进行更新
			isEdit := false
			saveData := overallhandle.MapOut()
			if v.Name != positCont.Name {
				saveData["name"] = v.Name
				isEdit = true
			}
			if positCont.State != 1 {
				saveData["state"] = 1
				isEdit = true
			}

			if v.Fnumber != positCont.Number {
				saveData["number"] = v.Fnumber
				isEdit = true
			}
			if zhiwuCont.Id != positCont.Duties {
				saveData["duties"] = zhiwuCont.Id
				isEdit = true
			}
			//获取行政组织
			var orgCont models.AdministrativeOrganization
			orgContErr := orgCont.GetCont(map[string]interface{}{"kingdeeid": v.FAdminOrgUnitID}, "id", "superior")
			if orgContErr == nil {
				if orgCont.Id != positCont.AdministrativeOrganization {
					saveData["administrative_organization"] = orgCont.Id
					saveData["department"] = overallhandle.GetGroupOrDepartPower(orgCont.Superior, 1)
					isEdit = true
				}
			}

			if isEdit == true {
				saveData["time"] = time.Now().Unix()
				editErr := positCont.EiteCont(map[string]interface{}{"id": positCont.Id}, saveData)
				if editErr == nil {
					overallhandle.WriteLog("edit", "职位更新成功！", editErr, v, saveData)
				} else {
					overallhandle.WriteLog("edit", "职位更新失败！", editErr, v, saveData)
				}
			}
		} else {
			//不存在，新增
			positCont.Number = v.Fnumber
			positCont.Name = v.Name
			positCont.KingdeeId = v.Id
			positCont.Time = time.Now().Unix()
			positCont.State = 1
			//获取行政组织
			var orgCont models.AdministrativeOrganization
			orgContErr := orgCont.GetCont(map[string]interface{}{"kingdeeid": v.FAdminOrgUnitID}, "id", "superior")
			if orgContErr == nil {
				positCont.AdministrativeOrganization = orgCont.Id
				positCont.Department = overallhandle.GetGroupOrDepartPower(orgCont.Superior, 1)
			}
			//获取知行学院及企业微信对照码
			var orgOldCont models.Position
			orgOldErr := overall.CONSTANT_DB_HR_Jin.Model(&models.Position{}).Select("school,person_in_charge").Where("`number` = ?", v.Fnumber).First(&orgOldCont).Error
			positCont.PersonInCharge = personInt64
			if orgOldErr == nil {
				if personInt64 != orgOldCont.PersonInCharge {
					if orgOldCont.PersonInCharge == 1 {
						positCont.PersonInCharge = orgOldCont.PersonInCharge
					}
				}
				positCont.School = orgOldCont.School
			}
			positCont.Duties = zhiwuCont.Id
			batchPosition = append(batchPosition, positCont)
			// if v.Id == "QBsfJ1fbSKW+3q6eOJltjHSuYS4=" {
			// 	fmt.Printf("positCont---->%v\n", positCont)
			// 	return
			// }

			if len(batchPosition)%100 == 0 {
				synPro.Add(1)
				go writePositis(batchPosition)
				var batchPositionNew []models.Position
				batchPosition = batchPositionNew

				// addErr := overall.CONSTANT_DB_HR.Create(&batchPosition).Error
				// if addErr == nil {
				// 	var batchPositionNew []models.Position
				// 	batchPosition = batchPositionNew
				// 	overallhandle.WriteLog("add", "职位写入成功！", addErr, batchPosition)
				// } else {
				// 	overallhandle.WriteLog("add", "职位写入失败！", addErr, batchPosition)
				// }
			}

		}
	}
	if len(batchPosition) > 0 {
		synPro.Add(1)
		go writePositis(batchPosition)
	}
	synPro.Wait()
	//职位上级校正
	var calibPositList []positionType
	for _, cv := range orgInfo {
		calibPositList = append(calibPositList, cv)
		if len(calibPositList)%100 == 0 {
			synPro.Add(1)
			go calibrationPosition(calibPositList)
			var calibPositListNew []positionType
			calibPositList = calibPositListNew
		}
	}

	if len(calibPositList) > 0 {
		synPro.Add(1)
		go calibrationPosition(calibPositList)
	}
	synPro.Wait()

	//关闭已经弃用得行政组织
	var orgAdminAll []models.Position
	allErr := overall.CONSTANT_DB_HR.Where("`state` = 1").Find(&orgAdminAll).Error
	if allErr == nil {
		var eidtId []string
		for _, av := range orgAdminAll {
			if overallhandle.StringIsInMap(av.KingdeeId, kingDeeIdAry) == false {
				if overallhandle.StringIsInMap(av.KingdeeId, eidtId) == false {
					eidtId = append(eidtId, av.KingdeeId)
				}
			}
		}
		if len(eidtId) > 0 {
			orgAdminEditErr := overall.CONSTANT_DB_HR.Model(&models.Position{}).Where("`kingdeeid` IN ?", eidtId).Updates(map[string]interface{}{"state": 2}).Error
			if orgAdminEditErr == nil {
				overallhandle.WriteLog("edit", "禁用已不使用得职位成功！", orgAdminEditErr, eidtId)
			} else {
				overallhandle.WriteLog("edit", "禁用已不使用得职位失败！", orgAdminEditErr, eidtId)
			}
		}
	}
}

// 协程写入职位
func writePositis(batchPositionNew []models.Position) {
	defer synPro.Done()
	if len(batchPositionNew) > 0 {
		addErr := overall.CONSTANT_DB_HR.Create(&batchPositionNew).Error
		if addErr == nil {
			overallhandle.WriteLog("add", "职位写入成功！", addErr, batchPositionNew)
		} else {
			overallhandle.WriteLog("add", "职位写入失败！", addErr, batchPositionNew)
		}
	}
}

// 协程职位校正
func calibrationPosition(orgInfo []positionType) {
	defer synPro.Done()
	if len(orgInfo) > 0 {
		for _, cv := range orgInfo {
			var parentContCorre models.Position
			parentErr := parentContCorre.GetCont(map[string]interface{}{"kingdeeid": cv.Id}, "`id`", "`superior`")
			if parentErr == nil {
				var orgCorrePrent models.Position
				orgCorrePrentErr := orgCorrePrent.GetCont(map[string]interface{}{"kingdeeid": cv.FParentID}, "id")
				if orgCorrePrentErr == nil {
					if parentContCorre.Superior != orgCorrePrent.Id {
						saveData := overallhandle.MapOut()
						saveData["superior"] = orgCorrePrent.Id
						saveData["time"] = time.Now().Unix()
						parentContCorre.EiteCont(map[string]interface{}{"id": parentContCorre.Id}, saveData)
					}
				}
			}
		}
	}
}