// 删除指定模块的缓存
delete require.cache[moduleName];

// 删除所有模块的缓存
Object.keys(require.cache).forEach(function(key) {
  delete require.cache[key];
})

define(id?, dependencies?, factory)

require([dependence], callback)

(function (global, factory) {
// CommonJS 规范
    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : 

// AMD规范
    typeof define === 'function' && define.amd ? define(factory) :
    (global = global || self, global.myBundle = factory());
}(this, (function () { 
    const main = () => {
        return 'hello world';
    };

    return main;
})))

sequelize: {
    enable: true, // 启用插件，false 表示禁用此插件
    package: 'egg-sequelize',
},

// sequelize 配置
config.equelize = {
  dialect: 'mysql',
  host: '127.0.0.1', // 连接的数据库主机地址
  port: 3306, // mysql服务端口
  database: 'demo', // 数据库名
  username: 'root',  // 数据库用户名
  password: 'root', // 数据库密码
  define: {  // model的全局配置
    freezeTableName: true,  // 防止修改表名为复数
    underscored: true,  // 自动转换字段为snake_case版本
    timestamps: false,   // 取消时间戳
    // paranoid: true,   // 偏执表
  },
  timezone: '+8:00',  // 由于 ORM 用的UTC时间，这里必须加上东八区，否则取出来的时间相差8小时
  dialectOptions: {  // 让读取 date 类型数据时返回字符串而不是UTC时间
    dateStrings: true,
    typeCast(field, next) {
      if (field.type === "DATETIME") {
        return field.string();
      }
      return next();
    }
  },
  // 连接池
  pool: {
    max: 5,
    min: 0,
    acquire: 30000,
    idle: 10000
  }
};

// app/modal/student.js

module.exports = app => {
  const { STRING, INTEGER } = app.Sequelize;

  const Student = app.model.define('student', {
    id: {
      type: INTEGER,
      autoIncrement: true,
      primaryKey: true,
      comment: '学生ID： 主键 + 自增',
    },
    number: {
      type: STRING(11),
      allowNull: false,
      comment: '学号： 非空',
    },
    password: {
      type: STRING(32),
      allowNull: false,
      comment: '密码： 非空',
    },
    classId: {
      type: INTEGER(11),
      foreignKey: true,
      comment: '课程ID： 课程表外键',
    }
  });
  return Student;
}

Sequelize.STRING                      // VARCHAR(255)
Sequelize.STRING(1234)                // VARCHAR(1234)
Sequelize.STRING.BINARY               // VARCHAR BINARY
Sequelize.TEXT                        // TEXT
Sequelize.TEXT('tiny')                // TINYTEXT

Sequelize.INTEGER                     // INTEGER
Sequelize.BIGINT                      // BIGINT
Sequelize.BIGINT(11)                  // BIGINT(11)

Sequelize.FLOAT                       // FLOAT
Sequelize.FLOAT(11)                   // FLOAT(11)
Sequelize.FLOAT(11, 12)               // FLOAT(11,12)

Sequelize.DOUBLE                      // DOUBLE
Sequelize.DOUBLE(11)                  // DOUBLE(11)
Sequelize.DOUBLE(11, 12)              // DOUBLE(11,12)

Sequelize.DECIMAL                     // DECIMAL
Sequelize.DECIMAL(10, 2)              // DECIMAL(10,2)

Sequelize.DATE                        // DATETIME 针对 mysql / sqlite, TIMESTAMP WITH TIME ZONE 针对 postgres
Sequelize.DATE(6)                     // DATETIME(6) 针对 mysql 5.6.4+. 小数秒支持多达6位精度
Sequelize.DATEONLY                    // DATE 不带时间.
Sequelize.BOOLEAN                     // TINYINT(1)

// 模糊查询序号/姓名
Student.findAll({
  where: {
    [Sequelize.Op.or]: [
      {
        // 姓名的模糊查询
        name: {
          [Sequelize.Op.like]: "%" + keyword + "%"
        }
      },
      {
        // 学号的模糊查询
        number: {
          [Sequelize.Op.like]: "%" + keyword + "%"
        }
      }
    ]
  }
});

config.sequelize = {
  // 使用默认运算符别名
  operatorsAliases:{
    $eq: Op.eq,
    $ne: Op.ne,
    $gte: Op.gte,
    $gt: Op.gt,
    $lte: Op.lte,
    $lt: Op.lt,
    $not: Op.not,
    $in: Op.in,
    $notIn: Op.notIn,
    $is: Op.is,
    $like: Op.like,
    $notLike: Op.notLike,
    $iLike: Op.iLike,
    $notILike: Op.notILike,
    $regexp: Op.regexp,
    $notRegexp: Op.notRegexp,
    $iRegexp: Op.iRegexp,
    $notIRegexp: Op.notIRegexp,
    $between: Op.between,
    $notBetween: Op.notBetween,
    $overlap: Op.overlap,
    $contains: Op.contains,
    $contained: Op.contained,
    $adjacent: Op.adjacent,
    $strictLeft: Op.strictLeft,
    $strictRight: Op.strictRight,
    $noExtendRight: Op.noExtendRight,
    $noExtendLeft: Op.noExtendLeft,
    $and: Op.and,
    $or: Op.or,
    $any: Op.any,
    $all: Op.all,
    $values: Op.values,
    $col: Op.col
  },
  // 其他配置
}

// 获取查询参数
const { pageIndex, pageSize } = ctx.request.query

Student.findAndCountAll({
  offset: (pageIndex - 1) * pageSize, // offet 去掉前多少个数据
  limit: pageSize, // limit 每页数据数量
}).then(res => {
// 查询结果
  return {
    data: res.rows,
    total: res.count,
  }
});

Student.findAndCountAll({
  order: [
	  // 多添加排序，在下面新增条件即可
	  ['id', 'DESC'], // ASC 升序 DESC 降序
	]
})

module.exports = app => {
  const { INTEGER } = app.Sequelize;

  const Student = app.model.define('student', {
    // 	1、修改表字段
    headerTeacherId: {
      type: INTEGER(11),
      foreignKey: true,
      comment: '班主任ID',
    }
  });

// 2、声明关联关系，一对一关系，即一个学生只有一个班主任，其他还有 一对多、多对多关系 
  app.model.Student.hasOne(app.model.Teacher, {
    foreignKey: 'headerTeacherId', // 外键约束
    as: 'headerTeacher', // 别名
  });
  return Student;
}

Student.findByPk(id, {
  include: [
    // 联表查询，
    {
      model: model.Teacher,
      as: "headerTeacher", // 注意这里的别名一定要和 model 中的别名一样 
    }
  ]
})

// 创建单条记录
Student.create({
  number,
  password,
  classId,
  headerTeacherId,
})

// 批量创建记录
Student.bulkCreate([
  {
    number,
    password,
    classId,
    headerTeacherId,
  },
  // 其他数据
])

const Student = sequelize.define('student', {
  // 其他操作
  password: {
    type: DataTypes.STRING,
    get() {
      // 按照指定格式返回数据，一般用于虚拟字段
      const rawValue = this.getDataValue(username);
      return rawValue ? rawValue.toUpperCase() : null;
    },
    set(value) {
      // 按照预定义规则配置数据
      this.setDataValue('password', hash(value));
    }
  },
});

Student.bulkCreate(vualueArray,
	{
	
		// updateOnDuplicate 表示在插入的时候如果行键（主键）已存在，则更新那些字段
		updateOnDuplicate: ['password', 'headerTeacherId'],
	}
)

// 1、查询数据
const student = await model.Student.findByPk(1)

if (student) {
  // 2、设置字段值
  student.set('password', newPassword)

  // 3 更新到数据库
  student.save()
}

// 表的关联
Student.associate = () => {
  // 以学生为源表，信息表为目标表，使用 hasOne 表示一个学生有一条信息
  app.model.Student.hasOne(app.model.Info,
    {
      foreignKey: "infoId",
      as: "info", // 别名
    }
  )
};

// 表的关联
Info.associate = () => {
  // 以信息为源表，学生表为目标表，使用 belongsTo 表示一条信息属于一个学生
  app.model.Info.belongsTo(app.model.Student,
    {
      foreignKey: "student_id",
      as: "student", // 别名
    }
  )
}

Student.findByPk(id, {
	include: [
		{
			model: model.Info,
			as: "info", // 必须和associate中的名称一样
			attributes: ["name", "mobile"], // 过滤需要的属性
		}
	]
}

Info.findByPk(id, {
  include: [
    {
      model: model.Student,
      as: "student", // 必须和associate中的名称一样
      attributes: ["name", "mobile"], // 过滤需要的属性
    }
  ]
}

// 表的关联
Class.associate = () => {
  // 以班级表为源，学生表为目标，使用 hasMany 表示一个班级有多个学生
  app.model.Class.hasMany(app.model.Student,
    {
      foreignKey: "student_id",
      as: "student", // 别名
    }
  )
}

// 表的关联
Student.associate = () => {
  // 以学生表为源表，班级表为目标表，使用 belongsTo 表示一个学生属于某个班级
  app.model.Student.belongsTo(app.model.Class,
    {
      foreignKey: "classId",
      as: "class", // 别名
    }
  )
};

// 表的关联
Student.associate = () => {
  // 查询当前学生有哪些课程
  app.model.Student.hasMany(app.model.Lesson,
    {
      through: app.model.StudentLesson, // 通过中间表关联查询
      foreignKey: "student_id", // StudentLesson 对 Student 表的外键
      otherKey: 'lesson_id', // StudentLesson 对 Lesson 表的外键，也可以不用声明，会自动匹配
      as: "lessons", // 别名
    }
  )

  // 或者

  // 查询当前课程有哪些学生
  app.model.Lesson.belongsToMany(app.model.Student,
    {
      through: app.model.StudentLesson, // 通过中间表关联查询 
      foreignKey: "lesson_id", // StudentLesson 对 Lesson 表的外键
      otherKey: 'student_id', // StudentLesson 对 Student 表的外键，也可以不用声明，会自动匹配
      as: "students", // 别名
    }
  )
}

module.exports = app => {
  const { INTEGER, DATE, NOW } = app.Sequelize;
  
  const Student = app.model.define('student', {
      id: {
        type: INTEGER,
        autoIncrement: true,
        primaryKey: true,
        comment: '学生ID： 主键 + 自增',
      },
      // 其他
      gmtCreate: {
        type: DATE,
        default: NOW,
        comment: "创建时间"
      },
      gmtModified: {
        type: DATE,
        comment: "修改时间"
      },
      gmtDelete: {
        type: DATE,
        comment: "删除标识",
        description: '当值非空时，则表示被删除'
      }
    },
    {
      paranoid: true, // 偏执表，用于软删除
      timestamps: true, // 启用时间戳

      // 重命名时间戳字段
      createdAt: "gmtCreate",
      updatedAt: "gmtModified",
      deletedAt: "gmtDelete"
    }
  );
  return Student;
};

let transaction;
try {
  // 创建事务
  transaction = await model.transaction();
  // 处理业务流程

  // 步骤一：新增教师记录
  const { dataValues: teacher } = await model.Teacher.create(rest, {
    transaction
  });

  // 步骤二：新增教授的课程列表：毛概、历史等课程
  await model.Lesson.bulkCreate(
    lessons.map(lesson => ({ ...lesson, teacherId: teacher.id })),
    {
      transaction
    }
  );

  //  步骤三：新增教授的班级
  await model.Class.create(
    { ...class, teacherId: teacher.id },
    { transaction }
  );

  // 事物提交
  await transaction.commit();
  return project;
} catch (error) {
  // 异常：事务回滚
  await transaction.rollback();
  throw error;
}

// 对象类型
interface User {
    name: string
    age: number
}

// 函数类型
interface SetUser {
    (name: string, age: number):  void;
}

// 类类型接口
interface ClockInterface {
  currentTime: Date;
  setTime(d: Date);
}

// 接口实现
class Clock implements ClockInterface {
  currentTime: Date;
  setTime(d: Date) {
      this.currentTime = d;
  }
  constructor(h: number, m: number) { }
}

interface Cat {
    eat: string;
}

interface Dog {
    pull: string;
}

// 类型继承
interface Zoom extends Cat, Dog {
    play: string;
}

const zoom: Zoom = {
    eat: '疯狂吃',
    pull: '疯狂拉',
    play: '疯狂撸'
}

// 基本类型别名
type IString = string; 

const name1: IString = '张三';
const name2: string = '李四';

// 对象类型
type User = {
    name: string
    age: number
}

// 函数类型
type SetUser = (name: string, age: number) => void;

// 对象类型
interface User {
    name: string
    age: number
}

// 函数类型
interface SetUser {
    (name: string, age: number):  void;
}

const user: User = {
    name: '张三',
    age: 24
}

let setUser: SetUser;

setUser = (name: string, age: number) => {
    console.log('SetUser:', name, age)
}

setUser('10', 10);

// 对象类型
type User = {
    name: string
    age: number
}

// 类型继承: 用以扩展字段
type Teacher = User & {
    education: string, // 学历
 }

// 声明变量
const teacher: Teacher = {
    name: '张三',
    age: 24,
    education: '本科'
}

// 对象类型
interface User {
    name: string
    age: number
}

// 类型继承 用以扩展字段
interface Teacher extends User {
    education: string, // 学历
 }

// 声明变量
const teacher: Teacher = {
    name: '张三',
    age: 24,
    education: '本科'
}

interface User {
    name: string
    age: number
}

// type extends interface
type Teacher = User & {
    education: string, // 学历
}

type User = {
    name: string
    age: number
}

// interface extends type
interface Teacher extends User {
    education: string, // 学历
}

/**
 * 清理对象参数值，过滤不合法参数
 * @params {object} params - 待清理的对象
 * @params {array} filters - 清理的值信息，默认当值为[null, undefined, NaN, '']中的任意值时，该字段被清理掉
 * @returns {object} 清理之后的对象
 */
export default function clearObject(
  params,
  filters = [null, undefined, NaN, '']
) {
  if (params instanceof Object) {
    const newParams = {}
    Object.keys(params).forEach(key => {
      if (!filters.includes(params[key])) {
        newParams[key] = params[key]
      }
    })
    return newParams
  }
  return params
}

/**
 * 时间格式化
 * @params {number} start - 开始时间戳，毫秒级
 * @params {number} end - 结束时间戳，毫秒级
 * @params {object} config - 格式化配置项
 *  @param {string} format - 转换格式，默认格式是YYYY-MM-DD HH:mm
 *  @param {string} separator - 分割字符串，默认是'-'
 * @returns {string}
 *
 * @example
 * fixDateRequestParams(1554790648037) ==> 2019-04-09 00:00
 *
 * @example
 * fixDateRequestParams(1554790648037, 1554790648037) ==> 2019-04-09 00:00 - 2019-04-09 00:00
 *
 * @example
 * fixDateRequestParams(1554790648037, 1554790648037, format = 'YYYY-MM-DD') ==> 2019-04 - 09-2019-04-09
 *
 * @example
 * fixDateRequestParams(1554790648037, 1554790648037,  format = 'YYYY-MM-DD', separator = '/' )  ==> 2019-0409/2019-04-09
 */
export default function formatDate (
  start,
  end,
  format = 'YYYY-MM-DD HH:mm',
  separator  = '-'
) {
  if ((start && !isNaN(start)) && (end && !isNaN(end))) {
    const startTime = moment(start).format(format)
    const endTime = moment(end).format(format)
    return `${startTime} ${separator} ${endTime}`
  }

  if (start && !isNaN(start)) {
    return moment(start).format(format)
  }

  if (end && !isNaN(end)) {
    return moment(end).format(format)
  }

  return ''
}

import moment from 'moment';
/**
 * 时间区间格式化
 * @param {number} date - 时间戳（毫秒级）
 * @returns {object}
 *  start 日起开始时间: YYYY-MM-DD 00:00:00
 *  end 日起结束时间: YYYY-MM-DD 23:59:59
 * 
 * @example
 * formatDateSpace(1554790648037) 
 * ==> 
 * {
 *  start: '2019-04-09 00:00:00',
 *  start: '2019-04-09 23:59:59' 
 * }
 */
export default function formatDateSpace(date) {
  if (date && !isNaN(date)) {
    return {
      start: `${moment(date).format('YYYY-MM-DD')} 00:00:00`,
      end: `${moment(date).format('YYYY-MM-DD')} 23:59:59`
    }
  }
  return {}
}

/**
 * 匹配枚举字段值
 * @param {number} key -  某状态/类型对应的type值
 * @param {array} source  -  所有状态/类型
 * @param {string} keyName -  匹配key字段名，默认是'label'
 * @param {string} valueName  -  匹配value字段名，默认是'value'
 * @return {string}  -  该key值对应的状态/类型，匹配失败'-'
 *
 * @example
 * const source = [
 *  {
 *    label: 1
 *    value:'例子1'
 *  },{
 *    label: 2
 *    value:'例子2'
 *  },
 * ]
 * matchRelevantValue(1, source) === '例子1'
 */
export default function formatMatchValue(key, source = [], keyName = 'label', valueName = 'value') {
  const item = source.find(item => item[`${keyName}`] === key)
  if (item) {
    return item[`${valueName}`] || '-'
  } else {
    return '-'
  }
}

/**
 * 数字格式化为千分位
 * @param {number} targetNumber -  数值
 * @param {number} fractionDigits -  保留小数位数
 * @returns {*}
 * @example
 * formatThousandsSeparator(1000) === 1,000
 * @example
 * formatThousandsSeparator(1000,2) === 1,000.00
 */
export default function formatThousandsSeparator(targetNumber, fractionDigits) {
  if (!targetNumber && targetNumber !== 0) {
    return '';
  }

  if (targetNumber === 0) {
    return 0;
  }

  let minus = false;
  /**
       * 兼容负数
       */
  if (targetNumber < 0) {
    minus = true;
    targetNumber = Math.abs(targetNumber);
  }
  fractionDigits = fractionDigits >= 0 && fractionDigits <= 20 ? fractionDigits : 2;
  /**
     * replace(/[^\d\.-]/g, '')
     * 匹配 除数字、逗号（,）、短横线（ - 负数符号）之外的字符串,替换成''
     * eq: 'a123'.replace(/[^\d\.-]/g, '') === 123
     * eq: 'a123bc'.replace(/[^\d\.-]/g, '0') === 012300
     * eq: 'a123-'.replace(/[^\d\.-]/g, '0') === 0123-
     */
  targetNumber = `${parseFloat((`${targetNumber}`).replace(/[^\d\.-]/g, '')).toFixed(fractionDigits)}`;
  const reversedSplitNumber = targetNumber.split('.')[0].split('').reverse();
  // 小数位
  const decimalPlace = targetNumber.split('.')[1];
  let reversedString = '';
  for (let i = 0; i < reversedSplitNumber.length; i += 1) {
    reversedString += reversedSplitNumber[i] + ((i + 1) % 3 === 0 && (i + 1) !== reversedSplitNumber.length ? ',' : '');
  }
  /**
       * 兼容负数和整数
       */
  return `${minus ? '-' : ''}${reversedString.split('').reverse().join('')}${decimalPlace ? `.${decimalPlace}` : ''}`;
}

import NP from 'number-precision'
import formatThousandsSeparator from './formatThousandsSeparator'
/**
 * 金额格式化转换
 *  元转分
 *  分转元（默认千分位格式化，并保留2位小数）
 * @param {number} money - 金额(元/分)
 * @param {string} mode - 模式：'toYuan'（分->元）'toCent'（元->分），默认是 'toYuan'
 * @params {object} config 转换配置项
 *    @param {boolean} thousandsSeparator -  是否需要格式化成千分位,默认为true
 *    @param {number} fractionDigits  - 保留小数位数,默认为2
 *    @param {string} illegalCharacter  - 非法数据是展示的字符
 *
 * @returns {*} 转换之后的金额
 *
 * @example
 * formatCentToYuan(100000) === 1,000.00
 */
export default function formatMoney(money, mode = 'toYuan', config = {}) {
  const { thousandsSeparator = true, fractionDigits = 2, illegalCharacter = '-'} = config

  if (!money || isNaN(money)) {
    return illegalCharacter
  }

  switch (mode) {
    case 'toYuan': {
      const yuan = NP.round(NP.divide(money, 100), fractionDigits)
      if (!thousandsSeparator) {
        return yuan
      }
      return formatThousandsSeparator(yuan, fractionDigits)
    }
    case 'toCent': {
      return NP.round(NP.times(money, 100), 0)
    }
    default:
      return illegalCharacter
  }
}

{
    "type": "object",
    "properties": {
        ...schema // 导入的schema配置
    }
}

() => {
    const schema = {
        orgName: {
          type: 'string',
          title: '企业名称/编码'
    }
    
    const onSearch = (params) => {
       // 根据条件搜索数据
    }
    
    return (
        <Search
            schema={schema}
            onSearch={onSearch}
        />
    )
}

import { useState } from 'react'

/**
 * useList hook，用于Table、有搜索栏的Table数据搜索
 *
 * @param {string} url 请求地址
 * @param {object} initialParams 初始化参数，初始化时需要有搜索参数，并且在后续搜索中可以被修改的参数
 * @param {object} staticParams 静态参数，每次搜索都固定不变的参数
 * */
export default (url, initialParams = {}, staticParams = {}) => {
  const [params, setParams] = useState(initialParams)
  const [dataSource, setDataSource] = useState([])

  const [pagination, setPagination] = useState({
    current: 1,
    pageSize: 10,
    total: 0,
    showQuickJumper: true,
    showTotal: total => `共${total}条`
  })

  /*
   * 查询列表信息：
   *  1 刷新时，分页器不变，搜索参数不变
   *  2 查询时，分页器清零，搜索参数改变
   * */
  const onFetch = (_pagination = pagination, _params = params) => {
    const { current: currentPage, pageSize } = _pagination

    const data = {
      pageIndex: currentPage,
      pageNo: currentPage,
      pageSize,
      ..._params,
      ...staticParams
    }
    
    
    /**
     * 向后端发送请求列表数据的方法根据项目实际自定义实现，主要
     * 是针对不同项目请求方式的不同做兼容处理
     
     * 注意：这里的请求没有写死，主要是因为很多项目中的请求方式不一样，使用时可以拷贝自行替换
     * */
    http.get(url, {
      pageIndex: currentPage,
      pageNo: currentPage,
      pageSize,
      ..._params,
      ...staticParams
    }).then((res) => {
      const { rows = [], total } = res.data || {}
      setDataSource(rows)
      setParams(_params)
      setPagination({
        ..._pagination,
        total,
        current: currentPage
      })
    })
  }

  /**
   * 参数查询列表信息
   * */
  const onSearch = (_params) => {
    onFetch({ ...pagination,  current: 1}, _params)
  }

  /**
   * 分页查询列表信息
   * */
  const onChange = (_pagination) => {
    onFetch(_pagination)
  }

  return {
    params,
    onSearch,
    onFetch,
    // table所需要的值
    table: {
      pagination,
      dataSource,
      onChange,
    },
  }
}

() => {
  const list = useList('serviceOrder/list')
  
  const onSearch = (params) => {
      list.onSearch(params)
  }
  
  useEffect(() => {
      list.onFetch() // 搜索数据
  }, [])
  
  // 有时候需要列表搜索的参数，可以取值 list.params
  
  const columns = [/** Table列表项 **/]
  
  return (
      <Table
        columns={columns}
        {...list.table}
      />
  )
}

import React from 'react'
import { Table} from 'antd'

import useList from './use-list'

export default (url, initialParams = {}, staticParams = {}) => {
  const list = useList(url, initialParams, staticParams)

  const XmTable = (props) => {
    const { rowKey = 'id', columns = [], ...rest } = props

    return  (
      <Table
        rowKey={rowKey}
        columns={columns}
        {...list.table}
        {...rest}
      />
    )
  }

  return {
    table: list,
    XmTable
  }
}

() => {
  const { table, XmTable } = useTable('serviceOrder/list')
  
  const onSearch = (params) => {
      table.onSearch(params)
  }
  
  useEffect(() => {
      table.onFetch() // 搜索数据
  }, [])
  
  // 有时候需要列表搜索的参数，可以取值 table.params
  
  const columns = [/** Table列表项 **/]
  
  return (
      <XmTable
        columns={columns}
      />
  )
}

import React, {useState, Fragment, useEffect} from 'react'

import useTable from './use-table'
import Search from "../Search"

export default (url, initialParams = {}, staticParams = {}) => {
  const [ initialValues, setInitialValues ] = useState(initialParams)
  const { table, XmTable } = useTable(url, initialParams, staticParams)

  const SearchTable = (props) => {
    const { schema, columns = [], onSearch, ...rest } = props
    
    const handleSearch = (params = initialParams) => {
      setInitialValues(params)
      table.onSearch(typeof onSearch === 'function' ? onSearch(params) : params)
    }
    
    return (
      <Fragment>
        <div className="app-page__card">
          <Search
            schema={schema}
            onSearch={handleSearch}
            initialValues={initialValues}
          />
        </div>
        <div className="app-page__card">
          <XmTable
            columns={columns}
            {...rest}
          />
        </div>
      </Fragment>
    )
  }

  useEffect(() => {
    table.onSearch(initialParams)
  }, [])

  return {
    table,
    SearchTable,
  }
}

() => {
  const { table, SearchTable } = useSearchTable('serviceOrder/list')
 
  // 有时候需要列表搜索的参数，可以取值 table.params

  const schema = { /** Search搜索项 **/ }
  const columns = [/** Table列表项 **/]

  return (
    <SearchTable
        schema={schema}
        columns={columns}
    />
  )
}

import { useState, useCallback } from 'react'
/**
 * 自定义 hook：用于弹出框的打开与关闭控制
 *
 * @param {boolean} initVisible 初始化modal的显示状态
 */
export default (initVisible = false) => {
  const [params, setParams] = useState()
  const [visible, setVisible] = useState(initVisible)

  const open = useCallback((_params) => {
    setParams(_params)
    setVisible(true)
  }, [])

  const close = useCallback(() => {
    setParams()
    setVisible(false)
  }, [])

  return {
    params,
    visible,
    open,
    close,
  }
}

() => {
  const editModal = useVisible()
  
  const opem = (orderId) => {
      // open 传递的参数
      editModal.open(orderId)
  }
  
  return (
  {
        editModal.visible && (
          <EditModal
            orderId={editModal.params}
            onCancel={editModal.close}
            onOk={() => {
              editModal.close()
              table.onFetch()
            }}
          />
        )
      }
  )
}

<SchemaForm>
    <Field type="Object" name="aaa">
       <Field type="string" name="bbb"/>
       <Field type="array" name="ccc">
          <Field type="object">
              <Field type="string" name="ddd"/>
           </Field> 
       </Field>
    </Field>
</SchemaForm>

const schema = {
   "type":"object",
    "properties":{
        "aaa":{
            "type":"object",
            "properties":{
                "bbb":{
                    "type":"string"
                },
                "ccc":{
                    "type":"array",
                    "items":{
                        "type":"object",
                        "properties":{
                            "ddd":{
                                "type":"string"
                            }
                        }
                    }
                }
            }
        }
    }
}

<SchemaForm schema={schema} />

<FormBlock title="办理配置" name="handleConfig">
    <Field
        required={required}
        editable={editable}
        title="目标客户"
        name="targetCustomer"
        type="string"
        description={useCount > 0 && `共计${useCount}人`}
        enum={targetCustomerOptions}
        x-props={{
          placeholder: '请输入',
          mode: 'multiple',
          showSearch: true,
          style: {width: 400},
          optionFilterProp: 'label',
          getPopupContainer: node => node.parentNode,
        }}
      />
      <Field
        required={required}
        editable={editable}
        title="用户办理方式"
        name="handleWay"
        type="radio"
        enum={HANDLE_METHOD}
      />
      <Field
        required={required}
        editable={editable}
        title="小程序办理"
        name="apps"
        type="switch-field"
        x-props={{
          message: '开启后可在小程序办理',
        }}
      />
      <Field
        required={required}
        editable={editable}
        title="关联渠道"
        name="channel"
        type="string"
        enum={channelOptions}
        x-props={{
          style: {width: 600},
          placeholder: '请输入',
          showSearch: true,
          showArrow: false,
          optionFilterProp: 'label',
          getPopupContainer: node => node.parentNode,
        }}
      />
    </FormBlock>