eta_api/controllers/assessment/assessment_researcher.go

package assessment

import (
	"encoding/json"
	"eta/eta_api/controllers"
	"eta/eta_api/models"
	"eta/eta_api/models/system"
	"eta/eta_api/utils"
	"fmt"
	"github.com/rdlucklib/rdluck_tools/paging"
	"strconv"
	"strings"
	"time"
)

// AssessmentResearcherController 考核研究员
type AssessmentResearcherController struct {
	controllers.BaseAuthController
}

// Add
// @Title 新增研究员
// @Description 新增研究员
// @Param	request	body models.AssessmentResearcherAddReq true "type json string"
// @Success 200 string "操作成功"
// @router /researcher/add [post]
func (this *AssessmentResearcherController) Add() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req models.AssessmentResearcherAddReq
	if e := json.Unmarshal(this.Ctx.Input.RequestBody, &req); e != nil {
		br.Msg = "参数有误"
		br.ErrMsg = fmt.Sprintf("参数解析失败, %v", e)
		return
	}
	if req.AdminId <= 0 {
		br.Msg = "请选择研究员"
		return
	}
	disabledResearcher := new(models.AssessmentResearcher)
	researcherOb := new(models.AssessmentResearcher)
	mappingOb := new(models.AssessmentResearcherAdminMapping)

	// 去重校验：系统用户ID
	{
		cond := fmt.Sprintf(` AND %s = ?`, researcherOb.Cols().AdminId)
		pars := make([]interface{}, 0)
		pars = append(pars, req.AdminId)
		exists, e := researcherOb.GetItemByCondition(cond, pars, "")
		if e != nil && !utils.IsErrNoRow(e) {
			br.Msg = "操作失败"
			br.ErrMsg = fmt.Sprintf("获取研究员失败, %v", e)
			return
		}
		// PS.由于删除研究员需要保留历史填报数据，如果研究员被删除(即禁用）那么重新启用即可
		if exists != nil && exists.AssessmentResearcherId > 0 {
			if exists.Enabled == models.AssessmentResearcherEnabled {
				br.Msg = "该研究员已添加，请勿重复添加"
				return
			}
			disabledResearcher = exists
		}
	}

	sysAdmin, e := system.GetSysAdminById(req.AdminId)
	if e != nil {
		if utils.IsErrNoRow(e) {
			br.Msg = "该用户不存在，请重新选择"
			return
		}
		br.Msg = "操作失败"
		br.ErrMsg = fmt.Sprintf("获取系统用户失败, %v", e)
		return
	}
	if sysAdmin == nil || sysAdmin.AdminId <= 0 {
		br.Msg = "该用户不存在，请重新选择"
		return
	}
	if sysAdmin.Enabled != 1 {
		br.Msg = "该用户被禁用，请重新选择"
		return
	}

	var researcherId int
	if disabledResearcher != nil && disabledResearcher.AssessmentResearcherId > 0 {
		disabledResearcher.RealName = sysAdmin.RealName
		disabledResearcher.Enabled = models.AssessmentResearcherEnabled
		disabledResearcher.ModifyTime = time.Now().Local()
		updateCols := []string{researcherOb.Cols().RealName, researcherOb.Cols().Enabled, researcherOb.Cols().ModifyTime}
		if e := disabledResearcher.Update(updateCols); e != nil {
			br.Msg = "操作失败"
			br.ErrMsg = fmt.Sprintf("重新启用研究员失败, %v", e)
			return
		}
		researcherId = disabledResearcher.AssessmentResearcherId

		// 清除原有关联
		cond := fmt.Sprintf(`%s = ?`, mappingOb.Cols().AssessmentResearcherId)
		pars := make([]interface{}, 0)
		pars = append(pars, researcherId)
		if e = mappingOb.RemoveByCondition(cond, pars); e != nil {
			br.Msg = "操作失败"
			br.ErrMsg = fmt.Sprintf("清空权限失败, %v", e)
			return
		}
	} else {
		newResearcher := new(models.AssessmentResearcher)
		newResearcher.AdminId = req.AdminId
		newResearcher.RealName = sysAdmin.RealName
		newResearcher.Enabled = models.AssessmentResearcherEnabled
		newResearcher.CreateTime = time.Now().Local()
		newResearcher.ModifyTime = time.Now().Local()
		if e = newResearcher.Create(); e != nil {
			br.Msg = "操作失败"
			br.ErrMsg = fmt.Sprintf("新增研究员失败, %v", e)
			return
		}
		researcherId = newResearcher.AssessmentResearcherId
	}

	// 查看/统计权限
	mappings := make([]*models.AssessmentResearcherAdminMapping, 0)
	if len(req.ViewAdminIds) > 0 {
		for _, v := range req.ViewAdminIds {
			m := new(models.AssessmentResearcherAdminMapping)
			m.AssessmentResearcherId = researcherId
			m.AdminId = req.AdminId
			m.AuthAdminId = v
			m.AuthType = models.AssessmentResearcherAdminAuthTypeView
			mappings = append(mappings, m)
		}
	}
	if len(req.AssessmentAdminIds) > 0 {
		for _, v := range req.AssessmentAdminIds {
			m := new(models.AssessmentResearcherAdminMapping)
			m.AssessmentResearcherId = researcherId
			m.AdminId = req.AdminId
			m.AuthAdminId = v
			m.AuthType = models.AssessmentResearcherAdminAuthTypeStatistics
			mappings = append(mappings, m)
		}
	}
	if len(mappings) > 0 {
		if e = mappingOb.CreateMulti(mappings); e != nil {
			br.Msg = "操作失败"
			br.ErrMsg = fmt.Sprintf("批量新增权限失败, %v", e)
			return
		}
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "操作成功"
}

// Edit
// @Title 编辑研究员
// @Description 编辑研究员
// @Param	request	body models.AssessmentResearcherEditReq true "type json string"
// @Success 200 string "操作成功"
// @router /researcher/edit [post]
func (this *AssessmentResearcherController) Edit() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req models.AssessmentResearcherEditReq
	if e := json.Unmarshal(this.Ctx.Input.RequestBody, &req); e != nil {
		br.Msg = "参数有误"
		br.ErrMsg = fmt.Sprintf("参数解析失败, %v", e)
		return
	}
	if req.AssessmentResearcherId <= 0 {
		br.Msg = "参数有误"
		br.ErrMsg = fmt.Sprintf("参数有误, AssessmentResearcherId: %d", req.AssessmentResearcherId)
		return
	}

	researcherOb := new(models.AssessmentResearcher)
	researcher, e := researcherOb.GetItemById(req.AssessmentResearcherId)
	if e != nil {
		if utils.IsErrNoRow(e) {
			br.Msg = "研究员不存在，请刷新页面"
			return
		}
		br.Msg = "操作失败"
		br.ErrMsg = fmt.Sprintf("获取研究员失败, %v", e)
		return
	}
	if researcher.Enabled == models.AssessmentResearcherDisabled {
		br.Msg = "研究员不存在，请刷新页面"
		return
	}

	// 查看/统计权限
	mappings := make([]*models.AssessmentResearcherAdminMapping, 0)
	if len(req.ViewAdminIds) > 0 {
		for _, v := range req.ViewAdminIds {
			m := new(models.AssessmentResearcherAdminMapping)
			m.AssessmentResearcherId = researcher.AssessmentResearcherId
			m.AdminId = researcher.AdminId
			m.AuthAdminId = v
			m.AuthType = models.AssessmentResearcherAdminAuthTypeView
			mappings = append(mappings, m)
		}
	}
	if len(req.AssessmentAdminIds) > 0 {
		for _, v := range req.AssessmentAdminIds {
			m := new(models.AssessmentResearcherAdminMapping)
			m.AssessmentResearcherId = researcher.AssessmentResearcherId
			m.AdminId = researcher.AdminId
			m.AuthAdminId = v
			m.AuthType = models.AssessmentResearcherAdminAuthTypeStatistics
			mappings = append(mappings, m)
		}
	}
	// 清空关联后新增
	mappingOb := new(models.AssessmentResearcherAdminMapping)
	{
		cond := fmt.Sprintf(`%s = ?`, mappingOb.Cols().AssessmentResearcherId)
		pars := make([]interface{}, 0)
		pars = append(pars, researcher.AssessmentResearcherId)
		if e = mappingOb.RemoveByCondition(cond, pars); e != nil {
			br.Msg = "操作失败"
			br.ErrMsg = fmt.Sprintf("清空权限失败, %v", e)
			return
		}
	}
	if len(mappings) > 0 {
		if e = mappingOb.CreateMulti(mappings); e != nil {
			br.Msg = "操作失败"
			br.ErrMsg = fmt.Sprintf("批量新增权限失败, %v", e)
			return
		}
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "操作成功"
}

// Remove
// @Title 删除研究员
// @Description 删除研究员
// @Param	request	body models.AssessmentResearcherRemoveReq true "type json string"
// @Success 200 string "操作成功"
// @router /researcher/remove [post]
func (this *AssessmentResearcherController) Remove() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req models.AssessmentResearcherRemoveReq
	if e := json.Unmarshal(this.Ctx.Input.RequestBody, &req); e != nil {
		br.Msg = "参数有误"
		br.ErrMsg = fmt.Sprintf("参数解析失败, %v", e)
		return
	}
	if req.AssessmentResearcherId <= 0 {
		br.Msg = "参数有误"
		br.ErrMsg = fmt.Sprintf("参数有误, AssessmentResearcherId: %d", req.AssessmentResearcherId)
		return
	}

	researcherOb := new(models.AssessmentResearcher)
	researcher, e := researcherOb.GetItemById(req.AssessmentResearcherId)
	if e != nil {
		if utils.IsErrNoRow(e) {
			br.Ret = 200
			br.Success = true
			br.Msg = "操作成功"
			return
		}
		br.Msg = "操作失败"
		br.ErrMsg = fmt.Sprintf("获取研究员失败, %v", e)
		return
	}
	if researcher.Enabled == models.AssessmentResearcherDisabled {
		br.Ret = 200
		br.Success = true
		br.Msg = "操作成功"
		return
	}

	// 由于要保留历史填报数据，这里实际为禁用操作
	updateCols := []string{researcherOb.Cols().Enabled, researcherOb.Cols().ModifyTime}
	researcher.Enabled = models.AssessmentResearcherDisabled
	researcher.ModifyTime = time.Now()
	if e = researcher.Update(updateCols); e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = fmt.Sprintf("禁用研究员失败, %v", e)
		return
	}

	// 关联也不需要清理
	//adminMappingOb := new(models.AssessmentResearcherAdminMapping)
	//{
	//	cond := fmt.Sprintf(`%s = ?`, adminMappingOb.Cols().AdminId)
	//	pars := make([]interface{}, 0)
	//	pars = append(pars, researcher.AdminId)
	//	if e = adminMappingOb.RemoveByCondition(cond, pars); e != nil {
	//		br.Msg = "操作失败"
	//		br.ErrMsg = fmt.Sprintf("清空权限失败, %v", e)
	//		return
	//	}
	//}
	//varietyMappingOb := new(models.AssessmentResearcherVarietyMapping)
	//{
	//	cond := fmt.Sprintf(`%s = ?`, varietyMappingOb.Cols().AdminId)
	//	pars := make([]interface{}, 0)
	//	pars = append(pars, researcher.AdminId)
	//	if e = varietyMappingOb.RemoveByCondition(cond, pars); e != nil {
	//		br.Msg = "操作失败"
	//		br.ErrMsg = fmt.Sprintf("清空品种关联失败, %v", e)
	//		return
	//	}
	//}

	br.Ret = 200
	br.Success = true
	br.Msg = "操作成功"
}

// Detail
// @Title 研究员详情
// @Description 研究员详情
// @Param   AssessmentResearcherId  query  int  true  "研究员ID"
// @Success 200 string "操作成功"
// @router /researcher/detail [get]
func (this *AssessmentResearcherController) Detail() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	researcherId, _ := this.GetInt("AssessmentResearcherId")
	if researcherId <= 0 {
		br.Msg = "参数有误"
		br.ErrMsg = fmt.Sprintf("参数有误, AssessmentResearcherId: %d", researcherId)
		return
	}

	researcherOb := new(models.AssessmentResearcher)
	researcher, e := researcherOb.GetItemById(researcherId)
	if e != nil {
		if utils.IsErrNoRow(e) {
			br.Msg = "研究员不存在，请重新页面"
			return
		}
		br.Msg = "获取失败"
		br.ErrMsg = fmt.Sprintf("获取研究员失败, %v", e)
		return
	}
	if researcher.Enabled == models.AssessmentResearcherDisabled {
		br.Msg = "研究员不存在，请刷新页面"
		return
	}
	resp := researcher.Format2Detail()

	// 获取系统用户
	adminMapping := make(map[int]*system.Admin)
	{
		admins, e := system.GetSysAdminList(``, make([]interface{}, 0), []string{}, "")
		if e != nil {
			br.Msg = "获取失败"
			br.ErrMsg = fmt.Sprintf("获取系统用户失败, %v", e)
			return
		}
		for _, v := range admins {
			adminMapping[v.AdminId] = v
		}
	}

	mappings := make([]*models.AssessmentResearcherAdminMapping, 0)
	{
		mappingOb := new(models.AssessmentResearcherAdminMapping)
		cond := fmt.Sprintf(` AND %s = ?`, mappingOb.Cols().AdminId)
		pars := make([]interface{}, 0)
		pars = append(pars, researcher.AdminId)
		list, e := mappingOb.GetItemsByCondition(cond, pars, []string{}, "")
		if e != nil {
			br.Msg = "获取失败"
			br.ErrMsg = fmt.Sprintf("获取研究员用户权限关系失败, %v", e)
			return
		}
		mappings = list
	}
	for _, m := range mappings {
		ad := adminMapping[m.AuthAdminId]
		if ad == nil {
			continue
		}
		// 详情这里只显示启用的系统用户
		if ad.Enabled != 1 {
			continue
		}
		ar := models.AssessmentResearcherDetail{
			AdminId:  m.AuthAdminId,
			RealName: ad.RealName,
			Enabled:  ad.Enabled,
		}
		if m.AuthType == models.AssessmentResearcherAdminAuthTypeView {
			resp.ViewAdmins = append(resp.ViewAdmins, ar)
			continue
		}
		resp.AssessmentAdmins = append(resp.AssessmentAdmins, ar)
	}

	br.Data = resp
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
}

// PageList
// @Title 研究员列表-分页
// @Description 研究员列表-分页
// @Param	request	body models.AssessmentResearcherPageListReq true "type json string"
// @Success 200 string "操作成功"
// @router /researcher/page_list [get]
func (this *AssessmentResearcherController) PageList() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	params := new(models.AssessmentResearcherPageListReq)
	if e := this.ParseForm(params); e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "参数解析失败, Err: " + e.Error()
		return
	}
	params.RealName = strings.TrimSpace(params.RealName)
	resp := new(models.AssessmentResearcherPageListResp)
	resp.List = make([]*models.AssessmentResearcherDetail, 0)

	// 分页
	var startSize int
	if params.PageSize <= 0 {
		params.PageSize = utils.PageSize20
	}
	if params.CurrentIndex <= 0 {
		params.CurrentIndex = 1
	}
	startSize = utils.StartIndex(params.CurrentIndex, params.PageSize)

	// 筛选条件
	researcherOb := new(models.AssessmentResearcher)
	cond := ``
	pars := make([]interface{}, 0)
	{
		// 研究员姓名
		if params.RealName != "" {
			kw := fmt.Sprint("%", params.RealName, "%")
			cond += fmt.Sprintf(` AND %s LIKE ?`, researcherOb.Cols().RealName)
			pars = append(pars, kw)
		}

		// 研究员IDs
		if params.AssessmentResearcherIds != "" {
			var researcherIds []int
			arr := strings.Split(params.AssessmentResearcherIds, ",")
			for _, v := range arr {
				i, _ := strconv.Atoi(v)
				if i > 0 {
					researcherIds = append(researcherIds, i)
				}
			}
			if len(researcherIds) == 0 {
				resp.Paging = paging.GetPaging(params.CurrentIndex, params.PageSize, 0)
				br.Data = resp
				br.Ret = 200
				br.Success = true
				br.Msg = "获取成功"
				return
			}
			cond += fmt.Sprintf(` AND %s IN (?)`, researcherOb.Cols().PrimaryId)
			pars = append(pars, researcherIds)
		}

		// 仅获取自己有权限的，与研究员IDs条件冲突
		if params.AssessmentResearcherIds == "" && params.ResearcherAuthType > 0 {
			// 自己如果是研究员的话要把自己也加进去
			var researcherIds []int
			condResearcher := fmt.Sprintf(` AND %s = ?`, researcherOb.Cols().AdminId)
			parsResearcher := make([]interface{}, 0)
			parsResearcher = append(parsResearcher, sysUser.AdminId)
			researcher, e := researcherOb.GetItemByCondition(condResearcher, parsResearcher, "")
			if e != nil && !utils.IsErrNoRow(e) {
				br.Msg = "获取失败"
				br.ErrMsg = fmt.Sprintf("获取研究员失败, %v", e)
				return
			}
			if researcher != nil && researcher.AssessmentResearcherId > 0 {
				researcherIds = append(researcherIds, researcher.AssessmentResearcherId)
			}

			mappingOb := new(models.AssessmentResearcherAdminMapping)
			condMapping := fmt.Sprintf(` AND %s = ? AND %s = ?`, mappingOb.Cols().AuthAdminId, mappingOb.Cols().AuthType)
			parsMapping := make([]interface{}, 0)
			parsMapping = append(parsMapping, sysUser.AdminId, params.ResearcherAuthType)
			list, e := mappingOb.GetItemsByCondition(condMapping, parsMapping, []string{}, "")
			if e != nil {
				br.Msg = "获取失败"
				br.ErrMsg = fmt.Sprintf("获取用户有权限的研究员失败, %v", e)
				return
			}
			for _, v := range list {
				researcherIds = append(researcherIds, v.AssessmentResearcherId)
			}
			if len(researcherIds) == 0 {
				resp.Paging = paging.GetPaging(params.CurrentIndex, params.PageSize, 0)
				br.Data = resp
				br.Ret = 200
				br.Success = true
				br.Msg = "获取成功"
				return
			}
			cond += fmt.Sprintf(` AND %s IN (?)`, researcherOb.Cols().PrimaryId)
			pars = append(pars, researcherIds)
		}

		// 仅显示启用的
		if params.OnlyEnabled {
			cond += fmt.Sprintf(` AND %s = ?`, researcherOb.Cols().Enabled)
			pars = append(pars, models.AssessmentResearcherEnabled)
		}
	}

	// 分页列表
	total, e := researcherOb.GetCountByCondition(cond, pars)
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = fmt.Sprintf("获取研究员列表总数失败, %v", e)
		return
	}
	researchers, e := researcherOb.GetPageItemsByCondition(cond, pars, []string{}, "", startSize, params.PageSize)
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = fmt.Sprintf("获取研究员失败, %v", e)
		return
	}
	var researcherIds []int
	for _, v := range researchers {
		researcherIds = append(researcherIds, v.AssessmentResearcherId)
	}
	if total == 0 || len(researcherIds) == 0 {
		resp.Paging = paging.GetPaging(params.CurrentIndex, params.PageSize, 0)
		br.Data = resp
		br.Ret = 200
		br.Success = true
		br.Msg = "获取成功"
		return
	}

	// 获取系统用户
	adminMapping := make(map[int]*system.Admin)
	{
		admins, e := system.GetSysAdminList(``, make([]interface{}, 0), []string{}, "")
		if e != nil {
			br.Msg = "获取失败"
			br.ErrMsg = fmt.Sprintf("获取系统用户失败, %v", e)
			return
		}
		for _, v := range admins {
			adminMapping[v.AdminId] = v
		}
	}

	// 研究员关联权限
	viewAdminMappings, assessmentAdminMappings := make(map[int][]models.AssessmentResearcherDetail), make(map[int][]models.AssessmentResearcherDetail)
	{
		mappingOb := new(models.AssessmentResearcherAdminMapping)
		condMapping := fmt.Sprintf(` AND %s IN (?)`, mappingOb.Cols().AssessmentResearcherId)
		parsMapping := make([]interface{}, 0)
		parsMapping = append(parsMapping, researcherIds)
		list, e := mappingOb.GetItemsByCondition(condMapping, parsMapping, []string{}, "")
		if e != nil {
			br.Msg = "获取失败"
			br.ErrMsg = fmt.Sprintf("获取研究员用户权限关系失败, %v", e)
			return
		}
		for _, v := range list {
			ad := adminMapping[v.AuthAdminId]
			if ad == nil {
				continue
			}
			// 详情这里只显示启用的系统用户
			if ad.Enabled != 1 {
				continue
			}
			ar := models.AssessmentResearcherDetail{
				AdminId:  v.AuthAdminId,
				RealName: ad.RealName,
				Enabled:  ad.Enabled,
			}
			if v.AuthType == models.AssessmentResearcherAdminAuthTypeView {
				viewAdminMappings[v.AdminId] = append(viewAdminMappings[v.AdminId], ar)
				continue
			}
			assessmentAdminMappings[v.AdminId] = append(assessmentAdminMappings[v.AdminId], ar)
		}
	}

	for _, v := range researchers {
		t := v.Format2Detail()
		t.ViewAdmins = viewAdminMappings[v.AdminId]
		t.AssessmentAdmins = assessmentAdminMappings[v.AdminId]
		resp.List = append(resp.List, t)
	}

	resp.Paging = paging.GetPaging(params.CurrentIndex, params.PageSize, total)
	br.Data = resp
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
}