wps多维表指令集

需要指令集的

一键复制代码js代码,粘贴即可用
字段操作,查询,添加,删除,更新

表操作,增删改查

数据操作,增删改查,上传图片,获取图片链接

构建上传单条数据格式,多条数据格式,增加修改数据无忧

function main(Context) {
    const {
        operateType,
        sheetName,    // 用表名，不是 ID
        sheetId = 0,
        records = [],
        recordIds = [],
        imgbas64 = "",
        recordId = "",
        imgname = "",
        pagefy = "",
        filter = null,
        upId = "",
        maxRecords = undefined,
        // Sheet 相关参数
        newSheetName = "",
        newSheetIndex = undefined,
        // View 相关参数
        viewId = 0,
        viewName = "",
        viewType = "",
        // Field 相关参数
        fieldId = "",
        fieldName = "",
        newFieldName = "",
        fieldType = "",
        fields = []
    } = Context.argv;

    // 中文字段类型映射
    const fieldTypeMap = {
        "多行文本": "MultiLineText",
        "文本": "MultiLineText",
        "日期": "Date",
        "时间": "Time",
        "数值": "Number",
        "数字": "Number",
        "货币": "Currency",
        "百分比": "Percentage",
        "身份证": "ID",
        "电话": "Phone",
        "电子邮箱": "Email",
        "邮箱": "Email",
        "超链接": "Url",
        "复选框": "Checkbox",
        "单选项": "SingleSelect",
        "多选项": "MultipleSelect",
        "等级": "Rating",
        "进度条": "Complete",
        "联系人": "Contact",
        "附件": "Attachment",
        "关联": "Link",
        "富文本": "Note",
        "编号": "AutoNumber",
        "创建者": "CreatedBy",
        "创建时间": "CreatedTime",
        "公式": "Formula",
        "引用": "Lookup"
    };

    // 视图类型映射
    const viewTypeMap = {
        "表格": "Grid",
        "看板": "Kanban",
        "画册": "Gallery",
        "表单": "Form",
        "甘特": "Gantt"
    };

    // 转换字段类型
    let finalFieldType = fieldType;
    if (fieldType && fieldTypeMap[fieldType]) {
        finalFieldType = fieldTypeMap[fieldType];
    }

    // 转换视图类型
    let finalViewType = viewType;
    if (viewType && viewTypeMap[viewType]) {
        finalViewType = viewTypeMap[viewType];
    }

    // 根据表名获取正确 sheetId
    let realSheetId = sheetId;
    if (sheetName) {
        const allSheets = Application.Sheet.GetSheets();
        for (let i = 0; i < allSheets.length; i++) {
            const s = allSheets[i];
            if (s.name.trim() === sheetName.trim()) {
                realSheetId = s.id;
                break;
            }
        }
    }

    // 只新增：根据表名获取索引
    function getSheetIndexByName(name) {
        const sheets = Application.Sheet.GetSheets();
        for (let i = 0; i < sheets.length; i++) {
            if (sheets[i].name.trim() === name.trim()) {
                return i + 1; // 索引从1开始
            }
        }
        return 1;
    }

    if (operateType === "query") {
        function fetchAllRecords() {
            let allRecords = [];
            let offset = pagefy ? pagefy : null;
            let pageCount = 0; // 计数，控制每次只查3页

            // 最多查2页就停止，防止超时
            while ((allRecords.length === 0 || offset) && pageCount < 2) {
                const queryParams = {
                    SheetId: realSheetId,
                    Offset: offset,
                    PageSize: 1000, // 严格遵守最大1000，不动！
                    MaxRecords: maxRecords
                };

                if (filter) queryParams.Filter = filter;
                if (!maxRecords) delete queryParams.MaxRecords;

                const recordsResult = Application.Record.GetRecords(queryParams);
                offset = recordsResult.offset;
                allRecords = allRecords.concat(recordsResult.records);

                pageCount++; // 页数+1
                if (!offset) break;
            }

            // 返回当前查到的所有数据 + 下一页offset，给Python继续拉
            return [offset, allRecords];
        }
        return fetchAllRecords();
    }

    // 上传图片（只修改这里：使用索引）其他完全不动
    if (operateType === "ym") {
        return Application.Sheets(getSheetIndexByName(sheetName)).Views(1).RecordRange(recordId, `@${imgname}`).Value = Application.DBCellValue([{
            fileData: imgbas64,
            fileName: `${recordId}.png`
        }]);
    }

    // 获取图片下载地址
    if (operateType === "xz") {
        return Application.Record.GetAttachmentURL({
            UploadId: upId,
            Source: "upload_ks3"
        });
    }

    // 新建
    if (operateType === "create") {
        return Application.Record.CreateRecords({
            SheetId: realSheetId,
            Records: records
        });
    }

    // 删除
    if (operateType === "delete") {
        return Application.Record.DeleteRecords({
            SheetId: realSheetId,
            RecordIds: recordIds
        });
    }

    // 更新
    if (operateType === "update") {
        return Application.Record.UpdateRecords({
            SheetId: realSheetId,
            Records: [{
                id: recordId,
                fields: records[0].fields
            }]
        });
    }

    // ======================== Sheet 表操作 ========================
    // 获取所有 Sheet 表
    if (operateType === "sheet_get_all") {
        try {
            const allSheets = Application.Sheet.GetSheets();
            const simplifiedSheets = [];
            
            for (let i = 0; i < allSheets.length; i++) {
                const sheet = allSheets[i];
                simplifiedSheets.push({
                    id: sheet.id,
                    name: sheet.name,
                    type: sheet.sheetType,
                    recordsCount: sheet.recordsCount || sheet.recoredsCount || 0,
                    fieldsCount: sheet.fields ? sheet.fields.length : 0
                });
            }
            
            return {
                totalCount: simplifiedSheets.length,
                sheets: simplifiedSheets
            };
        } catch (e) {
            return { error: e.message };
        }
    }

    // 创建新 Sheet 表（根据官方文档）
    if (operateType === "sheet_create") {
        try {
            const result = Application.Sheet.CreateSheet({
                Name: newSheetName,
                Fields: [
                    { name: '字段1', type: 'MultiLineText' }
                ],
                Views: [
                    { name: '视图1', type: 'Grid' }
                ]
            });
            
            return {
                success: true,
                message: "创建表成功",
                id: result.id,
                name: result.name
            };
        } catch (e) {
            return { error: e.message };
        }
    }

    // 删除 Sheet 表
    if (operateType === "sheet_delete") {
        try {
            Application.Sheet.DeleteSheet({
                SheetId: realSheetId
            });
            return {
                success: true,
                message: "删除表成功",
                sheetId: realSheetId,
                sheetName: sheetName
            };
        } catch (e) {
            return { error: e.message };
        }
    }

    // 重命名 Sheet 表
    if (operateType === "sheet_rename") {
        try {
            Application.Sheet.UpdateSheet({
                SheetId: realSheetId,
                Name: newSheetName
            });
            return {
                success: true,
                message: "重命名表成功",
                sheetId: realSheetId,
                oldName: sheetName,
                newName: newSheetName
            };
        } catch (e) {
            return { error: e.message };
        }
    }

    // ======================== View 视图操作 ========================
    // 获取某个 Sheet 的所有视图
    if (operateType === "view_get_all") {
        try {
            const allViews = Application.View.GetViews({ SheetId: realSheetId });
            const simplifiedViews = [];
            
            for (let i = 0; i < allViews.length; i++) {
                const view = allViews[i];
                simplifiedViews.push({
                    id: view.id,
                    name: view.name,
                    type: view.type
                });
            }
            
            return {
                totalCount: simplifiedViews.length,
                views: simplifiedViews
            };
        } catch (e) {
            return { error: e.message };
        }
    }

    // 创建视图
    if (operateType === "view_create") {
        try {
            const viewParams = { name: viewName, type: 'Grid' };
            if (finalViewType) {
                viewParams.type = finalViewType;
            }
            
            const result = Application.View.CreateView({
                SheetId: realSheetId,
                View: viewParams
            });
            
            return {
                success: true,
                message: "创建视图成功",
                id: result.id,
                name: result.name,
                type: result.type
            };
        } catch (e) {
            return { error: e.message };
        }
    }

    // 删除视图（用名称）
    if (operateType === "view_delete") {
        try {
            // 获取所有视图，通过名称找到ID
            const allViews = Application.View.GetViews({ SheetId: realSheetId });
            let targetViewId = viewId;
            
            if (viewName) {
                for (let i = 0; i < allViews.length; i++) {
                    if (allViews[i].name === viewName) {
                        targetViewId = allViews[i].id;
                        break;
                    }
                }
            }
            
            if (!targetViewId) {
                return { error: "未找到视图: " + (viewName || viewId) };
            }
            
            Application.View.DeleteView({
                SheetId: realSheetId,
                ViewId: targetViewId
            });
            
            return {
                success: true,
                message: "删除视图成功",
                viewId: targetViewId,
                viewName: viewName
            };
        } catch (e) {
            return { error: e.message };
        }
    }

    // 重命名视图（用原名称）
    if (operateType === "view_rename") {
        try {
            // 获取所有视图，通过原名称找到ID
            const allViews = Application.View.GetViews({ SheetId: realSheetId });
            let targetViewId = viewId;
            
            // fieldName 传的是原视图名
            if (fieldName && !viewId) {
                for (let i = 0; i < allViews.length; i++) {
                    if (allViews[i].name === fieldName) {
                        targetViewId = allViews[i].id;
                        break;
                    }
                }
            }
            
            if (!targetViewId) {
                return { error: "未找到视图: " + (fieldName || viewId) };
            }
            
            const result = Application.View.UpdateView({
                SheetId: realSheetId,
                ViewId: targetViewId,
                View: { name: viewName }
            });
            
            return {
                success: true,
                message: "重命名视图成功",
                id: result.id,
                oldName: fieldName,
                newName: viewName
            };
        } catch (e) {
            return { error: e.message };
        }
    }

    // ======================== Field 字段操作 ========================
    // 获取某个 Sheet 的所有字段 - 只返回 id 和 name 的字典
    if (operateType === "field_get_all") {
        try {
            const fields = Application.Field.GetFields({ SheetId: realSheetId });
            const result = {};
            for (let i = 0; i < fields.length; i++) {
                result[fields[i].id] = fields[i].name;
            }
            return result;
        } catch (e) {
            return { error: e.message };
        }
    }

    // 创建字段
    if (operateType === "field_create") {
        try {
            const result = Application.Field.CreateFields({
                SheetId: realSheetId,
                Fields: [{ name: fieldName, type: finalFieldType }]
            });
            
            if (result && result.length > 0) {
                return {
                    success: true,
                    message: "创建字段成功",
                    fieldId: result[0].id,
                    fieldName: result[0].name,
                    fieldType: result[0].type
                };
            }
            return result;
        } catch (e) {
            return { error: e.message };
        }
    }

    // 删除字段
    if (operateType === "field_delete") {
        try {
            // 获取所有字段，通过名称查找对应的ID
            const allFields = Application.Field.GetFields({ SheetId: realSheetId });
            let targetFieldId = fieldId;
            let targetFieldName = "";
            
            // 如果传入的是名称而不是ID，查找对应的ID
            if (fieldName) {
                for (let i = 0; i < allFields.length; i++) {
                    if (allFields[i].name === fieldName) {
                        targetFieldId = allFields[i].id;
                        targetFieldName = allFields[i].name;
                        break;
                    }
                }
            }
            
            if (!targetFieldId) {
                return { error: "未找到字段: " + (fieldName || fieldId) };
            }
            
            const result = Application.Field.DeleteFields({
                SheetId: realSheetId,
                FieldIds: [targetFieldId]
            });
            
            return {
                success: true,
                message: "删除字段成功",
                fieldId: targetFieldId,
                fieldName: targetFieldName || fieldName
            };
        } catch (e) {
            return { error: e.message };
        }
    }

    // 重命名字段
    if (operateType === "field_rename") {
        try {
            // 获取所有字段，通过名称查找对应的ID
            const allFields = Application.Field.GetFields({ SheetId: realSheetId });
            let targetFieldId = fieldId;
            
            // 如果传入的是原字段名称而不是ID，查找对应的ID
            if (fieldName && !fieldId) {
                for (let i = 0; i < allFields.length; i++) {
                    if (allFields[i].name === fieldName) {
                        targetFieldId = allFields[i].id;
                        break;
                    }
                }
            }
            
            if (!targetFieldId) {
                return { error: "未找到字段: " + (fieldName || fieldId) };
            }
            
            const result = Application.Field.UpdateFields({
                SheetId: realSheetId,
                Fields: [{ id: targetFieldId, name: newFieldName }]
            });
            
            if (result && result.length > 0) {
                return {
                    success: true,
                    message: "重命名成功",
                    fieldId: result[0].id,
                    newName: result[0].name
                };
            }
            return result;
        } catch (e) {
            return { error: e.message };
        }
    }

    // 更新字段类型
    if (operateType === "field_update_type") {
        try {
            // 获取所有字段，通过名称查找对应的ID
            const allFields = Application.Field.GetFields({ SheetId: realSheetId });
            let targetFieldId = fieldId;
            let targetFieldName = "";
            
            // 如果传入的是字段名称而不是ID，查找对应的ID
            if (fieldName && !fieldId) {
                for (let i = 0; i < allFields.length; i++) {
                    if (allFields[i].name === fieldName) {
                        targetFieldId = allFields[i].id;
                        targetFieldName = allFields[i].name;
                        break;
                    }
                }
            }
            
            if (!targetFieldId) {
                return { error: "未找到字段: " + (fieldName || fieldId) };
            }
            
            const result = Application.Field.UpdateFields({
                SheetId: realSheetId,
                Fields: [{ id: targetFieldId, type: finalFieldType }]
            });
            
            if (result && result.length > 0) {
                return {
                    success: true,
                    message: "更新字段类型成功",
                    fieldId: result[0].id,
                    fieldName: targetFieldName || fieldName,
                    newType: result[0].type
                };
            }
            return result;
        } catch (e) {
            return { error: e.message };
        }
    }

    throw new Error("不支持的操作类型：" + operateType);
}

return main(Context);

import xbot
from xbot import print, sleep
from . import package
from .package import variables as glv
import requests
import base64
import asyncio
import aiohttp

# ======================== 中文条件映射（官方标准） ========================
# 中文筛选条件 → 转成接口能识别的英文
条件映射 = {
    "等于": "Equals",
    "不等于": "NotEqu",
    "大于": "Greater",
    "大于等于": "GreaterEqu",
    "小于": "Less",
    "小于等于": "LessEqu",
    "介于取等": "GreaterEquAndLessEqu",
    "介于不等": "LessOrGreater",
    "开头是": "BeginWith",
    "结尾是": "EndWith",
    "包含": "Contains",
    "不包含": "NotContains",
    "指定值": "Intersected",
    "为空": "Empty",
    "不为空": "NotEmpty"
}

# ======================== 同步统一请求（底层接口，不用管） ========================
# 接口统一调用方法，所有增删改查都会走这里
def request_api(接口地址, 接口密钥, 操作类型, 参数数据):
    """
    :param 接口地址: 接口地址（全局变量里的 hook）
    :param 接口密钥: 接口密钥（全局变量里的 密钥）
    :param 操作类型: 操作类型（query/create/update/delete/ym/xz）
    :param 参数数据: 接口参数（字典格式）
    """
    请求头 = {
        "Content-Type": "application/json",
        "AirScript-Token": 接口密钥
    }
    响应 = requests.post(
        接口地址,
        json={"Context": {"argv": {"operateType": 操作类型, **参数数据}}},
        headers=请求头
    )
    结果 = 响应.json()
    数据 = 结果.get("data", {})
    错误 = 结果.get("error", "").strip()
    响应数据 = 数据.get("result")
    
    if 响应数据 is None or 错误:
        if 错误 != "运行超时":
            if 错误:
                raise Exception(错误)
    return 响应数据

# ======================== 异步请求（底层接口，不用管） ========================
async def _async_request_api(会话, 接口地址, 接口密钥, 操作类型, 参数数据):
    请求头 = {
        "Content-Type": "application/json",
        "AirScript-Token": 接口密钥
    }
    async with 会话.post(
        接口地址,
        json={"Context": {"argv": {"operateType": 操作类型, **参数数据}}},
        headers=请求头
    ) as 响应:
        结果 = await 响应.json()
        数据 = 结果.get("data", {})
        错误 = 结果.get("error", "").strip()
        响应数据 = 数据.get("result")
        
        if 响应数据 is None or 错误:
            if 错误 != "运行超时":
                if 错误:
                    raise Exception(错误)
        return 响应数据

# ======================== 全表数据查询（自动分页） ========================
def 查询全表数据(接口地址, 接口密钥, 表名):
    """
    【功能】查询整张表的所有数据
    :param 接口地址:    接口地址 → 填 glv["hook"]
    :param 接口密钥:  接口密钥 → 填 glv["密钥"]
    :param 表名: 表名     → 例："销售表"
    :return: 表格所有数据
    """
    async def run():
        所有数据 = []
        分页标识 = ""
        async with aiohttp.ClientSession() as 会话:
            while True:
                响应数据 = await _async_request_api(
                    会话, 接口地址, 接口密钥, "query", 
                    {"sheetName": 表名, "pagefy": 分页标识}
                )
                偏移量, 记录列表 = 响应数据
                所有数据 += 记录列表
                if not 偏移量:
                    break
                分页标识 = 偏移量
        return 所有数据
    return asyncio.run(run())

# ======================== 单条件筛选查询 ========================
def 查询单条件(接口地址, 接口密钥, 表名, 字段名, 中文条件, 条件值):
    """
    【功能】按一个条件查询数据
    :param 接口地址:    接口地址 → glv["hook"]
    :param 接口密钥:  接口密钥 → glv["密钥"]
    :param 表名: 表名     → "销售表"
    :param 字段名:      字段名   → "客户姓名"
    :param 中文条件:      条件     → "等于"/"包含"/"大于"
    :param 条件值:      条件值   → "张三"
    :return: 符合条件的数据
    """
    英文条件 = 条件映射[中文条件]
    筛选条件 = {
        "mode": "AND",
        "criteria": [{"field": 字段名, "op": 英文条件, "values": [条件值]}]
    }

    async def run():
        所有数据 = []
        分页标识 = ""
        async with aiohttp.ClientSession() as 会话:
            while True:
                响应数据 = await _async_request_api(
                    会话, 接口地址, 接口密钥, "query", {
                        "sheetName": 表名,
                        "pagefy": 分页标识,
                        "filter": 筛选条件
                    }
                )
                偏移量, 记录列表 = 响应数据
                所有数据 += 记录列表
                if not 偏移量:
                    break
                分页标识 = 偏移量
        return 所有数据
    return asyncio.run(run())

# ======================== 多条件组合筛选查询 ========================
def 查询多条件(接口地址, 接口密钥, 表名, 条件列表, 组合方式="AND"):
    """
    【功能】多个条件一起查询
    :param 接口地址:     接口地址 → glv["hook"]
    :param 接口密钥:   接口密钥 → glv["密钥"]
    :param 表名:  表名     → "测试表"
    :param 条件列表:  条件列表 → [(字段名,条件,值), (字段名,条件,值)]
    :param 组合方式:        组合方式 → AND=同时满足 / OR=任一满足
    :return: 符合条件的数据
    """
    条件集合 = []
    筛选条件 = {}
    
    if 条件列表 and len(条件列表) > 0:
        for 字段名, 中文条件, 条件值 in 条件列表:
            英文条件 = 条件映射[中文条件]
            条件集合.append({
                "field": 字段名, 
                "op": 英文条件, 
                "values": [条件值]
            })
        筛选条件 = {"mode": 组合方式, "criteria": 条件集合}

    async def run():
        所有数据 = []
        分页标识 = ""
        async with aiohttp.ClientSession() as 会话:
            while True:
                响应数据 = await _async_request_api(
                    会话, 接口地址, 接口密钥, "query", {
                        "sheetName": 表名,
                        "pagefy": 分页标识,
                        "filter": 筛选条件
                    }
                )
                偏移量, 记录列表 = 响应数据
                所有数据 += 记录列表
                if not 偏移量:
                    break
                分页标识 = 偏移量
        return 所有数据
    return asyncio.run(run())

# ======================== 单条新增数据 ========================
def 新增单条数据(接口地址, 接口密钥, 表名, 字段内容):
    """
    【功能】新增一条数据
    :param 接口地址:     接口地址 → glv["hook"]
    :param 接口密钥:   接口密钥 → glv["密钥"]
    :param 表名:  表名     → "客户表"
    :param 字段内容:      字段内容 → {"姓名":"张三","电话":"13800138000"}
    :return: 新增记录ID
    """
    return request_api(接口地址, 接口密钥, "create", {
        "sheetName": 表名,
        "records": [{"fields": 字段内容}]
    })

# ======================== 批量新增数据 ========================
def 新增批量数据(接口地址, 接口密钥, 表名, 记录列表):
    """
    【功能】一次性新增多条数据
    :param 接口地址:       接口地址 → glv["hook"]
    :param 接口密钥:     接口密钥 → glv["密钥"]
    :param 表名:    表名
    :param 记录列表:  多条记录列表
    """
    格式化记录 = [{"fields": 每一项} for 每一项 in 记录列表]
    return request_api(接口地址, 接口密钥, "create", {
        "sheetName": 表名,
        "records": 格式化记录
    })

# ======================== 更新单行数据 ========================
def 更新单条数据(接口地址, 接口密钥, 表名, 记录ID, 字段内容):
    """
    【功能】修改一条记录
    :param 接口地址:     接口地址 → glv["hook"]
    :param 接口密钥:   接口密钥 → glv["密钥"]
    :param 表名:  表名
    :param 记录ID:   记录ID（必须有）
    :param 字段内容:      要修改的字段内容
    """
    return request_api(接口地址, 接口密钥, "update", {
        "sheetName": 表名,
        "recordId": 记录ID,
        "records": [{"fields": 字段内容}]
    })

# ======================== 单条删除 ========================
def 删除单条数据(接口地址, 接口密钥, 表名, 记录ID):
    """
    【功能】删除一条记录
    :param 接口地址:     接口地址
    :param 接口密钥:   接口密钥
    :param 表名:  表名
    :param 记录ID:   要删除的记录ID
    """
    return request_api(接口地址, 接口密钥, "delete", {
        "sheetName": 表名,
        "recordIds": [记录ID]
    })

# ======================== 批量删除 ========================
def 删除批量数据(接口地址, 接口密钥, 表名, 记录ID列表):
    """
    【功能】批量删除多条记录
    :param 记录ID列表:  [记录ID1,记录ID2,...]
    """
    return request_api(接口地址, 接口密钥, "delete", {
        "sheetName": 表名,
        "recordIds": 记录ID列表
    })

# ======================== 上传图片 ========================
def 上传图片(接口地址, 接口密钥, 表名, 记录ID, 字段名, 图片路径):
    """
    【功能】给某条记录上传图片/附件
    :param 字段名:  附件字段名 → "图片和附件"
    :param 图片路径:    图片本地路径
    """
    with open(图片路径, "rb") as 文件句柄:
        编码内容 = base64.b64encode(文件句柄.read()).decode()
    
    return request_api(接口地址, 接口密钥, "ym", {
        "sheetName": 表名,
        "recordId": 记录ID,
        "imgname": 字段名,
        "imgbas64": f"data:image/png;base64,{编码内容}"
    })

# ======================== 获取图片下载地址 ========================
def 获取图片链接(接口地址, 接口密钥, 表名, 上传ID, 来源="upload_ks3"):
    """
    【功能】根据上传ID获取图片下载链接
    """
    return request_api(接口地址, 接口密钥, "xz", {
        "sheetName": 表名,
        "upId": 上传ID,
        "source": 来源
    })

# ======================== 新增数据 + 上传图片 ========================
def 新增带图片(接口地址, 接口密钥, 表名, 字段内容, 图片字典):
    记录ID = 新增单条数据(接口地址, 接口密钥, 表名, 字段内容)[0]["id"]
    for 字段, 路径 in 图片字典.items():
        for 尝试次数 in range(3):
            try:
                上传图片(接口地址, 接口密钥, 表名, 记录ID, 字段, 路径)
                break
            except Exception as 错误:
                pass

# ======================== 更新数据 + 替换图片 ========================
def 更新带图片(接口地址, 接口密钥, 表名, 记录ID, 字段内容, 图片字典):
    更新单条数据(接口地址, 接口密钥, 表名, 记录ID, 字段内容)
    for 字段, 路径 in 图片字典.items():
        for 尝试次数 in range(3):
            try:
                上传图片(接口地址, 接口密钥, 表名, 记录ID, 字段, 路径)
                break
            except Exception as 错误:
                pass

# ======================== Sheet 表操作 ========================
def 获取所有表(接口地址, 接口密钥):
    """
    【功能】获取所有 Sheet 表
    :param 接口地址:    接口地址
    :param 接口密钥:  接口密钥
    :return: 所有表信息
    """
    return request_api(接口地址, 接口密钥, "sheet_get_all", {})

def 创建表(接口地址, 接口密钥, 表名, 索引=None):
    """
    【功能】创建新的 Sheet 表
    :param 接口地址:    接口地址
    :param 接口密钥:  接口密钥
    :param 表名: 新表名
    :param 索引: 插入位置（可选）
    :return: 创建结果
    """
    参数 = {"newSheetName": 表名}
    if 索引 is not None:
        参数["newSheetIndex"] = 索引
    return request_api(接口地址, 接口密钥, "sheet_create", 参数)

def 删除表(接口地址, 接口密钥, 表名):
    """
    【功能】删除指定的 Sheet 表
    :param 接口地址:    接口地址
    :param 接口密钥:  接口密钥
    :param 表名: 要删除的表名
    """
    return request_api(接口地址, 接口密钥, "sheet_delete", {"sheetName": 表名})

def 重命名表(接口地址, 接口密钥, 原表名, 新表名):
    """
    【功能】重命名 Sheet 表
    :param 接口地址:    接口地址
    :param 接口密钥:  接口密钥
    :param 原表名: 原表名
    :param 新表名: 新表名
    """
    return request_api(接口地址, 接口密钥, "sheet_rename", {"sheetName": 原表名, "newSheetName": 新表名})

# ======================== View 视图操作 ========================
def 获取所有视图(接口地址, 接口密钥, 表名):
    """
    【功能】获取指定 Sheet 的所有视图
    :param 接口地址:    接口地址
    :param 接口密钥:  接口密钥
    :param 表名: 表名
    :return: 所有视图信息
    """
    return request_api(接口地址, 接口密钥, "view_get_all", {"sheetName": 表名})

def 创建视图(接口地址, 接口密钥, 表名, 视图名, 视图类型=None):
    """
    【功能】创建新视图
    :param 接口地址:    接口地址
    :param 接口密钥:  接口密钥
    :param 表名: 表名
    :param 视图名: 视图名称
    :param 视图类型: 视图类型（可选）
    :return: 创建结果
    """
    参数 = {"sheetName": 表名, "viewName": 视图名}
    if 视图类型:
        参数["viewType"] = 视图类型
    return request_api(接口地址, 接口密钥, "view_create", 参数)

def 删除视图(接口地址, 接口密钥, 表名, 视图名):
    """
    【功能】删除指定视图
    :param 接口地址:    接口地址
    :param 接口密钥:  接口密钥
    :param 表名: 表名
    :param 视图名: 视图名称
    """
    return request_api(接口地址, 接口密钥, "view_delete", {"sheetName": 表名, "viewName": 视图名})

def 重命名视图(接口地址, 接口密钥, 表名, 原视图名, 新视图名):
    """
    【功能】重命名视图
    :param 接口地址:    接口地址
    :param 接口密钥:  接口密钥
    :param 表名: 表名
    :param 原视图名: 原视图名称
    :param 新视图名: 新视图名称
    """
    return request_api(接口地址, 接口密钥, "view_rename", {"sheetName": 表名, "fieldName": 原视图名, "viewName": 新视图名})

# ======================== Field 字段操作 ========================
def 获取所有字段(接口地址, 接口密钥, 表名):
    """
    【功能】获取指定 Sheet 的所有字段
    :param 接口地址:    接口地址
    :param 接口密钥:  接口密钥
    :param 表名: 表名
    :return: 所有字段信息
    """
    return request_api(接口地址, 接口密钥, "field_get_all", {"sheetName": 表名})

def 创建字段(接口地址, 接口密钥, 表名, 字段名, 字段类型):
    """
    【功能】创建新字段
    :param 接口地址:    接口地址
    :param 接口密钥:  接口密钥
    :param 表名: 表名
    :param 字段名: 字段名称
    :param 字段类型: 字段类型
    :return: 创建结果
    """
    return request_api(接口地址, 接口密钥, "field_create", {"sheetName": 表名, "fieldName": 字段名, "fieldType": 字段类型})

def 删除字段(接口地址, 接口密钥, 表名, 字段名):
    """
    【功能】删除指定字段
    :param 接口地址:    接口地址
    :param 接口密钥:  接口密钥
    :param 表名: 表名
    :param 字段名: 字段名称
    """
    return request_api(接口地址, 接口密钥, "field_delete", {"sheetName": 表名, "fieldName": 字段名})

def 重命名字段(接口地址, 接口密钥, 表名, 原字段名, 新字段名):
    """
    【功能】重命名字段
    :param 接口地址:    接口地址
    :param 接口密钥:  接口密钥
    :param 表名: 表名
    :param 原字段名: 原字段名称
    :param 新字段名: 新字段名称
    """
    return request_api(接口地址, 接口密钥, "field_rename", {"sheetName": 表名, "fieldName": 原字段名, "newFieldName": 新字段名})

def 更新字段类型(接口地址, 接口密钥, 表名, 字段名, 新字段类型):
    """
    【功能】更新字段类型
    :param 接口地址:    接口地址
    :param 接口密钥:  接口密钥
    :param 表名: 表名
    :param 字段名: 字段名称
    :param 新字段类型: 新字段类型
    """
    return request_api(接口地址, 接口密钥, "field_update_type", {"sheetName": 表名, "fieldName": 字段名, "fieldType": 新字段类型})

# ===================== 实战调用示例 =====================
def main(args):
    # 读取影刀全局变量配置
    API_URL = glv["hook"]       # 接口地址
    API_TOKEN = glv["密钥"]     # 接口密钥

    # 多条件筛选：查询所有带有图片附件的数据
    条件列表 = [
        ("图片和附件", "不等于", ""),
    ]
    数据 = 查询多条件(API_URL, API_TOKEN, "测试", 条件列表, 组合方式="AND")
    print([每一项["fields"]["图片和附件"][0]["uploadId"] for 每一项 in 数据])
    print(获取图片链接(API_URL, API_TOKEN, "测试", [每一项["fields"]["图片和附件"][0]["uploadId"] for 每一项 in 数据][1]))