import React, { PropTypes } from 'react';
import * as types from '../constants/ActionTypes';
import {getServiceContracts,getServiceContractDetail,terminateServiceContract,renewServiceContract,
        addServiceContract,editServiceContract,updateServiceContract,ownersServiceContract,getServiceContractOwners,
        getServiceContractItems,addCustomers,getCustomer,getCustomers,addProfiles,editProfiles,profilesCustomerDetail,
        addCustomerLegalEntitie,updateCustomerLegalEntitie,deleteCustomerLegalEntitie,getCustomerLegalEntities,
        addContactsCustomer,deleteContactsCustomer,getContactsCustomers,updateContactsCustomer,updateContactsOwner,
        getContactsCustomerOwners,getContactsAdmin,addContactsAdmin,updateContactsAdmin,getFormDefind,editCustomerBasic,importCustomers,
        getRemindSetting,updateRemindSetting,getAttachments,downloadAttachments,addAttachments,downloadCustoms,getRecordsUtil,getFailRecordsUtil,getCustomerName,
        postCustomerRecord,getCustomercomments,
        getCustomerLegalEntitiesPaged,
        getListCustomers,changeCustom,
        addFormField,
        editFormField,
        delFormField,
        getFormFieldDetail,
        getClassifyList,
        getBasicFormList,
      } from '../../utils/customeUtil';
import {SubmissionError,change,submit} from 'redux-form';
import { message,notification } from 'antd';
import { NotificationIcon } from '../../utils/comonOtherUtil';
import { formatFormDefindNew } from '../../utils/commonUtils';
import { downloadFileByUrl } from '../../utils/fileUtil';



//导入记录列表
export function getRecordsList(params) {
    return dispatch => {
        return getRecordsUtil(params).then(data => {
              dispatch({
                  type      : types.GET_RECORD_LIST,
                  recordList: data
              })
          }).catch(err => { throw err; });
    };
}

//导入失败记录列表
export function getFailRecordsList(params) {
    return dispatch => {
        return getFailRecordsUtil(params)
            .then(data => {
                dispatch({
                    type          : types.FAIL_RECORD_LIST,
                    failRecordList: data
                })
            })
            .catch(err => { throw err; });
    };
}

/*客户管理*/
const sortArray = (values) => {
    const sortKey = { 'name': 0, 'address': 1, 'brief_name': 2, 'contact_name': 3, 'contact_mobile': 4, 'contact_position': 5, 'industry': 6, 'source': 9, 'email': 7, 'phone': 8 }
    const temp = [], other = [];
    values.map((item, i) => {
        if (sortKey[item.name] >= 0) {
            temp[sortKey[item.name]] = item;
        } else {
            other.push(item);
        }
    });
    return formatFormDefindNew(temp.concat(other));
}
/*导入客户*/
export function importCustomersAct(params) {
    return dispatch => {
        return importCustomers(params)
            .then(data => {
                if (data.code && data.code >= 300) {
                    dispatch({
                        type: types.IMPORT_CUSTOMER,
                        is_import: 'failed',
                        errorMeg: '客户导入失败，请按照要求上传文件'
                    });
                } else {
                    if (data.errors && data.errors != '[]') {
                        const tempErrors = JSON.parse(data.errors), temp = [];
                        tempErrors.map((err, i) => {
                            temp.push(err.message);
                        })
                        dispatch({
                            type: types.IMPORT_CUSTOMER,
                            is_import: 'failed',
                            errorMeg: '上传文件信息填写不完全，请按照模版要求填写' + temp.join(",")
                        });
                    } else {
                        dispatch({
                            type: types.IMPORT_CUSTOMER,
                            is_import: 'success',
                            errorMeg: '客户数据导入完成，导入结果请到导入记录中查看'
                        });
                    }
                }
            })
            .catch(err => { throw err; });
    };
}
export function cleanCustomeImport() {
    return {
        type: types.IMPORT_CUSTOMER,
        is_import: 'init',
        errorMeg: ''
    }
}

/*加载客户列表   精简版本客户列表  */
export function loadCustomList(values) {
    return dispatch => {
        return getCustomers(values)
        // return getListCustomers(values)
            .then(data => {
                const { items = [] } = data;
                if (data.code && data.code >= 300) {
                    message.error(data.message)
                } else {
                    dispatch({
                        type: types.CUSTOM_LIST,
                        customList: data
                    })
                    return data;
                }

            })
            .catch(err => { throw err; });
    };
}
/*加载客户列表   */
export function loadCustomListDet(values) {
    return dispatch => {
        return getListCustomers(values)
            .then(data => {
            
                if (data.code && data.code >= 300) {
                    message.error(data.message)
                } else {
                    dispatch({
                        type: types.CUSTOM_LIST,
                        customList: data
                    })
                    dispatch(change('customer_container_search', 'total_count', data.total_count));
                }
                
            })
            .catch(err => { throw err; });
    };
}

// 添加跟进记录
export function postCustomerRecordAct(values) {
    return dispatch => {
        return postCustomerRecord(values)
            .then(data => {
              
                if (data.code && data.code >= 300) {
                    message.error(data.message)
                    dispatch(change('customer_container_form', 'recordBtnDisabled', false))
                } else {
                    dispatch(change('customer_container_form', 'showAddRecord', false))
                }
                return data;
            })
            .catch(err => { throw err; });
    };
}
//获取跟进记录列表
export function getCustomerCommentsAction(values) {
    return dispatch => {
        return getCustomercomments(values)
            .then(data => {  
                if (data.code && data.code >= 300) {
                    message.error(data.message)
                } else {
                    dispatch({
                        type: types.CUSTOM_COMMENTS_LIST,
                        customCommentsList:  data.items||[]
                    }) 
                }
            })
            .catch(err => { throw err; });
    };
}

export function cleanCustom() {
    return {
        type: types.CUSTOM_LIST,
        customList: {}
    }
}

/*编辑客户基本信息*/
export function editCustomerBasicAct(values, from) {
    return dispatch => {
        return editCustomerBasic(values)
            .then(data => {
                if (data.code && data.code >= 300) {
                    message.error(data.message)
                } else {
                    message.success('更新成功！')
                    from && dispatch(submit('customer_container_search'))
                }
                return data
            })
            .catch(err => { throw err; });
    };
}

/*添加客户*/
export function createCustomer(params) {
    return dispatch => {
        dispatch({ type: 'MASK_SHOW', maskShow: true });
        return addCustomers(params)
            .then(data => {
                dispatch({ type: 'MASK_SHOW', maskShow: false });
                if (data.code && data.code >= 300) {
                    if (data.code == 409) {
                        dispatch({
                            type: types.ADD_FAIL,
                            is_fail: true,
                            add_custome_meg: data.message
                        });
                    } else {
                        dispatch({
                            type: types.ADD_FAIL,
                            is_fail: true,
                            add_custome_meg: data.message
                        });
                    }
                } else {
                    // dispatch(loadCustomList('limit=10&offset=0'));
                    dispatch(loadCustomListDet('limit=10&offset=0'));
                    dispatch({
                        type: types.ADD_FAIL,
                        is_fail: false,
                        add_custome_meg: "您所新建的客户已创建成功"
                    });
                }
                dispatch(change('step_one', 'current', 3));
            })
            .catch(err => { dispatch({ type: 'MASK_SHOW', maskShow: false }); throw err; });
    };
}

/*客户查重*/
export function getCustomerNameAct(name, type) {
    return dispatch => {
        return getCustomerName(name, type)
            .then(data => {
                if (data.code && data.code >= 300) {
                    if (type == 'link') {
                        dispatch(change('step_one','current',1))
                    } else {
                        message.success('公司名称可使用')
                    }
                } else {
                    // message.error('公司名称已存在')
                    message.error('客户被'+data.creator+'占用了')
                }
            })
            .catch(err => { throw err; });
    };
}

/*查看客户详情*/
export function getCustomerInfo(id) {
    return dispatch => {
        return getCustomer(id)
            .then(data => {
                dispatch({
                    type: types.GET_CUSTOM,
                    custom: data
                })
            })
            .catch(err => { throw err; });
    };
}

/*添加公司简介*/
export function addCompany(params) {
    return dispatch => {
        return addProfiles(params)
            .then(data => {
                if (data.code && data.code >= 300) {
                    message.error(data.message);
                } else {
                    dispatch(loadCompany(params.customer_id));
                }
            })
            .catch(err => { throw err; });
    };
}

/*编辑公司简介*/
export function editCompany(params) {
    return dispatch => {
        return editProfiles(params)
            .then(data => {
                if (data.code && data.code >= 300) {
                    message.error(data.message);
                } else {
                    message.success('编辑成功');
                    dispatch(loadCompany(params.customer_id));
                }
            })
            .catch(err => { throw err; });
    };
}

/*客户公司简介*/
export function loadCompany(id) {
    return dispatch => {
        return profilesCustomerDetail(id)
            .then(data => {
                dispatch({
                    type: types.GET_COMPANY_INFO,
                    company: data
                })
            })
            .catch(err => { throw err; });
    };
}
/*清楚客户公司简介*/
export function cleanCompany() {
    return {
        type: types.GET_COMPANY_INFO,
        company: {}
    };
}

/*添加法务实体*/
export function createCustomerLegalEntitie(params) {
    return dispatch => {
        return addCustomerLegalEntitie(params)
            .then(data => {
                if (data.code && data.code >= 300) {
                    message.error(data.message)
                    throw new SubmissionError({ _error: data.message });
                } else {
                    // dispatch(loadCustomerLegalEntities(params.customer_id));
                    dispatch(submit('legal_customer_list_search'))
                    dispatch(change('custom_det_form', 'showAddLegal', false))
                }
            })
            .catch(err => { throw err; });
    };
}

/*获取客户下的法务实体列表*/
export function loadCustomerLegalEntities(id) {
    return dispatch => {
        return getCustomerLegalEntities(id)
            .then(data => {
                const {items=[]} = data;
                dispatch({
                    type: types.LOAD_CUSTOMER_LEGAL_ENTITIES,
                    legalEntities: data
                });
                return items;
            })
            .catch(err => { throw err; });
    };
}
/*获取客户下的法务实体列表     支持分页*/  
export function getCustomerLegalEntitiesPagedAction(val) {
    return dispatch => {
        return getCustomerLegalEntitiesPaged(val)
            .then(data => {
                const {items=[],total_count=''} = data;
                dispatch({
                    type: types.LOAD_CUSTOMER_LEGAL_ENTITIES,
                    legalEntities: data
                });
                dispatch(change('legal_customer_list_search', 'total_count', total_count))
                return items;
            })
            .catch(err => { throw err; });
    };
}


export function clearCustomerLegalEntities() {//清空客户下的法务实体列表
    return dispatch => {
        dispatch({
            type: types.LOAD_CUSTOMER_LEGAL_ENTITIES,
            legalEntities: {}
        })
    };
}

/*修改法务实体*/
export function changeCustomerLegalEntitie(params) {
    return dispatch => {
        return updateCustomerLegalEntitie(params)
            .then(data => {
                if (data.code && data.code >= 300) {
                    message.error(data.message);
                    // throw new SubmissionError({ _error: data.message });
                    dispatch(change('legal_form','showEditLegal',true))
                } else {
                    // dispatch(loadCustomerLegalEntities(params.customer_id));
                    dispatch(submit('legal_customer_list_search'))
                    message.success('编辑成功');
                    dispatch(change('legal_form','showEditLegal',false))
                }
            })
            .catch(err => { throw err; });
    };
}


/*删除法务实体*/
export function delCustomerLegalEntitie(params) {
    return dispatch => {
        return deleteCustomerLegalEntitie(params)
            .then(data => {
                if (data.code && data.code >= 300) {
                    message.error(data.message);
                } else {
                    message.success('删除成功');
                    // dispatch(loadCustomerLegalEntities(params.customer_id));
                    dispatch(submit('legal_customer_list_search'))
                }
            })
            .catch(err => { throw err; });
    };
}

/*添加客户联系人*/
export function createContactsCustomer(params) {
    return dispatch => {
        return addContactsCustomer(params)
            .then(data => {
                if (data.code && data.code >= 300) {
                    message.error('该客户对接人已存在');
                } else {
                    dispatch(loadContactsCustomers(params.id));
                }
            })
            .catch(err => { throw err; });
    };
}

/*列表客户联系人*/
export function loadContactsCustomers(id) {
    return dispatch => {
        return getContactsCustomers(id)
            .then(data => {
                if (data.code && data.code >= 300) {
                    message.error(data.message);
                } else {
                    dispatch({
                        type: types.LOAD_CONTACTS_CUSTOMER,
                        contacts: data
                    })
                }
            })
            .catch(err => { throw err; });
    };
}

/*修改客户联系人*/
export function changeContactsCustomer(params) {
    return dispatch => {
        return updateContactsCustomer(params)
            .then(data => {
                if (data.code && data.code >= 300) {
                    message.error(data.message);
                } else {
                    dispatch(loadContactsCustomers(params.customer_id));
                }
            })
            .catch(err => { throw err; });
    };
}

/*删除客户联系人*/
export function delContactsCustomer(params) {
    return dispatch => {
        return deleteContactsCustomer(params)
            .then(data => {
                if (data.code && data.code >= 300) {
                    message.error(data.message);
                } else {
                    message.success('删除成功');
                    dispatch(loadContactsCustomers(params.customer_id));
                }
            })
            .catch(err => { throw err; });
    };
}

/*列表客户负责人*/
export function loadContactsCustomerOwners(id) {
    return dispatch => {
        return getContactsCustomerOwners(id)
            .then(data => {
                dispatch({
                    type: types.LOAD_CONTACTS_OWNERS,
                    owners: data
                })
            })
            .catch(err => { throw err; });
    };
}

/*更新客户负责人*/
export function changeContactsCustomerForService(params) {
    return dispatch => {
        return updateContactsOwner(params)
            .then(data => {
                if (data.code && data.code >= 300) {
                    message.error(data.message);
                } else {
                    message.success('编辑成功');
                    dispatch(loadContactsCustomerOwners(params.id));
                }
                return data;
            })
            .catch(err => { throw err; });
    };
}

/*获取根账号*/
export function getAdminAction(params) {
    return dispatch => {
        return getContactsAdmin(params)
            .then(data => {
                dispatch({
                    type: types.LOAD_CONTACTS_ADMIN,
                    adminDate: data
                })
            })
            .catch(err => { throw err; });
    };
}
/*客户账号信息开通账号*/
export function createContactsAdmin(params) {
    return dispatch => {
        return addContactsAdmin(params)
            .then(data => {
                if (data.code && data.code >= 300) {
                    notification.open({
                        message: '错误',
                        description: '开通失败,' + data.message,
                        icon: <NotificationIcon type='error' />,
                    });
                } else {
                    notification.open({
                        message: '成功',
                        description: '开通成功',
                        icon: <NotificationIcon type='success' />,
                    });
                    dispatch(getAdminAction(params.id));
                }
                return data;
            })
            .catch(err => { throw err; });
    };
}

/*客户账号信息变更账号*/
export function changeCustomAction(params) {
    return dispatch => {
        return changeCustom(params)
            .then(data => {
                if (data.code && data.code >= 300) {
                    notification.open({
                        message: '错误',
                        description: '变更失败,' + data.message,
                        icon: <NotificationIcon type='error' />,
                    });
                } else {
                    notification.open({
                        message: '成功',
                        description: '变更成功',
                        icon: <NotificationIcon type='success' />,
                    });
                    dispatch(getAdminAction(params.id));
                    return data;
                }
                
            })
            .catch(err => { throw err; });
    };
}

/*停用/启用账号*/
export function changeContactsAdmin(params) {
    return dispatch => {
        return updateContactsAdmin(params)
            .then(data => {
                dispatch(getAdminAction(params.customer_id));
            })
            .catch(err => { throw err; });
    };
}


/*服务合同*/
/*加载服务列表*/
export function loadServiceContractsList(params) {
    return dispatch => {
        return getServiceContracts(params)
            .then(data => {
                if(data.code &&data.code >= 300){
                    notification.open({
                        message: '错误',
                        description: '变更失败,' + data.message,
                        icon: <NotificationIcon type='error' />,
                    });
                }else{
                    const { items = [], total_count } = data;
                    dispatch({
                        type: types.SERVER_LIST,
                        serverList: data
                    })
                    if (params.indexOf('all=true') == -1) {
                        dispatch(change('search_list_custom', 'total_count', total_count));
                    }
                    return items;
                }
            })
            .catch(err => { throw err; });
    };
}

export function clearServiceContract(params) {
  return dispatch => {
      dispatch({
        type      : types.SERVER_LIST,
        serverList: {}
      })
  };
}

/*加载单个服务列表*/
export function loadServiceContractsCustome(params) {
    return dispatch => {
        return getServiceContracts(params)
            .then(data => {
                const { items = [], total_count } = data
                dispatch({
                    type: types.SERVER_LIST_CUSTOME,
                    serverListCustom: data
                });
                return data;
            })
            .catch(err => { throw err; });
    };
}

/*search加载单个服务列表*/
export function loadServiceContractsCustomeSearch(params) {
    return dispatch => {
        return getServiceContracts(params)
            .then(data => {
                const { items = [], total_count } = data
                dispatch({
                    type: types.SERVER_LIST_CUSTOME_SEARCH,
                    serverListCustomSearch: data
                })
            })
            .catch(err => { throw err; });
    };
}



/*清空合同列表*/
export function clearServiceContractsList() {
    return dispatch => {
        dispatch({
            type: types.SERVER_LIST_CUSTOME,
            serverListCustom: {}
        })
    };
}

/*清空合同列表search*/
export function clearServiceContractsListSearch() {
    return dispatch => {
        dispatch({
            type: types.SERVER_LIST_CUSTOME_SEARCH,
            serverListCustomSearch: {}
        })
    };
}


/*添加服务合同*/
export function createServiceContract(params) {
    return dispatch => {
        dispatch({ type: 'MASK_SHOW', maskShow: true });
        return addServiceContract(params)
            .then(data => {
                dispatch({ type: 'MASK_SHOW', maskShow: false });
                if (data && data.id) {
                    message.success('新增服务合同成功');
                    document.location.href = "#container/customService/0"
                } else if (data.message) {
                    if (data.errors) {
                        message.error(data.errors);
                    }
                }
            })
            .catch(err => { dispatch({ type: 'MASK_SHOW', maskShow: false }); throw err; });
    };
}
/*编辑服务合同*/
export function editServiceContractAct(params) {
    return dispatch => {
        return editServiceContract(params)
            .then(data => {
                if (data.code >= 300) {
                    if (data.errors && data.errors != '[]') {
                        //  let messageArr = [],errorMeg;
                        //  const newMessage = JSON.parse(data.errors);
                        //  newMessage.map(data=>{
                        //    messageArr.push(data.message);
                        //  });
                        //  errorMeg = messageArr.stringify()
                        //  message.error(errorMeg);
                    } else {
                        message.error(data.message);
                    }
                } else {
                    message.success('修改服务合同成功');
                    document.location.href = "#container/customService/0"
                }
            })
            .catch(err => { throw err; });
    };
}
export function cleanServerContractInfo() {
    return {
        type: types.SERVER_CONTRACT_INFO,
        serverContractInfo: ''
    }
}
/*查看服务合同详情*/
export function getServiceContractInfo(id) {
    return dispatch => {
        return getServiceContractDetail(id)
            .then(data => {
                dispatch({
                    type: types.SERVER_CONTRACT_INFO,
                    serverContractInfo: data
                });
                return data;
            })
            .catch(err => { throw err; });
    };
}

/*终止服务合同*/
export function stopServiceContract(params) {
    return dispatch => {
        return terminateServiceContract(params)
            .then(data => {
                if (data && data.code == 200) {
                    message.success('终止服务合同成功');
                    dispatch(loadServiceContractsList('?offset=0&limit=10&type=0'));
                    return data;
                }
            })
            .catch(err => { throw err; });
    };
}

/*续签服务合同*/
export function repeatServiceContract(params) {
    return dispatch => {
        return renewServiceContract(params)
            .then(data => {
                if (data && data.code == 200) {
                    message.success('续签服务合同成功');
                    document.location.href = "#container/customService/0"
                }
                // dispatch(loadServiceContractsList('?offset=0&limit=10&type=0'));
            })
            .catch(err => { throw err; });
    };
}

/*变更服务合同*/
export function changeServiceContract(params) {
    return dispatch => {
        return updateServiceContract(params)
            .then(data => {
                dispatch(loadServiceContractsList());
            })
            .catch(err => { throw err; });
    };
}

/*获取服务合同负责人列表*/
export function loadServiceContractOwners(id) {
    return dispatch => {
        return getServiceContractOwners(id)
            .then(data => {
                dispatch({
                    type: types.SERVER_CONTRACT_OWNERS,
                    serverContractOwners: data
                })
            })
            .catch(err => { throw err; });
    };
}

/*获取服务合同内容列表*/
export function loadServiceContractItems(id) {
    return dispatch => {
        return getServiceContractItems(id)
            .then(data => {
                dispatch({
                    type: types.SERVER_CONTRACT_ITEMS,
                    serverContractItems: data
                })
            })
            .catch(err => { throw err; });
    };
}

/*分配/变更负责人*/
export function changeOwnersServiceContract(params) {
    return dispatch => {
        return ownersServiceContract(params)
            .then(data => {
                if (data && data.code >= 300) {
                    message.error(data.message);
                    throw new SubmissionError({ _error: data.message });
                }
                dispatch(getServiceContractInfo(params.id));
            })
            .catch(err => { throw err; });
    };
}


/*获取提醒 - 设置*/
export function loadRemindSettingAction() {
    return dispatch => {
        return getRemindSetting()
            .then(data => {
                dispatch({
                    type: types.LOAD_REMIND_SETTING,
                    remindSetting: data
                });
            })
            .catch(err => { throw err; });
    };
}
//获取提醒 - 添加修改
export function changeRemindSettingAction(params) {
    return dispatch => {
        return updateRemindSetting(params)
            .then(data => {
                if (data && data.id) {
                    message.success('服务合同到期提醒设置成功');
                    dispatch(loadRemindSettingAction());
                    dispatch(submit('search_list_custom'));
                    return data;
                }
            })
            .catch(err => { throw err; });
    };
}


//列表纸制服务合同
export function loadAttachments(params) {
    return dispatch => {
        return getAttachments(params)
            .then(data => {
                const { items = [] } = data;
                dispatch({
                    type: types.LOAD_ATTACHMENTS,
                    attachments: items
                })
                dispatch(change('custom_stop_form', 'images', items));
            })
            .catch(err => { throw err; });
    };
}

//上传纸制服务合同
export function addAttachmentsAction(params) {
    return dispatch => {
        return addAttachments(params)
            .then(data => {
                if (data.code && data.code == '200')
                    message.success('上传成功');
                dispatch(submit('search_list_custom'));
            })
            .catch(err => { throw err; });
    };
}

//下载纸制服务合同
export function downloadAttachmentsAction(params) {
    return dispatch => {
        dispatch({ type: 'MASK_SHOW', maskShow: true });
        return downloadAttachments(params)
            .then(data => {
                const { download_path = '' } = data;
                if (download_path) {
                    downloadFileByUrl(download_path);
                }
                dispatch({ type: 'MASK_SHOW', maskShow: false });
            })
            .catch(err => { dispatch({ type: 'MASK_SHOW', maskShow: false }); throw err; });
    };
}
//导出客户列表
export function exportCustomAction(params){
  return dispatch => {
      return downloadCustoms(params)
          .then(data => {
              const {download_path=''} = data;
              if(download_path){
                 downloadFileByUrl(download_path);
              }

          })
          .catch(err => {throw err; });
  };
}

export function getBasicFormListAction(params) {
    return dispatch => {
      return getBasicFormList(params)
        .then(data => {
          const { items = [] } = data
          dispatch({
            type: types.LOAD_CRM_FORM_LIST,
            formBasicList: items
          })
          return data
        })
        .catch(err => { throw err })
    };
  }

// 获取表单定义
export function loadFormDefind() {
    return dispatch => {
        return getFormDefind()
            .then(data => {
                const { items = [] } = data
                dispatch({
                    type: types.LOAD_FORM_DEFIND,
                    formDefind: formatFormDefindNew(items)
                })
            })
            .catch(err => { throw err })
    }
}



// 添加表单定义字段
export function addFormFieldAction(params) {
    return dispatch => {
        return addFormField(params).then(data => {
            if (data.code && data.code >= 300) {
                notification.open({
                    message: '错误',
                    description: '添加失败,' + data.message,
                    icon: <NotificationIcon type='error' />,
                })
            } else {
                notification.open({
                    message: '成功',
                    description: '添加成功',
                    icon: <NotificationIcon type='success' />,
                })
                dispatch(loadFormDefind())
                dispatch(change('customer_tmp_setting_form', 'showFieldStatus', false ))
            }
            return data
        })
    }
}


// 编辑表单定义字段
export function editFormFieldAction(params) {
    return dispatch => {
        return editFormField(params).then(data => {
            if (data.code && data.code >= 300) {
                notification.open({
                    message: '错误',
                    description: '更新失败,' + data.message,
                    icon: <NotificationIcon type='error' />,
                })
            } else {
                notification.open({
                    message: '成功',
                    description: '更新成功',
                    icon: <NotificationIcon type='success' />,
                })
                dispatch(loadFormDefind())
                dispatch(change('customer_tmp_setting_form', 'showFieldStatus', false ))
            }
            return data
        })
    }
}


// 删除表单定义字段
export function delFormFieldAction(id) {
    return dispatch => {
        return delFormField(id).then(data => {
            if (data.code && data.code >= 300) {
                notification.open({
                    message: '错误',
                    description: '删除失败,' + data.message,
                    icon: <NotificationIcon type='error' />,
                })
            } else {
                notification.open({
                    message: '成功',
                    description: '删除成功',
                    icon: <NotificationIcon type='success' />,
                })
                dispatch(loadFormDefind())
            }
            return data
        })
    }
}

// 获取表单单个字段详情
export function getFormFieldDetailAction(id) {
    return dispatch => {
        return getFormFieldDetail(id).then(data => {
            return data
        })
    }
}

// 获取自定义表单分类列表
export function getClassifyListAction(params) {
    return dispatch => {
        return getClassifyList(params).then(data => {
            return data
        })
    }
}