1094 lines
32 KiB
Go
1094 lines
32 KiB
Go
package main
|
||
|
||
// sync.go 实现登录 + HTTP 同步引擎（本地优先）：
|
||
// 推送本地 dirty 行 → 按 updated_at 增量拉取远端 → Last-Write-Wins 冲突合并。
|
||
// 远端经 nl-pms-api（JWT）；本地仍用 SQLite。触发：登录成功、每 5 分钟巡检、手动同步。
|
||
|
||
import (
|
||
"database/sql"
|
||
"encoding/hex"
|
||
"encoding/json"
|
||
"errors"
|
||
"fmt"
|
||
"net/http"
|
||
"net/url"
|
||
"path/filepath"
|
||
"strconv"
|
||
"strings"
|
||
"time"
|
||
)
|
||
|
||
const syncTimeout = 10 * time.Second
|
||
|
||
// ---------- 配置与状态 ----------
|
||
|
||
// syncConfig 解析 API 基址。启动时写入本地 meta（见 applyPackagedSyncConfig）；
|
||
// 运行期以 meta 为准，meta 为空时回退到打包嵌入配置。
|
||
func (a *App) syncConfig() SyncConfig {
|
||
c := SyncConfig{BaseURL: strings.TrimRight(strings.TrimSpace(a.store.Meta("sync_base_url")), "/")}
|
||
if syncConfigComplete(c) {
|
||
return c
|
||
}
|
||
pkg := packagedSyncDefaults()
|
||
if syncConfigComplete(pkg) {
|
||
return pkg
|
||
}
|
||
return SyncConfig{}
|
||
}
|
||
|
||
// applyPackagedSyncConfig 启动时用打包配置覆盖本地 SQLite 中的 API 基址，
|
||
// 避免旧安装残留的 MySQL 连接 meta 继续生效。
|
||
func (a *App) applyPackagedSyncConfig() {
|
||
if a.store == nil {
|
||
return
|
||
}
|
||
pkg := packagedSyncDefaults()
|
||
if !syncConfigComplete(pkg) {
|
||
return
|
||
}
|
||
_ = a.store.SetMeta("sync_base_url", strings.TrimRight(strings.TrimSpace(pkg.BaseURL), "/"))
|
||
}
|
||
|
||
func syncConfigComplete(c SyncConfig) bool {
|
||
return strings.TrimSpace(c.BaseURL) != ""
|
||
}
|
||
|
||
func (a *App) GetSyncConfig() (SyncConfig, error) {
|
||
if e := a.ready(); e != nil {
|
||
return SyncConfig{}, e
|
||
}
|
||
return a.syncConfig(), nil
|
||
}
|
||
|
||
func (a *App) SaveSyncConfig(c SyncConfig) error {
|
||
if e := a.ready(); e != nil {
|
||
return e
|
||
}
|
||
u := strings.TrimRight(strings.TrimSpace(c.BaseURL), "/")
|
||
return a.store.SetMeta("sync_base_url", u)
|
||
}
|
||
|
||
func (a *App) syncUserID() int64 {
|
||
id, _ := strconv.ParseInt(a.store.Meta("sync_user_id"), 10, 64)
|
||
return id
|
||
}
|
||
|
||
func (a *App) GetSyncStatus() (SyncStatus, error) {
|
||
if e := a.ready(); e != nil {
|
||
return SyncStatus{}, e
|
||
}
|
||
a.syncMu.Lock()
|
||
lastErr := a.syncLastErr
|
||
a.syncMu.Unlock()
|
||
var pending int
|
||
_ = a.store.db.QueryRow(`SELECT (SELECT COUNT(*) FROM todos WHERE dirty=1)
|
||
+(SELECT COUNT(*) FROM tickets WHERE dirty=1)
|
||
+(SELECT COUNT(*) FROM notes WHERE dirty=1)`).Scan(&pending)
|
||
return SyncStatus{
|
||
Configured: syncConfigComplete(a.syncConfig()),
|
||
LoggedIn: a.syncUserID() > 0 && a.store.Meta("sync_access_token") != "",
|
||
UserID: a.syncUserID(),
|
||
Username: a.store.Meta("sync_username"),
|
||
LastSyncAt: a.store.Meta("sync_last_at"),
|
||
Syncing: a.syncing.Load(),
|
||
Online: a.syncOnline.Load(),
|
||
LastError: lastErr,
|
||
Pending: pending,
|
||
}, nil
|
||
}
|
||
|
||
// ---------- 注册 / 登录 / 登出 ----------
|
||
|
||
func validAccount(username, password string) error {
|
||
username = strings.TrimSpace(username)
|
||
if len(username) < 3 || len(username) > 64 {
|
||
return errors.New("SYNC_USERNAME_INVALID")
|
||
}
|
||
if len(password) < 6 {
|
||
return errors.New("SYNC_PASSWORD_TOO_SHORT")
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (a *App) SyncRegister(username, password string) error {
|
||
if e := a.ready(); e != nil {
|
||
return e
|
||
}
|
||
if e := validAccount(username, password); e != nil {
|
||
return e
|
||
}
|
||
if e := a.apiDecode(http.MethodPost, "/api/v1/auth/register", map[string]string{
|
||
"username": strings.TrimSpace(username),
|
||
"password": password,
|
||
}, nil, false); e != nil {
|
||
return e
|
||
}
|
||
a.ensureDefaultAvatar()
|
||
return nil
|
||
}
|
||
|
||
func (a *App) SyncLogin(username, password string) (SyncStatus, error) {
|
||
if e := a.ready(); e != nil {
|
||
return SyncStatus{}, e
|
||
}
|
||
username = strings.TrimSpace(username)
|
||
var out struct {
|
||
AccessToken string `json:"accessToken"`
|
||
RefreshToken string `json:"refreshToken"`
|
||
UserID int64 `json:"userId"`
|
||
Username string `json:"username"`
|
||
}
|
||
if e := a.apiDecode(http.MethodPost, "/api/v1/auth/login", map[string]string{
|
||
"username": username,
|
||
"password": password,
|
||
}, &out, false); e != nil {
|
||
return SyncStatus{}, e
|
||
}
|
||
if out.AccessToken == "" || out.UserID <= 0 {
|
||
return SyncStatus{}, errors.New("SYNC_BAD_CREDENTIALS")
|
||
}
|
||
id := out.UserID
|
||
if uname := strings.TrimSpace(out.Username); uname != "" {
|
||
username = uname
|
||
}
|
||
// 切换账号时重置拉取游标，并把本地数据整体标脏，合并进新账号。
|
||
if prev := a.store.Meta("sync_last_user_id"); prev != "" && prev != strconv.FormatInt(id, 10) {
|
||
for _, t := range []string{"todos", "tickets", "notes"} {
|
||
_ = a.store.SetMeta("sync_pull_"+t, "")
|
||
_, _ = a.store.db.Exec(`UPDATE ` + t + ` SET dirty=1`)
|
||
}
|
||
}
|
||
_ = a.store.SetMeta("sync_access_token", out.AccessToken)
|
||
_ = a.store.SetMeta("sync_refresh_token", out.RefreshToken)
|
||
_ = a.store.SetMeta("sync_user_id", strconv.FormatInt(id, 10))
|
||
_ = a.store.SetMeta("sync_last_user_id", strconv.FormatInt(id, 10))
|
||
_ = a.store.SetMeta("sync_username", username)
|
||
// 派生 API Key 加密密钥（可选功能，失败不阻断登录，只记录日志）。
|
||
if ee := a.ensureEncKey(password); ee != nil {
|
||
_ = a.store.SetMeta("sync_enc_key", "")
|
||
a.store.Log("warning", "同步", "API Key 加密密钥派生失败", ee.Error())
|
||
}
|
||
a.store.Log("info", "同步", "登录成功", username)
|
||
a.RefreshShell() // 原生账号菜单切换为已登录形态
|
||
go a.syncOnce(true)
|
||
return a.GetSyncStatus()
|
||
}
|
||
|
||
// SyncChangePassword 在线修改登录密码。加密密钥由密码派生，因此会同步轮换：
|
||
// 先调 API 改密，再用 HTTP 读写 settings 把 api_keys 密文换成新密钥。
|
||
// 其他已登录设备的旧密钥会失效，需用新密码重新登录。
|
||
func (a *App) SyncChangePassword(oldPassword, newPassword string) error {
|
||
if e := a.ready(); e != nil {
|
||
return e
|
||
}
|
||
userID := a.syncUserID()
|
||
if userID <= 0 {
|
||
return errors.New("SYNC_NOT_LOGGED_IN")
|
||
}
|
||
if len(newPassword) < 6 {
|
||
return errors.New("SYNC_PASSWORD_TOO_SHORT")
|
||
}
|
||
if a.store.Meta("sync_access_token") == "" {
|
||
return errors.New("SYNC_NOT_LOGGED_IN")
|
||
}
|
||
if e := a.apiDecode(http.MethodPost, "/api/v1/auth/change-password", map[string]string{
|
||
"oldPassword": oldPassword,
|
||
"newPassword": newPassword,
|
||
}, nil, true); e != nil {
|
||
return e
|
||
}
|
||
// 盐保持不变，新密码 + 原盐派生新密钥；缺盐（从未用过加密同步）时跳过密钥轮换。
|
||
var newKey []byte
|
||
saltVal, _, saltOK, se := a.apiGetSetting("enc_salt")
|
||
if se != nil {
|
||
return se
|
||
}
|
||
if saltOK {
|
||
if raw, de := hex.DecodeString(strings.TrimSpace(saltVal)); de == nil && len(raw) >= 8 {
|
||
newKey = deriveEncKey(newPassword, raw)
|
||
}
|
||
}
|
||
if newKey != nil {
|
||
blob, _, hasKeys, be := a.apiGetSetting("api_keys")
|
||
if be != nil {
|
||
return be
|
||
}
|
||
if hasKeys {
|
||
plain, de := "", errors.New("SYNC_DECRYPT_FAILED")
|
||
fromRemote := false
|
||
if old := a.encKey(); old != nil {
|
||
plain, de = decryptWithKey(old, blob)
|
||
fromRemote = de == nil
|
||
}
|
||
if de != nil {
|
||
// 旧密钥不可用时用本地明文 Key 重建密文；本地也没有就删除该行（写空并新时间戳无意义，跳过 PUT）。
|
||
if st, le := a.store.Settings(); le == nil && (st.SparkKey != "" || st.DeepSeekKey != "") {
|
||
b, _ := json.Marshal(map[string]string{"sparkKey": st.SparkKey, "deepSeekKey": st.DeepSeekKey})
|
||
plain, de = string(b), nil
|
||
}
|
||
}
|
||
switch {
|
||
case de == nil && fromRemote:
|
||
enc, ee := encryptWithKey(newKey, plain)
|
||
if ee != nil {
|
||
return ee
|
||
}
|
||
// 内容未变只换密文：保留原时间戳，LWW 语义完全不受影响。
|
||
_, at, _, _ := a.apiGetSetting("api_keys")
|
||
if at == "" {
|
||
at = nowRFC()
|
||
}
|
||
if e := a.apiPutSetting("api_keys", enc, at); e != nil {
|
||
return e
|
||
}
|
||
case de == nil:
|
||
enc, ee := encryptWithKey(newKey, plain)
|
||
if ee != nil {
|
||
return ee
|
||
}
|
||
if e := a.apiPutSetting("api_keys", enc, nowRFC()); e != nil {
|
||
return e
|
||
}
|
||
default:
|
||
// 无法解密也无法本地重建：用空值覆盖，避免旧密文永久卡死。
|
||
if e := a.apiPutSetting("api_keys", "", nowRFC()); e != nil {
|
||
return e
|
||
}
|
||
}
|
||
}
|
||
_ = a.store.SetMeta("sync_enc_key", hex.EncodeToString(newKey))
|
||
} else {
|
||
_ = a.store.SetMeta("sync_enc_key", "")
|
||
}
|
||
a.store.Log("info", "同步", "密码修改成功", a.store.Meta("sync_username"))
|
||
return nil
|
||
}
|
||
|
||
func (a *App) SyncLogout() error {
|
||
if e := a.ready(); e != nil {
|
||
return e
|
||
}
|
||
_ = a.store.SetMeta("sync_user_id", "")
|
||
_ = a.store.SetMeta("sync_username", "")
|
||
_ = a.store.SetMeta("sync_enc_key", "")
|
||
_ = a.store.SetMeta("sync_access_token", "")
|
||
_ = a.store.SetMeta("sync_refresh_token", "")
|
||
a.syncOnline.Store(false)
|
||
a.RefreshShell() // 原生账号菜单切换为未登录形态
|
||
return nil
|
||
}
|
||
|
||
// ---------- 同步引擎 ----------
|
||
|
||
// SyncNow 手动触发一次同步，同步完成后返回最新状态。
|
||
func (a *App) SyncNow() (SyncStatus, error) {
|
||
if e := a.ready(); e != nil {
|
||
return SyncStatus{}, e
|
||
}
|
||
if a.syncUserID() <= 0 {
|
||
return SyncStatus{}, errors.New("SYNC_NOT_LOGGED_IN")
|
||
}
|
||
pushed, pulled, e := a.syncOnce(false)
|
||
st, _ := a.GetSyncStatus()
|
||
st.Pushed, st.Pulled = pushed, pulled
|
||
if e != nil {
|
||
return st, e
|
||
}
|
||
return st, nil
|
||
}
|
||
|
||
// runSyncLoop 启动时立即尝试同步一次（在线优先），失败自动降级为本地模式；
|
||
// 之后每 5 分钟巡检：连接成功即视为在线，失败静默跳过（断网恢复后自然补同步）。
|
||
func (a *App) runSyncLoop() {
|
||
if a.bootstrap.State == BootstrapReady && a.syncUserID() > 0 {
|
||
_, _, _ = a.syncOnce(true)
|
||
}
|
||
t := time.NewTicker(5 * time.Minute)
|
||
defer t.Stop()
|
||
for {
|
||
select {
|
||
case <-a.ctx.Done():
|
||
return
|
||
case <-t.C:
|
||
if a.bootstrap.State == BootstrapReady && a.syncUserID() > 0 {
|
||
_, _, _ = a.syncOnce(true)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// syncOnce 执行一轮推送+拉取。silent 模式下网络错误不写消息中心。
|
||
func (a *App) syncOnce(silent bool) (pushed, pulled int, err error) {
|
||
if !a.syncing.CompareAndSwap(false, true) {
|
||
return 0, 0, errors.New("SYNC_IN_PROGRESS")
|
||
}
|
||
defer a.syncing.Store(false)
|
||
userID := a.syncUserID()
|
||
if userID <= 0 || a.store.Meta("sync_access_token") == "" {
|
||
return 0, 0, errors.New("SYNC_NOT_LOGGED_IN")
|
||
}
|
||
if !syncConfigComplete(a.syncConfig()) {
|
||
a.syncOnline.Store(false)
|
||
e := errors.New("SYNC_NOT_CONFIGURED")
|
||
a.setSyncErr(e.Error())
|
||
a.emitSyncDone()
|
||
return 0, 0, e
|
||
}
|
||
wasOnline := a.syncOnline.Load()
|
||
|
||
for _, t := range []syncTable{todoSync, ticketSync, noteSync} {
|
||
p, e := a.pushTable(t)
|
||
if e != nil {
|
||
a.syncOnline.Store(false)
|
||
a.setSyncErr(e.Error())
|
||
if !silent {
|
||
a.pushMessage("sync", a.syncText("fail"), e.Error(), "", 0, false)
|
||
}
|
||
a.emitSyncDone()
|
||
return pushed, pulled, e
|
||
}
|
||
pushed += p
|
||
g, e := a.pullTable(t)
|
||
if e != nil {
|
||
a.syncOnline.Store(false)
|
||
a.setSyncErr(e.Error())
|
||
if !silent {
|
||
a.pushMessage("sync", a.syncText("fail"), e.Error(), "", 0, false)
|
||
}
|
||
a.emitSyncDone()
|
||
return pushed, pulled, e
|
||
}
|
||
pulled += g
|
||
}
|
||
a.syncOnline.Store(true)
|
||
|
||
// API Key 加密同步（设置里开启后才执行）。
|
||
if st, se := a.store.Settings(); se == nil && st.SyncAPIKeys {
|
||
kp, kg, ke := a.syncAPIKeys(st)
|
||
if ke != nil {
|
||
a.setSyncErr(ke.Error())
|
||
a.emitSyncDone()
|
||
return pushed, pulled, ke
|
||
}
|
||
pushed += kp
|
||
pulled += kg
|
||
}
|
||
if ap, ag, ae := a.syncAvatar(); ae != nil {
|
||
a.setSyncErr(ae.Error())
|
||
a.emitSyncDone()
|
||
return pushed, pulled, ae
|
||
} else {
|
||
pushed += ap
|
||
pulled += ag
|
||
}
|
||
// paths:<machineID> 行先于身份文档处理：本机路径先落库，身份合并后待绑定清单才准确。
|
||
for _, d := range []struct {
|
||
name string
|
||
gen func() (string, error)
|
||
apply func(string) error
|
||
}{
|
||
{"paths:" + a.machineID(), a.machinePathsDoc, a.applyMachinePaths},
|
||
{"projects", a.projectsDoc, a.applyProjectsDoc},
|
||
{"rules", a.rulesDoc, a.applyRulesDoc},
|
||
} {
|
||
dp, dg, de := a.syncDoc(d.name, d.gen, d.apply)
|
||
if de != nil {
|
||
a.setSyncErr(de.Error())
|
||
a.emitSyncDone()
|
||
return pushed, pulled, de
|
||
}
|
||
pushed += dp
|
||
pulled += dg
|
||
}
|
||
if fp, fg, fe := a.syncFestivalImages(); fe != nil {
|
||
a.setSyncErr(fe.Error())
|
||
a.emitSyncDone()
|
||
return pushed, pulled, fe
|
||
} else {
|
||
pushed += fp
|
||
pulled += fg
|
||
}
|
||
if sp, sg, se := a.syncFileStorageConfig(); se != nil {
|
||
a.setSyncErr(se.Error())
|
||
a.emitSyncDone()
|
||
return pushed, pulled, se
|
||
} else {
|
||
pushed += sp
|
||
pulled += sg
|
||
}
|
||
a.syncUserProfile()
|
||
pulled += a.pullTeamNotices()
|
||
a.refreshTeamAssignedCache()
|
||
_ = a.store.SetMeta("sync_last_at", nowRFC())
|
||
a.setSyncErr("")
|
||
if pushed > 0 || pulled > 0 || !wasOnline {
|
||
a.store.Log("info", "同步", "同步完成", fmt.Sprintf("推送 %d 条 | 拉取 %d 条", pushed, pulled))
|
||
if pushed > 0 || pulled > 0 {
|
||
a.pushMessage("sync", a.syncText("done"), fmt.Sprintf(a.syncText("body"), pushed, pulled), "", 0, false)
|
||
}
|
||
}
|
||
a.emitSyncDone()
|
||
return pushed, pulled, nil
|
||
}
|
||
|
||
func (a *App) setSyncErr(v string) {
|
||
a.syncMu.Lock()
|
||
a.syncLastErr = v
|
||
a.syncMu.Unlock()
|
||
}
|
||
|
||
func (a *App) emitSyncDone() {
|
||
if st, e := a.GetSyncStatus(); e == nil {
|
||
a.emit("sync:done", st)
|
||
}
|
||
a.RefreshTrayStatus()
|
||
}
|
||
|
||
func (a *App) syncText(k string) string {
|
||
locale := "zh-CN"
|
||
if st, e := a.store.Settings(); e == nil {
|
||
locale = st.Locale
|
||
}
|
||
if locale == "en" {
|
||
return map[string]string{"done": "Sync finished", "fail": "Sync failed", "body": "pushed %d, pulled %d"}[k]
|
||
}
|
||
return map[string]string{"done": "同步完成", "fail": "同步失败", "body": "推送 %d 条，拉取 %d 条"}[k]
|
||
}
|
||
|
||
// ---------- API Key 加密同步（可选） ----------
|
||
|
||
// ensureEncKey 登录时从远端取（或初始化）每用户加密盐，用登录密码派生 AES 密钥并缓存到本地。
|
||
func (a *App) ensureEncKey(password string) error {
|
||
salt, _, ok, e := a.apiGetSetting("enc_salt")
|
||
if e != nil {
|
||
return e
|
||
}
|
||
if !ok {
|
||
if salt, e = newSaltHex(); e != nil {
|
||
return e
|
||
}
|
||
if e = a.apiPutSetting("enc_salt", salt, nowRFC()); e != nil {
|
||
return e
|
||
}
|
||
// 并发写入时以真正落库的盐为准。
|
||
salt, _, ok, e = a.apiGetSetting("enc_salt")
|
||
if e != nil {
|
||
return e
|
||
}
|
||
if !ok {
|
||
return errors.New("SYNC_DECRYPT_FAILED")
|
||
}
|
||
}
|
||
raw, e := hex.DecodeString(strings.TrimSpace(salt))
|
||
if e != nil || len(raw) < 8 {
|
||
return errors.New("SYNC_DECRYPT_FAILED")
|
||
}
|
||
return a.store.SetMeta("sync_enc_key", hex.EncodeToString(deriveEncKey(password, raw)))
|
||
}
|
||
|
||
// encKey 返回本地缓存的加密密钥；未登录或未派生成功时为 nil。
|
||
func (a *App) encKey() []byte {
|
||
raw, e := hex.DecodeString(a.store.Meta("sync_enc_key"))
|
||
if e != nil || len(raw) != 32 {
|
||
return nil
|
||
}
|
||
return raw
|
||
}
|
||
|
||
// syncAPIKeys 双向同步加密后的 AI API Key（单行 JSON 载荷，LWW 按 RFC3339 时间戳判定）。
|
||
func (a *App) syncAPIKeys(st AppSettings) (pushed, pulled int, err error) {
|
||
key := a.encKey()
|
||
if key == nil {
|
||
return 0, 0, errors.New("SYNC_DECRYPT_FAILED")
|
||
}
|
||
localAt := a.store.Meta("api_keys_updated_at")
|
||
if localAt == "" && (st.SparkKey != "" || st.DeepSeekKey != "") {
|
||
localAt = nowRFC()
|
||
_ = a.store.SetMeta("api_keys_updated_at", localAt)
|
||
}
|
||
remoteVal, remoteAt, hasRemote, e := a.apiGetSetting("api_keys")
|
||
if e != nil {
|
||
return 0, 0, e
|
||
}
|
||
switch {
|
||
case localAt != "" && (!hasRemote || localAt > remoteAt):
|
||
payload, e := json.Marshal(map[string]string{"sparkKey": st.SparkKey, "deepSeekKey": st.DeepSeekKey})
|
||
if e != nil {
|
||
return 0, 0, e
|
||
}
|
||
enc, e := encryptWithKey(key, string(payload))
|
||
if e != nil {
|
||
return 0, 0, e
|
||
}
|
||
if e = a.apiPutSetting("api_keys", enc, localAt); e != nil {
|
||
return 0, 0, e
|
||
}
|
||
pushed = 1
|
||
case hasRemote && remoteAt > localAt:
|
||
plain, e := decryptWithKey(key, remoteVal)
|
||
if e != nil {
|
||
return 0, 0, errors.New("SYNC_DECRYPT_FAILED")
|
||
}
|
||
var m map[string]string
|
||
if e := json.Unmarshal([]byte(plain), &m); e != nil {
|
||
return 0, 0, errors.New("SYNC_DECRYPT_FAILED")
|
||
}
|
||
if m["sparkKey"] != st.SparkKey || m["deepSeekKey"] != st.DeepSeekKey {
|
||
st.SparkKey, st.DeepSeekKey = m["sparkKey"], m["deepSeekKey"]
|
||
if e := a.store.SaveSettings(st); e != nil {
|
||
return 0, 0, e
|
||
}
|
||
}
|
||
_ = a.store.SetMeta("api_keys_updated_at", remoteAt)
|
||
pulled = 1
|
||
}
|
||
return pushed, pulled, nil
|
||
}
|
||
|
||
// syncAvatar 同步头像（settings name='avatar'，明文 JSON {mode,value}，LWW）。
|
||
// path 模式是设备本地行为：既不推送，也不参与拉取覆盖。
|
||
func (a *App) syncAvatar() (pushed, pulled int, err error) {
|
||
st, e := a.store.Settings()
|
||
if e != nil {
|
||
return 0, 0, e
|
||
}
|
||
if st.AvatarMode == "path" {
|
||
return 0, 0, nil
|
||
}
|
||
localAt := a.store.Meta("avatar_updated_at")
|
||
if localAt == "" && st.AvatarMode != "" {
|
||
localAt = nowRFC()
|
||
_ = a.store.SetMeta("avatar_updated_at", localAt)
|
||
}
|
||
remoteVal, remoteAt, hasRemote, e := a.apiGetSetting("avatar")
|
||
if e != nil {
|
||
return 0, 0, e
|
||
}
|
||
switch {
|
||
case localAt != "" && (!hasRemote || localAt > remoteAt):
|
||
payload, e := json.Marshal(map[string]string{"mode": st.AvatarMode, "value": st.AvatarValue})
|
||
if e != nil {
|
||
return 0, 0, e
|
||
}
|
||
if e = a.apiPutSetting("avatar", string(payload), localAt); e != nil {
|
||
return 0, 0, e
|
||
}
|
||
pushed = 1
|
||
case hasRemote && remoteAt > localAt:
|
||
var m map[string]string
|
||
if json.Unmarshal([]byte(remoteVal), &m) != nil {
|
||
return 0, 0, nil
|
||
}
|
||
mode := m["mode"]
|
||
if mode != "" && mode != "base64" && mode != "url" {
|
||
return 0, 0, nil
|
||
}
|
||
if mode != st.AvatarMode || m["value"] != st.AvatarValue {
|
||
st.AvatarMode, st.AvatarValue = mode, m["value"]
|
||
if e := a.store.SaveSettings(st); e != nil {
|
||
return 0, 0, e
|
||
}
|
||
}
|
||
_ = a.store.SetMeta("avatar_updated_at", remoteAt)
|
||
pulled = 1
|
||
}
|
||
return pushed, pulled, nil
|
||
}
|
||
|
||
// ---------- 项目/分组/收藏/排除规则文档同步 ----------
|
||
|
||
type projectDocEntry struct {
|
||
Name string `json:"name"`
|
||
Path string `json:"path,omitempty"`
|
||
Description string `json:"description,omitempty"`
|
||
Group string `json:"group,omitempty"`
|
||
Favorite bool `json:"favorite,omitempty"`
|
||
}
|
||
|
||
type ruleDocEntry struct {
|
||
Pattern string `json:"pattern"`
|
||
Category string `json:"category"`
|
||
}
|
||
|
||
func (a *App) projectsDoc() (string, error) {
|
||
rows, e := a.store.db.Query(`SELECT p.name,p.description,COALESCE(g.name,''),
|
||
EXISTS(SELECT 1 FROM favorites f WHERE f.project_id=p.id)
|
||
FROM projects p LEFT JOIN project_groups g ON g.id=p.group_id ORDER BY p.name`)
|
||
if e != nil {
|
||
return "", e
|
||
}
|
||
defer rows.Close()
|
||
list := []projectDocEntry{}
|
||
for rows.Next() {
|
||
var it projectDocEntry
|
||
if e := rows.Scan(&it.Name, &it.Description, &it.Group, &it.Favorite); e != nil {
|
||
return "", e
|
||
}
|
||
list = append(list, it)
|
||
}
|
||
b, e := json.Marshal(list)
|
||
return string(b), e
|
||
}
|
||
|
||
func (a *App) ensureGroupID(group string) (int64, error) {
|
||
gid := int64(1)
|
||
g := strings.TrimSpace(group)
|
||
if g == "" {
|
||
return gid, nil
|
||
}
|
||
e := a.store.db.QueryRow(`SELECT id FROM project_groups WHERE name=?`, g).Scan(&gid)
|
||
if e == sql.ErrNoRows {
|
||
now := nowRFC()
|
||
r, e2 := a.store.db.Exec(`INSERT INTO project_groups(name,created_at,updated_at) VALUES(?,?,?)`, g, now, now)
|
||
if e2 != nil {
|
||
return 0, e2
|
||
}
|
||
gid, _ = r.LastInsertId()
|
||
return gid, nil
|
||
}
|
||
return gid, e
|
||
}
|
||
|
||
func (a *App) applyProjectsDoc(doc string) error {
|
||
var list []projectDocEntry
|
||
if json.Unmarshal([]byte(doc), &list) != nil {
|
||
return nil
|
||
}
|
||
for _, it := range list {
|
||
name := strings.TrimSpace(it.Name)
|
||
if name == "" {
|
||
if p := strings.TrimSpace(it.Path); p != "" {
|
||
name = filepath.Base(p)
|
||
} else {
|
||
continue
|
||
}
|
||
}
|
||
gid, e := a.ensureGroupID(it.Group)
|
||
if e != nil {
|
||
return e
|
||
}
|
||
var pid int64
|
||
e = a.store.db.QueryRow(`SELECT id FROM projects WHERE name=? LIMIT 1`, name).Scan(&pid)
|
||
if e == sql.ErrNoRows {
|
||
if p := strings.TrimSpace(it.Path); p != "" {
|
||
e = a.store.db.QueryRow(`SELECT id FROM projects WHERE path=? LIMIT 1`, p).Scan(&pid)
|
||
}
|
||
}
|
||
switch {
|
||
case e == sql.ErrNoRows:
|
||
continue
|
||
case e != nil:
|
||
return e
|
||
}
|
||
if _, e := a.store.db.Exec(`UPDATE projects SET name=?,description=?,group_id=?,updated_at=? WHERE id=? AND (name!=? OR description!=? OR group_id!=?)`,
|
||
name, it.Description, gid, nowRFC(), pid, name, it.Description, gid); e != nil {
|
||
return e
|
||
}
|
||
if it.Favorite {
|
||
_, _ = a.store.db.Exec(`INSERT OR IGNORE INTO favorites(project_id,created_at) VALUES(?,?)`, pid, nowRFC())
|
||
} else {
|
||
_, _ = a.store.db.Exec(`DELETE FROM favorites WHERE project_id=?`, pid)
|
||
}
|
||
}
|
||
a.rebuildCloudPending(list)
|
||
return nil
|
||
}
|
||
|
||
func (a *App) rulesDoc() (string, error) {
|
||
rows, e := a.store.db.Query(`SELECT pattern,category FROM exclusion_rules WHERE builtin=0 ORDER BY pattern`)
|
||
if e != nil {
|
||
return "", e
|
||
}
|
||
defer rows.Close()
|
||
list := []ruleDocEntry{}
|
||
for rows.Next() {
|
||
var it ruleDocEntry
|
||
if e := rows.Scan(&it.Pattern, &it.Category); e != nil {
|
||
return "", e
|
||
}
|
||
list = append(list, it)
|
||
}
|
||
b, e := json.Marshal(list)
|
||
return string(b), e
|
||
}
|
||
|
||
func (a *App) applyRulesDoc(doc string) error {
|
||
var list []ruleDocEntry
|
||
if json.Unmarshal([]byte(doc), &list) != nil {
|
||
return nil
|
||
}
|
||
tx, e := a.store.db.Begin()
|
||
if e != nil {
|
||
return e
|
||
}
|
||
defer tx.Rollback()
|
||
if _, e := tx.Exec(`DELETE FROM exclusion_rules WHERE builtin=0`); e != nil {
|
||
return e
|
||
}
|
||
for _, it := range list {
|
||
p := strings.TrimSpace(it.Pattern)
|
||
if p == "" {
|
||
continue
|
||
}
|
||
c := it.Category
|
||
if c == "" {
|
||
c = "custom"
|
||
}
|
||
if _, e := tx.Exec(`INSERT OR IGNORE INTO exclusion_rules(pattern,category,builtin) VALUES(?,?,0)`, p, c); e != nil {
|
||
return e
|
||
}
|
||
}
|
||
return tx.Commit()
|
||
}
|
||
|
||
// syncDoc 单个文档行的双向同步：远端较新先套用合并，本地与远端内容不一致再回推。
|
||
func (a *App) syncDoc(name string, gen func() (string, error), apply func(string) error) (pushed, pulled int, err error) {
|
||
doc, e := gen()
|
||
if e != nil {
|
||
return 0, 0, e
|
||
}
|
||
remoteVal, remoteAt, hasRemote, e := a.apiGetSetting(name)
|
||
if e != nil {
|
||
return 0, 0, e
|
||
}
|
||
metaKey := "sync_doc_" + name + "_at"
|
||
lastAt := a.store.Meta(metaKey)
|
||
if hasRemote && remoteAt > lastAt {
|
||
if e := apply(remoteVal); e != nil {
|
||
return 0, 0, e
|
||
}
|
||
if doc, e = gen(); e != nil {
|
||
return 0, 0, e
|
||
}
|
||
lastAt = remoteAt
|
||
pulled = 1
|
||
}
|
||
if (hasRemote && doc != remoteVal) || (!hasRemote && doc != "[]" && doc != "{}") {
|
||
now := nowRFC()
|
||
if e = a.apiPutSetting(name, doc, now); e != nil {
|
||
return 0, 0, e
|
||
}
|
||
lastAt = now
|
||
pushed = 1
|
||
}
|
||
if lastAt != "" {
|
||
_ = a.store.SetMeta(metaKey, lastAt)
|
||
}
|
||
return pushed, pulled, nil
|
||
}
|
||
|
||
// syncFestivalImages 同步节日背景图：云端键 fest_img:<节日名>。
|
||
// 管理员推送本地 dirty 行；所有账号拉取（API 会从管理员名下读全局前缀）。
|
||
func (a *App) syncFestivalImages() (pushed, pulled int, err error) {
|
||
const prefix = "fest_img:"
|
||
if a.syncUserID() == festivalAdminID {
|
||
rows, e := a.store.db.Query(`SELECT fest_key,value,updated_at FROM festival_images WHERE dirty=1`)
|
||
if e != nil {
|
||
return 0, 0, e
|
||
}
|
||
type rec struct{ k, v, at string }
|
||
recs := []rec{}
|
||
for rows.Next() {
|
||
var r rec
|
||
if e := rows.Scan(&r.k, &r.v, &r.at); e != nil {
|
||
rows.Close()
|
||
return 0, 0, e
|
||
}
|
||
recs = append(recs, r)
|
||
}
|
||
rows.Close()
|
||
for _, r := range recs {
|
||
if e := a.apiPutSettingWithStepUp(prefix+r.k, r.v, r.at, true); e != nil {
|
||
// 无动态码时跳过推送，保留 dirty，待管理员验证后再同步
|
||
if e.Error() == "ADMIN_STEPUP_REQUIRED" || e.Error() == "ADMIN_IP_CHANGED" {
|
||
continue
|
||
}
|
||
return pushed, pulled, e
|
||
}
|
||
if _, e := a.store.db.Exec(`UPDATE festival_images SET dirty=0 WHERE fest_key=? AND updated_at=?`, r.k, r.at); e != nil {
|
||
return pushed, pulled, e
|
||
}
|
||
pushed++
|
||
}
|
||
}
|
||
items, e := a.apiListSettings(prefix)
|
||
if e != nil {
|
||
return pushed, pulled, e
|
||
}
|
||
cursor := a.store.Meta("sync_pull_fest_imgs")
|
||
maxSeen := cursor
|
||
for _, it := range items {
|
||
at := it.UpdatedAt
|
||
if at <= cursor {
|
||
continue
|
||
}
|
||
if at > maxSeen {
|
||
maxSeen = at
|
||
}
|
||
key := strings.TrimPrefix(it.Name, prefix)
|
||
var localAt string
|
||
ge := a.store.db.QueryRow(`SELECT updated_at FROM festival_images WHERE fest_key=?`, key).Scan(&localAt)
|
||
if ge == nil && localAt >= at {
|
||
continue
|
||
}
|
||
if _, e := a.store.db.Exec(`INSERT INTO festival_images(fest_key,value,updated_at,dirty) VALUES(?,?,?,0)
|
||
ON CONFLICT(fest_key) DO UPDATE SET value=excluded.value,updated_at=excluded.updated_at,dirty=0`, key, it.Value, at); e != nil {
|
||
return pushed, pulled, e
|
||
}
|
||
pulled++
|
||
}
|
||
if maxSeen != cursor {
|
||
_ = a.store.SetMeta("sync_pull_fest_imgs", maxSeen)
|
||
}
|
||
return pushed, pulled, nil
|
||
}
|
||
|
||
// syncFileStorageConfig 同步全局文件存储配置（settings name='file_storage'）。
|
||
func (a *App) syncFileStorageConfig() (pushed, pulled int, err error) {
|
||
localAt := a.store.Meta(fileStorageAtKey)
|
||
remoteVal, remoteAt, hasRemote, e := a.apiGetGlobalSetting(fileStorageKey)
|
||
if e != nil {
|
||
return 0, 0, e
|
||
}
|
||
switch {
|
||
case a.syncUserID() == festivalAdminID && localAt != "" && (!hasRemote || localAt > remoteAt):
|
||
b, e := json.Marshal(a.fileStorageConfig())
|
||
if e != nil {
|
||
return 0, 0, e
|
||
}
|
||
if e = a.apiPutSettingWithStepUp(fileStorageKey, string(b), localAt, true); e != nil {
|
||
if e.Error() == "ADMIN_STEPUP_REQUIRED" || e.Error() == "ADMIN_IP_CHANGED" {
|
||
return 0, 0, nil
|
||
}
|
||
return 0, 0, e
|
||
}
|
||
pushed = 1
|
||
case hasRemote && remoteAt > localAt:
|
||
var c FileStorageConfig
|
||
if json.Unmarshal([]byte(remoteVal), &c) != nil {
|
||
return 0, 0, nil
|
||
}
|
||
b, e := json.Marshal(normalizeFileStorage(c))
|
||
if e != nil {
|
||
return 0, 0, e
|
||
}
|
||
if e := a.store.SetMeta(fileStorageKey, string(b)); e != nil {
|
||
return 0, 0, e
|
||
}
|
||
_ = a.store.SetMeta(fileStorageAtKey, remoteAt)
|
||
pulled = 1
|
||
}
|
||
return pushed, pulled, nil
|
||
}
|
||
|
||
// syncTable 描述一张可同步表的本地列映射。
|
||
type syncTable struct {
|
||
local string
|
||
// localCols 顺序即 scan 顺序；project_id 与 project_name 的转换单独处理。
|
||
hasProject bool
|
||
hasTimes bool // 有 created_at（notes 没有）
|
||
extraCols []string
|
||
}
|
||
|
||
var (
|
||
todoSync = syncTable{local: "todos", hasProject: true, hasTimes: true, extraCols: []string{"title", "content", "due_at", "priority", "status", "history", "team_id"}}
|
||
ticketSync = syncTable{local: "tickets", hasProject: true, hasTimes: true, extraCols: []string{"title", "description", "type", "start_at", "due_at", "status", "priority", "history", "team_id"}}
|
||
noteSync = syncTable{local: "notes", extraCols: []string{"content"}}
|
||
)
|
||
|
||
// pushTable 收集本地 dirty 行，POST /sync/push 后清 dirty。
|
||
func (a *App) pushTable(t syncTable) (int, error) {
|
||
cols := append([]string{"uuid"}, t.extraCols...)
|
||
if t.hasProject {
|
||
cols = append(cols, "project_id")
|
||
}
|
||
if t.hasTimes {
|
||
cols = append(cols, "created_at")
|
||
}
|
||
cols = append(cols, "updated_at", "deleted")
|
||
rows, e := a.store.db.Query(`SELECT ` + strings.Join(cols, ",") + ` FROM ` + t.local + ` WHERE dirty=1`)
|
||
if e != nil {
|
||
return 0, e
|
||
}
|
||
type rec struct {
|
||
vals []any
|
||
uuid string
|
||
}
|
||
recs := []rec{}
|
||
for rows.Next() {
|
||
vals := make([]any, len(cols))
|
||
ptrs := make([]any, len(cols))
|
||
for i := range vals {
|
||
ptrs[i] = &vals[i]
|
||
}
|
||
if e := rows.Scan(ptrs...); e != nil {
|
||
rows.Close()
|
||
return 0, e
|
||
}
|
||
recs = append(recs, rec{vals: vals, uuid: asString(vals[0])})
|
||
}
|
||
rows.Close()
|
||
if len(recs) == 0 {
|
||
return 0, nil
|
||
}
|
||
|
||
payload := make([]map[string]any, 0, len(recs))
|
||
uuids := make([]string, 0, len(recs))
|
||
for _, r := range recs {
|
||
m := map[string]any{}
|
||
for i, c := range cols {
|
||
if c == "project_id" {
|
||
m["project_name"] = a.projectNameByID(asInt64(r.vals[i]))
|
||
continue
|
||
}
|
||
if c == "deleted" || c == "team_id" {
|
||
m[c] = asInt64(r.vals[i])
|
||
continue
|
||
}
|
||
m[c] = asString(r.vals[i])
|
||
}
|
||
payload = append(payload, m)
|
||
uuids = append(uuids, r.uuid)
|
||
}
|
||
var resp struct {
|
||
Pushed int `json:"pushed"`
|
||
}
|
||
if e := a.apiDecode(http.MethodPost, "/api/v1/sync/push", map[string]any{
|
||
"table": t.local,
|
||
"rows": payload,
|
||
}, &resp, true); e != nil {
|
||
return 0, e
|
||
}
|
||
for _, u := range uuids {
|
||
if _, e := a.store.db.Exec(`UPDATE `+t.local+` SET dirty=0 WHERE uuid=? AND dirty=1`, u); e != nil {
|
||
return 0, e
|
||
}
|
||
}
|
||
return len(uuids), nil
|
||
}
|
||
|
||
// pullTable 增量拉取远端更新（LWW：远端 updated_at 更新才覆盖本地）。
|
||
func (a *App) pullTable(t syncTable) (int, error) {
|
||
cursorKey := "sync_pull_" + t.local
|
||
cursor := a.store.Meta(cursorKey)
|
||
q := "/api/v1/sync/pull?table=" + url.QueryEscape(t.local) + "&cursor=" + url.QueryEscape(cursor)
|
||
var resp struct {
|
||
Rows []map[string]any `json:"rows"`
|
||
}
|
||
if e := a.apiDecode(http.MethodGet, q, nil, &resp, true); e != nil {
|
||
return 0, e
|
||
}
|
||
n, maxSeen := 0, cursor
|
||
for _, m := range resp.Rows {
|
||
updated := asString(m["updated_at"])
|
||
if updated > maxSeen {
|
||
maxSeen = updated
|
||
}
|
||
applied, e := a.applyRemoteRow(t, m)
|
||
if e != nil {
|
||
return n, e
|
||
}
|
||
if applied {
|
||
n++
|
||
}
|
||
}
|
||
if maxSeen != cursor {
|
||
_ = a.store.SetMeta(cursorKey, maxSeen)
|
||
}
|
||
return n, nil
|
||
}
|
||
|
||
// applyRemoteRow 将一条远端行按 LWW 合并进本地表。
|
||
func (a *App) applyRemoteRow(t syncTable, m map[string]any) (bool, error) {
|
||
uuid := asString(m["uuid"])
|
||
var localID int64
|
||
var localUpdated string
|
||
e := a.store.db.QueryRow(`SELECT id,updated_at FROM `+t.local+` WHERE uuid=?`, uuid).Scan(&localID, &localUpdated)
|
||
exists := e == nil
|
||
remoteUpdated := asString(m["updated_at"])
|
||
if exists && remoteUpdated <= localUpdated {
|
||
return false, nil
|
||
}
|
||
deleted := asInt64(m["deleted"])
|
||
switch t.local {
|
||
case "todos":
|
||
pid := a.projectIDByName(asString(m["project_name"]))
|
||
if exists {
|
||
_, e = a.store.db.Exec(`UPDATE todos SET title=?,content=?,project_id=?,due_at=?,priority=?,status=?,history=?,team_id=?,reminded=0,updated_at=?,deleted=?,dirty=0 WHERE id=?`,
|
||
asString(m["title"]), asString(m["content"]), pid, asString(m["due_at"]), asString(m["priority"]), asString(m["status"]), asString(m["history"]), asInt64(m["team_id"]), remoteUpdated, deleted, localID)
|
||
} else {
|
||
_, e = a.store.db.Exec(`INSERT INTO todos(uuid,title,content,project_id,due_at,priority,status,history,team_id,reminded,created_at,updated_at,deleted,dirty) VALUES(?,?,?,?,?,?,?,?,?,0,?,?,?,0)`,
|
||
uuid, asString(m["title"]), asString(m["content"]), pid, asString(m["due_at"]), asString(m["priority"]), asString(m["status"]), asString(m["history"]), asInt64(m["team_id"]), asString(m["created_at"]), remoteUpdated, deleted)
|
||
}
|
||
case "tickets":
|
||
pid := a.projectIDByName(asString(m["project_name"]))
|
||
if exists {
|
||
_, e = a.store.db.Exec(`UPDATE tickets SET title=?,description=?,type=?,project_id=?,start_at=?,due_at=?,status=?,priority=?,history=?,team_id=?,reminded=0,updated_at=?,deleted=?,dirty=0 WHERE id=?`,
|
||
asString(m["title"]), asString(m["description"]), asString(m["type"]), pid, asString(m["start_at"]), asString(m["due_at"]), asString(m["status"]), asString(m["priority"]), asString(m["history"]), asInt64(m["team_id"]), remoteUpdated, deleted, localID)
|
||
} else {
|
||
_, e = a.store.db.Exec(`INSERT INTO tickets(uuid,title,description,type,project_id,start_at,due_at,status,priority,history,team_id,reminded,created_at,updated_at,deleted,dirty) VALUES(?,?,?,?,?,?,?,?,?,?,?,0,?,?,?,0)`,
|
||
uuid, asString(m["title"]), asString(m["description"]), asString(m["type"]), pid, asString(m["start_at"]), asString(m["due_at"]), asString(m["status"]), asString(m["priority"]), asString(m["history"]), asInt64(m["team_id"]), asString(m["created_at"]), remoteUpdated, deleted)
|
||
}
|
||
case "notes":
|
||
if exists {
|
||
_, e = a.store.db.Exec(`UPDATE notes SET content=?,updated_at=?,deleted=?,dirty=0 WHERE id=?`,
|
||
asString(m["content"]), remoteUpdated, deleted, localID)
|
||
} else {
|
||
_, e = a.store.db.Exec(`INSERT INTO notes(uuid,content,updated_at,deleted,dirty) VALUES(?,?,?,?,0)`,
|
||
uuid, asString(m["content"]), remoteUpdated, deleted)
|
||
}
|
||
}
|
||
return e == nil, e
|
||
}
|
||
|
||
func (a *App) projectNameByID(id int64) string {
|
||
if id <= 0 {
|
||
return ""
|
||
}
|
||
var name string
|
||
_ = a.store.db.QueryRow(`SELECT name FROM projects WHERE id=?`, id).Scan(&name)
|
||
return name
|
||
}
|
||
|
||
func (a *App) projectIDByName(name string) int64 {
|
||
if name == "" {
|
||
return 0
|
||
}
|
||
var id int64
|
||
_ = a.store.db.QueryRow(`SELECT id FROM projects WHERE name=?`, name).Scan(&id)
|
||
return id
|
||
}
|
||
|
||
func asString(v any) string {
|
||
switch x := v.(type) {
|
||
case nil:
|
||
return ""
|
||
case string:
|
||
return x
|
||
case []byte:
|
||
return string(x)
|
||
default:
|
||
return fmt.Sprint(x)
|
||
}
|
||
}
|
||
|
||
func asInt64(v any) int64 {
|
||
switch x := v.(type) {
|
||
case int64:
|
||
return x
|
||
case float64:
|
||
return int64(x)
|
||
case json.Number:
|
||
n, _ := x.Int64()
|
||
return n
|
||
case []byte:
|
||
n, _ := strconv.ParseInt(string(x), 10, 64)
|
||
return n
|
||
case string:
|
||
n, _ := strconv.ParseInt(x, 10, 64)
|
||
return n
|
||
default:
|
||
return 0
|
||
}
|
||
}
|