feat(email): 实现邮件详情免配置一键翻译与原文切换功能并发布V2.14.0
Security Checks / security (push) Waiting to run

This commit is contained in:
xuans committed 2026-10-18 11:02:23 +08:00
1 parent 2cedb02bcc
commit 8cf7c55a0b
10 files changed
+568 -17

No files matched your search

+116
View File
@@ -0,0 +1,116 @@
package email
import (
"context"
"fmt"
"net/http"
"strings"
"git.pcux.cn/xuans/Smail/dto/response"
"git.pcux.cn/xuans/Smail/services/detail"
"git.pcux.cn/xuans/Smail/services/translate"
smailContext "git.pcux.cn/xuans/Smail/utils/context"
log "github.com/sirupsen/logrus"
)
type emailTranslateRequest struct {
ID int `json:"id"`
Subject string `json:"subject"`
Text string `json:"text"`
TargetLang string `json:"target_lang"`
}
type emailTranslateResponse struct {
SubjectTranslated string `json:"subject_translated"`
ContentTranslated string `json:"content_translated"`
DetectedLang string `json:"detected_lang"`
TargetLang string `json:"target_lang"`
}
// TranslateEmail 邮件免配置一键翻译接口
func TranslateEmail(ctx *smailContext.Context, w http.ResponseWriter, req *http.Request) {
var retData emailTranslateRequest
if err := decodeEmailJSONRequest(w, req, &retData, maxEmailJSONRequestBytes); err != nil {
log.WithContext(ctx).WithError(err).Info("invalid email translate request")
response.NewErrorResponse(response.ParamsError, "参数错误", "").FPrint(w)
return
}
targetLang := strings.TrimSpace(retData.TargetLang)
if targetLang == "" {
targetLang = "zh-CN"
}
var subjectToTranslate string
var contentToTranslate string
if retData.ID > 0 {
emailData, err := detail.GetEmailDetail(ctx, retData.ID, false)
if err != nil {
log.WithContext(ctx).WithError(err).Warnf("translate email: load email detail failed for id=%d", retData.ID)
response.NewErrorResponse(response.ServerError, "获取邮件失败", "").FPrint(w)
return
}
subjectToTranslate = emailData.Subject
if emailData.Text.Valid && strings.TrimSpace(emailData.Text.String) != "" {
contentToTranslate = emailData.Text.String
} else if emailData.Html.Valid {
contentToTranslate = emailData.Html.String
}
} else {
subjectToTranslate = retData.Subject
contentToTranslate = retData.Text
}
if strings.TrimSpace(subjectToTranslate) == "" && strings.TrimSpace(contentToTranslate) == "" {
response.NewSuccessResponse(emailTranslateResponse{
SubjectTranslated: "",
ContentTranslated: "",
DetectedLang: "auto",
TargetLang: targetLang,
}).FPrint(w)
return
}
callCtx := req.Context()
if callCtx == nil {
callCtx = context.Background()
}
var translatedSubject string
var detectedLang = "auto"
if strings.TrimSpace(subjectToTranslate) != "" {
subRes, err := translate.TranslateText(callCtx, subjectToTranslate, targetLang)
if err != nil {
log.WithContext(ctx).WithError(err).Warn("translate subject failed")
response.NewErrorResponse(response.ServerError, fmt.Sprintf("翻译主题失败: %v", err), "").FPrint(w)
return
}
translatedSubject = subRes.TranslatedText
if subRes.SourceLang != "" && subRes.SourceLang != "auto" {
detectedLang = subRes.SourceLang
}
}
var translatedContent string
if strings.TrimSpace(contentToTranslate) != "" {
contentRes, err := translate.TranslateText(callCtx, contentToTranslate, targetLang)
if err != nil {
log.WithContext(ctx).WithError(err).Warn("translate content failed")
response.NewErrorResponse(response.ServerError, fmt.Sprintf("翻译内容失败: %v", err), "").FPrint(w)
return
}
translatedContent = contentRes.TranslatedText
if detectedLang == "auto" && contentRes.SourceLang != "" && contentRes.SourceLang != "auto" {
detectedLang = contentRes.SourceLang
}
}
response.NewSuccessResponse(emailTranslateResponse{
SubjectTranslated: translatedSubject,
ContentTranslated: translatedContent,
DetectedLang: detectedLang,
TargetLang: targetLang,
}).FPrint(w)
}
@@ -0,0 +1,55 @@
package email
import (
"bytes"
"encoding/json"
"net/http"
"net/http/httptest"
"testing"
"git.pcux.cn/xuans/Smail/services/translate"
"git.pcux.cn/xuans/Smail/utils/context"
)
func TestTranslateEmailDirectText(t *testing.T) {
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
_, _ = w.Write([]byte(`[[["你好","Hello",null,null,10]],null,"en"]`))
}))
defer ts.Close()
translate.SetApiBaseURL(ts.URL)
translate.SetDefaultClient(ts.Client())
reqBody := emailTranslateRequest{
Subject: "Hello",
Text: "Hello",
TargetLang: "zh-CN",
}
bodyBytes, _ := json.Marshal(reqBody)
r := httptest.NewRequest(http.MethodPost, "/api/v1/email/translate", bytes.NewReader(bodyBytes))
w := httptest.NewRecorder()
ctx := &context.Context{UserID: 1}
TranslateEmail(ctx, w, r)
if w.Code != http.StatusOK {
t.Fatalf("expected status 200, got %d, body: %s", w.Code, w.Body.String())
}
var resp struct {
Code int `json:"code"`
Data emailTranslateResponse `json:"data"`
}
if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
t.Fatalf("unmarshal response failed: %v", err)
}
if resp.Data.SubjectTranslated != "你好" {
t.Errorf("expected SubjectTranslated='你好', got %q", resp.Data.SubjectTranslated)
}
if resp.Data.ContentTranslated != "你好" {
t.Errorf("expected ContentTranslated='你好', got %q", resp.Data.ContentTranslated)
}
}
@@ -67,6 +67,7 @@ func registerV1Routes(mux *http.ServeMux) {
registerV1MethodRoute(mux, "/api/v1/email/del", "/api/email/del", http.MethodPost, 256<<10, email.EmailDelete)
registerV1MethodRoute(mux, "/api/v1/email/read", "/api/email/read", http.MethodPost, 256<<10, email.MarkRead)
registerV1MethodRoute(mux, "/api/v1/email/detail", "/api/email/detail", http.MethodPost, 256<<10, email.EmailDetail)
registerV1MethodRoute(mux, "/api/v1/email/translate", "/api/email/translate", http.MethodPost, 256<<10, email.TranslateEmail)
registerV1MethodRoute(mux, "/api/v1/email/move", "/api/email/move", http.MethodPost, 256<<10, email.Move)
registerV1MethodRoute(mux, "/api/v1/email/send", "/api/email/send", http.MethodPost, 40<<20, email.Send)
registerV1MethodRoute(mux, "/api/v1/email/draft/save", "/api/email/draft/save", http.MethodPost, 40<<20, email.SaveDraft)
+123
View File
@@ -0,0 +1,123 @@
package translate
import (
"context"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"net/url"
"strings"
"time"
)
var defaultClient = &http.Client{
Timeout: 15 * time.Second,
}
var apiBaseURL = "https://translate.googleapis.com/translate_a/single"
// Result 包含翻译后内容及源语言
type Result struct {
OriginalText string `json:"original_text"`
TranslatedText string `json:"translated_text"`
SourceLang string `json:"source_lang"`
TargetLang string `json:"target_lang"`
}
// SetApiBaseURL 设置翻译引擎基础地址(主要用于单元测试与代理)
func SetApiBaseURL(u string) {
if u != "" {
apiBaseURL = u
}
}
// SetDefaultClient 设置 HTTP 客户端(主要用于单元测试与超时配置)
func SetDefaultClient(c *http.Client) {
if c != nil {
defaultClient = c
}
}
// TranslateText 调用免配置翻译引擎将文本翻译为目标语言(默认 zh-CN)
func TranslateText(ctx context.Context, text string, targetLang string) (*Result, error) {
text = strings.TrimSpace(text)
if text == "" {
return &Result{
OriginalText: "",
TranslatedText: "",
SourceLang: "auto",
TargetLang: targetLang,
}, nil
}
if targetLang == "" {
targetLang = "zh-CN"
}
apiURL := fmt.Sprintf("%s?client=gtx&sl=auto&tl=%s&dt=t", apiBaseURL, url.QueryEscape(targetLang))
formData := url.Values{}
formData.Set("q", text)
req, err := http.NewRequestWithContext(ctx, http.MethodPost, apiURL, strings.NewReader(formData.Encode()))
if err != nil {
return nil, fmt.Errorf("创建翻译请求失败: %w", err)
}
req.Header.Set("Content-Type", "application/x-www-form-urlencoded;charset=utf-8")
req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36")
resp, err := defaultClient.Do(req)
if err != nil {
return nil, fmt.Errorf("请求翻译服务失败: %w", err)
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
bodyBytes, _ := io.ReadAll(io.LimitReader(resp.Body, 512))
return nil, fmt.Errorf("翻译服务返回异常状态码 %d: %s", resp.StatusCode, string(bodyBytes))
}
bodyBytes, err := io.ReadAll(io.LimitReader(resp.Body, 4<<20))
if err != nil {
return nil, fmt.Errorf("读取翻译响应失败: %w", err)
}
var rawResponse []any
if err := json.Unmarshal(bodyBytes, &rawResponse); err != nil {
return nil, fmt.Errorf("解析翻译响应结构失败: %w", err)
}
if len(rawResponse) == 0 {
return nil, errors.New("翻译响应格式为空")
}
sentences, ok := rawResponse[0].([]any)
if !ok {
return nil, errors.New("未找到译文段落列表")
}
var translatedSb strings.Builder
for _, item := range sentences {
if sentenceArr, ok := item.([]any); ok && len(sentenceArr) > 0 {
if seg, ok := sentenceArr[0].(string); ok {
translatedSb.WriteString(seg)
}
}
}
sourceLang := "auto"
if len(rawResponse) > 2 {
if sl, ok := rawResponse[2].(string); ok && sl != "" {
sourceLang = sl
}
}
return &Result{
OriginalText: text,
TranslatedText: translatedSb.String(),
SourceLang: sourceLang,
TargetLang: targetLang,
}, nil
}
@@ -0,0 +1,61 @@
package translate
import (
"context"
"net/http"
"net/http/httptest"
"testing"
)
func TestTranslateEmptyText(t *testing.T) {
res, err := TranslateText(context.Background(), "", "zh-CN")
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if res.TranslatedText != "" {
t.Fatalf("expected empty translated text, got %q", res.TranslatedText)
}
}
func TestTranslateMockServer(t *testing.T) {
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodPost {
t.Errorf("expected POST method, got %s", r.Method)
}
if err := r.ParseForm(); err != nil {
t.Errorf("parse form failed: %v", err)
}
q := r.Form.Get("q")
if q != "Hello world" {
t.Errorf("expected q='Hello world', got %q", q)
}
w.Header().Set("Content-Type", "application/json")
// 模拟 Google GTX 翻译返回结构
w.WriteHeader(http.StatusOK)
_, _ = w.Write([]byte(`[[["你好世界","Hello world",null,null,10]],null,"en"]`))
}))
defer ts.Close()
oldURL := apiBaseURL
oldClient := defaultClient
defer func() {
SetApiBaseURL(oldURL)
SetDefaultClient(oldClient)
}()
SetApiBaseURL(ts.URL)
SetDefaultClient(ts.Client())
res, err := TranslateText(context.Background(), "Hello world", "zh-CN")
if err != nil {
t.Fatalf("TranslateText failed: %v", err)
}
if res.TranslatedText != "你好世界" {
t.Fatalf("expected '你好世界', got %q", res.TranslatedText)
}
if res.SourceLang != "en" {
t.Fatalf("expected source lang 'en', got %q", res.SourceLang)
}
}