gin-vue-admin/gin_server_admin/api/index/assessment/assesshandle.go

package assessment

import (
	"encoding/json"
	"fmt"
	"strconv"
	"time"

	"github.com/flipped-aurora/gin-vue-admin/server/api/v1/archiveapi"
	"github.com/flipped-aurora/gin-vue-admin/server/api/v1/assessment"
	"github.com/flipped-aurora/gin-vue-admin/server/api/wechatapp/sendmessage"
	"github.com/flipped-aurora/gin-vue-admin/server/commonus"
	"github.com/flipped-aurora/gin-vue-admin/server/global"
	"github.com/flipped-aurora/gin-vue-admin/server/model/assessmentmodel"
	"github.com/flipped-aurora/gin-vue-admin/server/model/common/response"
	"github.com/flipped-aurora/gin-vue-admin/server/model/systemuser"
	"github.com/flipped-aurora/gin-vue-admin/server/model/testpage"
	"github.com/flipped-aurora/gin-vue-admin/server/utils/redishandel"
	"github.com/gin-gonic/gin"
	"github.com/mitchellh/mapstructure"
)

//考核入口
func (a *Assessment) Index(c *gin.Context) {
	outPut := commonus.MapOut()
	response.Result(0, outPut, "用户端获取成功", c)
}

//扫码登录回传
func (a *Assessment) ScanCode(c *gin.Context) {
	var requestData scanCodeStr
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "参数错误！请重新提交！", c)
		return
	}
	var redisAdminInfo commonus.ScanCodeLogin
	redisClient := redishandel.RunRedis()
	redisClient.SetRedisDb(5)
	redisKey := fmt.Sprintf("ScanCode:Authentication:LoginApi_%v_%v", global.GVA_CONFIG.RedisPrefix.Alias, requestData.UserKey)

	tokenInfo, isTrue := redisClient.HashGetAll(redisKey)
	if isTrue != true {
		outData := commonus.MapOut()
		outData["redisKey"] = redisKey
		outData["tokenInfo"] = tokenInfo
		outData["isTrue"] = isTrue
		response.Result(102, outData, "验证失败！不允许登录！", c)
		return
	}
	identityErr := mapstructure.Decode(tokenInfo, &redisAdminInfo)
	if identityErr != nil {
		response.Result(103222, redisKey, "验证失败！不允许登录！", c)
		return
	}
	if requestData.UserToken != redisAdminInfo.UserToken {
		yanzheng := commonus.MapOut()
		yanzheng["User"] = redisAdminInfo
		yanzheng["redisKey"] = redisKey
		yanzheng["UserToken"] = requestData.UserToken
		yanzheng["RedisUserToken"] = redisAdminInfo.UserToken
		response.Result(104, yanzheng, "验证失败！不允许登录！", c)
		return
	}
	sendData := commonus.MapOut()
	sendData["key"] = redisAdminInfo.UserKey
	sendData["token"] = redisAdminInfo.UserToken
	sendData["userinfo"] = redisAdminInfo
	var jurisDiction []int64
	json.Unmarshal([]byte(redisAdminInfo.Jurisdiction), &jurisDiction)
	sendData["Jurisdiction"] = jurisDiction
	var menuOper []int64
	json.Unmarshal([]byte(redisAdminInfo.MenuOper), &menuOper)
	sendData["MenuOper"] = menuOper
	response.Result(0, sendData, "用户端获取成功", c)
}

func (a *Assessment) ScanCodeOld(c *gin.Context) {
	var requestData scanCodeStr
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "参数错误！请重新提交！", c)
		return
	}
	var redisAdminInfo systemuser.RedisAdminInfo
	redisClient := redishandel.RunRedis()
	redisKey := fmt.Sprintf("system:SystemAdminInfo_%v_%v", global.GVA_CONFIG.RedisPrefix.Alias, requestData.UserKey)
	tokenInfo, isTrue := redisClient.HashGetAll(redisKey)
	if isTrue != true {
		response.Result(102, err, "验证失败！不允许登录！", c)
		return
	}
	identityErr := mapstructure.Decode(tokenInfo, &redisAdminInfo)
	if identityErr != nil {
		response.Result(103222, redisKey, "验证失败！不允许登录！", c)
		return
	}
	if requestData.UserToken != redisAdminInfo.UserToken {
		yanzheng := commonus.MapOut()
		yanzheng["User"] = redisAdminInfo
		yanzheng["redisKey"] = redisKey
		yanzheng["UserToken"] = requestData.UserToken
		yanzheng["RedisUserToken"] = redisAdminInfo.UserToken
		response.Result(104, yanzheng, "验证失败！不允许登录！", c)
		return
	}
	sendData := commonus.MapOut()
	sendData["key"] = redisAdminInfo.UserKey
	sendData["token"] = redisAdminInfo.UserToken
	sendData["userinfo"] = redisAdminInfo
	var jurisDiction []int64
	json.Unmarshal([]byte(redisAdminInfo.JurisDiction), &jurisDiction)
	sendData["Jurisdiction"] = jurisDiction
	var menuOper []int64
	json.Unmarshal([]byte(redisAdminInfo.MenuOper), &menuOper)
	sendData["MenuOper"] = menuOper
	response.Result(0, sendData, "用户端获取成功", c)
}

//获取要考核的列表
func (a *Assessment) MyAssEssMentList(c *gin.Context) {
	var requestData getAssEssList
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		// response.Result(101, err, "参数错误！请重新提交！", c)
		// return
	}
	dayTime := time.Now()
	monthData := commonus.TimeStampToDate(dayTime.Unix(), 10) //当月
	switch requestData.DayState {
	case 1:
		monthData = commonus.TimeStampToDate(dayTime.Unix(), 10) //当月
	case 2:
		lastOneMonthStart, _ := commonus.AppointTimeFrontMonth(dayTime, 1)
		monthData = commonus.TimeStampToDate(lastOneMonthStart, 10) //上一个月
	case 3:
		lastOneMonthStart, _ := commonus.AppointTimeFrontMonth(dayTime, 2)
		monthData = commonus.TimeStampToDate(lastOneMonthStart, 10) //上两个月
	default:
		monthData = commonus.TimeStampToDate(dayTime.Unix(), 10) //当月
	}

	if requestData.PageSize == 0 {
		requestData.PageSize = 20
	}
	if requestData.Page <= 0 {
		requestData.Page = 1
	}
	isTrue, userCont := commonus.ClientIdentity()
	if isTrue != true {
		response.Result(101, err, "您的身份令牌已经失效！请重新登录获取身份令牌！", c)
		return
	}
	offSetPage := commonus.CalculatePages(requestData.Page, requestData.PageSize)
	gormDb := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DutyContent{}).Where("(`dc_user_dump` = ? OR `dc_dump` = ?) AND `dc_state` = 1", userCont.Key, userCont.Deparment)

	var total int64
	totalErr := gormDb.Count(&total).Error
	if totalErr != nil {
		total = 0
	}
	var assessList []assessmentmodel.DutyContent
	assessListerr := gormDb.Limit(requestData.PageSize).Offset(offSetPage).Order("dc_id desc").Find(&assessList).Error
	if assessListerr != nil {
		response.Result(102, assessListerr, "数据获取失败！", c)
		return
	}
	var assessOutList []assessOut
	for _, val := range assessList {
		var assessOutCont assessOut
		assessOutCont.Id = val.Id
		assessOutCont.OutId = strconv.FormatInt(val.Id, 10)

		assessOutCont.Title = val.Title
		assessOutCont.Time = val.Time
		assessOutCont.State = val.State
		assessOutCont.PartId = val.PartId
		assessOutCont.UserType = val.UserType
		assessOutCont.UserDump = val.UserDump
		assessOutCont.Dump = val.Dump
		isErr, assessClassCont := assessment.GetAssessClass(val.PartId)
		if isErr == true {
			assessOutCont.ClassId = assessClassCont.PartId
			assessOutCont.ClassTitle = assessClassCont.ClassTitle
			assessOutCont.AssessId = assessClassCont.Id
			assessOutCont.AssessTitle = assessClassCont.Title
		}

		assIsTrue, assDepartList := GetAssDepart(val.Id, monthData)
		// fmt.Printf("------------->%v-------->%v\n", assIsTrue, assDepartList)
		if assIsTrue == true {
			assessOutCont.AssessDepart = assDepartList
		}

		assessOutList = append(assessOutList, assessOutCont)
	}
	countSum := len(assessOutList)
	printData := commonus.OutPutList(total, int64(countSum), requestData.Page, requestData.PageSize, assessOutList)
	response.Result(0, printData, "查询成功！", c)
}

//获得项目考核部门
func GetAssDepart(dutyid int64, dataStr string) (isTrue bool, assessDepartstr []assessDepart) {
	isTrue = false
	var departDuty []assessmentmodel.DepartDuty
	assDepartErr := global.GVA_DB_Performanceappraisal.Where("`de_duty` = ? AND `de_satte` = 1", dutyid).Find(&departDuty).Error
	if assDepartErr != nil {
		return
	}
	for _, val := range departDuty {
		var assInfo assessDepart
		assInfo.DepartDutyId = val.Id
		assInfo.DepartId = val.PartId
		isTruew, bfCont := assessment.GetBranchFactory(val.PartId)
		if isTruew == true {
			assInfo.DepartTitle = bfCont.Name
		}

		assInfo.ClassId = val.ClassId
		assInfo.AssessId = val.AssessId
		assInfo.DutyId = val.DutyId
		assInfo.Rescore = val.Rescore
		assInfo.Group = val.Group
		assInfo.IsTrue = JudgeResAssEssExam(val.DutyId, val.PartId, dataStr)

		assessDepartstr = append(assessDepartstr, assInfo)
	}

	isTrue = true
	return
}

//判断部门指定月份是否已经考核完毕
func JudgeResAssEssExam(dutyId, departId int64, monthTimeStr string) (isTrue bool) {
	isTrue = false
	// var departscores assessmentmodel.Departscores
	monthTimeStr = monthTimeStr + "-01 12:00:00"

	fileTime, fileTimeErr := commonus.DateToTimeStampEs(monthTimeStr)
	if fileTimeErr != true {
		return
	}
	outMap := commonus.MapOut()
	err := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.Departscores{}).Select("s_id").Where("`s_duty` = ? AND `s_depart_id` = ? AND `s_file_time` = ?", dutyId, departId, fileTime).First(&outMap).Error
	if err == nil {
		isTrue = true
	}
	return
}

//根据具体考核项获取被考核部门
func (a *Assessment) GetDutyDepartList(c *gin.Context) {
	var requestData assessDepartRequest
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "参数错误！请重新提交！", c)
		return
	}
	if requestData.Id == "" {
		response.Result(102, err, "参数错误！请重新提交！", c)
		return
	}
	id, idErr := strconv.ParseInt(requestData.Id, 10, 64)
	if idErr != nil {
		response.Result(103, err, "参数错误！请重新提交！", c)
		return
	}
	dayTime := time.Now()
	monthData := commonus.TimeStampToDate(dayTime.Unix(), 10) //当月
	isTrue, departList := GetAssDepart(id, monthData)
	if isTrue != true {
		response.Result(104, departList, "获取失败！", c)
		return
	}
	outData := commonus.MapOut()
	outData["list"] = departList
	response.Result(0, outData, "查询成功！", c)
}

//添加考核评分
func (a *Assessment) AddAssessmentScore(c *gin.Context) {
	var requestData addAssEssScores
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "参数错误！请重新提交！", c)
		return
	}

	if requestData.DutyId == "" {
		response.Result(102, err, "未知具体职责！", c)
		return
	}
	//将具体职责ID转换为Int64
	dutyId, dutyIdErr := strconv.ParseInt(requestData.DutyId, 10, 64)
	if dutyIdErr != nil {
		response.Result(102, err, "未知具体职责！", c)
		return
	}

	// classId, dutyIdErr := strconv.ParseInt(requestData.ClassId, 10, 64)
	// if dutyIdErr != nil {
	// 	response.Result(102, err, "未知考核分类！", c)
	// 	return
	// }

	// assessId, dutyIdErr := strconv.ParseInt(requestData.AssessId, 10, 64)
	// if dutyIdErr != nil {
	// 	response.Result(102, err, "未知考核项目！", c)
	// 	return
	// }

	assIsTrue, assInfo := assessment.GetDutyInfoContAll(dutyId)
	if assIsTrue != true {
		response.Result(104, dutyId, "请指定考核项目已禁止使用！", c)
		return
	}

	classId := assInfo.ClassId
	assessId := assInfo.AssessId

	if requestData.FileTime == "" {
		response.Result(103, err, "未知考核年月！", c)
		return
	}
	timeStr := requestData.FileTime + "-01 12:00:00"
	assessmentTime, assessmentTimeErr := commonus.DateToTimeStampEs(timeStr)
	if assessmentTimeErr != true {
		response.Result(104, timeStr, "你提交的考核日期错误！", c)
		return
	}

	if requestData.DepartId == 0 {
		response.Result(105, err, "未知被考核部门！", c)
		return
	}

	isTrue, userCont := commonus.ClientIdentity()
	if isTrue != true {
		response.Result(106, err, "您的身份令牌已经失效！请重新登录获取身份令牌！", c)
		return
	}
	userKey, userKeyErr := strconv.ParseInt(userCont.Key, 10, 64)
	if userKeyErr != nil {
		response.Result(107, err, "您的身份令牌已经失效！请重新登录获取身份令牌！", c)
		return
	}

	//获取具体考核项对应部门理想分值
	var departDutyCont assessmentmodel.DepartDuty
	deducoErr := global.GVA_DB_Performanceappraisal.Select("`de_rescore`").Where("`de_partid` = ? AND `de_duty` = ? AND `de_satte` = 1", requestData.DepartId, dutyId).First(&departDutyCont).Error
	if deducoErr != nil {
		response.Result(108, err, "该考核项目已经失效！", c)
		return
	}

	if requestData.DeductPoints > departDutyCont.Rescore*10 {
		response.Result(108, err, "扣分不能高于参考值！", c)
		return
	}

	if requestData.ExtraPoints > departDutyCont.Rescore*10 {
		response.Result(108, err, "加分不能高于参考值！", c)
		return
	}

	actualScore := departDutyCont.Rescore - int64(requestData.DeductPoints) + int64(requestData.ExtraPoints)

	if actualScore < 0 {
		actualScore = 0
	}

	var departscores assessmentmodel.Departscores

	judgeOperationErr := global.GVA_DB_Performanceappraisal.Select("s_id").Where("`s_class` = ? AND `s_assess` = ? AND `s_duty` = ? AND `s_file_time` = ? AND `s_depart_id` = ? AND `s_comment_user` = ? AND `s_state` = 1", classId, assessId, dutyId, assessmentTime, requestData.DepartId, userKey).First(&departscores).Error

	if judgeOperationErr == nil {
		response.Result(109, err, "您已经对"+requestData.FileTime+"做出评价！请不要重复评价", c)
		return
	}

	departscores.Id = commonus.GetFileNumberEs()
	departscores.ClassId = classId
	departscores.AssessId = assessId
	departscores.DutyId = dutyId
	departscores.DeductPoints = requestData.DeductPoints
	departscores.ExtraPoints = requestData.ExtraPoints
	// departscores.Score = requestData.Score
	departscores.Score = actualScore
	departscores.FileTime = assessmentTime
	departscores.DepartId = requestData.DepartId
	departscores.CommentUser = userKey
	departscores.AddTime = time.Now().Unix()
	departscores.EiteTime = time.Now().Unix()
	departscores.State = 1

	addassessInfoErr := global.GVA_DB_Performanceappraisal.Create(&departscores).Error
	if addassessInfoErr != nil {
		response.Result(110, departscores, "数据写入失败！", c)
	} else {
		response.Result(0, departscores, "数据写入成功！", c)
	}
}

//我的评价记录
func (a *Assessment) MyEvaluateList(c *gin.Context) {
	var requestData usEvaluate
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		// response.Result(101, err, "参数错误！请重新提交！", c)
		// return
	}
	if requestData.PageSize == 0 {
		requestData.PageSize = 20
	}
	if requestData.Page <= 0 {
		requestData.Page = 1
	}
	offSetPage := commonus.CalculatePages(requestData.Page, requestData.PageSize)

	isTrue, userCont := commonus.ClientIdentity()
	if isTrue != true {
		response.Result(101, err, "您的身份令牌已经失效！请重新登录获取身份令牌！", c)
		return
	}
	// gormDb := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.Departscores{}).Select("s_depart_id", "s_file_time", "s_comment_user").Where("`s_comment_user` = ?", userCont.Key)
	gormDb := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.Departscores{}).Select("s_depart_id", "s_file_time", "s_comment_user", "SUM(s_score) as sumscore")
	if requestData.DepartId != 0 && requestData.Time != "" {
		timeStr := requestData.Time + "-01 12:00:00"
		assessmentTime, assessmentTimeErr := commonus.DateToTimeStampEs(timeStr)
		if assessmentTimeErr != true {
			response.Result(102, timeStr, "你提交的考核日期错误！", c)
			return
		}
		gormDb = gormDb.Group("s_depart_id,s_file_time,s_comment_user").Having("`s_depart_id` = ? AND `s_file_time` = ? AND `s_comment_user` = ?", requestData.DepartId, assessmentTime, userCont.Key)
	} else if requestData.DepartId != 0 {
		gormDb = gormDb.Group("`s_depart_id`,`s_file_time`,`s_comment_user`").Having("`s_depart_id` = ? AND `s_comment_user` = ?", requestData.DepartId, userCont.Key)
	} else if requestData.Time != "" {
		timeStr := requestData.Time + "-01 12:00:00"
		assessmentTime, assessmentTimeErr := commonus.DateToTimeStampEs(timeStr)
		if assessmentTimeErr != true {
			response.Result(103, timeStr, "你提交的考核日期错误！", c)
			return
		}
		gormDb = gormDb.Group("`s_depart_id`,`s_file_time`,`s_comment_user`").Having("`s_file_time` = ? AND `s_comment_user` = ?", assessmentTime, userCont.Key)
	} else {
		gormDb = gormDb.Group("`s_depart_id`,`s_file_time`,`s_comment_user`")
	}
	var total int64
	totalErr := gormDb.Count(&total).Error
	if totalErr != nil {
		total = 0
	}
	var assessList []usEvaluateOutList
	evaErr := gormDb.Limit(requestData.PageSize).Offset(offSetPage).Find(&assessList).Error

	if evaErr != nil {
		response.Result(104, evaErr, "数据获取失败！", c)
		return
	}
	var usEvaluateOutMap []usEvaluateOut
	for _, val := range assessList {
		var usEvaluateOutInfo usEvaluateOut

		usEvaluateOutInfo.FileTime = val.FileTime
		usEvaluateOutInfo.DepartId = val.DepartId
		usEvaluateOutInfo.CommentUser = val.CommentUser
		usEvaluateOutInfo.Score = val.Score
		timeStr := commonus.TimeStampToDate(val.FileTime, 10)
		usEvaluateOutInfo.FileTimeStr = timeStr

		isTrueBranFact, branFactCont := assessment.GetBranchFactory(val.DepartId)
		if isTrueBranFact == true {
			usEvaluateOutInfo.DepartTitle = branFactCont.Name
		}

		usEvaluateOutMap = append(usEvaluateOutMap, usEvaluateOutInfo)
	}

	countSum := len(usEvaluateOutMap)
	printData := commonus.OutPutList(total, int64(countSum), requestData.Page, requestData.PageSize, usEvaluateOutMap)
	response.Result(0, printData, "查询成功！", c)
}

//根据部门和时间获取考核详情
func (a *Assessment) GetDepartTimeAssess(c *gin.Context) {
	var requestData departTimeAssess
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "参数错误！请重新提交！", c)
		return
	}
	if requestData.DepartId == 0 {
		response.Result(102, err, "未知部门！", c)
		return
	}
	if requestData.Time == "" {
		response.Result(103, err, "未知时间！", c)
		return
	}
	timeStr := requestData.Time + "-01 12:00:00"
	assessmentTime, assessmentTimeErr := commonus.DateToTimeStampEs(timeStr)
	if assessmentTimeErr != true {
		response.Result(104, timeStr, "你提交的考核日期错误！", c)
		return
	}
	// var departScorsList []assessmentmodel.Departscores
	// scorErr := global.GVA_DB_Performanceappraisal.Where("`s_depart_id` = ? AND `s_file_time` = ? AND `s_state` = 1", requestData.DepartId, assessmentTime).Find(&departScorsList).Error
	// if scorErr != nil {
	// 	response.Result(104, scorErr, "未能获取到数据！", c)
	// 	return
	// }
	// var departDataAssessList []departDataAssess
	// for _, val := range departScorsList {
	// 	var departDataAssessInfo departDataAssess

	// 	departDataAssessInfo.Id = val.Id
	// 	departDataAssessInfo.DutyId = val.DutyId             //具体职责
	// 	departDataAssessInfo.DeductPoints = val.DeductPoints //扣分
	// 	departDataAssessInfo.ExtraPoints = val.ExtraPoints   //加分
	// 	departDataAssessInfo.Score = val.Score               //实际得分
	// 	departDataAssessInfo.FileTime = val.FileTime         //计分月份
	// 	departDataAssessInfo.DepartId = val.DepartId         //部门ID
	// 	departDataAssessInfo.CommentUser = val.CommentUser   //评论人
	// 	departDataAssessInfo.AddTime = val.AddTime           //添加时间
	// 	departDataAssessInfo.EiteTime = val.EiteTime         //编辑时间
	// 	departDataAssessInfo.State = val.State               //状态
	// 	timeStr := commonus.TimeStampToDate(val.FileTime, 10)
	// 	departDataAssessInfo.FileTimeStr = timeStr
	// 	isTrueBranFact, branFactCont := assessment.GetBranchFactory(val.DepartId)
	// 	if isTrueBranFact == true {
	// 		departDataAssessInfo.DepartTitle = branFactCont.Name
	// 	}

	// 	dutyCalssErr, dutyMap := GetDutyInfoCont(val.DutyId)

	// 	if dutyCalssErr == true {
	// 		departDataAssessInfo.ClassId = dutyMap.ClassId
	// 		departDataAssessInfo.ClassTitle = dutyMap.ClassTitle
	// 		departDataAssessInfo.AssessId = dutyMap.AssessId
	// 		departDataAssessInfo.AssessTitle = dutyMap.AssessTitle
	// 		departDataAssessInfo.DutyTitle = dutyMap.DutyTitle
	// 	}

	// 	departDataAssessList = append(departDataAssessList, departDataAssessInfo)
	// }
	// outPrint := commonus.MapOut()
	// outPrint["list"] = departDataAssessList
	// response.Result(0, outPrint, "获取成功！", c)
	var departScorsList []assessmentmodel.Departscores
	scorErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.Departscores{}).Select("s_class").Where("`s_depart_id` = ? AND `s_file_time` = ? AND `s_state` = 1", requestData.DepartId, assessmentTime).Group("s_class").Find(&departScorsList).Error
	if scorErr != nil {
		response.Result(104, scorErr, "未能获取到数据！", c)
		return
	}
	var departMonthList []departMonth
	for _, val := range departScorsList {
		var departMonthInfo departMonth
		departMonthInfo.Id = val.ClassId
		classErr, classInfo := assessment.GetDutyClassCont(val.ClassId)
		if classErr == true {
			departMonthInfo.Title = classInfo.Title
		}
		assErr, assList := GetAssList(val.ClassId, requestData.DepartId, assessmentTime)
		if assErr == true {
			departMonthInfo.Clide = assList
		}
		departMonthList = append(departMonthList, departMonthInfo)
	}
	outPrint := commonus.MapOut()
	outPrint["list"] = departMonthList
	response.Result(0, outPrint, "获取成功！", c)
}

//获取考核项目列表
func GetAssList(classId, depart, timeVal int64) (isTrue bool, departMonthAss []departMonthSun) {
	isTrue = false
	var departScorsList []assessmentmodel.Departscores
	scorErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.Departscores{}).Select("s_assess").Where("`s_depart_id` = ? AND `s_file_time` = ? AND `s_class` = ? AND `s_state` = 1", depart, timeVal, classId).Group("s_assess").Find(&departScorsList).Error
	if scorErr != nil {
		return
	}
	for _, val := range departScorsList {
		var departMonthSunsInfo departMonthSun
		departMonthSunsInfo.Id = val.AssessId

		classErr, classInfo := assessment.GetAssessClass(val.AssessId)
		if classErr == true {
			departMonthSunsInfo.Title = classInfo.Title
		}
		isErr, userDuty := GetDetailedDuty(classId, val.AssessId, depart, timeVal)
		if isErr == true {
			departMonthSunsInfo.Clide = userDuty
		}
		departMonthAss = append(departMonthAss, departMonthSunsInfo)
	}
	isTrue = true
	return
}

//获取具体考核项目
func GetDetailedDuty(classId, assId, depart, timeVal int64) (isTrue bool, departMonthUser []departMonthSun) {
	isTrue = false
	var departScorsList []commentUser
	scorErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.Departscores{}).Select("s_comment_user").Where("`s_depart_id` = ? AND `s_file_time` = ? AND `s_class` = ? AND `s_assess` = ? AND `s_state` = 1", depart, timeVal, classId, assId).Group("s_comment_user").Find(&departScorsList).Error
	// fmt.Printf("----------->%v\n", departScorsList)
	if scorErr != nil {
		return
	}
	// var departMonthUser []departMonthSun
	for _, val := range departScorsList {
		var departMonthUserInfo departMonthSun
		departMonthUserInfo.Id = val.UserKey
		usCont, usErr := archiveapi.GetUserInfo([]string{"worker_man.wm_number", "worker_man_data.wmd_name", "worker_man.wm_bf_id", "worker_man.wm_ws_id", "worker_man.wm_pt_id", "worker_man.wm_group"}, map[string]interface{}{"wm_key": val.UserKey})
		if usErr == true {
			departMonthUserInfo.Title = usCont.Name

			isTrueBranFact, branFactCont := assessment.GetBranchFactory(usCont.DepartmentId)
			if isTrueBranFact == true {
				departMonthUserInfo.DepartTitle = branFactCont.Name
			}

		}

		dutyErr, dutyMap := GetDutyContAry(classId, assId, depart, val.UserKey, timeVal)
		if dutyErr == true {
			departMonthUserInfo.List = dutyMap
		}

		departMonthUser = append(departMonthUser, departMonthUserInfo)
	}
	isTrue = true
	return
}

//获取考核具体职责项目
func GetDutyContAry(classId, assId, depart, userKey, timeVal int64) (isTrue bool, dutyList []departDutyList) {
	// fmt.Printf("--->%v--->%v\n", classId, assId)
	isTrue = false
	var dutyListMAp []departDutyList
	scorErr := global.GVA_DB_Performanceappraisal.Where("`s_depart_id` = ? AND `s_file_time` = ? AND `s_class` = ? AND `s_assess` = ? AND `s_comment_user` = ? AND `s_state` = 1", depart, timeVal, classId, assId, userKey).Find(&dutyListMAp).Error
	if scorErr != nil {
		return
	}
	// fmt.Printf("1--->%v--->%v\n", classId, assId)
	for _, val := range dutyListMAp {
		// fmt.Printf("2--->%v--->%v\n", classId, assId)
		var dutyCont departDutyList

		dutyCont.Id = val.Id
		dutyCont.ClassId = val.ClassId
		dutyCont.AssessId = val.AssessId
		dutyCont.DutyId = val.DutyId
		dutyCont.DeductPoints = val.DeductPoints
		dutyCont.ExtraPoints = val.ExtraPoints
		dutyCont.Score = val.Score
		dutyCont.FileTime = val.FileTime
		dutyCont.DepartId = val.DepartId
		dutyCont.CommentUser = val.CommentUser
		dutyCont.AddTime = val.AddTime
		dutyCont.EiteTime = val.EiteTime
		dutyCont.State = val.State
		dtyContErr, dtyCont := GetDutyInfoCont(val.DutyId)

		if dtyContErr == true {
			dutyCont.DutyTitle = dtyCont.DutyTitle
		}
		dutyList = append(dutyList, dutyCont)
	}
	isTrue = true
	return
}

//获取职责类别内容
func GetDutyInfoCont(id int64) (isTrue bool, outAssDutyInfo outAessDuty) {
	isTrue = false
	var ContInfo dutyAssClass
	err := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DutyContent{}).Select("dc_title", "dc_parent", "ai_title", "ai_parent").Joins("left join assessmentitems on assessmentitems.ai_id = dutycontent.dc_parent").Where("dc_id = ?", id).First(&ContInfo).Error
	if err != nil {
		return
	}
	outAssDutyInfo.AssessId = ContInfo.PartId
	outAssDutyInfo.AssessTitle = ContInfo.AssTitle
	outAssDutyInfo.DutyTitle = ContInfo.Title
	outAssDutyInfo.ClassId = ContInfo.AssPartId
	classErr, classInfo := assessment.GetDutyClassCont(ContInfo.AssPartId)
	if classErr == true {
		outAssDutyInfo.ClassTitle = classInfo.Title
	}
	isTrue = true
	return
}

//以部门为维度获取考核项目
func (a *Assessment) DepartmentAssess(c *gin.Context) {
	var requestData departAssessType
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "参数错误！请重新提交！", c)
		return
	}
	if requestData.DepartmentId == 0 {
		response.Result(102, err, "参数错误！请重新提交！", c)
		return
	}

	isTrue, userCont := commonus.ClientIdentity()
	if isTrue != true {
		response.Result(103, err, "您的身份令牌已经失效！请重新登录获取身份令牌！", c)
		return
	}

	if requestData.GroupId == 0 {
		groupId, groupErr := strconv.Atoi(userCont.Company)
		if groupErr == nil {
			requestData.GroupId = groupId
		} else {
			response.Result(104, err, "参数错误！请重新提交！", c)
			return
		}
	}

	dayTime := time.Now()
	monthData := commonus.TimeStampToDate(dayTime.Unix(), 10) //当月
	switch requestData.DayState {
	case 1:
		monthData = commonus.TimeStampToDate(dayTime.Unix(), 10) //当月
	case 2:
		lastOneMonthStart, _ := commonus.AppointTimeFrontMonth(dayTime, 1)
		monthData = commonus.TimeStampToDate(lastOneMonthStart, 10) //上一个月
	case 3:
		lastOneMonthStart, _ := commonus.AppointTimeFrontMonth(dayTime, 2)
		monthData = commonus.TimeStampToDate(lastOneMonthStart, 10) //上两个月
	default:
		monthData = commonus.TimeStampToDate(dayTime.Unix(), 10) //当月
	}
	var ContInfo []departAssessOutType
	departErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DepartDuty{}).Select("departduty.*", "dutycontent.dc_title", "dutycontent.dc_state", "dutycontent.dc_user_dump", "dutycontent.dc_dump", "dutycontent.dc_user_type", "dutycontent.dc_parent").Joins("left join dutycontent on departduty.de_duty = dutycontent.dc_id").Where("(`de_partid` = ? AND `de_group` = ? AND `de_satte` = 1) AND ((`dc_user_dump` = ? OR `dc_dump` = ?) AND `dc_state` = 1)", requestData.DepartmentId, requestData.GroupId, userCont.Key, userCont.Deparment).Find(&ContInfo).Error
	if departErr != nil {
		response.Result(105, err, "没有要考核的项目！", c)
		return
	}

	var outContMap []departAssessOutType
	// outMapList := []commonus.MapOut()
	for _, val := range ContInfo {
		var outCont departAssessOutType
		outCont.Id = val.Id
		outCont.Titles = val.Titles
		outCont.Rescore = val.Rescore
		outCont.OutID = strconv.FormatInt(val.Id, 10)
		isTrue := JudgeResAssEssExam(val.Id, int64(requestData.DepartmentId), monthData)
		outCont.IsTrue = isTrue
		if isTrue == false {
			outContMap = append(outContMap, outCont)
		}
	}
	// JudgeResAssEssExam(val.DutyId, val.PartId, dataStr)  .Where("(`dc_user_dump` = ? OR `dc_dump` = ?) AND `dc_state` = 1", userCont.Key, userCont.DepartmentId)
	response.Result(0, outContMap, "查询成功！", c)
}

//以部门为基准填写考核数据
func (a *Assessment) DepartmentAssessData(c *gin.Context) {
	var requestData DepartDutyData
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "参数错误！请重新提交！", c)
		return
	}
	var orderId int64
	var departId int
	var executorUser int64
	var executorDepart int
	orderId = 0
	departId = 0
	executorUser = 0
	executorDepart = 0
	if requestData.OrderId == "" {
		response.Result(102, err, "未知订单号！请重新提交！", c)
		return
	} else {
		orderIdVal, orderIdErr := strconv.ParseInt(requestData.OrderId, 10, 64)
		if orderIdErr == nil {
			orderId = orderIdVal
		} else {
			response.Result(103, err, "未知订单号！请重新提交！", c)
			return
		}
	}
	var assessLogCont assessmentmodel.AssessmentLog //考核记录
	orderContErr := global.GVA_DB_Performanceappraisal.Select("al_id").Where("`al_order_id` = ?", orderId).First(&assessLogCont).Error
	if orderContErr == nil {
		response.Result(121, orderId, "该订单已经提交审批！请不要重复提交审批！", c)
		return
	}

	if requestData.Title == "" {
		response.Result(104, err, "未知考核标题！请重新提交！", c)
		return
	}
	if requestData.DepartId == "" {
		response.Result(105, err, "未知被考核的部门！请重新提交！", c)
		return
	} else {
		departIdVal, departIdErr := strconv.Atoi(requestData.DepartId)
		if departIdErr == nil {
			departId = departIdVal
		} else {
			response.Result(106, err, "未知被考核的部门！请重新提交！", c)
			return
		}
	}

	if requestData.ExecutorUser == "" {
		response.Result(107, err, "未知考核执行人！请重新提交！", c)
		return
	} else {
		executorUserVal, executorUserErr := strconv.ParseInt(requestData.ExecutorUser, 10, 64)
		if executorUserErr == nil {
			executorUser = executorUserVal
		} else {
			response.Result(108, err, "未知考核执行人！请重新提交！", c)
			return
		}
	}

	if requestData.ExecutorDepart == "" {
		response.Result(109, err, "未知考核执行部门！请重新提交！", c)
		return
	} else {
		executorDepartVal, executorDepartErr := strconv.Atoi(requestData.ExecutorDepart)
		if executorDepartErr == nil {
			executorDepart = executorDepartVal
		} else {
			response.Result(110, err, "未知考核执行部门！请重新提交！", c)
			return
		}
	}
	if requestData.DateTime == "" {
		response.Result(111, err, "未知考核时间！请重新提交！", c)
		return
	}
	monthTimeStr := requestData.DateTime + "-01 12:00:00"
	fileTime, fileTimeErr := commonus.DateToTimeStampEs(monthTimeStr)
	if fileTimeErr != true {
		response.Result(112, err, "考核时间格式错误！请重新提交！", c)
		return
	}

	if len(requestData.DutyList) <= 0 {
	}
	for reIndex, reData := range requestData.DutyList {
		if reData.DutyId == "" {
			response.Result(113, reIndex, "未知考核项目！请重新提交！", c)
			return
		}
		if reData.DeductPoints > reData.ReferenceScore {
			response.Result(114, reIndex, "考核项目扣分大于参考分！请重新提交！", c)
			return
		}
		if reData.ExtraPoints > reData.ReferenceScore {
			response.Result(115, reIndex, "考核项目加分大于参考分！请重新提交！", c)
			return
		}

		if reData.DeductPoints > 0 && reData.DeductPointsText == "" {
			response.Result(1114, reData.DutyId, "考核项目有扣分，必须填写扣分原因！", c)
			return
		}
		if reData.ExtraPoints > 0 && reData.ExtraPointsText == "" {
			response.Result(1115, reData.DutyId, "考核项目有加分，必须填写加分原因！", c)
			return
		}
	}
	var assessLog assessmentmodel.AssessmentLog //考核记录
	// assessLog.Id = commonus.GetFileNumberEs()
	assessLog.Title = requestData.Title
	assessLog.Assdepart = departId
	assessLog.ExecutorUser = executorUser
	assessLog.ExecutorDepart = executorDepart
	assessLog.ExecutorTime = fileTime
	assessLog.OrderId = orderId
	assessLog.States = 1
	assessLog.AddTime = time.Now().Unix()
	assessLog.EiteTime = time.Now().Unix()

	var dutyListMap []assessmentmodel.Departscores
	for _, dutyCont := range requestData.DutyList {
		var dutyListCont assessmentmodel.Departscores
		dutyId, orderIdErr := strconv.ParseInt(dutyCont.DutyId, 10, 64)
		if orderIdErr != nil {
			response.Result(116, dutyCont.DutyId, "指定考核项目ID不正确！", c)
			return
		}
		assIsTrue, assInfo := commonus.GetDutyContDepart(dutyId)
		if assIsTrue != true {
			response.Result(117, dutyCont.DutyId, "指定考核项目已禁止使用！", c)
			return
		}
		classId := assInfo.ClassId
		assessId := assInfo.AssessId
		actualScore := dutyCont.ReferenceScore - dutyCont.DeductPoints + dutyCont.ExtraPoints
		if actualScore < 0 {
			actualScore = 0
		}
		dutyListCont.Id = commonus.GetFileNumberEs()
		dutyListCont.ClassId = classId
		dutyListCont.AssessId = assessId
		dutyListCont.DutyId = dutyId
		dutyListCont.DeductPoints = int64(dutyCont.DeductPoints)
		dutyListCont.ExtraPoints = int64(dutyCont.ExtraPoints)
		// dutyListCont.Score = requestData.Score
		dutyListCont.Score = int64(actualScore)
		dutyListCont.FileTime = fileTime
		dutyListCont.DepartId = int64(departId)
		dutyListCont.CommentUser = executorUser
		dutyListCont.AddTime = time.Now().Unix()
		dutyListCont.EiteTime = time.Now().Unix()
		dutyListCont.State = 1
		dutyListCont.DeductPointsText = dutyCont.DeductPointsText
		dutyListCont.ExtraPointsText = dutyCont.ExtraPointsText
		dutyListMap = append(dutyListMap, dutyListCont)
	}
	dutyList, dutyListErr := json.Marshal(dutyListMap)
	if dutyListErr == nil {
		assessLog.DutyList = string(dutyList)
	}
	outContMap := commonus.MapOut()
	outContMap["assessLog"] = assessLog
	outContMap["dutyListMap"] = dutyListMap
	outContMap["lookid"] = requestData.OrderId
	//写入数据
	affairDb := global.GVA_DB_Performanceappraisal.Begin()
	assessLogErr := affairDb.Create(&assessLog).Error
	dutyListMapErr := affairDb.Create(&dutyListMap).Error
	if assessLogErr == nil && dutyListMapErr == nil {
		affairDbErr := affairDb.Commit().Error
		if affairDbErr == nil {
			response.Result(0, outContMap, "数据写入成功！", c)
		} else {
			response.Result(118, outContMap, "数据写入失败！", c)
		}
	} else {
		affairDbErr := affairDb.Rollback().Error
		if affairDbErr == nil {
			response.Result(119, outContMap, "数据写入失败！", c)
		} else {
			response.Result(120, outContMap, "数据写入失败！", c)
		}
	}
}

//查看审批详细内容
func (a *Assessment) LookDepartmentAssessInfo(c *gin.Context) {
	var requestData LookDutyCont
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "参数错误！请重新提交！", c)
		return
	}
	if requestData.Id == "" {
		response.Result(102, err, "参数错误！不可产看！", c)
		return
	}
	orderId, orderIdErr := strconv.ParseInt(requestData.Id, 10, 64)
	if orderIdErr != nil {
		response.Result(103, err, "参数错误！不可产看！", c)
		return
	}
	var assessLogCont assessmentmodel.AssessmentLog //考核记录
	orderContErr := global.GVA_DB_Performanceappraisal.Where("`al_order_id` = ?", orderId).First(&assessLogCont).Error
	if orderContErr != nil {
		response.Result(104, orderId, "该审批单不存在！请检查是否查看错误！", c)
		return
	}
	var dutyListMap []assessmentmodel.Departscores
	jsonErr := json.Unmarshal([]byte(assessLogCont.DutyList), &dutyListMap)
	if jsonErr != nil {
		response.Result(105, jsonErr, "审批详情异常，不可查看！请联系系统管理员排查故障！", c)
		return
	}
	var lookSeeDutyContMap []LookSeeDutyCont
	outList := commonus.MapOutint()
	for index, val := range dutyListMap {
		var lookSeeDutyCont LookSeeDutyCont
		outInfo := commonus.MapOut()
		outInfo["id"] = strconv.FormatInt(val.Id, 10)
		outInfo["classID"] = strconv.FormatInt(val.ClassId, 10)
		outInfo["assessId"] = strconv.FormatInt(val.AssessId, 10)
		outInfo["dutyId"] = strconv.FormatInt(val.DutyId, 10)
		outInfo["deductPoints"] = strconv.FormatInt(val.DeductPoints, 10)
		outInfo["extraPoints"] = strconv.FormatInt(val.ExtraPoints, 10)
		outInfo["score"] = strconv.FormatInt(val.Score, 10)
		outInfo["departId"] = strconv.FormatInt(val.DepartId, 10)
		outInfo["commentUser"] = strconv.FormatInt(val.CommentUser, 10)

		lookSeeDutyCont.Id = strconv.FormatInt(val.Id, 10)
		lookSeeDutyCont.ClassID = strconv.FormatInt(val.ClassId, 10)
		lookSeeDutyCont.AssessId = strconv.FormatInt(val.AssessId, 10)
		lookSeeDutyCont.DutyId = strconv.FormatInt(val.DutyId, 10)
		lookSeeDutyCont.DeductPoints = strconv.FormatInt(val.DeductPoints, 10)
		lookSeeDutyCont.ExtraPoints = strconv.FormatInt(val.ExtraPoints, 10)
		lookSeeDutyCont.Score = strconv.FormatInt(val.Score, 10)
		lookSeeDutyCont.DepartId = strconv.FormatInt(val.DepartId, 10)
		lookSeeDutyCont.CommentUser = strconv.FormatInt(val.CommentUser, 10)

		lookSeeDutyCont.DeductPointstext = val.DeductPointsText
		lookSeeDutyCont.ExtraPointstext = val.ExtraPointsText

		// dtyContErr, dtyCont := GetDutyInfoCont(val.DutyId)
		dtyContErr, dtyCont := commonus.GetDutyContDepart(val.DutyId)
		if dtyContErr == true {
			outInfo["classTitle"] = dtyCont.ClassTitle
			outInfo["assessTitle"] = dtyCont.AssTitle
			outInfo["dutyTitle"] = dtyCont.Title

			lookSeeDutyCont.ClassTitle = dtyCont.ClassTitle
			lookSeeDutyCont.AssessTitle = dtyCont.AssTitle
			lookSeeDutyCont.DutyTitle = dtyCont.Title
		} else {
			outInfo["classTitle"] = ""
			outInfo["assessTitle"] = ""
			outInfo["dutyTitle"] = ""
		}
		outList[index] = outInfo
		lookSeeDutyContMap = append(lookSeeDutyContMap, lookSeeDutyCont)
	}
	outContMap := commonus.MapOut()
	outContMap["assessLog"] = assessLogCont
	outContMap["dutyListMap"] = lookSeeDutyContMap
	// outContMap["dutyListMaps"] = dutyListMap
	response.Result(0, outContMap, "数据写入成功！", c)
}

//查询自建应用审批单当前状态
func (a *Assessment) LookOpenApprovalDataInfo(c *gin.Context) {
	var requestData LookDutyCont
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "参数错误！请重新提交！", c)
		return
	}
	if requestData.Id == "" {
		response.Result(102, err, "参数错误！不可产看！", c)
		return
	}
	orderId, orderIdErr := strconv.ParseInt(requestData.Id, 10, 64)
	if orderIdErr != nil {
		response.Result(103, err, "参数错误！不可产看！", c)
		return
	}
	var assessLogCont assessmentmodel.AssessmentLog //考核记录
	orderContErr := global.GVA_DB_Performanceappraisal.Where("`al_order_id` = ?", orderId).First(&assessLogCont).Error
	if orderContErr != nil {
		response.Result(104, orderId, "该审批单不存在！请检查是否查看错误！", c)
		return
	}
	var oAS sendmessage.OpenApprovalState
	oAS.ThirdNo = requestData.Id
	callBackData, isTrue, msg := oAS.SendMessage("school")
	if isTrue != true {
		response.Result(105, string(callBackData), msg, c)
		return
	}
	var jsonToOpenApprovalStruct OpenApprovalDataInfo
	jsonErr := json.Unmarshal(callBackData, &jsonToOpenApprovalStruct)
	if jsonErr != nil {
		response.Result(106, string(callBackData), "数据解析错误", c)
		return
	}
	if jsonToOpenApprovalStruct.Errcode != 0 {
		response.Result(107, jsonToOpenApprovalStruct, jsonToOpenApprovalStruct.Errmsg, c)
		return
	}
	response.Result(0, jsonToOpenApprovalStruct, "查询成功！", c)
}

//查看本部门提交的和个人提交的审批
func (a *Assessment) LookPersonalOrDepartment(c *gin.Context) {
	var requestData commonus.PageSetLimt
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		// response.Result(101, err, "参数错误！请重新提交！", c)
		// return
	}
	if requestData.PageSize == 0 {
		requestData.PageSize = 20
	}
	if requestData.Page <= 0 {
		requestData.Page = 1
	}
	offSetPage := commonus.CalculatePages(requestData.Page, requestData.PageSize)
	isTrue, userInfo := commonus.ClientIdentity()
	if isTrue != true {
		response.Result(103, err, "您的身份令牌已经失效！请重新登录获取身份令牌！", c)
		return
	}
	departmentID, departmentIDErr := strconv.ParseInt(userInfo.Deparment, 10, 64)
	if departmentIDErr != nil {
		response.Result(104, err, "参数错误！请重新提交！", c)
		return
	}
	gormDb := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.AssessmentLog{})
	maxErr, maxCont := commonus.GetPositionMaxWeight(departmentID)
	// fmt.Printf("最大值：======>%v======>%v\n", maxErr, maxCont)
	if maxErr == true {
		postID, postIDErr := strconv.ParseInt(userInfo.Position, 10, 64)
		if postIDErr == nil {
			if maxCont.Id == postID {
				gormDb = gormDb.Where("`al_executor_depart` = ?", departmentID)
			} else {
				gormDb = gormDb.Where("`al_executor_user` = ?", userInfo.Key)
			}
		} else {
			gormDb = gormDb.Where("`al_executor_user` = ?", userInfo.Key)
		}
	} else {
		gormDb = gormDb.Where("`al_executor_user` = ?", userInfo.Key)
	}
	var total int64
	totalErr := gormDb.Count(&total).Error
	if totalErr != nil {
		total = 0
	}
	var assessList []assessmentmodel.AssessmentLog
	assessListerr := gormDb.Limit(requestData.PageSize).Offset(offSetPage).Order("al_id desc").Find(&assessList).Error
	if assessListerr != nil {
		response.Result(102, assessListerr, "数据获取失败！", c)
		return
	}
	var personalOrDepartment []PersonalOrDepartment
	for _, val := range assessList {
		var personalOrDepartments PersonalOrDepartment
		personalOrDepartments.Id = val.Id
		personalOrDepartments.Title = val.Title
		personalOrDepartments.Assdepart = val.Assdepart
		personalOrDepartments.ExecutorUser = val.ExecutorUser
		personalOrDepartments.ExecutorDepart = val.ExecutorDepart
		personalOrDepartments.ExecutorTime = val.ExecutorTime
		personalOrDepartments.OrderId = val.OrderId
		personalOrDepartments.States = val.States
		personalOrDepartments.AddTime = val.AddTime
		personalOrDepartments.EiteTime = val.EiteTime
		personalOrDepartments.DutyList = val.DutyList
		bfIsTrue, bfCont := commonus.GetBranchFactory(int64(val.Assdepart))
		if bfIsTrue == true {
			personalOrDepartments.AssdepartTitle = bfCont.Name
		}
		personalOrDepartment = append(personalOrDepartment, personalOrDepartments)
	}

	countSum := len(personalOrDepartment)
	printData := commonus.OutPutList(total, int64(countSum), requestData.Page, requestData.PageSize, personalOrDepartment)
	response.Result(0, printData, "查询成功！", c)
}

//获取班组列表
func (a *Assessment) GetTeamList(c *gin.Context) {
	var teamList []testpage.Teaming
	err := global.GVA_DB_Master.Order("tm_long ASC,tm_id ASC").Find(&teamList).Error
	if err != nil {
		response.Result(101, err, "查询失败！", c)
		return
	}
	response.Result(0, teamList, "查询成功！", c)
}