2338 lines
73 KiB
Go
2338 lines
73 KiB
Go
package service
|
||
|
||
import (
|
||
"bytes"
|
||
"context"
|
||
"crypto/md5"
|
||
"crypto/sha256"
|
||
"encoding/hex"
|
||
"encoding/xml"
|
||
"errors"
|
||
"fmt"
|
||
"io"
|
||
"log"
|
||
"math/rand"
|
||
"mime/multipart"
|
||
"os"
|
||
"os/exec"
|
||
"path/filepath"
|
||
"slices"
|
||
"strconv"
|
||
"strings"
|
||
"time"
|
||
|
||
"github.com/go-resty/resty/v2"
|
||
"github.com/google/uuid"
|
||
"github.com/openai/openai-go/v3"
|
||
|
||
"wechat-robot-client/dto"
|
||
"wechat-robot-client/interface/plugin"
|
||
"wechat-robot-client/interface/settings"
|
||
"wechat-robot-client/model"
|
||
"wechat-robot-client/pkg/robot"
|
||
"wechat-robot-client/repository"
|
||
"wechat-robot-client/vars"
|
||
)
|
||
|
||
type MessageService struct {
|
||
ctx context.Context
|
||
msgRepo *repository.Message
|
||
crmRepo *repository.ChatRoomMember
|
||
sysmsgRepo *repository.SystemMessage
|
||
robotAdminRepo *repository.RobotAdmin
|
||
}
|
||
|
||
var _ plugin.MessageServiceIface = (*MessageService)(nil)
|
||
|
||
func NewMessageService(ctx context.Context) *MessageService {
|
||
return &MessageService{
|
||
ctx: ctx,
|
||
msgRepo: repository.NewMessageRepo(ctx, vars.DB),
|
||
crmRepo: repository.NewChatRoomMemberRepo(ctx, vars.DB),
|
||
sysmsgRepo: repository.NewSystemMessageRepo(ctx, vars.DB),
|
||
robotAdminRepo: repository.NewRobotAdminRepo(ctx, vars.AdminDB),
|
||
}
|
||
}
|
||
|
||
func buildMessageLogPreview(content string) string {
|
||
preview := strings.ReplaceAll(strings.TrimSpace(content), "\n", `\n`)
|
||
previewRunes := []rune(preview)
|
||
if len(previewRunes) > 80 {
|
||
return string(previewRunes[:80]) + "..."
|
||
}
|
||
return preview
|
||
}
|
||
|
||
func shouldLogPluginMatch(messagePlugin plugin.MessageHandler) bool {
|
||
return !slices.Contains(messagePlugin.GetLabels(), "chat")
|
||
}
|
||
|
||
func (s *MessageService) logPluginMatch(messagePlugin plugin.MessageHandler, msgCtx *plugin.MessageContext) {
|
||
if msgCtx == nil || msgCtx.Message == nil || !shouldLogPluginMatch(messagePlugin) {
|
||
return
|
||
}
|
||
log.Printf("[PluginMatch] plugin=%s labels=%v msg_id=%d from=%s sender=%s is_chat_room=%t app_msg_type=%d content=%q",
|
||
messagePlugin.GetName(),
|
||
messagePlugin.GetLabels(),
|
||
msgCtx.Message.MsgId,
|
||
msgCtx.Message.FromWxID,
|
||
msgCtx.Message.SenderWxID,
|
||
msgCtx.Message.IsChatRoom,
|
||
msgCtx.Message.AppMsgType,
|
||
buildMessageLogPreview(msgCtx.MessageContent),
|
||
)
|
||
}
|
||
|
||
// ProcessTextMessage 处理文本消息
|
||
func (s *MessageService) ProcessTextMessage(message *model.Message, msgSettings settings.Settings) {
|
||
msgCtx := &plugin.MessageContext{
|
||
Context: s.ctx,
|
||
Settings: msgSettings,
|
||
Message: message,
|
||
MessageContent: message.Content,
|
||
MessageService: s,
|
||
}
|
||
for _, messagePlugin := range vars.MessagePlugin.Plugins {
|
||
if !slices.Contains(messagePlugin.GetLabels(), "text") {
|
||
continue
|
||
}
|
||
match := messagePlugin.Match(msgCtx)
|
||
if !match {
|
||
continue
|
||
}
|
||
s.logPluginMatch(messagePlugin, msgCtx)
|
||
messagePlugin.Run(msgCtx)
|
||
}
|
||
}
|
||
|
||
// ProcessImageMessage 处理图片消息
|
||
func (s *MessageService) ProcessImageMessage(message *model.Message, msgSettings settings.Settings) {
|
||
msgCtx := &plugin.MessageContext{
|
||
Context: s.ctx,
|
||
Settings: msgSettings,
|
||
Message: message,
|
||
MessageContent: message.Content,
|
||
MessageService: s,
|
||
}
|
||
for _, messagePlugin := range vars.MessagePlugin.Plugins {
|
||
if !slices.Contains(messagePlugin.GetLabels(), "image") {
|
||
continue
|
||
}
|
||
match := messagePlugin.Match(msgCtx)
|
||
if !match {
|
||
continue
|
||
}
|
||
s.logPluginMatch(messagePlugin, msgCtx)
|
||
messagePlugin.Run(msgCtx)
|
||
}
|
||
}
|
||
|
||
// ProcessVoiceMessage 处理语音消息
|
||
func (s *MessageService) ProcessVoiceMessage(message *model.Message) {
|
||
|
||
}
|
||
|
||
// ProcessVideoMessage 处理视频消息
|
||
func (s *MessageService) ProcessVideoMessage(message *model.Message) {
|
||
|
||
}
|
||
|
||
// ProcessEmojiMessage 处理表情消息
|
||
func (s *MessageService) ProcessEmojiMessage(message *model.Message) {
|
||
|
||
}
|
||
|
||
// ProcessReferMessage 处理引用消息
|
||
func (s *MessageService) ProcessReferMessage(message *model.Message, msgSettings settings.Settings) {
|
||
var xmlMessage robot.XmlMessage
|
||
err := vars.RobotRuntime.XmlDecoder(message.Content, &xmlMessage)
|
||
if err != nil {
|
||
log.Printf("解析引用消息失败: %v", err)
|
||
return
|
||
}
|
||
referMessageID, err := strconv.ParseInt(xmlMessage.AppMsg.ReferMsg.SvrID, 10, 64)
|
||
if err != nil {
|
||
log.Printf("解析引用消息ID失败: %v", err)
|
||
return
|
||
}
|
||
referMessage, err := s.msgRepo.GetByMsgID(referMessageID)
|
||
if err != nil {
|
||
log.Printf("获取引用消息失败: %v", err)
|
||
return
|
||
}
|
||
if referMessage == nil {
|
||
log.Printf("获取引用消息为空")
|
||
return
|
||
}
|
||
msgCtx := &plugin.MessageContext{
|
||
Context: s.ctx,
|
||
Settings: msgSettings,
|
||
Message: message,
|
||
MessageContent: xmlMessage.AppMsg.Title,
|
||
ReferMessage: referMessage,
|
||
MessageService: s,
|
||
}
|
||
for _, messagePlugin := range vars.MessagePlugin.Plugins {
|
||
if !slices.Contains(messagePlugin.GetLabels(), "text") {
|
||
continue
|
||
}
|
||
match := messagePlugin.Match(msgCtx)
|
||
if !match {
|
||
continue
|
||
}
|
||
s.logPluginMatch(messagePlugin, msgCtx)
|
||
messagePlugin.Run(msgCtx)
|
||
}
|
||
}
|
||
|
||
func (s *MessageService) ProcessRedEnvelopesMessage(message *model.Message, msgSettings settings.Settings) {
|
||
msgCtx := &plugin.MessageContext{
|
||
Context: s.ctx,
|
||
Settings: msgSettings,
|
||
Message: message,
|
||
MessageContent: message.Content,
|
||
MessageService: s,
|
||
}
|
||
for _, messagePlugin := range vars.MessagePlugin.Plugins {
|
||
if !slices.Contains(messagePlugin.GetLabels(), "red-envelopes") {
|
||
continue
|
||
}
|
||
match := messagePlugin.Match(msgCtx)
|
||
if !match {
|
||
continue
|
||
}
|
||
s.logPluginMatch(messagePlugin, msgCtx)
|
||
messagePlugin.Run(msgCtx)
|
||
}
|
||
}
|
||
|
||
// ProcessAppMessage 处理应用消息
|
||
func (s *MessageService) ProcessAppMessage(message *model.Message, msgSettings settings.Settings) {
|
||
if message.AppMsgType == model.AppMsgTypequote {
|
||
s.ProcessReferMessage(message, msgSettings)
|
||
return
|
||
}
|
||
if message.AppMsgType == model.AppMsgTypeRedEnvelopes {
|
||
s.ProcessRedEnvelopesMessage(message, msgSettings)
|
||
return
|
||
}
|
||
if message.AppMsgType == model.AppMsgTypeUrl {
|
||
xmlMessage, err := s.XmlDecoder(message.Content)
|
||
if err != nil {
|
||
log.Printf("解析应用消息失败: %v", err)
|
||
return
|
||
}
|
||
if xmlMessage.AppMsg.Title == "邀请你加入群聊" || xmlMessage.AppMsg.Title == "Group Chat Invitation" {
|
||
now := time.Now().Unix()
|
||
err := s.sysmsgRepo.Create(&model.SystemMessage{
|
||
MsgID: message.MsgId,
|
||
ClientMsgID: message.ClientMsgId,
|
||
Type: model.SystemMessageTypeJoinChatRoom,
|
||
ImageURL: xmlMessage.AppMsg.ThumbURL,
|
||
Description: xmlMessage.AppMsg.Des,
|
||
Content: message.Content,
|
||
FromWxid: message.FromWxID,
|
||
ToWxid: message.ToWxID,
|
||
Status: 0,
|
||
IsRead: false,
|
||
CreatedAt: now,
|
||
UpdatedAt: now,
|
||
})
|
||
if err != nil {
|
||
log.Printf("入库邀请进群通知消息失败: %v", err)
|
||
return
|
||
}
|
||
if message.ID > 0 {
|
||
// 消息已经没什么用了，删除掉
|
||
err := s.msgRepo.Delete(message)
|
||
if err != nil {
|
||
log.Printf("删除消息失败: %v", err)
|
||
return
|
||
}
|
||
}
|
||
return
|
||
}
|
||
return
|
||
}
|
||
}
|
||
|
||
// ProcessShareCardMessage 处理分享名片消息
|
||
func (s *MessageService) ProcessShareCardMessage(message *model.Message) {
|
||
|
||
}
|
||
|
||
// ProcessFriendVerifyMessage 处理好友添加请求通知消息
|
||
func (s *MessageService) ProcessFriendVerifyMessage(message *model.Message) {
|
||
now := time.Now().Unix()
|
||
var xmlMessage robot.NewFriendMessage
|
||
err := vars.RobotRuntime.XmlDecoder(message.Content, &xmlMessage)
|
||
if err != nil {
|
||
log.Printf("解析好友添加请求消息失败: %v", err)
|
||
return
|
||
}
|
||
|
||
systeMessage := model.SystemMessage{
|
||
MsgID: message.MsgId,
|
||
ClientMsgID: message.ClientMsgId,
|
||
Type: model.SystemMessageTypeVerify,
|
||
ImageURL: xmlMessage.BigHeadImgURL,
|
||
Description: xmlMessage.Content,
|
||
Content: message.Content,
|
||
FromWxid: message.FromWxID,
|
||
ToWxid: message.ToWxID,
|
||
Status: 0,
|
||
IsRead: false,
|
||
CreatedAt: now,
|
||
UpdatedAt: now,
|
||
}
|
||
err = s.sysmsgRepo.Create(&systeMessage)
|
||
if err != nil {
|
||
log.Printf("入库好友添加请求通知消息失败: %v", err)
|
||
return
|
||
}
|
||
|
||
// 自动通过好友
|
||
go func(systemSettingsID int64) {
|
||
err := NewContactService(context.Background()).FriendAutoPassVerify(systemSettingsID)
|
||
if err != nil {
|
||
log.Printf("自动通过好友验证失败: %v", err)
|
||
}
|
||
}(systeMessage.ID)
|
||
|
||
if message.ID > 0 {
|
||
// 消息已经没什么用了，删除掉
|
||
err := s.msgRepo.Delete(message)
|
||
if err != nil {
|
||
log.Printf("删除消息失败: %v", err)
|
||
return
|
||
}
|
||
}
|
||
}
|
||
|
||
// ProcessRecalledMessage 处理撤回消息
|
||
func (s *MessageService) ProcessRecalledMessage(message *model.Message, msgXml robot.SystemMessage) {
|
||
oldMsg, err := s.msgRepo.GetByMsgID(msgXml.RevokeMsg.NewMsgID)
|
||
if err != nil {
|
||
log.Printf("获取撤回的消息失败: %v", err)
|
||
return
|
||
}
|
||
if oldMsg != nil {
|
||
oldMsg.IsRecalled = true
|
||
err = s.msgRepo.Update(oldMsg)
|
||
if err != nil {
|
||
log.Printf("标记撤回消息失败: %v", err)
|
||
} else {
|
||
if message.ID > 0 {
|
||
// 消息已经没什么用了，删除掉
|
||
err := s.msgRepo.Delete(message)
|
||
if err != nil {
|
||
log.Printf("删除消息失败: %v", err)
|
||
return
|
||
}
|
||
}
|
||
}
|
||
return
|
||
}
|
||
}
|
||
|
||
// ProcessPatMessage 处理拍一拍消息
|
||
func (s *MessageService) ProcessPatMessage(message *model.Message, msgXml robot.SystemMessage, msgSettings settings.Settings) {
|
||
msgCtx := &plugin.MessageContext{
|
||
Context: s.ctx,
|
||
Settings: msgSettings,
|
||
Message: message,
|
||
MessageContent: message.Content,
|
||
Pat: message.IsChatRoom && msgXml.Pat.PattedUsername == vars.RobotRuntime.WxID,
|
||
MessageService: s,
|
||
}
|
||
for _, messagePlugin := range vars.MessagePlugin.Plugins {
|
||
if slices.Contains(messagePlugin.GetLabels(), "pat") {
|
||
match := messagePlugin.Match(msgCtx)
|
||
if !match {
|
||
continue
|
||
}
|
||
s.logPluginMatch(messagePlugin, msgCtx)
|
||
messagePlugin.Run(msgCtx)
|
||
}
|
||
}
|
||
}
|
||
|
||
func (s *MessageService) ProcessNewChatRoomMemberMessage(message *model.Message, msgXml robot.SystemMessage) {
|
||
var newMemberWechatIds []string
|
||
if len(msgXml.SysMsgTemplate.ContentTemplate.LinkList.Links) > 0 {
|
||
links := msgXml.SysMsgTemplate.ContentTemplate.LinkList.Links
|
||
for _, link := range links {
|
||
if link.Name == "names" || link.Name == "adder" {
|
||
if link.MemberList != nil {
|
||
for _, member := range link.MemberList.Members {
|
||
newMemberWechatIds = append(newMemberWechatIds, member.Username)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
newMembers, err := NewChatRoomService(s.ctx).UpdateChatRoomMembersOnNewMemberJoinIn(message.FromWxID, newMemberWechatIds)
|
||
if err != nil {
|
||
log.Printf("邀请新成员加入群聊时，更新群成员失败: %v", err)
|
||
}
|
||
if len(newMembers) == 0 {
|
||
log.Println("根据新成员微信ID获取群成员信息失败，没查询到有效的成员信息")
|
||
}
|
||
welcomeConfig, err := NewChatRoomSettingsService(s.ctx).GetChatRoomWelcomeConfig(message.FromWxID)
|
||
if err != nil {
|
||
log.Printf("获取群聊欢迎配置失败: %v", err)
|
||
return
|
||
}
|
||
if welcomeConfig.WelcomeEnabled != nil && !*welcomeConfig.WelcomeEnabled {
|
||
log.Printf("[%s]群聊欢迎消息未启用", message.FromWxID)
|
||
return
|
||
}
|
||
if welcomeConfig.WelcomeType == model.WelcomeTypeText {
|
||
s.SendTextMessage(message.FromWxID, welcomeConfig.WelcomeText)
|
||
}
|
||
if welcomeConfig.WelcomeType == model.WelcomeTypeEmoji {
|
||
s.SendEmoji(message.FromWxID, welcomeConfig.WelcomeEmojiMD5, int32(welcomeConfig.WelcomeEmojiLen))
|
||
}
|
||
if welcomeConfig.WelcomeType == model.WelcomeTypeImage {
|
||
resp, err := resty.New().R().SetDoNotParseResponse(true).Get(welcomeConfig.WelcomeImageURL)
|
||
if err != nil {
|
||
log.Println("获取欢迎图片失败: ", err)
|
||
return
|
||
}
|
||
defer resp.RawBody().Close()
|
||
// 创建临时文件
|
||
tempFile, err := os.CreateTemp("", "welcome_image_*")
|
||
if err != nil {
|
||
log.Println("创建临时文件失败: ", err)
|
||
return
|
||
}
|
||
defer tempFile.Close()
|
||
defer os.Remove(tempFile.Name()) // 清理临时文件
|
||
// 将图片数据写入临时文件
|
||
_, err = io.Copy(tempFile, resp.RawBody())
|
||
if err != nil {
|
||
log.Println("将图片数据写入临时文件失败: ", err)
|
||
return
|
||
}
|
||
_, err = s.MsgUploadImg(message.FromWxID, tempFile)
|
||
if err != nil {
|
||
log.Println("发送欢迎图片消息失败: ", err)
|
||
return
|
||
}
|
||
}
|
||
if welcomeConfig.WelcomeType == model.WelcomeTypeURL {
|
||
if len(newMembers) == 0 {
|
||
return
|
||
}
|
||
var title string
|
||
if len(newMembers) > 1 {
|
||
title = fmt.Sprintf("欢迎%d位家人加入群聊", len(newMembers))
|
||
} else if newMembers[0].Nickname != "" {
|
||
title = fmt.Sprintf("欢迎%s加入群聊", newMembers[0].Nickname)
|
||
} else {
|
||
title = "欢迎新成员加入群聊"
|
||
}
|
||
err := s.ShareLink(message.FromWxID, robot.ShareLinkMessage{
|
||
Title: title,
|
||
Des: welcomeConfig.WelcomeText,
|
||
Url: welcomeConfig.WelcomeURL,
|
||
ThumbUrl: robot.CDATAString(newMembers[0].Avatar),
|
||
})
|
||
if err != nil {
|
||
log.Println("发送欢迎链接消息失败: ", err)
|
||
}
|
||
}
|
||
}
|
||
|
||
// ProcessSystemMessage 处理系统消息
|
||
func (s *MessageService) ProcessSystemMessage(message *model.Message, msgSettings settings.Settings) {
|
||
var msgXml robot.SystemMessage
|
||
err := vars.RobotRuntime.XmlDecoder(message.Content, &msgXml)
|
||
if err != nil {
|
||
return
|
||
}
|
||
if msgXml.Type == "revokemsg" {
|
||
s.ProcessRecalledMessage(message, msgXml)
|
||
return
|
||
}
|
||
if msgXml.Type == "pat" {
|
||
s.ProcessPatMessage(message, msgXml, msgSettings)
|
||
return
|
||
}
|
||
if msgXml.Type == "sysmsgtemplate" &&
|
||
(strings.Contains(msgXml.SysMsgTemplate.ContentTemplate.Template, "加入了群聊") ||
|
||
strings.Contains(msgXml.SysMsgTemplate.ContentTemplate.Template, "分享的二维码加入群聊") ||
|
||
strings.Contains(msgXml.SysMsgTemplate.ContentTemplate.Template, "joined group chat")) {
|
||
s.ProcessNewChatRoomMemberMessage(message, msgXml)
|
||
return
|
||
}
|
||
}
|
||
|
||
// ProcessLocationMessage 处理位置消息
|
||
func (s *MessageService) ProcessLocationMessage(message *model.Message) {
|
||
|
||
}
|
||
|
||
// ProcessPromptMessage 处理提示消息
|
||
func (s *MessageService) ProcessPromptMessage(message *model.Message) {
|
||
|
||
}
|
||
|
||
func (s *MessageService) ProcessMessageSender(message *model.Message) {
|
||
self := vars.RobotRuntime.WxID
|
||
// 处理一下自己发的消息
|
||
// 自己发发到群聊
|
||
if message.FromWxID == self && strings.HasSuffix(message.ToWxID, "@chatroom") {
|
||
from := message.FromWxID
|
||
to := message.ToWxID
|
||
message.FromWxID = to
|
||
message.ToWxID = from
|
||
}
|
||
// 群聊消息
|
||
if strings.HasSuffix(message.FromWxID, "@chatroom") {
|
||
message.IsChatRoom = true
|
||
splitContents := strings.SplitN(message.Content, ":\n", 2)
|
||
if len(splitContents) > 1 {
|
||
message.Content = splitContents[1]
|
||
message.SenderWxID = splitContents[0]
|
||
} else {
|
||
// 绝对是自己发的消息! qwq
|
||
message.Content = splitContents[0]
|
||
message.SenderWxID = self
|
||
}
|
||
} else {
|
||
message.IsChatRoom = false
|
||
message.SenderWxID = message.FromWxID
|
||
if message.FromWxID == self {
|
||
message.FromWxID = message.ToWxID
|
||
message.ToWxID = self
|
||
}
|
||
}
|
||
}
|
||
|
||
func (s *MessageService) ProcessMessageShouldInsertToDB(message *model.Message) bool {
|
||
if message.Type == model.MsgTypeInit || message.Type == model.MsgTypeUnknow {
|
||
return false
|
||
}
|
||
if message.Type == model.MsgTypeSystem && message.SenderWxID == "weixin" {
|
||
return false
|
||
}
|
||
if message.Type == model.MsgTypeApp {
|
||
var xmlmsg robot.XmlMessage
|
||
if err := vars.RobotRuntime.XmlDecoder(message.Content, &xmlmsg); err != nil {
|
||
return true
|
||
}
|
||
message.AppMsgType = model.AppMessageType(xmlmsg.AppMsg.Type)
|
||
if message.AppMsgType == model.AppMsgTypeAttachUploading {
|
||
// 如果是上传中的应用消息，则不入库
|
||
return false
|
||
}
|
||
}
|
||
return true
|
||
}
|
||
|
||
// ProcessMentionedMeMessage 处理下艾特我的消息
|
||
func (s *MessageService) ProcessMentionedMeMessage(message *model.Message, msgSource string) {
|
||
self := vars.RobotRuntime.WxID
|
||
// 是否艾特我的消息
|
||
var msgsource robot.MessageSource
|
||
err := vars.RobotRuntime.XmlDecoder(message.MessageSource, &msgsource)
|
||
if err != nil {
|
||
return
|
||
}
|
||
if msgsource.AtUserList != "" {
|
||
atMembers := strings.Split(msgsource.AtUserList, ",")
|
||
for _, at := range atMembers {
|
||
if strings.Trim(at, " ") == self {
|
||
message.IsAtMe = true
|
||
break
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
func (s *MessageService) InitSettingsByMessage(message *model.Message) (settings settings.Settings) {
|
||
if message.IsChatRoom {
|
||
settings = NewChatRoomSettingsService(s.ctx)
|
||
} else {
|
||
settings = NewFriendSettingsService(s.ctx)
|
||
}
|
||
err := settings.InitByMessage(message)
|
||
if err != nil {
|
||
log.Println("初始化设置失败: ", err)
|
||
return nil
|
||
}
|
||
return
|
||
}
|
||
|
||
func (s *MessageService) ProcessMessage(syncResp robot.SyncMessage) {
|
||
for _, message := range syncResp.AddMsgs {
|
||
m := model.Message{
|
||
MsgId: message.NewMsgId,
|
||
ClientMsgId: message.MsgId,
|
||
Type: message.MsgType,
|
||
Content: *message.Content.String,
|
||
DisplayFullContent: message.PushContent,
|
||
MessageSource: message.MsgSource,
|
||
FromWxID: *message.FromUserName.String,
|
||
ToWxID: *message.ToUserName.String,
|
||
CreatedAt: message.CreateTime,
|
||
UpdatedAt: time.Now().Unix(),
|
||
}
|
||
s.ProcessMessageSender(&m)
|
||
if !s.ProcessMessageShouldInsertToDB(&m) {
|
||
continue
|
||
}
|
||
s.ProcessMentionedMeMessage(&m, message.MsgSource)
|
||
settings := s.InitSettingsByMessage(&m)
|
||
if settings == nil {
|
||
continue
|
||
}
|
||
err := s.msgRepo.Create(&m)
|
||
if err != nil {
|
||
log.Printf("入库消息失败: %v", err)
|
||
continue
|
||
}
|
||
if m.Type == model.MsgTypeText && vars.MemoryService != nil {
|
||
go vars.MemoryService.NotifyMessage(context.Background(), &m)
|
||
}
|
||
switch m.Type {
|
||
case model.MsgTypeText:
|
||
go s.ProcessTextMessage(&m, settings)
|
||
case model.MsgTypeImage:
|
||
go s.ProcessImageMessage(&m, settings)
|
||
case model.MsgTypeVoice:
|
||
go s.ProcessVoiceMessage(&m)
|
||
case model.MsgTypeVideo:
|
||
go s.ProcessVideoMessage(&m)
|
||
case model.MsgTypeEmoticon:
|
||
go s.ProcessEmojiMessage(&m)
|
||
case model.MsgTypeApp:
|
||
go s.ProcessAppMessage(&m, settings)
|
||
case model.MsgTypeShareCard:
|
||
go s.ProcessShareCardMessage(&m)
|
||
case model.MsgTypeVerify:
|
||
// 好友添加请求通知消息
|
||
go s.ProcessFriendVerifyMessage(&m)
|
||
case model.MsgTypeSystem:
|
||
go s.ProcessSystemMessage(&m, settings)
|
||
case model.MsgTypeLocation:
|
||
go s.ProcessLocationMessage(&m)
|
||
case model.MsgTypePrompt:
|
||
go s.ProcessPromptMessage(&m)
|
||
default:
|
||
// 未知消息类型
|
||
log.Printf("未知消息类型: %d, 内容: %s", m.Type, m.Content)
|
||
}
|
||
go func() {
|
||
// 插入一条联系人记录，获取联系人列表接口获取不到未保存到通讯录的群聊
|
||
NewContactService(s.ctx).InsertOrUpdateContactActiveTime(m.FromWxID)
|
||
if strings.HasSuffix(m.FromWxID, "@chatroom") {
|
||
NewChatRoomService(s.ctx).UpsertChatRoomMember(&model.ChatRoomMember{
|
||
ChatRoomID: m.FromWxID,
|
||
WechatID: m.SenderWxID,
|
||
})
|
||
}
|
||
}()
|
||
}
|
||
for _, contact := range syncResp.ModContacts {
|
||
if contact.UserName.String != nil {
|
||
if strings.HasSuffix(*contact.UserName.String, "@chatroom") {
|
||
// 群成员信息有变化，更新群聊成员（防抖，5 秒内只执行最后一次）
|
||
NewChatRoomService(context.Background()).DebounceSyncChatRoomMember(*contact.UserName.String)
|
||
} else {
|
||
// 更新联系人信息
|
||
NewContactService(context.Background()).DebounceSyncContact(*contact.UserName.String)
|
||
// 检测昵称变更并通知所在群
|
||
s.detectAndNotifyNicknameChange(contact)
|
||
}
|
||
}
|
||
}
|
||
for _, contact := range syncResp.DelContacts {
|
||
if contact.UserName.String != nil {
|
||
err := NewContactService(context.Background()).DeleteContactByContactID(*contact.UserName.String)
|
||
if err != nil {
|
||
log.Println("删除联系人失败: ", err)
|
||
}
|
||
}
|
||
}
|
||
// webhook 回调
|
||
s.MessageWebhook(syncResp)
|
||
}
|
||
|
||
func (s *MessageService) MessageWebhook(syncResp robot.SyncMessage) {
|
||
if vars.Webhook.URL != "" {
|
||
req := resty.New().R().
|
||
SetHeader("Content-Type", "application/json;chartset=utf-8").
|
||
SetBody(syncResp)
|
||
|
||
// 设置自定义 headers
|
||
if vars.Webhook.Headers != nil {
|
||
for k, v := range vars.Webhook.Headers {
|
||
switch val := v.(type) {
|
||
case string:
|
||
// 单个字符串值
|
||
req.SetHeader(k, val)
|
||
case []string:
|
||
// 字符串数组,设置多个相同 key 的 header
|
||
for _, headerVal := range val {
|
||
req.SetHeader(k, headerVal)
|
||
}
|
||
case []any:
|
||
// any 数组,尝试转换为字符串
|
||
for _, item := range val {
|
||
if strVal, ok := item.(string); ok {
|
||
req.SetHeader(k, strVal)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
webhookUrl := vars.Webhook.URL
|
||
if strings.Contains(webhookUrl, "?") {
|
||
webhookUrl += fmt.Sprintf("&robot_id=%d&robot_code=%s&robot_wxid=%s", vars.RobotRuntime.RobotID, vars.RobotRuntime.RobotCode, vars.RobotRuntime.WxID)
|
||
} else {
|
||
webhookUrl += fmt.Sprintf("?robot_id=%d&robot_code=%s&robot_wxid=%s", vars.RobotRuntime.RobotID, vars.RobotRuntime.RobotCode, vars.RobotRuntime.WxID)
|
||
}
|
||
_, err := req.Post(webhookUrl)
|
||
if err != nil {
|
||
log.Println("消息 webhook 调用失败: ", err.Error())
|
||
}
|
||
}
|
||
}
|
||
|
||
func (s *MessageService) SyncMessage() {
|
||
// 获取新消息
|
||
syncResp, err := vars.RobotRuntime.SyncMessage()
|
||
if err != nil {
|
||
// 有可能是用户退出了，或者掉线了，这里不处理，由心跳机制处理机器人在线/离线状态
|
||
log.Println("获取新消息失败: ", err)
|
||
return
|
||
}
|
||
if len(syncResp.AddMsgs) == 0 {
|
||
// 没有消息，直接返回
|
||
return
|
||
}
|
||
s.ProcessMessage(syncResp)
|
||
}
|
||
|
||
func (s *MessageService) XmlDecoder(content string) (robot.XmlMessage, error) {
|
||
var xmlMessage robot.XmlMessage
|
||
err := vars.RobotRuntime.XmlDecoder(content, &xmlMessage)
|
||
if err != nil {
|
||
return xmlMessage, err
|
||
}
|
||
return xmlMessage, nil
|
||
}
|
||
|
||
func (s *MessageService) MessageRevoke(req dto.MessageCommonRequest) error {
|
||
message, err := s.msgRepo.GetByID(req.MessageID)
|
||
if err != nil {
|
||
return fmt.Errorf("获取消息失败: %w", err)
|
||
}
|
||
if message == nil {
|
||
return errors.New("消息不存在")
|
||
}
|
||
// 两分钟前
|
||
if message.CreatedAt+120 < time.Now().Unix() {
|
||
return errors.New("消息已过期")
|
||
}
|
||
return vars.RobotRuntime.MessageRevoke(*message)
|
||
}
|
||
|
||
func (s *MessageService) SendTextMessage(toWxID, content string, at ...string) error {
|
||
atContent := ""
|
||
if len(at) > 0 {
|
||
// 手动拼接上 @ 符号和昵称
|
||
for index, wxid := range at {
|
||
var targetNickname string
|
||
|
||
if strings.HasSuffix(toWxID, "@chatroom") {
|
||
// 群聊消息，昵称优先取群备注，备注取不到或者取失败了，再去取联系人的昵称
|
||
chatRoomMember, err := s.crmRepo.GetChatRoomMember(toWxID, wxid)
|
||
if err != nil || chatRoomMember == nil {
|
||
r, err := vars.RobotRuntime.GetContactDetail("", []string{wxid})
|
||
if err != nil || len(r.ContactList) == 0 {
|
||
continue
|
||
}
|
||
if r.ContactList[0].NickName.String == nil {
|
||
continue
|
||
}
|
||
targetNickname = *r.ContactList[0].NickName.String
|
||
} else {
|
||
if chatRoomMember.Remark != "" {
|
||
targetNickname = chatRoomMember.Remark
|
||
} else {
|
||
targetNickname = chatRoomMember.Nickname
|
||
}
|
||
}
|
||
} else {
|
||
// 私聊消息
|
||
r, err := vars.RobotRuntime.GetContactDetail("", []string{wxid})
|
||
if err != nil || len(r.ContactList) == 0 {
|
||
continue
|
||
}
|
||
if r.ContactList[0].NickName.String == nil {
|
||
continue
|
||
}
|
||
targetNickname = *r.ContactList[0].NickName.String
|
||
}
|
||
|
||
if targetNickname == "" {
|
||
continue
|
||
}
|
||
if index > 0 {
|
||
atContent += " "
|
||
}
|
||
atContent += fmt.Sprintf("@%s%s", targetNickname, "\u2005")
|
||
}
|
||
}
|
||
content = atContent + content
|
||
newMessages, err := vars.RobotRuntime.SendTextMessage(toWxID, content, at...)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
// 通过机器人发送的消息，消息同步接口获取不到，所以这里需要手动入库
|
||
if len(newMessages.List) > 0 {
|
||
for _, message := range newMessages.List {
|
||
if message.Ret == 0 {
|
||
m := model.Message{
|
||
MsgId: message.NewMsgId,
|
||
ClientMsgId: message.ClientMsgid,
|
||
Type: model.MsgTypeText,
|
||
Content: content,
|
||
DisplayFullContent: "",
|
||
MessageSource: "",
|
||
FromWxID: toWxID,
|
||
ToWxID: vars.RobotRuntime.WxID,
|
||
SenderWxID: vars.RobotRuntime.WxID,
|
||
IsChatRoom: strings.HasSuffix(toWxID, "@chatroom"),
|
||
CreatedAt: message.Createtime,
|
||
UpdatedAt: time.Now().Unix(),
|
||
}
|
||
if m.IsChatRoom && len(at) > 0 {
|
||
m.ReplyWxID = at[0]
|
||
}
|
||
err = s.msgRepo.Create(&m)
|
||
if err != nil {
|
||
log.Printf("入库消息失败: %v", err)
|
||
}
|
||
// 插入一条联系人记录，获取联系人列表接口获取不到未保存到通讯录的群聊
|
||
NewContactService(s.ctx).InsertOrUpdateContactActiveTime(m.FromWxID)
|
||
}
|
||
}
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
func (s *MessageService) ToolsCompleted(toWxID, replyWxID string) error {
|
||
now := time.Now()
|
||
m := model.Message{
|
||
MsgId: now.UnixNano() + rand.Int63n(1000),
|
||
ClientMsgId: now.Unix(),
|
||
Type: model.MsgTypeText,
|
||
Content: "成功完成工具调用",
|
||
DisplayFullContent: "",
|
||
MessageSource: "",
|
||
FromWxID: toWxID,
|
||
ToWxID: vars.RobotRuntime.WxID,
|
||
SenderWxID: vars.RobotRuntime.WxID,
|
||
ReplyWxID: replyWxID,
|
||
IsChatRoom: strings.HasSuffix(toWxID, "@chatroom"),
|
||
CreatedAt: now.Unix(),
|
||
UpdatedAt: now.Unix(),
|
||
}
|
||
return s.msgRepo.Create(&m)
|
||
}
|
||
|
||
// MsgSendGroupMassMsgText 文本消息群发接口
|
||
func (s *MessageService) MsgSendGroupMassMsgText(toWxID []string, content string) error {
|
||
_, err := vars.RobotRuntime.MsgSendGroupMassMsgText(robot.MsgSendGroupMassMsgTextRequest{
|
||
ToWxid: toWxID,
|
||
Content: content,
|
||
})
|
||
if err != nil {
|
||
return err
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (s *MessageService) SendAppMessage(toWxID string, appMsgType int, appMsgXml string) error {
|
||
message, err := vars.RobotRuntime.SendAppMessage(toWxID, appMsgType, appMsgXml)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
m := model.Message{
|
||
MsgId: message.NewMsgId,
|
||
ClientMsgId: message.MsgId,
|
||
Type: model.MsgTypeApp,
|
||
AppMsgType: model.AppMessageType(appMsgType),
|
||
Content: message.Content,
|
||
DisplayFullContent: "",
|
||
MessageSource: message.MsgSource,
|
||
FromWxID: toWxID,
|
||
ToWxID: vars.RobotRuntime.WxID,
|
||
SenderWxID: vars.RobotRuntime.WxID,
|
||
IsChatRoom: strings.HasSuffix(toWxID, "@chatroom"),
|
||
CreatedAt: message.CreateTime,
|
||
UpdatedAt: time.Now().Unix(),
|
||
}
|
||
err = s.msgRepo.Create(&m)
|
||
if err != nil {
|
||
log.Println("入库消息失败: ", err)
|
||
}
|
||
// 插入一条联系人记录，获取联系人列表接口获取不到未保存到通讯录的群聊
|
||
NewContactService(s.ctx).InsertOrUpdateContactActiveTime(m.FromWxID)
|
||
|
||
return nil
|
||
}
|
||
|
||
// 发送图片信息
|
||
func (s *MessageService) MsgUploadImg(toWxID string, image io.Reader) (*model.Message, error) {
|
||
imageBytes, err := io.ReadAll(image)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("读取文件内容失败: %w", err)
|
||
}
|
||
message, err := vars.RobotRuntime.MsgUploadImg(toWxID, imageBytes)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
m := model.Message{
|
||
MsgId: message.Newmsgid,
|
||
ClientMsgId: message.Msgid,
|
||
Type: model.MsgTypeImage,
|
||
Content: "", // 获取不到图片的 xml 内容
|
||
DisplayFullContent: "",
|
||
MessageSource: message.MsgSource,
|
||
FromWxID: toWxID,
|
||
ToWxID: vars.RobotRuntime.WxID,
|
||
SenderWxID: vars.RobotRuntime.WxID,
|
||
IsChatRoom: strings.HasSuffix(toWxID, "@chatroom"),
|
||
CreatedAt: message.CreateTime,
|
||
UpdatedAt: time.Now().Unix(),
|
||
}
|
||
err = s.msgRepo.Create(&m)
|
||
if err != nil {
|
||
log.Println("入库消息失败: ", err)
|
||
}
|
||
// 插入一条联系人记录，获取联系人列表接口获取不到未保存到通讯录的群聊
|
||
NewContactService(s.ctx).InsertOrUpdateContactActiveTime(m.FromWxID)
|
||
|
||
return &m, nil
|
||
}
|
||
|
||
// SendImageMessageByRemoteURL 根据远程URL发送图片（优先使用分片下载，不支持则回退到普通下载）
|
||
func (s *MessageService) SendImageMessageByRemoteURL(toWxID string, imageURL string) error {
|
||
// 使用 Range 请求第一个字节来探测是否支持分片下载
|
||
rangeHeader := "bytes=0-0"
|
||
testResp, err := resty.New().R().
|
||
SetHeader("Range", rangeHeader).
|
||
SetDoNotParseResponse(true).
|
||
Get(imageURL)
|
||
if err != nil {
|
||
return fmt.Errorf("获取图片信息失败: %w", err)
|
||
}
|
||
testResp.RawBody().Close()
|
||
|
||
if testResp.StatusCode() != 206 && testResp.StatusCode() != 200 {
|
||
log.Printf("获取图片信息失败，HTTP状态码: %d\n", testResp.StatusCode())
|
||
return fmt.Errorf("获取图片信息失败，HTTP状态码: %d", testResp.StatusCode())
|
||
}
|
||
|
||
// 如果返回 206，说明支持 Range 请求
|
||
supportsRange := testResp.StatusCode() == 206
|
||
|
||
if !supportsRange {
|
||
log.Println("服务器不支持 Range 请求，使用普通下载方式")
|
||
return s.sendImageByNormalDownload(toWxID, imageURL)
|
||
}
|
||
|
||
// 从 Content-Range 获取文件总大小
|
||
contentLength := testResp.RawResponse.ContentLength
|
||
contentRange := testResp.Header().Get("Content-Range")
|
||
if contentRange != "" {
|
||
// Content-Range 格式: bytes 0-0/总大小
|
||
parts := strings.Split(contentRange, "/")
|
||
if len(parts) == 2 {
|
||
total, err := strconv.ParseInt(parts[1], 10, 64)
|
||
if err == nil {
|
||
contentLength = total
|
||
}
|
||
}
|
||
}
|
||
|
||
if contentLength <= 1 {
|
||
log.Println("无法获取图片大小，使用普通下载方式")
|
||
return s.sendImageByNormalDownload(toWxID, imageURL)
|
||
}
|
||
|
||
// 生成唯一的客户端图片ID
|
||
clientImgId := fmt.Sprintf("%v_%v", vars.RobotRuntime.WxID, time.Now().UnixNano())
|
||
|
||
// 计算分片数量
|
||
chunkSize := vars.UploadImageChunkSize
|
||
totalChunks := (contentLength + chunkSize - 1) / chunkSize
|
||
|
||
// 分片下载并上传
|
||
for chunkIndex := range totalChunks {
|
||
start := int64(chunkIndex) * chunkSize
|
||
end := start + chunkSize - 1
|
||
if end >= contentLength {
|
||
end = contentLength - 1
|
||
}
|
||
|
||
// 使用 Range 请求下载分片
|
||
rangeHeader := fmt.Sprintf("bytes=%d-%d", start, end)
|
||
resp, err := resty.New().R().
|
||
SetHeader("Range", rangeHeader).
|
||
SetDoNotParseResponse(true).
|
||
Get(imageURL)
|
||
if err != nil {
|
||
return fmt.Errorf("下载图片分片失败 (chunk %d/%d): %w", chunkIndex+1, totalChunks, err)
|
||
}
|
||
|
||
// 如果第一个分片就不支持 Range，回退到普通下载
|
||
if chunkIndex == 0 && resp.StatusCode() != 206 && resp.StatusCode() != 200 {
|
||
resp.RawBody().Close()
|
||
log.Printf("Range 请求返回状态码 %d，回退到普通下载方式", resp.StatusCode())
|
||
return s.sendImageByNormalDownload(toWxID, imageURL)
|
||
}
|
||
|
||
if resp.StatusCode() != 206 && resp.StatusCode() != 200 {
|
||
resp.RawBody().Close()
|
||
return fmt.Errorf("下载图片分片失败，HTTP状态码: %d (chunk %d/%d)", resp.StatusCode(), chunkIndex+1, totalChunks)
|
||
}
|
||
|
||
// 读取分片数据
|
||
chunkData, err := io.ReadAll(resp.RawBody())
|
||
resp.RawBody().Close()
|
||
if err != nil {
|
||
return fmt.Errorf("读取分片数据失败 (chunk %d/%d): %w", chunkIndex+1, totalChunks, err)
|
||
}
|
||
|
||
// 创建分片请求
|
||
req := dto.SendImageMessageRequest{
|
||
ToWxid: toWxID,
|
||
ClientImgId: clientImgId,
|
||
FileSize: contentLength,
|
||
ChunkIndex: int64(chunkIndex),
|
||
TotalChunks: totalChunks,
|
||
ImageURL: imageURL,
|
||
}
|
||
|
||
// 创建分片 reader
|
||
chunkReader := io.NopCloser(strings.NewReader(string(chunkData)))
|
||
chunkHeader := &multipart.FileHeader{
|
||
Filename: fmt.Sprintf("chunk_%d", chunkIndex),
|
||
Size: int64(len(chunkData)),
|
||
}
|
||
|
||
// 发送分片
|
||
_, err = s.SendImageMessageStream(s.ctx, req, chunkReader, chunkHeader)
|
||
if err != nil {
|
||
return fmt.Errorf("发送图片分片失败 (chunk %d/%d): %w", chunkIndex+1, totalChunks, err)
|
||
}
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
// sendImageByNormalDownload 普通下载方式（一次性下载，分片上传）
|
||
func (s *MessageService) sendImageByNormalDownload(toWxID string, imageURL string) error {
|
||
resp, err := resty.New().R().SetDoNotParseResponse(true).Get(imageURL)
|
||
if err != nil {
|
||
return fmt.Errorf("下载图片失败: %w", err)
|
||
}
|
||
defer resp.RawBody().Close()
|
||
|
||
if resp.StatusCode() != 200 {
|
||
return fmt.Errorf("下载图片失败，HTTP状态码: %d", resp.StatusCode())
|
||
}
|
||
|
||
// 读取整个图片到内存
|
||
imageData, err := io.ReadAll(resp.RawBody())
|
||
if err != nil {
|
||
return fmt.Errorf("读取图片数据失败: %w", err)
|
||
}
|
||
|
||
contentLength := int64(len(imageData))
|
||
if contentLength == 0 {
|
||
return fmt.Errorf("图片数据为空")
|
||
}
|
||
|
||
// 生成唯一的客户端图片ID
|
||
clientImgId := fmt.Sprintf("%v_%v", vars.RobotRuntime.WxID, time.Now().UnixNano())
|
||
|
||
// 计算分片数量
|
||
chunkSize := vars.UploadImageChunkSize
|
||
totalChunks := (contentLength + chunkSize - 1) / chunkSize
|
||
|
||
// 分片上传
|
||
for chunkIndex := range totalChunks {
|
||
start := int64(chunkIndex) * chunkSize
|
||
end := start + chunkSize
|
||
if end > contentLength {
|
||
end = contentLength
|
||
}
|
||
|
||
// 提取当前分片数据
|
||
chunkData := imageData[start:end]
|
||
|
||
// 创建分片请求
|
||
req := dto.SendImageMessageRequest{
|
||
ToWxid: toWxID,
|
||
ClientImgId: clientImgId,
|
||
FileSize: contentLength,
|
||
ChunkIndex: int64(chunkIndex),
|
||
TotalChunks: totalChunks,
|
||
ImageURL: imageURL,
|
||
}
|
||
|
||
// 创建分片 reader
|
||
chunkReader := io.NopCloser(strings.NewReader(string(chunkData)))
|
||
chunkHeader := &multipart.FileHeader{
|
||
Filename: fmt.Sprintf("chunk_%d", chunkIndex),
|
||
Size: int64(len(chunkData)),
|
||
}
|
||
|
||
// 发送分片
|
||
_, err = s.SendImageMessageStream(s.ctx, req, chunkReader, chunkHeader)
|
||
if err != nil {
|
||
return fmt.Errorf("发送图片分片失败 (chunk %d/%d): %w", chunkIndex+1, totalChunks, err)
|
||
}
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
// 分片发送图片信息
|
||
func (s *MessageService) SendImageMessageStream(ctx context.Context, req dto.SendImageMessageRequest, file io.Reader, fileHeader *multipart.FileHeader) (*model.Message, error) {
|
||
message, err := vars.RobotRuntime.SendImageMessageStream(robot.SendImageMessageStreamRequest{
|
||
ToWxid: req.ToWxid,
|
||
ClientImgId: req.ClientImgId,
|
||
TotalLen: req.FileSize,
|
||
StartPos: req.ChunkIndex * vars.UploadImageChunkSize,
|
||
}, file, fileHeader)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
// 图片还没上传完
|
||
if message == nil {
|
||
return nil, nil
|
||
}
|
||
|
||
m := model.Message{
|
||
MsgId: message.Newmsgid,
|
||
ClientMsgId: message.Msgid,
|
||
Type: model.MsgTypeImage,
|
||
Content: "", // 获取不到图片的 xml 内容
|
||
DisplayFullContent: "",
|
||
MessageSource: message.MsgSource,
|
||
FromWxID: req.ToWxid,
|
||
ToWxID: vars.RobotRuntime.WxID,
|
||
SenderWxID: vars.RobotRuntime.WxID,
|
||
IsChatRoom: strings.HasSuffix(req.ToWxid, "@chatroom"),
|
||
AttachmentUrl: req.ImageURL,
|
||
CreatedAt: message.CreateTime,
|
||
UpdatedAt: time.Now().Unix(),
|
||
}
|
||
err = s.msgRepo.Create(&m)
|
||
if err != nil {
|
||
log.Println("入库消息失败: ", err)
|
||
}
|
||
// 插入一条联系人记录，获取联系人列表接口获取不到未保存到通讯录的群聊
|
||
NewContactService(s.ctx).InsertOrUpdateContactActiveTime(m.FromWxID)
|
||
|
||
return &m, nil
|
||
}
|
||
|
||
func (s *MessageService) SendImageMessageByLocalPath(toWxID string, imagePath string) error {
|
||
_, _, err := s.ValidateLocalFileForSend(imagePath, map[string]bool{
|
||
".jpg": true,
|
||
".jpeg": true,
|
||
".png": true,
|
||
".gif": true,
|
||
".webp": true,
|
||
}, 0, "图片")
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
clientImgId := fmt.Sprintf("%v_%v", vars.RobotRuntime.WxID, time.Now().UnixNano())
|
||
return s.StreamLocalFileChunks(imagePath, vars.UploadImageChunkSize, func(chunkIndex, totalChunks, totalSize int64, chunkReader io.Reader, fileHeader *multipart.FileHeader) error {
|
||
_, err := s.SendImageMessageStream(s.ctx, dto.SendImageMessageRequest{
|
||
ToWxid: toWxID,
|
||
ClientImgId: clientImgId,
|
||
FileSize: totalSize,
|
||
ChunkIndex: chunkIndex,
|
||
TotalChunks: totalChunks,
|
||
}, chunkReader, fileHeader)
|
||
if err != nil {
|
||
return fmt.Errorf("发送图片分片失败 (chunk %d/%d): %w", chunkIndex+1, totalChunks, err)
|
||
}
|
||
return nil
|
||
})
|
||
}
|
||
|
||
func (s *MessageService) MsgSendVideo(toWxID string, video io.Reader, videoExt string) error {
|
||
videoBytes, err := io.ReadAll(video)
|
||
if err != nil {
|
||
return fmt.Errorf("读取文件内容失败: %w", err)
|
||
}
|
||
_, err = vars.RobotRuntime.MsgSendVideo(toWxID, videoBytes, videoExt)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
msgid := time.Now().UnixNano()
|
||
m := model.Message{
|
||
MsgId: msgid,
|
||
ClientMsgId: msgid,
|
||
Type: model.MsgTypeVideo,
|
||
Content: "", // 获取不到视频的 xml 内容
|
||
DisplayFullContent: "",
|
||
MessageSource: "",
|
||
FromWxID: toWxID,
|
||
ToWxID: vars.RobotRuntime.WxID,
|
||
SenderWxID: vars.RobotRuntime.WxID,
|
||
IsChatRoom: strings.HasSuffix(toWxID, "@chatroom"),
|
||
CreatedAt: time.Now().Unix(),
|
||
UpdatedAt: time.Now().Unix(),
|
||
}
|
||
err = s.msgRepo.Create(&m)
|
||
if err != nil {
|
||
log.Println("入库消息失败: ", err)
|
||
}
|
||
// 插入一条联系人记录，获取联系人列表接口获取不到未保存到通讯录的群聊
|
||
NewContactService(s.ctx).InsertOrUpdateContactActiveTime(m.FromWxID)
|
||
|
||
return nil
|
||
}
|
||
|
||
func (s *MessageService) SendVideoMessageByLocalPath(toWxID string, videoPath string) error {
|
||
_, _, err := s.ValidateLocalFileForSend(videoPath, map[string]bool{
|
||
".mp4": true,
|
||
".avi": true,
|
||
".mov": true,
|
||
".mkv": true,
|
||
".flv": true,
|
||
".webm": true,
|
||
}, 0, "视频")
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
message, err := vars.RobotRuntime.MsgSendVideoFromLocal(toWxID, videoPath)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if message == nil {
|
||
return errors.New("发送视频失败，获取视频结果为空")
|
||
}
|
||
|
||
m := model.Message{
|
||
MsgId: message.NewMsgId,
|
||
ClientMsgId: message.Msgid,
|
||
Type: model.MsgTypeVideo,
|
||
Content: "",
|
||
DisplayFullContent: "",
|
||
MessageSource: "",
|
||
FromWxID: toWxID,
|
||
ToWxID: vars.RobotRuntime.WxID,
|
||
SenderWxID: vars.RobotRuntime.WxID,
|
||
IsChatRoom: strings.HasSuffix(toWxID, "@chatroom"),
|
||
CreatedAt: time.Now().Unix(),
|
||
UpdatedAt: time.Now().Unix(),
|
||
}
|
||
err = s.msgRepo.Create(&m)
|
||
if err != nil {
|
||
log.Println("入库消息失败: ", err)
|
||
}
|
||
NewContactService(s.ctx).InsertOrUpdateContactActiveTime(m.FromWxID)
|
||
|
||
return nil
|
||
}
|
||
|
||
func (s *MessageService) SendVideoMessageByRemoteURL(toWxID string, videoURL string) error {
|
||
tempFile, err := os.CreateTemp("", "video_*")
|
||
if err != nil {
|
||
return fmt.Errorf("创建临时文件失败: %w", err)
|
||
}
|
||
tempFilePath := tempFile.Name()
|
||
defer os.Remove(tempFilePath)
|
||
|
||
const defaultUA = "Mozilla/5.0 (iPhone; CPU iPhone OS 14_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0 Mobile/15E148 Safari/604.1"
|
||
|
||
// 尝试分片下载
|
||
chunkSize := int64(1024 * 1024)
|
||
// 先尝试请求第一个分片，检测是否支持 Range
|
||
rangeHeader := fmt.Sprintf("bytes=0-%d", chunkSize-1)
|
||
resp, err := resty.New().R().
|
||
SetHeader("User-Agent", defaultUA).
|
||
SetHeader("Referer", "https://www.douyin.com/").
|
||
SetHeader("Range", rangeHeader).
|
||
SetDoNotParseResponse(true).
|
||
Get(videoURL)
|
||
if err != nil {
|
||
tempFile.Close()
|
||
return fmt.Errorf("下载视频失败: %w", err)
|
||
}
|
||
|
||
// 如果返回 206，说明支持分片下载
|
||
if resp.StatusCode() == 206 {
|
||
log.Println("服务器支持 Range 请求，使用分片下载")
|
||
// 获取文件总大小
|
||
contentLength := resp.RawResponse.ContentLength
|
||
contentRange := resp.Header().Get("Content-Range")
|
||
if contentRange != "" {
|
||
// Content-Range 格式: bytes 0-1048575/总大小
|
||
parts := strings.Split(contentRange, "/")
|
||
if len(parts) == 2 {
|
||
total, err := strconv.ParseInt(parts[1], 10, 64)
|
||
if err == nil {
|
||
contentLength = total
|
||
}
|
||
}
|
||
}
|
||
|
||
// 写入第一个分片
|
||
_, err = io.Copy(tempFile, resp.RawBody())
|
||
resp.RawBody().Close()
|
||
if err != nil {
|
||
tempFile.Close()
|
||
return fmt.Errorf("写入第一个分片失败: %w", err)
|
||
}
|
||
|
||
// 下载剩余分片
|
||
for start := chunkSize; start < contentLength; start += chunkSize {
|
||
end := start + chunkSize - 1
|
||
if end >= contentLength {
|
||
end = contentLength - 1
|
||
}
|
||
|
||
rangeHeader := fmt.Sprintf("bytes=%d-%d", start, end)
|
||
chunkResp, err := resty.New().R().
|
||
SetHeader("User-Agent", defaultUA).
|
||
SetHeader("Referer", "https://www.douyin.com/").
|
||
SetHeader("Range", rangeHeader).
|
||
SetDoNotParseResponse(true).
|
||
Get(videoURL)
|
||
if err != nil {
|
||
tempFile.Close()
|
||
return fmt.Errorf("下载视频分片失败 (bytes %d-%d): %w", start, end, err)
|
||
}
|
||
|
||
if chunkResp.StatusCode() != 206 && chunkResp.StatusCode() != 200 {
|
||
chunkResp.RawBody().Close()
|
||
tempFile.Close()
|
||
return fmt.Errorf("下载视频分片失败，HTTP状态码: %d (bytes %d-%d)", chunkResp.StatusCode(), start, end)
|
||
}
|
||
|
||
_, err = io.Copy(tempFile, chunkResp.RawBody())
|
||
chunkResp.RawBody().Close()
|
||
if err != nil {
|
||
tempFile.Close()
|
||
return fmt.Errorf("写入视频分片失败 (bytes %d-%d): %w", start, end, err)
|
||
}
|
||
}
|
||
} else if resp.StatusCode() == 200 {
|
||
log.Println("服务器不支持 Range 请求，使用普通下载方式")
|
||
_, err = io.Copy(tempFile, resp.RawBody())
|
||
resp.RawBody().Close()
|
||
if err != nil {
|
||
tempFile.Close()
|
||
return fmt.Errorf("写入视频数据失败: %w", err)
|
||
}
|
||
} else {
|
||
resp.RawBody().Close()
|
||
tempFile.Close()
|
||
return fmt.Errorf("下载视频失败，HTTP状态码: %d", resp.StatusCode())
|
||
}
|
||
|
||
tempFile.Close()
|
||
|
||
// 检查视频大小，超过 20MB 则用 ffmpeg 压缩
|
||
const maxVideoSize = 20 * 1024 * 1024
|
||
sendPath := tempFilePath
|
||
fileInfo, statErr := os.Stat(tempFilePath)
|
||
if statErr == nil && fileInfo.Size() > maxVideoSize {
|
||
compressedPath := tempFilePath + "_compressed.mp4"
|
||
log.Printf("[视频压缩] 原始大小: %dMB，开始压缩...", fileInfo.Size()/1024/1024)
|
||
if compressErr := compressVideoWithFFmpeg(tempFilePath, compressedPath, maxVideoSize); compressErr != nil {
|
||
log.Printf("[视频压缩] 压缩失败: %v，尝试直接发送原始文件", compressErr)
|
||
} else {
|
||
sendPath = compressedPath
|
||
defer os.Remove(compressedPath)
|
||
if ci, err2 := os.Stat(compressedPath); err2 == nil {
|
||
log.Printf("[视频压缩] 压缩完成: %dMB -> %dMB", fileInfo.Size()/1024/1024, ci.Size()/1024/1024)
|
||
}
|
||
}
|
||
}
|
||
|
||
message, err := vars.RobotRuntime.MsgSendVideoFromLocal(toWxID, sendPath)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if message == nil {
|
||
return errors.New("发送视频失败，获取视频结果为空")
|
||
}
|
||
|
||
m := model.Message{
|
||
MsgId: message.NewMsgId,
|
||
ClientMsgId: message.Msgid,
|
||
Type: model.MsgTypeVideo,
|
||
Content: "", // 获取不到视频的 xml 内容
|
||
DisplayFullContent: "",
|
||
MessageSource: "",
|
||
FromWxID: toWxID,
|
||
ToWxID: vars.RobotRuntime.WxID,
|
||
SenderWxID: vars.RobotRuntime.WxID,
|
||
IsChatRoom: strings.HasSuffix(toWxID, "@chatroom"),
|
||
AttachmentUrl: videoURL,
|
||
CreatedAt: time.Now().Unix(),
|
||
UpdatedAt: time.Now().Unix(),
|
||
}
|
||
err = s.msgRepo.Create(&m)
|
||
if err != nil {
|
||
log.Println("入库消息失败: ", err)
|
||
}
|
||
// 插入一条联系人记录，获取联系人列表接口获取不到未保存到通讯录的群聊
|
||
NewContactService(s.ctx).InsertOrUpdateContactActiveTime(m.FromWxID)
|
||
|
||
return nil
|
||
}
|
||
|
||
func (s *MessageService) MsgSendVoice(toWxID string, voice io.Reader, voiceExt string) error {
|
||
videoBytes, err := io.ReadAll(voice)
|
||
if err != nil {
|
||
return fmt.Errorf("读取文件内容失败: %w", err)
|
||
}
|
||
message, err := vars.RobotRuntime.MsgSendVoice(toWxID, videoBytes, voiceExt)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
clientMsgId, _ := strconv.ParseInt(message.ClientMsgId, 10, 64)
|
||
m := model.Message{
|
||
MsgId: message.NewMsgId,
|
||
ClientMsgId: clientMsgId,
|
||
Type: model.MsgTypeVoice,
|
||
Content: "", // 获取不到音频的 xml 内容
|
||
DisplayFullContent: "",
|
||
MessageSource: "",
|
||
FromWxID: toWxID,
|
||
ToWxID: vars.RobotRuntime.WxID,
|
||
SenderWxID: vars.RobotRuntime.WxID,
|
||
IsChatRoom: strings.HasSuffix(toWxID, "@chatroom"),
|
||
CreatedAt: message.CreateTime,
|
||
UpdatedAt: time.Now().Unix(),
|
||
}
|
||
err = s.msgRepo.Create(&m)
|
||
if err != nil {
|
||
log.Println("入库消息失败: ", err)
|
||
}
|
||
// 插入一条联系人记录，获取联系人列表接口获取不到未保存到通讯录的群聊
|
||
NewContactService(s.ctx).InsertOrUpdateContactActiveTime(m.FromWxID)
|
||
|
||
return nil
|
||
}
|
||
|
||
func (s *MessageService) SendVoiceMessageByLocalPath(toWxID string, voicePath string) error {
|
||
_, voiceExt, err := s.ValidateLocalFileForSend(voicePath, map[string]bool{
|
||
".amr": true,
|
||
".mp3": true,
|
||
".wav": true,
|
||
}, 50*1024*1024, "音频")
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
voiceFile, err := os.Open(voicePath)
|
||
if err != nil {
|
||
return fmt.Errorf("打开本地音频文件失败: %w", err)
|
||
}
|
||
defer voiceFile.Close()
|
||
|
||
return s.MsgSendVoice(toWxID, voiceFile, voiceExt)
|
||
}
|
||
|
||
func (s *MessageService) SendLongTextMessage(toWxID string, longText string) error {
|
||
currentRobot, err := s.robotAdminRepo.GetByWeChatID(vars.RobotRuntime.WxID)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if currentRobot == nil || currentRobot.Nickname == nil {
|
||
return fmt.Errorf("未找到机器人信息")
|
||
}
|
||
|
||
dataID := uuid.New().String()
|
||
fiveMinuteAgo := time.Now().Add(-5 * time.Minute)
|
||
|
||
recordInfo := robot.RecordInfo{
|
||
Info: fmt.Sprintf("%s: %s", *currentRobot.Nickname, longText),
|
||
IsChatRoom: 1,
|
||
Desc: fmt.Sprintf("%s: %s", *currentRobot.Nickname, longText),
|
||
FromScene: 3,
|
||
DataList: robot.DataList{
|
||
Count: 1,
|
||
Items: []robot.DataItem{
|
||
{
|
||
DataType: 1,
|
||
DataID: strings.ReplaceAll(dataID, "-", ""),
|
||
SrcMsgLocalID: rand.Intn(90000) + 10000,
|
||
SourceTime: fiveMinuteAgo.Format("2006-1-2 15:04"),
|
||
FromNewMsgID: time.Now().UnixNano() / 100,
|
||
SrcMsgCreateTime: fiveMinuteAgo.Unix(),
|
||
DataDesc: longText,
|
||
DataItemSource: &robot.DataItemSource{
|
||
HashUsername: fmt.Sprintf("%x", sha256.Sum256([]byte(vars.RobotRuntime.WxID))),
|
||
},
|
||
SourceName: *currentRobot.Nickname,
|
||
SourceHeadURL: *currentRobot.Avatar,
|
||
},
|
||
},
|
||
},
|
||
}
|
||
|
||
recordInfoBytes, err := xml.MarshalIndent(recordInfo, "", " ")
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
newMsg := robot.ChatHistoryMessage{
|
||
AppMsg: robot.ChatHistoryAppMsg{
|
||
AppID: "",
|
||
SDKVer: "0",
|
||
Title: "群聊的聊天记录",
|
||
Type: 19,
|
||
URL: "https://support.weixin.qq.com/cgi-bin/mmsupport-bin/readtemplate?t=page/favorite_record__w_unsupport",
|
||
Des: fmt.Sprintf("%s: %s", *currentRobot.Nickname, longText),
|
||
RecordItem: robot.ChatHistoryRecordItem{XML: fmt.Sprintf(`<![CDATA[
|
||
%s
|
||
]]>`, string(recordInfoBytes))},
|
||
},
|
||
}
|
||
message, err := vars.RobotRuntime.SendChatHistoryMessage(toWxID, newMsg)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
m := model.Message{
|
||
MsgId: message.NewMsgId,
|
||
ClientMsgId: message.MsgId,
|
||
Type: model.MsgTypeApp,
|
||
AppMsgType: model.AppMsgTypeChatHistory,
|
||
Content: message.Content,
|
||
DisplayFullContent: "",
|
||
MessageSource: message.MsgSource,
|
||
FromWxID: toWxID,
|
||
ToWxID: vars.RobotRuntime.WxID,
|
||
SenderWxID: vars.RobotRuntime.WxID,
|
||
IsChatRoom: strings.HasSuffix(toWxID, "@chatroom"),
|
||
CreatedAt: message.CreateTime,
|
||
UpdatedAt: time.Now().Unix(),
|
||
}
|
||
err = s.msgRepo.Create(&m)
|
||
if err != nil {
|
||
log.Println("入库消息失败: ", err)
|
||
}
|
||
// 插入一条联系人记录，获取联系人列表接口获取不到未保存到通讯录的群聊
|
||
NewContactService(s.ctx).InsertOrUpdateContactActiveTime(m.FromWxID)
|
||
|
||
return nil
|
||
}
|
||
|
||
func (s *MessageService) SendMusicMessage(toWxID string, songTitle string) error {
|
||
var resp robot.MusicSearchResponse
|
||
_, err := resty.New().R().
|
||
SetHeader("Content-Type", "application/json").
|
||
SetQueryParam("msg", songTitle).
|
||
SetQueryParam("type", "json").
|
||
SetQueryParam("n", "1").
|
||
SetQueryParam("br", "7").
|
||
SetResult(&resp).
|
||
Get(vars.MusicSearchApi)
|
||
if err != nil {
|
||
return fmt.Errorf("获取歌曲信息失败: %w", err)
|
||
}
|
||
result := resp.Data
|
||
if result.Title == nil {
|
||
return fmt.Errorf("没有搜索到歌曲 %s", songTitle)
|
||
}
|
||
|
||
songInfo := robot.SongInfo{}
|
||
songInfo.FromUsername = vars.RobotRuntime.WxID
|
||
songInfo.AppID = "wx8dd6ecd81906fd84"
|
||
songInfo.Title = *result.Title
|
||
songInfo.Singer = result.Singer
|
||
songInfo.Url = result.Link
|
||
songInfo.MusicUrl = result.MusicURL
|
||
if result.Cover != nil {
|
||
songInfo.CoverUrl = *result.Cover
|
||
}
|
||
if result.Lrc != nil {
|
||
songInfo.Lyric = *result.Lrc
|
||
}
|
||
|
||
message, err := vars.RobotRuntime.SendMusicMessage(toWxID, songInfo)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
m := model.Message{
|
||
MsgId: message.NewMsgId,
|
||
ClientMsgId: message.MsgId,
|
||
Type: model.MsgTypeApp,
|
||
AppMsgType: model.AppMsgTypeMusic,
|
||
DisplayFullContent: "机器人分享了一首歌曲",
|
||
MessageSource: message.MsgSource,
|
||
FromWxID: toWxID,
|
||
ToWxID: vars.RobotRuntime.WxID,
|
||
SenderWxID: vars.RobotRuntime.WxID,
|
||
IsChatRoom: strings.HasSuffix(toWxID, "@chatroom"),
|
||
CreatedAt: message.CreateTime,
|
||
UpdatedAt: time.Now().Unix(),
|
||
}
|
||
err = s.msgRepo.Create(&m)
|
||
if err != nil {
|
||
log.Println("入库消息失败: ", err)
|
||
}
|
||
// 插入一条联系人记录，获取联系人列表接口获取不到未保存到通讯录的群聊
|
||
NewContactService(s.ctx).InsertOrUpdateContactActiveTime(m.FromWxID)
|
||
|
||
return nil
|
||
}
|
||
|
||
// 发送文件信息
|
||
func (s *MessageService) SendFileMessage(ctx context.Context, req dto.SendFileMessageRequest, file io.Reader, fileHeader *multipart.FileHeader) error {
|
||
message, err := vars.RobotRuntime.MsgSendFile(robot.SendFileMessageRequest{
|
||
ToWxid: req.ToWxid,
|
||
ClientAppDataId: req.ClientAppDataId,
|
||
Filename: req.Filename,
|
||
FileMD5: req.FileHash,
|
||
TotalLen: req.FileSize,
|
||
StartPos: req.ChunkIndex * vars.UploadFileChunkSize,
|
||
TotalChunks: req.TotalChunks,
|
||
}, file, fileHeader)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
// 文件还没上传完
|
||
if message == nil {
|
||
return nil
|
||
}
|
||
|
||
clientMsgId, _ := strconv.ParseInt(message.ClientMsgId, 10, 64)
|
||
m := model.Message{
|
||
MsgId: message.NewMsgId,
|
||
ClientMsgId: clientMsgId,
|
||
Type: model.MsgTypeApp,
|
||
AppMsgType: model.AppMsgTypeAttach,
|
||
Content: message.Content,
|
||
DisplayFullContent: "机器人发送了一个文件",
|
||
MessageSource: message.MsgSource,
|
||
FromWxID: req.ToWxid,
|
||
ToWxID: vars.RobotRuntime.WxID,
|
||
SenderWxID: vars.RobotRuntime.WxID,
|
||
IsChatRoom: strings.HasSuffix(req.ToWxid, "@chatroom"),
|
||
CreatedAt: message.CreateTime,
|
||
UpdatedAt: time.Now().Unix(),
|
||
}
|
||
err = s.msgRepo.Create(&m)
|
||
if err != nil {
|
||
log.Println("入库消息失败: ", err)
|
||
}
|
||
// 插入一条联系人记录，获取联系人列表接口获取不到未保存到通讯录的群聊
|
||
NewContactService(s.ctx).InsertOrUpdateContactActiveTime(m.FromWxID)
|
||
|
||
return nil
|
||
}
|
||
|
||
func (s *MessageService) SendFileMessageByLocalPath(toWxID string, localFilePath string) error {
|
||
_, _, err := s.ValidateLocalFileForSend(localFilePath, nil, 0, "文件")
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
fileHash, err := s.CalculateFileMD5(localFilePath)
|
||
if err != nil {
|
||
return fmt.Errorf("计算文件哈希失败: %w", err)
|
||
}
|
||
|
||
clientAppDataId := fmt.Sprintf("%v_%v", vars.RobotRuntime.WxID, time.Now().UnixNano())
|
||
filename := filepath.Base(localFilePath)
|
||
|
||
return s.StreamLocalFileChunks(localFilePath, vars.UploadFileChunkSize, func(chunkIndex, totalChunks, totalSize int64, chunkReader io.Reader, fileHeader *multipart.FileHeader) error {
|
||
err := s.SendFileMessage(s.ctx, dto.SendFileMessageRequest{
|
||
ToWxid: toWxID,
|
||
ClientAppDataId: clientAppDataId,
|
||
Filename: filename,
|
||
FileHash: fileHash,
|
||
FileSize: totalSize,
|
||
ChunkIndex: chunkIndex,
|
||
TotalChunks: totalChunks,
|
||
}, chunkReader, fileHeader)
|
||
if err != nil {
|
||
return fmt.Errorf("发送文件分片失败 (chunk %d/%d): %w", chunkIndex+1, totalChunks, err)
|
||
}
|
||
return nil
|
||
})
|
||
}
|
||
|
||
func (s *MessageService) ValidateLocalFileForSend(filePath string, allowedExts map[string]bool, maxSize int64, fileType string) (os.FileInfo, string, error) {
|
||
trimmedPath := strings.TrimSpace(filePath)
|
||
if trimmedPath == "" {
|
||
return nil, "", errors.New("本地文件路径不能为空")
|
||
}
|
||
|
||
fileInfo, err := os.Stat(trimmedPath)
|
||
if err != nil {
|
||
if errors.Is(err, os.ErrNotExist) {
|
||
return nil, "", errors.New("本地文件不存在")
|
||
}
|
||
return nil, "", fmt.Errorf("读取本地%s信息失败: %w", fileType, err)
|
||
}
|
||
if fileInfo.IsDir() {
|
||
return nil, "", errors.New("本地文件路径不能是目录")
|
||
}
|
||
if fileInfo.Size() <= 0 {
|
||
return nil, "", fmt.Errorf("本地%s内容为空", fileType)
|
||
}
|
||
if maxSize > 0 && fileInfo.Size() > maxSize {
|
||
return nil, "", fmt.Errorf("%s大小不能超过%dMB", fileType, maxSize/(1024*1024))
|
||
}
|
||
|
||
fileExt := strings.ToLower(filepath.Ext(trimmedPath))
|
||
if len(allowedExts) == 0 {
|
||
return fileInfo, fileExt, nil
|
||
}
|
||
if allowedExts[fileExt] {
|
||
return fileInfo, fileExt, nil
|
||
}
|
||
|
||
detectedExt, err := s.DetectFileExtByMagic(trimmedPath)
|
||
if err != nil {
|
||
return nil, "", fmt.Errorf("检测本地%s类型失败: %w", fileType, err)
|
||
}
|
||
if allowedExts[detectedExt] {
|
||
return fileInfo, detectedExt, nil
|
||
}
|
||
|
||
return nil, "", fmt.Errorf("不支持的%s格式", fileType)
|
||
}
|
||
|
||
func (s *MessageService) DetectFileExtByMagic(filePath string) (string, error) {
|
||
file, err := os.Open(filePath)
|
||
if err != nil {
|
||
return "", fmt.Errorf("打开本地文件失败: %w", err)
|
||
}
|
||
defer file.Close()
|
||
|
||
header := make([]byte, 512)
|
||
n, err := file.Read(header)
|
||
if err != nil && !errors.Is(err, io.EOF) {
|
||
return "", fmt.Errorf("读取文件头失败: %w", err)
|
||
}
|
||
header = header[:n]
|
||
|
||
switch {
|
||
case len(header) >= 3 && bytes.Equal(header[:3], []byte{0xFF, 0xD8, 0xFF}):
|
||
return ".jpg", nil
|
||
case len(header) >= 8 && bytes.Equal(header[:8], []byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A}):
|
||
return ".png", nil
|
||
case len(header) >= 6 && (bytes.Equal(header[:6], []byte("GIF87a")) || bytes.Equal(header[:6], []byte("GIF89a"))):
|
||
return ".gif", nil
|
||
case len(header) >= 12 && bytes.Equal(header[:4], []byte("RIFF")) && bytes.Equal(header[8:12], []byte("WEBP")):
|
||
return ".webp", nil
|
||
case len(header) >= 9 && (bytes.Equal(header[:6], []byte("#!AMR\n")) || bytes.Equal(header[:9], []byte("#!AMR-WB\n"))):
|
||
return ".amr", nil
|
||
case len(header) >= 12 && bytes.Equal(header[:4], []byte("RIFF")) && bytes.Equal(header[8:12], []byte("WAVE")):
|
||
return ".wav", nil
|
||
case len(header) >= 3 && bytes.Equal(header[:3], []byte("ID3")):
|
||
return ".mp3", nil
|
||
case len(header) >= 2 && header[0] == 0xFF && header[1]&0xE0 == 0xE0:
|
||
return ".mp3", nil
|
||
case len(header) >= 12 && bytes.Equal(header[:4], []byte("RIFF")) && bytes.Equal(header[8:11], []byte("AVI")):
|
||
return ".avi", nil
|
||
case len(header) >= 3 && bytes.Equal(header[:3], []byte("FLV")):
|
||
return ".flv", nil
|
||
case len(header) >= 4 && bytes.Equal(header[:4], []byte{0x1A, 0x45, 0xDF, 0xA3}):
|
||
return ".mkv", nil
|
||
case len(header) >= 12 && bytes.Equal(header[4:8], []byte("ftyp")):
|
||
brand := string(header[8:12])
|
||
if strings.HasPrefix(brand, "qt") {
|
||
return ".mov", nil
|
||
}
|
||
return ".mp4", nil
|
||
default:
|
||
return "", nil
|
||
}
|
||
}
|
||
|
||
func (s *MessageService) CalculateFileMD5(filePath string) (string, error) {
|
||
file, err := os.Open(filePath)
|
||
if err != nil {
|
||
return "", fmt.Errorf("打开本地文件失败: %w", err)
|
||
}
|
||
defer file.Close()
|
||
|
||
hash := md5.New()
|
||
if _, err = io.Copy(hash, file); err != nil {
|
||
return "", fmt.Errorf("读取本地文件失败: %w", err)
|
||
}
|
||
|
||
return hex.EncodeToString(hash.Sum(nil)), nil
|
||
}
|
||
|
||
func (s *MessageService) StreamLocalFileChunks(filePath string, chunkSize int64, handler func(chunkIndex, totalChunks, totalSize int64, chunkReader io.Reader, fileHeader *multipart.FileHeader) error) error {
|
||
if chunkSize <= 0 {
|
||
return errors.New("分片大小必须大于0")
|
||
}
|
||
|
||
file, err := os.Open(filePath)
|
||
if err != nil {
|
||
return fmt.Errorf("打开本地文件失败: %w", err)
|
||
}
|
||
defer file.Close()
|
||
|
||
fileInfo, err := file.Stat()
|
||
if err != nil {
|
||
return fmt.Errorf("读取本地文件信息失败: %w", err)
|
||
}
|
||
if fileInfo.Size() <= 0 {
|
||
return errors.New("本地文件内容为空")
|
||
}
|
||
|
||
totalSize := fileInfo.Size()
|
||
totalChunks := (totalSize + chunkSize - 1) / chunkSize
|
||
filename := filepath.Base(filePath)
|
||
|
||
for chunkIndex := range totalChunks {
|
||
currentChunkSize := chunkSize
|
||
remaining := totalSize - chunkIndex*chunkSize
|
||
if remaining < currentChunkSize {
|
||
currentChunkSize = remaining
|
||
}
|
||
|
||
chunkData := make([]byte, int(currentChunkSize))
|
||
n, err := io.ReadFull(file, chunkData)
|
||
if err != nil && !errors.Is(err, io.EOF) && !errors.Is(err, io.ErrUnexpectedEOF) {
|
||
return fmt.Errorf("读取本地文件分片失败: %w", err)
|
||
}
|
||
if n == 0 {
|
||
return errors.New("读取本地文件分片失败: 数据为空")
|
||
}
|
||
|
||
if err := handler(chunkIndex, totalChunks, totalSize, bytes.NewReader(chunkData[:n]), &multipart.FileHeader{
|
||
Filename: filename,
|
||
Size: int64(n),
|
||
}); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
func (s *MessageService) SendEmoji(toWxID string, md5 string, totalLen int32) error {
|
||
message, err := vars.RobotRuntime.SendEmoji(robot.SendEmojiRequest{
|
||
ToWxid: toWxID,
|
||
Md5: md5,
|
||
TotalLen: totalLen,
|
||
})
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
for _, emojiItem := range message.EmojiItem {
|
||
if emojiItem.Ret != 0 {
|
||
continue
|
||
}
|
||
m := model.Message{
|
||
MsgId: emojiItem.NewMsgId,
|
||
ClientMsgId: emojiItem.MsgId,
|
||
Type: model.MsgTypeEmoticon,
|
||
Content: "",
|
||
DisplayFullContent: "机器人发送了一个表情",
|
||
MessageSource: "",
|
||
FromWxID: toWxID,
|
||
ToWxID: vars.RobotRuntime.WxID,
|
||
SenderWxID: vars.RobotRuntime.WxID,
|
||
IsChatRoom: strings.HasSuffix(toWxID, "@chatroom"),
|
||
CreatedAt: time.Now().Unix(),
|
||
UpdatedAt: time.Now().Unix(),
|
||
}
|
||
err = s.msgRepo.Create(&m)
|
||
if err != nil {
|
||
log.Println("入库消息失败: ", err)
|
||
}
|
||
// 插入一条联系人记录，获取联系人列表接口获取不到未保存到通讯录的群聊
|
||
NewContactService(s.ctx).InsertOrUpdateContactActiveTime(m.FromWxID)
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
func (s *MessageService) ShareLink(toWxID string, shareLinkInfo robot.ShareLinkMessage) error {
|
||
message, xmlStr, err := vars.RobotRuntime.ShareLink(toWxID, shareLinkInfo)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
m := model.Message{
|
||
MsgId: message.NewMsgId,
|
||
ClientMsgId: message.MsgId,
|
||
Type: model.MsgTypeApp,
|
||
AppMsgType: model.AppMsgTypeUrl,
|
||
Content: xmlStr,
|
||
DisplayFullContent: "机器人分享了一个链接",
|
||
MessageSource: message.MsgSource,
|
||
FromWxID: toWxID,
|
||
ToWxID: vars.RobotRuntime.WxID,
|
||
SenderWxID: vars.RobotRuntime.WxID,
|
||
IsChatRoom: strings.HasSuffix(toWxID, "@chatroom"),
|
||
CreatedAt: message.CreateTime,
|
||
UpdatedAt: time.Now().Unix(),
|
||
}
|
||
err = s.msgRepo.Create(&m)
|
||
if err != nil {
|
||
log.Println("入库消息失败: ", err)
|
||
}
|
||
// 插入一条联系人记录，获取联系人列表接口获取不到未保存到通讯录的群聊
|
||
NewContactService(s.ctx).InsertOrUpdateContactActiveTime(m.FromWxID)
|
||
return nil
|
||
}
|
||
|
||
func (s *MessageService) SendCDNFile(toWxID string, content string) error {
|
||
message, err := vars.RobotRuntime.SendCDNFile(robot.SendCDNAttachmentRequest{
|
||
ToWxid: toWxID,
|
||
Content: content,
|
||
})
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
m := model.Message{
|
||
MsgId: message.NewMsgId,
|
||
ClientMsgId: message.MsgId,
|
||
Type: model.MsgTypeApp,
|
||
AppMsgType: model.AppMsgTypeAttach,
|
||
Content: "",
|
||
DisplayFullContent: "机器人转发了一个文件",
|
||
MessageSource: message.MsgSource,
|
||
FromWxID: toWxID,
|
||
ToWxID: vars.RobotRuntime.WxID,
|
||
SenderWxID: vars.RobotRuntime.WxID,
|
||
IsChatRoom: strings.HasSuffix(toWxID, "@chatroom"),
|
||
CreatedAt: message.CreateTime,
|
||
UpdatedAt: time.Now().Unix(),
|
||
}
|
||
err = s.msgRepo.Create(&m)
|
||
if err != nil {
|
||
log.Println("入库消息失败: ", err)
|
||
}
|
||
// 插入一条联系人记录，获取联系人列表接口获取不到未保存到通讯录的群聊
|
||
NewContactService(s.ctx).InsertOrUpdateContactActiveTime(m.FromWxID)
|
||
|
||
return nil
|
||
}
|
||
|
||
func (s *MessageService) SendCDNImg(toWxID string, content string) error {
|
||
message, err := vars.RobotRuntime.SendCDNImg(robot.SendCDNAttachmentRequest{
|
||
ToWxid: toWxID,
|
||
Content: content,
|
||
})
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
m := model.Message{
|
||
MsgId: message.Newmsgid,
|
||
ClientMsgId: message.Msgid,
|
||
Type: model.MsgTypeImage,
|
||
Content: "",
|
||
DisplayFullContent: "机器人发送了一张图片",
|
||
MessageSource: message.MsgSource,
|
||
FromWxID: toWxID,
|
||
ToWxID: vars.RobotRuntime.WxID,
|
||
SenderWxID: vars.RobotRuntime.WxID,
|
||
IsChatRoom: strings.HasSuffix(toWxID, "@chatroom"),
|
||
CreatedAt: message.CreateTime,
|
||
UpdatedAt: time.Now().Unix(),
|
||
}
|
||
err = s.msgRepo.Create(&m)
|
||
if err != nil {
|
||
log.Println("入库消息失败: ", err)
|
||
}
|
||
// 插入一条联系人记录，获取联系人列表接口获取不到未保存到通讯录的群聊
|
||
NewContactService(s.ctx).InsertOrUpdateContactActiveTime(m.FromWxID)
|
||
|
||
return nil
|
||
}
|
||
|
||
func (s *MessageService) SendCDNVideo(toWxID string, content string) error {
|
||
message, err := vars.RobotRuntime.SendCDNVideo(robot.SendCDNAttachmentRequest{
|
||
ToWxid: toWxID,
|
||
Content: content,
|
||
})
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
m := model.Message{
|
||
MsgId: message.NewMsgId,
|
||
ClientMsgId: message.MsgId,
|
||
Type: model.MsgTypeVideo,
|
||
Content: "",
|
||
DisplayFullContent: "机器人发送了一个视频",
|
||
MessageSource: message.MsgSource,
|
||
FromWxID: toWxID,
|
||
ToWxID: vars.RobotRuntime.WxID,
|
||
SenderWxID: vars.RobotRuntime.WxID,
|
||
IsChatRoom: strings.HasSuffix(toWxID, "@chatroom"),
|
||
CreatedAt: time.Now().Unix(),
|
||
UpdatedAt: time.Now().Unix(),
|
||
}
|
||
err = s.msgRepo.Create(&m)
|
||
if err != nil {
|
||
log.Println("入库消息失败: ", err)
|
||
}
|
||
// 插入一条联系人记录，获取联系人列表接口获取不到未保存到通讯录的群聊
|
||
NewContactService(s.ctx).InsertOrUpdateContactActiveTime(m.FromWxID)
|
||
|
||
return nil
|
||
}
|
||
|
||
func (s *MessageService) aiTextMessage(isAssistant bool, content string) openai.ChatCompletionMessageParamUnion {
|
||
if isAssistant {
|
||
return openai.AssistantMessage(content)
|
||
}
|
||
return openai.UserMessage(content)
|
||
}
|
||
|
||
func (s *MessageService) aiTextPartMessage(isAssistant bool, texts ...string) openai.ChatCompletionMessageParamUnion {
|
||
if isAssistant {
|
||
parts := make([]openai.ChatCompletionAssistantMessageParamContentArrayOfContentPartUnion, 0, len(texts))
|
||
for _, text := range texts {
|
||
parts = append(parts, openai.ChatCompletionAssistantMessageParamContentArrayOfContentPartUnion{
|
||
OfText: &openai.ChatCompletionContentPartTextParam{Text: text},
|
||
})
|
||
}
|
||
return openai.AssistantMessage(parts)
|
||
}
|
||
|
||
parts := make([]openai.ChatCompletionContentPartUnionParam, 0, len(texts))
|
||
for _, text := range texts {
|
||
parts = append(parts, openai.TextContentPart(text))
|
||
}
|
||
return openai.UserMessage(parts)
|
||
}
|
||
|
||
func (s *MessageService) buildQuoteAIMessage(msg *model.Message, isAssistant bool) (openai.ChatCompletionMessageParamUnion, bool) {
|
||
var xmlMessage robot.XmlMessage
|
||
if err := vars.RobotRuntime.XmlDecoder(msg.Content, &xmlMessage); err != nil {
|
||
return openai.ChatCompletionMessageParamUnion{}, false
|
||
}
|
||
|
||
switch xmlMessage.AppMsg.ReferMsg.Type {
|
||
case int(model.MsgTypeText):
|
||
return s.aiTextPartMessage(isAssistant, xmlMessage.AppMsg.ReferMsg.Content, xmlMessage.AppMsg.Title), true
|
||
case int(model.MsgTypeImage):
|
||
referMsg, ok := s.getReferMessageByMsgID(xmlMessage.AppMsg.ReferMsg.SvrID)
|
||
if !ok {
|
||
return openai.ChatCompletionMessageParamUnion{}, false
|
||
}
|
||
return s.aiTextPartMessage(isAssistant, xmlMessage.AppMsg.Title+"\n\n 图片地址: "+referMsg.AttachmentUrl), true
|
||
case int(model.MsgTypeVideo):
|
||
referMsg, ok := s.getReferMessageByMsgID(xmlMessage.AppMsg.ReferMsg.SvrID)
|
||
if !ok {
|
||
return openai.ChatCompletionMessageParamUnion{}, false
|
||
}
|
||
return s.aiTextMessage(isAssistant, "视频地址: "+referMsg.AttachmentUrl+"\n\n"+xmlMessage.AppMsg.Title), true
|
||
case int(model.AppMsgTypequote):
|
||
referMsg, ok := s.getReferMessageByID(xmlMessage.AppMsg.ReferMsg.SvrID)
|
||
if !ok {
|
||
return openai.ChatCompletionMessageParamUnion{}, false
|
||
}
|
||
|
||
var subXmlMessage robot.XmlMessage
|
||
if err := vars.RobotRuntime.XmlDecoder(referMsg.Content, &subXmlMessage); err != nil {
|
||
return openai.ChatCompletionMessageParamUnion{}, false
|
||
}
|
||
return s.aiTextPartMessage(isAssistant, subXmlMessage.AppMsg.Title, xmlMessage.AppMsg.Title), true
|
||
case int(model.MsgTypeEmoticon):
|
||
if strings.TrimSpace(xmlMessage.AppMsg.Title) == "" {
|
||
return openai.ChatCompletionMessageParamUnion{}, false
|
||
}
|
||
return s.aiTextMessage(isAssistant, xmlMessage.AppMsg.Title), true
|
||
case int(model.MsgTypeApp):
|
||
referMsg, ok := s.getReferMessageByMsgID(xmlMessage.AppMsg.ReferMsg.SvrID)
|
||
if !ok {
|
||
return openai.ChatCompletionMessageParamUnion{}, false
|
||
}
|
||
if referMsg.AppMsgType == model.AppMsgTypeEmoji {
|
||
if strings.TrimSpace(xmlMessage.AppMsg.Title) == "" {
|
||
return openai.ChatCompletionMessageParamUnion{}, false
|
||
}
|
||
return s.aiTextMessage(isAssistant, xmlMessage.AppMsg.Title), true
|
||
}
|
||
}
|
||
|
||
return openai.ChatCompletionMessageParamUnion{}, false
|
||
}
|
||
|
||
func (s *MessageService) getReferMessageByMsgID(referMsgIDStr string) (*model.Message, bool) {
|
||
referMsgID, err := strconv.ParseInt(referMsgIDStr, 10, 64)
|
||
if err != nil {
|
||
return nil, false
|
||
}
|
||
referMsg, err := s.msgRepo.GetByMsgID(referMsgID)
|
||
if err != nil || referMsg == nil {
|
||
return nil, false
|
||
}
|
||
return referMsg, true
|
||
}
|
||
|
||
func (s *MessageService) getReferMessageByID(referMsgIDStr string) (*model.Message, bool) {
|
||
referMsgID, err := strconv.ParseInt(referMsgIDStr, 10, 64)
|
||
if err != nil {
|
||
return nil, false
|
||
}
|
||
referMsg, err := s.msgRepo.GetByID(referMsgID)
|
||
if err != nil || referMsg == nil {
|
||
return nil, false
|
||
}
|
||
return referMsg, true
|
||
}
|
||
|
||
func (s *MessageService) buildAIMessageContextMessage(msg *model.Message) (openai.ChatCompletionMessageParamUnion, bool) {
|
||
isAssistant := msg.SenderWxID == vars.RobotRuntime.WxID
|
||
|
||
switch {
|
||
case msg.Type == model.MsgTypeText:
|
||
if strings.TrimSpace(msg.Content) == "" {
|
||
return openai.ChatCompletionMessageParamUnion{}, false
|
||
}
|
||
return s.aiTextMessage(isAssistant, msg.Content), true
|
||
case msg.Type == model.MsgTypeImage && msg.AttachmentUrl != "":
|
||
return s.aiTextPartMessage(isAssistant, "图片地址: "+msg.AttachmentUrl), true
|
||
case msg.Type == model.MsgTypeVideo && msg.AttachmentUrl != "":
|
||
return s.aiTextMessage(isAssistant, "视频地址: "+msg.AttachmentUrl), true
|
||
case msg.Type == model.MsgTypeApp && msg.AppMsgType == model.AppMsgTypequote:
|
||
return s.buildQuoteAIMessage(msg, isAssistant)
|
||
default:
|
||
return openai.ChatCompletionMessageParamUnion{}, false
|
||
}
|
||
}
|
||
|
||
func (s *MessageService) ProcessAIMessageContext(messages []*model.Message) []openai.ChatCompletionMessageParamUnion {
|
||
aiMessages := make([]openai.ChatCompletionMessageParamUnion, 0, len(messages))
|
||
messageCtxMap := make(map[int64]bool)
|
||
|
||
for _, msg := range messages {
|
||
if messageCtxMap[msg.MsgId] {
|
||
continue
|
||
}
|
||
|
||
aiMessage, ok := s.buildAIMessageContextMessage(msg)
|
||
if !ok {
|
||
continue
|
||
}
|
||
|
||
messageCtxMap[msg.MsgId] = true
|
||
aiMessages = append(aiMessages, aiMessage)
|
||
}
|
||
|
||
return aiMessages
|
||
}
|
||
|
||
func (s *MessageService) SetMessageIsInContext(message *model.Message) error {
|
||
return s.msgRepo.SetMessageIsInContext(message)
|
||
}
|
||
|
||
func (s *MessageService) GetFriendAIMessageContext(message *model.Message) ([]openai.ChatCompletionMessageParamUnion, error) {
|
||
messages, err := s.msgRepo.GetFriendAIMessageContext(message)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if !slices.ContainsFunc(messages, func(m *model.Message) bool {
|
||
return m.ID == message.ID
|
||
}) {
|
||
messages = append(messages, message)
|
||
}
|
||
return s.ProcessAIMessageContext(messages), nil
|
||
}
|
||
|
||
func (s *MessageService) ResetFriendAIMessageContext(message *model.Message) error {
|
||
return s.msgRepo.ResetFriendAIMessageContext(message)
|
||
}
|
||
|
||
func (s *MessageService) GetChatRoomAIMessageContext(message *model.Message) ([]openai.ChatCompletionMessageParamUnion, error) {
|
||
messages, err := s.msgRepo.GetChatRoomAIMessageContext(message)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if !slices.ContainsFunc(messages, func(m *model.Message) bool {
|
||
return m.ID == message.ID
|
||
}) {
|
||
messages = append(messages, message)
|
||
}
|
||
return s.ProcessAIMessageContext(messages), nil
|
||
}
|
||
|
||
func (s *MessageService) UpdateMessage(message *model.Message) error {
|
||
return s.msgRepo.Update(message)
|
||
}
|
||
|
||
func (s *MessageService) ResetChatRoomAIMessageContext(message *model.Message) error {
|
||
return s.msgRepo.ResetChatRoomAIMessageContext(message)
|
||
}
|
||
|
||
func (s *MessageService) GetAIMessageContext(message *model.Message) ([]openai.ChatCompletionMessageParamUnion, error) {
|
||
if message.IsChatRoom {
|
||
return s.GetChatRoomAIMessageContext(message)
|
||
}
|
||
return s.GetFriendAIMessageContext(message)
|
||
}
|
||
|
||
func (s *MessageService) GetYesterdayChatRommRank(chatRoomID string) ([]*dto.ChatRoomRank, error) {
|
||
return s.msgRepo.GetYesterdayChatRommRank(vars.RobotRuntime.WxID, chatRoomID)
|
||
}
|
||
|
||
func (s *MessageService) GetLastWeekChatRommRank(chatRoomID string) ([]*dto.ChatRoomRank, error) {
|
||
return s.msgRepo.GetLastWeekChatRommRank(vars.RobotRuntime.WxID, chatRoomID)
|
||
}
|
||
|
||
func (s *MessageService) GetLastMonthChatRommRank(chatRoomID string) ([]*dto.ChatRoomRank, error) {
|
||
return s.msgRepo.GetLastMonthChatRommRank(vars.RobotRuntime.WxID, chatRoomID)
|
||
}
|
||
|
||
func (s *MessageService) ChatRoomAIDisabled(chatRoomID string) error {
|
||
chatRoomSettingsSvc := NewChatRoomSettingsService(s.ctx)
|
||
chatRoomSettings, err := chatRoomSettingsSvc.GetChatRoomSettings(chatRoomID)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if chatRoomSettings == nil || chatRoomSettings.ChatAIEnabled == nil || !*chatRoomSettings.ChatAIEnabled {
|
||
return nil
|
||
}
|
||
disabled := false
|
||
chatRoomSettings.ChatAIEnabled = &disabled
|
||
err = chatRoomSettingsSvc.SaveChatRoomSettings(chatRoomSettings)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// detectAndNotifyNicknameChange 检测联系人昵称变更并通知所在群
|
||
func (s *MessageService) detectAndNotifyNicknameChange(contact *robot.Contact) {
|
||
// 获取新的昵称
|
||
if contact.NickName.String == nil || *contact.NickName.String == "" {
|
||
return
|
||
}
|
||
newNickname := *contact.NickName.String
|
||
wechatID := *contact.UserName.String
|
||
|
||
// 获取该联系人所在的所有群（未离开的群成员记录）
|
||
members, err := s.crmRepo.GetChatRoomMemberByWeChatID(wechatID)
|
||
if err != nil {
|
||
log.Printf("[昵称变更] 查询群成员记录失败: %v", err)
|
||
return
|
||
}
|
||
if len(members) == 0 {
|
||
return
|
||
}
|
||
|
||
// 遍历每个群，检查昵称是否有变化
|
||
for _, member := range members {
|
||
if member.IsLeaved != nil && *member.IsLeaved {
|
||
continue
|
||
}
|
||
oldNickname := member.Nickname
|
||
remark := member.Remark
|
||
if oldNickname == "" && remark != "" {
|
||
oldNickname = remark
|
||
}
|
||
if oldNickname == newNickname || oldNickname == "" {
|
||
continue
|
||
}
|
||
// 昵称确实变了，更新数据库中的昵称
|
||
err = s.crmRepo.UpdateMemberInfo(member.ChatRoomID, wechatID, map[string]any{
|
||
"nickname": newNickname,
|
||
})
|
||
if err != nil {
|
||
log.Printf("[昵称变更] 更新群成员昵称失败: %v", err)
|
||
}
|
||
|
||
// 发送通知到群
|
||
notifyMsg := fmt.Sprintf("📋 群成员变动通知：\n📝 昵称修改：%s（%s → %s）", newNickname, oldNickname, newNickname)
|
||
err = s.SendTextMessage(member.ChatRoomID, notifyMsg)
|
||
if err != nil {
|
||
log.Printf("[昵称变更] 发送通知失败: %v", err)
|
||
} else {
|
||
log.Printf("[昵称变更] %s 在群 %s 中昵称已变更: %s -> %s", wechatID, member.ChatRoomID, oldNickname, newNickname)
|
||
}
|
||
}
|
||
}
|
||
|
||
func (s *MessageService) GetChatRoomMember(chatRoomID string, wechatID string) (*model.ChatRoomMember, error) {
|
||
return s.crmRepo.GetChatRoomMember(chatRoomID, wechatID)
|
||
}
|
||
|
||
// compressVideoWithFFmpeg 使用 ffmpeg 压缩视频到目标大小以内
|
||
func compressVideoWithFFmpeg(inputPath, outputPath string, targetSize int64) error {
|
||
// 先获取视频时长
|
||
probeCmd := exec.Command("ffprobe", "-v", "error", "-show_entries", "format=duration", "-of", "default=noprint_wrappers=1:nokey=1", inputPath)
|
||
durationOutput, err := probeCmd.Output()
|
||
if err != nil {
|
||
return fmt.Errorf("获取视频时长失败: %w", err)
|
||
}
|
||
|
||
durationStr := strings.TrimSpace(string(durationOutput))
|
||
duration, err := strconv.ParseFloat(durationStr, 64)
|
||
if err != nil || duration <= 0 {
|
||
duration = 60 // 默认假设60秒
|
||
}
|
||
|
||
// 计算目标码率 (bits/s)，留 10% 余量给音频
|
||
targetBitrate := int64(float64(targetSize) * 8 * 0.9 / duration)
|
||
if targetBitrate < 100000 {
|
||
targetBitrate = 100000 // 最低 100kbps
|
||
}
|
||
bitrateStr := fmt.Sprintf("%dk", targetBitrate/1000)
|
||
|
||
// 使用 ffmpeg 压缩：降低码率 + 缩小分辨率
|
||
ffmpegCmd := exec.Command("ffmpeg", "-y", "-i", inputPath,
|
||
"-c:v", "libx264", "-preset", "fast", "-b:v", bitrateStr,
|
||
"-vf", "scale='min(720,iw)':-2",
|
||
"-c:a", "aac", "-b:a", "64k",
|
||
"-movflags", "+faststart",
|
||
"-max_muxing_queue_size", "1024",
|
||
outputPath,
|
||
)
|
||
output, err := ffmpegCmd.CombinedOutput()
|
||
if err != nil {
|
||
return fmt.Errorf("ffmpeg 压缩失败: %w, output: %s", err, string(output))
|
||
}
|
||
|
||
// 验证输出文件
|
||
outInfo, err := os.Stat(outputPath)
|
||
if err != nil {
|
||
return fmt.Errorf("压缩后文件不存在: %w", err)
|
||
}
|
||
if outInfo.Size() == 0 {
|
||
return fmt.Errorf("压缩后文件为空")
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
|
||
|
||
|