336 lines
11 KiB
Go
336 lines
11 KiB
Go
package rpc
|
||
|
||
import (
|
||
"context"
|
||
"strconv"
|
||
"strings"
|
||
"unicode/utf8"
|
||
|
||
"github.com/gotd/td/tg"
|
||
|
||
"telesrv/internal/domain"
|
||
)
|
||
|
||
// 本文件集中 poll 的 tg↔domain 转换与 updateMessagePoll 组装。
|
||
// 定义快照（MessagePoll）不含机密；机密只进 PollDefinition（polls 权威表）。
|
||
|
||
// resolvePollAuxMedia 解析 poll 配图（答案图/题干图）：只允许引用或上传 photo/document，
|
||
// 其余 InputMedia（含嵌套 poll/todo——会先建孤儿权威行）显式拒绝。
|
||
func (r *Router) resolvePollAuxMedia(ctx context.Context, userID int64, input tg.InputMediaClass) (*domain.MessageMedia, error) {
|
||
switch input.(type) {
|
||
case *tg.InputMediaPhoto, *tg.InputMediaDocument, *tg.InputMediaUploadedPhoto, *tg.InputMediaUploadedDocument:
|
||
default:
|
||
return nil, mediaInvalidErr()
|
||
}
|
||
media, err := r.resolveInputMedia(ctx, userID, input)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if media == nil || (media.Kind != domain.MessageMediaKindPhoto && media.Kind != domain.MessageMediaKindDocument) {
|
||
return nil, mediaInvalidErr()
|
||
}
|
||
return media, nil
|
||
}
|
||
|
||
// domainPollFromInputMedia 校验 InputMediaPoll 并产出 (渲染快照, 权威定义)。
|
||
// pollID 由调用方分配；now 用于 close_period→close_date 折算。
|
||
func (r *Router) domainPollFromInputMedia(ctx context.Context, in *tg.InputMediaPoll, creatorUserID, pollID int64, now int) (*domain.MessagePoll, domain.PollDefinition, error) {
|
||
var zero domain.PollDefinition
|
||
poll := in.Poll
|
||
if poll.SubscribersOnly || len(poll.CountriesISO2) > 0 {
|
||
// subscribers-only / 国家限定是新版商业能力，当前无业务模型。
|
||
return nil, zero, mediaInvalidErr()
|
||
}
|
||
// open_answers（开放式答案，允许他人添加选项）在 TDesktop 创建面板默认勾选
|
||
//（kDefaultPollCreateFlags），不能拒；其依赖的 addPollAnswer/deletePollAnswer
|
||
// 未接入，故静默剥离不回 echo——客户端不渲染"添加答案"入口，行为自洽（矩阵 todo）。
|
||
question := poll.Question.Text
|
||
if strings.TrimSpace(question) == "" {
|
||
return nil, zero, mediaEmptyErr()
|
||
}
|
||
if utf8.RuneCountInString(question) > domain.MaxPollQuestionLength {
|
||
return nil, zero, mediaInvalidErr()
|
||
}
|
||
if len(poll.Question.Entities) > maxMessageEntityCount {
|
||
return nil, zero, limitInvalidErr()
|
||
}
|
||
if len(poll.Answers) < domain.MinPollAnswers {
|
||
return nil, zero, optionInvalidErr()
|
||
}
|
||
if len(poll.Answers) > domain.MaxPollAnswers {
|
||
return nil, zero, optionsTooMuchErr()
|
||
}
|
||
snapshot := &domain.MessagePoll{
|
||
ID: pollID,
|
||
Question: question,
|
||
QuestionEntities: domainMessageEntities(poll.Question.Entities),
|
||
PublicVoters: poll.PublicVoters,
|
||
MultipleChoice: poll.MultipleChoice,
|
||
Quiz: poll.Quiz,
|
||
RevotingDisabled: poll.RevotingDisabled,
|
||
ShuffleAnswers: poll.ShuffleAnswers,
|
||
HideResultsUntilClose: poll.HideResultsUntilClose,
|
||
}
|
||
def := domain.PollDefinition{
|
||
ID: pollID,
|
||
CreatorUserID: creatorUserID,
|
||
PublicVoters: poll.PublicVoters,
|
||
MultipleChoice: poll.MultipleChoice,
|
||
Quiz: poll.Quiz,
|
||
RevotingDisabled: poll.RevotingDisabled,
|
||
HideResultsUntilClose: poll.HideResultsUntilClose,
|
||
}
|
||
// 答案两种形态：pollAnswer 自带 option 键（DrKLO Android 路径）；
|
||
// inputPollAnswer 无 option（TDesktop 创建路径）——option 键由服务端分配。
|
||
seen := make(map[string]struct{}, len(poll.Answers))
|
||
pendingOption := make([]bool, 0, len(poll.Answers))
|
||
for _, answerClass := range poll.Answers {
|
||
var text tg.TextWithEntities
|
||
var option []byte
|
||
var answerMedia *domain.MessageMedia
|
||
switch answer := answerClass.(type) {
|
||
case *tg.PollAnswer:
|
||
if answer.Media != nil {
|
||
// pollAnswer.media 是 MessageMedia（服务端输出形态），不是合法输入。
|
||
return nil, zero, mediaInvalidErr()
|
||
}
|
||
if len(answer.Option) == 0 || len(answer.Option) > maxPollOptionBytes {
|
||
return nil, zero, pollOptionInvalidErr()
|
||
}
|
||
text = answer.Text
|
||
option = append([]byte(nil), answer.Option...)
|
||
case *tg.InputPollAnswer:
|
||
// 答案配图（TDesktop 创建面板可给每个答案附 photo/document）。
|
||
if input, ok := answer.GetMedia(); ok && input != nil {
|
||
media, err := r.resolvePollAuxMedia(ctx, creatorUserID, input)
|
||
if err != nil {
|
||
return nil, zero, err
|
||
}
|
||
answerMedia = media
|
||
}
|
||
text = answer.Text
|
||
default:
|
||
return nil, zero, pollAnswerInvalidErr()
|
||
}
|
||
if strings.TrimSpace(text.Text) == "" || utf8.RuneCountInString(text.Text) > domain.MaxPollAnswerTextLength {
|
||
return nil, zero, pollAnswerInvalidErr()
|
||
}
|
||
if len(text.Entities) > maxMessageEntityCount {
|
||
return nil, zero, limitInvalidErr()
|
||
}
|
||
if option != nil {
|
||
key := string(option)
|
||
if _, dup := seen[key]; dup {
|
||
return nil, zero, pollOptionInvalidErr()
|
||
}
|
||
seen[key] = struct{}{}
|
||
}
|
||
pendingOption = append(pendingOption, option == nil)
|
||
snapshot.Answers = append(snapshot.Answers, domain.MessagePollAnswer{
|
||
Text: text.Text,
|
||
Entities: domainMessageEntities(text.Entities),
|
||
Option: option,
|
||
Media: answerMedia,
|
||
})
|
||
}
|
||
// 为 inputPollAnswer 分配服务端 option 键：取未被显式键占用的最小单字节。
|
||
next := 0
|
||
for i := range snapshot.Answers {
|
||
if !pendingOption[i] {
|
||
continue
|
||
}
|
||
for next <= 0xFF {
|
||
key := []byte{byte(next)}
|
||
next++
|
||
if _, taken := seen[string(key)]; !taken {
|
||
seen[string(key)] = struct{}{}
|
||
snapshot.Answers[i].Option = key
|
||
break
|
||
}
|
||
}
|
||
if snapshot.Answers[i].Option == nil {
|
||
return nil, zero, pollOptionInvalidErr()
|
||
}
|
||
}
|
||
for _, answer := range snapshot.Answers {
|
||
def.Options = append(def.Options, answer.Option)
|
||
}
|
||
// quiz 机密：correct_answers（Layer 224+ 为答案下标）必须恰好 1 个且指向合法选项；
|
||
// solution 仅 quiz 可带。
|
||
correct, hasCorrect := in.GetCorrectAnswers()
|
||
solution, hasSolution := in.GetSolution()
|
||
if poll.Quiz {
|
||
if poll.MultipleChoice {
|
||
return nil, zero, mediaInvalidErr()
|
||
}
|
||
if !hasCorrect || len(correct) != 1 {
|
||
return nil, zero, quizCorrectAnswersInvalidErr()
|
||
}
|
||
for _, index := range correct {
|
||
if index < 0 || index >= len(def.Options) {
|
||
return nil, zero, quizCorrectAnswersInvalidErr()
|
||
}
|
||
def.CorrectOptions = append(def.CorrectOptions, append([]byte(nil), def.Options[index]...))
|
||
}
|
||
if hasSolution {
|
||
if strings.TrimSpace(solution) == "" || utf8.RuneCountInString(solution) > domain.MaxPollSolutionLength {
|
||
return nil, zero, mediaInvalidErr()
|
||
}
|
||
entities, _ := in.GetSolutionEntities()
|
||
if len(entities) > maxMessageEntityCount {
|
||
return nil, zero, limitInvalidErr()
|
||
}
|
||
def.Solution = solution
|
||
def.SolutionEntities = domainMessageEntities(entities)
|
||
}
|
||
} else if hasCorrect || hasSolution {
|
||
return nil, zero, mediaInvalidErr()
|
||
}
|
||
if _, ok := in.GetSolutionMedia(); ok {
|
||
// quiz 解释配图依赖 polls 权威表扩列（机密侧），当前未接入（矩阵 todo）。
|
||
return nil, zero, mediaInvalidErr()
|
||
}
|
||
if input, ok := in.GetAttachedMedia(); ok && input != nil {
|
||
// poll 题干配图（messageMediaPoll.attached_media），随快照落库。
|
||
media, err := r.resolvePollAuxMedia(ctx, creatorUserID, input)
|
||
if err != nil {
|
||
return nil, zero, err
|
||
}
|
||
snapshot.AttachedMedia = media
|
||
}
|
||
// close_period / close_date 互斥；period 折算出 close_date 供服务端到点判定。
|
||
closePeriod, hasPeriod := poll.GetClosePeriod()
|
||
closeDate, hasDate := poll.GetCloseDate()
|
||
if hasPeriod && hasDate {
|
||
return nil, zero, mediaInvalidErr()
|
||
}
|
||
if hasPeriod {
|
||
if closePeriod < domain.MinPollClosePeriod || closePeriod > domain.MaxPollClosePeriod {
|
||
return nil, zero, mediaInvalidErr()
|
||
}
|
||
snapshot.ClosePeriod = closePeriod
|
||
snapshot.CloseDate = now + closePeriod
|
||
def.ClosePeriod = closePeriod
|
||
def.CloseDate = now + closePeriod
|
||
} else if hasDate {
|
||
if closeDate <= now || closeDate > now+domain.MaxPollClosePeriod+60 {
|
||
return nil, zero, mediaInvalidErr()
|
||
}
|
||
snapshot.CloseDate = closeDate
|
||
def.CloseDate = closeDate
|
||
}
|
||
return snapshot, def, nil
|
||
}
|
||
|
||
// tgPoll 把定义快照转成 tg.Poll（Closed/Results 由读路径 enrichment 决定）。
|
||
func tgPoll(p domain.MessagePoll) tg.Poll {
|
||
out := tg.Poll{
|
||
ID: p.ID,
|
||
Closed: p.Closed,
|
||
PublicVoters: p.PublicVoters,
|
||
MultipleChoice: p.MultipleChoice,
|
||
Quiz: p.Quiz,
|
||
RevotingDisabled: p.RevotingDisabled,
|
||
ShuffleAnswers: p.ShuffleAnswers,
|
||
HideResultsUntilClose: p.HideResultsUntilClose,
|
||
Question: tgTextWithEntities(p.Question, p.QuestionEntities),
|
||
Answers: make([]tg.PollAnswerClass, 0, len(p.Answers)),
|
||
}
|
||
for _, answer := range p.Answers {
|
||
item := &tg.PollAnswer{
|
||
Text: tgTextWithEntities(answer.Text, answer.Entities),
|
||
Option: answer.Option,
|
||
}
|
||
if answer.Media != nil {
|
||
item.SetMedia(tgMessageMedia(answer.Media))
|
||
}
|
||
out.Answers = append(out.Answers, item)
|
||
}
|
||
if p.ClosePeriod > 0 {
|
||
out.SetClosePeriod(p.ClosePeriod)
|
||
}
|
||
if p.CloseDate > 0 {
|
||
out.SetCloseDate(p.CloseDate)
|
||
}
|
||
return out
|
||
}
|
||
|
||
// tgPollResults 输出 viewer 视角结果；未 enrich（Results==nil）时回退 min（客户端保留本地缓存）。
|
||
func tgPollResults(p domain.MessagePoll) tg.PollResults {
|
||
out := tg.PollResults{}
|
||
results := p.Results
|
||
if results == nil {
|
||
out.Min = true
|
||
return out
|
||
}
|
||
voters := make([]tg.PollAnswerVoters, 0, len(results.Voters))
|
||
for _, item := range results.Voters {
|
||
entry := tg.PollAnswerVoters{Chosen: item.Chosen, Correct: item.Correct, Option: item.Option}
|
||
entry.SetVoters(item.Voters)
|
||
voters = append(voters, entry)
|
||
}
|
||
out.SetResults(voters)
|
||
out.SetTotalVoters(results.TotalVoters)
|
||
if len(results.RecentVoters) > 0 {
|
||
peers := make([]tg.PeerClass, 0, len(results.RecentVoters))
|
||
for _, userID := range results.RecentVoters {
|
||
peers = append(peers, &tg.PeerUser{UserID: userID})
|
||
}
|
||
out.SetRecentVoters(peers)
|
||
}
|
||
if results.Solution != "" {
|
||
out.SetSolution(results.Solution)
|
||
out.SetSolutionEntities(tgMessageEntities(results.SolutionEntities))
|
||
}
|
||
return out
|
||
}
|
||
|
||
func tgTextWithEntities(text string, entities []domain.MessageEntity) tg.TextWithEntities {
|
||
converted := tgMessageEntities(entities)
|
||
if converted == nil {
|
||
converted = []tg.MessageEntityClass{}
|
||
}
|
||
return tg.TextWithEntities{Text: text, Entities: converted}
|
||
}
|
||
|
||
// tgUpdateMessagePoll 组装一条 updateMessagePoll（poll 总是内联，避免客户端缓存缺失）。
|
||
func tgUpdateMessagePoll(peer domain.Peer, msgID int, poll *domain.MessagePoll) *tg.UpdateMessagePoll {
|
||
if poll == nil {
|
||
return nil
|
||
}
|
||
update := &tg.UpdateMessagePoll{
|
||
PollID: poll.ID,
|
||
Results: tgPollResults(*poll),
|
||
}
|
||
update.SetPoll(tgPoll(*poll))
|
||
if tgp := tgPeer(peer); tgp != nil && msgID > 0 {
|
||
update.SetPeer(tgp)
|
||
update.SetMsgID(msgID)
|
||
}
|
||
return update
|
||
}
|
||
|
||
// pollVotesNextOffset 编解码 getPollVotes 翻页 token（"<date>,<user_id>"）。
|
||
func pollVotesNextOffset(votes []domain.PollVote) string {
|
||
if len(votes) == 0 {
|
||
return ""
|
||
}
|
||
last := votes[len(votes)-1]
|
||
return strconv.Itoa(last.Date) + "," + strconv.FormatInt(last.UserID, 10)
|
||
}
|
||
|
||
func decodePollVotesOffset(offset string) (date int, userID int64, ok bool) {
|
||
if offset == "" {
|
||
return 0, 0, true
|
||
}
|
||
parts := strings.SplitN(offset, ",", 2)
|
||
if len(parts) != 2 {
|
||
return 0, 0, false
|
||
}
|
||
d, err1 := strconv.Atoi(parts[0])
|
||
u, err2 := strconv.ParseInt(parts[1], 10, 64)
|
||
if err1 != nil || err2 != nil || d < 0 || u < 0 {
|
||
return 0, 0, false
|
||
}
|
||
return d, u, true
|
||
}
|