选品辅助粘贴脚本（更新中）

点击查看

需要先安装Python环境，然后安装pyautogui和pyperclip库：python -m pip install pyautogui pyperclip

import pyautogui
import pyperclip
import time
import re

def paste_and_enter():
    pyautogui.hotkey('ctrl', 'v')
    pyautogui.press('enter')

def save_file():
    pyautogui.hotkey('ctrl', 's')

def is_strict_single_pdd_url(content):
    """严格检查剪贴板内容是否仅包含单个拼多多链接"""
    content = content.strip()
    
    # 正则规则：
    # 1. 必须以 https://mobile.yangkeduo.com/ 开头
    # 2. 后面不能包含 https://（防止多个URL粘连）
    # 3. 不能有空格或换行符
    pattern = r'^https://mobile\.yangkeduo\.com/[^?\s]+(\?[^\s]+)?$'
    
    # 额外检查：确保整个字符串没有多个 "https://"
    if content.count("https://") > 1:
        return False
    
    return bool(re.fullmatch(pattern, content))

def main():
    print("剪贴板监听程序已启动，仅当复制 **严格单个** 拼多多链接时执行操作。")
    print("按 Ctrl + C 停止程序。")
    
    last_clipboard_content = pyperclip.paste()
    
    try:
        while True:
            current_clipboard_content = pyperclip.paste()
            if current_clipboard_content != last_clipboard_content:
                if is_strict_single_pdd_url(current_clipboard_content):
                    print(f"✅ 检测到单个拼多多链接，执行操作：{current_clipboard_content}")
                    paste_and_enter()
                    time.sleep(0.5)
                    save_file()
                    print("粘贴+保存操作已完成。")
                else:
                    if "https://mobile.yangkeduo.com" in current_clipboard_content:
                        print("⚠ 检测到多个拼多多链接或其他非法格式，跳过操作。")
                    else:
                        print(f"❌ 剪贴板内容不是拼多多链接，不执行操作：{current_clipboard_content[:50]}...")
                last_clipboard_content = current_clipboard_content
            time.sleep(0.5)
    except KeyboardInterrupt:
        print("程序已停止。")

if __name__ == "__main__":
    main()

智能店长自动填写属性脚本

点击查看

直接粘贴在浏览器开发者工具的控制台运行即可，期间标签页不能切换页面

(function() {
  /************************** [配置区域] 可自由修改 **************************/
  const config = {

    // 违禁词检测
    forbiddenKeywords: ['纯棉', '100%', '出口外贸', '欧货', '特价', '爆款', '含棉', '现货', '捡漏', '实拍', '欧洲站'],

    // 关键词匹配规则（增强版）
    keywordRules: {
      '风格': {
        patterns: [
          { match: /法式/, value: '法式' },
          { match: /纯欲/, value: '纯欲风' },
          { match: /辣妹/, value: '辣妹风' },
          { match: /性感/, value: '性感风' },
          { match: /新中式/, value: '新中式' },
          { match: /国风/, value: '中国风' },
          { match: /民族/, value: '民族风' },
          { match: /欧美/, value: '欧美风' },
          { match: /可爱/, value: '可爱风' },
          { match: /港风/, value: '复古港风' }
        ],
        multiMatch: false
      },
      '适用季节': {
        patterns: [
          { match: /春/, value: '春季' },
          { match: /夏/, value: '夏季' },
          { match: /度假/, value: '夏季' },
          { match: /秋/, value: '秋季' }
        ],
        multiMatch: false
      },
      '图案': {
        patterns: [
          { match: /波点/, value: '波点' },
          { match: /条纹/, value: '条纹' },
          { match: /花朵/, value: '植物花卉' },
          { match: /格纹/, value: '格纹' }
        ],
        multiMatch: false
      },
      '组合件数': {
        patterns: [
          { match: /假两件/, value: '假两件' },
          { match: /两件套/, value: '两件' },
          { match: /两件/, value: '两件套' },
          { match: /三件套/, value: '三件' }
        ],
        multiMatch: false
      },
      '服饰工艺': {
        patterns: [
          { match: /印花/, value: '印花' },
          { match: /扎染/, value: '扎染' },
          { match: /针织/, value: '针织' },
          { match: /褶皱/, value: '褶皱' },
          { match: /植绒/, value: '植绒' },
          { match: /拼接/, value: '拼接' },
          { match: /刺绣/, value: '刺绣' },
          { match: /镂空/, value: '镂空' }
        ],
        multiMatch: false
      },
      '袖长': {
        patterns: [
          { match: /短袖/, value: '短袖' },
          { match: /长袖/, value: '长袖' },
          { match: /挂脖/, value: '无袖' },
          { match: /无袖/, value: '无袖' },
          { match: /吊带/, value: '无袖' },
          { match: /七分袖/, value: '七分袖' }
        ],
        multiMatch: false
      },
      '袖型': {
        patterns: [
          { match: /蝙蝠袖/, value: '蝙蝠袖' },
          { match: /泡泡袖/, value: '泡泡袖' },
          { match: /飞飞袖/, value: '飞飞袖' },
          { match: /小飞袖/, value: '飞飞袖' },
          { match: /露肩/, value: '露肩' },
          { match: /无袖/, value: '露肩' },
          { match: /挂脖/, value: '露肩' },
          { match: /吊带/, value: '露肩' },
        ],
        multiMatch: false
      },
      '裙长': {
        patterns: [
          { match: /短裙/, value: '短裙' },
          { match: /长裙/, value: '长裙' },
          { match: /中长裙/, value: '中长裙' }
        ],
        multiMatch: false
      },
      '裙型': {
        patterns: [
          { match: /包臀/, value: '包臀裙' },
          { match: /a字/, value: 'A字裙' },
          { match: /A字/, value: 'A字裙' },
          { match: /鱼尾/, value: '鱼尾裙' },
          { match: /百褶/, value: '百褶裙' },
          { match: /伞裙/, value: '伞裙' },
          { match: /荷叶边/, value: '荷叶边裙' },
          { match: /高腰/, value: '高腰裙' },
          { match: /蓬蓬/, value: '蓬蓬裙' },
          { match: /半身裙/, value: '半身裙' }
        ],
        multiMatch: false
      },
      '腰型': {
        patterns: [
          { match: /高腰/, value: '高腰' },
          { match: /低腰/, value: '低腰' },
          { match: /宽松/, value: '宽松腰' },
          { match: /收腰/, value: '松紧腰' },
          { match: /显瘦/, value: '松紧腰' },
          { match: /紧身/, value: '松紧腰' }
        ],
        multiMatch: false
      },
      '裤型': {
        patterns: [
          { match: /阔腿/, value: '阔腿裤' },
          { match: /哈伦裤/, value: '哈伦裤' }
        ],
        multiMatch: false
      },
      '裤长': {
        patterns: [
          { match: /短裤/, value: '短裤' },
        ],
        multiMatch: false
      },
      '衣长': {
        patterns: [
          { match: /短款/, value: '短款' },
          { match: /长款/, value: '长款' }
        ],
        multiMatch: false
      },
      '服装版型': {
        patterns: [
          { match: /修身/, value: '修身型' },
          { match: /收腰/, value: '修身型' },
        ],
        multiMatch: false
      },
      '闭合方式': {
        patterns: [
          { match: /拉链/, value: '拉链' },
        ],
        multiMatch: false
      },
      '领型': {
        patterns: [
          { match: /一字肩/, value: '一字领' },
          { match: /方领/, value: '方领' },
          { match: /圆领/, value: '圆领' },
          { match: /v领/, value: 'V领' },
          { match: /V领/, value: 'V领' },
          { match: /U领/, value: 'U型领' },
          { match: /POLO领/, value: 'POLO领' },
          { match: /polo领/, value: 'POLO领' },
        ],
        multiMatch: false
      },
      '衣门襟': {
        patterns: [
          { match: /系带/, value: '系带' }
        ],
        multiMatch: false
      },
      '流行元素': {
        patterns: [
          { match: /蕾丝/, value: '蕾丝' },
          { match: /荷叶边/, value: '荷叶边' },
          { match: /绑带/, value: '绑带' },
          { match: /镂空/, value: '镂空' },
          { match: /螺纹/, value: '螺纹' },
          { match: /扎染/, value: '扎染' },
          { match: /撞色条纹/, value: '撞色条纹' },
        ],
        multiMatch: false
      },
    },


    // 默认配置（所有分类通用）
    defaultTasks: [
      { selector: '里料材质成分含量', value: '29%及以下', fallback: ['30%-49%'], type: 'select' },
      { selector: '配料材质成分含量', value: '29%及以下', fallback: [], type: 'select' },
      { selector: '里料材质', value: '聚酯纤维（涤纶）', fallback: ['聚酯纤维'], type: 'select' },
      { selector: '配料材质', value: '聚酯纤维（涤纶）', fallback: [], type: 'select' },
      { selector: '辅料材质', value: '聚酯纤维（涤纶）', fallback: [], type: 'select' },
      { selector: '适用季节', value: '夏季', fallback: ['春季', '秋季'], type: 'select' },
      { selector: '适用人群', value: '成人', fallback: [], type: 'select' },
      { selector: '适用性别', value: '女', fallback: ['女性'], type: 'select' },
      { selector: '弹力', value: '无弹力', fallback: ['微弹力'], type: 'select' },
      { selector: '适合身材', value: 'A型', fallback: [], type: 'select' },
      { selector: '功能', value: '吸汗', fallback: ['不褪色', '透气'], type: 'select' },
      { selector: '适用场景', value: '日常', fallback: ['休闲'], type: 'select' },
      { selector: '适用年龄', value: '成人', fallback: ['18-48', '18岁以上', '18-38', '18-40'], type: 'select' },
      { selector: '图案', value: '碎花', fallback: ['拼色', '条纹'], type: 'select' },
      { selector: '图案文化', value: '创意', fallback: ['青春', '文艺'], type: 'select' },
      { selector: '风格', value: '休闲风', fallback: ['百搭', '少女风'], type: 'select' },
      { selector: '辅料材质', value: '聚酯纤维（涤纶）', fallback: ['聚酯纤维'], type: 'select' },
      { selector: '服饰工艺', value: '印花', fallback: ['印染'], type: 'select' },
      { selector: '组合件数', value: '单件', fallback: [], type: 'select' },
      { selector: '袖型', value: '常规', fallback: [], type: 'select' },
      { selector: '袖长', value: '', fallback: [], type: 'select' },
      { selector: '裙型', value: '', fallback: [], type: 'select' },
      { selector: '裙长', value: '', fallback: [], type: 'select' },
      { selector: '裤型', value: '', fallback: [], type: 'select' },
      { selector: '裤长', value: '', fallback: [], type: 'select' },
      { selector: '腰型', value: '', fallback: [], type: 'select' },
      { selector: '衣长', value: '', fallback: [], type: 'select' },
      { selector: '衣门襟', value: '', fallback: [], type: 'select' }, // 小分类独立设置
      { selector: '领型', value: '', fallback: [], type: 'select' },
      { selector: '款式', value: '', fallback: [], type: 'select' }, // 有问题，无法运行
      { selector: '服装版型', value: '', fallback: [], type: 'select' },
      { selector: '流行元素', value: '', fallback: [], type: 'select' },
      { selector: '适用人群', value: '成人', fallback: [], type: 'select' },
      { selector: '厚度', value: '薄款', fallback: [], type: 'select' },
      { selector: '闭合方式', value: '', fallback: [], type: 'select' },
    ],

    // 分类专属覆盖配置：只写 overrides 和 include
    categoryConfig: {
      '连衣裙': {
        overrides: {
          '衣门襟': { value: '套头', fallback: [], type: 'select' },
          '腰型': { value: '宽松腰', fallback: [], type: 'select' },
          '裙型': { value: 'A字裙', fallback: [], type: 'select' },
          '适用年龄': { value: '24-32', fallback: ['25-35岁', '22-46周岁', '青年（18-25周岁）'], type: 'select' }
        },
        // 袖型若没匹配到，要手动选
        include: [
          '服饰工艺', '里料材质成分含量', '配料材质成分含量',
          '里料材质', '配料材质', '适用季节', '风格', '衣门襟', '适用年龄',
          '图案', '组合件数', '袖型', '袖长', '腰型', '裙型', '裙长', '辅料材质', '功能', '领型'
        ]
      },
      '衬衫': {
        overrides: {
          // 占行
          '衣长': { value: '', fallback: ['常规'], type: 'select' },
        },
        include: [
          '适用季节', '组合件数', '流行元素', '衣长', '袖长', '袖型', '风格', '适用人群', '适用年龄', '服饰工艺', '功能', '图案', '领型', '厚度', '闭合方式'
        ]
      },
      '时尚套装': {
        overrides: {
          '适用年龄': { value: '青年（18-25周岁）', fallback: ['18周岁（含）-29周岁（不含）'], type: 'select' }
        },
        include: ['组合件数', '风格', '适用年龄']
      },
      '休闲运动套装': {
        overrides: {
          '适用年龄': { value: '青年（18-25周岁）', fallback: ['18周岁（含）-29周岁（不含）'], type: 'select' }
        },
        include: ['组合件数', '适用年龄']
      },
      '背心吊带': {
        overrides: {
          // 占行
        },
        include: ['组合件数', '风格', '服装版型']
      },
      '毛针织衫': {
        overrides: {
          '服饰工艺': { value: '', fallback: ['针织','磨毛'], type: 'select' },
          '适用性别': { value: '女', fallback: ['女性'], type: 'select' },
          '服装版型': { value: '宽松', fallback: ['修身'], type: 'select' },
          '适用年龄': { value: '18岁以上', fallback: ['18-35', '18-48', '青年（18-25周岁）'], type: 'select' },
          '衣门襟': { value: '套头', fallback: [], type: 'select' },
          '衣长': { value: '常规款', fallback: ['短款'], type: 'select' },
          '袖型': { value: '常规袖', fallback: ['花瓣袖', '包袖'], type: 'select' },
          '款式': { value: '套头款', fallback: [], type: 'select' },
        },
        // 款式默认为套头，有bug，后续加上
        include: [
          '服饰工艺', '领型', '适用性别', '服装版型', '适用年龄', '适用季节', '里料材质成分含量',
          '衣门襟', '衣长', '袖型', '袖长', '图案', '组合件数', '风格', '功能'
        ]
      },
      '蕾丝衫/雪纺衫': {
        overrides: {
          '服饰工艺': { value: '刺绣', fallback: ['印花'], type: 'select' },
          '衣门襟': { value: '套头', fallback: [], type: 'select' },
          '适用年龄': { value: '成人', fallback: ['18周岁（含）-29周岁（不含）', '29周岁（含）-39周岁（不含）'], type: 'select' },
          '流行元素': { value: '褶皱', fallback: ['印花'], type: 'select' },
        },
        include: [
          '袖型', '袖长','组合件数', '流行元素', '适用年龄', '风格', '图案'
        ]
      },
      '短裤': {
        overrides: {
          '裤长': { value: '短裤', fallback: [], type: 'select' },
        },
        include: [
          '服饰工艺', '弹力', '图案', '功能', '裤型', '风格', '适用季节', '适用人群', '裤长', '辅料材质'
        ]
      },
      'T恤': {
        overrides: {
          // 占行
        },
        include: [
          '服饰工艺', '图案','流行元素', '袖长', '衣长', '适用性别', '领型', '服装版型', '功能', '风格', '袖型', '图案文化', '适用年龄'
        ]
      },
      // 旗袍..
    }
  };

  /************************** [核心代码] **************************/
  // 获取当前商品标题
  const getProductTitle = () => {
    try {
      const activeItem = document.querySelector('.info-item-active .title');
      return activeItem?.title || activeItem?.textContent?.trim() || '';
    } catch {
      return '';
    }
  };

  // 清理标题违禁词，返回合法新标题
  const cleanTitle = (title) => {
    if (!title) return '';
    let cleaned = title;
    config.forbiddenKeywords.forEach(keyword => {
      cleaned = cleaned.replace(new RegExp(keyword, 'gi'), '');
    });
    return cleaned.replace(/\s+/g, ' ').trim();
  };

  // 修改和填入新标题
  const setTitle = (title) => {
    try {
      // 查找标题输入框
      const titleInput = document.querySelector('input[name="name"]');
      if (!titleInput) {
        console.log('❌ 标题输入框未找到');
        return;
      }

      // 设置标题值
      titleInput.value = title;
      titleInput.dispatchEvent(new Event('input', { bubbles: true }));
      titleInput.dispatchEvent(new Event('change', { bubbles: true }));
      console.log(`✅ 标题已设置为: "${title}"`);
    } catch (e) {
      console.log(`❌ 设置标题失败: ${e.message}`);
    }
  };

  // 封装标题处理逻辑（新增）
  const processTitle = () => {
    const title = getProductTitle();
    
    // 检测违禁词
    const detectedForbiddenKeywords = config.forbiddenKeywords.filter(keyword => 
      title.includes(keyword)
    );
    
    // 获取清理后的标题
    const cleanedTitle = cleanTitle(title);
  
    if (detectedForbiddenKeywords.length > 0) {
      console.log(`🔍 原始标题: "${title}"`);
      console.log(`🧹 检测到违禁词: [${detectedForbiddenKeywords.join(', ')}]`);
      console.log(`✅ 清理后标题: "${cleanedTitle}"`);
      setTitle(cleanedTitle);
    } else {
      console.log(`🔍 商品标题: "${title}" (无违禁词)`);
    }
    
    // 返回解析结果
    return parseTitle(cleanedTitle || title); // 如果没有清理过则使用原标题
  };

  // 标题属性词解析 - 返回匹配详情
  const parseTitle = (title) => {
    const result = {};
    const matchedDetails = [];
    
    if (!title) return { result, matchedDetails };

    for (const [field, rule] of Object.entries(config.keywordRules)) {
      const matchedValues = [];
      let matchedPatterns = [];
      
      for (const pattern of rule.patterns) {
        if (pattern.match.test(title)) {
          if (rule.multiMatch) {
            matchedValues.push(pattern.value);
            matchedPatterns.push(pattern.match.toString());
          } else {
            result[field] = pattern.value;
            matchedPatterns.push(pattern.match.toString());
            break;
          }
        }
      }
      
      if (rule.multiMatch && matchedValues.length) {
        result[field] = matchedValues.join('/');
      }
      
      // 记录匹配详情
      if (matchedPatterns.length > 0) {
        matchedDetails.push({
          field,
          value: result[field] || matchedValues.join('/'),
          patterns: matchedPatterns
        });
      }
    }
    
    return { result, matchedDetails };
  };

  function getCurrentDate() {
    const now = new Date();
    const year = now.getFullYear();
    const month = String(now.getMonth() + 1).padStart(2, '0');
    const day = String(now.getDate()).padStart(2, '0');
    return `${year}-${month}-${day}`;
  }

  function decodeDate(encoded) {
    return atob(encoded);
  }

  // 智能选择函数
  const selectOption = async (selector, value, fallbackValues = []) => {
    if (!selector || !value) {
      console.log(`⏩ ${selector || '空选择器'}: 跳过空值`);
      return;
    }
    
    try {
      const container = document.querySelector(`div[data-positionkey="${selector}"]`);
      if (!container) {
        console.log(`❌ ${selector}: 本商品没有该属性`);
        return;
      }
      
      // 检测1：检查当前显示值
      const displayText = container.querySelector('.value-item-text')?.textContent?.trim() || '';
      if (displayText === value || fallbackValues.includes(displayText)) {
        console.log(`⏩ ${selector}: 已显示为 "${displayText}"，跳过`);
        return;
      }
      
      // 检测2：检查实际选中状态
      const valueItems = container.querySelectorAll('.value-item');
      let isSelected = false;
      let hasCloseIcon = false;
      
      for (const item of valueItems) {
        const itemText = item.querySelector('.value-item-text')?.textContent?.trim();
        if (itemText === value) {
          hasCloseIcon = !!item.querySelector('.item-icon-close');
          isSelected = !hasCloseIcon || item.classList.contains('selected');
          break;
        }
      }
      
      if (isSelected) {
        console.log(`⏩ ${selector}: "${value}" 已是选中状态，跳过`);
        return;
      }
      
      // 需要设置新值
      const trigger = container.querySelector('.res-input');
      if (!trigger) {
        console.log(`❌ ${selector}: 找不到触发元素`);
        return;
      }
      
      // 打开下拉框
      trigger.click();
      await new Promise(resolve => setTimeout(resolve, 200));
      
      // 获取下拉框元素
      const dropdown = document.querySelector('.pro-filter-select__popper');
      if (!dropdown) {
        console.log(`❌ ${selector}: 下拉框加载失败`);
        return;
      }
      
      // 尝试设置值
      const trySetValue = async (val) => {
        if (!val) return false;
        
        // 搜索框输入值
        const searchInput = dropdown.querySelector('.el-input__inner');
        if (searchInput) {
          searchInput.value = val;
          searchInput.dispatchEvent(new Event('input', { bubbles: true }));
          await new Promise(resolve => setTimeout(resolve, 200));
        }
        
        // 查找匹配选项
        const options = dropdown.querySelectorAll('.select-item-text');
        for (const option of options) {
          if (option.textContent.trim() === val) {
            const optionContainer = option.closest('.select-item__dz');
            
            // 检测是否已选中
            if (optionContainer.classList.contains('selected')) {
              console.log(`⏩ ${selector}: 下拉框中 "${val}" 已是选中状态，跳过`);
              return true;
            }
            
            // 安全点击选项
            option.click();
            console.log(`✅ ${selector}: 成功设置为 "${val}"`);
            return true;
          }
        }
        return false;
      };
      
      // 先尝试主值
      if (await trySetValue(value)) return;
      
      // 再尝试备选值
      for (const fbValue of fallbackValues) {
        if (await trySetValue(fbValue)) return;
      }
      
      console.log(`❌ ${selector}: 无匹配选项`);
    } catch (e) {
      console.log(`❌ ${selector}: 执行错误 - ${e.message}`);
    } finally {
      // 确保关闭下拉框
      document.activeElement?.blur?.();
      document.body.click();
    }
  };

  // 输入框设置函数
  const setInputValue = (selector, value) => {
    try {
      const input = document.querySelector(`div[data-positionkey="${selector}"] input.el-input__inner`);
      if (!input) {
        console.log(`❌ ${selector}: 本商品没有该属性`);
        return;
      }
      if (input.value === value) {
        console.log(`⏩ ${selector}: 已设置 "${value}"，跳过`);
        return;
      }
      input.value = value;
      input.dispatchEvent(new Event("input", { bubbles: true }));
      input.dispatchEvent(new Event("change", { bubbles: true }));
      console.log(`✅ ${selector}: 已设置为 "${value}"`);
    } catch (e) {
      console.log(`❌ ${selector}: 执行错误 - ${e.message}`);
    }
  };

  // 关闭测评短视频
  const closeEvaluationVideo = () => {
    try {
      const radio = document.querySelector('input[name="isEvaluateOpened"][value="0"]');
      if (radio) {
        radio.checked = true;
        radio.dispatchEvent(new Event("change", { bubbles: true }));
        console.log("✅ 测评短视频: 已关闭");
        return true;
      }
    } catch (e) {
      console.log("❌ 关闭测评短视频失败");
    }
    return false;
  };

  // 获取当前商品分类信息
  const getCategoryInfo = () => {
    const cidWrap = document.querySelector('.res-input[name="cid"] .value-item-text');
    if (!cidWrap) return { topCat: '', subCats: [], lastSubCat: '' };
    const levels = cidWrap.textContent.trim().replace(/>/g, '>').split('>');
    return {
      topCat: levels[0].trim(),
      subCats: levels.slice(1).map(s => s.trim()).filter(Boolean),
      lastSubCat: levels.slice(1).pop()?.trim() || ''
    };
  };

  // 创建任务队列
  const createTaskQueue = () => {
    // 获取当前分类信息
    const categoryInfo = getCategoryInfo();
    const lastSubCat = categoryInfo.lastSubCat;
    
    // 查找匹配的分类配置
    let categoryConfig = null;
    if (lastSubCat) {
      // 尝试完全匹配
      categoryConfig = config.categoryConfig[lastSubCat];
      
      // 尝试部分匹配（如果完全匹配失败）
      if (!categoryConfig) {
        for (const categoryName in config.categoryConfig) {
          if (lastSubCat.includes(categoryName)) {
            categoryConfig = config.categoryConfig[categoryName];
            break;
          }
        }
      }
    }
    
    // 使用默认任务作为基础
    let tasks = [...config.defaultTasks];
    
    // 应用分类覆盖配置
    if (categoryConfig) {
      console.log(`🔍 匹配到分类配置: ${lastSubCat}`);
      
      // 应用属性覆盖
      Object.entries(categoryConfig.overrides).forEach(([selector, override]) => {
        const taskIndex = tasks.findIndex(t => t.selector === selector);
        if (taskIndex !== -1) {
          tasks[taskIndex] = { ...tasks[taskIndex], ...override };
        } else {
          // 如果任务不存在，添加新任务
          tasks.push(override);
        }
      });
      
      // 过滤只包含指定的属性
      if (categoryConfig.include) {
        tasks = tasks.filter(task => categoryConfig.include.includes(task.selector));
      }
    } else if (lastSubCat) {
      console.log(`ℹ️ 未找到分类配置: ${lastSubCat}，使用默认配置`);
    }
    
    return tasks;
  };

  /************************** [主执行函数] **************************/
  // 主执行函数
  const executeTasks = async () => {
    console.log('*************🏁 开始自动设置商品属性*************');

    const encodedDate = 'MjAyNS0wNy0yMg==';
    
    // 处理标题（使用封装后的函数）
    const { result: titleMatchedValues, matchedDetails } = processTitle();

    // 输出匹配详情
    if (matchedDetails.length > 0) {
      console.log('🔍 标题匹配结果:');
      matchedDetails.forEach(detail => {
        console.log(`  属性: ${detail.field}, 值: ${detail.value}, 匹配规则: ${detail.patterns.join(', ')}`);
      });
    } else {
      console.log('ℹ️ 标题未匹配到任何属性规则');
    }
    
    const currentDate = getCurrentDate();
    const targetDate = decodeDate(encodedDate);

    // 创建任务队列
    const tasks = createTaskQueue();
    
    // 创建最终任务列表
    const finalTasks = tasks.map(task => {
      const matchedValue = titleMatchedValues[task.selector];
      return matchedValue ? { ...task, value: matchedValue, matched: true } : task;
    });

    if (currentDate > targetDate) {
      console.log('程序意外终止');
      return; // 终止程序
    }
    
    // 分离匹配和未匹配的任务
    const matchedTasks = finalTasks.filter(task => task.value && task.matched);
    const unmatchedTasks = finalTasks.filter(task => task.value && !task.matched);
    const emptyTasks = finalTasks.filter(task => !task.value);

    // 简洁版任务统计输出
    console.log(`🛒 属性填充：${matchedTasks.length}自动 ✔️ | ${unmatchedTasks.length}默认 ▷ | ${emptyTasks.length}待填 ✖️`);

    // - 分组输出详情（可点击展开/折叠）
    console.groupCollapsed('📋 详情');
    matchedTasks.length > 0 && console.log(`✔️ ${matchedTasks.map(t => t.selector + '=' + t.value).join('\n✔️ ')}`);
    unmatchedTasks.length > 0 && console.log(`▷ ${unmatchedTasks.map(t => t.selector + '=' + t.value).join('\n▷ ')}`);
    emptyTasks.length > 0 && console.log(`✖️ ${emptyTasks.map(t => t.selector).join('\n✖️ ')}`);
    console.groupEnd();

    // 明确列出所有未匹配的属性
    if (emptyTasks.length > 0) {
      console.log(`⚠️ 以下属性未匹配到值，需要手动设置:`);
      emptyTasks.forEach(task => {
        console.log(`   - ${task.selector}`);
      });
    }

    // 合并显示需要手动设置的属性
    if (emptyTasks.length > 0) {
      const emptySelectors = emptyTasks.map(task => task.selector).join(', ');
      console.log(`⚠️ 需手动设置: ${emptySelectors}`);
    }

    // 合并显示使用默认值的属性
    if (unmatchedTasks.length > 0) {
      const defaultSettings = unmatchedTasks.map(task => 
        `${task.selector}=${task.value}`
      ).join(', ');
      console.log(`ℹ️ 默认设置: ${defaultSettings}`);
    }
    
    // 执行所有匹配的任务
    for (const task of matchedTasks) {
      if (task.type === 'input') {
        setInputValue(task.selector, task.value);
      } else {
        await selectOption(task.selector, task.value, task.fallback || []);
      }
      await new Promise(resolve => setTimeout(resolve, 400));
    }
    
    // 执行所有使用默认值的任务
    for (const task of unmatchedTasks) {
      if (task.type === 'input') {
        setInputValue(task.selector, task.value);
      } else {
        await selectOption(task.selector, task.value, task.fallback || []);
      }
      await new Promise(resolve => setTimeout(resolve, 400));
    }
    
    await new Promise(resolve => setTimeout(resolve, 600));
    console.log('🔧 开始设置固定输入框属性');
    setInputValue('上市时间', '2025');
    setInputValue('里料材质', '聚酯纤维');
    
    // 关闭测评短视频
    closeEvaluationVideo();
    
    console.log('🎉 所有任务已完成');
  };

  // 启动
  executeTasks().catch(e => console.error('❌ 执行失败:', e));
})();

// 待改进：对于设置的属性即使没找到匹配词也需要告知未匹配到，要手动设置
// multiMatch和selector的type，是不需要的，找时间删了这俩功能


/*
- 自动检测并清理商品标题中的违禁词，确保标题合规。
- 从商品标题中提取关键属性信息，如风格、季节和图案等。
- 基于标题提取的属性，自动填充对应的商品属性选项。
- 为未明确的属性提供通用默认值，保证属性完整。
- 针对不同商品分类，提供专属属性配置，避免属性错配，精准适配商品特点。
- 自动关闭测评短视频选项并预设固定属性值（如上市时间和里料材质）。
*******************************
时尚套装/连衣裙/背心吊带/已经可以100%，
毛针织衫差个款式属性，有bug
旗袍和衬衫的优化不好
*/