notice/apiserver/service/message.go

package service

import (
	"errors"

	"gorm.io/gorm"
	"kpt.notice/apiserver/model"
	"kpt.notice/apiserver/model/http"
	"kpt.notice/pkg/log"
	"kpt.notice/pkg/util"
)

func (svc *Service) UpdateMessage(statics int, id int, val map[string]interface{}) (err error) {

	var res *gorm.DB
	if statics == 1 {
		// update update_at
		res = svc.DB.Model(&model.Message{}).Where("id= ?", id).Updates(val)
	}
	if statics == 2 {
		// update push_count,update_at,status
		res = svc.DB.Model(&model.Message{}).Where("id= ?", id).Updates(val)
	}
	if statics == 3 {
		// update status
		res = svc.DB.Model(&model.Message{}).Where("id= ?", id).Updates(val)
	}

	if res.Error != nil {
		return res.Error
	}
	return
}

// send  message
//type statics ,1:instant,
func (svc *Service) getMsgByType(statics int) (msgs []model.Message, err error) {
	// instant message
	var sql string
	if statics == 1 {
		sql = `select * from message m join message_type mt on m.msg_type_id = mt.id 
		where m.status = 1 and mt.remind_type_id = 1 and timestampdiff(second,m.update_at,now())>7200`
		err = svc.DB.Exec(sql).Find(&msgs).Error
		// err = svc.DB.Where("msg_type_id =? and status =0 and timestampdiff(second,update_at,now())>7200", 1).Find(&msgs).Error
	}
	if statics == 2 {
		sql = `select m.* from message m join message_type mt on m.msg_type_id = mt.id 
		where m.status = 1 and mt.remind_type_id = 2 and timestampdiff(hour,m.create_at,now())>=48 
		and timestampdiff(hour,m.update_at,now())>=24 and m.push_count mt.notice_count`
	}
	if statics == 3 {
		sql = `select * from message m join message_type mt on m.msg_type_id = mt.id 
		where m.status = 1 and mt.remind_type_id = 3 
        and    (   mt.push_date=concat('w', weekday(now() ) +1)   mt.push_date=concat('w', day(now() ) +1)  )`
	}
	return
}
func (svc *Service) InsertMessage(msg *http.MessageReq) (resp *http.MessageResp, err error) {
	log.Error("InsertMessage=============enter")
	tmp := make(map[string]interface{})
	tmp["miniprogram"] = msg.Miniprogram
	mt := svc.QueryMsgType(msg.MsgTypeID)
	if mt == nil {
		log.Errorf("InsertMessage=====QueryMsgType====%v", errors.New("没有匹配的模板"))
		return nil, errors.New("没有匹配的模板")
	}
	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{
		Target:       util.MarshalToString(msg.Target),
		MsgTypeID:    msg.MsgTypeID,
		RemindTypeID: mt[0].RemindTypeID,
		MsgContent:   util.MarshalToString(tmp),
	}

	result := svc.DB.Create(&msgDb)
	if result.Error != nil {
		log.Errorf("InsertMessage=====Create%v", result.Error)
		return nil, result.Error
	}
	resp = &http.MessageResp{
		Rows: int(result.RowsAffected),
	}
	err = result.Error
	return
}

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

func (svc *Service) InsertMessageType(req *http.MessageTypeReq) (m *model.MessageType, err error) {
	m = &model.MessageType{
		SysName:      req.SysName,
		TypeName:     req.TypeName,
		RemindTypeID: req.RemindTypeID,
		RemindType:   req.RemindType,
		PushDate:     req.PushDate,
		PushTime:     req.PushTime,
		IntervalTime: req.IntervalTime,
		PushLimit:    req.PushLimit,
		TemplateID:   req.TemplateID,
	}
	result := svc.DB.Create(m)
	if result.Error != nil {
		return nil, result.Error
	}
	return m, nil

}

// func (svc *Service) queryMsgType(id int) (m *model.MessageType, err error) {
// 	if tx.RowsAffected == 0 {
// 		return nil, errors.New("没有匹配的模板")
// 	}
// 	return m, nil
// }
func (svc *Service) QueryMsgType(id int) (m []model.MessageType) {
	log.Error("QueryMsgType=============enter")
	log.Errorf("QueryMsgType========params:%v", id)
	var tx *gorm.DB
	if id > 0 {
		tx = svc.DB.Where("id = ?", id).First(&m)
		log.Errorf("QueryMsgType========sql:%v", tx)
	} else if id == 0 {
		tx = svc.DB.Find(m)
	}

	if tx.RowsAffected == 0 {
		log.Errorf("QueryMsgType=====%v", errors.New("没有匹配的模板"))
		return nil
	}
	log.Error("QueryMsgType=====out=====")
	return m
}