@pisell/private-materials 6.2.51 → 6.2.52

package/lib/components/systemSettings/registry/services.js

@@ -0,0 +1,290 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/systemSettings/registry/services.ts
+var services_exports = {};
+__export(services_exports, {
+  createGroup: () => createGroup,
+  createItem: () => createItem,
+  deleteGroup: () => deleteGroup,
+  deleteItem: () => deleteItem,
+  getGroupList: () => getGroupList,
+  getItemList: () => getItemList,
+  getSectionList: () => getSectionList,
+  sortGroups: () => sortGroups,
+  sortItems: () => sortItems,
+  updateGroup: () => updateGroup,
+  updateItem: () => updateItem
+});
+module.exports = __toCommonJS(services_exports);
+var createGroup = async (request, params) => {
+  try {
+    if (!params.title || !params.code || !params.section_code || params.sort === void 0) {
+      throw new Error("Missing required parameters for group creation");
+    }
+    const response = await request.post(
+      "/api/setting_group:create",
+      params,
+      {
+        isNocobase: true,
+        headers: {
+          "x-data-source": "pisell2"
+        }
+      }
+    );
+    return response;
+  } catch (error) {
+    console.error("Failed to create group:", error);
+    throw error;
+  }
+};
+var updateGroup = async (request, params) => {
+  try {
+    if (!params.id || !params.title || !params.code) {
+      throw new Error("Missing required parameters for group update");
+    }
+    const response = await request.post(
+      `/api/setting_group:update?filterByTk=${params.id}`,
+      params,
+      {
+        isNocobase: true,
+        headers: {
+          "x-data-source": "pisell2"
+        }
+      }
+    );
+    return response;
+  } catch (error) {
+    console.error("Failed to update group:", error);
+    throw error;
+  }
+};
+var deleteGroup = async (request, params) => {
+  try {
+    if (!params.id) {
+      throw new Error("Missing required parameters for group deletion");
+    }
+    const response = await request.post(
+      `/api/setting_group:update?filterByTk=${params.id}`,
+      {
+        deleted_at: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      {
+        isNocobase: true,
+        headers: {
+          "x-data-source": "pisell2"
+        }
+      }
+    );
+    return response;
+  } catch (error) {
+    console.error("Failed to delete group:", error);
+    throw error;
+  }
+};
+var sortGroups = async (request, params) => {
+  try {
+    if (!params.section_code || !params.group_ids || !Array.isArray(params.group_ids)) {
+      throw new Error("Missing required parameters for group sorting");
+    }
+    const response = await request.post(
+      "/admin/setting/group/sort",
+      {
+        section_code: params.section_code,
+        group_ids: params.group_ids
+      },
+      {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      }
+    );
+    return response;
+  } catch (error) {
+    console.error("Failed to sort groups:", error);
+    throw error;
+  }
+};
+var getSectionList = async (request, params) => {
+  try {
+    const { page = 1, pageSize = 20, filter = {} } = params;
+    const filterWithSoftDelete = {
+      ...filter,
+      deleted_at: null
+    };
+    const queryParams = new URLSearchParams({
+      page: page.toString(),
+      pageSize: pageSize.toString(),
+      filter: JSON.stringify(filterWithSoftDelete)
+    });
+    const response = await request.get(
+      `/api/section:list?${queryParams.toString()}`,
+      {},
+      {
+        isNocobase: true,
+        headers: {
+          "x-data-source": "pisell2"
+        }
+      }
+    );
+    return response;
+  } catch (error) {
+    console.error("Failed to fetch section list:", error);
+    throw error;
+  }
+};
+var getGroupList = async (request, params) => {
+  try {
+    const { filter = {} } = params;
+    const filterWithSoftDelete = {
+      ...filter,
+      deleted_at: null
+      // "items.deleted_at": null
+    };
+    const queryParams = new URLSearchParams({
+      paginate: "false",
+      filter: JSON.stringify(filterWithSoftDelete),
+      appends: "items",
+      sort: "sort,id"
+    });
+    const response = await request.get(
+      `/api/setting_group:list?${queryParams.toString()}`,
+      {},
+      {
+        isNocobase: true,
+        headers: {
+          "x-data-source": "pisell2"
+        }
+      }
+    );
+    if (response.data.length > 0) {
+      response.data.forEach((item) => {
+        item.items = item.items.filter((item2) => item2.deleted_at === null);
+      });
+    }
+    return response;
+  } catch (error) {
+    console.error("Failed to fetch group list:", error);
+    throw error;
+  }
+};
+var createItem = async (request, params) => {
+  try {
+    if (!params.section_code || !params.group_id || !params.title || !params.code || !params.type) {
+      throw new Error("Missing required parameters for item creation");
+    }
+    const response = await request.post(
+      "/admin/setting/item",
+      params
+    );
+    return response;
+  } catch (error) {
+    console.error("Failed to create item:", error);
+    throw error;
+  }
+};
+var updateItem = async (request, params) => {
+  try {
+    if (!params.id || !params.section_code || !params.group_id || !params.title || !params.code || !params.type) {
+      throw new Error("Missing required parameters for item update");
+    }
+    const response = await request.put(
+      `/admin/setting/item/${params.id}`,
+      params
+    );
+    return response;
+  } catch (error) {
+    console.error("Failed to update item:", error);
+    throw error;
+  }
+};
+var deleteItem = async (request, params) => {
+  try {
+    console.log(request);
+    if (!params.id) {
+      throw new Error("Missing required parameters for item deletion");
+    }
+    const response = await request.remove(
+      `/admin/setting/item/${params.id}`,
+      {}
+    );
+    return response;
+  } catch (error) {
+    console.error("Failed to delete item:", error);
+    throw error;
+  }
+};
+var sortItems = async (request, params) => {
+  try {
+    if (!params.id || !params.group_id || !params.item_ids) {
+      throw new Error("Missing required parameters for item sorting");
+    }
+    const response = await request.post(
+      `/admin/setting/item/${params.id}/sort`,
+      {
+        group_id: params.group_id,
+        item_ids: params.item_ids
+      },
+      {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      }
+    );
+    return response;
+  } catch (error) {
+    console.error("Failed to sort items:", error);
+    throw error;
+  }
+};
+var getItemList = async (request, params) => {
+  try {
+    const { page = 1, pageSize = 20, filter = {} } = params;
+    const filterWithSoftDelete = {
+      ...filter,
+      deleted_at: null
+    };
+    const queryParams = new URLSearchParams({
+      page: page.toString(),
+      pageSize: pageSize.toString(),
+      filter: JSON.stringify(filterWithSoftDelete)
+    });
+    const response = await request.get(
+      `/api/setting_item:list?${queryParams.toString()}`,
+      {}
+    );
+    return response;
+  } catch (error) {
+    console.error("Failed to fetch item list:", error);
+    throw error;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createGroup,
+  createItem,
+  deleteGroup,
+  deleteItem,
+  getGroupList,
+  getItemList,
+  getSectionList,
+  sortGroups,
+  sortItems,
+  updateGroup,
+  updateItem
+});

package/lib/components/systemSettings/registry/types.d.ts

@@ -0,0 +1,126 @@
+import { CSSProperties } from 'react';
+export interface MultiLanguageText {
+    en: string;
+    'zh-CN': string;
+    'zh-HK': string;
+    original: string;
+}
+export interface BaseItem {
+    id: number;
+    name: string | MultiLanguageText;
+    code: string;
+    order?: number;
+}
+export interface SettingItem extends BaseItem {
+    key?: string;
+    scopes?: string[];
+    groupId?: number;
+    group_id?: number;
+    fieldType?: string;
+    type?: string;
+    interfaceType?: string;
+    interface?: string;
+    description?: string | MultiLanguageText;
+    systemDefaultValue?: string;
+    default?: string;
+    uiSchema?: string;
+    schema?: any;
+    title?: string | MultiLanguageText;
+    sort: number;
+    created_at?: string | null;
+    updated_at?: string | null;
+    deleted_at?: string | null;
+}
+export interface SettingGroup extends BaseItem {
+    items: SettingItem[];
+    expanded?: boolean;
+    sort: number;
+}
+export interface Section extends BaseItem {
+    icon?: string;
+    description?: string | MultiLanguageText;
+    groups: SettingGroup[];
+    created_at?: string | null;
+    updated_at?: string | null;
+    deleted_at?: string | null;
+}
+export interface TreeNode {
+    key: string;
+    type: 'group' | 'item';
+    data: SettingGroup | SettingItem;
+    children?: TreeNode[];
+    parentKey?: string;
+}
+export declare type OperationType = 'add' | 'edit' | 'delete';
+export interface DragItem {
+    id: number;
+    type: 'group' | 'item';
+    groupId?: number;
+}
+export interface RegistryProps {
+    className?: string;
+    style?: CSSProperties;
+    sections?: Section[];
+    selectedSectionId?: number;
+    onSectionSelect?: (sectionId: number) => void;
+    onDataChange?: (sections: Section[]) => void;
+}
+export interface SectionListProps {
+    sections: Section[];
+    selectedSectionId?: number;
+    onSectionSelect: (sectionId: number) => void;
+    loading?: boolean;
+    hasMore?: boolean;
+    onLoadMore?: () => void;
+}
+export interface SettingsTableProps {
+    section?: Section;
+    groupList?: SettingGroup[];
+    groupLoading?: boolean;
+    onDataChange?: (section: Section) => void;
+    onEditGroup?: (group: SettingGroup) => void;
+    onDeleteGroup?: (groupId: number) => void;
+    onAddItem?: (groupId: number) => void;
+    onEditItem?: (item: SettingItem) => void;
+    onDeleteItem?: (itemId: number) => void;
+    onGroupReorder?: (groupIds: number[]) => void;
+    onItemMove?: (itemId: number, targetGroupId: number, newOrder: number) => void;
+}
+export interface GroupFormData {
+    title: MultiLanguageText;
+    code: string;
+}
+export interface ItemFormData {
+    name: MultiLanguageText;
+    key: string;
+    fieldType: string;
+    interfaceType?: string;
+    scopes: string[];
+    description?: MultiLanguageText;
+    default?: string | null;
+    uiSchema?: string;
+}
+export interface GroupModalProps {
+    open: boolean;
+    type: OperationType;
+    data?: SettingGroup;
+    onOk: (data: GroupFormData) => void | Promise<void>;
+    onCancel: () => void;
+}
+export interface ItemModalProps {
+    open: boolean;
+    type: OperationType;
+    data?: SettingItem;
+    section?: Section;
+    onOk: (data: ItemFormData) => void | Promise<void>;
+    onCancel: () => void;
+}
+export interface ApiResponse<T> {
+    data: T[];
+    meta: {
+        count: number;
+        page: number;
+        pageSize: number;
+        totalPage: number;
+    };
+}

package/lib/components/systemSettings/registry/types.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/systemSettings/registry/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/lib/components/systemSettings/registry/utils/typeValidation.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 类型验证工具函数
+ * 用于验证默认值是否符合指定的字段类型
+ */
+export interface ValidationResult {
+    isValid: boolean;
+    error?: string;
+}
+/**
+ * 根据字段类型验证默认值
+ */
+export declare const validateDefaultValue: (fieldType: string, defaultValue: any) => ValidationResult;
+/**
+ * 解析默认值为对应的类型
+ */
+export declare const parseDefaultValue: (fieldType: string, defaultValue: any) => any;

package/lib/components/systemSettings/registry/utils/typeValidation.js

@@ -0,0 +1,228 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/systemSettings/registry/utils/typeValidation.ts
+var typeValidation_exports = {};
+__export(typeValidation_exports, {
+  parseDefaultValue: () => parseDefaultValue,
+  validateDefaultValue: () => validateDefaultValue
+});
+module.exports = __toCommonJS(typeValidation_exports);
+var validateString = (value) => {
+  if (value === null || value === void 0 || value === "") {
+    return { isValid: true };
+  }
+  if (typeof value === "string") {
+    return { isValid: true };
+  }
+  return {
+    isValid: false,
+    error: "默认值必须是字符串类型"
+  };
+};
+var validateInteger = (value) => {
+  if (value === null || value === void 0 || value === "") {
+    return { isValid: true };
+  }
+  if (typeof value === "number") {
+    if (!Number.isInteger(value)) {
+      return {
+        isValid: false,
+        error: "默认值必须是整数"
+      };
+    }
+    return { isValid: true };
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed === "") {
+      return { isValid: true };
+    }
+    const num = Number(trimmed);
+    if (isNaN(num) || !Number.isInteger(num)) {
+      return {
+        isValid: false,
+        error: "默认值必须是有效的整数"
+      };
+    }
+    return { isValid: true };
+  }
+  return {
+    isValid: false,
+    error: "默认值必须是有效的整数"
+  };
+};
+var validateFloat = (value) => {
+  if (value === null || value === void 0 || value === "") {
+    return { isValid: true };
+  }
+  if (typeof value === "number") {
+    if (!isFinite(value)) {
+      return {
+        isValid: false,
+        error: "默认值必须是有效的数字"
+      };
+    }
+    return { isValid: true };
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed === "") {
+      return { isValid: true };
+    }
+    const num = Number(trimmed);
+    if (isNaN(num) || !isFinite(num)) {
+      return {
+        isValid: false,
+        error: "默认值必须是有效的数字"
+      };
+    }
+    return { isValid: true };
+  }
+  return {
+    isValid: false,
+    error: "默认值必须是有效的数字"
+  };
+};
+var validateBoolean = (value) => {
+  if (value === null || value === void 0 || value === "") {
+    return { isValid: true };
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim().toLowerCase();
+    if (trimmed === "") {
+      return { isValid: true };
+    }
+    if (trimmed !== "true" && trimmed !== "false") {
+      return {
+        isValid: false,
+        error: "默认值必须是 true 或 false"
+      };
+    }
+    return { isValid: true };
+  }
+  if (typeof value === "boolean") {
+    return { isValid: true };
+  }
+  return {
+    isValid: false,
+    error: "默认值必须是 true 或 false"
+  };
+};
+var validateArray = (value) => {
+  if (value === null || value === void 0 || value === "") {
+    return { isValid: true };
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed === "") {
+      return { isValid: true };
+    }
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (typeof parsed !== "object" || parsed === null) {
+        return {
+          isValid: false,
+          error: "默认值必须是有效的JSON对象或数组"
+        };
+      }
+      return { isValid: true };
+    } catch (error) {
+      return {
+        isValid: false,
+        error: "默认值必须是有效的JSON对象或数组"
+      };
+    }
+  }
+  if (typeof value === "object" && value !== null) {
+    return { isValid: true };
+  }
+  return {
+    isValid: false,
+    error: "默认值必须是有效的JSON对象或数组"
+  };
+};
+var validateDefaultValue = (fieldType, defaultValue) => {
+  if (!fieldType) {
+    return {
+      isValid: false,
+      error: "字段类型不能为空"
+    };
+  }
+  switch (fieldType.toLowerCase()) {
+    case "string":
+      return validateString(defaultValue);
+    case "integer":
+      return validateInteger(defaultValue);
+    case "float":
+      return validateFloat(defaultValue);
+    case "boolean":
+      return validateBoolean(defaultValue);
+    case "array":
+      return validateArray(defaultValue);
+    default:
+      return {
+        isValid: false,
+        error: `不支持的字段类型: ${fieldType}`
+      };
+  }
+};
+var parseDefaultValue = (fieldType, defaultValue) => {
+  if (defaultValue === null || defaultValue === void 0 || defaultValue === "") {
+    return null;
+  }
+  switch (fieldType.toLowerCase()) {
+    case "string":
+      return String(defaultValue);
+    case "integer":
+      if (typeof defaultValue === "string") {
+        const trimmed = defaultValue.trim();
+        if (trimmed === "") return null;
+        return parseInt(trimmed, 10);
+      }
+      return defaultValue;
+    case "float":
+      if (typeof defaultValue === "string") {
+        const trimmed = defaultValue.trim();
+        if (trimmed === "") return null;
+        return parseFloat(trimmed);
+      }
+      return defaultValue;
+    case "boolean":
+      if (typeof defaultValue === "string") {
+        const trimmed = defaultValue.trim().toLowerCase();
+        if (trimmed === "") return null;
+        return trimmed === "true";
+      }
+      return Boolean(defaultValue);
+    case "array":
+      if (typeof defaultValue === "string") {
+        const trimmed = defaultValue.trim();
+        if (trimmed === "") return null;
+        return JSON.parse(trimmed);
+      }
+      return defaultValue;
+    default:
+      return defaultValue;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseDefaultValue,
+  validateDefaultValue
+});

package/lib/components/systemSettings/registry/utils/validators.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 验证器工具函数
+ */
+/**
+ * 创建带前缀的应用标识符验证器
+ * 用于验证设置项的键格式
+ */
+export declare const createPrefixedAppIdentifierValidator: (sectionCode: string) => (_: any, value: string) => Promise<void>;