454 lines
16 KiB
Go
454 lines
16 KiB
Go
package chat
|
||
|
||
import (
|
||
stdctx "context"
|
||
"fmt"
|
||
"mime/multipart"
|
||
"net/http"
|
||
"time"
|
||
"unicode/utf8"
|
||
|
||
"github.com/flamego/cache"
|
||
"github.com/pkg/errors"
|
||
"github.com/sirupsen/logrus"
|
||
|
||
"github.com/tamakyi/TamaBox/internal/conf"
|
||
"github.com/tamakyi/TamaBox/internal/context"
|
||
"github.com/tamakyi/TamaBox/internal/db"
|
||
"github.com/tamakyi/TamaBox/internal/i18n"
|
||
"github.com/tamakyi/TamaBox/internal/imagecheck"
|
||
"github.com/tamakyi/TamaBox/internal/mail"
|
||
"github.com/tamakyi/TamaBox/internal/security/moderation"
|
||
"github.com/tamakyi/TamaBox/internal/shared"
|
||
"github.com/tamakyi/TamaBox/internal/storage"
|
||
)
|
||
|
||
const (
|
||
MaxMessageImageSize = 5 * 1024 * 1024 // 5MB
|
||
)
|
||
|
||
// ConversationPage 私聊会话页（GET 入口）。审核拦截后的就地重渲染由 renderConversation 统一处理。
|
||
func ConversationPage(ctx context.Context) {
|
||
renderConversation(ctx, ctx.Param("domain"), ctx.Param("token"), "", nil)
|
||
}
|
||
|
||
// renderConversation 渲染私聊会话页，并可选地回填审核拦截提示与已输入内容。
|
||
//
|
||
// prefillContent 非空时回填到消息输入框：审核拦截（以及其它服务端校验失败）后保留用户已输入内容，
|
||
// 避免 Redirect 重渲染导致输入丢失。modErr 非空时作为错误提示展示（与提问链路 ctx.SetError
|
||
// 一致的就地重渲染，而非 flash + Redirect），提示通过 templates/base/alert 渲染。
|
||
// 函数内部在所有出口都会发起 Redirect 或 Success 渲染，调用方在调用后应直接 return。
|
||
func renderConversation(ctx context.Context, domain, token, prefillContent string, modErr error) {
|
||
pageUser, err := db.Users.GetByDomain(ctx.Request().Context(), domain)
|
||
if err != nil {
|
||
ctx.Redirect("/")
|
||
return
|
||
}
|
||
|
||
conv, err := db.Conversations.GetByToken(ctx.Request().Context(), token)
|
||
if err != nil {
|
||
ctx.Redirect("/")
|
||
return
|
||
}
|
||
|
||
if conv.IsDeletedByOwner {
|
||
ctx.SetErrorFlash(i18n.T(ctx.Lang(), "chat.errDeletedByOwner"))
|
||
ctx.Redirect("/_/" + domain)
|
||
return
|
||
}
|
||
|
||
// 纵深防御：私聊对话只能由其所属提问箱（domain 对应的真实属主）的页面访问。
|
||
// 否则攻击者可用其它 domain 构造访问，使下方拉黑判定用到错误的主体，绕过真实属主的拉黑。
|
||
if conv.OwnerID != pageUser.ID {
|
||
ctx.Redirect("/")
|
||
return
|
||
}
|
||
|
||
isOwner := ctx.IsLogged && ctx.User.ID == conv.OwnerID
|
||
isAsker := ctx.IsLogged && ctx.User.ID == conv.AskerID
|
||
if !isOwner && !isAsker {
|
||
ctx.Redirect("/")
|
||
return
|
||
}
|
||
|
||
// 提问者检查是否被对方（对话真实属主）拉黑
|
||
if isAsker {
|
||
blocked, err := db.Users.IsUserBlocked(ctx.Request().Context(), conv.OwnerID, conv.AskerID)
|
||
if err != nil {
|
||
logrus.WithError(err).Error("Failed to check block status for asker")
|
||
}
|
||
if blocked {
|
||
ctx.SetErrorFlash(i18n.T(ctx.Lang(), "chat.errBlockedView"))
|
||
ctx.Redirect("/_/" + domain)
|
||
return
|
||
}
|
||
}
|
||
|
||
// 检查是否已拉黑对方（仅对被提问者有效，以对话真实属主为准）
|
||
var isBlocked bool
|
||
if isOwner {
|
||
blocked, err := db.Users.IsUserBlocked(ctx.Request().Context(), conv.OwnerID, conv.AskerID)
|
||
if err != nil {
|
||
logrus.WithError(err).Error("Failed to check block status")
|
||
}
|
||
isBlocked = blocked
|
||
}
|
||
|
||
messages, err := db.Messages.GetByConversationID(ctx.Request().Context(), conv.ID, nil)
|
||
if err != nil {
|
||
logrus.WithContext(ctx.Request().Context()).WithError(err).Error("Failed to get messages")
|
||
ctx.SetInternalError()
|
||
return
|
||
}
|
||
|
||
// 获取所有消息的图片（被拉黑时不显示对方图片）
|
||
var messageImageMap map[uint][]*db.MessageImage
|
||
if !(isOwner && isBlocked) {
|
||
msgIDs := make([]uint, 0, len(messages))
|
||
for _, msg := range messages {
|
||
msgIDs = append(msgIDs, msg.ID)
|
||
}
|
||
messageImageMap, err = db.MessageImages.GetByMessageIDs(ctx.Request().Context(), msgIDs)
|
||
if err != nil {
|
||
logrus.WithError(err).Error("Failed to get message images")
|
||
messageImageMap = make(map[uint][]*db.MessageImage)
|
||
}
|
||
} else {
|
||
messageImageMap = make(map[uint][]*db.MessageImage)
|
||
}
|
||
|
||
ctx.Data["PageUser"] = pageUser
|
||
ctx.Data["Conversation"] = conv
|
||
ctx.Data["Messages"] = messages
|
||
ctx.Data["MessageImages"] = messageImageMap
|
||
ctx.Data["IsOwner"] = isOwner
|
||
ctx.Data["IsAsker"] = isAsker
|
||
ctx.Data["IsBlocked"] = isBlocked
|
||
// 单条消息字数上限，供发送 / 回复 textarea 的 maxlength 与后端校验同源
|
||
// （conf.Limits.ChatMessageLen，[limits] 配置段）
|
||
ctx.Data["ChatMessageLimit"] = conf.Limits.ChatMessageLen
|
||
canSend := !conv.IsClosed && !conv.IsDeletedByOwner &&
|
||
((isOwner && conv.MessageCount < conv.MaxMessages) || (isAsker && conv.MessageCount < conv.MaxMessages && !isBlocked))
|
||
ctx.Data["CanSend"] = canSend
|
||
|
||
// 回填审核拦截时已输入内容（仅当对话仍可发送，避免关闭/删除场景下回填到隐藏输入框）。
|
||
if canSend {
|
||
ctx.Data["Content"] = prefillContent
|
||
}
|
||
// 审核拦截等错误提示：就地通过 base/alert 渲染，不再走 flash + Redirect（否则内容丢失且无提示）。
|
||
if modErr != nil {
|
||
ctx.Data["HasError"] = true
|
||
ctx.Data["Error"] = modErr.Error()
|
||
}
|
||
ctx.Success("chat/conversation")
|
||
}
|
||
|
||
func SendMessage(ctx context.Context, cache cache.Cache) {
|
||
domain := ctx.Param("domain")
|
||
token := ctx.Param("token")
|
||
content := ctx.Request().FormValue("content")
|
||
|
||
// 处理图片上传
|
||
var imageFile multipart.File
|
||
var imageHeader *multipart.FileHeader
|
||
imageFile, imageHeader, err := ctx.Request().FormFile("image")
|
||
if err != nil && err != http.ErrMissingFile {
|
||
logrus.WithError(err).Error("Failed to read uploaded image")
|
||
}
|
||
if imageFile != nil {
|
||
defer imageFile.Close()
|
||
}
|
||
|
||
// 内容与图片至少有一个
|
||
if content == "" && imageFile == nil {
|
||
ctx.SetErrorFlash(i18n.T(ctx.Lang(), "chat.errEmpty"))
|
||
ctx.Redirect(fmt.Sprintf("/_/%s/chat/%s", domain, token))
|
||
return
|
||
}
|
||
|
||
// 内容长度限制（上限取自 conf.Limits.ChatMessageLen，[limits] 配置段）
|
||
if utf8.RuneCountInString(content) > conf.Limits.ChatMessageLen {
|
||
ctx.SetErrorFlash(i18n.T(ctx.Lang(), "chat.errTooLong", conf.Limits.ChatMessageLen))
|
||
ctx.Redirect(fmt.Sprintf("/_/%s/chat/%s", domain, token))
|
||
return
|
||
}
|
||
|
||
pageUser, err := db.Users.GetByDomain(ctx.Request().Context(), domain)
|
||
if err != nil {
|
||
ctx.Redirect("/")
|
||
return
|
||
}
|
||
|
||
conv, err := db.Conversations.GetByToken(ctx.Request().Context(), token)
|
||
if err != nil {
|
||
ctx.Redirect("/")
|
||
return
|
||
}
|
||
|
||
if conv.IsDeletedByOwner {
|
||
ctx.SetErrorFlash(i18n.T(ctx.Lang(), "chat.errConvDeletedSend"))
|
||
ctx.Redirect(fmt.Sprintf("/_/%s/chat/%s", domain, token))
|
||
return
|
||
}
|
||
|
||
// 纵深防御（与 ConversationPage 同一口径）：会话必须属于 URL 里这个箱子的真实属主。
|
||
//
|
||
// 少了这一步，domain 就只是一张"通行证"：拿 A 箱的 domain 拼 B 箱的会话 token，
|
||
// 下面所有以 pageUser 为主体的判定都会落到 A 箱主身上 ——
|
||
// 被 B 箱主拉黑的提问者换个 domain 就能继续发消息，A 箱主的屏蔽词与日限额被套用到 B 的会话上。
|
||
// GET 页面早就有这条校验，POST 漏了。
|
||
if conv.OwnerID != pageUser.ID {
|
||
ctx.Redirect("/")
|
||
return
|
||
}
|
||
|
||
isOwner := ctx.IsLogged && ctx.User.ID == conv.OwnerID
|
||
isAsker := ctx.IsLogged && ctx.User.ID == conv.AskerID
|
||
if !isOwner && !isAsker {
|
||
ctx.Redirect("/")
|
||
return
|
||
}
|
||
|
||
// 提问者发送时检查拉黑与每日限制
|
||
if isAsker {
|
||
blocked, err := db.Users.IsUserBlocked(ctx.Request().Context(), pageUser.ID, ctx.User.ID)
|
||
if err != nil {
|
||
logrus.WithError(err).Error("Failed to check block")
|
||
}
|
||
if blocked {
|
||
ctx.SetErrorFlash(i18n.T(ctx.Lang(), "chat.errBlockedSend"))
|
||
ctx.Redirect(fmt.Sprintf("/_/%s/chat/%s", domain, token))
|
||
return
|
||
}
|
||
|
||
// 箱主全局屏蔽词（提问/私聊/投票共用一份词表）：对方发给我的消息命中即拦截。
|
||
// 仅拦对方 → 箱主方向：我回复对方的内容不受自己设置的屏蔽词限制。
|
||
if content != "" {
|
||
if _, hit := shared.BlockWordHit(pageUser.BlockWords, content); hit {
|
||
ctx.SetErrorFlash(i18n.T(ctx.Lang(), "chat.errBlockWords"))
|
||
ctx.Redirect(fmt.Sprintf("/_/%s/chat/%s", domain, token))
|
||
return
|
||
}
|
||
}
|
||
|
||
if pageUser.DailyMessageLimit > 0 {
|
||
todayCount, err := db.Users.CountTodayMessagesFromUser(ctx.Request().Context(), pageUser.ID, ctx.User.ID)
|
||
if err != nil {
|
||
logrus.WithError(err).Error("Failed to count today messages")
|
||
ctx.SetInternalErrorFlash()
|
||
ctx.Redirect(fmt.Sprintf("/_/%s/chat/%s", domain, token))
|
||
return
|
||
}
|
||
if todayCount >= int64(pageUser.DailyMessageLimit) {
|
||
ctx.SetErrorFlash(i18n.T(ctx.Lang(), "chat.errDailyLimit", pageUser.DailyMessageLimit))
|
||
ctx.Redirect(fmt.Sprintf("/_/%s/chat/%s", domain, token))
|
||
return
|
||
}
|
||
}
|
||
}
|
||
|
||
if conv.IsClosed || conv.MessageCount >= conv.MaxMessages {
|
||
ctx.SetErrorFlash(i18n.T(ctx.Lang(), "chat.errLimitReached"))
|
||
ctx.Redirect(fmt.Sprintf("/_/%s/chat/%s", domain, token))
|
||
return
|
||
}
|
||
|
||
// 私聊功能开关：发送前重新校验箱主私聊功能是否仍开启（创建会话时已查过，
|
||
// 但箱主可能在会话中途关闭私聊，此时应阻止继续发消息）。
|
||
//
|
||
// 用 FeatureStateOfStrict（写路径约定）：FeatureStateOf 在配置读失败时回退
|
||
// 默认值，对提问/投票是「开启」——等于一次读配置失败就绕过箱主的关闭。
|
||
// 私聊恰好因默认关闭而侥幸安全，但这里仍统一用 Strict，避免依赖那个巧合。
|
||
chatState, err := db.FeatureStateOfStrict(ctx.Request().Context(), conv.OwnerID, db.FeatureChat)
|
||
if err != nil {
|
||
// 读配置失败即拒（fail-closed）：不能让一次配置抖动绕过箱主的关闭。
|
||
ctx.SetErrorFlash(i18n.T(ctx.Lang(), "chat.errChatClosed"))
|
||
ctx.Redirect(fmt.Sprintf("/_/%s/chat/%s", domain, token))
|
||
return
|
||
}
|
||
if !chatState.Open {
|
||
ctx.SetErrorFlash(i18n.T(ctx.Lang(), "chat.errChatClosed"))
|
||
ctx.Redirect(fmt.Sprintf("/_/%s/chat/%s", domain, token))
|
||
return
|
||
}
|
||
|
||
// 图片大小限制
|
||
if imageHeader != nil && imageHeader.Size > MaxMessageImageSize {
|
||
ctx.SetErrorFlash(i18n.T(ctx.Lang(), "chat.errImageTooLarge", MaxMessageImageSize/(1024*1024)))
|
||
ctx.Redirect(fmt.Sprintf("/_/%s/chat/%s", domain, token))
|
||
return
|
||
}
|
||
|
||
// 上传图片（如有）
|
||
var imageURL, imageKey string
|
||
imageAttached := false
|
||
if imageFile != nil {
|
||
uploadedURL, err := storage.UploadPictureToS3(imageFile, imageHeader)
|
||
if err != nil {
|
||
if errors.Is(err, imagecheck.ErrImageTooLarge) {
|
||
ctx.SetErrorFlash(i18n.T(ctx.Lang(), "image.errTooLarge", imagecheck.MaxImageSide, imagecheck.MaxImageSide))
|
||
} else {
|
||
logrus.WithError(err).Error("Failed to upload image")
|
||
ctx.SetErrorFlash(i18n.T(ctx.Lang(), "chat.errUploadFailed"))
|
||
}
|
||
ctx.Redirect(fmt.Sprintf("/_/%s/chat/%s", domain, token))
|
||
return
|
||
}
|
||
imageURL = uploadedURL
|
||
defer func() {
|
||
if imageAttached || imageKey != "" {
|
||
return
|
||
}
|
||
if err := db.R2DeleteTasks.EnqueueValues(stdctx.Background(), conf.Upload.ImageBucket, []string{imageURL}); err != nil {
|
||
logrus.WithError(err).Error("Failed to enqueue unresolved uploaded message image compensation")
|
||
}
|
||
}()
|
||
parsedKey, owned, err := storage.ObjectKeyFromCDNURL(imageURL, conf.Upload.ImageBucketCDNHost)
|
||
if err != nil || !owned || parsedKey == "" {
|
||
logrus.WithError(err).WithField("owned", owned).Error("Failed to resolve uploaded message image key")
|
||
ctx.SetInternalErrorFlash()
|
||
ctx.Redirect(fmt.Sprintf("/_/%s/chat/%s", domain, token))
|
||
return
|
||
}
|
||
imageKey = parsedKey
|
||
// 只有消息图片元数据成功落库才标记 attached；此前任意失败出口都补偿新对象。
|
||
defer func() {
|
||
if imageAttached {
|
||
return
|
||
}
|
||
if err := db.R2DeleteTasks.Enqueue(stdctx.Background(), conf.Upload.ImageBucket, []string{imageKey}); err != nil {
|
||
logrus.WithError(err).WithField("key", imageKey).Error("Failed to enqueue uploaded message image compensation")
|
||
}
|
||
}()
|
||
}
|
||
|
||
// 内容安全检测（仅文本）
|
||
// 统一守卫：与提问 / 投票共用同一份档位判定，箱主的「审核严格度」决定放行与否。
|
||
if content != "" {
|
||
if _, err := moderation.Check(ctx.Request().Context(), moderation.EffectiveStrictness(ctx.Request().Context(), pageUser.ID, pageUser.ModerationStrictness), ctx.Lang(), content); err != nil {
|
||
// 审核拦截：就地重渲染会话页，回填已输入内容并展示拦截原因。
|
||
// 不复用 SetErrorFlash + Redirect：那会导致输入框内容在刷新后丢失（用户已确认的无提示+内容消失问题）。
|
||
renderConversation(ctx, domain, token, content, err)
|
||
return
|
||
}
|
||
}
|
||
|
||
var image *db.CreateMessageImageOptions
|
||
if imageURL != "" {
|
||
image = &db.CreateMessageImageOptions{URL: imageURL, ObjectKey: imageKey, FileName: imageHeader.Filename, FileSize: imageHeader.Size}
|
||
}
|
||
_, err = db.Conversations.SendMessage(ctx.Request().Context(), db.SendConversationMessageOptions{
|
||
ConversationID: conv.ID, SenderID: ctx.User.ID, Content: content, Image: image,
|
||
})
|
||
if err != nil {
|
||
switch {
|
||
case errors.Is(err, db.ErrDailyMessageLimit):
|
||
ctx.SetErrorFlash(i18n.T(ctx.Lang(), "chat.errDailyLimit", pageUser.DailyMessageLimit))
|
||
case errors.Is(err, db.ErrConversationLimit):
|
||
ctx.SetErrorFlash(i18n.T(ctx.Lang(), "chat.errLimitReached"))
|
||
default:
|
||
logrus.WithContext(ctx.Request().Context()).WithError(err).Error("Failed to send message")
|
||
ctx.SetInternalErrorFlash()
|
||
}
|
||
ctx.Redirect(fmt.Sprintf("/_/%s/chat/%s", domain, token))
|
||
return
|
||
}
|
||
imageAttached = true
|
||
|
||
// 达到上限时关闭对话（幂等，多实例同时执行也安全）
|
||
if err := db.Conversations.MaybeClose(ctx.Request().Context(), conv.ID, conv.MaxMessages); err != nil {
|
||
logrus.WithContext(ctx.Request().Context()).WithError(err).Error("Failed to maybe close conversation")
|
||
}
|
||
|
||
senderName := ctx.User.Name
|
||
shared.SafeGo(func() {
|
||
var recipientEmail string
|
||
if isOwner {
|
||
asker, err := db.Users.GetByID(stdctx.Background(), conv.AskerID)
|
||
if err == nil {
|
||
recipientEmail = asker.Email
|
||
}
|
||
} else {
|
||
owner, err := db.Users.GetByID(stdctx.Background(), conv.OwnerID)
|
||
if err == nil {
|
||
recipientEmail = owner.Email
|
||
}
|
||
}
|
||
if recipientEmail == "" {
|
||
return
|
||
}
|
||
|
||
// 邮件节流：同一收件人 5 分钟内最多一封通知，防止刷屏导致邮件轰炸。
|
||
notifyKey := "chat-notify:" + recipientEmail
|
||
if _, err := cache.Get(stdctx.Background(), notifyKey); err == nil {
|
||
return
|
||
}
|
||
|
||
if err := mail.SendNewMessageMail(recipientEmail, senderName, pageUser.Domain, token, content); err != nil {
|
||
logrus.WithContext(stdctx.Background()).WithError(err).Error("Failed to send new message mail")
|
||
return
|
||
}
|
||
_ = cache.Set(stdctx.Background(), notifyKey, time.Now(), 5*time.Minute)
|
||
})
|
||
|
||
ctx.SetSuccessFlash(i18n.T(ctx.Lang(), "chat.flash.sent"))
|
||
ctx.Redirect(fmt.Sprintf("/_/%s/chat/%s", domain, token))
|
||
}
|
||
|
||
func DeleteConversation(ctx context.Context) {
|
||
token := ctx.Param("token")
|
||
|
||
conv, err := db.Conversations.GetByToken(ctx.Request().Context(), token)
|
||
if err != nil {
|
||
ctx.Redirect("/user/questions")
|
||
return
|
||
}
|
||
|
||
if !ctx.IsLogged || ctx.User.ID != conv.OwnerID {
|
||
ctx.SetErrorFlash(i18n.T(ctx.Lang(), "chat.errNoPermission"))
|
||
ctx.Redirect("/user/questions")
|
||
return
|
||
}
|
||
|
||
if err := db.Conversations.MarkDeletedByOwner(ctx.Request().Context(), conv.ID); err != nil {
|
||
logrus.WithContext(ctx.Request().Context()).WithError(err).Error("Failed to mark conversation deleted")
|
||
ctx.SetInternalErrorFlash()
|
||
ctx.Redirect("/user/questions")
|
||
return
|
||
}
|
||
|
||
ctx.SetSuccessFlash(i18n.T(ctx.Lang(), "chat.flash.deleted"))
|
||
ctx.Redirect("/user/questions")
|
||
}
|
||
|
||
// ToggleBlockUser 拉黑/取消屏蔽
|
||
func ToggleBlockUser(ctx context.Context) {
|
||
token := ctx.Param("token")
|
||
|
||
conv, err := db.Conversations.GetByToken(ctx.Request().Context(), token)
|
||
if err != nil {
|
||
ctx.Redirect("/user/questions")
|
||
return
|
||
}
|
||
|
||
if !ctx.IsLogged || ctx.User.ID != conv.OwnerID {
|
||
ctx.SetErrorFlash(i18n.T(ctx.Lang(), "chat.errNoPermission"))
|
||
ctx.Redirect("/user/questions")
|
||
return
|
||
}
|
||
|
||
blocked, _ := db.Users.IsUserBlocked(ctx.Request().Context(), conv.OwnerID, conv.AskerID)
|
||
if blocked {
|
||
err = db.Users.UnblockUser(ctx.Request().Context(), conv.OwnerID, conv.AskerID)
|
||
} else {
|
||
err = db.Users.BlockUser(ctx.Request().Context(), conv.OwnerID, conv.AskerID)
|
||
}
|
||
if err != nil {
|
||
logrus.WithContext(ctx.Request().Context()).WithError(err).Error("Failed to toggle block")
|
||
ctx.SetInternalErrorFlash()
|
||
} else {
|
||
ctx.SetSuccessFlash(i18n.T(ctx.Lang(), "chat.flash.operated"))
|
||
}
|
||
ctx.Redirect(fmt.Sprintf("/_/%s/chat/%s", ctx.Param("domain"), token))
|
||
}
|