notice/apiserver/service/message.go

package service

import (
	"time"

	"github.com/pkg/errors"
	"kpt.notice/apiserver/model"
	"kpt.notice/apiserver/model/http"
	"kpt.notice/pkg/log"
	"kpt.notice/pkg/util"
)

func (svc *Service) UpdateMessage(msg *model.Message) (err error) {
	mtype := &http.MessageTypeReq{
		SysName:   msg.SysName,
		PastureID: msg.PastureID,
		ServiceID: msg.ServiceID,
	}
	if mtypes, e := svc.QueryMsgType(mtype); e != nil {
		err = e
		return
	} else if len(mtypes) == 0 {
		err = errors.New("没有匹配的消息类型")
		return
	} else {
		m := make(map[string]interface{}, 3)
		if mtypes[0].RemindType == 1 {
			m["status"] = 1
		} else if mtypes[0].RemindType == 2 {
			if mtypes[0].CycleType == 1 || mtypes[0].CycleType == 3 {
				m["status"] = 1
			} else {
				m["updated_at"] = time.Now()
				m["push_count"] = msg.PushCount + 1
				if msg.PushCount+1 >= mtypes[0].PushLimit {
					m["status"] = 1
				}
			}
		} else if mtypes[0].RemindType == 3 {
			m["push_count"] = msg.PushCount + 1
			m["updated_at"] = time.Now()
		}
		if res := svc.DB.Table("message").Where("id=?", msg.ID).Updates(m); res.Error != nil {
			err = errors.Wrap(res.Error, "UpdateMessage.update=")
			log.Errorf("%v", err)
		}
	}
	return
}

func (svc *Service) UpdateMessageFail(msg *model.Message) (err error) {

	m := make(map[string]interface{}, 3)
	m["status"] = -1
	m["updated_at"] = time.Now()
	m["errInfo"] = msg.ErrInfo
	if res := svc.DB.Table("message").Where("id=?", msg.ID).Updates(m); res.Error != nil {
		err = errors.Wrap(res.Error, "UpdateMessage.update=")
		log.Errorf("%v", err)
	}

	return
}

func (svc *Service) QueryMsg() (msgs []model.Message, err error) {
	var sql2 string
	sql := `select sqltext from apisql where sqlname='getMessage' limit 1 `

	svc.DB.Raw(sql).Scan(&sql2)

	if err = svc.DB.Raw(sql2).Scan(&msgs).Error; err != nil {
		err = errors.Wrap(err, "queryMsg{query msg exec sql err}==%v")
		log.Errorf("%v", err)
		return
	}
	return
}
func (svc *Service) InsertMessage(msg *http.MessageReq, body []byte) (resp *http.MessageResp, err error) {
	tmp := make(map[string]interface{})
	tmp["miniprogram"] = msg.Miniprogram
	msgType := &http.MessageTypeReq{
		SysName:   msg.SysName,
		PastureID: msg.PastureID,
		ServiceID: msg.ServiceID,
	}

	sysuserList, e := svc.GetSysUser(msg.Target, msg.SysName, msg.PastureID)
	if err != nil {
		err = e
		return
	}
	var targetList []string
	for _, user := range sysuserList {
		targetList = append(targetList, user.Openid)
	}

	if mt, e := svc.QueryMsgType(msgType); e != nil {
		err = e
		return
	} else if len(mt) == 0 {
		err = errors.New("没有匹配的消息类型")
		return
	} else {
		tmp["template_id"] = mt[0].TemplateID
	}
	data := make(map[string]http.Tag)
	for i, v := range msg.Keys {
		data[v] = msg.Content[i]
	}
	tmp["data"] = data
	msgDb := model.Message{
		SysName:    msg.SysName,
		PastureID:  msg.PastureID,
		ServiceID:  msg.ServiceID,
		Target:     util.MarshalToString(targetList),
		MsgTypeID:  msg.MsgTypeID,
		MsgContent: util.MarshalToString(tmp),
		UpdatedAt:  time.Now(),
		BodyData:   string(body),
	}

	if err = svc.DB.Create(&msgDb).Error; err != nil {
		err = errors.Wrap(err, "InsertMessage{insert msg}==%v")
		log.Errorf("%v", err)
		return
	}
	resp = &http.MessageResp{
		ID: msgDb.ID,
	}
	return
}

// query the id or remind_type of the message  by name
func (svc *Service) QueryRemindTypeID(name string) (int, error) {
	m := new(http.MessageTypeReq)
	tx := svc.DB.Table("message_type").Where("type_name = ?").First(m)
	if tx.RowsAffected == 0 {
		return 0, errors.New("没有匹配的类型")
	}
	return m.ID, nil
}

func (svc *Service) InsertMsgType(req *http.MessageTypeReq) (resp *http.MessageTypeResp, err error) {
	//固定模板
	req.TemplateID = "1_zBqvbzD-edg0b-O5OD1kAEMefygikcmBZACSiwX0w"
	if query, e := svc.QueryMsgType(req); e != nil {
		err = e
		return
	} else {
		resp = new(http.MessageTypeResp)
		switch {
		case len(query) == 0:
			resp.Method = "insert"
			if res := svc.DB.Table("message_type").Create(req); res.Error != nil {
				err = errors.Wrap(res.Error, "InsertMsgType{create msg type===%v}")
				log.Errorf("%v", err)
			} else {
				resp.RowsAffected = int(res.RowsAffected)
			}
			break
		case len(query) > 0:
			resp.Method = "update"
			index := map[string]interface{}{
				"service_id": req.ServiceID,
				"pasture_id": req.PastureID,
				"sys_name":   req.SysName,
			}
			log.Infof("msg type update index%v", index)
			req.PastureID = 0
			req.SysName = ""
			req.ServiceID = 0
			log.Infof("msg type update value%v", req)
			if res := svc.DB.Table("message_type").Where(index).Updates(req); res.Error != nil {
				err = errors.Wrap(err, "InsertMsgType{update msg type ===%v}")
				log.Errorf("%v", err)
			} else {
				resp.RowsAffected = int(res.RowsAffected)
			}
			break
		}
	}
	return
}

func (svc *Service) QueryMsgType(req *http.MessageTypeReq) (m []http.MessageTypeReq, err error) {
	index := map[string]interface{}{}

	if req.ServiceID != 0 {
		index["service_id"] = req.ServiceID
	}
	if req.PastureID != 0 {
		index["pasture_id"] = req.PastureID
	}
	if req.SysName != "" {
		index["sys_name"] = req.SysName
	}
	log.Infof("query msg type===%v", index)
	if err = svc.DB.Table("message_type").Where(index).Find(&m).Error; err != nil {
		err = errors.Wrap(err, "QueryMsgType.find=")
		log.Errorf("%v", err)
	}
	return
}