pet-ai/server/plugin/wechat-integration/service/mp_auto_reply_service.go

package service

import (
	"errors"
	"strings"

	"github.com/flipped-aurora/gin-vue-admin/server/global"
	"github.com/flipped-aurora/gin-vue-admin/server/plugin/wechat-integration/model"
	"gorm.io/gorm"
)

type MpAutoReplyService struct{}

// GetAutoReplyList 获取自动回复列表
func (m *MpAutoReplyService) GetAutoReplyList(page, pageSize int, replyType *int) ([]model.MpAutoReply, int64, error) {
	var replies []model.MpAutoReply
	var total int64

	db := global.GVA_DB.Model(&model.MpAutoReply{})

	// 根据回复类型筛选
	if replyType != nil {
		db = db.Where("type = ?", *replyType)
	}

	// 获取总数
	err := db.Count(&total).Error
	if err != nil {
		return nil, 0, err
	}

	// 分页查询
	offset := (page - 1) * pageSize
	err = db.Offset(offset).Limit(pageSize).Order("created_at desc").Find(&replies).Error
	if err != nil {
		return nil, 0, err
	}

	return replies, total, nil
}

// CreateAutoReply 创建自动回复
func (m *MpAutoReplyService) CreateAutoReply(reply *model.MpAutoReply) error {
	err := global.GVA_DB.Create(reply).Error
	if err != nil {
		global.GVA_LOG.Error("创建自动回复失败: " + err.Error())
		return err
	}
	return nil
}

// UpdateAutoReply 更新自动回复
func (m *MpAutoReplyService) UpdateAutoReply(reply *model.MpAutoReply) error {
	err := global.GVA_DB.Save(reply).Error
	if err != nil {
		global.GVA_LOG.Error("更新自动回复失败: " + err.Error())
		return err
	}
	return nil
}

// DeleteAutoReply 删除自动回复
func (m *MpAutoReplyService) DeleteAutoReply(id uint) error {
	err := global.GVA_DB.Delete(&model.MpAutoReply{}, id).Error
	if err != nil {
		global.GVA_LOG.Error("删除自动回复失败: " + err.Error())
		return err
	}
	return nil
}

// GetAutoReplyByID 根据ID获取自动回复
func (m *MpAutoReplyService) GetAutoReplyByID(id uint) (*model.MpAutoReply, error) {
	var reply model.MpAutoReply
	err := global.GVA_DB.Where("id = ?", id).First(&reply).Error
	if err != nil {
		return nil, err
	}
	return &reply, nil
}

// GetSubscribeReply 获取关注回复
func (m *MpAutoReplyService) GetSubscribeReply() (*model.MpAutoReply, error) {
	var reply model.MpAutoReply
	err := global.GVA_DB.Where("type = ?", model.AutoReplyTypeSubscribe).First(&reply).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, nil // 没有设置关注回复
		}
		return nil, err
	}
	return &reply, nil
}

// GetKeywordReply 获取关键字回复
func (m *MpAutoReplyService) GetKeywordReply(keyword string) (*model.MpAutoReply, error) {
	var replies []model.MpAutoReply
	err := global.GVA_DB.Where("type = ?", model.AutoReplyTypeKeyword).Find(&replies).Error
	if err != nil {
		return nil, err
	}

	// 遍历所有关键字回复，查找匹配的
	for _, reply := range replies {
		if reply.RequestKeyword == nil {
			continue
		}

		// 完全匹配
		if reply.IsExactMatch() {
			if strings.EqualFold(keyword, *reply.RequestKeyword) {
				return &reply, nil
			}
		}

		// 部分匹配
		if reply.IsPartialMatch() {
			if strings.Contains(strings.ToLower(keyword), strings.ToLower(*reply.RequestKeyword)) {
				return &reply, nil
			}
		}
	}

	return nil, nil // 没有找到匹配的关键字回复
}

// GetMessageReply 获取消息回复
func (m *MpAutoReplyService) GetMessageReply(msgType string) (*model.MpAutoReply, error) {
	var reply model.MpAutoReply
	err := global.GVA_DB.Where("type = ? AND request_message_type = ?", model.AutoReplyTypeMessage, msgType).First(&reply).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, nil // 没有设置该类型消息的回复
		}
		return nil, err
	}
	return &reply, nil
}

// SetSubscribeReply 设置关注回复
func (m *MpAutoReplyService) SetSubscribeReply(content string) error {
	// 先查找是否已存在关注回复
	var reply model.MpAutoReply
	err := global.GVA_DB.Where("type = ?", model.AutoReplyTypeSubscribe).First(&reply).Error

	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			// 不存在，创建新的
			reply = model.MpAutoReply{
				Type:                model.AutoReplyTypeSubscribe,
				ResponseMessageType: "text",
				ResponseContent:     &content,
			}
			return m.CreateAutoReply(&reply)
		}
		return err
	}

	// 存在，更新内容
	reply.ResponseContent = &content
	return m.UpdateAutoReply(&reply)
}

// SetKeywordReply 设置关键字回复
func (m *MpAutoReplyService) SetKeywordReply(keyword, content string, matchType int) error {
	reply := model.MpAutoReply{
		Type:                model.AutoReplyTypeKeyword,
		RequestKeyword:      &keyword,
		RequestMatch:        &matchType,
		ResponseMessageType: "text",
		ResponseContent:     &content,
	}
	return m.CreateAutoReply(&reply)
}

// TestAutoReply 测试自动回复功能
func (m *MpAutoReplyService) TestAutoReply(keyword string) (*model.MpAutoReply, error) {
	// 先尝试关键字匹配
	reply, err := m.GetKeywordReply(keyword)
	if err != nil {
		return nil, err
	}
	if reply != nil {
		return reply, nil
	}

	// 如果没有关键字匹配，返回默认的文本消息回复
	return m.GetMessageReply("text")
}