import type { CrudSchema } from '@/hooks/web/useCrudSchemas'
import { dateFormatter } from '@/utils/formatTime'
import { validateTwoNum } from "@/utils/validator";
/**
 * @returns {Array} 基础物料信息
 */
export const ItemBasic = useCrudSchemas(reactive<CrudSchema[]>([
  { 
    label: '代码', 
    field: 'code',
    sort: 'custom',
    table: {
      width: 150
    },
    tableForm:{
      minWidth:200,
       sortable:false
    }
  },
  { 
    label: '名称', 
    field: 'name',
    sort: 'custom',
    table: {
      width: 150
    },
    tableForm:{
      minWidth:200,
       sortable:false
    }
  },
  { 
    label: '描述1', 
    field: 'desc1',
    sort: 'custom',
    table: {
      width: 150
    } ,
    isTableForm:false
  },
  { 
    label: '描述2', 
    field: 'desc2',
    sort: 'custom',
    table: {
      width: 150
    } ,
    isTableForm:false
  },
  {
    label: '状态',
    field: 'status',
    sort: 'custom',
    dictType: DICT_TYPE.ITEM_STATUS,
    dictClass: 'string',
    isForm: true,
    isSearch: true,
    isTable: true,
    table: {
      width: 100
    } ,
    form: {
      component: 'Switch',
    },
     tableForm:{
     width: 100,
      type:'Switch',
    }
  },
  {
    label: '计量单位',
    field: 'uom',
    sort: 'custom',
    dictType: DICT_TYPE.UOM,
    dictClass: 'string',
    isSearch: true,
    isTable: true,
    table: {
      width: 120
    } ,
     tableForm:{
     width: 200,
      type:'Select',
    }
  },
  {
    label: '替代计量单位',
    field: 'altUom',
    sort: 'custom',
    dictType: DICT_TYPE.UOM,
    dictClass: 'string',
    isSearch: true,
    isTable: true,
    table: {
      width: 150
    } ,
    isTableForm:false
  },
  {
    label: '是否标包',
    field: 'isStdPack',
    sort: 'custom',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true,
    table: {
      width: 120
    },
    form: {
      component: 'Switch',
    },
    tableForm:{
      width: 180,
      type:'Radio',
    }
  },
  {
    label: '可采购',
    field: 'enableBuy',
    sort: 'custom',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true,
    table: {
      width: 100
    },
    form: {
      component: 'Radio',
    },
    isTableForm:false
  },
  {
    label: '可制造',
    field: 'enableMake',
    sort: 'custom',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true,
    table: {
      width: 100
    } ,
    form: {
      component: 'Radio',
    },
    tableForm:{
      width: 180,
      type:'Checkbox',
    }
  },
  {
    label: '可委外加工',
    field: 'enableOutsourcing',
    sort: 'custom',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true,
    table: {
      width: 120
    } ,
    form: {
      component: 'Radio',
    },
    isTableForm:false
  },
  {
    label: '回收件',
    field: 'isRecycled',
    sort: 'custom',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true,
    table: {
      width: 100
    },
    form: {
      component: 'Radio',
    },
    isTableForm:false
  },
  {
    label: '虚零件',
    field: 'isPhantom',
    sort: 'custom',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true,
    table: {
      width: 100
    } ,
    form: {
      component: 'Radio',
    },
    isTableForm:false
  },
  {
    label: 'ABC类',
    field: 'abcClass',
    sort: 'custom',
    dictType: DICT_TYPE.ABC_CLASS,
    dictClass: 'string',
    isSearch: true,
    isTable: true,
    table: {
      width: 100
    } ,
    isTableForm:false
  },
  {
    label: '类型',
    field: 'type',
    sort: 'custom',
    dictType: DICT_TYPE.ITEM_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true,
    table: {
      width: 100
    } ,
    isTableForm:false
  },
  {
    label: '种类',
    field: 'category',
    sort: 'custom',
    dictType: DICT_TYPE.ITEM_CATEGORY,
    dictClass: 'string',
    isSearch: true,
    isTable: true,
    table: {
      width: 100
    } ,
    isTableForm:false
  },
  {
    label: '分组',
    field: 'itemGroup',
    sort: 'custom',
    dictType: DICT_TYPE.ITEM_GROUP,
    dictClass: 'string',
    isSearch: true,
    isTable: true,
    table: {
      width: 100
    } ,
    isTableForm:false
  },
  {
    label: '颜色',
    field: 'color',
    sort: 'custom',
    dictType: DICT_TYPE.ITEM_COLOR,
    dictClass: 'string',
    isSearch: true,
    isTable: true,
    table: {
      width: 100
    } ,
    isTableForm:false
  },
  {
    label: '配置',
    field: 'configuration',
    sort: 'custom',
    dictType: DICT_TYPE.ITEM_CONFIGURATION,
    dictClass: 'string',
    isSearch: true,
    isTable: true,
    table: {
      width: 100
    } ,
    isTableForm:false
  },
  { 
    label: '项目', 
    field: 'project', 
    sort: 'custom',
    table: {
      width: 100
    } ,
    isTableForm:false
  },
  {
    label: '质量等级',
    field: 'eqLevel',
    sort: 'custom',
    dictType: DICT_TYPE.EQ_LEVEL,
    dictClass: 'string',
    isSearch: true,
    isTable: true,
    table: {
      width: 120
    } ,
    isTableForm:false
  },
  { 
    label: '有效天数', 
    field: 'validityDays', 
    sort: 'custom',
    table: {
      width: 120
    },
    form: {
      component: 'InputNumber',
    },
    isTableForm:false
  },
  {
    label: '是否可用',
    field: 'available',
    sort: 'custom',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true,
    table: {
      width: 120
    },
    form: {
      component: 'Radio',
    },
    isTableForm:false
  },
  {
    label: '生效时间',
    field: 'activeTime',
    sort: 'custom',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    },
    table: {
      width: 120
    } ,
    form: {
      component: 'DatePicker',
      componentProps: {
        type: 'datetimerange',
      }
    },
    tableForm:{
      width: 200,
      type:'FormDateTime',
    }
  },
  {
    label: '失效时间',
    field: 'expireTime',
    sort: 'custom',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    },
    table: {
      width: 120
    } ,
    form: {
      component: 'DatePicker',
      componentProps: {
        type: 'datetimerange',
      }
    },
    isTableForm:false
  },
  {
    label: '创建时间',
    field: 'createTime',
    sort: 'custom',
    isTable: true,
    formatter: dateFormatter,
    isForm: false,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    },
    table: {
      width: 120
    } ,
    isTableForm:false
  },
  { label: '备注', field: 'remark', sort: 'custom', isTable: false,isTableForm:false},
  { label: '创建者ID', field: 'creator', sort: 'custom', isTable: false, isForm: false,isTableForm:false },
  {
    label: '操作',
    field: 'action',
    isDetail: false,
    isForm: false ,
    table: {
      width: 150
    },
    isTableForm:false
  }
]))

// 表单校验
export const ItemBasicRules = reactive({
  code: [
    { required: true, message: '请输入代码', trigger: 'blur' }
  ],
  name:  [
    { required: true, message: '请输入名称', trigger: 'blur' }
  ],
  status: [
    { required: true, message: '请选择状态', trigger: 'change' }
  ],
  uom: [
    { required: true, message: '请选择计量单位', trigger: 'change' }
  ],
  altUom:  [
    { required: true, message: '请选择替代计量单位', trigger: 'change' }
  ],
  isStdPack:  [
    { required: true, message: '请选择是否标包', trigger: 'change' }
  ],
  enableBuy:  [
    { required: true, message: '请选择是否可采购', trigger: 'change' }
  ],
  enableMake:  [
    { required: true, message: '请选择是否可制造', trigger: 'change' }
  ],
  enableOutsourcing:  [
    { required: true, message: '请选择是否可委外加工', trigger: 'change' }
  ],
  isRecycled:  [
    { required: true, message: '请选择回收件', trigger: 'change' }
  ],
  isPhantom:  [
    { required: true, message: '请选择虚零件', trigger: 'change' }
  ],
  abcClass:  [
    { required: true, message: '请选择ABC类', trigger: 'change' }
  ],
  type:  [
    { required: true, message: '请选择类型', trigger: 'change' }
  ],
  category:  [
    { required: true, message: '请选择种类', trigger: 'change' }
  ],
  itemGroup:  [
    { required: true, message: '请选择分组', trigger: 'change' }
  ],
  color:  [
    { required: true, message: '请选择颜色', trigger: 'change' }
  ],
  configuration:  [
    { required: true, message: '请选择配置', trigger: 'change' }
  ],
  project:  [
    { required: true, message: '请输入项目', trigger: 'blur' }
  ],
  eqLevel:  [
    { required: true, message: '请选择质量等级', trigger: 'change' }
  ],
  validityDays:  [
    { required: true, message: '请输入有效天数', trigger: 'change' }
  ],
  available:  [
    { required: true, message: '请选择是否可用', trigger: 'change' }
  ],
  activeTime:  [
    { required: true, message: '请输入生效时间', trigger: 'change' }
  ],
  expireTime:  [
    { required: true, message: '请输入失效时间', trigger: 'change' }
  ],
})

/**
 * @returns {Array} 基础包装信息
 */
export const Itempackaging = useCrudSchemas(reactive<CrudSchema[]>([
  { 
    label: '物品代码', 
    field: 'itemCode',
    sort: 'custom',
    table: {
      width: 150
    } 
  },
  {
    label: '计量单位',
    field: 'uom',
    sort: 'custom',
    dictType: DICT_TYPE.UOM,
    dictClass: 'string',
    isSearch: true,
    isTable: true,
    table: {
      width: 120
    } 
  },
  {
    label: '包装单位',
    field: 'stdPackUnit',
    sort: 'custom',
    dictType: DICT_TYPE.PACK_UNIT,
    dictClass: 'string',
    isSearch: true,
    isTable: true,
    table: {
      width: 120
    } 
  },
  { 
    label: '包装数量', 
    field: 'stdPackQty',
    sort: 'custom',
    table: {
      width: 120
    } 
  },
  {
    label: '替代包装单位',
    field: 'altPackUnit1',
    sort: 'custom',
    dictType: DICT_TYPE.PACK_UNIT,
    dictClass: 'string',
    isSearch: true,
    isTable: true,
    table: {
      width: 150
    } 
  },
  { 
    label: '替代包装量', 
    field: 'altPackQty1',
    sort: 'custom',
    table: {
      width: 120
    } 
  },
  {
    label: '替代包装单位',
    field: 'altPackUnit1',
    sort: 'custom',
    dictType: DICT_TYPE.PACK_UNIT,
    dictClass: 'string',
    isSearch: true,
    isTable: true,
    table: {
      width: 150
    } 
  },
  { 
    label: '替代包装量', 
    field: 'altPackQty2',
    sort: 'custom',
    table: {
      width: 120
    } 
  },
  {
    label: '替代包装单位',
    field: 'altPackUnit3',
    sort: 'custom',
    dictType: DICT_TYPE.PACK_UNIT,
    dictClass: 'string',
    isSearch: true,
    isTable: true,
    table: {
      width: 150
    } 
  },
  { 
    label: '替代包装量', 
    field: 'altPackQty3',
    sort: 'custom',
    table: {
      width: 120
    } 
  },
  {
    label: '替代包装单位',
    field: 'altPackUnit4',
    sort: 'custom',
    dictType: DICT_TYPE.PACK_UNIT,
    dictClass: 'string',
    table: {
      width: 150
    } 
  },
  { 
    label: '替代包装量', 
    field: 'altPackQty4',
    sort: 'custom',
    table: {
      width: 120
    } 
  },
  {
    label: '是否可用',
    field: 'available',
    sort: 'custom',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    table: {
      width: 120
    } 
  },
  {
    label: '生效时间',
    field: 'activeTime',
    sort: 'custom',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    },
    table: {
      width: 120
    } 
  },
  {
    label: '失效时间',
    field: 'expireTime',
    sort: 'custom',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    },
    table: {
      width: 120
    } 
  },
  {
    label: '创建时间',
    field: 'createTime',
    sort: 'custom',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    },
    table: {
      width: 120
    } 
  },
  { 
    label: '创建者', 
    field: 'creator',
    sort: 'custom',
    table: {
      width: 120
    } 
  },
  {
    label: '操作',
    field: 'action',
    isDetail: false,
    table: {
      width: 150
    }
  }
]))

// 表单校验
export const ItempackagingRules = reactive({
  itemCode: [{ required: true, message: '物品代码不能为空', trigger: 'blur' }],
  uom: [{ required: true, message: '计量单位不能为空', trigger: 'change' }],
  stdPackUnit: [{ required: true, message: '包装单位不能为空', trigger: 'change' }],
  stdPackQty: [{ required: true, message: '包装数量不能为空', trigger: 'blur' }],
  available: [{ required: true, message: '是否可用不能为空', trigger: 'change' }]
})

/** 
 * @returns {Array} 基础物料清单
*/
export const Bom = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '父物料代码',
    field: 'productItemCode',
    table: {
      width: 150
    }
  },
  {
    label: '子物料代码',
    field: 'componentItemCode',
    table: {
      width: 150
    }
  },
  {
    label: '子物料计量单位',
    field: 'componentUom',
    dictType: DICT_TYPE.UOM,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '子物料数量',
    field: 'componentQty'
  },
  {
    label: '工序代码',
    field: 'processCode'
  },
  {
    label: '版本',
    field: 'version'
  },
  {
    label: '层级',
    field: 'layer'
  },
  {
    label: '是否可用',
    field : 'available',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string'
  },
  {
    label: '生效时间',
    field: 'activeTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '失效时间',
    field: 'expireTime',
    isTable: true,
    formatter : dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建时间',
    field: 'createTime',
    isTable: true,
    formatter: dateFormatter,
    isForm: false,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  { label: '备注', field: 'remark', isTable: false },
  { label: '创建者ID', field: 'creator', isTable: false, isForm: false },
  {
    label: '操作',
    field: 'action',
    isDetail: false,
    isForm: false ,
    table: {
      width: 150
    }
  }
]))

//表单校验
export const BomRules = reactive({
  productItemCode: [
    { required: true, message: '请输入父物料代码', trigger: 'blur' }
  ],
  componentItemCode: [
    { required: true, message: '请输入子物料代码', trigger: 'blur' }
  ],
  componentUom: [
    { required: true, message: '请选择子物料计量单位', trigger: 'change' }
  ],
  componentQty: [
    { required: true, message: '请输入子物料数量', trigger: 'blur' }
  ],
  processCode: [
    { required: true, message: '请输入工序代码', trigger: 'blur' }
  ],
  available:  [
    { required: true, message: '请选择是否可用', trigger: 'change' }
  ],
})

/**
 * @returns {Array} 基础标准成本价格单
 */
export const Stdcostprice = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '供应商代码',
    field: 'supplierCode',
    table: {
      width: 150
    }
  },
  {
    label: '物料代码',
    field: 'itemCode',
    table: {
      width: 150
    }
  },
  {
    label: '货币',
    field: 'currency',
    dictType: DICT_TYPE.CURRENCY,
    dictClass: 'string',
    isSearch : true,
    isTable : true
  },
  {
    label: '价格',
    field: 'price'
  },
  {
    label: '是否可用',
    field: 'available',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '生效时间',
    field: 'activeTime',
    isTable: true,
    formatter : dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '失效时间',
    field: 'expireTime',
    isTable: true,
    formatter : dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建者',
    field: 'creator'
  },
  {
    label: '创建时间',
    field: 'createTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '操作',
    field: 'action',
    isDetail: false,
    isForm: false ,
    table: {
      width: 150
    }
  }
]))

//表单校验
export const StdcostpriceRules = reactive({
  supplierCode: [
    { required: true, message: '请输入供应商代码', trigger: 'blur' }
  ],
  itemCode: [
    { required: true, message: '请输入物料代码', trigger: 'blur' }
  ],
  currency: [
    { required: true, message: '请选择货币', trigger: 'change' }
  ],
  price: [
    { required: true, message: '请输入价格', trigger: 'blur' }
  ],
  available:  [
    { required: true, message: '请选择是否可用', trigger: 'change' }
  ],
})

/**
 * @returns {Array} 生产线物料关系
 */
export const Productionlineitem = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '完工收货库位',
    field: 'fgLocationCode',
    table: {
      width: 150
    }
  },
  {
    label: '产线代码' ,
    field: 'productionLineCode',
    table: {
      width: 150
    }
  },
  {
    label: '物品代码',
    field: 'itemCode',
    table: {
      width: 150
    }
  },
  {
    label: '是否可用',
    field: 'available',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '生效时间',
    field: 'activeTime',
    formatter : dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '失效时间',
    field: 'expireTime',
    formatter : dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label:'备注',
    field: 'remark'
  },
  {
    label: '创建时间',
    field: 'createTime',
    formatter: dateFormatter,
    detail: {
      dateFormat : 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建者',
    field: 'creator'
  },
  {
    label: '操作',
    field: 'action',
    isDetail: false,
    isForm: false ,
    table: {
      width: 150
    }
  }
]))

//表单校验
export const ProductionlineitemRules = reactive({
  fgLocationCode: [
    { required: true, message: '请输入完工收货库位', trigger: 'blur' }
  ],
  productionLineCode: [
    { required: true, message: '请输入产线代码', trigger: 'blur' }
  ],
  itemCode: [
    { required: true, message: '请输入物品代码', trigger: 'blur' }
  ],
  available:  [
    { required: true, message: '请选择是否可用', trigger: 'change' }
  ],
})

/**
 * @returns {Array} 供应商
 */
export const Supplier = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '代码',
    field: 'code',
    table: {
      width: 150
    }
  },
  {
    label: '名称',
    field: 'name',
    table: {
      width: 150
    }
  },
  {
    label: '简称',
    field: 'shortName',
    table: {
      width: 150
    }
  },
  {
    label: '地址',
    field: 'address',
    table: {
      width: 150
    }
  },
  {
    label: '国家',
    field: 'country',
    table: {
      width: 150
    }
  },
  {
    label: '城市',
    field: 'city',
    table: {
      width: 150
    }
  },
  {
    label: '电话',
    field: 'phone',
    table: {
      width: 150
    }
  },
  {
    label: '传真',
    field: 'fax',
    table: {
      width: 150
    }
  },
  {
    label: '邮编',
    field: 'postId',
    table: {
      width: 150
    }
  },
  {
    label: '联系人',
    field: 'contacts',
    table: {
      width: 150
    }
  },
  {
    label:'银行',
    field: 'bank',
    table: {
      width: 150
    }
  },
  {
    label: '币种',
    field: 'currency',
    dictType: DICT_TYPE.CURRENCY,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '税率',
    field: 'taxRate'
  },
  {
    label: '类型',
    field: 'type',
    dictType: DICT_TYPE.SUPPLIER_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '是否可用',
    field: 'available',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '生效时间',
    field: 'activeTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '失效时间',
    field: 'expireTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建时间',
    field: 'createTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建者',
    field: 'creator'
  },
  {
    label: '操作',
    field: 'action',
    isDetail: false,
    isForm: false ,
    table: {
      width: 150
    }
  }
]))

//表单校验
export const SupplierRules = reactive({
  code: [
    { required: true, message: '请输入代码', trigger: 'blur' }
  ],
  shortName: [
    { required: true, message: '请输入简称', trigger: 'blur' }
  ],
  available:  [
    { required: true, message: '请选择是否可用', trigger: 'change' }
  ],
})

/**
 * @returns {Array} 供应商物品
 */
export const Supplieritem = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '供应商代码',
    field: 'supplierCode'
  },
  {
    label: '物料代码',
    field: 'itemCode'
  },
  {
    label: '供应商物料代码',
    field: 'supplierItemCode'
  },
  {
    label: '供应商计量单位',
    field: 'supplierUom',
    dictType: DICT_TYPE.UOM,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '转换率',
    field: 'convertRate'
  },
  {
    label: '供应商包装单位',
    field: 'packUnit',
    dictType: DICT_TYPE.PACK_UNIT,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '供应商包装量',
    field: 'packQty'
  },
  {
    label: '供应商替代包装单位',
    field: 'altPackUnit',
    dictType: DICT_TYPE.PACK_UNIT,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '供应商替代包装量',
    field: 'altPackQty'
  },
  {
    label: '每器具包装数',
    field: 'packQtyOfContainer'
  },
  {
    label: '默认收货仓库',
    field: 'defaultWarehouseCode'
  },
  {
    label: '默认收货库位',
    field: 'defaultLocationCode'
  },
  {
    label: '结算方式',
    field: 'settlementType',
    dictType: DICT_TYPE.SETTLEMENT_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '是否可用',
    field: 'available',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '生效时间',
    field: 'activeTime',
    formatter: dateFormatter,
    isTable: true,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '失效时间',
    field: 'expireTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建时间',
    field: 'createTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建者',
    field: 'creator',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '操作',
    field: 'action',
    isDetail: false,
    isForm: false ,
    table: {
      width: 150
    }
  }
]))

//表单校验
export const SupplieritemRules = reactive({
  supplierCode: [
    { required: true, message: '请输入供应商代码', trigger: 'blur' }
  ],
  itemCode: [
    { required: true, message: '请输入物料代码', trigger: 'blur' }
  ],
  packUnit: [
    { required: true, message: '请选择供应商包装单位', trigger: 'change' }
  ],
  packQty: [
    { required: true, message: '请输入供应商包装量', trigger: 'blur' }
  ],
  packQtyOfContainer: [
    { required: true, message: '请输入每器具包装数', trigger: 'blur' }
  ],
  available:  [
    { required: true, message: '请选择是否可用', trigger: 'change' }
  ],
})

/**
 * @returns {Array} 采购价格单
 */
export const Purchaseprice = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '供应商代码',
    field: 'supplierCode'
  },
  {
    label: '物料代码',
    field: 'itemCode'
  },
  {
    label: '货币',
    field: 'currency',
    dictType: DICT_TYPE.CURRENCY,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '价格',
    field: 'price'
  },
  {
    label: '是否可用',
    field: 'available',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '生效时间',
    field: 'activeTime',
    isTable: true,
    formatter: dateFormatter,
    details: {
      dateFormatter: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '失效时间',
    field: 'expireTime',
    isTable: true,
    formatter: dateFormatter,
    details: {
      dateFormatter: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建时间',
    field: 'createTime',
    isTable: true,
    formatter: dateFormatter,
    details: {
      dateFormatter: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建者',
    field: 'creator'
  },
  {
    label: '操作',
    field: 'action',
    isDetail: false,
    isForm: false ,
    table: {
      width: 150
    }
  }
]))

//表单校验
export const PurchasepriceRules = reactive({
  supplierCode: [
    { required: true, message: '请输入供应商代码', trigger: 'blur' }
  ],
  itemCode: [
    { required: true, message: '请输入物品代码', trigger: 'blur' }
  ],
  currency: [
    { required: true, message: '请选择货币', trigger: 'change' }
  ],
  price: [
    { required: true, message: '请输入价格', trigger: 'blur' }
  ],
  available:  [
    { required: true, message: '请选择是否可用', trigger: 'change' }
  ],
})

/**
 * @returns {Array} 客户
 */
export const Customer = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '代码',
    field: 'code'
  },
  {
    label: '名称',
    field: 'name'
  },
  {
    label: '简称',
    field: 'shortName'
  },
  {
    label:'地址',
    field: 'address'
  },
  {
    label: '国家',
    field: 'country'
  },
  {
    label: '城市',
    field: 'city'
  },
  {
    label: '电话',
    field: 'phone'
  },
  {
    label: '传真',
    field: 'fax'
  },
  {
    label: '邮编',
    field: 'postId'
  },
  {
    label: '联系人',
    field: 'contacts'
  },
  {
    label: '银行',
    field: 'bank'
  },
  {
    label: '币种',
    field: 'currency',
    dictType: DICT_TYPE.CURRENCY,
    dictClass: 'string',
    isTable: true,
    isSearch: true
  },
  {
    label: '税率',
    field: 'taxRate'
  },
  {
    label: '类型',
    field: 'type',
    dictType: DICT_TYPE.CUSTOMER_TYPE,
    dictClass: 'string',
    isTable: true,
    isSearch: true
  },
  {
    label: '是否可用',
    field: 'available',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isTable: true,
    isSearch: true
  },
  {
    label: '生效时间',
    field: 'activeTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '失效时间',
    field: 'expireTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建时间',
    field: 'createTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建者',
    field: 'creator'
  },
  {
    label: '操作',
    field: 'action',
    isDetail: false,
    isForm: false ,
    table: {
      width: 150
    }
  }
]))

//表单校验
export const CustomerRules = reactive({
  code: [
    { required: true, message: '请输入代码', trigger: 'blur' }
  ],
  shortName: [
    { required: true, message: '请输入简称', trigger: 'blur' }
  ],
  available:  [
    { required: true, message: '请选择是否可用', trigger: 'change' }
  ],
})

/**
 * @returns {Array} 客户月台
 */
export const Customerdock = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '代码',
    field: 'code'
  },
  {
    label: '名称',
    field: 'name'
  },
  {
    label: '描述',
    field: 'description'
  },
  {
    label: '城市',
    field: 'city'
  },
  {
    label: '地址',
    field: 'address'
  },
  {
    label: '联系人姓名',
    field: 'contactPerson'
  },
  {
    label: '联系人电话',
    field: 'contactPhone'
  },
  {
    label: '客户代码',
    field: 'customerCode'
  },
  {
    label: '仓库',
    field: 'warehouseCode'
  },
  {
    label: '默认库位',
    field: 'defaultLocationCode'
  },
  {
    label: '是否可用',
    field: 'available',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isTable: true,
    isForm: false,
    isSearch: true
  },
  {
    label: '生效时间',
    field: 'activeTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '失效时间',
    field: 'expireTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建时间',
    field: 'createTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建者',
    field: 'creator'
  },
  {
    label: '操作',
    field: 'action',
    isDetail: false,
    isForm: false ,
    table: {
      width: 150
    }
  }
]))

//表单校验
export const CustomerdockRules = reactive({
  code: [
    { required: true, message: '请输入代码', trigger: 'blur' }
  ],
  customerCode: [
    { required: true, message: '请输入客户代码', trigger: 'blur' }
  ],
  defaultLocationCode: [
    { required: true, message: '请输入默认库位', trigger: 'blur' }
  ],
  available:  [
    { required: true, message: '请选择是否可用', trigger: 'change' }
  ],
})

/**
 * @returns {Array} 客户物品
 */
export const Customeritem = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '客户代码',
    field: 'customerCode'
  },
  {
    label: '物料代码',
    field: 'itemCode'
  },
  {
    label: '客户物料代码',
    field: 'customerItemCode'
  },
  {
    label: '客户计量单位',
    field: 'cusotmerUom',
    dictType: DICT_TYPE.UOM,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '转换率',
    field: 'convertRate'
  },
  {
    label: '客户包装单位',
    field: 'packUnit',
    dictType: DICT_TYPE.PACK_UNIT,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '客户包装量',
    field: 'packQty'
  },
  {
    label: '客户替代包装单位',
    field: 'altPackUnit',
    dictType: DICT_TYPE.PACK_UNIT,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '客户替代包装量',
    field: 'altPackQty'
  },
  {
    label: '每器具包装数',
    field: 'packQtyOfContainer'
  },
  {
    label: '是否可用',
    field: 'available',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isTable: true
  },
  {
    label: '生效时间',
    field: 'activeTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '失效时间',
    field: 'expireTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建时间',
    field: 'createTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建者',
    field: 'creator'
  },
  {
    label: '操作',
    field: 'action',
    isDetail: false,
    isForm: false ,
    table: {
      width: 150
    }
  }
]))

//表单校验
export const CustomeritemRules = reactive({
  customerCode: [
    { required: true, message: '请输入客户代码', trigger: 'blur' }
  ],
  itemCode: [
    { required: true, message: '请输入物品代码', trigger: 'blur' }
  ],
  packUnit: [
    { required: true, message: '请选择客户包装单位', trigger: 'change' }
  ],
  packQty: [
    { required: true, message: '请输入客户包装量', trigger: 'blur' }
  ],
  packQtyOfContainer: [
    { required: true, message: '请输入每器具包装数', trigger: 'blur' }
  ],
  available:  [
    { required: true, message: '请选择是否可用', trigger: 'change' }
  ],
})

/**
 * @returns {Array} 项目
 */
export const Project = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '代码',
    field: 'code'
  },
  {
    label: '名称',
    field: 'name'
  },
  {
    label: '客户代码',
    field: 'customerCode'
  },
  {
    label: '是否可用',
    field: 'available',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isTable: true,
    isSearch: true
  },
  {
    label: '生效时间',
    field: 'activeTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '失效时间',
    field: 'expireTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建时间',
    field: 'createTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建者',
    field: 'creator'
  },
  {
    label: '操作',
    field: 'action',
    isDetail: false,
    isForm: false ,
    table: {
      width: 150
    }
  }
]))

//表单校验
export const ProjectRules = reactive({
  code: [
    { required: true, message: '请输入代码', trigger: 'blur' }
  ],
  available:  [
    { required: true, message: '请选择是否可用', trigger: 'change' }
  ],
})

/**
 * @returns {Array} 销售价格单
 */
export const Saleprice = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '客户代码',
    field: 'customercode'
  },
  {
    label: '物料代码',
    field: 'itemcode'
  },
  {
    label: '货币',
    field: 'currency',
    dictType: DICT_TYPE.CURRENCY,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '价格',
    field: 'price'
  },
  {
    label: '是否可用',
    field: 'available',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isTable: true,
    isSearch: true
  },
  {
    label: '生效时间',
    field: 'activeTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '失效时间',
    field: 'expireTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建时间',
    field: 'createTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建者',
    field: 'creator'
  },
  {
    label: '操作',
    field: 'action',
    isDetail: false,
    isForm: false ,
    table: {
      width: 150
    }
  }
]))

//表单校验
export const SalepriceRules = reactive({
  customercode: [
    { required: true, message: '请输入客户代码', trigger: 'blur' }
  ],
  itemcode: [
    { required: true, message: '请输入物料代码', trigger: 'blur' }
  ],
  currency: [
    { required: true, message: '请选择货币', trigger: 'change' }
  ],
  price: [
    { required: true, message: '请输入价格', trigger: 'blur' }
  ],
  available:  [
    { required: true, message: '请选择是否可用', trigger: 'change' }
  ],
})

/**
 * @returns {Array} 仓库
 */
export const Warehouse = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '代码',
    field: 'code'
  },
  {
    label: '名称',
    field: 'name'
  },
  {
    label: '描述',
    field: 'description'
  },
  {
    label: '类型',
    field: 'type',
    dictType: DICT_TYPE.WAREHOUSE_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '是否可用',
    field: 'available',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isTable: true,
    isSearch: true
  },
  {
    label: '生效时间',
    field: 'activeTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '失效时间',
    field: 'expireTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建时间',
    field: 'createTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建者',
    field: 'creator'
  },
  {
    label: '操作',
    field: 'action',
    isDetail: false,
    isForm: false ,
    table: {
      width: 150
    }
  }
]))

//表单校验
export const WarehouseRules = reactive({
  code: [
    { required: true, message: '请输入代码', trigger: 'blur' }
  ],
  available:  [
    { required: true, message: '请选择是否可用', trigger: 'change' }
  ],
})

/**
 * @returns {Array} 月台
 */
export const Dock = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '代码',
    field: 'code'
  },
  {
    label: '名称',
    field: 'name'
  },
  {
    label: '城市',
    field: 'city'
  },
  {
    label: '地址',
    field: 'address'
  },
  {
    label: '类型',
    field: 'type',
    dictType: DICT_TYPE.DOCK_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '仓库代码',
    field: 'warehouseCode'
  },
  {
    label: '默认库位代码',
    field: 'defaultLocationCode'
  },
  {
    label: '联系人姓名',
    field: 'contactPerson'
  },
  {
    label: '联系人电话',
    field: 'contactPhone'
  },
  {
    label: '是否可用',
    field: 'available',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isTable: true,
    isSearch: true
  },
  {
    label: '生效时间',
    field: 'activeTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '失效时间',
    field: 'expireTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建时间',
    field: 'createTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建者',
    field: 'creator'
  },
  {
    label: '操作',
    field: 'action',
    isDetail: false,
    isForm: false ,
    table: {
      width: 150
    }
  }
]))

//表单校验
export const DockRules = reactive({
  code: [
    { required: true, message: '请输入代码', trigger: 'blur' }
  ],
  type: [
    { required: true, message: '请输入类型', trigger: 'change' }
  ],
  warehouseCode: [
    { required: true, message: '请输入仓库代码', trigger: 'blur' }
  ],
  defaultLocationCode: [
    { required: true, message: '请输入默认库位代码', trigger: 'blur' }
  ],
  available:  [
    { required: true, message: '请选择是否可用', trigger: 'change' }
  ],
})

/**
 * @returns {Array} 库区
 */
export const Area = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '代码',
    field: 'code'
  },
  {
    label: '名称',
    field: 'name'
  },
  {
    label: '仓库代码',
    field: 'warehouseCode'
  },
  {
    label: '类型',
    field: 'type',
    dictType: DICT_TYPE.AREA_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '是否是功能区',
    field: 'isFunctional',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '是否可用',
    field: 'available',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isTable: true,
    isSearch: true
  },
  {
    label: '生效时间',
    field: 'activeTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '失效时间',
    field: 'expireTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建时间',
    field: 'createTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建者',
    field: 'creator'
  },
  {
    label: '操作',
    field: 'action',
    isDetail: false,
    isForm: false ,
    table: {
      width: 150
    }
  }
]))

//表单校验
export const AreaRules = reactive({
  code: [
    { required: true, message: '请输入代码', trigger: 'blur' }
  ],
  warehouseCode: [
    { required: true, message: '请输入仓库代码', trigger: 'blur' }
  ],
  isFunctional: [
    { required: true, message: '请选择是否是功能区', trigger: 'change' }
  ],
  available:  [
    { required: true, message: '请选择是否可用', trigger: 'change' }
  ],
})

/**
 * @returns {Array} 库位组
 */
export const Locationgroup = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '代码',
    field: 'code'
  },
  {
    label: '名称',
    field: 'name'
  },
  {
    label: '仓库代码',
    field: 'warehouseCode'
  },
  {
    label: '区域代码',
    field: 'areaCode'
  },
  {
    label: '是否可用',
    field: 'available',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isTable: true,
    isSearch: true
  },
  {
    label: '生效时间',
    field: 'activeTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '失效时间',
    field: 'expireTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建时间',
    field: 'createTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建者',
    field: 'creator'
  },
  {
    label: '操作',
    field: 'action',
    isDetail: false,
    isForm: false ,
    table: {
      width: 150
    }
  }
]))

//表单校验
export const LocationgroupRules = reactive({
  code: [
    { required: true, message: '请输入代码', trigger: 'blur' }
  ],
  warehouseCode: [
    { required: true, message: '请输入仓库代码', trigger: 'blur' }
  ],
  areaCode: [
    { required: true, message: '请输入区域代码', trigger: 'blur' }
  ],
  available:  [
    { required: true, message: '请选择是否可用', trigger: 'change' }
  ],
})

/**
 * @returns {Array} 库位
 */
export const Location = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '代码',
    field: 'code'
  },
  {
    label: '名称',
    field: 'name'
  },
  {
    label: '仓库代码',
    field: 'warehouseCode'
  },
  {
    label: '区域代码',
    field: 'areaCode'
  },
  {
    label: '库位组代码',
    field: 'locationGroupCode'
  },
  {
    label: 'ERP库位代码',
    field: 'erpLocationCode',
    dictType: DICT_TYPE.ERP_LOCATION,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '类型',
    field: 'type',
    dictType: DICT_TYPE.LOCATION_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '巷道',
    field: 'aisle'
  },
  {
    label: '货架',
    field: 'shelf'
  },
  {
    label: '行',
    field: 'locationRow'
  },
  {
    label: '列',
    field: 'locationColum'
  },
  {
    label: '拣料优先级',
    field: 'pickPriority'
  },
  {
    label: '最大承重',
    field: 'maxWeight'
  },
  {
    label: '最大面积',
    field: 'maxArea'
  },
  {
    label: '最大体积',
    field: 'maxVolume'
  },
  {
    label: '用户组代码',
    field: 'userGroupCode'
  },
  {
    label: '是否可用',
    field: 'available',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isTable: true,
    isSearch: true,
  },
  {
    label: '生效时间',
    field: 'activeTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '失效时间',
    field: 'expireTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建时间',
    field: 'createTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建者',
    field: 'creator'
  },
  {
    label: '操作',
    field: 'action',
    isDetail: false,
    isForm: false ,
    table: {
      width: 150
    }
  }
]))

//表单校验
export const LocationRules = reactive({
  code: [
    { required: true, message: '请输入代码', trigger: 'blur' }
  ],
  warehouseCode: [
    { required: true, message: '请输入仓库代码', trigger: 'blur' }
  ],
  areaCode: [
    { required: true, message: '请输入库区代码', trigger: 'blur' }
  ],
  locationGroupCode: [
    { required: true, message: '请输入库位组代码', trigger: 'blur' }
  ],
  erpLocationCode: [
    { required: true, message: '请选择ERP库位代码', trigger: 'change' }
  ],
  type: [
    { required: true, message: '请选择类型', trigger: 'change' }
  ],
  pickPriority: [
    { required: true, message: '请输入拣料优先级', trigger: 'blur' }
  ],
  userGroupCode: [
    { required: true, message: '请输入用户组代码', trigger: 'blur' }
  ],
  available:  [
    { required: true, message: '请选择是否可用', trigger: 'change' }
  ],
})

/**
 * @returns {Array} 车间
 */
export const Workshop = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '代码',
    field: 'code'
  },
  {
    label: '名称',
    field: 'name'
  },
  {
    label: '类型',
    field: 'type',
    dictType: DICT_TYPE.WORKSHOP_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '是否可用',
    field: 'available',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '生效时间',
    field: 'activeTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '失效时间',
    field: 'expireTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建时间',
    field: 'createTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  { label: '备注', field: 'remark' },
  { label: '创建者', field: 'creator' },
  {
    label: '操作',
    field: 'action',
    isDetail: false,
    isForm: false ,
    table: {
      width: 150
    }
  }
]))

//表单校验
export const WorkshopRules = reactive({
  code: [
    { required: true, message: '请输入代码', trigger: 'blur' }
  ],
  available:  [
    { required: true, message: '请选择是否可用', trigger: 'change' }
  ],
})

/**
 * @returns {Array} 生产线
 */
export const Productionline = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '代码',
    field: 'code'
  },
  {
    label: '名称',
    field: 'name'
  },
  {
    label: '类型',
    field: 'type',
    dictType: DICT_TYPE.PRODUCTION_LINE_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '车间代码',
    field: 'workshopCode'
  },
  {
    label: '原料库位',
    field: 'rawLocationCode'
  },
  {
    label: '成品库位',
    field: 'fgLocationCode'
  },
  {
    label: '是否可用',
    field: 'available',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '生效时间',
    field: 'activeTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '失效时间',
    field: 'expireTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建时间',
    field: 'createTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  { label: '备注', field: 'remark' },
  { label: '创建者', field: 'creator' },
  {
    label: '操作',
    field: 'action',
    isDetail: false,
    isForm: false ,
    table: {
      width: 150
    }
  }
]))

//表单校验
export const ProductionlineRules = reactive({
  code: [
    { required: true, message: '请输入代码', trigger: 'blur' }
  ],
  workshopCode: [
    { required: true, message: '请输入车间代码', trigger: 'blur' }
  ],
  available:  [
    { required: true, message: '请选择是否可用', trigger: 'change' }
  ],
})

/**
 * @returns {Array} 工位
 */
export const Workstation = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '代码',
    field: 'code'
  },
  {
    label: '名称',
    field: 'name'
  },
  {
    label: '类型',
    field: 'type',
    dictType: DICT_TYPE.WORK_STATION_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '车间代码',
    field: 'workshopCode'
  },
  {
    label: '生产线代码',
    field: 'productionLineCode'
  },
  {
    label: '原料库位',
    field: 'rawLocationCode'
  },
  {
    label: '成品库位',
    field: 'fgLocationCode'
  },
  {
    label: '是否可用',
    field: 'available',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '生效时间',
    field: 'activeTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '失效时间',
    field: 'expireTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建时间',
    field: 'createTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  { label: '备注', field: 'remark' },
  { label: '创建者', field: 'creator' },
  {
    label: '操作',
    field: 'action',
    isDetail: false,
    isForm: false ,
    table: {
      width: 150
    }
  }
]))

//表单检验
export const WorkstationRules = reactive({
  code: [
    { required: true, message: '请输入代码', trigger: 'blur' }
  ],
  workshopCode: [
    { required: true, message: '请输入车间代码', trigger: 'blur' }
  ],
  productionLineCode: [
    { required: true, message: '请输入生产线代码', trigger: 'blur' }
  ],
  available:  [
    { required: true, message: '请选择是否可用', trigger: 'change' }
  ],
})

/**
 * @returns {Array} 工序
 */
export const Process = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '代码',
    field: 'code'
  },
  {
    label: '名称',
    field: 'name'
  },
  {
    label: '类型',
    field: 'type',
    dictType: DICT_TYPE.PROCESS_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '车间代码',
    field: 'workshopCode'
  },
  {
    label: '生产线代码',
    field: 'productionLineCode'
  },
  {
    label: '是否可用',
    field: 'available',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '生效时间',
    field: 'activeTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '失效时间',
    field: 'expireTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建时间',
    field: 'createTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  { label: '备注', field: 'remark' },
  { label: '创建者', field: 'creator' },
  {
    label: '操作',
    field: 'action',
    isDetail: false,
    isForm: false ,
    table: {
      width: 150
    }
  }
]))

//表单检验
export const ProcessRules = reactive({
  code: [
    { required: true, message: '请输入代码', trigger: 'blur' }
  ],
  workshopCode: [
    { required: true, message: '请输入车间代码', trigger: 'blur' }
  ],
  productionLineCode: [
    { required: true, message: '请输入生产线代码', trigger: 'blur' }
  ],
  available:  [
    { required: true, message: '请选择是否可用', trigger: 'change' }
  ],
})

/**
 * @returns {Array} 系统日历
 */
export const Systemcalendar = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '模块',
    field: 'module'
  },
  {
    label: '开始时间',
    field: 'startTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '结束时间',
    field: 'stopTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '是否可用',
    field: 'available',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '生效时间',
    field: 'activeTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '失效时间',
    field: 'expireTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建时间',
    field: 'createTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  { label: '备注', field: 'remark' },
  { label: '创建者', field: 'creator' },
  {
    label: '操作',
    field: 'action',
    isDetail: false,
    isForm: false ,
    table: {
      width: 150
    }
  }
]))

//表单校验
export const SystemcalendarRules = reactive({
  module: [
    { required: true, message: '请输入模块', trigger: 'blur' }
  ],
  available:  [
    { required: true, message: '请选择是否可用', trigger: 'change' }
  ],
})

/**
 * @returns {Array} 账期日历
 */
export const Accountcalendar = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '年',
    field: 'year'
  },
  {
    label: '月',
    field: 'month'
  },
  {
    label: '描述',
    field: 'descriiption'
  },
  {
    label: '开始时间',
    field: 'beginTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '结束时间',
    field: 'endTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '转换生效时间',
    field: 'converttotime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '是否可用',
    field: 'available',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '生效时间',
    field: 'activeTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '失效时间',
    field: 'expireTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建时间',
    field: 'createTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  { label: '备注', field: 'remark', },
  { label: '创建者', field: 'creator' },
  {
    label: '操作',
    field: 'action',
    isDetail: false,
    isForm: false ,
    table: {
      width: 150
    }
  }
]))

//表单校验
export const AccountcalendarRules = reactive({
  year: [
    { required: true, message: '请输入年', trigger: 'blur' }
  ],
  month: [
    { required: true, message: '请输入月', trigger: 'blur' }
  ],
  beginTime: [
    { required: true, message: '请输入开始时间', trigger: 'blur' }
  ],
  endTime: [
    { required: true, message: '请输入结束时间', trigger: 'blur' }
  ],
  converttotime: [
    { required: true, message: '请输入转换生效时间', trigger: 'blur' }
  ],
  available:  [
    { required: true, message: '请选择是否可用', trigger: 'change' }
  ],
})

/**
 * @returns {Array} 货币转换
 */
export const Currencyexchange = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '货币',
    field: 'currency',
    dictType: DICT_TYPE.CURRENCY,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '基础货币',
    field: 'basiccurrency',
    dictType: DICT_TYPE.CURRENCY,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '比率',
    field: 'rate'
  },
  {
    label: '是否可用',
    field: 'available',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '生效时间',
    field: 'activeTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '失效时间',
    field: 'expireTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建时间',
    field: 'createTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  { label: '备注', field: 'remark' },
  { label: '创建者', field: 'creator' },
  {
    label: '操作',
    field: 'action',
    isDetail: false,
    isForm: false ,
    table: {
      width: 150
    }
  }
]))

//表单校验
export const CurrencyexchangeRules = reactive({
  currency: [
    { required: true, message: '请选择货币', trigger: 'change' }
  ],
  basiccurrency: [
    { required: true, message: '请选择基础货币', trigger: 'change' }
  ],
  rate: [
    { required: true, message: '请输入比率', trigger: 'blur' }
  ],
  available:  [
    { required: true, message: '请选择是否可用', trigger: 'change' }
  ],
})

/**
 * @returns {Array} 货主
 */
export const Owner = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '代码',
    field: 'code'
  },
  {
    label: '名称',
    field: 'name'
  },
  {
    label: '简称',
    field: 'shortName'
  },
  {
    label: '地址',
    field: 'address'
  },
  {
    label: '国家',
    field: 'country'
  },
  {
    label: '城市',
    field: 'city'
  },
  {
    label: '电话',
    field: 'phone'
  },
  {
    label: '传真',
    field: 'fax'
  },
  {
    label: '邮编',
    field: 'postId'
  },
  {
    label: '联系人',
    field: 'contacts'
  },
  {
    label: '银行',
    field: 'bank'
  },
  {
    label: '币种',
    field: 'currency',
    dictType: DICT_TYPE.CURRENCY,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '税率',
    field: 'taxRate'
  },
  {
    label: '类型',
    field: 'type',
    dictType: DICT_TYPE.OWNER_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '是否可用',
    field: 'available',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isTable: true,
    isSearch: true
  },
  {
    label: '生效时间',
    field: 'activeTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '失效时间',
    field: 'expireTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建时间',
    field: 'createTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建者',
    field: 'creator'
  },
  {
    label: '操作',
    field: 'action',
    isDetail: false,
    isForm: false ,
    table: {
      width: 150
    }
  }
]))

//表单校验
export const OwnerRules = reactive({
  code: [
    { required: true, message: '请选择代码', trigger: 'blur' }
  ],
  shortName: [
    { required: true, message: '请选择简称', trigger: 'blur' }
  ],
  available:  [
    { required: true, message: '请选择是否可用', trigger: 'change' }
  ],
})

/**
 * @returns {Array} 承运商
 */
export const Carrier = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '代码',
    field: 'code'
  },
  {
    label: '名称',
    field: 'name'
  },
  {
    label: '简称',
    field: 'shortName'
  },
  {
    label: '地址',
    field: 'address'
  },
  {
    label: '国家',
    field: 'country'
  },
  {
    label: '城市',
    field: 'city'
  },
  {
    label: '电话',
    field: 'phone'
  },
  {
    label: '传真',
    field: 'fax'
  },
  {
    label: '邮编',
    field: 'postId'
  },
  {
    label: '联系人',
    field: 'contacts'
  },
  {
    label: '银行',
    field: 'bank'
  },
  {
    label: '币种',
    field: 'currency',
    dictType: DICT_TYPE.CURRENCY,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '税率',
    field: 'taxRate'
  },
  {
    label: '类型',
    field: 'type',
    dictType: DICT_TYPE.CARRIER_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '是否可用',
    field: 'available',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isTable: true,
    isSearch: true
  },
  {
    label: '生效时间',
    field: 'activeTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '失效时间',
    field: 'expireTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建时间',
    field: 'createTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建者',
    field: 'creator'
  },
  {
    label: '操作',
    field: 'action',
    isDetail: false,
    isForm: false ,
    table: {
      width: 150
    }
  }
]))

//表单校验
export const CarrierRules = reactive({
  code: [
    { required: true, message: '请选择代码', trigger: 'blur' }
  ],
  shortName: [
    { required: true, message: '请选择简称', trigger: 'blur' }
  ],
  available:  [
    { required: true, message: '请选择是否可用', trigger: 'change' }
  ],
})

/**
 * @returns {Array} 班次
 */
export const Shift = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '代码',
    field: 'code'
  },
  {
    label: '名称',
    field: 'name'
  },
  {
    label: '开始时间',
    field: 'beginTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '结束时间',
    field: 'entTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '是否跨天',
    field: 'endAtNextDay',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isTable: true
  },
  {
    label: '是否可用',
    field: 'available',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isTable: true,
    isSearch: true
  },
  {
    label: '生效时间',
    field: 'activeTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '失效时间',
    field: 'expireTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建时间',
    field: 'createTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建者',
    field: 'creator'
  },
  {
    label: '操作',
    field: 'action',
    isDetail: false,
    isForm: false ,
    table: {
      width: 150
    }
  }
]))

//表单校验
export const ShiftRules = reactive({
  code: [
    { required: true, message: '请选择代码', trigger: 'blur' }
  ],
  beginTime: [
    { required: true, message: '请选择开始时间', trigger: 'blur' }
  ],
  entTime: [
    { required: true, message: '请选择结束时间', trigger: 'blur' }
  ],
  endAtNextDay: [
    { required: true, message: '请选择是否跨天', trigger: 'change' }
  ],
  available:  [
    { required: true, message: '请选择是否可用', trigger: 'change' }
  ],
})

/**
 * @returns {Array} 班组
 */
export const Team = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '代码',
    field: 'code'
  },
  {
    label: '名称',
    field: 'name'
  },
  {
    label: '成员',
    field: 'members'
  },
  {
    label: '是否可用',
    field: 'available',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isTable: true,
    isSearch: true
  },
  {
    label: '生效时间',
    field: 'activeTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '失效时间',
    field: 'expireTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建时间',
    field: 'createTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建者',
    field: 'creator'
  },
  {
    label: '操作',
    field: 'action',
    isDetail: false,
    isForm: false ,
    table: {
      width: 150
    }
  }
]))

//表单校验
export const TeamRules = reactive({
  code: [
    { required: true, message: '请选择代码', trigger: 'blur' }
  ],
  available:  [
    { required: true, message: '请选择是否可用', trigger: 'change' }
  ],
})

/**
 * @returns {Array} 策略
 */
export const Strategy = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '代码',
    field: 'code'
  },
  {
    label: '名称',
    field: 'name'
  },
  {
    label: '描述',
    field: 'description'
  },
  {
    label: '类型',
    field: 'type',
    dictType: DICT_TYPE.STRATEGY_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '优先级',
    field: 'priority'
  },
  {
    label: '是否生效',
    field: 'isActive',
    dictType: DICT_TYPE.STRATEGY_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建时间',
    field: 'creationTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建者',
    field: 'creator'
  }
]))

/**
 * @returns {Array} 规则
 */
export const Rule = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '策略代码',
    field: 'strategyCode'
  },
  {
    label: '优先级',
    field: 'priority'
  },
  {
    label: '代码',
    field: 'code'
  },
  {
    label: '名称',
    field: 'name'
  },
  {
    label: '条件',
    field: 'condition'
  },
  {
    label: '配置',
    field: 'configuration'
  }
]))

/**
 * @returns {Array} 条件
 */
export const Condition = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '策略代码',
    field: 'strategyCode'
  },
  {
    label: '规则代码',
    field: 'ruleCode'
  },
  {
    label: '参数',
    field: 'paramCode'
  },
  {
    label: '操作符',
    field: 'operator',
    dictType: DICT_TYPE.STRATEGY_PARAM_OPEARTOR,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '值',
    field: 'value'
  },
  {
    label: '条件分组',
    field: 'groupCode'
  }
]))

/**
 * @returns {Array} 配置
 */
export const Configuration = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '策略代码',
    field: 'strategyCode'
  },
  {
    label: '规则代码',
    field: 'ruleCode'
  },
  {
    label: '配置名称',
    field: 'configurationCode'
  },
  {
    label: '描述',
    field: 'description'
  },
  {
    label: '配置值',
    field: 'configurationValue'
  },
  {
    label: '配置分组',
    field: 'groupCode'
  },
]))

/**
 * @returns {Array} 配置设置
 */
export const Configurationsetting = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '策略类型',
    field: 'strategyType',
    dictType: DICT_TYPE.STRATEGY_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '配置代码',
    field: 'configurationCode'
  },
  {
    label: '配置名称',
    field: 'configurationName'
  },
  {
    label: '数据类型',
    field: 'dataType',
    dictType: DICT_TYPE.DATA_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '值范围',
    field: 'valueScope'
  },
  {
    label: '关联到',
    field: 'relatedTo'
  },
  {
    label: '描述',
    field: 'description'
  },
  {
    label: '必填',
    field: 'isRequired',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
]))

/**
 * @returns {Array} 参数设置
 */
export const Paramsetting = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '策略代码',
    field: 'strategyType',
    dictType: DICT_TYPE.STRATEGY_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '参数代码',
    field: 'paramCode'
  },
  {
    label: '参数名称',
    field: 'paramName'
  },
  {
    label: '可用操作符',
    field: 'usableOpeartors',
    dictType: DICT_TYPE.STRATEGY_PARAM_OPEARTOR,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '数据类型',
    field: 'dataType',
    dictType: DICT_TYPE.DATA_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '值范围',
    field: 'valueScope'
  },
  {
    label: '关联到',
    field: 'relatedTo'
  },
  {
    label: '描述',
    field: 'description'
  },
  {
    label: '必填',
    field: 'isRequired',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
]))

/**
 * @returns {Array} 事务类型
 */
export const Transactiontype = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '代码',
    field: 'code'
  },
  {
    label: '名称',
    field: 'name'
  },
  {
    label: '描述',
    field: 'description'
  },
  {
    label: '库存动作',
    field: 'inventoryAction',
    dictType: DICT_TYPE.INVENTORY_ACTION,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '允许负数',
    field: 'allowNegative',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '是否可用',
    field: 'available',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '是否软删除',
    field: 'isSoftDeleted',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '生效时间',
    field: 'activeTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '失效时间',
    field: 'expireTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建时间',
    field: 'createTime',
    isTable: true,
    formatter: dateFormatter,
    isForm: false,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  { 
    label: '备注',
    field: 'remark',
    isTable: false
  },
  { 
    label: '创建者', 
    field: 'creator', 
    isTable: false, 
    isForm: false 
  },
]))

/**
 * @returns {Array} 业务类型
 */
export const Businesstype = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '代码',
    field: 'code'
  },
  {
    label: '名称',
    field: 'name'
  },
  {
    label: '描述',
    field: 'description'
  },
  {
    label: '可用物品类型范围',
    field: 'itemTypes',
    dictType: DICT_TYPE.ITEM_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '可用物品状态范围',
    field: 'itemStatuses',
    dictType: DICT_TYPE.ITEM_STATUS,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '出库库位类型范围',
    field: 'outLocationTypes',
    dictType: DICT_TYPE.LOCATION_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '入库库位类型范围',
    field: 'inLocationTypes',
    dictType: DICT_TYPE.LOCATION_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '出库库区范围',
    field: 'outAreaCodes'
  },
  {
    label: '入库库区范围',
    field: 'inAreaCodes'
  },
  {
    label: '出库库存状态范围',
    field: 'outInventoryStatuses',
    dictType: DICT_TYPE.INVENTORY_STATUS,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '入库库存状态范围',
    field: 'inInventoryStatuses',
    dictType: DICT_TYPE.INVENTORY_STATUS,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '出库事务类型',
    field: 'outTransactionType'
  },
  {
    label: '入库事务类型',
    field: 'inTransactionType'
  },
  {
    label: '是否使用在途库',
    field: 'useOnTheWay',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '在途库区',
    field: 'onTheWayArea'
  },
  {
    label: '生效时间',
    field: 'activeTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '失效时间',
    field: 'expireTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建时间',
    field: 'createTime',
    isTable: true,
    formatter: dateFormatter,
    isForm: false,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  { 
    label: '备注',
    field: 'remark',
    isTable: false
  },
  { 
    label: '创建者', 
    field: 'creator', 
    isTable: false, 
    isForm: false 
  },
  { 
    label: '是否可用', 
    field: 'available',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isTable: true,
    isSearch: true
  },
  { 
    label: '是否软删除', 
    field: 'isSoftDeleted', 
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isTable: true,
    isSearch: true 
  },
]))

/**
 * @returns {Array} 单据设置
 */
export const Documentsetting = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '代码',
    field: 'code'
  },
  {
    label: '名称',
    field: 'name'
  },
  {
    label: '描述',
    field: 'description'
  },
  {
    label: '单据类型',
    field: 'type',
    dictType: DICT_TYPE.DOCUMENT_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '业务类型',
    field: 'businessType'
  },
  {
    label: '号码前缀',
    field: 'numberPrefix'
  },
  {
    label: '号码时间格式',
    field: 'dateFormat'
  },
  {
    label: '号码流水长度',
    field: 'serialLength'
  },
  {
    label: '号码分隔符',
    field: 'separatorStr'
  },
  {
    label: '流水重置周期',
    field: 'resetPeriod',
    dictType: DICT_TYPE.RESET_PERIOD,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '生效时间',
    field: 'activeTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '失效时间',
    field: 'expireTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建时间',
    field: 'createTime',
    isTable: true,
    formatter: dateFormatter,
    isForm: false,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  { 
    label: '备注',
    field: 'remark',
    isTable: false
  },
  { 
    label: '创建者', 
    field: 'creator', 
    isTable: false, 
    isForm: false 
  },
  { 
    label: '是否可用', 
    field: 'available',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isTable: true,
    isSearch: true
  },
  { 
    label: '是否软删除', 
    field: 'isSoftDeleted', 
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isTable: true,
    isSearch: true 
  },
]))

/**
 * @returns {Array} 申请设置
 */
export const Requestsetting = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '代码',
    field: 'code'
  },
  {
    label: '申请模式',
    field: 'requestMode',
    dictType: DICT_TYPE.REQEUST_MODE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '自动提交',
    field: 'autoCommit',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '自动通过',
    field: 'autoAgree',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '自动执行',
    field: 'autoExecute',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '跳过任务直接删生成记录',
    field: 'directCreateRecord',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '是否可用',
    field: 'available',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '是否软删除',
    field: 'isSoftDeleted',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '生效时间',
    field: 'activeTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '失效时间',
    field: 'expireTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建时间',
    field: 'createTime',
    isTable: true,
    formatter: dateFormatter,
    isForm: false,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  { 
    label: '备注',
    field: 'remark',
    isTable: false
  },
  { 
    label: '创建者', 
    field: 'creator', 
    isTable: false, 
    isForm: false 
  },
]))

/**
 * @returns {Array} 任务设置
 */
export const Jobsetting = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '代码',
    field: 'code'
  },
  {
    label: '有效分钟',
    field: 'validMinutes'
  },
  {
    label: '自动完成',
    field: 'autoComplete',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '允许修改库位',
    field: 'allowModifyLocation',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '允许修改数量',
    field: 'allowModifyQty',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '允许大于推荐数量',
    field: 'allowBiggerQty',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '允许小于推荐数量',
    field: 'allowSmallerQty',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '允许修改库存状态',
    field: 'allowModifyInventoryStatus',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '允许连续扫描',
    field: 'allowContinuousScanning',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '允许部分完成',
    field: 'allowPartialComplete',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '允许修改批次',
    field: 'allowModifyBach',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '允许修改包装号',
    field: 'allowModifyPackingNumber',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '是否可用',
    field: 'available',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '是否软删除',
    field: 'isSoftDeleted',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '生效时间',
    field: 'activeTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '失效时间',
    field: 'expireTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建时间',
    field: 'createTime',
    isTable: true,
    formatter: dateFormatter,
    isForm: false,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  { 
    label: '备注',
    field: 'remark',
    isTable: false
  },
  { 
    label: '创建者', 
    field: 'creator', 
    isTable: false, 
    isForm: false 
  },
]))

/**
 * @returns {Array} 记录设置
 */
export const Recordsetting = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '代码',
    field: 'code'
  },
  {
    label: '接口类型',
    field: 'interfaceType',
    dictType: DICT_TYPE.INTERFACE_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '生效时间',
    field: 'activeTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '失效时间',
    field: 'expireTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建时间',
    field: 'createTime',
    isTable: true,
    formatter: dateFormatter,
    isForm: false,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  { 
    label: '备注',
    field: 'remark',
    isTable: false
  },
  { 
    label: '创建者', 
    field: 'creator', 
    isTable: false, 
    isForm: false 
  },
  { 
    label: '是否可用', 
    field: 'available',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isTable: true,
    isSearch: true
  },
  { 
    label: '是否软删除', 
    field: 'isSoftDeleted', 
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isTable: true,
    isSearch: true 
  },
]))

/**
 * @returns {Array} 库位容量
 */
export const Locationcapacity = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '库位代码',
    field: 'locationCode'
  },
  {
    label: '仓库代码',
    field: 'warehouseCode'
  },
  {
    label: '已用容量百分比',
    field: 'usedCapacity'
  },
  {
    label: '可用容量百分比',
    field: 'availableCapacity'
  },
  {
    label: '可承受过载容量百分比',
    field: 'bearableOverloadCapacity'
  },
  {
    label: '是否无限容量',
    field: 'isInfinity',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
]))

/**
 * @returns {Array} 包装
 */
export const Package = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '包装号',
    field: 'number'
  },
  {
    label: '物料代码',
    field: 'itemCode'
  },
  {
    label: '物品名称',
    field: 'itemName'
  },
  {
    label: '物品描述1',
    field: 'itemDesc1'
  },
  {
    label: '物品描述2',
    field: 'itemDesc2'
  },
  {
    label: '批次',
    field: 'batch'
  },
  {
    label: '替代批次',
    field: 'altBatch'
  },
  {
    label: '生产日期',
    field: 'produceDate',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '有效期',
    field: 'validityDays'
  },
  {
    label: '失效日期',
    field: 'expireDate',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '计量单位',
    field: 'uom',
    dictType: DICT_TYPE.UOM,
    dictClass: 'string',
    isSearch: true,
    isTable: true,
  },
  {
    label: '数量',
    field: 'qty'
  },
  {
    label: '替代计量单位',
    field: 'altUom',
    dictType: DICT_TYPE.UOM,
    dictClass: 'string',
    isSearch: true,
    isTable: true,
  },
  {
    label: '替代计量数量',
    field: 'altQty'
  },
  {
    label: '转换率',
    field: 'convertRate'
  },
  {
    label: '标包数量',
    field: 'stdPackQty'
  },
  {
    label: '标包单位',
    field: 'stdPackUnit',
    dictType: DICT_TYPE.PACK_UNIT,
    dictClass: 'string',
    isSearch: true,
    isTable: true,
  },
  {
    label: '仓库代码',
    field: 'toWarehouseCode'
  },
  {
    label: '月台代码',
    field: 'toDockCode'
  },
  {
    label: '库位代码',
    field: 'toLocationCode'
  },
  {
    label: '供应商代码',
    field: 'supplierCode'
  },
  {
    label: '供应商物品代码',
    field: 'supplierItemCode'
  },
  {
    label: '采购订单号',
    field: 'poNumber'
  },
  {
    label: '采购订单行',
    field: 'poLine'
  },
  {
    label: '采购计划单号',
    field: 'rpNumber'
  },
  {
    label: '发货单号',
    field: 'asnNumber'
  },
  {
    label: '生产订单号',
    field: 'woNumber'
  },
  {
    label: '生产订单行',
    field: 'woLine'
  },
  {
    label: '生产线代码',
    field: 'productionLineCode'
  },
  {
    label: '班组代码',
    field: 'teamCode'
  },
  {
    label: '班次代码',
    field: 'shiftCode'
  },
  {
    label: '客户代码',
    field: 'customerCode'
  },
  {
    label: '客户月台代码',
    field: 'customerDockCode'
  },
  {
    label: '客户物品代码',
    field: 'customerItemCode'
  },
  {
    label: '销售订单号',
    field: 'soNumber'
  },
  {
    label: '销售订单行',
    field: 'soLine'
  },
  {
    label: '质量等级',
    field: 'eqLevel'
  },
  {
    label: '货主',
    field: 'ownerCode'
  },
  {
    label: '重量',
    field: 'weight'
  },
  {
    label: '面积',
    field: 'area'
  },
  {
    label: '体积',
    field: 'volume'
  },
]))

/**
 * @returns {Array} 预计出库存
 */
export const Expectout = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '任务号',
    field: 'jobNumber'
  },
  {
    label: '业务类型',
    field: 'businessType'
  },
  {
    label: '包装号',
    field: 'packingNumber'
  },
  {
    label: '物料代码',
    field: 'itemCode'
  },
  {
    label: '批次',
    field: 'batch'
  },
  {
    label: '库存状态',
    field: 'inventoryStatus',
    dictType: DICT_TYPE.INVENTORY_STATUS,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '计量单位',
    field: 'uom',
    dictType: DICT_TYPE.UOM,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '数量',
    field: 'qty'
  },
  {
    label: '库位代码',
    field: 'locationCode'
  },
  {
    label: '仓库代码',
    field: 'warehouseCode'
  },
  {
    label: '货主代码',
    field: 'ownerCode'
  },
]))

/**
 * @returns {Array} 预计入库存
 */
export const Expectin = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '任务号',
    field: 'jobNumber'
  },
  {
    label: '业务类型',
    field: 'businessType'
  },
  {
    label: '物料代码',
    field: 'itemCode'
  },
  {
    label: '批次',
    field: 'batch'
  },
  {
    label: '库存状态',
    field: 'inventoryStatus',
    dictType: DICT_TYPE.INVENTORY_STATUS,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '计量单位',
    field: 'uom',
    dictType: DICT_TYPE.UOM,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '数量',
    field: 'qty'
  },
  {
    label: '库位代码',
    field: 'locationCode'
  },
  {
    label: '仓库代码',
    field: 'warehouseCode'
  },
  {
    label: '货主代码',
    field: 'ownerCode'
  },
]))

/**
 * @returns {Array} 库存余额
 */
export const Balance = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '包装号',
    field: 'packingNumber'
  },
  {
    label: '器具代码',
    field: 'containerNumber'
  },
  {
    label: '物料代码',
    field: 'itemCode'
  },
  {
    label: '批次',
    field: 'batch'
  },
  {
    label: '替代批次',
    field: 'altBatch'
  },
  {
    label: '到货日期',
    field: 'arriveDate',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '生产日期',
    field: 'produceDate',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '失效日期',
    field: 'expireDate',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '库存状态',
    field: 'inventoryStatus',
    dictType: DICT_TYPE.INVENTORY_STATUS,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '库位代码',
    field: 'locationCode'
  },
  {
    label: '库位组代码',
    field: 'locationGroupCode'
  },
  {
    label: '库区代码',
    field: 'areaCode'
  },
  {
    label: '仓库代码',
    field: 'warehouseCode'
  },
  {
    label: 'ERP库位代码',
    field: 'erpLocationCode',
    dictType: DICT_TYPE.ERP_LOCATION,
    dictClass: 'string',
    isTable: true,
    isSearch: true
  },
  {
    label: '货主代码',
    field: 'ownerCode'
  },
  {
    label: '计量单位',
    field: 'uom',
    dictType: DICT_TYPE.UOM,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '数量',
    field: 'qty'
  },
  {
    label: '锁定数量',
    field: 'lockedQty'
  },
  {
    label: '可用数量',
    field: 'usableQty'
  },
  {
    label: '单价',
    field: 'singlePrice'
  },
  {
    label: '金额',
    field: 'amount'
  },
  {
    label: '入库时间',
    field: 'putInTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '是否冻结',
    field: 'frozen',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '冻结原因',
    field: 'frozenReason',
    dictType: DICT_TYPE.FROZEN_REASON,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '最后事务号',
    field: 'lastTransNumber'
  },
  {
    label: '重量',
    field: 'weight'
  },
  {
    label: '面积',
    field: 'area'
  },
  {
    label: '体积',
    field: 'volume'
  },
]))

/**
 * @returns {Array} 库存事务
 */
export const Transaction = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '事务号',
    field: 'number'
  },
  {
    label: '事务类型',
    field: 'transactionType'
  },
  {
    label: '库存动作',
    field: 'inventoryAction',
    dictType: DICT_TYPE.INVENTORY_ACTION,
    dictClass: 'string',
    isTable: true,
    isSearch: true
  },
  {
    label: '操作员',
    field: 'worker'
  },
  {
    label: '业务类型',
    field: 'businessType'
  },
  {
    label: '记录号',
    field: 'recordNumber'
  },
  {
    label: '生效时间',
    field: 'activeTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '物料代码',
    field: 'itemCode'
  },
  {
    label: '批次',
    field: 'batch'
  },
  {
    label: '库存状态',
    field: 'inventoryStatus',
    dictType: DICT_TYPE.INVENTORY_STATUS,
    dictClass: 'string',
    isTable: true,
    isSearch: true
  },
  {
    label: '计量单位',
    field: 'uom',
    dictType: DICT_TYPE.UOM,
    dictClass: 'string',
    isTable: true,
    isSearch: true
  },
  {
    label: '数量',
    field: 'qty'
  },
  {
    label: '单价',
    field: 'singlePrice'
  },
  {
    label: '金额',
    field: 'amount'
  },
  {
    label: '替代批次',
    field: 'altBatch'
  },
  {
    label: '到货日期',
    field: 'arriveDate',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '生产日期',
    field: 'produceDate',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '失效日期',
    field: 'expireDate',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '包装号',
    field: 'packingNumber'
  },
  {
    label: '器具号',
    field: 'containerNumber'
  },
  {
    label: '库位代码',
    field: 'locationCode'
  },
  {
    label: '仓库代码',
    field: 'warehouseCode'
  },
  {
    label: '库区代码',
    field: 'areaCode'
  },
  {
    label: '库位组代码',
    field: 'locationGroupCode'
  },
  {
    label: 'ERP库位代码',
    field: 'erpLocationCode',
    dictType: DICT_TYPE.ERP_LOCATION,
    dictClass: 'string',
    isTable: true,
    isSearch: true
  },
  {
    label: '货主代码',
    field: 'ownerCode'
  },
]))

/**
 * @returns {Array} 库存转移日志
 */
export const Transferlog = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '日志号',
    field: 'number'
  },
  {
    label: '事务类型',
    field: 'transactionType'
  },
  {
    label: '操作员',
    field: 'worker'
  },
  {
    label: '业务类型',
    field: 'businessType'
  },
  {
    label: '单据号',
    field: 'recordNumber'
  },
  {
    label: '生效时间',
    field: 'activeTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '物料代码',
    field: 'itemCode'
  },
  {
    label: '计量单位',
    field: 'uom',
    dictType: DICT_TYPE.UOM,
    dictClass: 'string',
    isTable: true,
    isSearch: true
  },
  {
    label: '数量',
    field: 'qty'
  },
  {
    label: '替代批次',
    field: 'altBatch'
  },
  {
    label: '到货日期',
    field: 'arriveDate',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '生产日期',
    field: 'produceDate',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '失效日期',
    field: 'expireDate',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '从事务号',
    field: 'fomTransactionNumber'
  },
  {
    label: '从包装号',
    field: 'fromPackingNumber'
  },
  {
    label: '从批次',
    field: 'fromBatch'
  },
  {
    label: '从库存状态',
    field: 'fromInventoryStatus',
    dictType: DICT_TYPE.INVENTORY_STATUS,
    dictClass: 'string',
    isTable: true,
    isSearch: true
  },
  {
    label: '从器具号',
    field: 'fromContainerNumber'
  },
  {
    label: '从库位代码',
    field: 'fromLocationCode'
  },
  {
    label: '从仓库代码',
    field: 'fromWarehouseCode'
  },
  {
    label: '从库区代码',
    field: 'fromAreaCode'
  },
  {
    label: '从库位组代码',
    field: 'fromLocationGroupCode'
  },
  {
    label: '从ERP库位代码',
    field: 'fromErpLocationCode',
    dictType: DICT_TYPE.ERP_LOCATION,
    dictClass: 'string',
    isTable: true,
    isSearch: true
  },
  {
    label: '从货主代码',
    field: 'fromOwnerCode'
  },
  {
    label: '到事务号',
    field: 'toTransactionNumber'
  },
  {
    label: '到包装号',
    field: 'toPackingNumber'
  },
  {
    label: '到批次',
    field: 'toBatch'
  },
  {
    label: '到库存状态',
    field: 'toInventoryStatus',
    dictType: DICT_TYPE.INVENTORY_STATUS,
    dictClass: 'string',
    isTable: true,
    isSearch: true
  },
  {
    label: '到器具号',
    field: 'toContainerNumber'
  },
  {
    label: '到库位代码',
    field: 'toLocationCode'
  },
  {
    label: '到仓库代码',
    field: 'toWarehouseCode'
  },
  {
    label: '到库区代码',
    field: 'toAreaCode'
  },
  {
    label: '到库位组代码',
    field: 'toLocationGroupCode'
  },
  {
    label: '到ERP库位代码',
    field: 'toErpLocationCode',
    dictType: DICT_TYPE.ERP_LOCATION,
    dictClass: 'string',
    isTable: true,
    isSearch: true
  },
  {
    label: '到货主代码',
    field: 'toOwnerCode'
  },
]))

/**
 * @returns {Array} 标签定义
 */
export const Labeltype = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '标签类型',
    field: 'labelType'
  },
  {
    label: '描述',
    field: 'description'
  },
  {
    label: '数据协议',
    field: 'dataProtocol'
  },
  {
    label: '拆分方法',
    field: 'splitMehod'
  },
  {
    label: '数据头',
    field: 'header'
  },
  {
    label: '版本号',
    field: 'version'
  },
  {
    label: '分隔符',
    field: 'separators'
  },
  {
    label: '校验方法',
    field: 'validateMethod'
  },
  {
    label: '校验数',
    field: 'validateNumber'
  },
  {
    label: '加密方法',
    field: 'encyptEthod'
  },
  {
    label: '压缩方法',
    field: 'compressMethod'
  },
  {
    label: '模板名称',
    field: 'templateName'
  },
  {
    label: '模板文件',
    field: 'templateFile'
  },
  {
    label: '标签代码',
    field: 'labelCode'
  },
  {
    label: '是否加密',
    field: 'isEncypt',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isTable: true,
    isSearch: true
  },
  {
    label: '是否压缩',
    field: 'isCompress',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isTable: true,
    isSearch: true
  },
]))

/**
 * @returns {Array} 条码片段
 */
export const Barcode = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '代码',
    field: 'code'
  },
  {
    label: '名称',
    field: 'name'
  },
  {
    label: '描述',
    field: 'description'
  },
  {
    label: '顺序',
    field: 'order'
  },
  {
    label: '长度',
    field: 'length'
  },
  {
    label: '前缀长度',
    field: 'prefixLenght'
  },
  {
    label: '前缀字符',
    field: 'prefixChar',
    dictType: DICT_TYPE.BARCODE_PREFIX,
    dictClass: 'string',
    isTable: true,
    isSearch: true
  },
  {
    label: '实体属性',
    field: 'entityProperties'
  },
  {
    label: '加密方法',
    field: 'encyptMethod'
  },
  {
    label: '主表ID',
    field: 'masterId'
  },
  {
    label: '截断尾部空格',
    field: 'trimEnd',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isTable: true,
    isSearch: true
  },
  {
    label: '是否加密',
    field: 'isEncypt',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isTable: true,
    isSearch: true
  },
]))

/**
 * @returns {Array} 采购订单主表
 */
export const PurchaseMain = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '供应商代码',
    field: 'supplierCode'
  },
  {
    label: '单据号',
    field: 'number'
  },
  {
    label: '订单类型',
    field: 'type',
    dictType: DICT_TYPE.PURCHASE_ORDER_TYPE,
    dictClass: 'string',
    isTable: true,
    isSearch: true
  },
  {
    label: '状态',
    field: 'status',
    dictType: DICT_TYPE.PURCHASE_ORDER_STATUS,
    dictClass: 'string',
    isTable: true,
    isSearch: true
  },
  {
    label: '订单日期',
    field: 'orderDate',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '截止日期',
    field: 'dueDate',
    isTable: true,
    formatter: dateFormatter,
    detail:{
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '版本',
    field: 'version'
  },
  {
    label: '税率',
    field: 'taxRate'
  },
  {
    label: '联系人姓名',
    field: 'contactName'
  },
  {
    label: '联系人电话',
    field: 'contactPhone'
  },
  {
    label: '联系人电子邮件',
    field: 'contactEmail'
  },
  {
    label: '是否寄存订单',
    field: 'isConsignment',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '业务类型',
    field: 'businessType'
  },
  {
    label: '当前阶段',
    field: 'currentStage'
  },
  {
    label: '是否可用',
    field: 'available',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '创建者',
    field: 'creator',
  },
  {
    label: '创建时间',
    field: 'createTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '最后更新者',
    field: 'updater',
  },
  {
    label: '最后更新时间',
    field: 'updateTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  }
]))

/**
 * @returns {Array} 采购订单子表
 */
export const PurchaseDetail = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '行号',
    field: 'lineNumber'
  },
  {
    label: 'ERP库位',
    field: 'erpLocationCode'
  },
  {
    label: '项目代码',
    field: 'projectCode'
  },
  {
    label: '标包数量',
    field: 'stdPackQty'
  },
  {
    label: '标包单位',
    field: 'stdPackUnit',
    dictType: DICT_TYPE.PACK_UNIT,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '供应商计量数量',
    field: 'supplierQty'
  },
  {
    label: '供应商计量单位',
    field: 'supplierUom',
    dictType: DICT_TYPE.UOM,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
   label: '转换率',
   field: 'convertRate' 
  },
  {
    label: '已发货数量',
    field: 'shippedQty'
  },
  {
    label: '已收货数量',
    field: 'receivedQty'
  },
  {
    label: '已退货数量',
    field: 'returnedQty'
  },
  {
    label: '已上架数量',
    field: 'putawayQty'
  },
  {
    label: '超收百分比',
    field: 'overReceivingPercent'
  },
  {
    label: '单价',
    field: 'singlePrice'
  },
  {
    label: '金额',
    field: 'amount'
  },
  {
    label: '订单数量',
    field: 'orderQty'
  },
  {
    lable: '计量单位',
    field: 'uom',
    dictType: DICT_TYPE.UOM,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '单据号',
    field: 'nuumber'
  },
  {
    label: '物品代码',
    field: 'itemCode'
  },
  {
    label: 'status',
    field: '明细状态',
    dictType: DICT_TYPE.PURCHASE_ORDER_DETAIL_STATUS,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '备注',
    fielc: 'remark'
  },
  {
    label: '是否可用',
    field: 'available',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '创建者',
    field: 'creator',
  },
  {
    label: '创建时间',
    field: 'createTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '最后更新者',
    field: 'updater',
  },
  {
    label: '最后更新时间',
    field: 'updateTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  }
]))

/**
 * @returns {Array} 采购索赔申请主表
 */
export const PurchaseclaimRequestMain = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '发货单号',
    field: 'asnNumber'
  },
  {
    label: '要货计划单号',
    field: 'ppNumber'
  },
  {
    label: '供应商代码',
    field: 'supplierCode'
  },
  {
    label: '单据号',
    field: 'number'
  },
  {
    label: '业务类型',
    field: 'businessType'
  },
  {
    label: '申请时间',
    field: 'requestTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '截止时间',
    field: 'dueTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '部门',
    field: 'departmentCode'
  },
  {
    label: '状态',
    field: 'status',
    dictType: DICT_TYPE.REQUEST_STATUS,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建者',
    field: 'creator',
  },
  {
    label: '创建时间',
    field: 'createTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '最后更新者',
    field: 'updater',
  },
  {
    label: '最后更新时间',
    field: 'updateTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '自动提交',
    field: 'autoCommit',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '自动通过',
    field: 'autoAgree',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '自动执行',
    field: 'autoExecute',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '跳过任务直接删生成记录',
    field: 'directCreateRecord',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  }
]))

/**
 * @returns {Array} 采购索赔申请子表
 */
export const PurchaseclaimRequestDetail = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '批次',
    field: 'batch',
    tableForm:{
      isInpuFocusShow:true
    }
  },
  {
    label: '替代批次',
    field: 'altBatch'
  },
  {
    label: '订单号',
    field: 'poNumber'
  },
  {
    label: '订单行',
    field: 'poLine'
  },
  {
    label: '原因',
    field: 'reason',
    dictType: DICT_TYPE.PURCHASE_RETURN_REASON,
    dictClass: 'string',
    tableForm:{
      type:'Select',
    }
  },
  {
    label: '单价',
    field: 'singlePrice'
  },
  {
    label: '金额',
    field: 'amount',
    tableForm:{
      type:'number',
    }
  },
  {
    label: '单据号',
    field: 'number'
  },
  {
    label: '物品代码',
    field: 'itemCode'
  },
  {
    label: '物品名称',
    field: 'itemname'
  },
  {
    label: '物品描述1',
    field: 'itemDesc1'
  },
  {
    label: '物品描述2',
    field: 'itemDesc2'
  },
  {
    label: '项目代码',
    field: 'projectCode'
  },
  {
    label: '数量',
    field: 'qty'
  },
  {
    label: '计量单位',
    field: 'uom'
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建者',
    field: 'creator',
    isTableForm:false
  },
  {
    label: '创建时间',
    field: 'createTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    },
    isTableForm:false
  },
  {
    label: '最后更新者',
    field: 'updater',
    isTableForm:false
  },
  {
    label: '最后更新时间',
    field: 'updateTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    },
    isTableForm:false
  },
]))

export const PurchaseclaimRequestDetailRules = reactive({
  batch: [
    { required: true, message: '请输入批次', trigger: 'blur' }
  ],
  poNumber:  [
    { required: true, message: '请输入订单号码', trigger: 'blur' }
  ],
  amount:  [
    { required: true, message: '请输入金额', trigger: 'blur' },
    { validator: validateTwoNum, trigger: "blur"}
  ],
})

/**
 * @returns {Array} 采购索赔记录主表
 */
export const PurchaseclaimRecordMain = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '申请单号',
    field: 'requestNumber'
  },
  {
    label: '发货单号',
    field: 'asnNumber'
  },
  {
    label: '要货计划单号',
    field: 'ppNumber'
  },
  {
    label: '供应商代码',
    field: 'supplierCode'
  },
  {
    label: '出库事务类型',
    field: 'outTransactionType'
  },
  {
    label: '入库事务类型',
    field: 'inTransactionType'
  },
  {
    label: '执行时间',
    field: 'executeTime',
    isTable: true,
    formatter: dateFormatter,
    deatil: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '生效日期',
    field: 'activeDate',
    isTable: true,
    formatter: dateFormatter,
    deatil: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '申请时间',
    field: 'requestTime',
    isTable: true,
    formatter: dateFormatter,
    deatil: {
      dateFormatter: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '截止时间',
    field: 'dueTime',
    isTable: true,
    formatter: dateFormatter,
    deatil: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '部门',
    field: 'departmentCode'
  },
  {
    label: '代码',
    field: 'code'
  },
  {
    label: '接口类型',
    field: 'interfaceType',
    dictType: DICT_TYPE.INTERFACE_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '是否可用',
    field: 'available',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '创建者',
    field: 'creator',
  },
  {
    label: '创建时间',
    field: 'createTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
]))

/**
 * @returns {Array} 采购索赔记录子表
 */

export const PurchaseclaimRecordDetail = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '批次',
    field: 'batch'
  },
  {
    label: '替代批次',
    field: 'altBatch'
  },
  {
    label: '订单号',
    field: 'poNumber'
  },
  {
    label: '订单行',
    field: 'poLine'
  },
  {
    label: '原因',
    field: 'reason',
    isSearch: true,
    isTable: true,
    dictType: DICT_TYPE.PURCHASE_RETURN_REASON,
    dictClass: 'string'
  },
  {
    label: '单价',
    field: 'singlePrice'
  },
  {
    label: '金额',
    field: 'amount'
  },
  {
    label: '单据号',
    field: 'number'
  },
  {
    label: '代码',
    field: 'code'
  },
  {
    label: '接口类型',
    field: 'interfaceType',
    dictType: DICT_TYPE.INTERFACE_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '任务明细ID',
    field: 'jobDetailId'
  },
  {
    label: '是否可用',
    field: 'available',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '创建者',
    field: 'creator',
  },
  {
    label: '创建时间',
    field: 'createTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
]))

/**
 * @returns {Array} 供应商发票申请主表
 */
export const SupplierinvoiceRequestMain = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '供应商代码',
    field: 'supplierCode'
  },
  {
    label: '调增金额',
    field: 'adjustAmount'
  },
  {
    label: '单据号',
    field: 'number'
  },
  {
    label: 'businessType',
    field: '业务类型'
  },
  {
    label: '申请时间',
    field: 'requestTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '截止时间',
    field: 'dueTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '部门',
    field: 'departmentCode'
  },
  {
    label: '状态',
    field: 'status',
    dictType: DICT_TYPE.REQUEST_STATUS,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建者',
    field: 'creator',
  },
  {
    label: '创建时间',
    field: 'createTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '最后更新者',
    field: 'updater',
  },
  {
    label: '最后更新时间',
    field: 'updateTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '自动提交',
    field: 'autoCommit',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '自动通过',
    field: 'autoAgree',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '自动执行',
    field: 'autoExecute',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '跳过任务直接删生成记录',
    field: 'directCreateRecord',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  }
]))

/**
 * @returns {Array} 供应商发票申请子表
 */
export const SupplierinvoiceRequestDetail = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '收货单号',
    field: 'recordNumber'
  },
  {
    label: '货主代码',
    field: 'ownerCode'
  },
  {
    label: '包装号',
    field: 'packingNumber'
  },
  {
    label: '器具号',
    field: 'containerNumber'
  },
  {
    label: '批次',
    field: 'batch'
  },
  {
    label: '替代批次',
    field: 'altBatch'
  },
  {
    label: '订单号',
    field: 'poNumber'
  },
  {
    label: '订单行',
    field: 'poLine'
  },
  {
    label: '标包数量',
    field: 'stdPackQty'
  },
  {
    label: '标包单位',
    field: 'stdPackUnit',
    dictType: DICT_TYPE.PACK_UNIT,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '供应商计量数量',
    field: 'supplierPackQty'
  },
  {
    label: '供应商计量单位',
    field: 'supplierPackUnit',
    dictType: DICT_TYPE.UOM,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '转换率',
    field: 'convertRate'
  },
  {
    label: '单价',
    field: 'singlePrice'
  },
  {
    label: '金额',
    field: 'amount'
  },
  {
    label: '单据号',
    field: 'number'
  },
  {
    label: '物品代码',
    field: 'itemCode'
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建时间',
    field: 'createTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建者',
    field: 'creator'
  },
]))

/**
 * @returns {Array} 供应商发票记录主表
 */
export const SupplierinvoiceRecordMain = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '申请单号',
    field: 'requestNumber'
  },
  {
    label: '供应商代码',
    field: 'supplierCode'
  },
  {
    label: '调增金额',
    field: 'adjustAmount'
  },
  {
    label: '单据号',
    field:'number'
  },
  {
    label: '业务类型',
    field:'businessType'
  },
  {
    label: '出库事务类型',
    field: 'outTransactionType'
  },
  {
    label: '入库事务类型',
    field: 'inTransactionType'
  },
  {
    label: '执行时间',
    field: 'executeTime',
    isTable: true,
    formatter: dateFormatter,
    deatil: {
      dateFormatter: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '生效日期',
    field: 'activeDate',
    isTable: true,
    formatter: dateFormatter,
    deatil: {
      dateFormatter: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '申请时间',
    field: 'requestTime',
    isTable: true,
    formatter: dateFormatter,
    deatil: {
      dateFormatter: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '截止时间',
    field: 'dueTime',
    isTable: true,
    formatter: dateFormatter,
    deatil: {
      dateFormatter: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '部门',
    field: 'departmentCode'
  },
  {
    label: '代码',
    field: 'code'
  },
  {
    label: '接口类型',
    field: 'interfaceType',
    dictType: DICT_TYPE.INTERFACE_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '是否可用',
    field: 'available',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '创建者',
    field: 'creator',
  },
  {
    label: '创建时间',
    field: 'createTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
]))

/**
 * @returns {Array} 供应商发票记录子表
 */
export const SupplierinvoiceRecordDetail = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '收货单号',
    field: 'recordNumber'
  },
  {
    label: '包装号',
    field: 'packingNumber'
  },
  {
    label: '器具号',
    field: 'containerNumber'
  },
  {
    label: '批次',
    field: 'batch'
  },
  {
    label: '替代批次',
    field: 'altBatch'
  },
  {
    label: '订单号',
    field: 'poNumber'
  },
  {
    label: '订单行',
    field: 'poLine'
  },
  {
    label: '标包数量',
    field: 'stdPackQty'
  },
  {
    label: '标包单位',
    field: 'stdPackUnit',
    dictType: DICT_TYPE.PACK_UNIT,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '供应商计量数量',
    field: 'supplierPackQty'
  },
  {
    label: '供应商计量单位',
    field: 'supplierPackUnit',
    dictType: DICT_TYPE.UOM,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '转换率',
    field: 'convertRate'
  },
  {
    label: '单价',
    field: 'singlePrice'
  },
  {
    label: '金额',
    field: 'amount'
  },
  {
    label: '单据号',
    field: 'number'
  },
  {
    label: '物品代码',
    field: 'itemCode'
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建时间',
    field: 'createTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建者',
    field: 'creator'
  },
  {
    label: '物品名称',
    field: 'itemName'
  },
  {
    label: '物品描述1',
    field: 'itemDesc1'
  },
  {
    label: '物品描述2',
    field: 'itemDesc2'
  },
  {
    label: '项目代码',
    field: 'projectCode'
  },
  {
    label: '数量',
    field: 'qty'
  },
  {
    label: '计量单位',
    field: 'uom',
    dictType: DICT_TYPE.UOM,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '代码',
    field: 'code'
  },
  {
    label: '接口类型',
    field: 'interfaceType',
    dictType: DICT_TYPE.INTERFACE_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '任务明细ID',
    field: 'jobDetailId'
  },
]))

/**
 * @returns {Array} 要货预测主表
 */
export const DemandforecastingMain = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '供应商代码',
    field: 'supplierCode'
  },
  {
    label: '版本号',
    field: 'version'
  },
  {
    label: '发布时间',
    field: 'publishTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '开始时间',
    field: 'beginTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '结束时间',
    field: 'endTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '单据号',
    field: 'number'
  },
  {
    label: '业务类型',
    field: 'businessType'
  },
  {
    label: '状态',
    field: 'status'
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建时间',
    field: 'createTime',
    isTable: true,
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建者',
    field: 'creator'
  },
  {
    label: '是否可用',
    field: 'available',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
]))

/**
 * @returns {Array} 要货预测子表
 */
export const DemandforecastingDetail = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '预测时间类型',
    field: 'predictTimeType',
    dictType: DICT_TYPE.PACK_UNIT,
    dictClass: 'string'
  },
  {
    label: '预测日期',
    field: 'predictTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '单据号',
    field: 'number'
  },
  {
    label: '物品代码',
    field: 'itremCode'
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建时间',
    field: 'createTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建者',
    field: 'creator'
  },
  {
    label: '计划数量',
    field: 'planQty'
  },
  {
    label: '计量单位',
    field: 'uom',
    dictType: DICT_TYPE.UOM,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '最后更新时间',
    field: 'updateTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '最后更新者',
    field: 'updater'
  }
]))

/**
 * @returns {Array} 供应商发货申请主表
 */
export const SupplierdeliverRequestMain = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '要货计划单号',
    field: 'ppNumber'
  },
  {
    label: '发货单号',
    field: 'asnNumber'
  },
  {
    label: '供应商代码',
    field: 'supplierCode'
  },
  {
    label: '联系人姓名',
    field: 'contactName'
  },
  {
    label: '联系人电话',
    field: 'contactPhone'
  },
  {
    label: '联系人电子邮件',
    field: 'contactEmail'
  },
  {
    label: '从仓库代码',
    field: 'fromWarehouseCode'
  },
  {
    label: '到仓库代码',
    field: 'toWarehouseCode'
  },
  {
    label: '到月台代码',
    field: 'toDockCode'
  },
  {
    label: '时间窗口',
    field: 'timeWindow'
  },
  {
    label: '计划到货时间',
    field: 'planArriveTime'
  },
  {
    label: '承运商',
    field: 'carrierCode'
  },
  {
    label: '运输方式',
    field: 'transferMode'
  },
  {
    label: '车牌号',
    field: 'vehiclePlateNumber'
  },
  {
    label: '单据号',
    field: 'number'
  },
  {
    label: '业务类型',
    field: 'businessType'
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建时间',
    field: 'createTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建者',
    field: 'creator'
  },
  {
    label: '申请时间',
    field: 'requestTime',
    formatter: dateFormatter,
    detaul: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '截止时间',
    field: 'dueTime',
    formatter: dateFormatter,
    detaul: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '部门',
    field: 'departmentCode'
  },
  {
    label: '状态',
    field: 'status',
    dictType: DICT_TYPE.REQUEST_STATUS,
    dictClass: 'string',
    isSearch:true,
    isTable:true
  },
  {
    label: '最后更新时间',
    field: 'updateTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '最后更新者',
    field: 'updater'
  },
  {
    label: '自动提交',
    field: 'autoCommit',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '自动通过',
    field: 'autoAgree',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '自动执行',
    field: 'autoExecute',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '直接生成记录',
    field: 'directCreateRecord',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  }
]))

/**
 * @returns {Array} 供应商发货申请子表
 */
export const SupplierdeliverRequestDetail = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '包装号',
    field: 'packingNumber'
  },
  {
    label: '器具号',
    field: 'containerNumber'
  },
  {
    label: '批次',
    field: 'batch'
  },
  {
    label: '替代批次',
    field: 'altBatch'
  },
  {
    label: '到货日期',
    field: 'produceDate',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '生产日期',
    field: 'expireDate',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '过期日期',
    field: 'expireDate',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '订单号',
    field: 'poNumber'
  },
  {
    label: '订单行',
    field: 'poLine'
  },
  {
    label: '标包数量',
    field: 'stdPackQty'
  },
  {
    label: '标包单位',
    field: 'stdPackUnit',
    dictType: DICT_TYPE.PACK_UNIT,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '供应商计量数量',
    field: 'supplierPackQty'
  },
  {
    label: '供应商计量单位',
    field: 'supplierPackUnit',
    dictType: DICT_TYPE.UOM,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '转换率',
    field: 'convertRate'
  },
  {
    label: '单据号',
    field: 'number'
  },
  {
    label: '物品代码',
    field: 'itemCode'
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '从货主代码',
    field: 'fromOwnerCode'
  },
  {
    label: '到货主代码',
    field: 'toOwnerCode'
  },
  {
    label: '物品名称',
    field: 'itemName'
  },
  {
    label: '物品描述1',
    field: 'itemDesc1'
  },
  {
    label: '物品描述2',
    field: 'itemDesc2'
  },
  {
    label: '数量',
    field: 'qty'
  },
  {
    label: '计量单位',
    field: 'uom'
  },
  {
    label: '项目代码',
    field: 'projectCode'
  },
  {
    label: '创建时间',
    field: 'createTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建者',
    field: 'creator'
  },
  {
    label: '最后更新时间',
    field: 'updateTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '最后更新者',
    field: 'updater'
  },
]))

/**
 * @returns {Array} 供应商发货记录主表
 */
export const SupplierdeliverRecordMain = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '申请单号',
    field: 'requestNumber'
  },
  {
    label: '要货计划单号',
    field: 'ppNumber0'
  },
  {
    label: '发货单号',
    field: 'asnNumber'
  },
  {
    label: '供应商代码',
    field: 'supplierCode'
  },
  {
    label: '联系人姓名',
    field: 'contactName'
  },
  {
    label: '联系人电话',
    field: 'contactPhone'
  },
  {
    label: '联系人电子邮件',
    field: 'contactEmail'
  },
  {
    label: '从仓库代码',
    field: 'fromWarehouseCode'
  },
  {
    label: '到仓库代码',
    field: 'toWarehouseCode'
  },
  {
    label: '到月台代码',
    field: 'toDockCode'
  },
  {
    label: '时间窗口',
    field: 'timeWindow'
  },
  {
    label: '计划到货时间',
    field: 'planArriveTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '承运商',
    field: 'carrierCode'
  },
  {
    label: '运输方式',
    field: 'transferMode'
  },
  {
    label: '车牌号',
    field: 'vehiclePlateNumber'
  },
  {
    label: '出库事务类型',
    field: 'outTransaction'
  },
  {
    label: '入库事务类型',
    field: 'inTransaction'
  },
  {
    label: '执行时间',
    field: 'executeTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '生效日期',
    field: 'activeDate',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '申请时间',
    field: 'requestTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '截止时间',
    field: 'dueTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '部门',
    field: 'departmentCode'
  },
  {
    label: '接口类型',
    field: 'interfaceType',
    dictType: DICT_TYPE.INTERFACE_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '单据号',
    field: 'number'
  },
  {
    label: '业务类型',
    field: 'businessType'
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建时间',
    field: 'createTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建者',
    field: 'creator'
  },
  {
    label: '是否可用',
    field: 'available',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
]))

/**
 * @returns {Array} 供应商发货记录子表
 */
export const SupplierdeliverRecordDetail = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '从包装号',
    field: 'fromPackingNumber'
  },
  {
    label: '到包装号',
    field: 'toPackingNumber'
  },
  {
    label: '从批次',
    field: 'fromBatch'
  },
  {
    label: '到批次',
    field: 'toBatch'
  },
  {
    label: '替代批次',
    field: 'altBatch'
  },
  {
    label: '从器具号',
    field: 'fromContainerNumber'
  },
  {
    label: '到器具号',
    field: 'toContainerNumber'
  },
  {
    label: '到货日期',
    field: 'arriveDate',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '生产日期',
    field: 'produceDate',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '过期日期',
    field: 'expireDate',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '订单号',
    field: 'poNumber'
  },
  {
    label: '订单行',
    field: 'poLine'
  },
  {
    label: '标包数量',
    field: 'stdPackQty'
  },
  {
    label: '标包单位',
    field: 'stdPackUnit',
    dictType: DICT_TYPE.PACK_UNIT,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '供应商计量数量',
    field: 'supplierQty'
  },
  {
    label: '供应商计量单位',
    field: 'supplierUom',
    dictType: DICT_TYPE.UOM,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '从库位代码',
    field: 'fromLocationCode'
  },
  {
    label: '到库位代码',
    field: 'toLocationCode'
  },
  {
    label: '从库位组代码',
    field: 'fromLocationGroupCode'
  },
  {
    label: '到库位组代码',
    field: 'toLocationGroupCode'
  },
  {
    label: '从库区代码',
    field: 'fromAreaCode'
  },
  {
    label: '到库区代码',
    field: 'toAreaCode'
  },
  {
    label: '从货主代码',
    field: 'fromOwnerCode'
  },
  {
    label: '到货主代码',
    field: 'toOwnerCode'
  },
  {
    label: '物品代码',
    field: 'itemCode'
  },
  {
    label: '物品名称',
    field: 'itemName'
  },
  {
    label: '物品描述1',
    field: 'itemDesc1'
  },
  {
    label: '物品描述2',
    field: 'itemDesc2'
  },
  {
    label: '项目代码',
    field: 'projectCode'
  },
  {
    label: '数量',
    field: 'qty'
  },
  {
    label: '计量单位',
    field: 'uom',
    dictType: DICT_TYPE.UOM,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '单据号',
    field: 'number'
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建时间',
    field: 'createTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建者',
    field: 'creator'
  },
  {
    label: '任务明细ID',
    field: 'jobDetailId'
  },
]))

/**
 * @returns {Array} 采购收货申请主表
 */
export const PurchasereceiptRequestMain = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '发货单号',
    field: 'asnNumber'
  },
  {
    label: '要货计划单号',
    field: 'ppNumber'
  },
  {
    label: '供应商代码',
    field: 'supplierCode'
  },
  {
    label: '承运商',
    field: 'carrierCode'
  },
  {
    label: '运输方式',
    field: 'transferMode'
  },
  {
    label: '车牌号',
    field: 'vehiclePlateNumber'
  },
  {
    label: '从仓库代码',
    field: 'fromWarehouseCode'
  },
  {
    label: '到仓库代码',
    field: 'toWarehouseCode'
  },
  {
    label: '从库位类型范围',
    field: 'fromLocationTypes',
    dictType: DICT_TYPE.LOCATION_TYPE,
    dictClass: 'string'
  },
  {
    label: '到库位类型范围',
    field: 'toLocationTypes'
  },
  {
    label: '从库区代码范围',
    field: 'fromAreaCodes'
  },
  {
    label: '到库区代码范围',
    field: 'toAreaCodes'
  },
  {
    label: '到月台代码',
    field: 'toDockCode'
  },
  {
    label: '单据号',
    field: 'number'
  },
  {
    label: '业务类型',
    field: 'businessType'
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建时间',
    field: 'createTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建者',
    field: 'creator'
  },
  {
    label: '最后更新时间',
    field: 'updateTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '最后更新者',
    field: 'updater'
  },
  {
    label: '申请时间',
    field: 'requestTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '截止时间',
    field: 'dueTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '部门',
    field: 'departmentCode'
  },
  {
    label: '状态',
    field: 'status',
    dictType: DICT_TYPE.REQUEST_STATUS,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '自动提交',
    field: 'autoCommit',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '自动通过',
    field: 'autoAgree',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '自动执行',
    field: 'autoExecute',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '直接生成记录',
    field: 'directCreateRecord',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
]))

/**
 * @returns {Array} 采购收货申请子表
 */
export const PurchasereceiptRequestDetail = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '包装号',
    field: 'packingNumber'
  },
  {
    label: '器具号',
    field: 'containerNumber'
  },
  {
    label: '批次',
    field: 'batch'
  },
  {
    label: '替代批次',
    field: 'altBatch'
  },
  {
    label: '到货日期',
    field: 'arriveDate',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '生产日期',
    field: 'produceDate',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '过期日期',
    field: 'expireDate',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '库存状态',
    field: 'inventoryStatus',
    dictType: DICT_TYPE.INVENTORY_STATUS,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '从库位代码',
    field: 'fromLocationCode'
  },
  {
    label: '订单号',
    field: 'poNumber'
  },
  {
    label: '订单行',
    field: 'poLine'
  },
  {
    label: '标包数量',
    field: 'stdPackQty'
  },
  {
    label: '标包单位',
    field: 'stdPackUnit',
    dictType: DICT_TYPE.PACK_UNIT,
    dictClass: 'string'
  },
  {
    label: '供应商计量数量',
    field: 'supplierPackQty'
  },
  {
    label: '供应商计量单位',
    field: 'supplierPackUnit',
    dictType: DICT_TYPE.PACK_UNIT,
    dictClass: 'string'
  },
  {
    label: '转换率',
    field: 'convertRate'
  },
  {
    label: '单据号',
    field: 'number'
  },
  {
    label: '物品代码',
    field: 'itemCode'
  },
  {
    label: '物品名称',
    field: 'itemName'
  },
  {
    label: '物品描述1',
    field: 'itemDesc1'
  },
  {
    label: '物品描述2',
    field: 'itemDesc2'
  },
  {
    label: '项目代码',
    field: 'projectCode'
  },
  {
    label: '数量',
    field: 'qty'
  },
  {
    label: '计量单位',
    field: 'uom',
    dictType: DICT_TYPE.UOM,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '从货主代码',
    field: 'fromOwnerCode'
  },
  {
    label: '到货主代码',
    field: 'toOwnerCode'
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建者',
    field: 'creator'
  },
  {
    label: '创建时间',
    field: 'createTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '最后更新者',
    field: 'updater'
  },
  {
    label: '最后更新时间',
    field: 'updateTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  }
]))

/**
 * @returns {Array} 采购收货任务主表
 */
export const PurchasereceiptJobMain = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '申请单号',
    field: 'requestNumber'
  },
  {
    label: '发货单号',
    field: 'asnNumber'
  },
  {
    label: '要货计划单号',
    field: 'ppNumber'
  },
  {
    label: '供应商代码',
    field: 'supplierCode'
  },
  {
    label: '到月台代码',
    field: 'toDockCode'
  },
  {
    label: '承运商',
    field: 'carrierCode'
  },
  {
    label: '运输方式',
    field: 'transferMode'
  },
  {
    label: '车牌号',
    field: 'vehiclePlateNumber'
  },
  {
    label: '从仓库代码',
    field: 'fromWarehouseCode'
  },
  {
    label: '到仓库代码',
    field: 'toWarehouseCode'
  },
  {
    label: '申请时间',
    field: 'requestTime'
  },
  {
    label: '要求截止时间',
    field: 'requestDueTime'
  },
  {
    label: '状态',
    field: 'status',
    dictType: DICT_TYPE.JOB_STATUS,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '过期时间',
    field: 'expiredTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '状态',
    field: 'jobStageStatus'
  },
  {
    label: '优先级',
    field: 'priority'
  },
  {
    label: '优先级增量',
    field: 'priorityIncrement'
  },
  {
    label: '部门',
    field: 'departmentCode'
  },
  {
    label: '岗位',
    field: 'userPositionCode'
  },
  {
    label: '承接人',
    field: 'acceptUserId'
  },
  {
    label: '承接时间',
    field: 'acceptTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '完成人',
    field: 'completeUserId'
  },
  {
    label: '完成时间',
    field: 'completeTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '从库位类型范围',
    field: 'fromLocationTypes',
    dictType: DICT_TYPE.LOCATION_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '到库位类型范围',
    field: 'toLocationTypes',
    dictType: DICT_TYPE.LOCATION_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '从库区代码范围',
    field: 'fromAreaCodes'
  },
  {
    label: '到库区代码范围',
    field: 'toAreaCodes'
  },
  {
    label: '单据号',
    field: 'number'
  },
  {
    label: '业务类型',
    field: 'businessType'
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建者',
    field: 'creator'
  },
  {
    label: '创建时间',
    field: 'createTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '最后更新者',
    field: 'updater'
  },
  {
    label: '最后更新时间',
    field: 'updateTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '自动完成',
    field: 'autoComplete',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '允许修改库位',
    field: 'allowModifyLocation',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '允许修改数量',
    field: 'allowModifyQty',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '允许大于推荐数量',
    field: 'allowBiggerQty',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '允许小于推荐数量',
    field: 'allowSmallerQty',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '允许修改库存状态',
    field: 'allowModifyInventoryStatus',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '允许连续扫描',
    field: 'allowContinuousScanning',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '允许部分完成',
    field: 'allowPartialComplete',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '允许修改批次',
    field: 'allowModifyBatch',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '允许修改箱码',
    field: 'allowModifyPackingNumber',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  }
]))

/**
 * @returns {Array} 采购收货任务子表
 */
export const PurchasereceiptJobDetail = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '包装号',
    field: 'packingNumber'
  },
  {
    label: '器具号',
    field: 'containerNumber'
  },
  {
    label: '批次',
    field: 'batch'
  },
  {
    label: '替代批次',
    field: 'altBatch'
  },
  {
    label: '到货日期',
    field: 'arriveDate',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '生产日期',
    field: 'produceDate',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '过期日期',
    field: 'expireDate',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '库存状态',
    field: 'inventoryStatus',
    dictType: DICT_TYPE.INVENTORY_STATUS,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '从库位代码',
    field: 'fromLocationCode'
  },
  {
    label: '到库位代码',
    field: 'toLocationCode'
  },
  {
    label: '订单号',
    field: 'poNumber'
  },
  {
    label: '订单行',
    field: 'poLine'
  },
  {
    label: '标包数量',
    field: 'stdPackQty'
  },
  {
    label: '标包单位',
    field: 'stdPackUnit',
    dictType: DICT_TYPE.PACK_UNIT,
    dictClass: 'string'
  },
  {
    label: '供应商计量数量',
    field: 'supplierQty'
  },
  {
    label: '供应商计量单位',
    field: 'supplierUom',
    dictType: DICT_TYPE.UOM,
    dictClass: 'string'
  },
  {
    label: '转换率',
    field: 'convertRate'
  },
  {
    label: '从货主代码',
    field: 'fromOwnerCode'
  },
  {
    label: '到货主代码',
    field: 'toOwnerCode'
  },
  {
    label: '物品代码',
    field: 'itemCode'
  },
  {
    label: '物品名称',
    field: 'itemName'
  },
  {
    label: '物品描述1',
    field: 'itemDesc1'
  },
  {
    label: '物品描述2',
    field: 'itemDesc2'
  },
  {
    label: '项目代码',
    field: 'projectCode'
  },
  {
    label: '数量',
    field: 'qty'
  },
  {
    label: '计量单位',
    field: 'uom'
  },
  {
    label: '单据号',
    field: 'number'
  },
  {
    label: '备注',
    fiield: 'remark'
  },
  {
    label: '创建者',
    field: 'creator'
  },
  {
    label: '创建时间',
    field: 'createTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
]))

/**
 * @returns {Array} 采购收货记录主表
 */
export const PurchasereceiptRecordMain = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '申请单号',
    field: 'requestNumber'
  },
  {
    label: '任务单号',
    field: 'jobNumber'
  },
  {
    label: '发货单号',
    field: 'asnNumber'
  },
  {
    label: '要货计划单号',
    field: 'ppNumber'
  },
  {
    label: '供应商代码',
    field: 'supplierCode'
  },
  {
    label: '到月台代码',
    field: 'toDockCode'
  },
  {
    label: '承运商',
    field: 'carrierCode'
  },
  {
    label: '运输方式',
    field: 'transferMode'
  },
  {
    label: '车牌号',
    field: 'vehiclePlateNumber'
  },
  {
    label: '从仓库代码',
    field: 'fromWarehouseCode'
  },
  {
    label: '到仓库代码',
    field: 'toWarehouseCode'
  },
  {
    label: '从库位类型范围',
    field: 'fromLocationTypes',
    dictType: DICT_TYPE.LOCATION_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '到库位类型范围',
    field: 'toLocationTypes',
    dictType: DICT_TYPE.LOCATION_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '从库区代码范围',
    field: 'fromAreaCodes'
  },
  {
    label: '到库区代码范围',
    field: 'toAreaCodes'
  },
  {
    label: '出库事务类型',
    field: 'outTransaction'
  },
  {
    label: '入库事务类型',
    field: 'inTransaction'
  },
  {
    label: '执行时间',
    field: 'executeTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '生效日期',
    field: 'activeDate',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '申请时间',
    field: 'requestTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '截止时间',
    field: 'dueTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '部门',
    field: 'departmentCode'
  },
  {
    label: '代码',
    field: 'code'
  },
  {
    label: '接口类型',
    field: 'interfaceType',
    dictType: DICT_TYPE.INTERFACE_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '单据号',
    field: 'number'
  },
  {
    label: '业务类型',
    field: 'businessType'
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建者',
    field: 'creator'
  },
  {
    label: '创建时间',
    field: 'createTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '是否可用',
    field: 'available',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  }
]))

/**
 * @returns {Array} 采购收货记录子表
 */
export const PurchasereceiptRecordDetail = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '从包装号',
    field: 'fromPackingNumber'
  },
  {
    label: '到包装号',
    field: 'toPackingNumber'
  },
  {
    label: '从器具号',
    field: 'fromContainerNumber'
  },
  {
    label: '到器具号',
    field: 'toContainerNumber'
  },
  {
    label: '从批次',
    field: 'fromBatch'
  },
  {
    label: '到批次',
    field: 'toBatch'
  },
  {
    label: '替代批次',
    field: 'altBatch'
  },
  {
    label: '到货日期',
    field: 'arriveDate',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '生产日期',
    field: 'produceDate',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '过期日期',
    field: 'expireDate',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '库存状态',
    field: 'inventoryStatus'
  },
  {
    label: '从库位代码',
    field: 'fromLocationCode'
  },
  {
    label: '到库位代码',
    field: 'toLocationCode'
  },
  {
    label: '从库位组代码',
    field: 'fromLocationGroupCode'
  },
  {
    label: '到库位组代码',
    field: 'toLocationGroupCode'
  },
  {
    label: '从库区代码',
    field: 'fromAreaCodes'
  },
  {
    label: '到库区代码',
    field: 'toAreaCodes'
  },
  {
    label: '从货主代码',
    field: 'fromOwnerCode'
  },
  {
    label: '到货主代码',
    field: 'toOwnerCode'
  },
  {
    label: '订单号',
    field: 'poNumber'
  },
  {
    label: '订单行',
    field: 'poLine'
  },
  {
    label: '标包数量',
    field: 'stdPackQty'
  },
  {
    label: '标包单位',
    field: 'stdPackUnit'
  },
  {
    label: '数量',
    field: 'qty'
  },
  {
    label: '计量单位',
    field: 'uom'
  },
  {
    label: '供应商计量数量',
    field: 'supplierQty'
  },
  {
    label: '供应商计量单位',
    field: 'supplierUom',
    dictType: DICT_TYPE.UOM,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '转换率',
    field: 'convertRate'
  },
  {
    label: '目检结果',
    field: 'visualInspectResult'
  },
  {
    label: '目检照片',
    field: 'visualInspectPhotos'
  },
  {
    label: '不合格原因',
    field:'failedReason'
  },
  {
    label: '单价',
    field: 'singlePrice'
  },
  {
    label: '金额',
    field: 'amount'
  },
  {
    label: '任务明细ID',
    field: 'jobDetailId'
  },
  {
    label: '物品代码',
    field: 'itemCode'
  },
  {
    label: '物品名称',
    field: 'itemName'
  },
  {
    label: '物品描述1',
    field: 'itemDesc1'
  },
  {
    label: '物品描述2',
    field: 'itemDesc2'
  },
  {
    label: '项目代码',
    field: 'projectCode'
  },
  {
    label: '数量',
    field: 'qty'
  },
  {
    label: '计量单位',
    field: 'uom'
  },
  {
    label: '单据号',
    field: 'number'
  },
  {
    label: '代码',
    field: 'code'
  },
  {
    label: '接口类型',
    field: 'interfaceType',
    dictType: DICT_TYPE.INTERFACE_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建时间',
    field: 'createTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建者',
    field: 'creator'
  }
]))

/**
 * @returns {Array} 采购退货申请主表
 */
export const PurchasereturnRequestMain = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '采购收货记录单号',
    field: 'purchaseReceiptRecordNumber'
  },
  {
    label: '发货单号',
    field: 'asnNumber'
  },
  {
    label: '要货计划单号',
    field: 'ppNumber'
  },
  {
    label: '供应商代码',
    field: 'supplierCode'
  },
  {
    label: '承运商',
    field: 'carrierCode'
  },
  {
    label: '运输方式',
    field: 'transferMode'
  },
  {
    label: '车牌号',
    field: 'vehiclePlateNumber'
  },
  {
    label: '从仓库代码',
    field: 'fromWarehouseCode'
  },
  {
    label: '到仓库代码',
    field: 'toWarehouseCode'
  },
  {
    label: '从库位类型范围',
    field: 'fromLocationTypes',
    dictType: DICT_TYPE.LOCATION_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '到库位类型范围',
    field: 'toLocationTypes',
    dictType: DICT_TYPE.LOCATION_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '从库区代码范围',
    field: 'fromAreaCodes'
  },
  {
    label: '到库区代码范围',
    field: 'toAreaCodes'
  },
  {
    label: '从月台代码',
    field: 'fromDockCode'
  },
  {
    label: '单据号',
    field: 'number'
  },
  {
    label: '业务类型',
    field: 'businessType'
  },
  {
    label: '申请时间',
    field: 'requestTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '截止时间',
    field: 'dueTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '部门',
    field: 'departmentCode'
  },
  {
    label: '状态',
    field: 'status',
    dictType: DICT_TYPE.REQUEST_STATUS,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建者',
    field: 'creator'
  },
  {
    label: '创建时间',
    field: 'createTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '最后更新者',
    field: 'updater'
  },
  {
    label: '最后更新时间',
    field: 'updateTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '自动提交',
    field: 'autoCommit',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '自动通过',
    field: 'autoAgree',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '自动执行',
    field: 'autoExecute',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '直接生成记录',
    field: 'directCreateRecord',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
]))

/**
 * @returns {Array} 采购退货申请子表
 */
export const PurchasereturnRequestDetail = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '包装号',
    field: 'packingNumber'
  },
  {
    label: '器具号',
    field: 'containerNumber'
  },
  {
    label: '批次',
    field: 'batch'
  },
  {
    label: '替代批次',
    field: 'altBatch'
  },
  {
    label: '到库位代码',
    field: 'toLocationCode'
  },
  {
    label: '库存状态',
    field: 'inventoryStatus'
  },
  {
    label: '订单号',
    field: 'poNumber'
  },
  {
    label: '订单行',
    field: 'poLine'
  },
  {
    label: '原因',
    field: 'reason'
  },
  {
    label: '从货主代码',
    field: 'fromOwnerCode'
  },
  {
    label: '到货主代码',
    field: 'toOwnerCode'
  },
  {
    label: '单据号',
    field: 'number'
  },
  {
    label: '物品代码',
    field: 'itemCode'
  },
  {
    label: '物品名称',
    field: 'itemName'
  },
  {
    label: '物品描述1',
    field: 'itemDesc1'
  },
  {
    label: '物品描述2',
    field: 'itemDesc2'
  },
  {
    label: '项目代码',
    field: 'projectCode'
  },
  {
    label: '数量',
    field: 'qty'
  },
  {
    label: '计量单位',
    field: 'uom'
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建者',
    field: 'creator'
  },
  {
    label: '创建时间',
    field: 'createTime'
  },
  {
    label: '最后更新者',
    field: 'updator'
  },
  {
    label: '最后更新时间',
    field: 'updateTime'
  }
]))

/**
 * @returns {Array} 采购退货任务主表
 */
export const PurchasereturnJobMain = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '申请单号',
    field: 'requestNumber'
  },
  {
    label: '采购收货记录单号',
    field: 'purchaseReceiptRecordNumber'
  },
  {
    label: '发货单号',
    field: 'asnNumber'
  },
  {
    label: '要货计划单号',
    field: 'ppNumber'
  },
  {
    label: '供应商代码',
    field: 'supplierCode'
  },
  {
    label: '发货月台',
    field: 'deliverDock'
  },
  {
    label: '承运商',
    field: 'carrierCode'
  },
  {
    label: '运输方式',
    field: 'transferMode'
  },
  {
    label: '车牌号',
    field: 'vehiclePlateNumber'
  },
  {
    label: '从仓库代码',
    field: 'fromWarehouseCode'
  },
  {
    label: '到仓库代码',
    field: 'toWarehouseCode'
  },
  {
    label: '从库位类型范围',
    field: 'fromLocationTypes',
    dictType: DICT_TYPE.LOCATION_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '到库位类型范围',
    field: 'toLocationTypes',
    dictType: DICT_TYPE.LOCATION_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '从库区代码范围',
    field: 'fromAreaCodes'
  },
  {
    label: '到库区代码范围',
    field: 'toAreaCodes'
  },
  {
    label: '从月台代码',
    field: 'fromDockCode'
  },
  {
    label: '申请时间',
    field: 'requestTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '要求截止时间',
    field: 'requestDueTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '单据号',
    field: 'number'
  },
  {
    label: '业务类型',
    field: 'businessType'
  },
  {
    label: '状态',
    field: 'status',
    dictType: DICT_TYPE.JOB_STATUS,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '状态',
    field: 'jobStageStatus'
  },
  {
    label: '过期时间',
    field: 'expiredTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '优先级',
    field: 'priority'
  },
  {
    label: '优先级增量',
    field: 'priorityIncrement'
  },
  {
    label: '部门',
    field: 'departmentCode'
  },
  {
    label: '承接人',
    field: 'acceptUserId'
  },
  {
    label: '承接时间',
    field: 'acceptTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '完成人',
    field: 'completeUserId'
  },
  {
    label: '完成时间',
    field: 'completeTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '自动完成',
    field: 'autoComplete',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '允许修改库位',
    field: 'allowModifyLocation',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '允许修改数量',
    field: 'allowModifyQty',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '允许大于推荐数量',
    field: 'allowBiggerQty',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '允许小于推荐数量',
    field: 'allowSmallerQty',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '允许修改库存状态',
    field: 'allowModifyInventoryStatus',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '允许连续扫描',
    field: 'allowContinuousScanning',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '允许部分完成',
    field: 'allowPartialComplete',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '允许修改批次',
    field: 'allowModifyBatch',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '允许修改箱码',
    field: 'allowModifyPackingNumber',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建者',
    field: 'creator'
  },
  {
    label: '创建时间',
    field: 'createTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '最后更新者',
    field: 'updater'
  },
  {
    label: '最后更新时间',
    field: 'updateTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  }
]))

/**
 * @returns {Array} 采购退货任务子表
 */
export const PurchasereturnJobDetail = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '从货主代码',
    field: 'fromOwnerCode'
  },
  {
    label: '到货主代码',
    field: 'toOwnerCode'
  },
  {
    label: '包装号',
    field: 'packingNumber'
  },
  {
    label: '器具号',
    field: 'containerNumber'
  },
  {
    label: '批次',
    field: 'batch'
  },
  {
    label: '替代批次',
    field: 'altBatch'
  },
  {
    label: '从库位代码',
    field: 'fromLocationCode'
  },
  {
    label: '到库位代码',
    field: 'toLocationCode'
  },
  {
    label: '库存状态',
    field: 'inventoryStatus',
    dictType: DICT_TYPE.INVENTORY_STATUS,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '订单号',
    field: 'poNumber'
  },
  {
    label: '订单行',
    field: 'poLine'
  },
  {
    label: '原因',
    field: 'reason',
    dictType: DICT_TYPE.PURCHASE_RETURN_REASON,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '物品代码',
    field: 'itemCode'
  },
  {
    label: '物品名称',
    field: 'itemName'
  },
  {
    label: '物品描述1',
    field: 'itemDesc1'
  },
  {
    label: '物品描述2',
    field: 'itemDesc2'
  },
  {
    label: '项目代码',
    field: 'projectCode'
  },
  {
    label: '数量',
    field: 'qty'
  },
  {
    label: '计量单位',
    field: 'uom',
    dictType: DICT_TYPE.UOM,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '单据号',
    field: 'number'
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建时间',
    field: 'createTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建者',
    field: 'creator'
  }
]))

/**
 * @returns {Array} 采购退货记录主表
 */
export const PurchasereturnRecordMain = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '申请单号',
    field: 'requestNumber'
  },
  {
    label: '任务单号',
    field: 'jobNumber'
  },
  {
    label: '采购收货记录单号',
    field: 'purchaseReceiptRecordNumber'
  },
  {
    label: '发货单号',
    field: 'asnNumber'
  },
  {
    label: '要货计划单号',
    field: 'ppNumber'
  },
  {
    label: '供应商代码',
    field: 'supplierCode'
  },
  {
    label: '从月台代码',
    field: 'fromDockCode'
  },
  {
    label: '承运商',
    field: 'carrierCode'
  },
  {
    label: '运输方式',
    field: 'transferMode'
  },
  {
    label: '车牌号',
    field: 'vehiclePlateNumber'
  },
  {
    label: '从仓库代码',
    field: 'fromWarehouseCode'
  },
  {
    label: '到仓库代码',
    field: 'toWarehouseCode'
  },
  {
    label: '出库事务类型',
    field: 'outTransactionType'
  },
  {
    label: '入库事务类型',
    field: 'inTransactionType'
  },
  {
    label: '从库位类型范围',
    field: 'fromLocationTypes',
    dictType: DICT_TYPE.LOCATION_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '到库位类型范围',
    field: 'toLocationTypes',
    dictType: DICT_TYPE.LOCATION_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '从库区代码范围',
    field: 'fromAreaCodes'
  },
  {
    label: '到库区代码范围',
    field: 'toAreaCodes'
  },
  {
    label: '执行时间',
    field: 'executeTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '生效日期',
    field: 'activeDate',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '申请时间',
    field: 'requestTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '截止时间',
    field: 'dueTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '部门',
    field: 'departmentCode'
  },
  {
    label: '代码',
    field: 'code'
  },
  {
    label: '接口类型',
    field: 'interfaceType',
    dictType: DICT_TYPE.INTERFACE_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '单据号',
    field: 'number'
  },
  {
    label: '业务类型',
    field: 'businessType'
  },
  {
    label: '是否可用',
    field: 'available',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '备注',
    field: 'available'
  },
  {
    label: '创建时间',
    field: 'createTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建者',
    field: 'creator'
  }
]))

/**
 * @returns {Array} 采购退货记录子表
 */
export const PurchasereturnRecordDetail = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '从包装号',
    field: 'fromPackingNumber'
  },
  {
    label: '到包装号',
    field: 'toPackingNumber'
  },
  {
    label: '从器具号',
    field: 'fromContainerNumber'
  },
  {
    label: '到器具号',
    field: 'toContainerNumber'
  },
  {
    label: '从批次',
    field: 'fromBatch'
  },
  {
    label: '到批次',
    field: 'toBatch'
  },
  {
    label: '替代批次',
    field: 'altBatch'
  },
  {
    label: '从库位代码',
    field: 'fromLocationCode'
  },
  {
    label: '到库位代码',
    field: 'toLocationCode'
  },
  {
    label: '从库位组代码',
    field: 'fromLocationGroupCode'
  },
  {
    label: '到库位组代码',
    field: 'toLocationGroupCode'
  },
  {
    label: '从库区代码',
    field: 'fromAreaCode'
  },
  {
    label: '到库区代码',
    field: 'toAreaCode'
  },
  {
    label: '从货主代码',
    field: 'fromOwnerCode'
  },
  {
    label: '到货主代码',
    field: 'toOwnerCode'
  },
  {
    label: '库存状态',
    field: 'inventoryStatus',
    dictType: DICT_TYPE.INVENTORY_STATUS,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '订单号',
    field: 'poNumber'
  },
  {
    label: '订单行',
    field: 'poline'
  },
  {
    label: '原因',
    field: 'reason',
    dictType: DICT_TYPE.PURCHASE_RETURN_REASON,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '单价',
    field: 'singlePrice'
  },
  {
    label: '金额',
    field: 'amount'
  },
  {
    label: '物品代码',
    field: 'itemCode'
  },
  {
    label: '物品名称',
    field: 'itemName'
  },
  {
    label: '物品描述1',
    field: 'itemDesc1'
  },
  {
    label: '物品描述2',
    field: 'itemDesc2'
  },
  {
    label: '数量',
    field: 'qty'
  },
  {
    label: '计量单位',
    field: 'uom',
    dictType: DICT_TYPE.UOM,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '项目代码',
    field: 'projectCode'
  },
  {
    label: '代码',
    field: 'code'
  },
  {
    label: '接口类型',
    field: 'interfaceType',
    dictType: DICT_TYPE.INTERFACE_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '任务明细ID',
    field: 'jobDetailId'
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建时间',
    field: 'createTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建者',
    field: 'creator'
  }
]))

/**
 * @returns {Array} 检验申请主表
 */
export const InspectRequestMain = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '采购收货记录单号',
    field: 'purchaseReceiptRecordNumber'
  },
  {
    label: '供应商代码',
    field: 'supplierCode'
  },
  {
    label: '单据号',
    field: 'number'
  },
  {
    label: '业务类型',
    field: 'businessType'
  },
  {
    label: '从仓库代码范围',
    field: 'fromWarehouseCode'
  },
  {
    label: '从库区代码范围',
    field: 'fromAreaCodes'
  },
  {
    label: '从库位类型范围',
    field: 'fromLocationTypes',
    dictType: DICT_TYPE.LOCATION_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建者',
    field: 'creator'
  },
  {
    label: '创建时间',
    field: 'createTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '申请时间',
    field: 'requestTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '截止时间',
    field: 'dueTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '部门',
    field: 'departmentCode'
  },
  {
    label: '状态',
    field: 'status',
    dictType: DICT_TYPE.REQUEST_STATUS,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '最后更新者',
    field: 'updater'
  },
  {
    label: '最后更新时间',
    field: 'updateTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '订单号',
    field: 'poNumber'
  },
  {
    label: '订单行',
    field: 'poLine'
  },
  {
    label: '批次',
    field: 'batch'
  },
  {
    label: '物品代码',
    field: 'itemcode'
  },
  {
    label: '检验类型',
    field: 'inspectType',
    dictType: DICT_TYPE.INSPECT_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '下一步检验动作',
    field: 'nextAction',
    dictType: DICT_TYPE.NEXT_ACTION,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '抽检方式',
    field: 'sampleMethod',
    dictType: DICT_TYPE.SAMPLE_METHOD,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '计量单位',
    field: 'uom',
    dictType: DICT_TYPE.UOM,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '收货数量',
    field: 'receiveQty'
  },
  {
    label: '样品数量',
    field: 'sampleQty'
  },
  {
    label: '货主代码',
    field: 'ownerCode'
  },
  {
    label: '自动提交',
    field: 'autoCommit',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '自动通过',
    field: 'autoAgree',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '自动执行',
    field: 'autoExecute',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '直接生成记录',
    field: 'directCreateRecord',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
]))

/**
 * @returns {Array} 检验申请子表
 */
export const InspectRequestDetail = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '包装号',
    field: 'packingNumber'
  },
  {
    label: '器具号',
    field: 'containerNumber'
  },
  {
    label: '库存状态',
    field: 'inventoryStatus'
  },
  {
    label: '从库位代码',
    field: 'fromLocationCode'
  },
  {
    label: '最后更新时间',
    field: 'updateTime'
  },
  {
    label: '最后更新者',
    field: 'updater'
  },
  {
    label: '物品代码',
    field: 'itemCode'
  },
  {
    label: '物品名称',
    field: 'itemName'
  },
  {
    label: '物品描述1',
    field: 'itemDesc1'
  },
  {
    label: '物品描述2',
    field: 'itemDesc2'
  },
  {
    label: '项目代码',
    field: 'projectCode'
  },
  {
    label: '数量',
    field: 'qty'
  },
  {
    label: '计量单位',
    field: 'uom'
  }
]))

/**
 * @returns {Array} 检验任务主表
 */
export const InspectJobMain = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '申请单号',
    field: 'requestNumber'
  },
  {
    label: '采购收货记录单号',
    field: 'purchaseReceiptRecordNumber'
  },
  {
    label: '供应商代码',
    field: 'supplierCode'
  },
  {
    label: '仓库代码',
    field: 'warehouseCode'
  },
  {
    label: '申请时间',
    field: 'requestTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '要求截止时间',
    field: 'requestDueTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '状态',
    field: 'jobStageStatus'
  },
  {
    label: '过期时间',
    field: 'expiredTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '最后更新时间',
    field: 'updateTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '最后更新者',
    field: 'update'
  },
  {
    label: '状态',
    field: 'status',
    dictType: DICT_TYPE.REQUEST_STATUS,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '优先级',
    field: 'priority'
  },
  {
    label: '优先级增量',
    field: 'priorityIncrement'
  },
  {
    label: '部门',
    field: 'departmentCode'
  },
  {
    label: '承接人用户名',
    field: 'acceptUserId'
  },
  {
    label: '承接时间',
    field: 'acceptTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '完成人用户名',
    field: 'completeUserId'
  },
  {
    label: '完成时间',
    field: 'completeTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '从库位类型范围',
    field: 'fromLocationTypes',
    dictType: DICT_TYPE.LOCATION_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '到库位类型范围',
    field: 'toLocationTypes',
    dictType: DICT_TYPE.LOCATION_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '单据号',
    field: 'number'
  },
  {
    label: '业务类型',
    field: 'businessType'
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建时间',
    field: 'createTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建者',
    field: 'creator'
  },
  {
    label: '订单号',
    field: 'poNumber'
  },
  {
    label: '订单行',
    field: 'poLine'
  },
  {
    label: '批次',
    field: 'batch'
  },
  {
    label: '物品代码',
    field: 'itemCode'
  },
  {
    label: '检验类型',
    field: 'inspectType',
    dictType: DICT_TYPE.INSPECT_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '下一步检验动作',
    field: 'nextAction',
    dictType: DICT_TYPE.NEXT_ACTION,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '抽检方式',
    field: 'sampleMethod',
    dictType: DICT_TYPE.SAMPLE_METHOD,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '计量单位',
    field: 'uom',
    dictType: DICT_TYPE.UOM,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '收货数量',
    field: 'receiveQty'
  },
  {
    label: '样品数量',
    field: 'sampleQty'
  },
  {
    label: '货主代码',
    field: 'owner'
  },
  {
    label: '自动完成',
    field: 'autoComplete',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '允许修改库位',
    field: 'allowModifyLocation',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '允许修改数量',
    field: 'allowModifyQty',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '允许大于推荐数量',
    field: 'allowBiggerQty',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '允许小于推荐数量',
    field: 'allowSmallerQty',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '允许修改库存状态',
    field: 'allowModifyInventoryStatus',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '允许连续扫描',
    field: 'allowContinuousScanning',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '允许部分完成',
    field: 'allowPartialComplete',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '允许修改批次',
    field: 'allowModifyBatch',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '允许修改箱码',
    field: 'allowModifyPackingNumber',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
]))

/**
 * @returns {Array} 检验任务子表
 */
export const InspectJobDetail = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '包装号',
    field: 'packingNumber'
  },
  {
    label: '器具号',
    field: 'containerNumber'
  },
  {
    label: '库存状态',
    field: 'inventoryStatus',
    dictType: DICT_TYPE.INVENTORY_STATUS,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '从库位代码',
    field: 'fromLocationCode'
  },
  {
    label: '单据号',
    field: 'number'
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建时间',
    field: 'createTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建者',
    field: 'creator'
  },
  {
    label: '物品代码',
    field: 'itemCode'
  },
  {
    label: '物品名称',
    field: 'itemName'
  },
  {
    label: '物品描述1',
    field: 'itemDesc1'
  },
  {
    label: '物品描述2',
    field: 'itemDesc2'
  },
  {
    label: '项目代码',
    field: 'projectCode'
  },
  {
    label: '数量',
    field: 'qty'
  },
  {
    label: '计量单位',
    field: 'uom',
    dictType: DICT_TYPE.UOM,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
]))

/**
 * @returns {Array} 检验记录主表
 */
export const InspectRecordMain = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '申请单号',
    field: 'requestNumber'
  },
  {
    label: '任务单号',
    field: 'jobNumber'
  },
  {
    label: '采购收货记录单号',
    field: 'purchaseReceiptRecordNumber'
  },
  {
    label: '供应商代码',
    field: 'supplierCode'
  },
  {
    label: '出库事务类型',
    field: 'outTransactionType'
  },
  {
    label: '入库事务类型',
    field: 'inTransactionType'
  },
  {
    label: '执行时间',
    field: 'executeTime',
    formatter : dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '生效日期',
    field: 'activeDate',
    formatter : dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '申请时间',
    field: 'requestTime',
    formatter : dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '截止时间',
    field: 'dueTime',
    formatter : dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '部门',
    field: 'departmentCode'
  },
  {
    label: '接口类型',
    field: 'interfaceType',
    isSearch: true,
    isTable: true,
    dictType: DICT_TYPE.INTERFACE_TYPE,
    dictClass: 'string'
  },
  {
    label: '单据号',
    field: 'number'
  },
  {
    label: '业务类型',
    field: 'businessType'
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建时间',
    field: 'createTime',
    formatter : dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建者',
    field: 'creator'
  },
  {
    label: '代码',
    field: 'code'
  },
  {
    label: '订单号',
    field: 'poNumber'
  },
  {
    label: '订单行',
    field: 'poLine'
  },
  {
    label: '批次',
    field: 'batch'
  },
  {
    label: '检验类型',
    field: 'inspectType',
    isSearch: true,
    isTable: true,
    dictType: DICT_TYPE.INSPECT_TYPE,
    dictClass: 'string'
  },
  {
    label: '下一步检验动作',
    field: 'nextAction',
    isSearch: true,
    isTable: true,
    dictType: DICT_TYPE.NEXT_ACTION,
    dictClass: 'string'
  },
  {
    label: '抽检方式',
    field: 'sampleMethod',
    isSearch: true,
    isTable: true,
    dictType: DICT_TYPE.SAMPLE_METHOD,
    dictClass: 'string'
  },
  {
    label: '计量单位',
    field: 'uom',
    isSearch: true,
    isTable: true,
    dictType: DICT_TYPE.UOM,
    dictClass: 'string'
  },
  {
    label: '收货数量',
    field: 'receiveQty'
  },
  {
    label: '样品数量',
    field: 'sampleQty'
  },
  {
    label: '合格数量',
    field: 'batchGoodQty'
  },
  {
    label: '不合格数量',
    field: 'batchFaildQty'
  },
  {
    label: '破坏数量',
    field: 'batchCrackQty'
  },
  {
    label: '最终不合格数量',
    field: 'batchNotPassedQty'
  },
  {
    label: '物品代码',
    field: 'itemCode'
  },
  {
    label: '从仓库代码',
    field: 'fromWarehouseCode'
  },
  {
    label: '从库位类型范围',
    field: 'fromLocationTypes',
    isSearch: true,
    isTable: true,
    dictType: DICT_TYPE.LOCATION_TYPE,
    dictClass: 'string'
  },
  {
    label: '从库区代码范围',
    field: 'fromAreaCodes'
  },
  {
    label: '货主代码',
    field: 'ownerCode'
  },
  {
    label: '是否可用',
    field: 'available',
    isSearch: true,
    isTable: true,
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string'
  },
]))

/**
 * @returns {Array} 检验记录子表
 */
export const InspectRecordDetail = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '包装号',
    field: 'packingNumber'
  },
  {
    label: '器具号',
    field: 'containerNumber'
  },
  {
    label: '从库位代码',
    field: 'fromLocationCode'
  },
  {
    label: '从库位组代码',
    field: 'fromLocationGroupCode'
  },
  {
    label: '从库区代码',
    field: 'fromAreaCode'
  },
  {
    label: '样品数量',
    field: 'sampleQty'
  },
  {
    label: '合格数量',
    field: 'goodQty'
  },
  {
    label: '不合格数量',
    field: 'failedQty'
  },
  {
    label: '破坏数量',
    field: 'crackQty'
  },
  {
    label: '最终不合格数量',
    field: 'notPassedQty'
  },
  {
    label: '不合格原因',
    field: 'failedReason',
    dictType: DICT_TYPE.INSPECT_FAILED_REASON,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '异常照片',
    field: 'photos'
  },
  {
    label: '检验人',
    field: 'inspectUser'
  },
  {
    label: '检验结果',
    field: 'inspectResult',
    dictType: DICT_TYPE.INSPECT_RESULT,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '外观',
    field: 'appearance'
  },
  {
    label: '尺寸',
    field: 'volume'
  },
  {
    label: '重量',
    field: 'weight'
  },
  {
    label: '其他属性',
    field: 'otherProperties'
  },
  {
    label: '单据号',
    field: 'number'
  },
  {
    label: '物品代码',
    field: 'itemCode'
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建时间',
    field: 'creationTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建者',
    field: 'creator'
  },
  {
    label: '物品名称',
    field: 'itemName'
  },
  {
    label: '物品描述1',
    field: 'itemDesc1'
  },
  {
    label: '物品描述2',
    field: 'itemDesc2'
  },
  {
    label: '项目代码',
    field: 'projectCode'
  },
  {
    label: '数量',
    field: 'qty'
  },
  {
    label: '计量单位',
    field: 'uom',
    dictType: DICT_TYPE.UOM,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '代码',
    field: 'code'
  },
  {
    label: '接口类型',
    field: 'interfaceType',
    dictType: DICT_TYPE.INTERFACE_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '任务明细ID',
    field: 'jobDetailId'
  },
]))

/**
 * @returns {Array} 上架申请主表
 */
export const PutawayRequestMain = useCrudSchemas(reactive<CrudSchema[]>([
  {
    label: '供应商代码',
    field: 'supplierCode'
  },
  {
    label: '从仓库代码',
    field: 'fromWarehouseCode'
  },
  {
    label: '从库位类型范围',
    field: 'fromLocationTypes',
    dictType: DICT_TYPE.LOCATION_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '从库区代码范围',
    field: 'fromAreaCodes'
  },
  {
    label: '单据号',
    field: 'number'
  },
  {
    label: '业务类型',
    field: 'businessType'
  },
  {
    label: '备注',
    field: 'remark'
  },
  {
    label: '创建时间',
    field: 'createTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '创建者',
    field: 'creator'
  },
  {
    label: '申请时间',
    field: 'requestTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '截止时间',
    field: 'dueTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '部门',
    field: 'departmentCode'
  },
  {
    label: '状态',
    field: 'status',
    dictType: DICT_TYPE.REQUEST_STATUS,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '最后更新时间',
    field: 'updateTime',
    formatter: dateFormatter,
    detail: {
      dateFormat: 'YYYY-MM-DD HH:mm:ss'
    }
  },
  {
    label: '最后更新者',
    field: 'updater'
  },
  {
    label: '到仓库代码',
    field: 'toWarehouseCode'
  },
  {
    label: '到库位类型范围',
    field: 'toLocationTypes',
    dictType: DICT_TYPE.LOCATION_TYPE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '到库区代码范围',
    field: 'toAreaCodes'
  },
  {
    label: '自动提交',
    field: 'autoCommit',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '自动通过',
    field: 'autoAgree',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '自动执行',
    field: 'autoAgree',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
  {
    label: '直接生成记录',
    field: 'directCreateRecord',
    dictType: DICT_TYPE.TRUE_FALSE,
    dictClass: 'string',
    isSearch: true,
    isTable: true
  },
]))