函数库与调用接口

import java.util.ArrayList;
import java.util.List;

/** 列表和详情共用的查询条件：自己的函数加上别人公开的函数。 */
private static final String VISIBLE_WHERE = """
    from max_kb_function_lib
     where deleted = false
       and (user_id = ? or permission_type = 'PUBLIC')
    """;

/** 查询条件按占位符顺序累积，分页和列表共用。 */
private static final class Query {
  private String where;
  private final List<Object> params = new ArrayList<>();

  private Query(String where) {
    this.where = where;
  }
}

import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject;

/** 调试未保存的代码：先合并参数，再交给执行器，异常信息直接返回给界面。 */
public Object debug(JSONObject input) {
  JSONObject params = input.getJSONObject("init_params");
  params = params == null ? new JSONObject() : new JSONObject(params);
  JSONObject debug = new JSONObject();
  JSONArray values = input.getJSONArray("debug_field_list");
  if (values != null) {
    for (Object item : values) {
      JSONObject field = (JSONObject) item;
      debug.put(field.getString("name"), field.get("value"));
    }
  }
  JSONArray fields = input.getJSONArray("input_field_list");
  if (fields != null) {
    for (Object item : fields) {
      JSONObject field = (JSONObject) item;
      String name = field.getString("name");
      Object value = debug.get(name);
      if (value instanceof String text && text.isBlank()) {
        value = null;
      }
      if (value == null) {
        if (field.getBooleanValue("is_required")) {
          throw new IllegalArgumentException("缺少函数参数：" + name);
        }
        params.remove(name);
        continue;
      }
      params.put(name, convert(value, field.getString("type")));
    }
  }
  return Aop.get(IsolatedPythonExecutor.class).execute(input.getString("code"), params, input.getString("entrypoint"), false);
}

static Object convert(Object value, String type) {
  if (value == null) {
    return null;
  }
  return switch (type == null ? "string" : type) {
    case "int" -> Long.valueOf(value.toString().trim());
    case "float" -> Double.valueOf(value.toString().trim());
    case "dict" -> JSON.parseObject(value.toString());
    case "array" -> JSON.parseArray(value.toString());
    default -> value.toString();
  };
}

/** 保存前的字段校验，返回 null 表示通过。 */
static String validate(JSONObject data) {
  String name = data.getString("name");
  if (name == null || name.isBlank() || name.trim().length() > MAX_NAME_LENGTH) {
    return "函数名称不能为空且不能超过 64 个字符";
  }
  String code = data.getString("code");
  if (code == null || code.isBlank()) {
    return "函数代码不能为空";
  }
  if (code.getBytes(java.nio.charset.StandardCharsets.UTF_8).length > MAX_CODE_LENGTH) {
    return "函数代码不能超过 64 KiB";
  }
  JSONArray fields = data.getJSONArray("input_field_list");
  if (fields != null) {
    for (Object item : fields) {
      if (!(item instanceof JSONObject field)) {
        return "调用参数格式无效";
      }
      String type = field.getString("type");
      String source = field.getString("source");
      if (type != null && !FIELD_TYPES.contains(type)) {
        return "参数类型只支持 string、int、float、dict、array";
      }
      if (source != null && !FIELD_SOURCES.contains(source)) {
        return "参数来源只支持 custom、reference";
      }
    }
  }
  return null;
}

/** 保留前 2 位和后 4 位，中间用固定长度的星号占位。 */
static String mask(String secret) {
  String prefix = secret.substring(0, Math.min(2, secret.length()));
  String suffix = secret.length() > 4 ? secret.substring(secret.length() - 4) : "";
  return prefix + "********" + suffix;
}

/**
 * 详情里的密码类初始化参数是打过码的，界面原样回传时不能把星号写回库。
 *
 * <p>提交值和当前值的打码结果一致，说明用户没有改动，继续沿用库里的原值。
 */
private void restoreMaskedSecrets(Row existing, JSONObject data) {
  if (!(data.get("init_params") instanceof JSONObject submitted) || submitted.isEmpty()) {
    return;
  }
  JSONObject current = parseObject(existing.getObject("init_params"));
  for (String key : submitted.keySet()) {
    Object value = submitted.get(key);
    Object stored = current.get(key);
    if (stored != null && value != null && mask(stored.toString()).equals(value.toString())) {
      submitted.put(key, stored);
    }
  }
}

/** 初始化参数只保留仍在初始化字段列表里的键。 */
static JSONObject normalizeInitParams(JSONObject data, String initFieldsJson) {
  JSONObject params = data.getJSONObject("init_params");
  params = params == null ? new JSONObject() : new JSONObject(params);
  JSONArray fields = JSON.parseArray(initFieldsJson);
  List<String> keys = new ArrayList<>();
  for (Object item : fields) {
    if (item instanceof JSONObject field && field.getString("field") != null) {
      keys.add(field.getString("field"));
    }
  }
  params.keySet().removeIf(key -> !keys.contains(key));
  return params;
}

/**
 * 执行自己保存且启用的函数，请求体是调用参数，内部会合并函数自己的初始化参数。
 *
 * <p>同时作为 Java 侧工作流函数节点的共享入口。
 */
public Object execute(Long user, Long id, JSONObject arguments) {
  Row row = Db.findFirst("select * from max_kb_function_lib where id=? and user_id=? and deleted=false", id, user);
  if (row == null || !Boolean.TRUE.equals(row.getBoolean("is_active"))) {
    throw new IllegalArgumentException("函数不存在、已停用或无权执行");
  }
  JSONObject params = parseObject(row.getObject("init_params"));
  if (arguments != null) {
    params.putAll(arguments);
  }
  return Aop.get(IsolatedPythonExecutor.class).execute(row.getStr("code"), params, null, false);
}

import com.alibaba.fastjson2.JSONObject;
import nexus.io.jfinal.aop.Aop;
import nexus.io.maxkb.service.kb.PythonFunctionService;

/** 把上游节点的输出当作调用参数，直接调函数。 */
JSONObject arguments = new JSONObject();
arguments.put("query", upstreamNode.getStr("query"));
Object result = Aop.get(PythonFunctionService.class).execute(userId, functionId, arguments);

/**
 * 内置函数模板复制一份给自己的函数。
 *
 * <p>复制出来的函数只有名字是新的，代码和参数沿用模板，模板 id 记下来后界面会把它当成模板来源。
 */
public ResultVo addInternal(Long user, Long templateId, String name) {
  String trimmed = name == null ? null : name.trim();
  if (trimmed == null || trimmed.isBlank() || trimmed.length() > MAX_NAME_LENGTH) {
    return ResultVo.fail("函数名称格式无效");
  }
  Row source = Db.findFirst("select * from max_kb_function_lib where id=? and deleted=false", templateId);
  if (source == null || !"INTERNAL".equals(source.getStr("function_type"))) {
    return ResultVo.fail("函数模板不存在");
  }
  long id = SnowflakeIdUtils.id();
  Db.update("""
      insert into max_kb_function_lib(id,user_id,name,"desc",code,input_field_list,init_field_list,init_params,
        permission_type,is_active,icon,function_type,template_id)
      values(?,?,?,?,?,?::jsonb,?::jsonb,'{}'::jsonb,'PRIVATE',false,?,'PUBLIC',?)
      """, id, user, trimmed, source.getStr("desc"), source.getStr("code"),
      Objects.toString(source.getObject("input_field_list"), "[]"),
      Objects.toString(source.getObject("init_field_list"), "[]"), source.getStr("icon"), templateId);
  return get(user, id);
}

/** 导入 .fx 文件，导入结果是自己的私有函数，默认停用。 */
public ResultVo importFunction(Long user, UploadFile file) {
  if (file == null || file.getData() == null || file.getData().length == 0) {
    return ResultVo.fail("请选择要导入的文件");
  }
  JSONObject payload;
  try {
    payload = JSON.parseObject(new String(file.getData(), java.nio.charset.StandardCharsets.UTF_8));
  } catch (RuntimeException e) {
    return ResultVo.fail("不支持的文件格式");
  }
  if (payload == null || !EXPORT_VERSION.equals(payload.getString("version"))) {
    return ResultVo.fail("不支持的文件格式");
  }
  JSONObject input = new JSONObject();
  input.put("name", payload.getString("name"));
  input.put("desc", payload.getOrDefault("desc", ""));
  input.put("code", payload.getString("code"));
  input.put("input_field_list", payload.getOrDefault("input_field_list", new JSONArray()));
  input.put("init_field_list", payload.getOrDefault("init_field_list", new JSONArray()));
  input.put("permission_type", "PRIVATE");
  input.put("is_active", false);
  return save(user, null, input);
}

/**
 * 保存上传的图标并返回可访问路径。
 *
 * @return 形如 {@code /api/function_lib/icon/<文件名>} 的路径
 */
public String save(UploadFile file) {
  if (file == null || file.getData() == null || file.getData().length == 0) {
    throw new IllegalArgumentException("请选择要上传的图片");
  }
  if (file.getData().length > MAX_ICON_BYTES) {
    throw new IllegalArgumentException("图标不能超过 10 MB");
  }
  String suffix = suffix(file.getName());
  if (!ALLOWED_SUFFIX.contains(suffix)) {
    throw new IllegalArgumentException("图标只支持 png、jpg、gif、webp 格式");
  }
  String name = UUID.randomUUID().toString().replace("-", "") + "." + suffix;
  try {
    Path directory = Paths.get(STATIC_LOCATION, ICON_DIR);
    Files.createDirectories(directory);
    Files.write(directory.resolve(name), file.getData());
  } catch (IOException e) {
    throw new IllegalStateException("图标保存失败：" + e.getMessage(), e);
  }
  return "/api/function_lib/icon/" + name;
}

/** 文件名规则：随机十六进制串加白名单后缀，读取时用它挡住目录穿越。 */
private static final String FILE_NAME = "[0-9a-f]{32}\\.(png|jpg|jpeg|gif|webp|bmp)";

/**
 * 读取图标内容。
 *
 * @return 文件不存在或名称不合法时返回 null
 */
public byte[] read(String name) {
  if (name == null || !name.matches(FILE_NAME)) {
    return null;
  }
  Path path = Paths.get(STATIC_LOCATION, ICON_DIR, name);
  try {
    return Files.exists(path) ? Files.readAllBytes(path) : null;
  } catch (IOException e) {
    return null;
  }
}