feat: 新增阅读数功能

- 数据库添加 views 字段，兼容旧数据库自动添加
- API 新增 /api/items/<id>/view 接口增加阅读数
- 列表显示阅读数（👁图标）
- 详情页显示阅读数，点击详情时自动增加

README.md

@@ -141,6 +141,50 @@ xian-favor/
 
 ## 版本历史
 
+- **v2.4.0** (2026-04-16): 数据库备份机制
+  - 自动备份：每天 04:00 执行
+  - 手动备份：页面一键操作
+  - 备份清理规则：保留30天 + 每月第一天永久保留
+  - 手动备份最多保留10个
+  - 支持恢复备份和删除备份
+  - 备份管理页面入口在侧边栏
+- **v2.3.2** (2026-04-16): 搜索功能修复
+  - 修复 debounce 函数定义顺序问题
+  - 搜索框输入后可正常过滤列表
+- **v2.3.1** (2026-04-16): 日期放到标题后面，不增加卡片高度
+  - 日期紧跟标题，同一行显示
+  - 格式紧凑：`04-16 11:09→04-16 12:00`
+- **v2.3.0** (2026-04-16): 卡片显示创建和更新日期
+  - 每个收藏卡片底部显示日期
+  - 格式：04-16 11:09（月-日 时:分）
+  - 有更新时显示：创建 → 更新
+  - 字体更小更淡，不影响卡片高度
+- **v2.2.0** (2026-04-16): 快捷添加按钮，一键选择类型
+  - 顶部按钮栏分离为4个快捷添加按钮（文本、链接、待办、专栏）
+  - 点击直接进入对应类型的添加弹窗
+  - 弹窗标题显示类型图标和名称
+  - 不再需要下拉选择类型，操作更快捷
+- **v2.1.0** (2026-04-16): 待办截止时间支持日期+时间
+  - 截止日期改为日期时间选择器
+  - 列表显示友好格式：今天 18:30、明天 09:00 等
+  - 详情页显示完整格式：2026年4月16日 18:30
+  - 后端支持多种日期格式解析
+  - 只有日期的待办视为当天 23:59 到期
+- **v2.0.1** (2026-04-16): 转换弹窗优化
+  - 内容预览保留换行格式，提高可读性
+  - 转换方式默认改为复制创建
+- **v2.0.0** (2026-04-16): 收藏转待办功能（大版本更新）
+  - 新增 `/api/items/<id>/convert` API
+  - **直接转换**：原收藏变为待办，数据合并
+  - **复制创建**：保留原收藏，新建待办任务
+  - 文本/链接/专栏类型可转换
+  - 内容自动合并到待办备注
+  - 前端列表和详情页添加转换按钮
+  - 弹窗配置：标题、状态、优先级、截止日期
+- v1.11.0 (2026-04-16): 已完成待办可重新打开
+  - 新增 `/api/items/<id>/reopen` 接口
+  - 前端列表已完成待办显示重新打开按钮（↻图标）
+  - 可恢复为 pending 或 in_progress 状态
 - v1.10.0 (2026-04-16): 网页端待办到期提醒功能
   - 新增提醒 API `/api/reminders`
   - 获取已过期、今天到期、即将到期的待办

scripts/auto_backup.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python3
+"""
+Xian Favor 自动备份脚本
+定时任务调用此脚本进行自动备份
+"""
+
+import sys
+import os
+
+# 添加项目路径
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from xian_favor.db import db
+
+def main():
+    """执行自动备份"""
+    print(f"[{datetime.now().isoformat()}] 开始自动备份...")
+    
+    try:
+        backup_info = db.create_backup(manual=False)
+        print(f"备份成功: {backup_info['name']}")
+        print(f"大小: {backup_info['size']} bytes")
+        print(f"位置: {backup_info['path']}")
+        
+        # 清理旧备份
+        db._cleanup_old_backups()
+        print("旧备份清理完成")
+        
+    except Exception as e:
+        print(f"备份失败: {e}")
+        sys.exit(1)
+
+if __name__ == '__main__':
+    from datetime import datetime
+    main()

xian_favor/db.py

@@ -2,12 +2,17 @@
 
 import sqlite3
 import json
-from datetime import datetime
+import shutil
+import os
+from datetime import datetime, timedelta
 from typing import Optional, List, Dict, Any
 from contextlib import contextmanager
 
 from .config import DATABASE_URL, TODO_STATUS, PRIORITY_LEVELS
 
+# 备份目录
+BACKUP_DIR = os.path.join(os.path.dirname(DATABASE_URL), 'backups')
+
 
 class Database:
     """SQLite数据库管理"""
@@ -54,6 +59,8 @@ class Database:
                     priority TEXT DEFAULT 'medium',
                     due_date TEXT,
                     note TEXT,
+                    is_starred INTEGER DEFAULT 0,
+                    views INTEGER DEFAULT 0,
                     created_at TEXT NOT NULL,
                     updated_at TEXT NOT NULL
                 )
@@ -109,6 +116,21 @@ class Database:
             cursor.execute("CREATE INDEX IF NOT EXISTS idx_item_tags_item ON item_tags(item_id)")
             cursor.execute("CREATE INDEX IF NOT EXISTS idx_item_tags_tag ON item_tags(tag_id)")
             
+            # 检查并添加 is_starred 字段（兼容旧数据库）
+            try:
+                cursor.execute("SELECT is_starred FROM items LIMIT 1")
+            except sqlite3.OperationalError:
+                cursor.execute("ALTER TABLE items ADD COLUMN is_starred INTEGER DEFAULT 0")
+            
+            # 创建 is_starred 索引（字段添加后再创建）
+            cursor.execute("CREATE INDEX IF NOT EXISTS idx_items_starred ON items(is_starred)")
+            
+            # 检查并添加 views 字段（兼容旧数据库）
+            try:
+                cursor.execute("SELECT views FROM items LIMIT 1")
+            except sqlite3.OperationalError:
+                cursor.execute("ALTER TABLE items ADD COLUMN views INTEGER DEFAULT 0")
+            
             conn.commit()
     
     # ============ Item 操作 ============
@@ -116,7 +138,7 @@ class Database:
     def create_item(self, type: str = "text", title: str = None, content: str = None,
                     url: str = None, source: str = None, status: str = "pending",
                     priority: str = "medium", due_date: str = None, note: str = None,
-                    tags: List[str] = None) -> int:
+                    tags: List[str] = None, is_starred: bool = False) -> int:
         """创建新条目"""
         self._ensure_init()
         now = datetime.now().isoformat()
@@ -130,9 +152,9 @@ class Database:
         with self.get_conn() as conn:
             cursor = conn.cursor()
             cursor.execute("""
-                INSERT INTO items (type, title, content, url, source, status, priority, due_date, note, created_at, updated_at)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-            """, (type, title, content, url, source, status, priority, due_date, note, now, now))
+                INSERT INTO items (type, title, content, url, source, status, priority, due_date, note, is_starred, created_at, updated_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """, (type, title, content, url, source, status, priority, due_date, note, 1 if is_starred else 0, now, now))
             item_id = cursor.lastrowid
             
             # 添加标签
@@ -156,8 +178,13 @@ class Database:
             return item
     
     def list_items(self, type: str = None, status: str = None, tag: str = None,
-                   keyword: str = None, limit: int = 50, offset: int = 0) -> List[Dict[str, Any]]:
-        """列出条目"""
+                   keyword: str = None, starred: bool = None, sort_by: str = None,
+                   sort_order: str = None, limit: int = 50, offset: int = 0) -> List[Dict[str, Any]]:
+        """列出条目
+        
+        sort_by: created_at, updated_at
+        sort_order: desc, asc
+        """
         with self.get_conn() as conn:
             cursor = conn.cursor()
             
@@ -179,6 +206,10 @@ class Database:
                 conditions.append("i.status = ?")
                 params.append(status)
             
+            if starred is not None:
+                conditions.append("i.is_starred = ?")
+                params.append(1 if starred else 0)
+            
             if keyword:
                 conditions.append("(i.title LIKE ? OR i.content LIKE ? OR i.note LIKE ?)")
                 keyword_pattern = f"%{keyword}%"
@@ -187,7 +218,31 @@ class Database:
             if conditions:
                 query += " WHERE " + " AND ".join(conditions)
             
-            query += " ORDER BY i.created_at DESC LIMIT ? OFFSET ?"
+            # 排序逻辑
+            if sort_by == 'updated_at':
+                order_field = 'i.updated_at'
+            elif sort_by == 'created_at':
+                order_field = 'i.created_at'
+            else:
+                # 默认：重点关注优先 + 创建时间降序
+                order_field = 'i.created_at'
+            
+            order_dir = 'DESC' if (sort_order == 'asc' or sort_order is None) else 'ASC'
+            # 这里反转逻辑：用户选择"降序"时用DESC，选择"升序"时用ASC
+            
+            if sort_order == 'asc':
+                order_dir = 'ASC'
+            elif sort_order == 'desc':
+                order_dir = 'DESC'
+            else:
+                order_dir = 'DESC'  # 默认降序
+            
+            # 如果有指定排序字段，按该字段排序；否则默认重点关注优先
+            if sort_by:
+                query += f" ORDER BY {order_field} {order_dir} LIMIT ? OFFSET ?"
+            else:
+                # 默认：重点关注优先，然后创建时间降序
+                query += f" ORDER BY i.is_starred DESC, i.created_at DESC LIMIT ? OFFSET ?"
             params.extend([limit, offset])
             
             cursor.execute(query, params)
@@ -199,11 +254,51 @@ class Database:
             
             return items
     
+    def count_items(self, type: str = None, status: str = None, tag: str = None,
+                    keyword: str = None, starred: bool = None) -> int:
+        """计算符合条件的条目总数"""
+        with self.get_conn() as conn:
+            cursor = conn.cursor()
+            
+            query = "SELECT COUNT(DISTINCT i.id) as count FROM items i"
+            params = []
+            conditions = []
+            
+            # 标签过滤需要JOIN
+            if tag:
+                query += " JOIN item_tags it ON i.id = it.item_id JOIN tags t ON it.tag_id = t.id"
+                conditions.append("t.name = ?")
+                params.append(tag)
+            
+            if type:
+                conditions.append("i.type = ?")
+                params.append(type)
+            
+            if status:
+                conditions.append("i.status = ?")
+                params.append(status)
+            
+            if starred is not None:
+                conditions.append("i.is_starred = ?")
+                params.append(1 if starred else 0)
+            
+            if keyword:
+                conditions.append("(i.title LIKE ? OR i.content LIKE ? OR i.note LIKE ?)")
+                keyword_pattern = f"%{keyword}%"
+                params.extend([keyword_pattern, keyword_pattern, keyword_pattern])
+            
+            if conditions:
+                query += " WHERE " + " AND ".join(conditions)
+            
+            cursor.execute(query, params)
+            return cursor.fetchone()['count']
+    
     def update_item(self, item_id: int, **kwargs) -> bool:
         """更新条目"""
-        allowed_fields = ['type', 'title', 'content', 'url', 'source', 'status', 'priority', 'due_date', 'note']
+        allowed_fields = ['type', 'title', 'content', 'url', 'source', 'status', 'priority', 'due_date', 'note', 'is_starred']
         update_fields = {k: v for k, v in kwargs.items() if k in allowed_fields}
         
+        # 只有 tags 变化也算有效更新
         if not update_fields and 'tags' not in kwargs:
             return False
         
@@ -212,6 +307,11 @@ class Database:
         with self.get_conn() as conn:
             cursor = conn.cursor()
             
+            # 检查条目是否存在
+            cursor.execute("SELECT id FROM items WHERE id = ?", (item_id,))
+            if not cursor.fetchone():
+                return False
+            
             if update_fields:
                 set_clause = ", ".join(f"{k} = ?" for k in update_fields.keys())
                 set_clause += ", updated_at = ?"
@@ -226,7 +326,7 @@ class Database:
                     self._add_tags_to_item(conn, item_id, kwargs['tags'])
             
             conn.commit()
-            return cursor.rowcount > 0
+            return True
     
     def delete_item(self, item_id: int) -> bool:
         """删除条目"""
@@ -236,6 +336,39 @@ class Database:
             conn.commit()
             return cursor.rowcount > 0
     
+    def toggle_star(self, item_id: int) -> bool:
+        """切换重点关注状态"""
+        with self.get_conn() as conn:
+            cursor = conn.cursor()
+            # 先获取当前状态
+            cursor.execute("SELECT is_starred FROM items WHERE id = ?", (item_id,))
+            row = cursor.fetchone()
+            if not row:
+                return False
+            
+            new_status = 0 if row['is_starred'] else 1
+            now = datetime.now().isoformat()
+            cursor.execute("UPDATE items SET is_starred = ?, updated_at = ? WHERE id = ?", (new_status, now, item_id))
+            conn.commit()
+            return True
+    
+    def set_star(self, item_id: int, starred: bool = True) -> bool:
+        """设置重点关注状态"""
+        with self.get_conn() as conn:
+            cursor = conn.cursor()
+            now = datetime.now().isoformat()
+            cursor.execute("UPDATE items SET is_starred = ?, updated_at = ? WHERE id = ?", (1 if starred else 0, now, item_id))
+            conn.commit()
+            return cursor.rowcount > 0
+    
+    def increment_views(self, item_id: int) -> bool:
+        """增加阅读数"""
+        with self.get_conn() as conn:
+            cursor = conn.cursor()
+            cursor.execute("UPDATE items SET views = views + 1 WHERE id = ?", (item_id,))
+            conn.commit()
+            return cursor.rowcount > 0
+    
     # ============ Tag 操作 ============
     
     def create_tag(self, name: str, color: str = "#3498db") -> int:
@@ -464,21 +597,36 @@ class Database:
                 item['tags'] = self._get_item_tags(conn, item['id'])
                 
                 try:
-                    due_date = datetime.strptime(item['due_date'], '%Y-%m-%d')
-                    # 计算距离到期的时间
-                    days_left = (due_date.date() - now.date()).days
+                    due_date_str = item['due_date']
+                    # 支持多种日期格式
+                    if 'T' in due_date_str:
+                        # ISO 格式：2026-04-16T14:30
+                        due_date = datetime.strptime(due_date_str[:16], '%Y-%m-%dT%H:%M')
+                    elif len(due_date_str) == 10:
+                        # 只有日期：2026-04-16，视为当天 23:59:59
+                        due_date = datetime.strptime(due_date_str, '%Y-%m-%d').replace(hour=23, minute=59, second=59)
+                    else:
+                        # 其他格式，尝试解析
+                        due_date = datetime.strptime(due_date_str.split('.')[0], '%Y-%m-%dT%H:%M:%S')
                     
-                    if days_left < 0:
+                    # 计算距离到期的时间
+                    time_left = due_date - now
+                    
+                    if time_left.total_seconds() < 0:
                         # 已过期
-                        item['days_overdue'] = abs(days_left)
+                        days_overdue = abs(int(time_left.total_seconds() / 86400))
+                        item['days_overdue'] = days_overdue
                         reminders['overdue'].append(item)
-                    elif days_left == 0:
-                        # 今天到期
+                    elif time_left.total_seconds() < 86400:  # 24小时内
+                        # 判断是今天还是明天
+                        if due_date.date() == now.date():
+                            reminders['due_today'].append(item)
+                        else:
+                            reminders['due_soon'].append(item)
+                    elif due_date.date() == now.date():
+                        # 今天到期（超过24小时的情况，比如现在凌晨，截止时间是晚上）
                         reminders['due_today'].append(item)
-                    elif days_left == 1:
-                        # 明天到期（24小时内）
-                        reminders['due_soon'].append(item)
-                except ValueError:
+                except (ValueError, AttributeError) as e:
                     # 日期格式错误，跳过
                     continue
             
@@ -486,6 +634,184 @@ class Database:
             reminders['total'] = len(reminders['overdue']) + len(reminders['due_today']) + len(reminders['due_soon'])
             
             return reminders
+    
+    # ============ 备份操作 ============
+    
+    def create_backup(self, manual: bool = False) -> Dict[str, Any]:
+        """创建数据库备份"""
+        import os
+        
+        # 确保备份目录存在
+        os.makedirs(BACKUP_DIR, exist_ok=True)
+        
+        now = datetime.now()
+        backup_name = now.strftime('%Y-%m-%d_%H%M%S')
+        if manual:
+            backup_name += '_manual'
+        backup_path = os.path.join(BACKUP_DIR, f'{backup_name}.db')
+        
+        # 复制数据库文件
+        shutil.copy2(self.db_path, backup_path)
+        
+        # 获取备份信息
+        backup_info = {
+            'name': backup_name,
+            'path': backup_path,
+            'size': os.path.getsize(backup_path),
+            'created_at': now.isoformat(),
+            'manual': manual,
+            'is_first_of_month': now.day == 1
+        }
+        
+        # 保存备份元数据
+        self._save_backup_meta(backup_info)
+        
+        # 清理旧备份
+        self._cleanup_old_backups()
+        
+        return backup_info
+    
+    def list_backups(self) -> List[Dict[str, Any]]:
+        """列出所有备份"""
+        import os
+        
+        if not os.path.exists(BACKUP_DIR):
+            return []
+        
+        # 读取备份元数据
+        meta_path = os.path.join(BACKUP_DIR, 'backup_meta.json')
+        if os.path.exists(meta_path):
+            with open(meta_path, 'r') as f:
+                backups = json.load(f)
+        else:
+            # 从文件重建元数据
+            backups = []
+            for f in os.listdir(BACKUP_DIR):
+                if f.endswith('.db'):
+                    path = os.path.join(BACKUP_DIR, f)
+                    backups.append({
+                        'name': f.replace('.db', ''),
+                        'path': path,
+                        'size': os.path.getsize(path),
+                        'created_at': datetime.fromtimestamp(os.path.getmtime(path)).isoformat(),
+                        'manual': '_manual' in f,
+                        'is_first_of_month': self._is_first_of_month_filename(f)
+                    })
+        
+        # 按时间倒序排列
+        backups.sort(key=lambda x: x['created_at'], reverse=True)
+        
+        return backups
+    
+    def restore_backup(self, backup_name: str) -> bool:
+        """恢复备份"""
+        import os
+        
+        backup_path = os.path.join(BACKUP_DIR, f'{backup_name}.db')
+        if not os.path.exists(backup_path):
+            return False
+        
+        # 先备份当前数据库（以防万一）
+        current_backup = self.db_path + '.before_restore'
+        shutil.copy2(self.db_path, current_backup)
+        
+        # 恢复备份
+        shutil.copy2(backup_path, self.db_path)
+        
+        return True
+    
+    def delete_backup(self, backup_name: str) -> bool:
+        """删除备份"""
+        import os
+        
+        backup_path = os.path.join(BACKUP_DIR, f'{backup_name}.db')
+        if not os.path.exists(backup_path):
+            return False
+        
+        os.remove(backup_path)
+        
+        # 更新元数据
+        self._remove_backup_meta(backup_name)
+        
+        return True
+    
+    def _save_backup_meta(self, backup_info: Dict[str, Any]):
+        """保存备份元数据"""
+        import os
+        
+        meta_path = os.path.join(BACKUP_DIR, 'backup_meta.json')
+        
+        # 读取现有元数据
+        backups = []
+        if os.path.exists(meta_path):
+            with open(meta_path, 'r') as f:
+                backups = json.load(f)
+        
+        # 添加新备份
+        backups.append(backup_info)
+        
+        # 保存
+        with open(meta_path, 'w') as f:
+            json.dump(backups, f, indent=2)
+    
+    def _remove_backup_meta(self, backup_name: str):
+        """从元数据中删除备份"""
+        import os
+        
+        meta_path = os.path.join(BACKUP_DIR, 'backup_meta.json')
+        if not os.path.exists(meta_path):
+            return
+        
+        with open(meta_path, 'r') as f:
+            backups = json.load(f)
+        
+        backups = [b for b in backups if b['name'] != backup_name]
+        
+        with open(meta_path, 'w') as f:
+            json.dump(backups, f, indent=2)
+    
+    def _is_first_of_month_filename(self, filename: str) -> bool:
+        """判断是否是每月第一天的备份"""
+        # 格式：2026-04-01_040000.db 或 2026-05-01_...
+        try:
+            date_part = filename.split('_')[0]
+            day = int(date_part.split('-')[2])
+            return day == 1
+        except:
+            return False
+    
+    def _cleanup_old_backups(self):
+        """清理旧备份：保留30天 + 每月第一天"""
+        import os
+        
+        backups = self.list_backups()
+        now = datetime.now()
+        keep_paths = []
+        
+        for backup in backups:
+            backup_date = datetime.fromisoformat(backup['created_at'])
+            days_old = (now - backup_date).days
+            
+            # 保留条件：
+            # 1. 手动备份永久保留（最多10个）
+            # 2. 30天内的备份
+            # 3. 每月第一天的备份
+            
+            if backup['manual']:
+                # 手动备份保留，但最多10个
+                manual_backups = [b for b in backups if b['manual']]
+                if manual_backups.index(backup) < 10:
+                    keep_paths.append(backup['path'])
+                else:
+                    self.delete_backup(backup['name'])
+            elif days_old <= 30:
+                keep_paths.append(backup['path'])
+            elif backup['is_first_of_month']:
+                # 每月第一天永久保留
+                keep_paths.append(backup['path'])
+            else:
+                # 删除
+                self.delete_backup(backup['name'])
 
 
 # 全局数据库实例