AskaEth
3638ed7708
- 原状：image（base64/URL 字符串）在 API 层**无长度上限**、原样落库 ⇒ 一张 5 MiB 的图 ≈ 每页历史重传 6.7 MB - 修法：入口层（handleChat，位于 stream 分叉**之前** ⇒ 同步与 stream:true 两条路径同拦）按**字符串长度零分配**判定， 超限 → 400 `image_too_large`，文案给出上限并**指路 POST /api/v1/upload**；日志只记 session/chars/limit（不打图片内容） - 上限口径：**与 POST /upload 的 maxUploadBytes = 5 MiB 取同一个答案**（否则内联 base64 可绕开上传限制）； 字符上限 = ceil(n/3)*4 + 64（覆盖 data URI 前缀），**恰好 5 MiB 的整幅图编码后 = 6,990,508 字符，绝不误拒** - 复核：6 条用例（上限与 upload 同值、边界 ==limit 通过 / +1 拒、超限**0 个回合被驱动**、 stream:true 同样被拒、恰好等于上限逐字节到达 runner、小图行为逐字节不变）； **2 条变异反证**（忘接守卫 / 边界改 `<`）均已还原 - 实测附注：WS 侧今天**已被传输层关死**（wsReadLimit=4096，8KB chat 帧直接断连）⇒ 多 MB base64 无法经 WS 进入； 若日后放宽该上限，必须在 ws 入口补同一个校验（回报里给了精确落点） - 未做（登记）：上限暂不可配置（等 config.go 空闲）、REST 请求体仍整体读入内存（MaxBytesReader 属行为变更）、 vision 层 base64 路径无长度预检（纵深防御）、历史 base64 行需离线批处理（方案已出）
450 lines
18 KiB
Go
450 lines
18 KiB
Go
package gateway
|
||
|
||
import (
|
||
"encoding/json"
|
||
"net/http"
|
||
"strings"
|
||
"time"
|
||
|
||
"git.yeij.top/AskaEth/Cyrene_v2/internal/auth"
|
||
"git.yeij.top/AskaEth/Cyrene_v2/internal/channel/session"
|
||
apperr "git.yeij.top/AskaEth/Cyrene_v2/internal/errors"
|
||
"git.yeij.top/AskaEth/Cyrene_v2/internal/persona/loader"
|
||
"git.yeij.top/AskaEth/Cyrene_v2/internal/runtime/loop"
|
||
"git.yeij.top/AskaEth/Cyrene_v2/internal/runtime/model"
|
||
)
|
||
|
||
// tokenTTL 是已签发 JWT 的有效时长。
|
||
const tokenTTL = 24 * time.Hour
|
||
|
||
// PersonaSummary 是 REST/管理列表响应中一个人格的线上结构。
|
||
type PersonaSummary struct {
|
||
ID string `json:"id"`
|
||
Name string `json:"name"`
|
||
Character string `json:"character"`
|
||
IsDefault bool `json:"isDefault"`
|
||
Mode string `json:"mode"`
|
||
MemoryNS string `json:"memoryNamespace"`
|
||
Avatar string `json:"avatar,omitempty"`
|
||
// ChatBackground 持有分方向的壁纸；是本角色自己的，绝不是别人的。
|
||
ChatBackground ChatBackgroundSummary `json:"chatBackground,omitempty"`
|
||
// Mood 是该角色的当前情绪状态（design/01 §2：情绪跟随角色，
|
||
// 绝不是会话）。"" 意味着该角色没有受跟踪的情绪 —— 诚实的
|
||
// 空值，绝不是编造的默认。客户端从它给 mood 角标播种，因此
|
||
// 刷新不再闪出空 mood。
|
||
Mood string `json:"mood"`
|
||
// Thinking 携带人格可选的推理/呈现块
|
||
// （design/01 §2.1）。人格未配置时它是 nil —— 因而从 JSON 中缺席 ——
|
||
// 与写侧「省略的块保留
|
||
// 已存块」。仅管理列表：这些是模型调用开关，不是用户 UI 状态
|
||
// （用户列表取 Mood，把开关留给面板）。
|
||
Thinking *PersonaThinkingSummary `json:"thinking,omitempty"`
|
||
}
|
||
|
||
// PersonaThinkingSummary 在线上镜像人格的 `thinking` 块
|
||
// （design/01 §2.1；provider 映射见 design/04 §3.2）。
|
||
type PersonaThinkingSummary struct {
|
||
// BudgetTokens 是推理预算（Anthropic thinking.budget_tokens）。
|
||
BudgetTokens int `json:"budgetTokens"`
|
||
// Effort 是 provider 特有的推理强度（reasoning_effort）。
|
||
// 模型层会按活动 provider 的白名单校验它，并在它被丢弃时
|
||
// 打 WARN —— 这一侧只报告已存的内容。
|
||
Effort string `json:"effort"`
|
||
// ShowToUser 是三态的，且在线上保持如此：null = 未
|
||
// 配置（thinking 帧继续流出 —— 既有行为），
|
||
// true/false = 显式选择。普通 bool 会把「未设置」压平到
|
||
// 「关闭」上，丢掉写侧用 *bool 保持的区分。
|
||
ShowToUser *bool `json:"showToUser"`
|
||
// Mode 是显式的硬开关：default | on | off（"" = default）。
|
||
Mode string `json:"mode"`
|
||
}
|
||
|
||
// ChatBackgroundSummary 在线上镜像人格的 chatBackground。
|
||
type ChatBackgroundSummary struct {
|
||
Landscape string `json:"landscape,omitempty"`
|
||
Portrait string `json:"portrait,omitempty"`
|
||
}
|
||
|
||
// MemorySummary 是管理列表响应中一条记忆条目的线上结构。
|
||
type MemorySummary struct {
|
||
ID string `json:"id"`
|
||
Scope string `json:"scope"`
|
||
Text string `json:"text"`
|
||
}
|
||
|
||
// SessionSummary 是列表响应中一个渠道会话的线上结构。
|
||
type SessionSummary struct {
|
||
Platform string `json:"platform"`
|
||
ChannelID string `json:"channelId"`
|
||
SessionID string `json:"sessionId"`
|
||
ActorRole string `json:"actorRole"`
|
||
Owner bool `json:"owner"`
|
||
IsGroup bool `json:"isGroup"`
|
||
MemWrite bool `json:"memWritable"`
|
||
}
|
||
|
||
// loginRequest 是 POST /api/v1/auth/login 的请求体。
|
||
type loginRequest struct {
|
||
Username string `json:"username"`
|
||
Password string `json:"password"`
|
||
}
|
||
|
||
// loginResponse 是登录成功的载荷。RefreshToken 是 B2 新增的非透明
|
||
// 长期凭据（POST /auth/refresh）；未接线 refresh 存储时被省略，
|
||
// 因此 B2 之前的契约不变。
|
||
type loginResponse struct {
|
||
Token string `json:"token"`
|
||
ExpiresAt int64 `json:"expiresAt"`
|
||
Role string `json:"role"`
|
||
RefreshToken string `json:"refreshToken,omitempty"`
|
||
}
|
||
|
||
// chatRequest 是 POST /api/v1/chat 的请求体。Stream 为 true 时网关
|
||
// 经 WebSocket 通道触发流式并立即返回。Image 是
|
||
// 为视觉路径附带的可选 base64 data: URI 或 http(s) URL；
|
||
// loop 把它经视觉/OCR 工具或主模型路由（design/06 §0）。
|
||
// Image 受 maxChatImageChars 限制（与 POST /api/v1/upload 的 5 MiB 同口径），
|
||
// 超限一律 400 image_too_large，不被静默吃下。
|
||
// DeviceID 是客户端产出的发送浏览器/设备标识
|
||
// （design/16 §4.5），例如 "web:chrome:a1b2c3"；它可选且按原样持久化。
|
||
// Mode 是客户端发送该回合时的行为模式（design/01 §3、design/16
|
||
// §5.1）；它可选，并按消息持久化以供气泡渲染，省略时
|
||
// 回退到 "chat"。
|
||
type chatRequest struct {
|
||
SessionID string `json:"sessionId"`
|
||
Text string `json:"text"`
|
||
Image string `json:"image,omitempty"`
|
||
DeviceID string `json:"deviceId,omitempty"`
|
||
Mode string `json:"mode,omitempty"`
|
||
Stream bool `json:"stream"`
|
||
}
|
||
|
||
// chatResponse 是同步聊天回复的载荷。
|
||
type chatResponse struct {
|
||
Reply string `json:"reply"`
|
||
Steps int `json:"steps"`
|
||
StopReason string `json:"stopReason"`
|
||
}
|
||
|
||
// maxChatImageBytes 是 chat.image 允许的**解码后图像字节**上限，与
|
||
// POST /api/v1/upload 的 maxUploadBytes（5 MiB，见 upload.go）同口径：
|
||
// 图片有上传与内联两条入口，两边必须给出同一个「一张图能有多大」的答案，
|
||
// 否则上传的限制可被 base64 内联绕开 —— 客户端发来多大就落库多大，
|
||
// 每页历史（GET /sessions/{id}/messages）与每次 WS history 回放都要
|
||
// 把整段 base64 再传一遍（协同文档 G3）。
|
||
const maxChatImageBytes = 5 << 20
|
||
|
||
// chatImagePrefixAllowance 是 data: URI 前缀（如 "data:image/png;base64,"）
|
||
// 所占的字符余量。按常见图片 MIME 的最长前缀取整，不含 base64 载荷本身。
|
||
const chatImagePrefixAllowance = 64
|
||
|
||
// maxChatImageChars 是同一口径换算到 base64 字符串长度的上限。base64 每
|
||
// 3 字节编码为 4 字符（膨胀 4/3），因此正好 5 MiB 的整幅图编码后是
|
||
// ceil(maxChatImageBytes/3)*4 = 6990508 字符（这就是 (n+2)/3*4 的由来：
|
||
// 余 1、2 字节时末组仍需补满 4 字符），再加 data: 前缀余量 —— 恰好 5 MiB
|
||
// 的合法图片绝不会被误拒。
|
||
//
|
||
// 校验按**字符串长度**做，是因为入口层只有这一步是零分配的：vision 层要先
|
||
// base64 解码整个字符串才拿到真实字节数（vision.decodeBase64 →
|
||
// base64.StdEncoding.DecodeString），也就是先分配再报错。在入口层按长度拦下，
|
||
// 超大字符串根本走不到解码那一步。
|
||
const maxChatImageChars = ((maxChatImageBytes+2)/3)*4 + chatImagePrefixAllowance
|
||
|
||
// chatImageTooLargeCode 是 image 超限时返回给客户端的机器可读错误码，
|
||
// 与其它 400 文案区分开：客户端只看 code 就能把「图太大，请改走上传」
|
||
// 与「请求体格式错」分开处理。
|
||
const chatImageTooLargeCode = "image_too_large"
|
||
|
||
// checkChatImageSize 校验 image 字符串长度是否在 limit 之内，超限时返回
|
||
// 400 + image_too_large 的显式错误（带上限与本次长度，并指明改用
|
||
// POST /api/v1/upload 取 URL 再发）。limit 作为参数传入，使该判定能被
|
||
// 用小上限直接单测（边界与比较运算符因此可被钉住），REST 入口传的是
|
||
// maxChatImageChars。
|
||
//
|
||
// 文案里的体积由 limit 反推（base64 膨胀 4/3 → 解码后约 limit*3/4 字节），
|
||
// 因此换上限时文案自动跟随，不会出现「写着 5 MiB、实际是别的数」。
|
||
func checkChatImageSize(image string, limit int) error {
|
||
if len(image) <= limit {
|
||
return nil
|
||
}
|
||
return apperr.Wrap(apperr.ErrBadRequest, chatImageTooLargeCode,
|
||
"图片过大：image 上限约 %.1f MiB（base64 字符串上限 %d 字符，本次 %d 字符）；请先 POST /api/v1/upload 上传，再用返回的 url 作为 image 发送",
|
||
float64(limit)*3/4/(1<<20), limit, len(image))
|
||
}
|
||
|
||
// handleHealth 报告存活。它不认证，因为它是探针。
|
||
func (s *Server) handleHealth(w http.ResponseWriter, r *http.Request) {
|
||
writeJSON(w, http.StatusOK, map[string]any{"status": "ok"})
|
||
}
|
||
|
||
// handleLogin 用管理用户名/密码换取已签名的 JWT。
|
||
func (s *Server) handleLogin(w http.ResponseWriter, r *http.Request) {
|
||
var req loginRequest
|
||
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
||
writeError(w, apperr.Wrap(apperr.ErrBadRequest, "bad_request", "invalid request body"))
|
||
return
|
||
}
|
||
cfg := s.cfg.Auth
|
||
if req.Username != cfg.AdminUser || req.Password != cfg.AdminPass {
|
||
writeError(w, apperr.Wrap(apperr.ErrUnauthorized, "unauthorized", "invalid username or password"))
|
||
return
|
||
}
|
||
token, err := s.auth.Sign(req.Username, auth.RoleOwner, tokenTTL)
|
||
if err != nil {
|
||
s.log.Error("login sign", "err", err)
|
||
writeError(w, apperr.Wrap(apperr.ErrInternal, "login_failed", "could not sign token"))
|
||
return
|
||
}
|
||
resp := loginResponse{
|
||
Token: token,
|
||
ExpiresAt: time.Now().Add(tokenTTL).Unix(),
|
||
Role: string(auth.RoleOwner),
|
||
}
|
||
// 在签发访问令牌的同时签发长期 refresh 凭据。存储失败会让
|
||
// 登录失败，而不是静默交回一个没有所声称 refresh token 的
|
||
// 登录；明文绝不记日志。
|
||
if s.refresh != nil {
|
||
refreshToken, _, rerr := s.refresh.Issue(r.Context(), req.Username, auth.RoleOwner, s.refreshTTL())
|
||
if rerr != nil {
|
||
s.log.Error("login issue refresh token", "err", rerr)
|
||
writeError(w, apperr.Wrap(apperr.ErrInternal, "login_failed", "could not issue refresh token"))
|
||
return
|
||
}
|
||
resp.RefreshToken = refreshToken
|
||
}
|
||
writeJSON(w, http.StatusOK, resp)
|
||
}
|
||
|
||
// handleChat 运行一次同步 agent 回合（或触发流式）。
|
||
func (s *Server) handleChat(w http.ResponseWriter, r *http.Request) {
|
||
var req chatRequest
|
||
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
||
writeError(w, apperr.Wrap(apperr.ErrBadRequest, "bad_request", "invalid request body"))
|
||
return
|
||
}
|
||
// image 上限在**任何**解码/落库之前检查，且对同步与 stream 两条分支
|
||
// 都生效（stream 只是把该轮转发给 ws.chat，转发前必须先拒），
|
||
// 因此超限的图片既不进模型、也不落库、也不会被历史回放重传。
|
||
// 日志只带长度与上限，绝不带图片内容。
|
||
if err := checkChatImageSize(req.Image, maxChatImageChars); err != nil {
|
||
s.log.Warn("chat image rejected", "session", req.SessionID, "chars", len(req.Image), "limit", maxChatImageChars)
|
||
writeError(w, err)
|
||
return
|
||
}
|
||
if strings.TrimSpace(req.Text) == "" && strings.TrimSpace(req.Image) == "" {
|
||
writeError(w, apperr.Wrap(apperr.ErrBadRequest, "bad_request", "text or image is required"))
|
||
return
|
||
}
|
||
if req.Stream {
|
||
s.publishChatStream(r.Context(), req.SessionID, req.Text, req.Image, req.DeviceID, req.Mode)
|
||
writeJSON(w, http.StatusOK, map[string]any{"stream": true})
|
||
return
|
||
}
|
||
if s.runner == nil {
|
||
writeError(w, apperr.Wrap(apperr.ErrInternal, "chat_unavailable", "chat service is not configured"))
|
||
return
|
||
}
|
||
if req.SessionID == "" {
|
||
req.SessionID = "web"
|
||
}
|
||
// Web 主会话是主人的私密对话（JWT = owner），因此它绑定
|
||
// 全访问 env：记忆读+写，行为不变。角色
|
||
// 来自会话的绑定（design/22 §4.5）。
|
||
msgs := userChatMessages(req.Text, req.Image)
|
||
env := s.envResolver.owner(r.Context(), req.SessionID)
|
||
if s.hub.orchestrator != nil {
|
||
sr, res := s.hub.orchestrator.SubmitSync(withMode(withDeviceID(r.Context(), req.DeviceID), req.Mode), req.SessionID, msgs, env)
|
||
if !sr.Accepted {
|
||
if sr.PendingFull {
|
||
writeError(w, apperr.Wrap(apperr.ErrConflict, "chat_busy", "会话正忙，待处理消息已满"))
|
||
} else {
|
||
writeError(w, apperr.Wrap(apperr.ErrBadRequest, "bad_request", "text or image is required"))
|
||
}
|
||
return
|
||
}
|
||
// 忙碌会话返回非阻塞 ack（design/15 §2.1），而不是
|
||
// 让请求阻塞在一个可能跑一阵子的回合上。
|
||
if sr.Pending {
|
||
writeJSON(w, http.StatusAccepted, map[string]any{"queued": true, "queueDepth": sr.QueueDepth})
|
||
return
|
||
}
|
||
if sr.Err != nil {
|
||
s.log.Error("chat run", "err", sr.Err, "session", req.SessionID)
|
||
writeError(w, apperr.Wrap(apperr.ErrInternal, "chat_failed", "chat failed"))
|
||
return
|
||
}
|
||
writeJSON(w, http.StatusOK, chatResponse{Reply: res.Text, Steps: res.Steps, StopReason: res.StopReason})
|
||
return
|
||
}
|
||
// 未接线编排器时的旧同步路径（未接线的 hub
|
||
// 保持完全与 design/15 之前相同的回复契约）。
|
||
res, err := s.runner.Run(loop.WithSessionEnv(r.Context(), env), req.SessionID, msgs)
|
||
if err != nil {
|
||
s.log.Error("chat run", "err", err, "session", req.SessionID)
|
||
writeError(w, apperr.Wrap(apperr.ErrInternal, "chat_failed", "chat failed"))
|
||
return
|
||
}
|
||
writeJSON(w, http.StatusOK, chatResponse{Reply: res.Text, Steps: res.Steps, StopReason: res.StopReason})
|
||
}
|
||
|
||
// handleListSessions 在接线了 history 存储时返回持久化聊天历史会话
|
||
// （main + sub），否则回退到渠道会话视图。回退保持
|
||
// design/16 之前的契约：未接 history 的服务器仍列出已知的
|
||
// 渠道会话（未接线任何存储时为 []）。
|
||
func (s *Server) handleListSessions(w http.ResponseWriter, r *http.Request) {
|
||
if s.history != nil {
|
||
s.handleHistorySessions(w, r)
|
||
return
|
||
}
|
||
out := make([]SessionSummary, 0)
|
||
if s.sessions != nil {
|
||
list, err := s.sessions.List(r.Context())
|
||
if err != nil {
|
||
s.log.Error("list sessions", "err", err)
|
||
writeError(w, apperr.Wrap(apperr.ErrInternal, "sessions_failed", "failed to list sessions"))
|
||
return
|
||
}
|
||
for _, sess := range list {
|
||
out = append(out, summaryOfSession(sess))
|
||
}
|
||
}
|
||
writeJSON(w, http.StatusOK, out)
|
||
}
|
||
|
||
// handleListPersonas 返回人格（未接线存储时为 []）。它是
|
||
// 用户侧形状：角色级 mood 一并带上，仅管理的 thinking
|
||
// 开关则不然。
|
||
func (s *Server) handleListPersonas(w http.ResponseWriter, r *http.Request) {
|
||
writeJSON(w, http.StatusOK, s.collectPersonas(false))
|
||
}
|
||
|
||
// collectPersonas 从已配置的存储返回非 nil 的人格切片。
|
||
// withThinking 加上仅管理的 `thinking` 块；mood 总是报告，
|
||
// 因为用户 UI 要渲染角标。
|
||
func (s *Server) collectPersonas(withThinking bool) []PersonaSummary {
|
||
out := make([]PersonaSummary, 0)
|
||
if s.personas == nil {
|
||
return out
|
||
}
|
||
for _, c := range s.personas.List() {
|
||
id := c.PersonaID
|
||
if id == "" {
|
||
id = c.ID
|
||
}
|
||
sum := PersonaSummary{
|
||
ID: id,
|
||
Name: c.Name,
|
||
Character: c.Name,
|
||
IsDefault: c.Default,
|
||
Mode: firstMode(c.Modes),
|
||
Mood: s.moodOf(id),
|
||
}
|
||
// 读取该人格自己的视觉资产（头像 / 聊天背景）。每个
|
||
// 角色携带自己的；人格缺失或视觉未设置得到空，
|
||
// 绝不是别的角色的 —— 前端回退到中性默认。
|
||
if p, ok := s.personas.Persona(id); ok && p != nil {
|
||
if p.Visual.Avatar != "" {
|
||
sum.Avatar = p.Visual.Avatar
|
||
}
|
||
if p.Visual.ChatBackground.Landscape != "" || p.Visual.ChatBackground.Portrait != "" {
|
||
sum.ChatBackground = ChatBackgroundSummary{
|
||
Landscape: p.Visual.ChatBackground.Landscape,
|
||
Portrait: p.Visual.ChatBackground.Portrait,
|
||
}
|
||
}
|
||
sum.Thinking = thinkingSummaryOf(p.Thinking, withThinking)
|
||
}
|
||
out = append(out, sum)
|
||
}
|
||
return out
|
||
}
|
||
|
||
// moodOf 报告该角色的当前情绪状态。情绪归
|
||
// 人格存储所有（design/01 §2），经可选的 PersonaMoodStore
|
||
// 能力读取；不跟踪情绪的存储，或没有情绪机的角色，
|
||
// 报告 "" 而不是编造一个 mood。
|
||
func (s *Server) moodOf(id string) string {
|
||
store, ok := s.personas.(PersonaMoodStore)
|
||
if !ok {
|
||
return ""
|
||
}
|
||
emotions := store.Emotions()
|
||
if emotions == nil {
|
||
return ""
|
||
}
|
||
machine, _, ok := emotions.Get(id)
|
||
if !ok || machine == nil {
|
||
return ""
|
||
}
|
||
return string(machine.Current())
|
||
}
|
||
|
||
// thinkingSummaryOf 把已存 thinking 块映射到线上。人格未配置时
|
||
// 它返回 nil —— 该键因而缺席，使客户端能把「未配置」
|
||
// 与显式取值区分开（写侧「省略的块保留已存块」规则的
|
||
// 读侧镜像）。用户侧列表的 include 为 false，
|
||
// 因为用户侧不携带这些开关。
|
||
func thinkingSummaryOf(t loader.ThinkingParams, include bool) *PersonaThinkingSummary {
|
||
if !include || !thinkingConfigured(t) {
|
||
return nil
|
||
}
|
||
return &PersonaThinkingSummary{
|
||
BudgetTokens: t.BudgetTokens,
|
||
Effort: t.Effort,
|
||
ShowToUser: t.ShowToUser,
|
||
Mode: t.Mode,
|
||
}
|
||
}
|
||
|
||
// thinkingConfigured 报告是否有任何 thinking 开关被设置。空块
|
||
// 必须读作「未配置」，而不是全零对象。
|
||
func thinkingConfigured(t loader.ThinkingParams) bool {
|
||
return t.BudgetTokens != 0 || t.Effort != "" || t.ShowToUser != nil || t.Mode != ""
|
||
}
|
||
|
||
// firstMode 返回首个声明的行为模式，未设置时返回 ""。
|
||
func firstMode(modes []string) string {
|
||
if len(modes) == 0 {
|
||
return ""
|
||
}
|
||
return modes[0]
|
||
}
|
||
|
||
// userChatMessages 为 chat / stream 请求构建用户回合。image
|
||
// 存在时该回合成为图片消息（可带文本）；否则是
|
||
// 纯文本消息。空文本加图片得到仅图片的回合。
|
||
func userChatMessages(text, image string) []model.Message {
|
||
if strings.TrimSpace(image) != "" {
|
||
return []model.Message{model.ImageMessage(model.RoleUser, text, image)}
|
||
}
|
||
return []model.Message{model.TextMessage(model.RoleUser, text)}
|
||
}
|
||
|
||
// summaryOfSession 把 session.Session 映射为其线上结构。
|
||
func summaryOfSession(sess session.Session) SessionSummary {
|
||
return SessionSummary{
|
||
Platform: sess.Platform,
|
||
ChannelID: sess.ChannelID,
|
||
SessionID: sess.SessionID,
|
||
ActorRole: string(sess.ActorRole),
|
||
Owner: sess.Owner,
|
||
IsGroup: sess.IsGroup,
|
||
MemWrite: sess.MemWritable,
|
||
}
|
||
}
|
||
|
||
// writeJSON 把 v 编码为 {data: v} 信封并带上给定状态。
|
||
func writeJSON(w http.ResponseWriter, status int, v any) {
|
||
w.Header().Set("Content-Type", "application/json")
|
||
w.WriteHeader(status)
|
||
_ = json.NewEncoder(w).Encode(map[string]any{"data": v})
|
||
}
|
||
|
||
// writeError 把 err 编码为 {error:{code,message}} 信封，状态由
|
||
// apperr.HTTPStatus 解析。
|
||
func writeError(w http.ResponseWriter, err error) {
|
||
w.Header().Set("Content-Type", "application/json")
|
||
w.WriteHeader(apperr.HTTPStatus(err))
|
||
_ = json.NewEncoder(w).Encode(apperr.ToJSON(err))
|
||
}
|