crud增刪改查文件——自定義鉤子函數

import {initData,download} from '@/api/data'
import {parseTime,downloadFile} from '@/utils/index'
import Vue from 'vue'

/**
CRUD配置
*/
function CRUD(options){
	const defaultOptions = {
		tag:'default',
		//id字段名
		idFiled:'id',
		//標題
		title:'',
		//請求數據的url
		url:'',
		//表格數據
		data:[],
		//選擇項
		selections:[],
		//待查詢的對象
		query:{},
		//查詢數據的參數
		params:{},
		//form表單
		form:{},
		//重置表單
		defaultForm:()=>{},
		//排序規則，默認id降序
		sort:['id,desc'],
		//等待時間
		time:50,
		//CRUD Method
		crudMethod:{
			add:(form)=>{},
			del:(id)=>{},
			edit:(form)=>{},
			get:(id)=>{}
		},
		//主頁操作欄顯示哪些按鈕
		optShow:{
			add:true,
			edit:true,
			del:true,
			download:true,
			reset:true
		},
		//自定義一些擴展屬性
		props:{},
		//在主頁準備
		queryOnPresenterCreated:true,
		//調試開關
		debug:false
	}
	options = mergeOptions(defaultOptions,options)
	const data = {
		...options,
		//記錄數據狀態
		dataStatus:{},
		status:{
			add:CRUD.STATUS.NORMAL,
			edit:CRUD.STATUS.NORMAL,
			//添加或編輯狀態
			get cu() {
		        if (this.add === CRUD.STATUS.NORMAL && this.edit === CRUD.STATUS.NORMAL) {
		          return CRUD.STATUS.NORMAL
		        } else if (this.add === CRUD.STATUS.PREPARED || this.edit === CRUD.STATUS.PREPARED) {
		          return CRUD.STATUS.PREPARED
		        } else if (this.add === CRUD.STATUS.PROCESSING || this.edit === CRUD.STATUS.PROCESSING) {
		          return CRUD.STATUS.PROCESSING
		        }
		        throw new Error('wrong crud\'s cu status')
	      },
	      // 標題
	      get title() {
	        return this.add > CRUD.STATUS.NORMAL ? `新增${crud.title}` : this.edit > CRUD.STATUS.NORMAL ? `編輯${crud.title}` : crud.title
	      }
	    },
	    msg: {
	      submit: '提交成功',
	      add: '新增成功',
	      edit: '編輯成功',
	      del: '刪除成功'
	    },
	    page: {
	      // 頁碼
	      page: 0,
	      // 每頁數據條數
	      size: 10,
	      // 總數據條數
	      total: 0
	    },
	    // 整體loading
	    loading: false,
	    // 導出的 Loading
	    downloadLoading: false,
	    // 刪除的 Loading
	    delAllLoading: false
	  }
	  const methods = {
	    /**
	     * 通用的提示
	     */
	    submitSuccessNotify() {
	      crud.notify(crud.msg.submit, CRUD.NOTIFICATION_TYPE.SUCCESS)
	    },
	    addSuccessNotify() {
	      crud.notify(crud.msg.add, CRUD.NOTIFICATION_TYPE.SUCCESS)
	    },
	    editSuccessNotify() {
	      crud.notify(crud.msg.edit, CRUD.NOTIFICATION_TYPE.SUCCESS)
	    },
	    delSuccessNotify() {
	      crud.notify(crud.msg.del, CRUD.NOTIFICATION_TYPE.SUCCESS)
	    },
	    // 搜索
	    toQuery() {
	      // console.log('點擊了搜索按鈕')
	      crud.page.page = 1
	      crud.refresh()
	    },
	    // 刷新
	    refresh() {
	      if (!callVmHook(crud, CRUD.HOOK.beforeRefresh)) {
	        return
	      }
	      return new Promise((resolve, reject) => {
	        crud.loading = true
	        // 請求數據
	        initData(crud.url, crud.getQueryParams()).then(data => {
	          crud.page.total = data.totalElements
	          crud.data = data.content || data.data.acticleDtos
	          crud.resetDataStatus()
	          // time 毫秒後顯示錶格
	          setTimeout(() => {
	            crud.loading = false
	            callVmHook(crud, CRUD.HOOK.afterRefresh)
	          }, crud.time)
	          resolve(data)
	        }).catch(err => {
	          crud.loading = false
	          reject(err)
	        })
	      })
	    },
	    /**
	     * 啓動添加
	     */
	    toAdd() {
	      crud.resetForm()
	      if (!(callVmHook(crud, CRUD.HOOK.beforeToAdd, crud.form) && callVmHook(crud, CRUD.HOOK.beforeToCU, crud.form))) {
	        return
	      }
	      crud.status.add = CRUD.STATUS.PREPARED
	      callVmHook(crud, CRUD.HOOK.afterToAdd, crud.form)
	      callVmHook(crud, CRUD.HOOK.afterToCU, crud.form)
	    },
	    /**
	     * 啓動編輯
	     * @param {*} data 數據項
	     */
	    toEdit(data) {
	      crud.resetForm(JSON.parse(JSON.stringify(data)))
	      if (!(callVmHook(crud, CRUD.HOOK.beforeToEdit, crud.form) && callVmHook(crud, CRUD.HOOK.beforeToCU, crud.form))) {
	        return
	      }
	      crud.status.edit = CRUD.STATUS.PREPARED
	      crud.getDataStatus(crud.getDataId(data)).edit = CRUD.STATUS.PREPARED
	      callVmHook(crud, CRUD.HOOK.afterToEdit, crud.form)
	      callVmHook(crud, CRUD.HOOK.afterToCU, crud.form)
	    },
	    /**
	     * 啓動刪除
	     * @param {*} data 數據項
	     */
	    toDelete(data) {
	      crud.getDataStatus(crud.getDataId(data)).delete = CRUD.STATUS.PREPARED
	    },
	    /**
	     * 取消刪除
	     * @param {*} data 數據項
	     */
	    cancelDelete(data) {
	      if (!callVmHook(crud, CRUD.HOOK.beforeDeleteCancel, data)) {
	        return
	      }
	      crud.getDataStatus(crud.getDataId(data)).delete = CRUD.STATUS.NORMAL
	      callVmHook(crud, CRUD.HOOK.afterDeleteCancel, data)
	    },
	    /**
	     * 取消新增/編輯
	     */
	    cancelCU() {
	      const addStatus = crud.status.add
	      const editStatus = crud.status.edit
	      if (addStatus === CRUD.STATUS.PREPARED) {
	        if (!callVmHook(crud, CRUD.HOOK.beforeAddCancel, crud.form)) {
	          return
	        }
	        crud.status.add = CRUD.STATUS.NORMAL
	      }
	      if (editStatus === CRUD.STATUS.PREPARED) {
	        if (!callVmHook(crud, CRUD.HOOK.beforeEditCancel, crud.form)) {
	          return
	        }
	        crud.status.edit = CRUD.STATUS.NORMAL
	        crud.getDataStatus(crud.getDataId(crud.form)).edit = CRUD.STATUS.NORMAL
	      }
	      crud.resetForm()
	      if (addStatus === CRUD.STATUS.PREPARED) {
	        callVmHook(crud, CRUD.HOOK.afterAddCancel, crud.form)
	      }
	      if (editStatus === CRUD.STATUS.PREPARED) {
	        callVmHook(crud, CRUD.HOOK.afterEditCancel, crud.form)
	      }
	      // 清除表單驗證
	      if (crud.findVM('form').$refs['form']) {
	        crud.findVM('form').$refs['form'].clearValidate()
	      }
	    },
	    /**
	     * 提交新增/編輯
	     */
	    submitCU() {
	      if (!callVmHook(crud, CRUD.HOOK.beforeValidateCU)) {
	        return
	      }
	      crud.findVM('form').$refs['form'].validate(valid => {
	        if (!valid) {
	          return
	        }
	        if (!callVmHook(crud, CRUD.HOOK.afterValidateCU)) {
	          return
	        }
	        if (crud.status.add === CRUD.STATUS.PREPARED) {
	          crud.doAdd()
	        } else if (crud.status.edit === CRUD.STATUS.PREPARED) {
	          crud.doEdit()
	        }
	      })
	    },
	    /**
	     * 執行添加
	     */
	    doAdd() {
	      if (!callVmHook(crud, CRUD.HOOK.beforeSubmit)) {
	        return
	      }
	      crud.status.add = CRUD.STATUS.PROCESSING
	      crud.crudMethod.add(crud.form).then(() => {
	        crud.status.add = CRUD.STATUS.NORMAL
	        crud.resetForm()
	        crud.addSuccessNotify()
	        callVmHook(crud, CRUD.HOOK.afterSubmit)
	        crud.toQuery()
	      }).catch(() => {
	        crud.status.add = CRUD.STATUS.PREPARED
	        callVmHook(crud, CRUD.HOOK.afterAddError)
	      })
	    },
	    /**
	     * 執行編輯
	     */
	    doEdit() {
	      if (!callVmHook(crud, CRUD.HOOK.beforeSubmit)) {
	        return
	      }
	      crud.status.edit = CRUD.STATUS.PROCESSING
	      crud.crudMethod.edit(crud.form).then(() => {
	        crud.status.edit = CRUD.STATUS.NORMAL
	        crud.getDataStatus(crud.getDataId(crud.form)).edit = CRUD.STATUS.NORMAL
	        crud.editSuccessNotify()
	        crud.resetForm()
	        callVmHook(crud, CRUD.HOOK.afterSubmit)
	        crud.refresh()
	      }).catch(() => {
	        crud.status.edit = CRUD.STATUS.PREPARED
	        callVmHook(crud, CRUD.HOOK.afterEditError)
	      })
	    },
	    /**
	     * 執行刪除
	     * @param {*} data 數據項
	     */
	    doDelete(data) {
	      let delAll = false
	      let dataStatus
	      const ids = []
	      if (data instanceof Array) {
	        delAll = true
	        data.forEach(val => {
	          ids.push(this.getDataId(val))
	        })
	      } else {
	        ids.push(this.getDataId(data))
	        dataStatus = crud.getDataStatus(this.getDataId(data))
	      }
	      if (!callVmHook(crud, CRUD.HOOK.beforeDelete, data)) {
	        return
	      }
	      if (!delAll) {
	        dataStatus.delete = CRUD.STATUS.PROCESSING
	      }
	      return crud.crudMethod.del(ids).then(() => {
	        if (delAll) {
	          crud.delAllLoading = false
	        } else dataStatus.delete = CRUD.STATUS.PREPARED
	        crud.dleChangePage(1)
	        crud.delSuccessNotify()
	        callVmHook(crud, CRUD.HOOK.afterDelete, data)
	        crud.refresh()
	      }).catch(() => {
	        if (delAll) {
	          crud.delAllLoading = false
	        } else dataStatus.delete = CRUD.STATUS.PREPARED
	      })
	    },
	    /**
	     * 通用導出
	     */
	    doExport() {
	      crud.downloadLoading = true
	      download(crud.url + '/download', crud.getQueryParams()).then(result => {
	        downloadFile(result, crud.title + '數據', 'xlsx')
	        crud.downloadLoading = false
	      }).catch(() => {
	        crud.downloadLoading = false
	      })
	    },
	    /**
	     * 獲取查詢參數
	     */
	    getQueryParams: function () {
	      // 清除參數無值的情況
	      Object.keys(crud.query).length !== 0 && Object.keys(crud.query).forEach(item => {
	        if (crud.query[item] === null || crud.query[item] === '') crud.query[item] = undefined
	      })
	      Object.keys(crud.params).length !== 0 && Object.keys(crud.params).forEach(item => {
	        if (crud.params[item] === null || crud.params[item] === '') crud.params[item] = undefined
	      })
	      return {
	        page: crud.page.page - 1,
	        size: crud.page.size,
	        sort: crud.sort,
	        ...crud.query,
	        ...crud.params
	      }
	    },
	    // 當前頁改變
	    pageChangeHandler(e) {
	      crud.page.page = e
	      crud.refresh()
	    },
	    // 每頁條數改變
	    sizeChangeHandler(e) {
	      crud.page.size = e
	      crud.page.page = 1
	      crud.refresh()
	    },
	    // 預防刪除第二頁最後一條數據時，或者多選刪除第二頁的數據時，頁碼錯誤導致請求無數據
	    dleChangePage(size) {
	      if (crud.data.length === size && crud.page.page !== 1) {
	        crud.page.page -= 1
	      }
	    },
	    // 選擇改變
	    selectionChangeHandler(val) {
	      crud.selections = val
	      // console.log(val)
	    },
	    /**
	     * 重置查詢參數
	     * @param {Boolean} toQuery 重置後進行查詢操作
	     */
	    resetQuery(toQuery = true) {
	      const defaultQuery = JSON.parse(JSON.stringify(crud.defaultQuery))
	      const query = crud.query
	      Object.keys(query).forEach(key => {
	        query[key] = defaultQuery[key]
	      })
	      if (toQuery) {
	        crud.toQuery()
	      }
	    },
	    /**
	     * 重置表單
	     * @param {Array} data 數據
	     */
	    resetForm(data) {
	      const form = data || (typeof crud.defaultForm === 'object' ? JSON.parse(JSON.stringify(crud.defaultForm)) : crud.defaultForm.apply(crud.findVM('form')))
	      const crudFrom = crud.form
	      for (const key in form) {
	        if (crudFrom.hasOwnProperty(key)) {
	          crudFrom[key] = form[key]
	        } else {
	          Vue.set(crudFrom, key, form[key])
	        }
	      }
	    },
	    /**
	     * 重置數據狀態
	     */
	    resetDataStatus() {
	      const dataStatus = {}
	      function resetStatus(datas) {
	        datas.forEach(e => {
	          dataStatus[crud.getDataId(e)] = {
	            delete: 0,
	            edit: 0
	          }
	          if (e.children) {
	            resetStatus(e.children)
	          }
	        })
	      }
	      resetStatus(crud.data)
	      crud.dataStatus = dataStatus
	    },
	    /**
	     * 獲取數據狀態
	     * @param {Number | String} id 數據項id
	     */
	    getDataStatus(id) {
	      return crud.dataStatus[id]
	    },
	    /**
	     * 用於樹形表格多選, 選中所有
	     * @param selection
	     */
	    selectAllChange(selection) {
	      // 如果選中的數目與請求到的數目相同就選中子節點，否則就清空選中
	      if (selection && selection.length === crud.data.length) {
	        selection.forEach(val => {
	          crud.selectChange(selection, val)
	        })
	      } else {
	        crud.findVM('presenter').$refs['table'].clearSelection()
	      }
	    },
	    /**
	     * 用於樹形表格多選，單選的封裝
	     * @param selection
	     * @param row
	     */
	    selectChange(selection, row) {
	      // 如果selection中存在row代表是選中，否則是取消選中
	      if (selection.find(val => { return this.getDataId(val) === this.getDataId(row) })) {
	        if (row.children) {
	          row.children.forEach(val => {
	            crud.findVM('presenter').$refs['table'].toggleRowSelection(val, true)
	            selection.push(val)
	            if (val.children) {
	              crud.selectChange(selection, val)
	            }
	          })
	        }
	      } else {
	        crud.toggleRowSelection(selection, row)
	      }
	    },
	    /**
	     * 切換選中狀態
	     * @param selection
	     * @param data
	     */
	    toggleRowSelection(selection, data) {
	      if (data.children) {
	        data.children.forEach(val => {
	          crud.findVM('presenter').$refs['table'].toggleRowSelection(val, false)
	          if (val.children) {
	            crud.toggleRowSelection(selection, val)
	          }
	        })
	      }
	    },
	    findVM(type) {
	      return crud.vms.find(vm => vm && vm.type === type).vm
	    },
	    notify(title, type = CRUD.NOTIFICATION_TYPE.INFO) {
	      crud.vms[0].vm.$notify({
	        title,
	        type,
	        duration: 2500
	      })
	    },
	    updateProp(name, value) {
	      Vue.set(crud.props, name, value)
	    },
	    getDataId(data) {
	      if (!data.hasOwnProperty(this.idField)) {
	        console.error('[CRUD error]: no property [%s] in %o', this.idField, data)
	      }
	      return data[this.idField]
	    },
	    attchTable() {
	      const table = this.findVM('presenter').$refs.table
	      const columns = []
	      table.columns.forEach((e, index) => {
	        if (!e.property || e.type !== 'default') {
	          return
	        }
	        e.__index = index
	        columns.push({
	          property: e.property,
	          index,
	          label: e.label,
	          visible: true
	        })
	      })
	      this.updateProp('tableColumns', columns)
	      this.updateProp('table', table)
	    }
	  }
	  const crud = Object.assign({}, data)
	  // 可觀測化
	  Vue.observable(crud)
	  // 附加方法
	  Object.assign(crud, methods)
	  // 記錄初始默認的查詢參數，後續重置查詢時使用
	  Object.assign(crud, {
	    defaultQuery: JSON.parse(JSON.stringify(data.query)),
	    // 預留4位存儲：組件 主頁、頭部、分頁、表單，調試查看也方便找
	    vms: Array(4),
	    /**
	     * 註冊組件實例
	     * @param {String} type 類型
	     * @param {*} vm 組件實例
	     * @param {Number} index 該參數內部使用
	     */
	    registerVM(type, vm, index = -1) {
	      const vmObj = {
	        type,
	        vm: vm
	      }
	      if (index < 0) {
	        this.vms.push(vmObj)
	        return
	      }
	      if (index < 4) { // 內置預留vm數
	        this.vms[index] = vmObj
	        return
	      }
	      this.vms.length = Math.max(this.vms.length, index)
	      this.vms.splice(index, 1, vmObj)
	    },
	    /**
	     * 取消註冊組件實例
	     * @param {*} vm 組件實例
	     */
	    unregisterVM(type, vm) {
	      for (let i = this.vms.length - 1; i >= 0; i--) {
	        if (this.vms[i] === undefined) {
	          continue
	        }
	        if (this.vms[i].type === type && this.vms[i].vm === vm) {
	          if (i < 4) { // 內置預留vm數
	            this.vms[i] = undefined
	          } else {
	            this.vms.splice(i, 1)
	          }
	          break
	        }
	      }
	    }
	  })
	  // 凍結處理，需要擴展數據的話，使用crud.updateProp(name, value)，以crud.props.name形式訪問，這個是響應式的，可以做數據綁定
	  Object.freeze(crud)
	  return crud
	}
	
	// hook VM
	function callVmHook(crud, hook) {
	  if (crud.debug) {
	    // console.log('callVmHook: ' + hook)
	  }
	  const tagHook = crud.tag ? hook + '$' + crud.tag : null
	  let ret = true
	  const nargs = [crud]
	  for (let i = 2; i < arguments.length; ++i) {
	    nargs.push(arguments[i])
	  }
	  // 有些組件扮演了多個角色，調用鉤子時，需要去重
	  const vmSet = new Set()
	  crud.vms.forEach(vm => vm && vmSet.add(vm.vm))
	  vmSet.forEach(vm => {
	    if (vm[hook]) {
	      ret = vm[hook].apply(vm, nargs) !== false && ret
	    }
	    if (tagHook && vm[tagHook]) {
	      ret = vm[tagHook].apply(vm, nargs) !== false && ret
	    }
	  })
	  return ret
	}
	
	function mergeOptions(src, opts) {
	  const optsRet = {
	    ...src
	  }
	  for (const key in src) {
	    if (opts.hasOwnProperty(key)) {
	      optsRet[key] = opts[key]
	    }
	  }
	  return optsRet
	}
	
	/**
	 * 查找crud
	 * @param {string} tag
	 */
	function lookupCrud(vm, tag) {
	  tag = tag || vm.$attrs['crud-tag'] || 'default'
	  // function lookupCrud(vm, tag) {
	  if (vm.$crud) {
	    const ret = vm.$crud[tag]
	    if (ret) {
	      return ret
	    }
	  }
	  return vm.$parent ? lookupCrud(vm.$parent, tag) : undefined
	}
	
	/**
	 * crud主頁
	 */
	function presenter(crud) {
	  if (crud) {
	    console.warn('[CRUD warn]: ' + 'please use $options.cruds() { return CRUD(...) or [CRUD(...), ...] }')
	  }
	  return {
	    data() {
	      // 在data中返回crud，是爲了將crud與當前實例關聯，組件觀測crud相關屬性變化
	      return {
	        crud: this.crud
	      }
	    },
	    beforeCreate() {
	      this.$crud = this.$crud || {}
	      let cruds = this.$options.cruds instanceof Function ? this.$options.cruds() : crud
	      if (!(cruds instanceof Array)) {
	        cruds = [cruds]
	      }
	      cruds.forEach(ele => {
	        if (this.$crud[ele.tag]) {
	          console.error('[CRUD error]: ' + 'crud with tag [' + ele.tag + ' is already exist')
	        }
	        this.$crud[ele.tag] = ele
	        ele.registerVM('presenter', this, 0)
	      })
	      this.crud = this.$crud['defalut'] || cruds[0]
	    },
	    methods: {
	      parseTime
	    },
	    created() {
	      for (const k in this.$crud) {
	        if (this.$crud[k].queryOnPresenterCreated) {
	          this.$crud[k].toQuery()
	        }
	      }
	    },
	    destroyed() {
	      for (const k in this.$crud) {
	        this.$crud[k].unregisterVM('presenter', this)
	      }
	    },
	    mounted() {
	      // 如果table未實例化（例如使用了v-if），請稍後在適當時機crud.attchTable刷新table信息
	      if (this.$refs.table !== undefined) {
	        this.crud.attchTable()
	      }
	    }
	  }
	}
	
	/**
	 * 頭部
	 */
	function header() {
	  return {
	    data() {
	      return {
	        crud: this.crud,
	        query: this.crud.query
	      }
	    },
	    beforeCreate() {
	      this.crud = lookupCrud(this)
	      this.crud.registerVM('header', this, 1)
	    },
	    destroyed() {
	      this.crud.unregisterVM('header', this)
	    }
	  }
	}
	
	/**
	 * 分頁
	 */
	function pagination() {
	  return {
	    data() {
	      return {
	        crud: this.crud,
	        page: this.crud.page
	      }
	    },
	    beforeCreate() {
	      this.crud = lookupCrud(this)
	      this.crud.registerVM('pagination', this, 2)
	    },
	    destroyed() {
	      this.crud.unregisterVM('pagination', this)
	    }
	  }
	}
	
	/**
	 * 表單
	 */
	function form(defaultForm) {
	  return {
	    data() {
	      return {
	        crud: this.crud,
	        form: this.crud.form
	      }
	    },
	    beforeCreate() {
	      this.crud = lookupCrud(this)
	      this.crud.registerVM('form', this, 3)
	    },
	    created() {
	      this.crud.defaultForm = defaultForm
	      this.crud.resetForm()
	    },
	    destroyed() {
	      this.crud.unregisterVM('form', this)
	    }
	  }
	}
	
	/**
	 * crud
	 */
	function crud(options = {}) {
	  const defaultOptions = {
	    type: undefined
	  }
	  options = mergeOptions(defaultOptions, options)
	  return {
	    data() {
	      return {
	        crud: this.crud
	      }
	    },
	    beforeCreate() {
	      this.crud = lookupCrud(this)
	      this.crud.registerVM(options.type, this)
	    },
	    destroyed() {
	      this.crud.unregisterVM(options.type, this)
	    }
	  }
	}
	
	/**
	 * CRUD鉤子
	 */
	CRUD.HOOK = {
	  /** 刷新 - 之前 */
	  beforeRefresh: 'beforeCrudRefresh',
	  /** 刷新 - 之後 */
	  afterRefresh: 'afterCrudRefresh',
	  /** 刪除 - 之前 */
	  beforeDelete: 'beforeCrudDelete',
	  /** 刪除 - 之後 */
	  afterDelete: 'afterCrudDelete',
	  /** 刪除取消 - 之前 */
	  beforeDeleteCancel: 'beforeCrudDeleteCancel',
	  /** 刪除取消 - 之後 */
	  afterDeleteCancel: 'afterCrudDeleteCancel',
	  /** 新建 - 之前 */
	  beforeToAdd: 'beforeCrudToAdd',
	  /** 新建 - 之後 */
	  afterToAdd: 'afterCrudToAdd',
	  /** 編輯 - 之前 */
	  beforeToEdit: 'beforeCrudToEdit',
	  /** 編輯 - 之後 */
	  afterToEdit: 'afterCrudToEdit',
	  /** 開始 "新建/編輯" - 之前 */
	  beforeToCU: 'beforeCrudToCU',
	  /** 開始 "新建/編輯" - 之後 */
	  afterToCU: 'afterCrudToCU',
	  /** "新建/編輯" 驗證 - 之前 */
	  beforeValidateCU: 'beforeCrudValidateCU',
	  /** "新建/編輯" 驗證 - 之後 */
	  afterValidateCU: 'afterCrudValidateCU',
	  /** 添加取消 - 之前 */
	  beforeAddCancel: 'beforeCrudAddCancel',
	  /** 添加取消 - 之後 */
	  afterAddCancel: 'afterCrudAddCancel',
	  /** 編輯取消 - 之前 */
	  beforeEditCancel: 'beforeCrudEditCancel',
	  /** 編輯取消 - 之後 */
	  afterEditCancel: 'afterCrudEditCancel',
	  /** 提交 - 之前 */
	  beforeSubmit: 'beforeCrudSubmitCU',
	  /** 提交 - 之後 */
	  afterSubmit: 'afterCrudSubmitCU',
	  afterAddError: 'afterCrudAddError',
	  afterEditError: 'afterCrudEditError'
	}
	
	/**
	 * CRUD狀態
	 */
	CRUD.STATUS = {
	  NORMAL: 0,
	  PREPARED: 1,
	  PROCESSING: 2
	}
	
	/**
	 * CRUD通知類型
	 */
	CRUD.NOTIFICATION_TYPE = {
	  SUCCESS: 'success',
	  WARNING: 'warning',
	  INFO: 'info',
	  ERROR: 'error'
	}
	
	export default CRUD
	
	export {
	  presenter,
	  header,
	  form,
	  pagination,
	  crud
	}