---
notion-id: c7e8da97-0115-4e07-9a66-d5192cef6219
---
成员单选推送到协同人
```javascript
export async function updateUserArray(){
    // 通过唯一标识符获取客户信息
    const customerData = await sdk.getValue("text_20");
    console.log(customerData); 

    // 从customerData中提取id和name
    const { id, name } = customerData.value;

    // 获取coUserId的值
    const coUserData = await sdk.getValue("coUserId");
    
    // 若coUserData.value为undefined, 初始化为空数组
    let userArray = coUserData.value || [];

    // 将新的用户数据推送到userArray
    userArray.push({id, name});

    // 更新coUserId的值
    await sdk.setValue("coUserId", userArray);
}
```
情况二：直接使用成员信息覆盖coUserId
```javascript
export async function updateUserArray(){
    // 通过唯一标识符获取客户信息
    const customerData = await sdk.getValue("text_3");
    console.log(customerData); 

    // 从customerData中提取id和name
    const { id, name } = customerData.value;

    // 创建一个包含新用户数据的数组
    const userArray = [{id, name}];

    // 更新coUserId的值
    await sdk.setValue("coUserId", userArray);
}
```
情况三：可以不断叠加，对比已有的数据不会出现重复添加coUserId。
```javascript
export async function updateUserArray() {
    // 通过唯一标识符获取客户信息
    const customerData = await sdk.getValue("text_3");
    console.log(customerData);

    // 从customerData中提取id和name
    const { id, name } = customerData.value;

    // 获取coUserId的值
    const coUserData = await sdk.getValue("coUserId");

    // 若coUserData.value为undefined, 初始化为空数组
    let userArray = coUserData.value || [];

    // 检查userArray是否已经包含了具有相同id的用户数据
    const isUserExists = userArray.some(user => user.id === id);

    // 如果userArray中没有具有相同id的用户数据，则将新的用户数据添加到userArray
    if (!isUserExists) {
        userArray.push({ id, name });
    }

    // 更新coUserId的值
    await sdk.setValue("coUserId", userArray);
}
```
情况四：可以不断叠加，对比已有的数据不会出现重复添加coUserId【多字段补充】
```javascript
export async function handleText(inputName) {
    try {
        // 获取售前人员字段内容
        const memberSelection = await sdk.getValue(inputName);
        console.log(memberSelection);
        // 获取传参需要的参数，成员类字段只要为id和name；
        const memberId = memberSelection.value.id;
        const memberName = memberSelection.value.name;
        // 获取负责人字段内容
        const managerField = await sdk.getValue("coUserId");
        // 如果负责人字段不存在或不是一个数组，初始化为一个空数组
        const userArray = Array.isArray(managerField.value) ? managerField.value : [];
        // 检查userArray是否已经包含了具有相同id的用户数据
        const isUserExists = userArray.some(user => user.id === memberId);
        // 如果userArray中没有具有相同id的用户数据，则将新的用户数据添加到userArray
        if (!isUserExists) {
            userArray.push({ id: memberId, name: memberName });
        }
        // 对负责人字段赋值
        await sdk.setValue("coUserId", userArray);
    } catch (error) {
        console.error("发生错误:", error);
    }
}

// 调用 handleText 函数，分别处理不同的输入
export async function ce1() {
    await handleText("text_40");
}
export async function ce2() {
    await handleText("text_67");
}
export async function ce3() {
    await handleText("text_69");
}
```

---
```javascript

export async function KH() {
    let dealStatus;
    try {
        dealStatus = await sdk.getValue("text_14");
    } catch (error) {
        console.error("Error getting value:", error);
        // Handle error as needed
        return false;
    }
    console.log("是否成交的值：", dealStatus);

    if(dealStatus.value !== "是") {
        // 如果showWarningToast函数存在，则调用它
        if (typeof showWarningToast === "function") {
            await showWarningToast("不满足合同创建的要求，请确认是否完成签单前服务！");
        }
        return false;
    }
}
```
验证表单优化版本1
```javascript
//验证表单，可以配置不可见
//配置表单提交前
export async function KH() {
    // 通过sdk.getValue获取信息
    const 判断红线 = await sdk.getValue("date_2");
    
    // 赋值信息到N
    const N = 判断红线?.value;  // 使用了可选链，确保如果判断红线为undefined时，N也为undefined
    
    // 判断信息是否符合
    if (N === null || N === undefined) {
        // 弹出提示
        await sdk.showToast({
            type: "warning",
            content: "不满足有签单前设计服务的要求，请先创建签单前设计服务表单！"
        });
        
        // 拒绝数据提交
        return false;
    }
}
```
验证表单优化版本2
```javascript
export async function KH(){
    try {
        console.log("开始获取date_1的值...");
        
        // 通过sdk.getValue获取信息
        const dateValueResponse = await sdk.getValue("date_1");
        console.log("date_1的值:", dateValueResponse);

        // 赋值信息到dateValue
        const dateValue = dateValueResponse.value;
        console.log("赋值后的dateValue:", dateValue);

        // 判断信息是否符合
        if(dateValue === null){
            console.log("dateValue为null，显示警告...");
            
            // 弹出提示
            await sdk.showToast({
                type: "warning",
                content: "不满足有签单前设计服务的要求，请先创建签单前设计服务表单！"
            });
            
            // 拒绝数据提交
            console.log("数据验证失败，拒绝提交。");
            return false;
        }

        console.log("数据验证成功，允许提交。");
        // 允许数据提交
        return true;
    } catch (error) {
        console.error("验证过程中出现错误:", error);
        return false;
    }
}
```
验证添加函数判断，避免函数没有执行的时候正常提交
```javascript
export async function KH(){
    // 通过sdk.getValue获取信息
    // 字段可以被隐藏
    const 签单后服务开启 = await sdk.getValue("text_7");
    
    // 使用console.log打印获取的结果
    console.log("获取的是否签单后服务开启的值：", 签单后服务开启);
    
    // 赋值信息到N
    const N = 签单后服务开启.value;
    
    // 使用console.log打印赋值后的N
    console.log("赋值后的N：", N);
    
    // 判断信息是否符合
    if(N != "是"){
        // 使用console.log打印不符合的提示
        console.log("不满足有签单后设计服务的要求");
        
        try {
            // 弹出提示
            await sdk.showToast({
                type: "warning",
                content: "不满足创建签单后设计服务的要求，请先创建合同订单！",
                time: 3000
            });
        } catch (error) {
            // 如果出现错误，可以在这里处理
            console.error("Error showing toast:", error);
        }
        
        // 无论是否出现错误，都拒绝数据提交
        return false;
    }
}
```

---

```javascript
//弹窗类型一
export async function alert1() {
  const res = await sdk.alert({
    title: '警告',
    content: '请确保签单前数据已填写',
    confirmButtonText: '确认'
  });
  console.log(res)
}

//弹窗类型二
export async function ShowToast1() {
  const res = await sdk.showToast({
    type: '警告',
    content: '请确保签单前数据已填写',
    time: 3000
  })
  console.log(res)
}
```

---

```javascript
//下拉跨表单 相互编辑 注意：不需要配置关联和联动
//abcc函数名称
export async function abcc(){
//部署到联动的数据 例如客户姓名 值发生变动的时候
    const bb = await sdk.getValue("text_1")
//dataid取值问题导致错误
    const dataid = bb.value.dataId;
    
    const id = await abc(dataid)
//     const cc = id.data.data.headList[77].attrName
    console.log(id)
      const cc = id.data.paasFormDataESList[0].data.text_63.text
    if(cc=="设计阶段"){
    await sdk.setValue("text_7", {text: "设计阶段", value: "b9d9d780-30fb-9b9a-e893-c7e582ed9028"});
    }  
    else if (cc=="生产阶段"){
    await sdk.setValue("text_7", {text: "生产阶段", value:  "ef3065e0-5ec6-7b0b-707e-bfe6ef44f42c"});
    }  
    else if(cc=="安装阶段"){
    await sdk.setValue("text_7", {text: "安装阶段", value:  "15fba2f6-fe76-a932-3c5a-e201381e2ecc"});
    }
    else if(cc=="完成阶段"){
    await sdk.setValue("text_7", {text: "完成阶段", value:  "7f915670-7200-41bf-90b0-80839d198b41"});
    }
}


//abcd赋值
async function abc(abcd,page = 1) {
  return await sdk.getFormDataList({
    appId: 744517, 
    menuId: 8157216,
    saasMark: 1, 
    businessType: 100, 
    subBusinessType: 0, 
    formId: 7388263, 
    conditions: [{"attr":"dataId","fieldType":0,"symbol":"equal","value":[abcd]}], 
    page: page, 
    pageSize: 20
  })
}
```

---

```javascript
//代码辅助生成器 API调用
export async function abddd() {
  try {
	//
    const response = await sdk.api.request("/department/list", {});
    // 在这里处理返回的响应
    console.log("部门列表：", response);
  } catch (error) {
    // 处理错误
    console.error("请求部门列表时出错：", error);
  }
}
```

---
```javascript
//通过下拉选项，重新选定单选按钮
export async function sschange() {
  const val = await sdk.getValue('text_2')
  if (val.value.value === "adcf0f49-5591-9d2d-cbf8-7f7b08fb3dc6"){
      await sdk.setValue('text_10', { text: '1次', value: 'f4723a5e-6b1e-841e-580b-4860e1fb9f07' })
  } else if (val.value.value === "3de1f74a-116a-fb30-00f3-4adc13566689"){
      await sdk.setValue('text_10', { text: '2次', value: '70893f00-fea5-2804-b35b-6750a071a976' })
  }
}
```

---
```javascript
//读取数据
export async function sschange() {
    const val = await sdk.getValue('text_4');
    
    if (val && val.value) {
        const valcc = val.value.value;
        console.log(valcc);
    } else {
        console.log('Value is not available.');
    }
}


//锁定数据
export async function sschangesdd() {
    const val = await sdk.getValue('text_4');
    
  if (val.value.value === "8f46eabc-245e-49dc-94cc-98218f3e3f03"){
    await sdk.disableField("text_5");    
 }
}
```

---
```javascript
//调取部门名称
export async function ddd() {
  try {
    const result = await sdk.api.request("/department/list", {});
    console.log(result);
    return result;
  } catch (error) {
    console.error("Error fetching department list:", error);
    throw error;
  }
}
```
```javascript
//调取用户信息
export async function ddd() {
  try {
    const result = await sdk.api.request("/user/list", {
    "page": 1,
    "pageSize": 100,
    });
    console.log(result);
    return result;
  } catch (error) {
    console.error("Error fetching department list:", error);
    throw error;
  }
}
```
如果是表单展开时，正在读取数据，所以触发会获取值有问题，需要延时
```javascript
export async function KH() {
    // 延时2秒
    await new Promise(resolve => setTimeout(resolve, 2000));
    
    // 通过sdk.getValue获取信息
    const 是否成交 = await sdk.getValue("text_4");
    
    // 使用console.log打印获取的结果
    console.log("是否成交的值：", 是否成交);
    
    // 赋值信息到N
    const N = 是否成交.value;
    
    // 使用console.log打印赋值后的N
    console.log("赋值后的N：", N);
}
```
读取其他表单阶段推进信息，判断非签单，阻止提交，并弹窗；
```shell
export async function updateFormBasedOnDataId() {
    try {
        //表单提交前触发，获取客户信息
        const textData = await sdk.getValue("text_2");
        if (!textData || !textData.value) {
            console.error("Failed to get text data");
            return;
        }
				//获取用户ID，要不然会信息错误
        const dataid = textData.value[0].id;
				console.log(dataid);
        const formData = await fetchFormDataById(dataid);
				console.log(formData );
        if (!formData || !formData.data || !formData.data.paasFormDataESList || formData.data.paasFormDataESList.length === 0) {
            console.error("Invalid form data response");
            return;
        }

        const targetValue = formData.data.paasFormDataESList[0].data.text_18.text;
        console.log(targetValue);

        if(targetValue !== "签单") {
            await showConfirm("请将客户阶段推进至签单阶段，否则无法创建合同");
            return false;
        }

    } catch (error) {
        console.error("Error in updateFormBasedOnDataId:", error);
    }
}

async function fetchFormDataById(dataId, page = 1) {
    return await sdk.getFormDataList({
        appId: 744517,
        menuId: 8157216,
        saasMark: 1,
        businessType: 100,
        subBusinessType: 0,
        formId: 7388263,
        conditions: [{
            "attr": "dataId",
            "fieldType": 0,
            "symbol": "equal",
            "value": [dataId]
        }],
        page: page,
        pageSize: 20
    });
}

async function showConfirm(message) {
    const res = await sdk.confirm({
        title: '警告',
        content: message,
        confirmButtonText: '确认',
        cancelButtonText: '取消',
        type: 'warning'
    });
    console.log(res);
    return res.confirm;  // true: 用户点击了确认按钮, false: 用户点击了关闭按钮
}
```
客户信息判断数字范围，并归类到下拉选项，做好数据分类【版本1】
```javascript
//获取面积数据
export async function audd() {
  const mianji = await sdk.getValue('num_5');
  const mianjishuju = mianji.value;
  console.log(mianjishuju);
  
  let textValue, uuidValue;

  if (mianjishuju >= 0 && mianjishuju <= 100) {
    console.log("面积小于100");
    textValue = '100以下';
    uuidValue = 'fd8cbbc8-d0c2-da8a-72ac-e448a693defc';
  } else if (mianjishuju >= 100 && mianjishuju <= 130) {
    console.log("面积在100-130之间");
    textValue = '100-130';
    uuidValue = '7c609441-42ea-dc9f-2819-c488c03f4355';
  } else if (mianjishuju >= 131 && mianjishuju <= 151) {
    console.log("面积在131-151之间");
    textValue = '131-151';
    uuidValue = 'eb44fdab-a900-5a46-bde7-ed62781986a7';
  } else if (mianjishuju >= 152 && mianjishuju <= 160) {
    console.log("面积在152-160之间");
    textValue = '152-160';
    uuidValue = '7885e382-2fec-836b-a1e5-21b193a74d36';
  } else if (mianjishuju >= 161 && mianjishuju <= 199) {
    console.log("面积在161-199之间");
    textValue = '161-199';
    uuidValue = '6c7dc56e-7220-1b5c-95aa-9f28924eeb64';
  } else if (mianjishuju >= 200 && mianjishuju <= 230) {
    console.log("面积在200-230之间");
    textValue = '200-230';
    uuidValue = '2c254ae5-535a-ac70-c3da-ab8989a5b518';
  } else {
    console.log("面积在231以上");
    textValue = '231以上';
    uuidValue = '362b2c84-c29a-d49a-b2ae-0c70ee99332b';
  }

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

```
客户信息判断数字范围，并归类到下拉选项，做好数据分类【版本2】
```javascript
export async function auddchange() {
  const mianji = await sdk.getValue('num_5');
  const mianjishuju = mianji.value;
  console.log(mianjishuju);
  
  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: 151, text: '131-151', uuid: 'eb44fdab-a900-5a46-bde7-ed62781986a7' },
    { min: 152, max: 160, text: '152-160', uuid: '7885e382-2fec-836b-a1e5-21b193a74d36' },
    { min: 161, max: 199, text: '161-199', uuid: '6c7dc56e-7220-1b5c-95aa-9f28924eeb64' },
    { min: 200, max: 230, text: '200-230', uuid: '2c254ae5-535a-ac70-c3da-ab8989a5b518' },
  ];

  // 使用循环查找满足条件的范围
  for (const condition of conditions) {
    if (mianjishuju >= condition.min && mianjishuju <= condition.max) {
      console.log(`面积在${condition.min}-${condition.max}之间`);
      textValue = condition.text;
      uuidValue = condition.uuid;
      break; // 找到匹配条件后退出循环
    }
  }

  // 如果没有匹配的条件，默认处理
  if (!textValue) {
    console.log("面积在231以上");
    textValue = '231以上';
    uuidValue = '362b2c84-c29a-d49a-b2ae-0c70ee99332b';
  }

  await sdk.setValue('text_33', { text: textValue, value: uuidValue });
}
```
获取阶段，通过判断禁用字段
```javascript
export async function stageedit() {
    // 通过sdk.getValue获取信息
    const 获取阶段 = await sdk.getValue("text_18");

    // 从获取阶段的值中获取text属性的值
    const textValue = 获取阶段.value.text;

    console.log(textValue);  // 打印出 "有效客户信息"

    if(textValue === "有效客户信息") {
        // 定义要禁用的字段列表
        const fieldsToDisable = [
            'date_5', 'text_74', 'text_73', 
            'array_8', 'array_9', 'text_6', 
            'text_35', 'num_7'
        ];

        // 遍历字段并禁用它们
        for (let field of fieldsToDisable) {
            await sdk.disableField(field);
        }
    }
}
```
获取阶段推进器信息
```javascript
//获取阶段信息
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);
}
```
字段变动触发阶段
```javascript
//修改阶段信息修改首次到店日期，便触发阶段到到店客户
export async function change1() {
    // Retrieve the value of the field "text_45" using sdk.getValue
    const stageValue = await sdk.getValue("date_5");

    // Check if stageValue is not empty or undefined
    if (stageValue !== undefined && stageValue !== "") {
        // Create the complete stage object
        const stageObject = {
            allowSkipStage: 0,
            color: "#646566",
            enable: 1,
            fieldMap: [],
            isOther: 0,
            stageId: 2656214,
            stageProcessId: 516616,
            stageRatio: 0,
            stageType: 0,
            text: "到店客户",
            value: "2"
        };

        // Set the value for the field "text_18"
        await sdk.setValue("text_18", stageObject);
    }
}

//修改阶段信息修改交定日期，便触发阶段到定金客户
export async function change2() {
    // Retrieve the value of the field "text_45" using sdk.getValue
    const stageValue = await sdk.getValue("date_1");

    // Check if stageValue is not empty or undefined
    if (stageValue !== undefined && stageValue !== "") {
        // Create the complete stage object with new values
        const stageObject = {
            "allowSkipStage": 1,
            "color": "#646566",
            "enable": 1,
            "isOther": 0,
            "stageId": 2656216,
            "stageProcessId": 516616,
            "stageRatio": 0,
            "stageType": 0,
            "text": "定金客户",
            "value": "4"
        };

        // Set the value for the field "text_18"
        await sdk.setValue("text_18", stageObject);
    }
}
```
字段变动触发阶段【优化版本】
```javascript
//通过getvalue 获取数据
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);
    }
}
```

```javascript
export async function updateUserArray() {
    // 通过唯一标识符获取客户信息
    const uniqueIdentifiers = [
        "text_46", "text_47", "text_48", "text_49", "text_50", "text_51", "text_52", "text_53"
    ];
    const stageMappings = {
        "text_46": "水电阶段",
        "text_47": "木作阶段",
        "text_48": "泥作阶段",
        "text_49": "瓷粉阶段",
        "text_50": "竣工阶段",
        "text_51": "精装前期",
        "text_52": "精装中期",
        "text_53": "精装竣工"
    };

    for (const identifier of uniqueIdentifiers) {
        const customerData = await sdk.getValue(identifier);
        const cust = customerData.value.text;
        
        if (cust === "是" && stageMappings[identifier]) {
            await sdk.setValue("text_29", stageMappings[identifier]);
        }
        
        console.log(cust);
    }
}
```
客户状态【系统更换】
```javascript
//首次到店日期触发阶段更换
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);
  }
}
```

跨表查询版
```javascript
export async function updataid(){
    const textData = await sdk.getValue("text_1");
    console.log(textData)
    const dataid = textData.value.dataId;
    console.log(dataid)
    const formData = await fetchIda(dataid);
	  //初选获取的数据
    console.log(formData)
    const targetValue = formData.data.paasFormDataESList[0].data.array_1;
    console.log(targetValue);
    

}

//通过代码辅助生成器，跨表单数据调用生产
//注意abc参数是跨表查询字符串
async function fetchIda(abc,page = 1) {
  return await sdk.getFormDataList({
    appId: 744518, 
    menuId: 8432210,
    saasMark: 2, 
    businessType: 0, 
    subBusinessType: 0, 
    formId: 7628449, 
    conditions: [{"attr":"dataId","fieldType":0,"symbol":"equal","value":[abc]}], 
    page: page, 
    pageSize: 20
  })
}


```
下拉复选同步
```javascript
export async function updataid() {
    const textData = await sdk.getValue("text_2");
    console.log("获取关联字段",textData);
//获取关联id
    const dataid = textData.value[0].id;
    console.log("获取联动ID",dataid);
//通过异步查询关联id信息
    const formData = await fetchIda(dataid);
    console.log("获取关联查询数据集",formData);
//获取异步查询数据array_7
    const targetValue = formData.data.paasFormDataESList[0].data.array_7;
    console.log("获取关联字段",targetValue);

//将获取数据通过map赋值给textValues
	const textValues = targetValue.map((item) => ({ text: item.text, value: item.value }));

//将textValues赋值给array_7
	await sdk.setValue("array_7", textValues);
	

}

//异步查询数据
async function fetchIda(abcd,page = 1) {
  return await sdk.getFormDataList({
    appId: 744517, 
    menuId: 8157216,
    saasMark: 1, 
    businessType: 100, 
    subBusinessType: 0, 
    formId: 7388263, 
    conditions: [{"attr":"dataId","fieldType":0,"symbol":"equal","value":[abcd]}], 
    page: page, 
    pageSize: 20
  })
}
```

日期判断
```javascript
export async function KHD() {
    // 获取用户选择的日期
    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("错误：选定日期不在范围内");
        // 在这里可以添加不在范围内日期的逻辑
    }
}
```

```javascript
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
        // 在这里可以添加不在范围内日期的逻辑
    }
}
```

通过按钮判断数据
```javascript
//通过按键信息获取表单值
export async function checkbt(bt){
    console.log("获取信息:",bt);
    if(bt.val.btn.value == "新建签单前设计服务"){
        console.log("已选择新建签单前设计服务");
        const id = bt.val.originQuery.dataId;
        console.log("dataId值:",id);
        const checkdd = fetchfromdataid(id);
        console.log("异表查询:",checkdd);
    }
    else{
        console.log("没有选择新建签单前设计服务");
    }
}

async function fetchfromdataid(dataID,page = 1) {
  return await sdk.getFormDataList({
    appId: 744517, 
    menuId: 8157216,
    saasMark: 1, 
    businessType: 100, 
    subBusinessType: 0, 
    formId: 7388263, 
    conditions: [{"attr":"dataId","fieldType":0,"symbol":"equal","value":[dataID]}], 
    page: page, 
    pageSize: 20
  })
}
```