eta_api/controllers/report_ice_message.go

package controllers

import (
	"encoding/json"
	"eta_gn/eta_api/models"
	"eta_gn/eta_api/models/system"
	"eta_gn/eta_api/services"
	"eta_gn/eta_api/services/ice_message"
	"eta_gn/eta_api/utils"
	"fmt"
	"strconv"
	"strings"
	"time"

	"github.com/rdlucklib/rdluck_tools/paging"
)

type ReportIceMessageController struct {
	BaseAuthController
}

// MsgConfig
// @Title 消息推送配置
// @Description 消息推送配置
// @Param   Id   query   int  true       "版本ID"
// @Success 200 {object} models.ReportIceMsgConfigReq
// @router /ice_msg/config [post]
func (c *ReportIceMessageController) IceMsgConfig() {
	br := new(models.BaseResponse).Init()
	defer func() {
		c.Data["json"] = br
		c.ServeJSON()
	}()
	
	var req models.ReportIceMsgConfigReq
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.ClassifyId <= 0 {
		br.Msg = "分类ID不能为空"
		return
	}
	if len(req.NotifyUsers) == 0 {
		br.Msg = "通知用户列表不能为空"
		return
	}
	configObj := new(models.ReportMessageConfig)
	// 获取配置
	config, err := configObj.GetItemByClassifyId(req.ClassifyId)
	if err != nil &&  !utils.IsErrNoRow(err) {
		br.Msg = "获取配置失败"
		br.ErrMsg = "获取配置失败，Err:" + err.Error()
		return
	}
	if config == nil || config.ConfigId <= 0 {
		notifyUsers := make([]string, 0)
		for _, id := range req.NotifyUsers {
			uid := strconv.Itoa(id)
			notifyUsers = append(notifyUsers, uid)
		}
		// 新增配置
		config = &models.ReportMessageConfig{
			ClassifyId:  req.ClassifyId,
			NotifyUsers: strings.Join(notifyUsers, ","),
			CreateTime:  time.Now(),
			ModifyTime:  time.Now(),
		}
		err = config.Create()
		if err != nil {
			br.Msg = "新增配置失败"
			br.ErrMsg = "新增配置失败，Err:" + err.Error()
			return
		}
	} else {
		// 更新配置
		notifyUsers := make([]string, 0)
		for _, id := range req.NotifyUsers {
			uid := strconv.Itoa(id)
			notifyUsers = append(notifyUsers, uid)
		}
		config.NotifyUsers = strings.Join(notifyUsers, ",")
		config.ModifyTime = time.Now()
		err = config.Update([]string{"notify_users", "modify_time"})
		if err != nil {
			br.Msg = "更新配置失败"
			br.ErrMsg = "更新配置失败，Err:" + err.Error()
			return
		}
	}
	br.Msg = "操作成功"
	br.Ret = 200
	br.Success = true
}

// MsgRecord
// @Title 消息推送记录
// @Description 消息推送记录
// @Param   Id   query   int  true       "版本ID"
// @Success 200 {object} models.ReportIceMsgConfigReq
// @router /ice_msg/record [get]
func (c *ReportIceMessageController) IceMsgRecord() {
	br := new(models.BaseResponse).Init()
	defer func() {
		c.Data["json"] = br
		c.ServeJSON()
	}()
	// 根据分类ID，分类类型，推送状态，推送时间，分页查询
	pageSize, _ := c.GetInt("PageSize")
	currentIndex, _ := c.GetInt("CurrentIndex")
	classifyId, _ := c.GetInt("ClassifyId")
	classifyType, _ := c.GetInt("ClassifyType")
	sendStatus, _ := c.GetInt("Status")
	sendTime := c.GetString("SendTime")
    
	if pageSize <= 0 {
		pageSize = utils.PageSize20
	}
	if currentIndex <= 0 {
		currentIndex = 1
	}
	startSize := utils.StartIndex(currentIndex, pageSize)
	condition := ""
	pars := make([]interface{}, 0)
	
	if sendTime != "" {
		// 校验时间格式
		_, err := time.Parse(utils.FormatDate, sendTime)
		if err != nil {
			br.Msg = "时间格式错误"
			br.ErrMsg = "时间格式错误，Err:" + err.Error()
			return
		}
		startTime, _ := time.Parse(utils.FormatDate, sendTime)
		endTime := startTime.AddDate(0, 0, 1)
		condition += " AND send_time >= ? and send_time < ?"
		pars = append(pars, startTime)
		pars = append(pars, endTime)
	}
	if classifyId > 0 {
		condition += " AND classify_id = ?"
		pars = append(pars, classifyId)
	}
	if classifyType > 0 {
		condition += " AND classify_type = ?"
		pars = append(pars, classifyType)
	}
	if sendStatus > 0 {
		condition += " AND status = ?"
		pars = append(pars, sendStatus)
	}

	recordObj := new(models.ReportMessageRecord)
	total, err := recordObj.GetListCount(condition, pars)
	if err != nil {
		br.Msg = "查询失败"
		br.ErrMsg = "查询失败，Err:" + err.Error()
		return
	}
	tmpList, err := recordObj.GetList(condition, pars, startSize, pageSize)
	if err != nil {
		br.Msg = "查询失败"
		br.ErrMsg = "查询失败，Err:" + err.Error()
		return
	}
	// 获取分类名称
	classifyFullNameMap := make(map[int]string)
	// 有三级分类，想要获取全称，一级/二级/三级
	classifyList, err := models.GetAllClassifyOrderByLevel()
	if err != nil {
		br.Msg = "查询失败"
		br.ErrMsg = "查询失败，Err:" + err.Error()
		return
	}
	for _, item := range classifyList {
		if item.ParentId == 0 {
			classifyFullNameMap[item.Id] = item.ClassifyName
		}else if item.ParentId >0 {
			parentClassifyName, ok := classifyFullNameMap[item.ParentId]
			if ok {
				classifyFullNameMap[item.Id] = parentClassifyName + "/" + item.ClassifyName
			}
		}
	}

	// 查找账号名称
	adminIds := make([]int, 0)
	adminNameMap := make(map[int]string)
	for _, item := range tmpList {
		adminIds = append(adminIds, int(item.SendAdminId), int(item.ReceiveAdminId))
	}
	adminList, err := system.GetAdminListByIdList(adminIds)
	if err != nil {
		br.Msg = "查询失败"
		br.ErrMsg = "查询失败，Err:" + err.Error()
		return
	}
	for _, item := range adminList {
		adminNameMap[int(item.AdminId)] = item.RealName
	}
	
	list := make([]*models.ReportIceMsgRecordListItem, 0)
	for _, item := range tmpList {
		list = append(list, &models.ReportIceMsgRecordListItem{
			MessageId: item.MessageId,
			ReportId: item.ReportId,
			ReportTitle: item.ReportTitle,
			PptId: item.PptId,
			ClassifyId: item.ClassifyId,
			ClassifyFullName: classifyFullNameMap[item.ClassifyId],
			SendAdminId: item.SendAdminId,
			SendAdminName: adminNameMap[int(item.SendAdminId)],
			ReceiveAdminId: item.ReceiveAdminId,
			ReceiveAdminName: adminNameMap[int(item.ReceiveAdminId)],
			ClassifyType: item.ClassifyType,
			SendTime: item.SendTime.Format(utils.FormatDateTime),
		    Status: item.Status,
			CreateTime: item.CreateTime.Format(utils.FormatDateTime),
		})
	}
	
	page := paging.GetPaging(currentIndex, pageSize, total)
	resp := new(models.ReportIceMsgRecordListResp)
	resp.Paging = page
	resp.List = list
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// 消息推送
// @Title 消息推送
// @Description 消息推送
// @Param   Id   query   int  true       "版本ID"
// @Success 200 {object} models.ReportIceMsgConfigReq
// @router /ice_msg/push [post]
func (c *ReportIceMessageController) IceMsgPush() {
	br := new(models.BaseResponse).Init()
	defer func() {
		c.Data["json"] = br
		c.ServeJSON()
	}()
	sysUser := c.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}

	var req models.ReportIceMsgPushReq
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	sendClassifyId := 0
	classifyType := 1
	if req.ReportId > 0 {
		classifyType = 1
	}else if req.PptId > 0 {
		classifyType = 2
	}
	// 新增缓存判断消息还在处理中
	cacheKey := fmt.Sprintf("%s_%d_%d", utils.CACHE_REPORT_ICE_MSG_PUSH, req.ReportId, req.PptId)
	if !utils.Rc.SetNX(cacheKey, 1, 30*time.Second) {
		br.Msg = "系统处理中，请稍后重试！"
		br.ErrMsg = "系统处理中，请稍后重试！" + sysUser.RealName + ";data:" + string(c.Ctx.Input.RequestBody)
		return
	}
	defer func() {
		_ = utils.Rc.Delete(cacheKey)
	}()
	var title, summary, content string
	var reportInfo *models.Report
	var pptInfo *models.PptV2
	var classifyName string
	var url string
	// 根据类型判断
	if classifyType == 1 {// 推送研报
		if req.ReportId <= 0 {
			br.Msg = "研报ID不能为空"
			return
		}
		//查询研报
		reportInfo, err = models.GetBaseReportInfoByReportId(int(req.ReportId))
		if err != nil {
			if !utils.IsErrNoRow(err) {
				br.Msg = "查询失败"
				br.ErrMsg = "查询失败，Err:" + err.Error()
				return
			}else{
				br.Msg = "研报不存在"
				return
			}
		}
		//判断研报状态，只有已发布的研报和已审核的研报才能推动
		if reportInfo.State != 2 && reportInfo.State != 6 {
			br.Msg = "该研报未发布，请发布后重试"
			return
		}
		sendClassifyId = reportInfo.ClassifyIdThird
		if sendClassifyId <= 0 {
			sendClassifyId = reportInfo.ClassifyIdSecond
		}
		if sendClassifyId <= 0 {
			sendClassifyId = reportInfo.ClassifyIdFirst
		}
		title = reportInfo.Title
		url = reportInfo.DetailPdfUrl
	} else if classifyType == 2 {// 推送PPT
		if req.PptId <= 0 {
			br.Msg = "PPTID不能为空"
			return
		}
		// PPT
		pptInfo, err = models.GetBasePptV2ByPptId(int(req.PptId))
		if err != nil {
			br.Msg = "PPT不存在"
			return
		}
		if pptInfo.State != 2 && pptInfo.State != 6 {
			br.Msg = "该PPT未发布，请发布后重试"
			return
		}
		sendClassifyId = pptInfo.ClassifyId
		title = pptInfo.Title
		url = pptInfo.PptxUrl
	}
	// 获取分类名称
	classify, err := models.GetClassifyById(sendClassifyId)
	if err != nil {
		if !utils.IsErrNoRow(err) {
			br.Msg = "查询失败"
			br.ErrMsg = "查询失败，Err:" + err.Error()
			return
		}else{
			br.Msg = "分类不存在"
			return
		}
	}
	classifyName = classify.ClassifyName

	// 判断该分类是否设置了消息推送配置
	configObj := new(models.ReportMessageConfig)
	config, err := configObj.GetItemByClassifyId(sendClassifyId)
	if err != nil {
		if !utils.IsErrNoRow(err) {
			br.Msg = "查询失败"
			br.ErrMsg = "查询失败，Err:" + err.Error()
			return
		}else{
			br.Msg = "该报告分类未设置接收人，请配置后重试"
			return
		}
	}
	if config == nil || config.ConfigId <= 0 {
		br.Msg = "该报告分类未设置接收人，请配置后重试"
		return
	}else if config.NotifyUsers == "" {
		br.Msg = "该报告分类未设置接收人，请配置后重试"
		return
	}

	// 获取推送人的工号
	adminids := strings.Split(config.NotifyUsers, ",")
	
	adminList, err := system.GetSysAdminByIdSlice(adminids)
	if err != nil {
		br.Msg = "查询失败"
		br.ErrMsg = "查询失败，Err:" + err.Error()
		return
	}
	if len(adminList) == 0 {
		br.Msg = "该报告分类未设置接收人，请配置后重试"
		return
	}
	// 生成推送记录
	recordList := make([]*models.ReportMessageRecord, 0)
	successCount := 0
    for _, item := range adminList {
		if item.EmployeeId != "" {
			// 推送模版消息
			sendStatus := 1
			// 生成taskId
	        taskId := utils.MD5(fmt.Sprintf("%s_%s_%s_%s", req.ReportId, req.PptId, item.AdminId, time.Now().Format("20060102150405")))
	
			err = ice_message.PushIceMessage(title, summary, content, item.EmployeeId, taskId, req.ReportId, req.PptId, url, classifyName)
			if err != nil {
				sendStatus = 2
			}else{
				successCount++
			}
			pushRecord := &models.ReportMessageRecord{
				ReportId: int64(req.ReportId),
				PptId: int64(req.PptId),
				ReportTitle: title,
				ClassifyId: sendClassifyId,
				ClassifyType: int8(classifyType),
				SendAdminId: int64(sysUser.AdminId),
				SendTime: time.Now(),
				ReceiveAdminId: int64(item.AdminId),
				ReceiveAdminCode: item.EmployeeId,
				Status: int8(sendStatus),
				CreateTime: time.Now(),
				ModifyTime: time.Now(),
				TaskId: taskId,
			}
			recordList = append(recordList, pushRecord)
		}
	}
	
	recordObj := new(models.ReportMessageRecord)
	err = recordObj.BatchAdd(recordList)
	if err != nil {
		br.Msg = "推送失败"
		br.ErrMsg = "推送失败，Err:" + err.Error()
		return
	}

	if successCount > 0 {
		// 更新报告表的推送记录
		if classifyType == 1 {
			reportInfo.MsgIsSend = 1
			reportInfo.MsgSendTime = time.Now()
			err = reportInfo.Update([]string{"MsgIsSend", "MsgSendTime"})
			if err != nil {
				br.Msg = "更新推送记录失败"
				br.ErrMsg = "更新推送记录失败，Err:" + err.Error()
				return
			}
		}else if classifyType == 2 {
			pptInfo.MsgIsSend = 1
			pptInfo.MsgSendTime = time.Now()
			err = pptInfo.Update([]string{"MsgIsSend", "MsgSendTime"})
			if err != nil {
				br.Msg = "更新推送记录失败"
				br.ErrMsg = "更新推送记录失败，Err:" + err.Error()
				return
			}
		}
		br.Msg = "推送成功"
		br.Success = true
		br.Ret = 200
	}else{
		br.Msg = "推送失败"
		br.ErrMsg = "推送失败，Err:" + err.Error()
		br.Ret = 408
	}
}

// ListClassify
// @Title 获取分类列表
// @Description 获取分类列表
// @Param   KeyWord   query   string  true       "检索关键词"
// @Param   ClassifyType   query   int  false       "分类类型：0-全部(默认)；1-研报；2-PPT"
// @Param   Enabled   query   int  false       "启用状态：-1-全部(默认)；0-禁用；1-启用"
// @Success 200 {object} models.Classify
// @router /ice_msg/classify [get]
func (c *ReportIceMessageController) ListClassify() {
	br := new(models.BaseResponse).Init()
	defer func() {
		c.Data["json"] = br
		c.ServeJSON()
	}()

	classifyNames := make([]string, 0)
	classifyNames = append(classifyNames, utils.REPORT_ICE_MSG_CLASSIFY_NAMES...)
	

	// 获取所有分类
	originList, err := models.GetClassifyListByClassifyNameList(classifyNames)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}
	//查找所有的父级分类
	parentIds := make([]int, 0)
	for _, v := range originList {
		// 解析levelpath
		levelPath := strings.Split(v.LevelPath, ",")
		for _, i := range levelPath {
			if i != "" {
				parentId, _ := strconv.Atoi(i)
				parentIds = append(parentIds, parentId)
			}
		}
	}
	originList, err = models.GetClassifyListByParentIdList(parentIds)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}
	list := originList
	classifyIds := make([]int, 0)
	for _, v := range list {
		classifyIds = append(classifyIds, v.Id)
	}
	// 指定分类类型（上级中的分类类型可能与最下层的不一致，但是要把上级也一起取出来, 这需求...=_=!）'
	reportMsgConfigMap := make(map[int][]int)
	// 根据分类ID获取配置项
	reportMsgObj := new(models.ReportMessageConfig)
	configList, err := reportMsgObj.GetListByClassifyIdList(classifyIds)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}
	
	for _, v := range configList {
		if v.NotifyUsers != "" {
			notifyUsers := strings.Split(v.NotifyUsers, ",")
			for _, user := range notifyUsers {
				userInt, _ := strconv.Atoi(user)
				reportMsgConfigMap[v.ClassifyId] = append(reportMsgConfigMap[v.ClassifyId], userInt)
			}
		}
	}
	for _, v := range list {
		if iceMessageUsers, ok := reportMsgConfigMap[v.Id]; ok {
			v.IceMsgUsers = iceMessageUsers
		}
	}


	// 先将分类列表排序
	services.SortClassifyListBySortAndCreateTime(list)
	// 接着转换结构
	list = services.GetClassifyListTreeRecursive(list, 0)
	// 过滤掉没有子目录的分类
	list = services.RecursiveFilterNoChildTreeClassify(list)

	resp := new(models.ClassifyListResp)
	resp.List = list
	br.Data = resp
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
}