obsidian/子兰工作/子兰-CRM/子兰表单低代码-工作流/通用低代码.md

---

notion-id: 3ebd1793-eb97-4408-bf1e-9648ecc5c8

功能：通过触发条件获取相关信息

//可以是任何触发按键，包含提交前后。
export async function afterFormSubmit(data) {
  console.log(data)
}

//获取指定字段
export async function afterFormSubmit(datate) {
  const dd = datate.text_1
  console.log(dd)
}

功能：获取多个成员单选信息，在提交前，将成员推送到协同人，如果推送值和创建人相等，则跳过不推送，如果修改成员单选则直接更换协同人不累积添加并且不产生重复推送。

主要作用：所有表单

// 一个对象，用来存储每个函数最后一次添加的成员信息
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");
}

功能：拒绝列表快捷编辑

主要作用：开工报批，客户信息

//触发条件列表编辑按钮
export async function RejectQuickEdit(a){
    console.log(a)
    await sdk.showToast({
        type: "error",
        content: "不允许通过快捷列表编辑数据",
        time: 3000
    });
	return false;
}

功能：获取两个时间的计算结果，设定某个下拉框的值

主要作用：【无】

//获取两个时间的计算结果，设定某个下拉框的值
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

主要作用：【无】

//获取角色权限，需要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)
}

功能：输入不同的时间来，更新指定的时间段

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

// 初始化存储上一个值的对象，将所有字段初始化为 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;
}

功能：辅助完成签单前成交填写

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

//辅助完成签单前成交填写
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 "条件不满足。";
    }
}

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

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

// 使用 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; // 表示发生错误，检查未通过
    }
}

功能：初级子表单联动

主要作用：【无】

// 异步函数，用于获取数据并设置值
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,
  });
}

功能：中级子表单联动

主要作用：【无】

//子表单同步数据
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,
    }));
}

功能：校验表单是否有重复的值，前提是需要联动相关序号

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

// 定义一个延迟函数，用于实现异步延迟
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 // 每页数量
    })
}

功能：详情页按钮判单

//详情页按钮单击判断时间
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;      
        }
    }
}

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

//复选框内容配置进行排序然后配置到另一个字段，作为指标
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)
}

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

// 我们添加一个对象来记住每个函数最后一次添加的成员
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');
}

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

//通过判断选项空值或否，来清空指定字段
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);
        }
    }
}

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

//子表单获取行数和对应行数字段
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过滤数据，并通过信息弹出并且检验

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: '确认'
  });
}

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

//详情页按钮单击判断时间
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修改表单

// 通过按键获取客户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自动增加到店次数

//思路版本
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);
    }
}

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

//新建用户服务部表单
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: '确认'
    });
}

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

//正常运行版本,不包含部门筛选
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");
    }
}

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

//功能：判断客户阶段，并且锁定字段，补充内容   ---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--- 

功能：子表单认证手机号

//第一种遍历方式：
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 毫秒
}

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

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

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);
    }
}

功能：子表单只存在一行，删除其他行数据

//同表单内所有子表单所有子表单
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行，无需删除');
  }
}

功能：自动添加部门名称以及创建更新日期

/**
 * 尊敬的用户，你好：页面 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);
    }
}