landaiqing/voidraft
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 4 Wiki Activity

✨ Added the backup feature

Browse Source
This commit is contained in:
landaiqing
2025-07-17 00:12:00 +08:00
parent b4b0ad9bba
commit 9fff7bcfca
39 changed files with 1876 additions and 1018 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
internal/models/backup.go Normal file
View File

@@ -0,0 +1,28 @@
package models
// Git备份相关类型定义
type (
// AuthMethod 定义Git认证方式
AuthMethod string
)
const (
// 认证方式
Token AuthMethod = "token"
SSHKey AuthMethod = "ssh_key"
UserPass AuthMethod = "user_pass"
)
// GitBackupConfig Git备份配置
type GitBackupConfig struct {
Enabled bool `json:"enabled"`
RepoURL string `json:"repo_url"`
AuthMethod AuthMethod `json:"auth_method"`
Username string `json:"username,omitempty"`
Password string `json:"password,omitempty"`
Token string `json:"token,omitempty"`
SSHKeyPath string `json:"ssh_key_path,omitempty"`
SSHKeyPass string `json:"ssh_key_passphrase,omitempty"`
BackupInterval int `json:"backup_interval"` // 分钟
AutoBackup bool `json:"auto_backup"`
}

34
internal/models/config.go
View File

@@ -124,7 +124,7 @@ type AppConfig struct {
Editing EditingConfig `json:"editing"` // 编辑设置
Appearance AppearanceConfig `json:"appearance"` // 外观设置
Updates UpdatesConfig `json:"updates"` // 更新设置
Sync GitSyncConfig `json:"sync"` // Git同步设置
Backup GitBackupConfig `json:"backup"` // Git备份设置
Metadata ConfigMetadata `json:"metadata"` // 配置元数据
}
@@ -139,7 +139,6 @@ func NewDefaultAppConfig() *AppConfig {
currentDir, _ := os.UserHomeDir()
dataDir := filepath.Join(currentDir, ".voidraft", "data")
repoPath := filepath.Join(currentDir, ".voidraft", "sync-repo")
return &AppConfig{
General: GeneralConfig{
@@ -175,10 +174,10 @@ func NewDefaultAppConfig() *AppConfig {
CustomTheme: *NewDefaultCustomThemeConfig(),
},
Updates: UpdatesConfig{
Version: "1.2.0",
Version: "1.3.0",
AutoUpdate: true,
PrimarySource: UpdateSourceGithub,
BackupSource: UpdateSourceGitea,
PrimarySource: UpdateSourceGitea,
BackupSource: UpdateSourceGithub,
BackupBeforeUpdate: true,
UpdateTimeout: 30,
Github: GithubConfig{
@@ -191,21 +190,16 @@ func NewDefaultAppConfig() *AppConfig {
Repo: "voidraft",
},
},
Sync: GitSyncConfig{
Enabled: false,
RepoURL: "",
Branch: "main",
AuthMethod: Token,
Username: "",
Password: "",
Token: "",
SSHKeyPath: "",
SyncInterval: 60,
LastSyncTime: time.Time{},
AutoSync: true,
LocalRepoPath: repoPath,
SyncStrategy: LocalFirst,
FilesToSync: []string{"voidraft.db"},
Backup: GitBackupConfig{
Enabled: false,
RepoURL: "",
AuthMethod: UserPass,
Username: "",
Password: "",
Token: "",
SSHKeyPath: "",
BackupInterval: 60,
AutoBackup: false,
},
Metadata: ConfigMetadata{
LastUpdated: time.Now().Format(time.RFC3339),

2
internal/models/document.go
View File

@@ -11,7 +11,7 @@ type Document struct {
Content string `json:"content" db:"content"`
CreatedAt time.Time `json:"createdAt" db:"created_at"`
UpdatedAt time.Time `json:"updatedAt" db:"updated_at"`
IsDeleted bool `json:"is_deleted"`
IsDeleted bool `json:"is_deleted" db:"is_deleted"`
IsLocked bool `json:"is_locked" db:"is_locked"` // 锁定标志，锁定的文档无法被删除
}

63
internal/models/sync.go
View File

@@ -1,63 +0,0 @@
package models
import "time"
// AuthMethod 定义Git认证方式
type AuthMethod string
const (
Token AuthMethod = "token" // 个人访问令牌
SSHKey AuthMethod = "ssh_key" // SSH密钥
UserPass AuthMethod = "user_pass" // 用户名密码
)
// SyncStrategy 定义同步策略
type SyncStrategy string
const (
// LocalFirst 本地优先：如有冲突，保留本地修改
LocalFirst SyncStrategy = "local_first"
// RemoteFirst 远程优先：如有冲突，采用远程版本
RemoteFirst SyncStrategy = "remote_first"
)
// GitSyncConfig 保存Git同步的配置信息
type GitSyncConfig struct {
Enabled bool `json:"enabled"`
RepoURL string `json:"repo_url"`
Branch string `json:"branch"`
AuthMethod AuthMethod `json:"auth_method"`
Username string `json:"username,omitempty"`
Password string `json:"password,omitempty"`
Token string `json:"token,omitempty"`
SSHKeyPath string `json:"ssh_key_path,omitempty"`
SSHKeyPassphrase string `json:"ssh_key_passphrase,omitempty"`
SyncInterval int `json:"sync_interval"` // 同步间隔（分钟）
LastSyncTime time.Time `json:"last_sync_time"`
AutoSync bool `json:"auto_sync"` // 是否启用自动同步
LocalRepoPath string `json:"local_repo_path"`
SyncStrategy SyncStrategy `json:"sync_strategy"` // 合并冲突策略
FilesToSync []string `json:"files_to_sync"` // 要同步的文件列表，默认为数据库文件
}
// GitSyncStatus 保存同步状态信息
type GitSyncStatus struct {
IsSyncing bool `json:"is_syncing"`
LastSyncTime time.Time `json:"last_sync_time"`
LastSyncStatus string `json:"last_sync_status"` // success, failed, conflict
LastErrorMsg string `json:"last_error_msg,omitempty"`
LastCommitID string `json:"last_commit_id,omitempty"`
RemoteCommitID string `json:"remote_commit_id,omitempty"`
CommitAhead int `json:"commit_ahead"` // 本地领先远程的提交数
CommitBehind int `json:"commit_behind"` // 本地落后远程的提交数
}
// SyncLogEntry 记录每次同步操作的日志
type SyncLogEntry struct {
ID int64 `json:"id"`
Timestamp time.Time `json:"timestamp"`
Action string `json:"action"` // push, pull, reset
Status string `json:"status"` // success, failed
Message string `json:"message,omitempty"`
ChangedFiles int `json:"changed_files"`
}

16
internal/models/theme.go
View File

@@ -66,9 +66,9 @@ func NewDefaultDarkTheme() ThemeColorConfig {
Cursor: "#ffffff",
Selection: "#0865a9",
SelectionBlur: "#225377",
ActiveLine: "#ffffff",
LineNumber: "#ffffff",
ActiveLineNumber: "#ffffff",
ActiveLine: "#ffffff0a",
LineNumber: "#ffffff26",
ActiveLineNumber: "#ffffff99",
// 边框分割线
BorderColor: "#1e222a",
@@ -104,17 +104,17 @@ func NewDefaultLightTheme() ThemeColorConfig {
Cursor: "#000000",
Selection: "#77baff",
SelectionBlur: "#b2c2ca",
ActiveLine: "#000000",
LineNumber: "#000000",
ActiveLineNumber: "#000000",
ActiveLine: "#0000000a",
LineNumber: "#00000040",
ActiveLineNumber: "#000000aa",
// 边框分割线
BorderColor: "#dfdfdf",
BorderLight: "#0000000d",
BorderLight: "#0000000c",
// 搜索匹配
SearchMatch: "#005cc5",
MatchingBracket: "#0000001a",
MatchingBracket: "#00000019",
}
}

388
internal/services/backup_service.go Normal file
View File

@@ -0,0 +1,388 @@
package services
import (
"errors"
"fmt"
"os"
"path/filepath"
"strings"
"time"
"github.com/go-git/go-git/v5"
gitConfig "github.com/go-git/go-git/v5/config"
"github.com/go-git/go-git/v5/plumbing/object"
"github.com/go-git/go-git/v5/plumbing/transport"
"github.com/go-git/go-git/v5/plumbing/transport/http"
"github.com/go-git/go-git/v5/plumbing/transport/ssh"
"github.com/wailsapp/wails/v3/pkg/services/log"
"voidraft/internal/models"
_ "modernc.org/sqlite"
)
const (
dbSerializeFile = "voidraft_data.bin"
)
// BackupService 提供基于Git的备份功能
type BackupService struct {
configService *ConfigService
dbService *DatabaseService
repository *git.Repository
logger *log.Service
isInitialized bool
autoBackupTicker *time.Ticker
autoBackupStop chan bool
}
// NewBackupService 创建新的备份服务实例
func NewBackupService(configService *ConfigService, dbService *DatabaseService, logger *log.Service) *BackupService {
return &BackupService{
configService: configService,
dbService: dbService,
logger: logger,
}
}
// Initialize 初始化备份服务
func (s *BackupService) Initialize() error {
config, repoPath, err := s.getConfigAndPath()
if err != nil {
return fmt.Errorf("getting backup config: %w", err)
}
if !config.Enabled {
return nil
}
// 初始化仓库
if err := s.initializeRepository(config, repoPath); err != nil {
return fmt.Errorf("initializing repository: %w", err)
}
// 启动自动备份
if config.AutoBackup && config.BackupInterval > 0 {
s.StartAutoBackup()
}
s.isInitialized = true
return nil
}
// getConfigAndPath 获取备份配置和仓库路径
func (s *BackupService) getConfigAndPath() (*models.GitBackupConfig, string, error) {
appConfig, err := s.configService.GetConfig()
if err != nil {
return nil, "", fmt.Errorf("getting app config: %w", err)
}
return &appConfig.Backup, appConfig.General.DataPath, nil
}
// initializeRepository 初始化或打开Git仓库并设置远程
func (s *BackupService) initializeRepository(config *models.GitBackupConfig, repoPath string) error {
// 检查本地仓库是否存在
_, err := os.Stat(filepath.Join(repoPath, ".git"))
if os.IsNotExist(err) {
// 仓库不存在，初始化新仓库
repo, err := git.PlainInit(repoPath, false)
if err != nil {
return fmt.Errorf("error initializing repository: %w", err)
}
s.repository = repo
} else if err != nil {
return fmt.Errorf("error checking repository path: %w", err)
} else {
// 仓库已存在，打开现有仓库
repo, err := git.PlainOpen(repoPath)
if err != nil {
return fmt.Errorf("error opening local repository: %w", err)
}
s.repository = repo
}
// 设置或更新远程仓库
remote, err := s.repository.Remote("origin")
if err != nil {
if errors.Is(err, git.ErrRemoteNotFound) {
// 远程不存在，添加远程
_, err = s.repository.CreateRemote(&gitConfig.RemoteConfig{
Name: "origin",
URLs: []string{config.RepoURL},
})
if err != nil {
return fmt.Errorf("error creating remote: %w", err)
}
} else {
return fmt.Errorf("error getting remote: %w", err)
}
} else {
// 检查远程URL是否一致，如果不一致则更新
if len(remote.Config().URLs) > 0 && remote.Config().URLs[0] != config.RepoURL {
if err := s.repository.DeleteRemote("origin"); err != nil {
return fmt.Errorf("error deleting remote: %w", err)
}
_, err = s.repository.CreateRemote(&gitConfig.RemoteConfig{
Name: "origin",
URLs: []string{config.RepoURL},
})
if err != nil {
return fmt.Errorf("error creating new remote: %w", err)
}
}
}
return nil
}
// getAuthMethod 根据配置获取认证方法
func (s *BackupService) getAuthMethod(config *models.GitBackupConfig) (transport.AuthMethod, error) {
switch config.AuthMethod {
case models.Token:
if config.Token == "" {
return nil, errors.New("token authentication requires a valid token")
}
return &http.BasicAuth{
Username: "git", // 使用token时，用户名可以是任意值
Password: config.Token,
}, nil
case models.UserPass:
if config.Username == "" || config.Password == "" {
return nil, errors.New("username/password authentication requires both username and password")
}
return &http.BasicAuth{
Username: config.Username,
Password: config.Password,
}, nil
case models.SSHKey:
if config.SSHKeyPath == "" {
return nil, errors.New("SSH key authentication requires a valid SSH key path")
}
publicKeys, err := ssh.NewPublicKeysFromFile("git", config.SSHKeyPath, config.SSHKeyPass)
if err != nil {
return nil, fmt.Errorf("error creating SSH public keys: %w", err)
}
return publicKeys, nil
default:
return nil, fmt.Errorf("unsupported authentication method: %s", config.AuthMethod)
}
}
// serializeDatabase 序列化数据库到文件
func (s *BackupService) serializeDatabase(repoPath string) error {
if s.dbService == nil || s.dbService.db == nil {
return errors.New("database service not available")
}
// 获取数据库路径
dbPath, err := s.dbService.getDatabasePath()
if err != nil {
return fmt.Errorf("getting database path: %w", err)
}
// 关闭数据库连接以确保所有更改都写入磁盘
if err := s.dbService.ServiceShutdown(); err != nil {
s.logger.Error("Failed to close database connection", "error", err)
}
// 直接复制数据库文件到序列化文件
dbData, err := os.ReadFile(dbPath)
if err != nil {
return fmt.Errorf("reading database file: %w", err)
}
binFilePath := filepath.Join(repoPath, dbSerializeFile)
if err := os.WriteFile(binFilePath, dbData, 0644); err != nil {
return fmt.Errorf("writing serialized database to file: %w", err)
}
// 重新初始化数据库服务
if err := s.dbService.initDatabase(); err != nil {
return fmt.Errorf("reinitializing database: %w", err)
}
return nil
}
// PushToRemote 推送本地更改到远程仓库
func (s *BackupService) PushToRemote() error {
if !s.isInitialized {
return errors.New("backup service not initialized")
}
config, repoPath, err := s.getConfigAndPath()
if err != nil {
return fmt.Errorf("getting backup config: %w", err)
}
if !config.Enabled {
return errors.New("backup is disabled")
}
// 数据库序列化文件的路径
binFilePath := filepath.Join(repoPath, dbSerializeFile)
// 函数返回前都删除临时文件
defer func() {
if _, err := os.Stat(binFilePath); err == nil {
os.Remove(binFilePath)
}
}()
// 序列化数据库
if err := s.serializeDatabase(repoPath); err != nil {
return fmt.Errorf("serializing database: %w", err)
}
// 获取工作树
w, err := s.repository.Worktree()
if err != nil {
return fmt.Errorf("getting worktree: %w", err)
}
// 添加序列化的数据库文件
if _, err := w.Add(dbSerializeFile); err != nil {
return fmt.Errorf("adding serialized database file: %w", err)
}
// 检查是否有变化需要提交
status, err := w.Status()
if err != nil {
return fmt.Errorf("getting worktree status: %w", err)
}
// 如果没有变化，直接返回
if status.IsClean() {
return errors.New("no changes to backup")
}
// 创建提交
_, err = w.Commit(fmt.Sprintf("Backup %s", time.Now().Format("2006-01-02 15:04:05")), &git.CommitOptions{
Author: &object.Signature{
Name: "VoidRaft",
Email: "backup@voidraft.app",
When: time.Now(),
},
})
if err != nil {
if strings.Contains(err.Error(), "cannot create empty commit") {
return errors.New("no changes to backup")
}
return fmt.Errorf("creating commit: %w", err)
}
// 获取认证方法并推送到远程
auth, err := s.getAuthMethod(config)
if err != nil {
return fmt.Errorf("getting auth method: %w", err)
}
// 推送到远程仓库
if err := s.repository.Push(&git.PushOptions{
RemoteName: "origin",
Auth: auth,
}); err != nil && !errors.Is(err, git.NoErrAlreadyUpToDate) {
// 忽略一些常见的非错误情况
if strings.Contains(err.Error(), "clean working tree") ||
strings.Contains(err.Error(), "already up-to-date") ||
strings.Contains(err.Error(), " clean working tree") ||
strings.Contains(err.Error(), "reference not found") {
// 更新最后推送时间
return errors.New("no changes to backup")
}
return fmt.Errorf("push failed: %w", err)
}
return nil
}
// StartAutoBackup 启动自动备份定时器
func (s *BackupService) StartAutoBackup() error {
config, _, err := s.getConfigAndPath()
if err != nil {
return fmt.Errorf("getting backup config: %w", err)
}
if !config.AutoBackup || config.BackupInterval <= 0 {
return nil
}
s.StopAutoBackup()
// 将秒转换为分钟
s.autoBackupTicker = time.NewTicker(time.Duration(config.BackupInterval) * time.Minute)
s.autoBackupStop = make(chan bool)
go func() {
for {
select {
case <-s.autoBackupTicker.C:
// 执行推送操作
if err := s.PushToRemote(); err != nil {
s.logger.Error("Auto backup failed", "error", err)
}
case <-s.autoBackupStop:
return
}
}
}()
return nil
}
// StopAutoBackup 停止自动备份
func (s *BackupService) StopAutoBackup() {
if s.autoBackupTicker != nil {
s.autoBackupTicker.Stop()
s.autoBackupTicker = nil
}
if s.autoBackupStop != nil {
close(s.autoBackupStop)
s.autoBackupStop = nil
}
}
// Reinitialize 重新初始化备份服务，用于响应配置变更
func (s *BackupService) Reinitialize() error {
// 停止自动备份
s.StopAutoBackup()
// 重新设置标志
s.isInitialized = false
// 重新初始化
return s.Initialize()
}
// HandleConfigChange 处理备份配置变更
func (s *BackupService) HandleConfigChange(config *models.GitBackupConfig) error {
// 如果备份功能禁用，只需停止自动备份
if !config.Enabled {
s.StopAutoBackup()
s.isInitialized = false
return nil
}
// 如果服务已初始化，重新初始化以应用新配置
if s.isInitialized {
return s.Reinitialize()
}
// 如果服务未初始化但已启用，则初始化
if config.Enabled && !s.isInitialized {
return s.Initialize()
}
return nil
}
// ServiceShutdown 服务关闭时的清理工作
func (s *BackupService) ServiceShutdown() {
s.StopAutoBackup()
}

2
internal/services/config_migration_service.go
View File

@@ -19,7 +19,7 @@ import (
const (
// CurrentAppConfigVersion 当前应用配置版本
CurrentAppConfigVersion = "1.2.0"
CurrentAppConfigVersion = "1.3.0"
// BackupFilePattern 备份文件名模式
BackupFilePattern = "%s.backup.%s.json"

25
internal/services/config_notification_service.go
View File

@@ -22,6 +22,8 @@ const (
ConfigChangeTypeHotkey ConfigChangeType = "hotkey"
// ConfigChangeTypeDataPath 数据路径配置变更
ConfigChangeTypeDataPath ConfigChangeType = "datapath"
// ConfigChangeTypeBackup 备份配置变更
ConfigChangeTypeBackup ConfigChangeType = "backup"
)
// ConfigChangeCallback 配置变更回调函数类型
@@ -445,6 +447,29 @@ func CreateDataPathListener(name string, callback func() error) *ConfigListener
}
}
// CreateBackupConfigListener 创建备份配置监听器
func CreateBackupConfigListener(name string, callback func(config *models.GitBackupConfig) error) *ConfigListener {
return &ConfigListener{
Name: name,
ChangeType: ConfigChangeTypeBackup,
Callback: func(changeType ConfigChangeType, oldConfig, newConfig *models.AppConfig) error {
if newConfig == nil {
defaultConfig := models.NewDefaultAppConfig()
return callback(&defaultConfig.Backup)
}
return callback(&newConfig.Backup)
},
DebounceDelay: 200 * time.Millisecond,
GetConfigFunc: func(k *koanf.Koanf) *models.AppConfig {
var config models.AppConfig
if err := k.Unmarshal("", &config); err != nil {
return nil
}
return &config
},
}
}
// ServiceShutdown 关闭服务
func (cns *ConfigNotificationService) ServiceShutdown() error {
cns.Cleanup()

10
internal/services/config_service.go
View File

@@ -298,6 +298,16 @@ func (cs *ConfigService) SetDataPathChangeCallback(callback func() error) error
return cs.notificationService.RegisterListener(dataPathListener)
}
// SetBackupConfigChangeCallback 设置备份配置变更回调
func (cs *ConfigService) SetBackupConfigChangeCallback(callback func(config *models.GitBackupConfig) error) error {
cs.mu.Lock()
defer cs.mu.Unlock()
// 创建备份配置监听器并注册
backupListener := CreateBackupConfigListener("DefaultBackupConfigListener", callback)
return cs.notificationService.RegisterListener(backupListener)
}
// ServiceShutdown 关闭服务
func (cs *ConfigService) ServiceShutdown() error {
cs.stopWatching()

107
internal/services/database_service.go
View File

@@ -2,18 +2,18 @@ package services
import (
"context"
"database/sql"
"fmt"
"os"
"path/filepath"
"reflect"
"strings"
"sync"
"time"
"voidraft/internal/models"
"github.com/wailsapp/wails/v3/pkg/application"
"github.com/wailsapp/wails/v3/pkg/services/log"
"github.com/wailsapp/wails/v3/pkg/services/sqlite"
_ "modernc.org/sqlite"
)
const (
@@ -63,20 +63,6 @@ CREATE TABLE IF NOT EXISTS key_bindings (
updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
UNIQUE(command, extension)
)`
// Git sync logs table
sqlCreateSyncLogsTable = `
CREATE TABLE IF NOT EXISTS sync_logs (
id INTEGER PRIMARY KEY AUTOINCREMENT,
timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
action TEXT NOT NULL,
status TEXT NOT NULL,
message TEXT,
commit_id TEXT,
changed_files INTEGER DEFAULT 0,
repo_url TEXT NOT NULL,
branch TEXT NOT NULL
)`
)
// ColumnInfo 存储列的信息
@@ -95,7 +81,7 @@ type TableModel struct {
type DatabaseService struct {
configService *ConfigService
logger *log.Service
SQLite *sqlite.Service
db *sql.DB
mu sync.RWMutex
ctx context.Context
tableModels []TableModel // 注册的表模型
@@ -110,7 +96,6 @@ func NewDatabaseService(configService *ConfigService, logger *log.Service) *Data
ds := &DatabaseService{
configService: configService,
logger: logger,
SQLite: sqlite.New(),
}
// 注册所有模型
@@ -127,8 +112,6 @@ func (ds *DatabaseService) registerAllModels() {
ds.RegisterModel("extensions", &models.Extension{})
// 快捷键表
ds.RegisterModel("key_bindings", &models.KeyBinding{})
// 同步日志表
ds.RegisterModel("sync_logs", &models.SyncLogEntry{})
}
// ServiceStartup initializes the service when the application starts
@@ -150,28 +133,19 @@ func (ds *DatabaseService) initDatabase() error {
return fmt.Errorf("failed to create database directory: %w", err)
}
// 检查数据库文件是否存在，如果不存在则创建
if _, err := os.Stat(dbPath); os.IsNotExist(err) {
// 创建空文件
file, err := os.Create(dbPath)
if err != nil {
return fmt.Errorf("failed to create database file: %w", err)
}
file.Close()
}
// 配置SQLite服务
ds.SQLite.Configure(&sqlite.Config{
DBSource: dbPath,
})
// 打开数据库连接
if err := ds.SQLite.Open(); err != nil {
ds.db, err = sql.Open("sqlite", dbPath)
if err != nil {
return fmt.Errorf("failed to open database: %w", err)
}
// 测试连接
if err := ds.db.Ping(); err != nil {
return fmt.Errorf("failed to ping database: %w", err)
}
// 应用性能优化设置
if err := ds.SQLite.Execute(sqlOptimizationSettings); err != nil {
if _, err := ds.db.Exec(sqlOptimizationSettings); err != nil {
return fmt.Errorf("failed to apply optimization settings: %w", err)
}
@@ -207,11 +181,10 @@ func (ds *DatabaseService) createTables() error {
sqlCreateDocumentsTable,
sqlCreateExtensionsTable,
sqlCreateKeyBindingsTable,
sqlCreateSyncLogsTable,
}
for _, table := range tables {
if err := ds.SQLite.Execute(table); err != nil {
if _, err := ds.db.Exec(table); err != nil {
return err
}
}
@@ -231,14 +204,10 @@ func (ds *DatabaseService) createIndexes() error {
`CREATE INDEX IF NOT EXISTS idx_key_bindings_command ON key_bindings(command)`,
`CREATE INDEX IF NOT EXISTS idx_key_bindings_extension ON key_bindings(extension)`,
`CREATE INDEX IF NOT EXISTS idx_key_bindings_enabled ON key_bindings(enabled)`,
// Sync logs indexes
`CREATE INDEX IF NOT EXISTS idx_sync_logs_timestamp ON sync_logs(timestamp DESC)`,
`CREATE INDEX IF NOT EXISTS idx_sync_logs_action ON sync_logs(action)`,
`CREATE INDEX IF NOT EXISTS idx_sync_logs_status ON sync_logs(status)`,
}
for _, index := range indexes {
if err := ds.SQLite.Execute(index); err != nil {
if _, err := ds.db.Exec(index); err != nil {
return err
}
}
@@ -286,7 +255,7 @@ func (ds *DatabaseService) syncModelTable(tableName string, model interface{}) e
// 执行添加列的SQL
alterSQL := fmt.Sprintf("ALTER TABLE %s ADD COLUMN %s %s DEFAULT %s",
tableName, colName, colInfo.SQLType, colInfo.DefaultValue)
if err := ds.SQLite.Execute(alterSQL); err != nil {
if _, err := ds.db.Exec(alterSQL); err != nil {
return fmt.Errorf("failed to add column %s: %w", colName, err)
}
}
@@ -298,23 +267,30 @@ func (ds *DatabaseService) syncModelTable(tableName string, model interface{}) e
// getTableColumns 获取表的列信息
func (ds *DatabaseService) getTableColumns(table string) (map[string]string, error) {
query := fmt.Sprintf("PRAGMA table_info(%s)", table)
rows, err := ds.SQLite.Query(query)
rows, err := ds.db.Query(query)
if err != nil {
return nil, err
}
defer rows.Close()
columns := make(map[string]string)
for _, row := range rows {
name, ok1 := row["name"].(string)
typeName, ok2 := row["type"].(string)
for rows.Next() {
var cid int
var name, typeName string
var notNull, pk int
var dflt_value interface{}
if !ok1 || !ok2 {
continue
if err := rows.Scan(&cid, &name, &typeName, &notNull, &dflt_value, &pk); err != nil {
return nil, err
}
columns[name] = typeName
}
if err := rows.Err(); err != nil {
return nil, err
}
return columns, nil
}
@@ -336,11 +312,11 @@ func (ds *DatabaseService) getModelColumns(model interface{}) (map[string]Column
for i := 0; i < t.NumField(); i++ {
field := t.Field(i)
// 获取数据库字段名
// 只处理有db标签的字段
dbTag := field.Tag.Get("db")
if dbTag == "" {
// 如果没有db标签，则使用字段名的蛇形命名方式
dbTag = toSnakeCase(field.Name)
// 如果没有db标签，跳过该字段
continue
}
// 获取字段类型对应的SQL类型和默认值
@@ -355,18 +331,6 @@ func (ds *DatabaseService) getModelColumns(model interface{}) (map[string]Column
return columns, nil
}
// toSnakeCase 将驼峰命名转换为蛇形命名
func toSnakeCase(s string) string {
var result strings.Builder
for i, r := range s {
if i > 0 && 'A' <= r && r <= 'Z' {
result.WriteRune('_')
}
result.WriteRune(r)
}
return strings.ToLower(result.String())
}
// getSQLTypeAndDefault 根据Go类型获取对应的SQL类型和默认值
func getSQLTypeAndDefault(t reflect.Type) (string, string) {
switch t.Kind() {
@@ -390,14 +354,19 @@ func getSQLTypeAndDefault(t reflect.Type) (string, string) {
// ServiceShutdown shuts down the service when the application closes
func (ds *DatabaseService) ServiceShutdown() error {
return ds.SQLite.Close()
if ds.db != nil {
return ds.db.Close()
}
return nil
}
// OnDataPathChanged handles data path changes
func (ds *DatabaseService) OnDataPathChanged() error {
// 关闭当前连接
if err := ds.SQLite.Close(); err != nil {
return err
if ds.db != nil {
if err := ds.db.Close(); err != nil {
return err
}
}
// 用新路径重新初始化

42
internal/services/dialog_service.go
View File

@@ -50,7 +50,6 @@ func (ds *DialogService) SelectDirectory() (string, error) {
// 对话框文本配置
Title: "Select Directory",
Message: "Select the folder where you want to store your app data",
ButtonText: "Select",
// 不设置过滤器，因为我们选择目录
@@ -69,3 +68,44 @@ func (ds *DialogService) SelectDirectory() (string, error) {
}
return path, nil
}
// SelectFile 打开文件选择对话框
func (ds *DialogService) SelectFile() (string, error) {
dialog := application.OpenFileDialog()
dialog.SetOptions(&application.OpenFileDialogOptions{
// 目录选择配置
CanChooseDirectories: false, // 允许选择目录
CanChooseFiles: true, // 不允许选择文件
CanCreateDirectories: true, // 允许创建新目录
AllowsMultipleSelection: false, // 单选模式
// 显示配置
ShowHiddenFiles: true, // 不显示隐藏文件
HideExtension: false, // 不隐藏扩展名
CanSelectHiddenExtension: false, // 不允许选择隐藏扩展名
TreatsFilePackagesAsDirectories: false, // 不将文件包当作目录处理
AllowsOtherFileTypes: false, // 不允许其他文件类型
// 系统配置
ResolvesAliases: true, // 解析别名/快捷方式
// 对话框文本配置
Title: "Select File",
ButtonText: "Select File",
// 不设置过滤器，因为我们选择目录
Filters: nil,
// 不指定默认目录，让系统决定
Directory: "",
// 绑定到主窗口
Window: ds.window,
})
path, err := dialog.PromptForSingleSelection()
if err != nil {
return "", err
}
return path, nil
}

269
internal/services/document_service.go
View File

@@ -111,19 +111,15 @@ func (ds *DocumentService) ServiceStartup(ctx context.Context, options applicati
// ensureDefaultDocument ensures a default document exists
func (ds *DocumentService) ensureDefaultDocument() error {
if ds.databaseService == nil || ds.databaseService.db == nil {
return errors.New("database service not available")
}
// Check if any document exists
rows, err := ds.databaseService.SQLite.Query(sqlCountDocuments)
var count int64
err := ds.databaseService.db.QueryRow(sqlCountDocuments).Scan(&count)
if err != nil {
return err
}
if len(rows) == 0 {
return fmt.Errorf("failed to query document count")
}
count, ok := rows[0]["COUNT(*)"].(int64)
if !ok {
return fmt.Errorf("failed to convert count to int64")
return fmt.Errorf("failed to query document count: %w", err)
}
// If no documents exist, create default document
@@ -140,52 +136,42 @@ func (ds *DocumentService) GetDocumentByID(id int64) (*models.Document, error) {
ds.mu.RLock()
defer ds.mu.RUnlock()
rows, err := ds.databaseService.SQLite.Query(sqlGetDocumentByID, id)
if ds.databaseService == nil || ds.databaseService.db == nil {
return nil, errors.New("database service not available")
}
doc := &models.Document{}
var createdAt, updatedAt string
var isDeleted, isLocked int
err := ds.databaseService.db.QueryRow(sqlGetDocumentByID, id).Scan(
&doc.ID,
&doc.Title,
&doc.Content,
&createdAt,
&updatedAt,
&isDeleted,
&isLocked,
)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return nil, nil
}
return nil, fmt.Errorf("failed to get document by ID: %w", err)
}
if len(rows) == 0 {
return nil, nil
// 转换时间字段
if t, err := time.Parse("2006-01-02 15:04:05", createdAt); err == nil {
doc.CreatedAt = t
}
if t, err := time.Parse("2006-01-02 15:04:05", updatedAt); err == nil {
doc.UpdatedAt = t
}
row := rows[0]
doc := &models.Document{}
// 从Row中提取数据
if idVal, ok := row["id"].(int64); ok {
doc.ID = idVal
}
if title, ok := row["title"].(string); ok {
doc.Title = title
}
if content, ok := row["content"].(string); ok {
doc.Content = content
}
if createdAt, ok := row["created_at"].(string); ok {
t, err := time.Parse("2006-01-02 15:04:05", createdAt)
if err == nil {
doc.CreatedAt = t
}
}
if updatedAt, ok := row["updated_at"].(string); ok {
t, err := time.Parse("2006-01-02 15:04:05", updatedAt)
if err == nil {
doc.UpdatedAt = t
}
}
if isDeletedInt, ok := row["is_deleted"].(int64); ok {
doc.IsDeleted = isDeletedInt == 1
}
if isLockedInt, ok := row["is_locked"].(int64); ok {
doc.IsLocked = isLockedInt == 1
}
// 转换布尔字段
doc.IsDeleted = isDeleted == 1
doc.IsLocked = isLocked == 1
return doc, nil
}
@@ -195,6 +181,10 @@ func (ds *DocumentService) CreateDocument(title string) (*models.Document, error
ds.mu.Lock()
defer ds.mu.Unlock()
if ds.databaseService == nil || ds.databaseService.db == nil {
return nil, errors.New("database service not available")
}
// Create document with default content
now := time.Now()
doc := &models.Document{
@@ -207,27 +197,18 @@ func (ds *DocumentService) CreateDocument(title string) (*models.Document, error
}
// 执行插入操作
if err := ds.databaseService.SQLite.Execute(sqlInsertDocument,
doc.Title, doc.Content, doc.CreatedAt, doc.UpdatedAt); err != nil {
result, err := ds.databaseService.db.Exec(sqlInsertDocument,
doc.Title, doc.Content, doc.CreatedAt.Format("2006-01-02 15:04:05"), doc.UpdatedAt.Format("2006-01-02 15:04:05"))
if err != nil {
return nil, fmt.Errorf("failed to create document: %w", err)
}
// 获取自增ID
lastIDRows, err := ds.databaseService.SQLite.Query("SELECT last_insert_rowid()")
lastID, err := result.LastInsertId()
if err != nil {
return nil, fmt.Errorf("failed to get last insert ID: %w", err)
}
if len(lastIDRows) == 0 {
return nil, fmt.Errorf("no rows returned for last insert ID query")
}
// 从结果中提取ID
lastID, ok := lastIDRows[0]["last_insert_rowid()"].(int64)
if !ok {
return nil, fmt.Errorf("failed to convert last insert ID to int64")
}
// 返回带ID的文档
doc.ID = lastID
return doc, nil
@@ -238,6 +219,10 @@ func (ds *DocumentService) LockDocument(id int64) error {
ds.mu.Lock()
defer ds.mu.Unlock()
if ds.databaseService == nil || ds.databaseService.db == nil {
return errors.New("database service not available")
}
// 检查文档是否存在且未删除
doc, err := ds.GetDocumentByID(id)
if err != nil {
@@ -255,7 +240,7 @@ func (ds *DocumentService) LockDocument(id int64) error {
return nil
}
err = ds.databaseService.SQLite.Execute(sqlSetDocumentLocked, time.Now(), id)
_, err = ds.databaseService.db.Exec(sqlSetDocumentLocked, time.Now().Format("2006-01-02 15:04:05"), id)
if err != nil {
return fmt.Errorf("failed to lock document: %w", err)
}
@@ -267,6 +252,10 @@ func (ds *DocumentService) UnlockDocument(id int64) error {
ds.mu.Lock()
defer ds.mu.Unlock()
if ds.databaseService == nil || ds.databaseService.db == nil {
return errors.New("database service not available")
}
// 检查文档是否存在
doc, err := ds.GetDocumentByID(id)
if err != nil {
@@ -281,7 +270,7 @@ func (ds *DocumentService) UnlockDocument(id int64) error {
return nil
}
err = ds.databaseService.SQLite.Execute(sqlSetDocumentUnlocked, time.Now(), id)
_, err = ds.databaseService.db.Exec(sqlSetDocumentUnlocked, time.Now().Format("2006-01-02 15:04:05"), id)
if err != nil {
return fmt.Errorf("failed to unlock document: %w", err)
}
@@ -293,7 +282,11 @@ func (ds *DocumentService) UpdateDocumentContent(id int64, content string) error
ds.mu.Lock()
defer ds.mu.Unlock()
err := ds.databaseService.SQLite.Execute(sqlUpdateDocumentContent, content, time.Now(), id)
if ds.databaseService == nil || ds.databaseService.db == nil {
return errors.New("database service not available")
}
_, err := ds.databaseService.db.Exec(sqlUpdateDocumentContent, content, time.Now().Format("2006-01-02 15:04:05"), id)
if err != nil {
return fmt.Errorf("failed to update document content: %w", err)
}
@@ -305,7 +298,11 @@ func (ds *DocumentService) UpdateDocumentTitle(id int64, title string) error {
ds.mu.Lock()
defer ds.mu.Unlock()
err := ds.databaseService.SQLite.Execute(sqlUpdateDocumentTitle, title, time.Now(), id)
if ds.databaseService == nil || ds.databaseService.db == nil {
return errors.New("database service not available")
}
_, err := ds.databaseService.db.Exec(sqlUpdateDocumentTitle, title, time.Now().Format("2006-01-02 15:04:05"), id)
if err != nil {
return fmt.Errorf("failed to update document title: %w", err)
}
@@ -317,6 +314,10 @@ func (ds *DocumentService) DeleteDocument(id int64) error {
ds.mu.Lock()
defer ds.mu.Unlock()
if ds.databaseService == nil || ds.databaseService.db == nil {
return errors.New("database service not available")
}
// 不允许删除默认文档
if id == sqlDefaultDocumentID {
return fmt.Errorf("cannot delete the default document")
@@ -334,7 +335,7 @@ func (ds *DocumentService) DeleteDocument(id int64) error {
return fmt.Errorf("cannot delete locked document: %d", id)
}
err = ds.databaseService.SQLite.Execute(sqlMarkDocumentAsDeleted, time.Now(), id)
_, err = ds.databaseService.db.Exec(sqlMarkDocumentAsDeleted, time.Now().Format("2006-01-02 15:04:05"), id)
if err != nil {
return fmt.Errorf("failed to mark document as deleted: %w", err)
}
@@ -346,7 +347,11 @@ func (ds *DocumentService) RestoreDocument(id int64) error {
ds.mu.Lock()
defer ds.mu.Unlock()
err := ds.databaseService.SQLite.Execute(sqlRestoreDocument, time.Now(), id)
if ds.databaseService == nil || ds.databaseService.db == nil {
return errors.New("database service not available")
}
_, err := ds.databaseService.db.Exec(sqlRestoreDocument, time.Now().Format("2006-01-02 15:04:05"), id)
if err != nil {
return fmt.Errorf("failed to restore document: %w", err)
}
@@ -358,44 +363,50 @@ func (ds *DocumentService) ListAllDocumentsMeta() ([]*models.Document, error) {
ds.mu.RLock()
defer ds.mu.RUnlock()
rows, err := ds.databaseService.SQLite.Query(sqlListAllDocumentsMeta)
if ds.databaseService == nil || ds.databaseService.db == nil {
return nil, errors.New("database service not available")
}
rows, err := ds.databaseService.db.Query(sqlListAllDocumentsMeta)
if err != nil {
return nil, fmt.Errorf("failed to list document meta: %w", err)
}
defer rows.Close()
var documents []*models.Document
for _, row := range rows {
for rows.Next() {
doc := &models.Document{IsDeleted: false}
var createdAt, updatedAt string
var isLocked int
if id, ok := row["id"].(int64); ok {
doc.ID = id
err := rows.Scan(
&doc.ID,
&doc.Title,
&createdAt,
&updatedAt,
&isLocked,
)
if err != nil {
return nil, fmt.Errorf("failed to scan document row: %w", err)
}
if title, ok := row["title"].(string); ok {
doc.Title = title
}
if createdAt, ok := row["created_at"].(string); ok {
t, err := time.Parse("2006-01-02 15:04:05", createdAt)
if err == nil {
doc.CreatedAt = t
}
}
if updatedAt, ok := row["updated_at"].(string); ok {
t, err := time.Parse("2006-01-02 15:04:05", updatedAt)
if err == nil {
doc.UpdatedAt = t
}
}
if isLockedInt, ok := row["is_locked"].(int64); ok {
doc.IsLocked = isLockedInt == 1
// 转换时间字段
if t, err := time.Parse("2006-01-02 15:04:05", createdAt); err == nil {
doc.CreatedAt = t
}
if t, err := time.Parse("2006-01-02 15:04:05", updatedAt); err == nil {
doc.UpdatedAt = t
}
doc.IsLocked = isLocked == 1
documents = append(documents, doc)
}
if err = rows.Err(); err != nil {
return nil, fmt.Errorf("error iterating document rows: %w", err)
}
return documents, nil
}
@@ -404,44 +415,50 @@ func (ds *DocumentService) ListDeletedDocumentsMeta() ([]*models.Document, error
ds.mu.RLock()
defer ds.mu.RUnlock()
rows, err := ds.databaseService.SQLite.Query(sqlListDeletedDocumentsMeta)
if ds.databaseService == nil || ds.databaseService.db == nil {
return nil, errors.New("database service not available")
}
rows, err := ds.databaseService.db.Query(sqlListDeletedDocumentsMeta)
if err != nil {
return nil, fmt.Errorf("failed to list deleted document meta: %w", err)
}
defer rows.Close()
var documents []*models.Document
for _, row := range rows {
for rows.Next() {
doc := &models.Document{IsDeleted: true}
var createdAt, updatedAt string
var isLocked int
if id, ok := row["id"].(int64); ok {
doc.ID = id
err := rows.Scan(
&doc.ID,
&doc.Title,
&createdAt,
&updatedAt,
&isLocked,
)
if err != nil {
return nil, fmt.Errorf("failed to scan document row: %w", err)
}
if title, ok := row["title"].(string); ok {
doc.Title = title
}
if createdAt, ok := row["created_at"].(string); ok {
t, err := time.Parse("2006-01-02 15:04:05", createdAt)
if err == nil {
doc.CreatedAt = t
}
}
if updatedAt, ok := row["updated_at"].(string); ok {
t, err := time.Parse("2006-01-02 15:04:05", updatedAt)
if err == nil {
doc.UpdatedAt = t
}
}
if isLockedInt, ok := row["is_locked"].(int64); ok {
doc.IsLocked = isLockedInt == 1
// 转换时间字段
if t, err := time.Parse("2006-01-02 15:04:05", createdAt); err == nil {
doc.CreatedAt = t
}
if t, err := time.Parse("2006-01-02 15:04:05", updatedAt); err == nil {
doc.UpdatedAt = t
}
doc.IsLocked = isLocked == 1
documents = append(documents, doc)
}
if err = rows.Err(); err != nil {
return nil, fmt.Errorf("error iterating deleted document rows: %w", err)
}
return documents, nil
}
@@ -450,7 +467,12 @@ func (ds *DocumentService) GetFirstDocumentID() (int64, error) {
ds.mu.RLock()
defer ds.mu.RUnlock()
rows, err := ds.databaseService.SQLite.Query(sqlGetFirstDocumentID)
if ds.databaseService == nil || ds.databaseService.db == nil {
return 0, errors.New("database service not available")
}
var id int64
err := ds.databaseService.db.QueryRow(sqlGetFirstDocumentID).Scan(&id)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return 0, nil // No documents exist
@@ -458,14 +480,5 @@ func (ds *DocumentService) GetFirstDocumentID() (int64, error) {
return 0, fmt.Errorf("failed to get first document ID: %w", err)
}
if len(rows) == 0 {
return 0, nil
}
id, ok := rows[0]["id"].(int64)
if !ok {
return 0, fmt.Errorf("failed to convert ID to int64")
}
return id, nil
}

98
internal/services/extension_service.go
View File

@@ -104,21 +104,17 @@ func (es *ExtensionService) initDatabase() error {
es.mu.Lock()
defer es.mu.Unlock()
if es.databaseService == nil || es.databaseService.db == nil {
return &ExtensionError{"check_db", "", errors.New("database service not available")}
}
// 检查是否已有扩展数据
rows, err := es.databaseService.SQLite.Query("SELECT COUNT(*) FROM extensions")
var count int64
err := es.databaseService.db.QueryRow("SELECT COUNT(*) FROM extensions").Scan(&count)
if err != nil {
return &ExtensionError{"check_extensions_count", "", err}
}
if len(rows) == 0 {
return &ExtensionError{"check_extensions_count", "", fmt.Errorf("no rows returned")}
}
count, ok := rows[0]["COUNT(*)"].(int64)
if !ok {
return &ExtensionError{"convert_count", "", fmt.Errorf("failed to convert count to int64")}
}
// 如果没有数据，插入默认配置
if count == 0 {
if err := es.insertDefaultExtensions(); err != nil {
@@ -133,16 +129,15 @@ func (es *ExtensionService) initDatabase() error {
// insertDefaultExtensions 插入默认扩展配置
func (es *ExtensionService) insertDefaultExtensions() error {
defaultSettings := models.NewDefaultExtensionSettings()
now := time.Now()
now := time.Now().Format("2006-01-02 15:04:05")
for _, ext := range defaultSettings.Extensions {
configJSON, err := json.Marshal(ext.Config)
if err != nil {
return &ExtensionError{"marshal_config", string(ext.ID), err}
}
err = es.databaseService.SQLite.Execute(sqlInsertExtension,
_, err = es.databaseService.db.Exec(sqlInsertExtension,
string(ext.ID),
ext.Enabled,
ext.IsDefault,
@@ -153,7 +148,6 @@ func (es *ExtensionService) insertDefaultExtensions() error {
if err != nil {
return &ExtensionError{"insert_extension", string(ext.ID), err}
}
}
return nil
@@ -179,38 +173,51 @@ func (es *ExtensionService) GetAllExtensions() ([]models.Extension, error) {
es.mu.RLock()
defer es.mu.RUnlock()
rows, err := es.databaseService.SQLite.Query(sqlGetAllExtensions)
if es.databaseService == nil || es.databaseService.db == nil {
return nil, &ExtensionError{"query_db", "", errors.New("database service not available")}
}
rows, err := es.databaseService.db.Query(sqlGetAllExtensions)
if err != nil {
return nil, &ExtensionError{"query_extensions", "", err}
}
defer rows.Close()
var extensions []models.Extension
for _, row := range rows {
for rows.Next() {
var ext models.Extension
var id string
var configJSON string
var enabled, isDefault int
if id, ok := row["id"].(string); ok {
ext.ID = models.ExtensionID(id)
err := rows.Scan(
&id,
&enabled,
&isDefault,
&configJSON,
)
if err != nil {
return nil, &ExtensionError{"scan_extension", "", err}
}
if enabled, ok := row["enabled"].(int64); ok {
ext.Enabled = enabled == 1
}
ext.ID = models.ExtensionID(id)
ext.Enabled = enabled == 1
ext.IsDefault = isDefault == 1
if isDefault, ok := row["is_default"].(int64); ok {
ext.IsDefault = isDefault == 1
}
if configJSON, ok := row["config"].(string); ok {
var config models.ExtensionConfig
if err := json.Unmarshal([]byte(configJSON), &config); err != nil {
return nil, &ExtensionError{"unmarshal_config", string(ext.ID), err}
}
ext.Config = config
var config models.ExtensionConfig
if err := json.Unmarshal([]byte(configJSON), &config); err != nil {
return nil, &ExtensionError{"unmarshal_config", id, err}
}
ext.Config = config
extensions = append(extensions, ext)
}
if err = rows.Err(); err != nil {
return nil, &ExtensionError{"iterate_extensions", "", err}
}
return extensions, nil
}
@@ -224,6 +231,10 @@ func (es *ExtensionService) UpdateExtensionState(id models.ExtensionID, enabled
es.mu.Lock()
defer es.mu.Unlock()
if es.databaseService == nil || es.databaseService.db == nil {
return &ExtensionError{"check_db", string(id), errors.New("database service not available")}
}
var configJSON []byte
var err error
@@ -234,24 +245,19 @@ func (es *ExtensionService) UpdateExtensionState(id models.ExtensionID, enabled
}
} else {
// 如果没有提供配置，保持原有配置
rows, err := es.databaseService.SQLite.Query("SELECT config FROM extensions WHERE id = ?", string(id))
var currentConfigJSON string
err := es.databaseService.db.QueryRow("SELECT config FROM extensions WHERE id = ?", string(id)).Scan(&currentConfigJSON)
if err != nil {
return &ExtensionError{"query_current_config", string(id), err}
}
if len(rows) == 0 {
return &ExtensionError{"query_current_config", string(id), fmt.Errorf("extension not found")}
}
currentConfigJSON, ok := rows[0]["config"].(string)
if !ok {
return &ExtensionError{"convert_config", string(id), fmt.Errorf("failed to get current config")}
}
configJSON = []byte(currentConfigJSON)
}
err = es.databaseService.SQLite.Execute(sqlUpdateExtension, enabled, string(configJSON), time.Now(), string(id))
_, err = es.databaseService.db.Exec(sqlUpdateExtension,
enabled,
string(configJSON),
time.Now().Format("2006-01-02 15:04:05"),
string(id))
if err != nil {
return &ExtensionError{"update_extension", string(id), err}
}
@@ -276,8 +282,12 @@ func (es *ExtensionService) ResetAllExtensionsToDefault() error {
es.mu.Lock()
defer es.mu.Unlock()
if es.databaseService == nil || es.databaseService.db == nil {
return &ExtensionError{"check_db", "", errors.New("database service not available")}
}
// 删除所有现有扩展
err := es.databaseService.SQLite.Execute(sqlDeleteAllExtensions)
_, err := es.databaseService.db.Exec(sqlDeleteAllExtensions)
if err != nil {
return &ExtensionError{"delete_all_extensions", "", err}
}

68
internal/services/keybinding_service.go
View File

@@ -105,21 +105,17 @@ func (kbs *KeyBindingService) initDatabase() error {
kbs.mu.Lock()
defer kbs.mu.Unlock()
if kbs.databaseService == nil || kbs.databaseService.db == nil {
return &KeyBindingError{"check_db", "", errors.New("database service not available")}
}
// 检查是否已有快捷键数据
rows, err := kbs.databaseService.SQLite.Query("SELECT COUNT(*) FROM key_bindings")
var count int64
err := kbs.databaseService.db.QueryRow("SELECT COUNT(*) FROM key_bindings").Scan(&count)
if err != nil {
return &KeyBindingError{"check_keybindings_count", "", err}
}
if len(rows) == 0 {
return &KeyBindingError{"check_keybindings_count", "", fmt.Errorf("no rows returned")}
}
count, ok := rows[0]["COUNT(*)"].(int64)
if !ok {
return &KeyBindingError{"convert_count", "", fmt.Errorf("failed to convert count to int64")}
}
// 如果没有数据，插入默认配置
if count == 0 {
if err := kbs.insertDefaultKeyBindings(); err != nil {
@@ -134,11 +130,10 @@ func (kbs *KeyBindingService) initDatabase() error {
// insertDefaultKeyBindings 插入默认快捷键配置
func (kbs *KeyBindingService) insertDefaultKeyBindings() error {
defaultConfig := models.NewDefaultKeyBindingConfig()
now := time.Now()
now := time.Now().Format("2006-01-02 15:04:05")
for _, kb := range defaultConfig.KeyBindings {
err := kbs.databaseService.SQLite.Execute(sqlInsertKeyBinding,
_, err := kbs.databaseService.db.Exec(sqlInsertKeyBinding,
string(kb.Command), // 转换为字符串存储
string(kb.Extension), // 转换为字符串存储
kb.Key,
@@ -150,7 +145,6 @@ func (kbs *KeyBindingService) insertDefaultKeyBindings() error {
if err != nil {
return &KeyBindingError{"insert_keybinding", string(kb.Command), err}
}
}
return nil
@@ -161,38 +155,46 @@ func (kbs *KeyBindingService) GetAllKeyBindings() ([]models.KeyBinding, error) {
kbs.mu.RLock()
defer kbs.mu.RUnlock()
rows, err := kbs.databaseService.SQLite.Query(sqlGetAllKeyBindings)
if kbs.databaseService == nil || kbs.databaseService.db == nil {
return nil, &KeyBindingError{"query_db", "", errors.New("database service not available")}
}
rows, err := kbs.databaseService.db.Query(sqlGetAllKeyBindings)
if err != nil {
return nil, &KeyBindingError{"query_keybindings", "", err}
}
defer rows.Close()
var keyBindings []models.KeyBinding
for _, row := range rows {
for rows.Next() {
var kb models.KeyBinding
var command, extension string
var enabled, isDefault int
if command, ok := row["command"].(string); ok {
kb.Command = models.KeyBindingCommand(command)
err := rows.Scan(
&command,
&extension,
&kb.Key,
&enabled,
&isDefault,
)
if err != nil {
return nil, &KeyBindingError{"scan_keybinding", "", err}
}
if extension, ok := row["extension"].(string); ok {
kb.Extension = models.ExtensionID(extension)
}
if key, ok := row["key"].(string); ok {
kb.Key = key
}
if enabled, ok := row["enabled"].(int64); ok {
kb.Enabled = enabled == 1
}
if isDefault, ok := row["is_default"].(int64); ok {
kb.IsDefault = isDefault == 1
}
kb.Command = models.KeyBindingCommand(command)
kb.Extension = models.ExtensionID(extension)
kb.Enabled = enabled == 1
kb.IsDefault = isDefault == 1
keyBindings = append(keyBindings, kb)
}
if err = rows.Err(); err != nil {
return nil, &KeyBindingError{"iterate_keybindings", "", err}
}
return keyBindings, nil
}

26
internal/services/service_manager.go
View File

@@ -5,14 +5,12 @@ import (
"github.com/wailsapp/wails/v3/pkg/application"
"github.com/wailsapp/wails/v3/pkg/services/log"
"github.com/wailsapp/wails/v3/pkg/services/sqlite"
)
// ServiceManager 服务管理器，负责协调各个服务
type ServiceManager struct {
configService *ConfigService
databaseService *DatabaseService
sqliteService *sqlite.Service
documentService *DocumentService
windowService *WindowService
migrationService *MigrationService
@@ -25,6 +23,7 @@ type ServiceManager struct {
startupService *StartupService
selfUpdateService *SelfUpdateService
translationService *TranslationService
BackupService *BackupService
logger *log.Service
}
@@ -36,9 +35,6 @@ func NewServiceManager() *ServiceManager {
// 初始化配置服务
configService := NewConfigService(logger)
// 初始化SQLite服务
sqliteService := sqlite.New()
// 初始化数据库服务
databaseService := NewDatabaseService(configService, logger)
@@ -81,6 +77,9 @@ func NewServiceManager() *ServiceManager {
// 初始化翻译服务
translationService := NewTranslationService(logger)
// 初始化备份服务
backupService := NewBackupService(configService, databaseService, logger)
// 使用新的配置通知系统设置热键配置变更监听
err = configService.SetHotkeyChangeCallback(func(enable bool, hotkey *models.HotkeyCombo) error {
return hotkeyService.UpdateHotkey(enable, hotkey)
@@ -97,10 +96,17 @@ func NewServiceManager() *ServiceManager {
panic(err)
}
// 设置备份配置变更监听，处理备份配置变更
err = configService.SetBackupConfigChangeCallback(func(config *models.GitBackupConfig) error {
return backupService.HandleConfigChange(config)
})
if err != nil {
panic(err)
}
return &ServiceManager{
configService: configService,
databaseService: databaseService,
sqliteService: sqliteService,
documentService: documentService,
windowService: windowService,
migrationService: migrationService,
@@ -113,6 +119,7 @@ func NewServiceManager() *ServiceManager {
startupService: startupService,
selfUpdateService: selfUpdateService,
translationService: translationService,
BackupService: backupService,
logger: logger,
}
}
@@ -121,7 +128,6 @@ func NewServiceManager() *ServiceManager {
func (sm *ServiceManager) GetServices() []application.Service {
services := []application.Service{
application.NewService(sm.configService),
application.NewService(sm.sqliteService),
application.NewService(sm.databaseService),
application.NewService(sm.documentService),
application.NewService(sm.windowService),
@@ -135,6 +141,7 @@ func (sm *ServiceManager) GetServices() []application.Service {
application.NewService(sm.startupService),
application.NewService(sm.selfUpdateService),
application.NewService(sm.translationService),
application.NewService(sm.BackupService),
}
return services
}
@@ -194,11 +201,6 @@ func (sm *ServiceManager) GetDatabaseService() *DatabaseService {
return sm.databaseService
}
// GetSQLiteService 获取SQLite服务实例
func (sm *ServiceManager) GetSQLiteService() *sqlite.Service {
return sm.sqliteService
}
// GetWindowService 获取窗口服务实例
func (sm *ServiceManager) GetWindowService() *WindowService {
return sm.windowService