opms_backend/opms_admin/app/service/sys_message.go

package service

import (
	"context"
	"fmt"
	"strings"

	"dashoo.cn/micro/app/dao"
	"dashoo.cn/micro/app/model"
	"github.com/gogf/gf/container/gset"
	"github.com/gogf/gf/frame/g"
	"github.com/gogf/gf/os/gtime"
	"github.com/gogf/gf/util/gconv"
)

type MessageService struct {
	*contextService
	Dao     *dao.SysMessageDao
	logDao  *dao.SysMessageLogDao
	userDao *dao.SysUserDao
}

func NewMessageService(ctx context.Context) (svc *MessageService, err error) {
	svc = new(MessageService)
	if svc.contextService, err = svc.Init(ctx); err != nil {
		return nil, err
	}
	svc.Dao = dao.NewSysMessageDao(svc.Tenant)
	svc.logDao = dao.NewSysMessageLogDao(svc.Tenant)
	svc.userDao = dao.NewSysUserDao(svc.Tenant)
	return svc, nil
}

func (s *MessageService) GetList(req *model.SysMessageSearchReq) (total int, list []*model.SysMessage, err error) {
	m := s.Dao.M
	if req != nil {
		if req.MsgTitle != "" {
			m = m.WhereLike(s.Dao.C.MsgTitle, "%"+req.MsgTitle+"%")
		}
		if req.MsgType != "" {
			m = m.Where(s.Dao.C.MsgType, req.MsgType)
		}
	}
	total, err = m.Count()
	if err != nil {
		return
	}
	err = m.Page(req.GetPage()).OrderDesc("id").Scan(&list)
	if err != nil {
		return
	}
	return
}

func (s *MessageService) GetListByUser(req *model.SysMessageSearchReq) (total int, list []*model.SysMessage, err error) {
	m := s.Dao.As("msg").LeftJoin(dao.SysMessageLog.Table, "log", "msg.id=log.msg_id").Where("log.user_id", s.GetCxtUserId())
	if req != nil {
		if req.MsgTitle != "" {
			m = m.WhereLike("msg."+s.Dao.C.MsgTitle, "%"+req.MsgTitle+"%")
		}
		if req.MsgType != "" {
			m = m.Where("msg."+s.Dao.C.MsgType, req.MsgType)
		}
		if req.IsRead != "" {
			m = m.Where("log.is_read", req.IsRead)
		}
	}
	total, err = m.Count()
	if err != nil {
		return
	}
	err = m.Page(req.GetPage()).Fields("msg.*,log.is_read,log.read_time").Order("log.is_read, msg.created_time DESC").Scan(&list)
	if err != nil {
		return
	}
	return
}

func (s *MessageService) GetEntityById(id int64) (msg *model.SysMessage, err error) {
	msg, err = s.Dao.WherePri(id).One()
	if err != nil {
		return nil, err
	}
	data := g.Map{
		s.logDao.C.IsRead:   "20",
		s.logDao.C.ReadTime: gtime.Now(),
	}
	_, err = s.logDao.Where(s.logDao.C.MsgId, id).Where(s.logDao.C.UserId, s.GetCxtUserId()).Data(data).Update()
	return
}

// Create 添加操作
func (s *MessageService) Create(req *model.CreateSysMessageReq) (err error) {
	data := new(model.SysMessage)
	if err := gconv.Struct(req, data); err != nil {
		return err
	}
	if data.SendType == "" {
		data.SendType = "10"
	}
	SetCreatedInfo(data, s.GetCxtUserId(), s.GetCxtUserName())
	lastId, err := s.Dao.InsertAndGetId(data)
	if err != nil {
		return err
	}
	data.Id = int(lastId)
	userIds := strings.Split(data.RecvUserIds, ",")
	if len(userIds) == 0 {
		return nil
	}
	userIds = gset.NewStrSetFrom(userIds).Slice()
	// 如果 msgType 为公告，并且没有指定 userIds 则向所有人发送通知
	if data.RecvUserIds == "" && data.MsgType == "10" && data.SendType == "10" {
		v, err := s.userDao.Fields("id").Array()
		if err != nil {
			return err
		}
		for _, i := range v {
			userIds = append(userIds, i.String())
		}
	}
	for _, userId := range userIds {
		if userId == "" {
			continue
		}
		log := g.Map{
			s.logDao.C.MsgId:  lastId,
			s.logDao.C.UserId: userId,
			s.logDao.C.IsRead: "10",
		}
		s.logDao.Data(log).Insert()
	}
	sendMsgType := strings.Split(data.SendType, ",")
	for _, v := range gset.NewStrSetFrom(sendMsgType).Slice() {
		switch v {
		case "10": // 10：websocket
			go BatchSendMessageNotify(userIds, *data)
			fmt.Println(v, "10")
		case "20": // 20：邮件
			go s.BatchSendUserEmailMsg(userIds, data.MsgTitle, data.MsgContent)
			fmt.Println(v, "20")
		case "30": // 30：钉钉
			go s.BatchSendUserDingTalkTextMsg(userIds, data.MsgType, data.MsgTitle, data.MsgContent)
			fmt.Println(v, "30")
		case "40": // 40：微信小程序订阅消息

			fmt.Println(v, "40")

		}
	}
	return
}

// 按照配置处理消息
func (s *MessageService) handleMsgBySetting(userIds []string, data *model.SysMessage) {
	msgType := g.Config().GetString("message.type")
	if msgType == "websocket" {
		go BatchSendMessageNotify(userIds, *data)
	} else if msgType == "dingding" {
		go s.BatchSendUserDingTalkTextMsg(userIds, data.MsgType, data.MsgTitle, data.MsgContent)
	} else {
		fmt.Println("非法的消息类型：" + msgType)
	}
}

// SendMail 发送邮件
func (s *MessageService) SendMail(req *model.SendMessageReq) (err error) {
	data := new(model.SysMessage)
	if err := gconv.Struct(req, data); err != nil {
		return err
	}
	//SetCreatedInfo(data, s.GetCxtUserId(), s.GetCxtUserName())
	//lastId, err := s.Dao.InsertAndGetId(data)
	//if err != nil {
	//	return err
	//}
	//data.Id = int(lastId)
	//log := g.Map{
	//	s.logDao.C.MsgId:  lastId,
	//	s.logDao.C.UserId: data.RecvUserIds,
	//	s.logDao.C.IsRead: "10",
	//}
	//s.logDao.Data(log).Insert()
	s.SendUserEmailMsg(data.RecvUserIds, data.MsgTitle, data.MsgContent, data.OpnUrl)
	return
}

// UpdateById 修改系统参数
func (s *MessageService) UpdateById(req *model.UpdateSysMessageReq) (err error) {
	data := new(model.SysMessage)
	if err := gconv.Struct(req, data); err != nil {
		return err
	}
	SetUpdatedInfo(data, s.GetCxtUserId(), s.GetCxtUserName())
	_, err = s.Dao.FieldsEx(UpdateFieldEx...).WherePri(req.Id).Data(data).Update()
	s.logDao.Where(s.logDao.C.MsgId, data.Id).Delete()
	userIds := strings.Split(data.RecvUserIds, ",")
	for _, uid := range userIds {
		if uid == "" {
			continue
		}
		log := g.Map{
			s.logDao.C.MsgId:  data.Id,
			s.logDao.C.UserId: uid,
			s.logDao.C.IsRead: "10",
		}
		s.logDao.Data(log).Insert()
	}
	return
}

// DeleteByIds 删除
func (s *MessageService) DeleteByIds(ids []int64) error {
	_, err := s.Dao.WhereIn(s.Dao.C.Id, ids).Delete()
	return err
}

// 全部已读
func (s *MessageService) AllRead() error {
	data := g.Map{
		s.logDao.C.IsRead:   "20",
		s.logDao.C.ReadTime: gtime.Now(),
	}
	_, err := s.logDao.Where(s.logDao.C.UserId, s.GetCxtUserId()).Data(data).Update()
	return err
}