@yjli/wedaopenapi 1.0.0

package/auth.js

@@ -0,0 +1,65 @@
+const fetch = require('node-fetch');
+
+class Auth {
+  constructor(options) {
+    this.options = Object.assign(
+      {
+        // 主机地址
+        host: 'https://weda.web.scut.edu.cn',
+
+        // 访问令牌密钥
+        secretId: undefined,
+        secretKey: undefined,
+
+        debug: false,
+      },
+      options
+    );
+
+    if (!this.options.secretId || !this.options.secretKey) {
+      throw new Error('secretId 或 secretKey 未设置');
+    }
+  }
+
+  /**
+   * 获取访问令牌
+   */
+  async getAccessToken() {
+    // 如果缓存中存在（未过期），则直接返回缓存中的值
+    if (this.token && this.tokenExpiredAt > Date.now()) {
+      return this.token;
+    }
+
+    // 否则，获取 token，并存入缓存
+    const tokenResponse = await fetch(
+      `${this.options.host}/auth/v1/token/clientCredential`,
+      {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Basic ${Buffer.from(
+            `${this.options.secretId}:${this.options.secretKey}`
+          ).toString('base64')}`,
+        },
+        body: JSON.stringify({
+          grant_type: 'client_credentials',
+        }),
+      }
+    );
+
+    const json = await tokenResponse.json();
+
+    if (this.options.debug) {
+      console.log('Access Token Response', json);
+    }
+
+    const { access_token, expires_in } = json;
+
+    // 缓存 token，并设置过期时间，提前 1 分钟过期扩大容错。
+    this.token = access_token;
+    this.tokenExpiredAt = Date.now() + expires_in * 1000 - 60000;
+
+    return access_token;
+  }
+}
+module.exports = Auth;

package/index.js

@@ -0,0 +1,4 @@
+module.exports = {
+    WedaOpenApi: require("./wedaopenapi"),
+    Workflow: require("./workflow")
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@yjli/wedaopenapi",
+  "version": "1.0.0",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://ncgit.scut.edu.cn/dev/lowcode/wedaopenapi.git"
+  },
+  "keywords": [
+    "weda",
+    "openapi"
+  ],
+  "author": "yjli",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "node-fetch": "^2.7.0"
+  },
+  "devDependencies": {
+    "dotenv": "^17.4.0"
+  }
+}

package/test.js

@@ -0,0 +1,20 @@
+require('dotenv').config({ path: require('path').resolve(__dirname, '.env.test') });
+
+const { WedaOpenApi } = require('./index');
+
+(async () => {
+  try {
+    const api = new WedaOpenApi({
+      host: process.env.WEDA_HOST,
+      envId: process.env.WEDA_ENV_ID,
+      secretId: process.env.WEDA_SECRET_ID,
+      secretKey: process.env.WEDA_SECRET_KEY,
+    });
+
+    const res = await api.describeUserList(1, 10);
+    console.log('describeUserList result:', res);
+  } catch (error) {
+    console.error('Failed to initialize WedaOpenApi:', error);
+    process.exitCode = 1;
+  }
+})();

package/wedaopenapi.js

@@ -0,0 +1,836 @@
+/**
+ * 微搭 open api （服务端接口）
+ * const WedaOpenApi = require("./wedaopenapi");
+ * const wedaapi = new WedaOpenApi({host: "hhh", envId: "iii", secretId: "xxx", secretKey: "xxx"});
+ *
+ */
+const fetch = require('node-fetch');
+const Auth = require('./auth');
+
+class WedaOpenApi {
+  constructor(options = {}) {
+    this.wedaPath = this.wedaPath.bind(this);
+    this.auth = this.auth.bind(this);
+
+    this.options = Object.assign(
+      {
+        // 主机地址
+        host: 'https://weda.web.scut.edu.cn',
+
+        // 环境信息
+        envId: 'lowcode-7gwjk8v14d46dda1',
+        envType: 'prod',
+
+        // 访问令牌密钥
+        secretId: undefined,
+        secretKey: undefined,
+
+        debug: false,
+      },
+      options,
+    );
+
+    this.oauth = new Auth(this.options);
+
+    return;
+  }
+
+  /**
+   * 请求指定微搭路径
+   * @param {String} path 路径
+   * @param {String} httpMethod http 方法，用到：GET|PUT|POST|PATCH|DELETE
+   * @param {String} queryString 查询字符串
+   * @param {Object} bodyObject 请求体
+   * @returns
+   */
+  async wedaPath(path, httpMethod, queryString, body) {
+    const timeLabel = 'weda-api-' + Date.now() + Math.random();
+
+    const token = await this.oauth.getAccessToken();
+    let request = {
+      method: httpMethod,
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${token}`,
+        'X-Request-Id': timeLabel,
+      },
+    };
+
+    let url = this.options.host + path;
+
+    if (queryString && queryString.trim().length > 0) {
+      url = url.concat('?').concat(queryString.trim());
+    }
+
+    if (body) {
+      request.body = JSON.stringify(body);
+    }
+
+    if (this.options.debug) {
+      console.time(timeLabel);
+      console.log(new Date().toLocaleString(), 'Request URL', url);
+      console.log(request);
+    }
+
+    const response = await fetch(url, request);
+
+    if (this.options.debug) {
+      console.log('Response Status:', response.status);
+      console.timeEnd(timeLabel);
+    }
+
+    if (response.status >= 400) {
+      console.error(`Response url: ${response.url}`);
+      console.error(`Response status: ${response.status}`);
+      console.error(`Response statusText: ${response.statusText}`);
+    }
+
+    return response;
+  }
+
+  //-------------------------------------------------------------------------------//
+  //                          以下是 auth 接口
+  //-------------------------------------------------------------------------------//
+
+  /**
+   * auth 接口
+   * @see https://docs.cloudbase.net/lowcode/manage/auth
+   * @param {String} methodName 接口方法名
+   * @param {String} version 版本
+   * @param {String} httpMethod HTTP 请求方法名
+   * @param {String} queryString queryString
+   * @param {Object} body 请求 body
+   * @returns
+   */
+  async auth(methodName, version, httpMethod, queryString, body) {
+    return await (
+      await this.wedaPath(
+        `/weda/auth/${version}/${this.options.envType}/${methodName}`,
+        httpMethod,
+        queryString,
+        body,
+      )
+    ).json();
+  }
+
+  /**
+   * 增加用户
+   * @param {Object} user 用户对象，example: {Name: "john", NickName: "John Smith", Uuid: "john"}
+   * @returns {Object}
+   */
+  async addUser(user) {
+    return await this.auth('addUser', 'v1.1', 'POST', undefined, user);
+  }
+
+  /**
+   * 删除用户
+   * @param {Array} userIdArray 用户id数组，example: ["17023423432497238478", "17034832794329988"]
+   * @returns {Object}
+   */
+  async deleteUser(userIdArray) {
+    return await this.auth('deleteUser', 'v1.1', 'POST', undefined, {
+      UserIdList: userIdArray,
+    });
+  }
+
+  /**
+   * 更新用户信息
+   * @param {Object} user 用户对象，example: {UserId: "id", Name: "john", NickName: "John Smith", Uuid: "john"}
+   * 注意：MainOrg 和 Orgs 参数，不传或传 null 时，都会清空。其他参数不传表示不修改。
+   * @returns {Object} {Response: {Error: {Code, Message}, Data: boolean}}
+   */
+  async updateUserInfoByUserId(user) {
+    return await this.auth(
+      'updateUserInfoByUserId',
+      'v1.1',
+      'POST',
+      undefined,
+      user,
+    );
+  }
+
+  /**
+   * 查询用户详细信息
+   * @param {String} id 用户id
+   * @param {Boolean} fetchRoles 是否获取角色
+   * @param {Boolean} fetchIdentities  是否获取 IdP Token 信息
+   * @returns {Object} {Response: {Data: {Name, NickName, UserId, RelatedRoles: {Id,...}, MainOrg: {OrgId,...}, ...}}}
+   */
+  async describeWedaUser(id, fetchRoles = false, fetchIdentities = false) {
+    const body = { UserId: id };
+    if (fetchRoles) {
+      body.RelatedType = 'UserRelatedRole';
+    }
+    if (fetchIdentities) {
+      body.WithIdentities = true;
+    }
+    return await this.auth('describeWedaUser', 'v1.1', 'POST', undefined, body);
+  }
+
+  /**
+   * 分页查询所有用户
+   * @param {Number} pageNumber 页码，从第1页开始，默认是1
+   * @param {Number} pageSize 每页记录数，默认100
+   * @returns {Object}
+   */
+  async describeUserList(pageNumber = 1, pageSize = 100) {
+    const body = {
+      PageNo: pageNumber < 1 ? 1 : pageNumber,
+      PageSize: pageSize < 0 ? 100 : pageSize,
+    };
+    return await this.auth('describeUserList', 'v1.1', 'POST', undefined, body);
+  }
+
+  /**
+   * 批量增加新用户
+   * 注意：此接口目前混合云不支持
+   * @param {Array} users 用户对象数组，数量不能超过100. eg: {users: [{"name": "", nickName: "", uuid: "", roleIds: ["1", "2"], mainOrg: {"orgId": "id"}}]}
+   * @returns {Object}
+   */
+  async batchAddUsers(users) {
+    return await this.auth('batchAddUsers', 'v1', 'POST', undefined, {
+      users: users,
+    });
+  }
+
+  /**
+   * 新建组织机构
+   * @param {Object} org 组织机构对象，{*departmentCode，*departmentName, departmentParentCode, info}
+   * @returns {Object}
+   */
+  async addOrg(org) {
+    const body = {
+      OrgData: JSON.stringify(org),
+    };
+    return await this.auth('addOrg', 'v1', 'POST', undefined, body);
+  }
+
+  /**
+   * 更新组织机构
+   * @param {Object} org 组织机构对象，{*_id, departmentName, departmentParentCode, info}
+   * @returns {Object} { Response: { RequestId: '03e0a9f91364c', Data: 1 } }
+   */
+  async updateOrg(org) {
+    const body = {
+      OrgData: JSON.stringify(org),
+    };
+    return await this.auth('updateOrg', 'v1', 'POST', undefined, body);
+  }
+
+  /**
+   * 删除组织机构
+   * @param {String} id
+   * @returns {Object} { Response: { RequestId: 'caeddf6c3136c', Data: 1 } }
+   */
+  async deleteOrg(id) {
+    const body = {
+      OrgId: id,
+    };
+    return await this.auth('deleteOrg', 'v1', 'POST', undefined, body);
+  }
+
+  /**
+   * 分页查询组织机构
+   * @param {Number} pageNumber 页码，从第1页开始，默认是1
+   * @param {Number} pageSize 每页记录数，默认1000
+   * @returns {Object} {Response: {RequestId, Data: {Total, Schema, DataList[{DataId: _id, DataRecord: jsonString}]}}}
+   * jsonString: '{"departmentName":"","departmentParentCode":"!!ROOT","departmentCode":"","source":1.0,"depth":1,"_id":"","##DATA":{"_userInfoList":[]}}'
+   */
+  async describeOrgs(pageNumber = 1, pageSize = 1000) {
+    const body = {
+      PageNo: pageNumber < 1 ? 1 : pageNumber,
+      PageSize: pageSize < 0 ? 1000 : pageSize,
+    };
+    return await this.auth('describeOrgs', 'v1', 'POST', undefined, body);
+  }
+
+  /**
+   * 设置组织机构负责人
+   * @param {String} orgId 组织机构id
+   * @param {Array} userIdList 用户id数组
+   * @returns {Object}
+   */
+  async setOrgPrincipal(orgId, userIdList) {
+    const body = {
+      orgId: orgId,
+      userIdList: userIdList,
+    };
+    return await this.auth('setOrgPrincipal', 'v1', 'POST', undefined, body);
+  }
+
+  /**
+   * 新建角色
+   * @param {Object} role 角色对象 {*roleName, *roleIdentity, description}
+   * @returns {Object} {response: {requestId, error: {code, message}, data: roleId}}
+   */
+  async createRole(role) {
+    return await this.auth('createRole', 'v1', 'POST', undefined, role);
+  }
+
+  /**
+   * 修改角色
+   * @param {Object} role 角色对象 {*roleId, roleName, description}
+   * @returns {Object} {response: {requestId, error: {code, message}, data: boolean}}
+   */
+  async modifyRole(role) {
+    return await this.auth('modifyRole', 'v1', 'PUT', undefined, role);
+  }
+
+  /**
+   * 删除角色
+   * @param {String} roleId 角色id
+   * @returns {Object} {response: {requestId, error: {code, message}, data: boolean}}
+   */
+  async deleteRole(roleId) {
+    return await this.auth(
+      'deleteRole',
+      'v1',
+      'DELETE',
+      `roleId=${roleId}`,
+      undefined,
+    );
+  }
+
+  /**
+   * 查询角色详情
+   * @param {String} roleName 角色名
+   * @returns {Object} {response: {requestId, error: {code, message}, data: {roleName, roleIdentity, roleId, description, isReleased}}}
+   */
+  async describeRole(roleName) {
+    return await this.auth(
+      'describeRole',
+      'v1',
+      'GET',
+      `roleName=${roleName}`,
+      undefined,
+    );
+  }
+
+  /**
+   * 分页查询角色
+   * @param {Number} pageNumber 页码，从第1页开始，默认是1
+   * @param {Number} pageSize 每页记录数，默认1000
+   * @returns {Object} {Response: {RequestId, Data: {Total, RoleList: []}}}
+   */
+  async describeRoleList(pageNumber = 1, pageSize = 1000) {
+    const body = {
+      PageNo: pageNumber < 1 ? 1 : pageNumber,
+      PageSize: pageSize < 0 ? 1000 : pageSize,
+    };
+    return await this.auth('describeRoleList', 'v1.1', 'POST', undefined, body);
+  }
+
+  /**
+   * 查询拥有角色的用户
+   * @param {String} roleId 角色 id
+   * @param {Number} pageNumber 页码，从第1页开始，默认是1
+   * @param {Number} pageSize 每页记录数，默认1000
+   * @returns {Object} {Response: {RequestId, Data: {Total, UserList: []}}}
+   */
+  async describeUsersByRoleId(roleId, pageNumber = 1, pageSize = 1000) {
+    const body = {
+      RoleId: roleId,
+      PageNo: pageNumber < 1 ? 1 : pageNumber,
+      PageSize: pageSize < 0 ? 1000 : pageSize,
+    };
+    return await this.auth(
+      'describeUsersByRoleId',
+      'v1',
+      'POST',
+      undefined,
+      body,
+    );
+  }
+
+  /**
+   * 批量设置关联角色，注意此操作会完全替换用户的角色，并非增加关联。
+   * @param {Array} authorizations 授权数组 [{UserId, RoleIds: []}, ...]
+   * @returns {Object} {Response: {RequestId, Error: {Code, Message}, Data: boolean}}
+   */
+  async batchAuthorize(authorizations) {
+    const body = {
+      AuthorizeParam: authorizations,
+    };
+    return await this.auth('batchAuthorize', 'v1', 'POST', undefined, body);
+  }
+
+  /**
+   * 取消指定角色的关联用户
+   * @param {String} roleId 角色 id
+   * @param {Array} userIds 用户 id 数组
+   * @returns {Object} {response: {requestId, error: {code, message}, data: boolean}}
+   */
+  async unbindRoleUsers(roleId, userIds) {
+    const body = {
+      roleId: roleId,
+      userIds: userIds,
+    };
+    return await this.auth('unbindRoleUsers', 'v1', 'POST', undefined, body);
+  }
+
+  /**
+   * 更新指定角色的关联用户。
+   * @param {String} roleId 角色 id
+   * @param {Array} userIds 用户 id 数组
+   * @returns {Object} {response: {requestId, error: {code, message}, data: boolean}}
+   */
+  async updateRoleUsers(roleId, userIds) {
+    const body = {
+      roleId: roleId,
+      userIds: userIds,
+    };
+    return await this.auth('updateRoleUsers', 'v1', 'POST', undefined, body);
+  }
+
+  /**
+   * 查询角色的资源权限
+   * @param {String} roleId 角色 id
+   * @param {String} resourceType  资源类型，app, page, modelApp, modelAppPage, dataSource, flow
+   * @param {Array} resourceIds 资源 id 数组
+   * @returns {Object} {response: {data: [{roleId, resourceType, resourceId, isAccess, rowPermissionParams: [{rowPermissionScopeType, rowPermissionOperationType}]}]}}
+   */
+  async checkRoleResource(roleId, resourceType, resourceIds) {
+    const body = {
+      roleId: roleId,
+      resourceType: resourceType,
+      resourceIds: resourceIds,
+    };
+    return await this.auth('checkRoleResource', 'v1', 'POST', undefined, body);
+  }
+
+  /**
+   * 查询角色对 APIs 方法的权限
+   * @param {String} roleId 角色 id
+   * @param {String} dataSourceId 属于源 id
+   * @returns {Object} {response: {data: {methodAuthList: [{methodName, isAccess: boolean}]}}}
+   */
+  async describeMethodAuth(roleId, dataSourceId) {
+    return await this.auth(
+      'describeMethodAuth',
+      'v1',
+      'GET',
+      `roleId=${roleId}&dataSourceId=${dataSourceId}`,
+      undefined,
+    );
+  }
+
+  /**
+   * 查询角色绑定的数据模型列权限
+   * @param {String} roleId 角色 id
+   * @param {String} dataSourceId 数据源 id
+   * @param {Array} columnList 字段数组
+   * @returns {Object} {response: {data: {columnAuthList: [{column, auth: boolean}]}}}
+   */
+  async describeColumnAuth(roleId, dataSourceId, columnList) {
+    return await this.auth(
+      'describeColumnAuth',
+      'v1',
+      'GET',
+      `roleId=${roleId}&dataSourceId=${dataSourceId}&columnList=${columnList.join(',')}`,
+      undefined,
+    );
+  }
+
+  /**
+   * 查询用户对资源的权限（资源鉴权）
+   * @param {String} userId 用户 id
+   * @param {String} resourceType 资源类型，自定义应用：app，模型应用：modelApp，数据源：dataSource，流程：flow
+   * @param {Array} resourceList 资源列表，[{ResourceId: appId|datasourceId|flowId, SubResourceId: [pageId...], MethodIdList: [methodId...], ColumnList: []}]
+   * @returns {Object} {Response: {Data: [{ResourceId, ResourceType, IsAccess}]}}
+   */
+  async describeResourcesPermission(userId, resourceType, resourceList) {
+    const body = {
+      UserInfo: {
+        Uid: userId,
+        Source: 4,
+      },
+      ResourceList: resourceList,
+      ResourceType: resourceType,
+    };
+    return await this.auth(
+      'describeResourcesPermission',
+      'v1',
+      'POST',
+      undefined,
+      body,
+    );
+  }
+
+  //-------------------------------------------------------------------------------//
+  //                          以下是数据源操作接口                                   //
+  //-------------------------------------------------------------------------------//
+
+  /**
+   * 查询数据模型信息
+   * @param {Object} params {PageNum = 1, PageSize = 10, IdList, NameList, QueryAll = boolean}
+   * @returns {Object} {response: {data: {DataSourceList, Total}}}
+   */
+  async describeDataSourceList(params) {
+    let body = Object.assign(
+      {
+        PageNum: 1,
+        PageSize: 10,
+      },
+      params,
+    );
+    return await (
+      await this.wedaPath(
+        '/weda/model/v1/describeDataSourceList',
+        'POST',
+        undefined,
+        body,
+      )
+    ).json();
+  }
+
+  /**
+   * 查询选项集信息
+   * @param {Array} optionSetNames 选项集标识列表
+   * @returns {Object} {response: {data: {total, items: [{name, title, config, data}]}}}
+   */
+  async describeOptionSet(optionSetNames) {
+    return await (
+      await this.wedaPath(
+        '/weda/model/v1/describeOptionSet',
+        'POST',
+        undefined,
+        { optionSetNames: optionSetNames },
+      )
+    ).json();
+  }
+
+  /**
+   * 查询数据源 Schema
+   * @param {String} dataSourceName 数据源标识，不提供时查询环境下所有 Schema
+   * @returns {Response: {Data: {QueryDataSourceSchemaResultList}}}
+   */
+  async getSchemaList(dataSourceName = '') {
+    console.log(dataSourceName);
+    return await (
+      await this.wedaPath(
+        `/weda/model/v1/getSchemaList/${dataSourceName}`,
+        'GET',
+        undefined,
+        undefined,
+      )
+    ).json();
+  }
+
+  /**
+   * 新建一个数据
+   * @param {String} dataSourceName 数据模型标识
+   * @param {Object} data 数据对象
+   * @returns {Object} 成功返回数据对象json，失败返回{error: {code, message}}
+   */
+  async odataCreate(dataSourceName, data) {
+    return await (
+      await this.wedaPath(
+        `/weda/odata/v1/${this.options.envType}/${dataSourceName}`,
+        'POST',
+        undefined,
+        data,
+      )
+    ).json();
+  }
+
+  /**
+   * 更新一个数据
+   * @param {String} dataSourceName 数据模型标识
+   * @param {String} id 数据 id
+   * @param {Object} data 需要修改的数据属性及其取值
+   * @returns {Number} status
+   */
+  async odataUpdate(dataSourceName, id, data) {
+    return (
+      await this.wedaPath(
+        `/weda/odata/v1/${this.options.envType}/${dataSourceName}('${id}')`,
+        'PATCH',
+        undefined,
+        data,
+      )
+    ).ok;
+  }
+
+  /**
+   * 删除一个数据
+   * @param {String} dataSourceName 数据模型标识
+   * @param {String} id 数据 id
+   * @returns {Number} response status
+   */
+  async odataDelete(dataSourceName, id) {
+    return (
+      await this.wedaPath(
+        `/weda/odata/v1/${this.options.envType}/${dataSourceName}('${id}')`,
+        'DELETE',
+        undefined,
+        undefined,
+      )
+    ).ok;
+  }
+
+  /**
+   * 根据 id 获取一个数据
+   * @param {String} dataSourceName 数据模型标识
+   * @param {String} id 数据 id
+   * @returns {Object} 数据对象。如果没有对应数据，则对象里面所有属性为 null，可以检查 _id 是否为 null。
+   */
+  async odataById(dataSourceName, id) {
+    if (id) {
+      return await (
+        await this.wedaPath(
+          `/weda/odata/v1/${this.options.envType}/${dataSourceName}('${id}')`,
+          'GET',
+          undefined,
+          undefined,
+        )
+      ).json();
+    } else {
+      return await (
+        await this.wedaPath(
+          `/weda/odata/v1/${this.options.envType}/${dataSourceName}`,
+          'GET',
+          undefined,
+          undefined,
+        )
+      ).json();
+    }
+  }
+
+  /**
+   * 查询数据
+   * @param {String} dataSourceName 数据模型标识
+   * @param {Object} params {$filter, $select, $orderby, $skip=0, $top=10, $count, NotQueryRelateDepartment=true, ResultWithRelation=false}
+   * @returns {Object} {"@odata.context", "@odata.count", value=[]}
+   * @param {String} version v1,v2
+   */
+  async odataQuery(dataSourceName, params, version = 'v1') {
+    const query = Object.assign(
+      {
+        $skip: 0,
+        $top: 10,
+        NotQueryRelateDepartment: true,
+        ResultWithRelation: false,
+      },
+      params,
+    );
+
+    let queryArray = [];
+    for (let q in query) {
+      queryArray.push(`${q}=${query[q]}`);
+    }
+    const response = await this.wedaPath(
+      `/weda/odata/${version}/${this.options.envType}/${dataSourceName}`,
+      'GET',
+      queryArray.join('&'),
+    );
+    const json = await response.json();
+
+    if (!response.ok) {
+      console.error(json);
+    }
+
+    return json;
+  }
+
+  /**
+   * 批量创建数据
+   * 注意：混合云不支持此接口
+   * @param {String} dataSourceName 数据模型标识
+   * @param {Array} objects 需要创建的对象数组
+   * @returns {Object} {"@odata.context", value=[]}
+   */
+  async odataBatchCreate(dataSourceName, objects) {
+    return await (
+      await this.wedaPath(
+        `/weda/odata/v1/batch/${this.options.envType}/${dataSourceName}`,
+        'POST',
+        undefined,
+        { value: objects },
+      )
+    ).json();
+  }
+
+  /**
+   * 批量更新
+   * @param {String} dataSourceName 数据模型标识
+   * @param {Array} ids id 数组，注意数组长度，组装后 url 总长度不要超过长度限制（2048）
+   * @param {Object} obj 更新的属性和值
+   * @returns {Object} {updateCount}
+   */
+  async odataBatchUpdate(dataSourceName, ids, obj) {
+    return await (
+      await this.wedaPath(
+        `/weda/odata/v1/batch/${this.options.envType}/${dataSourceName}('${ids.join(',')}')`,
+        'PATCH',
+        undefined,
+        obj,
+      )
+    ).json();
+  }
+
+  /**
+   * 根据 id 批量获取数据
+   * @param {String} dataSourceName 数据模型标识
+   * @param {Array} ids 数据 id 数组，注意数组长度，组装后 url 总长度不要超过长度限制（2048）
+   * @returns {Object} {"odata.context", value=[]}
+   */
+  async odataByIds(dataSourceName, ids) {
+    return await (
+      await this.wedaPath(
+        `/weda/odata/v1/batch/${this.options.envType}/${dataSourceName}('${ids.join(',')}')`,
+        'GET',
+        undefined,
+        undefined,
+      )
+    ).json();
+  }
+
+  /**
+   * 根据 id 批量获取数据
+   * @param {String} dataSourceName 数据模型标识
+   * @param {Array} ids 数据 id 数组，注意数组长度，组装后 url 总长度不要超过长度限制（2048）
+   * @returns {Object} {deleteCount}
+   */
+  async odataBatchDelete(dataSourceName, ids) {
+    return await (
+      await this.wedaPath(
+        `/weda/odata/v1/batch/${this.options.envType}/${dataSourceName}('${ids.join(',')}')`,
+        'DELETE',
+        undefined,
+        undefined,
+      )
+    ).json();
+  }
+
+  //-------------------------------------------------------------------------------//
+  //                          以下是自定义接口                                      //
+  //-------------------------------------------------------------------------------//
+
+  /**
+   * 对某个属性，提供多个值按批次循环进行相等查询，返回所有结果。
+   * 适合于对某个属性进行查询，但是值很多的情况，避免请求长度过长的问题。
+   * 2025-04-11: 服务器端目前限制查询参数 batch 不能超过10
+   * @param {Object} parameters {dataSourceName, prop, values, select, order, batch: 10, version: 'v1'|'v2'}
+   * 注意 v2 目前不支持 order
+   * @returns
+   */
+  async odataQueryByPropEQValues(parameters) {
+    const params = Object.assign({ batch: 10, version: 'v1' }, parameters);
+
+    const query = {};
+    if (params.select) {
+      query.$select = params.select;
+    } else {
+      query.$select = '*';
+    }
+
+    // 2025-04-11: 服务器端目前限制查询参数 batch 不能超过10
+    if (params.batch > 10) {
+      params.batch = 10;
+    }
+
+    if (params.order) {
+      query.$orderby = params.order;
+    }
+
+    const items = [];
+
+    for (let i = 0; i < params.values.length; i += params.batch) {
+      query.$filter = params.values
+        .slice(i, i + params.batch)
+        .map((v) => `${params.prop} eq '${v}'`)
+        .join(' or ');
+      const response = await this.odataQueryCollectAll(
+        params.dataSourceName,
+        query,
+        params.version,
+      );
+
+      for (const item of response) {
+        items.push(item);
+      }
+    }
+
+    return items;
+  }
+
+  /**
+   * 收集所有结果，受限于 api 每次最多1000个记录的限制，需要多次查询。注意结果集对内存的需求。
+   * @param {String} dataSourceName
+   * @param {Object} params {$filter, $select, $orderby, $skip=0, $top=10, $count, NotQueryRelateDepartment=true, ResultWithRelation=false}
+   * $orderby 应该提供，避免排序不稳定导致数据重复或遗漏
+   * @param {String} version v1,v2
+   * @returns
+   */
+  async odataQueryCollectAll(dataSourceName, params, version = 'v1') {
+    const items = [];
+    const batch = version === 'v1' ? 1000 : 200;
+    const _params = Object.assign({}, params);
+    _params.$top = batch;
+    _params.$count = true;
+
+    for (let i = 0, count = -1; i < count || count == -1; i += batch) {
+      _params.$skip = i;
+      const response = await this.odataQuery(dataSourceName, _params, version);
+
+      if (count === -1) {
+        count = response['@odata.count'] ? response['@odata.count'] : 0;
+        _params.$count = false;
+      }
+
+      if (response.value) {
+        for (const item of response.value) {
+          items.push(item);
+        }
+      }
+    }
+    return items;
+  }
+
+  /**
+   * 为指定用户分配角色（增加）
+   * @param {String} userId 用户id
+   * @param {Array} roleIds 角色id数组
+   * @returns {Boolean}
+   * @throws
+   */
+  async addAuthorizes(userId, roleIds) {
+    const _roleIds = roleIds.slice();
+
+    // 合并已有角色授权
+    const describeResponse = await this.describeWedaUser(userId, true, false);
+    if (describeResponse.Response.Error) {
+      throw new Error(
+        `describeWedaUser('${userId}', true, false): ${JSON.stringify(describeResponse.Response.Error)}`,
+      );
+    }
+    const wedaUser = describeResponse.Response.Data;
+    if (wedaUser && wedaUser.RelatedRoles) {
+      const existsRoleIds = wedaUser.RelatedRoles.map((r) => r.Id);
+
+      // 如果没有新的角色需要授权，直接返回
+      if (roleIds.every((id) => existsRoleIds.includes(id))) {
+        return false;
+      }
+
+      existsRoleIds.forEach((id) => {
+        if (!_roleIds.includes(id)) {
+          _roleIds.push(id);
+        }
+      });
+    }
+
+    const response = await this.batchAuthorize([
+      { UserId: userId, RoleIds: _roleIds },
+    ]);
+    if (response.Response.Error) {
+      throw new Error(
+        `batchAuthorize('${userId}', ${JSON.stringify(_roleIds)}): ${JSON.stringify(response.Response.Error)}`,
+      );
+    }
+
+    return true;
+  }
+}
+
+module.exports = WedaOpenApi;

package/workflow.js

@@ -0,0 +1,130 @@
+const fetch = require('node-fetch');
+const Auth = require('./auth');
+
+/**
+ * 审批流接口
+ * 详细文档：https://cloud.tencent.com/document/product/1301/94470
+ * 
+ * 流程：ProcessKey 为流程的唯一标识。流程可以有多个版本。
+ * 流程具体版本：FlowCode 为流程具体版本的唯一标识，在流程每次保存、发布后，会生成新的 FlowCode（ProcessKey 不变）
+ * 
+ * 流程实例：触发流程后产生的运行态实例；InstanceId 为流程实例的唯一标识；一个流程可以被触发多次，即一个流程在运行态包含多个流程实例。
+ * 审批任务：每个审批节点下每个审批人被分配的任务；FlowTaskId（TaskId）为审批任务的唯一标识；在一个流程实例中，流转到某一个审批节点时，会为该审批节点下每个审批人分配审批任务，即一个流程实例包含多个审批任务。
+ */
+class Workflow {
+  constructor(options) {
+
+    this.options = Object.assign(
+      {
+        // 主机地址
+        host: 'https://weda.web.scut.edu.cn',
+
+        // 环境信息
+        envId: 'lowcode-7gwjk8v14d46dda1',
+        envType: 'prod',
+
+        debug: false,
+      },
+      options
+    );
+
+    console.log(this.options);
+
+    this.auth = new Auth(this.options);
+    this.baseUrl = `${this.options.host}/weda/workflow/v1/${this.options.envType}`;
+  }
+
+  async post(path, body) {
+    const token = await this.auth.getAccessToken();
+
+    if (this.options.debug) {
+      console.log(`Request URL: ${this.baseUrl}/${path}`);
+      console.log("Request Body:", body);
+    }
+    
+    const response = await fetch(`${this.baseUrl}/${path}`, {
+      method: 'POST',
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${token}`,
+      },
+      body: JSON.stringify(body)
+    });
+
+    if (this.options.debug) {
+      console.log(response);
+    }
+
+    const data = await response.json();
+    return data;
+  }
+
+  /**
+   * 查询已部署的流程列表
+   * @param {Object} body {Type: integer}
+   * Type: 1 逻辑流，2 审批流
+   * @returns 
+   */
+  async listDeployedFlows(body) {
+    return this.post('ListDeployedFlows', body);
+  }
+
+  /**
+   * 根据类型查询流程实例列表
+   * @param {Object} body 
+   * @returns 
+   */
+  async ListProcessInstances(body) {
+    return this.post('ListProcessInstances', body);
+  }
+
+  /**
+   * 查询流程任务相关信息
+   * @param {Object} body 
+   * @returns 
+   */
+  async getFlowInstanceTasks(body) {
+    return this.post('GetFlowInstanceTasks', body);
+  }
+
+  /**
+   * 查询流程实例详情
+   * @param {Object} body { FlowTaskId: string, PageType: string, UserInfo, NeedUserExtraInfo: boolean }
+   * PageType: 'TODO' | 'DONE' | 'CREATE' | 'CC'
+   * UserInfo: { UserId: string, Type: integer }
+   * @returns 
+   */
+  async describeProcessInstance(body) {
+    return this.post('DescribeProcessInstance', body);
+  }
+
+  /**
+   * 终止单个流程实例
+   * @param {Object} body { InstanceId: string, Operator: UserInfo, DeleteReason: string }
+   * UserInfo: { UserId: string, Type: integer }
+   * @returns { Response: { RequestId: string, Data: { Result: boolean } } }
+   */
+  async stopFlow(body) {
+    return this.post('StopFlow', body);
+  }
+
+  /**
+   * 管理后台终止操作
+   * @param {Object} body { InstanceIdList: [string], UserInfo: UserInfo }
+   * @returns { Response: { RequestId: string, Data: { Result: boolean } } }
+   */
+  async manageStopProcessList(body) {
+    return this.post('ManageStopProcessList', body);
+  }
+
+  /**
+   * 查询流程操作相关信息
+   * @param {Object} body { InstanceId: string, ElementIds: [string], OperatorUser: UserInfo, PageNumber: integer, PageSize: integer, NeedUserExtraInfo: boolean }
+   * @returns { Response: { RequestId: string, Data: { Result: [] }, TotalCount: integer } }
+   */
+  async getFlowInstanceOperations(body) {
+    return this.post('GetFlowInstanceOperations', body);
+  }
+}
+
+module.exports = Workflow;