---
title: 低代码学习案例
date: 2024-11-15T20:31:20+08:00
lastmod: 2024-11-16T17:14:55+08:00
---

# 低代码学习案例

<iframe src="/widgets/Flip-Clock/" data-src="/widgets/Flip-Clock/" data-subtype="widget" border="0" frameborder="no" framespacing="0" allowfullscreen="true" style="width: 1077px; height: 116px;"></iframe>

# <span data-type="text" style="text-shadow: 1px 1px var(--b3-theme-surface-lighter), 2px 2px var(--b3-theme-surface-lighter), 3px 3px var(--b3-theme-surface-lighter), 4px 4px var(--b3-theme-surface-lighter);">功能：不同的时间字段，选取最新字段更新指定的时间字段</span>

　　主要作用：将所有时间字段更新至指定时间字段，只要其中一个更新，都会将最新的时间字段同步到指定字段。

```javascript
// 初始化存储上一个值的对象，将所有字段初始化为 undefined
let previousValues = {
    "date_3": undefined,
    "date_4": undefined,
    "date_5": undefined,
    "date_6": undefined,
    "date_7": undefined,
    "date_9": undefined,
    "date_10": undefined,
    "date_11": undefined
};

// 异步函数，用于处理时间戳
export async function handleTimestamp() {
    try {
        // 从多个字段中获取时间戳，这里只是示例，请根据实际字段标识修改
        const result3 = await sdk.getValue("date_3");
        const result4 = await sdk.getValue("date_4");
        const result5 = await sdk.getValue("date_5");
        const result6 = await sdk.getValue("date_6");
        const result7 = await sdk.getValue("date_7");
        const result9 = await sdk.getValue("date_9");
        const result10 = await sdk.getValue("date_10");
        const result11 = await sdk.getValue("date_11");

        // 获取实际的值，确保存在 result 对象和其包含 value 属性
        const date3 = result3 && result3.value;
        const date4 = result4 && result4.value;
        const date5 = result5 && result5.value;
        const date6 = result6 && result6.value;
        const date7 = result7 && result7.value;
        const date9 = result9 && result9.value;
        const date10 = result10 && result10.value;
        const date11 = result11 && result11.value;

        // 检查哪个字段发生了变化
        const changedField = getChangedField(
            { name: "date_3", value: date3 },
            { name: "date_4", value: date4 },
            { name: "date_5", value: date5 },
            { name: "date_6", value: date6 },
            { name: "date_7", value: date7 },
            { name: "date_9", value: date9 },
            { name: "date_10", value: date10 },
            { name: "date_11", value: date11 }
        );

        // 更新前一个值，使用字符串作为属性名，以确保代码清晰可读
        previousValues = {
            "date_3": date3,
            "date_4": date4,
            "date_5": date5,
            "date_6": date6,
            "date_7": date7,
            "date_9": date9,
            "date_10": date10,
            "date_11": date11
        };

        if (changedField) {
            // 将变动的字段值赋给 date_13
            await sdk.setValue("date_13", changedField.value);
            console.log(`成功设置 date_13 字段，值为: ${changedField.value}`);
        } else {
            console.log("没有字段发生变化，无需设置 date_13。");
        }

    } catch (error) {
        console.error("发生错误:", error);
    }
}

// 辅助函数，用于检查哪个字段发生了变化
function getChangedField(...fields) {
    for (const field of fields) {
        const previousValue = previousValues[field.name];

        // 同时检查undefined和null
        if (field.value !== previousValue && (field.value !== undefined || previousValue !== undefined)) {
            console.log(`字段 ${field.name} 的值发生了变化。先前值: ${previousValue}, 当前值: ${field.value}`);
            return field;
        }
    }
    console.log("没有字段发生变化。");
    return null;
}
```

# 功能：弹窗辅助判断完成签单前成交填写

　　主要作用：签单前服务，提交表单的时候获取成交字段，如果不等于是，则弹出提示框，辅助判断是否成交，如果确认“是”，则继续提醒完成下个阶段的填写，并且可以继续操作。如果确认为“否”则，弹出提示。

```jsx
//辅助完成签单前成交填写
export async function remindup() {
    // 获取成交信息
    const isTransactionCompleted = await sdk.getValue("text_11"); 
    const isTransactionCompletedValue = isTransactionCompleted.value;
  
    if (isTransactionCompletedValue.text !== "是") {
        const result = await sdk.confirm({
            title: '温馨提示',
            content: '请确认客户成交情况！',
            confirmButtonText: '成交',
            cancelButtonText: '未成交',
            type: 'warning'
        });

        const valuerestule = result.confirm
            ? { text: '是', value: "63e16b96-9f6c-50b6-0e68-7a7e987b5383" }
            : { text: '否', value: "5a752092-1d3f-12b4-762f-8fff9170ae95" };

        // await sdk.setValue("text_11", valuerestule); 

  
        // 处理确认或取消后的逻辑
        if (result.confirm) {
            // 处理确认后的逻辑
            await sdk.setValue("text_11", valuerestule); 
            const text41value = await sdk.getValue("text_41")
            console.log("特性:",text41value)
            if (text41value.value !== "是" || text41value.value === undefined){
                console.log("请填写签单节点");
                await sdk.showToast({
                type: 'Reminder',
                content: '温馨提示：请填写是否按时发送设计节点！',
                time: 5000
            });
						  //阻止继续提交，避免导致提交无法点选。
                return false;
            }
            console.log("点击了确认按钮");
        } else {
            // 处理取消后的逻辑
            console.log("点击了取消按钮");

            // 如果选择的是未成交，弹出提示
            await sdk.showToast({
                type: 'Reminder',
                content: '温馨提示：该客户确认未成交，不允许创建合同订单。',
                time: 4000
            });

            // 继续执行其他取消后的逻辑
            console.log("继续执行其他取消后的逻辑");
        }
    } else {
        console.log("条件不满足。");
        return "条件不满足。";
    }
}
```

# 功能：通过确认来判断值的情况继续操作

　　主要作用：来判断流量部的客管经理是否填写，如果每天写只是弹出提醒，但是`不影响`后续操作。

```javascript
// 使用 async function 来包裹异步操作
export async function checkUser() {
    try {
        // 使用 await 来获取 ownerId 的值
        const user = await sdk.getValue("ownerId");
        console.log(user.value);

        // 检查 user.value 是否为 undefined 并且当成员清空以后数组不能等于0
        if (user.value === undefined || user.value.length == 0) {
            // 使用 await 来等待用户的确认操作
            const result = await sdk.confirm({
                title: '温馨提示',
                content: '此单未填写客管经理，将进入公海池，请确认操作！',
                confirmButtonText: '确认',
                cancelButtonText: '取消',
                type: 'warning'
            });

            // 根据确认结果进行相应的处理
            if (result.confirm) {
                console.log("点击了确认");
            } else {
                console.log("点击了取消");
                return false;
            }
        }
  
        // 如果 ownerId 的值不为 undefined，或者用户点击了确认，继续执行后续逻辑
        // 你可以在这里添加其他逻辑

        return true; // 表示检查通过
    } catch (error) {
        console.error("发生错误:", error);
        return false; // 表示发生错误，检查未通过
    }
}
```

# 功能：初级子表单联动异步调动

```jsx
// 异步函数，用于获取数据并设置值
export async function fetchDataAndSetValue() {
  // 获取名为 "text_1" 的数据
  const inputData = await sdk.getValue("text_1");
  console.log("获取信息", inputData);

  // 从获取的数据中提取 dataId
  const dataId = inputData.value.dataId;
  console.log("确认dataID", dataId);

  // 使用 dataId 异步获取数据
  const asyncData = await fetchDataById(dataId);
  console.log("异步数据", asyncData);

  // 初始化数组用于存储子表单数据
  var dataArray = new Array();
  const subFormData = asyncData.data.data.data.subForm_1;

  // 获取子表单数据的长度
  const subFormDataLength = subFormData.length;

  // 将子表单数据添加到数组中
  for (var i = 0; i < subFormDataLength; i++) {
    dataArray.push(subFormData[i]);
  }
  console.log(dataArray);

  // 映射数据格式，准备设置的数据
  const mappedData = dataArray.map(item => {
    return {
      text_1: item.text_1,
      num_1: item.num_1,
      subID: 32131,
      editFlag: true,
    };
  });

  // 将映射后的数据设置为名为 "subForm_1" 的数据
  await sdk.setValue("subForm_1", mappedData);
}

// 异步函数，根据 dataId 获取表单数据
async function fetchDataById(dataId) {
  return await sdk.getFormDataById({
    appId: 744518,
    menuId: 9194218,
    saasMark: 2,
    businessType: 0,
    subBusinessType: 0,
    formId: 8438148,
    dataId,
  });
}
```

# <span data-type="text" style="text-shadow: 1px 1px var(--b3-theme-surface-lighter), 2px 2px var(--b3-theme-surface-lighter), 3px 3px var(--b3-theme-surface-lighter), 4px 4px var(--b3-theme-surface-lighter);">功能：中级子表单联动</span>

```javascript
//子表单同步数据
export async function processAndExportFormData() {
    //获取数据信息
    const sourceData = await sdk.getValue("text_1");
    console.log("Fetched information:", sourceData);
    //获取数据信息其中的dataId
    const dataId = sourceData.value.dataId;
    console.log("Confirmed dataID:", dataId);
    //通过异步数据fetchDataById获取其中的dataId
    const asyncData = await fetchDataById(dataId);
    console.log("Async data:", asyncData);
    //获取其中的的异步数据data.subForm_1
    const subFormDataArray = asyncData.data.data.data.subForm_1;
    //通过异步数据获取mapAndTransformSubFormData其中的subFormDataArray
    const transformedData = mapAndTransformSubFormData(subFormDataArray);

    console.log("Transformed data:", transformedData);
    //部署子表单数据
    await sdk.setValue("subForm_1", transformedData);
}

//异步数据
async function fetchDataById(dataId) {
    return await sdk.getFormDataById({
        appId: 744518,
        menuId: 9194218,
        saasMark: 2,
        businessType: 0,
        subBusinessType: 0,
        formId: 8438148,
        dataId
    });
}
//异步数据
function mapAndTransformSubFormData(subFormDataArray) {
    return subFormDataArray.map(item => ({
        text_1: item.text_1,
        num_1: item.num_1,
        subID: 32131,
        editFlag: true,
    }));
}
```

# <span data-type="text" style="text-shadow: 1px 1px var(--b3-theme-surface-lighter), 2px 2px var(--b3-theme-surface-lighter), 3px 3px var(--b3-theme-surface-lighter), 4px 4px var(--b3-theme-surface-lighter);">功能：校验表单是否有重复的值，前提是需要联动相关序号</span>

　　主要表单：签单前服务，前提条件，关联客户信息的流水号【静态值】，来查询签单前的服务是否已存在，如果存在就弹出提醒。

```javascript
// 定义一个延迟函数，用于实现异步延迟
async function delay(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
}

// 主函数，用于检查并提醒用户避免重复提交表单
export async function DDcheck() {
    // 获取当前的低代码平台类型（比如编辑模式或其他）
    const datetype = await sdk.getLowCodeType();
    console.log(datetype);

    // 如果是编辑模式，则不继续执行
    if (datetype.type === "edit") {
        console.log("编辑模式不继续执行。")
        return;
    }

    // 延迟3秒等待联动数据获取，避免因数据未同步而导致的错误
    await delay(3000);

    // 获取特定字段的值
    const a = await sdk.getValue("text_9");
    console.log("获取值1:", a);
    const b = a.value;
    console.log("获取值2:", b);

    // 使用dfc函数查询签单前表单是否已经联动相关客户流水号
    const c = await dfc(b);
    console.log("获取值3:", c);

    // 如果已存在联动的表单数据，则提醒用户不要重复创建表单
    if (c.data.paasFormDataESList.length && c.data.paasFormDataESList.length > 0) {
        await sdk.alert({
            title: '温馨提示',
            content: '你已创建过该表单，此表单将无法保存，请勿重复创建表单！',
            confirmButtonText: '确认'
        });
        //刷新表单
        await sdk.refreshPage()
        return false;
    }
}

// 查询指定数据【签单前数据】的表单是否已经存在，用于避免重复提交
async function dfc(data, page = 1) {
    // 通过sdk.getFormDataList方法查询表单数据
    return await sdk.getFormDataList({
        appId: 756754, // 应用ID
        menuId: 8330561, // 菜单ID
        saasMark: 2, // SaaS标识
        businessType: 0, // 业务类型
        subBusinessType: 0, // 子业务类型
        formId: 7539701, // 表单ID
        conditions: [{ "attr": "text_9", "fieldType": 1, "symbol": "equal", "value": [data] }], // 查询条件
        page: page, // 分页页码
        pageSize: 20 // 每页数量
    })
}
```

# <span data-type="text" style="text-shadow: 1px 1px var(--b3-theme-surface-lighter), 2px 2px var(--b3-theme-surface-lighter), 3px 3px var(--b3-theme-surface-lighter), 4px 4px var(--b3-theme-surface-lighter);">功能：详情页按钮判单</span>

```jsx
//详情页按钮单击判断时间
export async function checkCurrentTime({ val }) {
    console.log(val);

    if (val.btn.value == '新建开工报批') {
        // 获取当前日期
    const currentDate = new Date();
    console.log("当前日期:", currentDate);

    // 获取当前日期的日数
    const currentDay = currentDate.getDate();

    // 判断是否在1-3号或者16-17号范围内
    if ((currentDay >= 8 && currentDay <= 10) || (currentDay >= 23 && currentDay <= 25)) {
        console.log("当前日期在8-10号或者23-25号范围内");
    } else {
        await sdk.showToast({
        type: "error",
        content: '请在每月的8号至10号以及23号至25号内提交您的内容，其他时间系统将无法保存。',
        time: 3000
    });
    console.log("当前日期不在1-3号或者16-17号范围内");
    return false;  
        }
    }
}
```

## 功能：复选内容通过排序到另一个文本字段

```jsx
//复选框内容配置进行排序然后配置到另一个字段，作为指标
export async function getss() {
    const a = await sdk.getValue("array_1");
    let texts = ""; // 在这里声明texts变量，确保它在if语句外部也可以被访问
    // 假设a.value是需要排序的数组
    if (a && a.success && a.value && Array.isArray(a.value)) {
        // 对数组进行排序比较函数应当有两个参数（在你的例子中是item1和item2），并且返回一个用于确定元素间顺序的值。
        a.value.sort((item1, item2) => item1.text.localeCompare(item2.text));

        // 整合text属性并用逗号连接成一个字符串
        texts = a.value.map(item => item.text).join('、');
    }
    console.log(a);
    console.log(texts); // 现在texts变量在这里也可以被访问了
    await sdk.setValue("text_10",texts)
}

```

## **功能：成员单选人员实时同步新增或删除协同人，不影响后续新增**

```jsx
// 我们添加一个对象来记住每个函数最后一次添加的成员
const lastAdded = {};

export async function handleText(inputName, funcName) {
    try {
        const memberSelection = await sdk.getValue(inputName);
        const managerField = await sdk.getValue("coUserId");
        const userArray = Array.isArray(managerField.value) ? managerField.value : [];

        if (!memberSelection || !memberSelection.value) {
            // 从 userArray 中删除 funcName 最后一次添加的成员
            const lastAddedMember = lastAdded[funcName];
            if (lastAddedMember) {
                const index = userArray.findIndex(user => user.id === lastAddedMember.id);
                if (index !== -1) {
                    userArray.splice(index, 1);
                }
            }
        } else {
            const memberId = memberSelection.value.id;
            const memberName = memberSelection.value.name;
            const isUserExists = userArray.some(user => user.id === memberId);
            if (!isUserExists) {
                userArray.push({ id: memberId, name: memberName });
                // 记住 funcName 这次添加的成员
                lastAdded[funcName] = { id: memberId, name: memberName };
            }
        }

        await sdk.setValue("coUserId", userArray);
    } catch (error) {
        console.error("发生错误:", error);
    }
}

export async function ce1() {
    await handleText("text_40", 'ce1');
}

export async function ce2() {
    await handleText("text_67", 'ce2');
}

export async function ce3() {
    await handleText("text_69", 'ce3');
}

export async function ce4() {
    await handleText("text_48", 'ce4');
}
```

## 功能：通过判断选项值，清空指定字段。【关联成员单选删除】

```jsx
//通过判断选项空值或否，来清空指定字段
export async function getClearAll() {
    // 定义一个数组，每个元素都是一个包含 getText 和 setText 的对象
    const fields = [
        { getText: "text_51", setText: "text_67" },
        { getText: "text_52", setText: "text_69" },
        { getText: "text_70", setText: "text_48" }
    ];

    for (let { getText, setText } of fields) {
        const change = await sdk.getValue(getText);
        // 删除调试用 console.log(change);
        // 先检查 change.value 是否为 undefined
        if (change.value === undefined || change.value.text === "否") {
            await sdk.setValue(setText, undefined);
        }
    }
}

```

## 功能：子表单获取行数和对应行数字段,并且重新赋值

```jsx
//子表单获取行数和对应行数字段
export async function getForm() {
  //获取子表单字段值
  const idd = await sdk.getValue("subForm_1");
  //获取子表单行数
  const count = idd.value.length;
  //根据子表单行数遍历
  for (let row = 0; row < count; row++) {
  //获取子表单不同的字段
    const requests = [
      {
        formId: "subForm_1",
        row: row,
        fieldId: "text_1"
      },
      {
        formId: "subForm_1",
        row: row,
        fieldId: "text_2"
      },
      {
        formId: "subForm_1",
        row: row,
        fieldId: "date_1"
      },
      {
        formId: "subForm_1",
        row: row,
        fieldId: "date_2"
      }
    ];

    const responses = await Promise.all(
      requests.map(request => sdk.getSubformValue(request))
    );

    const values = responses.map(response => response.value);
    //不能使用双引号
    console.log(`获取第${row + 1}行:`, values[0]);
    console.log(`获取第${row + 1}行:`, values[1]);
    console.log(`获取第${row + 1}行:`, values[2]);
    console.log(`获取第${row + 1}行:`, values[3]);
  }
}
```

## 功能：通过JSON过滤数据，并通过信息弹出并且检验

```jsx
export async function getinfo() {
  const userinfo = await sdk.getUserInfo();
  console.log(userinfo);

  // 创建一个新对象，包含userinfo中除了corpid和xbbAccessToken以外的所有属性
  const filteredUserInfo = Object.entries(userinfo).reduce((acc, [key, value]) => {
    if (key !== "corpid" && key !== "xbbAccessToken") {
      acc[key] = value;
    }
    return acc;
  }, {});

  // 将过滤后的对象转换为JSON字符串
  const filteredUserInfoStr = JSON.stringify(filteredUserInfo, null, 2);

  await sdk.alert({
    title: 'alert标题',
    content: filteredUserInfoStr,
    confirmButtonText: '确认'
  });
}
```

## 功能：移动端配置权限认证数据

```jsx
//详情页按钮单击判断时间
export async function checkCurrentTime({ val }) {
    // 获取用户信息
    const user = await sdk.getUserInfo();
    //提取用户ID
    const userId = user.userId;
    const response = await sdk.api.request("/user/list", {
        userIdIn: [userId],
    });
    //获取角色权限
    const roleList = response.result.userList[0].roleList;
    //提取角色权限ID
    const roleIds = roleList.map((role) => role.id);
    console.log(roleIds); //结果为：[34237,1]数组
    //获取管理员权限
    const hasRoleroot = roleIds.includes(1);
    //获取临时修改权限
    const hasRolevip = roleIds.includes(34237);
    if (hasRoleroot || hasRolevip) {
        await sdk.alert({
            title: "欢迎您",
            content: "尊敬的VIP用户",
            confirmButtonText: "确认",
        });
        return;
    }
    // console.log(val);
    if (val.btn.value == "新建开工报批") {
        // 获取当前日期
        const currentDate = new Date();
        console.log("当前日期:", currentDate);
        // 获取当前日期的日数
        const currentDay = currentDate.getDate();
        // 判断是否在1-3号或者16-17号范围内
        if (
            (currentDay >= 1 && currentDay <= 15) ||
            (currentDay >= 15 && currentDay <= 25)
        ) {
            console.log("当前日期在1-10号或者15-25号范围内");
        } else {
            await sdk.showToast({
                type: "error",
                content:
                    "请在每月的1号至10号以及15号至25号内提交您的内容，其他时间系统将无法保存。感谢配合",
                time: 3000,
            });
            console.log("当前日期不在1-10号或者15-25号范围内");
            return false;
        }
    }
}

```

## 功能：通过按钮获取客户dataId让然后api修改表单

```jsx
// 通过按键获取客户dataId通过api编辑
// 定义一个异步函数 getd，接受参数 aa
export async function getd(aa) {
    // 打印传入的参数 aa，用于测试
    console.log("Input parameter:", aa);
    // 将选中的数据对象转换为要发送的数据列表
    const dataList = aa.val.xbb_selected_datas.map(data => ({
        // 提取每个数据对象的 dataId
        "dataId": data.dataId,
        // 定义要更新的数据字段，例如设置 text_10 为 "是"
        "dataList": {
            "text_10": "是"
        }
    }));
    // 打印转换后的数据列表，用于测试
    console.log("Data list:", dataList);
    // 使用 Promise.all 来并行发送每个编辑请求
    await Promise.all(dataList.map(async item => {
        // 打印每个编辑请求，用于测试
        console.log("Editing request:", item);
        // 使用 SDK 发送编辑请求到 "/paas/edit" 接口，并等待完成
        const result = await sdk.api.request("/paas/edit", item);
        // 打印编辑请求结果，用于测试
        console.log("Editing result:", result);
    }));
    // 测试完成，函数执行完毕
    console.log("Testing completed.");
}

```

## 功能：API自动增加到店次数

```jsx
//思路版本
export async function addcount(a){
    console.log(a)
    const b = a.val.originQuery.dataId
    console.log(b)
    const c = await sdk.getFormDataById({
    appId: 744517, 
    menuId: 8157216,
    saasMark: 1, 
    businessType: 100, 
    subBusinessType: 0, 
    formId: 7388263, 
    dataId: b
    })
    console.log(c)
    console.log(c.data.data.data.num_7)
    const d = c.data.data.data.num_7 
    const e = d + 1;
    console.log(e)
    const f = await sdk.api.request("/customer/edit", {
        "dataId": b,
        "dataList": {
            "num_7": e,
        }
    }) 
    console.log(f)
}

//美化版本，详情页增加次数，回单阶段增加，不需要考虑其他阶段未填写资料
//上线时间2024-04-06：23:57
export async function addcount(a) {
    try {
        // 提取 dataId
        const dataId = a?.val?.originQuery?.dataId;
        if (!dataId) {
            console.error("Data ID is missing or invalid.");
            return;
        }

        console.log("Data ID:", dataId);

        // 获取表单数据
        const formDataResponse = await sdk.getFormDataById({
            appId: 744517, 
            menuId: 8157216,
            saasMark: 1, 
            businessType: 100, 
            subBusinessType: 0, 
            formId: 7388263, 
            dataId: dataId
        });
    
    
        const formData = formDataResponse.data?.data?.data;

        console.log("Form Data:", formData);
        if(formData.text_4.text === "有效客户"){
            await sdk.alert({
                title: '温馨提示',
                content: '该客户状态为有效客户，请推进阶段至到店客户',
                confirmButtonText: '确认'
            });
            return false;
        }
        const CN = formData.text_1;
        const num7 = formData.num_7;

        console.log("Current Count:", num7);

        // 增加计数器值
        const updatedCount = num7 + 1;

        console.log("Updated Count:", updatedCount);

        // 不同的条件下更新 num_7
        if (updatedCount === 2) {
            const updateResponse = await sdk.api.request("/customer/edit", {
                "dataId": dataId,
                "dataList": {
                    "num_7": updatedCount,
                    "text_50": "二客",
                    "text_77": "二客"
                }
            });
            console.log("Update Result:", updateResponse);
        } else if (updatedCount > 2) {
            const updateResponse = await sdk.api.request("/customer/edit", {
                "dataId": dataId,
                "dataList": {
                    "num_7": updatedCount,
                    "text_50": "多客",
                    "text_77": "多客"
                }
            });
            console.log("Update Result:", updateResponse);
        }
            
        await sdk.alert({
            title: '客户姓名:'+ CN,
            content: '到店次数从'+num7+'次，增加到'+updatedCount+'次',
            confirmButtonText: '确认'
        });

    } catch (error) {
        console.error("An error occurred:", error);
    }
}

```

## 功能：通过联动创建相关数据

```jsx
//新建用户服务部表单
export async function homevist(a){
    console.log("1,获取表单初步信息:",a)
    const u = await sdk.getUserInfo()  
    console.log("2,获取当前用户信息:",u)
    const t = u.userId
    console.log("3,提取用户ID:",t)
    //获取主键dataId
    const b = a.val.originQuery.dataId
    console.log("4,提取当前表单dataId:",b)
    const c = await sdk.getFormDataById({
    appId: 744517, 
    menuId: 8157216,
    saasMark: 1, 
    businessType: 100, 
    subBusinessType: 0, 
    formId: 7388263, 
    dataId: b
    })
    console.log("5,获取表单详细信息:",c)
    const g = c.data.data.data.text_70
    console.log(g)
    if(g === undefined || g.text === "否" ){
        const o = await sdk.confirm({
        title: '温馨提示',
        content: '设计师未确认是否家访，是否强制继续',
        confirmButtonText: '确认',
        cancelButtonText: '取消',
        type: 'warning'
        });
        console.log(o)
        if(!o.confirm){
            return false;
        }
    }
    const i = await sdk.api.request("/customer/edit", {
        "dataId": b,
        "dataList": {
            "text_70": "是"
            }
        })
    console.log(i)

    //获取关键信息，客户+电话
    const f = c.data.data.data.text_76
    //通过API新建表单关联数据
    const e = await sdk.api.request("/paas/add", {
            "formId": 7527528,      //自定义表单
            "dataList": {
                "text_3": b,        //使用主键的dataId关联
                "text_13": f,       //客户+电话
                "text_16": "否",    //必填信息
                "text_8": "否",     //必填信息
            },
            "userId": t             //操作人未当前用户
        })
    console.log(e);
    const r = e.msg
    await sdk.alert({
    title: '温馨提示',
    content: r,
    confirmButtonText: '确认'
    });
}
```

## 功能：自动查找相关部门主管信息，并且赋值给指定字段

```jsx
//正常运行版本,不包含部门筛选
export async function info3(){
    const b = await sdk.getValue("text_4");
    // 获取当前用户ID
    console.log(b.value.id);

    const a = await sdk.api.request("/user/list", {
        "userIdIn": [b.value.id]
    });
    console.log(a);

    // 赋值当前用户的部门ID
    const d = a.result.userList[0].departmentList[1].id;
    console.log(d);

    // 通过当前用户的部门ID，查询部门人员信息
    const dd = await sdk.api.request("/user/list", {
        "departmentId": d
    });
    console.log(dd);

    // 遍历部门人员信息，找到 isLeader 等于 1 的用户并输出其 userId 和部门名称
    for (const user of dd.result.userList) {
        // 遍历用户所属部门列表
        for (const department of user.departmentList) {
            // 检查部门中的 isLeader 属性是否等于 1
            if (department.isLeader === 1) {
                console.log(`拥有 isLeader 等于 1 的用户的 userId 是：${user.userId}，所属部门名称是：${department.name}`);
                return; // 找到一个符合条件的用户后就结束函数执行
            }
        }
    }
}

//该代码不适合多部门的用户
export async function info(){
    const b = await sdk.getValue("text_4");
    // 获取当前用户ID
    console.log(b);
    // 获取用户完整信息
    const a = await sdk.api.request("/user/list", {
        "userIdIn": [b.value.id]
    });
    console.log(a);

    // 遍历部门列表，找到不等于1的部门id, 因为1是主架构生活
    let departmentId = null;
    for (const department of a.result.userList[0].departmentList) {
        if (department.id !== 1) {
            departmentId = department.id;
            break; // 找到一个不等于1的部门id后就退出循环
        }
    }

    // 如果找到了不等于1的部门id，则继续查询该部门的用户信息
    if (departmentId !== null) {
        console.log("找到不等于1的部门id:", departmentId);
    
        // 查询部门人员信息
        const dd = await sdk.api.request("/user/list", {
            "departmentId": departmentId
        });
        console.log(dd);

        // 遍历部门人员信息，找到 isLeader 等于 1 的用户并输出其 userId、姓名和部门名称
        for (const user of dd.result.userList) {
            // 遍历用户所属部门列表
            for (const department of user.departmentList) {
                // 检查部门中的 isLeader 属性是否等于 1
                if (department.isLeader === 1) {
                    console.log(`拥有 isLeader 等于 1 的用户的 userId 是：${user.userId}，姓名是：${user.name}，所属部门名称是：${department.name}`);
                
                    // 设置值为找到的用户ID和姓名，text_6是字段表示可修改
                    await sdk.setValue("text_6", {"id": user.userId, "name": user.name});
                
                    return; // 找到一个符合条件的用户后就结束函数执行
                }
            }
        }
    } else {
        console.log("未找到不等于1的部门id");
    }
}

```

## 功能：跨表判断客户阶段，并且锁定字段，补充内容。

```jsx
//功能：判断客户阶段，并且锁定字段，补充内容   ---start--- 
// 主功能函数，处理定金判断逻辑
export async function handleDepositCheck() {
    try {
        const { value: serialNumber } = await sdk.getValue("text_22");
        console.log("流水号：", serialNumber);

        const customerInfo = await fetchCustomerInfo(serialNumber);
        console.log("信息：", customerInfo);

        const decisionValue = customerInfo.data.paasFormDataESList[0].data.text_4.value;
        if (["4", "5"].includes(decisionValue)) {
            await showDepositAlert();
            await disableAndSetValue('text_40', '是', '0c051543-0043-2082-f104-e900523f1b40');
        }
    } catch (error) {
        console.error("处理过程中发生错误：", error);
    }
}

//显示定金提醒对话框
async function showDepositAlert() {
    await sdk.alert({
        title: '温馨提示',
        content: '定金&签单阶段的客户，请补充心得分享。',
        confirmButtonText: '确认'
    });
}

// 禁用字段并设置值
async function disableAndSetValue(fieldId, text, value) {
    await sdk.disableField(fieldId);
    await sdk.setValue(fieldId, { text, value });
}

// 获取客户信息
async function fetchCustomerInfo(info, page = 1) {
    // 定义与函数逻辑密切相关的常量
    const APP_ID = 744517;
    const MENU_ID = 8157216;
    const FORM_ID = 7388263;

    return await sdk.getFormDataList({
        appId: APP_ID,
        menuId: MENU_ID,
        saasMark: 1,
        businessType: 100,
        subBusinessType: 0,
        formId: FORM_ID,
        conditions: [{"attr":"text_59","fieldType":1,"symbol":"equal","value":[info]}],
        page: page,
        pageSize: 20
    });
}
//功能：判断客户阶段，并且锁定字段，补充内容   ---end--- 
```

# 功能：子表单认证手机号

```jsx
//第一种遍历方式：
export async function subfrom() {
    const data = await sdk.getValue('subForm_1');
    console.log(data) //测试用
    data.value.forEach((item, index) => {
        if (item.text_1.text === "手机号码") {
            const phoneString = item.text_2?.replace(/\\D/g, '') || ''; // 移除非数字字符并处理可能的 undefined

            const phoneRegex = /^1[3-9]\\d{9}$/;

            if (!phoneRegex.test(phoneString)) {
                console.error(`第 ${index + 1} 条记录的手机号格式不正确，请输入有效的手机号。`);
                alert(`第 ${index + 1} 条记录的手机号格式不正确，请输入有效的手机号。`);

                return;
            }

            // 其他逻辑代码，例如提交表单或其他处理
            console.log(`第 ${index + 1} 条记录的手机号格式正确，继续处理...`);
        }
    });
}

//第二种遍历方式：
export async function subfrom() {
    const data = await sdk.getValue('subForm_1');

    for (let i = 0; i < data.value.length; i++) {
        const item = data.value[i];
        if(item.text_2 === ""){
            return;
        }
        if (item.text_1.text === "手机号码") {
            const phoneString = item.text_2?.replace(/\\D/g, '') || ''; // 移除非数字字符并处理可能的 undefined

            const phoneRegex = /^1[3-9]\\d{9}$/;

            if (!phoneRegex.test(phoneString)) {
                console.error(`第 ${i + 1} 条记录的手机号格式不正确，请输入有效的手机号。`);
                alert(`第 ${i + 1} 条记录的手机号格式不正确，请输入有效的手机号。`);

                // 将该行的手机号码字段设置为空值
                await sdk.setSubformValue({
                    formId: 'subForm_1',
                    row: i,
                    fieldId: 'text_2',
                    value: ''
                });

                // 跳出循环，避免重复提示
                break;
            }

            // 其他逻辑代码，例如提交表单或其他处理
            console.log(`第 ${i + 1} 条记录的手机号格式正确，继续处理...`);
        }
    }
}

//增加防抖功能避免手机输入手机号验证过快
let timeoutId;

export async function subfrom() {
  clearTimeout(timeoutId); // 清除之前的定时器

  timeoutId = setTimeout(async () => {
    const data = await sdk.getValue("subForm_1");

    for (let i = 0; i < data.value.length; i++) {
      const item = data.value[i];
      if (item.text_2 === "") {
        return;
      }

      if (item.text_1.text === "手机号码") {
        const phoneString = item.text_2?.replace(/\\D/g, "") || ""; // 移除非数字字符并处理可能的 undefined

        const phoneRegex = /^1[3-9]\\d{9}$/;

        if (!phoneRegex.test(phoneString)) {
          console.error(
            `第 ${i + 1} 条记录的手机号格式不正确，请输入有效的手机号。`
          );
          alert(`第 ${i + 1} 条记录的手机号格式不正确，请输入有效的手机号。`);

          // 将该行的手机号码字段设置为空值
          await sdk.setSubformValue({
            formId: "subForm_1",
            row: i,
            fieldId: "text_2",
            value: "",
          });

          // 跳出循环，避免重复提示
          break;
        }

        // 其他逻辑代码，例如提交表单或其他处理
        console.log(`第 ${i + 1} 条记录的手机号格式正确，继续处理...`);
      }
    }
  }, 1500); // 延迟 500 毫秒
}

```

# 功能：销售机会修改客户名称，提交表单后出发。可保存。

```bash

export async function changID(){
    //获取本表单dataID主键
    const res = await sdk.getDataId()
    const dataId = res.value
    //查看销售机会详情
    const resId = await sdk.api.request("/opportunity/detail", {
      "dataId": dataId
    })
    //获取客户名称的数据关联
    const a = await sdk.getValue("text_3")
    //获取订货单位关联ID数据关联
    const d = await sdk.getValue("text_24")
    //编辑销售机会
    await sdk.api.request("/opportunity/edit", {
        //本表单dataID
        "dataId": dataId,
        //修改客户信息
        "dataList": {
        //关联用户字段，只需要用户dataId
            "text_3": d.value.data.dataId
        }
    })
    console.log("值变动即触发，不需要保存")
    // await sdk.refreshPage()
    await sdk.setValue('text_24', undefined);
    await sdk.setValue('text_22', { text: '是', value: '02be1223-518a-5b00-cb3a-9f94e3bd2cd8' })
}
```

# 作用：将登录人员信息赋值到协同人

```jsx
export async function setcoUserId(){
    //获取登录人员信息
    const bb = await sdk.getValue("text_20");
    //提取人员id
    const id = bb.value.id;
    //提取人员name
    const name = bb.value.name;
    //获取协同人值
    const ccc = await sdk.getValue("coUserId");
    //使用let赋值变量
    let user = ccc.value;
    // 检查user是否是undefined，并初始化为一个空数组
    if (!user) {
        user = [];
    }
    //通过push()，推送上下文数据
    user.push({id:id,name:name});
    await sdk.setValue("coUserId", user);
}
```

　　**通过输入面积信息，调整下拉选项数据**

```jsx
export async function calculateArea() {
  const area = await sdk.getValue('num_5');
  const areaValue = area.value;
  console.log(areaValue);
  
  let textValue, uuidValue;

  const conditions = [
    { min: 0, max: 100, text: '100以下', uuid: 'fd8cbbc8-d0c2-da8a-72ac-e448a693defc' },
    { min: 100, max: 130, text: '100-130', uuid: '7c609441-42ea-dc9f-2819-c488c03f4355' },
    { min: 131, max: 150, text: '131-150', uuid: 'eb44fdab-a900-5a46-bde7-ed62781986a7' },
    { min: 151, max: 199, text: '151-199', uuid: '7885e382-2fec-836b-a1e5-21b193a74d36' },
    { min: 200, max: 250, text: '200-250', uuid: '6c7dc56e-7220-1b5c-95aa-9f28924eeb64' },
    { min: 250, max: 1000, text: '250以上', uuid: '362b2c84-c29a-d49a-b2ae-0c70ee99332b' },
    //
  ];

  for (const condition of conditions) {
    if (areaValue >= condition.min && areaValue <= condition.max) {
      console.log(`面积在${condition.min}-${condition.max}之间`);
      textValue = condition.text;
      uuidValue = condition.uuid;
      break;
    }
  }

  if (!textValue) {
    textValue = '231以上';
  }

  await sdk.setValue('text_33', { text: textValue, value: uuidValue });
}
```

　　**获取客户阶段信息**

```jsx
export async function getinfo() {
    const test = await sdk.getValue("text_18");
    console.log(test);

    const testvalue = test.value
    console.log(testvalue);

    const testvaluetext = test.value.text;
    console.log(testvaluetext);

    console.log("asdf");
    const text2 = await sdk.getValue("text_4");
   // const bbb = text2.value
    console.log(text2);
}
```

　　**获取客户状态信息**

```jsx
export async function getstatinfo(){
    const info = await sdk.getValue("text_4")
    console.log("客户状态",info)
}
```

　　**判断首日和交定修改阶段推进**

```jsx
//联合判断
export async function changeStage() {
    const firstVisitDateResponse = await sdk.getValue("date_5");
    const depositDateResponse = await sdk.getValue("date_1");

    const firstVisitDate = firstVisitDateResponse.value;
    const depositDate = depositDateResponse.value;

    console.log("First Visit Date: ", firstVisitDate);
    console.log("Deposit Date: ", depositDate);

    let stageObject = null;

    // 检查 firstVisitDate 是否有值
    if (firstVisitDate !== undefined && firstVisitDate !== "") {
        // 如果 firstVisitDate 有值，但 depositDate 没有值
        if (!depositDate || depositDate === undefined || depositDate === "" || depositDate === null) {
            console.log("Setting stage to 到店客户");
            stageObject = {
                allowSkipStage: 0,
                color: "#646566",
                enable: 1,
                fieldMap: [],
                isOther: 0,
                stageId: 2656214,
                stageProcessId: 516616,
                stageRatio: 0,
                stageType: 0,
                text: "到店客户",
                value: "2"
            };
        }
        // 如果 firstVisitDate 和 depositDate 都有值
        else {
            console.log("Setting stage to 定金客户");
            stageObject = {
                allowSkipStage: 1,
                color: "#646566",
                enable: 1,
                isOther: 0,
                stageId: 2656216,
                stageProcessId: 516616,
                stageRatio: 0,
                stageType: 0,
                text: "定金客户",
                value: "4"
            };
        }
    } else {
        console.log("firstVisitDate is not set, no stage change triggered.");
    }

    if (stageObject !== null) {
        const result = await sdk.setValue("text_18", stageObject);
        console.log("Setting stage result:", result);
    }
}
```

　　**通过日期判断修改客户阶段**

```jsx
//首次到店日期触发阶段更换
export async function hdpz() {
  const data_hd = {
    color: "#FFC849",
    text: "回单客户",
    value: "10"
  };

  try {
    const hdpz = await sdk.setValue("text_4", data_hd);
    console.log("成功设置值：", hdpz);
  } catch (error) {
    console.error("设置值失败:", error);
  }
}

//交定日期触发阶段更换
export async function djpz() {
  const data_dj = {
    color: "#FF8C2E",
    text: "定金客户",
    value: "5"
  };

  try {
    const djpz = await sdk.setValue("text_4", data_dj);
    console.log("成功设置值：", djpz);
  } catch (error) {
    console.error("设置值失败:", error);
  }
}
```

　　**校验数据是否满足提交前提**

```jsx
xport async function KH(){
    // 通过sdk.getValue获取信息
    // 字段可以被隐藏
    const 是否家访 = await sdk.getValue("text_10");
  
    // 使用console.log打印获取的结果
    console.log("是否成交的值：", 是否家访);
  
    // 赋值信息到N
    const N = 是否家访.value;
  
    // 使用console.log打印赋值后的N
    console.log("赋值后的N：", N);
  
    // 判断信息是否符合
    if(N != "是"){
        // 使用console.log打印不符合的提示
        console.log("不满足创建服务的要求");
    
        // 弹出提示
        await sdk.showToast({
            type: "warning",
            content: "客户信息未确认家访，请确定后创建"
        });
    
        // 拒绝数据提交
        return false;
    }
}
```

　　**通过日期判单解锁字段编辑功能，并且赋值下拉选项**

```jsx
export async function eld1 () {
  const res = await sdk.enableField('date_5');
  console.log(res)
}

export async function pinshen1(){
    const 获取预约时间 = await sdk.getValue("date_4");
    if(获取预约时间 !== null || 获取预约时间 !== undefined)
        {
            await sdk.setValue('text_21', { text: '应评审总数'})  
        } 
}

export async function eld2 () {
  const res = await sdk.disableField('date_4');
  console.log(res)
}

export async function pinshen2(){
    const 获取实际时间 = await sdk.getValue("date_5");
    if(获取实际时间 !== null || 获取实际时间 !== undefined)
        {
            await sdk.setValue('text_21', { text: '实际评审数'})  
        } 
}
```

　　判断值是否为是，解锁按钮，【表单展示是如果为是，也解锁按钮】

```jsx
//预勘测不为是，则锁定是否提报
export async function checkdata() {
    //判断是否预勘测
    const bo = await sdk.getValue("text_12");
    console.log(bo)
    if (!bo || !bo.value || bo.value.text !== "是") {
        //锁定提报按键，并且将单项选择设定否
        const bbb = await sdk.setValue('text_15', { text: '否',value: "63e6f6b3-c7a7-03d7-729c-f0da4e13f0e3"})
        console.log(bbb)
        await sdk.disableField("text_15")
    }
    else {
        //解锁提报按键
        await sdk.enableField("text_15")
    }
}
```

　　开工时间范围规定，包含数据执行条件

```jsx
//验证日期填写规范
export async function KHD() {
    // 获取项目经理
    const xmjl = await sdk.getValue("text_18");

    // 检查项目经理是否为空或未定义
    if (!xmjl || xmjl.value === null || xmjl.value === undefined) {
        // 如果项目经理为空或未定义，继续执行下面的代码
    } else {
        return; // 如果项目经理不为空，不执行下面的代码
    }

    // 获取用户选择的日期
    const dd = await sdk.getValue("date_2");

    // 检查用户是否已选择日期
    if (!dd || !dd.value) {
        console.log("错误：您还没有选择日期");
        // 在这里可以添加更多逻辑，如显示错误提示给用户
        return;
    }

    const selectedDate = new Date(dd.value * 1000);

    // 获取当前日期
    const currentDate = new Date();
    console.log("选定日期:", selectedDate);
    console.log("当前日期:", currentDate);

    // 获取当前月份和年份
    const currentMonth = currentDate.getMonth();
    const currentYear = currentDate.getFullYear();

    // 定义范围的起始日期和结束日期
    let rangeStartDate, rangeEndDate;

    if (currentDate.getDate() >= 1 && currentDate.getDate() <= 15) {
        // 当月的1号到15号，用户只能选择当月的16号及之后的日期
        rangeStartDate = new Date(currentYear, currentMonth, 16);
        rangeEndDate = new Date(currentYear, currentMonth, 31);
        console.log("在当前月的1号到15号范围内，只能选择当月的16号及之后的日期");
    } else {
        // 当月的16号之后，用户只能选择下个月的1号到15号的日期
        const nextMonth = (currentMonth + 1) % 12;
        const nextYear = (currentMonth === 11) ? currentYear + 1 : currentYear;
        rangeStartDate = new Date(nextYear, nextMonth, 1);
        rangeEndDate = new Date(nextYear, nextMonth, 15);
        console.log("在当前月的16号之后，只能选择下个月的1号到15号的日期");
    }

    // 检查用户选择的日期是否在允许的范围内
    if (selectedDate >= rangeStartDate && selectedDate <= rangeEndDate) {
        console.log("选定日期在范围内");
        // 在这里可以添加范围内日期的逻辑
    } else {
        console.log("错误：选定日期不在范围内");
        await sdk.showToast({
        type: "warning",
        content: "预排期时间不在规定范围内，将无法提交！",
        time: 3000
        });
        return false
        // 在这里可以添加不在范围内日期的逻辑
    }
}
```

　　验证数据是否可以继续执行

```jsx
export async function KH(){
    // 通过sdk.getValue获取信息
    // 字段可以被隐藏
    const 签单后服务开启 = await sdk.getValue("text_36");
  
    // 使用console.log打印获取的结果
    console.log("获取的是否签单后服务开启的值：", 签单后服务开启);
  
    // 赋值信息到N
    const N = 签单后服务开启.value;
  
    // 使用console.log打印赋值后的N
    console.log("赋值后的N：", N);
  
    // 判断信息是否符合
    if(N != "是"){
        // 使用console.log打印不符合的提示
        console.log("不满足开工报批的要求");
    
        // 弹出提示
        await sdk.showToast({
            type: "warning",
            content: "不满足开工的要求，请确认合同订单！"
        });
    
        // 拒绝数据提交
        return false;
    }
}
```

　　功能：通过判断数据，提交过程中，配置弹出窗口按钮赋值数据。

　　主要作用：做一个全局代码，来判断是否脚本是否执行，如果执行则跳过

```jsx
//--------分割线--------
//提交前判单代码
let tijiaoExecuted = false; // 添加标志，表示是否已经执行过 tijiao

export async function infomsg() {
  try {
    //获取提报按键的值
    const text15Value = (await sdk.getValue("text_15")).value;
    console.log(text15Value);
    //获取项目经理的值
    const xmjlValue = (await sdk.getValue("text_18")).value;
    console.log(xmjlValue);
    //是否提报的值等于是 并且 项目经理的值等于undefined
    // if (text15Value === "是" && xmjlValue === undefined) {
    // await sdk.setValue('text_15', { text: '否', value: "63e6f6b3-c7a7-03d7-729c-f0da4e13f0e3" });
    // console.log("text_15 的强制设置值为 '否'并且跳过执行。");
    if(xmjlValue === undefined){
    const res = await sdk.alert({
        title: '温馨提示',
        content: '交付部正在安排项目经理',
        confirmButtonText: '确认'
        });

        if(res.confirm){
            console.log("暂停表单提交点击后继续");
            return;
        }else{
            console.log("取消阻塞");
            return false;
        }

    }else{
        console.log("继续执行下面指令")
    }

// 继续执行下面的代码
// ...

    // 获取登录用户信息
    const userInfo = await sdk.getUserInfo();
    console.log(userInfo.roleIds);

    // 检查是否包含30727，如果包含则直接跳过后续操作
    // 不能使用includes 备注未修改
    if (userInfo.roleIds.includes("30727")) {
      console.log("用户包含角色30727，跳过执行。");
      return;
    }
    //如果不包含30727并且项目经理不等于空值，则继续执行下面操作
    const [a, b, c, d] = await Promise.all([
      sdk.getValue("date_2"),
      sdk.getValue("text_12"),
      sdk.getValue("text_18"),
      sdk.getValue("text_11")
    ]);
    //判断审核是否通过，如果为是，直接跳过后续指令
    if(d.value.text === "是"){
        console.log("审核通过，跳过执行")
        return;
    }

    if (a.value !== null && b.value.text === '是' && c.value.text !== null) {
      tijiaoExecuted = true;  // 直接表示已经触发
      const result = await sdk.confirm({
        title: '温馨提示',
        content: '是否通知核算部，开始审批【纸质资料】。',
        confirmButtonText: '确认',
        cancelButtonText: '取消',
        type: 'warning'
      });

      const value = result.confirm
        ? { text: '是', value: "1e230627-e839-8320-11c7-101d2686c9e2" }
        : { text: '否', value: "63e6f6b3-c7a7-03d7-729c-f0da4e13f0e3" };

      await sdk.setValue('text_15', value);

      // 在这里处理确认后的逻辑，主要起阻塞的作用。
      if (result.confirm) {
        // 处理确认后的逻辑
        console.log("点击了确认按钮");

        // 继续执行其他代码
        console.log("继续执行其他代码");
      } else {
        // 处理取消后的逻辑
        console.log("点击了取消按钮");
      }
    } else {
      console.log("条件满足。");
      return "条件满足。";
    }
  } catch (error) {
    // 处理错误
    console.error("发生错误:", error);
  }
}
```

　　功能：根据情况配置字段

　　主要作用：优化条件来配置字段

```jsx
//当项目经理变成空的时候，是否提交变成否
export async function xmjl1(){
    const assd =await sdk.getValue("text_11")

    const ass = await sdk.getValue("text_18")

    if(assd.value.text === "否"){

        if(ass.value === undefined){

        await sdk.setValue('text_15', { text: '否', value: "63e6f6b3-c7a7-03d7-729c-f0da4e13f0e3" });

        }
    }
}
```

　　通过查询数据，来提示是否有重复的表单。

```jsx
//延迟触发函数创建
async function delay(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
}

export async function chongcheck(){
    try{//延迟触发，避免查询信息错误。
    const datatype = await sdk.getLowCodeType();
    if(datatype.type === "edit"){
        console.log("编辑模式不继续执行。")
        return;
    }
    await delay(3000);
    //直接获取客户流水号值
    const a = (await sdk.getValue("text_10")).value;
    const b = await cc(a);
    console.log(b)
    if(b.data.paasFormDataESList && b.data.paasFormDataESList.length > 0){
        await sdk.alert({
        title: '温馨提示',
        content: '您已创建过客户信息，请勿重新创建！',
        confirmButtonText: '确认'
        });
    return false;
    }else{
        console.log("正常触发")
        }
    }
    catch{
        console.log("发生错误。")
    }
  
}

async function cc(dateid,page = 1) {
  return await sdk.getFormDataList({
    appId: 758244, 
    menuId: 8313500,
    saasMark: 2, 
    businessType: 0, 
    subBusinessType: 0, 
    formId: 7524824, 
    conditions: [{"attr":"text_10","fieldType":1,"symbol":"equal","value":[dateid]}], 
    page: page, 
    pageSize: 20
  })
}
```