---
notion-id: 3ebd1793-eb97-4408-bf1e-9648ecc5c803
---
## 功能：通过触发条件获取相关信息
```javascript
//可以是任何触发按键，包含提交前后。
export async function afterFormSubmit(data) {
  console.log(data)
}

//获取指定字段
export async function afterFormSubmit(datate) {
  const dd = datate.text_1
  console.log(dd)
}
```
## 功能：获取多个成员单选信息，在提交前，将成员推送到协同人，如果推送值和创建人相等，则跳过不推送，如果修改成员单选则直接更换协同人不`累积添加`并且不产生`重复推送`。
主要作用：所有表单
```javascript
// 一个对象，用来存储每个函数最后一次添加的成员信息
const lastAdded = {};

export async function updateUserInfo(identifier) {
    console.log(`Updating user info for identifier: ${identifier}`);

    try {
        // 通过唯一标识符获取客户信息
        const customerData = await sdk.getValue(identifier);
        console.log("Customer Data:", customerData);

        // 获取创建人的信息
        const ownID = await sdk.getValue("ownerId");
        console.log("Own ID Data:", ownID);

        // 如果customerData为undefined或者其value属性不存在，输出日志并直接返回
        if (!customerData || !customerData.value) {
            console.log(`Customer data is undefined for identifier: ${identifier}`);
            return;
        }

        //从ownID中提取id和name，创建人是数组
        const { id: ownId, name: ownName } = ownID.value[0];
        console.log("Own ID and Name:", ownId, ownName);

        // 从customerData中提取id和name
        const { id: customerDataId, name: customerDataName } = customerData.value;
        console.log("Customer Data ID and Name:", customerDataId, customerDataName);

        // 判断ownID和customerData的id和name是否相同，如果相同则不执行下面的代码
        if (ownId === customerDataId && ownName === customerDataName) {
            console.log("ID 和姓名相同，跳过后续代码。");
        } else {
            // 下面的代码将在id和name不相同时执行
            // 获取coUserId的值
            const coUserData = await sdk.getValue("coUserId");
            console.log("Co-User Data:", coUserData);

            // 若coUserData.value为undefined，初始化为空数组
            let userArray = coUserData.value || [];
            console.log("User Array Before Update:", userArray);

            // 删除之前添加的成员
            const lastAddedMember = lastAdded[identifier];
            if (lastAddedMember) {
                const index = userArray.findIndex(user => user.id === lastAddedMember.id);
                if (index !== -1) {
                    userArray.splice(index, 1);
                }
            }

            // 将新的用户数据推送到userArray
            const isNewUser = userArray.some(user => user.id === customerDataId);

            if (!isNewUser) {
                userArray.push({ id: customerDataId, name: customerDataName });
                console.log("User Array After Push:", userArray);

                // 更新coUserId的值
                await sdk.setValue("coUserId", userArray);

                // 记住最后一次添加的成员
                lastAdded[identifier] = { id: customerDataId, name: customerDataName };

                console.log(`用户信息已更新，标识符为: ${identifier}`);
            } else {
                console.log(`用户已存在于coUserId中，标识符为: ${identifier}`);
            }
        }
    } catch (error) {
        console.error("发生错误:", error);
    }
}

export async function updateUse() {
    // 增加主案设计师成为协同人
    await updateUserInfo("text_21");
    // 删除同步定制设计师变成协同人
    await updateUserInfo("text_2");
}
```
## 功能：拒绝列表快捷编辑
主要作用：开工报批，客户信息
```javascript
//触发条件列表编辑按钮
export async function RejectQuickEdit(a){
    console.log(a)
    await sdk.showToast({
        type: "error",
        content: "不允许通过快捷列表编辑数据",
        time: 3000
    });
	return false;
}
```
## 功能：获取两个时间的计算结果，设定某个下拉框的值
主要作用：【无】
```javascript
//获取两个时间的计算结果，设定某个下拉框的值
export async function checktime(){
    const dd = await sdk.getValue("num_1");
    console.log(dd)
    let text = "";
    let value = "";
    
    if(dd.value >=  0){
        text = "提前完成";
        value = "a49baec9-8f9c-8b0f-a2a2-6fea5a280248";
    }
    else{
        text = "超时完成";
        value = "fe91ab54-50cb-8cfb-8e26-58166b3403ea";
    }

    try {
        await sdk.setValue("text_14", {text, value});
    } catch (error) {
        // 处理错误
    }
}
```
## 功能：获取角色权限信息/获取数据集ID
主要作用：【无】
```javascript
//获取角色权限，需要split来分割，并且filter过滤
export async function getinfo(){
  const userinfo = await sdk.getUserInfo();
  console.log(userinfo)
  const roleIdsArray = userinfo.roleIds.split('|').filter(id => id !== ''); // 将角色ID字符串转换为数组
  console.log(roleIdsArray);
  if(roleIdsArray.some(id => id === "1" || id === "34237")){
      console.log("尊敬的VIP用户")
    }
}


//自定义按钮-获取数据dataId
export async function ad() {
  const res = await sdk.getDataId()
  console.log(res)
}
```
## 功能：输入不同的时间来，更新指定的时间段
主要作用：监察部，将所有时间字段更新至指定时间字段，只要其中一个更新，都会将最新的时间字段同步到指定字段。
```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;
}
```
## 功能：辅助完成签单前成交填写
主要作用：签单前服务，提交表单的时候获取成交字段，如果不等于是，则弹出提示框，辅助判断是否成交，如果确认“是”，则继续提醒完成下个阶段的填写，并且可以继续操作。如果确认为“否”则，弹出提示。
```javascript
//辅助完成签单前成交填写
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; // 表示发生错误，检查未通过
    }
}
```
## 功能：初级子表单联动
主要作用：【无】
```javascript
// 异步函数，用于获取数据并设置值
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,
  });
}
```
## 功能：中级子表单联动
主要作用：【无】
```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,
    }));
}
```
## 功能：校验表单是否有重复的值，前提是需要联动相关序号
主要表单：签单前服务，前提条件，关联客户信息的流水号【静态值】，来查询签单前的服务是否已存在，如果存在就弹出提醒。
```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 // 每页数量
    })
}
```
## 功能：详情页按钮判单
```javascript
//详情页按钮单击判断时间
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;      
        }
    }
}
```
## 功能：复选内容通过排序到另一个文本字段
```javascript
//复选框内容配置进行排序然后配置到另一个字段，作为指标
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)
}

```
## **功能：成员单选人员实时同步新增或删除协同人，不影响后续新增**
```javascript
// 我们添加一个对象来记住每个函数最后一次添加的成员
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');
}
```
## 功能：通过判断选项值，清空指定字段。【关联成员单选删除】
```javascript
//通过判断选项空值或否，来清空指定字段
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);
        }
    }
}

```
## 功能：子表单获取行数和对应行数字段,并且重新赋值
```javascript
//子表单获取行数和对应行数字段
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过滤数据，并通过信息弹出并且检验
```javascript
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: '确认'
  });
}
```
## 功能：移动端配置权限认证数据
```javascript
//详情页按钮单击判断时间
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修改表单
```javascript
// 通过按键获取客户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自动增加到店次数
```javascript
//思路版本
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);
    }
}

```
## 功能：通过联动创建相关数据
```javascript
//新建用户服务部表单
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: '确认'
    });
}
```
## 功能：自动查找相关部门主管信息，并且赋值给指定字段
```javascript
//正常运行版本,不包含部门筛选
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");
    }
}

```
## 功能：跨表判断客户阶段，并且锁定字段，补充内容。
```javascript
//功能：判断客户阶段，并且锁定字段，补充内容   ---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--- 
```
# 功能：子表单认证手机号
```javascript
//第一种遍历方式：
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 毫秒
}

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

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' })
}
```
# 功能：通过fetch获取信息，然后注入Alert
```bash
export async function examplAlert() {
    try {
        // 先 fetch 拿数据
        const res = await fetch('https://jsonplaceholder.typicode.com/posts/1');
        if (!res.ok) throw new Error(`HTTP 错误: ${res.status}`);
        const data = await res.json();

        // 调用 sdk.alert，把 data.body 放到 content
        const alertRes = await sdk.alert({
            title: 'alert标题',
            content: data.body, // 这里用 API 返回的 body
            confirmButtonText: '确认'
        });

        console.log('alert 返回值:', alertRes);
    } catch (err) {
        console.error('请求或弹窗失败:', err);
    }
}
```
# 功能：子表单只存在一行，删除其他行数据
```javascript
//同表单内所有子表单所有子表单
export async function clearAllExtraSubformRows() {
  const subForms = ['subForm_1', 'subForm_2', 'subForm_3'];
  
  for (const formId of subForms) {
    await clearExtraSubformRows(formId);
  }
}

async function clearExtraSubformRows(formId) {
  const data = await sdk.getValue(formId);
  console.log(`${formId}当前行数:`, data.value.length);
  
  if (data.value.length >= 2) {
    for (let i = data.value.length - 1; i > 0; i--) {
      const res = await sdk.deleteSubFormRow({
        formId: formId,
        index: i
      });
      console.log(`${formId}删除第${i}行:`, res);
    }
    console.log(`${formId}删除完成，仅保留第0行`);
  } else {
    console.log(`${formId}行数不足2行，无需删除`);
  }
}

//一个子表单
export async function clearExtraSubformRows() {
  const data = await sdk.getValue('subForm_1');
  console.log('当前行数:', data.value.length);
  
  if (data.value.length >= 2) {
    // 从最后一行开始删除，避免索引变化问题
    for (let i = data.value.length - 1; i > 0; i--) {
      const res = await sdk.deleteSubFormRow({
        formId: 'subForm_1',
        index: i
      });
      console.log(`删除第${i}行:`, res);
    }
    console.log('删除完成，仅保留第0行');
  } else {
    console.log('行数不足2行，无需删除');
  }
}

```
# 功能：自动添加部门名称以及创建更新日期
```javascript
/**
 * 尊敬的用户，你好：页面 JS 面板是高阶用法，一般不建议非开发者使用。
 * 如遇到问题，请联系销帮帮的技术支持获得服务。
*/
export async function datainfo() {
    const res = await sdk.getSubformValue({
        formId: 'subForm_1', 
        row: 0, 
        fieldId: 'date_1',
    })
  console.log(res)
}

//注意增加下拉数据
const departmentValues = {
    澜光设计工作室: "4a617452-f443-8bb3-238c-4643f8891395",
    蘭堂设计工作室: "ecd4f722-84b8-4a2d-4953-55d89979759f",
    麓居设计工作室: "8af2df7b-73ff-2146-6e41-219cca4faf2f",
    熹言设计工作室: "f9c0b565-272c-7375-33a1-6cf0489e21a6",
    光宸筑境工作室: "0c0e788c-d212-730a-69f1-a73f18882463"
};

export async function designuserinfo() {
    try {
        console.log("优化代码版V2.2");

        const data = await sdk.getValue('subForm_1');
        //data.value.length初始值为1
        //data_row初始值为0
        const data_row = data.value.length - 1;

        // 获取选中成员用户ID
        const userResponse = await sdk.getValue("subForm_1.text_2");
        //userResponse.value默认初始值是0
        if (!userResponse || !userResponse.value || !userResponse.value[data_row]?.id) {
            console.error("Failed to retrieve user data.");
            await sdk.setValue("subForm_1.text_1", '');
            return;
        }
        //userResponse.value默认初始值是0
        const userId = userResponse.value[data_row].id;
        console.log(`User ID: ${userId}`);

        // 获取用户完整信息
        const userListResponse = await sdk.api.request("/user/list", {
            userIdIn: [userId]
        });
        //领导值默认等于0
        const userInfo = userListResponse?.result?.userList?.[0];
        if (!userInfo) {
            console.error("User list is empty or undefined.");
            return;
        }

        const departmentList = userInfo.departmentList;
        const validDepartment = departmentList.find(d => d.id !== 1);

        if (!validDepartment) {
            console.log("未找到不等于1的部门id");
            return;
        }

        // 查询部门人员信息（找负责人）
        const departmentUserListResponse = await sdk.api.request("/user/list", {
            departmentId: validDepartment.id
        });

        const leader = departmentUserListResponse?.result?.userList?.find(user =>
            user.departmentList.some(d =>
                d.isLeader === 1 && d.id === validDepartment.id
            )
        );

        if (!leader) {
            console.log("No leader found in the department.");
            return;
        }

        console.log(`Leader found: ${leader.userId}, ${leader.name}, ${validDepartment.name}`);

        // === 关键合并逻辑开始 ===

        const departmentValue = departmentValues[validDepartment.name];
        if (!departmentValue) {
            console.error("No corresponding department value found.");
            return;
        }

        // 当天日期 YYYY-MM-DD
       // 当天 00:00:00 的秒级时间戳
        const today = new Date()
        today.setHours(0, 0, 0, 0)
        const todayTimestamp = Math.floor(today.getTime() / 1000)

        await Promise.all([
            sdk.setSubformValue({
                formId: 'subForm_1',
                row: data_row,
                fieldId: 'text_1',
                value: departmentValue
            }),
            sdk.setSubformValue({
                formId: 'subForm_1',
                row: data_row,
                fieldId: 'date_1',
                value: todayTimestamp
            })
        ]);

        console.log("子表单部门 & 日期写入成功");

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

```