automation-quick-fix

Compare original and translation side by side

🇺🇸

Original

English

🇨🇳

Translation

Chinese

Automation Quick Fix

自动化快速修复

Fast-track resolver for common automation workflow error patterns across multiple platforms with immediate, proven solutions.

针对多平台常见自动化工作流错误模式的快速解决工具，提供经过验证的即时修复方案。

Supported Platforms

支持的平台

Power Automate (Microsoft)
n8n (Open-source)
Make (formerly Integromat)
Zapier
Other JSON-based workflow platforms

Power Automate (Microsoft)
n8n (开源)
Make (原Integromat)
Zapier
其他基于JSON的工作流平台

Purpose

用途

Provides rapid fixes for frequently encountered automation workflow errors across all platforms:

Authentication errors (401/403)
Throttling errors (429)
Data format issues (JSON parsing, data transformation)
Timeout errors
Not found errors (404)
Basic expression/formula errors

When to use this skill: Error matches a well-known pattern When to use automation-debugger instead: Unknown error, complex scenario, or quick fix doesn't resolve

为所有平台上频繁遇到的自动化工作流错误提供快速修复：

认证错误（401/403）
限流错误（429）
数据格式问题（JSON解析、数据转换）
超时错误
未找到资源错误（404）
基础表达式/公式错误

何时使用该技能：错误匹配已知模式 何时改用automation-debugger：未知错误、复杂场景，或快速修复无法解决问题

Activation Triggers

触发条件

Activates for messages like:

"Quick fix for 429 error in SharePoint/API/webhook"
"Fast solution for authentication error in n8n"
"I'm getting throttled in Make, need immediate fix"
"Parse JSON is failing in Zapier, quick help"
"Function expects one parameter but was invoked with 2"
"Unable to process template language expressions"
"Fix this expression/filter/query/condition"
User provides code snippet and asks for "quick fix" or "fix this"
Status codes: 401, 403, 404, 429 with platform/connector context
Platform-specific: "n8n node error", "Make scenario failing", "Power Automate action issue"

当收到以下类似消息时激活：

"SharePoint/API/webhook中429错误的快速修复"
"n8n中认证错误的快速解决方案"
"我在Make中被限流了，需要即时修复"
"Zapier中的JSON解析失败，求快速帮助"
"函数需要一个参数但传入了2个"
"无法处理模板语言表达式"
"修复这个表达式/筛选器/查询/条件"
用户提供代码片段并请求"快速修复"或"修复这个"
状态码：401、403、404、429，且带有平台/连接器上下文
平台特定消息："n8n节点错误"、"Make场景失败"、"Power Automate操作问题"

⚠️ IMPORTANT: Data Structure Check (NEW!)

⚠️ 重要提示：数据结构检查（新增！）

Before applying any quick fix, quickly verify data structures in your flow:

在应用任何快速修复之前，请快速验证流中的数据结构：

Quick Data Type Check

快速数据类型检查

javascript

// In filters/queries, check the where clause:

// Array of STRINGS (primitives):
"where": "@contains(item(), 'text')"  // ← item() without property

// Array of OBJECTS:
"where": "@contains(item()?['Name'], 'text')"  // ← item()?['Property']

If your flow has data structure mismatches (filter uses

item()

but loop uses

items('Loop')?['Property']

), this is NOT a quick fix scenario → use automation-debugger instead.

Quick Fix applies to: Authentication, throttling, timeouts, parse JSON, NOT structural bugs.

javascript

// 在筛选器/查询中，检查where子句：

// 字符串数组（原始类型）：
"where": "@contains(item(), 'text')"  // ← 无属性的item()

// 对象数组：
"where": "@contains(item()?['Name'], 'text')"  // ← item()?['Property']

如果你的流存在数据结构不匹配（筛选器使用

item()

但循环使用

items('Loop')?['Property']

），这不属于快速修复场景 → 请使用automation-debugger。

快速修复适用于：认证、限流、超时、JSON解析，不适用于结构性错误。

Quick Fix Patterns

快速修复模式

Data Structure Mismatch (Quick Check - NEW!)

数据结构不匹配（快速检查 - 新增！）

Pattern Recognition:

Error: "Cannot evaluate property on undefined/null"
Loop accessing
```
items('Loop')?['Property']
```
but source is array of strings

Quick Diagnosis:

javascript

// Check your filter:
"where": "@contains(item(), 'value')"  // ← This means array of STRINGS!

// But loop tries:
"value": "@items('Loop')?['PropertyName']"  // ← ERROR: Can't access property on string!

Quick Decision:

❌ NOT a quick fix → Use automation-debugger skill
This requires analyzing full data flow and structure
Quick fix = known patterns; structural bugs = deep debugging

模式识别:

错误："无法对未定义/空值评估属性"
循环访问
```
items('Loop')?['Property']
```
但数据源是字符串数组

快速诊断:

javascript

// 检查你的筛选器：
"where": "@contains(item(), 'value')"  // ← 这意味着是字符串数组！

// 但循环尝试：
"value": "@items('Loop')?['PropertyName']"  // ← 错误：无法访问字符串的属性！

快速判断:

❌ 不适用快速修复 → 使用automation-debugger技能
这需要分析完整数据流和结构
快速修复=已知模式；结构性错误=深度调试

Authentication Errors (401/403)

认证错误（401/403）

Pattern Recognition:

Status: 401 or 403
Keywords: "unauthorized", "forbidden", "access denied"

Immediate Fix:

json

{
  "actions": {
    "Scope_With_Auth_Handling": {
      "type": "Scope",
      "actions": {
        "Your_Action": {
          "type": "ApiConnection",
          "inputs": { /* your config */ },
          "authentication": {
            "type": "Raw",
            "value": "@parameters('$connections')['shared_sharepointonline']['connectionId']"
          }
        }
      }
    },
    "Catch_Auth_Error": {
      "type": "Terminate",
      "inputs": {
        "runStatus": "Failed",
        "runError": {
          "code": "AuthenticationFailed",
          "message": "Please re-authenticate the connection in Power Automate"
        }
      },
      "runAfter": {
        "Scope_With_Auth_Handling": ["Failed"]
      }
    }
  }
}

Instructions:

Copy the Scope structure above
Replace "Your_Action" with your failing action
Update connection name if not SharePoint
Save and re-authenticate connection in Power Automate UI

模式识别:

状态码：401或403
关键词："unauthorized"、"forbidden"、"access denied"

即时修复:

json

{
  "actions": {
    "Scope_With_Auth_Handling": {
      "type": "Scope",
      "actions": {
        "Your_Action": {
          "type": "ApiConnection",
          "inputs": { /* your config */ },
          "authentication": {
            "type": "Raw",
            "value": "@parameters('$connections')['shared_sharepointonline']['connectionId']"
          }
        }
      }
    },
    "Catch_Auth_Error": {
      "type": "Terminate",
      "inputs": {
        "runStatus": "Failed",
        "runError": {
          "code": "AuthenticationFailed",
          "message": "Please re-authenticate the connection in Power Automate"
        }
      },
      "runAfter": {
        "Scope_With_Auth_Handling": ["Failed"]
      }
    }
  }
}

操作步骤:

复制上述Scope结构
将"Your_Action"替换为你的失败操作
如果不是SharePoint，更新连接名称
保存并在Power Automate UI中重新认证连接

Throttling Errors (429)

限流错误（429）

Pattern Recognition:

Status: 429
Keywords: "TooManyRequests", "throttled", "rate limit"

Immediate Fix - SharePoint/OneDrive:

json

{
  "actions": {
    "Apply_to_each_FIXED": {
      "type": "Foreach",
      "foreach": "@body('Get_items')?['value']",
      "runtimeConfiguration": {
        "concurrency": {
          "repetitions": 1
        }
      },
      "actions": {
        "Your_API_Action": {
          "type": "ApiConnection",
          "inputs": { /* your config */ },
          "runAfter": {}
        },
        "Delay_1_Second": {
          "type": "Wait",
          "inputs": {
            "interval": {
              "count": 1,
              "unit": "Second"
            }
          },
          "runAfter": {
            "Your_API_Action": ["Succeeded"]
          }
        }
      }
    }
  }
}

Instructions:

Find your Apply to each loop

Add

runtimeConfiguration.concurrency.repetitions: 1

Add Delay action after API calls (1 second for SharePoint, 3 seconds for OneDrive)
Save and test

Quick calculation:

SharePoint limit: 600/minute → 1-second delay = 60/minute (safe)
OneDrive limit: 100/minute → 3-second delay = 20/minute (safe)

模式识别:

状态码：429
关键词："TooManyRequests"、"throttled"、"rate limit"

即时修复 - SharePoint/OneDrive:

json

{
  "actions": {
    "Apply_to_each_FIXED": {
      "type": "Foreach",
      "foreach": "@body('Get_items')?['value']",
      "runtimeConfiguration": {
        "concurrency": {
          "repetitions": 1
        }
      },
      "actions": {
        "Your_API_Action": {
          "type": "ApiConnection",
          "inputs": { /* your config */ },
          "runAfter": {}
        },
        "Delay_1_Second": {
          "type": "Wait",
          "inputs": {
            "interval": {
              "count": 1,
              "unit": "Second"
            }
          },
          "runAfter": {
            "Your_API_Action": ["Succeeded"]
          }
        }
      }
    }
  }
}

操作步骤:

找到你的Apply to each循环

添加

runtimeConfiguration.concurrency.repetitions: 1

在API调用后添加Delay操作（SharePoint延迟1秒，OneDrive延迟3秒）
保存并测试

快速计算:

SharePoint限制：600次/分钟 → 1秒延迟=60次/分钟（安全）
OneDrive限制：100次/分钟 →3秒延迟=20次/分钟（安全）

Parse JSON Failures

JSON解析失败

Pattern Recognition:

Error: "InvalidTemplate", "cannot be evaluated"
Keywords: "Parse JSON", "dynamic content", "schema"

Immediate Fix:

json

{
  "actions": {
    "Parse_JSON_FIXED": {
      "type": "ParseJson",
      "inputs": {
        "content": "@body('HTTP')",
        "schema": {
          "type": "object",
          "properties": {
            "id": {"type": "string"},
            "name": {"type": "string"},
            "value": {"type": ["string", "null"]}
          }
        }
      }
    },
    "Safe_Access_Property": {
      "type": "Compose",
      "inputs": "@coalesce(body('Parse_JSON_FIXED')?['value'], 'default')",
      "runAfter": {
        "Parse_JSON_FIXED": ["Succeeded"]
      }
    }
  }
}

Instructions:

Add Parse JSON action with proper schema
Use
```
?['property']
```
for safe navigation (optional chaining)
Use
```
coalesce()
```
for default values with null properties
Test with sample payload first

Schema generation tip:

Copy sample JSON response
Use "Generate from sample" in Parse JSON action
Add
```
"null"
```
to type array for optional fields:
```
{"type": ["string", "null"]}
```

模式识别:

错误："InvalidTemplate"、"无法评估"
关键词："Parse JSON"、"动态内容"、"schema"

即时修复:

json

{
  "actions": {
    "Parse_JSON_FIXED": {
      "type": "ParseJson",
      "inputs": {
        "content": "@body('HTTP')",
        "schema": {
          "type": "object",
          "properties": {
            "id": {"type": "string"},
            "name": {"type": "string"},
            "value": {"type": ["string", "null"]}
          }
        }
      }
    },
    "Safe_Access_Property": {
      "type": "Compose",
      "inputs": "@coalesce(body('Parse_JSON_FIXED')?['value'], 'default')",
      "runAfter": {
        "Parse_JSON_FIXED": ["Succeeded"]
      }
    }
  }
}

操作步骤:

添加带有正确schema的Parse JSON操作
使用
```
?['property']
```
进行安全导航（可选链式调用）
对空属性使用
```
coalesce()
```
设置默认值
先使用示例负载测试

Schema生成技巧:

复制示例JSON响应
在Parse JSON操作中使用“从示例生成”
为可选字段在类型数组中添加
```
"null"
```
：
```
{"type": ["string", "null"]}
```

Timeout Errors

超时错误

Pattern Recognition:

Error: "timeout", "timed out"
Context: Large files, long operations, Do until loops

Immediate Fix - Do Until:

json

{
  "actions": {
    "Do_until_FIXED": {
      "type": "Until",
      "expression": "@equals(variables('Complete'), true)",
      "limit": {
        "count": 60,
        "timeout": "PT1H"
      },
      "actions": {
        "Your_Action": {
          "type": "Compose",
          "inputs": "@variables('Data')"
        },
        "Check_Complete": {
          "type": "SetVariable",
          "inputs": {
            "name": "Complete",
            "value": "@greater(length(variables('Data')), 0)"
          },
          "runAfter": {
            "Your_Action": ["Succeeded"]
          }
        }
      }
    }
  }
}

Instructions:

Always set
```
limit.count
```
and
```
limit.timeout
```
in Do until
Recommended: count=60, timeout="PT1H" (1 hour)
Add exit condition that WILL eventually be true
Test with smaller iterations first

Immediate Fix - Large Files:

json

{
  "actions": {
    "Check_File_Size_FIXED": {
      "type": "If",
      "expression": {
        "and": [{
          "lessOrEquals": [
            "@triggerBody()?['Size']",
            50000000
          ]
        }]
      },
      "actions": {
        "Process_Normal_File": {
          "type": "ApiConnection",
          "inputs": { /* your file action */ }
        }
      },
      "else": {
        "actions": {
          "Log_Large_File": {
            "type": "Compose",
            "inputs": "File over 50MB - skipping"
          }
        }
      }
    }
  }
}

Instructions:

Add file size check before processing
OneDrive: 50MB limit (50000000 bytes)
SharePoint attachments: 90MB limit (94371840 bytes)
Alternative: Use different API for large files

模式识别:

错误："timeout"、"timed out"
场景：大文件、长时间操作、Do until循环

即时修复 - Do Until:

json

{
  "actions": {
    "Do_until_FIXED": {
      "type": "Until",
      "expression": "@equals(variables('Complete'), true)",
      "limit": {
        "count": 60,
        "timeout": "PT1H"
      },
      "actions": {
        "Your_Action": {
          "type": "Compose",
          "inputs": "@variables('Data')"
        },
        "Check_Complete": {
          "type": "SetVariable",
          "inputs": {
            "name": "Complete",
            "value": "@greater(length(variables('Data')), 0)"
          },
          "runAfter": {
            "Your_Action": ["Succeeded"]
          }
        }
      }
    }
  }
}

操作步骤:

始终在Do until中设置
```
limit.count
```
和
```
limit.timeout
```
推荐设置：count=60，timeout="PT1H"（1小时）
添加最终会为true的退出条件
先使用较小的迭代次数测试

即时修复 - 大文件:

json

{
  "actions": {
    "Check_File_Size_FIXED": {
      "type": "If",
      "expression": {
        "and": [{
          "lessOrEquals": [
            "@triggerBody()?['Size']",
            50000000
          ]
        }]
      },
      "actions": {
        "Process_Normal_File": {
          "type": "ApiConnection",
          "inputs": { /* your file action */ }
        }
      },
      "else": {
        "actions": {
          "Log_Large_File": {
            "type": "Compose",
            "inputs": "File over 50MB - skipping"
          }
        }
      }
    }
  }
}

操作步骤:

在处理前添加文件大小检查
OneDrive：50MB限制（50000000字节）
SharePoint附件：90MB限制（94371840字节）
替代方案：使用不同的API处理大文件

Not Found Errors (404)

未找到资源错误（404）

Pattern Recognition:

Status: 404
Keywords: "not found", "does not exist"

Immediate Fix:

json

{
  "actions": {
    "Try_Get_Item": {
      "type": "Scope",
      "actions": {
        "Get_Item": {
          "type": "ApiConnection",
          "inputs": { /* your get action */ }
        }
      }
    },
    "Handle_Not_Found": {
      "type": "If",
      "expression": {
        "and": [{
          "equals": [
            "@result('Try_Get_Item')[0]['status']",
            "Failed"
          ]
        }]
      },
      "runAfter": {
        "Try_Get_Item": ["Failed", "Succeeded"]
      },
      "actions": {
        "Create_If_Missing": {
          "type": "ApiConnection",
          "inputs": { /* your create action */ }
        }
      },
      "else": {
        "actions": {
          "Use_Existing": {
            "type": "Compose",
            "inputs": "@body('Get_Item')"
          }
        }
      }
    }
  }
}

Instructions:

Wrap Get action in Scope
Check result status with
```
result()
```
function
Create item if not found (or handle alternative)
Use dynamic IDs from previous actions (don't hardcode)

模式识别:

状态码：404
关键词："not found"、"does not exist"

即时修复:

json

{
  "actions": {
    "Try_Get_Item": {
      "type": "Scope",
      "actions": {
        "Get_Item": {
          "type": "ApiConnection",
          "inputs": { /* your get action */ }
        }
      }
    },
    "Handle_Not_Found": {
      "type": "If",
      "expression": {
        "and": [{
          "equals": [
            "@result('Try_Get_Item')[0]['status']",
            "Failed"
          ]
        }]
      },
      "runAfter": {
        "Try_Get_Item": ["Failed", "Succeeded"]
      },
      "actions": {
        "Create_If_Missing": {
          "type": "ApiConnection",
          "inputs": { /* your create action */ }
        }
      },
      "else": {
        "actions": {
          "Use_Existing": {
            "type": "Compose",
            "inputs": "@body('Get_Item')"
          }
        }
      }
    }
  }
}

操作步骤:

将Get操作包裹在Scope中
使用
```
result()
```
函数检查结果状态
如果未找到则创建项目（或进行其他处理）
使用之前操作的动态ID（不要硬编码）

Expression Errors

表达式错误

Pattern Recognition:

Error: "Unable to process template language expressions"
Keywords: "property doesn't exist", "invalid expression"

Common Quick Fixes:

Missing Property:

javascript

// BAD
@body('Get_Item')['MissingProperty']

// GOOD
@body('Get_Item')?['MissingProperty']

// BETTER (with default)
@coalesce(body('Get_Item')?['MissingProperty'], 'default_value')

Type Mismatch:

javascript

// BAD - concatenating string and number
@concat('Value: ', variables('NumberVariable'))

// GOOD
@concat('Value: ', string(variables('NumberVariable')))

Array Access:

javascript

// BAD - array might be empty
@first(body('Get_Items')?['value'])

// GOOD
@if(greater(length(body('Get_Items')?['value']), 0), first(body('Get_Items')?['value']), null)

Null Checks:

javascript

// BAD
@variables('NullableVar')

// GOOD
@if(empty(variables('NullableVar')), 'default', variables('NullableVar'))

Function Parenthesis Placement (NEW!):

javascript

// BAD - format parameter outside formatDateTime()
toLower(formatDateTime(outputs('Action')?['body/Date'], 'yyyy-MM'))
//                                                     ↑
//                              This closes formatDateTime BEFORE format string!

// ERROR MESSAGE:
// "The template language function 'toLower' expects one parameter:
//  the string to convert to lower casing. The function was invoked with '2' parameters."

// GOOD - format parameter INSIDE formatDateTime()
toLower(formatDateTime(outputs('Action')?['body/Date'], 'yyyy-MM'))
//                                                      ↑
//                          Format string is now INSIDE formatDateTime()

Copy-Paste Fix for Filter Query:

javascript

// Original (broken):
@and(
  contains(toLower(item()), 'cnesst'),
  contains(
    toLower(item()),
    toLower(formatDateTime(outputs('Ajouter_une_ligne_à_un_tableau')?['body/Date d''événement CNESST']),'yyyy-MM'))
  )

// Fixed expression (ready to copy-paste into Filter Query action):
@and(
  contains(toLower(item()), 'cnesst'),
  contains(
    toLower(item()),
    toLower(formatDateTime(outputs('Ajouter_une_ligne_à_un_tableau')?['body/Date d''événement CNESST'], 'yyyy-MM'))
  )
)

模式识别:

错误："无法处理模板语言表达式"
关键词："property doesn't exist"、"invalid expression"

常见快速修复:

属性缺失:

javascript

// 错误写法
@body('Get_Item')['MissingProperty']

// 正确写法
@body('Get_Item')?['MissingProperty']

// 更佳写法（带默认值）
@coalesce(body('Get_Item')?['MissingProperty'], 'default_value')

类型不匹配:

javascript

// 错误写法 - 拼接字符串和数字
@concat('Value: ', variables('NumberVariable'))

// 正确写法
@concat('Value: ', string(variables('NumberVariable')))

数组访问:

javascript

// 错误写法 - 数组可能为空
@first(body('Get_Items')?['value'])

// 正确写法
@if(greater(length(body('Get_Items')?['value']), 0), first(body('Get_Items')?['value']), null)

空值检查:

javascript

// 错误写法
@variables('NullableVar')

// 正确写法
@if(empty(variables('NullableVar')), 'default', variables('NullableVar'))

函数括号位置（新增！）:

javascript

// 错误写法 - 格式参数在formatDateTime()外部
toLower(formatDateTime(outputs('Action')?['body/Date'], 'yyyy-MM'))
//                                                     ↑
//                              这会在格式字符串之前闭合formatDateTime()！

// 错误消息:
// "模板语言函数'toLower'需要一个参数：
//  要转换为小写的字符串。函数被传入了2个参数。"

// 正确写法 - 格式参数在formatDateTime()内部
toLower(formatDateTime(outputs('Action')?['body/Date'], 'yyyy-MM'))
//                                                      ↑
//                          格式字符串现在位于formatDateTime()内部

筛选器查询的复制粘贴修复:

javascript

// 原始（错误）写法:
@and(
  contains(toLower(item()), 'cnesst'),
  contains(
    toLower(item()),
    toLower(formatDateTime(outputs('Ajouter_une_ligne_à_un_tableau')?['body/Date d''événement CNESST']),'yyyy-MM'))
  )

// 修复后的表达式（可直接复制粘贴到筛选器查询操作）:
@and(
  contains(toLower(item()), 'cnesst'),
  contains(
    toLower(item()),
    toLower(formatDateTime(outputs('Ajouter_une_ligne_à_un_tableau')?['body/Date d''événement CNESST'], 'yyyy-MM'))
  )
)

Quick Fix Decision Tree

快速修复决策树

Error Code/Type
│
├── Data Structure Mismatch (item() vs item()?['Prop']) → ❌ Use automation-debugger (NOT quick fix)
│
├── 401/403 → Re-authenticate connection + Add error handling
│
├── 429 → Set concurrency=1 + Add delays
│
├── 404 → Add existence check + Handle not found case
│
├── Timeout → Add limits to Do until OR check file sizes
│
├── Parse JSON → Add schema + Use safe navigation (?[])
│
└── Expression Errors
    ├── "Function expects N parameters but was invoked with M" → Check parenthesis placement
    ├── Missing/null properties → Add ?[] + coalesce()
    ├── Type mismatch → Add string(), int() conversions
    └── Array access → Add length checks + first()/last()

错误代码/类型
│
├── 数据结构不匹配（item() vs item()?['Prop']）→ ❌ 使用automation-debugger（不适用快速修复）
│
├── 401/403 → 重新认证连接 + 添加错误处理
│
├── 429 → 设置并发数=1 + 添加延迟
│
├── 404 → 添加存在性检查 + 处理未找到情况
│
├── 超时 → 为Do until添加限制或检查文件大小
│
├── JSON解析 → 添加schema + 使用安全导航(?[])
│
└── 表达式错误
    ├── "函数需要N个参数但传入了M个" → 检查括号位置
    ├── 属性缺失/空值 → 添加?[] + coalesce()
    ├── 类型不匹配 → 添加string()、int()转换
    └── 数组访问 → 添加长度检查 + first()/last()

When Quick Fix Isn't Enough

何时快速修复不够用

Escalate to automation-debugger skill if:

Quick fix doesn't resolve the error
Error doesn't match common patterns
Multiple interrelated errors
Complex flow logic involved
Need deep documentation research
Unclear root cause

如果出现以下情况，请升级到automation-debugger技能：

快速修复无法解决错误
错误不符合常见模式
存在多个相互关联的错误
涉及复杂的流逻辑
需要深入研究文档
根本原因不明确

Output Format

输出格式

Quick fixes provide:

Pattern identification (which common error)
Immediate fix (JSON snippet for actions/nodes)
Copy-paste ready expressions (for Filter Query, Condition, Variable, etc.) - ALWAYS include the complete @{...} expression ready to copy directly into Power Automate
Instructions (how to apply)
Validation (how to test)

IMPORTANT: For expression errors (Filter Query, Condition, Variable, Compose, etc.), ALWAYS provide:

❌ Original (broken): The full broken expression
✅ Fixed expression: The complete corrected expression ready to copy-paste

Example output format:

Quick Fix: Function Parenthesis Placement Error

Pattern: formatDateTime() format parameter placed outside function call

Original (broken):
@and(contains(toLower(item()), 'text'), contains(toLower(item()), toLower(formatDateTime(outputs('Action')?['body/Date']),'yyyy-MM')))

Fixed expression (copy-paste ready):
@and(contains(toLower(item()), 'text'), contains(toLower(item()), toLower(formatDateTime(outputs('Action')?['body/Date'], 'yyyy-MM'))))

What changed: Moved 'yyyy-MM' format string INSIDE formatDateTime() parentheses

No need for full debug report structure - focus on speed and copy-paste ready fixes.

快速修复提供以下内容：

模式识别（属于哪种常见错误）
即时修复（用于操作/节点的JSON片段）
可直接复制粘贴的表达式（用于筛选器查询、条件、变量等）- 始终包含完整的@{...}表达式，可直接复制到Power Automate
操作步骤（如何应用）
验证方法（如何测试）

重要提示：对于表达式错误（筛选器查询、条件、变量、Compose等），始终提供：

❌ 原始（错误）写法：完整的错误表达式
✅ 修复后的表达式：完整的修正后表达式，可直接复制粘贴

示例输出格式:

快速修复：函数括号位置错误

模式：formatDateTime()的格式参数放在函数调用外部

原始（错误）写法:
@and(contains(toLower(item()), 'text'), contains(toLower(item()), toLower(formatDateTime(outputs('Action')?['body/Date']),'yyyy-MM')))

修复后的表达式（可直接复制粘贴）:
@and(contains(toLower(item()), 'text'), contains(toLower(item()), toLower(formatDateTime(outputs('Action')?['body/Date'], 'yyyy-MM'))))

修改点：将'yyyy-MM'格式字符串移到formatDateTime()括号内部

无需完整的调试报告结构 - 重点关注速度和可直接复制粘贴的修复方案。

Best Practices

最佳实践

Test first: Apply quick fix to copy of flow
Verify limits: Confirm connector-specific constraints
Monitor: Check flow run history after fix
Escalate if needed: Use automation-debugger for persistent issues

先测试：将快速修复应用到流的副本
验证限制：确认连接器特定的约束
监控：修复后检查流运行历史
必要时升级：对于持续存在的问题，使用automation-debugger

Common Connector Limits (Quick Reference)

常见连接器限制（快速参考）

Connector	API Limit	Recommended Delay
SharePoint	600/60s	1 second
OneDrive	100/60s	3 seconds
HTTP	600/60s	1 second
Apply to each	50 concurrent	Set to 1 for APIs

连接器	API限制	推荐延迟
SharePoint	600次/60秒	1秒
OneDrive	100次/60秒	3秒
HTTP	600次/60秒	1秒
Apply to each	50并发	针对API设置为1

Examples

示例

User: "I'm getting throttled in SharePoint, need quick fix"

Output:

Quick Fix: SharePoint Throttling (429)

Reduce concurrency and add delays:

[JSON snippet with concurrency + delay]

Apply these changes:
1. Set concurrency to 1
2. Add 1-second delay
3. Save and test

This limits you to 60 API calls/minute (well under 600/minute limit).

User: "Parse JSON failing with 'property doesn't exist'"

Output:

Quick Fix: Parse JSON Property Access

Use safe navigation (?[]) and defaults:

[JSON snippet with coalesce()]

Changes needed:
1. Replace ['property'] with ?['property']
2. Add coalesce() for defaults
3. Test with sample data

This handles null/missing properties gracefully.

User: "Getting error 'toLower expects one parameter but was invoked with 2 parameters' in my Filter Query"

Output:

Quick Fix: Function Parenthesis Placement Error

Pattern: formatDateTime() format parameter placed outside function call

Original (broken):
@and(
  contains(toLower(item()), 'cnesst'),
  contains(
    toLower(item()),
    toLower(formatDateTime(outputs('Ajouter_une_ligne_à_un_tableau')?['body/Date d''événement CNESST']),'yyyy-MM'))
  )

Fixed expression (copy-paste ready):
@and(
  contains(toLower(item()), 'cnesst'),
  contains(
    toLower(item()),
    toLower(formatDateTime(outputs('Ajouter_une_ligne_à_un_tableau')?['body/Date d''événement CNESST'], 'yyyy-MM'))
  )
)

What changed:
1. Moved 'yyyy-MM' format string INSIDE formatDateTime() parentheses (before the closing parenthesis)
2. The format parameter is now the second parameter of formatDateTime(), not a second parameter to toLower()

How to apply:
1. Open your Filter Query action in Power Automate
2. Delete the current expression
3. Paste the fixed expression above
4. Save and test with your data

用户："我在SharePoint中被限流了，需要快速修复"

输出:

快速修复：SharePoint限流（429）

降低并发数并添加延迟:

[带有并发设置+延迟的JSON片段]

应用以下更改:
1. 设置并发数为1
2. 添加1秒延迟
3. 保存并测试

这会将你的API调用限制为60次/分钟（远低于600次/分钟的限制）。

用户："JSON解析失败，提示'属性不存在'"

输出:

快速修复：JSON解析属性访问

使用安全导航(?[])和默认值:

[带有coalesce()的JSON片段]

需要的更改:
1. 将['property']替换为?['property']
2. 添加coalesce()设置默认值
3. 使用示例数据测试

这会优雅地处理空值/缺失属性。

用户："我的筛选器查询中出现错误'toLower需要一个参数但传入了2个'"

输出:

快速修复：函数括号位置错误

模式：formatDateTime()的格式参数放在函数调用外部

原始（错误）写法:
@and(
  contains(toLower(item()), 'cnesst'),
  contains(
    toLower(item()),
    toLower(formatDateTime(outputs('Ajouter_une_ligne_à_un_tableau')?['body/Date d''événement CNESST']),'yyyy-MM'))
  )

修复后的表达式（可直接复制粘贴）:
@and(
  contains(toLower(item()), 'cnesst'),
  contains(
    toLower(item()),
    toLower(formatDateTime(outputs('Ajouter_une_ligne_à_un_tableau')?['body/Date d''événement CNESST'], 'yyyy-MM'))
  )
)

修改点:
1. 将'yyyy-MM'格式字符串移到formatDateTime()括号内部（在闭合括号之前）
2. 格式参数现在是formatDateTime()的第二个参数，而不是toLower()的第二个参数

应用方法:
1. 在Power Automate中打开你的筛选器查询操作
2. 删除当前表达式
3. 粘贴上述修复后的表达式
4. 保存并使用你的数据测试

Integration with Other Skills

与其他技能的集成

Quick fix succeeds → Done!
Quick fix fails → Automatically suggest automation-debugger
Unknown error → Immediately defer to automation-debugger

This skill optimizes for speed on common patterns while maintaining quality through specialized skill delegation when needed.

Version: 1.2 Last Updated: 2025-10-31

快速修复成功 → 完成！
快速修复失败 → 自动建议使用automation-debugger
未知错误 → 立即转至automation-debugger

该技能针对常见模式优化速度，同时在需要时通过专业技能委托保持质量。

版本: 1.2 最后更新: 2025-10-31

Changelog

更新日志

Version 1.2 (2025-10-31)

版本1.2（2025-10-31）

Major Enhancements:

✅ Added Function Parenthesis Placement Error pattern to Expression Errors
✅ Enhanced Output Format to emphasize copy-paste ready expressions for all expression types
✅ Updated Activation Triggers to include expression error patterns
✅ Expanded Decision Tree with detailed expression error breakdown
✅ Added complete example showing function parenthesis error fix

Key Additions:

Function parameter placement detection (e.g.,
```
toLower(formatDateTime(...), 'format')
```
→ error)
Copy-paste ready expression format with ❌ broken / ✅ fixed sections
Direct support for Filter Query, Condition, Variable, Compose expression fixes
Clear before/after comparison showing exactly what changed

New Triggers:

"Function expects one parameter but was invoked with 2"
"Unable to process template language expressions"
"Fix this expression/filter/query/condition"
User provides code snippet and asks for "quick fix"

Output Philosophy:

Always provide complete, ready-to-paste expressions
Show original (broken) and fixed versions side-by-side
Explain exactly what changed and why
Include step-by-step application instructions

主要增强:

✅ 在表达式错误中新增函数括号位置错误模式
✅ 增强输出格式，强调所有表达式类型的可直接复制粘贴的表达式
✅ 更新触发条件，添加表达式错误模式
✅ 扩展决策树，添加详细的表达式错误分支
✅ 添加完整示例，展示函数括号错误修复

关键新增:

函数参数位置检测（例如
```
toLower(formatDateTime(...), 'format')
```
→ 错误）
带有❌错误/✅修复部分的可复制粘贴表达式格式
直接支持筛选器查询、条件、变量、Compose表达式修复
清晰的前后对比，显示具体修改内容

新触发条件:

"函数需要一个参数但传入了2个"
"无法处理模板语言表达式"
"修复这个表达式/筛选器/查询/条件"
用户提供代码片段并请求"快速修复"

输出理念:

始终提供完整的、可直接粘贴的表达式
并排显示原始（错误）和修复后的版本
解释具体修改内容和原因
包含分步应用说明

Version 1.1 (2025-10-31)

版本1.1（2025-10-31）

Minor Improvements:

✅ Added Data Structure Check section - Quick validation before applying fixes
✅ Added Data Structure Mismatch pattern - Recognizes when NOT to quick fix
✅ Updated Decision Tree - Now includes structural bug detection
✅ Clarified escalation to automation-debugger for structural issues

Key Additions:

Quick data type check:
```
item()
```
vs
```
item()?['Property']
```
indicator
Clear guidance on when quick fix is inappropriate
Structural bugs (string vs object mismatch) → Use automation-debugger

Philosophy:

Quick fixes are for known, simple patterns
Data structure bugs require deep analysis → Not quick fix territory
Fast triage: Recognize when to escalate immediately

小改进:

✅ 新增数据结构检查部分 - 应用修复前的快速验证
✅ 新增数据结构不匹配模式 - 识别不适用快速修复的情况
✅ 更新决策树 - 现在包含结构性错误检测
✅ 明确升级到automation-debugger处理结构性问题的指引

关键新增:

快速数据类型检查：
```
item()
```
vs
```
item()?['Property']
```
指示器
清晰的快速修复适用范围指引
结构性错误（字符串与对象不匹配）→ 使用automation-debugger

理念:

快速修复适用于已知的简单模式
数据结构错误需要深度分析 → 不属于快速修复范畴
快速分类：立即识别何时需要升级