Apple快捷指令基于plist的校验方案

背景

在分发 Apple 快捷指令时，为了确保用户下载的快捷指令未被篡改，我们需要一个可靠的校验方案。本文将介绍如何基于 plist 文件实现快捷指令的完整性校验。

校验流程

1. 解析 UUID

首先需要从 iCloud 快捷指令分享链接中提取 UUID。这个 UUID 是快捷指令的唯一标识符。

2. 请求快捷指令记录

通过 API 获取快捷指令的详细信息：
https://www.icloud.com/shortcuts/api/records/${uuid}

API 返回的数据中包含了多个重要字段，其中最关键的是 fields.shortcut.value.downloadURL，这个 URL 指向快捷指令的 plist 源代码文件。

以下为响应示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
{
    "modified": {
        "timestamp": 1729843932106,
        "deviceID": "2",
        "userRecordName": "_a702d02db102341342355d5ae64b8e07"
    },
    "recordName": "24A3DF29-5477-4066-AA4B-C2972641D8AA",
    "pluginFields": {},
    "recordType": "SharedShortcut",
    "fields": {
        "signingStatus": {
            "value": "APPROVED",
            "type": "STRING"
        },
        "name": {
            "type": "STRING",
            "value": "J1_Master_Service"
        },
        "shortcut": {
            "value": {
                "fileChecksum": "ARxTDezw48oN4rjHSrwoi0IJZH4f",
                "downloadURL": "https://cvws.icloud-content.com/B/ARxTDezw48oN4rjHSrwoi0IJZH4f/${f}?o=Apdo7O_GY8G4lB3H_Vyh2CAMSi01xomyL8rMB-5goDQZQ7I1SUDffxR9_2K6zGeq3Q&v=1&x=3&a=CAogQtQpktwpsOTgCC9z1PtCXzpomfUMx-_nGdKCQmLKz1YSexDZ27j7sjIY2biU_bIyIgEAUgQJZH4fajCPvFYHwlBiGLsleZUzY04l00Kz5drKGxcoUu4F4jGm8Ub0rESU3CCMH2dWaZIWemlyMHoPDlTnAqlXSAYWGLkZduD34WZ3zxFeqp2sY-TtL8CK4WLHvZvDPOnDUP0jDMg8fQ&e=1731671170&fl=&r=04369aac-804d-4efe-9561-b31475d220c8-1&k=_&ckc=com.apple.shortcuts&ckz=_defaultZone&p=33&s=6iKWpP9jHRuD5upNSbPA3zWOjmA",
                "size": 6262
            },
            "type": "ASSETID"
        },
        "signedShortcut": {
            "value": {
                "fileChecksum": "ARLCrUGKlVrpZjVGPIfWSQQJLYOF",
                "size": 24546,
                "downloadURL": "https://cvws.icloud-content.com/B/ARLCrUGKlVrpZjVGPIfWSQQJLYOF/${f}?o=AkXUKGZfLfIG_P2aoMt-iZKTSxbFF_gUVI-tLrvr-LUUw8IyGQwYysXRSiTDAQtBUA&v=1&x=3&a=CAogMGluUoUKTwnyc_HzHFPLAJVdZLdnaCs4qO7FaX9xf18SexDZ27j7sjIY2biU_bIyIgEAUgQJLYOFajDO01nBCXtDe4sx462_uncIXxDnM6bP5Q-bNaHeoTpLWx1e65rrOEfJtHe21JU6-aByMFH3KDSAY3rbskyyYA_zGKRS5eEoZ4P_5B53tuJG7KLhy_-k5U6_BgWiSv0MPZE4ng&e=1731671170&fl=&r=04369aac-804d-4efe-9561-b31475d220c8-1&k=_&ckc=com.apple.shortcuts&ckz=_defaultZone&p=33&s=5zq5fLlTRKeSisqGF3ZXHu2MPOI"
            },
            "type": "ASSETID"
        },
        "icon": {
            "value": {
                "downloadURL": "https://cvws.icloud-content.com/B/AbZY1r4P6McNdWpIahVqESSnO-fO/${f}?o=AvoZZHa9gm7rDymLj89P4vhu-QA7PIpSSu6MDnK76eBR9xKKczwgpwfiBXqYl_WL6A&v=1&x=3&a=CAogeXm1whlrDL7G5i_01JgRzNSF3TP2HXsi5JIFhHi4ug4SexDZ27j7sjIY2biU_bIyIgEAUgSnO-fOajBndIf0jvSnrG57XI2iolFb88-qxjp6QDhgGZwDq9ltL_XaCHRqhLLPQddHHmht6JhyMLKP8rq_L5X8jicx8hIjevn446-TVd_CIbz1fA7WVCK7fuc3YBUKSNl8v9lgL7sF2A&e=1731671170&fl=&r=04369aac-804d-4efe-9561-b31475d220c8-1&k=_&ckc=com.apple.shortcuts&ckz=_defaultZone&p=33&s=THQoINfCkzWJ3068c90zZPo1FPM",
                "fileChecksum": "AbZY1r4P6McNdWpIahVqESSnO+fO",
                "size": 48742
            },
            "type": "ASSETID"
        },
        "signingCertificateExpirationDate": {
            "value": 1763576151000,
            "type": "TIMESTAMP"
        },
        "icon_color": {
            "value": 4271458815,
            "type": "NUMBER_INT64"
        },
        "maliciousScanningContentVersion": {
            "value": 1,
            "type": "NUMBER_INT64"
        },
        "icon_glyph": {
            "type": "NUMBER_INT64",
            "value": 61567
        }
    },
    "deleted": false,
    "created": {
        "timestamp": 1729843920636,
        "userRecordName": "_ed3d8913b2df4c4c67b23a57e3096099",
        "deviceID": "74DD7EA936E87E6A494752E803E58270A2AD63BC3A1FC6592F853FA7F296DD6F"
    },
    "recordChangeTag": "m2ogenlm"
}

3. 获取源代码文件

从 downloadURL 下载快捷指令的 plist 源代码文件，这个文件包含了快捷指令的完整配置信息。

4. plist 转换

将下载的二进制 plist 文件转换为可读的 plist 字符串格式。

5. 获取本地文件

编写快捷指令获取需要进行校验的本地快捷指令 plist 文件。

快捷指令获取plist文件

6. 解析操作内容

从两个 plist 字符串中解析出 WFWorkflowActions 字段的内容。这个字段包含了快捷指令的所有操作步骤。

7. 校验一致性

将两个快捷指令的操作内容转换为 JSON 字符串（注意键名需要按字母顺序排序），然后比较两个字符串是否完全一致。

特殊情况处理

当快捷指令包含导入问题（Import Questions）时，简单的字符串比较可能会失败。这种情况下需要特殊处理：

  1. 通过 WFWorkflowImportQuestions 字段识别需要用户输入的部分
  2. 根据 ActionIndex 找到对应的操作
  3. 在比较之前移除这些可能发生变化的操作
  4. 对剩余的操作进行一致性校验

例如，当快捷指令要求用户输入唯一识别码时，这部分内容在导入后会被修改，因此需要在校验时排除这些操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<key>WFWorkflowImportQuestions</key>
    <array>
        <dict>
            <key>ActionIndex</key>
            <integer>2</integer>
            <key>Category</key>
            <string>Parameter</string>
            <key>DefaultValue</key>
            <string></string>
            <key>ParameterKey</key>
            <string>WFTextActionText</string>
            <key>Text</key>
            <string>请输入用户唯一识别码</string>
        </dict>
    </array>

安全建议

  1. 确保使用 HTTPS 协议获取 plist 文件
  2. 验证 API 返回的签名状态（signingStatus 字段）
  3. 检查证书过期时间（signingCertificateExpirationDate 字段）
  4. 考虑增加本地缓存机制，避免频繁请求 API

总结

通过以上方案，我们可以有效地验证快捷指令的完整性，确保用户使用的是未经篡改的原始版本。这对于需要分发重要快捷指令的开发者来说是一个可靠的解决方案。

需要注意的是，这个方案主要关注快捷指令的内容一致性，如果需要更高级别的安全保护，可以考虑配合其他安全机制一起使用。

代码示例

JavaScript示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
(async function () {
    "use strict";
    const bplist = require('bplist-parser');
    const plist = require('plist');

    /**
     * @brief 从快捷指令URL中提取UUID
     * @param {string} url - iCloud快捷指令的URL
     * @return {string|undefined} 返回32位的UUID，如果未找到则返回undefined
     */
    function getShortcutUUIDFromPath(url) {
        url = new URL(url);
        const e = url.pathname.split("/");
        const n = e[e.length - 1];
        if (n.match(/[0-9a-f]{32}/)) return n;
    }
    
    /**
     * @brief 下载并解析快捷指令内容
     * @param {string} url - iCloud快捷指令的URL
     * @return {Promise<string>} 返回解析后的plist内容
     * @throws {Error} 当URL无效或下载失败时抛出错误
     */
    async function downloadShortcut(url) {
        try {
            const uuid = getShortcutUUIDFromPath(url);
            if (!uuid) {
                throw new Error('Invalid shortcut URL');
            }

            const apiUrl = `https://www.icloud.com/shortcuts/api/records/${uuid}`;
            const response = await fetch(apiUrl);
            if (!response.ok) {
                throw new Error(`API request failed: ${response.status} ${response.statusText}`);
            }

            const data = await response.json();
            if (!data?.fields?.shortcut?.value?.downloadURL) {
                throw new Error('Failed to get download URL');
            }

            const downloadURL = data.fields.shortcut.value.downloadURL;
            const shortcut = await fetch(downloadURL);
            if (!shortcut.ok) {
                throw new Error(`Shortcut download failed: ${shortcut.status} ${shortcut.statusText}`);
            }

            const shortcutBlob = await shortcut.blob();
            const binaryContent = await shortcutBlob.arrayBuffer();
            const [parsedContent] = bplist.parseBuffer(Buffer.from(binaryContent));
            const content = plist.build(parsedContent);
            
            return content;
        } catch (error) {
            console.error('Error downloading shortcut:', error.message);
            throw error;
        }
    }

    /**
     * @brief 比较两个快捷指令的动作是否相同
     * @param {string} content1 - 第一个快捷指令的plist内容
     * @param {string} content2 - 第二个快捷指令的plist内容
     * @return {Promise<boolean>} 如果动作完全相同返回true，否则返回false
     * @throws {Error} 当解析失败或找不到动作列表时抛出错误
     */
    async function compareShortcutActions(content1, content2) {
        try {
            const doc1 = plist.parse(content1);
            const doc2 = plist.parse(content2);

            const getWorkflowActions = (doc) => {
                return doc.WFWorkflowActions;
            };

            const actions1 = getWorkflowActions(doc1);
            const actions2 = getWorkflowActions(doc2);

            if (!actions1 || !actions2) {
                throw new Error('Could not find WFWorkflowActions in one or both shortcuts');
            }

            return sortedJSONStringify(actions1) === sortedJSONStringify(actions2);
        } catch (error) {
            console.error('Error comparing shortcuts:', error.message);
            throw error;
        }
    }

    /**
     * @brief 对对象进行排序并转换为JSON字符串
     * @param {Object} obj - 需要排序的对象
     * @return {string} 返回经过键名排序后的JSON字符串
     */
    function sortedJSONStringify(obj) {
        return JSON.stringify(obj, (key, value) => {
            if (value && typeof value === 'object' && !Array.isArray(value)) {
                // 将对象的 key 按升序排序
                return Object.keys(value)
                    .sort()
                    .reduce((sortedObj, key) => {
                        sortedObj[key] = value[key];
                        return sortedObj;
                    }, {});
            }
            return value;
        });
    }

    try {
        const url = "https://www.icloud.com/shortcuts/24a3df2954774066aa4bc2972641d8aa";
        const content1 = await downloadShortcut(url);

        // 读取本地 plist 文件
        const fs = require('fs').promises;
        const path = require('path');
        const filePath = path.join(__dirname, 'file.plist');
        const content2 = await fs.readFile(filePath, 'utf-8');
        
        const isEqual = await compareShortcutActions(content1, content2);
        console.log('Shortcut actions are' + (isEqual ? ' ' : ' not ') + 'equal');
    } catch (error) {
        console.error('Execution failed:', error.message);
    }
})();

file.plist

点击下载 js示例中的file.plist

Java示例

1
2
3
4
5
<dependency>
    <groupId>com.googlecode.plist</groupId>
    <artifactId>dd-plist</artifactId>
    <version>1.28</version>
</dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject;
import com.dd.plist.NSObject;
import com.dd.plist.PropertyListFormatException;
import com.dd.plist.PropertyListParser;
import lombok.extern.slf4j.Slf4j;
import ltd.loox.ghost_data.common.exception.ApiErrorCode;
import ltd.loox.ghost_data.common.exception.BizException;
import ltd.loox.ghost_data.dal.domain.autopilot.ShortcutInfoDO;
import ltd.loox.ghost_data.dal.mapper.mysql.ShortcutInfoMapper;
import ltd.loox.ghost_data.integration.ShortcutProxyService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;
import org.xml.sax.SAXException;

import javax.xml.parsers.ParserConfigurationException;
import java.io.IOException;
import java.text.ParseException;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


/**
 * @Author 夏佳怡
 */
@Slf4j
@Service
public class PlistCoreService {
    @Autowired
    private ShortcutProxyService shortcutProxyService;
    @Autowired
    private ShortcutInfoMapper shortcutInfoMapper;

    private static final Pattern UUID_PATTERN = Pattern.compile("[0-9a-f]{32}");

    /**
     * 提取 iCloud 快捷指令 URL 中的 UUID
     *
     * @param url iCloud 快捷指令的 URL
     * @return UUID 字符串，如果未找到返回 null
     */
    private String getShortcutUUIDFromPath(String url) {
        Matcher matcher = UUID_PATTERN.matcher(url);
        if (matcher.find()) {
            return matcher.group();
        }
        return null;
    }

    /**
     * 从 URL 下载并解析快捷指令内容
     *
     * @param shortcutUrl iCloud 快捷指令的 URL
     * @return Plist 文件的内容
     */
    private String downloadShortcut(String shortcutUrl) {
        String uuid = getShortcutUUIDFromPath(shortcutUrl);
        if (uuid == null) {
            throw new BizException(ApiErrorCode.INVALID_SHORTCUT_URL);
        }
        // 从 API 响应中提取下载链接
        String downloadUrl = shortcutProxyService.getShortcutsRecordsByUUID(uuid);

        if (downloadUrl == null || downloadUrl.isEmpty()) {
            throw new BizException(ApiErrorCode.FAILED_TO_GET_DOWNLOAD_URL);
        }
        byte[] binaryData = shortcutProxyService.getPlistBinary(downloadUrl);

        NSObject plistObject = null;
        try {
            plistObject = PropertyListParser.parse(binaryData);
        } catch (IOException | PropertyListFormatException | ParseException | ParserConfigurationException |
                 SAXException e) {
            throw new BizException(ApiErrorCode.PROPERTY_LIST_PARSER_EXCEPTION);
        }
        return plistObject.toXMLPropertyList();
    }

    /**
     * 比较两个快捷指令的动作
     *
     * @param content1 第一个快捷指令的 plist 内容 xml
     * @param content2 第二个快捷指令的 plist 内容 xml
     * @return 如果动作相同返回 true，否则返回 false
     * @throws Exception 解析失败时抛出异常
     */
    private boolean compareShortcutActions(String content1, String content2) {
        JSONArray actions1 = getWorkflowActions(content1);
        JSONArray actions2 = getWorkflowActions(content2);

        // 去除自定义输出名的动作
        actions1 = removeActionsWithCustomOutputName(actions1);
        actions2 = removeActionsWithCustomOutputName(actions2);
        // 去除筛选模板中的 Unit 字段，ios 18.1的快捷指令分享出来后Unit字段的值不一样
        actions1 = removeUnitFieldFromFilterTemplates(actions1);
        actions2 = removeUnitFieldFromFilterTemplates(actions2);
        if (actions1.toString().length() != actions2.toString().length()) {
            log.info("shortcut length not equal");
            return false;
        }
        String s = sortedJSONString(actions1);
        String s1 = sortedJSONString(actions2);
        return s.equals(s1);
    }

    /**
     * 比较两个快捷指令的动作
     *
     * @param content1 第一个快捷指令的 plist 内容 json
     * @param content2 第二个快捷指令的 plist 内容 xml
     * @return 如果动作相同返回 true，否则返回 false
     * @throws Exception 解析失败时抛出异常
     */
    private boolean compareShortcutActionsWithJsonAndXml(String content1, String content2) {
        // 从 content1 的 JSON 中提取 WFWorkflowActions 节点
        JSONArray actions1 = getWorkflowActionsFromJson(content1);
        // 从 content2 的 XML 中提取 WFWorkflowActions 节点
        JSONArray actions2 = getWorkflowActions(content2);
        // 去除自定义输出名的动作
        actions1 = removeActionsWithCustomOutputName(actions1);
        actions2 = removeActionsWithCustomOutputName(actions2);
        // 去除筛选模板中的 Unit 字段
        actions1 = removeUnitFieldFromFilterTemplates(actions1);
        actions2 = removeUnitFieldFromFilterTemplates(actions2);
        if (actions1.toString().length() != actions2.toString().length()) {
            log.info("shortcut length not equal");
            return false;
        }
        String s = sortedJSONString(actions1);
        String s1 = sortedJSONString(actions2);
        // 比较两个 JSON 数组内容是否相同
        return s.equals(s1);
    }

    /**
     * 从 JSON 格式的 plist 内容中提取 WFWorkflowActions 节点
     *
     * @param content JSON 格式的 plist 内容
     * @return WFWorkflowActions 节点的内容（JSONArray）
     * @throws Exception 如果解析失败抛出异常
     */
    private JSONArray getWorkflowActionsFromJson(String content) {
        JSONObject jsonObject = JSON.parseObject(content);
        // 提取 WFWorkflowActions 节点
        JSONArray workflowActions = jsonObject.getJSONArray("WFWorkflowActions");
        if (workflowActions == null) {
            throw new BizException(ApiErrorCode.PROPERTY_LIST_PARSER_EXCEPTION);
        }
        return workflowActions;
    }


    /**
     * 获取工作流的动作列表
     *
     * @return 返回动作列表
     */
    private JSONArray getWorkflowActions(String xmlContent) {
        try {
            // 使用 dd.plist 将 XML 转换为 JSONObject
            NSObject plistObject = PropertyListParser.parse(xmlContent.getBytes());
            Map<String, Object> plistMap = (Map<String, Object>) plistObject.toJavaObject();
            // 直接获取 "WFWorkflowActions" 字段，避免重复的 JSON 转换
            Object actions = plistMap.get("WFWorkflowActions");
            if (actions instanceof Iterable) {
                return new JSONArray((Iterable<?>) actions);
            } else if (actions != null && actions.getClass().isArray()) {
                return new JSONArray((Object[]) actions);
            } else {
                log.warn("No 'WFWorkflowActions' field found or invalid format");
                return new JSONArray(); // 返回空数组
            }
        } catch (Exception e) {
            log.error("Failed to parse workflow actions", e);
            throw new BizException(ApiErrorCode.PROPERTY_LIST_PARSER_EXCEPTION);
        }
    }

    /**
     * 对对象进行排序并转换为 JSON 字符串
     *
     * @param obj 需要排序的对象
     * @return 排序后的 JSON 字符串
     */
    private Object sortObjectRecursively(Object obj) {
        if (obj instanceof JSONObject) {
            JSONObject jsonObj = (JSONObject) obj;
            JSONObject sortedObj = JSONObject.of();

            // 对 key 进行排序
            jsonObj.keySet().stream()
                    .sorted()
                    .forEach(key -> {
                        // 对值进行递归排序
                        Object value = jsonObj.get(key);
                        sortedObj.put(key, sortObjectRecursively(value));
                    });

            return sortedObj;
        } else if (obj instanceof JSONArray) {
            JSONArray jsonArr = (JSONArray) obj;
            JSONArray sortedArr = new JSONArray();
            // 对数组中的每个元素进行递归排序
            for (int i = 0; i < jsonArr.size(); i++) {
                sortedArr.add(sortObjectRecursively(jsonArr.get(i)));
            }
            return sortedArr;
        } else if (obj instanceof Map) {
            JSONObject jsonObject = JSON.parseObject(JSON.toJSONString(obj));
            return sortObjectRecursively(jsonObject);
        }

        // 对于基本类型，直接返回
        return obj;
    }

    private String sortedJSONString(JSONArray array) {
        JSONArray sortedArray = (JSONArray) sortObjectRecursively(array);
        return JSON.toJSONString(sortedArray);
    }

    /**
     * 删除 JSONArray 中 "CustomOutputName" 为 "uniqueId" 的节点
     *
     * @param actions JSONArray 动作列表
     * @return 处理后的 JSONArray
     */
    private JSONArray removeActionsWithCustomOutputName(JSONArray actions) {
        JSONArray filteredActions = new JSONArray();
        String targetValue = "uniqueId";
        for (int i = 0; i < actions.size(); i++) {
            JSONObject action = actions.getJSONObject(i);

            // 判断节点中是否包含目标字段和值
            JSONObject parameters = action.getJSONObject("WFWorkflowActionParameters");
            if (parameters == null || !targetValue.equals(parameters.getString("CustomOutputName"))) {
                filteredActions.add(action); // 保留不匹配的节点
            }
        }

        return filteredActions;
    }

    /**
     * 筛选 JSONArray 中所有 WFWorkflowActionIdentifier 为 "is.workflow.actions.filter.files" 的对象，
     * 并删除其 WFWorkflowActionParameters.WFContentItemFilter.Value.WFActionParameterFilterTemplates
     * 列表中所有对象的 Values.Unit 字段。
     *
     * @param actions JSONArray 动作列表
     * @return 处理后的 JSONArray
     */
    private JSONArray removeUnitFieldFromFilterTemplates(JSONArray actions) {
        for (int i = 0; i < actions.size(); i++) {
            JSONObject action = actions.getJSONObject(i);

            if ("is.workflow.actions.filter.files".equals(action.getString("WFWorkflowActionIdentifier"))) {
                JSONObject parameters = action.getJSONObject("WFWorkflowActionParameters");
                if (parameters == null) continue;

                JSONObject contentItemFilter = parameters.getJSONObject("WFContentItemFilter");
                if (contentItemFilter == null) continue;

                JSONObject value = contentItemFilter.getJSONObject("Value");
                if (value == null) continue;

                JSONArray filterTemplates = value.getJSONArray("WFActionParameterFilterTemplates");
                if (filterTemplates == null) continue;

                // 创建一个新的 filterTemplates
                JSONArray newFilterTemplates = new JSONArray();

                for (int j = 0; j < filterTemplates.size(); j++) {
                    JSONObject template = filterTemplates.getJSONObject(j);
                    JSONObject values = template.getJSONObject("Values");

                    if (values != null) {
                        // 创建一个新的 Values 对象，显式地排除 Unit 字段
                        JSONObject newValues = new JSONObject();
                        for (String key : values.keySet()) {
                            if (!"Unit".equals(key)) {
                                newValues.put(key, values.get(key));
                            }
                        }

                        // 创建新的 template 对象
                        JSONObject newTemplate = new JSONObject();
                        for (String key : template.keySet()) {
                            if ("Values".equals(key)) {
                                newTemplate.put(key, newValues);
                            } else {
                                newTemplate.put(key, template.get(key));
                            }
                        }

                        newFilterTemplates.add(newTemplate);
                    } else {
                        newFilterTemplates.add(template);
                    }
                }

                // 更新 value 中的 filterTemplates
                value.put("WFActionParameterFilterTemplates", newFilterTemplates);
            }
        }

        return actions;
    }


    /**
     * 验证快捷指令是否相同
     *
     * @param file       快捷指令Plist文件
     * @param shortcutId 快捷指令id
     * @param version    快捷指令版本
     */
    public boolean validateShortcut(MultipartFile file, String shortcutId, String version) {
        // 读取本地 plist 文件
        String userShortcut = null;
        try {
            userShortcut = new String(file.getBytes());
        } catch (IOException e) {
            throw new BizException(ApiErrorCode.FAILED_TO_READ_FILE);
        }
        //从数据库获取快捷指令的url
        ShortcutInfoDO shortcutInfoDO = shortcutInfoMapper.selectByShortcutIdAndVersion(shortcutId, version);
        String correctShortcutUrl = shortcutInfoDO.getUrl();
        String correctShortcut = downloadShortcut(correctShortcutUrl);
        log.info("userShortcut:{}", userShortcut);
        log.info("correctShortcut:{}", correctShortcut);
        boolean isEqual = compareShortcutActions(userShortcut, correctShortcut);
        return isEqual;
    }

    /**
     * 验证快捷指令是否相同
     * 客户端传过来的plist文件是转义过的json
     *
     * @param userShortcut 快捷指令Plist文件的json字符串
     * @param shortcutId   快捷指令id
     * @param version      快捷指令版本
     */
    public boolean validateShortcut(String userShortcut, String shortcutId, String version) {
        ShortcutInfoDO shortcutInfoDO = shortcutInfoMapper.selectByShortcutIdAndVersion(shortcutId, version);
        if (shortcutInfoDO == null) {
            throw new BizException(ApiErrorCode.SHORTCUT_NOT_FOUND);
        }
        String correctShortcutUrl = shortcutInfoDO.getUrl();
        String correctShortcut = downloadShortcut(correctShortcutUrl);
        boolean isEqual = compareShortcutActionsWithJsonAndXml(userShortcut, correctShortcut);
        return isEqual;
    }

}