hr_server/api/version1/personnelapi/staffarchives.go

package personnelapi

import (
	"fmt"
	"hr_server/models"
	"hr_server/overall"
	"hr_server/overall/overallhandle"
	"strconv"
	"strings"
	"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
	gormDb := overall.CONSTANT_DB_HR.Model(&models.ManCont{}).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 {
		gormDb = gormDb.Where("admin_org = ?", requestData.AdminOrg)
	}
	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 IN ?", overall.EmployeeStatusIng)
	}
	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
	}
	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
	var positionAry []peopleManOutList

	for _, v := range staffList {
		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)
		//公司
		var getSpurDepart models.AdministrativeOrganization
		getWheDepart := overallhandle.MapOut()
		getWheDepart["id"] = v.Company
		getSpurDepart.GetCont(getWheDepart, "name")
		staffInfo.CompanyName = getSpurDepart.Name
		//主部门
		var getSpurDepartMain models.AdministrativeOrganization
		getWheDepartMain := overallhandle.MapOut()
		getWheDepartMain["id"] = v.MainDeparment
		getSpurDepartMain.GetCont(getWheDepartMain, "name")
		staffInfo.MainDeparmentName = getSpurDepartMain.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, " ")
				}
			}
		}
		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)   //预计转正日期
	//获取双职工信息
	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.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)
			}
		}
	}
}