pet-ai/server/plugin/wechat-integration/api/mp_auto_reply_api.go

package api

import (
	"strconv"

	"github.com/flipped-aurora/gin-vue-admin/server/global"
	"github.com/flipped-aurora/gin-vue-admin/server/model/common/response"
	"github.com/flipped-aurora/gin-vue-admin/server/plugin/wechat-integration/model"
	"github.com/flipped-aurora/gin-vue-admin/server/plugin/wechat-integration/model/request"
	wechatResponse "github.com/flipped-aurora/gin-vue-admin/server/plugin/wechat-integration/model/response"
	"github.com/flipped-aurora/gin-vue-admin/server/plugin/wechat-integration/service"
	"github.com/gin-gonic/gin"
	"go.uber.org/zap"
)

type MpAutoReplyApi struct{}

var mpAutoReplyService = service.ServiceGroupApp.MpAutoReplyService

// GetAutoReplyList 获取自动回复列表
// @Tags MpAutoReply
// @Summary 获取自动回复列表
// @Description 获取公众号自动回复规则列表
// @Accept json
// @Produce json
// @Param page query int false "页码"
// @Param pageSize query int false "每页数量"
// @Param replyType query int false "回复类型"
// @Success 200 {object} response.Response{data=response.PageResult} "获取成功"
// @Router /wechat/mp/auto-reply [get]
func (m *MpAutoReplyApi) GetAutoReplyList(c *gin.Context) {
	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
	pageSize, _ := strconv.Atoi(c.DefaultQuery("pageSize", "10"))

	var replyType *int
	if rt := c.Query("replyType"); rt != "" {
		if t, err := strconv.Atoi(rt); err == nil {
			replyType = &t
		}
	}

	if page <= 0 {
		page = 1
	}
	if pageSize <= 0 || pageSize > 100 {
		pageSize = 10
	}

	replies, total, err := mpAutoReplyService.GetAutoReplyList(page, pageSize, replyType)
	if err != nil {
		global.GVA_LOG.Error("获取自动回复列表失败!", zap.Error(err))
		response.FailWithMessage("获取失败: "+err.Error(), c)
		return
	}

	response.OkWithDetailed(wechatResponse.PageResult{
		List:     replies,
		Total:    total,
		Page:     page,
		PageSize: pageSize,
	}, "获取成功", c)
}

// GetAutoReplyByID 获取自动回复详情
// @Tags MpAutoReply
// @Summary 获取自动回复详情
// @Description 根据ID获取自动回复详细信息
// @Accept json
// @Produce json
// @Param id path int true "自动回复ID"
// @Success 200 {object} response.Response{data=model.MpAutoReply} "获取成功"
// @Router /wechat/mp/auto-reply/{id} [get]
func (m *MpAutoReplyApi) GetAutoReplyByID(c *gin.Context) {
	idStr := c.Param("id")
	id, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		response.FailWithMessage("无效的自动回复ID", c)
		return
	}

	reply, err := mpAutoReplyService.GetAutoReplyByID(uint(id))
	if err != nil {
		global.GVA_LOG.Error("获取自动回复详情失败!", zap.Error(err))
		response.FailWithMessage("获取失败: "+err.Error(), c)
		return
	}

	response.OkWithData(reply, c)
}

// CreateAutoReply 创建自动回复
// @Tags MpAutoReply
// @Summary 创建自动回复
// @Description 创建新的自动回复规则
// @Accept json
// @Produce json
// @Param data body request.CreateAutoReplyRequest true "创建参数"
// @Success 200 {object} response.Response{data=model.MpAutoReply} "创建成功"
// @Router /wechat/mp/auto-reply [post]
func (m *MpAutoReplyApi) CreateAutoReply(c *gin.Context) {
	var req request.CreateAutoReplyRequest
	err := c.ShouldBindJSON(&req)
	if err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}

	// 验证必填字段
	if req.Type == 0 || req.ResponseMessageType == "" || req.ResponseContent == "" {
		response.FailWithMessage("回复类型、响应消息类型和响应内容不能为空", c)
		return
	}

	// 构建自动回复对象
	autoReply := &model.MpAutoReply{
		Type:                req.Type,
		ResponseMessageType: req.ResponseMessageType,
		ResponseContent:     &req.ResponseContent,
	}

	// 根据类型设置特定字段
	if req.Type == model.AutoReplyTypeKeyword {
		if req.RequestKeyword == "" {
			response.FailWithMessage("关键字回复必须设置关键字", c)
			return
		}
		autoReply.RequestKeyword = &req.RequestKeyword
		if req.RequestMatch != 0 {
			autoReply.RequestMatch = &req.RequestMatch
		}
	} else if req.Type == model.AutoReplyTypeMessage {
		if req.RequestMessageType == "" {
			response.FailWithMessage("消息回复必须设置请求消息类型", c)
			return
		}
		autoReply.RequestMessageType = &req.RequestMessageType
	}

	err = mpAutoReplyService.CreateAutoReply(autoReply)
	if err != nil {
		global.GVA_LOG.Error("创建自动回复失败!", zap.Error(err))
		response.FailWithMessage("创建失败: "+err.Error(), c)
		return
	}

	response.OkWithDetailed(autoReply, "创建成功", c)
}

// UpdateAutoReply 更新自动回复
// @Tags MpAutoReply
// @Summary 更新自动回复
// @Description 更新自动回复规则
// @Accept json
// @Produce json
// @Param data body request.UpdateAutoReplyRequest true "更新参数"
// @Success 200 {object} response.Response "更新成功"
// @Router /wechat/mp/auto-reply [put]
func (m *MpAutoReplyApi) UpdateAutoReply(c *gin.Context) {
	var req request.UpdateAutoReplyRequest
	err := c.ShouldBindJSON(&req)
	if err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}

	if req.ID == 0 {
		response.FailWithMessage("ID不能为空", c)
		return
	}

	// 获取现有记录
	existingReply, err := mpAutoReplyService.GetAutoReplyByID(req.ID)
	if err != nil {
		global.GVA_LOG.Error("获取自动回复失败!", zap.Error(err))
		response.FailWithMessage("获取失败: "+err.Error(), c)
		return
	}

	// 更新字段
	if req.ResponseContent != "" {
		existingReply.ResponseContent = &req.ResponseContent
	}
	if req.RequestKeyword != "" {
		existingReply.RequestKeyword = &req.RequestKeyword
	}
	if req.RequestMatch != 0 {
		existingReply.RequestMatch = &req.RequestMatch
	}

	err = mpAutoReplyService.UpdateAutoReply(existingReply)
	if err != nil {
		global.GVA_LOG.Error("更新自动回复失败!", zap.Error(err))
		response.FailWithMessage("更新失败: "+err.Error(), c)
		return
	}

	response.OkWithMessage("更新成功", c)
}

// DeleteAutoReply 删除自动回复
// @Tags MpAutoReply
// @Summary 删除自动回复
// @Description 删除指定的自动回复规则
// @Accept json
// @Produce json
// @Param id path int true "自动回复ID"
// @Success 200 {object} response.Response "删除成功"
// @Router /wechat/mp/auto-reply/{id} [delete]
func (m *MpAutoReplyApi) DeleteAutoReply(c *gin.Context) {
	idStr := c.Param("id")
	id, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		response.FailWithMessage("无效的自动回复ID", c)
		return
	}

	err = mpAutoReplyService.DeleteAutoReply(uint(id))
	if err != nil {
		global.GVA_LOG.Error("删除自动回复失败!", zap.Error(err))
		response.FailWithMessage("删除失败: "+err.Error(), c)
		return
	}

	response.OkWithMessage("删除成功", c)
}

// TestAutoReply 测试自动回复
// @Tags MpAutoReply
// @Summary 测试自动回复
// @Description 测试关键字是否能触发自动回复
// @Accept json
// @Produce json
// @Param data body request.TestAutoReplyRequest true "测试参数"
// @Success 200 {object} response.Response{data=model.MpAutoReply} "测试成功"
// @Router /wechat/mp/auto-reply/test [post]
func (m *MpAutoReplyApi) TestAutoReply(c *gin.Context) {
	var req request.TestAutoReplyRequest
	err := c.ShouldBindJSON(&req)
	if err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}

	if req.Keyword == "" {
		response.FailWithMessage("测试关键字不能为空", c)
		return
	}

	reply, err := mpAutoReplyService.TestAutoReply(req.Keyword)
	if err != nil {
		global.GVA_LOG.Error("测试自动回复失败!", zap.Error(err))
		response.FailWithMessage("测试失败: "+err.Error(), c)
		return
	}

	if reply == nil {
		response.OkWithDetailed(nil, "没有匹配的自动回复", c)
		return
	}

	response.OkWithDetailed(reply, "找到匹配的自动回复", c)
}

// SetSubscribeReply 设置关注回复
// @Tags MpAutoReply
// @Summary 设置关注回复
// @Description 设置用户关注时的自动回复
// @Accept json
// @Produce json
// @Param data body request.SetSubscribeReplyRequest true "设置参数"
// @Success 200 {object} response.Response "设置成功"
// @Router /wechat/mp/auto-reply/subscribe [post]
func (m *MpAutoReplyApi) SetSubscribeReply(c *gin.Context) {
	var req request.SetSubscribeReplyRequest
	err := c.ShouldBindJSON(&req)
	if err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}

	if req.Content == "" {
		response.FailWithMessage("回复内容不能为空", c)
		return
	}

	err = mpAutoReplyService.SetSubscribeReply(req.Content)
	if err != nil {
		global.GVA_LOG.Error("设置关注回复失败!", zap.Error(err))
		response.FailWithMessage("设置失败: "+err.Error(), c)
		return
	}

	response.OkWithMessage("设置成功", c)
}