hr_server/api/version1/personnelapi/staffarchives.go

package personnelapi

import (
	"fmt"
	"hr_server/models"
	"hr_server/overall"
	"hr_server/overall/overallhandle"
	"strconv"
	"time"

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

//人员列表
func (s *StaffApi) ArchivesList(c *gin.Context) {
	var requestData peopleList
	c.ShouldBindJSON(&requestData)
	if requestData.Page < 0 {
		requestData.Page = 1
	}
	if requestData.PageSize < 0 {
		requestData.PageSize = 10
	}
	// var staffList []models.ManCont
	// var staffList []models.PersonArchives
	gormDb := overall.CONSTANT_DB_HR.Model(&models.PersonArchives{}).Select("`id`").Where("state = 1")

	if requestData.Number != "" {
		gormDb = gormDb.Where("number LIKE ?", "%"+requestData.Number+"%")
	}
	if requestData.Name != "" {
		gormDb = gormDb.Where("name LIKE ?", "%"+requestData.Name+"%")
	}
	if requestData.HireClass != 0 {
		gormDb = gormDb.Where("hire_class = ?", requestData.HireClass)
	}
	if requestData.Company != 0 {
		gormDb = gormDb.Where("company = ?", requestData.Company)
	}
	// if requestData.Deparment != "" {
	// 	gormDb = gormDb.Where("FIND_IN_SET(?,`deparment`)", requestData.Deparment)
	// }
	if requestData.AdminOrg != 0 {
		var idAry []int64
		idAry = overallhandle.GetDepartmentSun(requestData.AdminOrg, idAry)
		idAry = append(idAry, requestData.AdminOrg)
		gormDb = gormDb.Where("admin_org IN ?", idAry)
	}
	if requestData.Position != 0 {
		gormDb = gormDb.Where("position = ?", requestData.Position)
	}
	if requestData.EmpType != 0 {
		gormDb = gormDb.Where("emp_type = ?", requestData.EmpType)
	} else {
		gormDb = gormDb.Where("emp_type BETWEEN  ? AND ?", 1, 10)
	}
	if requestData.Role != "" {
		gormDb = gormDb.Where("FIND_IN_SET(?,`role`)", requestData.Role)
	}

	var total int64
	totalErr := gormDb.Count(&total).Error
	if totalErr != nil {
		total = 0
	}
	var idAry []int64
	// errGorm := gormDb.Order("company ASC,maindeparment ASC,admin_org ASC,position ASC").Limit(requestData.PageSize).Offset(overallhandle.LimitPage(requestData.Page, requestData.PageSize)).Find(&staffList).Error
	errGorm := gormDb.Order("company ASC,maindeparment ASC,admin_org ASC,position ASC").Limit(requestData.PageSize).Limit(requestData.PageSize).Offset(overallhandle.LimitPage(requestData.Page, requestData.PageSize)).Find(&idAry).Error
	var positionAry []peopleManOutList

	var manContList []models.ManCont
	errGorm = overall.CONSTANT_DB_HR.Where("`id` IN ?", idAry).Find(&manContList).Error

	for _, v := range manContList {
		var staffInfo peopleManOutList
		staffInfo.ManCont = v
		var getSpur models.Position
		getWhe := overallhandle.MapOut()
		getWhe["id"] = v.Position
		getSpur.GetCont(getWhe, "name")
		staffInfo.PositionName = getSpur.Name
		staffInfo.KeyStr = strconv.FormatInt(v.Key, 10)
		//公司
		if v.Company != 0 {
			var getSpurDepart models.AdministrativeOrganization
			getWheDepart := overallhandle.MapOut()
			getWheDepart["id"] = v.Company
			getSpurDepart.GetCont(getWheDepart, "name")
			staffInfo.CompanyName = getSpurDepart.Name
		}
		//主部门
		if v.MainDeparment != 0 {
			var getSpurDepartMain models.AdministrativeOrganization
			getWheDepartMain := overallhandle.MapOut()
			getWheDepartMain["id"] = v.MainDeparment
			getSpurDepartMain.GetCont(getWheDepartMain, "name")
			staffInfo.MainDeparmentName = getSpurDepartMain.Name
		}
		//二级著部门
		if v.SunMainDeparment != 0 {
			var sunMainDepart models.AdministrativeOrganization
			sunMainDepart.GetCont(map[string]interface{}{"`id`": v.SunMainDeparment}, "`name`")
			staffInfo.SunMainDeparmentName = sunMainDepart.Name
		}
		//获取部门
		// departmentAry := strings.Split(v.Deparment, ",")
		// if len(departmentAry) > 0 {
		// 	var departCont []getDepartmentInfo
		// 	departErr := overall.CONSTANT_DB_HR.Model(&models.AdministrativeOrganization{}).Select("id,number,name").Where("`id` IN ?", departmentAry).Order("`organization_type` ASC").Find(&departCont).Error

		// 	if departErr == nil {
		// 		var departNameAry []string
		// 		for _, d_v := range departCont {
		// 			departNameAry = append(departNameAry, d_v.Name)
		// 		}
		// 		if len(departNameAry) > 0 {
		// 			staffInfo.DeparmentName = strings.Join(departNameAry, " ")
		// 		}
		// 	}
		// }
		var orgContTypeCont models.OrgContType
		orgContTypeCont.GetCont(map[string]interface{}{"`id`": v.AdminOrg}, "`name`", "`level`")
		if orgContTypeCont.Level >= 6 {
			staffInfo.WorkPostName = orgContTypeCont.Name
		}

		positionAry = append(positionAry, staffInfo)

	}
	if errGorm != nil {
		overallhandle.Result(105, errGorm, c)
	} else {
		overallhandle.ResultList(0, requestData.Page, requestData.PageSize, total, int64(len(positionAry)), positionAry, c)
	}
}

//获取单个人员档案
//人员列表
func (s *StaffApi) ArchivesCon(c *gin.Context) {
	var requestData overallhandle.GetId
	c.ShouldBindJSON(&requestData)
	if requestData.IdStr == "" && requestData.Id == 0 {
		overallhandle.Result(101, requestData, c)
		return
	}
	if requestData.IdStr != "" {
		idInt, idErr := strconv.ParseInt(requestData.IdStr, 10, 64)
		if idErr == nil {
			requestData.Id = idInt
		}
	}
	var satffCont models.ManCont
	staffErr := satffCont.GetCont(map[string]interface{}{"`id`": requestData.Id})
	if staffErr != nil {
		overallhandle.Result(105, staffErr, c)
		return
	}
	var staffCenter staffArchivesCont
	staffCenter.ManCont = satffCont
	staffCenter.IdStr = strconv.FormatInt(satffCont.Id, 10)
	staffCenter.BirthdayTime = overallhandle.UnixTimeToDay(satffCont.Birthday, 14)               //生日
	staffCenter.IdCardStartTimeData = overallhandle.UnixTimeToDay(satffCont.Idcardstartdate, 14) //身份证有效期开始时间
	staffCenter.IdCardEndTimeData = overallhandle.UnixTimeToDay(satffCont.Idcardenddate, 14)     //身份证有效期结束时间
	staffCenter.EntrydateTime = overallhandle.UnixTimeToDay(satffCont.Entrydate, 14)             //入职日期
	staffCenter.PlanformaldateTime = overallhandle.UnixTimeToDay(satffCont.Planformaldate, 14)   //预计转正日期
	if satffCont.Company != 0 {
		var groupInfos models.AdministrativeOrganization
		groupInfos.GetCont(map[string]interface{}{"`id`": satffCont.Company}, "`name`")
		staffCenter.CompanyName = groupInfos.Name
	}
	if satffCont.MainDeparment != 0 {
		var demperMainInfos models.AdministrativeOrganization
		demperMainInfos.GetCont(map[string]interface{}{"`id`": satffCont.MainDeparment}, "`name`")
		staffCenter.MainDeparmentName = demperMainInfos.Name
	}
	if satffCont.AdminOrg != 0 {
		var adminOrg models.AdministrativeOrganization
		adminOrg.GetCont(map[string]interface{}{"`id`": satffCont.AdminOrg}, "`name`")
		staffCenter.AdminOrgName = adminOrg.Name
	}
	if satffCont.Position != 0 {
		var postisInfo models.Position
		postisInfo.GetCont(map[string]interface{}{"`id`": satffCont.Position}, "`name`")
		staffCenter.PositionName = postisInfo.Name
	}
	if satffCont.JobClass != 0 {
		var jobsInfo models.JobClass
		jobsInfo.GetCont(map[string]interface{}{"`id`": satffCont.JobClass}, "`name`")
		staffCenter.JobClassName = jobsInfo.Name
	}
	if satffCont.JobId != 0 {
		var dutiresInfo models.Duties
		dutiresInfo.GetCont(map[string]interface{}{"`id`": satffCont.JobId}, "`name`")
		staffCenter.JobIdName = dutiresInfo.Name
	}

	staffCenter.PoliticalOutlookName = overallhandle.PolitiToString(satffCont.PoliticalOutlook)
	//获取双职工信息
	synPro.Add(1)
	go func() {
		staffCenter.DoubleWorkerList = getDoubleWorkerCont(satffCont.Key) //双职工
	}()
	//紧急联系人
	synPro.Add(1)
	go func() {
		staffCenter.EmergencyContact = getEmercyCallMan(satffCont.Key) //紧急联系人
	}()
	//家庭成员
	synPro.Add(1)
	go func() {
		staffCenter.MemberOfFamily = getMemberOfFamily(satffCont.Key) //家庭成员
	}()
	//教育经历
	synPro.Add(1)
	go func() {
		staffCenter.EducationalExperience = getEducationalExperience(satffCont.Key) //教育经历
	}()
	//工作履历
	synPro.Add(1)
	go func() {
		staffCenter.WorkHistoryList = getWorkHistoryList(satffCont.Key) //工作履历
	}()
	//集团内工作履历
	synPro.Add(1)
	go func() {
		staffCenter.InsideWorkHistory = getGroupWorkHistoryList(satffCont.Key) //工作履历
	}()
	synPro.Wait()
	overallhandle.Result(0, staffCenter, c)
	return
}

//获取双职工信息
func getDoubleWorkerCont(key int64) (doubleworkerlist []DoubleWorkerCont) {
	defer synPro.Done()
	var dowWorkMan []models.DoubleWorker
	err := overall.CONSTANT_DB_HR.Select("`id`", "`number`", "`name`", "`company`", "`department`", "`position`", "`tel`").Where("`state` = 1 AND `key` = ?", key).Find(&dowWorkMan).Error
	if err == nil {

		for _, v := range dowWorkMan {
			var dwManCont DoubleWorkerCont
			dwManCont.Id = strconv.FormatInt(v.Id, 10)
			dwManCont.Number = v.Number         //工号
			dwManCont.Name = v.Name             //姓名
			dwManCont.Company = v.Company       //公司
			dwManCont.Department = v.Department //分厂（部室）
			dwManCont.Position = v.Position     //职位（岗位）
			dwManCont.Mobilephone = v.Tel       //联系电话
			doubleworkerlist = append(doubleworkerlist, dwManCont)
		}
	}
	return
}

//紧急联系人
func getEmercyCallMan(key int64) (callMan []emergencyContact) {
	defer synPro.Done()
	var dowWorkMan []models.EmergencyContact
	err := overall.CONSTANT_DB_HR.Select("`id`", "`name`", "`relationship`", "`tel`").Where("`state` = 1 AND `key` = ?", key).Find(&dowWorkMan).Error
	if err == nil {

		for _, v := range dowWorkMan {
			var dwManCont emergencyContact //
			dwManCont.Id = strconv.FormatInt(v.Id, 10)
			dwManCont.Name = v.Name                 //姓名
			dwManCont.Relationship = v.Relationship //与紧急联系人
			dwManCont.Mobilephone = v.Tel           //联系电话
			callMan = append(callMan, dwManCont)
		}
	}
	return
}

//获取家庭成员
func getMemberOfFamily(key int64) (callMan []memberOfFamily) {
	defer synPro.Done()
	var dowWorkMan []models.FamilyMembers
	err := overall.CONSTANT_DB_HR.Select("`id`", "`name`", "`relation`", "`company`", "`deparment`", "`postnme`", "`tel`,`political_outlook`").Where("`state` = 1 AND `key` = ?", key).Find(&dowWorkMan).Error
	if err == nil {
		for _, v := range dowWorkMan {
			var dwManCont memberOfFamily                    //工号
			dwManCont.Name = v.Name                         //姓名
			dwManCont.Relationship = v.Relationship         //与紧急联系人
			dwManCont.Mobilephone = v.Tel                   //联系电话
			dwManCont.Company = v.Company                   //公司
			dwManCont.Department = v.Deparment              //分厂（部室）
			dwManCont.Position = v.Postnme                  //职位（岗位）
			dwManCont.PoliticalOutlook = v.PoliticalOutlook //政治面貌
			dwManCont.IdStr = strconv.FormatInt(v.Id, 10)
			callMan = append(callMan, dwManCont)
		}
	}
	return
}

//获取教育经历
func getEducationalExperience(key int64) (callMan []educatExp) {
	defer synPro.Done()
	var dowWorkMan []models.PersonnelEducation
	err := overall.CONSTANT_DB_HR.Select("`id`", "`education`", "`graduation_school`", "`subject`", "`admission_time`", "`graduation_time`", "`level`,`academic_degree`").Where("`state` = 1 AND `key` = ?", key).Find(&dowWorkMan).Error
	if err == nil {
		for _, v := range dowWorkMan {
			var dwManCont educatExp                                                      //
			dwManCont.GraduationSchool = v.GraduationSchool                              //毕业学校
			dwManCont.Subject = v.Subject                                                //专业
			dwManCont.Education = v.Education                                            //学历
			dwManCont.AdmissionTime = overallhandle.UnixTimeToDay(v.AdmissionTime, 14)   //入学时间
			dwManCont.GraduationTime = overallhandle.UnixTimeToDay(v.GraduationTime, 14) //毕业时间
			dwManCont.AcademicDegree = getXueWei(v.AcademicDegree)                       //学位
			dwManCont.AcademicDegreeId = v.AcademicDegree
			dwManCont.Level = getXueWeiClass(v.Level)
			dwManCont.LevelId = v.Level //学历类型
			dwManCont.Id = strconv.FormatInt(v.Id, 10)
			callMan = append(callMan, dwManCont)
		}
	}
	return
}

//学位
func getXueWei(id int) string {
	switch id {
	case 1:
		return "无"
	case 2:
		return "学士"
	case 3:
		return "硕士"
	case 4:
		return "博士"
	default:
		return "无"
	}
	return "无"
}

//学历类型
func getXueWeiClass(id int) string {
	switch id {
	case 2:
		return "第一学历"
	case 3:
		return "最高学历"
	default:
		return "普通"
	}
	return "普通"
}

//工作履历
func getWorkHistoryList(key int64) (workHisList []workHistoryAry) {
	defer synPro.Done()
	var workHisContList []models.WorkHistory
	workHisContListErr := overall.CONSTANT_DB_HR.Where("`state` = 1 AND `key` = ?", key).Find(&workHisContList).Error
	if workHisContListErr == nil {
		for _, v := range workHisContList {
			var workCont workHistoryAry
			workCont.Company = v.Company                                      //公司
			workCont.Department = v.Deparment                                 //部门
			workCont.Position = v.Job                                         //职务
			workCont.EntryTime = overallhandle.UnixTimeToDay(v.EntryTime, 14) //入职时间
			workCont.LeaveDate = overallhandle.UnixTimeToDay(v.Leavedate, 14) //离职日期
			workCont.Witness = v.Witness                                      //证明人
			workCont.WitnessTel = v.WitnessTel                                //证明人电话
			workCont.Remarks = v.Remarks                                      //备注
			workHisList = append(workHisList, workCont)
		}
	}
	return
}

//添加双职工
func (s *StaffApi) AddDoubleWorkerApi(c *gin.Context) {
	var requestData DoubleWorkerCont
	c.ShouldBindJSON(&requestData)
	// if err != nil {
	// 	overallhandle.Result(100, err, c)
	// 	return
	// }
	if requestData.Id == "" {
		overallhandle.Result(101, requestData.Id, c, "参数错误")
		return
	}
	if requestData.Name == "" {
		overallhandle.Result(101, requestData.Name, c, "请输入姓名")
		return
	}
	if requestData.Mobilephone == "" {
		overallhandle.Result(101, requestData.Mobilephone, c, "请输入联系方式")
		return
	}
	var manCont models.PersonArchives
	manCont.GetCont(map[string]interface{}{"`key`": requestData.Id}, "`number`")
	var doubleWorkInfo models.DoubleWorker
	doubleWorkInfo.Number = manCont.Number
	doubleWorkInfo.Name = requestData.Name
	doubleWorkInfo.Company = requestData.Company
	doubleWorkInfo.Department = requestData.Department
	doubleWorkInfo.Position = requestData.Position
	doubleWorkInfo.Tel = requestData.Mobilephone
	doubleWorkInfo.Time = time.Now().Unix()
	doubleWorkInfo.State = 1
	keyInt, _ := strconv.ParseInt(requestData.Id, 10, 64)
	doubleWorkInfo.Key = keyInt
	addErr := overall.CONSTANT_DB_HR.Create(&doubleWorkInfo).Error
	if addErr != nil {
		overallhandle.Result(104, addErr, c)
		return
	}
	overallhandle.Result(0, addErr, c)
}

//编辑双职工
func (s *StaffApi) EidtDoubleWorkerApi(c *gin.Context) {
	var requestData DoubleWorkerCont
	c.ShouldBindJSON(&requestData)
	// if err != nil {
	// 	overallhandle.Result(100, err, c)
	// 	return
	// }
	if requestData.Id == "" {
		overallhandle.Result(101, requestData.Id, c)
		return
	}
	var doubleWorkCont models.DoubleWorker
	wErr := doubleWorkCont.GetCont(map[string]interface{}{"`id`": requestData.Id})
	if wErr != nil {
		overallhandle.Result(107, requestData.Id, c)
		return
	}
	saveData := overallhandle.MapOut()
	if requestData.Name != "" && requestData.Name != doubleWorkCont.Name {
		saveData["name"] = requestData.Name
	}
	if requestData.Company != "" && requestData.Company != doubleWorkCont.Company {
		saveData["company"] = requestData.Company
	}
	if requestData.Department != "" && requestData.Department != doubleWorkCont.Department {
		saveData["department"] = requestData.Department
	}
	if requestData.Position != "" && requestData.Position != doubleWorkCont.Position {
		saveData["position"] = requestData.Position
	}

	if requestData.Mobilephone != "" && requestData.Mobilephone != doubleWorkCont.Tel {
		saveData["tel"] = requestData.Mobilephone
	}
	if len(saveData) > 0 {
		saveData["time"] = time.Now().Unix()
		var eidtCont models.DoubleWorker
		eidtErr := eidtCont.EiteCont(map[string]interface{}{"`id`": requestData.Id}, saveData)
		if eidtErr == nil {
			overallhandle.Result(0, saveData, c)
		} else {
			overallhandle.Result(106, eidtErr, c)
		}
	} else {
		overallhandle.Result(0, saveData, c)
	}
}

//编辑双职工状态
func (s *StaffApi) EidtDoubleWorkerState(c *gin.Context) {
	var requestData eidtWorkState
	c.ShouldBindJSON(&requestData)
	if requestData.Id == "" {
		overallhandle.Result(101, requestData.Id, c)
		return
	}
	var doubleWorkCont models.DoubleWorker
	wErr := doubleWorkCont.GetCont(map[string]interface{}{"`id`": requestData.Id})
	if wErr != nil {
		overallhandle.Result(107, requestData.Id, c)
		return
	}
	if requestData.State == 0 {
		requestData.State = 1
	}
	if requestData.IsDel <= 1 {
		saveData := overallhandle.MapOut()
		saveData["time"] = time.Now().Unix()
		saveData["state"] = requestData.State
		var eidtCont models.DoubleWorker
		eidtErr := eidtCont.EiteCont(map[string]interface{}{"`id`": requestData.Id}, saveData)
		if eidtErr == nil {
			overallhandle.Result(0, saveData, c)
		} else {
			overallhandle.Result(106, eidtErr, c)
		}
	} else {
		if requestData.State == 3 {
			delErr := overall.CONSTANT_DB_HR.Where(map[string]interface{}{"`id`": requestData.Id}).Delete(&models.DoubleWorker{}).Error
			if delErr == nil {
				overallhandle.Result(0, delErr, c)
			} else {
				overallhandle.Result(108, delErr, c)
			}
		} else {
			saveData := overallhandle.MapOut()
			saveData["time"] = time.Now().Unix()
			saveData["state"] = requestData.State
			var eidtCont models.DoubleWorker
			eidtErr := eidtCont.EiteCont(map[string]interface{}{"`id`": requestData.Id}, saveData)
			if eidtErr == nil {
				overallhandle.Result(0, saveData, c)
			} else {
				overallhandle.Result(106, eidtErr, c)
			}
		}
	}
}

//添加紧急联系人
func (s *StaffApi) AddEmercyCall(c *gin.Context) {
	var requestData addEmergencyContact
	c.ShouldBindJSON(&requestData)
	if requestData.Id == "" || len(requestData.List) <= 0 {
		overallhandle.Result(101, requestData, c)
		return
	}
	keyInt, keyErr := strconv.ParseInt(requestData.Id, 10, 64)
	if keyErr != nil {
		overallhandle.Result(100, keyErr, c)
		return
	}
	var manCont models.PersonArchives
	manErr := manCont.GetCont(map[string]interface{}{"`key`": keyInt}, "`number`")
	if manErr != nil {
		overallhandle.Result(107, manErr, c)
		return
	}
	var emerContList []models.EmergencyContact
	isWrite := 1
	for _, v := range requestData.List {
		if v.Name != "" && v.Mobilephone != "" {
			var emerContCont models.EmergencyContact
			emerContCont.Number = manCont.Number       //员工工号;index"`
			emerContCont.Name = v.Name                 //紧急联系人姓名"`
			emerContCont.Relationship = v.Relationship //与紧急联系人关系"`
			emerContCont.Tel = v.Mobilephone           //紧急联系人电话"`
			emerContCont.Time = time.Now().Unix()      //创建时间"`
			emerContCont.State = 1                     //状态（1：启用；2：禁用；3：删除）"`
			emerContCont.Key = keyInt                  //
			emerContList = append(emerContList, emerContCont)
		} else {
			isWrite = 2
		}
	}
	if isWrite != 1 {
		overallhandle.Result(100, requestData.List, c)
		return
	}
	if len(emerContList) <= 0 {
		overallhandle.Result(1, emerContList, c, "没有要添加的数据！")
		return
	}
	addErr := overall.CONSTANT_DB_HR.Create(&emerContList).Error
	if addErr != nil {
		overallhandle.Result(104, requestData.List, c)
	} else {
		overallhandle.Result(0, addErr, c)
	}
}

//编辑紧急联系人
func (s *StaffApi) EditEmercyCall(c *gin.Context) {
	var requestData emergencyContact
	c.ShouldBindJSON(&requestData)
	if requestData.Id == "" {
		overallhandle.Result(101, requestData, c)
		return
	}
	var enerCont models.EmergencyContact
	err := enerCont.GetCont(map[string]interface{}{"`id`": requestData.Id}, "`id`", "`name`", "`relationship`", "`tel`")
	if err != nil {
		overallhandle.Result(105, err, c)
		return
	}
	saveData := overallhandle.MapOut()
	if requestData.Name != "" && requestData.Name != enerCont.Name {
		saveData["name"] = requestData.Name
	}
	if requestData.Relationship != "" && requestData.Relationship != enerCont.Relationship {
		saveData["relationship"] = requestData.Relationship
	}
	if requestData.Mobilephone != "" && requestData.Mobilephone != enerCont.Tel {
		saveData["tel"] = requestData.Mobilephone
	}
	if len(saveData) > 0 {
		saveData["time"] = time.Now().Unix()
		eidtErr := enerCont.EiteCont(map[string]interface{}{"`id`": requestData.Id}, saveData)
		if eidtErr != nil {
			overallhandle.Result(106, eidtErr, c)
		} else {
			overallhandle.Result(0, eidtErr, c)
		}
	} else {
		overallhandle.Result(0, saveData, c)
	}
}

//编辑紧急联系人
func (s *StaffApi) EditEmercyCallState(c *gin.Context) {
	var requestData eidtWorkState
	c.ShouldBindJSON(&requestData)
	if requestData.Id == "" {
		overallhandle.Result(101, requestData.Id, c)
		return
	}
	var doubleWorkCont models.EmergencyContact
	wErr := doubleWorkCont.GetCont(map[string]interface{}{"`id`": requestData.Id})
	if wErr != nil {
		overallhandle.Result(107, requestData.Id, c)
		return
	}
	if requestData.State == 0 {
		requestData.State = 1
	}
	if requestData.IsDel <= 1 {
		saveData := overallhandle.MapOut()
		saveData["time"] = time.Now().Unix()
		saveData["state"] = requestData.State
		var eidtCont models.EmergencyContact
		eidtErr := eidtCont.EiteCont(map[string]interface{}{"`id`": requestData.Id}, saveData)
		if eidtErr == nil {
			overallhandle.Result(0, saveData, c)
		} else {
			overallhandle.Result(106, eidtErr, c)
		}
	} else {
		if requestData.State == 3 {
			delErr := overall.CONSTANT_DB_HR.Where(map[string]interface{}{"`id`": requestData.Id}).Delete(&models.EmergencyContact{}).Error
			if delErr == nil {
				overallhandle.Result(0, delErr, c)
			} else {
				overallhandle.Result(108, delErr, c)
			}
		} else {
			saveData := overallhandle.MapOut()
			saveData["time"] = time.Now().Unix()
			saveData["state"] = requestData.State
			var eidtCont models.EmergencyContact
			eidtErr := eidtCont.EiteCont(map[string]interface{}{"`id`": requestData.Id}, saveData)
			if eidtErr == nil {
				overallhandle.Result(0, saveData, c)
			} else {
				overallhandle.Result(106, eidtErr, c)
			}
		}
	}
}

//添加家庭成员
func (s *StaffApi) AddFamilyMembers(c *gin.Context) {
	var requestData addFamilyPeople
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		overallhandle.Result(101, err, c)
		return
	}
	if requestData.Id == "" || len(requestData.List) <= 0 {
		overallhandle.Result(101, requestData, c)
		return
	}
	keyInt, keyErr := strconv.ParseInt(requestData.Id, 10, 64)
	if keyErr != nil {
		overallhandle.Result(100, keyErr, c)
		return
	}
	var manCont models.PersonArchives
	manErr := manCont.GetCont(map[string]interface{}{"`key`": keyInt}, "`number`")
	if manErr != nil {
		overallhandle.Result(107, manErr, c)
		return
	}
	var emerContList []models.FamilyMembers
	isWrite := 1
	for _, v := range requestData.List {
		if v.Name != "" && v.Mobilephone != "" {
			var emerContCont models.FamilyMembers
			emerContCont.Number = manCont.Number
			emerContCont.Relationship = v.Relationship //与家属关系"`
			emerContCont.Name = v.Name                 //家属姓名"`
			emerContCont.Company = v.Company
			emerContCont.Deparment = v.Department
			emerContCont.Postnme = v.Position
			emerContCont.Tel = v.Mobilephone //家属电话"`
			poloutlook := v.PoliticalOutlook
			if poloutlook == 0 {
				poloutlook = 1
			}
			emerContCont.PoliticalOutlook = poloutlook
			emerContCont.Time = time.Now().Unix() //创建时间"`
			emerContCont.State = 1                //状态（1：启用；2：禁用；3：删除）"`
			emerContCont.Key = keyInt             //
			emerContList = append(emerContList, emerContCont)
		} else {
			isWrite = 2
		}
	}
	if isWrite != 1 {
		overallhandle.Result(100, requestData.List, c)
		return
	}
	if len(emerContList) <= 0 {
		overallhandle.Result(1, emerContList, c, "没有要添加的数据！")
		return
	}
	addErr := overall.CONSTANT_DB_HR.Create(&emerContList).Error
	if addErr != nil {
		overallhandle.Result(104, requestData.List, c)
	} else {
		overallhandle.Result(0, addErr, c)
	}
}

//编辑家属信息
func (s *StaffApi) EditFamilyMembers(c *gin.Context) {
	var requestData memberOfFamily
	c.ShouldBindJSON(&requestData)
	if requestData.Id == "" {
		overallhandle.Result(101, requestData, c)
		return
	}
	var enerCont models.FamilyMembers
	err := enerCont.GetCont(map[string]interface{}{"`id`": requestData.Id})
	if err != nil {
		overallhandle.Result(105, err, c)
		return
	}
	saveData := overallhandle.MapOut()
	if requestData.Name != "" && requestData.Name != enerCont.Name {
		saveData["name"] = requestData.Name
	}
	if requestData.Relationship != "" && requestData.Relationship != enerCont.Relationship {
		saveData["relation"] = requestData.Relationship
	}
	if requestData.Mobilephone != "" && requestData.Mobilephone != enerCont.Tel {
		saveData["tel"] = requestData.Mobilephone
	}

	if requestData.Company != "" && requestData.Company != enerCont.Company {
		saveData["company"] = requestData.Company
	}
	if requestData.Department != "" && requestData.Department != enerCont.Deparment {
		saveData["deparment"] = requestData.Department
	}
	if requestData.Position != "" && requestData.Position != enerCont.Postnme {
		saveData["postnme"] = requestData.Position
	}
	if requestData.PoliticalOutlook != 0 && requestData.PoliticalOutlook != enerCont.PoliticalOutlook {
		saveData["political_outlook"] = requestData.PoliticalOutlook
	}
	if len(saveData) > 0 {
		saveData["time"] = time.Now().Unix()
		eidtErr := enerCont.EiteCont(map[string]interface{}{"`id`": requestData.Id}, saveData)
		if eidtErr != nil {
			overallhandle.Result(106, eidtErr, c)
		} else {
			overallhandle.Result(0, eidtErr, c)
		}
	} else {
		overallhandle.Result(0, saveData, c)
	}
}

//编辑家属状态
func (s *StaffApi) EditFamilyMembersSatte(c *gin.Context) {
	var requestData eidtWorkState
	c.ShouldBindJSON(&requestData)
	if requestData.Id == "" {
		overallhandle.Result(101, requestData.Id, c)
		return
	}
	var doubleWorkCont models.FamilyMembers
	wErr := doubleWorkCont.GetCont(map[string]interface{}{"`id`": requestData.Id})
	if wErr != nil {
		overallhandle.Result(107, requestData.Id, c)
		return
	}
	if requestData.State == 0 {
		requestData.State = 1
	}
	if requestData.IsDel <= 1 {
		saveData := overallhandle.MapOut()
		saveData["time"] = time.Now().Unix()
		saveData["state"] = requestData.State
		var eidtCont models.FamilyMembers
		eidtErr := eidtCont.EiteCont(map[string]interface{}{"`id`": requestData.Id}, saveData)
		if eidtErr == nil {
			overallhandle.Result(0, saveData, c)
		} else {
			overallhandle.Result(106, eidtErr, c)
		}
	} else {
		if requestData.State == 3 {
			delErr := overall.CONSTANT_DB_HR.Where(map[string]interface{}{"`id`": requestData.Id}).Delete(&models.FamilyMembers{}).Error
			if delErr == nil {
				overallhandle.Result(0, delErr, c)
			} else {
				overallhandle.Result(108, delErr, c)
			}
		} else {
			saveData := overallhandle.MapOut()
			saveData["time"] = time.Now().Unix()
			saveData["state"] = requestData.State
			var eidtCont models.FamilyMembers
			eidtErr := eidtCont.EiteCont(map[string]interface{}{"`id`": requestData.Id}, saveData)
			if eidtErr == nil {
				overallhandle.Result(0, saveData, c)
			} else {
				overallhandle.Result(106, eidtErr, c)
			}
		}
	}
}

//添加教育经历
func (s *StaffApi) AddEducationalExperience(c *gin.Context) {
	var requestData addExpToSchool
	c.ShouldBindJSON(&requestData)
	// err := c.ShouldBindJSON(&requestData)
	// if err != nil {
	// 	overallhandle.Result(101, err, c)
	// 	return
	// }
	if requestData.Id == "" || len(requestData.List) <= 0 {
		overallhandle.Result(101, requestData, c)
		return
	}
	keyInt, keyErr := strconv.ParseInt(requestData.Id, 10, 64)
	if keyErr != nil {
		overallhandle.Result(100, keyErr, c)
		return
	}
	var manCont models.PersonArchives
	manErr := manCont.GetCont(map[string]interface{}{"`key`": keyInt}, "`number`")
	if manErr != nil {
		overallhandle.Result(107, manErr, c)
		return
	}
	var emerContList []models.PersonnelEducation
	isWrite := 1
	for _, v := range requestData.List {
		if v.GraduationSchool != "" && v.Subject != "" {
			var emerContCont models.PersonnelEducation
			emerContCont.Number = manCont.Number
			eduCation := v.Education
			if eduCation == 0 {
				eduCation = 1
			}
			emerContCont.Education = eduCation
			emerContCont.GraduationSchool = v.GraduationSchool
			emerContCont.Subject = v.Subject
			entranceTimeFirst := time.Now().Unix()
			if v.AdmissionTime != "" {
				entranceTimeFirst, _ = overallhandle.DateToTimeStamp(fmt.Sprintf("%v 00:00:00", v.AdmissionTime))
			}
			emerContCont.AdmissionTime = entranceTimeFirst //  入学时间"`
			graduationTimef := time.Now().Unix()
			if v.GraduationTime != "" {
				graduationTimef, _ = overallhandle.DateToTimeStamp(fmt.Sprintf("%v 00:00:00", v.GraduationTime))
			}
			emerContCont.GraduationTime = graduationTimef //  毕业时间"`
			emerContCont.Time = time.Now().Unix()         //  写入时间"`
			acaLeve, _ := strconv.Atoi(v.AcademicDegree)
			if acaLeve == 0 {
				acaLeve = 1
			}
			emerContCont.AcademicDegree = acaLeve
			emerContCont.Time = time.Now().Unix() //创建时间"`
			emerContCont.State = 1                //状态（1：启用；2：禁用；3：删除）"`
			emerContCont.Key = keyInt             //
			switch v.Level {
			case "2":
				var editPerCont models.PersonnelEducation
				editPerCont.EiteCont(map[string]interface{}{"`key`": keyInt, "`level`": 2}, map[string]interface{}{"`level`": 1})
				emerContCont.Level = 2
			case "3":
				var editPerCont models.PersonnelEducation
				editPerCont.EiteCont(map[string]interface{}{"`key`": keyInt, "`level`": 3}, map[string]interface{}{"`level`": 1})
				emerContCont.Level = 3
			default:
				emerContCont.Level = 1
			}
			emerContList = append(emerContList, emerContCont)
		} else {
			isWrite = 2
		}
	}
	if isWrite != 1 {
		overallhandle.Result(100, requestData.List, c)
		return
	}
	if len(emerContList) <= 0 {
		overallhandle.Result(1, emerContList, c, "没有要添加的数据！")
		return
	}
	addErr := overall.CONSTANT_DB_HR.Create(&emerContList).Error
	if addErr != nil {
		overallhandle.Result(104, requestData.List, c)
	} else {
		overallhandle.Result(0, addErr, c)
	}
}

//编辑教育经历
func (s *StaffApi) EditEducationalExperience(c *gin.Context) {
	var requestData editExpToSchool
	c.ShouldBindJSON(&requestData)
	if requestData.Id == "" {
		overallhandle.Result(101, requestData, c)
		return
	}
	var enerCont models.PersonnelEducation
	err := enerCont.GetCont(map[string]interface{}{"`id`": requestData.Id})
	if err != nil {
		overallhandle.Result(105, err, c)
		return
	}
	saveData := overallhandle.MapOut()
	if requestData.GraduationSchool != "" && requestData.GraduationSchool != enerCont.GraduationSchool {
		saveData["graduation_school"] = requestData.GraduationSchool
	}
	if requestData.Subject != "" && requestData.Subject != enerCont.Subject {
		saveData["subject"] = requestData.Subject
	}
	if requestData.Education != 0 && requestData.Education != enerCont.Education {
		saveData["education"] = requestData.Education
	}

	if requestData.AdmissionTime != "" {
		admissionTimeInt, _ := overallhandle.DateToTimeStamp(fmt.Sprintf("%v 00:00:00", requestData.AdmissionTime))
		if admissionTimeInt != enerCont.AdmissionTime {
			saveData["admission_time"] = admissionTimeInt
		}

	}
	if requestData.GraduationTime != "" {
		graduationTimeInt, _ := overallhandle.DateToTimeStamp(fmt.Sprintf("%v 00:00:00", requestData.GraduationTime))
		if graduationTimeInt != enerCont.GraduationTime {
			saveData["graduation_time"] = graduationTimeInt
		}

	}
	if requestData.AcademicDegree != "" {
		acaLeve, _ := strconv.Atoi(requestData.AcademicDegree)
		if acaLeve != enerCont.AcademicDegree {
			saveData["academic_degree"] = acaLeve
		}
	}

	if requestData.Level != "" {
		levelInt, _ := strconv.Atoi(requestData.Level)
		if levelInt != enerCont.Level {
			switch levelInt {
			case 2:
				var editPerCont models.PersonnelEducation
				editPerCont.EiteCont(map[string]interface{}{"`key`": enerCont.Key, "`level`": 2}, map[string]interface{}{"`level`": 1})
				saveData["academic_degree"] = 2
			case 3:
				var editPerCont models.PersonnelEducation
				editPerCont.EiteCont(map[string]interface{}{"`key`": enerCont.Key, "`level`": 3}, map[string]interface{}{"`level`": 1})
				saveData["academic_degree"] = 3
			default:
				saveData["academic_degree"] = 1
			}

		}
	}

	if len(saveData) > 0 {
		saveData["time"] = time.Now().Unix()
		eidtErr := enerCont.EiteCont(map[string]interface{}{"`id`": requestData.Id}, saveData)
		if eidtErr != nil {
			overallhandle.Result(106, eidtErr, c)
		} else {
			overallhandle.Result(0, eidtErr, c)
		}
	} else {
		overallhandle.Result(0, saveData, c)
	}
}

//编辑教育经历状态
func (s *StaffApi) EditEduExpState(c *gin.Context) {
	var requestData eidtWorkState
	c.ShouldBindJSON(&requestData)
	if requestData.Id == "" {
		overallhandle.Result(101, requestData.Id, c)
		return
	}
	var doubleWorkCont models.PersonnelEducation
	wErr := doubleWorkCont.GetCont(map[string]interface{}{"`id`": requestData.Id})
	if wErr != nil {
		overallhandle.Result(107, requestData.Id, c)
		return
	}
	if requestData.State == 0 {
		requestData.State = 1
	}
	if requestData.IsDel <= 1 {
		saveData := overallhandle.MapOut()
		saveData["time"] = time.Now().Unix()
		saveData["state"] = requestData.State
		var eidtCont models.PersonnelEducation
		eidtErr := eidtCont.EiteCont(map[string]interface{}{"`id`": requestData.Id}, saveData)
		if eidtErr == nil {
			overallhandle.Result(0, saveData, c)
		} else {
			overallhandle.Result(106, eidtErr, c)
		}
	} else {
		if requestData.State == 3 {
			delErr := overall.CONSTANT_DB_HR.Where(map[string]interface{}{"`id`": requestData.Id}).Delete(&models.PersonnelEducation{}).Error
			if delErr == nil {
				overallhandle.Result(0, delErr, c)
			} else {
				overallhandle.Result(108, delErr, c)
			}
		} else {
			saveData := overallhandle.MapOut()
			saveData["time"] = time.Now().Unix()
			saveData["state"] = requestData.State
			var eidtCont models.PersonnelEducation
			eidtErr := eidtCont.EiteCont(map[string]interface{}{"`id`": requestData.Id}, saveData)
			if eidtErr == nil {
				overallhandle.Result(0, saveData, c)
			} else {
				overallhandle.Result(106, eidtErr, c)
			}
		}
	}
}

//添加工作履历
func (s *StaffApi) AddWorkHistoryCont(c *gin.Context) {
	var requestData addWorkHistory
	c.ShouldBindJSON(&requestData)
	// err := c.ShouldBindJSON(&requestData)
	// if err != nil {
	// 	overallhandle.Result(101, err, c)
	// 	return
	// }
	if requestData.Id == "" || len(requestData.List) <= 0 {
		overallhandle.Result(101, requestData, c)
		return
	}
	keyInt, keyErr := strconv.ParseInt(requestData.Id, 10, 64)
	if keyErr != nil {
		overallhandle.Result(100, keyErr, c)
		return
	}
	var manCont models.PersonArchives
	manErr := manCont.GetCont(map[string]interface{}{"`key`": keyInt}, "`number`")
	if manErr != nil {
		overallhandle.Result(107, manErr, c)
		return
	}
	var emerContList []models.WorkHistory
	isWrite := 1
	for _, v := range requestData.List {
		if v.Company != "" && v.Department != "" {
			var emerContCont models.WorkHistory
			emerContCont.Number = manCont.Number
			emerContCont.Key = keyInt

			emerContCont.Company = v.Company      //公司"`
			emerContCont.Deparment = v.Department //部门"`
			emerContCont.Job = v.Position         //职务"`
			joinTime := time.Now().Unix()
			if v.EntryTime != "" {
				joinTime, _ = overallhandle.DateToTimeStamp(fmt.Sprintf("%v 00:00:00", v.EntryTime))
			}
			emerContCont.EntryTime = joinTime //入职时间"`
			outTime := time.Now().Unix()
			if v.LeaveDate != "" {
				outTime, _ = overallhandle.DateToTimeStamp(fmt.Sprintf("%v 00:00:00", v.LeaveDate))
			}
			emerContCont.Leavedate = outTime       //离职日期"`
			emerContCont.Witness = v.Witness       //证明人"`
			emerContCont.WitnessTel = v.WitnessTel //证明人电话"`
			emerContCont.Remarks = v.Remarks       //备注"`
			emerContCont.Time = time.Now().Unix()  //创建时间"`
			emerContCont.State = 1                 //状态（1：启用；2：禁用；3：删除）"`

			emerContList = append(emerContList, emerContCont)
		} else {
			isWrite = 2
		}
	}
	if isWrite != 1 {
		overallhandle.Result(100, requestData.List, c)
		return
	}
	if len(emerContList) <= 0 {
		overallhandle.Result(1, emerContList, c, "没有要添加的数据！")
		return
	}
	addErr := overall.CONSTANT_DB_HR.Create(&emerContList).Error
	if addErr != nil {
		overallhandle.Result(104, requestData.List, c)
	} else {
		overallhandle.Result(0, addErr, c)
	}
}

//编辑工作履历
func (s *StaffApi) EditWorkHistoryCont(c *gin.Context) {
	var requestData editWorkHistory
	c.ShouldBindJSON(&requestData)
	if requestData.Id == "" {
		overallhandle.Result(101, requestData, c)
		return
	}
	var enerCont models.WorkHistory
	err := enerCont.GetCont(map[string]interface{}{"`id`": requestData.Id})
	if err != nil {
		overallhandle.Result(105, err, c)
		return
	}
	saveData := overallhandle.MapOut()
	if requestData.Company != "" && requestData.Company != enerCont.Company {
		saveData["company"] = requestData.Company
	}
	if requestData.Department != "" && requestData.Department != enerCont.Deparment {
		saveData["deparment"] = requestData.Department
	}
	if requestData.Position != "" && requestData.Position != enerCont.Job {
		saveData["job"] = requestData.Position
	}

	if requestData.EntryTime != "" {
		EntryTimeInt, _ := overallhandle.DateToTimeStamp(fmt.Sprintf("%v 00:00:00", requestData.EntryTime))
		if EntryTimeInt != enerCont.EntryTime {
			saveData["entry_time"] = EntryTimeInt
		}

	}
	if requestData.LeaveDate != "" {
		LeaveDateInt, _ := overallhandle.DateToTimeStamp(fmt.Sprintf("%v 00:00:00", requestData.LeaveDate))
		if LeaveDateInt != enerCont.Leavedate {
			saveData["leavedate"] = LeaveDateInt
		}
	}

	if requestData.Witness != "" && requestData.Witness != enerCont.Witness {
		saveData["witness"] = requestData.Witness
	}
	if requestData.WitnessTel != "" && requestData.WitnessTel != enerCont.WitnessTel {
		saveData["witness_tel"] = requestData.WitnessTel
	}
	if requestData.Remarks != "" && requestData.Remarks != enerCont.Remarks {
		saveData["remarks"] = requestData.Remarks
	}

	if len(saveData) > 0 {
		saveData["time"] = time.Now().Unix()
		eidtErr := enerCont.EiteCont(map[string]interface{}{"`id`": requestData.Id}, saveData)
		if eidtErr != nil {
			overallhandle.Result(106, eidtErr, c)
		} else {
			overallhandle.Result(0, eidtErr, c)
		}
	} else {
		overallhandle.Result(0, saveData, c)
	}
}

//编辑工作履历状态
func (s *StaffApi) EditWorkHistoryState(c *gin.Context) {
	var requestData eidtWorkState
	c.ShouldBindJSON(&requestData)
	if requestData.Id == "" {
		overallhandle.Result(101, requestData.Id, c)
		return
	}
	var doubleWorkCont models.WorkHistory
	wErr := doubleWorkCont.GetCont(map[string]interface{}{"`id`": requestData.Id})
	if wErr != nil {
		overallhandle.Result(107, requestData.Id, c)
		return
	}
	if requestData.State == 0 {
		requestData.State = 1
	}
	if requestData.IsDel <= 1 {
		saveData := overallhandle.MapOut()
		saveData["time"] = time.Now().Unix()
		saveData["state"] = requestData.State
		var eidtCont models.WorkHistory
		eidtErr := eidtCont.EiteCont(map[string]interface{}{"`id`": requestData.Id}, saveData)
		if eidtErr == nil {
			overallhandle.Result(0, saveData, c)
		} else {
			overallhandle.Result(106, eidtErr, c)
		}
	} else {
		if requestData.State == 3 {
			delErr := overall.CONSTANT_DB_HR.Where(map[string]interface{}{"`id`": requestData.Id}).Delete(&models.WorkHistory{}).Error
			if delErr == nil {
				overallhandle.Result(0, delErr, c)
			} else {
				overallhandle.Result(108, delErr, c)
			}
		} else {
			saveData := overallhandle.MapOut()
			saveData["time"] = time.Now().Unix()
			saveData["state"] = requestData.State
			var eidtCont models.WorkHistory
			eidtErr := eidtCont.EiteCont(map[string]interface{}{"`id`": requestData.Id}, saveData)
			if eidtErr == nil {
				overallhandle.Result(0, saveData, c)
			} else {
				overallhandle.Result(106, eidtErr, c)
			}
		}
	}
}

//集团内部工作履历
func getGroupWorkHistoryList(key int64) (workHisList []insideHistory) {
	defer synPro.Done()
	var workHisContList []models.InsideWorkHistory
	workHisContListErr := overall.CONSTANT_DB_HR.Where("`state` IN ? AND `key` = ?", []int{1, 2}, key).Find(&workHisContList).Error
	if workHisContListErr == nil {
		for _, v := range workHisContList {
			var workCont insideHistory
			var groupInfo models.AdministrativeOrganization
			groupInfo.GetCont(map[string]interface{}{"`id`": v.Group}, "`name`")
			workCont.Group = groupInfo.Name //集团
			var companyInfo models.AdministrativeOrganization
			companyInfo.GetCont(map[string]interface{}{"`id`": v.Company}, "`name`")
			workCont.Company = companyInfo.Name //公司
			var deparment models.AdministrativeOrganization
			deparment.GetCont(map[string]interface{}{"`id`": v.Department}, "`name`")
			workCont.Department = deparment.Name //部门
			var workshop models.AdministrativeOrganization
			workshop.GetCont(map[string]interface{}{"`id`": v.WorkShop}, "`name`")
			workCont.Workshop = workshop.Name //二级部门或车间

			var workshopsetdsas models.AdministrativeOrganization
			workshopsetdsas.GetCont(map[string]interface{}{"`id`": v.WorkshopSection}, "`name`")
			workCont.WorkshopSection = workshopsetdsas.Name //二级部门或车间

			var positCont models.Position
			positCont.GetCont(map[string]interface{}{"`id`": v.Position}, "`name`")
			workCont.Position = positCont.Name //职务

			workCont.GradePositions = v.GradePositions //职务

			workCont.StartTime = overallhandle.UnixTimeToDay(v.StartTime, 14) //开始日期
			workCont.EndTime = overallhandle.UnixTimeToDay(v.EndTime, 14)     //结束日期
			workCont.ChangeType = v.ChangeType                                //
			workHisList = append(workHisList, workCont)
		}
	}
	return
}

//添加工作履历
func (s *StaffApi) AddInsideHistory(c *gin.Context) {
	var requestData eidtInsideHistoryWork
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		overallhandle.Result(101, err, c)
		return
	}
	if requestData.Id == "" {
		overallhandle.Result(1, requestData.Id, c, "员工标识符不能为空")
		return
	}
	if requestData.OrgId == "" {
		overallhandle.Result(1, requestData.Id, c, "行政组织不能为空")
		return
	}
	if requestData.Position == "" {
		overallhandle.Result(1, requestData.Id, c, "职位不能为空")
		return
	}
	if requestData.Team == "" {
		overallhandle.Result(1, requestData.Id, c, "班组不能为空")
		return
	}
	if requestData.StartTime == "" {
		overallhandle.Result(1, requestData.Id, c, "就任此职位开始时间不能为空")
		return
	}
	if requestData.ChangeType == 0 {
		requestData.ChangeType = 1
	}
	if requestData.AssignType == 0 {
		requestData.AssignType = 1
	}
	var insiderHistoryWork models.InsideWorkHistory
	idInt, _ := strconv.ParseInt(requestData.Id, 10, 64)
	insiderHistoryWork.Key = idInt
	orgIdInt, _ := strconv.ParseInt(requestData.OrgId, 10, 64)
	insiderHistoryWork.Group, insiderHistoryWork.Company, insiderHistoryWork.Department, insiderHistoryWork.WorkShop, insiderHistoryWork.WorkshopSection = overallhandle.GetOrgStructure(orgIdInt)
	positionInt, _ := strconv.ParseInt(requestData.Position, 10, 64)
	insiderHistoryWork.Position = positionInt
	insiderHistoryWork.GradePositions = requestData.GradePositions
	startTime, _ := overallhandle.DateToTimeStamp(fmt.Sprintf("%v 00:00:00", requestData.StartTime))
	insiderHistoryWork.StartTime = startTime
	if requestData.EndTime != "" && requestData.EndTime != "0" && requestData.EndTime != "至今" {
		endTime, endErr := overallhandle.DateToTimeStamp(fmt.Sprintf("%v 00:00:00", requestData.EndTime))
		if endErr == true {
			insiderHistoryWork.StartTime = endTime
		}
	}
	teamIdInt, _ := strconv.ParseInt(requestData.Team, 10, 64)
	insiderHistoryWork.Team = teamIdInt
	insiderHistoryWork.ChangeType = requestData.ChangeType
	insiderHistoryWork.Time = time.Now().Unix()
	insiderHistoryWork.State = 1
	insiderHistoryWork.AssignType = requestData.AssignType
	addErr := overall.CONSTANT_DB_HR.Create(&insiderHistoryWork).Error
	if addErr != nil {
		overallhandle.Result(104, addErr, c)
	} else {
		overallhandle.Result(0, addErr, c)
	}
}

//编辑集团内部工作
func (s *StaffApi) EidtInsideHistoryWorkCont(c *gin.Context) {
	var requestData eidtInsideHistoryWork
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		overallhandle.Result(101, err, c)
		return
	}
	if requestData.Id == "" {
		overallhandle.Result(1, requestData.Id, c, "ID不能为空")
		return
	}

	var insiderHistoryWork models.InsideWorkHistory
	getErr := insiderHistoryWork.GetCont(map[string]interface{}{"`id`": requestData.Id})
	if getErr != nil {
		overallhandle.Result(107, requestData.Id, c)
		return
	}
	saveData := overallhandle.MapOut()
	if requestData.OrgId == "" {
		orgIdInt, _ := strconv.ParseInt(requestData.OrgId, 10, 64)
		groupId, companyId, departmentId, sunDepartId, workId := overallhandle.GetOrgStructure(orgIdInt)
		if groupId != insiderHistoryWork.Group {
			saveData["group"] = groupId
		}
		if companyId != insiderHistoryWork.Company {
			saveData["company"] = groupId
		}
		if departmentId != insiderHistoryWork.Department {
			saveData["department"] = groupId
		}
		if sunDepartId != insiderHistoryWork.WorkShop {
			saveData["workshop"] = groupId
		}
		if workId != insiderHistoryWork.WorkshopSection {
			saveData["workshop_section"] = groupId
		}
	}
	if requestData.Position == "" {
		positionInt, _ := strconv.ParseInt(requestData.Position, 10, 64)
		if positionInt != insiderHistoryWork.Position {
			saveData["position"] = positionInt
		}
	}
	if requestData.Team == "" {
		if requestData.Team != strconv.FormatInt(insiderHistoryWork.Team, 10) {
			saveData["position"] = requestData.Team
		}
	}
	if requestData.StartTime == "" {
		startTime, _ := overallhandle.DateToTimeStamp(fmt.Sprintf("%v 00:00:00", requestData.StartTime))
		if startTime != insiderHistoryWork.StartTime {
			saveData["start_time"] = startTime
		}
	}
	if requestData.ChangeType != 0 {
		if requestData.ChangeType != insiderHistoryWork.ChangeType {
			saveData["change_type"] = requestData.ChangeType
		}
	}
	if requestData.AssignType != 0 {
		if requestData.AssignType != insiderHistoryWork.AssignType {
			saveData["assign_type"] = requestData.AssignType
		}
	}
	if requestData.EndTime != "" && requestData.EndTime != "0" && requestData.EndTime != "至今" {
		endTime, endErr := overallhandle.DateToTimeStamp(fmt.Sprintf("%v 00:00:00", requestData.EndTime))
		if endErr == true {
			if endTime != insiderHistoryWork.EndTime {
				saveData["end_time"] = endTime
			}
		}
	} else {
		saveData["end_time"] = 0
	}
	if requestData.GradePositions != 0 && requestData.GradePositions != insiderHistoryWork.GradePositions {
		saveData["grade_positions"] = requestData.GradePositions
	}
	if len(saveData) > 0 {
		saveData["time"] = time.Now().Unix()
		eidtErr := insiderHistoryWork.EditCont(map[string]interface{}{"`id`": requestData.Id}, saveData)
		if eidtErr == nil {
			overallhandle.Result(0, eidtErr, c)
		} else {
			overallhandle.Result(106, eidtErr, c)
		}
	} else {
		overallhandle.Result(0, getErr, c)
	}
}

//编辑或删除集团内工作记录
func (s *StaffApi) EditOrDelInsideWorkHistoryState(c *gin.Context) {
	var requestData eidtWorkState
	c.ShouldBindJSON(&requestData)
	if requestData.Id == "" {
		overallhandle.Result(101, requestData.Id, c)
		return
	}
	var doubleWorkCont models.InsideWorkHistory
	wErr := doubleWorkCont.GetCont(map[string]interface{}{"`id`": requestData.Id})
	if wErr != nil {
		overallhandle.Result(107, requestData.Id, c)
		return
	}
	if requestData.State == 0 {
		requestData.State = 1
	}
	if requestData.IsDel <= 1 {
		saveData := overallhandle.MapOut()
		saveData["time"] = time.Now().Unix()
		saveData["state"] = requestData.State
		var eidtCont models.InsideWorkHistory
		eidtErr := eidtCont.EditCont(map[string]interface{}{"`id`": requestData.Id}, saveData)
		if eidtErr == nil {
			overallhandle.Result(0, saveData, c)
		} else {
			overallhandle.Result(106, eidtErr, c)
		}
	} else {
		if requestData.State == 3 {
			delErr := overall.CONSTANT_DB_HR.Where(map[string]interface{}{"`id`": requestData.Id}).Delete(&models.InsideWorkHistory{}).Error
			if delErr == nil {
				overallhandle.Result(0, delErr, c)
			} else {
				overallhandle.Result(108, delErr, c)
			}
		} else {
			saveData := overallhandle.MapOut()
			saveData["time"] = time.Now().Unix()
			saveData["state"] = requestData.State
			var eidtCont models.InsideWorkHistory
			eidtErr := eidtCont.EditCont(map[string]interface{}{"`id`": requestData.Id}, saveData)
			if eidtErr == nil {
				overallhandle.Result(0, saveData, c)
			} else {
				overallhandle.Result(106, eidtErr, c)
			}
		}
	}
}

//集团内部工作经历列表
func (s *StaffApi) InsideWorkHistoryList(c *gin.Context) {
	var requestData allocationOfRightsToRole
	c.ShouldBindJSON(&requestData)
	if requestData.Id == "" {
		overallhandle.Result(101, requestData.Id, c)
		return
	}
	var insideWorkHistoryList []models.InsideWorkView
	gormDb := overall.CONSTANT_DB_HR.Model(&models.InsideWorkView{}).Where("`state` IN (1,2) AND `key` = ?", requestData.Id)
	err := gormDb.Order("end_time asc").Order("start_time desc").Order("`id` desc").Find(&insideWorkHistoryList).Error
	if err != nil {
		overallhandle.Result(107, err, c)
	} else {
		overallhandle.Result(0, insideWorkHistoryList, c)
	}
}

//工作履历列表
func (s *StaffApi) WorkHistoryList(c *gin.Context) {
	var requestData allocationOfRightsToRole
	c.ShouldBindJSON(&requestData)
	if requestData.Id == "" {
		overallhandle.Result(101, requestData.Id, c)
		return
	}
	var insideWorkHistoryList []models.WorkHistory
	gormDb := overall.CONSTANT_DB_HR.Model(&models.WorkHistory{}).Where("`state` IN (1,2) AND `key` = ?", requestData.Id)
	err := gormDb.Order("`id` desc").Find(&insideWorkHistoryList).Error
	if err != nil {
		overallhandle.Result(107, err, c)
	} else {
		overallhandle.Result(0, insideWorkHistoryList, c)
	}
}

//教育经历列表
func (s *StaffApi) PersonnelEducationList(c *gin.Context) {
	var requestData allocationOfRightsToRole
	c.ShouldBindJSON(&requestData)
	if requestData.Id == "" {
		overallhandle.Result(101, requestData.Id, c)
		return
	}
	var insideWorkHistoryList []models.PersonnelEducation
	gormDb := overall.CONSTANT_DB_HR.Model(&models.PersonnelEducation{}).Where("`state` IN (1,2) AND `key` = ?", requestData.Id)
	err := gormDb.Order("`id` desc").Find(&insideWorkHistoryList).Error
	if err != nil {
		overallhandle.Result(107, err, c)
	} else {
		overallhandle.Result(0, insideWorkHistoryList, c)
	}
}

//家庭成员列表
func (s *StaffApi) FamilyMemBersList(c *gin.Context) {
	var requestData allocationOfRightsToRole
	c.ShouldBindJSON(&requestData)
	if requestData.Id == "" {
		overallhandle.Result(101, requestData.Id, c)
		return
	}
	var insideWorkHistoryList []models.FamilyMembers
	gormDb := overall.CONSTANT_DB_HR.Model(&models.FamilyMembers{}).Where("`state` IN (1,2) AND `key` = ?", requestData.Id)
	err := gormDb.Order("`id` desc").Find(&insideWorkHistoryList).Error
	if err != nil {
		overallhandle.Result(107, err, c)
	} else {
		overallhandle.Result(0, insideWorkHistoryList, c)
	}
}

//紧急联系人列表
func (s *StaffApi) EmergencyContactList(c *gin.Context) {
	var requestData allocationOfRightsToRole
	c.ShouldBindJSON(&requestData)
	if requestData.Id == "" {
		overallhandle.Result(101, requestData.Id, c)
		return
	}
	var insideWorkHistoryList []models.EmergencyContact
	gormDb := overall.CONSTANT_DB_HR.Model(&models.EmergencyContact{}).Where("`state` IN (1,2) AND `key` = ?", requestData.Id)
	err := gormDb.Order("`id` desc").Find(&insideWorkHistoryList).Error
	if err != nil {
		overallhandle.Result(107, err, c)
	} else {
		overallhandle.Result(0, insideWorkHistoryList, c)
	}
}

//双职工列表
func (s *StaffApi) DoubleWorkerList(c *gin.Context) {
	var requestData allocationOfRightsToRole
	c.ShouldBindJSON(&requestData)
	if requestData.Id == "" {
		overallhandle.Result(101, requestData.Id, c)
		return
	}
	var insideWorkHistoryList []models.DoubleWorker
	gormDb := overall.CONSTANT_DB_HR.Model(&models.DoubleWorker{}).Where("`state` IN (1,2) AND `key` = ?", requestData.Id)
	err := gormDb.Order("`id` desc").Find(&insideWorkHistoryList).Error
	if err != nil {
		overallhandle.Result(107, err, c)
	} else {
		overallhandle.Result(0, insideWorkHistoryList, c)
	}
}