// 1. Initialize
const app = dva({
    fetchConfig:{
            // Here fill out your packaged request file
            // get post delete...  after that, method will read your exposed name directly.
            netTool:request,
            // URL transfer mode
            // 1.If netApi is empty     url:'/book'
            // 2.If netApi is not empty The name of the function that needs to be passed out by the netApi url:'book'
            netApi:netaApi,
            // Global network start processing
            // Each person has different processing specifications for network requests. 
            // Here you can directly write your corresponding processing logic. true is ok false is non conformity goto onNetError function 
            onGLNetStart:({retData})=>{
                debugger
                // Do not do redundant operations besides logical judgment here
                if (retData.error_code == 0){
                    return retData.result
                }else {
                    return false
                }
            },
            //Global error handling
            onGLNetError:({retData})=>{
              // if the data is here, the data will continue to merge, but because the data is wrong,
              // the wrong network request is not merged into model, nor does it refresh data.
              // avoid the problem of re refreshing the page due to interface errors.
              // you can also intercept the onError of a single request in the fetch/sendData of each interface.
              // the error onError will be recorded in the fetch model. You can directly replay through fetch.isNetError (interface name).
            },
            // The above network error is just a mistake that does not conform to the conditions of netStart, and the other is a direct catch thrown out of the more serious.
            onGLNetCatch:()=>{
                
            },
            // Unified single network end event
            // Even if the previous network request has entered onNetError, it will continue to perform.
            // Unless your network request has directly thrown an exception.
            onGLNetFinall:()=>{

            },
            // Extended attributes
            // If you want to send a single data to all events, you can put it here.
            //Here you will be unified in all fetch functions.
            extendAttr:()=>({a:'1'}),
            // Global parameters
            // Here you can send the corresponding model data globally to make your fetch request cleaner.
            // For example, you don't need to pass a token and other data when you need get or post each time.
            GLParams:()=>({}),
            // Global network request delay processing default 10 seconds
            GLTimeOut:10000,
            // Global timeout request
            // onGLTimeOut
    }
});

    this.props.dispatch({type: 'fetch/sendData',payload:[
      {
        // The name of the model to be modified needs to be consistent with the name of the namespace field in model.
        target: 'example',
        // The name of the URL address to be requested has two ways of writing
        // If netApi is introduced into fetchConfig in DVA initialization, the name here needs to be consistent with the name of the function exposed by netApi.
        // Otherwise, it's equal to passing the URL directly.
        url: 'movie',

        // You need to pass the past parameters
        // params:{}, object
        
        // Delay time of a single network request
        // timeOut: number
        // priority timeout > fetchConfig > default 10 seconds

        // tranData:function
        // ts:The interface for converting the network to the later data
        // In this way, the data returned by the network request can be converted to format.
        // tranData:(data)=>({list:data.list})

        // tranUrl : false | true
        // If your URL is {specId}/id like this, as long as tranUrl is true
        // It will automatically help you find the corresponding specId from params.

        // method this parameter will bind to the netTool in fetchConfig.
        // For example, method:'get'is actually reading the get function in netTool for network request.
        // You can customize the name here, as long as you expose it in netTool.
        // isOnlyNet : bool 
        // Is it just a network request without refreshing the page by default false?
        // If you just want to make a network request, set it to true.

        // onError : function
        // If you compare the error management with the single interface, you can do it here.
        // It does not block global error management. It can still be received.
        // The condition of error management is that fetchConfig.onNetStart does not conform to custom requirements before entering here.

        // onCallBack ：function
        // tranData It is used to do data conversion, if you want to perform some operations in the case of normal data acquisition.
        // For example, this.setState can be carried out here. If there is a mistake in the network, it will not come here.

        // because this payload is an array structure, your multiple network requests will be merged and will only be refreshed at the end.
        // not because you have multiple network requests, which will cause many refreshes.
        // secondly, if you want to cancel this request after launching a network request, you only need to resend one.
        // this.props.dispatch ({type:'CANCEL_FETCH'}) can cancel all network requests of that queue.
        // you can also judge the current state in fetchConfig.onNetStart only need to return to false.
        // for example, when the current token does not meet the requirements, give up all requests until token meets the requirements.
        // it will go to the corresponding onError without data merging, and will not cause the page to be refreshed again.
      }
    ]})