Merge pull request #50 from x1ao4/dev

优化剧集编号提取逻辑，避免误提取 4K 中的数字

.dockerignore

@@ -1,4 +1,4 @@
 .git
 .github
 __pycache__
-/img
+README.md

app/static/css/main.css

@@ -2885,6 +2885,19 @@ div.jsoneditor-treepath * {
   .pagination-settings .dropdown-toggle {
     height: 32px;
   }
+
+  /* 移动端分页按钮优化：确保不换行 */
+  .pagination-controls {
+    flex-wrap: nowrap !important; /* 强制不换行 */
+    max-width: 100%;
+    overflow-x: auto;
+    scrollbar-width: none; /* Firefox */
+    -ms-overflow-style: none; /* IE and Edge */
+  }
+  
+  .pagination-controls::-webkit-scrollbar {
+    display: none; /* Chrome, Safari and Opera */
+  }
 }
 
 .pagination-settings {

app/static/js/sort_file_by_name.js

@@ -154,7 +154,7 @@ function sortFileByName(file) {
             const resolution_patterns = [
                 /\b\d+[pP]\b/g,  // 匹配 720p, 1080P, 2160p 等
                 /\b\d+x\d+\b/g,  // 匹配 1920x1080 等
-                // 注意：不移除4K/8K，因为剧集匹配规则中有 (\d+)[-_\s]*4[Kk] 模式
+                // 注意：不移除4K/8K，避免误删文件名中的4K标识
             ];
 
             for (const pattern of resolution_patterns) {

app/templates/index.html

@@ -2081,7 +2081,7 @@
             anime_save_path: "动画目录前缀/剧名 (年份)/剧名 - S季数",
             variety_save_path: "综艺目录前缀/剧名 (年份)/剧名 - S季数",
             documentary_save_path: "纪录片目录前缀/剧名 (年份)/剧名 - S季数",
-            movie_naming_pattern: "^(.*)\.([^.]+)",
+            movie_naming_pattern: "^(.*)\\.([^.]+)",
             movie_naming_replace: "片名 (年份).\\2",
             tv_naming_rule: "剧名 - S季数E[]",
             tv_ignore_extension: true
@@ -3178,18 +3178,18 @@
                   anime_save_path: "动画目录前缀/剧名 (年份)/剧名 - S季数",
                   variety_save_path: "综艺目录前缀/剧名 (年份)/剧名 - S季数",
                   documentary_save_path: "纪录片目录前缀/剧名 (年份)/剧名 - S季数",
-                  movie_naming_pattern: "^(.*)\.([^.]+)",
+                  movie_naming_pattern: "^(.*)\\.([^.]+)",
                   movie_naming_replace: "片名 (年份).\\2",
                   tv_naming_rule: "剧名 - S季数E[]",
                   tv_ignore_extension: true,
                   auto_search_resources: "enabled"
                 };
               }
-              // 确保电影命名规则字段存在
-              if (!config_data.task_settings.movie_naming_pattern) {
-                config_data.task_settings.movie_naming_pattern = "^(.*)\.([^.]+)";
+              // 确保电影命名规则字段存在，只在字段不存在时设置默认值，允许用户设置为空字符串
+              if (config_data.task_settings.movie_naming_pattern === undefined) {
+                config_data.task_settings.movie_naming_pattern = "^(.*)\\.([^.]+)";
               }
-              if (!config_data.task_settings.movie_naming_replace) {
+              if (config_data.task_settings.movie_naming_replace === undefined) {
                 config_data.task_settings.movie_naming_replace = "片名 (年份).\\2";
               }
               // 确保电视忽略后缀设置存在
@@ -5017,31 +5017,54 @@
         getVisiblePageNumbers() {
           const current = parseInt(this.historyParams.page) || 1;
           const total = parseInt(this.totalPages) || 1;
-          const delta = 2; // 当前页左右显示的页码数
+          // 根据屏幕宽度动态调整显示的页码数：移动端显示较少页码，桌面端显示较多页码
+          const isMobile = window.innerWidth <= 768;
+          const delta = isMobile ? 1 : 2; // 移动端左右各显示1个页码，桌面端左右各显示2个页码
           
           // 处理特殊情况
           if (total <= 1) return [];
           
           let range = [];
           
-          // 确定显示范围
-          let rangeStart = Math.max(2, current - delta);
-          let rangeEnd = Math.min(total - 1, current + delta);
-          
-          // 调整范围，确保显示足够的页码
-          if (rangeEnd - rangeStart < delta * 2) {
-            if (current - rangeStart < delta) {
-              // 当前页靠近开始，扩展结束范围
-              rangeEnd = Math.min(total - 1, rangeStart + delta * 2);
+          // 移动端简化逻辑：只显示当前页附近的少数页码
+          if (isMobile) {
+            // 移动端：最多显示4个中间页码按钮（不包括第1页和最后1页），总共5个页码
+            if (current <= 4) {
+              // 当前页在前面时，显示 1, 2, 3, 4
+              for (let i = 2; i <= Math.min(4, total - 1); i++) {
+                range.push(i);
+              }
+            } else if (current >= total - 3) {
+              // 当前页在后面时，显示倒数几页
+              for (let i = Math.max(2, total - 3); i <= total - 1; i++) {
+                range.push(i);
+              }
             } else {
-              // 当前页靠近结束，扩展开始范围
-              rangeStart = Math.max(2, rangeEnd - delta * 2);
+              // 当前页在中间时，显示当前页前后各1页，总共3个中间页码
+              range.push(current - 1);
+              range.push(current);
+              range.push(current + 1);
+            }
+          } else {
+            // 桌面端保持原有逻辑
+            let rangeStart = Math.max(2, current - delta);
+            let rangeEnd = Math.min(total - 1, current + delta);
+            
+            // 调整范围，确保显示足够的页码
+            if (rangeEnd - rangeStart < delta * 2) {
+              if (current - rangeStart < delta) {
+                // 当前页靠近开始，扩展结束范围
+                rangeEnd = Math.min(total - 1, rangeStart + delta * 2);
+              } else {
+                // 当前页靠近结束，扩展开始范围
+                rangeStart = Math.max(2, rangeEnd - delta * 2);
+              }
+            }
+            
+            // 生成页码数组
+            for (let i = rangeStart; i <= rangeEnd; i++) {
+              range.push(i);
             }
-          }
-          
-          // 生成页码数组
-          for (let i = rangeStart; i <= rangeEnd; i++) {
-            range.push(i);
           }
           
           return range;
@@ -6273,31 +6296,54 @@
         getVisibleFolderPageNumbers() {
           const current = parseInt(this.fileManager.currentPage) || 1;
           const total = parseInt(this.fileManager.totalPages) || 1;
-          const delta = 2; // 当前页左右显示的页码数
+          // 根据屏幕宽度动态调整显示的页码数：移动端显示较少页码，桌面端显示较多页码
+          const isMobile = window.innerWidth <= 768;
+          const delta = isMobile ? 1 : 2; // 移动端左右各显示1个页码，桌面端左右各显示2个页码
           
           // 处理特殊情况
           if (total <= 1) return [];
           
           let range = [];
           
-          // 确定显示范围
-          let rangeStart = Math.max(2, current - delta);
-          let rangeEnd = Math.min(total - 1, current + delta);
-          
-          // 调整范围，确保显示足够的页码
-          if (rangeEnd - rangeStart < delta * 2) {
-            if (current - rangeStart < delta) {
-              // 当前页靠近开始，扩展结束范围
-              rangeEnd = Math.min(total - 1, rangeStart + delta * 2);
+          // 移动端简化逻辑：只显示当前页附近的少数页码
+          if (isMobile) {
+            // 移动端：最多显示4个中间页码按钮（不包括第1页和最后1页），总共5个页码
+            if (current <= 4) {
+              // 当前页在前面时，显示 1, 2, 3, 4
+              for (let i = 2; i <= Math.min(4, total - 1); i++) {
+                range.push(i);
+              }
+            } else if (current >= total - 3) {
+              // 当前页在后面时，显示倒数几页
+              for (let i = Math.max(2, total - 3); i <= total - 1; i++) {
+                range.push(i);
+              }
             } else {
-              // 当前页靠近结束，扩展开始范围
-              rangeStart = Math.max(2, rangeEnd - delta * 2);
+              // 当前页在中间时，显示当前页前后各1页，总共3个中间页码
+              range.push(current - 1);
+              range.push(current);
+              range.push(current + 1);
+            }
+          } else {
+            // 桌面端保持原有逻辑
+            let rangeStart = Math.max(2, current - delta);
+            let rangeEnd = Math.min(total - 1, current + delta);
+            
+            // 调整范围，确保显示足够的页码
+            if (rangeEnd - rangeStart < delta * 2) {
+              if (current - rangeStart < delta) {
+                // 当前页靠近开始，扩展结束范围
+                rangeEnd = Math.min(total - 1, rangeStart + delta * 2);
+              } else {
+                // 当前页靠近结束，扩展开始范围
+                rangeStart = Math.max(2, rangeEnd - delta * 2);
+              }
+            }
+            
+            // 生成页码数组
+            for (let i = rangeStart; i <= rangeEnd; i++) {
+              range.push(i);
             }
-          }
-          
-          // 生成页码数组
-          for (let i = rangeStart; i <= rangeEnd; i++) {
-            range.push(i);
           }
           
           return range;
@@ -6864,34 +6910,54 @@
         getVisibleFolderPageNumbers() {
           const current = parseInt(this.fileManager.currentPage) || 1;
           const total = parseInt(this.fileManager.totalPages) || 1;
-          const delta = 2; // 当前页左右显示的页码数
+          // 根据屏幕宽度动态调整显示的页码数：移动端显示较少页码，桌面端显示较多页码
+          const isMobile = window.innerWidth <= 768;
+          const delta = isMobile ? 1 : 2; // 移动端左右各显示1个页码，桌面端左右各显示2个页码
           
           // 处理特殊情况
           if (total <= 1) return [];
-          if (total <= 5) {
-            return Array.from({ length: total - 2 }, (_, i) => i + 2);
-          }
           
           let range = [];
           
-          // 确定显示范围
-          let rangeStart = Math.max(2, current - delta);
-          let rangeEnd = Math.min(total - 1, current + delta);
-          
-          // 调整范围，确保显示足够的页码
-          if (rangeEnd - rangeStart < delta * 2) {
-            if (current - rangeStart < delta) {
-              // 当前页靠近开始，扩展结束范围
-              rangeEnd = Math.min(total - 1, rangeStart + delta * 2);
+          // 移动端简化逻辑：只显示当前页附近的少数页码
+          if (isMobile) {
+            // 移动端：最多显示4个中间页码按钮（不包括第1页和最后1页），总共5个页码
+            if (current <= 4) {
+              // 当前页在前面时，显示 1, 2, 3, 4
+              for (let i = 2; i <= Math.min(4, total - 1); i++) {
+                range.push(i);
+              }
+            } else if (current >= total - 3) {
+              // 当前页在后面时，显示倒数几页
+              for (let i = Math.max(2, total - 3); i <= total - 1; i++) {
+                range.push(i);
+              }
             } else {
-              // 当前页靠近结束，扩展开始范围
-              rangeStart = Math.max(2, rangeEnd - delta * 2);
+              // 当前页在中间时，显示当前页前后各1页，总共3个中间页码
+              range.push(current - 1);
+              range.push(current);
+              range.push(current + 1);
+            }
+          } else {
+            // 桌面端保持原有逻辑
+            let rangeStart = Math.max(2, current - delta);
+            let rangeEnd = Math.min(total - 1, current + delta);
+            
+            // 调整范围，确保显示足够的页码
+            if (rangeEnd - rangeStart < delta * 2) {
+              if (current - rangeStart < delta) {
+                // 当前页靠近开始，扩展结束范围
+                rangeEnd = Math.min(total - 1, rangeStart + delta * 2);
+              } else {
+                // 当前页靠近结束，扩展开始范围
+                rangeStart = Math.max(2, rangeEnd - delta * 2);
+              }
+            }
+            
+            // 生成页码数组
+            for (let i = rangeStart; i <= rangeEnd; i++) {
+              range.push(i);
             }
-          }
-          
-          // 生成页码数组
-          for (let i = rangeStart; i <= rangeEnd; i++) {
-            range.push(i);
           }
           
           return range;

quark_auto_save.py

@@ -215,7 +215,7 @@ def sort_file_by_name(file):
             resolution_patterns = [
                 r'\b\d+[pP]\b',  # 匹配 720p, 1080P, 2160p 等
                 r'\b\d+x\d+\b',  # 匹配 1920x1080 等
-                # 注意：不移除4K/8K，因为剧集匹配规则中有 (\d+)[-_\s]*4[Kk] 模式
+                # 注意：不移除4K/8K，避免误删文件名中的4K标识
             ]
 
             for pattern in resolution_patterns:
@@ -394,7 +394,7 @@ def extract_episode_number(filename, episode_patterns=None, config_data=None):
     resolution_patterns = [
         r'\b\d+[pP]\b',  # 匹配 720p, 1080P, 2160p 等
         r'\b\d+x\d+\b',  # 匹配 1920x1080 等
-        # 注意：不移除4K/8K，因为剧集匹配规则中有 (\d+)[-_\s]*4[Kk] 模式
+        # 注意：不移除4K/8K，避免误删文件名中的4K标识
     ]
 
     for pattern in resolution_patterns:
@@ -423,6 +423,41 @@ def extract_episode_number(filename, episode_patterns=None, config_data=None):
     if match_e:
         return int(match_e.group(1))
     
+    # 添加中文数字匹配模式（优先匹配）
+    chinese_patterns = [
+        r'第([一二三四五六七八九十百千万零两]+)集',
+        r'第([一二三四五六七八九十百千万零两]+)期',
+        r'第([一二三四五六七八九十百千万零两]+)话',
+        r'([一二三四五六七八九十百千万零两]+)集',
+        r'([一二三四五六七八九十百千万零两]+)期',
+        r'([一二三四五六七八九十百千万零两]+)话'
+    ]
+    
+    # 优先匹配中文数字模式
+    for pattern_regex in chinese_patterns:
+        try:
+            match = re.search(pattern_regex, filename_without_dates)
+            if match:
+                chinese_num = match.group(1)
+                arabic_num = chinese_to_arabic(chinese_num)
+                if arabic_num is not None:
+                    return arabic_num
+        except:
+            continue
+    
+    # 智能4K匹配：检查是否匹配到4K模式，但要验证这个匹配是否合理
+    match_4k = re.search(r'(\d+)[-_\s]*4[Kk]', filename_without_dates)
+    if match_4k:
+        episode_num = int(match_4k.group(1))
+        # 检查文件名中是否已经有明确的剧集标识（中文数字或阿拉伯数字）
+        has_episode_indicator = re.search(r'第[一二三四五六七八九十百千万零两]+[期集话]|第\d+[期集话]', filename_without_dates)
+        if has_episode_indicator:
+            # 如果已经有明确的剧集标识，跳过4K匹配，避免冲突
+            pass
+        else:
+            # 没有明确的剧集标识，4K匹配有效
+            return episode_num
+    
     # 尝试匹配更多格式（注意：避免匹配季数）
     default_patterns = [
         r'第(\d+)集',
@@ -438,16 +473,6 @@ def extract_episode_number(filename, episode_patterns=None, config_data=None):
         r'_?(\d+)_?'
     ]
     
-    # 添加中文数字匹配模式
-    chinese_patterns = [
-        r'第([一二三四五六七八九十百千万零两]+)集',
-        r'第([一二三四五六七八九十百千万零两]+)期',
-        r'第([一二三四五六七八九十百千万零两]+)话',
-        r'([一二三四五六七八九十百千万零两]+)集',
-        r'([一二三四五六七八九十百千万零两]+)期',
-        r'([一二三四五六七八九十百千万零两]+)话'
-    ]
-    
     patterns = None
     
     # 检查传入的episode_patterns参数
@@ -529,18 +554,6 @@ def extract_episode_number(filename, episode_patterns=None, config_data=None):
         except:
             continue
     
-    # 尝试匹配中文数字模式
-    for pattern_regex in chinese_patterns:
-        try:
-            match = re.search(pattern_regex, filename_without_dates)
-            if match:
-                chinese_num = match.group(1)
-                arabic_num = chinese_to_arabic(chinese_num)
-                if arabic_num is not None:
-                    return arabic_num
-        except:
-            continue
-    
     # 如果文件名是纯数字，且不是日期格式，则可能是剧集号
     if filename_without_dates.isdigit() and not is_date_format(filename_without_dates):
         return int(filename_without_dates)